Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * USB Attached SCSI
0004  * Note that this is not the same as the USB Mass Storage driver
0005  *
0006  * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 - 2016
0007  * Copyright Matthew Wilcox for Intel Corp, 2010
0008  * Copyright Sarah Sharp for Intel Corp, 2010
0009  */
0010 
0011 #include <linux/blkdev.h>
0012 #include <linux/slab.h>
0013 #include <linux/types.h>
0014 #include <linux/module.h>
0015 #include <linux/usb.h>
0016 #include <linux/usb_usual.h>
0017 #include <linux/usb/hcd.h>
0018 #include <linux/usb/storage.h>
0019 #include <linux/usb/uas.h>
0020 
0021 #include <scsi/scsi.h>
0022 #include <scsi/scsi_eh.h>
0023 #include <scsi/scsi_dbg.h>
0024 #include <scsi/scsi_cmnd.h>
0025 #include <scsi/scsi_device.h>
0026 #include <scsi/scsi_host.h>
0027 #include <scsi/scsi_tcq.h>
0028 
0029 #include "uas-detect.h"
0030 #include "scsiglue.h"
0031 
0032 #define MAX_CMNDS 256
0033 
0034 struct uas_dev_info {
0035     struct usb_interface *intf;
0036     struct usb_device *udev;
0037     struct usb_anchor cmd_urbs;
0038     struct usb_anchor sense_urbs;
0039     struct usb_anchor data_urbs;
0040     unsigned long flags;
0041     int qdepth, resetting;
0042     unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
0043     unsigned use_streams:1;
0044     unsigned shutdown:1;
0045     struct scsi_cmnd *cmnd[MAX_CMNDS];
0046     spinlock_t lock;
0047     struct work_struct work;
0048     struct work_struct scan_work;      /* for async scanning */
0049 };
0050 
0051 enum {
0052     SUBMIT_STATUS_URB   = BIT(1),
0053     ALLOC_DATA_IN_URB   = BIT(2),
0054     SUBMIT_DATA_IN_URB  = BIT(3),
0055     ALLOC_DATA_OUT_URB  = BIT(4),
0056     SUBMIT_DATA_OUT_URB = BIT(5),
0057     ALLOC_CMD_URB       = BIT(6),
0058     SUBMIT_CMD_URB      = BIT(7),
0059     COMMAND_INFLIGHT        = BIT(8),
0060     DATA_IN_URB_INFLIGHT    = BIT(9),
0061     DATA_OUT_URB_INFLIGHT   = BIT(10),
0062     COMMAND_ABORTED         = BIT(11),
0063     IS_IN_WORK_LIST         = BIT(12),
0064 };
0065 
0066 /* Overrides scsi_pointer */
0067 struct uas_cmd_info {
0068     unsigned int state;
0069     unsigned int uas_tag;
0070     struct urb *cmd_urb;
0071     struct urb *data_in_urb;
0072     struct urb *data_out_urb;
0073 };
0074 
0075 /* I hate forward declarations, but I actually have a loop */
0076 static int uas_submit_urbs(struct scsi_cmnd *cmnd,
0077                 struct uas_dev_info *devinfo);
0078 static void uas_do_work(struct work_struct *work);
0079 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller);
0080 static void uas_free_streams(struct uas_dev_info *devinfo);
0081 static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
0082                 int status);
0083 
0084 /*
0085  * This driver needs its own workqueue, as we need to control memory allocation.
0086  *
0087  * In the course of error handling and power management uas_wait_for_pending_cmnds()
0088  * needs to flush pending work items. In these contexts we cannot allocate memory
0089  * by doing block IO as we would deadlock. For the same reason we cannot wait
0090  * for anything allocating memory not heeding these constraints.
0091  *
0092  * So we have to control all work items that can be on the workqueue we flush.
0093  * Hence we cannot share a queue and need our own.
0094  */
0095 static struct workqueue_struct *workqueue;
0096 
0097 static void uas_do_work(struct work_struct *work)
0098 {
0099     struct uas_dev_info *devinfo =
0100         container_of(work, struct uas_dev_info, work);
0101     struct uas_cmd_info *cmdinfo;
0102     struct scsi_cmnd *cmnd;
0103     unsigned long flags;
0104     int i, err;
0105 
0106     spin_lock_irqsave(&devinfo->lock, flags);
0107 
0108     if (devinfo->resetting)
0109         goto out;
0110 
0111     for (i = 0; i < devinfo->qdepth; i++) {
0112         if (!devinfo->cmnd[i])
0113             continue;
0114 
0115         cmnd = devinfo->cmnd[i];
0116         cmdinfo = scsi_cmd_priv(cmnd);
0117 
0118         if (!(cmdinfo->state & IS_IN_WORK_LIST))
0119             continue;
0120 
0121         err = uas_submit_urbs(cmnd, cmnd->device->hostdata);
0122         if (!err)
0123             cmdinfo->state &= ~IS_IN_WORK_LIST;
0124         else
0125             queue_work(workqueue, &devinfo->work);
0126     }
0127 out:
0128     spin_unlock_irqrestore(&devinfo->lock, flags);
0129 }
0130 
0131 static void uas_scan_work(struct work_struct *work)
0132 {
0133     struct uas_dev_info *devinfo =
0134         container_of(work, struct uas_dev_info, scan_work);
0135     struct Scsi_Host *shost = usb_get_intfdata(devinfo->intf);
0136 
0137     dev_dbg(&devinfo->intf->dev, "starting scan\n");
0138     scsi_scan_host(shost);
0139     dev_dbg(&devinfo->intf->dev, "scan complete\n");
0140 }
0141 
0142 static void uas_add_work(struct scsi_cmnd *cmnd)
0143 {
0144     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0145     struct uas_dev_info *devinfo = cmnd->device->hostdata;
0146 
0147     lockdep_assert_held(&devinfo->lock);
0148     cmdinfo->state |= IS_IN_WORK_LIST;
0149     queue_work(workqueue, &devinfo->work);
0150 }
0151 
0152 static void uas_zap_pending(struct uas_dev_info *devinfo, int result)
0153 {
0154     struct uas_cmd_info *cmdinfo;
0155     struct scsi_cmnd *cmnd;
0156     unsigned long flags;
0157     int i, err;
0158 
0159     spin_lock_irqsave(&devinfo->lock, flags);
0160     for (i = 0; i < devinfo->qdepth; i++) {
0161         if (!devinfo->cmnd[i])
0162             continue;
0163 
0164         cmnd = devinfo->cmnd[i];
0165         cmdinfo = scsi_cmd_priv(cmnd);
0166         uas_log_cmd_state(cmnd, __func__, 0);
0167         /* Sense urbs were killed, clear COMMAND_INFLIGHT manually */
0168         cmdinfo->state &= ~COMMAND_INFLIGHT;
0169         cmnd->result = result << 16;
0170         err = uas_try_complete(cmnd, __func__);
0171         WARN_ON(err != 0);
0172     }
0173     spin_unlock_irqrestore(&devinfo->lock, flags);
0174 }
0175 
0176 static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
0177 {
0178     struct sense_iu *sense_iu = urb->transfer_buffer;
0179     struct scsi_device *sdev = cmnd->device;
0180 
0181     if (urb->actual_length > 16) {
0182         unsigned len = be16_to_cpup(&sense_iu->len);
0183         if (len + 16 != urb->actual_length) {
0184             int newlen = min(len + 16, urb->actual_length) - 16;
0185             if (newlen < 0)
0186                 newlen = 0;
0187             sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
0188                 "disagrees with IU sense data length %d, "
0189                 "using %d bytes of sense data\n", __func__,
0190                     urb->actual_length, len, newlen);
0191             len = newlen;
0192         }
0193         memcpy(cmnd->sense_buffer, sense_iu->sense, len);
0194     }
0195 
0196     cmnd->result = sense_iu->status;
0197 }
0198 
0199 static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
0200                   int status)
0201 {
0202     struct uas_cmd_info *ci = scsi_cmd_priv(cmnd);
0203 
0204     if (status == -ENODEV) /* too late */
0205         return;
0206 
0207     scmd_printk(KERN_INFO, cmnd,
0208             "%s %d uas-tag %d inflight:%s%s%s%s%s%s%s%s%s%s%s%s ",
0209             prefix, status, ci->uas_tag,
0210             (ci->state & SUBMIT_STATUS_URB)     ? " s-st"  : "",
0211             (ci->state & ALLOC_DATA_IN_URB)     ? " a-in"  : "",
0212             (ci->state & SUBMIT_DATA_IN_URB)    ? " s-in"  : "",
0213             (ci->state & ALLOC_DATA_OUT_URB)    ? " a-out" : "",
0214             (ci->state & SUBMIT_DATA_OUT_URB)   ? " s-out" : "",
0215             (ci->state & ALLOC_CMD_URB)         ? " a-cmd" : "",
0216             (ci->state & SUBMIT_CMD_URB)        ? " s-cmd" : "",
0217             (ci->state & COMMAND_INFLIGHT)      ? " CMD"   : "",
0218             (ci->state & DATA_IN_URB_INFLIGHT)  ? " IN"    : "",
0219             (ci->state & DATA_OUT_URB_INFLIGHT) ? " OUT"   : "",
0220             (ci->state & COMMAND_ABORTED)       ? " abort" : "",
0221             (ci->state & IS_IN_WORK_LIST)       ? " work"  : "");
0222     scsi_print_command(cmnd);
0223 }
0224 
0225 static void uas_free_unsubmitted_urbs(struct scsi_cmnd *cmnd)
0226 {
0227     struct uas_cmd_info *cmdinfo;
0228 
0229     if (!cmnd)
0230         return;
0231 
0232     cmdinfo = scsi_cmd_priv(cmnd);
0233 
0234     if (cmdinfo->state & SUBMIT_CMD_URB)
0235         usb_free_urb(cmdinfo->cmd_urb);
0236 
0237     /* data urbs may have never gotten their submit flag set */
0238     if (!(cmdinfo->state & DATA_IN_URB_INFLIGHT))
0239         usb_free_urb(cmdinfo->data_in_urb);
0240     if (!(cmdinfo->state & DATA_OUT_URB_INFLIGHT))
0241         usb_free_urb(cmdinfo->data_out_urb);
0242 }
0243 
0244 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
0245 {
0246     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0247     struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
0248 
0249     lockdep_assert_held(&devinfo->lock);
0250     if (cmdinfo->state & (COMMAND_INFLIGHT |
0251                   DATA_IN_URB_INFLIGHT |
0252                   DATA_OUT_URB_INFLIGHT |
0253                   COMMAND_ABORTED))
0254         return -EBUSY;
0255     devinfo->cmnd[cmdinfo->uas_tag - 1] = NULL;
0256     uas_free_unsubmitted_urbs(cmnd);
0257     scsi_done(cmnd);
0258     return 0;
0259 }
0260 
0261 static void uas_xfer_data(struct urb *urb, struct scsi_cmnd *cmnd,
0262               unsigned direction)
0263 {
0264     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0265     int err;
0266 
0267     cmdinfo->state |= direction | SUBMIT_STATUS_URB;
0268     err = uas_submit_urbs(cmnd, cmnd->device->hostdata);
0269     if (err) {
0270         uas_add_work(cmnd);
0271     }
0272 }
0273 
0274 static bool uas_evaluate_response_iu(struct response_iu *riu, struct scsi_cmnd *cmnd)
0275 {
0276     u8 response_code = riu->response_code;
0277 
0278     switch (response_code) {
0279     case RC_INCORRECT_LUN:
0280         set_host_byte(cmnd, DID_BAD_TARGET);
0281         break;
0282     case RC_TMF_SUCCEEDED:
0283         set_host_byte(cmnd, DID_OK);
0284         break;
0285     case RC_TMF_NOT_SUPPORTED:
0286         set_host_byte(cmnd, DID_TARGET_FAILURE);
0287         break;
0288     default:
0289         uas_log_cmd_state(cmnd, "response iu", response_code);
0290         set_host_byte(cmnd, DID_ERROR);
0291         break;
0292     }
0293 
0294     return response_code == RC_TMF_SUCCEEDED;
0295 }
0296 
0297 static void uas_stat_cmplt(struct urb *urb)
0298 {
0299     struct iu *iu = urb->transfer_buffer;
0300     struct Scsi_Host *shost = urb->context;
0301     struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
0302     struct urb *data_in_urb = NULL;
0303     struct urb *data_out_urb = NULL;
0304     struct scsi_cmnd *cmnd;
0305     struct uas_cmd_info *cmdinfo;
0306     unsigned long flags;
0307     unsigned int idx;
0308     int status = urb->status;
0309     bool success;
0310 
0311     spin_lock_irqsave(&devinfo->lock, flags);
0312 
0313     if (devinfo->resetting)
0314         goto out;
0315 
0316     if (status) {
0317         if (status != -ENOENT && status != -ECONNRESET && status != -ESHUTDOWN)
0318             dev_err(&urb->dev->dev, "stat urb: status %d\n", status);
0319         goto out;
0320     }
0321 
0322     idx = be16_to_cpup(&iu->tag) - 1;
0323     if (idx >= MAX_CMNDS || !devinfo->cmnd[idx]) {
0324         dev_err(&urb->dev->dev,
0325             "stat urb: no pending cmd for uas-tag %d\n", idx + 1);
0326         goto out;
0327     }
0328 
0329     cmnd = devinfo->cmnd[idx];
0330     cmdinfo = scsi_cmd_priv(cmnd);
0331 
0332     if (!(cmdinfo->state & COMMAND_INFLIGHT)) {
0333         uas_log_cmd_state(cmnd, "unexpected status cmplt", 0);
0334         goto out;
0335     }
0336 
0337     switch (iu->iu_id) {
0338     case IU_ID_STATUS:
0339         uas_sense(urb, cmnd);
0340         if (cmnd->result != 0) {
0341             /* cancel data transfers on error */
0342             data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
0343             data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
0344         }
0345         cmdinfo->state &= ~COMMAND_INFLIGHT;
0346         uas_try_complete(cmnd, __func__);
0347         break;
0348     case IU_ID_READ_READY:
0349         if (!cmdinfo->data_in_urb ||
0350                 (cmdinfo->state & DATA_IN_URB_INFLIGHT)) {
0351             uas_log_cmd_state(cmnd, "unexpected read rdy", 0);
0352             break;
0353         }
0354         uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
0355         break;
0356     case IU_ID_WRITE_READY:
0357         if (!cmdinfo->data_out_urb ||
0358                 (cmdinfo->state & DATA_OUT_URB_INFLIGHT)) {
0359             uas_log_cmd_state(cmnd, "unexpected write rdy", 0);
0360             break;
0361         }
0362         uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
0363         break;
0364     case IU_ID_RESPONSE:
0365         cmdinfo->state &= ~COMMAND_INFLIGHT;
0366         success = uas_evaluate_response_iu((struct response_iu *)iu, cmnd);
0367         if (!success) {
0368             /* Error, cancel data transfers */
0369             data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
0370             data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
0371         }
0372         uas_try_complete(cmnd, __func__);
0373         break;
0374     default:
0375         uas_log_cmd_state(cmnd, "bogus IU", iu->iu_id);
0376     }
0377 out:
0378     usb_free_urb(urb);
0379     spin_unlock_irqrestore(&devinfo->lock, flags);
0380 
0381     /* Unlinking of data urbs must be done without holding the lock */
0382     if (data_in_urb) {
0383         usb_unlink_urb(data_in_urb);
0384         usb_put_urb(data_in_urb);
0385     }
0386     if (data_out_urb) {
0387         usb_unlink_urb(data_out_urb);
0388         usb_put_urb(data_out_urb);
0389     }
0390 }
0391 
0392 static void uas_data_cmplt(struct urb *urb)
0393 {
0394     struct scsi_cmnd *cmnd = urb->context;
0395     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0396     struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
0397     struct scsi_data_buffer *sdb = &cmnd->sdb;
0398     unsigned long flags;
0399     int status = urb->status;
0400 
0401     spin_lock_irqsave(&devinfo->lock, flags);
0402 
0403     if (cmdinfo->data_in_urb == urb) {
0404         cmdinfo->state &= ~DATA_IN_URB_INFLIGHT;
0405         cmdinfo->data_in_urb = NULL;
0406     } else if (cmdinfo->data_out_urb == urb) {
0407         cmdinfo->state &= ~DATA_OUT_URB_INFLIGHT;
0408         cmdinfo->data_out_urb = NULL;
0409     }
0410 
0411     if (devinfo->resetting)
0412         goto out;
0413 
0414     /* Data urbs should not complete before the cmd urb is submitted */
0415     if (cmdinfo->state & SUBMIT_CMD_URB) {
0416         uas_log_cmd_state(cmnd, "unexpected data cmplt", 0);
0417         goto out;
0418     }
0419 
0420     if (status) {
0421         if (status != -ENOENT && status != -ECONNRESET && status != -ESHUTDOWN)
0422             uas_log_cmd_state(cmnd, "data cmplt err", status);
0423         /* error: no data transfered */
0424         scsi_set_resid(cmnd, sdb->length);
0425     } else {
0426         scsi_set_resid(cmnd, sdb->length - urb->actual_length);
0427     }
0428     uas_try_complete(cmnd, __func__);
0429 out:
0430     usb_free_urb(urb);
0431     spin_unlock_irqrestore(&devinfo->lock, flags);
0432 }
0433 
0434 static void uas_cmd_cmplt(struct urb *urb)
0435 {
0436     if (urb->status)
0437         dev_err(&urb->dev->dev, "cmd cmplt err %d\n", urb->status);
0438 
0439     usb_free_urb(urb);
0440 }
0441 
0442 static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
0443                       struct scsi_cmnd *cmnd,
0444                       enum dma_data_direction dir)
0445 {
0446     struct usb_device *udev = devinfo->udev;
0447     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0448     struct urb *urb = usb_alloc_urb(0, gfp);
0449     struct scsi_data_buffer *sdb = &cmnd->sdb;
0450     unsigned int pipe = (dir == DMA_FROM_DEVICE)
0451         ? devinfo->data_in_pipe : devinfo->data_out_pipe;
0452 
0453     if (!urb)
0454         goto out;
0455     usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length,
0456               uas_data_cmplt, cmnd);
0457     if (devinfo->use_streams)
0458         urb->stream_id = cmdinfo->uas_tag;
0459     urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
0460     urb->sg = sdb->table.sgl;
0461  out:
0462     return urb;
0463 }
0464 
0465 static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
0466                        struct scsi_cmnd *cmnd)
0467 {
0468     struct usb_device *udev = devinfo->udev;
0469     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0470     struct urb *urb = usb_alloc_urb(0, gfp);
0471     struct sense_iu *iu;
0472 
0473     if (!urb)
0474         goto out;
0475 
0476     iu = kzalloc(sizeof(*iu), gfp);
0477     if (!iu)
0478         goto free;
0479 
0480     usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
0481               uas_stat_cmplt, cmnd->device->host);
0482     if (devinfo->use_streams)
0483         urb->stream_id = cmdinfo->uas_tag;
0484     urb->transfer_flags |= URB_FREE_BUFFER;
0485  out:
0486     return urb;
0487  free:
0488     usb_free_urb(urb);
0489     return NULL;
0490 }
0491 
0492 static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
0493                     struct scsi_cmnd *cmnd)
0494 {
0495     struct usb_device *udev = devinfo->udev;
0496     struct scsi_device *sdev = cmnd->device;
0497     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0498     struct urb *urb = usb_alloc_urb(0, gfp);
0499     struct command_iu *iu;
0500     int len;
0501 
0502     if (!urb)
0503         goto out;
0504 
0505     len = cmnd->cmd_len - 16;
0506     if (len < 0)
0507         len = 0;
0508     len = ALIGN(len, 4);
0509     iu = kzalloc(sizeof(*iu) + len, gfp);
0510     if (!iu)
0511         goto free;
0512 
0513     iu->iu_id = IU_ID_COMMAND;
0514     iu->tag = cpu_to_be16(cmdinfo->uas_tag);
0515     iu->prio_attr = UAS_SIMPLE_TAG;
0516     iu->len = len;
0517     int_to_scsilun(sdev->lun, &iu->lun);
0518     memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
0519 
0520     usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
0521                             uas_cmd_cmplt, NULL);
0522     urb->transfer_flags |= URB_FREE_BUFFER;
0523  out:
0524     return urb;
0525  free:
0526     usb_free_urb(urb);
0527     return NULL;
0528 }
0529 
0530 /*
0531  * Why should I request the Status IU before sending the Command IU?  Spec
0532  * says to, but also says the device may receive them in any order.  Seems
0533  * daft to me.
0534  */
0535 
0536 static struct urb *uas_submit_sense_urb(struct scsi_cmnd *cmnd, gfp_t gfp)
0537 {
0538     struct uas_dev_info *devinfo = cmnd->device->hostdata;
0539     struct urb *urb;
0540     int err;
0541 
0542     urb = uas_alloc_sense_urb(devinfo, gfp, cmnd);
0543     if (!urb)
0544         return NULL;
0545     usb_anchor_urb(urb, &devinfo->sense_urbs);
0546     err = usb_submit_urb(urb, gfp);
0547     if (err) {
0548         usb_unanchor_urb(urb);
0549         uas_log_cmd_state(cmnd, "sense submit err", err);
0550         usb_free_urb(urb);
0551         return NULL;
0552     }
0553     return urb;
0554 }
0555 
0556 static int uas_submit_urbs(struct scsi_cmnd *cmnd,
0557                struct uas_dev_info *devinfo)
0558 {
0559     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0560     struct urb *urb;
0561     int err;
0562 
0563     lockdep_assert_held(&devinfo->lock);
0564     if (cmdinfo->state & SUBMIT_STATUS_URB) {
0565         urb = uas_submit_sense_urb(cmnd, GFP_ATOMIC);
0566         if (!urb)
0567             return SCSI_MLQUEUE_DEVICE_BUSY;
0568         cmdinfo->state &= ~SUBMIT_STATUS_URB;
0569     }
0570 
0571     if (cmdinfo->state & ALLOC_DATA_IN_URB) {
0572         cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, GFP_ATOMIC,
0573                             cmnd, DMA_FROM_DEVICE);
0574         if (!cmdinfo->data_in_urb)
0575             return SCSI_MLQUEUE_DEVICE_BUSY;
0576         cmdinfo->state &= ~ALLOC_DATA_IN_URB;
0577     }
0578 
0579     if (cmdinfo->state & SUBMIT_DATA_IN_URB) {
0580         usb_anchor_urb(cmdinfo->data_in_urb, &devinfo->data_urbs);
0581         err = usb_submit_urb(cmdinfo->data_in_urb, GFP_ATOMIC);
0582         if (err) {
0583             usb_unanchor_urb(cmdinfo->data_in_urb);
0584             uas_log_cmd_state(cmnd, "data in submit err", err);
0585             return SCSI_MLQUEUE_DEVICE_BUSY;
0586         }
0587         cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
0588         cmdinfo->state |= DATA_IN_URB_INFLIGHT;
0589     }
0590 
0591     if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
0592         cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, GFP_ATOMIC,
0593                             cmnd, DMA_TO_DEVICE);
0594         if (!cmdinfo->data_out_urb)
0595             return SCSI_MLQUEUE_DEVICE_BUSY;
0596         cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
0597     }
0598 
0599     if (cmdinfo->state & SUBMIT_DATA_OUT_URB) {
0600         usb_anchor_urb(cmdinfo->data_out_urb, &devinfo->data_urbs);
0601         err = usb_submit_urb(cmdinfo->data_out_urb, GFP_ATOMIC);
0602         if (err) {
0603             usb_unanchor_urb(cmdinfo->data_out_urb);
0604             uas_log_cmd_state(cmnd, "data out submit err", err);
0605             return SCSI_MLQUEUE_DEVICE_BUSY;
0606         }
0607         cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
0608         cmdinfo->state |= DATA_OUT_URB_INFLIGHT;
0609     }
0610 
0611     if (cmdinfo->state & ALLOC_CMD_URB) {
0612         cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, GFP_ATOMIC, cmnd);
0613         if (!cmdinfo->cmd_urb)
0614             return SCSI_MLQUEUE_DEVICE_BUSY;
0615         cmdinfo->state &= ~ALLOC_CMD_URB;
0616     }
0617 
0618     if (cmdinfo->state & SUBMIT_CMD_URB) {
0619         usb_anchor_urb(cmdinfo->cmd_urb, &devinfo->cmd_urbs);
0620         err = usb_submit_urb(cmdinfo->cmd_urb, GFP_ATOMIC);
0621         if (err) {
0622             usb_unanchor_urb(cmdinfo->cmd_urb);
0623             uas_log_cmd_state(cmnd, "cmd submit err", err);
0624             return SCSI_MLQUEUE_DEVICE_BUSY;
0625         }
0626         cmdinfo->cmd_urb = NULL;
0627         cmdinfo->state &= ~SUBMIT_CMD_URB;
0628         cmdinfo->state |= COMMAND_INFLIGHT;
0629     }
0630 
0631     return 0;
0632 }
0633 
0634 static int uas_queuecommand_lck(struct scsi_cmnd *cmnd)
0635 {
0636     struct scsi_device *sdev = cmnd->device;
0637     struct uas_dev_info *devinfo = sdev->hostdata;
0638     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0639     unsigned long flags;
0640     int idx, err;
0641 
0642     /* Re-check scsi_block_requests now that we've the host-lock */
0643     if (cmnd->device->host->host_self_blocked)
0644         return SCSI_MLQUEUE_DEVICE_BUSY;
0645 
0646     if ((devinfo->flags & US_FL_NO_ATA_1X) &&
0647             (cmnd->cmnd[0] == ATA_12 || cmnd->cmnd[0] == ATA_16)) {
0648         memcpy(cmnd->sense_buffer, usb_stor_sense_invalidCDB,
0649                sizeof(usb_stor_sense_invalidCDB));
0650         cmnd->result = SAM_STAT_CHECK_CONDITION;
0651         scsi_done(cmnd);
0652         return 0;
0653     }
0654 
0655     spin_lock_irqsave(&devinfo->lock, flags);
0656 
0657     if (devinfo->resetting) {
0658         set_host_byte(cmnd, DID_ERROR);
0659         scsi_done(cmnd);
0660         goto zombie;
0661     }
0662 
0663     /* Find a free uas-tag */
0664     for (idx = 0; idx < devinfo->qdepth; idx++) {
0665         if (!devinfo->cmnd[idx])
0666             break;
0667     }
0668     if (idx == devinfo->qdepth) {
0669         spin_unlock_irqrestore(&devinfo->lock, flags);
0670         return SCSI_MLQUEUE_DEVICE_BUSY;
0671     }
0672 
0673     memset(cmdinfo, 0, sizeof(*cmdinfo));
0674     cmdinfo->uas_tag = idx + 1; /* uas-tag == usb-stream-id, so 1 based */
0675     cmdinfo->state = SUBMIT_STATUS_URB | ALLOC_CMD_URB | SUBMIT_CMD_URB;
0676 
0677     switch (cmnd->sc_data_direction) {
0678     case DMA_FROM_DEVICE:
0679         cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
0680         break;
0681     case DMA_BIDIRECTIONAL:
0682         cmdinfo->state |= ALLOC_DATA_IN_URB | SUBMIT_DATA_IN_URB;
0683         fallthrough;
0684     case DMA_TO_DEVICE:
0685         cmdinfo->state |= ALLOC_DATA_OUT_URB | SUBMIT_DATA_OUT_URB;
0686         break;
0687     case DMA_NONE:
0688         break;
0689     }
0690 
0691     if (!devinfo->use_streams)
0692         cmdinfo->state &= ~(SUBMIT_DATA_IN_URB | SUBMIT_DATA_OUT_URB);
0693 
0694     err = uas_submit_urbs(cmnd, devinfo);
0695     /*
0696      * in case of fatal errors the SCSI layer is peculiar
0697      * a command that has finished is a success for the purpose
0698      * of queueing, no matter how fatal the error
0699      */
0700     if (err == -ENODEV) {
0701         set_host_byte(cmnd, DID_ERROR);
0702         scsi_done(cmnd);
0703         goto zombie;
0704     }
0705     if (err) {
0706         /* If we did nothing, give up now */
0707         if (cmdinfo->state & SUBMIT_STATUS_URB) {
0708             spin_unlock_irqrestore(&devinfo->lock, flags);
0709             return SCSI_MLQUEUE_DEVICE_BUSY;
0710         }
0711         uas_add_work(cmnd);
0712     }
0713 
0714     devinfo->cmnd[idx] = cmnd;
0715 zombie:
0716     spin_unlock_irqrestore(&devinfo->lock, flags);
0717     return 0;
0718 }
0719 
0720 static DEF_SCSI_QCMD(uas_queuecommand)
0721 
0722 /*
0723  * For now we do not support actually sending an abort to the device, so
0724  * this eh always fails. Still we must define it to make sure that we've
0725  * dropped all references to the cmnd in question once this function exits.
0726  */
0727 static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
0728 {
0729     struct uas_cmd_info *cmdinfo = scsi_cmd_priv(cmnd);
0730     struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
0731     struct urb *data_in_urb = NULL;
0732     struct urb *data_out_urb = NULL;
0733     unsigned long flags;
0734 
0735     spin_lock_irqsave(&devinfo->lock, flags);
0736 
0737     uas_log_cmd_state(cmnd, __func__, 0);
0738 
0739     /* Ensure that try_complete does not call scsi_done */
0740     cmdinfo->state |= COMMAND_ABORTED;
0741 
0742     /* Drop all refs to this cmnd, kill data urbs to break their ref */
0743     devinfo->cmnd[cmdinfo->uas_tag - 1] = NULL;
0744     if (cmdinfo->state & DATA_IN_URB_INFLIGHT)
0745         data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
0746     if (cmdinfo->state & DATA_OUT_URB_INFLIGHT)
0747         data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
0748 
0749     uas_free_unsubmitted_urbs(cmnd);
0750 
0751     spin_unlock_irqrestore(&devinfo->lock, flags);
0752 
0753     if (data_in_urb) {
0754         usb_kill_urb(data_in_urb);
0755         usb_put_urb(data_in_urb);
0756     }
0757     if (data_out_urb) {
0758         usb_kill_urb(data_out_urb);
0759         usb_put_urb(data_out_urb);
0760     }
0761 
0762     return FAILED;
0763 }
0764 
0765 static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
0766 {
0767     struct scsi_device *sdev = cmnd->device;
0768     struct uas_dev_info *devinfo = sdev->hostdata;
0769     struct usb_device *udev = devinfo->udev;
0770     unsigned long flags;
0771     int err;
0772 
0773     err = usb_lock_device_for_reset(udev, devinfo->intf);
0774     if (err) {
0775         shost_printk(KERN_ERR, sdev->host,
0776                  "%s FAILED to get lock err %d\n", __func__, err);
0777         return FAILED;
0778     }
0779 
0780     shost_printk(KERN_INFO, sdev->host, "%s start\n", __func__);
0781 
0782     spin_lock_irqsave(&devinfo->lock, flags);
0783     devinfo->resetting = 1;
0784     spin_unlock_irqrestore(&devinfo->lock, flags);
0785 
0786     usb_kill_anchored_urbs(&devinfo->cmd_urbs);
0787     usb_kill_anchored_urbs(&devinfo->sense_urbs);
0788     usb_kill_anchored_urbs(&devinfo->data_urbs);
0789     uas_zap_pending(devinfo, DID_RESET);
0790 
0791     err = usb_reset_device(udev);
0792 
0793     spin_lock_irqsave(&devinfo->lock, flags);
0794     devinfo->resetting = 0;
0795     spin_unlock_irqrestore(&devinfo->lock, flags);
0796 
0797     usb_unlock_device(udev);
0798 
0799     if (err) {
0800         shost_printk(KERN_INFO, sdev->host, "%s FAILED err %d\n",
0801                  __func__, err);
0802         return FAILED;
0803     }
0804 
0805     shost_printk(KERN_INFO, sdev->host, "%s success\n", __func__);
0806     return SUCCESS;
0807 }
0808 
0809 static int uas_target_alloc(struct scsi_target *starget)
0810 {
0811     struct uas_dev_info *devinfo = (struct uas_dev_info *)
0812             dev_to_shost(starget->dev.parent)->hostdata;
0813 
0814     if (devinfo->flags & US_FL_NO_REPORT_LUNS)
0815         starget->no_report_luns = 1;
0816 
0817     return 0;
0818 }
0819 
0820 static int uas_slave_alloc(struct scsi_device *sdev)
0821 {
0822     struct uas_dev_info *devinfo =
0823         (struct uas_dev_info *)sdev->host->hostdata;
0824 
0825     sdev->hostdata = devinfo;
0826 
0827     /*
0828      * The protocol has no requirements on alignment in the strict sense.
0829      * Controllers may or may not have alignment restrictions.
0830      * As this is not exported, we use an extremely conservative guess.
0831      */
0832     blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
0833 
0834     if (devinfo->flags & US_FL_MAX_SECTORS_64)
0835         blk_queue_max_hw_sectors(sdev->request_queue, 64);
0836     else if (devinfo->flags & US_FL_MAX_SECTORS_240)
0837         blk_queue_max_hw_sectors(sdev->request_queue, 240);
0838 
0839     return 0;
0840 }
0841 
0842 static int uas_slave_configure(struct scsi_device *sdev)
0843 {
0844     struct uas_dev_info *devinfo = sdev->hostdata;
0845 
0846     if (devinfo->flags & US_FL_NO_REPORT_OPCODES)
0847         sdev->no_report_opcodes = 1;
0848 
0849     /* A few buggy USB-ATA bridges don't understand FUA */
0850     if (devinfo->flags & US_FL_BROKEN_FUA)
0851         sdev->broken_fua = 1;
0852 
0853     /* UAS also needs to support FL_ALWAYS_SYNC */
0854     if (devinfo->flags & US_FL_ALWAYS_SYNC) {
0855         sdev->skip_ms_page_3f = 1;
0856         sdev->skip_ms_page_8 = 1;
0857         sdev->wce_default_on = 1;
0858     }
0859 
0860     /* Some disks cannot handle READ_CAPACITY_16 */
0861     if (devinfo->flags & US_FL_NO_READ_CAPACITY_16)
0862         sdev->no_read_capacity_16 = 1;
0863 
0864     /* Some disks cannot handle WRITE_SAME */
0865     if (devinfo->flags & US_FL_NO_SAME)
0866         sdev->no_write_same = 1;
0867     /*
0868      * Some disks return the total number of blocks in response
0869      * to READ CAPACITY rather than the highest block number.
0870      * If this device makes that mistake, tell the sd driver.
0871      */
0872     if (devinfo->flags & US_FL_FIX_CAPACITY)
0873         sdev->fix_capacity = 1;
0874 
0875     /*
0876      * in some cases we have to guess
0877      */
0878     if (devinfo->flags & US_FL_CAPACITY_HEURISTICS)
0879         sdev->guess_capacity = 1;
0880 
0881     /*
0882      * Some devices don't like MODE SENSE with page=0x3f,
0883      * which is the command used for checking if a device
0884      * is write-protected.  Now that we tell the sd driver
0885      * to do a 192-byte transfer with this command the
0886      * majority of devices work fine, but a few still can't
0887      * handle it.  The sd driver will simply assume those
0888      * devices are write-enabled.
0889      */
0890     if (devinfo->flags & US_FL_NO_WP_DETECT)
0891         sdev->skip_ms_page_3f = 1;
0892 
0893     scsi_change_queue_depth(sdev, devinfo->qdepth - 2);
0894     return 0;
0895 }
0896 
0897 static struct scsi_host_template uas_host_template = {
0898     .module = THIS_MODULE,
0899     .name = "uas",
0900     .queuecommand = uas_queuecommand,
0901     .target_alloc = uas_target_alloc,
0902     .slave_alloc = uas_slave_alloc,
0903     .slave_configure = uas_slave_configure,
0904     .eh_abort_handler = uas_eh_abort_handler,
0905     .eh_device_reset_handler = uas_eh_device_reset_handler,
0906     .this_id = -1,
0907     .skip_settle_delay = 1,
0908     .dma_boundary = PAGE_SIZE - 1,
0909     .cmd_size = sizeof(struct uas_cmd_info),
0910 };
0911 
0912 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
0913             vendorName, productName, useProtocol, useTransport, \
0914             initFunction, flags) \
0915 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
0916     .driver_info = (flags) }
0917 
0918 static struct usb_device_id uas_usb_ids[] = {
0919 #   include "unusual_uas.h"
0920     { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
0921     { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
0922     { }
0923 };
0924 MODULE_DEVICE_TABLE(usb, uas_usb_ids);
0925 
0926 #undef UNUSUAL_DEV
0927 
0928 static int uas_switch_interface(struct usb_device *udev,
0929                 struct usb_interface *intf)
0930 {
0931     struct usb_host_interface *alt;
0932 
0933     alt = uas_find_uas_alt_setting(intf);
0934     if (!alt)
0935         return -ENODEV;
0936 
0937     return usb_set_interface(udev, alt->desc.bInterfaceNumber,
0938             alt->desc.bAlternateSetting);
0939 }
0940 
0941 static int uas_configure_endpoints(struct uas_dev_info *devinfo)
0942 {
0943     struct usb_host_endpoint *eps[4] = { };
0944     struct usb_device *udev = devinfo->udev;
0945     int r;
0946 
0947     r = uas_find_endpoints(devinfo->intf->cur_altsetting, eps);
0948     if (r)
0949         return r;
0950 
0951     devinfo->cmd_pipe = usb_sndbulkpipe(udev,
0952                         usb_endpoint_num(&eps[0]->desc));
0953     devinfo->status_pipe = usb_rcvbulkpipe(udev,
0954                         usb_endpoint_num(&eps[1]->desc));
0955     devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
0956                         usb_endpoint_num(&eps[2]->desc));
0957     devinfo->data_out_pipe = usb_sndbulkpipe(udev,
0958                         usb_endpoint_num(&eps[3]->desc));
0959 
0960     if (udev->speed < USB_SPEED_SUPER) {
0961         devinfo->qdepth = 32;
0962         devinfo->use_streams = 0;
0963     } else {
0964         devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1,
0965                             3, MAX_CMNDS, GFP_NOIO);
0966         if (devinfo->qdepth < 0)
0967             return devinfo->qdepth;
0968         devinfo->use_streams = 1;
0969     }
0970 
0971     return 0;
0972 }
0973 
0974 static void uas_free_streams(struct uas_dev_info *devinfo)
0975 {
0976     struct usb_device *udev = devinfo->udev;
0977     struct usb_host_endpoint *eps[3];
0978 
0979     eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
0980     eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
0981     eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
0982     usb_free_streams(devinfo->intf, eps, 3, GFP_NOIO);
0983 }
0984 
0985 static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
0986 {
0987     int result = -ENOMEM;
0988     struct Scsi_Host *shost = NULL;
0989     struct uas_dev_info *devinfo;
0990     struct usb_device *udev = interface_to_usbdev(intf);
0991     unsigned long dev_flags;
0992 
0993     if (!uas_use_uas_driver(intf, id, &dev_flags))
0994         return -ENODEV;
0995 
0996     if (uas_switch_interface(udev, intf))
0997         return -ENODEV;
0998 
0999     shost = scsi_host_alloc(&uas_host_template,
1000                 sizeof(struct uas_dev_info));
1001     if (!shost)
1002         goto set_alt0;
1003 
1004     shost->max_cmd_len = 16 + 252;
1005     shost->max_id = 1;
1006     shost->max_lun = 256;
1007     shost->max_channel = 0;
1008     shost->sg_tablesize = udev->bus->sg_tablesize;
1009 
1010     devinfo = (struct uas_dev_info *)shost->hostdata;
1011     devinfo->intf = intf;
1012     devinfo->udev = udev;
1013     devinfo->resetting = 0;
1014     devinfo->shutdown = 0;
1015     devinfo->flags = dev_flags;
1016     init_usb_anchor(&devinfo->cmd_urbs);
1017     init_usb_anchor(&devinfo->sense_urbs);
1018     init_usb_anchor(&devinfo->data_urbs);
1019     spin_lock_init(&devinfo->lock);
1020     INIT_WORK(&devinfo->work, uas_do_work);
1021     INIT_WORK(&devinfo->scan_work, uas_scan_work);
1022 
1023     result = uas_configure_endpoints(devinfo);
1024     if (result)
1025         goto set_alt0;
1026 
1027     /*
1028      * 1 tag is reserved for untagged commands +
1029      * 1 tag to avoid off by one errors in some bridge firmwares
1030      */
1031     shost->can_queue = devinfo->qdepth - 2;
1032 
1033     usb_set_intfdata(intf, shost);
1034     result = scsi_add_host(shost, &intf->dev);
1035     if (result)
1036         goto free_streams;
1037 
1038     /* Submit the delayed_work for SCSI-device scanning */
1039     schedule_work(&devinfo->scan_work);
1040 
1041     return result;
1042 
1043 free_streams:
1044     uas_free_streams(devinfo);
1045     usb_set_intfdata(intf, NULL);
1046 set_alt0:
1047     usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
1048     if (shost)
1049         scsi_host_put(shost);
1050     return result;
1051 }
1052 
1053 static int uas_cmnd_list_empty(struct uas_dev_info *devinfo)
1054 {
1055     unsigned long flags;
1056     int i, r = 1;
1057 
1058     spin_lock_irqsave(&devinfo->lock, flags);
1059 
1060     for (i = 0; i < devinfo->qdepth; i++) {
1061         if (devinfo->cmnd[i]) {
1062             r = 0; /* Not empty */
1063             break;
1064         }
1065     }
1066 
1067     spin_unlock_irqrestore(&devinfo->lock, flags);
1068 
1069     return r;
1070 }
1071 
1072 /*
1073  * Wait for any pending cmnds to complete, on usb-2 sense_urbs may temporarily
1074  * get empty while there still is more work to do due to sense-urbs completing
1075  * with a READ/WRITE_READY iu code, so keep waiting until the list gets empty.
1076  */
1077 static int uas_wait_for_pending_cmnds(struct uas_dev_info *devinfo)
1078 {
1079     unsigned long start_time;
1080     int r;
1081 
1082     start_time = jiffies;
1083     do {
1084         flush_work(&devinfo->work);
1085 
1086         r = usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000);
1087         if (r == 0)
1088             return -ETIME;
1089 
1090         r = usb_wait_anchor_empty_timeout(&devinfo->data_urbs, 500);
1091         if (r == 0)
1092             return -ETIME;
1093 
1094         if (time_after(jiffies, start_time + 5 * HZ))
1095             return -ETIME;
1096     } while (!uas_cmnd_list_empty(devinfo));
1097 
1098     return 0;
1099 }
1100 
1101 static int uas_pre_reset(struct usb_interface *intf)
1102 {
1103     struct Scsi_Host *shost = usb_get_intfdata(intf);
1104     struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1105     unsigned long flags;
1106 
1107     if (devinfo->shutdown)
1108         return 0;
1109 
1110     /* Block new requests */
1111     spin_lock_irqsave(shost->host_lock, flags);
1112     scsi_block_requests(shost);
1113     spin_unlock_irqrestore(shost->host_lock, flags);
1114 
1115     if (uas_wait_for_pending_cmnds(devinfo) != 0) {
1116         shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1117         scsi_unblock_requests(shost);
1118         return 1;
1119     }
1120 
1121     uas_free_streams(devinfo);
1122 
1123     return 0;
1124 }
1125 
1126 static int uas_post_reset(struct usb_interface *intf)
1127 {
1128     struct Scsi_Host *shost = usb_get_intfdata(intf);
1129     struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1130     unsigned long flags;
1131     int err;
1132 
1133     if (devinfo->shutdown)
1134         return 0;
1135 
1136     err = uas_configure_endpoints(devinfo);
1137     if (err && err != -ENODEV)
1138         shost_printk(KERN_ERR, shost,
1139                  "%s: alloc streams error %d after reset",
1140                  __func__, err);
1141 
1142     /* we must unblock the host in every case lest we deadlock */
1143     spin_lock_irqsave(shost->host_lock, flags);
1144     scsi_report_bus_reset(shost, 0);
1145     spin_unlock_irqrestore(shost->host_lock, flags);
1146 
1147     scsi_unblock_requests(shost);
1148 
1149     return err ? 1 : 0;
1150 }
1151 
1152 static int uas_suspend(struct usb_interface *intf, pm_message_t message)
1153 {
1154     struct Scsi_Host *shost = usb_get_intfdata(intf);
1155     struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1156 
1157     if (uas_wait_for_pending_cmnds(devinfo) != 0) {
1158         shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1159         return -ETIME;
1160     }
1161 
1162     return 0;
1163 }
1164 
1165 static int uas_resume(struct usb_interface *intf)
1166 {
1167     return 0;
1168 }
1169 
1170 static int uas_reset_resume(struct usb_interface *intf)
1171 {
1172     struct Scsi_Host *shost = usb_get_intfdata(intf);
1173     struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1174     unsigned long flags;
1175     int err;
1176 
1177     err = uas_configure_endpoints(devinfo);
1178     if (err) {
1179         shost_printk(KERN_ERR, shost,
1180                  "%s: alloc streams error %d after reset",
1181                  __func__, err);
1182         return -EIO;
1183     }
1184 
1185     spin_lock_irqsave(shost->host_lock, flags);
1186     scsi_report_bus_reset(shost, 0);
1187     spin_unlock_irqrestore(shost->host_lock, flags);
1188 
1189     return 0;
1190 }
1191 
1192 static void uas_disconnect(struct usb_interface *intf)
1193 {
1194     struct Scsi_Host *shost = usb_get_intfdata(intf);
1195     struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1196     unsigned long flags;
1197 
1198     spin_lock_irqsave(&devinfo->lock, flags);
1199     devinfo->resetting = 1;
1200     spin_unlock_irqrestore(&devinfo->lock, flags);
1201 
1202     cancel_work_sync(&devinfo->work);
1203     usb_kill_anchored_urbs(&devinfo->cmd_urbs);
1204     usb_kill_anchored_urbs(&devinfo->sense_urbs);
1205     usb_kill_anchored_urbs(&devinfo->data_urbs);
1206     uas_zap_pending(devinfo, DID_NO_CONNECT);
1207 
1208     /*
1209      * Prevent SCSI scanning (if it hasn't started yet)
1210      * or wait for the SCSI-scanning routine to stop.
1211      */
1212     cancel_work_sync(&devinfo->scan_work);
1213 
1214     scsi_remove_host(shost);
1215     uas_free_streams(devinfo);
1216     scsi_host_put(shost);
1217 }
1218 
1219 /*
1220  * Put the device back in usb-storage mode on shutdown, as some BIOS-es
1221  * hang on reboot when the device is still in uas mode. Note the reset is
1222  * necessary as some devices won't revert to usb-storage mode without it.
1223  */
1224 static void uas_shutdown(struct device *dev)
1225 {
1226     struct usb_interface *intf = to_usb_interface(dev);
1227     struct usb_device *udev = interface_to_usbdev(intf);
1228     struct Scsi_Host *shost = usb_get_intfdata(intf);
1229     struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1230 
1231     if (system_state != SYSTEM_RESTART)
1232         return;
1233 
1234     devinfo->shutdown = 1;
1235     uas_free_streams(devinfo);
1236     usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
1237     usb_reset_device(udev);
1238 }
1239 
1240 static struct usb_driver uas_driver = {
1241     .name = "uas",
1242     .probe = uas_probe,
1243     .disconnect = uas_disconnect,
1244     .pre_reset = uas_pre_reset,
1245     .post_reset = uas_post_reset,
1246     .suspend = uas_suspend,
1247     .resume = uas_resume,
1248     .reset_resume = uas_reset_resume,
1249     .drvwrap.driver.shutdown = uas_shutdown,
1250     .id_table = uas_usb_ids,
1251 };
1252 
1253 static int __init uas_init(void)
1254 {
1255     int rv;
1256 
1257     workqueue = alloc_workqueue("uas", WQ_MEM_RECLAIM, 0);
1258     if (!workqueue)
1259         return -ENOMEM;
1260 
1261     rv = usb_register(&uas_driver);
1262     if (rv) {
1263         destroy_workqueue(workqueue);
1264         return -ENOMEM;
1265     }
1266 
1267     return 0;
1268 }
1269 
1270 static void __exit uas_exit(void)
1271 {
1272     usb_deregister(&uas_driver);
1273     destroy_workqueue(workqueue);
1274 }
1275 
1276 module_init(uas_init);
1277 module_exit(uas_exit);
1278 
1279 MODULE_LICENSE("GPL");
1280 MODULE_IMPORT_NS(USB_STORAGE);
1281 MODULE_AUTHOR(
1282     "Hans de Goede <hdegoede@redhat.com>, Matthew Wilcox and Sarah Sharp");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!