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 | US_FL_WRITE_CACHE); 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 'p': 533 f |= US_FL_WRITE_CACHE; 534 break; 535 case 'r': 536 f |= US_FL_IGNORE_RESIDUE; 537 break; 538 case 's': 539 f |= US_FL_SINGLE_LUN; 540 break; 541 case 'w': 542 f |= US_FL_NO_WP_DETECT; 543 break; 544 /* Ignore unrecognized flag characters */ 545 } 546 } 547 us->fflags = (us->fflags & ~mask) | f; 548 } 549 550 /* Get the unusual_devs entries and the string descriptors */ 551 static int get_device_info(struct us_data *us, const struct usb_device_id *id, 552 struct us_unusual_dev *unusual_dev) 553 { 554 struct usb_device *dev = us->pusb_dev; 555 struct usb_interface_descriptor *idesc = 556 &us->pusb_intf->cur_altsetting->desc; 557 struct device *pdev = &us->pusb_intf->dev; 558 559 /* Store the entries */ 560 us->unusual_dev = unusual_dev; 561 us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ? 562 idesc->bInterfaceSubClass : 563 unusual_dev->useProtocol; 564 us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ? 565 idesc->bInterfaceProtocol : 566 unusual_dev->useTransport; 567 us->fflags = USB_US_ORIG_FLAGS(id->driver_info); 568 adjust_quirks(us); 569 570 if (us->fflags & US_FL_IGNORE_DEVICE) { 571 dev_info(pdev, "device ignored\n"); 572 return -ENODEV; 573 } 574 575 /* 576 * This flag is only needed when we're in high-speed, so let's 577 * disable it if we're in full-speed 578 */ 579 if (dev->speed != USB_SPEED_HIGH) 580 us->fflags &= ~US_FL_GO_SLOW; 581 582 if (us->fflags) 583 dev_info(pdev, "Quirks match for vid %04x pid %04x: %lx\n", 584 le16_to_cpu(dev->descriptor.idVendor), 585 le16_to_cpu(dev->descriptor.idProduct), 586 us->fflags); 587 588 /* Log a message if a non-generic unusual_dev entry contains an 589 * unnecessary subclass or protocol override. This may stimulate 590 * reports from users that will help us remove unneeded entries 591 * from the unusual_devs.h table. 592 */ 593 if (id->idVendor || id->idProduct) { 594 static const char *msgs[3] = { 595 "an unneeded SubClass entry", 596 "an unneeded Protocol entry", 597 "unneeded SubClass and Protocol entries"}; 598 struct usb_device_descriptor *ddesc = &dev->descriptor; 599 int msg = -1; 600 601 if (unusual_dev->useProtocol != USB_SC_DEVICE && 602 us->subclass == idesc->bInterfaceSubClass) 603 msg += 1; 604 if (unusual_dev->useTransport != USB_PR_DEVICE && 605 us->protocol == idesc->bInterfaceProtocol) 606 msg += 2; 607 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE)) 608 dev_notice(pdev, "This device " 609 "(%04x,%04x,%04x S %02x P %02x)" 610 " has %s in unusual_devs.h (kernel" 611 " %s)\n" 612 " Please send a copy of this message to " 613 "<linux-usb@vger.kernel.org> and " 614 "<usb-storage@lists.one-eyed-alien.net>\n", 615 le16_to_cpu(ddesc->idVendor), 616 le16_to_cpu(ddesc->idProduct), 617 le16_to_cpu(ddesc->bcdDevice), 618 idesc->bInterfaceSubClass, 619 idesc->bInterfaceProtocol, 620 msgs[msg], 621 utsname()->release); 622 } 623 624 return 0; 625 } 626 627 /* Get the transport settings */ 628 static void get_transport(struct us_data *us) 629 { 630 switch (us->protocol) { 631 case USB_PR_CB: 632 us->transport_name = "Control/Bulk"; 633 us->transport = usb_stor_CB_transport; 634 us->transport_reset = usb_stor_CB_reset; 635 us->max_lun = 7; 636 break; 637 638 case USB_PR_CBI: 639 us->transport_name = "Control/Bulk/Interrupt"; 640 us->transport = usb_stor_CB_transport; 641 us->transport_reset = usb_stor_CB_reset; 642 us->max_lun = 7; 643 break; 644 645 case USB_PR_BULK: 646 us->transport_name = "Bulk"; 647 us->transport = usb_stor_Bulk_transport; 648 us->transport_reset = usb_stor_Bulk_reset; 649 break; 650 } 651 } 652 653 /* Get the protocol settings */ 654 static void get_protocol(struct us_data *us) 655 { 656 switch (us->subclass) { 657 case USB_SC_RBC: 658 us->protocol_name = "Reduced Block Commands (RBC)"; 659 us->proto_handler = usb_stor_transparent_scsi_command; 660 break; 661 662 case USB_SC_8020: 663 us->protocol_name = "8020i"; 664 us->proto_handler = usb_stor_pad12_command; 665 us->max_lun = 0; 666 break; 667 668 case USB_SC_QIC: 669 us->protocol_name = "QIC-157"; 670 us->proto_handler = usb_stor_pad12_command; 671 us->max_lun = 0; 672 break; 673 674 case USB_SC_8070: 675 us->protocol_name = "8070i"; 676 us->proto_handler = usb_stor_pad12_command; 677 us->max_lun = 0; 678 break; 679 680 case USB_SC_SCSI: 681 us->protocol_name = "Transparent SCSI"; 682 us->proto_handler = usb_stor_transparent_scsi_command; 683 break; 684 685 case USB_SC_UFI: 686 us->protocol_name = "Uniform Floppy Interface (UFI)"; 687 us->proto_handler = usb_stor_ufi_command; 688 break; 689 } 690 } 691 692 /* Get the pipe settings */ 693 static int get_pipes(struct us_data *us) 694 { 695 struct usb_host_interface *altsetting = 696 us->pusb_intf->cur_altsetting; 697 int i; 698 struct usb_endpoint_descriptor *ep; 699 struct usb_endpoint_descriptor *ep_in = NULL; 700 struct usb_endpoint_descriptor *ep_out = NULL; 701 struct usb_endpoint_descriptor *ep_int = NULL; 702 703 /* 704 * Find the first endpoint of each type we need. 705 * We are expecting a minimum of 2 endpoints - in and out (bulk). 706 * An optional interrupt-in is OK (necessary for CBI protocol). 707 * We will ignore any others. 708 */ 709 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) { 710 ep = &altsetting->endpoint[i].desc; 711 712 if (usb_endpoint_xfer_bulk(ep)) { 713 if (usb_endpoint_dir_in(ep)) { 714 if (!ep_in) 715 ep_in = ep; 716 } else { 717 if (!ep_out) 718 ep_out = ep; 719 } 720 } 721 722 else if (usb_endpoint_is_int_in(ep)) { 723 if (!ep_int) 724 ep_int = ep; 725 } 726 } 727 728 if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) { 729 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n"); 730 return -EIO; 731 } 732 733 /* Calculate and store the pipe values */ 734 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0); 735 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0); 736 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, 737 usb_endpoint_num(ep_out)); 738 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 739 usb_endpoint_num(ep_in)); 740 if (ep_int) { 741 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, 742 usb_endpoint_num(ep_int)); 743 us->ep_bInterval = ep_int->bInterval; 744 } 745 return 0; 746 } 747 748 /* Initialize all the dynamic resources we need */ 749 static int usb_stor_acquire_resources(struct us_data *us) 750 { 751 int p; 752 struct task_struct *th; 753 754 us->current_urb = usb_alloc_urb(0, GFP_KERNEL); 755 if (!us->current_urb) { 756 US_DEBUGP("URB allocation failed\n"); 757 return -ENOMEM; 758 } 759 760 /* Just before we start our control thread, initialize 761 * the device if it needs initialization */ 762 if (us->unusual_dev->initFunction) { 763 p = us->unusual_dev->initFunction(us); 764 if (p) 765 return p; 766 } 767 768 /* Start up our control thread */ 769 th = kthread_run(usb_stor_control_thread, us, "usb-storage"); 770 if (IS_ERR(th)) { 771 dev_warn(&us->pusb_intf->dev, 772 "Unable to start control thread\n"); 773 return PTR_ERR(th); 774 } 775 us->ctl_thread = th; 776 777 return 0; 778 } 779 780 /* Release all our dynamic resources */ 781 static void usb_stor_release_resources(struct us_data *us) 782 { 783 US_DEBUGP("-- %s\n", __func__); 784 785 /* Tell the control thread to exit. The SCSI host must 786 * already have been removed and the DISCONNECTING flag set 787 * so that we won't accept any more commands. 788 */ 789 US_DEBUGP("-- sending exit command to thread\n"); 790 complete(&us->cmnd_ready); 791 if (us->ctl_thread) 792 kthread_stop(us->ctl_thread); 793 794 /* Call the destructor routine, if it exists */ 795 if (us->extra_destructor) { 796 US_DEBUGP("-- calling extra_destructor()\n"); 797 us->extra_destructor(us->extra); 798 } 799 800 /* Free the extra data and the URB */ 801 kfree(us->extra); 802 usb_free_urb(us->current_urb); 803 } 804 805 /* Dissociate from the USB device */ 806 static void dissociate_dev(struct us_data *us) 807 { 808 US_DEBUGP("-- %s\n", __func__); 809 810 /* Free the buffers */ 811 kfree(us->cr); 812 usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma); 813 814 /* Remove our private data from the interface */ 815 usb_set_intfdata(us->pusb_intf, NULL); 816 } 817 818 /* First stage of disconnect processing: stop SCSI scanning, 819 * remove the host, and stop accepting new commands 820 */ 821 static void quiesce_and_remove_host(struct us_data *us) 822 { 823 struct Scsi_Host *host = us_to_host(us); 824 825 /* If the device is really gone, cut short reset delays */ 826 if (us->pusb_dev->state == USB_STATE_NOTATTACHED) { 827 set_bit(US_FLIDX_DISCONNECTING, &us->dflags); 828 wake_up(&us->delay_wait); 829 } 830 831 /* Prevent SCSI scanning (if it hasn't started yet) 832 * or wait for the SCSI-scanning routine to stop. 833 */ 834 cancel_delayed_work_sync(&us->scan_dwork); 835 836 /* Balance autopm calls if scanning was cancelled */ 837 if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags)) 838 usb_autopm_put_interface_no_suspend(us->pusb_intf); 839 840 /* Removing the host will perform an orderly shutdown: caches 841 * synchronized, disks spun down, etc. 842 */ 843 scsi_remove_host(host); 844 845 /* Prevent any new commands from being accepted and cut short 846 * reset delays. 847 */ 848 scsi_lock(host); 849 set_bit(US_FLIDX_DISCONNECTING, &us->dflags); 850 scsi_unlock(host); 851 wake_up(&us->delay_wait); 852 } 853 854 /* Second stage of disconnect processing: deallocate all resources */ 855 static void release_everything(struct us_data *us) 856 { 857 usb_stor_release_resources(us); 858 dissociate_dev(us); 859 860 /* Drop our reference to the host; the SCSI core will free it 861 * (and "us" along with it) when the refcount becomes 0. */ 862 scsi_host_put(us_to_host(us)); 863 } 864 865 /* Delayed-work routine to carry out SCSI-device scanning */ 866 static void usb_stor_scan_dwork(struct work_struct *work) 867 { 868 struct us_data *us = container_of(work, struct us_data, 869 scan_dwork.work); 870 struct device *dev = &us->pusb_intf->dev; 871 872 dev_dbg(dev, "starting scan\n"); 873 874 /* For bulk-only devices, determine the max LUN value */ 875 if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) { 876 mutex_lock(&us->dev_mutex); 877 us->max_lun = usb_stor_Bulk_max_lun(us); 878 mutex_unlock(&us->dev_mutex); 879 } 880 scsi_scan_host(us_to_host(us)); 881 dev_dbg(dev, "scan complete\n"); 882 883 /* Should we unbind if no devices were detected? */ 884 885 usb_autopm_put_interface(us->pusb_intf); 886 clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags); 887 } 888 889 static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf) 890 { 891 struct usb_device *usb_dev = interface_to_usbdev(intf); 892 893 if (usb_dev->bus->sg_tablesize) { 894 return usb_dev->bus->sg_tablesize; 895 } 896 return SG_ALL; 897 } 898 899 /* First part of general USB mass-storage probing */ 900 int usb_stor_probe1(struct us_data **pus, 901 struct usb_interface *intf, 902 const struct usb_device_id *id, 903 struct us_unusual_dev *unusual_dev) 904 { 905 struct Scsi_Host *host; 906 struct us_data *us; 907 int result; 908 909 US_DEBUGP("USB Mass Storage device detected\n"); 910 911 /* 912 * Ask the SCSI layer to allocate a host structure, with extra 913 * space at the end for our private us_data structure. 914 */ 915 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us)); 916 if (!host) { 917 dev_warn(&intf->dev, 918 "Unable to allocate the scsi host\n"); 919 return -ENOMEM; 920 } 921 922 /* 923 * Allow 16-byte CDBs and thus > 2TB 924 */ 925 host->max_cmd_len = 16; 926 host->sg_tablesize = usb_stor_sg_tablesize(intf); 927 *pus = us = host_to_us(host); 928 memset(us, 0, sizeof(struct us_data)); 929 mutex_init(&(us->dev_mutex)); 930 us_set_lock_class(&us->dev_mutex, intf); 931 init_completion(&us->cmnd_ready); 932 init_completion(&(us->notify)); 933 init_waitqueue_head(&us->delay_wait); 934 INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork); 935 936 /* Associate the us_data structure with the USB device */ 937 result = associate_dev(us, intf); 938 if (result) 939 goto BadDevice; 940 941 /* Get the unusual_devs entries and the descriptors */ 942 result = get_device_info(us, id, unusual_dev); 943 if (result) 944 goto BadDevice; 945 946 /* Get standard transport and protocol settings */ 947 get_transport(us); 948 get_protocol(us); 949 950 /* Give the caller a chance to fill in specialized transport 951 * or protocol settings. 952 */ 953 return 0; 954 955 BadDevice: 956 US_DEBUGP("storage_probe() failed\n"); 957 release_everything(us); 958 return result; 959 } 960 EXPORT_SYMBOL_GPL(usb_stor_probe1); 961 962 /* Second part of general USB mass-storage probing */ 963 int usb_stor_probe2(struct us_data *us) 964 { 965 int result; 966 struct device *dev = &us->pusb_intf->dev; 967 968 /* Make sure the transport and protocol have both been set */ 969 if (!us->transport || !us->proto_handler) { 970 result = -ENXIO; 971 goto BadDevice; 972 } 973 US_DEBUGP("Transport: %s\n", us->transport_name); 974 US_DEBUGP("Protocol: %s\n", us->protocol_name); 975 976 /* fix for single-lun devices */ 977 if (us->fflags & US_FL_SINGLE_LUN) 978 us->max_lun = 0; 979 980 /* Find the endpoints and calculate pipe values */ 981 result = get_pipes(us); 982 if (result) 983 goto BadDevice; 984 985 /* 986 * If the device returns invalid data for the first READ(10) 987 * command, indicate the command should be retried. 988 */ 989 if (us->fflags & US_FL_INITIAL_READ10) 990 set_bit(US_FLIDX_REDO_READ10, &us->dflags); 991 992 /* Acquire all the other resources and add the host */ 993 result = usb_stor_acquire_resources(us); 994 if (result) 995 goto BadDevice; 996 snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s", 997 dev_name(&us->pusb_intf->dev)); 998 result = scsi_add_host(us_to_host(us), dev); 999 if (result) { 1000 dev_warn(dev, 1001 "Unable to add the scsi host\n"); 1002 goto BadDevice; 1003 } 1004 1005 /* Submit the delayed_work for SCSI-device scanning */ 1006 usb_autopm_get_interface_no_resume(us->pusb_intf); 1007 set_bit(US_FLIDX_SCAN_PENDING, &us->dflags); 1008 1009 if (delay_use > 0) 1010 dev_dbg(dev, "waiting for device to settle before scanning\n"); 1011 queue_delayed_work(system_freezable_wq, &us->scan_dwork, 1012 delay_use * HZ); 1013 return 0; 1014 1015 /* We come here if there are any problems */ 1016 BadDevice: 1017 US_DEBUGP("storage_probe() failed\n"); 1018 release_everything(us); 1019 return result; 1020 } 1021 EXPORT_SYMBOL_GPL(usb_stor_probe2); 1022 1023 /* Handle a USB mass-storage disconnect */ 1024 void usb_stor_disconnect(struct usb_interface *intf) 1025 { 1026 struct us_data *us = usb_get_intfdata(intf); 1027 1028 US_DEBUGP("storage_disconnect() called\n"); 1029 quiesce_and_remove_host(us); 1030 release_everything(us); 1031 } 1032 EXPORT_SYMBOL_GPL(usb_stor_disconnect); 1033 1034 /* The main probe routine for standard devices */ 1035 static int storage_probe(struct usb_interface *intf, 1036 const struct usb_device_id *id) 1037 { 1038 struct us_unusual_dev *unusual_dev; 1039 struct us_data *us; 1040 int result; 1041 int size; 1042 1043 /* 1044 * If libusual is configured, let it decide whether a standard 1045 * device should be handled by usb-storage or by ub. 1046 * If the device isn't standard (is handled by a subdriver 1047 * module) then don't accept it. 1048 */ 1049 if (usb_usual_check_type(id, USB_US_TYPE_STOR) || 1050 usb_usual_ignore_device(intf)) 1051 return -ENXIO; 1052 1053 /* 1054 * Call the general probe procedures. 1055 * 1056 * The unusual_dev_list array is parallel to the usb_storage_usb_ids 1057 * table, so we use the index of the id entry to find the 1058 * corresponding unusual_devs entry. 1059 */ 1060 1061 size = ARRAY_SIZE(us_unusual_dev_list); 1062 if (id >= usb_storage_usb_ids && id < usb_storage_usb_ids + size) { 1063 unusual_dev = (id - usb_storage_usb_ids) + us_unusual_dev_list; 1064 } else { 1065 unusual_dev = &for_dynamic_ids; 1066 1067 US_DEBUGP("%s %s 0x%04x 0x%04x\n", "Use Bulk-Only transport", 1068 "with the Transparent SCSI protocol for dynamic id:", 1069 id->idVendor, id->idProduct); 1070 } 1071 1072 result = usb_stor_probe1(&us, intf, id, unusual_dev); 1073 if (result) 1074 return result; 1075 1076 /* No special transport or protocol settings in the main module */ 1077 1078 result = usb_stor_probe2(us); 1079 return result; 1080 } 1081 1082 /*********************************************************************** 1083 * Initialization and registration 1084 ***********************************************************************/ 1085 1086 static struct usb_driver usb_storage_driver = { 1087 .name = "usb-storage", 1088 .probe = storage_probe, 1089 .disconnect = usb_stor_disconnect, 1090 .suspend = usb_stor_suspend, 1091 .resume = usb_stor_resume, 1092 .reset_resume = usb_stor_reset_resume, 1093 .pre_reset = usb_stor_pre_reset, 1094 .post_reset = usb_stor_post_reset, 1095 .id_table = usb_storage_usb_ids, 1096 .supports_autosuspend = 1, 1097 .soft_unbind = 1, 1098 }; 1099 1100 static int __init usb_stor_init(void) 1101 { 1102 int retval; 1103 1104 pr_info("Initializing USB Mass Storage driver...\n"); 1105 1106 /* register the driver, return usb_register return code if error */ 1107 retval = usb_register(&usb_storage_driver); 1108 if (retval == 0) { 1109 pr_info("USB Mass Storage support registered.\n"); 1110 usb_usual_set_present(USB_US_TYPE_STOR); 1111 } 1112 return retval; 1113 } 1114 1115 static void __exit usb_stor_exit(void) 1116 { 1117 US_DEBUGP("usb_stor_exit() called\n"); 1118 1119 /* Deregister the driver 1120 * This will cause disconnect() to be called for each 1121 * attached unit 1122 */ 1123 US_DEBUGP("-- calling usb_deregister()\n"); 1124 usb_deregister(&usb_storage_driver) ; 1125 1126 usb_usual_clear_present(USB_US_TYPE_STOR); 1127 } 1128 1129 module_init(usb_stor_init); 1130 module_exit(usb_stor_exit); 1131