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