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