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/sched.h>
88 #include <linux/errno.h>
89 #include <linux/init.h>
90 #include <linux/slab.h>
92 /* Some informational data */
93 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
94 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
95 MODULE_LICENSE("GPL");
97 static int storage_probe(struct usb_interface *iface,
98 const struct usb_device_id *id);
100 static void storage_disconnect(struct usb_interface *iface);
102 /* The entries in this table, except for final ones here
103 * (USB_MASS_STORAGE_CLASS and the empty entry), correspond,
104 * line for line with the entries of us_unsuaul_dev_list[].
107 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
108 vendorName, productName,useProtocol, useTransport, \
109 initFunction, flags) \
110 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax) }
112 static struct usb_device_id storage_usb_ids [] = {
114 # include "unusual_devs.h"
116 /* Control/Bulk transport for all SubClass values */
117 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CB) },
118 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CB) },
119 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CB) },
120 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CB) },
121 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CB) },
122 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CB) },
124 /* Control/Bulk/Interrupt transport for all SubClass values */
125 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CBI) },
126 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CBI) },
127 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CBI) },
128 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CBI) },
129 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CBI) },
130 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CBI) },
132 /* Bulk-only transport for all SubClass values */
133 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_BULK) },
134 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_BULK) },
135 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_BULK) },
136 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_BULK) },
137 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_BULK) },
138 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) },
140 /* Terminating entry */
144 MODULE_DEVICE_TABLE (usb, storage_usb_ids);
146 /* This is the list of devices we recognize, along with their flag data */
148 /* The vendor name should be kept at eight characters or less, and
149 * the product name should be kept at 16 characters or less. If a device
150 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
151 * normally generated by a device thorugh the INQUIRY response will be
152 * taken from this list, and this is the reason for the above size
153 * restriction. However, if the flag is not present, then you
154 * are free to use as many characters as you like.
158 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
159 vendor_name, product_name, use_protocol, use_transport, \
160 init_function, Flags) \
162 .vendorName = vendor_name, \
163 .productName = product_name, \
164 .useProtocol = use_protocol, \
165 .useTransport = use_transport, \
166 .initFunction = init_function, \
170 static struct us_unusual_dev us_unusual_dev_list[] = {
171 # include "unusual_devs.h"
173 /* Control/Bulk transport for all SubClass values */
174 { .useProtocol = US_SC_RBC,
175 .useTransport = US_PR_CB},
176 { .useProtocol = US_SC_8020,
177 .useTransport = US_PR_CB},
178 { .useProtocol = US_SC_QIC,
179 .useTransport = US_PR_CB},
180 { .useProtocol = US_SC_UFI,
181 .useTransport = US_PR_CB},
182 { .useProtocol = US_SC_8070,
183 .useTransport = US_PR_CB},
184 { .useProtocol = US_SC_SCSI,
185 .useTransport = US_PR_CB},
187 /* Control/Bulk/Interrupt transport for all SubClass values */
188 { .useProtocol = US_SC_RBC,
189 .useTransport = US_PR_CBI},
190 { .useProtocol = US_SC_8020,
191 .useTransport = US_PR_CBI},
192 { .useProtocol = US_SC_QIC,
193 .useTransport = US_PR_CBI},
194 { .useProtocol = US_SC_UFI,
195 .useTransport = US_PR_CBI},
196 { .useProtocol = US_SC_8070,
197 .useTransport = US_PR_CBI},
198 { .useProtocol = US_SC_SCSI,
199 .useTransport = US_PR_CBI},
201 /* Bulk-only transport for all SubClass values */
202 { .useProtocol = US_SC_RBC,
203 .useTransport = US_PR_BULK},
204 { .useProtocol = US_SC_8020,
205 .useTransport = US_PR_BULK},
206 { .useProtocol = US_SC_QIC,
207 .useTransport = US_PR_BULK},
208 { .useProtocol = US_SC_UFI,
209 .useTransport = US_PR_BULK},
210 { .useProtocol = US_SC_8070,
211 .useTransport = US_PR_BULK},
212 { .useProtocol = US_SC_SCSI,
213 .useTransport = US_PR_BULK},
215 /* Terminating entry */
219 struct usb_driver usb_storage_driver = {
220 .owner = THIS_MODULE,
221 .name = "usb-storage",
222 .probe = storage_probe,
223 .disconnect = storage_disconnect,
224 .id_table = storage_usb_ids,
228 * fill_inquiry_response takes an unsigned char array (which must
229 * be at least 36 characters) and populates the vendor name,
230 * product name, and revision fields. Then the array is copied
231 * into the SCSI command's response buffer (oddly enough
232 * called request_buffer). data_len contains the length of the
233 * data array, which again must be at least 36.
236 void fill_inquiry_response(struct us_data *us, unsigned char *data,
237 unsigned int data_len)
239 if (data_len<36) // You lose.
242 if(data[0]&0x20) { /* USB device currently not connected. Return
243 peripheral qualifier 001b ("...however, the
244 physical device is not currently connected
245 to this logical unit") and leave vendor and
246 product identification empty. ("If the target
247 does store some of the INQUIRY data on the
248 device, it may return zeros or ASCII spaces
249 (20h) in those fields until the data is
250 available from the device."). */
253 memcpy(data+8, us->unusual_dev->vendorName,
254 strlen(us->unusual_dev->vendorName) > 8 ? 8 :
255 strlen(us->unusual_dev->vendorName));
256 memcpy(data+16, us->unusual_dev->productName,
257 strlen(us->unusual_dev->productName) > 16 ? 16 :
258 strlen(us->unusual_dev->productName));
259 data[32] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice>>12) & 0x0F);
260 data[33] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice>>8) & 0x0F);
261 data[34] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice>>4) & 0x0F);
262 data[35] = 0x30 + ((us->pusb_dev->descriptor.bcdDevice) & 0x0F);
265 usb_stor_set_xfer_buf(data, data_len, us->srb);
268 static int usb_stor_control_thread(void * __us)
270 struct us_data *us = (struct us_data *)__us;
275 * This thread doesn't need any user-level access,
276 * so get rid of all our resources.
278 daemonize("usb-storage");
280 current->flags |= PF_NOFREEZE;
284 /* signal that we've started the thread */
285 complete(&(us->notify));
288 struct Scsi_Host *host;
289 US_DEBUGP("*** thread sleeping.\n");
290 if(down_interruptible(&us->sema))
293 US_DEBUGP("*** thread awakened.\n");
295 /* if us->srb is NULL, we are being asked to exit */
296 if (us->srb == NULL) {
297 US_DEBUGP("-- exit command received\n");
300 host = us->srb->device->host;
302 /* lock access to the state */
305 /* has the command been aborted *already* ? */
306 if (us->sm_state == US_STATE_ABORTING) {
307 us->srb->result = DID_ABORT << 16;
311 /* set the state and release the lock */
312 us->sm_state = US_STATE_RUNNING;
315 /* lock the device pointers */
316 down(&(us->dev_semaphore));
318 /* don't do anything if we are disconnecting */
319 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
320 US_DEBUGP("No command during disconnect\n");
321 us->srb->result = DID_BAD_TARGET << 16;
324 /* reject the command if the direction indicator
327 else if (us->srb->sc_data_direction == SCSI_DATA_UNKNOWN) {
328 US_DEBUGP("UNKNOWN data direction\n");
329 us->srb->result = DID_ERROR << 16;
332 /* reject if target != 0 or if LUN is higher than
333 * the maximum known LUN
335 else if (us->srb->device->id &&
336 !(us->flags & US_FL_SCM_MULT_TARG)) {
337 US_DEBUGP("Bad target number (%d:%d)\n",
338 us->srb->device->id, us->srb->device->lun);
339 us->srb->result = DID_BAD_TARGET << 16;
342 else if (us->srb->device->lun > us->max_lun) {
343 US_DEBUGP("Bad LUN (%d:%d)\n",
344 us->srb->device->id, us->srb->device->lun);
345 us->srb->result = DID_BAD_TARGET << 16;
348 /* Handle those devices which need us to fake
349 * their inquiry data */
350 else if ((us->srb->cmnd[0] == INQUIRY) &&
351 (us->flags & US_FL_FIX_INQUIRY)) {
352 unsigned char data_ptr[36] = {
353 0x00, 0x80, 0x02, 0x02,
354 0x1F, 0x00, 0x00, 0x00};
356 US_DEBUGP("Faking INQUIRY command\n");
357 fill_inquiry_response(us, data_ptr, 36);
358 us->srb->result = SAM_STAT_GOOD;
361 /* we've got a command, let's do it! */
363 US_DEBUG(usb_stor_show_command(us->srb));
364 us->proto_handler(us->srb, us);
367 /* unlock the device pointers */
368 up(&(us->dev_semaphore));
370 /* lock access to the state */
373 /* indicate that the command is done */
374 if (us->srb->result != DID_ABORT << 16) {
375 US_DEBUGP("scsi cmd done, result=0x%x\n",
377 us->srb->scsi_done(us->srb);
380 US_DEBUGP("scsi command aborted\n");
383 /* If an abort request was received we need to signal that
384 * the abort has finished. The proper test for this is
385 * sm_state == US_STATE_ABORTING, not srb->result == DID_ABORT,
386 * because an abort request might be received after all the
387 * USB processing was complete. */
388 if (us->sm_state == US_STATE_ABORTING)
389 complete(&(us->notify));
391 /* empty the queue, reset the state, and release the lock */
393 us->sm_state = US_STATE_IDLE;
397 /* notify the exit routine that we're actually exiting now
399 * complete()/wait_for_completion() is similar to up()/down(),
400 * except that complete() is safe in the case where the structure
401 * is getting deleted in a parallel mode of execution (i.e. just
402 * after the down() -- that's necessary for the thread-shutdown
405 * complete_and_exit() goes even further than this -- it is safe in
406 * the case that the thread of the caller is going away (not just
407 * the structure) -- this is necessary for the module-remove case.
408 * This is important in preemption kernels, which transfer the flow
409 * of execution immediately upon a complete().
411 complete_and_exit(&(us->notify), 0);
414 /***********************************************************************
415 * Device probing and disconnecting
416 ***********************************************************************/
418 /* Associate our private data with the USB device */
419 static int associate_dev(struct us_data *us, struct usb_interface *intf)
421 US_DEBUGP("-- %s\n", __FUNCTION__);
423 /* Fill in the device-related fields */
424 us->pusb_dev = interface_to_usbdev(intf);
425 us->pusb_intf = intf;
426 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
428 /* Store our private data in the interface and increment the
429 * device's reference count */
430 usb_set_intfdata(intf, us);
431 usb_get_dev(us->pusb_dev);
433 /* Allocate the device-related DMA-mapped buffers */
434 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr),
435 GFP_KERNEL, &us->cr_dma);
437 US_DEBUGP("usb_ctrlrequest allocation failed\n");
441 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE,
442 GFP_KERNEL, &us->iobuf_dma);
444 US_DEBUGP("I/O buffer allocation failed\n");
450 /* Get the unusual_devs entries and the string descriptors */
451 static void get_device_info(struct us_data *us, int id_index)
453 struct usb_device *dev = us->pusb_dev;
454 struct usb_interface_descriptor *idesc =
455 &us->pusb_intf->cur_altsetting->desc;
456 struct us_unusual_dev *unusual_dev = &us_unusual_dev_list[id_index];
457 struct usb_device_id *id = &storage_usb_ids[id_index];
459 if (unusual_dev->vendorName)
460 US_DEBUGP("Vendor: %s\n", unusual_dev->vendorName);
461 if (unusual_dev->productName)
462 US_DEBUGP("Product: %s\n", unusual_dev->productName);
464 /* Store the entries */
465 us->unusual_dev = unusual_dev;
466 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
467 idesc->bInterfaceSubClass :
468 unusual_dev->useProtocol;
469 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
470 idesc->bInterfaceProtocol :
471 unusual_dev->useTransport;
472 us->flags = unusual_dev->flags;
474 /* Log a message if a non-generic unusual_dev entry contains an
475 * unnecessary subclass or protocol override. This may stimulate
476 * reports from users that will help us remove unneeded entries
477 * from the unusual_devs.h table.
479 if (id->idVendor || id->idProduct) {
480 static char *msgs[3] = {
481 "an unneeded SubClass entry",
482 "an unneeded Protocol entry",
483 "unneeded SubClass and Protocol entries"};
484 struct usb_device_descriptor *ddesc = &dev->descriptor;
487 if (unusual_dev->useProtocol != US_SC_DEVICE &&
488 us->subclass == idesc->bInterfaceSubClass)
490 if (unusual_dev->useTransport != US_PR_DEVICE &&
491 us->protocol == idesc->bInterfaceProtocol)
494 printk(KERN_NOTICE USB_STORAGE "This device "
495 "(%04x,%04x,%04x S %02x P %02x)"
496 " has %s in unusual_devs.h\n"
497 " Please send a copy of this message to "
498 "<linux-usb-devel@lists.sourceforge.net>\n",
499 ddesc->idVendor, ddesc->idProduct,
501 idesc->bInterfaceSubClass,
502 idesc->bInterfaceProtocol,
506 /* Read the device's string descriptors */
507 if (dev->descriptor.iManufacturer)
508 usb_string(dev, dev->descriptor.iManufacturer,
509 us->vendor, sizeof(us->vendor));
510 if (dev->descriptor.iProduct)
511 usb_string(dev, dev->descriptor.iProduct,
512 us->product, sizeof(us->product));
513 if (dev->descriptor.iSerialNumber)
514 usb_string(dev, dev->descriptor.iSerialNumber,
515 us->serial, sizeof(us->serial));
517 /* Use the unusual_dev strings if the device didn't provide them */
518 if (strlen(us->vendor) == 0) {
519 if (unusual_dev->vendorName)
520 strlcpy(us->vendor, unusual_dev->vendorName,
523 strcpy(us->vendor, "Unknown");
525 if (strlen(us->product) == 0) {
526 if (unusual_dev->productName)
527 strlcpy(us->product, unusual_dev->productName,
528 sizeof(us->product));
530 strcpy(us->product, "Unknown");
532 if (strlen(us->serial) == 0)
533 strcpy(us->serial, "None");
536 /* Get the transport settings */
537 static int get_transport(struct us_data *us)
539 switch (us->protocol) {
541 us->transport_name = "Control/Bulk";
542 us->transport = usb_stor_CB_transport;
543 us->transport_reset = usb_stor_CB_reset;
548 us->transport_name = "Control/Bulk/Interrupt";
549 us->transport = usb_stor_CBI_transport;
550 us->transport_reset = usb_stor_CB_reset;
555 us->transport_name = "Bulk";
556 us->transport = usb_stor_Bulk_transport;
557 us->transport_reset = usb_stor_Bulk_reset;
560 #ifdef CONFIG_USB_STORAGE_HP8200e
561 case US_PR_SCM_ATAPI:
562 us->transport_name = "SCM/ATAPI";
563 us->transport = hp8200e_transport;
564 us->transport_reset = usb_stor_CB_reset;
569 #ifdef CONFIG_USB_STORAGE_SDDR09
570 case US_PR_EUSB_SDDR09:
571 us->transport_name = "EUSB/SDDR09";
572 us->transport = sddr09_transport;
573 us->transport_reset = usb_stor_CB_reset;
578 #ifdef CONFIG_USB_STORAGE_SDDR55
580 us->transport_name = "SDDR55";
581 us->transport = sddr55_transport;
582 us->transport_reset = sddr55_reset;
587 #ifdef CONFIG_USB_STORAGE_DPCM
589 us->transport_name = "Control/Bulk-EUSB/SDDR09";
590 us->transport = dpcm_transport;
591 us->transport_reset = usb_stor_CB_reset;
596 #ifdef CONFIG_USB_STORAGE_FREECOM
598 us->transport_name = "Freecom";
599 us->transport = freecom_transport;
600 us->transport_reset = usb_stor_freecom_reset;
605 #ifdef CONFIG_USB_STORAGE_DATAFAB
607 us->transport_name = "Datafab Bulk-Only";
608 us->transport = datafab_transport;
609 us->transport_reset = usb_stor_Bulk_reset;
614 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
616 us->transport_name = "Lexar Jumpshot Control/Bulk";
617 us->transport = jumpshot_transport;
618 us->transport_reset = usb_stor_Bulk_reset;
626 US_DEBUGP("Transport: %s\n", us->transport_name);
628 /* fix for single-lun devices */
629 if (us->flags & US_FL_SINGLE_LUN)
634 /* Get the protocol settings */
635 static int get_protocol(struct us_data *us)
637 switch (us->subclass) {
639 us->protocol_name = "Reduced Block Commands (RBC)";
640 us->proto_handler = usb_stor_transparent_scsi_command;
644 us->protocol_name = "8020i";
645 us->proto_handler = usb_stor_ATAPI_command;
650 us->protocol_name = "QIC-157";
651 us->proto_handler = usb_stor_qic157_command;
656 us->protocol_name = "8070i";
657 us->proto_handler = usb_stor_ATAPI_command;
662 us->protocol_name = "Transparent SCSI";
663 us->proto_handler = usb_stor_transparent_scsi_command;
667 us->protocol_name = "Uniform Floppy Interface (UFI)";
668 us->proto_handler = usb_stor_ufi_command;
671 #ifdef CONFIG_USB_STORAGE_ISD200
673 us->protocol_name = "ISD200 ATA/ATAPI";
674 us->proto_handler = isd200_ata_command;
681 US_DEBUGP("Protocol: %s\n", us->protocol_name);
685 /* Get the pipe settings */
686 static int get_pipes(struct us_data *us)
688 struct usb_host_interface *altsetting =
689 us->pusb_intf->cur_altsetting;
691 struct usb_endpoint_descriptor *ep;
692 struct usb_endpoint_descriptor *ep_in = NULL;
693 struct usb_endpoint_descriptor *ep_out = NULL;
694 struct usb_endpoint_descriptor *ep_int = NULL;
697 * Find the endpoints we need.
698 * We are expecting a minimum of 2 endpoints - in and out (bulk).
699 * An optional interrupt is OK (necessary for CBI protocol).
700 * We will ignore any others.
702 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
703 ep = &altsetting->endpoint[i].desc;
705 /* Is it a BULK endpoint? */
706 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
707 == USB_ENDPOINT_XFER_BULK) {
708 /* BULK in or out? */
709 if (ep->bEndpointAddress & USB_DIR_IN)
715 /* Is it an interrupt endpoint? */
716 else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
717 == USB_ENDPOINT_XFER_INT) {
721 US_DEBUGP("Endpoints: In: 0x%p Out: 0x%p Int: 0x%p (Period %d)\n",
722 ep_in, ep_out, ep_int, ep_int ? ep_int->bInterval : 0);
724 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
725 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
729 /* Calculate and store the pipe values */
730 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
731 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
732 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
733 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
734 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
735 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
737 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
738 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
739 us->ep_bInterval = ep_int->bInterval;
744 /* Initialize all the dynamic resources we need */
745 static int usb_stor_acquire_resources(struct us_data *us)
749 us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
750 if (!us->current_urb) {
751 US_DEBUGP("URB allocation failed\n");
755 /* Lock the device while we carry out the next two operations */
756 down(&us->dev_semaphore);
758 /* For bulk-only devices, determine the max LUN value */
759 if (us->protocol == US_PR_BULK)
760 us->max_lun = usb_stor_Bulk_max_lun(us);
762 /* Just before we start our control thread, initialize
763 * the device if it needs initialization */
764 if (us->unusual_dev->initFunction)
765 us->unusual_dev->initFunction(us);
767 up(&us->dev_semaphore);
769 /* Start up our control thread */
770 us->sm_state = US_STATE_IDLE;
771 p = kernel_thread(usb_stor_control_thread, us, CLONE_VM);
773 printk(KERN_WARNING USB_STORAGE
774 "Unable to start control thread\n");
779 /* Wait for the thread to start */
780 wait_for_completion(&(us->notify));
783 * Since this is a new device, we need to register a SCSI
784 * host definition with the higher SCSI layers.
786 us->host = scsi_host_alloc(&usb_stor_host_template, sizeof(us));
788 printk(KERN_WARNING USB_STORAGE
789 "Unable to register the scsi host\n");
793 /* Set the hostdata to prepare for scanning */
794 us->host->hostdata[0] = (unsigned long) us;
799 /* Dissociate from the USB device */
800 static void dissociate_dev(struct us_data *us)
802 US_DEBUGP("-- %s\n", __FUNCTION__);
803 down(&us->dev_semaphore);
805 /* Free the device-related DMA-mapped buffers */
807 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
812 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
817 /* Remove our private data from the interface and decrement the
818 * device's reference count */
819 usb_set_intfdata(us->pusb_intf, NULL);
820 usb_put_dev(us->pusb_dev);
823 us->pusb_intf = NULL;
824 up(&us->dev_semaphore);
827 /* Release all our static and dynamic resources */
828 void usb_stor_release_resources(struct us_data *us)
831 * The host must already have been removed
832 * and dissociate_dev() must have been called.
835 /* Finish the SCSI host removal sequence */
837 us->host->hostdata[0] = 0;
838 scsi_host_put(us->host);
841 /* Kill the control thread
843 * Enqueue the command, wake up the thread, and wait for
844 * notification that it has exited.
847 US_DEBUGP("-- sending exit command to thread\n");
848 BUG_ON(us->sm_state != US_STATE_IDLE);
851 wait_for_completion(&(us->notify));
854 /* Call the destructor routine, if it exists */
855 if (us->extra_destructor) {
856 US_DEBUGP("-- calling extra_destructor()\n");
857 us->extra_destructor(us->extra);
860 /* Free the extra data and the URB */
864 usb_free_urb(us->current_urb);
866 /* Free the structure itself */
868 US_DEBUGP("-- %s finished\n", __FUNCTION__);
871 /* Probe to see if we can drive a newly-connected USB device */
872 static int storage_probe(struct usb_interface *intf,
873 const struct usb_device_id *id)
876 const int id_index = id - storage_usb_ids;
879 US_DEBUGP("USB Mass Storage device detected\n");
880 US_DEBUGP("altsetting is %d, id_index is %d\n",
881 intf->cur_altsetting->desc.bAlternateSetting,
884 /* Allocate the us_data structure and initialize the mutexes */
885 us = (struct us_data *) kmalloc(sizeof(*us), GFP_KERNEL);
887 printk(KERN_WARNING USB_STORAGE "Out of memory\n");
890 memset(us, 0, sizeof(struct us_data));
891 init_MUTEX(&(us->dev_semaphore));
892 init_MUTEX_LOCKED(&(us->sema));
893 init_completion(&(us->notify));
895 /* Associate the us_data structure with the USB device */
896 result = associate_dev(us, intf);
901 * Get the unusual_devs entries and the descriptors
903 * id_index is calculated in the declaration to be the index number
904 * of the match from the usb_device_id table, so we can find the
905 * corresponding entry in the private table.
907 get_device_info(us, id_index);
909 #ifdef CONFIG_USB_STORAGE_SDDR09
910 if (us->protocol == US_PR_EUSB_SDDR09 ||
911 us->protocol == US_PR_DPCM_USB) {
912 /* set the configuration -- STALL is an acceptable response here */
913 if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) {
914 US_DEBUGP("active config #%d != 1 ??\n", us->pusb_dev
915 ->actconfig->desc.bConfigurationValue);
918 result = usb_reset_configuration(us->pusb_dev);
920 US_DEBUGP("Result of usb_reset_configuration is %d\n", result);
921 if (result == -EPIPE) {
922 US_DEBUGP("-- stall on control interface\n");
923 } else if (result != 0) {
924 /* it's not a stall, but another error -- time to bail */
925 US_DEBUGP("-- Unknown error. Rejecting device\n");
931 /* Get the transport, protocol, and pipe settings */
932 result = get_transport(us);
935 result = get_protocol(us);
938 result = get_pipes(us);
942 /* Acquire all the other resources */
943 result = usb_stor_acquire_resources(us);
947 /* Finally, add the host (this does SCSI device scanning) */
948 result = scsi_add_host(us->host, &intf->dev);
950 printk(KERN_WARNING USB_STORAGE
951 "Unable to add the scsi host\n");
955 scsi_scan_host(us->host);
958 "USB Mass Storage device found at %d\n", us->pusb_dev->devnum);
961 /* We come here if there are any problems */
963 US_DEBUGP("storage_probe() failed\n");
965 usb_stor_release_resources(us);
969 /* Handle a disconnect event from the USB core */
970 static void storage_disconnect(struct usb_interface *intf)
972 struct us_data *us = usb_get_intfdata(intf);
974 US_DEBUGP("storage_disconnect() called\n");
976 /* Prevent new USB transfers and stop the current command */
977 set_bit(US_FLIDX_DISCONNECTING, &us->flags);
978 usb_stor_stop_transport(us);
980 /* Dissociate from the USB device */
983 scsi_remove_host(us->host);
985 /* TODO: somehow, wait for the device to
986 * be 'idle' (tasklet completion) */
988 /* Release all our other resources */
989 usb_stor_release_resources(us);
992 /***********************************************************************
993 * Initialization and registration
994 ***********************************************************************/
996 static int __init usb_stor_init(void)
999 printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
1001 /* register the driver, return usb_register return code if error */
1002 retval = usb_register(&usb_storage_driver);
1007 printk(KERN_INFO "USB Mass Storage support registered.\n");
1012 static void __exit usb_stor_exit(void)
1014 US_DEBUGP("usb_stor_exit() called\n");
1016 /* Deregister the driver
1017 * This will cause disconnect() to be called for each
1020 US_DEBUGP("-- calling usb_deregister()\n");
1021 usb_deregister(&usb_storage_driver) ;
1024 /* While there are still virtual hosts, unregister them
1025 * Note that it's important to do this completely before removing
1026 * the structures because of possible races with the /proc
1029 for (next = us_list; next; next = next->next) {
1030 US_DEBUGP("-- calling scsi_unregister_host()\n");
1031 scsi_unregister_host(&usb_stor_host_template);
1034 /* While there are still structures, free them. Note that we are
1035 * now race-free, since these structures can no longer be accessed
1036 * from either the SCSI command layer or the /proc interface
1039 /* keep track of where the next one is */
1040 next = us_list->next;
1042 /* If there's extra data in the us_data structure then
1043 * free that first */
1044 if (us_list->extra) {
1045 /* call the destructor routine, if it exists */
1046 if (us_list->extra_destructor) {
1047 US_DEBUGP("-- calling extra_destructor()\n");
1048 us_list->extra_destructor(us_list->extra);
1051 /* destroy the extra data */
1052 US_DEBUGP("-- freeing the data structure\n");
1053 kfree(us_list->extra);
1056 /* free the structure itself */
1059 /* advance the list pointer */
1065 module_init(usb_stor_init);
1066 module_exit(usb_stor_exit);