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