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