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