Version:  2.0.40 2.2.26 2.4.37 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 3.18

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

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