Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/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);
1141 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us