blob: da2bfa944b964a5e03ba9ed16d8e9ce155c9993e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
237 /* Wait for the aborted command to finish */
238 wait_for_completion(&us->notify);
239
240 /* Reacquire the lock and allow USB transfers to resume */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 clear_bit(US_FLIDX_ABORTING, &us->flags);
242 clear_bit(US_FLIDX_TIMED_OUT, &us->flags);
243 return SUCCESS;
244}
245
246/* This invokes the transport reset mechanism to reset the state of the
247 * device */
248/* This is always called with scsi_lock(host) held */
249static int device_reset(struct scsi_cmnd *srb)
250{
251 struct us_data *us = host_to_us(srb->device->host);
252 int result;
253
254 US_DEBUGP("%s called\n", __FUNCTION__);
255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 /* lock the device pointers and do the reset */
257 down(&(us->dev_semaphore));
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700258 result = us->transport_reset(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 up(&(us->dev_semaphore));
260
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700261 return result < 0 ? FAILED : SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262}
263
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700264/* Simulate a SCSI bus reset by resetting the device's USB port. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265/* This is always called with scsi_lock(host) held */
266static int bus_reset(struct scsi_cmnd *srb)
267{
268 struct us_data *us = host_to_us(srb->device->host);
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700269 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 US_DEBUGP("%s called\n", __FUNCTION__);
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 down(&(us->dev_semaphore));
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700274 result = usb_stor_port_reset(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 up(&(us->dev_semaphore));
276
277 /* lock the host for the return */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 return result < 0 ? FAILED : SUCCESS;
279}
280
281/* Report a driver-initiated device reset to the SCSI layer.
282 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
283 * The caller must own the SCSI host lock. */
284void usb_stor_report_device_reset(struct us_data *us)
285{
286 int i;
287 struct Scsi_Host *host = us_to_host(us);
288
289 scsi_report_device_reset(host, 0, 0);
290 if (us->flags & US_FL_SCM_MULT_TARG) {
291 for (i = 1; i < host->max_id; ++i)
292 scsi_report_device_reset(host, 0, i);
293 }
294}
295
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700296/* Report a driver-initiated bus reset to the SCSI layer.
297 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
298 * The caller must own the SCSI host lock. */
299void usb_stor_report_bus_reset(struct us_data *us)
300{
301 scsi_report_bus_reset(us_to_host(us), 0);
302}
303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304/***********************************************************************
305 * /proc/scsi/ functions
306 ***********************************************************************/
307
308/* we use this macro to help us write into the buffer */
309#undef SPRINTF
310#define SPRINTF(args...) \
311 do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
312
313static int proc_info (struct Scsi_Host *host, char *buffer,
314 char **start, off_t offset, int length, int inout)
315{
316 struct us_data *us = host_to_us(host);
317 char *pos = buffer;
318 const char *string;
319
320 /* if someone is sending us data, just throw it away */
321 if (inout)
322 return length;
323
324 /* print the controller name */
325 SPRINTF(" Host scsi%d: usb-storage\n", host->host_no);
326
327 /* print product, vendor, and serial number strings */
328 if (us->pusb_dev->manufacturer)
329 string = us->pusb_dev->manufacturer;
330 else if (us->unusual_dev->vendorName)
331 string = us->unusual_dev->vendorName;
332 else
333 string = "Unknown";
334 SPRINTF(" Vendor: %s\n", string);
335 if (us->pusb_dev->product)
336 string = us->pusb_dev->product;
337 else if (us->unusual_dev->productName)
338 string = us->unusual_dev->productName;
339 else
340 string = "Unknown";
341 SPRINTF(" Product: %s\n", string);
342 if (us->pusb_dev->serial)
343 string = us->pusb_dev->serial;
344 else
345 string = "None";
346 SPRINTF("Serial Number: %s\n", string);
347
348 /* show the protocol and transport */
349 SPRINTF(" Protocol: %s\n", us->protocol_name);
350 SPRINTF(" Transport: %s\n", us->transport_name);
351
352 /* show the device flags */
353 if (pos < buffer + length) {
354 pos += sprintf(pos, " Quirks:");
355
356#define US_FLAG(name, value) \
357 if (us->flags & value) pos += sprintf(pos, " " #name);
358US_DO_ALL_FLAGS
359#undef US_FLAG
360
361 *(pos++) = '\n';
362 }
363
364 /*
365 * Calculate start of next buffer, and return value.
366 */
367 *start = buffer + offset;
368
369 if ((pos - buffer) < offset)
370 return (0);
371 else if ((pos - buffer - offset) < length)
372 return (pos - buffer - offset);
373 else
374 return (length);
375}
376
377/***********************************************************************
378 * Sysfs interface
379 ***********************************************************************/
380
381/* Output routine for the sysfs max_sectors file */
Yani Ioannou060b8842005-05-17 06:44:04 -0400382static ssize_t show_max_sectors(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383{
384 struct scsi_device *sdev = to_scsi_device(dev);
385
386 return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
387}
388
389/* Input routine for the sysfs max_sectors file */
Yani Ioannou060b8842005-05-17 06:44:04 -0400390static ssize_t store_max_sectors(struct device *dev, struct device_attribute *attr, const char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 size_t count)
392{
393 struct scsi_device *sdev = to_scsi_device(dev);
394 unsigned short ms;
395
396 if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
397 blk_queue_max_sectors(sdev->request_queue, ms);
398 return strlen(buf);
399 }
400 return -EINVAL;
401}
402
403static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
404 store_max_sectors);
405
406static struct device_attribute *sysfs_device_attr_list[] = {
407 &dev_attr_max_sectors,
408 NULL,
409 };
410
411/*
412 * this defines our host template, with which we'll allocate hosts
413 */
414
415struct scsi_host_template usb_stor_host_template = {
416 /* basic userland interface stuff */
417 .name = "usb-storage",
418 .proc_name = "usb-storage",
419 .proc_info = proc_info,
420 .info = host_info,
421
422 /* command interface -- queued only */
423 .queuecommand = queuecommand,
424
425 /* error and abort handlers */
426 .eh_abort_handler = command_abort,
427 .eh_device_reset_handler = device_reset,
428 .eh_bus_reset_handler = bus_reset,
429
430 /* queue commands only, only one command per LUN */
431 .can_queue = 1,
432 .cmd_per_lun = 1,
433
434 /* unknown initiator id */
435 .this_id = -1,
436
437 .slave_alloc = slave_alloc,
438 .slave_configure = slave_configure,
439
440 /* lots of sg segments can be handled */
441 .sg_tablesize = SG_ALL,
442
443 /* limit the total size of a transfer to 120 KB */
444 .max_sectors = 240,
445
446 /* merge commands... this seems to help performance, but
447 * periodically someone should test to see which setting is more
448 * optimal.
449 */
450 .use_clustering = 1,
451
452 /* emulated HBA */
453 .emulated = 1,
454
455 /* we do our own delay after a device or bus reset */
456 .skip_settle_delay = 1,
457
458 /* sysfs device attributes */
459 .sdev_attrs = sysfs_device_attr_list,
460
461 /* module management */
462 .module = THIS_MODULE
463};
464
465/* To Report "Illegal Request: Invalid Field in CDB */
466unsigned char usb_stor_sense_invalidCDB[18] = {
467 [0] = 0x70, /* current error */
468 [2] = ILLEGAL_REQUEST, /* Illegal Request = 0x05 */
469 [7] = 0x0a, /* additional length */
470 [12] = 0x24 /* Invalid Field in CDB */
471};
472