Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 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

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 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                                         "<linux-usb@vger.kernel.org> and "
623                                         "<usb-storage@lists.one-eyed-alien.net>\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);
1104 

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