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