blob: 323293a3e61f08936ab16fcbc9820fdcc9056492 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* Driver for USB Mass Storage compliant devices
2 *
3 * $Id: transport.c,v 1.47 2002/04/22 03:39:43 mdharm Exp $
4 *
5 * Current development and maintenance by:
6 * (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
7 *
8 * Developed with the assistance of:
9 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
10 * (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
11 * (c) 2002 Alan Stern <stern@rowland.org>
12 *
13 * Initial work by:
14 * (c) 1999 Michael Gee (michael@linuxspecific.com)
15 *
16 * This driver is based on the 'USB Mass Storage Class' document. This
17 * describes in detail the protocol used to communicate with such
18 * devices. Clearly, the designers had SCSI and ATAPI commands in
19 * mind when they created this document. The commands are all very
20 * similar to commands in the SCSI-II and ATAPI specifications.
21 *
22 * It is important to note that in a number of cases this class
23 * exhibits class-specific exemptions from the USB specification.
24 * Notably the usage of NAK, STALL and ACK differs from the norm, in
25 * that they are used to communicate wait, failed and OK on commands.
26 *
27 * Also, for certain devices, the interrupt endpoint is used to convey
28 * status of a command.
29 *
30 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
31 * information about this driver.
32 *
33 * This program is free software; you can redistribute it and/or modify it
34 * under the terms of the GNU General Public License as published by the
35 * Free Software Foundation; either version 2, or (at your option) any
36 * later version.
37 *
38 * This program is distributed in the hope that it will be useful, but
39 * WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41 * General Public License for more details.
42 *
43 * You should have received a copy of the GNU General Public License along
44 * with this program; if not, write to the Free Software Foundation, Inc.,
45 * 675 Mass Ave, Cambridge, MA 02139, USA.
46 */
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/sched.h>
49#include <linux/errno.h>
50#include <linux/slab.h>
51
52#include <scsi/scsi.h>
53#include <scsi/scsi_cmnd.h>
54#include <scsi/scsi_device.h>
55
56#include "usb.h"
57#include "transport.h"
58#include "protocol.h"
59#include "scsiglue.h"
60#include "debug.h"
61
62
63/***********************************************************************
64 * Data transfer routines
65 ***********************************************************************/
66
67/*
68 * This is subtle, so pay attention:
69 * ---------------------------------
70 * We're very concerned about races with a command abort. Hanging this code
71 * is a sure fire way to hang the kernel. (Note that this discussion applies
72 * only to transactions resulting from a scsi queued-command, since only
73 * these transactions are subject to a scsi abort. Other transactions, such
74 * as those occurring during device-specific initialization, must be handled
75 * by a separate code path.)
76 *
77 * The abort function (usb_storage_command_abort() in scsiglue.c) first
78 * sets the machine state and the ABORTING bit in us->flags to prevent
79 * new URBs from being submitted. It then calls usb_stor_stop_transport()
80 * below, which atomically tests-and-clears the URB_ACTIVE bit in us->flags
81 * to see if the current_urb needs to be stopped. Likewise, the SG_ACTIVE
82 * bit is tested to see if the current_sg scatter-gather request needs to be
83 * stopped. The timeout callback routine does much the same thing.
84 *
85 * When a disconnect occurs, the DISCONNECTING bit in us->flags is set to
86 * prevent new URBs from being submitted, and usb_stor_stop_transport() is
87 * called to stop any ongoing requests.
88 *
89 * The submit function first verifies that the submitting is allowed
90 * (neither ABORTING nor DISCONNECTING bits are set) and that the submit
91 * completes without errors, and only then sets the URB_ACTIVE bit. This
92 * prevents the stop_transport() function from trying to cancel the URB
93 * while the submit call is underway. Next, the submit function must test
94 * the flags to see if an abort or disconnect occurred during the submission
95 * or before the URB_ACTIVE bit was set. If so, it's essential to cancel
96 * the URB if it hasn't been cancelled already (i.e., if the URB_ACTIVE bit
97 * is still set). Either way, the function must then wait for the URB to
Alan Sternb375a042005-07-29 16:11:07 -040098 * finish. Note that the URB can still be in progress even after a call to
99 * usb_unlink_urb() returns.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 *
101 * The idea is that (1) once the ABORTING or DISCONNECTING bit is set,
102 * either the stop_transport() function or the submitting function
103 * is guaranteed to call usb_unlink_urb() for an active URB,
104 * and (2) test_and_clear_bit() prevents usb_unlink_urb() from being
105 * called more than once or from being called during usb_submit_urb().
106 */
107
108/* This is the completion handler which will wake us up when an URB
109 * completes.
110 */
David Howells7d12e782006-10-05 14:55:46 +0100111static void usb_stor_blocking_completion(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
113 struct completion *urb_done_ptr = (struct completion *)urb->context;
114
115 complete(urb_done_ptr);
116}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118/* This is the common part of the URB message submission code
119 *
120 * All URBs from the usb-storage driver involved in handling a queued scsi
121 * command _must_ pass through this function (or something like it) for the
122 * abort mechanisms to work properly.
123 */
124static int usb_stor_msg_common(struct us_data *us, int timeout)
125{
126 struct completion urb_done;
Franck Bui-Huu3428cc42006-05-24 16:57:28 +0200127 long timeleft;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 int status;
129
130 /* don't submit URBs during abort/disconnect processing */
131 if (us->flags & ABORTING_OR_DISCONNECTING)
132 return -EIO;
133
134 /* set up data structures for the wakeup system */
135 init_completion(&urb_done);
136
137 /* fill the common fields in the URB */
138 us->current_urb->context = &urb_done;
139 us->current_urb->actual_length = 0;
140 us->current_urb->error_count = 0;
141 us->current_urb->status = 0;
142
143 /* we assume that if transfer_buffer isn't us->iobuf then it
144 * hasn't been mapped for DMA. Yes, this is clunky, but it's
145 * easier than always having the caller tell us whether the
146 * transfer buffer has already been mapped. */
Alan Sternb375a042005-07-29 16:11:07 -0400147 us->current_urb->transfer_flags = URB_NO_SETUP_DMA_MAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 if (us->current_urb->transfer_buffer == us->iobuf)
149 us->current_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
150 us->current_urb->transfer_dma = us->iobuf_dma;
151 us->current_urb->setup_dma = us->cr_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 */
162 set_bit(US_FLIDX_URB_ACTIVE, &us->flags);
163
164 /* did an abort/disconnect occur during the submission? */
165 if (us->flags & ABORTING_OR_DISCONNECTING) {
166
167 /* cancel the URB, if it hasn't been cancelled already */
168 if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->flags)) {
169 US_DEBUGP("-- cancelling URB\n");
170 usb_unlink_urb(us->current_urb);
171 }
172 }
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 /* wait for the completion of the URB */
Franck Bui-Huu3428cc42006-05-24 16:57:28 +0200175 timeleft = wait_for_completion_interruptible_timeout(
176 &urb_done, timeout ? : MAX_SCHEDULE_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
Franck Bui-Huu3428cc42006-05-24 16:57:28 +0200178 clear_bit(US_FLIDX_URB_ACTIVE, &us->flags);
179
180 if (timeleft <= 0) {
181 US_DEBUGP("%s -- cancelling URB\n",
182 timeleft == 0 ? "Timeout" : "Signal");
Alan Sternd6b7d3b2006-07-10 04:44:47 -0700183 usb_kill_urb(us->current_urb);
Franck Bui-Huu3428cc42006-05-24 16:57:28 +0200184 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
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 */
194int 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 __FUNCTION__, 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}
222
223/* This is a version of usb_clear_halt() that allows early termination and
224 * doesn't read the status from the device -- this is because some devices
225 * crash their internal firmware when the status is requested after a halt.
226 *
227 * A definitive list of these 'bad' devices is too difficult to maintain or
228 * make complete enough to be useful. This problem was first observed on the
229 * Hagiwara FlashGate DUAL unit. However, bus traces reveal that neither
230 * MacOS nor Windows checks the status after clearing a halt.
231 *
232 * Since many vendors in this space limit their testing to interoperability
233 * with these two OSes, specification violations like this one are common.
234 */
235int usb_stor_clear_halt(struct us_data *us, unsigned int pipe)
236{
237 int result;
238 int endp = usb_pipeendpoint(pipe);
239
240 if (usb_pipein (pipe))
241 endp |= USB_DIR_IN;
242
243 result = usb_stor_control_msg(us, us->send_ctrl_pipe,
244 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT,
245 USB_ENDPOINT_HALT, endp,
246 NULL, 0, 3*HZ);
247
248 /* reset the endpoint toggle */
Matthew Dharm5203ad42005-06-06 17:19:29 -0700249 if (result >= 0)
250 usb_settoggle(us->pusb_dev, usb_pipeendpoint(pipe),
251 usb_pipeout(pipe), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 US_DEBUGP("%s: result = %d\n", __FUNCTION__, result);
254 return result;
255}
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 */
265static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 /* 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 */
328int 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 __FUNCTION__, 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}
354
355/*
356 * Receive one interrupt buffer, without timeouts, but allowing early
357 * termination. Return codes are USB_STOR_XFER_xxx.
358 *
359 * This routine always uses us->recv_intr_pipe as the pipe and
360 * us->ep_bInterval as the interrupt interval.
361 */
362static int usb_stor_intr_transfer(struct us_data *us, void *buf,
363 unsigned int length)
364{
365 int result;
366 unsigned int pipe = us->recv_intr_pipe;
367 unsigned int maxp;
368
369 US_DEBUGP("%s: xfer %u bytes\n", __FUNCTION__, length);
370
371 /* calculate the max packet size */
372 maxp = usb_maxpacket(us->pusb_dev, pipe, usb_pipeout(pipe));
373 if (maxp > length)
374 maxp = length;
375
376 /* fill and submit the URB */
377 usb_fill_int_urb(us->current_urb, us->pusb_dev, pipe, buf,
378 maxp, usb_stor_blocking_completion, NULL,
379 us->ep_bInterval);
380 result = usb_stor_msg_common(us, 0);
381
382 return interpret_urb_result(us, pipe, length, result,
383 us->current_urb->actual_length);
384}
385
386/*
387 * Transfer one buffer via bulk pipe, without timeouts, but allowing early
388 * termination. Return codes are USB_STOR_XFER_xxx. If the bulk pipe
389 * stalls during the transfer, the halt is automatically cleared.
390 */
391int usb_stor_bulk_transfer_buf(struct us_data *us, unsigned int pipe,
392 void *buf, unsigned int length, unsigned int *act_len)
393{
394 int result;
395
396 US_DEBUGP("%s: xfer %u bytes\n", __FUNCTION__, length);
397
398 /* fill and submit the URB */
399 usb_fill_bulk_urb(us->current_urb, us->pusb_dev, pipe, buf, length,
400 usb_stor_blocking_completion, NULL);
401 result = usb_stor_msg_common(us, 0);
402
403 /* store the actual length of the data transferred */
404 if (act_len)
405 *act_len = us->current_urb->actual_length;
406 return interpret_urb_result(us, pipe, length, result,
407 us->current_urb->actual_length);
408}
409
410/*
411 * Transfer a scatter-gather list via bulk transfer
412 *
413 * This function does basically the same thing as usb_stor_bulk_transfer_buf()
414 * above, but it uses the usbcore scatter-gather library.
415 */
416static int usb_stor_bulk_transfer_sglist(struct us_data *us, unsigned int pipe,
417 struct scatterlist *sg, int num_sg, unsigned int length,
418 unsigned int *act_len)
419{
420 int result;
421
422 /* don't submit s-g requests during abort/disconnect processing */
423 if (us->flags & ABORTING_OR_DISCONNECTING)
424 return USB_STOR_XFER_ERROR;
425
426 /* initialize the scatter-gather request block */
427 US_DEBUGP("%s: xfer %u bytes, %d entries\n", __FUNCTION__,
428 length, num_sg);
429 result = usb_sg_init(&us->current_sg, us->pusb_dev, pipe, 0,
Christoph Lameter55acbda2006-12-06 20:33:13 -0800430 sg, num_sg, length, GFP_NOIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 if (result) {
432 US_DEBUGP("usb_sg_init returned %d\n", result);
433 return USB_STOR_XFER_ERROR;
434 }
435
436 /* since the block has been initialized successfully, it's now
437 * okay to cancel it */
438 set_bit(US_FLIDX_SG_ACTIVE, &us->flags);
439
440 /* did an abort/disconnect occur during the submission? */
441 if (us->flags & ABORTING_OR_DISCONNECTING) {
442
443 /* cancel the request, if it hasn't been cancelled already */
444 if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->flags)) {
445 US_DEBUGP("-- cancelling sg request\n");
446 usb_sg_cancel(&us->current_sg);
447 }
448 }
449
450 /* wait for the completion of the transfer */
451 usb_sg_wait(&us->current_sg);
452 clear_bit(US_FLIDX_SG_ACTIVE, &us->flags);
453
454 result = us->current_sg.status;
455 if (act_len)
456 *act_len = us->current_sg.bytes;
457 return interpret_urb_result(us, pipe, length, result,
458 us->current_sg.bytes);
459}
460
461/*
462 * Transfer an entire SCSI command's worth of data payload over the bulk
463 * pipe.
464 *
465 * Note that this uses usb_stor_bulk_transfer_buf() and
466 * usb_stor_bulk_transfer_sglist() to achieve its goals --
467 * this function simply determines whether we're going to use
468 * scatter-gather or not, and acts appropriately.
469 */
470int usb_stor_bulk_transfer_sg(struct us_data* us, unsigned int pipe,
471 void *buf, unsigned int length_left, int use_sg, int *residual)
472{
473 int result;
474 unsigned int partial;
475
476 /* are we scatter-gathering? */
477 if (use_sg) {
478 /* use the usb core scatter-gather primitives */
479 result = usb_stor_bulk_transfer_sglist(us, pipe,
480 (struct scatterlist *) buf, use_sg,
481 length_left, &partial);
482 length_left -= partial;
483 } else {
484 /* no scatter-gather, just make the request */
485 result = usb_stor_bulk_transfer_buf(us, pipe, buf,
486 length_left, &partial);
487 length_left -= partial;
488 }
489
490 /* store the residual and return the error code */
491 if (residual)
492 *residual = length_left;
493 return result;
494}
495
496/***********************************************************************
497 * Transport routines
498 ***********************************************************************/
499
500/* Invoke the transport and basic error-handling/recovery methods
501 *
502 * This is used by the protocol layers to actually send the message to
503 * the device and receive the response.
504 */
505void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
506{
507 int need_auto_sense;
508 int result;
509
510 /* send the command to the transport layer */
511 srb->resid = 0;
512 result = us->transport(srb, us);
513
514 /* if the command gets aborted by the higher layers, we need to
515 * short-circuit all other processing
516 */
517 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
518 US_DEBUGP("-- command was aborted\n");
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700519 srb->result = DID_ABORT << 16;
520 goto Handle_Errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522
523 /* if there is a transport error, reset and don't auto-sense */
524 if (result == USB_STOR_TRANSPORT_ERROR) {
525 US_DEBUGP("-- transport indicates error, resetting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 srb->result = DID_ERROR << 16;
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700527 goto Handle_Errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 }
529
530 /* if the transport provided its own sense data, don't auto-sense */
531 if (result == USB_STOR_TRANSPORT_NO_SENSE) {
532 srb->result = SAM_STAT_CHECK_CONDITION;
533 return;
534 }
535
536 srb->result = SAM_STAT_GOOD;
537
538 /* Determine if we need to auto-sense
539 *
540 * I normally don't use a flag like this, but it's almost impossible
541 * to understand what's going on here if I don't.
542 */
543 need_auto_sense = 0;
544
545 /*
546 * If we're running the CB transport, which is incapable
547 * of determining status on its own, we will auto-sense
548 * unless the operation involved a data-in transfer. Devices
549 * can signal most data-in errors by stalling the bulk-in pipe.
550 */
551 if ((us->protocol == US_PR_CB || us->protocol == US_PR_DPCM_USB) &&
552 srb->sc_data_direction != DMA_FROM_DEVICE) {
553 US_DEBUGP("-- CB transport device requiring auto-sense\n");
554 need_auto_sense = 1;
555 }
556
557 /*
558 * If we have a failure, we're going to do a REQUEST_SENSE
559 * automatically. Note that we differentiate between a command
560 * "failure" and an "error" in the transport mechanism.
561 */
562 if (result == USB_STOR_TRANSPORT_FAILED) {
563 US_DEBUGP("-- transport indicates command failure\n");
564 need_auto_sense = 1;
565 }
566
567 /*
568 * A short transfer on a command where we don't expect it
569 * is unusual, but it doesn't mean we need to auto-sense.
570 */
571 if ((srb->resid > 0) &&
572 !((srb->cmnd[0] == REQUEST_SENSE) ||
573 (srb->cmnd[0] == INQUIRY) ||
574 (srb->cmnd[0] == MODE_SENSE) ||
575 (srb->cmnd[0] == LOG_SENSE) ||
576 (srb->cmnd[0] == MODE_SENSE_10))) {
577 US_DEBUGP("-- unexpectedly short transfer\n");
578 }
579
580 /* Now, if we need to do the auto-sense, let's do it */
581 if (need_auto_sense) {
582 int temp_result;
583 void* old_request_buffer;
584 unsigned short old_sg;
585 unsigned old_request_bufflen;
586 unsigned char old_sc_data_direction;
587 unsigned char old_cmd_len;
588 unsigned char old_cmnd[MAX_COMMAND_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 int old_resid;
590
591 US_DEBUGP("Issuing auto-REQUEST_SENSE\n");
592
593 /* save the old command */
594 memcpy(old_cmnd, srb->cmnd, MAX_COMMAND_SIZE);
595 old_cmd_len = srb->cmd_len;
596
597 /* set the command and the LUN */
598 memset(srb->cmnd, 0, MAX_COMMAND_SIZE);
599 srb->cmnd[0] = REQUEST_SENSE;
600 srb->cmnd[1] = old_cmnd[1] & 0xE0;
601 srb->cmnd[4] = 18;
602
603 /* FIXME: we must do the protocol translation here */
604 if (us->subclass == US_SC_RBC || us->subclass == US_SC_SCSI)
605 srb->cmd_len = 6;
606 else
607 srb->cmd_len = 12;
608
609 /* set the transfer direction */
610 old_sc_data_direction = srb->sc_data_direction;
611 srb->sc_data_direction = DMA_FROM_DEVICE;
612
613 /* use the new buffer we have */
614 old_request_buffer = srb->request_buffer;
Alan Sternbbafa462005-10-23 19:40:22 -0700615 srb->request_buffer = us->sensebuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 /* set the buffer length for transfer */
618 old_request_bufflen = srb->request_bufflen;
Alan Sternbbafa462005-10-23 19:40:22 -0700619 srb->request_bufflen = US_SENSE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 /* set up for no scatter-gather use */
622 old_sg = srb->use_sg;
623 srb->use_sg = 0;
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /* issue the auto-sense command */
626 old_resid = srb->resid;
627 srb->resid = 0;
628 temp_result = us->transport(us->srb, us);
629
630 /* let's clean up right away */
Alan Sternbbafa462005-10-23 19:40:22 -0700631 memcpy(srb->sense_buffer, us->sensebuf, US_SENSE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 srb->resid = old_resid;
633 srb->request_buffer = old_request_buffer;
634 srb->request_bufflen = old_request_bufflen;
635 srb->use_sg = old_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 srb->sc_data_direction = old_sc_data_direction;
637 srb->cmd_len = old_cmd_len;
638 memcpy(srb->cmnd, old_cmnd, MAX_COMMAND_SIZE);
639
640 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
641 US_DEBUGP("-- auto-sense aborted\n");
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700642 srb->result = DID_ABORT << 16;
643 goto Handle_Errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 }
645 if (temp_result != USB_STOR_TRANSPORT_GOOD) {
646 US_DEBUGP("-- auto-sense failure\n");
647
648 /* we skip the reset if this happens to be a
649 * multi-target device, since failure of an
650 * auto-sense is perfectly valid
651 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 srb->result = DID_ERROR << 16;
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700653 if (!(us->flags & US_FL_SCM_MULT_TARG))
654 goto Handle_Errors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 return;
656 }
657
658 US_DEBUGP("-- Result from auto-sense is %d\n", temp_result);
659 US_DEBUGP("-- code: 0x%x, key: 0x%x, ASC: 0x%x, ASCQ: 0x%x\n",
660 srb->sense_buffer[0],
661 srb->sense_buffer[2] & 0xf,
662 srb->sense_buffer[12],
663 srb->sense_buffer[13]);
664#ifdef CONFIG_USB_STORAGE_DEBUG
665 usb_stor_show_sense(
666 srb->sense_buffer[2] & 0xf,
667 srb->sense_buffer[12],
668 srb->sense_buffer[13]);
669#endif
670
671 /* set the result so the higher layers expect this data */
672 srb->result = SAM_STAT_CHECK_CONDITION;
673
674 /* If things are really okay, then let's show that. Zero
675 * out the sense buffer so the higher layers won't realize
676 * we did an unsolicited auto-sense. */
677 if (result == USB_STOR_TRANSPORT_GOOD &&
678 /* Filemark 0, ignore EOM, ILI 0, no sense */
679 (srb->sense_buffer[2] & 0xaf) == 0 &&
680 /* No ASC or ASCQ */
681 srb->sense_buffer[12] == 0 &&
682 srb->sense_buffer[13] == 0) {
683 srb->result = SAM_STAT_GOOD;
684 srb->sense_buffer[0] = 0x0;
685 }
686 }
687
688 /* Did we transfer less than the minimum amount required? */
689 if (srb->result == SAM_STAT_GOOD &&
690 srb->request_bufflen - srb->resid < srb->underflow)
691 srb->result = (DID_ERROR << 16) | (SUGGEST_RETRY << 24);
692
693 return;
694
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700695 /* Error and abort processing: try to resynchronize with the device
696 * by issuing a port reset. If that fails, try a class-specific
697 * device reset. */
698 Handle_Errors:
699
Alan Stern47104b02006-06-01 13:52:56 -0400700 /* Set the RESETTING bit, and clear the ABORTING bit so that
701 * the reset may proceed. */
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700702 scsi_lock(us_to_host(us));
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700703 set_bit(US_FLIDX_RESETTING, &us->flags);
704 clear_bit(US_FLIDX_ABORTING, &us->flags);
705 scsi_unlock(us_to_host(us));
706
Alan Stern47104b02006-06-01 13:52:56 -0400707 /* We must release the device lock because the pre_reset routine
708 * will want to acquire it. */
709 mutex_unlock(&us->dev_mutex);
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700710 result = usb_stor_port_reset(us);
Alan Stern47104b02006-06-01 13:52:56 -0400711 mutex_lock(&us->dev_mutex);
712
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700713 if (result < 0) {
714 scsi_lock(us_to_host(us));
715 usb_stor_report_device_reset(us);
716 scsi_unlock(us_to_host(us));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 us->transport_reset(us);
Matthew Dharm4d07ef72005-06-06 17:21:41 -0700718 }
719 clear_bit(US_FLIDX_RESETTING, &us->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
721
722/* Stop the current URB transfer */
723void usb_stor_stop_transport(struct us_data *us)
724{
725 US_DEBUGP("%s called\n", __FUNCTION__);
726
727 /* If the state machine is blocked waiting for an URB,
728 * let's wake it up. The test_and_clear_bit() call
729 * guarantees that if a URB has just been submitted,
730 * it won't be cancelled more than once. */
731 if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->flags)) {
732 US_DEBUGP("-- cancelling URB\n");
733 usb_unlink_urb(us->current_urb);
734 }
735
736 /* If we are waiting for a scatter-gather operation, cancel it. */
737 if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->flags)) {
738 US_DEBUGP("-- cancelling sg request\n");
739 usb_sg_cancel(&us->current_sg);
740 }
741}
742
743/*
744 * Control/Bulk/Interrupt transport
745 */
746
747int usb_stor_CBI_transport(struct scsi_cmnd *srb, struct us_data *us)
748{
749 unsigned int transfer_length = srb->request_bufflen;
750 unsigned int pipe = 0;
751 int result;
752
753 /* COMMAND STAGE */
754 /* let's send the command via the control pipe */
755 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
756 US_CBI_ADSC,
757 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0,
758 us->ifnum, srb->cmnd, srb->cmd_len);
759
760 /* check the return code for the command */
761 US_DEBUGP("Call to usb_stor_ctrl_transfer() returned %d\n", result);
762
763 /* if we stalled the command, it means command failed */
764 if (result == USB_STOR_XFER_STALLED) {
765 return USB_STOR_TRANSPORT_FAILED;
766 }
767
768 /* Uh oh... serious problem here */
769 if (result != USB_STOR_XFER_GOOD) {
770 return USB_STOR_TRANSPORT_ERROR;
771 }
772
773 /* DATA STAGE */
774 /* transfer the data payload for this command, if one exists*/
775 if (transfer_length) {
776 pipe = srb->sc_data_direction == DMA_FROM_DEVICE ?
777 us->recv_bulk_pipe : us->send_bulk_pipe;
778 result = usb_stor_bulk_transfer_sg(us, pipe,
779 srb->request_buffer, transfer_length,
780 srb->use_sg, &srb->resid);
781 US_DEBUGP("CBI data stage result is 0x%x\n", result);
782
783 /* if we stalled the data transfer it means command failed */
784 if (result == USB_STOR_XFER_STALLED)
785 return USB_STOR_TRANSPORT_FAILED;
786 if (result > USB_STOR_XFER_STALLED)
787 return USB_STOR_TRANSPORT_ERROR;
788 }
789
790 /* STATUS STAGE */
791 result = usb_stor_intr_transfer(us, us->iobuf, 2);
792 US_DEBUGP("Got interrupt data (0x%x, 0x%x)\n",
793 us->iobuf[0], us->iobuf[1]);
794 if (result != USB_STOR_XFER_GOOD)
795 return USB_STOR_TRANSPORT_ERROR;
796
797 /* UFI gives us ASC and ASCQ, like a request sense
798 *
799 * REQUEST_SENSE and INQUIRY don't affect the sense data on UFI
800 * devices, so we ignore the information for those commands. Note
801 * that this means we could be ignoring a real error on these
802 * commands, but that can't be helped.
803 */
804 if (us->subclass == US_SC_UFI) {
805 if (srb->cmnd[0] == REQUEST_SENSE ||
806 srb->cmnd[0] == INQUIRY)
807 return USB_STOR_TRANSPORT_GOOD;
808 if (us->iobuf[0])
809 goto Failed;
810 return USB_STOR_TRANSPORT_GOOD;
811 }
812
813 /* If not UFI, we interpret the data as a result code
814 * The first byte should always be a 0x0.
815 *
816 * Some bogus devices don't follow that rule. They stuff the ASC
817 * into the first byte -- so if it's non-zero, call it a failure.
818 */
819 if (us->iobuf[0]) {
820 US_DEBUGP("CBI IRQ data showed reserved bType 0x%x\n",
821 us->iobuf[0]);
822 goto Failed;
823
824 }
825
826 /* The second byte & 0x0F should be 0x0 for good, otherwise error */
827 switch (us->iobuf[1] & 0x0F) {
828 case 0x00:
829 return USB_STOR_TRANSPORT_GOOD;
830 case 0x01:
831 goto Failed;
832 }
833 return USB_STOR_TRANSPORT_ERROR;
834
835 /* the CBI spec requires that the bulk pipe must be cleared
836 * following any data-in/out command failure (section 2.4.3.1.3)
837 */
838 Failed:
839 if (pipe)
840 usb_stor_clear_halt(us, pipe);
841 return USB_STOR_TRANSPORT_FAILED;
842}
843
844/*
845 * Control/Bulk transport
846 */
847int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
848{
849 unsigned int transfer_length = srb->request_bufflen;
850 int result;
851
852 /* COMMAND STAGE */
853 /* let's send the command via the control pipe */
854 result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
855 US_CBI_ADSC,
856 USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0,
857 us->ifnum, srb->cmnd, srb->cmd_len);
858
859 /* check the return code for the command */
860 US_DEBUGP("Call to usb_stor_ctrl_transfer() returned %d\n", result);
861
862 /* if we stalled the command, it means command failed */
863 if (result == USB_STOR_XFER_STALLED) {
864 return USB_STOR_TRANSPORT_FAILED;
865 }
866
867 /* Uh oh... serious problem here */
868 if (result != USB_STOR_XFER_GOOD) {
869 return USB_STOR_TRANSPORT_ERROR;
870 }
871
872 /* DATA STAGE */
873 /* transfer the data payload for this command, if one exists*/
874 if (transfer_length) {
875 unsigned int pipe = srb->sc_data_direction == DMA_FROM_DEVICE ?
876 us->recv_bulk_pipe : us->send_bulk_pipe;
877 result = usb_stor_bulk_transfer_sg(us, pipe,
878 srb->request_buffer, transfer_length,
879 srb->use_sg, &srb->resid);
880 US_DEBUGP("CB data stage result is 0x%x\n", result);
881
882 /* if we stalled the data transfer it means command failed */
883 if (result == USB_STOR_XFER_STALLED)
884 return USB_STOR_TRANSPORT_FAILED;
885 if (result > USB_STOR_XFER_STALLED)
886 return USB_STOR_TRANSPORT_ERROR;
887 }
888
889 /* STATUS STAGE */
890 /* NOTE: CB does not have a status stage. Silly, I know. So
891 * we have to catch this at a higher level.
892 */
893 return USB_STOR_TRANSPORT_GOOD;
894}
895
896/*
897 * Bulk only transport
898 */
899
900/* Determine what the maximum LUN supported is */
901int usb_stor_Bulk_max_lun(struct us_data *us)
902{
903 int result;
904
905 /* issue the command */
Alan Sternb876aef2005-10-23 19:38:56 -0700906 us->iobuf[0] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 result = usb_stor_control_msg(us, us->recv_ctrl_pipe,
908 US_BULK_GET_MAX_LUN,
909 USB_DIR_IN | USB_TYPE_CLASS |
910 USB_RECIP_INTERFACE,
911 0, us->ifnum, us->iobuf, 1, HZ);
912
913 US_DEBUGP("GetMaxLUN command result is %d, data is %d\n",
914 result, us->iobuf[0]);
915
916 /* if we have a successful request, return the result */
917 if (result > 0)
918 return us->iobuf[0];
919
920 /*
921 * Some devices (i.e. Iomega Zip100) need this -- apparently
922 * the bulk pipes get STALLed when the GetMaxLUN request is
923 * processed. This is, in theory, harmless to all other devices
924 * (regardless of if they stall or not).
925 */
926 if (result == -EPIPE) {
927 usb_stor_clear_halt(us, us->recv_bulk_pipe);
928 usb_stor_clear_halt(us, us->send_bulk_pipe);
929 }
930
931 /*
932 * Some devices don't like GetMaxLUN. They may STALL the control
933 * pipe, they may return a zero-length result, they may do nothing at
934 * all and timeout, or they may fail in even more bizarrely creative
935 * ways. In these cases the best approach is to use the default
936 * value: only one LUN.
937 */
938 return 0;
939}
940
941int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
942{
943 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
944 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
945 unsigned int transfer_length = srb->request_bufflen;
946 unsigned int residue;
947 int result;
948 int fake_sense = 0;
949 unsigned int cswlen;
950 unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
951
952 /* Take care of BULK32 devices; set extra byte to 0 */
953 if ( unlikely(us->flags & US_FL_BULK32)) {
954 cbwlen = 32;
955 us->iobuf[31] = 0;
956 }
957
958 /* set up the command wrapper */
959 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
960 bcb->DataTransferLength = cpu_to_le32(transfer_length);
961 bcb->Flags = srb->sc_data_direction == DMA_FROM_DEVICE ? 1 << 7 : 0;
Matthew Dharm0f64e072005-07-28 14:43:08 -0700962 bcb->Tag = ++us->tag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 bcb->Lun = srb->device->lun;
964 if (us->flags & US_FL_SCM_MULT_TARG)
965 bcb->Lun |= srb->device->id << 4;
966 bcb->Length = srb->cmd_len;
967
968 /* copy the command payload */
969 memset(bcb->CDB, 0, sizeof(bcb->CDB));
970 memcpy(bcb->CDB, srb->cmnd, bcb->Length);
971
972 /* send it to out endpoint */
973 US_DEBUGP("Bulk Command S 0x%x T 0x%x L %d F %d Trg %d LUN %d CL %d\n",
974 le32_to_cpu(bcb->Signature), bcb->Tag,
975 le32_to_cpu(bcb->DataTransferLength), bcb->Flags,
976 (bcb->Lun >> 4), (bcb->Lun & 0x0F),
977 bcb->Length);
978 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
979 bcb, cbwlen, NULL);
980 US_DEBUGP("Bulk command transfer result=%d\n", result);
981 if (result != USB_STOR_XFER_GOOD)
982 return USB_STOR_TRANSPORT_ERROR;
983
984 /* DATA STAGE */
985 /* send/receive data payload, if there is any */
986
987 /* Some USB-IDE converter chips need a 100us delay between the
988 * command phase and the data phase. Some devices need a little
989 * more than that, probably because of clock rate inaccuracies. */
990 if (unlikely(us->flags & US_FL_GO_SLOW))
Phil Dibowitze4334fa2005-04-18 17:39:27 -0700991 udelay(125);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
993 if (transfer_length) {
994 unsigned int pipe = srb->sc_data_direction == DMA_FROM_DEVICE ?
995 us->recv_bulk_pipe : us->send_bulk_pipe;
996 result = usb_stor_bulk_transfer_sg(us, pipe,
997 srb->request_buffer, transfer_length,
998 srb->use_sg, &srb->resid);
999 US_DEBUGP("Bulk data transfer result 0x%x\n", result);
1000 if (result == USB_STOR_XFER_ERROR)
1001 return USB_STOR_TRANSPORT_ERROR;
1002
1003 /* If the device tried to send back more data than the
1004 * amount requested, the spec requires us to transfer
1005 * the CSW anyway. Since there's no point retrying the
1006 * the command, we'll return fake sense data indicating
1007 * Illegal Request, Invalid Field in CDB.
1008 */
1009 if (result == USB_STOR_XFER_LONG)
1010 fake_sense = 1;
1011 }
1012
1013 /* See flow chart on pg 15 of the Bulk Only Transport spec for
1014 * an explanation of how this code works.
1015 */
1016
1017 /* get CSW for device status */
1018 US_DEBUGP("Attempting to get CSW...\n");
1019 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1020 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
1021
1022 /* Some broken devices add unnecessary zero-length packets to the
1023 * end of their data transfers. Such packets show up as 0-length
1024 * CSWs. If we encounter such a thing, try to read the CSW again.
1025 */
1026 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
1027 US_DEBUGP("Received 0-length CSW; retrying...\n");
1028 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1029 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
1030 }
1031
1032 /* did the attempt to read the CSW fail? */
1033 if (result == USB_STOR_XFER_STALLED) {
1034
1035 /* get the status again */
1036 US_DEBUGP("Attempting to get CSW (2nd try)...\n");
1037 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
1038 bcs, US_BULK_CS_WRAP_LEN, NULL);
1039 }
1040
1041 /* if we still have a failure at this point, we're in trouble */
1042 US_DEBUGP("Bulk status result = %d\n", result);
1043 if (result != USB_STOR_XFER_GOOD)
1044 return USB_STOR_TRANSPORT_ERROR;
1045
1046 /* check bulk status */
1047 residue = le32_to_cpu(bcs->Residue);
1048 US_DEBUGP("Bulk Status S 0x%x T 0x%x R %u Stat 0x%x\n",
1049 le32_to_cpu(bcs->Signature), bcs->Tag,
1050 residue, bcs->Status);
Matthew Dharm0f64e072005-07-28 14:43:08 -07001051 if (bcs->Tag != us->tag || bcs->Status > US_BULK_STAT_PHASE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 US_DEBUGP("Bulk logical error\n");
1053 return USB_STOR_TRANSPORT_ERROR;
1054 }
1055
1056 /* Some broken devices report odd signatures, so we do not check them
1057 * for validity against the spec. We store the first one we see,
1058 * and check subsequent transfers for validity against this signature.
1059 */
1060 if (!us->bcs_signature) {
1061 us->bcs_signature = bcs->Signature;
1062 if (us->bcs_signature != cpu_to_le32(US_BULK_CS_SIGN))
1063 US_DEBUGP("Learnt BCS signature 0x%08X\n",
1064 le32_to_cpu(us->bcs_signature));
1065 } else if (bcs->Signature != us->bcs_signature) {
1066 US_DEBUGP("Signature mismatch: got %08X, expecting %08X\n",
1067 le32_to_cpu(bcs->Signature),
1068 le32_to_cpu(us->bcs_signature));
1069 return USB_STOR_TRANSPORT_ERROR;
1070 }
1071
1072 /* try to compute the actual residue, based on how much data
1073 * was really transferred and what the device tells us */
1074 if (residue) {
1075 if (!(us->flags & US_FL_IGNORE_RESIDUE)) {
1076 residue = min(residue, transfer_length);
1077 srb->resid = max(srb->resid, (int) residue);
1078 }
1079 }
1080
1081 /* based on the status code, we report good or bad */
1082 switch (bcs->Status) {
1083 case US_BULK_STAT_OK:
1084 /* device babbled -- return fake sense data */
1085 if (fake_sense) {
1086 memcpy(srb->sense_buffer,
1087 usb_stor_sense_invalidCDB,
1088 sizeof(usb_stor_sense_invalidCDB));
1089 return USB_STOR_TRANSPORT_NO_SENSE;
1090 }
1091
1092 /* command good -- note that data could be short */
1093 return USB_STOR_TRANSPORT_GOOD;
1094
1095 case US_BULK_STAT_FAIL:
1096 /* command failed */
1097 return USB_STOR_TRANSPORT_FAILED;
1098
1099 case US_BULK_STAT_PHASE:
1100 /* phase error -- note that a transport reset will be
1101 * invoked by the invoke_transport() function
1102 */
1103 return USB_STOR_TRANSPORT_ERROR;
1104 }
1105
1106 /* we should never get here, but if we do, we're in trouble */
1107 return USB_STOR_TRANSPORT_ERROR;
1108}
1109
1110/***********************************************************************
1111 * Reset routines
1112 ***********************************************************************/
1113
1114/* This is the common part of the device reset code.
1115 *
1116 * It's handy that every transport mechanism uses the control endpoint for
1117 * resets.
1118 *
Matthew Dharm5203ad42005-06-06 17:19:29 -07001119 * Basically, we send a reset with a 5-second timeout, so we don't get
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 * jammed attempting to do the reset.
1121 */
1122static int usb_stor_reset_common(struct us_data *us,
1123 u8 request, u8 requesttype,
1124 u16 value, u16 index, void *data, u16 size)
1125{
1126 int result;
1127 int result2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001129 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
1130 US_DEBUGP("No reset during disconnect\n");
1131 return -EIO;
1132 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 result = usb_stor_control_msg(us, us->send_ctrl_pipe,
1135 request, requesttype, value, index, data, size,
Matthew Dharm5203ad42005-06-06 17:19:29 -07001136 5*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 if (result < 0) {
1138 US_DEBUGP("Soft reset failed: %d\n", result);
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001139 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 }
1141
1142 /* Give the device some time to recover from the reset,
1143 * but don't delay disconnect processing. */
1144 wait_event_interruptible_timeout(us->delay_wait,
1145 test_bit(US_FLIDX_DISCONNECTING, &us->flags),
1146 HZ*6);
1147 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
1148 US_DEBUGP("Reset interrupted by disconnect\n");
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001149 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 }
1151
1152 US_DEBUGP("Soft reset: clearing bulk-in endpoint halt\n");
1153 result = usb_stor_clear_halt(us, us->recv_bulk_pipe);
1154
1155 US_DEBUGP("Soft reset: clearing bulk-out endpoint halt\n");
1156 result2 = usb_stor_clear_halt(us, us->send_bulk_pipe);
1157
Matthew Dharm5203ad42005-06-06 17:19:29 -07001158 /* return a result code based on the result of the clear-halts */
1159 if (result >= 0)
1160 result = result2;
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001161 if (result < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 US_DEBUGP("Soft reset failed\n");
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001163 else
1164 US_DEBUGP("Soft reset done\n");
1165 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166}
1167
1168/* This issues a CB[I] Reset to the device in question
1169 */
1170#define CB_RESET_CMD_SIZE 12
1171
1172int usb_stor_CB_reset(struct us_data *us)
1173{
1174 US_DEBUGP("%s called\n", __FUNCTION__);
1175
1176 memset(us->iobuf, 0xFF, CB_RESET_CMD_SIZE);
1177 us->iobuf[0] = SEND_DIAGNOSTIC;
1178 us->iobuf[1] = 4;
1179 return usb_stor_reset_common(us, US_CBI_ADSC,
1180 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1181 0, us->ifnum, us->iobuf, CB_RESET_CMD_SIZE);
1182}
1183
1184/* This issues a Bulk-only Reset to the device in question, including
1185 * clearing the subsequent endpoint halts that may occur.
1186 */
1187int usb_stor_Bulk_reset(struct us_data *us)
1188{
1189 US_DEBUGP("%s called\n", __FUNCTION__);
1190
1191 return usb_stor_reset_common(us, US_BULK_RESET_REQUEST,
1192 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1193 0, us->ifnum, NULL, 0);
1194}
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001195
Alan Stern47104b02006-06-01 13:52:56 -04001196/* Issue a USB port reset to the device. The caller must not hold
1197 * us->dev_mutex.
1198 */
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001199int usb_stor_port_reset(struct us_data *us)
1200{
Alan Stern47104b02006-06-01 13:52:56 -04001201 int result, rc_lock;
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001202
Alan Stern47104b02006-06-01 13:52:56 -04001203 result = rc_lock =
1204 usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
1205 if (result < 0)
1206 US_DEBUGP("unable to lock device for reset: %d\n", result);
1207 else {
1208 /* Were we disconnected while waiting for the lock? */
1209 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
1210 result = -EIO;
1211 US_DEBUGP("No reset during disconnect\n");
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001212 } else {
Alan Stern47104b02006-06-01 13:52:56 -04001213 result = usb_reset_composite_device(
1214 us->pusb_dev, us->pusb_intf);
1215 US_DEBUGP("usb_reset_composite_device returns %d\n",
1216 result);
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001217 }
Alan Stern47104b02006-06-01 13:52:56 -04001218 if (rc_lock)
1219 usb_unlock_device(us->pusb_dev);
Matthew Dharm4d07ef72005-06-06 17:21:41 -07001220 }
1221 return result;
1222}