Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* Driver for USB Mass Storage compliant devices |
| 2 | * SCSI layer glue code |
| 3 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * Current development and maintenance by: |
| 5 | * (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net) |
| 6 | * |
| 7 | * Developed with the assistance of: |
| 8 | * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org) |
| 9 | * (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov) |
| 10 | * |
| 11 | * Initial work by: |
| 12 | * (c) 1999 Michael Gee (michael@linuxspecific.com) |
| 13 | * |
| 14 | * This driver is based on the 'USB Mass Storage Class' document. This |
| 15 | * describes in detail the protocol used to communicate with such |
| 16 | * devices. Clearly, the designers had SCSI and ATAPI commands in |
| 17 | * mind when they created this document. The commands are all very |
| 18 | * similar to commands in the SCSI-II and ATAPI specifications. |
| 19 | * |
| 20 | * It is important to note that in a number of cases this class |
| 21 | * exhibits class-specific exemptions from the USB specification. |
| 22 | * Notably the usage of NAK, STALL and ACK differs from the norm, in |
| 23 | * that they are used to communicate wait, failed and OK on commands. |
| 24 | * |
| 25 | * Also, for certain devices, the interrupt endpoint is used to convey |
| 26 | * status of a command. |
| 27 | * |
| 28 | * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more |
| 29 | * information about this driver. |
| 30 | * |
| 31 | * This program is free software; you can redistribute it and/or modify it |
| 32 | * under the terms of the GNU General Public License as published by the |
| 33 | * Free Software Foundation; either version 2, or (at your option) any |
| 34 | * later version. |
| 35 | * |
| 36 | * This program is distributed in the hope that it will be useful, but |
| 37 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 38 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 39 | * General Public License for more details. |
| 40 | * |
| 41 | * You should have received a copy of the GNU General Public License along |
| 42 | * with this program; if not, write to the Free Software Foundation, Inc., |
| 43 | * 675 Mass Ave, Cambridge, MA 02139, USA. |
| 44 | */ |
| 45 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | #include <linux/module.h> |
Arjan van de Ven | 4186ecf | 2006-01-11 15:55:29 +0100 | [diff] [blame] | 47 | #include <linux/mutex.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | |
| 49 | #include <scsi/scsi.h> |
| 50 | #include <scsi/scsi_cmnd.h> |
| 51 | #include <scsi/scsi_devinfo.h> |
| 52 | #include <scsi/scsi_device.h> |
| 53 | #include <scsi/scsi_eh.h> |
| 54 | |
| 55 | #include "usb.h" |
| 56 | #include "scsiglue.h" |
| 57 | #include "debug.h" |
| 58 | #include "transport.h" |
| 59 | #include "protocol.h" |
| 60 | |
Alan Stern | a81a81a | 2008-12-18 16:41:49 -0500 | [diff] [blame] | 61 | /* Vendor IDs for companies that seem to include the READ CAPACITY bug |
| 62 | * in all their devices |
| 63 | */ |
| 64 | #define VENDOR_ID_NOKIA 0x0421 |
| 65 | #define VENDOR_ID_NIKON 0x04b0 |
Alan Stern | 506e946 | 2009-02-04 15:48:03 -0500 | [diff] [blame] | 66 | #define VENDOR_ID_PENTAX 0x0a17 |
Alan Stern | a81a81a | 2008-12-18 16:41:49 -0500 | [diff] [blame] | 67 | #define VENDOR_ID_MOTOROLA 0x22b8 |
| 68 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | /*********************************************************************** |
| 70 | * Host functions |
| 71 | ***********************************************************************/ |
| 72 | |
| 73 | static const char* host_info(struct Scsi_Host *host) |
| 74 | { |
Matthew Wilcox | 00fa43e | 2009-09-24 16:19:11 -0600 | [diff] [blame] | 75 | struct us_data *us = host_to_us(host); |
| 76 | return us->scsi_name; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | } |
| 78 | |
| 79 | static int slave_alloc (struct scsi_device *sdev) |
| 80 | { |
| 81 | /* |
| 82 | * Set the INQUIRY transfer length to 36. We don't use any of |
| 83 | * the extra data and many devices choke if asked for more or |
| 84 | * less than 36 bytes. |
| 85 | */ |
| 86 | sdev->inquiry_len = 36; |
Alan Stern | 3a3416b | 2006-08-21 12:00:53 -0400 | [diff] [blame] | 87 | |
Alan Stern | f756cbd | 2008-06-30 13:39:59 -0400 | [diff] [blame] | 88 | /* USB has unusual DMA-alignment requirements: Although the |
| 89 | * starting address of each scatter-gather element doesn't matter, |
| 90 | * the length of each element except the last must be divisible |
| 91 | * by the Bulk maxpacket value. There's currently no way to |
| 92 | * express this by block-layer constraints, so we'll cop out |
| 93 | * and simply require addresses to be aligned at 512-byte |
| 94 | * boundaries. This is okay since most block I/O involves |
| 95 | * hardware sectors that are multiples of 512 bytes in length, |
| 96 | * and since host controllers up through USB 2.0 have maxpacket |
| 97 | * values no larger than 512. |
| 98 | * |
| 99 | * But it doesn't suffice for Wireless USB, where Bulk maxpacket |
| 100 | * values can be as large as 2048. To make that work properly |
| 101 | * will require changes to the block layer. |
Alan Stern | 148d9fe | 2008-03-27 14:52:57 -0400 | [diff] [blame] | 102 | */ |
Alan Stern | f756cbd | 2008-06-30 13:39:59 -0400 | [diff] [blame] | 103 | blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1)); |
James Bottomley | 465ff31 | 2008-01-01 10:00:10 -0600 | [diff] [blame] | 104 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | return 0; |
| 106 | } |
| 107 | |
| 108 | static int slave_configure(struct scsi_device *sdev) |
| 109 | { |
| 110 | struct us_data *us = host_to_us(sdev->host); |
| 111 | |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 112 | /* Many devices have trouble transferring more than 32KB at a time, |
Phil Dibowitz | 883d989 | 2006-06-24 17:27:10 -0700 | [diff] [blame] | 113 | * while others have trouble with more than 64K. At this time we |
| 114 | * are limiting both to 32K (64 sectores). |
| 115 | */ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 116 | if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) { |
Doug Maxey | 33abc04 | 2007-12-05 23:36:45 -0600 | [diff] [blame] | 117 | unsigned int max_sectors = 64; |
| 118 | |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 119 | if (us->fflags & US_FL_MAX_SECTORS_MIN) |
Doug Maxey | 33abc04 | 2007-12-05 23:36:45 -0600 | [diff] [blame] | 120 | max_sectors = PAGE_CACHE_SIZE >> 9; |
Alan Stern | 49d6271 | 2010-02-26 11:49:39 -0500 | [diff] [blame] | 121 | if (queue_max_hw_sectors(sdev->request_queue) > max_sectors) |
Martin K. Petersen | 086fa5f | 2010-02-26 00:20:38 -0500 | [diff] [blame] | 122 | blk_queue_max_hw_sectors(sdev->request_queue, |
Doug Maxey | 33abc04 | 2007-12-05 23:36:45 -0600 | [diff] [blame] | 123 | max_sectors); |
Alan Stern | 5c16034 | 2009-03-23 09:51:02 -0400 | [diff] [blame] | 124 | } else if (sdev->type == TYPE_TAPE) { |
| 125 | /* Tapes need much higher max_sector limits, so just |
| 126 | * raise it to the maximum possible (4 GB / 512) and |
| 127 | * let the queue segment size sort out the real limit. |
| 128 | */ |
Martin K. Petersen | 086fa5f | 2010-02-26 00:20:38 -0500 | [diff] [blame] | 129 | blk_queue_max_hw_sectors(sdev->request_queue, 0x7FFFFF); |
Doug Maxey | 33abc04 | 2007-12-05 23:36:45 -0600 | [diff] [blame] | 130 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | |
Alan Stern | 96983d2 | 2008-11-21 11:46:17 -0500 | [diff] [blame] | 132 | /* Some USB host controllers can't do DMA; they have to use PIO. |
| 133 | * They indicate this by setting their dma_mask to NULL. For |
| 134 | * such controllers we need to make sure the block layer sets |
| 135 | * up bounce buffers in addressable memory. |
| 136 | */ |
| 137 | if (!us->pusb_dev->bus->controller->dma_mask) |
| 138 | blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_HIGH); |
| 139 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | /* We can't put these settings in slave_alloc() because that gets |
| 141 | * called before the device type is known. Consequently these |
| 142 | * settings can't be overridden via the scsi devinfo mechanism. */ |
| 143 | if (sdev->type == TYPE_DISK) { |
| 144 | |
Alan Stern | a81a81a | 2008-12-18 16:41:49 -0500 | [diff] [blame] | 145 | /* Some vendors seem to put the READ CAPACITY bug into |
| 146 | * all their devices -- primarily makers of cell phones |
| 147 | * and digital cameras. Since these devices always use |
| 148 | * flash media and can be expected to have an even number |
| 149 | * of sectors, we will always enable the CAPACITY_HEURISTICS |
| 150 | * flag unless told otherwise. */ |
| 151 | switch (le16_to_cpu(us->pusb_dev->descriptor.idVendor)) { |
| 152 | case VENDOR_ID_NOKIA: |
| 153 | case VENDOR_ID_NIKON: |
Alan Stern | 506e946 | 2009-02-04 15:48:03 -0500 | [diff] [blame] | 154 | case VENDOR_ID_PENTAX: |
Alan Stern | a81a81a | 2008-12-18 16:41:49 -0500 | [diff] [blame] | 155 | case VENDOR_ID_MOTOROLA: |
| 156 | if (!(us->fflags & (US_FL_FIX_CAPACITY | |
| 157 | US_FL_CAPACITY_OK))) |
| 158 | us->fflags |= US_FL_CAPACITY_HEURISTICS; |
| 159 | break; |
| 160 | } |
| 161 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | /* Disk-type devices use MODE SENSE(6) if the protocol |
| 163 | * (SubClass) is Transparent SCSI, otherwise they use |
| 164 | * MODE SENSE(10). */ |
Michal Nazarewicz | 8fa7fd7 | 2010-10-07 13:05:21 +0200 | [diff] [blame] | 165 | if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | sdev->use_10_for_ms = 1; |
| 167 | |
| 168 | /* Many disks only accept MODE SENSE transfer lengths of |
| 169 | * 192 bytes (that's what Windows uses). */ |
| 170 | sdev->use_192_bytes_for_3f = 1; |
| 171 | |
| 172 | /* Some devices don't like MODE SENSE with page=0x3f, |
| 173 | * which is the command used for checking if a device |
| 174 | * is write-protected. Now that we tell the sd driver |
| 175 | * to do a 192-byte transfer with this command the |
| 176 | * majority of devices work fine, but a few still can't |
| 177 | * handle it. The sd driver will simply assume those |
| 178 | * devices are write-enabled. */ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 179 | if (us->fflags & US_FL_NO_WP_DETECT) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | sdev->skip_ms_page_3f = 1; |
| 181 | |
| 182 | /* A number of devices have problems with MODE SENSE for |
| 183 | * page x08, so we will skip it. */ |
| 184 | sdev->skip_ms_page_8 = 1; |
| 185 | |
Alan Stern | 09b6b51 | 2012-01-10 13:43:30 -0500 | [diff] [blame] | 186 | /* Some devices don't handle VPD pages correctly */ |
| 187 | sdev->skip_vpd_pages = 1; |
| 188 | |
Martin K. Petersen | 3c6bdae | 2012-09-18 12:19:30 -0400 | [diff] [blame] | 189 | /* Do not attempt to use REPORT SUPPORTED OPERATION CODES */ |
| 190 | sdev->no_report_opcodes = 1; |
| 191 | |
Martin K. Petersen | 5db4486 | 2012-09-18 12:19:32 -0400 | [diff] [blame^] | 192 | /* Do not attempt to use WRITE SAME */ |
| 193 | sdev->no_write_same = 1; |
| 194 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | /* Some disks return the total number of blocks in response |
| 196 | * to READ CAPACITY rather than the highest block number. |
| 197 | * If this device makes that mistake, tell the sd driver. */ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 198 | if (us->fflags & US_FL_FIX_CAPACITY) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | sdev->fix_capacity = 1; |
Matthew Dharm | 86dbde9 | 2005-06-06 17:22:42 -0700 | [diff] [blame] | 200 | |
Oliver Neukum | 61bf54b | 2007-02-08 09:04:48 +0100 | [diff] [blame] | 201 | /* A few disks have two indistinguishable version, one of |
| 202 | * which reports the correct capacity and the other does not. |
| 203 | * The sd driver has to guess which is the case. */ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 204 | if (us->fflags & US_FL_CAPACITY_HEURISTICS) |
Oliver Neukum | 61bf54b | 2007-02-08 09:04:48 +0100 | [diff] [blame] | 205 | sdev->guess_capacity = 1; |
| 206 | |
Hans de Goede | 0091402 | 2010-10-01 14:20:11 -0700 | [diff] [blame] | 207 | /* Some devices cannot handle READ_CAPACITY_16 */ |
| 208 | if (us->fflags & US_FL_NO_READ_CAPACITY_16) |
| 209 | sdev->no_read_capacity_16 = 1; |
| 210 | |
Alan Stern | 6a0bdff | 2012-06-20 16:04:19 -0400 | [diff] [blame] | 211 | /* |
| 212 | * Many devices do not respond properly to READ_CAPACITY_16. |
| 213 | * Tell the SCSI layer to try READ_CAPACITY_10 first. |
| 214 | */ |
| 215 | sdev->try_rc_10_first = 1; |
| 216 | |
Ben Efros | 1537e0a | 2008-11-18 13:31:13 -0800 | [diff] [blame] | 217 | /* assume SPC3 or latter devices support sense size > 18 */ |
| 218 | if (sdev->scsi_level > SCSI_SPC_2) |
| 219 | us->fflags |= US_FL_SANE_SENSE; |
| 220 | |
Matthew Dharm | 86dbde9 | 2005-06-06 17:22:42 -0700 | [diff] [blame] | 221 | /* USB-IDE bridges tend to report SK = 0x04 (Non-recoverable |
| 222 | * Hardware Error) when any low-level error occurs, |
| 223 | * recoverable or not. Setting this flag tells the SCSI |
| 224 | * midlayer to retry such commands, which frequently will |
| 225 | * succeed and fix the error. The worst this can lead to |
| 226 | * is an occasional series of retries that will all fail. */ |
| 227 | sdev->retry_hwerror = 1; |
| 228 | |
Mauro Carvalho Chehab | f09e495 | 2007-10-10 16:29:02 -0400 | [diff] [blame] | 229 | /* USB disks should allow restart. Some drives spin down |
| 230 | * automatically, requiring a START-STOP UNIT command. */ |
| 231 | sdev->allow_restart = 1; |
| 232 | |
Hans de Goede | 23c3e29 | 2008-01-20 11:27:29 +0100 | [diff] [blame] | 233 | /* Some USB cardreaders have trouble reading an sdcard's last |
| 234 | * sector in a larger then 1 sector read, since the performance |
| 235 | * impact is negible we set this flag for all USB disks */ |
| 236 | sdev->last_sector_bug = 1; |
Alan Stern | 25ff1c3 | 2008-12-15 12:43:41 -0500 | [diff] [blame] | 237 | |
| 238 | /* Enable last-sector hacks for single-target devices using |
| 239 | * the Bulk-only transport, unless we already know the |
| 240 | * capacity will be decremented or is correct. */ |
| 241 | if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK | |
| 242 | US_FL_SCM_MULT_TARG)) && |
Michal Nazarewicz | 8fa7fd7 | 2010-10-07 13:05:21 +0200 | [diff] [blame] | 243 | us->protocol == USB_PR_BULK) |
Alan Stern | 25ff1c3 | 2008-12-15 12:43:41 -0500 | [diff] [blame] | 244 | us->use_last_sector_hacks = 1; |
Namjae Jeon | eaa05df | 2012-07-07 23:05:28 -0400 | [diff] [blame] | 245 | |
| 246 | /* Check if write cache default on flag is set or not */ |
| 247 | if (us->fflags & US_FL_WRITE_CACHE) |
| 248 | sdev->wce_default_on = 1; |
| 249 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 250 | } else { |
| 251 | |
| 252 | /* Non-disk-type devices don't need to blacklist any pages |
| 253 | * or to force 192-byte transfer lengths for MODE SENSE. |
| 254 | * But they do need to use MODE SENSE(10). */ |
| 255 | sdev->use_10_for_ms = 1; |
Hans de Goede | ae38c78 | 2010-10-01 14:20:10 -0700 | [diff] [blame] | 256 | |
| 257 | /* Some (fake) usb cdrom devices don't like READ_DISC_INFO */ |
| 258 | if (us->fflags & US_FL_NO_READ_DISC_INFO) |
| 259 | sdev->no_read_disc_info = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | } |
| 261 | |
Alan Stern | f3f4906 | 2007-01-08 16:18:05 -0500 | [diff] [blame] | 262 | /* The CB and CBI transports have no way to pass LUN values |
| 263 | * other than the bits in the second byte of a CDB. But those |
| 264 | * bits don't get set to the LUN value if the device reports |
| 265 | * scsi_level == 0 (UNKNOWN). Hence such devices must necessarily |
| 266 | * be single-LUN. |
| 267 | */ |
Michal Nazarewicz | 8fa7fd7 | 2010-10-07 13:05:21 +0200 | [diff] [blame] | 268 | if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) && |
Alan Stern | f3f4906 | 2007-01-08 16:18:05 -0500 | [diff] [blame] | 269 | sdev->scsi_level == SCSI_UNKNOWN) |
| 270 | us->max_lun = 0; |
| 271 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | /* Some devices choke when they receive a PREVENT-ALLOW MEDIUM |
| 273 | * REMOVAL command, so suppress those commands. */ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 274 | if (us->fflags & US_FL_NOT_LOCKABLE) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | sdev->lockable = 0; |
| 276 | |
| 277 | /* this is to satisfy the compiler, tho I don't think the |
| 278 | * return code is ever checked anywhere. */ |
| 279 | return 0; |
| 280 | } |
| 281 | |
Alan Stern | 09b6b51 | 2012-01-10 13:43:30 -0500 | [diff] [blame] | 282 | static int target_alloc(struct scsi_target *starget) |
| 283 | { |
Alan Stern | af74d2d | 2012-01-10 13:43:40 -0500 | [diff] [blame] | 284 | struct us_data *us = host_to_us(dev_to_shost(starget->dev.parent)); |
| 285 | |
Alan Stern | 09b6b51 | 2012-01-10 13:43:30 -0500 | [diff] [blame] | 286 | /* |
| 287 | * Some USB drives don't support REPORT LUNS, even though they |
| 288 | * report a SCSI revision level above 2. Tell the SCSI layer |
| 289 | * not to issue that command; it will perform a normal sequential |
| 290 | * scan instead. |
| 291 | */ |
| 292 | starget->no_report_luns = 1; |
Alan Stern | af74d2d | 2012-01-10 13:43:40 -0500 | [diff] [blame] | 293 | |
| 294 | /* |
| 295 | * The UFI spec treats the Peripheral Qualifier bits in an |
| 296 | * INQUIRY result as reserved and requires devices to set them |
| 297 | * to 0. However the SCSI spec requires these bits to be set |
| 298 | * to 3 to indicate when a LUN is not present. |
| 299 | * |
| 300 | * Let the scanning code know if this target merely sets |
| 301 | * Peripheral Device Type to 0x1f to indicate no LUN. |
| 302 | */ |
| 303 | if (us->subclass == USB_SC_UFI) |
| 304 | starget->pdt_1f_for_no_lun = 1; |
| 305 | |
Alan Stern | 09b6b51 | 2012-01-10 13:43:30 -0500 | [diff] [blame] | 306 | return 0; |
| 307 | } |
| 308 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | /* queue a command */ |
| 310 | /* This is always called with scsi_lock(host) held */ |
Jeff Garzik | f281233 | 2010-11-16 02:10:29 -0500 | [diff] [blame] | 311 | static int queuecommand_lck(struct scsi_cmnd *srb, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | void (*done)(struct scsi_cmnd *)) |
| 313 | { |
| 314 | struct us_data *us = host_to_us(srb->device->host); |
| 315 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 316 | US_DEBUGP("%s called\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | |
| 318 | /* check for state-transition errors */ |
| 319 | if (us->srb != NULL) { |
| 320 | printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 321 | __func__, us->srb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | return SCSI_MLQUEUE_HOST_BUSY; |
| 323 | } |
| 324 | |
| 325 | /* fail the command if we are disconnecting */ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 326 | if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | US_DEBUGP("Fail command during disconnect\n"); |
| 328 | srb->result = DID_NO_CONNECT << 16; |
| 329 | done(srb); |
| 330 | return 0; |
| 331 | } |
| 332 | |
| 333 | /* enqueue the command and wake up the control thread */ |
| 334 | srb->scsi_done = done; |
| 335 | us->srb = srb; |
Alan Stern | 7119e3c | 2008-05-01 15:36:13 -0400 | [diff] [blame] | 336 | complete(&us->cmnd_ready); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | |
| 338 | return 0; |
| 339 | } |
| 340 | |
Jeff Garzik | f281233 | 2010-11-16 02:10:29 -0500 | [diff] [blame] | 341 | static DEF_SCSI_QCMD(queuecommand) |
| 342 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | /*********************************************************************** |
| 344 | * Error handling functions |
| 345 | ***********************************************************************/ |
| 346 | |
| 347 | /* Command timeout and abort */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | static int command_abort(struct scsi_cmnd *srb) |
| 349 | { |
| 350 | struct us_data *us = host_to_us(srb->device->host); |
| 351 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 352 | US_DEBUGP("%s called\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | |
Matthew Dharm | 226173e | 2005-08-25 20:03:50 -0700 | [diff] [blame] | 354 | /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING |
| 355 | * bits are protected by the host lock. */ |
| 356 | scsi_lock(us_to_host(us)); |
| 357 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | /* Is this command still active? */ |
| 359 | if (us->srb != srb) { |
Matthew Dharm | 226173e | 2005-08-25 20:03:50 -0700 | [diff] [blame] | 360 | scsi_unlock(us_to_host(us)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | US_DEBUGP ("-- nothing to abort\n"); |
| 362 | return FAILED; |
| 363 | } |
| 364 | |
| 365 | /* Set the TIMED_OUT bit. Also set the ABORTING bit, but only if |
| 366 | * a device reset isn't already in progress (to avoid interfering |
Matthew Dharm | 226173e | 2005-08-25 20:03:50 -0700 | [diff] [blame] | 367 | * with the reset). Note that we must retain the host lock while |
| 368 | * calling usb_stor_stop_transport(); otherwise it might interfere |
| 369 | * with an auto-reset that begins as soon as we release the lock. */ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 370 | set_bit(US_FLIDX_TIMED_OUT, &us->dflags); |
| 371 | if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) { |
| 372 | set_bit(US_FLIDX_ABORTING, &us->dflags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 373 | usb_stor_stop_transport(us); |
| 374 | } |
Matthew Dharm | 226173e | 2005-08-25 20:03:50 -0700 | [diff] [blame] | 375 | scsi_unlock(us_to_host(us)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | |
| 377 | /* Wait for the aborted command to finish */ |
| 378 | wait_for_completion(&us->notify); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | return SUCCESS; |
| 380 | } |
| 381 | |
| 382 | /* This invokes the transport reset mechanism to reset the state of the |
| 383 | * device */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | static int device_reset(struct scsi_cmnd *srb) |
| 385 | { |
| 386 | struct us_data *us = host_to_us(srb->device->host); |
| 387 | int result; |
| 388 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 389 | US_DEBUGP("%s called\n", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | |
Greg Kroah-Hartman | d526875 | 2007-09-13 06:01:24 -0700 | [diff] [blame] | 391 | /* lock the device pointers and do the reset */ |
| 392 | mutex_lock(&(us->dev_mutex)); |
| 393 | result = us->transport_reset(us); |
| 394 | mutex_unlock(&us->dev_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | |
Matthew Dharm | 4d07ef7 | 2005-06-06 17:21:41 -0700 | [diff] [blame] | 396 | return result < 0 ? FAILED : SUCCESS; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | } |
| 398 | |
Matthew Dharm | 4d07ef7 | 2005-06-06 17:21:41 -0700 | [diff] [blame] | 399 | /* Simulate a SCSI bus reset by resetting the device's USB port. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | static int bus_reset(struct scsi_cmnd *srb) |
| 401 | { |
| 402 | struct us_data *us = host_to_us(srb->device->host); |
Matthew Dharm | 4d07ef7 | 2005-06-06 17:21:41 -0700 | [diff] [blame] | 403 | int result; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 404 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 405 | US_DEBUGP("%s called\n", __func__); |
Matthew Dharm | 4d07ef7 | 2005-06-06 17:21:41 -0700 | [diff] [blame] | 406 | result = usb_stor_port_reset(us); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 407 | return result < 0 ? FAILED : SUCCESS; |
| 408 | } |
| 409 | |
| 410 | /* Report a driver-initiated device reset to the SCSI layer. |
| 411 | * Calling this for a SCSI-initiated reset is unnecessary but harmless. |
| 412 | * The caller must own the SCSI host lock. */ |
| 413 | void usb_stor_report_device_reset(struct us_data *us) |
| 414 | { |
| 415 | int i; |
| 416 | struct Scsi_Host *host = us_to_host(us); |
| 417 | |
| 418 | scsi_report_device_reset(host, 0, 0); |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 419 | if (us->fflags & US_FL_SCM_MULT_TARG) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 420 | for (i = 1; i < host->max_id; ++i) |
| 421 | scsi_report_device_reset(host, 0, i); |
| 422 | } |
| 423 | } |
| 424 | |
Matthew Dharm | 4d07ef7 | 2005-06-06 17:21:41 -0700 | [diff] [blame] | 425 | /* Report a driver-initiated bus reset to the SCSI layer. |
| 426 | * Calling this for a SCSI-initiated reset is unnecessary but harmless. |
Alan Stern | f07600c | 2007-05-30 15:38:16 -0400 | [diff] [blame] | 427 | * The caller must not own the SCSI host lock. */ |
Matthew Dharm | 4d07ef7 | 2005-06-06 17:21:41 -0700 | [diff] [blame] | 428 | void usb_stor_report_bus_reset(struct us_data *us) |
| 429 | { |
Alan Stern | f07600c | 2007-05-30 15:38:16 -0400 | [diff] [blame] | 430 | struct Scsi_Host *host = us_to_host(us); |
| 431 | |
| 432 | scsi_lock(host); |
| 433 | scsi_report_bus_reset(host, 0); |
| 434 | scsi_unlock(host); |
Matthew Dharm | 4d07ef7 | 2005-06-06 17:21:41 -0700 | [diff] [blame] | 435 | } |
| 436 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 437 | /*********************************************************************** |
| 438 | * /proc/scsi/ functions |
| 439 | ***********************************************************************/ |
| 440 | |
| 441 | /* we use this macro to help us write into the buffer */ |
| 442 | #undef SPRINTF |
| 443 | #define SPRINTF(args...) \ |
| 444 | do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0) |
| 445 | |
| 446 | static int proc_info (struct Scsi_Host *host, char *buffer, |
| 447 | char **start, off_t offset, int length, int inout) |
| 448 | { |
| 449 | struct us_data *us = host_to_us(host); |
| 450 | char *pos = buffer; |
| 451 | const char *string; |
| 452 | |
| 453 | /* if someone is sending us data, just throw it away */ |
| 454 | if (inout) |
| 455 | return length; |
| 456 | |
| 457 | /* print the controller name */ |
| 458 | SPRINTF(" Host scsi%d: usb-storage\n", host->host_no); |
| 459 | |
| 460 | /* print product, vendor, and serial number strings */ |
| 461 | if (us->pusb_dev->manufacturer) |
| 462 | string = us->pusb_dev->manufacturer; |
| 463 | else if (us->unusual_dev->vendorName) |
| 464 | string = us->unusual_dev->vendorName; |
| 465 | else |
| 466 | string = "Unknown"; |
| 467 | SPRINTF(" Vendor: %s\n", string); |
| 468 | if (us->pusb_dev->product) |
| 469 | string = us->pusb_dev->product; |
| 470 | else if (us->unusual_dev->productName) |
| 471 | string = us->unusual_dev->productName; |
| 472 | else |
| 473 | string = "Unknown"; |
| 474 | SPRINTF(" Product: %s\n", string); |
| 475 | if (us->pusb_dev->serial) |
| 476 | string = us->pusb_dev->serial; |
| 477 | else |
| 478 | string = "None"; |
| 479 | SPRINTF("Serial Number: %s\n", string); |
| 480 | |
| 481 | /* show the protocol and transport */ |
| 482 | SPRINTF(" Protocol: %s\n", us->protocol_name); |
| 483 | SPRINTF(" Transport: %s\n", us->transport_name); |
| 484 | |
| 485 | /* show the device flags */ |
| 486 | if (pos < buffer + length) { |
| 487 | pos += sprintf(pos, " Quirks:"); |
| 488 | |
| 489 | #define US_FLAG(name, value) \ |
Alan Stern | 7e4d6c3 | 2008-05-01 15:35:18 -0400 | [diff] [blame] | 490 | if (us->fflags & value) pos += sprintf(pos, " " #name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 491 | US_DO_ALL_FLAGS |
| 492 | #undef US_FLAG |
| 493 | |
| 494 | *(pos++) = '\n'; |
| 495 | } |
| 496 | |
| 497 | /* |
| 498 | * Calculate start of next buffer, and return value. |
| 499 | */ |
| 500 | *start = buffer + offset; |
| 501 | |
| 502 | if ((pos - buffer) < offset) |
| 503 | return (0); |
| 504 | else if ((pos - buffer - offset) < length) |
| 505 | return (pos - buffer - offset); |
| 506 | else |
| 507 | return (length); |
| 508 | } |
| 509 | |
| 510 | /*********************************************************************** |
| 511 | * Sysfs interface |
| 512 | ***********************************************************************/ |
| 513 | |
| 514 | /* Output routine for the sysfs max_sectors file */ |
Yani Ioannou | 060b884 | 2005-05-17 06:44:04 -0400 | [diff] [blame] | 515 | static ssize_t show_max_sectors(struct device *dev, struct device_attribute *attr, char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 516 | { |
| 517 | struct scsi_device *sdev = to_scsi_device(dev); |
| 518 | |
Alan Stern | 49d6271 | 2010-02-26 11:49:39 -0500 | [diff] [blame] | 519 | return sprintf(buf, "%u\n", queue_max_hw_sectors(sdev->request_queue)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | } |
| 521 | |
| 522 | /* Input routine for the sysfs max_sectors file */ |
Yani Ioannou | 060b884 | 2005-05-17 06:44:04 -0400 | [diff] [blame] | 523 | static ssize_t store_max_sectors(struct device *dev, struct device_attribute *attr, const char *buf, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 524 | size_t count) |
| 525 | { |
| 526 | struct scsi_device *sdev = to_scsi_device(dev); |
| 527 | unsigned short ms; |
| 528 | |
Alan Stern | 49d6271 | 2010-02-26 11:49:39 -0500 | [diff] [blame] | 529 | if (sscanf(buf, "%hu", &ms) > 0) { |
Martin K. Petersen | 086fa5f | 2010-02-26 00:20:38 -0500 | [diff] [blame] | 530 | blk_queue_max_hw_sectors(sdev->request_queue, ms); |
Alan Stern | 49d6271 | 2010-02-26 11:49:39 -0500 | [diff] [blame] | 531 | return count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 532 | } |
| 533 | return -EINVAL; |
| 534 | } |
| 535 | |
| 536 | static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors, |
| 537 | store_max_sectors); |
| 538 | |
| 539 | static struct device_attribute *sysfs_device_attr_list[] = { |
| 540 | &dev_attr_max_sectors, |
| 541 | NULL, |
| 542 | }; |
| 543 | |
| 544 | /* |
| 545 | * this defines our host template, with which we'll allocate hosts |
| 546 | */ |
| 547 | |
| 548 | struct scsi_host_template usb_stor_host_template = { |
| 549 | /* basic userland interface stuff */ |
| 550 | .name = "usb-storage", |
| 551 | .proc_name = "usb-storage", |
| 552 | .proc_info = proc_info, |
| 553 | .info = host_info, |
| 554 | |
| 555 | /* command interface -- queued only */ |
| 556 | .queuecommand = queuecommand, |
| 557 | |
| 558 | /* error and abort handlers */ |
| 559 | .eh_abort_handler = command_abort, |
| 560 | .eh_device_reset_handler = device_reset, |
| 561 | .eh_bus_reset_handler = bus_reset, |
| 562 | |
| 563 | /* queue commands only, only one command per LUN */ |
| 564 | .can_queue = 1, |
| 565 | .cmd_per_lun = 1, |
| 566 | |
| 567 | /* unknown initiator id */ |
| 568 | .this_id = -1, |
| 569 | |
| 570 | .slave_alloc = slave_alloc, |
| 571 | .slave_configure = slave_configure, |
Alan Stern | 09b6b51 | 2012-01-10 13:43:30 -0500 | [diff] [blame] | 572 | .target_alloc = target_alloc, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 573 | |
| 574 | /* lots of sg segments can be handled */ |
Alan Stern | 49d6271 | 2010-02-26 11:49:39 -0500 | [diff] [blame] | 575 | .sg_tablesize = SCSI_MAX_SG_CHAIN_SEGMENTS, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 576 | |
| 577 | /* limit the total size of a transfer to 120 KB */ |
| 578 | .max_sectors = 240, |
| 579 | |
| 580 | /* merge commands... this seems to help performance, but |
| 581 | * periodically someone should test to see which setting is more |
| 582 | * optimal. |
| 583 | */ |
| 584 | .use_clustering = 1, |
| 585 | |
| 586 | /* emulated HBA */ |
| 587 | .emulated = 1, |
| 588 | |
| 589 | /* we do our own delay after a device or bus reset */ |
| 590 | .skip_settle_delay = 1, |
| 591 | |
| 592 | /* sysfs device attributes */ |
| 593 | .sdev_attrs = sysfs_device_attr_list, |
| 594 | |
| 595 | /* module management */ |
| 596 | .module = THIS_MODULE |
| 597 | }; |
| 598 | |
| 599 | /* To Report "Illegal Request: Invalid Field in CDB */ |
| 600 | unsigned char usb_stor_sense_invalidCDB[18] = { |
| 601 | [0] = 0x70, /* current error */ |
| 602 | [2] = ILLEGAL_REQUEST, /* Illegal Request = 0x05 */ |
| 603 | [7] = 0x0a, /* additional length */ |
| 604 | [12] = 0x24 /* Invalid Field in CDB */ |
| 605 | }; |
Alan Stern | e6e244b | 2009-02-12 14:47:44 -0500 | [diff] [blame] | 606 | EXPORT_SYMBOL_GPL(usb_stor_sense_invalidCDB); |