drivers/usb/storage/usb.c

   1 /* Driver for USB Mass Storage compliant devices
   2  *
   3  * Current development and maintenance by:
   4  *   (c) 1999-2003 Matthew Dharm ([email protected])
   5  *
   6  * Developed with the assistance of:
   7  *   (c) 2000 David L. Brown, Jr. ([email protected])
   8  *   (c) 2003-2009 Alan Stern ([email protected])
   9  *
  10  * Initial work by:
  11  *   (c) 1999 Michael Gee ([email protected])
  12  *
  13  * usb_device_id support by Adam J. Richter ([email protected]):
  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 <[email protected]>");
  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                                         "<[email protected]> and "
 630                                         "<[email protected]>\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);