Version:  2.0.40 2.2.26 2.4.37 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 4.2

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 #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);
1147 

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