3 * Note that this is not the same as the USB Mass Storage driver
5 * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 - 2014
6 * Copyright Matthew Wilcox for Intel Corp, 2010
7 * Copyright Sarah Sharp for Intel Corp, 2010
9 * Distributed under the terms of the GNU GPL, version two.
12 #include <linux/blkdev.h>
13 #include <linux/slab.h>
14 #include <linux/types.h>
15 #include <linux/module.h>
16 #include <linux/usb.h>
17 #include <linux/usb_usual.h>
18 #include <linux/usb/hcd.h>
19 #include <linux/usb/storage.h>
20 #include <linux/usb/uas.h>
22 #include <scsi/scsi.h>
23 #include <scsi/scsi_eh.h>
24 #include <scsi/scsi_dbg.h>
25 #include <scsi/scsi_cmnd.h>
26 #include <scsi/scsi_device.h>
27 #include <scsi/scsi_host.h>
28 #include <scsi/scsi_tcq.h>
30 #include "uas-detect.h"
36 struct usb_interface
*intf
;
37 struct usb_device
*udev
;
38 struct usb_anchor cmd_urbs
;
39 struct usb_anchor sense_urbs
;
40 struct usb_anchor data_urbs
;
42 int qdepth
, resetting
;
43 unsigned cmd_pipe
, status_pipe
, data_in_pipe
, data_out_pipe
;
44 unsigned use_streams
:1;
46 struct scsi_cmnd
*cmnd
[MAX_CMNDS
];
48 struct work_struct work
;
52 SUBMIT_STATUS_URB
= (1 << 1),
53 ALLOC_DATA_IN_URB
= (1 << 2),
54 SUBMIT_DATA_IN_URB
= (1 << 3),
55 ALLOC_DATA_OUT_URB
= (1 << 4),
56 SUBMIT_DATA_OUT_URB
= (1 << 5),
57 ALLOC_CMD_URB
= (1 << 6),
58 SUBMIT_CMD_URB
= (1 << 7),
59 COMMAND_INFLIGHT
= (1 << 8),
60 DATA_IN_URB_INFLIGHT
= (1 << 9),
61 DATA_OUT_URB_INFLIGHT
= (1 << 10),
62 COMMAND_ABORTED
= (1 << 11),
63 IS_IN_WORK_LIST
= (1 << 12),
66 /* Overrides scsi_pointer */
71 struct urb
*data_in_urb
;
72 struct urb
*data_out_urb
;
75 /* I hate forward declarations, but I actually have a loop */
76 static int uas_submit_urbs(struct scsi_cmnd
*cmnd
,
77 struct uas_dev_info
*devinfo
, gfp_t gfp
);
78 static void uas_do_work(struct work_struct
*work
);
79 static int uas_try_complete(struct scsi_cmnd
*cmnd
, const char *caller
);
80 static void uas_free_streams(struct uas_dev_info
*devinfo
);
81 static void uas_log_cmd_state(struct scsi_cmnd
*cmnd
, const char *prefix
,
84 static void uas_do_work(struct work_struct
*work
)
86 struct uas_dev_info
*devinfo
=
87 container_of(work
, struct uas_dev_info
, work
);
88 struct uas_cmd_info
*cmdinfo
;
89 struct scsi_cmnd
*cmnd
;
93 spin_lock_irqsave(&devinfo
->lock
, flags
);
95 if (devinfo
->resetting
)
98 for (i
= 0; i
< devinfo
->qdepth
; i
++) {
99 if (!devinfo
->cmnd
[i
])
102 cmnd
= devinfo
->cmnd
[i
];
103 cmdinfo
= (void *)&cmnd
->SCp
;
105 if (!(cmdinfo
->state
& IS_IN_WORK_LIST
))
108 err
= uas_submit_urbs(cmnd
, cmnd
->device
->hostdata
, GFP_ATOMIC
);
110 cmdinfo
->state
&= ~IS_IN_WORK_LIST
;
112 schedule_work(&devinfo
->work
);
115 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
118 static void uas_add_work(struct uas_cmd_info
*cmdinfo
)
120 struct scsi_pointer
*scp
= (void *)cmdinfo
;
121 struct scsi_cmnd
*cmnd
= container_of(scp
, struct scsi_cmnd
, SCp
);
122 struct uas_dev_info
*devinfo
= cmnd
->device
->hostdata
;
124 lockdep_assert_held(&devinfo
->lock
);
125 cmdinfo
->state
|= IS_IN_WORK_LIST
;
126 schedule_work(&devinfo
->work
);
129 static void uas_zap_pending(struct uas_dev_info
*devinfo
, int result
)
131 struct uas_cmd_info
*cmdinfo
;
132 struct scsi_cmnd
*cmnd
;
136 spin_lock_irqsave(&devinfo
->lock
, flags
);
137 for (i
= 0; i
< devinfo
->qdepth
; i
++) {
138 if (!devinfo
->cmnd
[i
])
141 cmnd
= devinfo
->cmnd
[i
];
142 cmdinfo
= (void *)&cmnd
->SCp
;
143 uas_log_cmd_state(cmnd
, __func__
, 0);
144 /* Sense urbs were killed, clear COMMAND_INFLIGHT manually */
145 cmdinfo
->state
&= ~COMMAND_INFLIGHT
;
146 cmnd
->result
= result
<< 16;
147 err
= uas_try_complete(cmnd
, __func__
);
150 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
153 static void uas_sense(struct urb
*urb
, struct scsi_cmnd
*cmnd
)
155 struct sense_iu
*sense_iu
= urb
->transfer_buffer
;
156 struct scsi_device
*sdev
= cmnd
->device
;
158 if (urb
->actual_length
> 16) {
159 unsigned len
= be16_to_cpup(&sense_iu
->len
);
160 if (len
+ 16 != urb
->actual_length
) {
161 int newlen
= min(len
+ 16, urb
->actual_length
) - 16;
164 sdev_printk(KERN_INFO
, sdev
, "%s: urb length %d "
165 "disagrees with IU sense data length %d, "
166 "using %d bytes of sense data\n", __func__
,
167 urb
->actual_length
, len
, newlen
);
170 memcpy(cmnd
->sense_buffer
, sense_iu
->sense
, len
);
173 cmnd
->result
= sense_iu
->status
;
177 * scsi-tags go from 0 - (nr_tags - 1), uas tags need to match stream-ids,
178 * which go from 1 - nr_streams. And we use 1 for untagged commands.
180 static int uas_get_tag(struct scsi_cmnd
*cmnd
)
184 if (blk_rq_tagged(cmnd
->request
))
185 tag
= cmnd
->request
->tag
+ 2;
192 static void uas_log_cmd_state(struct scsi_cmnd
*cmnd
, const char *prefix
,
195 struct uas_cmd_info
*ci
= (void *)&cmnd
->SCp
;
197 scmd_printk(KERN_INFO
, cmnd
,
198 "%s %d tag %d inflight:%s%s%s%s%s%s%s%s%s%s%s%s ",
199 prefix
, status
, uas_get_tag(cmnd
),
200 (ci
->state
& SUBMIT_STATUS_URB
) ? " s-st" : "",
201 (ci
->state
& ALLOC_DATA_IN_URB
) ? " a-in" : "",
202 (ci
->state
& SUBMIT_DATA_IN_URB
) ? " s-in" : "",
203 (ci
->state
& ALLOC_DATA_OUT_URB
) ? " a-out" : "",
204 (ci
->state
& SUBMIT_DATA_OUT_URB
) ? " s-out" : "",
205 (ci
->state
& ALLOC_CMD_URB
) ? " a-cmd" : "",
206 (ci
->state
& SUBMIT_CMD_URB
) ? " s-cmd" : "",
207 (ci
->state
& COMMAND_INFLIGHT
) ? " CMD" : "",
208 (ci
->state
& DATA_IN_URB_INFLIGHT
) ? " IN" : "",
209 (ci
->state
& DATA_OUT_URB_INFLIGHT
) ? " OUT" : "",
210 (ci
->state
& COMMAND_ABORTED
) ? " abort" : "",
211 (ci
->state
& IS_IN_WORK_LIST
) ? " work" : "");
212 scsi_print_command(cmnd
);
215 static void uas_free_unsubmitted_urbs(struct scsi_cmnd
*cmnd
)
217 struct uas_cmd_info
*cmdinfo
;
222 cmdinfo
= (void *)&cmnd
->SCp
;
224 if (cmdinfo
->state
& SUBMIT_CMD_URB
)
225 usb_free_urb(cmdinfo
->cmd_urb
);
227 /* data urbs may have never gotten their submit flag set */
228 if (!(cmdinfo
->state
& DATA_IN_URB_INFLIGHT
))
229 usb_free_urb(cmdinfo
->data_in_urb
);
230 if (!(cmdinfo
->state
& DATA_OUT_URB_INFLIGHT
))
231 usb_free_urb(cmdinfo
->data_out_urb
);
234 static int uas_try_complete(struct scsi_cmnd
*cmnd
, const char *caller
)
236 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
237 struct uas_dev_info
*devinfo
= (void *)cmnd
->device
->hostdata
;
239 lockdep_assert_held(&devinfo
->lock
);
240 if (cmdinfo
->state
& (COMMAND_INFLIGHT
|
241 DATA_IN_URB_INFLIGHT
|
242 DATA_OUT_URB_INFLIGHT
|
245 devinfo
->cmnd
[uas_get_tag(cmnd
) - 1] = NULL
;
246 uas_free_unsubmitted_urbs(cmnd
);
247 cmnd
->scsi_done(cmnd
);
251 static void uas_xfer_data(struct urb
*urb
, struct scsi_cmnd
*cmnd
,
254 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
257 cmdinfo
->state
|= direction
| SUBMIT_STATUS_URB
;
258 err
= uas_submit_urbs(cmnd
, cmnd
->device
->hostdata
, GFP_ATOMIC
);
260 uas_add_work(cmdinfo
);
264 static void uas_stat_cmplt(struct urb
*urb
)
266 struct iu
*iu
= urb
->transfer_buffer
;
267 struct Scsi_Host
*shost
= urb
->context
;
268 struct uas_dev_info
*devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
269 struct urb
*data_in_urb
= NULL
;
270 struct urb
*data_out_urb
= NULL
;
271 struct scsi_cmnd
*cmnd
;
272 struct uas_cmd_info
*cmdinfo
;
276 spin_lock_irqsave(&devinfo
->lock
, flags
);
278 if (devinfo
->resetting
)
282 if (urb
->status
!= -ENOENT
&& urb
->status
!= -ECONNRESET
) {
283 dev_err(&urb
->dev
->dev
, "stat urb: status %d\n",
289 idx
= be16_to_cpup(&iu
->tag
) - 1;
290 if (idx
>= MAX_CMNDS
|| !devinfo
->cmnd
[idx
]) {
291 dev_err(&urb
->dev
->dev
,
292 "stat urb: no pending cmd for tag %d\n", idx
+ 1);
296 cmnd
= devinfo
->cmnd
[idx
];
297 cmdinfo
= (void *)&cmnd
->SCp
;
299 if (!(cmdinfo
->state
& COMMAND_INFLIGHT
)) {
300 uas_log_cmd_state(cmnd
, "unexpected status cmplt", 0);
306 uas_sense(urb
, cmnd
);
307 if (cmnd
->result
!= 0) {
308 /* cancel data transfers on error */
309 data_in_urb
= usb_get_urb(cmdinfo
->data_in_urb
);
310 data_out_urb
= usb_get_urb(cmdinfo
->data_out_urb
);
312 cmdinfo
->state
&= ~COMMAND_INFLIGHT
;
313 uas_try_complete(cmnd
, __func__
);
315 case IU_ID_READ_READY
:
316 if (!cmdinfo
->data_in_urb
||
317 (cmdinfo
->state
& DATA_IN_URB_INFLIGHT
)) {
318 uas_log_cmd_state(cmnd
, "unexpected read rdy", 0);
321 uas_xfer_data(urb
, cmnd
, SUBMIT_DATA_IN_URB
);
323 case IU_ID_WRITE_READY
:
324 if (!cmdinfo
->data_out_urb
||
325 (cmdinfo
->state
& DATA_OUT_URB_INFLIGHT
)) {
326 uas_log_cmd_state(cmnd
, "unexpected write rdy", 0);
329 uas_xfer_data(urb
, cmnd
, SUBMIT_DATA_OUT_URB
);
332 uas_log_cmd_state(cmnd
, "unexpected response iu",
333 ((struct response_iu
*)iu
)->response_code
);
334 /* Error, cancel data transfers */
335 data_in_urb
= usb_get_urb(cmdinfo
->data_in_urb
);
336 data_out_urb
= usb_get_urb(cmdinfo
->data_out_urb
);
337 cmdinfo
->state
&= ~COMMAND_INFLIGHT
;
338 cmnd
->result
= DID_ERROR
<< 16;
339 uas_try_complete(cmnd
, __func__
);
342 uas_log_cmd_state(cmnd
, "bogus IU", iu
->iu_id
);
346 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
348 /* Unlinking of data urbs must be done without holding the lock */
350 usb_unlink_urb(data_in_urb
);
351 usb_put_urb(data_in_urb
);
354 usb_unlink_urb(data_out_urb
);
355 usb_put_urb(data_out_urb
);
359 static void uas_data_cmplt(struct urb
*urb
)
361 struct scsi_cmnd
*cmnd
= urb
->context
;
362 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
363 struct uas_dev_info
*devinfo
= (void *)cmnd
->device
->hostdata
;
364 struct scsi_data_buffer
*sdb
= NULL
;
367 spin_lock_irqsave(&devinfo
->lock
, flags
);
369 if (cmdinfo
->data_in_urb
== urb
) {
371 cmdinfo
->state
&= ~DATA_IN_URB_INFLIGHT
;
372 cmdinfo
->data_in_urb
= NULL
;
373 } else if (cmdinfo
->data_out_urb
== urb
) {
374 sdb
= scsi_out(cmnd
);
375 cmdinfo
->state
&= ~DATA_OUT_URB_INFLIGHT
;
376 cmdinfo
->data_out_urb
= NULL
;
383 if (devinfo
->resetting
)
386 /* Data urbs should not complete before the cmd urb is submitted */
387 if (cmdinfo
->state
& SUBMIT_CMD_URB
) {
388 uas_log_cmd_state(cmnd
, "unexpected data cmplt", 0);
393 if (urb
->status
!= -ENOENT
&& urb
->status
!= -ECONNRESET
)
394 uas_log_cmd_state(cmnd
, "data cmplt err", urb
->status
);
395 /* error: no data transfered */
396 sdb
->resid
= sdb
->length
;
398 sdb
->resid
= sdb
->length
- urb
->actual_length
;
400 uas_try_complete(cmnd
, __func__
);
403 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
406 static void uas_cmd_cmplt(struct urb
*urb
)
409 dev_err(&urb
->dev
->dev
, "cmd cmplt err %d\n", urb
->status
);
414 static struct urb
*uas_alloc_data_urb(struct uas_dev_info
*devinfo
, gfp_t gfp
,
415 struct scsi_cmnd
*cmnd
,
416 enum dma_data_direction dir
)
418 struct usb_device
*udev
= devinfo
->udev
;
419 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
420 struct urb
*urb
= usb_alloc_urb(0, gfp
);
421 struct scsi_data_buffer
*sdb
= (dir
== DMA_FROM_DEVICE
)
422 ? scsi_in(cmnd
) : scsi_out(cmnd
);
423 unsigned int pipe
= (dir
== DMA_FROM_DEVICE
)
424 ? devinfo
->data_in_pipe
: devinfo
->data_out_pipe
;
428 usb_fill_bulk_urb(urb
, udev
, pipe
, NULL
, sdb
->length
,
429 uas_data_cmplt
, cmnd
);
430 urb
->stream_id
= cmdinfo
->stream
;
431 urb
->num_sgs
= udev
->bus
->sg_tablesize
? sdb
->table
.nents
: 0;
432 urb
->sg
= sdb
->table
.sgl
;
437 static struct urb
*uas_alloc_sense_urb(struct uas_dev_info
*devinfo
, gfp_t gfp
,
438 struct scsi_cmnd
*cmnd
)
440 struct usb_device
*udev
= devinfo
->udev
;
441 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
442 struct urb
*urb
= usb_alloc_urb(0, gfp
);
448 iu
= kzalloc(sizeof(*iu
), gfp
);
452 usb_fill_bulk_urb(urb
, udev
, devinfo
->status_pipe
, iu
, sizeof(*iu
),
453 uas_stat_cmplt
, cmnd
->device
->host
);
454 urb
->stream_id
= cmdinfo
->stream
;
455 urb
->transfer_flags
|= URB_FREE_BUFFER
;
463 static struct urb
*uas_alloc_cmd_urb(struct uas_dev_info
*devinfo
, gfp_t gfp
,
464 struct scsi_cmnd
*cmnd
)
466 struct usb_device
*udev
= devinfo
->udev
;
467 struct scsi_device
*sdev
= cmnd
->device
;
468 struct urb
*urb
= usb_alloc_urb(0, gfp
);
469 struct command_iu
*iu
;
475 len
= cmnd
->cmd_len
- 16;
479 iu
= kzalloc(sizeof(*iu
) + len
, gfp
);
483 iu
->iu_id
= IU_ID_COMMAND
;
484 iu
->tag
= cpu_to_be16(uas_get_tag(cmnd
));
485 iu
->prio_attr
= UAS_SIMPLE_TAG
;
487 int_to_scsilun(sdev
->lun
, &iu
->lun
);
488 memcpy(iu
->cdb
, cmnd
->cmnd
, cmnd
->cmd_len
);
490 usb_fill_bulk_urb(urb
, udev
, devinfo
->cmd_pipe
, iu
, sizeof(*iu
) + len
,
491 uas_cmd_cmplt
, NULL
);
492 urb
->transfer_flags
|= URB_FREE_BUFFER
;
501 * Why should I request the Status IU before sending the Command IU? Spec
502 * says to, but also says the device may receive them in any order. Seems
506 static struct urb
*uas_submit_sense_urb(struct scsi_cmnd
*cmnd
, gfp_t gfp
)
508 struct uas_dev_info
*devinfo
= cmnd
->device
->hostdata
;
512 urb
= uas_alloc_sense_urb(devinfo
, gfp
, cmnd
);
515 usb_anchor_urb(urb
, &devinfo
->sense_urbs
);
516 err
= usb_submit_urb(urb
, gfp
);
518 usb_unanchor_urb(urb
);
519 uas_log_cmd_state(cmnd
, "sense submit err", err
);
526 static int uas_submit_urbs(struct scsi_cmnd
*cmnd
,
527 struct uas_dev_info
*devinfo
, gfp_t gfp
)
529 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
533 lockdep_assert_held(&devinfo
->lock
);
534 if (cmdinfo
->state
& SUBMIT_STATUS_URB
) {
535 urb
= uas_submit_sense_urb(cmnd
, gfp
);
537 return SCSI_MLQUEUE_DEVICE_BUSY
;
538 cmdinfo
->state
&= ~SUBMIT_STATUS_URB
;
541 if (cmdinfo
->state
& ALLOC_DATA_IN_URB
) {
542 cmdinfo
->data_in_urb
= uas_alloc_data_urb(devinfo
, gfp
,
543 cmnd
, DMA_FROM_DEVICE
);
544 if (!cmdinfo
->data_in_urb
)
545 return SCSI_MLQUEUE_DEVICE_BUSY
;
546 cmdinfo
->state
&= ~ALLOC_DATA_IN_URB
;
549 if (cmdinfo
->state
& SUBMIT_DATA_IN_URB
) {
550 usb_anchor_urb(cmdinfo
->data_in_urb
, &devinfo
->data_urbs
);
551 err
= usb_submit_urb(cmdinfo
->data_in_urb
, gfp
);
553 usb_unanchor_urb(cmdinfo
->data_in_urb
);
554 uas_log_cmd_state(cmnd
, "data in submit err", err
);
555 return SCSI_MLQUEUE_DEVICE_BUSY
;
557 cmdinfo
->state
&= ~SUBMIT_DATA_IN_URB
;
558 cmdinfo
->state
|= DATA_IN_URB_INFLIGHT
;
561 if (cmdinfo
->state
& ALLOC_DATA_OUT_URB
) {
562 cmdinfo
->data_out_urb
= uas_alloc_data_urb(devinfo
, gfp
,
563 cmnd
, DMA_TO_DEVICE
);
564 if (!cmdinfo
->data_out_urb
)
565 return SCSI_MLQUEUE_DEVICE_BUSY
;
566 cmdinfo
->state
&= ~ALLOC_DATA_OUT_URB
;
569 if (cmdinfo
->state
& SUBMIT_DATA_OUT_URB
) {
570 usb_anchor_urb(cmdinfo
->data_out_urb
, &devinfo
->data_urbs
);
571 err
= usb_submit_urb(cmdinfo
->data_out_urb
, gfp
);
573 usb_unanchor_urb(cmdinfo
->data_out_urb
);
574 uas_log_cmd_state(cmnd
, "data out submit err", err
);
575 return SCSI_MLQUEUE_DEVICE_BUSY
;
577 cmdinfo
->state
&= ~SUBMIT_DATA_OUT_URB
;
578 cmdinfo
->state
|= DATA_OUT_URB_INFLIGHT
;
581 if (cmdinfo
->state
& ALLOC_CMD_URB
) {
582 cmdinfo
->cmd_urb
= uas_alloc_cmd_urb(devinfo
, gfp
, cmnd
);
583 if (!cmdinfo
->cmd_urb
)
584 return SCSI_MLQUEUE_DEVICE_BUSY
;
585 cmdinfo
->state
&= ~ALLOC_CMD_URB
;
588 if (cmdinfo
->state
& SUBMIT_CMD_URB
) {
589 usb_anchor_urb(cmdinfo
->cmd_urb
, &devinfo
->cmd_urbs
);
590 err
= usb_submit_urb(cmdinfo
->cmd_urb
, gfp
);
592 usb_unanchor_urb(cmdinfo
->cmd_urb
);
593 uas_log_cmd_state(cmnd
, "cmd submit err", err
);
594 return SCSI_MLQUEUE_DEVICE_BUSY
;
596 cmdinfo
->cmd_urb
= NULL
;
597 cmdinfo
->state
&= ~SUBMIT_CMD_URB
;
598 cmdinfo
->state
|= COMMAND_INFLIGHT
;
604 static int uas_queuecommand_lck(struct scsi_cmnd
*cmnd
,
605 void (*done
)(struct scsi_cmnd
*))
607 struct scsi_device
*sdev
= cmnd
->device
;
608 struct uas_dev_info
*devinfo
= sdev
->hostdata
;
609 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
614 BUILD_BUG_ON(sizeof(struct uas_cmd_info
) > sizeof(struct scsi_pointer
));
616 /* Re-check scsi_block_requests now that we've the host-lock */
617 if (cmnd
->device
->host
->host_self_blocked
)
618 return SCSI_MLQUEUE_DEVICE_BUSY
;
620 if ((devinfo
->flags
& US_FL_NO_ATA_1X
) &&
621 (cmnd
->cmnd
[0] == ATA_12
|| cmnd
->cmnd
[0] == ATA_16
)) {
622 memcpy(cmnd
->sense_buffer
, usb_stor_sense_invalidCDB
,
623 sizeof(usb_stor_sense_invalidCDB
));
624 cmnd
->result
= SAM_STAT_CHECK_CONDITION
;
625 cmnd
->scsi_done(cmnd
);
629 spin_lock_irqsave(&devinfo
->lock
, flags
);
631 if (devinfo
->resetting
) {
632 cmnd
->result
= DID_ERROR
<< 16;
633 cmnd
->scsi_done(cmnd
);
634 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
638 stream
= uas_get_tag(cmnd
);
639 if (devinfo
->cmnd
[stream
- 1]) {
640 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
641 return SCSI_MLQUEUE_DEVICE_BUSY
;
644 cmnd
->scsi_done
= done
;
646 memset(cmdinfo
, 0, sizeof(*cmdinfo
));
647 cmdinfo
->stream
= stream
;
648 cmdinfo
->state
= SUBMIT_STATUS_URB
| ALLOC_CMD_URB
| SUBMIT_CMD_URB
;
650 switch (cmnd
->sc_data_direction
) {
651 case DMA_FROM_DEVICE
:
652 cmdinfo
->state
|= ALLOC_DATA_IN_URB
| SUBMIT_DATA_IN_URB
;
654 case DMA_BIDIRECTIONAL
:
655 cmdinfo
->state
|= ALLOC_DATA_IN_URB
| SUBMIT_DATA_IN_URB
;
657 cmdinfo
->state
|= ALLOC_DATA_OUT_URB
| SUBMIT_DATA_OUT_URB
;
662 if (!devinfo
->use_streams
) {
663 cmdinfo
->state
&= ~(SUBMIT_DATA_IN_URB
| SUBMIT_DATA_OUT_URB
);
667 err
= uas_submit_urbs(cmnd
, devinfo
, GFP_ATOMIC
);
669 /* If we did nothing, give up now */
670 if (cmdinfo
->state
& SUBMIT_STATUS_URB
) {
671 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
672 return SCSI_MLQUEUE_DEVICE_BUSY
;
674 uas_add_work(cmdinfo
);
677 devinfo
->cmnd
[stream
- 1] = cmnd
;
678 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
682 static DEF_SCSI_QCMD(uas_queuecommand
)
685 * For now we do not support actually sending an abort to the device, so
686 * this eh always fails. Still we must define it to make sure that we've
687 * dropped all references to the cmnd in question once this function exits.
689 static int uas_eh_abort_handler(struct scsi_cmnd
*cmnd
)
691 struct uas_cmd_info
*cmdinfo
= (void *)&cmnd
->SCp
;
692 struct uas_dev_info
*devinfo
= (void *)cmnd
->device
->hostdata
;
693 struct urb
*data_in_urb
= NULL
;
694 struct urb
*data_out_urb
= NULL
;
697 spin_lock_irqsave(&devinfo
->lock
, flags
);
699 uas_log_cmd_state(cmnd
, __func__
, 0);
701 /* Ensure that try_complete does not call scsi_done */
702 cmdinfo
->state
|= COMMAND_ABORTED
;
704 /* Drop all refs to this cmnd, kill data urbs to break their ref */
705 devinfo
->cmnd
[uas_get_tag(cmnd
) - 1] = NULL
;
706 if (cmdinfo
->state
& DATA_IN_URB_INFLIGHT
)
707 data_in_urb
= usb_get_urb(cmdinfo
->data_in_urb
);
708 if (cmdinfo
->state
& DATA_OUT_URB_INFLIGHT
)
709 data_out_urb
= usb_get_urb(cmdinfo
->data_out_urb
);
711 uas_free_unsubmitted_urbs(cmnd
);
713 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
716 usb_kill_urb(data_in_urb
);
717 usb_put_urb(data_in_urb
);
720 usb_kill_urb(data_out_urb
);
721 usb_put_urb(data_out_urb
);
727 static int uas_eh_bus_reset_handler(struct scsi_cmnd
*cmnd
)
729 struct scsi_device
*sdev
= cmnd
->device
;
730 struct uas_dev_info
*devinfo
= sdev
->hostdata
;
731 struct usb_device
*udev
= devinfo
->udev
;
735 err
= usb_lock_device_for_reset(udev
, devinfo
->intf
);
737 shost_printk(KERN_ERR
, sdev
->host
,
738 "%s FAILED to get lock err %d\n", __func__
, err
);
742 shost_printk(KERN_INFO
, sdev
->host
, "%s start\n", __func__
);
744 spin_lock_irqsave(&devinfo
->lock
, flags
);
745 devinfo
->resetting
= 1;
746 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
748 usb_kill_anchored_urbs(&devinfo
->cmd_urbs
);
749 usb_kill_anchored_urbs(&devinfo
->sense_urbs
);
750 usb_kill_anchored_urbs(&devinfo
->data_urbs
);
751 uas_zap_pending(devinfo
, DID_RESET
);
753 err
= usb_reset_device(udev
);
755 spin_lock_irqsave(&devinfo
->lock
, flags
);
756 devinfo
->resetting
= 0;
757 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
759 usb_unlock_device(udev
);
762 shost_printk(KERN_INFO
, sdev
->host
, "%s FAILED err %d\n",
767 shost_printk(KERN_INFO
, sdev
->host
, "%s success\n", __func__
);
771 static int uas_slave_alloc(struct scsi_device
*sdev
)
773 sdev
->hostdata
= (void *)sdev
->host
->hostdata
;
775 /* USB has unusual DMA-alignment requirements: Although the
776 * starting address of each scatter-gather element doesn't matter,
777 * the length of each element except the last must be divisible
778 * by the Bulk maxpacket value. There's currently no way to
779 * express this by block-layer constraints, so we'll cop out
780 * and simply require addresses to be aligned at 512-byte
781 * boundaries. This is okay since most block I/O involves
782 * hardware sectors that are multiples of 512 bytes in length,
783 * and since host controllers up through USB 2.0 have maxpacket
784 * values no larger than 512.
786 * But it doesn't suffice for Wireless USB, where Bulk maxpacket
787 * values can be as large as 2048. To make that work properly
788 * will require changes to the block layer.
790 blk_queue_update_dma_alignment(sdev
->request_queue
, (512 - 1));
795 static int uas_slave_configure(struct scsi_device
*sdev
)
797 struct uas_dev_info
*devinfo
= sdev
->hostdata
;
799 if (devinfo
->flags
& US_FL_NO_REPORT_OPCODES
)
800 sdev
->no_report_opcodes
= 1;
802 scsi_set_tag_type(sdev
, MSG_ORDERED_TAG
);
803 scsi_activate_tcq(sdev
, devinfo
->qdepth
- 2);
807 static struct scsi_host_template uas_host_template
= {
808 .module
= THIS_MODULE
,
810 .queuecommand
= uas_queuecommand
,
811 .slave_alloc
= uas_slave_alloc
,
812 .slave_configure
= uas_slave_configure
,
813 .eh_abort_handler
= uas_eh_abort_handler
,
814 .eh_bus_reset_handler
= uas_eh_bus_reset_handler
,
815 .can_queue
= 65536, /* Is there a limit on the _host_ ? */
817 .sg_tablesize
= SG_NONE
,
818 .cmd_per_lun
= 1, /* until we override it */
819 .skip_settle_delay
= 1,
823 * The uas drivers expects tags not to be bigger than the maximum
824 * per-device queue depth, which is not true with the blk-mq tag
827 .disable_blk_mq
= true,
830 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
831 vendorName, productName, useProtocol, useTransport, \
832 initFunction, flags) \
833 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
834 .driver_info = (flags) }
836 static struct usb_device_id uas_usb_ids
[] = {
837 # include "unusual_uas.h"
838 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE
, USB_SC_SCSI
, USB_PR_BULK
) },
839 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE
, USB_SC_SCSI
, USB_PR_UAS
) },
842 MODULE_DEVICE_TABLE(usb
, uas_usb_ids
);
846 static int uas_switch_interface(struct usb_device
*udev
,
847 struct usb_interface
*intf
)
851 alt
= uas_find_uas_alt_setting(intf
);
855 return usb_set_interface(udev
,
856 intf
->altsetting
[0].desc
.bInterfaceNumber
, alt
);
859 static int uas_configure_endpoints(struct uas_dev_info
*devinfo
)
861 struct usb_host_endpoint
*eps
[4] = { };
862 struct usb_device
*udev
= devinfo
->udev
;
865 r
= uas_find_endpoints(devinfo
->intf
->cur_altsetting
, eps
);
869 devinfo
->cmd_pipe
= usb_sndbulkpipe(udev
,
870 usb_endpoint_num(&eps
[0]->desc
));
871 devinfo
->status_pipe
= usb_rcvbulkpipe(udev
,
872 usb_endpoint_num(&eps
[1]->desc
));
873 devinfo
->data_in_pipe
= usb_rcvbulkpipe(udev
,
874 usb_endpoint_num(&eps
[2]->desc
));
875 devinfo
->data_out_pipe
= usb_sndbulkpipe(udev
,
876 usb_endpoint_num(&eps
[3]->desc
));
878 if (udev
->speed
< USB_SPEED_SUPER
) {
879 devinfo
->qdepth
= 32;
880 devinfo
->use_streams
= 0;
882 devinfo
->qdepth
= usb_alloc_streams(devinfo
->intf
, eps
+ 1,
883 3, MAX_CMNDS
, GFP_NOIO
);
884 if (devinfo
->qdepth
< 0)
885 return devinfo
->qdepth
;
886 devinfo
->use_streams
= 1;
892 static void uas_free_streams(struct uas_dev_info
*devinfo
)
894 struct usb_device
*udev
= devinfo
->udev
;
895 struct usb_host_endpoint
*eps
[3];
897 eps
[0] = usb_pipe_endpoint(udev
, devinfo
->status_pipe
);
898 eps
[1] = usb_pipe_endpoint(udev
, devinfo
->data_in_pipe
);
899 eps
[2] = usb_pipe_endpoint(udev
, devinfo
->data_out_pipe
);
900 usb_free_streams(devinfo
->intf
, eps
, 3, GFP_NOIO
);
903 static int uas_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
905 int result
= -ENOMEM
;
906 struct Scsi_Host
*shost
= NULL
;
907 struct uas_dev_info
*devinfo
;
908 struct usb_device
*udev
= interface_to_usbdev(intf
);
910 if (!uas_use_uas_driver(intf
, id
))
913 if (uas_switch_interface(udev
, intf
))
916 shost
= scsi_host_alloc(&uas_host_template
,
917 sizeof(struct uas_dev_info
));
921 shost
->max_cmd_len
= 16 + 252;
923 shost
->max_lun
= 256;
924 shost
->max_channel
= 0;
925 shost
->sg_tablesize
= udev
->bus
->sg_tablesize
;
927 devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
928 devinfo
->intf
= intf
;
929 devinfo
->udev
= udev
;
930 devinfo
->resetting
= 0;
931 devinfo
->shutdown
= 0;
932 devinfo
->flags
= id
->driver_info
;
933 usb_stor_adjust_quirks(udev
, &devinfo
->flags
);
934 init_usb_anchor(&devinfo
->cmd_urbs
);
935 init_usb_anchor(&devinfo
->sense_urbs
);
936 init_usb_anchor(&devinfo
->data_urbs
);
937 spin_lock_init(&devinfo
->lock
);
938 INIT_WORK(&devinfo
->work
, uas_do_work
);
940 result
= uas_configure_endpoints(devinfo
);
944 result
= scsi_init_shared_tag_map(shost
, devinfo
->qdepth
- 2);
948 usb_set_intfdata(intf
, shost
);
949 result
= scsi_add_host(shost
, &intf
->dev
);
953 scsi_scan_host(shost
);
957 uas_free_streams(devinfo
);
958 usb_set_intfdata(intf
, NULL
);
960 usb_set_interface(udev
, intf
->altsetting
[0].desc
.bInterfaceNumber
, 0);
962 scsi_host_put(shost
);
966 static int uas_cmnd_list_empty(struct uas_dev_info
*devinfo
)
971 spin_lock_irqsave(&devinfo
->lock
, flags
);
973 for (i
= 0; i
< devinfo
->qdepth
; i
++) {
974 if (devinfo
->cmnd
[i
]) {
975 r
= 0; /* Not empty */
980 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
986 * Wait for any pending cmnds to complete, on usb-2 sense_urbs may temporarily
987 * get empty while there still is more work to do due to sense-urbs completing
988 * with a READ/WRITE_READY iu code, so keep waiting until the list gets empty.
990 static int uas_wait_for_pending_cmnds(struct uas_dev_info
*devinfo
)
992 unsigned long start_time
;
995 start_time
= jiffies
;
997 flush_work(&devinfo
->work
);
999 r
= usb_wait_anchor_empty_timeout(&devinfo
->sense_urbs
, 5000);
1003 r
= usb_wait_anchor_empty_timeout(&devinfo
->data_urbs
, 500);
1007 if (time_after(jiffies
, start_time
+ 5 * HZ
))
1009 } while (!uas_cmnd_list_empty(devinfo
));
1014 static int uas_pre_reset(struct usb_interface
*intf
)
1016 struct Scsi_Host
*shost
= usb_get_intfdata(intf
);
1017 struct uas_dev_info
*devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
1018 unsigned long flags
;
1020 if (devinfo
->shutdown
)
1023 /* Block new requests */
1024 spin_lock_irqsave(shost
->host_lock
, flags
);
1025 scsi_block_requests(shost
);
1026 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1028 if (uas_wait_for_pending_cmnds(devinfo
) != 0) {
1029 shost_printk(KERN_ERR
, shost
, "%s: timed out\n", __func__
);
1030 scsi_unblock_requests(shost
);
1034 uas_free_streams(devinfo
);
1039 static int uas_post_reset(struct usb_interface
*intf
)
1041 struct Scsi_Host
*shost
= usb_get_intfdata(intf
);
1042 struct uas_dev_info
*devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
1043 unsigned long flags
;
1046 if (devinfo
->shutdown
)
1049 err
= uas_configure_endpoints(devinfo
);
1051 shost_printk(KERN_ERR
, shost
,
1052 "%s: alloc streams error %d after reset",
1057 spin_lock_irqsave(shost
->host_lock
, flags
);
1058 scsi_report_bus_reset(shost
, 0);
1059 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1061 scsi_unblock_requests(shost
);
1066 static int uas_suspend(struct usb_interface
*intf
, pm_message_t message
)
1068 struct Scsi_Host
*shost
= usb_get_intfdata(intf
);
1069 struct uas_dev_info
*devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
1071 if (uas_wait_for_pending_cmnds(devinfo
) != 0) {
1072 shost_printk(KERN_ERR
, shost
, "%s: timed out\n", __func__
);
1079 static int uas_resume(struct usb_interface
*intf
)
1084 static int uas_reset_resume(struct usb_interface
*intf
)
1086 struct Scsi_Host
*shost
= usb_get_intfdata(intf
);
1087 struct uas_dev_info
*devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
1088 unsigned long flags
;
1091 err
= uas_configure_endpoints(devinfo
);
1093 shost_printk(KERN_ERR
, shost
,
1094 "%s: alloc streams error %d after reset",
1099 spin_lock_irqsave(shost
->host_lock
, flags
);
1100 scsi_report_bus_reset(shost
, 0);
1101 spin_unlock_irqrestore(shost
->host_lock
, flags
);
1106 static void uas_disconnect(struct usb_interface
*intf
)
1108 struct Scsi_Host
*shost
= usb_get_intfdata(intf
);
1109 struct uas_dev_info
*devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
1110 unsigned long flags
;
1112 spin_lock_irqsave(&devinfo
->lock
, flags
);
1113 devinfo
->resetting
= 1;
1114 spin_unlock_irqrestore(&devinfo
->lock
, flags
);
1116 cancel_work_sync(&devinfo
->work
);
1117 usb_kill_anchored_urbs(&devinfo
->cmd_urbs
);
1118 usb_kill_anchored_urbs(&devinfo
->sense_urbs
);
1119 usb_kill_anchored_urbs(&devinfo
->data_urbs
);
1120 uas_zap_pending(devinfo
, DID_NO_CONNECT
);
1122 scsi_remove_host(shost
);
1123 uas_free_streams(devinfo
);
1124 scsi_host_put(shost
);
1128 * Put the device back in usb-storage mode on shutdown, as some BIOS-es
1129 * hang on reboot when the device is still in uas mode. Note the reset is
1130 * necessary as some devices won't revert to usb-storage mode without it.
1132 static void uas_shutdown(struct device
*dev
)
1134 struct usb_interface
*intf
= to_usb_interface(dev
);
1135 struct usb_device
*udev
= interface_to_usbdev(intf
);
1136 struct Scsi_Host
*shost
= usb_get_intfdata(intf
);
1137 struct uas_dev_info
*devinfo
= (struct uas_dev_info
*)shost
->hostdata
;
1139 if (system_state
!= SYSTEM_RESTART
)
1142 devinfo
->shutdown
= 1;
1143 uas_free_streams(devinfo
);
1144 usb_set_interface(udev
, intf
->altsetting
[0].desc
.bInterfaceNumber
, 0);
1145 usb_reset_device(udev
);
1148 static struct usb_driver uas_driver
= {
1151 .disconnect
= uas_disconnect
,
1152 .pre_reset
= uas_pre_reset
,
1153 .post_reset
= uas_post_reset
,
1154 .suspend
= uas_suspend
,
1155 .resume
= uas_resume
,
1156 .reset_resume
= uas_reset_resume
,
1157 .drvwrap
.driver
.shutdown
= uas_shutdown
,
1158 .id_table
= uas_usb_ids
,
1161 module_usb_driver(uas_driver
);
1163 MODULE_LICENSE("GPL");
1165 "Hans de Goede <hdegoede@redhat.com>, Matthew Wilcox and Sarah Sharp");