1 /* Driver for USB Mass Storage compliant devices 2 * 3 * $Id: usb.c,v 1.75 2002/04/22 03:39:43 mdharm Exp $ 4 * 5 * Current development and maintenance by: 6 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net) 7 * 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) 11 * 12 * Initial work by: 13 * (c) 1999 Michael Gee (michael@linuxspecific.com) 14 * 15 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com): 16 * (c) 2000 Yggdrasil Computing, Inc. 17 * 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. 23 * 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. 28 * 29 * Also, for certain devices, the interrupt endpoint is used to convey 30 * status of a command. 31 * 32 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more 33 * information about this driver. 34 * 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 38 * later version. 39 * 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. 44 * 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. 48 */ 49 50 #include <linux/config.h> 51 #include <linux/sched.h> 52 #include <linux/errno.h> 53 #include <linux/suspend.h> 54 #include <linux/module.h> 55 #include <linux/init.h> 56 #include <linux/slab.h> 57 58 #include <scsi/scsi.h> 59 #include <scsi/scsi_cmnd.h> 60 #include <scsi/scsi_device.h> 61 62 #include "usb.h" 63 #include "scsiglue.h" 64 #include "transport.h" 65 #include "protocol.h" 66 #include "debug.h" 67 #include "initializers.h" 68 69 #ifdef CONFIG_USB_STORAGE_USBAT 70 #include "shuttle_usbat.h" 71 #endif 72 #ifdef CONFIG_USB_STORAGE_SDDR09 73 #include "sddr09.h" 74 #endif 75 #ifdef CONFIG_USB_STORAGE_SDDR55 76 #include "sddr55.h" 77 #endif 78 #ifdef CONFIG_USB_STORAGE_DPCM 79 #include "dpcm.h" 80 #endif 81 #ifdef CONFIG_USB_STORAGE_FREECOM 82 #include "freecom.h" 83 #endif 84 #ifdef CONFIG_USB_STORAGE_ISD200 85 #include "isd200.h" 86 #endif 87 #ifdef CONFIG_USB_STORAGE_DATAFAB 88 #include "datafab.h" 89 #endif 90 #ifdef CONFIG_USB_STORAGE_JUMPSHOT 91 #include "jumpshot.h" 92 #endif 93 #ifdef CONFIG_USB_STORAGE_ONETOUCH 94 #include "onetouch.h" 95 #endif 96 97 /* Some informational data */ 98 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>"); 99 MODULE_DESCRIPTION("USB Mass Storage driver for Linux"); 100 MODULE_LICENSE("GPL"); 101 102 static unsigned int delay_use = 5; 103 module_param(delay_use, uint, S_IRUGO | S_IWUSR); 104 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device"); 105 106 107 /* These are used to make sure the module doesn't unload before all the 108 * threads have exited. 109 */ 110 static atomic_t total_threads = ATOMIC_INIT(0); 111 static DECLARE_COMPLETION(threads_gone); 112 113 114 static int storage_probe(struct usb_interface *iface, 115 const struct usb_device_id *id); 116 117 static void storage_disconnect(struct usb_interface *iface); 118 119 /* The entries in this table, except for final ones here 120 * (USB_MASS_STORAGE_CLASS and the empty entry), correspond, 121 * line for line with the entries of us_unsuaul_dev_list[]. 122 */ 123 124 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 125 vendorName, productName,useProtocol, useTransport, \ 126 initFunction, flags) \ 127 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax) } 128 129 static struct usb_device_id storage_usb_ids [] = { 130 131 # include "unusual_devs.h" 132 #undef UNUSUAL_DEV 133 /* Control/Bulk transport for all SubClass values */ 134 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CB) }, 135 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CB) }, 136 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CB) }, 137 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CB) }, 138 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CB) }, 139 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CB) }, 140 141 /* Control/Bulk/Interrupt transport for all SubClass values */ 142 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CBI) }, 143 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CBI) }, 144 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CBI) }, 145 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CBI) }, 146 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CBI) }, 147 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CBI) }, 148 149 /* Bulk-only transport for all SubClass values */ 150 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_BULK) }, 151 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_BULK) }, 152 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_BULK) }, 153 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_BULK) }, 154 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_BULK) }, 155 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) }, 156 157 /* Terminating entry */ 158 { } 159 }; 160 161 MODULE_DEVICE_TABLE (usb, storage_usb_ids); 162 163 /* This is the list of devices we recognize, along with their flag data */ 164 165 /* The vendor name should be kept at eight characters or less, and 166 * the product name should be kept at 16 characters or less. If a device 167 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names 168 * normally generated by a device thorugh the INQUIRY response will be 169 * taken from this list, and this is the reason for the above size 170 * restriction. However, if the flag is not present, then you 171 * are free to use as many characters as you like. 172 */ 173 174 #undef UNUSUAL_DEV 175 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 176 vendor_name, product_name, use_protocol, use_transport, \ 177 init_function, Flags) \ 178 { \ 179 .vendorName = vendor_name, \ 180 .productName = product_name, \ 181 .useProtocol = use_protocol, \ 182 .useTransport = use_transport, \ 183 .initFunction = init_function, \ 184 .flags = Flags, \ 185 } 186 187 static struct us_unusual_dev us_unusual_dev_list[] = { 188 # include "unusual_devs.h" 189 # undef UNUSUAL_DEV 190 /* Control/Bulk transport for all SubClass values */ 191 { .useProtocol = US_SC_RBC, 192 .useTransport = US_PR_CB}, 193 { .useProtocol = US_SC_8020, 194 .useTransport = US_PR_CB}, 195 { .useProtocol = US_SC_QIC, 196 .useTransport = US_PR_CB}, 197 { .useProtocol = US_SC_UFI, 198 .useTransport = US_PR_CB}, 199 { .useProtocol = US_SC_8070, 200 .useTransport = US_PR_CB}, 201 { .useProtocol = US_SC_SCSI, 202 .useTransport = US_PR_CB}, 203 204 /* Control/Bulk/Interrupt transport for all SubClass values */ 205 { .useProtocol = US_SC_RBC, 206 .useTransport = US_PR_CBI}, 207 { .useProtocol = US_SC_8020, 208 .useTransport = US_PR_CBI}, 209 { .useProtocol = US_SC_QIC, 210 .useTransport = US_PR_CBI}, 211 { .useProtocol = US_SC_UFI, 212 .useTransport = US_PR_CBI}, 213 { .useProtocol = US_SC_8070, 214 .useTransport = US_PR_CBI}, 215 { .useProtocol = US_SC_SCSI, 216 .useTransport = US_PR_CBI}, 217 218 /* Bulk-only transport for all SubClass values */ 219 { .useProtocol = US_SC_RBC, 220 .useTransport = US_PR_BULK}, 221 { .useProtocol = US_SC_8020, 222 .useTransport = US_PR_BULK}, 223 { .useProtocol = US_SC_QIC, 224 .useTransport = US_PR_BULK}, 225 { .useProtocol = US_SC_UFI, 226 .useTransport = US_PR_BULK}, 227 { .useProtocol = US_SC_8070, 228 .useTransport = US_PR_BULK}, 229 { .useProtocol = US_SC_SCSI, 230 .useTransport = US_PR_BULK}, 231 232 /* Terminating entry */ 233 { NULL } 234 }; 235 236 static struct usb_driver usb_storage_driver = { 237 .owner = THIS_MODULE, 238 .name = "usb-storage", 239 .probe = storage_probe, 240 .disconnect = storage_disconnect, 241 .id_table = storage_usb_ids, 242 }; 243 244 /* 245 * fill_inquiry_response takes an unsigned char array (which must 246 * be at least 36 characters) and populates the vendor name, 247 * product name, and revision fields. Then the array is copied 248 * into the SCSI command's response buffer (oddly enough 249 * called request_buffer). data_len contains the length of the 250 * data array, which again must be at least 36. 251 */ 252 253 void fill_inquiry_response(struct us_data *us, unsigned char *data, 254 unsigned int data_len) 255 { 256 if (data_len<36) // You lose. 257 return; 258 259 if(data[0]&0x20) { /* USB device currently not connected. Return 260 peripheral qualifier 001b ("...however, the 261 physical device is not currently connected 262 to this logical unit") and leave vendor and 263 product identification empty. ("If the target 264 does store some of the INQUIRY data on the 265 device, it may return zeros or ASCII spaces 266 (20h) in those fields until the data is 267 available from the device."). */ 268 memset(data+8,0,28); 269 } else { 270 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice); 271 memcpy(data+8, us->unusual_dev->vendorName, 272 strlen(us->unusual_dev->vendorName) > 8 ? 8 : 273 strlen(us->unusual_dev->vendorName)); 274 memcpy(data+16, us->unusual_dev->productName, 275 strlen(us->unusual_dev->productName) > 16 ? 16 : 276 strlen(us->unusual_dev->productName)); 277 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F); 278 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F); 279 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F); 280 data[35] = 0x30 + ((bcdDevice) & 0x0F); 281 } 282 283 usb_stor_set_xfer_buf(data, data_len, us->srb); 284 } 285 286 static int usb_stor_control_thread(void * __us) 287 { 288 struct us_data *us = (struct us_data *)__us; 289 struct Scsi_Host *host = us_to_host(us); 290 291 lock_kernel(); 292 293 /* 294 * This thread doesn't need any user-level access, 295 * so get rid of all our resources. 296 */ 297 daemonize("usb-storage"); 298 current->flags |= PF_NOFREEZE; 299 unlock_kernel(); 300 301 /* acquire a reference to the host, so it won't be deallocated 302 * until we're ready to exit */ 303 scsi_host_get(host); 304 305 /* signal that we've started the thread */ 306 complete(&(us->notify)); 307 308 for(;;) { 309 US_DEBUGP("*** thread sleeping.\n"); 310 if(down_interruptible(&us->sema)) 311 break; 312 313 US_DEBUGP("*** thread awakened.\n"); 314 315 /* lock the device pointers */ 316 down(&(us->dev_semaphore)); 317 318 /* if the device has disconnected, we are free to exit */ 319 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 320 US_DEBUGP("-- exiting\n"); 321 up(&(us->dev_semaphore)); 322 break; 323 } 324 325 /* lock access to the state */ 326 scsi_lock(host); 327 328 /* has the command timed out *already* ? */ 329 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) { 330 us->srb->result = DID_ABORT << 16; 331 goto SkipForAbort; 332 } 333 334 scsi_unlock(host); 335 336 /* reject the command if the direction indicator 337 * is UNKNOWN 338 */ 339 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) { 340 US_DEBUGP("UNKNOWN data direction\n"); 341 us->srb->result = DID_ERROR << 16; 342 } 343 344 /* reject if target != 0 or if LUN is higher than 345 * the maximum known LUN 346 */ 347 else if (us->srb->device->id && 348 !(us->flags & US_FL_SCM_MULT_TARG)) { 349 US_DEBUGP("Bad target number (%d:%d)\n", 350 us->srb->device->id, us->srb->device->lun); 351 us->srb->result = DID_BAD_TARGET << 16; 352 } 353 354 else if (us->srb->device->lun > us->max_lun) { 355 US_DEBUGP("Bad LUN (%d:%d)\n", 356 us->srb->device->id, us->srb->device->lun); 357 us->srb->result = DID_BAD_TARGET << 16; 358 } 359 360 /* Handle those devices which need us to fake 361 * their inquiry data */ 362 else if ((us->srb->cmnd[0] == INQUIRY) && 363 (us->flags & US_FL_FIX_INQUIRY)) { 364 unsigned char data_ptr[36] = { 365 0x00, 0x80, 0x02, 0x02, 366 0x1F, 0x00, 0x00, 0x00}; 367 368 US_DEBUGP("Faking INQUIRY command\n"); 369 fill_inquiry_response(us, data_ptr, 36); 370 us->srb->result = SAM_STAT_GOOD; 371 } 372 373 /* we've got a command, let's do it! */ 374 else { 375 US_DEBUG(usb_stor_show_command(us->srb)); 376 us->proto_handler(us->srb, us); 377 } 378 379 /* lock access to the state */ 380 scsi_lock(host); 381 382 /* indicate that the command is done */ 383 if (us->srb->result != DID_ABORT << 16) { 384 US_DEBUGP("scsi cmd done, result=0x%x\n", 385 us->srb->result); 386 us->srb->scsi_done(us->srb); 387 } else { 388 SkipForAbort: 389 US_DEBUGP("scsi command aborted\n"); 390 } 391 392 /* If an abort request was received we need to signal that 393 * the abort has finished. The proper test for this is 394 * the TIMED_OUT flag, not srb->result == DID_ABORT, because 395 * a timeout/abort request might be received after all the 396 * USB processing was complete. */ 397 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) 398 complete(&(us->notify)); 399 400 /* finished working on this command */ 401 us->srb = NULL; 402 scsi_unlock(host); 403 404 /* unlock the device pointers */ 405 up(&(us->dev_semaphore)); 406 } /* for (;;) */ 407 408 scsi_host_put(host); 409 410 /* notify the exit routine that we're actually exiting now 411 * 412 * complete()/wait_for_completion() is similar to up()/down(), 413 * except that complete() is safe in the case where the structure 414 * is getting deleted in a parallel mode of execution (i.e. just 415 * after the down() -- that's necessary for the thread-shutdown 416 * case. 417 * 418 * complete_and_exit() goes even further than this -- it is safe in 419 * the case that the thread of the caller is going away (not just 420 * the structure) -- this is necessary for the module-remove case. 421 * This is important in preemption kernels, which transfer the flow 422 * of execution immediately upon a complete(). 423 */ 424 complete_and_exit(&threads_gone, 0); 425 } 426 427 /*********************************************************************** 428 * Device probing and disconnecting 429 ***********************************************************************/ 430 431 /* Associate our private data with the USB device */ 432 static int associate_dev(struct us_data *us, struct usb_interface *intf) 433 { 434 US_DEBUGP("-- %s\n", __FUNCTION__); 435 436 /* Fill in the device-related fields */ 437 us->pusb_dev = interface_to_usbdev(intf); 438 us->pusb_intf = intf; 439 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber; 440 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n", 441 le16_to_cpu(us->pusb_dev->descriptor.idVendor), 442 le16_to_cpu(us->pusb_dev->descriptor.idProduct), 443 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice)); 444 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n", 445 intf->cur_altsetting->desc.bInterfaceSubClass, 446 intf->cur_altsetting->desc.bInterfaceProtocol); 447 448 /* Store our private data in the interface */ 449 usb_set_intfdata(intf, us); 450 451 /* Allocate the device-related DMA-mapped buffers */ 452 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr), 453 GFP_KERNEL, &us->cr_dma); 454 if (!us->cr) { 455 US_DEBUGP("usb_ctrlrequest allocation failed\n"); 456 return -ENOMEM; 457 } 458 459 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE, 460 GFP_KERNEL, &us->iobuf_dma); 461 if (!us->iobuf) { 462 US_DEBUGP("I/O buffer allocation failed\n"); 463 return -ENOMEM; 464 } 465 return 0; 466 } 467 468 /* Get the unusual_devs entries and the string descriptors */ 469 static void get_device_info(struct us_data *us, int id_index) 470 { 471 struct usb_device *dev = us->pusb_dev; 472 struct usb_interface_descriptor *idesc = 473 &us->pusb_intf->cur_altsetting->desc; 474 struct us_unusual_dev *unusual_dev = &us_unusual_dev_list[id_index]; 475 struct usb_device_id *id = &storage_usb_ids[id_index]; 476 477 /* Store the entries */ 478 us->unusual_dev = unusual_dev; 479 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ? 480 idesc->bInterfaceSubClass : 481 unusual_dev->useProtocol; 482 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? 483 idesc->bInterfaceProtocol : 484 unusual_dev->useTransport; 485 us->flags = unusual_dev->flags; 486 487 /* 488 * This flag is only needed when we're in high-speed, so let's 489 * disable it if we're in full-speed 490 */ 491 if (dev->speed != USB_SPEED_HIGH) 492 us->flags &= ~US_FL_GO_SLOW; 493 494 /* Log a message if a non-generic unusual_dev entry contains an 495 * unnecessary subclass or protocol override. This may stimulate 496 * reports from users that will help us remove unneeded entries 497 * from the unusual_devs.h table. 498 */ 499 if (id->idVendor || id->idProduct) { 500 static char *msgs[3] = { 501 "an unneeded SubClass entry", 502 "an unneeded Protocol entry", 503 "unneeded SubClass and Protocol entries"}; 504 struct usb_device_descriptor *ddesc = &dev->descriptor; 505 int msg = -1; 506 507 if (unusual_dev->useProtocol != US_SC_DEVICE && 508 us->subclass == idesc->bInterfaceSubClass) 509 msg += 1; 510 if (unusual_dev->useTransport != US_PR_DEVICE && 511 us->protocol == idesc->bInterfaceProtocol) 512 msg += 2; 513 if (msg >= 0 && !(unusual_dev->flags & US_FL_NEED_OVERRIDE)) 514 printk(KERN_NOTICE USB_STORAGE "This device " 515 "(%04x,%04x,%04x S %02x P %02x)" 516 " has %s in unusual_devs.h\n" 517 " Please send a copy of this message to " 518 "<linux-usb-devel@lists.sourceforge.net>\n", 519 le16_to_cpu(ddesc->idVendor), 520 le16_to_cpu(ddesc->idProduct), 521 le16_to_cpu(ddesc->bcdDevice), 522 idesc->bInterfaceSubClass, 523 idesc->bInterfaceProtocol, 524 msgs[msg]); 525 } 526 } 527 528 /* Get the transport settings */ 529 static int get_transport(struct us_data *us) 530 { 531 switch (us->protocol) { 532 case US_PR_CB: 533 us->transport_name = "Control/Bulk"; 534 us->transport = usb_stor_CB_transport; 535 us->transport_reset = usb_stor_CB_reset; 536 us->max_lun = 7; 537 break; 538 539 case US_PR_CBI: 540 us->transport_name = "Control/Bulk/Interrupt"; 541 us->transport = usb_stor_CBI_transport; 542 us->transport_reset = usb_stor_CB_reset; 543 us->max_lun = 7; 544 break; 545 546 case US_PR_BULK: 547 us->transport_name = "Bulk"; 548 us->transport = usb_stor_Bulk_transport; 549 us->transport_reset = usb_stor_Bulk_reset; 550 break; 551 552 #ifdef CONFIG_USB_STORAGE_USBAT 553 case US_PR_SCM_ATAPI: 554 us->transport_name = "SCM/ATAPI"; 555 us->transport = usbat_transport; 556 us->transport_reset = usb_stor_CB_reset; 557 us->max_lun = 1; 558 break; 559 #endif 560 561 #ifdef CONFIG_USB_STORAGE_SDDR09 562 case US_PR_EUSB_SDDR09: 563 us->transport_name = "EUSB/SDDR09"; 564 us->transport = sddr09_transport; 565 us->transport_reset = usb_stor_CB_reset; 566 us->max_lun = 0; 567 break; 568 #endif 569 570 #ifdef CONFIG_USB_STORAGE_SDDR55 571 case US_PR_SDDR55: 572 us->transport_name = "SDDR55"; 573 us->transport = sddr55_transport; 574 us->transport_reset = sddr55_reset; 575 us->max_lun = 0; 576 break; 577 #endif 578 579 #ifdef CONFIG_USB_STORAGE_DPCM 580 case US_PR_DPCM_USB: 581 us->transport_name = "Control/Bulk-EUSB/SDDR09"; 582 us->transport = dpcm_transport; 583 us->transport_reset = usb_stor_CB_reset; 584 us->max_lun = 1; 585 break; 586 #endif 587 588 #ifdef CONFIG_USB_STORAGE_FREECOM 589 case US_PR_FREECOM: 590 us->transport_name = "Freecom"; 591 us->transport = freecom_transport; 592 us->transport_reset = usb_stor_freecom_reset; 593 us->max_lun = 0; 594 break; 595 #endif 596 597 #ifdef CONFIG_USB_STORAGE_DATAFAB 598 case US_PR_DATAFAB: 599 us->transport_name = "Datafab Bulk-Only"; 600 us->transport = datafab_transport; 601 us->transport_reset = usb_stor_Bulk_reset; 602 us->max_lun = 1; 603 break; 604 #endif 605 606 #ifdef CONFIG_USB_STORAGE_JUMPSHOT 607 case US_PR_JUMPSHOT: 608 us->transport_name = "Lexar Jumpshot Control/Bulk"; 609 us->transport = jumpshot_transport; 610 us->transport_reset = usb_stor_Bulk_reset; 611 us->max_lun = 1; 612 break; 613 #endif 614 615 default: 616 return -EIO; 617 } 618 US_DEBUGP("Transport: %s\n", us->transport_name); 619 620 /* fix for single-lun devices */ 621 if (us->flags & US_FL_SINGLE_LUN) 622 us->max_lun = 0; 623 return 0; 624 } 625 626 /* Get the protocol settings */ 627 static int get_protocol(struct us_data *us) 628 { 629 switch (us->subclass) { 630 case US_SC_RBC: 631 us->protocol_name = "Reduced Block Commands (RBC)"; 632 us->proto_handler = usb_stor_transparent_scsi_command; 633 break; 634 635 case US_SC_8020: 636 us->protocol_name = "8020i"; 637 us->proto_handler = usb_stor_ATAPI_command; 638 us->max_lun = 0; 639 break; 640 641 case US_SC_QIC: 642 us->protocol_name = "QIC-157"; 643 us->proto_handler = usb_stor_qic157_command; 644 us->max_lun = 0; 645 break; 646 647 case US_SC_8070: 648 us->protocol_name = "8070i"; 649 us->proto_handler = usb_stor_ATAPI_command; 650 us->max_lun = 0; 651 break; 652 653 case US_SC_SCSI: 654 us->protocol_name = "Transparent SCSI"; 655 us->proto_handler = usb_stor_transparent_scsi_command; 656 break; 657 658 case US_SC_UFI: 659 us->protocol_name = "Uniform Floppy Interface (UFI)"; 660 us->proto_handler = usb_stor_ufi_command; 661 break; 662 663 #ifdef CONFIG_USB_STORAGE_ISD200 664 case US_SC_ISD200: 665 us->protocol_name = "ISD200 ATA/ATAPI"; 666 us->proto_handler = isd200_ata_command; 667 break; 668 #endif 669 670 default: 671 return -EIO; 672 } 673 US_DEBUGP("Protocol: %s\n", us->protocol_name); 674 return 0; 675 } 676 677 /* Get the pipe settings */ 678 static int get_pipes(struct us_data *us) 679 { 680 struct usb_host_interface *altsetting = 681 us->pusb_intf->cur_altsetting; 682 int i; 683 struct usb_endpoint_descriptor *ep; 684 struct usb_endpoint_descriptor *ep_in = NULL; 685 struct usb_endpoint_descriptor *ep_out = NULL; 686 struct usb_endpoint_descriptor *ep_int = NULL; 687 688 /* 689 * Find the endpoints we need. 690 * We are expecting a minimum of 2 endpoints - in and out (bulk). 691 * An optional interrupt is OK (necessary for CBI protocol). 692 * We will ignore any others. 693 */ 694 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) { 695 ep = &altsetting->endpoint[i].desc; 696 697 /* Is it a BULK endpoint? */ 698 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 699 == USB_ENDPOINT_XFER_BULK) { 700 /* BULK in or out? */ 701 if (ep->bEndpointAddress & USB_DIR_IN) 702 ep_in = ep; 703 else 704 ep_out = ep; 705 } 706 707 /* Is it an interrupt endpoint? */ 708 else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) 709 == USB_ENDPOINT_XFER_INT) { 710 ep_int = ep; 711 } 712 } 713 714 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) { 715 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 716 return -EIO; 717 } 718 719 /* Calculate and store the pipe values */ 720 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0); 721 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0); 722 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, 723 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 724 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 725 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 726 if (ep_int) { 727 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, 728 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 729 us->ep_bInterval = ep_int->bInterval; 730 } 731 return 0; 732 } 733 734 /* Initialize all the dynamic resources we need */ 735 static int usb_stor_acquire_resources(struct us_data *us) 736 { 737 int p; 738 739 us->current_urb = usb_alloc_urb(0, GFP_KERNEL); 740 if (!us->current_urb) { 741 US_DEBUGP("URB allocation failed\n"); 742 return -ENOMEM; 743 } 744 745 /* Lock the device while we carry out the next two operations */ 746 down(&us->dev_semaphore); 747 748 /* For bulk-only devices, determine the max LUN value */ 749 if (us->protocol == US_PR_BULK) { 750 p = usb_stor_Bulk_max_lun(us); 751 if (p < 0) { 752 up(&us->dev_semaphore); 753 return p; 754 } 755 us->max_lun = p; 756 } 757 758 /* Just before we start our control thread, initialize 759 * the device if it needs initialization */ 760 if (us->unusual_dev->initFunction) 761 us->unusual_dev->initFunction(us); 762 763 up(&us->dev_semaphore); 764 765 /* Start up our control thread */ 766 p = kernel_thread(usb_stor_control_thread, us, CLONE_VM); 767 if (p < 0) { 768 printk(KERN_WARNING USB_STORAGE 769 "Unable to start control thread\n"); 770 return p; 771 } 772 us->pid = p; 773 atomic_inc(&total_threads); 774 775 /* Wait for the thread to start */ 776 wait_for_completion(&(us->notify)); 777 778 return 0; 779 } 780 781 /* Release all our dynamic resources */ 782 static void usb_stor_release_resources(struct us_data *us) 783 { 784 US_DEBUGP("-- %s\n", __FUNCTION__); 785 786 /* Tell the control thread to exit. The SCSI host must 787 * already have been removed so it won't try to queue 788 * any more commands. 789 */ 790 US_DEBUGP("-- sending exit command to thread\n"); 791 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 792 up(&us->sema); 793 794 /* Call the destructor routine, if it exists */ 795 if (us->extra_destructor) { 796 US_DEBUGP("-- calling extra_destructor()\n"); 797 us->extra_destructor(us->extra); 798 } 799 800 /* Free the extra data and the URB */ 801 kfree(us->extra); 802 usb_free_urb(us->current_urb); 803 } 804 805 /* Dissociate from the USB device */ 806 static void dissociate_dev(struct us_data *us) 807 { 808 US_DEBUGP("-- %s\n", __FUNCTION__); 809 810 /* Free the device-related DMA-mapped buffers */ 811 if (us->cr) 812 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr, 813 us->cr_dma); 814 if (us->iobuf) 815 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, 816 us->iobuf_dma); 817 818 /* Remove our private data from the interface */ 819 usb_set_intfdata(us->pusb_intf, NULL); 820 } 821 822 /* First stage of disconnect processing: stop all commands and remove 823 * the host */ 824 static void quiesce_and_remove_host(struct us_data *us) 825 { 826 /* Prevent new USB transfers, stop the current command, and 827 * interrupt a SCSI-scan or device-reset delay */ 828 set_bit(US_FLIDX_DISCONNECTING, &us->flags); 829 usb_stor_stop_transport(us); 830 wake_up(&us->delay_wait); 831 832 /* It doesn't matter if the SCSI-scanning thread is still running. 833 * The thread will exit when it sees the DISCONNECTING flag. */ 834 835 /* Wait for the current command to finish, then remove the host */ 836 down(&us->dev_semaphore); 837 up(&us->dev_semaphore); 838 839 /* queuecommand won't accept any new commands and the control 840 * thread won't execute a previously-queued command. If there 841 * is such a command pending, complete it with an error. */ 842 if (us->srb) { 843 us->srb->result = DID_NO_CONNECT << 16; 844 scsi_lock(us_to_host(us)); 845 us->srb->scsi_done(us->srb); 846 us->srb = NULL; 847 scsi_unlock(us_to_host(us)); 848 } 849 850 /* Now we own no commands so it's safe to remove the SCSI host */ 851 scsi_remove_host(us_to_host(us)); 852 } 853 854 /* Second stage of disconnect processing: deallocate all resources */ 855 static void release_everything(struct us_data *us) 856 { 857 usb_stor_release_resources(us); 858 dissociate_dev(us); 859 860 /* Drop our reference to the host; the SCSI core will free it 861 * (and "us" along with it) when the refcount becomes 0. */ 862 scsi_host_put(us_to_host(us)); 863 } 864 865 /* Thread to carry out delayed SCSI-device scanning */ 866 static int usb_stor_scan_thread(void * __us) 867 { 868 struct us_data *us = (struct us_data *)__us; 869 870 /* 871 * This thread doesn't need any user-level access, 872 * so get rid of all our resources. 873 */ 874 lock_kernel(); 875 daemonize("usb-stor-scan"); 876 unlock_kernel(); 877 878 /* Acquire a reference to the host, so it won't be deallocated 879 * until we're ready to exit */ 880 scsi_host_get(us_to_host(us)); 881 882 /* Signal that we've started the thread */ 883 complete(&(us->notify)); 884 885 printk(KERN_DEBUG 886 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 887 888 /* Wait for the timeout to expire or for a disconnect */ 889 if (delay_use > 0) { 890 printk(KERN_DEBUG "usb-storage: waiting for device " 891 "to settle before scanning\n"); 892 retry: 893 wait_event_interruptible_timeout(us->delay_wait, 894 test_bit(US_FLIDX_DISCONNECTING, &us->flags), 895 delay_use * HZ); 896 if (try_to_freeze()) 897 goto retry; 898 } 899 900 /* If the device is still connected, perform the scanning */ 901 if (!test_bit(US_FLIDX_DISCONNECTING, &us->flags)) { 902 scsi_scan_host(us_to_host(us)); 903 printk(KERN_DEBUG "usb-storage: device scan complete\n"); 904 905 /* Should we unbind if no devices were detected? */ 906 } 907 908 scsi_host_put(us_to_host(us)); 909 complete_and_exit(&threads_gone, 0); 910 } 911 912 913 /* Probe to see if we can drive a newly-connected USB device */ 914 static int storage_probe(struct usb_interface *intf, 915 const struct usb_device_id *id) 916 { 917 struct Scsi_Host *host; 918 struct us_data *us; 919 const int id_index = id - storage_usb_ids; 920 int result; 921 922 US_DEBUGP("USB Mass Storage device detected\n"); 923 924 /* 925 * Ask the SCSI layer to allocate a host structure, with extra 926 * space at the end for our private us_data structure. 927 */ 928 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us)); 929 if (!host) { 930 printk(KERN_WARNING USB_STORAGE 931 "Unable to allocate the scsi host\n"); 932 return -ENOMEM; 933 } 934 935 us = host_to_us(host); 936 memset(us, 0, sizeof(struct us_data)); 937 init_MUTEX(&(us->dev_semaphore)); 938 init_MUTEX_LOCKED(&(us->sema)); 939 init_completion(&(us->notify)); 940 init_waitqueue_head(&us->delay_wait); 941 942 /* Associate the us_data structure with the USB device */ 943 result = associate_dev(us, intf); 944 if (result) 945 goto BadDevice; 946 947 /* 948 * Get the unusual_devs entries and the descriptors 949 * 950 * id_index is calculated in the declaration to be the index number 951 * of the match from the usb_device_id table, so we can find the 952 * corresponding entry in the private table. 953 */ 954 get_device_info(us, id_index); 955 956 #ifdef CONFIG_USB_STORAGE_SDDR09 957 if (us->protocol == US_PR_EUSB_SDDR09 || 958 us->protocol == US_PR_DPCM_USB) { 959 /* set the configuration -- STALL is an acceptable response here */ 960 if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) { 961 US_DEBUGP("active config #%d != 1 ??\n", us->pusb_dev 962 ->actconfig->desc.bConfigurationValue); 963 goto BadDevice; 964 } 965 result = usb_reset_configuration(us->pusb_dev); 966 967 US_DEBUGP("Result of usb_reset_configuration is %d\n", result); 968 if (result == -EPIPE) { 969 US_DEBUGP("-- stall on control interface\n"); 970 } else if (result != 0) { 971 /* it's not a stall, but another error -- time to bail */ 972 US_DEBUGP("-- Unknown error. Rejecting device\n"); 973 goto BadDevice; 974 } 975 } 976 #endif 977 978 /* Get the transport, protocol, and pipe settings */ 979 result = get_transport(us); 980 if (result) 981 goto BadDevice; 982 result = get_protocol(us); 983 if (result) 984 goto BadDevice; 985 result = get_pipes(us); 986 if (result) 987 goto BadDevice; 988 989 /* Acquire all the other resources and add the host */ 990 result = usb_stor_acquire_resources(us); 991 if (result) 992 goto BadDevice; 993 result = scsi_add_host(host, &intf->dev); 994 if (result) { 995 printk(KERN_WARNING USB_STORAGE 996 "Unable to add the scsi host\n"); 997 goto BadDevice; 998 } 999 1000 /* Start up the thread for delayed SCSI-device scanning */ 1001 result = kernel_thread(usb_stor_scan_thread, us, CLONE_VM); 1002 if (result < 0) { 1003 printk(KERN_WARNING USB_STORAGE 1004 "Unable to start the device-scanning thread\n"); 1005 quiesce_and_remove_host(us); 1006 goto BadDevice; 1007 } 1008 atomic_inc(&total_threads); 1009 1010 /* Wait for the thread to start */ 1011 wait_for_completion(&(us->notify)); 1012 1013 return 0; 1014 1015 /* We come here if there are any problems */ 1016 BadDevice: 1017 US_DEBUGP("storage_probe() failed\n"); 1018 release_everything(us); 1019 return result; 1020 } 1021 1022 /* Handle a disconnect event from the USB core */ 1023 static void storage_disconnect(struct usb_interface *intf) 1024 { 1025 struct us_data *us = usb_get_intfdata(intf); 1026 1027 US_DEBUGP("storage_disconnect() called\n"); 1028 quiesce_and_remove_host(us); 1029 release_everything(us); 1030 } 1031 1032 /*********************************************************************** 1033 * Initialization and registration 1034 ***********************************************************************/ 1035 1036 static int __init usb_stor_init(void) 1037 { 1038 int retval; 1039 printk(KERN_INFO "Initializing USB Mass Storage driver...\n"); 1040 1041 /* register the driver, return usb_register return code if error */ 1042 retval = usb_register(&usb_storage_driver); 1043 if (retval == 0) 1044 printk(KERN_INFO "USB Mass Storage support registered.\n"); 1045 1046 return retval; 1047 } 1048 1049 static void __exit usb_stor_exit(void) 1050 { 1051 US_DEBUGP("usb_stor_exit() called\n"); 1052 1053 /* Deregister the driver 1054 * This will cause disconnect() to be called for each 1055 * attached unit 1056 */ 1057 US_DEBUGP("-- calling usb_deregister()\n"); 1058 usb_deregister(&usb_storage_driver) ; 1059 1060 /* Don't return until all of our control and scanning threads 1061 * have exited. Since each thread signals threads_gone as its 1062 * last act, we have to call wait_for_completion the right number 1063 * of times. 1064 */ 1065 while (atomic_read(&total_threads) > 0) { 1066 wait_for_completion(&threads_gone); 1067 atomic_dec(&total_threads); 1068 } 1069 } 1070 1071 module_init(usb_stor_init); 1072 module_exit(usb_stor_exit); 1073