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 default bflags. These can be overridden for individual
77 * models and vendors via the scsi devinfo mechanism. The only
78 * flag we need is to force 36-byte INQUIRYs; we don't use any
79 * of the extra data and many devices choke if asked for more or
82 sdev->sdev_bflags = BLIST_INQUIRY_36;
87 static int slave_configure(struct scsi_device *sdev)
89 struct us_data *us = (struct us_data *) sdev->host->hostdata[0];
91 /* Scatter-gather buffers (all but the last) must have a length
92 * divisible by the bulk maxpacket size. Otherwise a data packet
93 * would end up being short, causing a premature end to the data
94 * transfer. Since high-speed bulk pipes have a maxpacket size
95 * of 512, we'll use that as the scsi device queue's DMA alignment
96 * mask. Guaranteeing proper alignment of the first buffer will
97 * have the desired effect because, except at the beginning and
98 * the end, scatter-gather buffers follow page boundaries. */
99 blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
101 /* According to the technical support people at Genesys Logic,
102 * devices using their chips have problems transferring more than
103 * 32 KB at a time. In practice people have found that 64 KB
104 * works okay and that's what Windows does. But we'll be
105 * conservative; people can always use the sysfs interface to
106 * increase max_sectors. */
107 if (us->pusb_dev->descriptor.idVendor == USB_VENDOR_ID_GENESYS &&
108 sdev->request_queue->max_sectors > 64)
109 blk_queue_max_sectors(sdev->request_queue, 64);
111 /* We can't put these settings in slave_alloc() because that gets
112 * called before the device type is known. Consequently these
113 * settings can't be overridden via the scsi devinfo mechanism. */
114 if (sdev->type == TYPE_DISK) {
116 /* Disk-type devices use MODE SENSE(6) if the protocol
117 * (SubClass) is Transparent SCSI, otherwise they use
119 if (us->subclass != US_SC_SCSI)
120 sdev->use_10_for_ms = 1;
122 /* Many disks only accept MODE SENSE transfer lengths of
123 * 192 bytes (that's what Windows uses). */
124 sdev->use_192_bytes_for_3f = 1;
126 /* A number of devices have problems with MODE SENSE for
127 * page x08, so we will skip it. */
128 sdev->skip_ms_page_8 = 1;
130 #ifndef CONFIG_USB_STORAGE_RW_DETECT
131 /* Some devices may not like MODE SENSE with page=0x3f.
132 * Now that we're using 192-byte transfers this may no
133 * longer be a problem. So this will be a configuration
135 sdev->skip_ms_page_3f = 1;
140 /* Non-disk-type devices don't need to blacklist any pages
141 * or to force 192-byte transfer lengths for MODE SENSE.
142 * But they do need to use MODE SENSE(10). */
143 sdev->use_10_for_ms = 1;
146 /* this is to satisfy the compiler, tho I don't think the
147 * return code is ever checked anywhere. */
151 /* queue a command */
152 /* This is always called with scsi_lock(srb->host) held */
153 static int queuecommand(struct scsi_cmnd *srb,
154 void (*done)(struct scsi_cmnd *))
156 struct us_data *us = (struct us_data *)srb->device->host->hostdata[0];
158 US_DEBUGP("%s called\n", __FUNCTION__);
159 srb->host_scribble = (unsigned char *)us;
161 /* check for state-transition errors */
162 if (us->sm_state != US_STATE_IDLE || us->srb != NULL) {
163 printk(KERN_ERR USB_STORAGE "Error in %s: "
164 "state = %d, us->srb = %p\n",
165 __FUNCTION__, us->sm_state, us->srb);
166 return SCSI_MLQUEUE_HOST_BUSY;
169 /* fail the command if we are disconnecting */
170 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
171 US_DEBUGP("Fail command during disconnect\n");
172 srb->result = DID_NO_CONNECT << 16;
177 /* enqueue the command and wake up the control thread */
178 srb->scsi_done = done;
185 /***********************************************************************
186 * Error handling functions
187 ***********************************************************************/
190 /* This is always called with scsi_lock(srb->host) held */
191 static int command_abort(struct scsi_cmnd *srb )
193 struct Scsi_Host *host = srb->device->host;
194 struct us_data *us = (struct us_data *) host->hostdata[0];
196 US_DEBUGP("%s called\n", __FUNCTION__);
198 /* Is this command still active? */
199 if (us->srb != srb) {
200 US_DEBUGP ("-- nothing to abort\n");
204 /* Normally the current state is RUNNING. If the control thread
205 * hasn't even started processing this command, the state will be
206 * IDLE. Anything else is a bug. */
207 if (us->sm_state != US_STATE_RUNNING
208 && us->sm_state != US_STATE_IDLE) {
209 printk(KERN_ERR USB_STORAGE "Error in %s: "
210 "invalid state %d\n", __FUNCTION__, us->sm_state);
214 /* Set state to ABORTING and set the ABORTING bit, but only if
215 * a device reset isn't already in progress (to avoid interfering
216 * with the reset). To prevent races with auto-reset, we must
217 * stop any ongoing USB transfers while still holding the host
219 us->sm_state = US_STATE_ABORTING;
220 if (!test_bit(US_FLIDX_RESETTING, &us->flags)) {
221 set_bit(US_FLIDX_ABORTING, &us->flags);
222 usb_stor_stop_transport(us);
226 /* Wait for the aborted command to finish */
227 wait_for_completion(&us->notify);
229 /* Reacquire the lock and allow USB transfers to resume */
231 clear_bit(US_FLIDX_ABORTING, &us->flags);
235 /* This invokes the transport reset mechanism to reset the state of the
237 /* This is always called with scsi_lock(srb->host) held */
238 static int device_reset(struct scsi_cmnd *srb)
240 struct us_data *us = (struct us_data *)srb->device->host->hostdata[0];
243 US_DEBUGP("%s called\n", __FUNCTION__);
244 if (us->sm_state != US_STATE_IDLE) {
245 printk(KERN_ERR USB_STORAGE "Error in %s: "
246 "invalid state %d\n", __FUNCTION__, us->sm_state);
250 /* set the state and release the lock */
251 us->sm_state = US_STATE_RESETTING;
252 scsi_unlock(srb->device->host);
254 /* lock the device pointers and do the reset */
255 down(&(us->dev_semaphore));
256 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
258 US_DEBUGP("No reset during disconnect\n");
260 result = us->transport_reset(us);
261 up(&(us->dev_semaphore));
263 /* lock access to the state and clear it */
264 scsi_lock(srb->device->host);
265 us->sm_state = US_STATE_IDLE;
269 /* This resets the device's USB port. */
270 /* It refuses to work if there's more than one interface in
271 * the device, so that other users are not affected. */
272 /* This is always called with scsi_lock(srb->host) held */
273 static int bus_reset(struct scsi_cmnd *srb)
275 struct us_data *us = (struct us_data *)srb->device->host->hostdata[0];
278 US_DEBUGP("%s called\n", __FUNCTION__);
279 if (us->sm_state != US_STATE_IDLE) {
280 printk(KERN_ERR USB_STORAGE "Error in %s: "
281 "invalid state %d\n", __FUNCTION__, us->sm_state);
285 /* set the state and release the lock */
286 us->sm_state = US_STATE_RESETTING;
287 scsi_unlock(srb->device->host);
289 /* The USB subsystem doesn't handle synchronisation between
290 * a device's several drivers. Therefore we reset only devices
291 * with just one interface, which we of course own. */
293 down(&(us->dev_semaphore));
294 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
296 US_DEBUGP("No reset during disconnect\n");
297 } else if (us->pusb_dev->actconfig->desc.bNumInterfaces != 1) {
299 US_DEBUGP("Refusing to reset a multi-interface device\n");
301 result = usb_reset_device(us->pusb_dev);
302 US_DEBUGP("usb_reset_device returns %d\n", result);
304 up(&(us->dev_semaphore));
306 /* lock access to the state and clear it */
307 scsi_lock(srb->device->host);
308 us->sm_state = US_STATE_IDLE;
309 return result < 0 ? FAILED : SUCCESS;
312 /* Report a driver-initiated device reset to the SCSI layer.
313 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
314 * The caller must own the SCSI host lock. */
315 void usb_stor_report_device_reset(struct us_data *us)
319 scsi_report_device_reset(us->host, 0, 0);
320 if (us->flags & US_FL_SCM_MULT_TARG) {
321 for (i = 1; i < us->host->max_id; ++i)
322 scsi_report_device_reset(us->host, 0, i);
326 /***********************************************************************
327 * /proc/scsi/ functions
328 ***********************************************************************/
330 /* we use this macro to help us write into the buffer */
332 #define SPRINTF(args...) \
333 do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
335 do { if (us->flags & US_FL_##a) pos += sprintf(pos, " " #a); } while(0)
337 static int proc_info (struct Scsi_Host *hostptr, char *buffer, char **start, off_t offset,
338 int length, int inout)
343 /* if someone is sending us data, just throw it away */
347 us = (struct us_data*)hostptr->hostdata[0];
349 /* print the controller name */
350 SPRINTF(" Host scsi%d: usb-storage\n", hostptr->host_no);
352 /* print product, vendor, and serial number strings */
353 SPRINTF(" Vendor: %s\n", us->vendor);
354 SPRINTF(" Product: %s\n", us->product);
355 SPRINTF("Serial Number: %s\n", us->serial);
357 /* show the protocol and transport */
358 SPRINTF(" Protocol: %s\n", us->protocol_name);
359 SPRINTF(" Transport: %s\n", us->transport_name);
361 /* show the device flags */
362 if (pos < buffer + length) {
363 pos += sprintf(pos, " Quirks:");
366 DO_FLAG(SCM_MULT_TARG);
367 DO_FLAG(FIX_INQUIRY);
368 DO_FLAG(FIX_CAPACITY);
374 * Calculate start of next buffer, and return value.
376 *start = buffer + offset;
378 if ((pos - buffer) < offset)
380 else if ((pos - buffer - offset) < length)
381 return (pos - buffer - offset);
386 /***********************************************************************
388 ***********************************************************************/
390 /* Output routine for the sysfs max_sectors file */
391 static ssize_t show_max_sectors(struct device *dev, char *buf)
393 struct scsi_device *sdev = to_scsi_device(dev);
395 return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
398 /* Input routine for the sysfs max_sectors file */
399 static ssize_t store_max_sectors(struct device *dev, const char *buf,
402 struct scsi_device *sdev = to_scsi_device(dev);
405 if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
406 blk_queue_max_sectors(sdev->request_queue, ms);
412 static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
415 static struct device_attribute *sysfs_device_attr_list[] = {
416 &dev_attr_max_sectors,
421 * this defines our host template, with which we'll allocate hosts
424 struct scsi_host_template usb_stor_host_template = {
425 /* basic userland interface stuff */
426 .name = "usb-storage",
427 .proc_name = "usb-storage",
428 .proc_info = proc_info,
431 /* command interface -- queued only */
432 .queuecommand = queuecommand,
434 /* error and abort handlers */
435 .eh_abort_handler = command_abort,
436 .eh_device_reset_handler = device_reset,
437 .eh_bus_reset_handler = bus_reset,
439 /* queue commands only, only one command per LUN */
443 /* unknown initiator id */
446 .slave_alloc = slave_alloc,
447 .slave_configure = slave_configure,
449 /* lots of sg segments can be handled */
450 .sg_tablesize = SG_ALL,
452 /* limit the total size of a transfer to 120 KB */
455 /* merge commands... this seems to help performance, but
456 * periodically someone should test to see which setting is more
464 /* we do our own delay after a device or bus reset */
465 .skip_settle_delay = 1,
467 /* sysfs device attributes */
468 .sdev_attrs = sysfs_device_attr_list,
470 /* module management */
471 .module = THIS_MODULE
474 /* For a device that is "Not Ready" */
475 unsigned char usb_stor_sense_notready[18] = {
476 [0] = 0x70, /* current error */
477 [2] = 0x02, /* not ready */
478 [7] = 0x0a, /* additional length */
479 [12] = 0x04, /* not ready */
480 [13] = 0x03 /* manual intervention */
483 /* To Report "Illegal Request: Invalid Field in CDB */
484 unsigned char usb_stor_sense_invalidCDB[18] = {
485 [0] = 0x70, /* current error */
486 [2] = ILLEGAL_REQUEST, /* Illegal Request = 0x05 */
487 [7] = 0x0a, /* additional length */
488 [12] = 0x24 /* Invalid Field in CDB */