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