aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/storage/scsiglue.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/usb/storage/scsiglue.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/usb/storage/scsiglue.c')
-rw-r--r--drivers/usb/storage/scsiglue.c500
1 files changed, 500 insertions, 0 deletions
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
new file mode 100644
index 000000000000..22e48a2b0bd1
--- /dev/null
+++ b/drivers/usb/storage/scsiglue.c
@@ -0,0 +1,500 @@
1/* Driver for USB Mass Storage compliant devices
2 * SCSI layer glue code
3 *
4 * $Id: scsiglue.c,v 1.26 2002/04/22 03:39:43 mdharm Exp $
5 *
6 * Current development and maintenance by:
7 * (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
8 *
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)
12 *
13 * Initial work by:
14 * (c) 1999 Michael Gee (michael@linuxspecific.com)
15 *
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.
21 *
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.
26 *
27 * Also, for certain devices, the interrupt endpoint is used to convey
28 * status of a command.
29 *
30 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
31 * information about this driver.
32 *
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.
37 *
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.
42 *
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.
46 */
47
48#include <linux/slab.h>
49#include <linux/module.h>
50
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
57#include "usb.h"
58#include "scsiglue.h"
59#include "debug.h"
60#include "transport.h"
61#include "protocol.h"
62
63/***********************************************************************
64 * Host functions
65 ***********************************************************************/
66
67static const char* host_info(struct Scsi_Host *host)
68{
69 return "SCSI emulation for USB Mass Storage devices";
70}
71
72static int slave_alloc (struct scsi_device *sdev)
73{
74 /*
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.
78 */
79 sdev->inquiry_len = 36;
80 return 0;
81}
82
83static int slave_configure(struct scsi_device *sdev)
84{
85 struct us_data *us = host_to_us(sdev->host);
86
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));
96
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).
102 *
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.
106 *
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.
110 */
111 if (sdev->scsi_level < SCSI_2)
112 sdev->scsi_level = SCSI_2;
113
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);
123
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) {
128
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;
134
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;
138
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;
148
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;
152
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 {
159
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;
164 }
165
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;
170
171 /* this is to satisfy the compiler, tho I don't think the
172 * return code is ever checked anywhere. */
173 return 0;
174}
175
176/* queue a command */
177/* This is always called with scsi_lock(host) held */
178static int queuecommand(struct scsi_cmnd *srb,
179 void (*done)(struct scsi_cmnd *))
180{
181 struct us_data *us = host_to_us(srb->device->host);
182
183 US_DEBUGP("%s called\n", __FUNCTION__);
184
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;
190 }
191
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;
198 }
199
200 /* enqueue the command and wake up the control thread */
201 srb->scsi_done = done;
202 us->srb = srb;
203 up(&(us->sema));
204
205 return 0;
206}
207
208/***********************************************************************
209 * Error handling functions
210 ***********************************************************************/
211
212/* Command timeout and abort */
213/* This is always called with scsi_lock(host) held */
214static int command_abort(struct scsi_cmnd *srb)
215{
216 struct us_data *us = host_to_us(srb->device->host);
217
218 US_DEBUGP("%s called\n", __FUNCTION__);
219
220 /* Is this command still active? */
221 if (us->srb != srb) {
222 US_DEBUGP ("-- nothing to abort\n");
223 return FAILED;
224 }
225
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);
235 }
236 scsi_unlock(us_to_host(us));
237
238 /* Wait for the aborted command to finish */
239 wait_for_completion(&us->notify);
240
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;
246}
247
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 */
251static int device_reset(struct scsi_cmnd *srb)
252{
253 struct us_data *us = host_to_us(srb->device->host);
254 int result;
255
256 US_DEBUGP("%s called\n", __FUNCTION__);
257
258 scsi_unlock(us_to_host(us));
259
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));
268
269 /* lock the host for the return */
270 scsi_lock(us_to_host(us));
271 return result;
272}
273
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 */
278static int bus_reset(struct scsi_cmnd *srb)
279{
280 struct us_data *us = host_to_us(srb->device->host);
281 int result, rc;
282
283 US_DEBUGP("%s called\n", __FUNCTION__);
284
285 scsi_unlock(us_to_host(us));
286
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. */
290
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);
308 }
309 }
310 up(&(us->dev_semaphore));
311
312 /* lock the host for the return */
313 scsi_lock(us_to_host(us));
314 return result < 0 ? FAILED : SUCCESS;
315}
316
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. */
320void usb_stor_report_device_reset(struct us_data *us)
321{
322 int i;
323 struct Scsi_Host *host = us_to_host(us);
324
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);
329 }
330}
331
332/***********************************************************************
333 * /proc/scsi/ functions
334 ***********************************************************************/
335
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)
340
341static int proc_info (struct Scsi_Host *host, char *buffer,
342 char **start, off_t offset, int length, int inout)
343{
344 struct us_data *us = host_to_us(host);
345 char *pos = buffer;
346 const char *string;
347
348 /* if someone is sending us data, just throw it away */
349 if (inout)
350 return length;
351
352 /* print the controller name */
353 SPRINTF(" Host scsi%d: usb-storage\n", host->host_no);
354
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);
375
376 /* show the protocol and transport */
377 SPRINTF(" Protocol: %s\n", us->protocol_name);
378 SPRINTF(" Transport: %s\n", us->transport_name);
379
380 /* show the device flags */
381 if (pos < buffer + length) {
382 pos += sprintf(pos, " Quirks:");
383
384#define US_FLAG(name, value) \
385 if (us->flags & value) pos += sprintf(pos, " " #name);
386US_DO_ALL_FLAGS
387#undef US_FLAG
388
389 *(pos++) = '\n';
390 }
391
392 /*
393 * Calculate start of next buffer, and return value.
394 */
395 *start = buffer + offset;
396
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);
403}
404
405/***********************************************************************
406 * Sysfs interface
407 ***********************************************************************/
408
409/* Output routine for the sysfs max_sectors file */
410static ssize_t show_max_sectors(struct device *dev, char *buf)
411{
412 struct scsi_device *sdev = to_scsi_device(dev);
413
414 return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
415}
416
417/* Input routine for the sysfs max_sectors file */
418static ssize_t store_max_sectors(struct device *dev, const char *buf,
419 size_t count)
420{
421 struct scsi_device *sdev = to_scsi_device(dev);
422 unsigned short ms;
423
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);
427 }
428 return -EINVAL;
429}
430
431static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
432 store_max_sectors);
433
434static struct device_attribute *sysfs_device_attr_list[] = {
435 &dev_attr_max_sectors,
436 NULL,
437 };
438
439/*
440 * this defines our host template, with which we'll allocate hosts
441 */
442
443struct 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,
449
450 /* command interface -- queued only */
451 .queuecommand = queuecommand,
452
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,
457
458 /* queue commands only, only one command per LUN */
459 .can_queue = 1,
460 .cmd_per_lun = 1,
461
462 /* unknown initiator id */
463 .this_id = -1,
464
465 .slave_alloc = slave_alloc,
466 .slave_configure = slave_configure,
467
468 /* lots of sg segments can be handled */
469 .sg_tablesize = SG_ALL,
470
471 /* limit the total size of a transfer to 120 KB */
472 .max_sectors = 240,
473
474 /* merge commands... this seems to help performance, but
475 * periodically someone should test to see which setting is more
476 * optimal.
477 */
478 .use_clustering = 1,
479
480 /* emulated HBA */
481 .emulated = 1,
482
483 /* we do our own delay after a device or bus reset */
484 .skip_settle_delay = 1,
485
486 /* sysfs device attributes */
487 .sdev_attrs = sysfs_device_attr_list,
488
489 /* module management */
490 .module = THIS_MODULE
491};
492
493/* To Report "Illegal Request: Invalid Field in CDB */
494unsigned 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 */
499};
500