projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
uas: Add a uas_find_uas_alt_setting helper function
[deliverable/linux.git] / drivers / usb / storage / uas.c
1 /*
2 * USB Attached SCSI
3 * Note that this is not the same as the USB Mass Storage driver
4 *
5 * Copyright Matthew Wilcox for Intel Corp, 2010
6 * Copyright Sarah Sharp for Intel Corp, 2010
7 *
8 * Distributed under the terms of the GNU GPL, version two.
9 */
10
11 #include <linux/blkdev.h>
12 #include <linux/slab.h>
13 #include <linux/types.h>
14 #include <linux/module.h>
15 #include <linux/usb.h>
16 #include <linux/usb/hcd.h>
17 #include <linux/usb/storage.h>
18 #include <linux/usb/uas.h>
19
20 #include <scsi/scsi.h>
21 #include <scsi/scsi_eh.h>
22 #include <scsi/scsi_dbg.h>
23 #include <scsi/scsi_cmnd.h>
24 #include <scsi/scsi_device.h>
25 #include <scsi/scsi_host.h>
26 #include <scsi/scsi_tcq.h>
27
28 /*
29 * The r00-r01c specs define this version of the SENSE IU data structure.
30 * It's still in use by several different firmware releases.
31 */
32 struct sense_iu_old {
33 __u8 iu_id;
34 __u8 rsvd1;
35 __be16 tag;
36 __be16 len;
37 __u8 status;
38 __u8 service_response;
39 __u8 sense[SCSI_SENSE_BUFFERSIZE];
40 };
41
42 struct uas_dev_info {
43 struct usb_interface *intf;
44 struct usb_device *udev;
45 struct usb_anchor cmd_urbs;
46 struct usb_anchor sense_urbs;
47 struct usb_anchor data_urbs;
48 int qdepth, resetting;
49 struct response_iu response;
50 unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
51 unsigned use_streams:1;
52 unsigned uas_sense_old:1;
53 struct scsi_cmnd *cmnd;
54 spinlock_t lock;
55 struct work_struct work;
56 struct list_head work_list;
57 struct list_head dead_list;
58 };
59
60 enum {
61 SUBMIT_STATUS_URB = (1 << 1),
62 ALLOC_DATA_IN_URB = (1 << 2),
63 SUBMIT_DATA_IN_URB = (1 << 3),
64 ALLOC_DATA_OUT_URB = (1 << 4),
65 SUBMIT_DATA_OUT_URB = (1 << 5),
66 ALLOC_CMD_URB = (1 << 6),
67 SUBMIT_CMD_URB = (1 << 7),
68 COMMAND_INFLIGHT = (1 << 8),
69 DATA_IN_URB_INFLIGHT = (1 << 9),
70 DATA_OUT_URB_INFLIGHT = (1 << 10),
71 COMMAND_COMPLETED = (1 << 11),
72 COMMAND_ABORTED = (1 << 12),
73 UNLINK_DATA_URBS = (1 << 13),
74 IS_IN_WORK_LIST = (1 << 14),
75 };
76
77 /* Overrides scsi_pointer */
78 struct uas_cmd_info {
79 unsigned int state;
80 unsigned int stream;
81 struct urb *cmd_urb;
82 struct urb *data_in_urb;
83 struct urb *data_out_urb;
84 struct list_head work;
85 struct list_head dead;
86 };
87
88 /* I hate forward declarations, but I actually have a loop */
89 static int uas_submit_urbs(struct scsi_cmnd *cmnd,
90 struct uas_dev_info *devinfo, gfp_t gfp);
91 static void uas_do_work(struct work_struct *work);
92 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller);
93 static void uas_configure_endpoints(struct uas_dev_info *devinfo);
94 static void uas_free_streams(struct uas_dev_info *devinfo);
95 static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller);
96
97 /* Must be called with devinfo->lock held, will temporary unlock the lock */
98 static void uas_unlink_data_urbs(struct uas_dev_info *devinfo,
99 struct uas_cmd_info *cmdinfo,
100 unsigned long *lock_flags)
101 {
102 /*
103 * The UNLINK_DATA_URBS flag makes sure uas_try_complete
104 * (called by urb completion) doesn't release cmdinfo
105 * underneath us.
106 */
107 cmdinfo->state |= UNLINK_DATA_URBS;
108 spin_unlock_irqrestore(&devinfo->lock, *lock_flags);
109
110 if (cmdinfo->data_in_urb)
111 usb_unlink_urb(cmdinfo->data_in_urb);
112 if (cmdinfo->data_out_urb)
113 usb_unlink_urb(cmdinfo->data_out_urb);
114
115 spin_lock_irqsave(&devinfo->lock, *lock_flags);
116 cmdinfo->state &= ~UNLINK_DATA_URBS;
117 }
118
119 static void uas_do_work(struct work_struct *work)
120 {
121 struct uas_dev_info *devinfo =
122 container_of(work, struct uas_dev_info, work);
123 struct uas_cmd_info *cmdinfo;
124 struct uas_cmd_info *temp;
125 unsigned long flags;
126 int err;
127
128 spin_lock_irqsave(&devinfo->lock, flags);
129 list_for_each_entry_safe(cmdinfo, temp, &devinfo->work_list, work) {
130 struct scsi_pointer *scp = (void *)cmdinfo;
131 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd,
132 SCp);
133 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
134 if (!err) {
135 cmdinfo->state &= ~IS_IN_WORK_LIST;
136 list_del(&cmdinfo->work);
137 } else {
138 schedule_work(&devinfo->work);
139 }
140 }
141 spin_unlock_irqrestore(&devinfo->lock, flags);
142 }
143
144 static void uas_abort_work(struct uas_dev_info *devinfo)
145 {
146 struct uas_cmd_info *cmdinfo;
147 struct uas_cmd_info *temp;
148 unsigned long flags;
149
150 spin_lock_irqsave(&devinfo->lock, flags);
151 list_for_each_entry_safe(cmdinfo, temp, &devinfo->work_list, work) {
152 struct scsi_pointer *scp = (void *)cmdinfo;
153 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd,
154 SCp);
155 uas_log_cmd_state(cmnd, __func__);
156 WARN_ON_ONCE(cmdinfo->state & COMMAND_ABORTED);
157 cmdinfo->state |= COMMAND_ABORTED;
158 cmdinfo->state &= ~IS_IN_WORK_LIST;
159 list_del(&cmdinfo->work);
160 list_add_tail(&cmdinfo->dead, &devinfo->dead_list);
161 }
162 spin_unlock_irqrestore(&devinfo->lock, flags);
163 }
164
165 static void uas_add_work(struct uas_cmd_info *cmdinfo)
166 {
167 struct scsi_pointer *scp = (void *)cmdinfo;
168 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, SCp);
169 struct uas_dev_info *devinfo = cmnd->device->hostdata;
170
171 WARN_ON_ONCE(!spin_is_locked(&devinfo->lock));
172 list_add_tail(&cmdinfo->work, &devinfo->work_list);
173 cmdinfo->state |= IS_IN_WORK_LIST;
174 schedule_work(&devinfo->work);
175 }
176
177 static void uas_zap_dead(struct uas_dev_info *devinfo)
178 {
179 struct uas_cmd_info *cmdinfo;
180 struct uas_cmd_info *temp;
181 unsigned long flags;
182
183 spin_lock_irqsave(&devinfo->lock, flags);
184 list_for_each_entry_safe(cmdinfo, temp, &devinfo->dead_list, dead) {
185 struct scsi_pointer *scp = (void *)cmdinfo;
186 struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd,
187 SCp);
188 uas_log_cmd_state(cmnd, __func__);
189 WARN_ON_ONCE(!(cmdinfo->state & COMMAND_ABORTED));
190 /* all urbs are killed, clear inflight bits */
191 cmdinfo->state &= ~(COMMAND_INFLIGHT |
192 DATA_IN_URB_INFLIGHT |
193 DATA_OUT_URB_INFLIGHT);
194 uas_try_complete(cmnd, __func__);
195 }
196 spin_unlock_irqrestore(&devinfo->lock, flags);
197 }
198
199 static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
200 {
201 struct sense_iu *sense_iu = urb->transfer_buffer;
202 struct scsi_device *sdev = cmnd->device;
203
204 if (urb->actual_length > 16) {
205 unsigned len = be16_to_cpup(&sense_iu->len);
206 if (len + 16 != urb->actual_length) {
207 int newlen = min(len + 16, urb->actual_length) - 16;
208 if (newlen < 0)
209 newlen = 0;
210 sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
211 "disagrees with IU sense data length %d, "
212 "using %d bytes of sense data\n", __func__,
213 urb->actual_length, len, newlen);
214 len = newlen;
215 }
216 memcpy(cmnd->sense_buffer, sense_iu->sense, len);
217 }
218
219 cmnd->result = sense_iu->status;
220 }
221
222 static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd)
223 {
224 struct sense_iu_old *sense_iu = urb->transfer_buffer;
225 struct scsi_device *sdev = cmnd->device;
226
227 if (urb->actual_length > 8) {
228 unsigned len = be16_to_cpup(&sense_iu->len) - 2;
229 if (len + 8 != urb->actual_length) {
230 int newlen = min(len + 8, urb->actual_length) - 8;
231 if (newlen < 0)
232 newlen = 0;
233 sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
234 "disagrees with IU sense data length %d, "
235 "using %d bytes of sense data\n", __func__,
236 urb->actual_length, len, newlen);
237 len = newlen;
238 }
239 memcpy(cmnd->sense_buffer, sense_iu->sense, len);
240 }
241
242 cmnd->result = sense_iu->status;
243 }
244
245 static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller)
246 {
247 struct uas_cmd_info *ci = (void *)&cmnd->SCp;
248
249 scmd_printk(KERN_INFO, cmnd, "%s %p tag %d, inflight:"
250 "%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
251 caller, cmnd, cmnd->request->tag,
252 (ci->state & SUBMIT_STATUS_URB) ? " s-st" : "",
253 (ci->state & ALLOC_DATA_IN_URB) ? " a-in" : "",
254 (ci->state & SUBMIT_DATA_IN_URB) ? " s-in" : "",
255 (ci->state & ALLOC_DATA_OUT_URB) ? " a-out" : "",
256 (ci->state & SUBMIT_DATA_OUT_URB) ? " s-out" : "",
257 (ci->state & ALLOC_CMD_URB) ? " a-cmd" : "",
258 (ci->state & SUBMIT_CMD_URB) ? " s-cmd" : "",
259 (ci->state & COMMAND_INFLIGHT) ? " CMD" : "",
260 (ci->state & DATA_IN_URB_INFLIGHT) ? " IN" : "",
261 (ci->state & DATA_OUT_URB_INFLIGHT) ? " OUT" : "",
262 (ci->state & COMMAND_COMPLETED) ? " done" : "",
263 (ci->state & COMMAND_ABORTED) ? " abort" : "",
264 (ci->state & UNLINK_DATA_URBS) ? " unlink": "",
265 (ci->state & IS_IN_WORK_LIST) ? " work" : "");
266 }
267
268 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
269 {
270 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
271 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
272
273 WARN_ON_ONCE(!spin_is_locked(&devinfo->lock));
274 if (cmdinfo->state & (COMMAND_INFLIGHT |
275 DATA_IN_URB_INFLIGHT |
276 DATA_OUT_URB_INFLIGHT |
277 UNLINK_DATA_URBS))
278 return -EBUSY;
279 WARN_ON_ONCE(cmdinfo->state & COMMAND_COMPLETED);
280 cmdinfo->state |= COMMAND_COMPLETED;
281 usb_free_urb(cmdinfo->data_in_urb);
282 usb_free_urb(cmdinfo->data_out_urb);
283 if (cmdinfo->state & COMMAND_ABORTED) {
284 scmd_printk(KERN_INFO, cmnd, "abort completed\n");
285 cmnd->result = DID_ABORT << 16;
286 list_del(&cmdinfo->dead);
287 }
288 cmnd->scsi_done(cmnd);
289 return 0;
290 }
291
292 static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
293 unsigned direction)
294 {
295 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
296 int err;
297
298 cmdinfo->state |= direction | SUBMIT_STATUS_URB;
299 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
300 if (err) {
301 uas_add_work(cmdinfo);
302 }
303 }
304
305 static void uas_stat_cmplt(struct urb *urb)
306 {
307 struct iu *iu = urb->transfer_buffer;
308 struct Scsi_Host *shost = urb->context;
309 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
310 struct scsi_cmnd *cmnd;
311 struct uas_cmd_info *cmdinfo;
312 unsigned long flags;
313 u16 tag;
314
315 if (urb->status) {
316 if (urb->status == -ENOENT) {
317 dev_err(&urb->dev->dev, "stat urb: killed, stream %d\n",
318 urb->stream_id);
319 } else {
320 dev_err(&urb->dev->dev, "stat urb: status %d\n",
321 urb->status);
322 }
323 usb_free_urb(urb);
324 return;
325 }
326
327 if (devinfo->resetting) {
328 usb_free_urb(urb);
329 return;
330 }
331
332 spin_lock_irqsave(&devinfo->lock, flags);
333 tag = be16_to_cpup(&iu->tag) - 1;
334 if (tag == 0)
335 cmnd = devinfo->cmnd;
336 else
337 cmnd = scsi_host_find_tag(shost, tag - 1);
338
339 if (!cmnd) {
340 if (iu->iu_id == IU_ID_RESPONSE) {
341 /* store results for uas_eh_task_mgmt() */
342 memcpy(&devinfo->response, iu, sizeof(devinfo->response));
343 }
344 usb_free_urb(urb);
345 spin_unlock_irqrestore(&devinfo->lock, flags);
346 return;
347 }
348
349 cmdinfo = (void *)&cmnd->SCp;
350 switch (iu->iu_id) {
351 case IU_ID_STATUS:
352 if (devinfo->cmnd == cmnd)
353 devinfo->cmnd = NULL;
354
355 if (urb->actual_length < 16)
356 devinfo->uas_sense_old = 1;
357 if (devinfo->uas_sense_old)
358 uas_sense_old(urb, cmnd);
359 else
360 uas_sense(urb, cmnd);
361 if (cmnd->result != 0) {
362 /* cancel data transfers on error */
363 uas_unlink_data_urbs(devinfo, cmdinfo, &flags);
364 }
365 cmdinfo->state &= ~COMMAND_INFLIGHT;
366 uas_try_complete(cmnd, __func__);
367 break;
368 case IU_ID_READ_READY:
369 uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
370 break;
371 case IU_ID_WRITE_READY:
372 uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
373 break;
374 default:
375 scmd_printk(KERN_ERR, cmnd,
376 "Bogus IU (%d) received on status pipe\n", iu->iu_id);
377 }
378 usb_free_urb(urb);
379 spin_unlock_irqrestore(&devinfo->lock, flags);
380 }
381
382 static void uas_data_cmplt(struct urb *urb)
383 {
384 struct scsi_cmnd *cmnd = urb->context;
385 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
386 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
387 struct scsi_data_buffer *sdb = NULL;
388 unsigned long flags;
389
390 spin_lock_irqsave(&devinfo->lock, flags);
391 if (cmdinfo->data_in_urb == urb) {
392 sdb = scsi_in(cmnd);
393 cmdinfo->state &= ~DATA_IN_URB_INFLIGHT;
394 } else if (cmdinfo->data_out_urb == urb) {
395 sdb = scsi_out(cmnd);
396 cmdinfo->state &= ~DATA_OUT_URB_INFLIGHT;
397 }
398 if (sdb == NULL) {
399 WARN_ON_ONCE(1);
400 } else if (urb->status) {
401 /* error: no data transfered */
402 sdb->resid = sdb->length;
403 } else {
404 sdb->resid = sdb->length - urb->actual_length;
405 }
406 uas_try_complete(cmnd, __func__);
407 spin_unlock_irqrestore(&devinfo->lock, flags);
408 }
409
410 static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
411 unsigned int pipe, u16 stream_id,
412 struct scsi_cmnd *cmnd,
413 enum dma_data_direction dir)
414 {
415 struct usb_device *udev = devinfo->udev;
416 struct urb *urb = usb_alloc_urb(0, gfp);
417 struct scsi_data_buffer *sdb = (dir == DMA_FROM_DEVICE)
418 ? scsi_in(cmnd) : scsi_out(cmnd);
419
420 if (!urb)
421 goto out;
422 usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length,
423 uas_data_cmplt, cmnd);
424 if (devinfo->use_streams)
425 urb->stream_id = stream_id;
426 urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
427 urb->sg = sdb->table.sgl;
428 out:
429 return urb;
430 }
431
432 static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
433 struct Scsi_Host *shost, u16 stream_id)
434 {
435 struct usb_device *udev = devinfo->udev;
436 struct urb *urb = usb_alloc_urb(0, gfp);
437 struct sense_iu *iu;
438
439 if (!urb)
440 goto out;
441
442 iu = kzalloc(sizeof(*iu), gfp);
443 if (!iu)
444 goto free;
445
446 usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
447 uas_stat_cmplt, shost);
448 urb->stream_id = stream_id;
449 urb->transfer_flags |= URB_FREE_BUFFER;
450 out:
451 return urb;
452 free:
453 usb_free_urb(urb);
454 return NULL;
455 }
456
457 static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
458 struct scsi_cmnd *cmnd)
459 {
460 struct usb_device *udev = devinfo->udev;
461 struct scsi_device *sdev = cmnd->device;
462 struct urb *urb = usb_alloc_urb(0, gfp);
463 struct command_iu *iu;
464 int len;
465
466 if (!urb)
467 goto out;
468
469 len = cmnd->cmd_len - 16;
470 if (len < 0)
471 len = 0;
472 len = ALIGN(len, 4);
473 iu = kzalloc(sizeof(*iu) + len, gfp);
474 if (!iu)
475 goto free;
476
477 iu->iu_id = IU_ID_COMMAND;
478 if (blk_rq_tagged(cmnd->request))
479 iu->tag = cpu_to_be16(cmnd->request->tag + 2);
480 else
481 iu->tag = cpu_to_be16(1);
482 iu->prio_attr = UAS_SIMPLE_TAG;
483 iu->len = len;
484 int_to_scsilun(sdev->lun, &iu->lun);
485 memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
486
487 usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
488 usb_free_urb, NULL);
489 urb->transfer_flags |= URB_FREE_BUFFER;
490 out:
491 return urb;
492 free:
493 usb_free_urb(urb);
494 return NULL;
495 }
496
497 static int uas_submit_task_urb(struct scsi_cmnd *cmnd, gfp_t gfp,
498 u8 function, u16 stream_id)
499 {
500 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
501 struct usb_device *udev = devinfo->udev;
502 struct urb *urb = usb_alloc_urb(0, gfp);
503 struct task_mgmt_iu *iu;
504 int err = -ENOMEM;
505
506 if (!urb)
507 goto err;
508
509 iu = kzalloc(sizeof(*iu), gfp);
510 if (!iu)
511 goto err;
512
513 iu->iu_id = IU_ID_TASK_MGMT;
514 iu->tag = cpu_to_be16(stream_id);
515 int_to_scsilun(cmnd->device->lun, &iu->lun);
516
517 iu->function = function;
518 switch (function) {
519 case TMF_ABORT_TASK:
520 if (blk_rq_tagged(cmnd->request))
521 iu->task_tag = cpu_to_be16(cmnd->request->tag + 2);
522 else
523 iu->task_tag = cpu_to_be16(1);
524 break;
525 }
526
527 usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu),
528 usb_free_urb, NULL);
529 urb->transfer_flags |= URB_FREE_BUFFER;
530
531 usb_anchor_urb(urb, &devinfo->cmd_urbs);
532 err = usb_submit_urb(urb, gfp);
533 if (err) {
534 usb_unanchor_urb(urb);
535 goto err;
536 }
537
538 return 0;
539
540 err:
541 usb_free_urb(urb);
542 return err;
543 }
544
545 /*
546 * Why should I request the Status IU before sending the Command IU? Spec
547 * says to, but also says the device may receive them in any order. Seems
548 * daft to me.
549 */
550
551 static int uas_submit_sense_urb(struct Scsi_Host *shost,
552 gfp_t gfp, unsigned int stream)
553 {
554 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
555 struct urb *urb;
556
557 urb = uas_alloc_sense_urb(devinfo, gfp, shost, stream);
558 if (!urb)
559 return SCSI_MLQUEUE_DEVICE_BUSY;
560 usb_anchor_urb(urb, &devinfo->sense_urbs);
561 if (usb_submit_urb(urb, gfp)) {
562 usb_unanchor_urb(urb);
563 shost_printk(KERN_INFO, shost,
564 "sense urb submission failure\n");
565 usb_free_urb(urb);
566 return SCSI_MLQUEUE_DEVICE_BUSY;
567 }
568 return 0;
569 }
570
571 static int uas_submit_urbs(struct scsi_cmnd *cmnd,
572 struct uas_dev_info *devinfo, gfp_t gfp)
573 {
574 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
575 int err;
576
577 WARN_ON_ONCE(!spin_is_locked(&devinfo->lock));
578 if (cmdinfo->state & SUBMIT_STATUS_URB) {
579 err = uas_submit_sense_urb(cmnd->device->host, gfp,
580 cmdinfo->stream);
581 if (err) {
582 return err;
583 }
584 cmdinfo->state &= ~SUBMIT_STATUS_URB;
585 }
586
587 if (cmdinfo->state & ALLOC_DATA_IN_URB) {
588 cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
589 devinfo->data_in_pipe, cmdinfo->stream,
590 cmnd, DMA_FROM_DEVICE);
591 if (!cmdinfo->data_in_urb)
592 return SCSI_MLQUEUE_DEVICE_BUSY;
593 cmdinfo->state &= ~ALLOC_DATA_IN_URB;
594 }
595
596 if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
597 usb_anchor_urb(cmdinfo->data_in_urb, &devinfo->data_urbs);
598 if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) {
599 usb_unanchor_urb(cmdinfo->data_in_urb);
600 scmd_printk(KERN_INFO, cmnd,
601 "data in urb submission failure\n");
602 return SCSI_MLQUEUE_DEVICE_BUSY;
603 }
604 cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
605 cmdinfo->state |= DATA_IN_URB_INFLIGHT;
606 }
607
608 if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
609 cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
610 devinfo->data_out_pipe, cmdinfo->stream,
611 cmnd, DMA_TO_DEVICE);
612 if (!cmdinfo->data_out_urb)
613 return SCSI_MLQUEUE_DEVICE_BUSY;
614 cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
615 }
616
617 if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
618 usb_anchor_urb(cmdinfo->data_out_urb, &devinfo->data_urbs);
619 if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) {
620 usb_unanchor_urb(cmdinfo->data_out_urb);
621 scmd_printk(KERN_INFO, cmnd,
622 "data out urb submission failure\n");
623 return SCSI_MLQUEUE_DEVICE_BUSY;
624 }
625 cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
626 cmdinfo->state |= DATA_OUT_URB_INFLIGHT;
627 }
628
629 if (cmdinfo->state & ALLOC_CMD_URB) {
630 cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd);
631 if (!cmdinfo->cmd_urb)
632 return SCSI_MLQUEUE_DEVICE_BUSY;
633 cmdinfo->state &= ~ALLOC_CMD_URB;
634 }
635
636 if (cmdinfo->state & SUBMIT_CMD_URB) {
637 usb_anchor_urb(cmdinfo->cmd_urb, &devinfo->cmd_urbs);
638 if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
639 usb_unanchor_urb(cmdinfo->cmd_urb);
640 scmd_printk(KERN_INFO, cmnd,
641 "cmd urb submission failure\n");
642 return SCSI_MLQUEUE_DEVICE_BUSY;
643 }
644 cmdinfo->cmd_urb = NULL;
645 cmdinfo->state &= ~SUBMIT_CMD_URB;
646 cmdinfo->state |= COMMAND_INFLIGHT;
647 }
648
649 return 0;
650 }
651
652 static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
653 void (*done)(struct scsi_cmnd *))
654 {
655 struct scsi_device *sdev = cmnd->device;
656 struct uas_dev_info *devinfo = sdev->hostdata;
657 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
658 unsigned long flags;
659 int err;
660
661 BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
662
663 if (devinfo->resetting) {
664 cmnd->result = DID_ERROR << 16;
665 cmnd->scsi_done(cmnd);
666 return 0;
667 }
668
669 spin_lock_irqsave(&devinfo->lock, flags);
670 if (devinfo->cmnd) {
671 spin_unlock_irqrestore(&devinfo->lock, flags);
672 return SCSI_MLQUEUE_DEVICE_BUSY;
673 }
674
675 if (blk_rq_tagged(cmnd->request)) {
676 cmdinfo->stream = cmnd->request->tag + 2;
677 } else {
678 devinfo->cmnd = cmnd;
679 cmdinfo->stream = 1;
680 }
681
682 cmnd->scsi_done = done;
683
684 cmdinfo->state = SUBMIT_STATUS_URB |
685 ALLOC_CMD_URB | SUBMIT_CMD_URB;
686
687 switch (cmnd->sc_data_direction) {
688 case DMA_FROM_DEVICE:
689 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
690 break;
691 case DMA_BIDIRECTIONAL:
692 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
693 case DMA_TO_DEVICE:
694 cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
695 case DMA_NONE:
696 break;
697 }
698
699 if (!devinfo->use_streams) {
700 cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
701 cmdinfo->stream = 0;
702 }
703
704 err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
705 if (err) {
706 /* If we did nothing, give up now */
707 if (cmdinfo->state & SUBMIT_STATUS_URB) {
708 spin_unlock_irqrestore(&devinfo->lock, flags);
709 return SCSI_MLQUEUE_DEVICE_BUSY;
710 }
711 uas_add_work(cmdinfo);
712 }
713
714 spin_unlock_irqrestore(&devinfo->lock, flags);
715 return 0;
716 }
717
718 static DEF_SCSI_QCMD(uas_queuecommand)
719
720 static int uas_eh_task_mgmt(struct scsi_cmnd *cmnd,
721 const char *fname, u8 function)
722 {
723 struct Scsi_Host *shost = cmnd->device->host;
724 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
725 u16 tag = devinfo->qdepth;
726 unsigned long flags;
727
728 spin_lock_irqsave(&devinfo->lock, flags);
729 memset(&devinfo->response, 0, sizeof(devinfo->response));
730 if (uas_submit_sense_urb(shost, GFP_ATOMIC, tag)) {
731 shost_printk(KERN_INFO, shost,
732 "%s: %s: submit sense urb failed\n",
733 __func__, fname);
734 spin_unlock_irqrestore(&devinfo->lock, flags);
735 return FAILED;
736 }
737 if (uas_submit_task_urb(cmnd, GFP_ATOMIC, function, tag)) {
738 shost_printk(KERN_INFO, shost,
739 "%s: %s: submit task mgmt urb failed\n",
740 __func__, fname);
741 spin_unlock_irqrestore(&devinfo->lock, flags);
742 return FAILED;
743 }
744 spin_unlock_irqrestore(&devinfo->lock, flags);
745
746 if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 3000) == 0) {
747 shost_printk(KERN_INFO, shost,
748 "%s: %s timed out\n", __func__, fname);
749 return FAILED;
750 }
751 if (be16_to_cpu(devinfo->response.tag) != tag) {
752 shost_printk(KERN_INFO, shost,
753 "%s: %s failed (wrong tag %d/%d)\n", __func__,
754 fname, be16_to_cpu(devinfo->response.tag), tag);
755 return FAILED;
756 }
757 if (devinfo->response.response_code != RC_TMF_COMPLETE) {
758 shost_printk(KERN_INFO, shost,
759 "%s: %s failed (rc 0x%x)\n", __func__,
760 fname, devinfo->response.response_code);
761 return FAILED;
762 }
763 return SUCCESS;
764 }
765
766 static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
767 {
768 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
769 struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
770 unsigned long flags;
771 int ret;
772
773 uas_log_cmd_state(cmnd, __func__);
774 spin_lock_irqsave(&devinfo->lock, flags);
775 WARN_ON_ONCE(cmdinfo->state & COMMAND_ABORTED);
776 cmdinfo->state |= COMMAND_ABORTED;
777 list_add_tail(&cmdinfo->dead, &devinfo->dead_list);
778 if (cmdinfo->state & IS_IN_WORK_LIST) {
779 list_del(&cmdinfo->work);
780 cmdinfo->state &= ~IS_IN_WORK_LIST;
781 }
782 if (cmdinfo->state & COMMAND_INFLIGHT) {
783 spin_unlock_irqrestore(&devinfo->lock, flags);
784 ret = uas_eh_task_mgmt(cmnd, "ABORT TASK", TMF_ABORT_TASK);
785 } else {
786 uas_unlink_data_urbs(devinfo, cmdinfo, &flags);
787 uas_try_complete(cmnd, __func__);
788 spin_unlock_irqrestore(&devinfo->lock, flags);
789 ret = SUCCESS;
790 }
791 return ret;
792 }
793
794 static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
795 {
796 sdev_printk(KERN_INFO, cmnd->device, "%s\n", __func__);
797 return uas_eh_task_mgmt(cmnd, "LOGICAL UNIT RESET",
798 TMF_LOGICAL_UNIT_RESET);
799 }
800
801 static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
802 {
803 struct scsi_device *sdev = cmnd->device;
804 struct uas_dev_info *devinfo = sdev->hostdata;
805 struct usb_device *udev = devinfo->udev;
806 int err;
807
808 err = usb_lock_device_for_reset(udev, devinfo->intf);
809 if (err) {
810 shost_printk(KERN_ERR, sdev->host,
811 "%s FAILED to get lock err %d\n", __func__, err);
812 return FAILED;
813 }
814
815 shost_printk(KERN_INFO, sdev->host, "%s start\n", __func__);
816 devinfo->resetting = 1;
817 uas_abort_work(devinfo);
818 usb_kill_anchored_urbs(&devinfo->cmd_urbs);
819 usb_kill_anchored_urbs(&devinfo->sense_urbs);
820 usb_kill_anchored_urbs(&devinfo->data_urbs);
821 uas_zap_dead(devinfo);
822 err = usb_reset_device(udev);
823 devinfo->resetting = 0;
824
825 usb_unlock_device(udev);
826
827 if (err) {
828 shost_printk(KERN_INFO, sdev->host, "%s FAILED\n", __func__);
829 return FAILED;
830 }
831
832 shost_printk(KERN_INFO, sdev->host, "%s success\n", __func__);
833 return SUCCESS;
834 }
835
836 static int uas_slave_alloc(struct scsi_device *sdev)
837 {
838 sdev->hostdata = (void *)sdev->host->hostdata[0];
839 return 0;
840 }
841
842 static int uas_slave_configure(struct scsi_device *sdev)
843 {
844 struct uas_dev_info *devinfo = sdev->hostdata;
845 scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
846 scsi_activate_tcq(sdev, devinfo->qdepth - 2);
847 return 0;
848 }
849
850 static struct scsi_host_template uas_host_template = {
851 .module = THIS_MODULE,
852 .name = "uas",
853 .queuecommand = uas_queuecommand,
854 .slave_alloc = uas_slave_alloc,
855 .slave_configure = uas_slave_configure,
856 .eh_abort_handler = uas_eh_abort_handler,
857 .eh_device_reset_handler = uas_eh_device_reset_handler,
858 .eh_bus_reset_handler = uas_eh_bus_reset_handler,
859 .can_queue = 65536, /* Is there a limit on the _host_ ? */
860 .this_id = -1,
861 .sg_tablesize = SG_NONE,
862 .cmd_per_lun = 1, /* until we override it */
863 .skip_settle_delay = 1,
864 .ordered_tag = 1,
865 };
866
867 static struct usb_device_id uas_usb_ids[] = {
868 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
869 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
870 /* 0xaa is a prototype device I happen to have access to */
871 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
872 { }
873 };
874 MODULE_DEVICE_TABLE(usb, uas_usb_ids);
875
876 static int uas_is_interface(struct usb_host_interface *intf)
877 {
878 return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE &&
879 intf->desc.bInterfaceSubClass == USB_SC_SCSI &&
880 intf->desc.bInterfaceProtocol == USB_PR_UAS);
881 }
882
883 static int uas_isnt_supported(struct usb_device *udev)
884 {
885 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
886
887 dev_warn(&udev->dev, "The driver for the USB controller %s does not "
888 "support scatter-gather which is\n",
889 hcd->driver->description);
890 dev_warn(&udev->dev, "required by the UAS driver. Please try an"
891 "alternative USB controller if you wish to use UAS.\n");
892 return -ENODEV;
893 }
894
895 static int uas_find_uas_alt_setting(struct usb_interface *intf)
896 {
897 int i;
898 struct usb_device *udev = interface_to_usbdev(intf);
899 int sg_supported = udev->bus->sg_tablesize != 0;
900
901 for (i = 0; i < intf->num_altsetting; i++) {
902 struct usb_host_interface *alt = &intf->altsetting[i];
903
904 if (uas_is_interface(alt)) {
905 if (!sg_supported)
906 return uas_isnt_supported(udev);
907 return alt->desc.bAlternateSetting;
908 }
909 }
910
911 return -ENODEV;
912 }
913
914 static int uas_switch_interface(struct usb_device *udev,
915 struct usb_interface *intf)
916 {
917 int alt;
918
919 alt = uas_find_uas_alt_setting(intf);
920 if (alt < 0)
921 return alt;
922
923 return usb_set_interface(udev,
924 intf->altsetting[0].desc.bInterfaceNumber, alt);
925 }
926
927 static void uas_configure_endpoints(struct uas_dev_info *devinfo)
928 {
929 struct usb_host_endpoint *eps[4] = { };
930 struct usb_interface *intf = devinfo->intf;
931 struct usb_device *udev = devinfo->udev;
932 struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
933 unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints;
934
935 devinfo->uas_sense_old = 0;
936 devinfo->cmnd = NULL;
937
938 for (i = 0; i < n_endpoints; i++) {
939 unsigned char *extra = endpoint[i].extra;
940 int len = endpoint[i].extralen;
941 while (len > 1) {
942 if (extra[1] == USB_DT_PIPE_USAGE) {
943 unsigned pipe_id = extra[2];
944 if (pipe_id > 0 && pipe_id < 5)
945 eps[pipe_id - 1] = &endpoint[i];
946 break;
947 }
948 len -= extra[0];
949 extra += extra[0];
950 }
951 }
952
953 /*
954 * Assume that if we didn't find a control pipe descriptor, we're
955 * using a device with old firmware that happens to be set up like
956 * this.
957 */
958 if (!eps[0]) {
959 devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1);
960 devinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
961 devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
962 devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);
963
964 eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe);
965 eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
966 eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
967 } else {
968 devinfo->cmd_pipe = usb_sndbulkpipe(udev,
969 usb_endpoint_num(&eps[0]->desc));
970 devinfo->status_pipe = usb_rcvbulkpipe(udev,
971 usb_endpoint_num(&eps[1]->desc));
972 devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
973 usb_endpoint_num(&eps[2]->desc));
974 devinfo->data_out_pipe = usb_sndbulkpipe(udev,
975 usb_endpoint_num(&eps[3]->desc));
976 }
977
978 devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256,
979 GFP_KERNEL);
980 if (devinfo->qdepth < 0) {
981 devinfo->qdepth = 256;
982 devinfo->use_streams = 0;
983 } else {
984 devinfo->use_streams = 1;
985 }
986 }
987
988 static void uas_free_streams(struct uas_dev_info *devinfo)
989 {
990 struct usb_device *udev = devinfo->udev;
991 struct usb_host_endpoint *eps[3];
992
993 eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
994 eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
995 eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
996 usb_free_streams(devinfo->intf, eps, 3, GFP_KERNEL);
997 }
998
999 /*
1000 * XXX: What I'd like to do here is register a SCSI host for each USB host in
1001 * the system. Follow usb-storage's design of registering a SCSI host for
1002 * each USB device for the moment. Can implement this by walking up the
1003 * USB hierarchy until we find a USB host.
1004 */
1005 static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
1006 {
1007 int result = -ENOMEM;
1008 struct Scsi_Host *shost = NULL;
1009 struct uas_dev_info *devinfo;
1010 struct usb_device *udev = interface_to_usbdev(intf);
1011
1012 if (uas_switch_interface(udev, intf))
1013 return -ENODEV;
1014
1015 devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
1016 if (!devinfo)
1017 goto set_alt0;
1018
1019 shost = scsi_host_alloc(&uas_host_template, sizeof(void *));
1020 if (!shost)
1021 goto set_alt0;
1022
1023 shost->max_cmd_len = 16 + 252;
1024 shost->max_id = 1;
1025 shost->max_lun = 256;
1026 shost->max_channel = 0;
1027 shost->sg_tablesize = udev->bus->sg_tablesize;
1028
1029 devinfo->intf = intf;
1030 devinfo->udev = udev;
1031 devinfo->resetting = 0;
1032 init_usb_anchor(&devinfo->cmd_urbs);
1033 init_usb_anchor(&devinfo->sense_urbs);
1034 init_usb_anchor(&devinfo->data_urbs);
1035 spin_lock_init(&devinfo->lock);
1036 INIT_WORK(&devinfo->work, uas_do_work);
1037 INIT_LIST_HEAD(&devinfo->work_list);
1038 INIT_LIST_HEAD(&devinfo->dead_list);
1039 uas_configure_endpoints(devinfo);
1040
1041 result = scsi_init_shared_tag_map(shost, devinfo->qdepth - 2);
1042 if (result)
1043 goto free_streams;
1044
1045 result = scsi_add_host(shost, &intf->dev);
1046 if (result)
1047 goto free_streams;
1048
1049 shost->hostdata[0] = (unsigned long)devinfo;
1050
1051 scsi_scan_host(shost);
1052 usb_set_intfdata(intf, shost);
1053 return result;
1054
1055 free_streams:
1056 uas_free_streams(devinfo);
1057 set_alt0:
1058 usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
1059 kfree(devinfo);
1060 if (shost)
1061 scsi_host_put(shost);
1062 return result;
1063 }
1064
1065 static int uas_pre_reset(struct usb_interface *intf)
1066 {
1067 struct Scsi_Host *shost = usb_get_intfdata(intf);
1068 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
1069 unsigned long flags;
1070
1071 /* Block new requests */
1072 spin_lock_irqsave(shost->host_lock, flags);
1073 scsi_block_requests(shost);
1074 spin_unlock_irqrestore(shost->host_lock, flags);
1075
1076 /* Wait for any pending requests to complete */
1077 flush_work(&devinfo->work);
1078 if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000) == 0) {
1079 shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1080 return 1;
1081 }
1082
1083 uas_free_streams(devinfo);
1084
1085 return 0;
1086 }
1087
1088 static int uas_post_reset(struct usb_interface *intf)
1089 {
1090 struct Scsi_Host *shost = usb_get_intfdata(intf);
1091 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
1092 unsigned long flags;
1093
1094 uas_configure_endpoints(devinfo);
1095
1096 spin_lock_irqsave(shost->host_lock, flags);
1097 scsi_report_bus_reset(shost, 0);
1098 spin_unlock_irqrestore(shost->host_lock, flags);
1099
1100 scsi_unblock_requests(shost);
1101
1102 return 0;
1103 }
1104
1105 static void uas_disconnect(struct usb_interface *intf)
1106 {
1107 struct Scsi_Host *shost = usb_get_intfdata(intf);
1108 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
1109
1110 devinfo->resetting = 1;
1111 cancel_work_sync(&devinfo->work);
1112 uas_abort_work(devinfo);
1113 usb_kill_anchored_urbs(&devinfo->cmd_urbs);
1114 usb_kill_anchored_urbs(&devinfo->sense_urbs);
1115 usb_kill_anchored_urbs(&devinfo->data_urbs);
1116 uas_zap_dead(devinfo);
1117 scsi_remove_host(shost);
1118 uas_free_streams(devinfo);
1119 kfree(devinfo);
1120 }
1121
1122 /*
1123 * XXX: Should this plug into libusual so we can auto-upgrade devices from
1124 * Bulk-Only to UAS?
1125 */
1126 static struct usb_driver uas_driver = {
1127 .name = "uas",
1128 .probe = uas_probe,
1129 .disconnect = uas_disconnect,
1130 .pre_reset = uas_pre_reset,
1131 .post_reset = uas_post_reset,
1132 .id_table = uas_usb_ids,
1133 };
1134
1135 module_usb_driver(uas_driver);
1136
1137 MODULE_LICENSE("GPL");
1138 MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp");
Linux kernel - Deliverables
This page took 0.070619 seconds and 6 git commands to generate.