drivers/usb/storage/usb.c

   1 /* Driver for USB Mass Storage compliant devices
   2  *
   3  * Current development and maintenance by:
   4  *   (c) 1999-2003 Matthew Dharm ([email protected])
   5  *
   6  * Developed with the assistance of:
   7  *   (c) 2000 David L. Brown, Jr. ([email protected])
   8  *   (c) 2003-2009 Alan Stern ([email protected])
   9  *
  10  * Initial work by:
  11  *   (c) 1999 Michael Gee ([email protected])
  12  *
  13  * usb_device_id support by Adam J. Richter ([email protected]):
  14  *   (c) 2000 Yggdrasil Computing, Inc.
  15  *
  16  * This driver is based on the 'USB Mass Storage Class' document. This
  17  * describes in detail the protocol used to communicate with such
  18  * devices.  Clearly, the designers had SCSI and ATAPI commands in
  19  * mind when they created this document.  The commands are all very
  20  * similar to commands in the SCSI-II and ATAPI specifications.
  21  *
  22  * It is important to note that in a number of cases this class
  23  * exhibits class-specific exemptions from the USB specification.
  24  * Notably the usage of NAK, STALL and ACK differs from the norm, in
  25  * that they are used to communicate wait, failed and OK on commands.
  26  *
  27  * Also, for certain devices, the interrupt endpoint is used to convey
  28  * status of a command.
  29  *
  30  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
  31  * information about this driver.
  32  *
  33  * This program is free software; you can redistribute it and/or modify it
  34  * under the terms of the GNU General Public License as published by the
  35  * Free Software Foundation; either version 2, or (at your option) any
  36  * later version.
  37  *
  38  * This program is distributed in the hope that it will be useful, but
  39  * WITHOUT ANY WARRANTY; without even the implied warranty of
  40  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  41  * General Public License for more details.
  42  *
  43  * You should have received a copy of the GNU General Public License along
  44  * with this program; if not, write to the Free Software Foundation, Inc.,
  45  * 675 Mass Ave, Cambridge, MA 02139, USA.
  46  */
  47
  48 #ifdef CONFIG_USB_STORAGE_DEBUG
  49 #define DEBUG
  50 #endif
  51
  52 #include <linux/sched.h>
  53 #include <linux/errno.h>
  54 #include <linux/freezer.h>
  55 #include <linux/module.h>
  56 #include <linux/slab.h>
  57 #include <linux/kthread.h>
  58 #include <linux/mutex.h>
  59 #include <linux/utsname.h>
  60
  61 #include <scsi/scsi.h>
  62 #include <scsi/scsi_cmnd.h>
  63 #include <scsi/scsi_device.h>
  64
  65 #include "usb.h"
  66 #include "scsiglue.h"
  67 #include "transport.h"
  68 #include "protocol.h"
  69 #include "debug.h"
  70 #include "initializers.h"
  71
  72 #include "sierra_ms.h"
  73 #include "option_ms.h"
  74
  75 #if IS_ENABLED(CONFIG_USB_UAS)
  76 #include "uas-detect.h"
  77 #endif
  78
  79 /* Some informational data */
  80 MODULE_AUTHOR("Matthew Dharm <[email protected]>");
  81 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
  82 MODULE_LICENSE("GPL");
  83
  84 static unsigned int delay_use = 1;
  85 module_param(delay_use, uint, S_IRUGO | S_IWUSR);
  86 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
  87
  88 static char quirks[128];
  89 module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR);
  90 MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
  91
  92
  93 /*
  94  * The entries in this table correspond, line for line,
  95  * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
  96  */
  97
  98 /* The vendor name should be kept at eight characters or less, and
  99  * the product name should be kept at 16 characters or less. If a device
 100  * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
 101  * normally generated by a device thorugh 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
 483         p = quirks;
 484         while (*p) {
 485                 /* Each entry consists of VID:PID:flags */
 486                 if (vid == simple_strtoul(p, &p, 16) &&
 487                                 *p == ':' &&
 488                                 pid == simple_strtoul(p+1, &p, 16) &&
 489                                 *p == ':')
 490                         break;
 491
 492                 /* Move forward to the next entry */
 493                 while (*p) {
 494                         if (*p++ == ',')
 495                                 break;
 496                 }
 497         }
 498         if (!*p)        /* No match */
 499                 return;
 500
 501         /* Collect the flags */
 502         while (*++p && *p != ',') {
 503                 switch (TOLOWER(*p)) {
 504                 case 'a':
 505                         f |= US_FL_SANE_SENSE;
 506                         break;
 507                 case 'b':
 508                         f |= US_FL_BAD_SENSE;
 509                         break;
 510                 case 'c':
 511                         f |= US_FL_FIX_CAPACITY;
 512                         break;
 513                 case 'd':
 514                         f |= US_FL_NO_READ_DISC_INFO;
 515                         break;
 516                 case 'e':
 517                         f |= US_FL_NO_READ_CAPACITY_16;
 518                         break;
 519                 case 'h':
 520                         f |= US_FL_CAPACITY_HEURISTICS;
 521                         break;
 522                 case 'i':
 523                         f |= US_FL_IGNORE_DEVICE;
 524                         break;
 525                 case 'l':
 526                         f |= US_FL_NOT_LOCKABLE;
 527                         break;
 528                 case 'm':
 529                         f |= US_FL_MAX_SECTORS_64;
 530                         break;
 531                 case 'n':
 532                         f |= US_FL_INITIAL_READ10;
 533                         break;
 534                 case 'o':
 535                         f |= US_FL_CAPACITY_OK;
 536                         break;
 537                 case 'p':
 538                         f |= US_FL_WRITE_CACHE;
 539                         break;
 540                 case 'r':
 541                         f |= US_FL_IGNORE_RESIDUE;
 542                         break;
 543                 case 's':
 544                         f |= US_FL_SINGLE_LUN;
 545                         break;
 546                 case 'u':
 547                         f |= US_FL_IGNORE_UAS;
 548                         break;
 549                 case 'w':
 550                         f |= US_FL_NO_WP_DETECT;
 551                         break;
 552                 /* Ignore unrecognized flag characters */
 553                 }
 554         }
 555         *fflags = (*fflags & ~mask) | f;
 556 }
 557 EXPORT_SYMBOL_GPL(usb_stor_adjust_quirks);
 558
 559 /* Get the unusual_devs entries and the string descriptors */
 560 static int get_device_info(struct us_data *us, const struct usb_device_id *id,
 561                 struct us_unusual_dev *unusual_dev)
 562 {
 563         struct usb_device *dev = us->pusb_dev;
 564         struct usb_interface_descriptor *idesc =
 565                 &us->pusb_intf->cur_altsetting->desc;
 566         struct device *pdev = &us->pusb_intf->dev;
 567
 568         /* Store the entries */
 569         us->unusual_dev = unusual_dev;
 570         us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
 571                         idesc->bInterfaceSubClass :
 572                         unusual_dev->useProtocol;
 573         us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
 574                         idesc->bInterfaceProtocol :
 575                         unusual_dev->useTransport;
 576         us->fflags = id->driver_info;
 577         usb_stor_adjust_quirks(us->pusb_dev, &us->fflags);
 578
 579         if (us->fflags & US_FL_IGNORE_DEVICE) {
 580                 dev_info(pdev, "device ignored\n");
 581                 return -ENODEV;
 582         }
 583
 584         /*
 585          * This flag is only needed when we're in high-speed, so let's
 586          * disable it if we're in full-speed
 587          */
 588         if (dev->speed != USB_SPEED_HIGH)
 589                 us->fflags &= ~US_FL_GO_SLOW;
 590
 591         if (us->fflags)
 592                 dev_info(pdev, "Quirks match for vid %04x pid %04x: %lx\n",
 593                                 le16_to_cpu(dev->descriptor.idVendor),
 594                                 le16_to_cpu(dev->descriptor.idProduct),
 595                                 us->fflags);
 596
 597         /* Log a message if a non-generic unusual_dev entry contains an
 598          * unnecessary subclass or protocol override.  This may stimulate
 599          * reports from users that will help us remove unneeded entries
 600          * from the unusual_devs.h table.
 601          */
 602         if (id->idVendor || id->idProduct) {
 603                 static const char *msgs[3] = {
 604                         "an unneeded SubClass entry",
 605                         "an unneeded Protocol entry",
 606                         "unneeded SubClass and Protocol entries"};
 607                 struct usb_device_descriptor *ddesc = &dev->descriptor;
 608                 int msg = -1;
 609
 610                 if (unusual_dev->useProtocol != USB_SC_DEVICE &&
 611                         us->subclass == idesc->bInterfaceSubClass)
 612                         msg += 1;
 613                 if (unusual_dev->useTransport != USB_PR_DEVICE &&
 614                         us->protocol == idesc->bInterfaceProtocol)
 615                         msg += 2;
 616                 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
 617                         dev_notice(pdev, "This device "
 618                                         "(%04x,%04x,%04x S %02x P %02x)"
 619                                         " has %s in unusual_devs.h (kernel"
 620                                         " %s)\n"
 621                                         "   Please send a copy of this message to "
 622                                         "<[email protected]> and "
 623                                         "<[email protected]>\n",
 624                                         le16_to_cpu(ddesc->idVendor),
 625                                         le16_to_cpu(ddesc->idProduct),
 626                                         le16_to_cpu(ddesc->bcdDevice),
 627                                         idesc->bInterfaceSubClass,
 628                                         idesc->bInterfaceProtocol,
 629                                         msgs[msg],
 630                                         utsname()->release);
 631         }
 632
 633         return 0;
 634 }
 635
 636 /* Get the transport settings */
 637 static void get_transport(struct us_data *us)
 638 {
 639         switch (us->protocol) {
 640         case USB_PR_CB:
 641                 us->transport_name = "Control/Bulk";
 642                 us->transport = usb_stor_CB_transport;
 643                 us->transport_reset = usb_stor_CB_reset;
 644                 us->max_lun = 7;
 645                 break;
 646
 647         case USB_PR_CBI:
 648                 us->transport_name = "Control/Bulk/Interrupt";
 649                 us->transport = usb_stor_CB_transport;
 650                 us->transport_reset = usb_stor_CB_reset;
 651                 us->max_lun = 7;
 652                 break;
 653
 654         case USB_PR_BULK:
 655                 us->transport_name = "Bulk";
 656                 us->transport = usb_stor_Bulk_transport;
 657                 us->transport_reset = usb_stor_Bulk_reset;
 658                 break;
 659         }
 660 }
 661
 662 /* Get the protocol settings */
 663 static void get_protocol(struct us_data *us)
 664 {
 665         switch (us->subclass) {
 666         case USB_SC_RBC:
 667                 us->protocol_name = "Reduced Block Commands (RBC)";
 668                 us->proto_handler = usb_stor_transparent_scsi_command;
 669                 break;
 670
 671         case USB_SC_8020:
 672                 us->protocol_name = "8020i";
 673                 us->proto_handler = usb_stor_pad12_command;
 674                 us->max_lun = 0;
 675                 break;
 676
 677         case USB_SC_QIC:
 678                 us->protocol_name = "QIC-157";
 679                 us->proto_handler = usb_stor_pad12_command;
 680                 us->max_lun = 0;
 681                 break;
 682
 683         case USB_SC_8070:
 684                 us->protocol_name = "8070i";
 685                 us->proto_handler = usb_stor_pad12_command;
 686                 us->max_lun = 0;
 687                 break;
 688
 689         case USB_SC_SCSI:
 690                 us->protocol_name = "Transparent SCSI";
 691                 us->proto_handler = usb_stor_transparent_scsi_command;
 692                 break;
 693
 694         case USB_SC_UFI:
 695                 us->protocol_name = "Uniform Floppy Interface (UFI)";
 696                 us->proto_handler = usb_stor_ufi_command;
 697                 break;
 698         }
 699 }
 700
 701 /* Get the pipe settings */
 702 static int get_pipes(struct us_data *us)
 703 {
 704         struct usb_host_interface *altsetting =
 705                 us->pusb_intf->cur_altsetting;
 706         int i;
 707         struct usb_endpoint_descriptor *ep;
 708         struct usb_endpoint_descriptor *ep_in = NULL;
 709         struct usb_endpoint_descriptor *ep_out = NULL;
 710         struct usb_endpoint_descriptor *ep_int = NULL;
 711
 712         /*
 713          * Find the first endpoint of each type we need.
 714          * We are expecting a minimum of 2 endpoints - in and out (bulk).
 715          * An optional interrupt-in is OK (necessary for CBI protocol).
 716          * We will ignore any others.
 717          */
 718         for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
 719                 ep = &altsetting->endpoint[i].desc;
 720
 721                 if (usb_endpoint_xfer_bulk(ep)) {
 722                         if (usb_endpoint_dir_in(ep)) {
 723                                 if (!ep_in)
 724                                         ep_in = ep;
 725                         } else {
 726                                 if (!ep_out)
 727                                         ep_out = ep;
 728                         }
 729                 }
 730
 731                 else if (usb_endpoint_is_int_in(ep)) {
 732                         if (!ep_int)
 733                                 ep_int = ep;
 734                 }
 735         }
 736
 737         if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
 738                 usb_stor_dbg(us, "Endpoint sanity check failed! Rejecting dev.\n");
 739                 return -EIO;
 740         }
 741
 742         /* Calculate and store the pipe values */
 743         us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
 744         us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
 745         us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
 746                 usb_endpoint_num(ep_out));
 747         us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
 748                 usb_endpoint_num(ep_in));
 749         if (ep_int) {
 750                 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
 751                         usb_endpoint_num(ep_int));
 752                 us->ep_bInterval = ep_int->bInterval;
 753         }
 754         return 0;
 755 }
 756
 757 /* Initialize all the dynamic resources we need */
 758 static int usb_stor_acquire_resources(struct us_data *us)
 759 {
 760         int p;
 761         struct task_struct *th;
 762
 763         us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
 764         if (!us->current_urb) {
 765                 usb_stor_dbg(us, "URB allocation failed\n");
 766                 return -ENOMEM;
 767         }
 768
 769         /* Just before we start our control thread, initialize
 770          * the device if it needs initialization */
 771         if (us->unusual_dev->initFunction) {
 772                 p = us->unusual_dev->initFunction(us);
 773                 if (p)
 774                         return p;
 775         }
 776
 777         /* Start up our control thread */
 778         th = kthread_run(usb_stor_control_thread, us, "usb-storage");
 779         if (IS_ERR(th)) {
 780                 dev_warn(&us->pusb_intf->dev,
 781                                 "Unable to start control thread\n");
 782                 return PTR_ERR(th);
 783         }
 784         us->ctl_thread = th;
 785
 786         return 0;
 787 }
 788
 789 /* Release all our dynamic resources */
 790 static void usb_stor_release_resources(struct us_data *us)
 791 {
 792         /* Tell the control thread to exit.  The SCSI host must
 793          * already have been removed and the DISCONNECTING flag set
 794          * so that we won't accept any more commands.
 795          */
 796         usb_stor_dbg(us, "-- sending exit command to thread\n");
 797         complete(&us->cmnd_ready);
 798         if (us->ctl_thread)
 799                 kthread_stop(us->ctl_thread);
 800
 801         /* Call the destructor routine, if it exists */
 802         if (us->extra_destructor) {
 803                 usb_stor_dbg(us, "-- calling extra_destructor()\n");
 804                 us->extra_destructor(us->extra);
 805         }
 806
 807         /* Free the extra data and the URB */
 808         kfree(us->extra);
 809         usb_free_urb(us->current_urb);
 810 }
 811
 812 /* Dissociate from the USB device */
 813 static void dissociate_dev(struct us_data *us)
 814 {
 815         /* Free the buffers */
 816         kfree(us->cr);
 817         usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);
 818
 819         /* Remove our private data from the interface */
 820         usb_set_intfdata(us->pusb_intf, NULL);
 821 }
 822
 823 /* First stage of disconnect processing: stop SCSI scanning,
 824  * remove the host, and stop accepting new commands
 825  */
 826 static void quiesce_and_remove_host(struct us_data *us)
 827 {
 828         struct Scsi_Host *host = us_to_host(us);
 829
 830         /* If the device is really gone, cut short reset delays */
 831         if (us->pusb_dev->state == USB_STATE_NOTATTACHED) {
 832                 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 833                 wake_up(&us->delay_wait);
 834         }
 835
 836         /* Prevent SCSI scanning (if it hasn't started yet)
 837          * or wait for the SCSI-scanning routine to stop.
 838          */
 839         cancel_delayed_work_sync(&us->scan_dwork);
 840
 841         /* Balance autopm calls if scanning was cancelled */
 842         if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags))
 843                 usb_autopm_put_interface_no_suspend(us->pusb_intf);
 844
 845         /* Removing the host will perform an orderly shutdown: caches
 846          * synchronized, disks spun down, etc.
 847          */
 848         scsi_remove_host(host);
 849
 850         /* Prevent any new commands from being accepted and cut short
 851          * reset delays.
 852          */
 853         scsi_lock(host);
 854         set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 855         scsi_unlock(host);
 856         wake_up(&us->delay_wait);
 857 }
 858
 859 /* Second stage of disconnect processing: deallocate all resources */
 860 static void release_everything(struct us_data *us)
 861 {
 862         usb_stor_release_resources(us);
 863         dissociate_dev(us);
 864
 865         /* Drop our reference to the host; the SCSI core will free it
 866          * (and "us" along with it) when the refcount becomes 0. */
 867         scsi_host_put(us_to_host(us));
 868 }
 869
 870 /* Delayed-work routine to carry out SCSI-device scanning */
 871 static void usb_stor_scan_dwork(struct work_struct *work)
 872 {
 873         struct us_data *us = container_of(work, struct us_data,
 874                         scan_dwork.work);
 875         struct device *dev = &us->pusb_intf->dev;
 876
 877         dev_dbg(dev, "starting scan\n");
 878
 879         /* For bulk-only devices, determine the max LUN value */
 880         if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) {
 881                 mutex_lock(&us->dev_mutex);
 882                 us->max_lun = usb_stor_Bulk_max_lun(us);
 883                 mutex_unlock(&us->dev_mutex);
 884         }
 885         scsi_scan_host(us_to_host(us));
 886         dev_dbg(dev, "scan complete\n");
 887
 888         /* Should we unbind if no devices were detected? */
 889
 890         usb_autopm_put_interface(us->pusb_intf);
 891         clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
 892 }
 893
 894 static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
 895 {
 896         struct usb_device *usb_dev = interface_to_usbdev(intf);
 897
 898         if (usb_dev->bus->sg_tablesize) {
 899                 return usb_dev->bus->sg_tablesize;
 900         }
 901         return SG_ALL;
 902 }
 903
 904 /* First part of general USB mass-storage probing */
 905 int usb_stor_probe1(struct us_data **pus,
 906                 struct usb_interface *intf,
 907                 const struct usb_device_id *id,
 908                 struct us_unusual_dev *unusual_dev)
 909 {
 910         struct Scsi_Host *host;
 911         struct us_data *us;
 912         int result;
 913
 914         dev_info(&intf->dev, "USB Mass Storage device detected\n");
 915
 916         /*
 917          * Ask the SCSI layer to allocate a host structure, with extra
 918          * space at the end for our private us_data structure.
 919          */
 920         host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
 921         if (!host) {
 922                 dev_warn(&intf->dev, "Unable to allocate the scsi host\n");
 923                 return -ENOMEM;
 924         }
 925
 926         /*
 927          * Allow 16-byte CDBs and thus > 2TB
 928          */
 929         host->max_cmd_len = 16;
 930         host->sg_tablesize = usb_stor_sg_tablesize(intf);
 931         *pus = us = host_to_us(host);
 932         mutex_init(&(us->dev_mutex));
 933         us_set_lock_class(&us->dev_mutex, intf);
 934         init_completion(&us->cmnd_ready);
 935         init_completion(&(us->notify));
 936         init_waitqueue_head(&us->delay_wait);
 937         INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork);
 938
 939         /* Associate the us_data structure with the USB device */
 940         result = associate_dev(us, intf);
 941         if (result)
 942                 goto BadDevice;
 943
 944         /* Get the unusual_devs entries and the descriptors */
 945         result = get_device_info(us, id, unusual_dev);
 946         if (result)
 947                 goto BadDevice;
 948
 949         /* Get standard transport and protocol settings */
 950         get_transport(us);
 951         get_protocol(us);
 952
 953         /* Give the caller a chance to fill in specialized transport
 954          * or protocol settings.
 955          */
 956         return 0;
 957
 958 BadDevice:
 959         usb_stor_dbg(us, "storage_probe() failed\n");
 960         release_everything(us);
 961         return result;
 962 }
 963 EXPORT_SYMBOL_GPL(usb_stor_probe1);
 964
 965 /* Second part of general USB mass-storage probing */
 966 int usb_stor_probe2(struct us_data *us)
 967 {
 968         int result;
 969         struct device *dev = &us->pusb_intf->dev;
 970
 971         /* Make sure the transport and protocol have both been set */
 972         if (!us->transport || !us->proto_handler) {
 973                 result = -ENXIO;
 974                 goto BadDevice;
 975         }
 976         usb_stor_dbg(us, "Transport: %s\n", us->transport_name);
 977         usb_stor_dbg(us, "Protocol: %s\n", us->protocol_name);
 978
 979         /* fix for single-lun devices */
 980         if (us->fflags & US_FL_SINGLE_LUN)
 981                 us->max_lun = 0;
 982
 983         if (!(us->fflags & US_FL_SCM_MULT_TARG))
 984                 us_to_host(us)->max_id = 1;
 985
 986         /* Find the endpoints and calculate pipe values */
 987         result = get_pipes(us);
 988         if (result)
 989                 goto BadDevice;
 990
 991         /*
 992          * If the device returns invalid data for the first READ(10)
 993          * command, indicate the command should be retried.
 994          */
 995         if (us->fflags & US_FL_INITIAL_READ10)
 996                 set_bit(US_FLIDX_REDO_READ10, &us->dflags);
 997
 998         /* Acquire all the other resources and add the host */
 999         result = usb_stor_acquire_resources(us);
1000         if (result)
1001                 goto BadDevice;
1002         snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
1003                                         dev_name(&us->pusb_intf->dev));
1004         result = scsi_add_host(us_to_host(us), dev);
1005         if (result) {
1006                 dev_warn(dev,
1007                                 "Unable to add the scsi host\n");
1008                 goto BadDevice;
1009         }
1010
1011         /* Submit the delayed_work for SCSI-device scanning */
1012         usb_autopm_get_interface_no_resume(us->pusb_intf);
1013         set_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
1014
1015         if (delay_use > 0)
1016                 dev_dbg(dev, "waiting for device to settle before scanning\n");
1017         queue_delayed_work(system_freezable_wq, &us->scan_dwork,
1018                         delay_use * HZ);
1019         return 0;
1020
1021         /* We come here if there are any problems */
1022 BadDevice:
1023         usb_stor_dbg(us, "storage_probe() failed\n");
1024         release_everything(us);
1025         return result;
1026 }
1027 EXPORT_SYMBOL_GPL(usb_stor_probe2);
1028
1029 /* Handle a USB mass-storage disconnect */
1030 void usb_stor_disconnect(struct usb_interface *intf)
1031 {
1032         struct us_data *us = usb_get_intfdata(intf);
1033
1034         quiesce_and_remove_host(us);
1035         release_everything(us);
1036 }
1037 EXPORT_SYMBOL_GPL(usb_stor_disconnect);
1038
1039 /* The main probe routine for standard devices */
1040 static int storage_probe(struct usb_interface *intf,
1041                          const struct usb_device_id *id)
1042 {
1043         struct us_unusual_dev *unusual_dev;
1044         struct us_data *us;
1045         int result;
1046         int size;
1047
1048         /* If uas is enabled and this device can do uas then ignore it. */
1049 #if IS_ENABLED(CONFIG_USB_UAS)
1050         if (uas_use_uas_driver(intf, id))
1051                 return -ENXIO;
1052 #endif
1053
1054         /*
1055          * If the device isn't standard (is handled by a subdriver
1056          * module) then don't accept it.
1057          */
1058         if (usb_usual_ignore_device(intf))
1059                 return -ENXIO;
1060
1061         /*
1062          * Call the general probe procedures.
1063          *
1064          * The unusual_dev_list array is parallel to the usb_storage_usb_ids
1065          * table, so we use the index of the id entry to find the
1066          * corresponding unusual_devs entry.
1067          */
1068
1069         size = ARRAY_SIZE(us_unusual_dev_list);
1070         if (id >= usb_storage_usb_ids && id < usb_storage_usb_ids + size) {
1071                 unusual_dev = (id - usb_storage_usb_ids) + us_unusual_dev_list;
1072         } else {
1073                 unusual_dev = &for_dynamic_ids;
1074
1075                 dev_dbg(&intf->dev, "Use Bulk-Only transport with the Transparent SCSI protocol for dynamic id: 0x%04x 0x%04x\n",
1076                         id->idVendor, id->idProduct);
1077         }
1078
1079         result = usb_stor_probe1(&us, intf, id, unusual_dev);
1080         if (result)
1081                 return result;
1082
1083         /* No special transport or protocol settings in the main module */
1084
1085         result = usb_stor_probe2(us);
1086         return result;
1087 }
1088
1089 static struct usb_driver usb_storage_driver = {
1090         .name =         "usb-storage",
1091         .probe =        storage_probe,
1092         .disconnect =   usb_stor_disconnect,
1093         .suspend =      usb_stor_suspend,
1094         .resume =       usb_stor_resume,
1095         .reset_resume = usb_stor_reset_resume,
1096         .pre_reset =    usb_stor_pre_reset,
1097         .post_reset =   usb_stor_post_reset,
1098         .id_table =     usb_storage_usb_ids,
1099         .supports_autosuspend = 1,
1100         .soft_unbind =  1,
1101 };
1102
1103 module_usb_driver(usb_storage_driver);