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