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