[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / usb / storage / scsiglue.c
blob22e48a2b0bd186879f0e0ae6f5001560f382f5f1
1 /* Driver for USB Mass Storage compliant devices
2 * SCSI layer glue code
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)
13 * Initial work by:
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
36 * later version.
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>
57 #include "usb.h"
58 #include "scsiglue.h"
59 #include "debug.h"
60 #include "transport.h"
61 #include "protocol.h"
63 /***********************************************************************
64 * Host functions
65 ***********************************************************************/
67 static const char* host_info(struct Scsi_Host *host)
69 return "SCSI emulation for USB Mass Storage devices";
72 static int slave_alloc (struct scsi_device *sdev)
75 * Set the INQUIRY transfer length to 36. We don't use any of
76 * the extra data and many devices choke if asked for more or
77 * less than 36 bytes.
79 sdev->inquiry_len = 36;
80 return 0;
83 static int slave_configure(struct scsi_device *sdev)
85 struct us_data *us = host_to_us(sdev->host);
87 /* Scatter-gather buffers (all but the last) must have a length
88 * divisible by the bulk maxpacket size. Otherwise a data packet
89 * would end up being short, causing a premature end to the data
90 * transfer. Since high-speed bulk pipes have a maxpacket size
91 * of 512, we'll use that as the scsi device queue's DMA alignment
92 * mask. Guaranteeing proper alignment of the first buffer will
93 * have the desired effect because, except at the beginning and
94 * the end, scatter-gather buffers follow page boundaries. */
95 blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
97 /* Set the SCSI level to at least 2. We'll leave it at 3 if that's
98 * what is originally reported. We need this to avoid confusing
99 * the SCSI layer with devices that report 0 or 1, but need 10-byte
100 * commands (ala ATAPI devices behind certain bridges, or devices
101 * which simply have broken INQUIRY data).
103 * NOTE: This means /dev/sg programs (ala cdrecord) will get the
104 * actual information. This seems to be the preference for
105 * programs like that.
107 * NOTE: This also means that /proc/scsi/scsi and sysfs may report
108 * the actual value or the modified one, depending on where the
109 * data comes from.
111 if (sdev->scsi_level < SCSI_2)
112 sdev->scsi_level = SCSI_2;
114 /* According to the technical support people at Genesys Logic,
115 * devices using their chips have problems transferring more than
116 * 32 KB at a time. In practice people have found that 64 KB
117 * works okay and that's what Windows does. But we'll be
118 * conservative; people can always use the sysfs interface to
119 * increase max_sectors. */
120 if (le16_to_cpu(us->pusb_dev->descriptor.idVendor) == USB_VENDOR_ID_GENESYS &&
121 sdev->request_queue->max_sectors > 64)
122 blk_queue_max_sectors(sdev->request_queue, 64);
124 /* We can't put these settings in slave_alloc() because that gets
125 * called before the device type is known. Consequently these
126 * settings can't be overridden via the scsi devinfo mechanism. */
127 if (sdev->type == TYPE_DISK) {
129 /* Disk-type devices use MODE SENSE(6) if the protocol
130 * (SubClass) is Transparent SCSI, otherwise they use
131 * MODE SENSE(10). */
132 if (us->subclass != US_SC_SCSI)
133 sdev->use_10_for_ms = 1;
135 /* Many disks only accept MODE SENSE transfer lengths of
136 * 192 bytes (that's what Windows uses). */
137 sdev->use_192_bytes_for_3f = 1;
139 /* Some devices don't like MODE SENSE with page=0x3f,
140 * which is the command used for checking if a device
141 * is write-protected. Now that we tell the sd driver
142 * to do a 192-byte transfer with this command the
143 * majority of devices work fine, but a few still can't
144 * handle it. The sd driver will simply assume those
145 * devices are write-enabled. */
146 if (us->flags & US_FL_NO_WP_DETECT)
147 sdev->skip_ms_page_3f = 1;
149 /* A number of devices have problems with MODE SENSE for
150 * page x08, so we will skip it. */
151 sdev->skip_ms_page_8 = 1;
153 /* Some disks return the total number of blocks in response
154 * to READ CAPACITY rather than the highest block number.
155 * If this device makes that mistake, tell the sd driver. */
156 if (us->flags & US_FL_FIX_CAPACITY)
157 sdev->fix_capacity = 1;
158 } else {
160 /* Non-disk-type devices don't need to blacklist any pages
161 * or to force 192-byte transfer lengths for MODE SENSE.
162 * But they do need to use MODE SENSE(10). */
163 sdev->use_10_for_ms = 1;
166 /* Some devices choke when they receive a PREVENT-ALLOW MEDIUM
167 * REMOVAL command, so suppress those commands. */
168 if (us->flags & US_FL_NOT_LOCKABLE)
169 sdev->lockable = 0;
171 /* this is to satisfy the compiler, tho I don't think the
172 * return code is ever checked anywhere. */
173 return 0;
176 /* queue a command */
177 /* This is always called with scsi_lock(host) held */
178 static int queuecommand(struct scsi_cmnd *srb,
179 void (*done)(struct scsi_cmnd *))
181 struct us_data *us = host_to_us(srb->device->host);
183 US_DEBUGP("%s called\n", __FUNCTION__);
185 /* check for state-transition errors */
186 if (us->srb != NULL) {
187 printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
188 __FUNCTION__, us->srb);
189 return SCSI_MLQUEUE_HOST_BUSY;
192 /* fail the command if we are disconnecting */
193 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
194 US_DEBUGP("Fail command during disconnect\n");
195 srb->result = DID_NO_CONNECT << 16;
196 done(srb);
197 return 0;
200 /* enqueue the command and wake up the control thread */
201 srb->scsi_done = done;
202 us->srb = srb;
203 up(&(us->sema));
205 return 0;
208 /***********************************************************************
209 * Error handling functions
210 ***********************************************************************/
212 /* Command timeout and abort */
213 /* This is always called with scsi_lock(host) held */
214 static int command_abort(struct scsi_cmnd *srb)
216 struct us_data *us = host_to_us(srb->device->host);
218 US_DEBUGP("%s called\n", __FUNCTION__);
220 /* Is this command still active? */
221 if (us->srb != srb) {
222 US_DEBUGP ("-- nothing to abort\n");
223 return FAILED;
226 /* Set the TIMED_OUT bit. Also set the ABORTING bit, but only if
227 * a device reset isn't already in progress (to avoid interfering
228 * with the reset). To prevent races with auto-reset, we must
229 * stop any ongoing USB transfers while still holding the host
230 * lock. */
231 set_bit(US_FLIDX_TIMED_OUT, &us->flags);
232 if (!test_bit(US_FLIDX_RESETTING, &us->flags)) {
233 set_bit(US_FLIDX_ABORTING, &us->flags);
234 usb_stor_stop_transport(us);
236 scsi_unlock(us_to_host(us));
238 /* Wait for the aborted command to finish */
239 wait_for_completion(&us->notify);
241 /* Reacquire the lock and allow USB transfers to resume */
242 scsi_lock(us_to_host(us));
243 clear_bit(US_FLIDX_ABORTING, &us->flags);
244 clear_bit(US_FLIDX_TIMED_OUT, &us->flags);
245 return SUCCESS;
248 /* This invokes the transport reset mechanism to reset the state of the
249 * device */
250 /* This is always called with scsi_lock(host) held */
251 static int device_reset(struct scsi_cmnd *srb)
253 struct us_data *us = host_to_us(srb->device->host);
254 int result;
256 US_DEBUGP("%s called\n", __FUNCTION__);
258 scsi_unlock(us_to_host(us));
260 /* lock the device pointers and do the reset */
261 down(&(us->dev_semaphore));
262 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
263 result = FAILED;
264 US_DEBUGP("No reset during disconnect\n");
265 } else
266 result = us->transport_reset(us);
267 up(&(us->dev_semaphore));
269 /* lock the host for the return */
270 scsi_lock(us_to_host(us));
271 return result;
274 /* This resets the device's USB port. */
275 /* It refuses to work if there's more than one interface in
276 * the device, so that other users are not affected. */
277 /* This is always called with scsi_lock(host) held */
278 static int bus_reset(struct scsi_cmnd *srb)
280 struct us_data *us = host_to_us(srb->device->host);
281 int result, rc;
283 US_DEBUGP("%s called\n", __FUNCTION__);
285 scsi_unlock(us_to_host(us));
287 /* The USB subsystem doesn't handle synchronisation between
288 * a device's several drivers. Therefore we reset only devices
289 * with just one interface, which we of course own. */
291 down(&(us->dev_semaphore));
292 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
293 result = -EIO;
294 US_DEBUGP("No reset during disconnect\n");
295 } else if (us->pusb_dev->actconfig->desc.bNumInterfaces != 1) {
296 result = -EBUSY;
297 US_DEBUGP("Refusing to reset a multi-interface device\n");
298 } else {
299 rc = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
300 if (rc < 0) {
301 US_DEBUGP("unable to lock device for reset: %d\n", rc);
302 result = rc;
303 } else {
304 result = usb_reset_device(us->pusb_dev);
305 if (rc)
306 usb_unlock_device(us->pusb_dev);
307 US_DEBUGP("usb_reset_device returns %d\n", result);
310 up(&(us->dev_semaphore));
312 /* lock the host for the return */
313 scsi_lock(us_to_host(us));
314 return result < 0 ? FAILED : SUCCESS;
317 /* Report a driver-initiated device reset to the SCSI layer.
318 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
319 * The caller must own the SCSI host lock. */
320 void usb_stor_report_device_reset(struct us_data *us)
322 int i;
323 struct Scsi_Host *host = us_to_host(us);
325 scsi_report_device_reset(host, 0, 0);
326 if (us->flags & US_FL_SCM_MULT_TARG) {
327 for (i = 1; i < host->max_id; ++i)
328 scsi_report_device_reset(host, 0, i);
332 /***********************************************************************
333 * /proc/scsi/ functions
334 ***********************************************************************/
336 /* we use this macro to help us write into the buffer */
337 #undef SPRINTF
338 #define SPRINTF(args...) \
339 do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
341 static int proc_info (struct Scsi_Host *host, char *buffer,
342 char **start, off_t offset, int length, int inout)
344 struct us_data *us = host_to_us(host);
345 char *pos = buffer;
346 const char *string;
348 /* if someone is sending us data, just throw it away */
349 if (inout)
350 return length;
352 /* print the controller name */
353 SPRINTF(" Host scsi%d: usb-storage\n", host->host_no);
355 /* print product, vendor, and serial number strings */
356 if (us->pusb_dev->manufacturer)
357 string = us->pusb_dev->manufacturer;
358 else if (us->unusual_dev->vendorName)
359 string = us->unusual_dev->vendorName;
360 else
361 string = "Unknown";
362 SPRINTF(" Vendor: %s\n", string);
363 if (us->pusb_dev->product)
364 string = us->pusb_dev->product;
365 else if (us->unusual_dev->productName)
366 string = us->unusual_dev->productName;
367 else
368 string = "Unknown";
369 SPRINTF(" Product: %s\n", string);
370 if (us->pusb_dev->serial)
371 string = us->pusb_dev->serial;
372 else
373 string = "None";
374 SPRINTF("Serial Number: %s\n", string);
376 /* show the protocol and transport */
377 SPRINTF(" Protocol: %s\n", us->protocol_name);
378 SPRINTF(" Transport: %s\n", us->transport_name);
380 /* show the device flags */
381 if (pos < buffer + length) {
382 pos += sprintf(pos, " Quirks:");
384 #define US_FLAG(name, value) \
385 if (us->flags & value) pos += sprintf(pos, " " #name);
386 US_DO_ALL_FLAGS
387 #undef US_FLAG
389 *(pos++) = '\n';
393 * Calculate start of next buffer, and return value.
395 *start = buffer + offset;
397 if ((pos - buffer) < offset)
398 return (0);
399 else if ((pos - buffer - offset) < length)
400 return (pos - buffer - offset);
401 else
402 return (length);
405 /***********************************************************************
406 * Sysfs interface
407 ***********************************************************************/
409 /* Output routine for the sysfs max_sectors file */
410 static ssize_t show_max_sectors(struct device *dev, char *buf)
412 struct scsi_device *sdev = to_scsi_device(dev);
414 return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
417 /* Input routine for the sysfs max_sectors file */
418 static ssize_t store_max_sectors(struct device *dev, const char *buf,
419 size_t count)
421 struct scsi_device *sdev = to_scsi_device(dev);
422 unsigned short ms;
424 if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
425 blk_queue_max_sectors(sdev->request_queue, ms);
426 return strlen(buf);
428 return -EINVAL;
431 static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
432 store_max_sectors);
434 static struct device_attribute *sysfs_device_attr_list[] = {
435 &dev_attr_max_sectors,
436 NULL,
440 * this defines our host template, with which we'll allocate hosts
443 struct scsi_host_template usb_stor_host_template = {
444 /* basic userland interface stuff */
445 .name = "usb-storage",
446 .proc_name = "usb-storage",
447 .proc_info = proc_info,
448 .info = host_info,
450 /* command interface -- queued only */
451 .queuecommand = queuecommand,
453 /* error and abort handlers */
454 .eh_abort_handler = command_abort,
455 .eh_device_reset_handler = device_reset,
456 .eh_bus_reset_handler = bus_reset,
458 /* queue commands only, only one command per LUN */
459 .can_queue = 1,
460 .cmd_per_lun = 1,
462 /* unknown initiator id */
463 .this_id = -1,
465 .slave_alloc = slave_alloc,
466 .slave_configure = slave_configure,
468 /* lots of sg segments can be handled */
469 .sg_tablesize = SG_ALL,
471 /* limit the total size of a transfer to 120 KB */
472 .max_sectors = 240,
474 /* merge commands... this seems to help performance, but
475 * periodically someone should test to see which setting is more
476 * optimal.
478 .use_clustering = 1,
480 /* emulated HBA */
481 .emulated = 1,
483 /* we do our own delay after a device or bus reset */
484 .skip_settle_delay = 1,
486 /* sysfs device attributes */
487 .sdev_attrs = sysfs_device_attr_list,
489 /* module management */
490 .module = THIS_MODULE
493 /* To Report "Illegal Request: Invalid Field in CDB */
494 unsigned char usb_stor_sense_invalidCDB[18] = {
495 [0] = 0x70, /* current error */
496 [2] = ILLEGAL_REQUEST, /* Illegal Request = 0x05 */
497 [7] = 0x0a, /* additional length */
498 [12] = 0x24 /* Invalid Field in CDB */