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