xref: /openbmc/linux/drivers/usb/storage/scsiglue.c (revision 9eb04add)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Driver for USB Mass Storage compliant devices
4  * SCSI layer glue code
5  *
6  * Current development and maintenance by:
7  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
8  *
9  * Developed with the assistance of:
10  *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
11  *   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
12  *
13  * Initial work by:
14  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
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 
31 #include <linux/blkdev.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/module.h>
34 #include <linux/mutex.h>
35 
36 #include <scsi/scsi.h>
37 #include <scsi/scsi_cmnd.h>
38 #include <scsi/scsi_devinfo.h>
39 #include <scsi/scsi_device.h>
40 #include <scsi/scsi_eh.h>
41 
42 #include "usb.h"
43 #include <linux/usb/hcd.h>
44 #include "scsiglue.h"
45 #include "debug.h"
46 #include "transport.h"
47 #include "protocol.h"
48 
49 /*
50  * Vendor IDs for companies that seem to include the READ CAPACITY bug
51  * in all their devices
52  */
53 #define VENDOR_ID_NOKIA		0x0421
54 #define VENDOR_ID_NIKON		0x04b0
55 #define VENDOR_ID_PENTAX	0x0a17
56 #define VENDOR_ID_MOTOROLA	0x22b8
57 
58 /***********************************************************************
59  * Host functions
60  ***********************************************************************/
61 
host_info(struct Scsi_Host * host)62 static const char* host_info(struct Scsi_Host *host)
63 {
64 	struct us_data *us = host_to_us(host);
65 	return us->scsi_name;
66 }
67 
slave_alloc(struct scsi_device * sdev)68 static int slave_alloc (struct scsi_device *sdev)
69 {
70 	struct us_data *us = host_to_us(sdev->host);
71 
72 	/*
73 	 * Set the INQUIRY transfer length to 36.  We don't use any of
74 	 * the extra data and many devices choke if asked for more or
75 	 * less than 36 bytes.
76 	 */
77 	sdev->inquiry_len = 36;
78 
79 	/*
80 	 * Some host controllers may have alignment requirements.
81 	 * We'll play it safe by requiring 512-byte alignment always.
82 	 */
83 	blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
84 
85 	/* Tell the SCSI layer if we know there is more than one LUN */
86 	if (us->protocol == USB_PR_BULK && us->max_lun > 0)
87 		sdev->sdev_bflags |= BLIST_FORCELUN;
88 
89 	return 0;
90 }
91 
slave_configure(struct scsi_device * sdev)92 static int slave_configure(struct scsi_device *sdev)
93 {
94 	struct us_data *us = host_to_us(sdev->host);
95 	struct device *dev = us->pusb_dev->bus->sysdev;
96 
97 	/*
98 	 * Many devices have trouble transferring more than 32KB at a time,
99 	 * while others have trouble with more than 64K. At this time we
100 	 * are limiting both to 32K (64 sectores).
101 	 */
102 	if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
103 		unsigned int max_sectors = 64;
104 
105 		if (us->fflags & US_FL_MAX_SECTORS_MIN)
106 			max_sectors = PAGE_SIZE >> 9;
107 		if (queue_max_hw_sectors(sdev->request_queue) > max_sectors)
108 			blk_queue_max_hw_sectors(sdev->request_queue,
109 					      max_sectors);
110 	} else if (sdev->type == TYPE_TAPE) {
111 		/*
112 		 * Tapes need much higher max_sector limits, so just
113 		 * raise it to the maximum possible (4 GB / 512) and
114 		 * let the queue segment size sort out the real limit.
115 		 */
116 		blk_queue_max_hw_sectors(sdev->request_queue, 0x7FFFFF);
117 	} else if (us->pusb_dev->speed >= USB_SPEED_SUPER) {
118 		/*
119 		 * USB3 devices will be limited to 2048 sectors. This gives us
120 		 * better throughput on most devices.
121 		 */
122 		blk_queue_max_hw_sectors(sdev->request_queue, 2048);
123 	}
124 
125 	/*
126 	 * The max_hw_sectors should be up to maximum size of a mapping for
127 	 * the device. Otherwise, a DMA API might fail on swiotlb environment.
128 	 */
129 	blk_queue_max_hw_sectors(sdev->request_queue,
130 		min_t(size_t, queue_max_hw_sectors(sdev->request_queue),
131 		      dma_max_mapping_size(dev) >> SECTOR_SHIFT));
132 
133 	/*
134 	 * Some USB host controllers can't do DMA; they have to use PIO.
135 	 * For such controllers we need to make sure the block layer sets
136 	 * up bounce buffers in addressable memory.
137 	 */
138 	if (!hcd_uses_dma(bus_to_hcd(us->pusb_dev->bus)) ||
139 			(bus_to_hcd(us->pusb_dev->bus)->localmem_pool != NULL))
140 		blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_HIGH);
141 
142 	/*
143 	 * We can't put these settings in slave_alloc() because that gets
144 	 * called before the device type is known.  Consequently these
145 	 * settings can't be overridden via the scsi devinfo mechanism.
146 	 */
147 	if (sdev->type == TYPE_DISK) {
148 
149 		/*
150 		 * Some vendors seem to put the READ CAPACITY bug into
151 		 * all their devices -- primarily makers of cell phones
152 		 * and digital cameras.  Since these devices always use
153 		 * flash media and can be expected to have an even number
154 		 * of sectors, we will always enable the CAPACITY_HEURISTICS
155 		 * flag unless told otherwise.
156 		 */
157 		switch (le16_to_cpu(us->pusb_dev->descriptor.idVendor)) {
158 		case VENDOR_ID_NOKIA:
159 		case VENDOR_ID_NIKON:
160 		case VENDOR_ID_PENTAX:
161 		case VENDOR_ID_MOTOROLA:
162 			if (!(us->fflags & (US_FL_FIX_CAPACITY |
163 					US_FL_CAPACITY_OK)))
164 				us->fflags |= US_FL_CAPACITY_HEURISTICS;
165 			break;
166 		}
167 
168 		/*
169 		 * Disk-type devices use MODE SENSE(6) if the protocol
170 		 * (SubClass) is Transparent SCSI, otherwise they use
171 		 * MODE SENSE(10).
172 		 */
173 		if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB)
174 			sdev->use_10_for_ms = 1;
175 
176 		/*
177 		 *Many disks only accept MODE SENSE transfer lengths of
178 		 * 192 bytes (that's what Windows uses).
179 		 */
180 		sdev->use_192_bytes_for_3f = 1;
181 
182 		/*
183 		 * Some devices report generic values until the media has been
184 		 * accessed. Force a READ(10) prior to querying device
185 		 * characteristics.
186 		 */
187 		sdev->read_before_ms = 1;
188 
189 		/*
190 		 * Some devices don't like MODE SENSE with page=0x3f,
191 		 * which is the command used for checking if a device
192 		 * is write-protected.  Now that we tell the sd driver
193 		 * to do a 192-byte transfer with this command the
194 		 * majority of devices work fine, but a few still can't
195 		 * handle it.  The sd driver will simply assume those
196 		 * devices are write-enabled.
197 		 */
198 		if (us->fflags & US_FL_NO_WP_DETECT)
199 			sdev->skip_ms_page_3f = 1;
200 
201 		/*
202 		 * A number of devices have problems with MODE SENSE for
203 		 * page x08, so we will skip it.
204 		 */
205 		sdev->skip_ms_page_8 = 1;
206 
207 		/*
208 		 * Some devices don't handle VPD pages correctly, so skip vpd
209 		 * pages if not forced by SCSI layer.
210 		 */
211 		sdev->skip_vpd_pages = !sdev->try_vpd_pages;
212 
213 		/* Do not attempt to use REPORT SUPPORTED OPERATION CODES */
214 		sdev->no_report_opcodes = 1;
215 
216 		/* Do not attempt to use WRITE SAME */
217 		sdev->no_write_same = 1;
218 
219 		/*
220 		 * Some disks return the total number of blocks in response
221 		 * to READ CAPACITY rather than the highest block number.
222 		 * If this device makes that mistake, tell the sd driver.
223 		 */
224 		if (us->fflags & US_FL_FIX_CAPACITY)
225 			sdev->fix_capacity = 1;
226 
227 		/*
228 		 * A few disks have two indistinguishable version, one of
229 		 * which reports the correct capacity and the other does not.
230 		 * The sd driver has to guess which is the case.
231 		 */
232 		if (us->fflags & US_FL_CAPACITY_HEURISTICS)
233 			sdev->guess_capacity = 1;
234 
235 		/* Some devices cannot handle READ_CAPACITY_16 */
236 		if (us->fflags & US_FL_NO_READ_CAPACITY_16)
237 			sdev->no_read_capacity_16 = 1;
238 
239 		/*
240 		 * Many devices do not respond properly to READ_CAPACITY_16.
241 		 * Tell the SCSI layer to try READ_CAPACITY_10 first.
242 		 * However some USB 3.0 drive enclosures return capacity
243 		 * modulo 2TB. Those must use READ_CAPACITY_16
244 		 */
245 		if (!(us->fflags & US_FL_NEEDS_CAP16))
246 			sdev->try_rc_10_first = 1;
247 
248 		/*
249 		 * assume SPC3 or latter devices support sense size > 18
250 		 * unless US_FL_BAD_SENSE quirk is specified.
251 		 */
252 		if (sdev->scsi_level > SCSI_SPC_2 &&
253 		    !(us->fflags & US_FL_BAD_SENSE))
254 			us->fflags |= US_FL_SANE_SENSE;
255 
256 		/*
257 		 * USB-IDE bridges tend to report SK = 0x04 (Non-recoverable
258 		 * Hardware Error) when any low-level error occurs,
259 		 * recoverable or not.  Setting this flag tells the SCSI
260 		 * midlayer to retry such commands, which frequently will
261 		 * succeed and fix the error.  The worst this can lead to
262 		 * is an occasional series of retries that will all fail.
263 		 */
264 		sdev->retry_hwerror = 1;
265 
266 		/*
267 		 * USB disks should allow restart.  Some drives spin down
268 		 * automatically, requiring a START-STOP UNIT command.
269 		 */
270 		sdev->allow_restart = 1;
271 
272 		/*
273 		 * Some USB cardreaders have trouble reading an sdcard's last
274 		 * sector in a larger then 1 sector read, since the performance
275 		 * impact is negligible we set this flag for all USB disks
276 		 */
277 		sdev->last_sector_bug = 1;
278 
279 		/*
280 		 * Enable last-sector hacks for single-target devices using
281 		 * the Bulk-only transport, unless we already know the
282 		 * capacity will be decremented or is correct.
283 		 */
284 		if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
285 					US_FL_SCM_MULT_TARG)) &&
286 				us->protocol == USB_PR_BULK)
287 			us->use_last_sector_hacks = 1;
288 
289 		/* Check if write cache default on flag is set or not */
290 		if (us->fflags & US_FL_WRITE_CACHE)
291 			sdev->wce_default_on = 1;
292 
293 		/* A few buggy USB-ATA bridges don't understand FUA */
294 		if (us->fflags & US_FL_BROKEN_FUA)
295 			sdev->broken_fua = 1;
296 
297 		/* Some even totally fail to indicate a cache */
298 		if (us->fflags & US_FL_ALWAYS_SYNC) {
299 			/* don't read caching information */
300 			sdev->skip_ms_page_8 = 1;
301 			sdev->skip_ms_page_3f = 1;
302 			/* assume sync is needed */
303 			sdev->wce_default_on = 1;
304 		}
305 	} else {
306 
307 		/*
308 		 * Non-disk-type devices don't need to ignore any pages
309 		 * or to force 192-byte transfer lengths for MODE SENSE.
310 		 * But they do need to use MODE SENSE(10).
311 		 */
312 		sdev->use_10_for_ms = 1;
313 
314 		/* Some (fake) usb cdrom devices don't like READ_DISC_INFO */
315 		if (us->fflags & US_FL_NO_READ_DISC_INFO)
316 			sdev->no_read_disc_info = 1;
317 	}
318 
319 	/*
320 	 * The CB and CBI transports have no way to pass LUN values
321 	 * other than the bits in the second byte of a CDB.  But those
322 	 * bits don't get set to the LUN value if the device reports
323 	 * scsi_level == 0 (UNKNOWN).  Hence such devices must necessarily
324 	 * be single-LUN.
325 	 */
326 	if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) &&
327 			sdev->scsi_level == SCSI_UNKNOWN)
328 		us->max_lun = 0;
329 
330 	/*
331 	 * Some devices choke when they receive a PREVENT-ALLOW MEDIUM
332 	 * REMOVAL command, so suppress those commands.
333 	 */
334 	if (us->fflags & US_FL_NOT_LOCKABLE)
335 		sdev->lockable = 0;
336 
337 	/*
338 	 * this is to satisfy the compiler, tho I don't think the
339 	 * return code is ever checked anywhere.
340 	 */
341 	return 0;
342 }
343 
target_alloc(struct scsi_target * starget)344 static int target_alloc(struct scsi_target *starget)
345 {
346 	struct us_data *us = host_to_us(dev_to_shost(starget->dev.parent));
347 
348 	/*
349 	 * Some USB drives don't support REPORT LUNS, even though they
350 	 * report a SCSI revision level above 2.  Tell the SCSI layer
351 	 * not to issue that command; it will perform a normal sequential
352 	 * scan instead.
353 	 */
354 	starget->no_report_luns = 1;
355 
356 	/*
357 	 * The UFI spec treats the Peripheral Qualifier bits in an
358 	 * INQUIRY result as reserved and requires devices to set them
359 	 * to 0.  However the SCSI spec requires these bits to be set
360 	 * to 3 to indicate when a LUN is not present.
361 	 *
362 	 * Let the scanning code know if this target merely sets
363 	 * Peripheral Device Type to 0x1f to indicate no LUN.
364 	 */
365 	if (us->subclass == USB_SC_UFI)
366 		starget->pdt_1f_for_no_lun = 1;
367 
368 	return 0;
369 }
370 
371 /* queue a command */
372 /* This is always called with scsi_lock(host) held */
queuecommand_lck(struct scsi_cmnd * srb)373 static int queuecommand_lck(struct scsi_cmnd *srb)
374 {
375 	void (*done)(struct scsi_cmnd *) = scsi_done;
376 	struct us_data *us = host_to_us(srb->device->host);
377 
378 	/* check for state-transition errors */
379 	if (us->srb != NULL) {
380 		dev_err(&us->pusb_intf->dev,
381 			"Error in %s: us->srb = %p\n", __func__, us->srb);
382 		return SCSI_MLQUEUE_HOST_BUSY;
383 	}
384 
385 	/* fail the command if we are disconnecting */
386 	if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
387 		usb_stor_dbg(us, "Fail command during disconnect\n");
388 		srb->result = DID_NO_CONNECT << 16;
389 		done(srb);
390 		return 0;
391 	}
392 
393 	if ((us->fflags & US_FL_NO_ATA_1X) &&
394 			(srb->cmnd[0] == ATA_12 || srb->cmnd[0] == ATA_16)) {
395 		memcpy(srb->sense_buffer, usb_stor_sense_invalidCDB,
396 		       sizeof(usb_stor_sense_invalidCDB));
397 		srb->result = SAM_STAT_CHECK_CONDITION;
398 		done(srb);
399 		return 0;
400 	}
401 
402 	/* enqueue the command and wake up the control thread */
403 	us->srb = srb;
404 	complete(&us->cmnd_ready);
405 
406 	return 0;
407 }
408 
DEF_SCSI_QCMD(queuecommand)409 static DEF_SCSI_QCMD(queuecommand)
410 
411 /***********************************************************************
412  * Error handling functions
413  ***********************************************************************/
414 
415 /* Command timeout and abort */
416 static int command_abort_matching(struct us_data *us, struct scsi_cmnd *srb_match)
417 {
418 	/*
419 	 * us->srb together with the TIMED_OUT, RESETTING, and ABORTING
420 	 * bits are protected by the host lock.
421 	 */
422 	scsi_lock(us_to_host(us));
423 
424 	/* is there any active pending command to abort ? */
425 	if (!us->srb) {
426 		scsi_unlock(us_to_host(us));
427 		usb_stor_dbg(us, "-- nothing to abort\n");
428 		return SUCCESS;
429 	}
430 
431 	/* Does the command match the passed srb if any ? */
432 	if (srb_match && us->srb != srb_match) {
433 		scsi_unlock(us_to_host(us));
434 		usb_stor_dbg(us, "-- pending command mismatch\n");
435 		return FAILED;
436 	}
437 
438 	/*
439 	 * Set the TIMED_OUT bit.  Also set the ABORTING bit, but only if
440 	 * a device reset isn't already in progress (to avoid interfering
441 	 * with the reset).  Note that we must retain the host lock while
442 	 * calling usb_stor_stop_transport(); otherwise it might interfere
443 	 * with an auto-reset that begins as soon as we release the lock.
444 	 */
445 	set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
446 	if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
447 		set_bit(US_FLIDX_ABORTING, &us->dflags);
448 		usb_stor_stop_transport(us);
449 	}
450 	scsi_unlock(us_to_host(us));
451 
452 	/* Wait for the aborted command to finish */
453 	wait_for_completion(&us->notify);
454 	return SUCCESS;
455 }
456 
command_abort(struct scsi_cmnd * srb)457 static int command_abort(struct scsi_cmnd *srb)
458 {
459 	struct us_data *us = host_to_us(srb->device->host);
460 
461 	usb_stor_dbg(us, "%s called\n", __func__);
462 	return command_abort_matching(us, srb);
463 }
464 
465 /*
466  * This invokes the transport reset mechanism to reset the state of the
467  * device
468  */
device_reset(struct scsi_cmnd * srb)469 static int device_reset(struct scsi_cmnd *srb)
470 {
471 	struct us_data *us = host_to_us(srb->device->host);
472 	int result;
473 
474 	usb_stor_dbg(us, "%s called\n", __func__);
475 
476 	/* abort any pending command before reset */
477 	command_abort_matching(us, NULL);
478 
479 	/* lock the device pointers and do the reset */
480 	mutex_lock(&(us->dev_mutex));
481 	result = us->transport_reset(us);
482 	mutex_unlock(&us->dev_mutex);
483 
484 	return result < 0 ? FAILED : SUCCESS;
485 }
486 
487 /* Simulate a SCSI bus reset by resetting the device's USB port. */
bus_reset(struct scsi_cmnd * srb)488 static int bus_reset(struct scsi_cmnd *srb)
489 {
490 	struct us_data *us = host_to_us(srb->device->host);
491 	int result;
492 
493 	usb_stor_dbg(us, "%s called\n", __func__);
494 
495 	result = usb_stor_port_reset(us);
496 	return result < 0 ? FAILED : SUCCESS;
497 }
498 
499 /*
500  * Report a driver-initiated device reset to the SCSI layer.
501  * Calling this for a SCSI-initiated reset is unnecessary but harmless.
502  * The caller must own the SCSI host lock.
503  */
usb_stor_report_device_reset(struct us_data * us)504 void usb_stor_report_device_reset(struct us_data *us)
505 {
506 	int i;
507 	struct Scsi_Host *host = us_to_host(us);
508 
509 	scsi_report_device_reset(host, 0, 0);
510 	if (us->fflags & US_FL_SCM_MULT_TARG) {
511 		for (i = 1; i < host->max_id; ++i)
512 			scsi_report_device_reset(host, 0, i);
513 	}
514 }
515 
516 /*
517  * Report a driver-initiated bus reset to the SCSI layer.
518  * Calling this for a SCSI-initiated reset is unnecessary but harmless.
519  * The caller must not own the SCSI host lock.
520  */
usb_stor_report_bus_reset(struct us_data * us)521 void usb_stor_report_bus_reset(struct us_data *us)
522 {
523 	struct Scsi_Host *host = us_to_host(us);
524 
525 	scsi_lock(host);
526 	scsi_report_bus_reset(host, 0);
527 	scsi_unlock(host);
528 }
529 
530 /***********************************************************************
531  * /proc/scsi/ functions
532  ***********************************************************************/
533 
write_info(struct Scsi_Host * host,char * buffer,int length)534 static int write_info(struct Scsi_Host *host, char *buffer, int length)
535 {
536 	/* if someone is sending us data, just throw it away */
537 	return length;
538 }
539 
show_info(struct seq_file * m,struct Scsi_Host * host)540 static int show_info (struct seq_file *m, struct Scsi_Host *host)
541 {
542 	struct us_data *us = host_to_us(host);
543 	const char *string;
544 
545 	/* print the controller name */
546 	seq_printf(m, "   Host scsi%d: usb-storage\n", host->host_no);
547 
548 	/* print product, vendor, and serial number strings */
549 	if (us->pusb_dev->manufacturer)
550 		string = us->pusb_dev->manufacturer;
551 	else if (us->unusual_dev->vendorName)
552 		string = us->unusual_dev->vendorName;
553 	else
554 		string = "Unknown";
555 	seq_printf(m, "       Vendor: %s\n", string);
556 	if (us->pusb_dev->product)
557 		string = us->pusb_dev->product;
558 	else if (us->unusual_dev->productName)
559 		string = us->unusual_dev->productName;
560 	else
561 		string = "Unknown";
562 	seq_printf(m, "      Product: %s\n", string);
563 	if (us->pusb_dev->serial)
564 		string = us->pusb_dev->serial;
565 	else
566 		string = "None";
567 	seq_printf(m, "Serial Number: %s\n", string);
568 
569 	/* show the protocol and transport */
570 	seq_printf(m, "     Protocol: %s\n", us->protocol_name);
571 	seq_printf(m, "    Transport: %s\n", us->transport_name);
572 
573 	/* show the device flags */
574 	seq_printf(m, "       Quirks:");
575 
576 #define US_FLAG(name, value) \
577 	if (us->fflags & value) seq_printf(m, " " #name);
578 US_DO_ALL_FLAGS
579 #undef US_FLAG
580 	seq_putc(m, '\n');
581 	return 0;
582 }
583 
584 /***********************************************************************
585  * Sysfs interface
586  ***********************************************************************/
587 
588 /* Output routine for the sysfs max_sectors file */
max_sectors_show(struct device * dev,struct device_attribute * attr,char * buf)589 static ssize_t max_sectors_show(struct device *dev, struct device_attribute *attr, char *buf)
590 {
591 	struct scsi_device *sdev = to_scsi_device(dev);
592 
593 	return sprintf(buf, "%u\n", queue_max_hw_sectors(sdev->request_queue));
594 }
595 
596 /* Input routine for the sysfs max_sectors file */
max_sectors_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)597 static ssize_t max_sectors_store(struct device *dev, struct device_attribute *attr, const char *buf,
598 		size_t count)
599 {
600 	struct scsi_device *sdev = to_scsi_device(dev);
601 	unsigned short ms;
602 
603 	if (sscanf(buf, "%hu", &ms) > 0) {
604 		blk_queue_max_hw_sectors(sdev->request_queue, ms);
605 		return count;
606 	}
607 	return -EINVAL;
608 }
609 static DEVICE_ATTR_RW(max_sectors);
610 
611 static struct attribute *usb_sdev_attrs[] = {
612 	&dev_attr_max_sectors.attr,
613 	NULL,
614 };
615 
616 ATTRIBUTE_GROUPS(usb_sdev);
617 
618 /*
619  * this defines our host template, with which we'll allocate hosts
620  */
621 
622 static const struct scsi_host_template usb_stor_host_template = {
623 	/* basic userland interface stuff */
624 	.name =				"usb-storage",
625 	.proc_name =			"usb-storage",
626 	.show_info =			show_info,
627 	.write_info =			write_info,
628 	.info =				host_info,
629 
630 	/* command interface -- queued only */
631 	.queuecommand =			queuecommand,
632 
633 	/* error and abort handlers */
634 	.eh_abort_handler =		command_abort,
635 	.eh_device_reset_handler =	device_reset,
636 	.eh_bus_reset_handler =		bus_reset,
637 
638 	/* queue commands only, only one command per LUN */
639 	.can_queue =			1,
640 
641 	/* unknown initiator id */
642 	.this_id =			-1,
643 
644 	.slave_alloc =			slave_alloc,
645 	.slave_configure =		slave_configure,
646 	.target_alloc =			target_alloc,
647 
648 	/* lots of sg segments can be handled */
649 	.sg_tablesize =			SG_MAX_SEGMENTS,
650 
651 
652 	/*
653 	 * Limit the total size of a transfer to 120 KB.
654 	 *
655 	 * Some devices are known to choke with anything larger. It seems like
656 	 * the problem stems from the fact that original IDE controllers had
657 	 * only an 8-bit register to hold the number of sectors in one transfer
658 	 * and even those couldn't handle a full 256 sectors.
659 	 *
660 	 * Because we want to make sure we interoperate with as many devices as
661 	 * possible, we will maintain a 240 sector transfer size limit for USB
662 	 * Mass Storage devices.
663 	 *
664 	 * Tests show that other operating have similar limits with Microsoft
665 	 * Windows 7 limiting transfers to 128 sectors for both USB2 and USB3
666 	 * and Apple Mac OS X 10.11 limiting transfers to 256 sectors for USB2
667 	 * and 2048 for USB3 devices.
668 	 */
669 	.max_sectors =                  240,
670 
671 	/* emulated HBA */
672 	.emulated =			1,
673 
674 	/* we do our own delay after a device or bus reset */
675 	.skip_settle_delay =		1,
676 
677 	/* sysfs device attributes */
678 	.sdev_groups =			usb_sdev_groups,
679 
680 	/* module management */
681 	.module =			THIS_MODULE
682 };
683 
usb_stor_host_template_init(struct scsi_host_template * sht,const char * name,struct module * owner)684 void usb_stor_host_template_init(struct scsi_host_template *sht,
685 				 const char *name, struct module *owner)
686 {
687 	*sht = usb_stor_host_template;
688 	sht->name = name;
689 	sht->proc_name = name;
690 	sht->module = owner;
691 }
692 EXPORT_SYMBOL_GPL(usb_stor_host_template_init);
693 
694 /* To Report "Illegal Request: Invalid Field in CDB */
695 unsigned char usb_stor_sense_invalidCDB[18] = {
696 	[0]	= 0x70,			    /* current error */
697 	[2]	= ILLEGAL_REQUEST,	    /* Illegal Request = 0x05 */
698 	[7]	= 0x0a,			    /* additional length */
699 	[12]	= 0x24			    /* Invalid Field in CDB */
700 };
701 EXPORT_SYMBOL_GPL(usb_stor_sense_invalidCDB);
702