1 /* Driver for USB Mass Storage compliant devices 2 * 3 * Current development and maintenance by: 4 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net) 5 * 6 * Developed with the assistance of: 7 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org) 8 * (c) 2003-2009 Alan Stern (stern@rowland.harvard.edu) 9 * 10 * Initial work by: 11 * (c) 1999 Michael Gee (michael@linuxspecific.com) 12 * 13 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com): 14 * (c) 2000 Yggdrasil Computing, Inc. 15 * 16 * This driver is based on the 'USB Mass Storage Class' document. This 17 * describes in detail the protocol used to communicate with such 18 * devices. Clearly, the designers had SCSI and ATAPI commands in 19 * mind when they created this document. The commands are all very 20 * similar to commands in the SCSI-II and ATAPI specifications. 21 * 22 * It is important to note that in a number of cases this class 23 * exhibits class-specific exemptions from the USB specification. 24 * Notably the usage of NAK, STALL and ACK differs from the norm, in 25 * that they are used to communicate wait, failed and OK on commands. 26 * 27 * Also, for certain devices, the interrupt endpoint is used to convey 28 * status of a command. 29 * 30 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more 31 * information about this driver. 32 * 33 * This program is free software; you can redistribute it and/or modify it 34 * under the terms of the GNU General Public License as published by the 35 * Free Software Foundation; either version 2, or (at your option) any 36 * later version. 37 * 38 * This program is distributed in the hope that it will be useful, but 39 * WITHOUT ANY WARRANTY; without even the implied warranty of 40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 41 * General Public License for more details. 42 * 43 * You should have received a copy of the GNU General Public License along 44 * with this program; if not, write to the Free Software Foundation, Inc., 45 * 675 Mass Ave, Cambridge, MA 02139, USA. 46 */ 47 48 #include <linux/sched.h> 49 #include <linux/errno.h> 50 #include <linux/freezer.h> 51 #include <linux/module.h> 52 #include <linux/init.h> 53 #include <linux/slab.h> 54 #include <linux/kthread.h> 55 #include <linux/mutex.h> 56 #include <linux/utsname.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_SDDR55 73 #include "sddr55.h" 74 #endif 75 #ifdef CONFIG_USB_STORAGE_FREECOM 76 #include "freecom.h" 77 #endif 78 #ifdef CONFIG_USB_STORAGE_ISD200 79 #include "isd200.h" 80 #endif 81 #ifdef CONFIG_USB_STORAGE_DATAFAB 82 #include "datafab.h" 83 #endif 84 #ifdef CONFIG_USB_STORAGE_JUMPSHOT 85 #include "jumpshot.h" 86 #endif 87 #ifdef CONFIG_USB_STORAGE_ONETOUCH 88 #include "onetouch.h" 89 #endif 90 #ifdef CONFIG_USB_STORAGE_ALAUDA 91 #include "alauda.h" 92 #endif 93 #ifdef CONFIG_USB_STORAGE_KARMA 94 #include "karma.h" 95 #endif 96 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB 97 #include "cypress_atacb.h" 98 #endif 99 #include "sierra_ms.h" 100 #include "option_ms.h" 101 102 /* Some informational data */ 103 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>"); 104 MODULE_DESCRIPTION("USB Mass Storage driver for Linux"); 105 MODULE_LICENSE("GPL"); 106 107 static unsigned int delay_use = 5; 108 module_param(delay_use, uint, S_IRUGO | S_IWUSR); 109 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device"); 110 111 static char quirks[128]; 112 module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR); 113 MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks"); 114 115 116 /* 117 * The entries in this table correspond, line for line, 118 * with the entries in usb_storage_usb_ids[], defined in usual-tables.c. 119 */ 120 121 /* The vendor name should be kept at eight characters or less, and 122 * the product name should be kept at 16 characters or less. If a device 123 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names 124 * normally generated by a device thorugh the INQUIRY response will be 125 * taken from this list, and this is the reason for the above size 126 * restriction. However, if the flag is not present, then you 127 * are free to use as many characters as you like. 128 */ 129 130 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 131 vendor_name, product_name, use_protocol, use_transport, \ 132 init_function, Flags) \ 133 { \ 134 .vendorName = vendor_name, \ 135 .productName = product_name, \ 136 .useProtocol = use_protocol, \ 137 .useTransport = use_transport, \ 138 .initFunction = init_function, \ 139 } 140 141 #define COMPLIANT_DEV UNUSUAL_DEV 142 143 #define USUAL_DEV(use_protocol, use_transport, use_type) \ 144 { \ 145 .useProtocol = use_protocol, \ 146 .useTransport = use_transport, \ 147 } 148 149 static struct us_unusual_dev us_unusual_dev_list[] = { 150 # include "unusual_devs.h" 151 { } /* Terminating entry */ 152 }; 153 154 #undef UNUSUAL_DEV 155 #undef COMPLIANT_DEV 156 #undef USUAL_DEV 157 158 159 #ifdef CONFIG_PM /* Minimal support for suspend and resume */ 160 161 int usb_stor_suspend(struct usb_interface *iface, pm_message_t message) 162 { 163 struct us_data *us = usb_get_intfdata(iface); 164 165 /* Wait until no command is running */ 166 mutex_lock(&us->dev_mutex); 167 168 US_DEBUGP("%s\n", __func__); 169 if (us->suspend_resume_hook) 170 (us->suspend_resume_hook)(us, US_SUSPEND); 171 172 /* When runtime PM is working, we'll set a flag to indicate 173 * whether we should autoresume when a SCSI request arrives. */ 174 175 mutex_unlock(&us->dev_mutex); 176 return 0; 177 } 178 EXPORT_SYMBOL_GPL(usb_stor_suspend); 179 180 int usb_stor_resume(struct usb_interface *iface) 181 { 182 struct us_data *us = usb_get_intfdata(iface); 183 184 mutex_lock(&us->dev_mutex); 185 186 US_DEBUGP("%s\n", __func__); 187 if (us->suspend_resume_hook) 188 (us->suspend_resume_hook)(us, US_RESUME); 189 190 mutex_unlock(&us->dev_mutex); 191 return 0; 192 } 193 EXPORT_SYMBOL_GPL(usb_stor_resume); 194 195 int usb_stor_reset_resume(struct usb_interface *iface) 196 { 197 struct us_data *us = usb_get_intfdata(iface); 198 199 US_DEBUGP("%s\n", __func__); 200 201 /* Report the reset to the SCSI core */ 202 usb_stor_report_bus_reset(us); 203 204 /* FIXME: Notify the subdrivers that they need to reinitialize 205 * the device */ 206 return 0; 207 } 208 EXPORT_SYMBOL_GPL(usb_stor_reset_resume); 209 210 #endif /* CONFIG_PM */ 211 212 /* 213 * The next two routines get called just before and just after 214 * a USB port reset, whether from this driver or a different one. 215 */ 216 217 int usb_stor_pre_reset(struct usb_interface *iface) 218 { 219 struct us_data *us = usb_get_intfdata(iface); 220 221 US_DEBUGP("%s\n", __func__); 222 223 /* Make sure no command runs during the reset */ 224 mutex_lock(&us->dev_mutex); 225 return 0; 226 } 227 EXPORT_SYMBOL_GPL(usb_stor_pre_reset); 228 229 int usb_stor_post_reset(struct usb_interface *iface) 230 { 231 struct us_data *us = usb_get_intfdata(iface); 232 233 US_DEBUGP("%s\n", __func__); 234 235 /* Report the reset to the SCSI core */ 236 usb_stor_report_bus_reset(us); 237 238 /* FIXME: Notify the subdrivers that they need to reinitialize 239 * the device */ 240 241 mutex_unlock(&us->dev_mutex); 242 return 0; 243 } 244 EXPORT_SYMBOL_GPL(usb_stor_post_reset); 245 246 /* 247 * fill_inquiry_response takes an unsigned char array (which must 248 * be at least 36 characters) and populates the vendor name, 249 * product name, and revision fields. Then the array is copied 250 * into the SCSI command's response buffer (oddly enough 251 * called request_buffer). data_len contains the length of the 252 * data array, which again must be at least 36. 253 */ 254 255 void fill_inquiry_response(struct us_data *us, unsigned char *data, 256 unsigned int data_len) 257 { 258 if (data_len<36) // You lose. 259 return; 260 261 if(data[0]&0x20) { /* USB device currently not connected. Return 262 peripheral qualifier 001b ("...however, the 263 physical device is not currently connected 264 to this logical unit") and leave vendor and 265 product identification empty. ("If the target 266 does store some of the INQUIRY data on the 267 device, it may return zeros or ASCII spaces 268 (20h) in those fields until the data is 269 available from the device."). */ 270 memset(data+8,0,28); 271 } else { 272 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice); 273 memcpy(data+8, us->unusual_dev->vendorName, 274 strlen(us->unusual_dev->vendorName) > 8 ? 8 : 275 strlen(us->unusual_dev->vendorName)); 276 memcpy(data+16, us->unusual_dev->productName, 277 strlen(us->unusual_dev->productName) > 16 ? 16 : 278 strlen(us->unusual_dev->productName)); 279 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F); 280 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F); 281 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F); 282 data[35] = 0x30 + ((bcdDevice) & 0x0F); 283 } 284 285 usb_stor_set_xfer_buf(data, data_len, us->srb); 286 } 287 EXPORT_SYMBOL_GPL(fill_inquiry_response); 288 289 static int usb_stor_control_thread(void * __us) 290 { 291 struct us_data *us = (struct us_data *)__us; 292 struct Scsi_Host *host = us_to_host(us); 293 294 for(;;) { 295 US_DEBUGP("*** thread sleeping.\n"); 296 if (wait_for_completion_interruptible(&us->cmnd_ready)) 297 break; 298 299 US_DEBUGP("*** thread awakened.\n"); 300 301 /* lock the device pointers */ 302 mutex_lock(&(us->dev_mutex)); 303 304 /* lock access to the state */ 305 scsi_lock(host); 306 307 /* When we are called with no command pending, we're done */ 308 if (us->srb == NULL) { 309 scsi_unlock(host); 310 mutex_unlock(&us->dev_mutex); 311 US_DEBUGP("-- exiting\n"); 312 break; 313 } 314 315 /* has the command timed out *already* ? */ 316 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) { 317 us->srb->result = DID_ABORT << 16; 318 goto SkipForAbort; 319 } 320 321 scsi_unlock(host); 322 323 /* reject the command if the direction indicator 324 * is UNKNOWN 325 */ 326 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) { 327 US_DEBUGP("UNKNOWN data direction\n"); 328 us->srb->result = DID_ERROR << 16; 329 } 330 331 /* reject if target != 0 or if LUN is higher than 332 * the maximum known LUN 333 */ 334 else if (us->srb->device->id && 335 !(us->fflags & US_FL_SCM_MULT_TARG)) { 336 US_DEBUGP("Bad target number (%d:%d)\n", 337 us->srb->device->id, us->srb->device->lun); 338 us->srb->result = DID_BAD_TARGET << 16; 339 } 340 341 else if (us->srb->device->lun > us->max_lun) { 342 US_DEBUGP("Bad LUN (%d:%d)\n", 343 us->srb->device->id, us->srb->device->lun); 344 us->srb->result = DID_BAD_TARGET << 16; 345 } 346 347 /* Handle those devices which need us to fake 348 * their inquiry data */ 349 else if ((us->srb->cmnd[0] == INQUIRY) && 350 (us->fflags & US_FL_FIX_INQUIRY)) { 351 unsigned char data_ptr[36] = { 352 0x00, 0x80, 0x02, 0x02, 353 0x1F, 0x00, 0x00, 0x00}; 354 355 US_DEBUGP("Faking INQUIRY command\n"); 356 fill_inquiry_response(us, data_ptr, 36); 357 us->srb->result = SAM_STAT_GOOD; 358 } 359 360 /* we've got a command, let's do it! */ 361 else { 362 US_DEBUG(usb_stor_show_command(us->srb)); 363 us->proto_handler(us->srb, us); 364 } 365 366 /* lock access to the state */ 367 scsi_lock(host); 368 369 /* indicate that the command is done */ 370 if (us->srb->result != DID_ABORT << 16) { 371 US_DEBUGP("scsi cmd done, result=0x%x\n", 372 us->srb->result); 373 us->srb->scsi_done(us->srb); 374 } else { 375 SkipForAbort: 376 US_DEBUGP("scsi command aborted\n"); 377 } 378 379 /* If an abort request was received we need to signal that 380 * the abort has finished. The proper test for this is 381 * the TIMED_OUT flag, not srb->result == DID_ABORT, because 382 * the timeout might have occurred after the command had 383 * already completed with a different result code. */ 384 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) { 385 complete(&(us->notify)); 386 387 /* Allow USB transfers to resume */ 388 clear_bit(US_FLIDX_ABORTING, &us->dflags); 389 clear_bit(US_FLIDX_TIMED_OUT, &us->dflags); 390 } 391 392 /* finished working on this command */ 393 us->srb = NULL; 394 scsi_unlock(host); 395 396 /* unlock the device pointers */ 397 mutex_unlock(&us->dev_mutex); 398 } /* for (;;) */ 399 400 /* Wait until we are told to stop */ 401 for (;;) { 402 set_current_state(TASK_INTERRUPTIBLE); 403 if (kthread_should_stop()) 404 break; 405 schedule(); 406 } 407 __set_current_state(TASK_RUNNING); 408 return 0; 409 } 410 411 /*********************************************************************** 412 * Device probing and disconnecting 413 ***********************************************************************/ 414 415 /* Associate our private data with the USB device */ 416 static int associate_dev(struct us_data *us, struct usb_interface *intf) 417 { 418 US_DEBUGP("-- %s\n", __func__); 419 420 /* Fill in the device-related fields */ 421 us->pusb_dev = interface_to_usbdev(intf); 422 us->pusb_intf = intf; 423 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber; 424 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n", 425 le16_to_cpu(us->pusb_dev->descriptor.idVendor), 426 le16_to_cpu(us->pusb_dev->descriptor.idProduct), 427 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice)); 428 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n", 429 intf->cur_altsetting->desc.bInterfaceSubClass, 430 intf->cur_altsetting->desc.bInterfaceProtocol); 431 432 /* Store our private data in the interface */ 433 usb_set_intfdata(intf, us); 434 435 /* Allocate the device-related DMA-mapped buffers */ 436 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr), 437 GFP_KERNEL, &us->cr_dma); 438 if (!us->cr) { 439 US_DEBUGP("usb_ctrlrequest allocation failed\n"); 440 return -ENOMEM; 441 } 442 443 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE, 444 GFP_KERNEL, &us->iobuf_dma); 445 if (!us->iobuf) { 446 US_DEBUGP("I/O buffer allocation failed\n"); 447 return -ENOMEM; 448 } 449 return 0; 450 } 451 452 /* Works only for digits and letters, but small and fast */ 453 #define TOLOWER(x) ((x) | 0x20) 454 455 /* Adjust device flags based on the "quirks=" module parameter */ 456 static void adjust_quirks(struct us_data *us) 457 { 458 char *p; 459 u16 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor); 460 u16 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct); 461 unsigned f = 0; 462 unsigned int mask = (US_FL_SANE_SENSE | US_FL_FIX_CAPACITY | 463 US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE | 464 US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 | 465 US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE | 466 US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT); 467 468 p = quirks; 469 while (*p) { 470 /* Each entry consists of VID:PID:flags */ 471 if (vid == simple_strtoul(p, &p, 16) && 472 *p == ':' && 473 pid == simple_strtoul(p+1, &p, 16) && 474 *p == ':') 475 break; 476 477 /* Move forward to the next entry */ 478 while (*p) { 479 if (*p++ == ',') 480 break; 481 } 482 } 483 if (!*p) /* No match */ 484 return; 485 486 /* Collect the flags */ 487 while (*++p && *p != ',') { 488 switch (TOLOWER(*p)) { 489 case 'a': 490 f |= US_FL_SANE_SENSE; 491 break; 492 case 'c': 493 f |= US_FL_FIX_CAPACITY; 494 break; 495 case 'h': 496 f |= US_FL_CAPACITY_HEURISTICS; 497 break; 498 case 'i': 499 f |= US_FL_IGNORE_DEVICE; 500 break; 501 case 'l': 502 f |= US_FL_NOT_LOCKABLE; 503 break; 504 case 'm': 505 f |= US_FL_MAX_SECTORS_64; 506 break; 507 case 'o': 508 f |= US_FL_CAPACITY_OK; 509 break; 510 case 'r': 511 f |= US_FL_IGNORE_RESIDUE; 512 break; 513 case 's': 514 f |= US_FL_SINGLE_LUN; 515 break; 516 case 'w': 517 f |= US_FL_NO_WP_DETECT; 518 break; 519 /* Ignore unrecognized flag characters */ 520 } 521 } 522 us->fflags = (us->fflags & ~mask) | f; 523 dev_info(&us->pusb_intf->dev, "Quirks match for " 524 "vid %04x pid %04x: %x\n", 525 vid, pid, f); 526 } 527 528 /* Get the unusual_devs entries and the string descriptors */ 529 static int get_device_info(struct us_data *us, const struct usb_device_id *id, 530 struct us_unusual_dev *unusual_dev) 531 { 532 struct usb_device *dev = us->pusb_dev; 533 struct usb_interface_descriptor *idesc = 534 &us->pusb_intf->cur_altsetting->desc; 535 536 /* Store the entries */ 537 us->unusual_dev = unusual_dev; 538 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ? 539 idesc->bInterfaceSubClass : 540 unusual_dev->useProtocol; 541 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ? 542 idesc->bInterfaceProtocol : 543 unusual_dev->useTransport; 544 us->fflags = USB_US_ORIG_FLAGS(id->driver_info); 545 adjust_quirks(us); 546 547 if (us->fflags & US_FL_IGNORE_DEVICE) { 548 printk(KERN_INFO USB_STORAGE "device ignored\n"); 549 return -ENODEV; 550 } 551 552 /* 553 * This flag is only needed when we're in high-speed, so let's 554 * disable it if we're in full-speed 555 */ 556 if (dev->speed != USB_SPEED_HIGH) 557 us->fflags &= ~US_FL_GO_SLOW; 558 559 /* Log a message if a non-generic unusual_dev entry contains an 560 * unnecessary subclass or protocol override. This may stimulate 561 * reports from users that will help us remove unneeded entries 562 * from the unusual_devs.h table. 563 */ 564 if (id->idVendor || id->idProduct) { 565 static const char *msgs[3] = { 566 "an unneeded SubClass entry", 567 "an unneeded Protocol entry", 568 "unneeded SubClass and Protocol entries"}; 569 struct usb_device_descriptor *ddesc = &dev->descriptor; 570 int msg = -1; 571 572 if (unusual_dev->useProtocol != US_SC_DEVICE && 573 us->subclass == idesc->bInterfaceSubClass) 574 msg += 1; 575 if (unusual_dev->useTransport != US_PR_DEVICE && 576 us->protocol == idesc->bInterfaceProtocol) 577 msg += 2; 578 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE)) 579 printk(KERN_NOTICE USB_STORAGE "This device " 580 "(%04x,%04x,%04x S %02x P %02x)" 581 " has %s in unusual_devs.h (kernel" 582 " %s)\n" 583 " Please send a copy of this message to " 584 "<linux-usb@vger.kernel.org> and " 585 "<usb-storage@lists.one-eyed-alien.net>\n", 586 le16_to_cpu(ddesc->idVendor), 587 le16_to_cpu(ddesc->idProduct), 588 le16_to_cpu(ddesc->bcdDevice), 589 idesc->bInterfaceSubClass, 590 idesc->bInterfaceProtocol, 591 msgs[msg], 592 utsname()->release); 593 } 594 595 return 0; 596 } 597 598 /* Get the transport settings */ 599 static void get_transport(struct us_data *us) 600 { 601 switch (us->protocol) { 602 case US_PR_CB: 603 us->transport_name = "Control/Bulk"; 604 us->transport = usb_stor_CB_transport; 605 us->transport_reset = usb_stor_CB_reset; 606 us->max_lun = 7; 607 break; 608 609 case US_PR_CBI: 610 us->transport_name = "Control/Bulk/Interrupt"; 611 us->transport = usb_stor_CB_transport; 612 us->transport_reset = usb_stor_CB_reset; 613 us->max_lun = 7; 614 break; 615 616 case US_PR_BULK: 617 us->transport_name = "Bulk"; 618 us->transport = usb_stor_Bulk_transport; 619 us->transport_reset = usb_stor_Bulk_reset; 620 break; 621 622 #ifdef CONFIG_USB_STORAGE_USBAT 623 case US_PR_USBAT: 624 us->transport_name = "Shuttle USBAT"; 625 us->transport = usbat_transport; 626 us->transport_reset = usb_stor_CB_reset; 627 us->max_lun = 1; 628 break; 629 #endif 630 631 #ifdef CONFIG_USB_STORAGE_SDDR55 632 case US_PR_SDDR55: 633 us->transport_name = "SDDR55"; 634 us->transport = sddr55_transport; 635 us->transport_reset = sddr55_reset; 636 us->max_lun = 0; 637 break; 638 #endif 639 640 #ifdef CONFIG_USB_STORAGE_FREECOM 641 case US_PR_FREECOM: 642 us->transport_name = "Freecom"; 643 us->transport = freecom_transport; 644 us->transport_reset = usb_stor_freecom_reset; 645 us->max_lun = 0; 646 break; 647 #endif 648 649 #ifdef CONFIG_USB_STORAGE_DATAFAB 650 case US_PR_DATAFAB: 651 us->transport_name = "Datafab Bulk-Only"; 652 us->transport = datafab_transport; 653 us->transport_reset = usb_stor_Bulk_reset; 654 us->max_lun = 1; 655 break; 656 #endif 657 658 #ifdef CONFIG_USB_STORAGE_JUMPSHOT 659 case US_PR_JUMPSHOT: 660 us->transport_name = "Lexar Jumpshot Control/Bulk"; 661 us->transport = jumpshot_transport; 662 us->transport_reset = usb_stor_Bulk_reset; 663 us->max_lun = 1; 664 break; 665 #endif 666 667 #ifdef CONFIG_USB_STORAGE_ALAUDA 668 case US_PR_ALAUDA: 669 us->transport_name = "Alauda Control/Bulk"; 670 us->transport = alauda_transport; 671 us->transport_reset = usb_stor_Bulk_reset; 672 us->max_lun = 1; 673 break; 674 #endif 675 676 #ifdef CONFIG_USB_STORAGE_KARMA 677 case US_PR_KARMA: 678 us->transport_name = "Rio Karma/Bulk"; 679 us->transport = rio_karma_transport; 680 us->transport_reset = usb_stor_Bulk_reset; 681 break; 682 #endif 683 684 } 685 } 686 687 /* Get the protocol settings */ 688 static void get_protocol(struct us_data *us) 689 { 690 switch (us->subclass) { 691 case US_SC_RBC: 692 us->protocol_name = "Reduced Block Commands (RBC)"; 693 us->proto_handler = usb_stor_transparent_scsi_command; 694 break; 695 696 case US_SC_8020: 697 us->protocol_name = "8020i"; 698 us->proto_handler = usb_stor_pad12_command; 699 us->max_lun = 0; 700 break; 701 702 case US_SC_QIC: 703 us->protocol_name = "QIC-157"; 704 us->proto_handler = usb_stor_pad12_command; 705 us->max_lun = 0; 706 break; 707 708 case US_SC_8070: 709 us->protocol_name = "8070i"; 710 us->proto_handler = usb_stor_pad12_command; 711 us->max_lun = 0; 712 break; 713 714 case US_SC_SCSI: 715 us->protocol_name = "Transparent SCSI"; 716 us->proto_handler = usb_stor_transparent_scsi_command; 717 break; 718 719 case US_SC_UFI: 720 us->protocol_name = "Uniform Floppy Interface (UFI)"; 721 us->proto_handler = usb_stor_ufi_command; 722 break; 723 724 #ifdef CONFIG_USB_STORAGE_ISD200 725 case US_SC_ISD200: 726 us->protocol_name = "ISD200 ATA/ATAPI"; 727 us->proto_handler = isd200_ata_command; 728 break; 729 #endif 730 731 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB 732 case US_SC_CYP_ATACB: 733 us->protocol_name = "Transparent SCSI with Cypress ATACB"; 734 us->proto_handler = cypress_atacb_passthrough; 735 break; 736 #endif 737 738 } 739 } 740 741 /* Get the pipe settings */ 742 static int get_pipes(struct us_data *us) 743 { 744 struct usb_host_interface *altsetting = 745 us->pusb_intf->cur_altsetting; 746 int i; 747 struct usb_endpoint_descriptor *ep; 748 struct usb_endpoint_descriptor *ep_in = NULL; 749 struct usb_endpoint_descriptor *ep_out = NULL; 750 struct usb_endpoint_descriptor *ep_int = NULL; 751 752 /* 753 * Find the first endpoint of each type we need. 754 * We are expecting a minimum of 2 endpoints - in and out (bulk). 755 * An optional interrupt-in is OK (necessary for CBI protocol). 756 * We will ignore any others. 757 */ 758 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) { 759 ep = &altsetting->endpoint[i].desc; 760 761 if (usb_endpoint_xfer_bulk(ep)) { 762 if (usb_endpoint_dir_in(ep)) { 763 if (!ep_in) 764 ep_in = ep; 765 } else { 766 if (!ep_out) 767 ep_out = ep; 768 } 769 } 770 771 else if (usb_endpoint_is_int_in(ep)) { 772 if (!ep_int) 773 ep_int = ep; 774 } 775 } 776 777 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) { 778 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 779 return -EIO; 780 } 781 782 /* Calculate and store the pipe values */ 783 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0); 784 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0); 785 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, 786 usb_endpoint_num(ep_out)); 787 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 788 usb_endpoint_num(ep_in)); 789 if (ep_int) { 790 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, 791 usb_endpoint_num(ep_int)); 792 us->ep_bInterval = ep_int->bInterval; 793 } 794 return 0; 795 } 796 797 /* Initialize all the dynamic resources we need */ 798 static int usb_stor_acquire_resources(struct us_data *us) 799 { 800 int p; 801 struct task_struct *th; 802 803 us->current_urb = usb_alloc_urb(0, GFP_KERNEL); 804 if (!us->current_urb) { 805 US_DEBUGP("URB allocation failed\n"); 806 return -ENOMEM; 807 } 808 809 /* Just before we start our control thread, initialize 810 * the device if it needs initialization */ 811 if (us->unusual_dev->initFunction) { 812 p = us->unusual_dev->initFunction(us); 813 if (p) 814 return p; 815 } 816 817 /* Start up our control thread */ 818 th = kthread_run(usb_stor_control_thread, us, "usb-storage"); 819 if (IS_ERR(th)) { 820 printk(KERN_WARNING USB_STORAGE 821 "Unable to start control thread\n"); 822 return PTR_ERR(th); 823 } 824 us->ctl_thread = th; 825 826 return 0; 827 } 828 829 /* Release all our dynamic resources */ 830 static void usb_stor_release_resources(struct us_data *us) 831 { 832 US_DEBUGP("-- %s\n", __func__); 833 834 /* Tell the control thread to exit. The SCSI host must 835 * already have been removed and the DISCONNECTING flag set 836 * so that we won't accept any more commands. 837 */ 838 US_DEBUGP("-- sending exit command to thread\n"); 839 complete(&us->cmnd_ready); 840 if (us->ctl_thread) 841 kthread_stop(us->ctl_thread); 842 843 /* Call the destructor routine, if it exists */ 844 if (us->extra_destructor) { 845 US_DEBUGP("-- calling extra_destructor()\n"); 846 us->extra_destructor(us->extra); 847 } 848 849 /* Free the extra data and the URB */ 850 kfree(us->extra); 851 usb_free_urb(us->current_urb); 852 } 853 854 /* Dissociate from the USB device */ 855 static void dissociate_dev(struct us_data *us) 856 { 857 US_DEBUGP("-- %s\n", __func__); 858 859 /* Free the device-related DMA-mapped buffers */ 860 if (us->cr) 861 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr, 862 us->cr_dma); 863 if (us->iobuf) 864 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, 865 us->iobuf_dma); 866 867 /* Remove our private data from the interface */ 868 usb_set_intfdata(us->pusb_intf, NULL); 869 } 870 871 /* First stage of disconnect processing: stop SCSI scanning, 872 * remove the host, and stop accepting new commands 873 */ 874 static void quiesce_and_remove_host(struct us_data *us) 875 { 876 struct Scsi_Host *host = us_to_host(us); 877 878 /* If the device is really gone, cut short reset delays */ 879 if (us->pusb_dev->state == USB_STATE_NOTATTACHED) 880 set_bit(US_FLIDX_DISCONNECTING, &us->dflags); 881 882 /* Prevent SCSI-scanning (if it hasn't started yet) 883 * and wait for the SCSI-scanning thread to stop. 884 */ 885 set_bit(US_FLIDX_DONT_SCAN, &us->dflags); 886 wake_up(&us->delay_wait); 887 wait_for_completion(&us->scanning_done); 888 889 /* Removing the host will perform an orderly shutdown: caches 890 * synchronized, disks spun down, etc. 891 */ 892 scsi_remove_host(host); 893 894 /* Prevent any new commands from being accepted and cut short 895 * reset delays. 896 */ 897 scsi_lock(host); 898 set_bit(US_FLIDX_DISCONNECTING, &us->dflags); 899 scsi_unlock(host); 900 wake_up(&us->delay_wait); 901 } 902 903 /* Second stage of disconnect processing: deallocate all resources */ 904 static void release_everything(struct us_data *us) 905 { 906 usb_stor_release_resources(us); 907 dissociate_dev(us); 908 909 /* Drop our reference to the host; the SCSI core will free it 910 * (and "us" along with it) when the refcount becomes 0. */ 911 scsi_host_put(us_to_host(us)); 912 } 913 914 /* Thread to carry out delayed SCSI-device scanning */ 915 static int usb_stor_scan_thread(void * __us) 916 { 917 struct us_data *us = (struct us_data *)__us; 918 919 printk(KERN_DEBUG 920 "usb-storage: device found at %d\n", us->pusb_dev->devnum); 921 922 set_freezable(); 923 /* Wait for the timeout to expire or for a disconnect */ 924 if (delay_use > 0) { 925 printk(KERN_DEBUG "usb-storage: waiting for device " 926 "to settle before scanning\n"); 927 wait_event_freezable_timeout(us->delay_wait, 928 test_bit(US_FLIDX_DONT_SCAN, &us->dflags), 929 delay_use * HZ); 930 } 931 932 /* If the device is still connected, perform the scanning */ 933 if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) { 934 935 /* For bulk-only devices, determine the max LUN value */ 936 if (us->protocol == US_PR_BULK && 937 !(us->fflags & US_FL_SINGLE_LUN)) { 938 mutex_lock(&us->dev_mutex); 939 us->max_lun = usb_stor_Bulk_max_lun(us); 940 mutex_unlock(&us->dev_mutex); 941 } 942 scsi_scan_host(us_to_host(us)); 943 printk(KERN_DEBUG "usb-storage: device scan complete\n"); 944 945 /* Should we unbind if no devices were detected? */ 946 } 947 948 complete_and_exit(&us->scanning_done, 0); 949 } 950 951 952 /* First part of general USB mass-storage probing */ 953 int usb_stor_probe1(struct us_data **pus, 954 struct usb_interface *intf, 955 const struct usb_device_id *id, 956 struct us_unusual_dev *unusual_dev) 957 { 958 struct Scsi_Host *host; 959 struct us_data *us; 960 int result; 961 962 US_DEBUGP("USB Mass Storage device detected\n"); 963 964 /* 965 * Ask the SCSI layer to allocate a host structure, with extra 966 * space at the end for our private us_data structure. 967 */ 968 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us)); 969 if (!host) { 970 printk(KERN_WARNING USB_STORAGE 971 "Unable to allocate the scsi host\n"); 972 return -ENOMEM; 973 } 974 975 /* 976 * Allow 16-byte CDBs and thus > 2TB 977 */ 978 host->max_cmd_len = 16; 979 *pus = us = host_to_us(host); 980 memset(us, 0, sizeof(struct us_data)); 981 mutex_init(&(us->dev_mutex)); 982 init_completion(&us->cmnd_ready); 983 init_completion(&(us->notify)); 984 init_waitqueue_head(&us->delay_wait); 985 init_completion(&us->scanning_done); 986 987 /* Associate the us_data structure with the USB device */ 988 result = associate_dev(us, intf); 989 if (result) 990 goto BadDevice; 991 992 /* Get the unusual_devs entries and the descriptors */ 993 result = get_device_info(us, id, unusual_dev); 994 if (result) 995 goto BadDevice; 996 997 /* Get standard transport and protocol settings */ 998 get_transport(us); 999 get_protocol(us); 1000 1001 /* Give the caller a chance to fill in specialized transport 1002 * or protocol settings. 1003 */ 1004 return 0; 1005 1006 BadDevice: 1007 US_DEBUGP("storage_probe() failed\n"); 1008 release_everything(us); 1009 return result; 1010 } 1011 EXPORT_SYMBOL_GPL(usb_stor_probe1); 1012 1013 /* Second part of general USB mass-storage probing */ 1014 int usb_stor_probe2(struct us_data *us) 1015 { 1016 struct task_struct *th; 1017 int result; 1018 1019 /* Make sure the transport and protocol have both been set */ 1020 if (!us->transport || !us->proto_handler) { 1021 result = -ENXIO; 1022 goto BadDevice; 1023 } 1024 US_DEBUGP("Transport: %s\n", us->transport_name); 1025 US_DEBUGP("Protocol: %s\n", us->protocol_name); 1026 1027 /* fix for single-lun devices */ 1028 if (us->fflags & US_FL_SINGLE_LUN) 1029 us->max_lun = 0; 1030 1031 /* Find the endpoints and calculate pipe values */ 1032 result = get_pipes(us); 1033 if (result) 1034 goto BadDevice; 1035 1036 /* Acquire all the other resources and add the host */ 1037 result = usb_stor_acquire_resources(us); 1038 if (result) 1039 goto BadDevice; 1040 result = scsi_add_host(us_to_host(us), &us->pusb_intf->dev); 1041 if (result) { 1042 printk(KERN_WARNING USB_STORAGE 1043 "Unable to add the scsi host\n"); 1044 goto BadDevice; 1045 } 1046 1047 /* Start up the thread for delayed SCSI-device scanning */ 1048 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan"); 1049 if (IS_ERR(th)) { 1050 printk(KERN_WARNING USB_STORAGE 1051 "Unable to start the device-scanning thread\n"); 1052 complete(&us->scanning_done); 1053 quiesce_and_remove_host(us); 1054 result = PTR_ERR(th); 1055 goto BadDevice; 1056 } 1057 1058 wake_up_process(th); 1059 1060 return 0; 1061 1062 /* We come here if there are any problems */ 1063 BadDevice: 1064 US_DEBUGP("storage_probe() failed\n"); 1065 release_everything(us); 1066 return result; 1067 } 1068 EXPORT_SYMBOL_GPL(usb_stor_probe2); 1069 1070 /* Handle a USB mass-storage disconnect */ 1071 void usb_stor_disconnect(struct usb_interface *intf) 1072 { 1073 struct us_data *us = usb_get_intfdata(intf); 1074 1075 US_DEBUGP("storage_disconnect() called\n"); 1076 quiesce_and_remove_host(us); 1077 release_everything(us); 1078 } 1079 EXPORT_SYMBOL_GPL(usb_stor_disconnect); 1080 1081 /* The main probe routine for standard devices */ 1082 static int storage_probe(struct usb_interface *intf, 1083 const struct usb_device_id *id) 1084 { 1085 struct us_data *us; 1086 int result; 1087 1088 /* 1089 * If libusual is configured, let it decide whether a standard 1090 * device should be handled by usb-storage or by ub. 1091 * If the device isn't standard (is handled by a subdriver 1092 * module) then don't accept it. 1093 */ 1094 if (usb_usual_check_type(id, USB_US_TYPE_STOR) || 1095 usb_usual_ignore_device(intf)) 1096 return -ENXIO; 1097 1098 /* 1099 * Call the general probe procedures. 1100 * 1101 * The unusual_dev_list array is parallel to the usb_storage_usb_ids 1102 * table, so we use the index of the id entry to find the 1103 * corresponding unusual_devs entry. 1104 */ 1105 result = usb_stor_probe1(&us, intf, id, 1106 (id - usb_storage_usb_ids) + us_unusual_dev_list); 1107 if (result) 1108 return result; 1109 1110 /* No special transport or protocol settings in the main module */ 1111 1112 result = usb_stor_probe2(us); 1113 return result; 1114 } 1115 1116 /*********************************************************************** 1117 * Initialization and registration 1118 ***********************************************************************/ 1119 1120 static struct usb_driver usb_storage_driver = { 1121 .name = "usb-storage", 1122 .probe = storage_probe, 1123 .disconnect = usb_stor_disconnect, 1124 .suspend = usb_stor_suspend, 1125 .resume = usb_stor_resume, 1126 .reset_resume = usb_stor_reset_resume, 1127 .pre_reset = usb_stor_pre_reset, 1128 .post_reset = usb_stor_post_reset, 1129 .id_table = usb_storage_usb_ids, 1130 .soft_unbind = 1, 1131 }; 1132 1133 static int __init usb_stor_init(void) 1134 { 1135 int retval; 1136 1137 printk(KERN_INFO "Initializing USB Mass Storage driver...\n"); 1138 1139 /* register the driver, return usb_register return code if error */ 1140 retval = usb_register(&usb_storage_driver); 1141 if (retval == 0) { 1142 printk(KERN_INFO "USB Mass Storage support registered.\n"); 1143 usb_usual_set_present(USB_US_TYPE_STOR); 1144 } 1145 return retval; 1146 } 1147 1148 static void __exit usb_stor_exit(void) 1149 { 1150 US_DEBUGP("usb_stor_exit() called\n"); 1151 1152 /* Deregister the driver 1153 * This will cause disconnect() to be called for each 1154 * attached unit 1155 */ 1156 US_DEBUGP("-- calling usb_deregister()\n"); 1157 usb_deregister(&usb_storage_driver) ; 1158 1159 usb_usual_clear_present(USB_US_TYPE_STOR); 1160 } 1161 1162 module_init(usb_stor_init); 1163 module_exit(usb_stor_exit); 1164