drivers/usb/storage/uas.c

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