1 /* Driver for USB Mass Storage compliant devices
3 * $Id: usb.c,v 1.75 2002/04/22 03:39:43 mdharm Exp $
5 * Current development and maintenance by:
6 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
8 * Developed with the assistance of:
9 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
10 * (c) 2003 Alan Stern (stern@rowland.harvard.edu)
13 * (c) 1999 Michael Gee (michael@linuxspecific.com)
15 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com):
16 * (c) 2000 Yggdrasil Computing, Inc.
18 * This driver is based on the 'USB Mass Storage Class' document. This
19 * describes in detail the protocol used to communicate with such
20 * devices. Clearly, the designers had SCSI and ATAPI commands in
21 * mind when they created this document. The commands are all very
22 * similar to commands in the SCSI-II and ATAPI specifications.
24 * It is important to note that in a number of cases this class
25 * exhibits class-specific exemptions from the USB specification.
26 * Notably the usage of NAK, STALL and ACK differs from the norm, in
27 * that they are used to communicate wait, failed and OK on commands.
29 * Also, for certain devices, the interrupt endpoint is used to convey
30 * status of a command.
32 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
33 * information about this driver.
35 * This program is free software; you can redistribute it and/or modify it
36 * under the terms of the GNU General Public License as published by the
37 * Free Software Foundation; either version 2, or (at your option) any
40 * This program is distributed in the hope that it will be useful, but
41 * WITHOUT ANY WARRANTY; without even the implied warranty of
42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43 * General Public License for more details.
45 * You should have received a copy of the GNU General Public License along
46 * with this program; if not, write to the Free Software Foundation, Inc.,
47 * 675 Mass Ave, Cambridge, MA 02139, USA.
50 #include <linux/config.h>
51 #include <linux/sched.h>
52 #include <linux/errno.h>
55 #include "transport.h"
58 #include "initializers.h"
60 #ifdef CONFIG_USB_STORAGE_HP8200e
61 #include "shuttle_usbat.h"
63 #ifdef CONFIG_USB_STORAGE_SDDR09
66 #ifdef CONFIG_USB_STORAGE_SDDR55
69 #ifdef CONFIG_USB_STORAGE_DPCM
72 #ifdef CONFIG_USB_STORAGE_FREECOM
75 #ifdef CONFIG_USB_STORAGE_ISD200
78 #ifdef CONFIG_USB_STORAGE_DATAFAB
81 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
86 #include <linux/module.h>
87 #include <linux/init.h>
88 #include <linux/slab.h>
90 /* Some informational data */
91 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
92 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
93 MODULE_LICENSE("GPL");
95 static int storage_probe(struct usb_interface *iface,
96 const struct usb_device_id *id);
98 static void storage_disconnect(struct usb_interface *iface);
100 /* The entries in this table, except for final ones here
101 * (USB_MASS_STORAGE_CLASS and the empty entry), correspond,
102 * line for line with the entries of us_unsuaul_dev_list[].
105 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
106 vendorName, productName,useProtocol, useTransport, \
107 initFunction, flags) \
108 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax) }
110 static struct usb_device_id storage_usb_ids [] = {
112 # include "unusual_devs.h"
114 /* Control/Bulk transport for all SubClass values */
115 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CB) },
116 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CB) },
117 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CB) },
118 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CB) },
119 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CB) },
120 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CB) },
122 /* Control/Bulk/Interrupt transport for all SubClass values */
123 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CBI) },
124 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CBI) },
125 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CBI) },
126 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CBI) },
127 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CBI) },
128 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CBI) },
130 /* Bulk-only transport for all SubClass values */
131 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_BULK) },
132 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_BULK) },
133 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_BULK) },
134 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_BULK) },
135 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_BULK) },
136 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) },
138 /* Terminating entry */
142 MODULE_DEVICE_TABLE (usb, storage_usb_ids);
144 /* This is the list of devices we recognize, along with their flag data */
146 /* The vendor name should be kept at eight characters or less, and
147 * the product name should be kept at 16 characters or less. If a device
148 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
149 * normally generated by a device thorugh the INQUIRY response will be
150 * taken from this list, and this is the reason for the above size
151 * restriction. However, if the flag is not present, then you
152 * are free to use as many characters as you like.
156 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
157 vendor_name, product_name, use_protocol, use_transport, \
158 init_function, Flags) \
160 .vendorName = vendor_name, \
161 .productName = product_name, \
162 .useProtocol = use_protocol, \
163 .useTransport = use_transport, \
164 .initFunction = init_function, \
168 static struct us_unusual_dev us_unusual_dev_list[] = {
169 # include "unusual_devs.h"
171 /* Control/Bulk transport for all SubClass values */
172 { .useProtocol = US_SC_RBC,
173 .useTransport = US_PR_CB},
174 { .useProtocol = US_SC_8020,
175 .useTransport = US_PR_CB},
176 { .useProtocol = US_SC_QIC,
177 .useTransport = US_PR_CB},
178 { .useProtocol = US_SC_UFI,
179 .useTransport = US_PR_CB},
180 { .useProtocol = US_SC_8070,
181 .useTransport = US_PR_CB},
182 { .useProtocol = US_SC_SCSI,
183 .useTransport = US_PR_CB},
185 /* Control/Bulk/Interrupt transport for all SubClass values */
186 { .useProtocol = US_SC_RBC,
187 .useTransport = US_PR_CBI},
188 { .useProtocol = US_SC_8020,
189 .useTransport = US_PR_CBI},
190 { .useProtocol = US_SC_QIC,
191 .useTransport = US_PR_CBI},
192 { .useProtocol = US_SC_UFI,
193 .useTransport = US_PR_CBI},
194 { .useProtocol = US_SC_8070,
195 .useTransport = US_PR_CBI},
196 { .useProtocol = US_SC_SCSI,
197 .useTransport = US_PR_CBI},
199 /* Bulk-only transport for all SubClass values */
200 { .useProtocol = US_SC_RBC,
201 .useTransport = US_PR_BULK},
202 { .useProtocol = US_SC_8020,
203 .useTransport = US_PR_BULK},
204 { .useProtocol = US_SC_QIC,
205 .useTransport = US_PR_BULK},
206 { .useProtocol = US_SC_UFI,
207 .useTransport = US_PR_BULK},
208 { .useProtocol = US_SC_8070,
209 .useTransport = US_PR_BULK},
210 { .useProtocol = US_SC_SCSI,
211 .useTransport = US_PR_BULK},
213 /* Terminating entry */
217 struct usb_driver usb_storage_driver = {
218 .owner = THIS_MODULE,
219 .name = "usb-storage",
220 .probe = storage_probe,
221 .disconnect = storage_disconnect,
222 .id_table = storage_usb_ids,
226 * fill_inquiry_response takes an unsigned char array (which must
227 * be at least 36 characters) and populates the vendor name,
228 * product name, and revision fields. Then the array is copied
229 * into the SCSI command's response buffer (oddly enough
230 * called request_buffer). data_len contains the length of the
231 * data array, which again must be at least 36.
234 void fill_inquiry_response(struct us_data *us, unsigned char *data,
235 unsigned int data_len)
237 if (data_len<36) // You lose.
240 if(data[0]&0x20) { /* USB device currently not connected. Return
241 peripheral qualifier 001b ("...however, the
242 physical device is not currently connected
243 to this logical unit") and leave vendor and
244 product identification empty. ("If the target
245 does store some of the INQUIRY data on the
246 device, it may return zeros or ASCII spaces
247 (20h) in those fields until the data is
248 available from the device."). */
251 memcpy(data+8, us->unusual_dev->vendorName,
252 strlen(us->unusual_dev->vendorName) > 8 ? 8 :
253 strlen(us->unusual_dev->vendorName));
254 memcpy(data+16, us->unusual_dev->productName,
255 strlen(us->unusual_dev->productName) > 16 ? 16 :
256 strlen(us->unusual_dev->productName));
257 data[32] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice>>12) & 0x0F);
258 data[33] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice>>8) & 0x0F);
259 data[34] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice>>4) & 0x0F);
260 data[35] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice) & 0x0F);
263 usb_stor_set_xfer_buf(data, data_len, us->srb);
266 static int usb_stor_control_thread(void * __us)
268 struct us_data *us = (struct us_data *)__us;
273 * This thread doesn't need any user-level access,
274 * so get rid of all our resources.
276 daemonize("usb-storage");
278 current->flags |= PF_NOFREEZE;
282 /* signal that we've started the thread */
283 complete(&(us->notify));
286 struct Scsi_Host *host;
287 US_DEBUGP("*** thread sleeping.\n");
288 if(down_interruptible(&us->sema))
291 US_DEBUGP("*** thread awakened.\n");
293 /* if us->srb is NULL, we are being asked to exit */
294 if (us->srb == NULL) {
295 US_DEBUGP("-- exit command received\n");
298 host = us->srb->device->host;
300 /* lock access to the state */
303 /* has the command been aborted *already* ? */
304 if (us->sm_state == US_STATE_ABORTING) {
305 us->srb->result = DID_ABORT << 16;
309 /* set the state and release the lock */
310 us->sm_state = US_STATE_RUNNING;
313 /* lock the device pointers */
314 down(&(us->dev_semaphore));
316 /* don't do anything if we are disconnecting */
317 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
318 US_DEBUGP("No command during disconnect\n");
319 us->srb->result = DID_BAD_TARGET << 16;
322 /* reject the command if the direction indicator
325 else if (us->srb->sc_data_direction == SCSI_DATA_UNKNOWN) {
326 US_DEBUGP("UNKNOWN data direction\n");
327 us->srb->result = DID_ERROR << 16;
330 /* reject if target != 0 or if LUN is higher than
331 * the maximum known LUN
333 else if (us->srb->device->id &&
334 !(us->flags & US_FL_SCM_MULT_TARG)) {
335 US_DEBUGP("Bad target number (%d:%d)\n",
336 us->srb->device->id, us->srb->device->lun);
337 us->srb->result = DID_BAD_TARGET << 16;
340 else if (us->srb->device->lun > us->max_lun) {
341 US_DEBUGP("Bad LUN (%d:%d)\n",
342 us->srb->device->id, us->srb->device->lun);
343 us->srb->result = DID_BAD_TARGET << 16;
346 /* Handle those devices which need us to fake
347 * their inquiry data */
348 else if ((us->srb->cmnd[0] == INQUIRY) &&
349 (us->flags & US_FL_FIX_INQUIRY)) {
350 unsigned char data_ptr[36] = {
351 0x00, 0x80, 0x02, 0x02,
352 0x1F, 0x00, 0x00, 0x00};
354 US_DEBUGP("Faking INQUIRY command\n");
355 fill_inquiry_response(us, data_ptr, 36);
356 us->srb->result = SAM_STAT_GOOD;
359 /* we've got a command, let's do it! */
361 US_DEBUG(usb_stor_show_command(us->srb));
362 us->proto_handler(us->srb, us);
365 /* unlock the device pointers */
366 up(&(us->dev_semaphore));
368 /* lock access to the state */
371 /* indicate that the command is done */
372 if (us->srb->result != DID_ABORT << 16) {
373 US_DEBUGP("scsi cmd done, result=0x%x\n",
375 us->srb->scsi_done(us->srb);
378 US_DEBUGP("scsi command aborted\n");
381 /* If an abort request was received we need to signal that
382 * the abort has finished. The proper test for this is
383 * sm_state == US_STATE_ABORTING, not srb->result == DID_ABORT,
384 * because an abort request might be received after all the
385 * USB processing was complete. */
386 if (us->sm_state == US_STATE_ABORTING)
387 complete(&(us->notify));
389 /* empty the queue, reset the state, and release the lock */
391 us->sm_state = US_STATE_IDLE;
395 /* notify the exit routine that we're actually exiting now
397 * complete()/wait_for_completion() is similar to up()/down(),
398 * except that complete() is safe in the case where the structure
399 * is getting deleted in a parallel mode of execution (i.e. just
400 * after the down() -- that's necessary for the thread-shutdown
403 * complete_and_exit() goes even further than this -- it is safe in
404 * the case that the thread of the caller is going away (not just
405 * the structure) -- this is necessary for the module-remove case.
406 * This is important in preemption kernels, which transfer the flow
407 * of execution immediately upon a complete().
409 complete_and_exit(&(us->notify), 0);
412 /***********************************************************************
413 * Device probing and disconnecting
414 ***********************************************************************/
416 /* Associate our private data with the USB device */
417 static int associate_dev(struct us_data *us, struct usb_interface *intf)
419 US_DEBUGP("-- %s\n", __FUNCTION__);
421 /* Fill in the device-related fields */
422 us->pusb_dev = interface_to_usbdev(intf);
423 us->pusb_intf = intf;
424 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
426 /* Store our private data in the interface and increment the
427 * device's reference count */
428 usb_set_intfdata(intf, us);
429 usb_get_dev(us->pusb_dev);
431 /* Allocate the device-related DMA-mapped buffers */
432 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr),
433 GFP_KERNEL, &us->cr_dma);
435 US_DEBUGP("usb_ctrlrequest allocation failed\n");
439 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE,
440 GFP_KERNEL, &us->iobuf_dma);
442 US_DEBUGP("I/O buffer allocation failed\n");
448 /* Get the unusual_devs entries and the string descriptors */
449 static void get_device_info(struct us_data *us, int id_index)
451 struct usb_device *dev = us->pusb_dev;
452 struct usb_interface_descriptor *idesc =
453 &us->pusb_intf->cur_altsetting->desc;
454 struct us_unusual_dev *unusual_dev = &us_unusual_dev_list[id_index];
455 struct usb_device_id *id = &storage_usb_ids[id_index];
457 if (unusual_dev->vendorName)
458 US_DEBUGP("Vendor: %s\n", unusual_dev->vendorName);
459 if (unusual_dev->productName)
460 US_DEBUGP("Product: %s\n", unusual_dev->productName);
462 /* Store the entries */
463 us->unusual_dev = unusual_dev;
464 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
465 idesc->bInterfaceSubClass :
466 unusual_dev->useProtocol;
467 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
468 idesc->bInterfaceProtocol :
469 unusual_dev->useTransport;
470 us->flags = unusual_dev->flags;
472 /* Log a message if a non-generic unusual_dev entry contains an
473 * unnecessary subclass or protocol override. This may stimulate
474 * reports from users that will help us remove unneeded entries
475 * from the unusual_devs.h table.
477 if (id->idVendor || id->idProduct) {
478 static char *msgs[3] = {
479 "an unneeded SubClass entry",
480 "an unneeded Protocol entry",
481 "unneeded SubClass and Protocol entries"};
482 struct usb_device_descriptor *ddesc = &dev->descriptor;
485 if (unusual_dev->useProtocol != US_SC_DEVICE &&
486 us->subclass == idesc->bInterfaceSubClass)
488 if (unusual_dev->useTransport != US_PR_DEVICE &&
489 us->protocol == idesc->bInterfaceProtocol)
491 if (msg >= 0 && !(unusual_dev->flags & US_FL_NEED_OVERRIDE))
492 printk(KERN_NOTICE USB_STORAGE "This device "
493 "(%04x,%04x,%04x S %02x P %02x)"
494 " has %s in unusual_devs.h\n"
495 " Please send a copy of this message to "
496 "<linux-usb-devel@lists.sourceforge.net>\n",
497 ddesc->idVendor, ddesc->idProduct,
499 idesc->bInterfaceSubClass,
500 idesc->bInterfaceProtocol,
504 /* Read the device's string descriptors */
505 if (dev->descriptor.iManufacturer)
506 usb_string(dev, dev->descriptor.iManufacturer,
507 us->vendor, sizeof(us->vendor));
508 if (dev->descriptor.iProduct)
509 usb_string(dev, dev->descriptor.iProduct,
510 us->product, sizeof(us->product));
511 if (dev->descriptor.iSerialNumber)
512 usb_string(dev, dev->descriptor.iSerialNumber,
513 us->serial, sizeof(us->serial));
515 /* Use the unusual_dev strings if the device didn't provide them */
516 if (strlen(us->vendor) == 0) {
517 if (unusual_dev->vendorName)
518 strlcpy(us->vendor, unusual_dev->vendorName,
521 strcpy(us->vendor, "Unknown");
523 if (strlen(us->product) == 0) {
524 if (unusual_dev->productName)
525 strlcpy(us->product, unusual_dev->productName,
526 sizeof(us->product));
528 strcpy(us->product, "Unknown");
530 if (strlen(us->serial) == 0)
531 strcpy(us->serial, "None");
534 /* Get the transport settings */
535 static int get_transport(struct us_data *us)
537 switch (us->protocol) {
539 us->transport_name = "Control/Bulk";
540 us->transport = usb_stor_CB_transport;
541 us->transport_reset = usb_stor_CB_reset;
546 us->transport_name = "Control/Bulk/Interrupt";
547 us->transport = usb_stor_CBI_transport;
548 us->transport_reset = usb_stor_CB_reset;
553 us->transport_name = "Bulk";
554 us->transport = usb_stor_Bulk_transport;
555 us->transport_reset = usb_stor_Bulk_reset;
558 #ifdef CONFIG_USB_STORAGE_HP8200e
559 case US_PR_SCM_ATAPI:
560 us->transport_name = "SCM/ATAPI";
561 us->transport = hp8200e_transport;
562 us->transport_reset = usb_stor_CB_reset;
567 #ifdef CONFIG_USB_STORAGE_SDDR09
568 case US_PR_EUSB_SDDR09:
569 us->transport_name = "EUSB/SDDR09";
570 us->transport = sddr09_transport;
571 us->transport_reset = usb_stor_CB_reset;
576 #ifdef CONFIG_USB_STORAGE_SDDR55
578 us->transport_name = "SDDR55";
579 us->transport = sddr55_transport;
580 us->transport_reset = sddr55_reset;
585 #ifdef CONFIG_USB_STORAGE_DPCM
587 us->transport_name = "Control/Bulk-EUSB/SDDR09";
588 us->transport = dpcm_transport;
589 us->transport_reset = usb_stor_CB_reset;
594 #ifdef CONFIG_USB_STORAGE_FREECOM
596 us->transport_name = "Freecom";
597 us->transport = freecom_transport;
598 us->transport_reset = usb_stor_freecom_reset;
603 #ifdef CONFIG_USB_STORAGE_DATAFAB
605 us->transport_name = "Datafab Bulk-Only";
606 us->transport = datafab_transport;
607 us->transport_reset = usb_stor_Bulk_reset;
612 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
614 us->transport_name = "Lexar Jumpshot Control/Bulk";
615 us->transport = jumpshot_transport;
616 us->transport_reset = usb_stor_Bulk_reset;
624 US_DEBUGP("Transport: %s\n", us->transport_name);
626 /* fix for single-lun devices */
627 if (us->flags & US_FL_SINGLE_LUN)
632 /* Get the protocol settings */
633 static int get_protocol(struct us_data *us)
635 switch (us->subclass) {
637 us->protocol_name = "Reduced Block Commands (RBC)";
638 us->proto_handler = usb_stor_transparent_scsi_command;
642 us->protocol_name = "8020i";
643 us->proto_handler = usb_stor_ATAPI_command;
648 us->protocol_name = "QIC-157";
649 us->proto_handler = usb_stor_qic157_command;
654 us->protocol_name = "8070i";
655 us->proto_handler = usb_stor_ATAPI_command;
660 us->protocol_name = "Transparent SCSI";
661 us->proto_handler = usb_stor_transparent_scsi_command;
665 us->protocol_name = "Uniform Floppy Interface (UFI)";
666 us->proto_handler = usb_stor_ufi_command;
669 #ifdef CONFIG_USB_STORAGE_ISD200
671 us->protocol_name = "ISD200 ATA/ATAPI";
672 us->proto_handler = isd200_ata_command;
679 US_DEBUGP("Protocol: %s\n", us->protocol_name);
683 /* Get the pipe settings */
684 static int get_pipes(struct us_data *us)
686 struct usb_host_interface *altsetting =
687 us->pusb_intf->cur_altsetting;
689 struct usb_endpoint_descriptor *ep;
690 struct usb_endpoint_descriptor *ep_in = NULL;
691 struct usb_endpoint_descriptor *ep_out = NULL;
692 struct usb_endpoint_descriptor *ep_int = NULL;
695 * Find the endpoints we need.
696 * We are expecting a minimum of 2 endpoints - in and out (bulk).
697 * An optional interrupt is OK (necessary for CBI protocol).
698 * We will ignore any others.
700 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
701 ep = &altsetting->endpoint[i].desc;
703 /* Is it a BULK endpoint? */
704 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
705 == USB_ENDPOINT_XFER_BULK) {
706 /* BULK in or out? */
707 if (ep->bEndpointAddress & USB_DIR_IN)
713 /* Is it an interrupt endpoint? */
714 else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
715 == USB_ENDPOINT_XFER_INT) {
719 US_DEBUGP("Endpoints: In: 0x%p Out: 0x%p Int: 0x%p (Period %d)\n",
720 ep_in, ep_out, ep_int, ep_int ? ep_int->bInterval : 0);
722 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
723 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
727 /* Calculate and store the pipe values */
728 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
729 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
730 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
731 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
732 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
733 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
735 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
736 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
737 us->ep_bInterval = ep_int->bInterval;
742 /* Initialize all the dynamic resources we need */
743 static int usb_stor_acquire_resources(struct us_data *us)
747 us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
748 if (!us->current_urb) {
749 US_DEBUGP("URB allocation failed\n");
753 /* Lock the device while we carry out the next two operations */
754 down(&us->dev_semaphore);
756 /* For bulk-only devices, determine the max LUN value */
757 if (us->protocol == US_PR_BULK)
758 us->max_lun = usb_stor_Bulk_max_lun(us);
760 /* Just before we start our control thread, initialize
761 * the device if it needs initialization */
762 if (us->unusual_dev->initFunction)
763 us->unusual_dev->initFunction(us);
765 up(&us->dev_semaphore);
767 /* Start up our control thread */
768 us->sm_state = US_STATE_IDLE;
769 p = kernel_thread(usb_stor_control_thread, us, CLONE_VM);
771 printk(KERN_WARNING USB_STORAGE
772 "Unable to start control thread\n");
777 /* Wait for the thread to start */
778 wait_for_completion(&(us->notify));
781 * Since this is a new device, we need to register a SCSI
782 * host definition with the higher SCSI layers.
784 us->host = scsi_host_alloc(&usb_stor_host_template, sizeof(us));
786 printk(KERN_WARNING USB_STORAGE
787 "Unable to register the scsi host\n");
791 /* Set the hostdata to prepare for scanning */
792 us->host->hostdata[0] = (unsigned long) us;
797 /* Dissociate from the USB device */
798 static void dissociate_dev(struct us_data *us)
800 US_DEBUGP("-- %s\n", __FUNCTION__);
801 down(&us->dev_semaphore);
803 /* Free the device-related DMA-mapped buffers */
805 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
810 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
815 /* Remove our private data from the interface and decrement the
816 * device's reference count */
817 usb_set_intfdata(us->pusb_intf, NULL);
818 usb_put_dev(us->pusb_dev);
821 us->pusb_intf = NULL;
822 up(&us->dev_semaphore);
825 /* Release all our static and dynamic resources */
826 void usb_stor_release_resources(struct us_data *us)
829 * The host must already have been removed
830 * and dissociate_dev() must have been called.
833 /* Finish the SCSI host removal sequence */
835 us->host->hostdata[0] = 0;
836 scsi_host_put(us->host);
839 /* Kill the control thread
841 * Enqueue the command, wake up the thread, and wait for
842 * notification that it has exited.
845 US_DEBUGP("-- sending exit command to thread\n");
846 BUG_ON(us->sm_state != US_STATE_IDLE);
849 wait_for_completion(&(us->notify));
852 /* Call the destructor routine, if it exists */
853 if (us->extra_destructor) {
854 US_DEBUGP("-- calling extra_destructor()\n");
855 us->extra_destructor(us->extra);
858 /* Free the extra data and the URB */
862 usb_free_urb(us->current_urb);
864 /* Free the structure itself */
866 US_DEBUGP("-- %s finished\n", __FUNCTION__);
869 /* Probe to see if we can drive a newly-connected USB device */
870 static int storage_probe(struct usb_interface *intf,
871 const struct usb_device_id *id)
874 const int id_index = id - storage_usb_ids;
877 US_DEBUGP("USB Mass Storage device detected\n");
878 US_DEBUGP("altsetting is %d, id_index is %d\n",
879 intf->cur_altsetting->desc.bAlternateSetting,
882 /* Allocate the us_data structure and initialize the mutexes */
883 us = (struct us_data *) kmalloc(sizeof(*us), GFP_KERNEL);
885 printk(KERN_WARNING USB_STORAGE "Out of memory\n");
888 memset(us, 0, sizeof(struct us_data));
889 init_MUTEX(&(us->dev_semaphore));
890 init_MUTEX_LOCKED(&(us->sema));
891 init_completion(&(us->notify));
893 /* Associate the us_data structure with the USB device */
894 result = associate_dev(us, intf);
899 * Get the unusual_devs entries and the descriptors
901 * id_index is calculated in the declaration to be the index number
902 * of the match from the usb_device_id table, so we can find the
903 * corresponding entry in the private table.
905 get_device_info(us, id_index);
907 #ifdef CONFIG_USB_STORAGE_SDDR09
908 if (us->protocol == US_PR_EUSB_SDDR09 ||
909 us->protocol == US_PR_DPCM_USB) {
910 /* set the configuration -- STALL is an acceptable response here */
911 if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) {
912 US_DEBUGP("active config #%d != 1 ??\n", us->pusb_dev
913 ->actconfig->desc.bConfigurationValue);
916 result = usb_reset_configuration(us->pusb_dev);
918 US_DEBUGP("Result of usb_reset_configuration is %d\n", result);
919 if (result == -EPIPE) {
920 US_DEBUGP("-- stall on control interface\n");
921 } else if (result != 0) {
922 /* it's not a stall, but another error -- time to bail */
923 US_DEBUGP("-- Unknown error. Rejecting device\n");
929 /* Get the transport, protocol, and pipe settings */
930 result = get_transport(us);
933 result = get_protocol(us);
936 result = get_pipes(us);
940 /* Acquire all the other resources */
941 result = usb_stor_acquire_resources(us);
945 /* Finally, add the host (this does SCSI device scanning) */
946 result = scsi_add_host(us->host, &intf->dev);
948 printk(KERN_WARNING USB_STORAGE
949 "Unable to add the scsi host\n");
953 scsi_scan_host(us->host);
956 "USB Mass Storage device found at %d\n", us->pusb_dev->devnum);
959 /* We come here if there are any problems */
961 US_DEBUGP("storage_probe() failed\n");
963 usb_stor_release_resources(us);
967 /* Handle a disconnect event from the USB core */
968 static void storage_disconnect(struct usb_interface *intf)
970 struct us_data *us = usb_get_intfdata(intf);
972 US_DEBUGP("storage_disconnect() called\n");
974 /* Prevent new USB transfers and stop the current command */
975 set_bit(US_FLIDX_DISCONNECTING, &us->flags);
976 usb_stor_stop_transport(us);
978 /* Dissociate from the USB device */
981 scsi_remove_host(us->host);
983 /* TODO: somehow, wait for the device to
984 * be 'idle' (tasklet completion) */
986 /* Release all our other resources */
987 usb_stor_release_resources(us);
990 /***********************************************************************
991 * Initialization and registration
992 ***********************************************************************/
994 static int __init usb_stor_init(void)
997 printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
999 /* register the driver, return usb_register return code if error */
1000 retval = usb_register(&usb_storage_driver);
1005 printk(KERN_INFO "USB Mass Storage support registered.\n");
1010 static void __exit usb_stor_exit(void)
1012 US_DEBUGP("usb_stor_exit() called\n");
1014 /* Deregister the driver
1015 * This will cause disconnect() to be called for each
1018 US_DEBUGP("-- calling usb_deregister()\n");
1019 usb_deregister(&usb_storage_driver) ;
1022 /* While there are still virtual hosts, unregister them
1023 * Note that it's important to do this completely before removing
1024 * the structures because of possible races with the /proc
1027 for (next = us_list; next; next = next->next) {
1028 US_DEBUGP("-- calling scsi_unregister_host()\n");
1029 scsi_unregister_host(&usb_stor_host_template);
1032 /* While there are still structures, free them. Note that we are
1033 * now race-free, since these structures can no longer be accessed
1034 * from either the SCSI command layer or the /proc interface
1037 /* keep track of where the next one is */
1038 next = us_list->next;
1040 /* If there's extra data in the us_data structure then
1041 * free that first */
1042 if (us_list->extra) {
1043 /* call the destructor routine, if it exists */
1044 if (us_list->extra_destructor) {
1045 US_DEBUGP("-- calling extra_destructor()\n");
1046 us_list->extra_destructor(us_list->extra);
1049 /* destroy the extra data */
1050 US_DEBUGP("-- freeing the data structure\n");
1051 kfree(us_list->extra);
1054 /* free the structure itself */
1057 /* advance the list pointer */
1063 module_init(usb_stor_init);
1064 module_exit(usb_stor_exit);