1 /* Driver for USB Mass Storage compliant devices
4 * $Id: scsiglue.c,v 1.26 2002/04/22 03:39:43 mdharm Exp $
6 * Current development and maintenance by:
7 * (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
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)
14 * (c) 1999 Michael Gee (michael@linuxspecific.com)
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.
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.
27 * Also, for certain devices, the interrupt endpoint is used to convey
28 * status of a command.
30 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
31 * information about this driver.
33 * This program is free software; you can redistribute it and/or modify it
34 * under the terms of the GNU General Public License as published by the
35 * Free Software Foundation; either version 2, or (at your option) any
38 * This program is distributed in the hope that it will be useful, but
39 * WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41 * General Public License for more details.
43 * You should have received a copy of the GNU General Public License along
44 * with this program; if not, write to the Free Software Foundation, Inc.,
45 * 675 Mass Ave, Cambridge, MA 02139, USA.
48 #include <linux/slab.h>
49 #include <linux/module.h>
51 #include <scsi/scsi.h>
52 #include <scsi/scsi_cmnd.h>
53 #include <scsi/scsi_devinfo.h>
54 #include <scsi/scsi_device.h>
55 #include <scsi/scsi_eh.h>
56 #include <scsi/scsi_host.h>
61 #include "transport.h"
64 /***********************************************************************
66 ***********************************************************************/
68 static const char* host_info(struct Scsi_Host *host)
70 return "SCSI emulation for USB Mass Storage devices";
73 static int slave_alloc (struct scsi_device *sdev)
76 * Set the INQUIRY transfer length to 36. We don't use any of
77 * the extra data and many devices choke if asked for more or
80 sdev->inquiry_len = 36;
84 static int slave_configure(struct scsi_device *sdev)
86 struct us_data *us = (struct us_data *) sdev->host->hostdata[0];
88 /* Scatter-gather buffers (all but the last) must have a length
89 * divisible by the bulk maxpacket size. Otherwise a data packet
90 * would end up being short, causing a premature end to the data
91 * transfer. Since high-speed bulk pipes have a maxpacket size
92 * of 512, we'll use that as the scsi device queue's DMA alignment
93 * mask. Guaranteeing proper alignment of the first buffer will
94 * have the desired effect because, except at the beginning and
95 * the end, scatter-gather buffers follow page boundaries. */
96 blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
98 /* Set the SCSI level to at least 2. We'll leave it at 3 if that's
99 * what is originally reported. We need this to avoid confusing
100 * the SCSI layer with devices that report 0 or 1, but need 10-byte
101 * commands (ala ATAPI devices behind certain bridges, or devices
102 * which simply have broken INQUIRY data).
104 * NOTE: This means /dev/sg programs (ala cdrecord) will get the
105 * actual information. This seems to be the preference for
106 * programs like that.
108 * NOTE: This also means that /proc/scsi/scsi and sysfs may report
109 * the actual value or the modified one, depending on where the
112 if (sdev->scsi_level < SCSI_2)
113 sdev->scsi_level = SCSI_2;
115 /* According to the technical support people at Genesys Logic,
116 * devices using their chips have problems transferring more than
117 * 32 KB at a time. In practice people have found that 64 KB
118 * works okay and that's what Windows does. But we'll be
119 * conservative; people can always use the sysfs interface to
120 * increase max_sectors. */
121 if (le16_to_cpu(us->pusb_dev->descriptor.idVendor) == USB_VENDOR_ID_GENESYS &&
122 sdev->request_queue->max_sectors > 64)
123 blk_queue_max_sectors(sdev->request_queue, 64);
125 /* We can't put these settings in slave_alloc() because that gets
126 * called before the device type is known. Consequently these
127 * settings can't be overridden via the scsi devinfo mechanism. */
128 if (sdev->type == TYPE_DISK) {
130 /* Disk-type devices use MODE SENSE(6) if the protocol
131 * (SubClass) is Transparent SCSI, otherwise they use
133 if (us->subclass != US_SC_SCSI)
134 sdev->use_10_for_ms = 1;
136 /* Many disks only accept MODE SENSE transfer lengths of
137 * 192 bytes (that's what Windows uses). */
138 sdev->use_192_bytes_for_3f = 1;
140 /* A number of devices have problems with MODE SENSE for
141 * page x08, so we will skip it. */
142 sdev->skip_ms_page_8 = 1;
144 #ifndef CONFIG_USB_STORAGE_RW_DETECT
145 /* Some devices may not like MODE SENSE with page=0x3f.
146 * Now that we're using 192-byte transfers this may no
147 * longer be a problem. So this will be a configuration
149 sdev->skip_ms_page_3f = 1;
154 /* Non-disk-type devices don't need to blacklist any pages
155 * or to force 192-byte transfer lengths for MODE SENSE.
156 * But they do need to use MODE SENSE(10). */
157 sdev->use_10_for_ms = 1;
160 /* this is to satisfy the compiler, tho I don't think the
161 * return code is ever checked anywhere. */
165 /* queue a command */
166 /* This is always called with scsi_lock(srb->host) held */
167 static int queuecommand(struct scsi_cmnd *srb,
168 void (*done)(struct scsi_cmnd *))
170 struct us_data *us = (struct us_data *)srb->device->host->hostdata[0];
172 US_DEBUGP("%s called\n", __FUNCTION__);
173 srb->host_scribble = (unsigned char *)us;
175 /* check for state-transition errors */
176 if (us->srb != NULL) {
177 printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
178 __FUNCTION__, us->srb);
179 return SCSI_MLQUEUE_HOST_BUSY;
182 /* fail the command if we are disconnecting */
183 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
184 US_DEBUGP("Fail command during disconnect\n");
185 srb->result = DID_NO_CONNECT << 16;
190 /* enqueue the command and wake up the control thread */
191 srb->scsi_done = done;
198 /***********************************************************************
199 * Error handling functions
200 ***********************************************************************/
202 /* Command timeout and abort */
203 /* This is always called with scsi_lock(srb->host) held */
204 static int command_abort(struct scsi_cmnd *srb )
206 struct Scsi_Host *host = srb->device->host;
207 struct us_data *us = (struct us_data *) host->hostdata[0];
209 US_DEBUGP("%s called\n", __FUNCTION__);
211 /* Is this command still active? */
212 if (us->srb != srb) {
213 US_DEBUGP ("-- nothing to abort\n");
217 /* Set the TIMED_OUT bit. Also set the ABORTING bit, but only if
218 * a device reset isn't already in progress (to avoid interfering
219 * with the reset). To prevent races with auto-reset, we must
220 * stop any ongoing USB transfers while still holding the host
222 set_bit(US_FLIDX_TIMED_OUT, &us->flags);
223 if (!test_bit(US_FLIDX_RESETTING, &us->flags)) {
224 set_bit(US_FLIDX_ABORTING, &us->flags);
225 usb_stor_stop_transport(us);
229 /* Wait for the aborted command to finish */
230 wait_for_completion(&us->notify);
232 /* Reacquire the lock and allow USB transfers to resume */
234 clear_bit(US_FLIDX_ABORTING, &us->flags);
235 clear_bit(US_FLIDX_TIMED_OUT, &us->flags);
239 /* This invokes the transport reset mechanism to reset the state of the
241 /* This is always called with scsi_lock(srb->host) held */
242 static int device_reset(struct scsi_cmnd *srb)
244 struct us_data *us = (struct us_data *)srb->device->host->hostdata[0];
247 US_DEBUGP("%s called\n", __FUNCTION__);
249 scsi_unlock(srb->device->host);
251 /* lock the device pointers and do the reset */
252 down(&(us->dev_semaphore));
253 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
255 US_DEBUGP("No reset during disconnect\n");
257 result = us->transport_reset(us);
258 up(&(us->dev_semaphore));
260 /* lock the host for the return */
261 scsi_lock(srb->device->host);
265 /* This resets the device's USB port. */
266 /* It refuses to work if there's more than one interface in
267 * the device, so that other users are not affected. */
268 /* This is always called with scsi_lock(srb->host) held */
269 static int bus_reset(struct scsi_cmnd *srb)
271 struct us_data *us = (struct us_data *)srb->device->host->hostdata[0];
274 US_DEBUGP("%s called\n", __FUNCTION__);
276 scsi_unlock(srb->device->host);
278 /* The USB subsystem doesn't handle synchronisation between
279 * a device's several drivers. Therefore we reset only devices
280 * with just one interface, which we of course own. */
282 down(&(us->dev_semaphore));
283 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
285 US_DEBUGP("No reset during disconnect\n");
286 } else if (us->pusb_dev->actconfig->desc.bNumInterfaces != 1) {
288 US_DEBUGP("Refusing to reset a multi-interface device\n");
290 rc = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
292 US_DEBUGP("unable to lock device for reset: %d\n", rc);
295 result = usb_reset_device(us->pusb_dev);
297 usb_unlock_device(us->pusb_dev);
298 US_DEBUGP("usb_reset_device returns %d\n", result);
301 up(&(us->dev_semaphore));
303 /* lock the host for the return */
304 scsi_lock(srb->device->host);
305 return result < 0 ? FAILED : SUCCESS;
308 /* Report a driver-initiated device reset to the SCSI layer.
309 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
310 * The caller must own the SCSI host lock. */
311 void usb_stor_report_device_reset(struct us_data *us)
315 scsi_report_device_reset(us->host, 0, 0);
316 if (us->flags & US_FL_SCM_MULT_TARG) {
317 for (i = 1; i < us->host->max_id; ++i)
318 scsi_report_device_reset(us->host, 0, i);
322 /***********************************************************************
323 * /proc/scsi/ functions
324 ***********************************************************************/
326 /* we use this macro to help us write into the buffer */
328 #define SPRINTF(args...) \
329 do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
331 do { if (us->flags & US_FL_##a) pos += sprintf(pos, " " #a); } while(0)
333 static int proc_info (struct Scsi_Host *hostptr, char *buffer, char **start, off_t offset,
334 int length, int inout)
339 /* if someone is sending us data, just throw it away */
343 us = (struct us_data*)hostptr->hostdata[0];
345 /* print the controller name */
346 SPRINTF(" Host scsi%d: usb-storage\n", hostptr->host_no);
348 /* print product, vendor, and serial number strings */
349 SPRINTF(" Vendor: %s\n", us->vendor);
350 SPRINTF(" Product: %s\n", us->product);
351 SPRINTF("Serial Number: %s\n", us->serial);
353 /* show the protocol and transport */
354 SPRINTF(" Protocol: %s\n", us->protocol_name);
355 SPRINTF(" Transport: %s\n", us->transport_name);
357 /* show the device flags */
358 if (pos < buffer + length) {
359 pos += sprintf(pos, " Quirks:");
362 DO_FLAG(SCM_MULT_TARG);
363 DO_FLAG(FIX_INQUIRY);
364 DO_FLAG(FIX_CAPACITY);
370 * Calculate start of next buffer, and return value.
372 *start = buffer + offset;
374 if ((pos - buffer) < offset)
376 else if ((pos - buffer - offset) < length)
377 return (pos - buffer - offset);
382 /***********************************************************************
384 ***********************************************************************/
386 /* Output routine for the sysfs max_sectors file */
387 static ssize_t show_max_sectors(struct device *dev, char *buf)
389 struct scsi_device *sdev = to_scsi_device(dev);
391 return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
394 /* Input routine for the sysfs max_sectors file */
395 static ssize_t store_max_sectors(struct device *dev, const char *buf,
398 struct scsi_device *sdev = to_scsi_device(dev);
401 if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
402 blk_queue_max_sectors(sdev->request_queue, ms);
408 static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
411 static struct device_attribute *sysfs_device_attr_list[] = {
412 &dev_attr_max_sectors,
417 * this defines our host template, with which we'll allocate hosts
420 struct scsi_host_template usb_stor_host_template = {
421 /* basic userland interface stuff */
422 .name = "usb-storage",
423 .proc_name = "usb-storage",
424 .proc_info = proc_info,
427 /* command interface -- queued only */
428 .queuecommand = queuecommand,
430 /* error and abort handlers */
431 .eh_abort_handler = command_abort,
432 .eh_device_reset_handler = device_reset,
433 .eh_bus_reset_handler = bus_reset,
435 /* queue commands only, only one command per LUN */
439 /* unknown initiator id */
442 .slave_alloc = slave_alloc,
443 .slave_configure = slave_configure,
445 /* lots of sg segments can be handled */
446 .sg_tablesize = SG_ALL,
448 /* limit the total size of a transfer to 120 KB */
451 /* merge commands... this seems to help performance, but
452 * periodically someone should test to see which setting is more
460 /* we do our own delay after a device or bus reset */
461 .skip_settle_delay = 1,
463 /* sysfs device attributes */
464 .sdev_attrs = sysfs_device_attr_list,
466 /* module management */
467 .module = THIS_MODULE
470 /* For a device that is "Not Ready" */
471 unsigned char usb_stor_sense_notready[18] = {
472 [0] = 0x70, /* current error */
473 [2] = 0x02, /* not ready */
474 [7] = 0x0a, /* additional length */
475 [12] = 0x04, /* not ready */
476 [13] = 0x03 /* manual intervention */
479 /* To Report "Illegal Request: Invalid Field in CDB */
480 unsigned char usb_stor_sense_invalidCDB[18] = {
481 [0] = 0x70, /* current error */
482 [2] = ILLEGAL_REQUEST, /* Illegal Request = 0x05 */
483 [7] = 0x0a, /* additional length */
484 [12] = 0x24 /* Invalid Field in CDB */