3 * Note that this is not the same as the USB Mass Storage driver
5 * Copyright Matthew Wilcox for Intel Corp, 2010
6 * Copyright Sarah Sharp for Intel Corp, 2010
8 * Distributed under the terms of the GNU GPL, version two.
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/storage.h>
18 #include <scsi/scsi.h>
19 #include <scsi/scsi_dbg.h>
20 #include <scsi/scsi_cmnd.h>
21 #include <scsi/scsi_device.h>
22 #include <scsi/scsi_host.h>
23 #include <scsi/scsi_tcq.h>
25 /* Common header for all IUs */
35 IU_ID_RESPONSE = 0x04,
36 IU_ID_TASK_MGMT = 0x05,
37 IU_ID_READ_READY = 0x06,
38 IU_ID_WRITE_READY = 0x07,
50 __u8 cdb[16]; /* XXX: Overflow-checking tools may misunderstand */
54 * Also used for the Read Ready and Write Ready IUs since they have the
55 * same first four bytes
65 __u8 sense[SCSI_SENSE_BUFFERSIZE];
69 * The r00-r01c specs define this version of the SENSE IU data structure.
70 * It's still in use by several different firmware releases.
78 __u8 service_response;
79 __u8 sense[SCSI_SENSE_BUFFERSIZE];
95 struct usb_interface *intf;
96 struct usb_device *udev;
98 unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
99 unsigned use_streams:1;
100 unsigned uas_sense_old:1;
104 ALLOC_STATUS_URB = (1 << 0),
105 SUBMIT_STATUS_URB = (1 << 1),
106 ALLOC_DATA_IN_URB = (1 << 2),
107 SUBMIT_DATA_IN_URB = (1 << 3),
108 ALLOC_DATA_OUT_URB = (1 << 4),
109 SUBMIT_DATA_OUT_URB = (1 << 5),
110 ALLOC_CMD_URB = (1 << 6),
111 SUBMIT_CMD_URB = (1 << 7),
114 /* Overrides scsi_pointer */
115 struct uas_cmd_info {
119 struct urb *status_urb;
120 struct urb *data_in_urb;
121 struct urb *data_out_urb;
122 struct list_head list;
125 /* I hate forward declarations, but I actually have a loop */
126 static int uas_submit_urbs(struct scsi_cmnd *cmnd,
127 struct uas_dev_info *devinfo, gfp_t gfp);
128 static void uas_do_work(struct work_struct *work);
130 static DECLARE_WORK(uas_work, uas_do_work);
131 static DEFINE_SPINLOCK(uas_work_lock);
132 static LIST_HEAD(uas_work_list);
134 static void uas_do_work(struct work_struct *work)
136 struct uas_cmd_info *cmdinfo;
137 struct uas_cmd_info *temp;
138 struct list_head list;
141 spin_lock_irq(&uas_work_lock);
142 list_replace_init(&uas_work_list, &list);
143 spin_unlock_irq(&uas_work_lock);
145 list_for_each_entry_safe(cmdinfo, temp, &list, list) {
146 struct scsi_pointer *scp = (void *)cmdinfo;
147 struct scsi_cmnd *cmnd = container_of(scp,
148 struct scsi_cmnd, SCp);
149 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_NOIO);
151 list_del(&cmdinfo->list);
152 spin_lock_irq(&uas_work_lock);
153 list_add_tail(&cmdinfo->list, &uas_work_list);
154 spin_unlock_irq(&uas_work_lock);
155 schedule_work(&uas_work);
160 static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
162 struct sense_iu *sense_iu = urb->transfer_buffer;
163 struct scsi_device *sdev = cmnd->device;
165 if (urb->actual_length > 16) {
166 unsigned len = be16_to_cpup(&sense_iu->len);
167 if (len + 16 != urb->actual_length) {
168 int newlen = min(len + 16, urb->actual_length) - 16;
171 sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
172 "disagrees with IU sense data length %d, "
173 "using %d bytes of sense data\n", __func__,
174 urb->actual_length, len, newlen);
177 memcpy(cmnd->sense_buffer, sense_iu->sense, len);
180 cmnd->result = sense_iu->status;
181 if (sdev->current_cmnd)
182 sdev->current_cmnd = NULL;
183 cmnd->scsi_done(cmnd);
187 static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd)
189 struct sense_iu_old *sense_iu = urb->transfer_buffer;
190 struct scsi_device *sdev = cmnd->device;
192 if (urb->actual_length > 8) {
193 unsigned len = be16_to_cpup(&sense_iu->len) - 2;
194 if (len + 8 != urb->actual_length) {
195 int newlen = min(len + 8, urb->actual_length) - 8;
198 sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
199 "disagrees with IU sense data length %d, "
200 "using %d bytes of sense data\n", __func__,
201 urb->actual_length, len, newlen);
204 memcpy(cmnd->sense_buffer, sense_iu->sense, len);
207 cmnd->result = sense_iu->status;
208 if (sdev->current_cmnd)
209 sdev->current_cmnd = NULL;
210 cmnd->scsi_done(cmnd);
214 static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
217 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
220 cmdinfo->state = direction | SUBMIT_STATUS_URB;
221 err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
223 spin_lock(&uas_work_lock);
224 list_add_tail(&cmdinfo->list, &uas_work_list);
225 spin_unlock(&uas_work_lock);
226 schedule_work(&uas_work);
230 static void uas_stat_cmplt(struct urb *urb)
232 struct iu *iu = urb->transfer_buffer;
233 struct scsi_device *sdev = urb->context;
234 struct uas_dev_info *devinfo = sdev->hostdata;
235 struct scsi_cmnd *cmnd;
239 dev_err(&urb->dev->dev, "URB BAD STATUS %d\n", urb->status);
244 tag = be16_to_cpup(&iu->tag) - 1;
245 if (sdev->current_cmnd)
246 cmnd = sdev->current_cmnd;
248 cmnd = scsi_find_tag(sdev, tag);
254 if (urb->actual_length < 16)
255 devinfo->uas_sense_old = 1;
256 if (devinfo->uas_sense_old)
257 uas_sense_old(urb, cmnd);
259 uas_sense(urb, cmnd);
261 case IU_ID_READ_READY:
262 uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
264 case IU_ID_WRITE_READY:
265 uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
268 scmd_printk(KERN_ERR, cmnd,
269 "Bogus IU (%d) received on status pipe\n", iu->iu_id);
273 static void uas_data_cmplt(struct urb *urb)
275 struct scsi_data_buffer *sdb = urb->context;
276 sdb->resid = sdb->length - urb->actual_length;
280 static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
281 unsigned int pipe, u16 stream_id,
282 struct scsi_data_buffer *sdb,
283 enum dma_data_direction dir)
285 struct usb_device *udev = devinfo->udev;
286 struct urb *urb = usb_alloc_urb(0, gfp);
290 usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length, uas_data_cmplt,
292 if (devinfo->use_streams)
293 urb->stream_id = stream_id;
294 urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
295 urb->sg = sdb->table.sgl;
300 static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
301 struct scsi_cmnd *cmnd, u16 stream_id)
303 struct usb_device *udev = devinfo->udev;
304 struct urb *urb = usb_alloc_urb(0, gfp);
310 iu = kzalloc(sizeof(*iu), gfp);
314 usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
315 uas_stat_cmplt, cmnd->device);
316 urb->stream_id = stream_id;
317 urb->transfer_flags |= URB_FREE_BUFFER;
325 static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
326 struct scsi_cmnd *cmnd, u16 stream_id)
328 struct usb_device *udev = devinfo->udev;
329 struct scsi_device *sdev = cmnd->device;
330 struct urb *urb = usb_alloc_urb(0, gfp);
331 struct command_iu *iu;
337 len = cmnd->cmd_len - 16;
341 iu = kzalloc(sizeof(*iu) + len, gfp);
345 iu->iu_id = IU_ID_COMMAND;
346 if (blk_rq_tagged(cmnd->request))
347 iu->tag = cpu_to_be16(cmnd->request->tag + 1);
349 iu->tag = cpu_to_be16(1);
350 iu->prio_attr = UAS_SIMPLE_TAG;
352 int_to_scsilun(sdev->lun, &iu->lun);
353 memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
355 usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
357 urb->transfer_flags |= URB_FREE_BUFFER;
366 * Why should I request the Status IU before sending the Command IU? Spec
367 * says to, but also says the device may receive them in any order. Seems
371 static int uas_submit_urbs(struct scsi_cmnd *cmnd,
372 struct uas_dev_info *devinfo, gfp_t gfp)
374 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
376 if (cmdinfo->state & ALLOC_STATUS_URB) {
377 cmdinfo->status_urb = uas_alloc_sense_urb(devinfo, gfp, cmnd,
379 if (!cmdinfo->status_urb)
380 return SCSI_MLQUEUE_DEVICE_BUSY;
381 cmdinfo->state &= ~ALLOC_STATUS_URB;
384 if (cmdinfo->state & SUBMIT_STATUS_URB) {
385 if (usb_submit_urb(cmdinfo->status_urb, gfp)) {
386 scmd_printk(KERN_INFO, cmnd,
387 "sense urb submission failure\n");
388 return SCSI_MLQUEUE_DEVICE_BUSY;
390 cmdinfo->state &= ~SUBMIT_STATUS_URB;
393 if (cmdinfo->state & ALLOC_DATA_IN_URB) {
394 cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
395 devinfo->data_in_pipe, cmdinfo->stream,
396 scsi_in(cmnd), DMA_FROM_DEVICE);
397 if (!cmdinfo->data_in_urb)
398 return SCSI_MLQUEUE_DEVICE_BUSY;
399 cmdinfo->state &= ~ALLOC_DATA_IN_URB;
402 if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
403 if (usb_submit_urb(cmdinfo->data_in_urb, gfp)) {
404 scmd_printk(KERN_INFO, cmnd,
405 "data in urb submission failure\n");
406 return SCSI_MLQUEUE_DEVICE_BUSY;
408 cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
411 if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
412 cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
413 devinfo->data_out_pipe, cmdinfo->stream,
414 scsi_out(cmnd), DMA_TO_DEVICE);
415 if (!cmdinfo->data_out_urb)
416 return SCSI_MLQUEUE_DEVICE_BUSY;
417 cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
420 if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
421 if (usb_submit_urb(cmdinfo->data_out_urb, gfp)) {
422 scmd_printk(KERN_INFO, cmnd,
423 "data out urb submission failure\n");
424 return SCSI_MLQUEUE_DEVICE_BUSY;
426 cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
429 if (cmdinfo->state & ALLOC_CMD_URB) {
430 cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd,
432 if (!cmdinfo->cmd_urb)
433 return SCSI_MLQUEUE_DEVICE_BUSY;
434 cmdinfo->state &= ~ALLOC_CMD_URB;
437 if (cmdinfo->state & SUBMIT_CMD_URB) {
438 if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
439 scmd_printk(KERN_INFO, cmnd,
440 "cmd urb submission failure\n");
441 return SCSI_MLQUEUE_DEVICE_BUSY;
443 cmdinfo->state &= ~SUBMIT_CMD_URB;
449 static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
450 void (*done)(struct scsi_cmnd *))
452 struct scsi_device *sdev = cmnd->device;
453 struct uas_dev_info *devinfo = sdev->hostdata;
454 struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
457 BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
459 if (!cmdinfo->status_urb && sdev->current_cmnd)
460 return SCSI_MLQUEUE_DEVICE_BUSY;
462 if (blk_rq_tagged(cmnd->request)) {
463 cmdinfo->stream = cmnd->request->tag + 1;
465 sdev->current_cmnd = cmnd;
469 cmnd->scsi_done = done;
471 cmdinfo->state = ALLOC_STATUS_URB | SUBMIT_STATUS_URB |
472 ALLOC_CMD_URB | SUBMIT_CMD_URB;
474 switch (cmnd->sc_data_direction) {
475 case DMA_FROM_DEVICE:
476 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
478 case DMA_BIDIRECTIONAL:
479 cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
481 cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
486 if (!devinfo->use_streams) {
487 cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
491 err = uas_submit_urbs(cmnd, devinfo, GFP_ATOMIC);
493 /* If we did nothing, give up now */
494 if (cmdinfo->state & SUBMIT_STATUS_URB) {
495 usb_free_urb(cmdinfo->status_urb);
496 return SCSI_MLQUEUE_DEVICE_BUSY;
498 spin_lock(&uas_work_lock);
499 list_add_tail(&cmdinfo->list, &uas_work_list);
500 spin_unlock(&uas_work_lock);
501 schedule_work(&uas_work);
507 static DEF_SCSI_QCMD(uas_queuecommand)
509 static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
511 struct scsi_device *sdev = cmnd->device;
512 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
515 /* XXX: Send ABORT TASK Task Management command */
519 static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
521 struct scsi_device *sdev = cmnd->device;
522 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
525 /* XXX: Send LOGICAL UNIT RESET Task Management command */
529 static int uas_eh_target_reset_handler(struct scsi_cmnd *cmnd)
531 struct scsi_device *sdev = cmnd->device;
532 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
535 /* XXX: Can we reset just the one USB interface?
536 * Would calling usb_set_interface() have the right effect?
541 static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
543 struct scsi_device *sdev = cmnd->device;
544 struct uas_dev_info *devinfo = sdev->hostdata;
545 struct usb_device *udev = devinfo->udev;
547 sdev_printk(KERN_INFO, sdev, "%s tag %d\n", __func__,
550 if (usb_reset_device(udev))
556 static int uas_slave_alloc(struct scsi_device *sdev)
558 sdev->hostdata = (void *)sdev->host->hostdata[0];
562 static int uas_slave_configure(struct scsi_device *sdev)
564 struct uas_dev_info *devinfo = sdev->hostdata;
565 scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
566 scsi_activate_tcq(sdev, devinfo->qdepth - 1);
570 static struct scsi_host_template uas_host_template = {
571 .module = THIS_MODULE,
573 .queuecommand = uas_queuecommand,
574 .slave_alloc = uas_slave_alloc,
575 .slave_configure = uas_slave_configure,
576 .eh_abort_handler = uas_eh_abort_handler,
577 .eh_device_reset_handler = uas_eh_device_reset_handler,
578 .eh_target_reset_handler = uas_eh_target_reset_handler,
579 .eh_bus_reset_handler = uas_eh_bus_reset_handler,
580 .can_queue = 65536, /* Is there a limit on the _host_ ? */
582 .sg_tablesize = SG_NONE,
583 .cmd_per_lun = 1, /* until we override it */
584 .skip_settle_delay = 1,
588 static struct usb_device_id uas_usb_ids[] = {
589 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
590 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
591 /* 0xaa is a prototype device I happen to have access to */
592 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
595 MODULE_DEVICE_TABLE(usb, uas_usb_ids);
597 static int uas_is_interface(struct usb_host_interface *intf)
599 return (intf->desc.bInterfaceClass == USB_CLASS_MASS_STORAGE &&
600 intf->desc.bInterfaceSubClass == USB_SC_SCSI &&
601 intf->desc.bInterfaceProtocol == USB_PR_UAS);
604 static int uas_switch_interface(struct usb_device *udev,
605 struct usb_interface *intf)
609 if (uas_is_interface(intf->cur_altsetting))
612 for (i = 0; i < intf->num_altsetting; i++) {
613 struct usb_host_interface *alt = &intf->altsetting[i];
614 if (alt == intf->cur_altsetting)
616 if (uas_is_interface(alt))
617 return usb_set_interface(udev,
618 alt->desc.bInterfaceNumber,
619 alt->desc.bAlternateSetting);
625 static void uas_configure_endpoints(struct uas_dev_info *devinfo)
627 struct usb_host_endpoint *eps[4] = { };
628 struct usb_interface *intf = devinfo->intf;
629 struct usb_device *udev = devinfo->udev;
630 struct usb_host_endpoint *endpoint = intf->cur_altsetting->endpoint;
631 unsigned i, n_endpoints = intf->cur_altsetting->desc.bNumEndpoints;
633 devinfo->uas_sense_old = 0;
635 for (i = 0; i < n_endpoints; i++) {
636 unsigned char *extra = endpoint[i].extra;
637 int len = endpoint[i].extralen;
639 if (extra[1] == USB_DT_PIPE_USAGE) {
640 unsigned pipe_id = extra[2];
641 if (pipe_id > 0 && pipe_id < 5)
642 eps[pipe_id - 1] = &endpoint[i];
651 * Assume that if we didn't find a control pipe descriptor, we're
652 * using a device with old firmware that happens to be set up like
656 devinfo->cmd_pipe = usb_sndbulkpipe(udev, 1);
657 devinfo->status_pipe = usb_rcvbulkpipe(udev, 1);
658 devinfo->data_in_pipe = usb_rcvbulkpipe(udev, 2);
659 devinfo->data_out_pipe = usb_sndbulkpipe(udev, 2);
661 eps[1] = usb_pipe_endpoint(udev, devinfo->status_pipe);
662 eps[2] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
663 eps[3] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
665 devinfo->cmd_pipe = usb_sndbulkpipe(udev,
666 eps[0]->desc.bEndpointAddress);
667 devinfo->status_pipe = usb_rcvbulkpipe(udev,
668 eps[1]->desc.bEndpointAddress);
669 devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
670 eps[2]->desc.bEndpointAddress);
671 devinfo->data_out_pipe = usb_sndbulkpipe(udev,
672 eps[3]->desc.bEndpointAddress);
675 devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1, 3, 256,
677 if (devinfo->qdepth < 0) {
678 devinfo->qdepth = 256;
679 devinfo->use_streams = 0;
681 devinfo->use_streams = 1;
686 * XXX: What I'd like to do here is register a SCSI host for each USB host in
687 * the system. Follow usb-storage's design of registering a SCSI host for
688 * each USB device for the moment. Can implement this by walking up the
689 * USB hierarchy until we find a USB host.
691 static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
694 struct Scsi_Host *shost;
695 struct uas_dev_info *devinfo;
696 struct usb_device *udev = interface_to_usbdev(intf);
698 if (uas_switch_interface(udev, intf))
701 devinfo = kmalloc(sizeof(struct uas_dev_info), GFP_KERNEL);
706 shost = scsi_host_alloc(&uas_host_template, sizeof(void *));
710 shost->max_cmd_len = 16 + 252;
712 shost->sg_tablesize = udev->bus->sg_tablesize;
714 result = scsi_add_host(shost, &intf->dev);
717 shost->hostdata[0] = (unsigned long)devinfo;
719 devinfo->intf = intf;
720 devinfo->udev = udev;
721 uas_configure_endpoints(devinfo);
723 scsi_scan_host(shost);
724 usb_set_intfdata(intf, shost);
729 scsi_host_put(shost);
733 static int uas_pre_reset(struct usb_interface *intf)
735 /* XXX: Need to return 1 if it's not our device in error handling */
739 static int uas_post_reset(struct usb_interface *intf)
741 /* XXX: Need to return 1 if it's not our device in error handling */
745 static void uas_disconnect(struct usb_interface *intf)
747 struct usb_device *udev = interface_to_usbdev(intf);
748 struct usb_host_endpoint *eps[3];
749 struct Scsi_Host *shost = usb_get_intfdata(intf);
750 struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
752 scsi_remove_host(shost);
754 eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
755 eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
756 eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
757 usb_free_streams(intf, eps, 3, GFP_KERNEL);
763 * XXX: Should this plug into libusual so we can auto-upgrade devices from
766 static struct usb_driver uas_driver = {
769 .disconnect = uas_disconnect,
770 .pre_reset = uas_pre_reset,
771 .post_reset = uas_post_reset,
772 .id_table = uas_usb_ids,
775 static int uas_init(void)
777 return usb_register(&uas_driver);
780 static void uas_exit(void)
782 usb_deregister(&uas_driver);
785 module_init(uas_init);
786 module_exit(uas_exit);
788 MODULE_LICENSE("GPL");
789 MODULE_AUTHOR("Matthew Wilcox and Sarah Sharp");