1 /* Driver for USB Mass Storage compliant devices
4 * Current development and maintenance by:
5 * (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
7 * Developed with the assistance of:
8 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
9 * (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
12 * (c) 1999 Michael Gee (michael@linuxspecific.com)
14 * This driver is based on the 'USB Mass Storage Class' document. This
15 * describes in detail the protocol used to communicate with such
16 * devices. Clearly, the designers had SCSI and ATAPI commands in
17 * mind when they created this document. The commands are all very
18 * similar to commands in the SCSI-II and ATAPI specifications.
20 * It is important to note that in a number of cases this class
21 * exhibits class-specific exemptions from the USB specification.
22 * Notably the usage of NAK, STALL and ACK differs from the norm, in
23 * that they are used to communicate wait, failed and OK on commands.
25 * Also, for certain devices, the interrupt endpoint is used to convey
26 * status of a command.
28 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
29 * information about this driver.
31 * This program is free software; you can redistribute it and/or modify it
32 * under the terms of the GNU General Public License as published by the
33 * Free Software Foundation; either version 2, or (at your option) any
36 * This program is distributed in the hope that it will be useful, but
37 * WITHOUT ANY WARRANTY; without even the implied warranty of
38 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
39 * General Public License for more details.
41 * You should have received a copy of the GNU General Public License along
42 * with this program; if not, write to the Free Software Foundation, Inc.,
43 * 675 Mass Ave, Cambridge, MA 02139, USA.
46 #include <linux/slab.h>
47 #include <linux/module.h>
48 #include <linux/mutex.h>
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>
59 #include "transport.h"
62 /* Vendor IDs for companies that seem to include the READ CAPACITY bug
63 * in all their devices
65 #define VENDOR_ID_NOKIA 0x0421
66 #define VENDOR_ID_NIKON 0x04b0
67 #define VENDOR_ID_PENTAX 0x0a17
68 #define VENDOR_ID_MOTOROLA 0x22b8
70 /***********************************************************************
72 ***********************************************************************/
74 static const char* host_info(struct Scsi_Host *host)
76 return "SCSI emulation for USB Mass Storage devices";
79 static int slave_alloc (struct scsi_device *sdev)
81 struct us_data *us = host_to_us(sdev->host);
84 * Set the INQUIRY transfer length to 36. We don't use any of
85 * the extra data and many devices choke if asked for more or
88 sdev->inquiry_len = 36;
90 /* USB has unusual DMA-alignment requirements: Although the
91 * starting address of each scatter-gather element doesn't matter,
92 * the length of each element except the last must be divisible
93 * by the Bulk maxpacket value. There's currently no way to
94 * express this by block-layer constraints, so we'll cop out
95 * and simply require addresses to be aligned at 512-byte
96 * boundaries. This is okay since most block I/O involves
97 * hardware sectors that are multiples of 512 bytes in length,
98 * and since host controllers up through USB 2.0 have maxpacket
99 * values no larger than 512.
101 * But it doesn't suffice for Wireless USB, where Bulk maxpacket
102 * values can be as large as 2048. To make that work properly
103 * will require changes to the block layer.
105 blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
108 * The UFI spec treates the Peripheral Qualifier bits in an
109 * INQUIRY result as reserved and requires devices to set them
110 * to 0. However the SCSI spec requires these bits to be set
111 * to 3 to indicate when a LUN is not present.
113 * Let the scanning code know if this target merely sets
114 * Peripheral Device Type to 0x1f to indicate no LUN.
116 if (us->subclass == US_SC_UFI)
117 sdev->sdev_target->pdt_1f_for_no_lun = 1;
122 static int slave_configure(struct scsi_device *sdev)
124 struct us_data *us = host_to_us(sdev->host);
126 /* Many devices have trouble transfering more than 32KB at a time,
127 * while others have trouble with more than 64K. At this time we
128 * are limiting both to 32K (64 sectores).
130 if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
131 unsigned int max_sectors = 64;
133 if (us->fflags & US_FL_MAX_SECTORS_MIN)
134 max_sectors = PAGE_CACHE_SIZE >> 9;
135 if (sdev->request_queue->max_sectors > max_sectors)
136 blk_queue_max_sectors(sdev->request_queue,
138 } else if (sdev->type == TYPE_TAPE) {
139 /* Tapes need much higher max_sector limits, so just
140 * raise it to the maximum possible (4 GB / 512) and
141 * let the queue segment size sort out the real limit.
143 blk_queue_max_sectors(sdev->request_queue, 0x7FFFFF);
146 /* We can't put these settings in slave_alloc() because that gets
147 * called before the device type is known. Consequently these
148 * settings can't be overridden via the scsi devinfo mechanism. */
149 if (sdev->type == TYPE_DISK) {
151 /* Some vendors seem to put the READ CAPACITY bug into
152 * all their devices -- primarily makers of cell phones
153 * and digital cameras. Since these devices always use
154 * flash media and can be expected to have an even number
155 * of sectors, we will always enable the CAPACITY_HEURISTICS
156 * flag unless told otherwise. */
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 |
164 us->fflags |= US_FL_CAPACITY_HEURISTICS;
168 /* Disk-type devices use MODE SENSE(6) if the protocol
169 * (SubClass) is Transparent SCSI, otherwise they use
171 if (us->subclass != US_SC_SCSI && us->subclass != US_SC_CYP_ATACB)
172 sdev->use_10_for_ms = 1;
174 /* Many disks only accept MODE SENSE transfer lengths of
175 * 192 bytes (that's what Windows uses). */
176 sdev->use_192_bytes_for_3f = 1;
178 /* Some devices don't like MODE SENSE with page=0x3f,
179 * which is the command used for checking if a device
180 * is write-protected. Now that we tell the sd driver
181 * to do a 192-byte transfer with this command the
182 * majority of devices work fine, but a few still can't
183 * handle it. The sd driver will simply assume those
184 * devices are write-enabled. */
185 if (us->fflags & US_FL_NO_WP_DETECT)
186 sdev->skip_ms_page_3f = 1;
188 /* A number of devices have problems with MODE SENSE for
189 * page x08, so we will skip it. */
190 sdev->skip_ms_page_8 = 1;
192 /* Some disks return the total number of blocks in response
193 * to READ CAPACITY rather than the highest block number.
194 * If this device makes that mistake, tell the sd driver. */
195 if (us->fflags & US_FL_FIX_CAPACITY)
196 sdev->fix_capacity = 1;
198 /* A few disks have two indistinguishable version, one of
199 * which reports the correct capacity and the other does not.
200 * The sd driver has to guess which is the case. */
201 if (us->fflags & US_FL_CAPACITY_HEURISTICS)
202 sdev->guess_capacity = 1;
204 /* Some devices report a SCSI revision level above 2 but are
205 * unable to handle the REPORT LUNS command (for which
206 * support is mandatory at level 3). Since we already have
207 * a Get-Max-LUN request, we won't lose much by setting the
208 * revision level down to 2. The only devices that would be
209 * affected are those with sparse LUNs. */
210 if (sdev->scsi_level > SCSI_2)
211 sdev->sdev_target->scsi_level =
212 sdev->scsi_level = SCSI_2;
214 /* USB-IDE bridges tend to report SK = 0x04 (Non-recoverable
215 * Hardware Error) when any low-level error occurs,
216 * recoverable or not. Setting this flag tells the SCSI
217 * midlayer to retry such commands, which frequently will
218 * succeed and fix the error. The worst this can lead to
219 * is an occasional series of retries that will all fail. */
220 sdev->retry_hwerror = 1;
222 /* USB disks should allow restart. Some drives spin down
223 * automatically, requiring a START-STOP UNIT command. */
224 sdev->allow_restart = 1;
226 /* Some USB cardreaders have trouble reading an sdcard's last
227 * sector in a larger then 1 sector read, since the performance
228 * impact is negible we set this flag for all USB disks */
229 sdev->last_sector_bug = 1;
231 /* Enable last-sector hacks for single-target devices using
232 * the Bulk-only transport, unless we already know the
233 * capacity will be decremented or is correct. */
234 if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
235 US_FL_SCM_MULT_TARG)) &&
236 us->protocol == US_PR_BULK)
237 us->use_last_sector_hacks = 1;
240 /* Non-disk-type devices don't need to blacklist any pages
241 * or to force 192-byte transfer lengths for MODE SENSE.
242 * But they do need to use MODE SENSE(10). */
243 sdev->use_10_for_ms = 1;
246 /* The CB and CBI transports have no way to pass LUN values
247 * other than the bits in the second byte of a CDB. But those
248 * bits don't get set to the LUN value if the device reports
249 * scsi_level == 0 (UNKNOWN). Hence such devices must necessarily
252 if ((us->protocol == US_PR_CB || us->protocol == US_PR_CBI) &&
253 sdev->scsi_level == SCSI_UNKNOWN)
256 /* Some devices choke when they receive a PREVENT-ALLOW MEDIUM
257 * REMOVAL command, so suppress those commands. */
258 if (us->fflags & US_FL_NOT_LOCKABLE)
261 /* this is to satisfy the compiler, tho I don't think the
262 * return code is ever checked anywhere. */
266 /* queue a command */
267 /* This is always called with scsi_lock(host) held */
268 static int queuecommand(struct scsi_cmnd *srb,
269 void (*done)(struct scsi_cmnd *))
271 struct us_data *us = host_to_us(srb->device->host);
273 US_DEBUGP("%s called\n", __func__);
275 /* check for state-transition errors */
276 if (us->srb != NULL) {
277 printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
279 return SCSI_MLQUEUE_HOST_BUSY;
282 /* fail the command if we are disconnecting */
283 if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
284 US_DEBUGP("Fail command during disconnect\n");
285 srb->result = DID_NO_CONNECT << 16;
290 /* enqueue the command and wake up the control thread */
291 srb->scsi_done = done;
293 complete(&us->cmnd_ready);
298 /***********************************************************************
299 * Error handling functions
300 ***********************************************************************/
302 /* Command timeout and abort */
303 static int command_abort(struct scsi_cmnd *srb)
305 struct us_data *us = host_to_us(srb->device->host);
307 US_DEBUGP("%s called\n", __func__);
309 /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
310 * bits are protected by the host lock. */
311 scsi_lock(us_to_host(us));
313 /* Is this command still active? */
314 if (us->srb != srb) {
315 scsi_unlock(us_to_host(us));
316 US_DEBUGP ("-- nothing to abort\n");
320 /* Set the TIMED_OUT bit. Also set the ABORTING bit, but only if
321 * a device reset isn't already in progress (to avoid interfering
322 * with the reset). Note that we must retain the host lock while
323 * calling usb_stor_stop_transport(); otherwise it might interfere
324 * with an auto-reset that begins as soon as we release the lock. */
325 set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
326 if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
327 set_bit(US_FLIDX_ABORTING, &us->dflags);
328 usb_stor_stop_transport(us);
330 scsi_unlock(us_to_host(us));
332 /* Wait for the aborted command to finish */
333 wait_for_completion(&us->notify);
337 /* This invokes the transport reset mechanism to reset the state of the
339 static int device_reset(struct scsi_cmnd *srb)
341 struct us_data *us = host_to_us(srb->device->host);
344 US_DEBUGP("%s called\n", __func__);
346 /* lock the device pointers and do the reset */
347 mutex_lock(&(us->dev_mutex));
348 result = us->transport_reset(us);
349 mutex_unlock(&us->dev_mutex);
351 return result < 0 ? FAILED : SUCCESS;
354 /* Simulate a SCSI bus reset by resetting the device's USB port. */
355 static int bus_reset(struct scsi_cmnd *srb)
357 struct us_data *us = host_to_us(srb->device->host);
360 US_DEBUGP("%s called\n", __func__);
361 result = usb_stor_port_reset(us);
362 return result < 0 ? FAILED : SUCCESS;
365 /* Report a driver-initiated device reset to the SCSI layer.
366 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
367 * The caller must own the SCSI host lock. */
368 void usb_stor_report_device_reset(struct us_data *us)
371 struct Scsi_Host *host = us_to_host(us);
373 scsi_report_device_reset(host, 0, 0);
374 if (us->fflags & US_FL_SCM_MULT_TARG) {
375 for (i = 1; i < host->max_id; ++i)
376 scsi_report_device_reset(host, 0, i);
380 /* Report a driver-initiated bus reset to the SCSI layer.
381 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
382 * The caller must not own the SCSI host lock. */
383 void usb_stor_report_bus_reset(struct us_data *us)
385 struct Scsi_Host *host = us_to_host(us);
388 scsi_report_bus_reset(host, 0);
392 /***********************************************************************
393 * /proc/scsi/ functions
394 ***********************************************************************/
396 /* we use this macro to help us write into the buffer */
398 #define SPRINTF(args...) \
399 do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
401 static int proc_info (struct Scsi_Host *host, char *buffer,
402 char **start, off_t offset, int length, int inout)
404 struct us_data *us = host_to_us(host);
408 /* if someone is sending us data, just throw it away */
412 /* print the controller name */
413 SPRINTF(" Host scsi%d: usb-storage\n", host->host_no);
415 /* print product, vendor, and serial number strings */
416 if (us->pusb_dev->manufacturer)
417 string = us->pusb_dev->manufacturer;
418 else if (us->unusual_dev->vendorName)
419 string = us->unusual_dev->vendorName;
422 SPRINTF(" Vendor: %s\n", string);
423 if (us->pusb_dev->product)
424 string = us->pusb_dev->product;
425 else if (us->unusual_dev->productName)
426 string = us->unusual_dev->productName;
429 SPRINTF(" Product: %s\n", string);
430 if (us->pusb_dev->serial)
431 string = us->pusb_dev->serial;
434 SPRINTF("Serial Number: %s\n", string);
436 /* show the protocol and transport */
437 SPRINTF(" Protocol: %s\n", us->protocol_name);
438 SPRINTF(" Transport: %s\n", us->transport_name);
440 /* show the device flags */
441 if (pos < buffer + length) {
442 pos += sprintf(pos, " Quirks:");
444 #define US_FLAG(name, value) \
445 if (us->fflags & value) pos += sprintf(pos, " " #name);
453 * Calculate start of next buffer, and return value.
455 *start = buffer + offset;
457 if ((pos - buffer) < offset)
459 else if ((pos - buffer - offset) < length)
460 return (pos - buffer - offset);
465 /***********************************************************************
467 ***********************************************************************/
469 /* Output routine for the sysfs max_sectors file */
470 static ssize_t show_max_sectors(struct device *dev, struct device_attribute *attr, char *buf)
472 struct scsi_device *sdev = to_scsi_device(dev);
474 return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
477 /* Input routine for the sysfs max_sectors file */
478 static ssize_t store_max_sectors(struct device *dev, struct device_attribute *attr, const char *buf,
481 struct scsi_device *sdev = to_scsi_device(dev);
484 if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
485 blk_queue_max_sectors(sdev->request_queue, ms);
491 static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
494 static struct device_attribute *sysfs_device_attr_list[] = {
495 &dev_attr_max_sectors,
500 * this defines our host template, with which we'll allocate hosts
503 struct scsi_host_template usb_stor_host_template = {
504 /* basic userland interface stuff */
505 .name = "usb-storage",
506 .proc_name = "usb-storage",
507 .proc_info = proc_info,
510 /* command interface -- queued only */
511 .queuecommand = queuecommand,
513 /* error and abort handlers */
514 .eh_abort_handler = command_abort,
515 .eh_device_reset_handler = device_reset,
516 .eh_bus_reset_handler = bus_reset,
518 /* queue commands only, only one command per LUN */
522 /* unknown initiator id */
525 .slave_alloc = slave_alloc,
526 .slave_configure = slave_configure,
528 /* lots of sg segments can be handled */
529 .sg_tablesize = SG_ALL,
531 /* limit the total size of a transfer to 120 KB */
534 /* merge commands... this seems to help performance, but
535 * periodically someone should test to see which setting is more
543 /* we do our own delay after a device or bus reset */
544 .skip_settle_delay = 1,
546 /* sysfs device attributes */
547 .sdev_attrs = sysfs_device_attr_list,
549 /* module management */
550 .module = THIS_MODULE
553 /* To Report "Illegal Request: Invalid Field in CDB */
554 unsigned char usb_stor_sense_invalidCDB[18] = {
555 [0] = 0x70, /* current error */
556 [2] = ILLEGAL_REQUEST, /* Illegal Request = 0x05 */
557 [7] = 0x0a, /* additional length */
558 [12] = 0x24 /* Invalid Field in CDB */