Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
transport.c
Go to the documentation of this file.
1 /* Driver for USB Mass Storage compliant devices
2  *
3  * Current development and maintenance by:
4  * (c) 1999-2002 Matthew Dharm ([email protected])
5  *
6  * Developed with the assistance of:
7  * (c) 2000 David L. Brown, Jr. ([email protected])
8  * (c) 2000 Stephen J. Gowdy ([email protected])
9  * (c) 2002 Alan Stern <[email protected]>
10  *
11  * Initial work by:
12  * (c) 1999 Michael Gee ([email protected])
13  *
14  * This driver is based on the 'USB Mass Storage Class' document. This
15  * describes in detail the protocol used to communicate with such
16  * devices. Clearly, the designers had SCSI and ATAPI commands in
17  * mind when they created this document. The commands are all very
18  * similar to commands in the SCSI-II and ATAPI specifications.
19  *
20  * It is important to note that in a number of cases this class
21  * exhibits class-specific exemptions from the USB specification.
22  * Notably the usage of NAK, STALL and ACK differs from the norm, in
23  * that they are used to communicate wait, failed and OK on commands.
24  *
25  * Also, for certain devices, the interrupt endpoint is used to convey
26  * status of a command.
27  *
28  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
29  * information about this driver.
30  *
31  * This program is free software; you can redistribute it and/or modify it
32  * under the terms of the GNU General Public License as published by the
33  * Free Software Foundation; either version 2, or (at your option) any
34  * later version.
35  *
36  * This program is distributed in the hope that it will be useful, but
37  * WITHOUT ANY WARRANTY; without even the implied warranty of
38  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
39  * General Public License for more details.
40  *
41  * You should have received a copy of the GNU General Public License along
42  * with this program; if not, write to the Free Software Foundation, Inc.,
43  * 675 Mass Ave, Cambridge, MA 02139, USA.
44  */
45 
46 #include <linux/sched.h>
47 #include <linux/gfp.h>
48 #include <linux/errno.h>
49 #include <linux/export.h>
50 
51 #include <linux/usb/quirks.h>
52 
53 #include <scsi/scsi.h>
54 #include <scsi/scsi_eh.h>
55 #include <scsi/scsi_device.h>
56 
57 #include "usb.h"
58 #include "transport.h"
59 #include "protocol.h"
60 #include "scsiglue.h"
61 #include "debug.h"
62 
63 #include <linux/blkdev.h>
64 #include "../../scsi/sd.h"
65 
66 
67 /***********************************************************************
68  * Data transfer routines
69  ***********************************************************************/
70 
71 /*
72  * This is subtle, so pay attention:
73  * ---------------------------------
74  * We're very concerned about races with a command abort. Hanging this code
75  * is a sure fire way to hang the kernel. (Note that this discussion applies
76  * only to transactions resulting from a scsi queued-command, since only
77  * these transactions are subject to a scsi abort. Other transactions, such
78  * as those occurring during device-specific initialization, must be handled
79  * by a separate code path.)
80  *
81  * The abort function (usb_storage_command_abort() in scsiglue.c) first
82  * sets the machine state and the ABORTING bit in us->dflags to prevent
83  * new URBs from being submitted. It then calls usb_stor_stop_transport()
84  * below, which atomically tests-and-clears the URB_ACTIVE bit in us->dflags
85  * to see if the current_urb needs to be stopped. Likewise, the SG_ACTIVE
86  * bit is tested to see if the current_sg scatter-gather request needs to be
87  * stopped. The timeout callback routine does much the same thing.
88  *
89  * When a disconnect occurs, the DISCONNECTING bit in us->dflags is set to
90  * prevent new URBs from being submitted, and usb_stor_stop_transport() is
91  * called to stop any ongoing requests.
92  *
93  * The submit function first verifies that the submitting is allowed
94  * (neither ABORTING nor DISCONNECTING bits are set) and that the submit
95  * completes without errors, and only then sets the URB_ACTIVE bit. This
96  * prevents the stop_transport() function from trying to cancel the URB
97  * while the submit call is underway. Next, the submit function must test
98  * the flags to see if an abort or disconnect occurred during the submission
99  * or before the URB_ACTIVE bit was set. If so, it's essential to cancel
100  * the URB if it hasn't been cancelled already (i.e., if the URB_ACTIVE bit
101  * is still set). Either way, the function must then wait for the URB to
102  * finish. Note that the URB can still be in progress even after a call to
103  * usb_unlink_urb() returns.
104  *
105  * The idea is that (1) once the ABORTING or DISCONNECTING bit is set,
106  * either the stop_transport() function or the submitting function
107  * is guaranteed to call usb_unlink_urb() for an active URB,
108  * and (2) test_and_clear_bit() prevents usb_unlink_urb() from being
109  * called more than once or from being called during usb_submit_urb().
110  */
111 
112 /* This is the completion handler which will wake us up when an URB
113  * completes.
114  */
115 static void usb_stor_blocking_completion(struct urb *urb)
116 {
117  struct completion *urb_done_ptr = urb->context;
118 
119  complete(urb_done_ptr);
120 }
121 
122 /* This is the common part of the URB message submission code
123  *
124  * All URBs from the usb-storage driver involved in handling a queued scsi
125  * command _must_ pass through this function (or something like it) for the
126  * abort mechanisms to work properly.
127  */
128 static int usb_stor_msg_common(struct us_data *us, int timeout)
129 {
130  struct completion urb_done;
131  long timeleft;
132  int status;
133 
134  /* don't submit URBs during abort processing */
135  if (test_bit(US_FLIDX_ABORTING, &us->dflags))
136  return -EIO;
137 
138  /* set up data structures for the wakeup system */
139  init_completion(&urb_done);
140 
141  /* fill the common fields in the URB */
142  us->current_urb->context = &urb_done;
143  us->current_urb->transfer_flags = 0;
144 
145  /* we assume that if transfer_buffer isn't us->iobuf then it
146  * hasn't been mapped for DMA. Yes, this is clunky, but it's
147  * easier than always having the caller tell us whether the
148  * transfer buffer has already been mapped. */
149  if (us->current_urb->transfer_buffer == us->iobuf)
150  us->current_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
151  us->current_urb->transfer_dma = us->iobuf_dma;
152 
153  /* submit the URB */
154  status = usb_submit_urb(us->current_urb, GFP_NOIO);
155  if (status) {
156  /* something went wrong */
157  return status;
158  }
159 
160  /* since the URB has been submitted successfully, it's now okay
161  * to cancel it */
163 
164  /* did an abort occur during the submission? */
165  if (test_bit(US_FLIDX_ABORTING, &us->dflags)) {
166 
167  /* cancel the URB, if it hasn't been cancelled already */
169  US_DEBUGP("-- cancelling URB\n");
171  }
172  }
173 
174  /* wait for the completion of the URB */
176  &urb_done, timeout ? : MAX_SCHEDULE_TIMEOUT);
177 
179 
180  if (timeleft <= 0) {
181  US_DEBUGP("%s -- cancelling URB\n",
182  timeleft == 0 ? "Timeout" : "Signal");
184  }
185 
186  /* return the URB status */
187  return us->current_urb->status;
188 }
189 
190 /*
191  * Transfer one control message, with timeouts, and allowing early
192  * termination. Return codes are usual -Exxx, *not* USB_STOR_XFER_xxx.
193  */
194 int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
195  u8 request, u8 requesttype, u16 value, u16 index,
196  void *data, u16 size, int timeout)
197 {
198  int status;
199 
200  US_DEBUGP("%s: rq=%02x rqtype=%02x value=%04x index=%02x len=%u\n",
201  __func__, request, requesttype,
202  value, index, size);
203 
204  /* fill in the devrequest structure */
205  us->cr->bRequestType = requesttype;
206  us->cr->bRequest = request;
207  us->cr->wValue = cpu_to_le16(value);
208  us->cr->wIndex = cpu_to_le16(index);
209  us->cr->wLength = cpu_to_le16(size);
210 
211  /* fill and submit the URB */
212  usb_fill_control_urb(us->current_urb, us->pusb_dev, pipe,
213  (unsigned char*) us->cr, data, size,
214  usb_stor_blocking_completion, NULL);
215  status = usb_stor_msg_common(us, timeout);
216 
217  /* return the actual length of the data transferred if no error */
218  if (status == 0)
219  status = us->current_urb->actual_length;
220  return status;
221 }
223 
224 /* This is a version of usb_clear_halt() that allows early termination and
225  * doesn't read the status from the device -- this is because some devices
226  * crash their internal firmware when the status is requested after a halt.
227  *
228  * A definitive list of these 'bad' devices is too difficult to maintain or
229  * make complete enough to be useful. This problem was first observed on the
230  * Hagiwara FlashGate DUAL unit. However, bus traces reveal that neither
231  * MacOS nor Windows checks the status after clearing a halt.
232  *
233  * Since many vendors in this space limit their testing to interoperability
234  * with these two OSes, specification violations like this one are common.
235  */
236 int usb_stor_clear_halt(struct us_data *us, unsigned int pipe)
237 {
238  int result;
239  int endp = usb_pipeendpoint(pipe);
240 
241  if (usb_pipein (pipe))
242  endp |= USB_DIR_IN;
243 
244  result = usb_stor_control_msg(us, us->send_ctrl_pipe,
246  USB_ENDPOINT_HALT, endp,
247  NULL, 0, 3*HZ);
248 
249  if (result >= 0)
250  usb_reset_endpoint(us->pusb_dev, endp);
251 
252  US_DEBUGP("%s: result = %d\n", __func__, result);
253  return result;
254 }
256 
257 
258 /*
259  * Interpret the results of a URB transfer
260  *
261  * This function prints appropriate debugging messages, clears halts on
262  * non-control endpoints, and translates the status to the corresponding
263  * USB_STOR_XFER_xxx return code.
264  */
265 static int interpret_urb_result(struct us_data *us, unsigned int pipe,
266  unsigned int length, int result, unsigned int partial)
267 {
268  US_DEBUGP("Status code %d; transferred %u/%u\n",
269  result, partial, length);
270  switch (result) {
271 
272  /* no error code; did we send all the data? */
273  case 0:
274  if (partial != length) {
275  US_DEBUGP("-- short transfer\n");
276  return USB_STOR_XFER_SHORT;
277  }
278 
279  US_DEBUGP("-- transfer complete\n");
280  return USB_STOR_XFER_GOOD;
281 
282  /* stalled */
283  case -EPIPE:
284  /* for control endpoints, (used by CB[I]) a stall indicates
285  * a failed command */
286  if (usb_pipecontrol(pipe)) {
287  US_DEBUGP("-- stall on control pipe\n");
288  return USB_STOR_XFER_STALLED;
289  }
290 
291  /* for other sorts of endpoint, clear the stall */
292  US_DEBUGP("clearing endpoint halt for pipe 0x%x\n", pipe);
293  if (usb_stor_clear_halt(us, pipe) < 0)
294  return USB_STOR_XFER_ERROR;
295  return USB_STOR_XFER_STALLED;
296 
297  /* babble - the device tried to send more than we wanted to read */
298  case -EOVERFLOW:
299  US_DEBUGP("-- babble\n");
300  return USB_STOR_XFER_LONG;
301 
302  /* the transfer was cancelled by abort, disconnect, or timeout */
303  case -ECONNRESET:
304  US_DEBUGP("-- transfer cancelled\n");
305  return USB_STOR_XFER_ERROR;
306 
307  /* short scatter-gather read transfer */
308  case -EREMOTEIO:
309  US_DEBUGP("-- short read transfer\n");
310  return USB_STOR_XFER_SHORT;
311 
312  /* abort or disconnect in progress */
313  case -EIO:
314  US_DEBUGP("-- abort or disconnect in progress\n");
315  return USB_STOR_XFER_ERROR;
316 
317  /* the catch-all error case */
318  default:
319  US_DEBUGP("-- unknown error\n");
320  return USB_STOR_XFER_ERROR;
321  }
322 }
323 
324 /*
325  * Transfer one control message, without timeouts, but allowing early
326  * termination. Return codes are USB_STOR_XFER_xxx.
327  */
328 int usb_stor_ctrl_transfer(struct us_data *us, unsigned int pipe,
329  u8 request, u8 requesttype, u16 value, u16 index,
330  void *data, u16 size)
331 {
332  int result;
333 
334  US_DEBUGP("%s: rq=%02x rqtype=%02x value=%04x index=%02x len=%u\n",
335  __func__, request, requesttype,
336  value, index, size);
337 
338  /* fill in the devrequest structure */
339  us->cr->bRequestType = requesttype;
340  us->cr->bRequest = request;
341  us->cr->wValue = cpu_to_le16(value);
342  us->cr->wIndex = cpu_to_le16(index);
343  us->cr->wLength = cpu_to_le16(size);
344 
345  /* fill and submit the URB */
346  usb_fill_control_urb(us->current_urb, us->pusb_dev, pipe,
347  (unsigned char*) us->cr, data, size,
348  usb_stor_blocking_completion, NULL);
349  result = usb_stor_msg_common(us, 0);
350 
351  return interpret_urb_result(us, pipe, size, result,
352  us->current_urb->actual_length);
353 }
355 
356 /*
357  * Receive one interrupt buffer, without timeouts, but allowing early
358  * termination. Return codes are USB_STOR_XFER_xxx.
359  *
360  * This routine always uses us->recv_intr_pipe as the pipe and
361  * us->ep_bInterval as the interrupt interval.
362  */
363 static int usb_stor_intr_transfer(struct us_data *us, void *buf,
364  unsigned int length)
365 {
366  int result;
367  unsigned int pipe = us->recv_intr_pipe;
368  unsigned int maxp;
369 
370  US_DEBUGP("%s: xfer %u bytes\n", __func__, length);
371 
372  /* calculate the max packet size */
373  maxp = usb_maxpacket(us->pusb_dev, pipe, usb_pipeout(pipe));
374  if (maxp > length)
375  maxp = length;
376 
377  /* fill and submit the URB */
378  usb_fill_int_urb(us->current_urb, us->pusb_dev, pipe, buf,
379  maxp, usb_stor_blocking_completion, NULL,
380  us->ep_bInterval);
381  result = usb_stor_msg_common(us, 0);
382 
383  return interpret_urb_result(us, pipe, length, result,
384  us->current_urb->actual_length);
385 }
386 
387 /*
388  * Transfer one buffer via bulk pipe, without timeouts, but allowing early
389  * termination. Return codes are USB_STOR_XFER_xxx. If the bulk pipe
390  * stalls during the transfer, the halt is automatically cleared.
391  */
392 int usb_stor_bulk_transfer_buf(struct us_data *us, unsigned int pipe,
393  void *buf, unsigned int length, unsigned int *act_len)
394 {
395  int result;
396 
397  US_DEBUGP("%s: xfer %u bytes\n", __func__, length);
398 
399  /* fill and submit the URB */
400  usb_fill_bulk_urb(us->current_urb, us->pusb_dev, pipe, buf, length,
401  usb_stor_blocking_completion, NULL);
402  result = usb_stor_msg_common(us, 0);
403 
404  /* store the actual length of the data transferred */
405  if (act_len)
406  *act_len = us->current_urb->actual_length;
407  return interpret_urb_result(us, pipe, length, result,
408  us->current_urb->actual_length);
409 }
411 
412 /*
413  * Transfer a scatter-gather list via bulk transfer
414  *
415  * This function does basically the same thing as usb_stor_bulk_transfer_buf()
416  * above, but it uses the usbcore scatter-gather library.
417  */
418 static int usb_stor_bulk_transfer_sglist(struct us_data *us, unsigned int pipe,
419  struct scatterlist *sg, int num_sg, unsigned int length,
420  unsigned int *act_len)
421 {
422  int result;
423 
424  /* don't submit s-g requests during abort processing */
425  if (test_bit(US_FLIDX_ABORTING, &us->dflags))
426  return USB_STOR_XFER_ERROR;
427 
428  /* initialize the scatter-gather request block */
429  US_DEBUGP("%s: xfer %u bytes, %d entries\n", __func__,
430  length, num_sg);
431  result = usb_sg_init(&us->current_sg, us->pusb_dev, pipe, 0,
432  sg, num_sg, length, GFP_NOIO);
433  if (result) {
434  US_DEBUGP("usb_sg_init returned %d\n", result);
435  return USB_STOR_XFER_ERROR;
436  }
437 
438  /* since the block has been initialized successfully, it's now
439  * okay to cancel it */
441 
442  /* did an abort occur during the submission? */
443  if (test_bit(US_FLIDX_ABORTING, &us->dflags)) {
444 
445  /* cancel the request, if it hasn't been cancelled already */
447  US_DEBUGP("-- cancelling sg request\n");
449  }
450  }
451 
452  /* wait for the completion of the transfer */
453  usb_sg_wait(&us->current_sg);
455 
456  result = us->current_sg.status;
457  if (act_len)
458  *act_len = us->current_sg.bytes;
459  return interpret_urb_result(us, pipe, length, result,
460  us->current_sg.bytes);
461 }
462 
463 /*
464  * Common used function. Transfer a complete command
465  * via usb_stor_bulk_transfer_sglist() above. Set cmnd resid
466  */
467 int usb_stor_bulk_srb(struct us_data* us, unsigned int pipe,
468  struct scsi_cmnd* srb)
469 {
470  unsigned int partial;
471  int result = usb_stor_bulk_transfer_sglist(us, pipe, scsi_sglist(srb),
472  scsi_sg_count(srb), scsi_bufflen(srb),
473  &partial);
474 
475  scsi_set_resid(srb, scsi_bufflen(srb) - partial);
476  return result;
477 }
479 
480 /*
481  * Transfer an entire SCSI command's worth of data payload over the bulk
482  * pipe.
483  *
484  * Note that this uses usb_stor_bulk_transfer_buf() and
485  * usb_stor_bulk_transfer_sglist() to achieve its goals --
486  * this function simply determines whether we're going to use
487  * scatter-gather or not, and acts appropriately.
488  */
489 int usb_stor_bulk_transfer_sg(struct us_data* us, unsigned int pipe,
490  void *buf, unsigned int length_left, int use_sg, int *residual)
491 {
492  int result;
493  unsigned int partial;
494 
495  /* are we scatter-gathering? */
496  if (use_sg) {
497  /* use the usb core scatter-gather primitives */
498  result = usb_stor_bulk_transfer_sglist(us, pipe,
499  (struct scatterlist *) buf, use_sg,
500  length_left, &partial);
501  length_left -= partial;
502  } else {
503  /* no scatter-gather, just make the request */
504  result = usb_stor_bulk_transfer_buf(us, pipe, buf,
505  length_left, &partial);
506  length_left -= partial;
507  }
508 
509  /* store the residual and return the error code */
510  if (residual)
511  *residual = length_left;
512  return result;
513 }
515 
516 /***********************************************************************
517  * Transport routines
518  ***********************************************************************/
519 
520 /* There are so many devices that report the capacity incorrectly,
521  * this routine was written to counteract some of the resulting
522  * problems.
523  */
524 static void last_sector_hacks(struct us_data *us, struct scsi_cmnd *srb)
525 {
526  struct gendisk *disk;
527  struct scsi_disk *sdkp;
528  u32 sector;
529 
530  /* To Report "Medium Error: Record Not Found */
531  static unsigned char record_not_found[18] = {
532  [0] = 0x70, /* current error */
533  [2] = MEDIUM_ERROR, /* = 0x03 */
534  [7] = 0x0a, /* additional length */
535  [12] = 0x14 /* Record Not Found */
536  };
537 
538  /* If last-sector problems can't occur, whether because the
539  * capacity was already decremented or because the device is
540  * known to report the correct capacity, then we don't need
541  * to do anything.
542  */
543  if (!us->use_last_sector_hacks)
544  return;
545 
546  /* Was this command a READ(10) or a WRITE(10)? */
547  if (srb->cmnd[0] != READ_10 && srb->cmnd[0] != WRITE_10)
548  goto done;
549 
550  /* Did this command access the last sector? */
551  sector = (srb->cmnd[2] << 24) | (srb->cmnd[3] << 16) |
552  (srb->cmnd[4] << 8) | (srb->cmnd[5]);
553  disk = srb->request->rq_disk;
554  if (!disk)
555  goto done;
556  sdkp = scsi_disk(disk);
557  if (!sdkp)
558  goto done;
559  if (sector + 1 != sdkp->capacity)
560  goto done;
561 
562  if (srb->result == SAM_STAT_GOOD && scsi_get_resid(srb) == 0) {
563 
564  /* The command succeeded. We know this device doesn't
565  * have the last-sector bug, so stop checking it.
566  */
567  us->use_last_sector_hacks = 0;
568 
569  } else {
570  /* The command failed. Allow up to 3 retries in case this
571  * is some normal sort of failure. After that, assume the
572  * capacity is wrong and we're trying to access the sector
573  * beyond the end. Replace the result code and sense data
574  * with values that will cause the SCSI core to fail the
575  * command immediately, instead of going into an infinite
576  * (or even just a very long) retry loop.
577  */
578  if (++us->last_sector_retries < 3)
579  return;
581  memcpy(srb->sense_buffer, record_not_found,
582  sizeof(record_not_found));
583  }
584 
585  done:
586  /* Don't reset the retry counter for TEST UNIT READY commands,
587  * because they get issued after device resets which might be
588  * caused by a failed last-sector access.
589  */
590  if (srb->cmnd[0] != TEST_UNIT_READY)
591  us->last_sector_retries = 0;
592 }
593 
594 /* Invoke the transport and basic error-handling/recovery methods
595  *
596  * This is used by the protocol layers to actually send the message to
597  * the device and receive the response.
598  */
599 void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
600 {
601  int need_auto_sense;
602  int result;
603 
604  /* send the command to the transport layer */
605  scsi_set_resid(srb, 0);
606  result = us->transport(srb, us);
607 
608  /* if the command gets aborted by the higher layers, we need to
609  * short-circuit all other processing
610  */
611  if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
612  US_DEBUGP("-- command was aborted\n");
613  srb->result = DID_ABORT << 16;
614  goto Handle_Errors;
615  }
616 
617  /* if there is a transport error, reset and don't auto-sense */
618  if (result == USB_STOR_TRANSPORT_ERROR) {
619  US_DEBUGP("-- transport indicates error, resetting\n");
620  srb->result = DID_ERROR << 16;
621  goto Handle_Errors;
622  }
623 
624  /* if the transport provided its own sense data, don't auto-sense */
625  if (result == USB_STOR_TRANSPORT_NO_SENSE) {
627  last_sector_hacks(us, srb);
628  return;
629  }
630 
631  srb->result = SAM_STAT_GOOD;
632 
633  /* Determine if we need to auto-sense
634  *
635  * I normally don't use a flag like this, but it's almost impossible
636  * to understand what's going on here if I don't.
637  */
638  need_auto_sense = 0;
639 
640  /*
641  * If we're running the CB transport, which is incapable
642  * of determining status on its own, we will auto-sense
643  * unless the operation involved a data-in transfer. Devices
644  * can signal most data-in errors by stalling the bulk-in pipe.
645  */
646  if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_DPCM_USB) &&
648  US_DEBUGP("-- CB transport device requiring auto-sense\n");
649  need_auto_sense = 1;
650  }
651 
652  /*
653  * If we have a failure, we're going to do a REQUEST_SENSE
654  * automatically. Note that we differentiate between a command
655  * "failure" and an "error" in the transport mechanism.
656  */
657  if (result == USB_STOR_TRANSPORT_FAILED) {
658  US_DEBUGP("-- transport indicates command failure\n");
659  need_auto_sense = 1;
660  }
661 
662  /*
663  * Determine if this device is SAT by seeing if the
664  * command executed successfully. Otherwise we'll have
665  * to wait for at least one CHECK_CONDITION to determine
666  * SANE_SENSE support
667  */
668  if (unlikely((srb->cmnd[0] == ATA_16 || srb->cmnd[0] == ATA_12) &&
669  result == USB_STOR_TRANSPORT_GOOD &&
670  !(us->fflags & US_FL_SANE_SENSE) &&
671  !(us->fflags & US_FL_BAD_SENSE) &&
672  !(srb->cmnd[2] & 0x20))) {
673  US_DEBUGP("-- SAT supported, increasing auto-sense\n");
674  us->fflags |= US_FL_SANE_SENSE;
675  }
676 
677  /*
678  * A short transfer on a command where we don't expect it
679  * is unusual, but it doesn't mean we need to auto-sense.
680  */
681  if ((scsi_get_resid(srb) > 0) &&
682  !((srb->cmnd[0] == REQUEST_SENSE) ||
683  (srb->cmnd[0] == INQUIRY) ||
684  (srb->cmnd[0] == MODE_SENSE) ||
685  (srb->cmnd[0] == LOG_SENSE) ||
686  (srb->cmnd[0] == MODE_SENSE_10))) {
687  US_DEBUGP("-- unexpectedly short transfer\n");
688  }
689 
690  /* Now, if we need to do the auto-sense, let's do it */
691  if (need_auto_sense) {
692  int temp_result;
693  struct scsi_eh_save ses;
694  int sense_size = US_SENSE_SIZE;
695  struct scsi_sense_hdr sshdr;
696  const u8 *scdd;
697  u8 fm_ili;
698 
699  /* device supports and needs bigger sense buffer */
700  if (us->fflags & US_FL_SANE_SENSE)
701  sense_size = ~0;
702 Retry_Sense:
703  US_DEBUGP("Issuing auto-REQUEST_SENSE\n");
704 
705  scsi_eh_prep_cmnd(srb, &ses, NULL, 0, sense_size);
706 
707  /* FIXME: we must do the protocol translation here */
708  if (us->subclass == USB_SC_RBC || us->subclass == USB_SC_SCSI ||
709  us->subclass == USB_SC_CYP_ATACB)
710  srb->cmd_len = 6;
711  else
712  srb->cmd_len = 12;
713 
714  /* issue the auto-sense command */
715  scsi_set_resid(srb, 0);
716  temp_result = us->transport(us->srb, us);
717 
718  /* let's clean up right away */
719  scsi_eh_restore_cmnd(srb, &ses);
720 
721  if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
722  US_DEBUGP("-- auto-sense aborted\n");
723  srb->result = DID_ABORT << 16;
724 
725  /* If SANE_SENSE caused this problem, disable it */
726  if (sense_size != US_SENSE_SIZE) {
727  us->fflags &= ~US_FL_SANE_SENSE;
728  us->fflags |= US_FL_BAD_SENSE;
729  }
730  goto Handle_Errors;
731  }
732 
733  /* Some devices claim to support larger sense but fail when
734  * trying to request it. When a transport failure happens
735  * using US_FS_SANE_SENSE, we always retry with a standard
736  * (small) sense request. This fixes some USB GSM modems
737  */
738  if (temp_result == USB_STOR_TRANSPORT_FAILED &&
739  sense_size != US_SENSE_SIZE) {
740  US_DEBUGP("-- auto-sense failure, retry small sense\n");
741  sense_size = US_SENSE_SIZE;
742  us->fflags &= ~US_FL_SANE_SENSE;
743  us->fflags |= US_FL_BAD_SENSE;
744  goto Retry_Sense;
745  }
746 
747  /* Other failures */
748  if (temp_result != USB_STOR_TRANSPORT_GOOD) {
749  US_DEBUGP("-- auto-sense failure\n");
750 
751  /* we skip the reset if this happens to be a
752  * multi-target device, since failure of an
753  * auto-sense is perfectly valid
754  */
755  srb->result = DID_ERROR << 16;
756  if (!(us->fflags & US_FL_SCM_MULT_TARG))
757  goto Handle_Errors;
758  return;
759  }
760 
761  /* If the sense data returned is larger than 18-bytes then we
762  * assume this device supports requesting more in the future.
763  * The response code must be 70h through 73h inclusive.
764  */
765  if (srb->sense_buffer[7] > (US_SENSE_SIZE - 8) &&
766  !(us->fflags & US_FL_SANE_SENSE) &&
767  !(us->fflags & US_FL_BAD_SENSE) &&
768  (srb->sense_buffer[0] & 0x7C) == 0x70) {
769  US_DEBUGP("-- SANE_SENSE support enabled\n");
770  us->fflags |= US_FL_SANE_SENSE;
771 
772  /* Indicate to the user that we truncated their sense
773  * because we didn't know it supported larger sense.
774  */
775  US_DEBUGP("-- Sense data truncated to %i from %i\n",
777  srb->sense_buffer[7] + 8);
778  srb->sense_buffer[7] = (US_SENSE_SIZE - 8);
779  }
780 
782  &sshdr);
783 
784  US_DEBUGP("-- Result from auto-sense is %d\n", temp_result);
785  US_DEBUGP("-- code: 0x%x, key: 0x%x, ASC: 0x%x, ASCQ: 0x%x\n",
786  sshdr.response_code, sshdr.sense_key,
787  sshdr.asc, sshdr.ascq);
788 #ifdef CONFIG_USB_STORAGE_DEBUG
789  usb_stor_show_sense(sshdr.sense_key, sshdr.asc, sshdr.ascq);
790 #endif
791 
792  /* set the result so the higher layers expect this data */
794 
797  fm_ili = (scdd ? scdd[3] : srb->sense_buffer[2]) & 0xA0;
798 
799  /* We often get empty sense data. This could indicate that
800  * everything worked or that there was an unspecified
801  * problem. We have to decide which.
802  */
803  if (sshdr.sense_key == 0 && sshdr.asc == 0 && sshdr.ascq == 0 &&
804  fm_ili == 0) {
805  /* If things are really okay, then let's show that.
806  * Zero out the sense buffer so the higher layers
807  * won't realize we did an unsolicited auto-sense.
808  */
809  if (result == USB_STOR_TRANSPORT_GOOD) {
810  srb->result = SAM_STAT_GOOD;
811  srb->sense_buffer[0] = 0x0;
812 
813  /* If there was a problem, report an unspecified
814  * hardware error to prevent the higher layers from
815  * entering an infinite retry loop.
816  */
817  } else {
818  srb->result = DID_ERROR << 16;
819  if ((sshdr.response_code & 0x72) == 0x72)
820  srb->sense_buffer[1] = HARDWARE_ERROR;
821  else
822  srb->sense_buffer[2] = HARDWARE_ERROR;
823  }
824  }
825  }
826 
827  /*
828  * Some devices don't work or return incorrect data the first
829  * time they get a READ(10) command, or for the first READ(10)
830  * after a media change. If the INITIAL_READ10 flag is set,
831  * keep track of whether READ(10) commands succeed. If the
832  * previous one succeeded and this one failed, set the REDO_READ10
833  * flag to force a retry.
834  */
835  if (unlikely((us->fflags & US_FL_INITIAL_READ10) &&
836  srb->cmnd[0] == READ_10)) {
837  if (srb->result == SAM_STAT_GOOD) {
839  } else if (test_bit(US_FLIDX_READ10_WORKED, &us->dflags)) {
842  }
843 
844  /*
845  * Next, if the REDO_READ10 flag is set, return a result
846  * code that will cause the SCSI core to retry the READ(10)
847  * command immediately.
848  */
849  if (test_bit(US_FLIDX_REDO_READ10, &us->dflags)) {
851  srb->result = DID_IMM_RETRY << 16;
852  srb->sense_buffer[0] = 0;
853  }
854  }
855 
856  /* Did we transfer less than the minimum amount required? */
857  if ((srb->result == SAM_STAT_GOOD || srb->sense_buffer[2] == 0) &&
858  scsi_bufflen(srb) - scsi_get_resid(srb) < srb->underflow)
859  srb->result = DID_ERROR << 16;
860 
861  last_sector_hacks(us, srb);
862  return;
863 
864  /* Error and abort processing: try to resynchronize with the device
865  * by issuing a port reset. If that fails, try a class-specific
866  * device reset. */
867  Handle_Errors:
868 
869  /* Set the RESETTING bit, and clear the ABORTING bit so that
870  * the reset may proceed. */
871  scsi_lock(us_to_host(us));
874  scsi_unlock(us_to_host(us));
875 
876  /* We must release the device lock because the pre_reset routine
877  * will want to acquire it. */
878  mutex_unlock(&us->dev_mutex);
879  result = usb_stor_port_reset(us);
880  mutex_lock(&us->dev_mutex);
881 
882  if (result < 0) {
883  scsi_lock(us_to_host(us));
885  scsi_unlock(us_to_host(us));
886  us->transport_reset(us);
887  }
889  last_sector_hacks(us, srb);
890 }
891 
892 /* Stop the current URB transfer */
894 {
895  US_DEBUGP("%s called\n", __func__);
896 
897  /* If the state machine is blocked waiting for an URB,
898  * let's wake it up. The test_and_clear_bit() call
899  * guarantees that if a URB has just been submitted,
900  * it won't be cancelled more than once. */
902  US_DEBUGP("-- cancelling URB\n");
904  }
905 
906  /* If we are waiting for a scatter-gather operation, cancel it. */
908  US_DEBUGP("-- cancelling sg request\n");
910  }
911 }
912 
913 /*
914  * Control/Bulk and Control/Bulk/Interrupt transport
915  */
916 
917 int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
918 {
919  unsigned int transfer_length = scsi_bufflen(srb);
920  unsigned int pipe = 0;
921  int result;
922 
923  /* COMMAND STAGE */
924  /* let's send the command via the control pipe */
925  result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
926  US_CBI_ADSC,
928  us->ifnum, srb->cmnd, srb->cmd_len);
929 
930  /* check the return code for the command */
931  US_DEBUGP("Call to usb_stor_ctrl_transfer() returned %d\n", result);
932 
933  /* if we stalled the command, it means command failed */
934  if (result == USB_STOR_XFER_STALLED) {
936  }
937 
938  /* Uh oh... serious problem here */
939  if (result != USB_STOR_XFER_GOOD) {
941  }
942 
943  /* DATA STAGE */
944  /* transfer the data payload for this command, if one exists*/
945  if (transfer_length) {
946  pipe = srb->sc_data_direction == DMA_FROM_DEVICE ?
947  us->recv_bulk_pipe : us->send_bulk_pipe;
948  result = usb_stor_bulk_srb(us, pipe, srb);
949  US_DEBUGP("CBI data stage result is 0x%x\n", result);
950 
951  /* if we stalled the data transfer it means command failed */
952  if (result == USB_STOR_XFER_STALLED)
954  if (result > USB_STOR_XFER_STALLED)
956  }
957 
958  /* STATUS STAGE */
959 
960  /* NOTE: CB does not have a status stage. Silly, I know. So
961  * we have to catch this at a higher level.
962  */
963  if (us->protocol != USB_PR_CBI)
965 
966  result = usb_stor_intr_transfer(us, us->iobuf, 2);
967  US_DEBUGP("Got interrupt data (0x%x, 0x%x)\n",
968  us->iobuf[0], us->iobuf[1]);
969  if (result != USB_STOR_XFER_GOOD)
971 
972  /* UFI gives us ASC and ASCQ, like a request sense
973  *
974  * REQUEST_SENSE and INQUIRY don't affect the sense data on UFI
975  * devices, so we ignore the information for those commands. Note
976  * that this means we could be ignoring a real error on these
977  * commands, but that can't be helped.
978  */
979  if (us->subclass == USB_SC_UFI) {
980  if (srb->cmnd[0] == REQUEST_SENSE ||
981  srb->cmnd[0] == INQUIRY)
983  if (us->iobuf[0])
984  goto Failed;
986  }
987 
988  /* If not UFI, we interpret the data as a result code
989  * The first byte should always be a 0x0.
990  *
991  * Some bogus devices don't follow that rule. They stuff the ASC
992  * into the first byte -- so if it's non-zero, call it a failure.
993  */
994  if (us->iobuf[0]) {
995  US_DEBUGP("CBI IRQ data showed reserved bType 0x%x\n",
996  us->iobuf[0]);
997  goto Failed;
998 
999  }
1000 
1001  /* The second byte & 0x0F should be 0x0 for good, otherwise error */
1002  switch (us->iobuf[1] & 0x0F) {
1003  case 0x00:
1004  return USB_STOR_TRANSPORT_GOOD;
1005  case 0x01:
1006  goto Failed;
1007  }
1008  return USB_STOR_TRANSPORT_ERROR;
1009 
1010  /* the CBI spec requires that the bulk pipe must be cleared
1011  * following any data-in/out command failure (section 2.4.3.1.3)
1012  */
1013  Failed:
1014  if (pipe)
1015  usb_stor_clear_halt(us, pipe);
1017 }
1019 
1020 /*
1021  * Bulk only transport
1022  */
1023 
1024 /* Determine what the maximum LUN supported is */
1026 {
1027  int result;
1028 
1029  /* issue the command */
1030  us->iobuf[0] = 0;
1031  result = usb_stor_control_msg(us, us->recv_ctrl_pipe,
1035  0, us->ifnum, us->iobuf, 1, 10*HZ);
1036 
1037  US_DEBUGP("GetMaxLUN command result is %d, data is %d\n",
1038  result, us->iobuf[0]);
1039 
1040  /* if we have a successful request, return the result */
1041  if (result > 0)
1042  return us->iobuf[0];
1043 
1044  /*
1045  * Some devices don't like GetMaxLUN. They may STALL the control
1046  * pipe, they may return a zero-length result, they may do nothing at
1047  * all and timeout, or they may fail in even more bizarrely creative
1048  * ways. In these cases the best approach is to use the default
1049  * value: only one LUN.
1050  */
1051  return 0;
1052 }
1053 
1054 int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
1055 {
1056  struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1057  struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
1058  unsigned int transfer_length = scsi_bufflen(srb);
1059  unsigned int residue;
1060  int result;
1061  int fake_sense = 0;
1062  unsigned int cswlen;
1063  unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
1064 
1065  /* Take care of BULK32 devices; set extra byte to 0 */
1066  if (unlikely(us->fflags & US_FL_BULK32)) {
1067  cbwlen = 32;
1068  us->iobuf[31] = 0;
1069  }
1070 
1071  /* set up the command wrapper */
1073  bcb->DataTransferLength = cpu_to_le32(transfer_length);
1074  bcb->Flags = srb->sc_data_direction == DMA_FROM_DEVICE ?
1075  US_BULK_FLAG_IN : 0;
1076  bcb->Tag = ++us->tag;
1077  bcb->Lun = srb->device->lun;
1078  if (us->fflags & US_FL_SCM_MULT_TARG)
1079  bcb->Lun |= srb->device->id << 4;
1080  bcb->Length = srb->cmd_len;
1081 
1082  /* copy the command payload */
1083  memset(bcb->CDB, 0, sizeof(bcb->CDB));
1084  memcpy(bcb->CDB, srb->cmnd, bcb->Length);
1085 
1086  /* send it to out endpoint */
1087  US_DEBUGP("Bulk Command S 0x%x T 0x%x L %d F %d Trg %d LUN %d CL %d\n",
1088  le32_to_cpu(bcb->Signature), bcb->Tag,
1089  le32_to_cpu(bcb->DataTransferLength), bcb->Flags,
1090  (bcb->Lun >> 4), (bcb->Lun & 0x0F),
1091  bcb->Length);
1092  result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
1093  bcb, cbwlen, NULL);
1094  US_DEBUGP("Bulk command transfer result=%d\n", result);
1095  if (result != USB_STOR_XFER_GOOD)
1096  return USB_STOR_TRANSPORT_ERROR;
1097 
1098  /* DATA STAGE */
1099  /* send/receive data payload, if there is any */
1100 
1101  /* Some USB-IDE converter chips need a 100us delay between the
1102  * command phase and the data phase. Some devices need a little
1103  * more than that, probably because of clock rate inaccuracies. */
1104  if (unlikely(us->fflags & US_FL_GO_SLOW))
1105  udelay(125);
1106 
1107  if (transfer_length) {
1108  unsigned int pipe = srb->sc_data_direction == DMA_FROM_DEVICE ?
1109  us->recv_bulk_pipe : us->send_bulk_pipe;
1110  result = usb_stor_bulk_srb(us, pipe, srb);
1111  US_DEBUGP("Bulk data transfer result 0x%x\n", result);
1112  if (result == USB_STOR_XFER_ERROR)
1113  return USB_STOR_TRANSPORT_ERROR;
1114 
1115  /* If the device tried to send back more data than the
1116  * amount requested, the spec requires us to transfer
1117  * the CSW anyway. Since there's no point retrying the
1118  * the command, we'll return fake sense data indicating
1119  * Illegal Request, Invalid Field in CDB.
1120  */
1121  if (result == USB_STOR_XFER_LONG)
1122  fake_sense = 1;
1123  }
1124 
1125  /* See flow chart on pg 15 of the Bulk Only Transport spec for
1126  * an explanation of how this code works.
1127  */
1128 
1129  /* get CSW for device status */
1130  US_DEBUGP("Attempting to get CSW...\n");
1131  result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1132  bcs, US_BULK_CS_WRAP_LEN, &cswlen);
1133 
1134  /* Some broken devices add unnecessary zero-length packets to the
1135  * end of their data transfers. Such packets show up as 0-length
1136  * CSWs. If we encounter such a thing, try to read the CSW again.
1137  */
1138  if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
1139  US_DEBUGP("Received 0-length CSW; retrying...\n");
1140  result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1141  bcs, US_BULK_CS_WRAP_LEN, &cswlen);
1142  }
1143 
1144  /* did the attempt to read the CSW fail? */
1145  if (result == USB_STOR_XFER_STALLED) {
1146 
1147  /* get the status again */
1148  US_DEBUGP("Attempting to get CSW (2nd try)...\n");
1149  result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1150  bcs, US_BULK_CS_WRAP_LEN, NULL);
1151  }
1152 
1153  /* if we still have a failure at this point, we're in trouble */
1154  US_DEBUGP("Bulk status result = %d\n", result);
1155  if (result != USB_STOR_XFER_GOOD)
1156  return USB_STOR_TRANSPORT_ERROR;
1157 
1158  /* check bulk status */
1159  residue = le32_to_cpu(bcs->Residue);
1160  US_DEBUGP("Bulk Status S 0x%x T 0x%x R %u Stat 0x%x\n",
1161  le32_to_cpu(bcs->Signature), bcs->Tag,
1162  residue, bcs->Status);
1163  if (!(bcs->Tag == us->tag || (us->fflags & US_FL_BULK_IGNORE_TAG)) ||
1164  bcs->Status > US_BULK_STAT_PHASE) {
1165  US_DEBUGP("Bulk logical error\n");
1166  return USB_STOR_TRANSPORT_ERROR;
1167  }
1168 
1169  /* Some broken devices report odd signatures, so we do not check them
1170  * for validity against the spec. We store the first one we see,
1171  * and check subsequent transfers for validity against this signature.
1172  */
1173  if (!us->bcs_signature) {
1174  us->bcs_signature = bcs->Signature;
1176  US_DEBUGP("Learnt BCS signature 0x%08X\n",
1177  le32_to_cpu(us->bcs_signature));
1178  } else if (bcs->Signature != us->bcs_signature) {
1179  US_DEBUGP("Signature mismatch: got %08X, expecting %08X\n",
1180  le32_to_cpu(bcs->Signature),
1181  le32_to_cpu(us->bcs_signature));
1182  return USB_STOR_TRANSPORT_ERROR;
1183  }
1184 
1185  /* try to compute the actual residue, based on how much data
1186  * was really transferred and what the device tells us */
1187  if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
1188 
1189  /* Heuristically detect devices that generate bogus residues
1190  * by seeing what happens with INQUIRY and READ CAPACITY
1191  * commands.
1192  */
1193  if (bcs->Status == US_BULK_STAT_OK &&
1194  scsi_get_resid(srb) == 0 &&
1195  ((srb->cmnd[0] == INQUIRY &&
1196  transfer_length == 36) ||
1197  (srb->cmnd[0] == READ_CAPACITY &&
1198  transfer_length == 8))) {
1199  us->fflags |= US_FL_IGNORE_RESIDUE;
1200 
1201  } else {
1202  residue = min(residue, transfer_length);
1203  scsi_set_resid(srb, max(scsi_get_resid(srb),
1204  (int) residue));
1205  }
1206  }
1207 
1208  /* based on the status code, we report good or bad */
1209  switch (bcs->Status) {
1210  case US_BULK_STAT_OK:
1211  /* device babbled -- return fake sense data */
1212  if (fake_sense) {
1213  memcpy(srb->sense_buffer,
1215  sizeof(usb_stor_sense_invalidCDB));
1217  }
1218 
1219  /* command good -- note that data could be short */
1220  return USB_STOR_TRANSPORT_GOOD;
1221 
1222  case US_BULK_STAT_FAIL:
1223  /* command failed */
1225 
1226  case US_BULK_STAT_PHASE:
1227  /* phase error -- note that a transport reset will be
1228  * invoked by the invoke_transport() function
1229  */
1230  return USB_STOR_TRANSPORT_ERROR;
1231  }
1232 
1233  /* we should never get here, but if we do, we're in trouble */
1234  return USB_STOR_TRANSPORT_ERROR;
1235 }
1237 
1238 /***********************************************************************
1239  * Reset routines
1240  ***********************************************************************/
1241 
1242 /* This is the common part of the device reset code.
1243  *
1244  * It's handy that every transport mechanism uses the control endpoint for
1245  * resets.
1246  *
1247  * Basically, we send a reset with a 5-second timeout, so we don't get
1248  * jammed attempting to do the reset.
1249  */
1250 static int usb_stor_reset_common(struct us_data *us,
1251  u8 request, u8 requesttype,
1252  u16 value, u16 index, void *data, u16 size)
1253 {
1254  int result;
1255  int result2;
1256 
1257  if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
1258  US_DEBUGP("No reset during disconnect\n");
1259  return -EIO;
1260  }
1261 
1262  result = usb_stor_control_msg(us, us->send_ctrl_pipe,
1263  request, requesttype, value, index, data, size,
1264  5*HZ);
1265  if (result < 0) {
1266  US_DEBUGP("Soft reset failed: %d\n", result);
1267  return result;
1268  }
1269 
1270  /* Give the device some time to recover from the reset,
1271  * but don't delay disconnect processing. */
1274  HZ*6);
1275  if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
1276  US_DEBUGP("Reset interrupted by disconnect\n");
1277  return -EIO;
1278  }
1279 
1280  US_DEBUGP("Soft reset: clearing bulk-in endpoint halt\n");
1281  result = usb_stor_clear_halt(us, us->recv_bulk_pipe);
1282 
1283  US_DEBUGP("Soft reset: clearing bulk-out endpoint halt\n");
1284  result2 = usb_stor_clear_halt(us, us->send_bulk_pipe);
1285 
1286  /* return a result code based on the result of the clear-halts */
1287  if (result >= 0)
1288  result = result2;
1289  if (result < 0)
1290  US_DEBUGP("Soft reset failed\n");
1291  else
1292  US_DEBUGP("Soft reset done\n");
1293  return result;
1294 }
1295 
1296 /* This issues a CB[I] Reset to the device in question
1297  */
1298 #define CB_RESET_CMD_SIZE 12
1299 
1301 {
1302  US_DEBUGP("%s called\n", __func__);
1303 
1304  memset(us->iobuf, 0xFF, CB_RESET_CMD_SIZE);
1305  us->iobuf[0] = SEND_DIAGNOSTIC;
1306  us->iobuf[1] = 4;
1307  return usb_stor_reset_common(us, US_CBI_ADSC,
1309  0, us->ifnum, us->iobuf, CB_RESET_CMD_SIZE);
1310 }
1312 
1313 /* This issues a Bulk-only Reset to the device in question, including
1314  * clearing the subsequent endpoint halts that may occur.
1315  */
1317 {
1318  US_DEBUGP("%s called\n", __func__);
1319 
1320  return usb_stor_reset_common(us, US_BULK_RESET_REQUEST,
1322  0, us->ifnum, NULL, 0);
1323 }
1325 
1326 /* Issue a USB port reset to the device. The caller must not hold
1327  * us->dev_mutex.
1328  */
1330 {
1331  int result;
1332 
1333  /*for these devices we must use the class specific method */
1334  if (us->pusb_dev->quirks & USB_QUIRK_RESET)
1335  return -EPERM;
1336 
1337  result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
1338  if (result < 0)
1339  US_DEBUGP("unable to lock device for reset: %d\n", result);
1340  else {
1341  /* Were we disconnected while waiting for the lock? */
1342  if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
1343  result = -EIO;
1344  US_DEBUGP("No reset during disconnect\n");
1345  } else {
1346  result = usb_reset_device(us->pusb_dev);
1347  US_DEBUGP("usb_reset_device returns %d\n",
1348  result);
1349  }
1350  usb_unlock_device(us->pusb_dev);
1351  }
1352  return result;
1353 }