Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 1 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 2 | |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 3 | #include <linux/slab.h> |
| 4 | #include <linux/module.h> |
| 5 | #include <linux/mutex.h> |
| 6 | |
| 7 | #include <scsi/scsi.h> |
| 8 | #include <scsi/scsi_cmnd.h> |
| 9 | #include <scsi/scsi_devinfo.h> |
| 10 | #include <scsi/scsi_device.h> |
| 11 | #include <scsi/scsi_eh.h> |
| 12 | |
| 13 | #include "usb.h" |
| 14 | #include "scsiglue.h" |
| 15 | #include "transport.h" |
| 16 | |
| 17 | /* Host functions */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 18 | /* |
| 19 | * host_info() |
| 20 | */ |
| 21 | static const char *host_info(struct Scsi_Host *host) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 22 | { |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 23 | /* pr_info("scsiglue --- host_info\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 24 | return "SCSI emulation for USB Mass Storage devices"; |
| 25 | } |
| 26 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 27 | /* |
| 28 | * slave_alloc() |
| 29 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 30 | static int slave_alloc(struct scsi_device *sdev) |
| 31 | { |
| 32 | struct us_data *us = host_to_us(sdev->host); |
| 33 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 34 | /* pr_info("scsiglue --- slave_alloc\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 35 | sdev->inquiry_len = 36; |
| 36 | |
| 37 | blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1)); |
| 38 | |
Greg Kroah-Hartman | bceaddd | 2010-10-28 09:53:38 -0700 | [diff] [blame] | 39 | if (us->subclass == USB_SC_UFI) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 40 | sdev->sdev_target->pdt_1f_for_no_lun = 1; |
| 41 | |
| 42 | return 0; |
| 43 | } |
| 44 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 45 | /* |
| 46 | * slave_configure() |
| 47 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 48 | static int slave_configure(struct scsi_device *sdev) |
| 49 | { |
| 50 | struct us_data *us = host_to_us(sdev->host); |
| 51 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 52 | /* pr_info("scsiglue --- slave_configure\n"); */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 53 | if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 54 | unsigned int max_sectors = 64; |
| 55 | |
| 56 | if (us->fflags & US_FL_MAX_SECTORS_MIN) |
| 57 | max_sectors = PAGE_CACHE_SIZE >> 9; |
| 58 | if (queue_max_sectors(sdev->request_queue) > max_sectors) |
| 59 | blk_queue_max_hw_sectors(sdev->request_queue, |
| 60 | max_sectors); |
| 61 | } |
| 62 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 63 | if (sdev->type == TYPE_DISK) { |
| 64 | if (us->subclass != USB_SC_SCSI && |
| 65 | us->subclass != USB_SC_CYP_ATACB) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 66 | sdev->use_10_for_ms = 1; |
| 67 | sdev->use_192_bytes_for_3f = 1; |
| 68 | if (us->fflags & US_FL_NO_WP_DETECT) |
| 69 | sdev->skip_ms_page_3f = 1; |
| 70 | sdev->skip_ms_page_8 = 1; |
| 71 | if (us->fflags & US_FL_FIX_CAPACITY) |
| 72 | sdev->fix_capacity = 1; |
| 73 | if (us->fflags & US_FL_CAPACITY_HEURISTICS) |
| 74 | sdev->guess_capacity = 1; |
| 75 | if (sdev->scsi_level > SCSI_2) |
Amarjargal Gundjalam | b9594b8 | 2013-05-17 01:06:49 -0700 | [diff] [blame] | 76 | sdev->sdev_target->scsi_level = sdev->scsi_level |
| 77 | = SCSI_2; |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 78 | sdev->retry_hwerror = 1; |
| 79 | sdev->allow_restart = 1; |
| 80 | sdev->last_sector_bug = 1; |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 81 | } else { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 82 | sdev->use_10_for_ms = 1; |
| 83 | } |
| 84 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 85 | if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) && |
| 86 | sdev->scsi_level == SCSI_UNKNOWN) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 87 | us->max_lun = 0; |
| 88 | |
| 89 | if (us->fflags & US_FL_NOT_LOCKABLE) |
| 90 | sdev->lockable = 0; |
| 91 | |
| 92 | return 0; |
| 93 | } |
| 94 | |
| 95 | /* This is always called with scsi_lock(host) held */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 96 | /* |
| 97 | * queuecommand() |
| 98 | */ |
| 99 | static int queuecommand_lck(struct scsi_cmnd *srb, |
| 100 | void (*done)(struct scsi_cmnd *)) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 101 | { |
| 102 | struct us_data *us = host_to_us(srb->device->host); |
| 103 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 104 | /* pr_info("scsiglue --- queuecommand\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 105 | |
| 106 | /* check for state-transition errors */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 107 | if (us->srb != NULL) { |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 108 | /* pr_info("Error in %s: us->srb = %p\n" |
| 109 | __FUNCTION__, us->srb); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 110 | return SCSI_MLQUEUE_HOST_BUSY; |
| 111 | } |
| 112 | |
| 113 | /* fail the command if we are disconnecting */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 114 | if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) { |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 115 | pr_info("Fail command during disconnect\n"); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 116 | srb->result = DID_NO_CONNECT << 16; |
| 117 | done(srb); |
| 118 | return 0; |
| 119 | } |
| 120 | |
| 121 | /* enqueue the command and wake up the control thread */ |
| 122 | srb->scsi_done = done; |
| 123 | us->srb = srb; |
| 124 | complete(&us->cmnd_ready); |
| 125 | |
| 126 | return 0; |
| 127 | } |
| 128 | |
Jeff Garzik | f281233 | 2010-11-16 02:10:29 -0500 | [diff] [blame] | 129 | static DEF_SCSI_QCMD(queuecommand) |
| 130 | |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 131 | /*********************************************************************** |
| 132 | * Error handling functions |
| 133 | ***********************************************************************/ |
| 134 | |
| 135 | /* Command timeout and abort */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 136 | /* |
| 137 | * command_abort() |
| 138 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 139 | static int command_abort(struct scsi_cmnd *srb) |
| 140 | { |
| 141 | struct us_data *us = host_to_us(srb->device->host); |
| 142 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 143 | /* pr_info("scsiglue --- command_abort\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 144 | |
| 145 | scsi_lock(us_to_host(us)); |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 146 | if (us->srb != srb) { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 147 | scsi_unlock(us_to_host(us)); |
Laura Lawniczak | 29b3142 | 2013-06-06 18:10:47 +0200 | [diff] [blame] | 148 | dev_info(&us->pusb_dev->dev, "-- nothing to abort\n"); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 149 | return FAILED; |
| 150 | } |
| 151 | |
| 152 | set_bit(US_FLIDX_TIMED_OUT, &us->dflags); |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 153 | if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 154 | set_bit(US_FLIDX_ABORTING, &us->dflags); |
| 155 | usb_stor_stop_transport(us); |
| 156 | } |
| 157 | scsi_unlock(us_to_host(us)); |
| 158 | |
| 159 | /* Wait for the aborted command to finish */ |
| 160 | wait_for_completion(&us->notify); |
| 161 | return SUCCESS; |
| 162 | } |
| 163 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 164 | /* This invokes the transport reset mechanism to reset the state of the |
| 165 | * device. |
| 166 | */ |
| 167 | /* |
| 168 | * device_reset() |
| 169 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 170 | static int device_reset(struct scsi_cmnd *srb) |
| 171 | { |
| 172 | struct us_data *us = host_to_us(srb->device->host); |
| 173 | int result; |
| 174 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 175 | /* pr_info("scsiglue --- device_reset\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 176 | |
| 177 | /* lock the device pointers and do the reset */ |
| 178 | mutex_lock(&(us->dev_mutex)); |
| 179 | result = us->transport_reset(us); |
| 180 | mutex_unlock(&us->dev_mutex); |
| 181 | |
| 182 | return result < 0 ? FAILED : SUCCESS; |
| 183 | } |
| 184 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 185 | /* |
| 186 | * bus_reset() |
| 187 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 188 | static int bus_reset(struct scsi_cmnd *srb) |
| 189 | { |
| 190 | struct us_data *us = host_to_us(srb->device->host); |
| 191 | int result; |
| 192 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 193 | /* pr_info("scsiglue --- bus_reset\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 194 | result = usb_stor_port_reset(us); |
| 195 | return result < 0 ? FAILED : SUCCESS; |
| 196 | } |
| 197 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 198 | /* |
| 199 | * usb_stor_report_device_reset() |
| 200 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 201 | void usb_stor_report_device_reset(struct us_data *us) |
| 202 | { |
| 203 | int i; |
| 204 | struct Scsi_Host *host = us_to_host(us); |
| 205 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 206 | /* pr_info("scsiglue --- usb_stor_report_device_reset\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 207 | scsi_report_device_reset(host, 0, 0); |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 208 | if (us->fflags & US_FL_SCM_MULT_TARG) { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 209 | for (i = 1; i < host->max_id; ++i) |
| 210 | scsi_report_device_reset(host, 0, i); |
| 211 | } |
| 212 | } |
| 213 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 214 | /* |
| 215 | * usb_stor_report_bus_reset() |
| 216 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 217 | void usb_stor_report_bus_reset(struct us_data *us) |
| 218 | { |
| 219 | struct Scsi_Host *host = us_to_host(us); |
| 220 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 221 | /* pr_info("scsiglue --- usb_stor_report_bus_reset\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 222 | scsi_lock(host); |
| 223 | scsi_report_bus_reset(host, 0); |
| 224 | scsi_unlock(host); |
| 225 | } |
| 226 | |
| 227 | /*********************************************************************** |
| 228 | * /proc/scsi/ functions |
| 229 | ***********************************************************************/ |
| 230 | |
| 231 | /* we use this macro to help us write into the buffer */ |
| 232 | #undef SPRINTF |
Al Viro | 60e8b80 | 2013-03-31 02:08:31 -0400 | [diff] [blame] | 233 | #define SPRINTF(args...) seq_printf(m, ##args) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 234 | |
Al Viro | 60e8b80 | 2013-03-31 02:08:31 -0400 | [diff] [blame] | 235 | static int write_info(struct Scsi_Host *host, char *buffer, int length) |
| 236 | { |
| 237 | return length; |
| 238 | } |
| 239 | |
| 240 | static int show_info(struct seq_file *m, struct Scsi_Host *host) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 241 | { |
| 242 | struct us_data *us = host_to_us(host); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 243 | const char *string; |
| 244 | |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 245 | /* print the controller name */ |
| 246 | SPRINTF(" Host scsi%d: usb-storage\n", host->host_no); |
| 247 | |
| 248 | /* print product, vendor, and serial number strings */ |
| 249 | if (us->pusb_dev->manufacturer) |
| 250 | string = us->pusb_dev->manufacturer; |
| 251 | else if (us->unusual_dev->vendorName) |
| 252 | string = us->unusual_dev->vendorName; |
| 253 | else |
| 254 | string = "Unknown"; |
| 255 | SPRINTF(" Vendor: %s\n", string); |
| 256 | if (us->pusb_dev->product) |
| 257 | string = us->pusb_dev->product; |
| 258 | else if (us->unusual_dev->productName) |
| 259 | string = us->unusual_dev->productName; |
| 260 | else |
| 261 | string = "Unknown"; |
| 262 | SPRINTF(" Product: %s\n", string); |
| 263 | if (us->pusb_dev->serial) |
| 264 | string = us->pusb_dev->serial; |
| 265 | else |
| 266 | string = "None"; |
| 267 | SPRINTF("Serial Number: %s\n", string); |
| 268 | |
| 269 | /* show the protocol and transport */ |
| 270 | SPRINTF(" Protocol: %s\n", us->protocol_name); |
| 271 | SPRINTF(" Transport: %s\n", us->transport_name); |
| 272 | |
| 273 | /* show the device flags */ |
Al Viro | 60e8b80 | 2013-03-31 02:08:31 -0400 | [diff] [blame] | 274 | SPRINTF(" Quirks:"); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 275 | |
| 276 | #define US_FLAG(name, value) \ |
William Blair | a2c49a9 | 2012-06-13 01:16:49 -0400 | [diff] [blame] | 277 | do { \ |
| 278 | if (us->fflags & value) \ |
Al Viro | 60e8b80 | 2013-03-31 02:08:31 -0400 | [diff] [blame] | 279 | SPRINTF(" " #name); \ |
William Blair | a2c49a9 | 2012-06-13 01:16:49 -0400 | [diff] [blame] | 280 | } while (0); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 281 | US_DO_ALL_FLAGS |
| 282 | #undef US_FLAG |
Al Viro | 60e8b80 | 2013-03-31 02:08:31 -0400 | [diff] [blame] | 283 | seq_putc(m, '\n'); |
| 284 | return 0; |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 285 | } |
| 286 | |
| 287 | /*********************************************************************** |
| 288 | * Sysfs interface |
| 289 | ***********************************************************************/ |
| 290 | |
| 291 | /* Output routine for the sysfs max_sectors file */ |
Greg Kroah-Hartman | 0000961 | 2013-08-24 10:33:07 -0700 | [diff] [blame] | 292 | static ssize_t max_sectors_show(struct device *dev, |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 293 | struct device_attribute *attr, char *buf) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 294 | { |
| 295 | struct scsi_device *sdev = to_scsi_device(dev); |
| 296 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 297 | /* pr_info("scsiglue --- ssize_t show_max_sectors\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 298 | return sprintf(buf, "%u\n", queue_max_sectors(sdev->request_queue)); |
| 299 | } |
| 300 | |
| 301 | /* Input routine for the sysfs max_sectors file */ |
Greg Kroah-Hartman | 0000961 | 2013-08-24 10:33:07 -0700 | [diff] [blame] | 302 | static ssize_t max_sectors_store(struct device *dev, |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 303 | struct device_attribute *attr, |
| 304 | const char *buf, size_t count) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 305 | { |
| 306 | struct scsi_device *sdev = to_scsi_device(dev); |
| 307 | unsigned short ms; |
| 308 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 309 | /* pr_info("scsiglue --- ssize_t store_max_sectors\n"); */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 310 | if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 311 | blk_queue_max_hw_sectors(sdev->request_queue, ms); |
| 312 | return strlen(buf); |
| 313 | } |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 314 | return -EINVAL; |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 315 | } |
Greg Kroah-Hartman | 0000961 | 2013-08-24 10:33:07 -0700 | [diff] [blame] | 316 | static DEVICE_ATTR_RW(max_sectors); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 317 | |
Johannes Schilling | 0ea8a16 | 2013-06-06 18:10:50 +0200 | [diff] [blame] | 318 | static struct device_attribute *sysfs_device_attr_list[] = { |
| 319 | &dev_attr_max_sectors, NULL, |
| 320 | }; |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 321 | |
| 322 | /* this defines our host template, with which we'll allocate hosts */ |
| 323 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 324 | /* |
| 325 | * usb_stor_host_template() |
| 326 | */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 327 | struct scsi_host_template usb_stor_host_template = { |
| 328 | /* basic userland interface stuff */ |
| 329 | .name = "eucr-storage", |
| 330 | .proc_name = "eucr-storage", |
Al Viro | 60e8b80 | 2013-03-31 02:08:31 -0400 | [diff] [blame] | 331 | .write_info = write_info, |
| 332 | .show_info = show_info, |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 333 | .info = host_info, |
| 334 | |
| 335 | /* command interface -- queued only */ |
| 336 | .queuecommand = queuecommand, |
| 337 | |
| 338 | /* error and abort handlers */ |
| 339 | .eh_abort_handler = command_abort, |
| 340 | .eh_device_reset_handler = device_reset, |
| 341 | .eh_bus_reset_handler = bus_reset, |
| 342 | |
| 343 | /* queue commands only, only one command per LUN */ |
| 344 | .can_queue = 1, |
| 345 | .cmd_per_lun = 1, |
| 346 | |
| 347 | /* unknown initiator id */ |
| 348 | .this_id = -1, |
| 349 | |
| 350 | .slave_alloc = slave_alloc, |
| 351 | .slave_configure = slave_configure, |
| 352 | |
| 353 | /* lots of sg segments can be handled */ |
| 354 | .sg_tablesize = SG_ALL, |
| 355 | |
| 356 | /* limit the total size of a transfer to 120 KB */ |
| 357 | .max_sectors = 240, |
| 358 | |
| 359 | /* merge commands... this seems to help performance, but |
| 360 | * periodically someone should test to see which setting is more |
| 361 | * optimal. |
| 362 | */ |
| 363 | .use_clustering = 1, |
| 364 | |
| 365 | /* emulated HBA */ |
| 366 | .emulated = 1, |
| 367 | |
| 368 | /* we do our own delay after a device or bus reset */ |
| 369 | .skip_settle_delay = 1, |
| 370 | |
| 371 | /* sysfs device attributes */ |
| 372 | .sdev_attrs = sysfs_device_attr_list, |
| 373 | |
| 374 | /* module management */ |
| 375 | .module = THIS_MODULE |
| 376 | }; |
| 377 | |
| 378 | /* To Report "Illegal Request: Invalid Field in CDB */ |
| 379 | unsigned char usb_stor_sense_invalidCDB[18] = { |
| 380 | [0] = 0x70, /* current error */ |
| 381 | [2] = ILLEGAL_REQUEST, /* Illegal Request = 0x05 */ |
| 382 | [7] = 0x0a, /* additional length */ |
| 383 | [12] = 0x24 /* Invalid Field in CDB */ |
| 384 | }; |
| 385 | |
| 386 | /*********************************************************************** |
| 387 | * Scatter-gather transfer buffer access routines |
| 388 | ***********************************************************************/ |
| 389 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 390 | /* |
| 391 | * usb_stor_access_xfer_buf() |
| 392 | */ |
Amarjargal Gundjalam | b9594b8 | 2013-05-17 01:06:49 -0700 | [diff] [blame] | 393 | unsigned int usb_stor_access_xfer_buf(struct us_data *us, |
| 394 | unsigned char *buffer, unsigned int buflen, |
| 395 | struct scsi_cmnd *srb, struct scatterlist **sgptr, |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 396 | unsigned int *offset, enum xfer_buf_dir dir) |
| 397 | { |
| 398 | unsigned int cnt; |
| 399 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 400 | /* pr_info("transport --- usb_stor_access_xfer_buf\n"); */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 401 | struct scatterlist *sg = *sgptr; |
| 402 | |
| 403 | if (!sg) |
| 404 | sg = scsi_sglist(srb); |
| 405 | |
| 406 | cnt = 0; |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 407 | while (cnt < buflen && sg) { |
| 408 | struct page *page = sg_page(sg) + |
| 409 | ((sg->offset + *offset) >> PAGE_SHIFT); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 410 | unsigned int poff = (sg->offset + *offset) & (PAGE_SIZE-1); |
| 411 | unsigned int sglen = sg->length - *offset; |
| 412 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 413 | if (sglen > buflen - cnt) { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 414 | /* Transfer ends within this s-g entry */ |
| 415 | sglen = buflen - cnt; |
| 416 | *offset += sglen; |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 417 | } else { |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 418 | /* Transfer continues to next s-g entry */ |
| 419 | *offset = 0; |
| 420 | sg = sg_next(sg); |
| 421 | } |
| 422 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 423 | while (sglen > 0) { |
| 424 | unsigned int plen = min(sglen, |
Amarjargal Gundjalam | b9594b8 | 2013-05-17 01:06:49 -0700 | [diff] [blame] | 425 | (unsigned int)PAGE_SIZE - poff); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 426 | unsigned char *ptr = kmap(page); |
| 427 | |
| 428 | if (dir == TO_XFER_BUF) |
| 429 | memcpy(ptr + poff, buffer + cnt, plen); |
| 430 | else |
| 431 | memcpy(buffer + cnt, ptr + poff, plen); |
| 432 | kunmap(page); |
| 433 | |
| 434 | /* Start at the beginning of the next page */ |
| 435 | poff = 0; |
| 436 | ++page; |
| 437 | cnt += plen; |
| 438 | sglen -= plen; |
| 439 | } |
| 440 | } |
| 441 | *sgptr = sg; |
| 442 | |
| 443 | /* Return the amount actually transferred */ |
| 444 | return cnt; |
| 445 | } |
| 446 | |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 447 | /* |
| 448 | * Store the contents of buffer into srb's transfer |
| 449 | * buffer and set the SCSI residue. |
| 450 | */ |
| 451 | /* |
| 452 | * usb_stor_set_xfer_buf() |
| 453 | */ |
| 454 | void usb_stor_set_xfer_buf(struct us_data *us, unsigned char *buffer, |
| 455 | unsigned int buflen, struct scsi_cmnd *srb, unsigned int dir) |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 456 | { |
| 457 | unsigned int offset = 0; |
| 458 | struct scatterlist *sg = NULL; |
| 459 | |
Cho, Yu-Chen | beddfe8 | 2011-04-01 14:38:41 +0800 | [diff] [blame] | 460 | /* pr_info("transport --- usb_stor_set_xfer_buf\n"); */ |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 461 | /* TO_XFER_BUF = 0, FROM_XFER_BUF = 1 */ |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 462 | buflen = min(buflen, scsi_bufflen(srb)); |
Cho, Yu-Chen | 8a25a2c | 2011-05-18 18:40:11 +0800 | [diff] [blame] | 463 | buflen = usb_stor_access_xfer_buf(us, buffer, buflen, srb, |
| 464 | &sg, &offset, dir); |
Al Cho | 126bb03 | 2010-09-08 00:42:32 -0700 | [diff] [blame] | 465 | if (buflen < scsi_bufflen(srb)) |
| 466 | scsi_set_resid(srb, scsi_bufflen(srb) - buflen); |
| 467 | } |