Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/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 <hdegoede@redhat.com> 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          * The uas drivers expects tags not to be bigger than the maximum
976          * per-device queue depth, which is not true with the blk-mq tag
977          * allocator.
978          */
979         .disable_blk_mq = true,
980 };
981 
982 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
983                     vendorName, productName, useProtocol, useTransport, \
984                     initFunction, flags) \
985 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
986         .driver_info = (flags) }
987 
988 static struct usb_device_id uas_usb_ids[] = {
989 #       include "unusual_uas.h"
990         { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
991         { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
992         /* 0xaa is a prototype device I happen to have access to */
993         { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
994         { }
995 };
996 MODULE_DEVICE_TABLE(usb, uas_usb_ids);
997 
998 #undef UNUSUAL_DEV
999 
1000 static int uas_switch_interface(struct usb_device *udev,
1001                                 struct usb_interface *intf)
1002 {
1003         int alt;
1004 
1005         alt = uas_find_uas_alt_setting(intf);
1006         if (alt < 0)
1007                 return alt;
1008 
1009         return usb_set_interface(udev,
1010                         intf->altsetting[0].desc.bInterfaceNumber, alt);
1011 }
1012 
1013 static int uas_configure_endpoints(struct uas_dev_info *devinfo)
1014 {
1015         struct usb_host_endpoint *eps[4] = { };
1016         struct usb_device *udev = devinfo->udev;
1017         int r;
1018 
1019         devinfo->uas_sense_old = 0;
1020         devinfo->cmnd = NULL;
1021 
1022         r = uas_find_endpoints(devinfo->intf->cur_altsetting, eps);
1023         if (r)
1024                 return r;
1025 
1026         devinfo->cmd_pipe = usb_sndbulkpipe(udev,
1027                                             usb_endpoint_num(&eps[0]->desc));
1028         devinfo->status_pipe = usb_rcvbulkpipe(udev,
1029                                             usb_endpoint_num(&eps[1]->desc));
1030         devinfo->data_in_pipe = usb_rcvbulkpipe(udev,
1031                                             usb_endpoint_num(&eps[2]->desc));
1032         devinfo->data_out_pipe = usb_sndbulkpipe(udev,
1033                                             usb_endpoint_num(&eps[3]->desc));
1034 
1035         if (udev->speed != USB_SPEED_SUPER) {
1036                 devinfo->qdepth = 32;
1037                 devinfo->use_streams = 0;
1038         } else {
1039                 devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1,
1040                                                     3, 256, GFP_NOIO);
1041                 if (devinfo->qdepth < 0)
1042                         return devinfo->qdepth;
1043                 devinfo->use_streams = 1;
1044         }
1045 
1046         return 0;
1047 }
1048 
1049 static void uas_free_streams(struct uas_dev_info *devinfo)
1050 {
1051         struct usb_device *udev = devinfo->udev;
1052         struct usb_host_endpoint *eps[3];
1053 
1054         eps[0] = usb_pipe_endpoint(udev, devinfo->status_pipe);
1055         eps[1] = usb_pipe_endpoint(udev, devinfo->data_in_pipe);
1056         eps[2] = usb_pipe_endpoint(udev, devinfo->data_out_pipe);
1057         usb_free_streams(devinfo->intf, eps, 3, GFP_NOIO);
1058 }
1059 
1060 static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
1061 {
1062         int result = -ENOMEM;
1063         struct Scsi_Host *shost = NULL;
1064         struct uas_dev_info *devinfo;
1065         struct usb_device *udev = interface_to_usbdev(intf);
1066 
1067         if (!uas_use_uas_driver(intf, id))
1068                 return -ENODEV;
1069 
1070         if (uas_switch_interface(udev, intf))
1071                 return -ENODEV;
1072 
1073         shost = scsi_host_alloc(&uas_host_template,
1074                                 sizeof(struct uas_dev_info));
1075         if (!shost)
1076                 goto set_alt0;
1077 
1078         shost->max_cmd_len = 16 + 252;
1079         shost->max_id = 1;
1080         shost->max_lun = 256;
1081         shost->max_channel = 0;
1082         shost->sg_tablesize = udev->bus->sg_tablesize;
1083 
1084         devinfo = (struct uas_dev_info *)shost->hostdata;
1085         devinfo->intf = intf;
1086         devinfo->udev = udev;
1087         devinfo->resetting = 0;
1088         devinfo->running_task = 0;
1089         devinfo->shutdown = 0;
1090         init_usb_anchor(&devinfo->cmd_urbs);
1091         init_usb_anchor(&devinfo->sense_urbs);
1092         init_usb_anchor(&devinfo->data_urbs);
1093         spin_lock_init(&devinfo->lock);
1094         INIT_WORK(&devinfo->work, uas_do_work);
1095         INIT_LIST_HEAD(&devinfo->inflight_list);
1096         INIT_LIST_HEAD(&devinfo->dead_list);
1097 
1098         result = uas_configure_endpoints(devinfo);
1099         if (result)
1100                 goto set_alt0;
1101 
1102         result = scsi_init_shared_tag_map(shost, devinfo->qdepth - 2);
1103         if (result)
1104                 goto free_streams;
1105 
1106         usb_set_intfdata(intf, shost);
1107         result = scsi_add_host(shost, &intf->dev);
1108         if (result)
1109                 goto free_streams;
1110 
1111         scsi_scan_host(shost);
1112         return result;
1113 
1114 free_streams:
1115         uas_free_streams(devinfo);
1116         usb_set_intfdata(intf, NULL);
1117 set_alt0:
1118         usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
1119         if (shost)
1120                 scsi_host_put(shost);
1121         return result;
1122 }
1123 
1124 static int uas_pre_reset(struct usb_interface *intf)
1125 {
1126         struct Scsi_Host *shost = usb_get_intfdata(intf);
1127         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1128         unsigned long flags;
1129 
1130         if (devinfo->shutdown)
1131                 return 0;
1132 
1133         /* Block new requests */
1134         spin_lock_irqsave(shost->host_lock, flags);
1135         scsi_block_requests(shost);
1136         spin_unlock_irqrestore(shost->host_lock, flags);
1137 
1138         /* Wait for any pending requests to complete */
1139         flush_work(&devinfo->work);
1140         if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000) == 0) {
1141                 shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1142                 return 1;
1143         }
1144 
1145         uas_free_streams(devinfo);
1146 
1147         return 0;
1148 }
1149 
1150 static int uas_post_reset(struct usb_interface *intf)
1151 {
1152         struct Scsi_Host *shost = usb_get_intfdata(intf);
1153         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1154         unsigned long flags;
1155 
1156         if (devinfo->shutdown)
1157                 return 0;
1158 
1159         if (uas_configure_endpoints(devinfo) != 0) {
1160                 shost_printk(KERN_ERR, shost,
1161                              "%s: alloc streams error after reset", __func__);
1162                 return 1;
1163         }
1164 
1165         spin_lock_irqsave(shost->host_lock, flags);
1166         scsi_report_bus_reset(shost, 0);
1167         spin_unlock_irqrestore(shost->host_lock, flags);
1168 
1169         scsi_unblock_requests(shost);
1170 
1171         return 0;
1172 }
1173 
1174 static int uas_suspend(struct usb_interface *intf, pm_message_t message)
1175 {
1176         struct Scsi_Host *shost = usb_get_intfdata(intf);
1177         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1178 
1179         /* Wait for any pending requests to complete */
1180         flush_work(&devinfo->work);
1181         if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000) == 0) {
1182                 shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
1183                 return -ETIME;
1184         }
1185 
1186         return 0;
1187 }
1188 
1189 static int uas_resume(struct usb_interface *intf)
1190 {
1191         return 0;
1192 }
1193 
1194 static int uas_reset_resume(struct usb_interface *intf)
1195 {
1196         struct Scsi_Host *shost = usb_get_intfdata(intf);
1197         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1198         unsigned long flags;
1199 
1200         if (uas_configure_endpoints(devinfo) != 0) {
1201                 shost_printk(KERN_ERR, shost,
1202                              "%s: alloc streams error after reset", __func__);
1203                 return -EIO;
1204         }
1205 
1206         spin_lock_irqsave(shost->host_lock, flags);
1207         scsi_report_bus_reset(shost, 0);
1208         spin_unlock_irqrestore(shost->host_lock, flags);
1209 
1210         return 0;
1211 }
1212 
1213 static void uas_disconnect(struct usb_interface *intf)
1214 {
1215         struct Scsi_Host *shost = usb_get_intfdata(intf);
1216         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1217 
1218         devinfo->resetting = 1;
1219         cancel_work_sync(&devinfo->work);
1220         uas_abort_inflight(devinfo, DID_NO_CONNECT, __func__);
1221         usb_kill_anchored_urbs(&devinfo->cmd_urbs);
1222         usb_kill_anchored_urbs(&devinfo->sense_urbs);
1223         usb_kill_anchored_urbs(&devinfo->data_urbs);
1224         uas_zap_dead(devinfo);
1225         scsi_remove_host(shost);
1226         uas_free_streams(devinfo);
1227         scsi_host_put(shost);
1228 }
1229 
1230 /*
1231  * Put the device back in usb-storage mode on shutdown, as some BIOS-es
1232  * hang on reboot when the device is still in uas mode. Note the reset is
1233  * necessary as some devices won't revert to usb-storage mode without it.
1234  */
1235 static void uas_shutdown(struct device *dev)
1236 {
1237         struct usb_interface *intf = to_usb_interface(dev);
1238         struct usb_device *udev = interface_to_usbdev(intf);
1239         struct Scsi_Host *shost = usb_get_intfdata(intf);
1240         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
1241 
1242         if (system_state != SYSTEM_RESTART)
1243                 return;
1244 
1245         devinfo->shutdown = 1;
1246         uas_free_streams(devinfo);
1247         usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
1248         usb_reset_device(udev);
1249 }
1250 
1251 static struct usb_driver uas_driver = {
1252         .name = "uas",
1253         .probe = uas_probe,
1254         .disconnect = uas_disconnect,
1255         .pre_reset = uas_pre_reset,
1256         .post_reset = uas_post_reset,
1257         .suspend = uas_suspend,
1258         .resume = uas_resume,
1259         .reset_resume = uas_reset_resume,
1260         .drvwrap.driver.shutdown = uas_shutdown,
1261         .id_table = uas_usb_ids,
1262 };
1263 
1264 module_usb_driver(uas_driver);
1265 
1266 MODULE_LICENSE("GPL");
1267 MODULE_AUTHOR(
1268         "Hans de Goede <hdegoede@redhat.com>, Matthew Wilcox and Sarah Sharp");
1269 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us