开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
transport.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：37k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

transport.c：源码内容
  1. /* Driver for USB Mass Storage compliant devices
  2.  *
  3.  * $Id: transport.c,v 1.44 2002/02/25 00:43:41 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.  */
  48. #include <linux/config.h>
  49. #include "transport.h"
  50. #include "protocol.h"
  51. #include "usb.h"
  52. #include "debug.h"
  54. #include <linux/sched.h>
  55. #include <linux/errno.h>
  56. #include <linux/slab.h>
  58. /***********************************************************************
  59.  * Helper routines
  60.  ***********************************************************************/
  62. /* Calculate the length of the data transfer (not the command) for any
  63.  * given SCSI command
  64.  */
  65. unsigned int usb_stor_transfer_length(Scsi_Cmnd *srb)
  66. {
  67.        int i;
  68. int doDefault = 0;
  69. unsigned int len = 0;
  70. unsigned int total = 0;
  71. struct scatterlist *sg;
  73. /* This table tells us:
  74.    X = command not supported
  75.    L = return length in cmnd[4] (8 bits).
  76.    M = return length in cmnd[8] (8 bits).
  77.    G = return length in cmnd[3] and cmnd[4] (16 bits)
  78.    H = return length in cmnd[7] and cmnd[8] (16 bits)
  79.    I = return length in cmnd[8] and cmnd[9] (16 bits)
  80.    C = return length in cmnd[2] to cmnd[5] (32 bits)
  81.    D = return length in cmnd[6] to cmnd[9] (32 bits)
  82.    B = return length in blocksize so we use buff_len
  83.    R = return length in cmnd[2] to cmnd[4] (24 bits)
  84.    S = return length in cmnd[3] to cmnd[5] (24 bits)
  85.    T = return length in cmnd[6] to cmnd[8] (24 bits)
  86.    U = return length in cmnd[7] to cmnd[9] (24 bits)
  87.    0-9 = fixed return length
  88.    V = 20 bytes
  89.    W = 24 bytes
  90.    Z = return length is mode dependant or not in command, use buff_len
  91. */
  93. static char *lengths =
  95.       /* 0123456789ABCDEF   0123456789ABCDEF */
  97. "00XLZ6XZBXBBXXXB" "00LBBLG0R0L0GG0X"  /* 00-1F */
  98. "XXXXT8XXB4B0BBBB" "ZZZ0B00HCSSZTBHH"  /* 20-3F */
  99. "M0HHB0X000H0HH0X" "XHH0HHXX0TH0H0XX"  /* 40-5F */
  100. "XXXXXXXXXXXXXXXX" "XXXXXXXXXXXXXXXX"  /* 60-7F */
  101. "XXXXXXXXXXXXXXXX" "XXXXXXXXXXXXXXXX"  /* 80-9F */
  102. "X0XXX00XB0BXBXBB" "ZZZ0XUIDU000XHBX"  /* A0-BF */
  103. "XXXXXXXXXXXXXXXX" "XXXXXXXXXXXXXXXX"  /* C0-DF */
  104. "XDXXXXXXXXXXXXXX" "XXW00HXXXXXXXXXX"; /* E0-FF */
  106. /* Commands checked in table:
  108.    CHANGE_DEFINITION 40
  109.    COMPARE 39
  110.    COPY 18
  111.    COPY_AND_VERIFY 3a
  112.    ERASE 19
  113.    ERASE_10 2c
  114.    ERASE_12 ac
  115.    EXCHANGE_MEDIUM a6
  116.    FORMAT_UNIT 04
  117.    GET_DATA_BUFFER_STATUS 34
  118.    GET_MESSAGE_10 28
  119.    GET_MESSAGE_12 a8
  120.    GET_WINDOW 25   !!! Has more data than READ_CAPACITY, need to fix table
  121.    INITIALIZE_ELEMENT_STATUS 07 !!! REASSIGN_BLOCKS luckily uses buff_len
  122.    INQUIRY 12
  123.    LOAD_UNLOAD 1b
  124.    LOCATE 2b
  125.    LOCK_UNLOCK_CACHE 36
  126.    LOG_SELECT 4c
  127.    LOG_SENSE 4d
  128.    MEDIUM_SCAN 38     !!! This was M
  129.    MODE_SELECT6 15
  130.    MODE_SELECT_10 55
  131.    MODE_SENSE_6 1a
  132.    MODE_SENSE_10 5a
  133.    MOVE_MEDIUM a5
  134.    OBJECT_POSITION 31  !!! Same as SEARCH_DATA_EQUAL
  135.    PAUSE_RESUME 4b
  136.    PLAY_AUDIO_10 45
  137.    PLAY_AUDIO_12 a5
  138.    PLAY_AUDIO_MSF 47
  139.    PLAY_AUDIO_TRACK_INDEX 48
  140.        PLAY_AUDIO_TRACK_RELATIVE_10 49
  141.    PLAY_AUDIO_TRACK_RELATIVE_12 a9
  142.    POSITION_TO_ELEMENT 2b
  143.           PRE-FETCH 34
  144.    PREVENT_ALLOW_MEDIUM_REMOVAL 1e
  145.    PRINT 0a             !!! Same as WRITE_6 but is always in bytes
  146.    READ_6 08
  147.    READ_10 28
  148.    READ_12 a8
  149.    READ_BLOCK_LIMITS 05
  150.    READ_BUFFER 3c
  151.    READ_CAPACITY 25
  152.    READ_CDROM_CAPACITY 25
  153.    READ_DEFECT_DATA 37
  154.    READ_DEFECT_DATA_12 b7
  155.    READ_ELEMENT_STATUS b8 !!! Think this is in bytes
  156.    READ_GENERATION 29 !!! Could also be M?
  157.    READ_HEADER 44     !!! This was L
  158.    READ_LONG 3e
  159.    READ_POSITION 34   !!! This should be V but conflicts with PRE-FETCH
  160.    READ_REVERSE 0f
  161.    READ_SUB-CHANNEL 42 !!! Is this in bytes?
  162.    READ_TOC 43         !!! Is this in bytes?
  163.    READ_UPDATED_BLOCK 2d
  164.    REASSIGN_BLOCKS 07
  165.    RECEIVE 08        !!! Same as READ_6 probably in bytes though
  166.    RECEIVE_DIAGNOSTIC_RESULTS 1c
  167.    RECOVER_BUFFERED_DATA 14 !!! For PRINTERs this is bytes
  168.    RELEASE_UNIT 17
  169.    REQUEST_SENSE 03
  170.    REQUEST_VOLUME_ELEMENT_ADDRESS b5 !!! Think this is in bytes
  171.    RESERVE_UNIT 16
  172.    REWIND 01
  173.    REZERO_UNIT 01
  174.    SCAN 1b          !!! Conflicts with various commands, should be L
  175.    SEARCH_DATA_EQUAL 31
  176.    SEARCH_DATA_EQUAL_12 b1
  177.    SEARCH_DATA_LOW 30
  178.    SEARCH_DATA_LOW_12 b0
  179.    SEARCH_DATA_HIGH 32
  180.    SEARCH_DATA_HIGH_12 b2
  181.    SEEK_6 0b         !!! Conflicts with SLEW_AND_PRINT
  182.    SEEK_10 2b
  183.    SEND 0a           !!! Same as WRITE_6, probably in bytes though
  184.    SEND 2a           !!! Similar to WRITE_10 but for scanners
  185.    SEND_DIAGNOSTIC 1d
  186.    SEND_MESSAGE_6 0a   !!! Same as WRITE_6 - is in bytes
  187.    SEND_MESSAGE_10 2a  !!! Same as WRITE_10 - is in bytes
  188.    SEND_MESSAGE_12 aa  !!! Same as WRITE_12 - is in bytes
  189.    SEND_OPC 54
  190.    SEND_VOLUME_TAG b6 !!! Think this is in bytes
  191.    SET_LIMITS 33
  192.    SET_LIMITS_12 b3
  193.    SET_WINDOW 24
  194.    SLEW_AND_PRINT 0b !!! Conflicts with SEEK_6
  195.    SPACE 11
  196.    START_STOP_UNIT 1b
  197.    STOP_PRINT 1b
  198.    SYNCHRONIZE_BUFFER 10
  199.    SYNCHRONIZE_CACHE 35
  200.    TEST_UNIT_READY 00
  201.    UPDATE_BLOCK 3d
  202.    VERIFY 13
  203.    VERIFY 2f
  204.    VERIFY_12 af
  205.    WRITE_6 0a
  206.    WRITE_10 2a
  207.    WRITE_12 aa
  208.    WRITE_AND_VERIFY 2e
  209.    WRITE_AND_VERIFY_12 ae
  210.    WRITE_BUFFER 3b
  211.    WRITE_FILEMARKS 10
  212.    WRITE_LONG 3f
  213.    WRITE_SAME 41
  214. */
  216. if (srb->sc_data_direction == SCSI_DATA_WRITE) {
  217. doDefault = 1;
  218. }
  219. else
  220. switch (lengths[srb->cmnd[0]]) {
  221. case 'L':
  222. len = srb->cmnd[4];
  223. break;
  225. case 'M':
  226. len = srb->cmnd[8];
  227. break;
  229. case '0':
  230. case '1':
  231. case '2':
  232. case '3':
  233. case '4':
  234. case '5':
  235. case '6':
  236. case '7':
  237. case '8':
  238. case '9':
  239. len = lengths[srb->cmnd[0]]-'0';
  240. break;
  242. case 'G':
  243. len = (((unsigned int)srb->cmnd[3])<<8) |
  244. srb->cmnd[4];
  245. break;
  247. case 'H':
  248. len = (((unsigned int)srb->cmnd[7])<<8) |
  249. srb->cmnd[8];
  250. break;
  252. case 'I':
  253. len = (((unsigned int)srb->cmnd[8])<<8) |
  254. srb->cmnd[9];
  255. break;
  257. case 'R':
  258. len = (((unsigned int)srb->cmnd[2])<<16) |
  259. (((unsigned int)srb->cmnd[3])<<8) |
  260. srb->cmnd[4];
  261. break;
  263. case 'S':
  264. len = (((unsigned int)srb->cmnd[3])<<16) |
  265. (((unsigned int)srb->cmnd[4])<<8) |
  266. srb->cmnd[5];
  267. break;
  269. case 'T':
  270. len = (((unsigned int)srb->cmnd[6])<<16) |
  271. (((unsigned int)srb->cmnd[7])<<8) |
  272. srb->cmnd[8];
  273. break;
  275. case 'U':
  276. len = (((unsigned int)srb->cmnd[7])<<16) |
  277. (((unsigned int)srb->cmnd[8])<<8) |
  278. srb->cmnd[9];
  279. break;
  281. case 'C':
  282. len = (((unsigned int)srb->cmnd[2])<<24) |
  283. (((unsigned int)srb->cmnd[3])<<16) |
  284. (((unsigned int)srb->cmnd[4])<<8) |
  285. srb->cmnd[5];
  286. break;
  288. case 'D':
  289. len = (((unsigned int)srb->cmnd[6])<<24) |
  290. (((unsigned int)srb->cmnd[7])<<16) |
  291. (((unsigned int)srb->cmnd[8])<<8) |
  292. srb->cmnd[9];
  293. break;
  295. case 'V':
  296. len = 20;
  297. break;
  299. case 'W':
  300. len = 24;
  301. break;
  303. case 'B':
  304. /* Use buffer size due to different block sizes */
  305. doDefault = 1;
  306. break;
  308. case 'X':
  309. US_DEBUGP("Error: UNSUPPORTED COMMAND %02Xn",
  310. srb->cmnd[0]);
  311. doDefault = 1;
  312. break;
  314. case 'Z':
  315. /* Use buffer size due to mode dependence */
  316. doDefault = 1;
  317. break;
  319. default:
  320. US_DEBUGP("Error: COMMAND %02X out of range or table inconsistent (%c).n",
  321. srb->cmnd[0], lengths[srb->cmnd[0]] );
  322. doDefault = 1;
  323. }
  324.    
  325.    if ( doDefault == 1 ) {
  326.    /* Are we going to scatter gather? */
  327.    if (srb->use_sg) {
  328.    /* Add up the sizes of all the sg segments */
  329.    sg = (struct scatterlist *) srb->request_buffer;
  330.    for (i = 0; i < srb->use_sg; i++)
  331.    total += sg[i].length;
  332.    len = total;
  333.    }
  334.    else
  335.    /* Just return the length of the buffer */
  336.    len = srb->request_bufflen;
  337.    }
  339. return len;
  340. }
  342. /***********************************************************************
  343.  * Data transfer routines
  344.  ***********************************************************************/
  346. /* This is the completion handler which will wake us up when an URB
  347.  * completes.
  348.  */
  349. static void usb_stor_blocking_completion(struct urb *urb)
  350. {
  351. struct completion *urb_done_ptr = (struct completion *)urb->context;
  353. complete(urb_done_ptr);
  354. }
  356. /* This is our function to emulate usb_control_msg() but give us enough
  357.  * access to make aborts/resets work
  358.  */
  359. int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
  360.  u8 request, u8 requesttype, u16 value, u16 index, 
  361.  void *data, u16 size)
  362. {
  363. int status;
  364. struct usb_ctrlrequest *dr;
  366. /* allocate the device request structure */
  367. dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
  368. if (!dr)
  369. return -ENOMEM;
  371. /* fill in the structure */
  372. dr->bRequestType = requesttype;
  373. dr->bRequest = request;
  374. dr->wValue = cpu_to_le16(value);
  375. dr->wIndex = cpu_to_le16(index);
  376. dr->wLength = cpu_to_le16(size);
  378. /* set up data structures for the wakeup system */
  379. init_completion(&us->current_done);
  381. /* lock the URB */
  382. down(&(us->current_urb_sem));
  384. /* fill the URB */
  385. FILL_CONTROL_URB(us->current_urb, us->pusb_dev, pipe, 
  386.  (unsigned char*) dr, data, size, 
  387.  usb_stor_blocking_completion, &us->current_done);
  388. us->current_urb->actual_length = 0;
  389. us->current_urb->error_count = 0;
  390. us->current_urb->transfer_flags = USB_ASYNC_UNLINK;
  392. /* submit the URB */
  393. status = usb_submit_urb(us->current_urb);
  394. if (status) {
  395. /* something went wrong */
  396. up(&(us->current_urb_sem));
  397. kfree(dr);
  398. return status;
  399. }
  401. /* wait for the completion of the URB */
  402. up(&(us->current_urb_sem));
  403. wait_for_completion(&us->current_done);
  404. down(&(us->current_urb_sem));
  406. /* return the actual length of the data transferred if no error*/
  407. status = us->current_urb->status;
  408. if (status >= 0)
  409. status = us->current_urb->actual_length;
  411. /* release the lock and return status */
  412. up(&(us->current_urb_sem));
  413. kfree(dr);
  414.    return status;
  415. }
  417. /* This is our function to emulate usb_bulk_msg() but give us enough
  418.  * access to make aborts/resets work
  419.  */
  420. int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe,
  421.       unsigned int len, unsigned int *act_len)
  422. {
  423. int status;
  425. /* set up data structures for the wakeup system */
  426. init_completion(&us->current_done);
  428. /* lock the URB */
  429. down(&(us->current_urb_sem));
  431. /* fill the URB */
  432. FILL_BULK_URB(us->current_urb, us->pusb_dev, pipe, data, len,
  433.       usb_stor_blocking_completion, &us->current_done);
  434. us->current_urb->actual_length = 0;
  435. us->current_urb->error_count = 0;
  436. us->current_urb->transfer_flags = USB_ASYNC_UNLINK;
  438. /* submit the URB */
  439. status = usb_submit_urb(us->current_urb);
  440. if (status) {
  441. /* something went wrong */
  442. up(&(us->current_urb_sem));
  443. return status;
  444. }
  446. /* wait for the completion of the URB */
  447. up(&(us->current_urb_sem));
  448. wait_for_completion(&us->current_done);
  449. down(&(us->current_urb_sem));
  451. /* return the actual length of the data transferred */
  452. *act_len = us->current_urb->actual_length;
  454. /* release the lock and return status */
  455. up(&(us->current_urb_sem));
  456. return us->current_urb->status;
  457. }
  459. /* This is a version of usb_clear_halt() that doesn't read the status from
  460.  * the device -- this is because some devices crash their internal firmware
  461.  * when the status is requested after a halt
  462.  */
  463. int usb_stor_clear_halt(struct us_data *us, int pipe)
  464. {
  465. int result;
  466. int endp = usb_pipeendpoint(pipe) | (usb_pipein(pipe) << 7);
  468. result = usb_stor_control_msg(us,
  469. usb_sndctrlpipe(us->pusb_dev, 0),
  470. USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0,
  471. endp, NULL, 0); /* note: no 3*HZ timeout */
  472. US_DEBUGP("usb_stor_clear_halt: result=%dn", result);
  474. /* this is a failure case */
  475. if (result < 0)
  476. return result;
  478. /* reset the toggles and endpoint flags */
  479. usb_endpoint_running(us->pusb_dev, usb_pipeendpoint(pipe),
  480. usb_pipeout(pipe));
  481. usb_settoggle(us->pusb_dev, usb_pipeendpoint(pipe),
  482. usb_pipeout(pipe), 0);
  484. return 0;
  485. }
  487. /*
  488.  * Transfer one SCSI scatter-gather buffer via bulk transfer
  489.  *
  490.  * Note that this function is necessary because we want the ability to
  491.  * use scatter-gather memory.  Good performance is achieved by a combination
  492.  * of scatter-gather and clustering (which makes each chunk bigger).
  493.  *
  494.  * Note that the lower layer will always retry when a NAK occurs, up to the
  495.  * timeout limit.  Thus we don't have to worry about it for individual
  496.  * packets.
  497.  */
  498. int usb_stor_transfer_partial(struct us_data *us, char *buf, int length)
  499. {
  500. int result;
  501. int partial;
  502. int pipe;
  504. /* calculate the appropriate pipe information */
  505. if (us->srb->sc_data_direction == SCSI_DATA_READ)
  506. pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
  507. else
  508. pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
  510. /* transfer the data */
  511. US_DEBUGP("usb_stor_transfer_partial(): xfer %d bytesn", length);
  512. result = usb_stor_bulk_msg(us, buf, pipe, length, &partial);
  513. US_DEBUGP("usb_stor_bulk_msg() returned %d xferred %d/%dn",
  514.   result, partial, length);
  516. /* if we stall, we need to clear it before we go on */
  517. if (result == -EPIPE) {
  518. US_DEBUGP("clearing endpoint halt for pipe 0x%xn", pipe);
  519. usb_stor_clear_halt(us, pipe);
  520. }
  522. /* did we abort this command? */
  523. if (result == -ENOENT) {
  524. US_DEBUGP("usb_stor_transfer_partial(): transfer abortedn");
  525. return US_BULK_TRANSFER_ABORTED;
  526. }
  528. /* did we send all the data? */
  529. if (partial == length) {
  530. US_DEBUGP("usb_stor_transfer_partial(): transfer completen");
  531. return US_BULK_TRANSFER_GOOD;
  532. }
  534. /* NAK - that means we've retried a few times already */
  535. if (result == -ETIMEDOUT) {
  536. US_DEBUGP("usb_stor_transfer_partial(): device NAKedn");
  537. return US_BULK_TRANSFER_FAILED;
  538. }
  540. /* the catch-all error case */
  541. if (result) {
  542. US_DEBUGP("usb_stor_transfer_partial(): unknown errorn");
  543. return US_BULK_TRANSFER_FAILED;
  544. }
  546. /* no error code, so we must have transferred some data, 
  547.  * just not all of it */
  548. return US_BULK_TRANSFER_SHORT;
  549. }
  551. /*
  552.  * Transfer an entire SCSI command's worth of data payload over the bulk
  553.  * pipe.
  554.  *
  555.  * Note that this uses usb_stor_transfer_partial to achieve its goals -- this
  556.  * function simply determines if we're going to use scatter-gather or not,
  557.  * and acts appropriately.  For now, it also re-interprets the error codes.
  558.  */
  559. void usb_stor_transfer(Scsi_Cmnd *srb, struct us_data* us)
  560. {
  561. int i;
  562. int result = -1;
  563. struct scatterlist *sg;
  564. unsigned int total_transferred = 0;
  565. unsigned int transfer_amount;
  567. /* calculate how much we want to transfer */
  568. transfer_amount = usb_stor_transfer_length(srb);
  570. /* was someone foolish enough to request more data than available
  571.  * buffer space? */
  572. if (transfer_amount > srb->request_bufflen)
  573. transfer_amount = srb->request_bufflen;
  575. /* are we scatter-gathering? */
  576. if (srb->use_sg) {
  578. /* loop over all the scatter gather structures and 
  579.  * make the appropriate requests for each, until done
  580.  */
  581. sg = (struct scatterlist *) srb->request_buffer;
  582. for (i = 0; i < srb->use_sg; i++) {
  584. /* transfer the lesser of the next buffer or the
  585.  * remaining data */
  586. if (transfer_amount - total_transferred >= 
  587. sg[i].length) {
  588. result = usb_stor_transfer_partial(us,
  589. sg[i].address, sg[i].length);
  590. total_transferred += sg[i].length;
  591. } else
  592. result = usb_stor_transfer_partial(us,
  593. sg[i].address,
  594. transfer_amount - total_transferred);
  596. /* if we get an error, end the loop here */
  597. if (result)
  598. break;
  599. }
  600. }
  601. else
  602. /* no scatter-gather, just make the request */
  603. result = usb_stor_transfer_partial(us, srb->request_buffer, 
  604.      transfer_amount);
  606. /* return the result in the data structure itself */
  607. srb->result = result;
  608. }
  610. /***********************************************************************
  611.  * Transport routines
  612.  ***********************************************************************/
  614. /* Invoke the transport and basic error-handling/recovery methods
  615.  *
  616.  * This is used by the protocol layers to actually send the message to
  617.  * the device and receive the response.
  618.  */
  619. void usb_stor_invoke_transport(Scsi_Cmnd *srb, struct us_data *us)
  620. {
  621. int need_auto_sense;
  622. int result;
  624. /* send the command to the transport layer */
  625. result = us->transport(srb, us);
  627. /* if the command gets aborted by the higher layers, we need to
  628.  * short-circuit all other processing
  629.  */
  630. if (result == USB_STOR_TRANSPORT_ABORTED) {
  631. US_DEBUGP("-- transport indicates command was abortedn");
  632. srb->result = DID_ABORT << 16;
  633. return;
  634. }
  636. /* if there is a transport error, reset and don't auto-sense */
  637. if (result == USB_STOR_TRANSPORT_ERROR) {
  638. US_DEBUGP("-- transport indicates error, resettingn");
  639. us->transport_reset(us);
  640. srb->result = DID_ERROR << 16;
  641. return;
  642. }
  644. /* Determine if we need to auto-sense
  645.  *
  646.  * I normally don't use a flag like this, but it's almost impossible
  647.  * to understand what's going on here if I don't.
  648.  */
  649. need_auto_sense = 0;
  651. /*
  652.  * If we're running the CB transport, which is incapable
  653.  * of determining status on it's own, we need to auto-sense almost
  654.  * every time.
  655.  */
  656. if (us->protocol == US_PR_CB || us->protocol == US_PR_DPCM_USB) {
  657. US_DEBUGP("-- CB transport device requiring auto-sensen");
  658. need_auto_sense = 1;
  660. /* There are some exceptions to this.  Notably, if this is
  661.  * a UFI device and the command is REQUEST_SENSE or INQUIRY,
  662.  * then it is impossible to truly determine status.
  663.  */
  664. if (us->subclass == US_SC_UFI &&
  665.     ((srb->cmnd[0] == REQUEST_SENSE) ||
  666.      (srb->cmnd[0] == INQUIRY))) {
  667. US_DEBUGP("** no auto-sense for a special commandn");
  668. need_auto_sense = 0;
  669. }
  670. }
  672. /*
  673.  * If we have a failure, we're going to do a REQUEST_SENSE 
  674.  * automatically.  Note that we differentiate between a command
  675.  * "failure" and an "error" in the transport mechanism.
  676.  */
  677. if (result == USB_STOR_TRANSPORT_FAILED) {
  678. US_DEBUGP("-- transport indicates command failuren");
  679. need_auto_sense = 1;
  680. }
  682. /*
  683.  * Also, if we have a short transfer on a command that can't have
  684.  * a short transfer, we're going to do this.
  685.  */
  686. if ((srb->result == US_BULK_TRANSFER_SHORT) &&
  687.     !((srb->cmnd[0] == REQUEST_SENSE) ||
  688.       (srb->cmnd[0] == INQUIRY) ||
  689.       (srb->cmnd[0] == MODE_SENSE) ||
  690.       (srb->cmnd[0] == LOG_SENSE) ||
  691.       (srb->cmnd[0] == MODE_SENSE_10))) {
  692. US_DEBUGP("-- unexpectedly short transfern");
  693. need_auto_sense = 1;
  694. }
  696. /* Now, if we need to do the auto-sense, let's do it */
  697. if (need_auto_sense) {
  698. int temp_result;
  699. void* old_request_buffer;
  700. unsigned short old_sg;
  701. unsigned old_request_bufflen;
  702. unsigned char old_sc_data_direction;
  703. unsigned char old_cmnd[MAX_COMMAND_SIZE];
  705. US_DEBUGP("Issuing auto-REQUEST_SENSEn");
  707. /* save the old command */
  708. memcpy(old_cmnd, srb->cmnd, MAX_COMMAND_SIZE);
  710. /* set the command and the LUN */
  711. srb->cmnd[0] = REQUEST_SENSE;
  712. srb->cmnd[1] = old_cmnd[1] & 0xE0;
  713. srb->cmnd[2] = 0;
  714. srb->cmnd[3] = 0;
  715. srb->cmnd[4] = 18;
  716. srb->cmnd[5] = 0;
  718. /* set the transfer direction */
  719. old_sc_data_direction = srb->sc_data_direction;
  720. srb->sc_data_direction = SCSI_DATA_READ;
  722. /* use the new buffer we have */
  723. old_request_buffer = srb->request_buffer;
  724. srb->request_buffer = srb->sense_buffer;
  726. /* set the buffer length for transfer */
  727. old_request_bufflen = srb->request_bufflen;
  728. srb->request_bufflen = 18;
  730. /* set up for no scatter-gather use */
  731. old_sg = srb->use_sg;
  732. srb->use_sg = 0;
  734. /* issue the auto-sense command */
  735. temp_result = us->transport(us->srb, us);
  737. /* let's clean up right away */
  738. srb->request_buffer = old_request_buffer;
  739. srb->request_bufflen = old_request_bufflen;
  740. srb->use_sg = old_sg;
  741. srb->sc_data_direction = old_sc_data_direction;
  742. memcpy(srb->cmnd, old_cmnd, MAX_COMMAND_SIZE);
  744. if (temp_result == USB_STOR_TRANSPORT_ABORTED) {
  745. US_DEBUGP("-- auto-sense abortedn");
  746. srb->result = DID_ABORT << 16;
  747. return;
  748. }
  749. if (temp_result != USB_STOR_TRANSPORT_GOOD) {
  750. US_DEBUGP("-- auto-sense failuren");
  752. /* we skip the reset if this happens to be a
  753.  * multi-target device, since failure of an
  754.  * auto-sense is perfectly valid
  755.  */
  756. if (!(us->flags & US_FL_SCM_MULT_TARG)) {
  757. us->transport_reset(us);
  758. }
  759. srb->result = DID_ERROR << 16;
  760. return;
  761. }
  763. US_DEBUGP("-- Result from auto-sense is %dn", temp_result);
  764. US_DEBUGP("-- code: 0x%x, key: 0x%x, ASC: 0x%x, ASCQ: 0x%xn",
  765.   srb->sense_buffer[0],
  766.   srb->sense_buffer[2] & 0xf,
  767.   srb->sense_buffer[12], 
  768.   srb->sense_buffer[13]);
  769. #ifdef CONFIG_USB_STORAGE_DEBUG
  770. usb_stor_show_sense(
  771.   srb->sense_buffer[2] & 0xf,
  772.   srb->sense_buffer[12], 
  773.   srb->sense_buffer[13]);
  774. #endif
  776. /* set the result so the higher layers expect this data */
  777. srb->result = CHECK_CONDITION << 1;
  779. /* If things are really okay, then let's show that */
  780. if ((srb->sense_buffer[2] & 0xf) == 0x0)
  781. srb->result = GOOD << 1;
  782. } else /* if (need_auto_sense) */
  783. srb->result = GOOD << 1;
  785. /* Regardless of auto-sense, if we _know_ we have an error
  786.  * condition, show that in the result code
  787.  */
  788. if (result == USB_STOR_TRANSPORT_FAILED)
  789. srb->result = CHECK_CONDITION << 1;
  791. /* If we think we're good, then make sure the sense data shows it.
  792.  * This is necessary because the auto-sense for some devices always
  793.  * sets byte 0 == 0x70, even if there is no error
  794.  */
  795. if ((us->protocol == US_PR_CB || us->protocol == US_PR_DPCM_USB) && 
  796.     (result == USB_STOR_TRANSPORT_GOOD) &&
  797.     ((srb->sense_buffer[2] & 0xf) == 0x0))
  798. srb->sense_buffer[0] = 0x0;
  799. }
  801. /*
  802.  * Control/Bulk/Interrupt transport
  803.  */
  805. /* The interrupt handler for CBI devices */
  806. void usb_stor_CBI_irq(struct urb *urb)
  807. {
  808. struct us_data *us = (struct us_data *)urb->context;
  810. US_DEBUGP("USB IRQ received for device on host %dn", us->host_no);
  811. US_DEBUGP("-- IRQ data length is %dn", urb->actual_length);
  812. US_DEBUGP("-- IRQ state is %dn", urb->status);
  813. US_DEBUGP("-- Interrupt Status (0x%x, 0x%x)n",
  814. us->irqbuf[0], us->irqbuf[1]);
  816. /* reject improper IRQs */
  817. if (urb->actual_length != 2) {
  818. US_DEBUGP("-- IRQ too shortn");
  819. return;
  820. }
  822. /* is the device removed? */
  823. if (urb->status == -ENOENT) {
  824. US_DEBUGP("-- device has been removedn");
  825. return;
  826. }
  828. /* was this a command-completion interrupt? */
  829. if (us->irqbuf[0] && (us->subclass != US_SC_UFI)) {
  830. US_DEBUGP("-- not a command-completion IRQn");
  831. return;
  832. }
  834. /* was this a wanted interrupt? */
  835. if (!atomic_read(us->ip_wanted)) {
  836. US_DEBUGP("ERROR: Unwanted interrupt received!n");
  837. return;
  838. }
  840. /* adjust the flag */
  841. atomic_set(us->ip_wanted, 0);
  843. /* copy the valid data */
  844. us->irqdata[0] = us->irqbuf[0];
  845. us->irqdata[1] = us->irqbuf[1];
  847. /* wake up the command thread */
  848. US_DEBUGP("-- Current value of ip_waitq is: %dn",
  849. atomic_read(&us->ip_waitq.count));
  850. up(&(us->ip_waitq));
  851. }
  853. int usb_stor_CBI_transport(Scsi_Cmnd *srb, struct us_data *us)
  854. {
  855. int result;
  857. /* Set up for status notification */
  858. atomic_set(us->ip_wanted, 1);
  860. /* re-initialize the mutex so that we avoid any races with
  861.  * early/late IRQs from previous commands */
  862. init_MUTEX_LOCKED(&(us->ip_waitq));
  864. /* COMMAND STAGE */
  865. /* let's send the command via the control pipe */
  866. result = usb_stor_control_msg(us, usb_sndctrlpipe(us->pusb_dev,0),
  867.       US_CBI_ADSC, 
  868.       USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, 
  869.       us->ifnum, srb->cmnd, srb->cmd_len);
  871. /* check the return code for the command */
  872. US_DEBUGP("Call to usb_stor_control_msg() returned %dn", result);
  873. if (result < 0) {
  874. /* Reset flag for status notification */
  875. atomic_set(us->ip_wanted, 0);
  876. }
  878. /* if the command was aborted, indicate that */
  879. if (result == -ENOENT)
  880. return USB_STOR_TRANSPORT_ABORTED;
  882. /* STALL must be cleared when it is detected */
  883. if (result == -EPIPE) {
  884. US_DEBUGP("-- Stall on control pipe. Clearingn");
  885. result = usb_stor_clear_halt(us,
  886. usb_sndctrlpipe(us->pusb_dev, 0));
  888. /* if the command was aborted, indicate that */
  889. if (result == -ENOENT)
  890. return USB_STOR_TRANSPORT_ABORTED;
  891. return USB_STOR_TRANSPORT_FAILED;
  892. }
  894. if (result < 0) {
  895. /* Uh oh... serious problem here */
  896. return USB_STOR_TRANSPORT_ERROR;
  897. }
  899. /* DATA STAGE */
  900. /* transfer the data payload for this command, if one exists*/
  901. if (usb_stor_transfer_length(srb)) {
  902. usb_stor_transfer(srb, us);
  903. result = srb->result;
  904. US_DEBUGP("CBI data stage result is 0x%xn", result);
  906. /* report any errors */
  907. if (result == US_BULK_TRANSFER_ABORTED) {
  908. atomic_set(us->ip_wanted, 0);
  909. return USB_STOR_TRANSPORT_ABORTED;
  910. }
  911. if (result == US_BULK_TRANSFER_FAILED) {
  912. atomic_set(us->ip_wanted, 0);
  913. return USB_STOR_TRANSPORT_FAILED;
  914. }
  915. }
  917. /* STATUS STAGE */
  919. /* go to sleep until we get this interrupt */
  920. US_DEBUGP("Current value of ip_waitq is: %dn", atomic_read(&us->ip_waitq.count));
  921. down(&(us->ip_waitq));
  923. /* if we were woken up by an abort instead of the actual interrupt */
  924. if (atomic_read(us->ip_wanted)) {
  925. US_DEBUGP("Did not get interrupt on CBIn");
  926. atomic_set(us->ip_wanted, 0);
  927. return USB_STOR_TRANSPORT_ABORTED;
  928. }
  930. US_DEBUGP("Got interrupt data (0x%x, 0x%x)n", 
  931. us->irqdata[0], us->irqdata[1]);
  933. /* UFI gives us ASC and ASCQ, like a request sense
  934.  *
  935.  * REQUEST_SENSE and INQUIRY don't affect the sense data on UFI
  936.  * devices, so we ignore the information for those commands.  Note
  937.  * that this means we could be ignoring a real error on these
  938.  * commands, but that can't be helped.
  939.  */
  940. if (us->subclass == US_SC_UFI) {
  941. if (srb->cmnd[0] == REQUEST_SENSE ||
  942.     srb->cmnd[0] == INQUIRY)
  943. return USB_STOR_TRANSPORT_GOOD;
  944. else
  945. if (((unsigned char*)us->irq_urb->transfer_buffer)[0])
  946. return USB_STOR_TRANSPORT_FAILED;
  947. else
  948. return USB_STOR_TRANSPORT_GOOD;
  949. }
  951. /* If not UFI, we interpret the data as a result code 
  952.  * The first byte should always be a 0x0
  953.  * The second byte & 0x0F should be 0x0 for good, otherwise error 
  954.  */
  955. if (us->irqdata[0]) {
  956. US_DEBUGP("CBI IRQ data showed reserved bType %dn",
  957. us->irqdata[0]);
  958. return USB_STOR_TRANSPORT_ERROR;
  959. }
  961. switch (us->irqdata[1] & 0x0F) {
  962. case 0x00: 
  963. return USB_STOR_TRANSPORT_GOOD;
  964. case 0x01: 
  965. return USB_STOR_TRANSPORT_FAILED;
  966. default: 
  967. return USB_STOR_TRANSPORT_ERROR;
  968. }
  970. /* we should never get here, but if we do, we're in trouble */
  971. return USB_STOR_TRANSPORT_ERROR;
  972. }
  974. /*
  975.  * Control/Bulk transport
  976.  */
  977. int usb_stor_CB_transport(Scsi_Cmnd *srb, struct us_data *us)
  978. {
  979. int result;
  981. /* COMMAND STAGE */
  982. /* let's send the command via the control pipe */
  983. result = usb_stor_control_msg(us, usb_sndctrlpipe(us->pusb_dev,0),
  984.       US_CBI_ADSC, 
  985.       USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, 
  986.       us->ifnum, srb->cmnd, srb->cmd_len);
  988. /* check the return code for the command */
  989. US_DEBUGP("Call to usb_stor_control_msg() returned %dn", result);
  990. if (result < 0) {
  991. /* if the command was aborted, indicate that */
  992. if (result == -ENOENT)
  993. return USB_STOR_TRANSPORT_ABORTED;
  995. /* a stall is a fatal condition from the device */
  996. if (result == -EPIPE) {
  997. US_DEBUGP("-- Stall on control pipe. Clearingn");
  998. result = usb_stor_clear_halt(us,
  999. usb_sndctrlpipe(us->pusb_dev, 0));
  1001. /* if the command was aborted, indicate that */
  1002. if (result == -ENOENT)
  1003. return USB_STOR_TRANSPORT_ABORTED;
  1004. return USB_STOR_TRANSPORT_FAILED;
  1005. }
  1007. /* Uh oh... serious problem here */
  1008. return USB_STOR_TRANSPORT_ERROR;
  1009. }
  1011. /* DATA STAGE */
  1012. /* transfer the data payload for this command, if one exists*/
  1013. if (usb_stor_transfer_length(srb)) {
  1014. usb_stor_transfer(srb, us);
  1015. result = srb->result;
  1016. US_DEBUGP("CB data stage result is 0x%xn", result);
  1018. /* report any errors */
  1019. if (result == US_BULK_TRANSFER_ABORTED) {
  1020. return USB_STOR_TRANSPORT_ABORTED;
  1021. }
  1022. if (result == US_BULK_TRANSFER_FAILED) {
  1023. return USB_STOR_TRANSPORT_FAILED;
  1024. }
  1025. }
  1027. /* STATUS STAGE */
  1028. /* NOTE: CB does not have a status stage.  Silly, I know.  So
  1029.  * we have to catch this at a higher level.
  1030.  */
  1031. return USB_STOR_TRANSPORT_GOOD;
  1032. }
  1034. /*
  1035.  * Bulk only transport
  1036.  */
  1038. /* Determine what the maximum LUN supported is */
  1039. int usb_stor_Bulk_max_lun(struct us_data *us)
  1040. {
  1041. unsigned char *data;
  1042. int result;
  1043. int pipe;
  1045. data = kmalloc(sizeof *data, GFP_KERNEL);
  1046. if (!data) {
  1047. return 0;
  1048. }
  1050. /* issue the command -- use usb_control_msg() because
  1051.  *  the state machine is not yet alive */
  1052. pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
  1053. result = usb_control_msg(us->pusb_dev, pipe,
  1054.  US_BULK_GET_MAX_LUN, 
  1055.  USB_DIR_IN | USB_TYPE_CLASS | 
  1056.  USB_RECIP_INTERFACE,
  1057.  0, us->ifnum, data, sizeof(data), HZ);
  1059. US_DEBUGP("GetMaxLUN command result is %d, data is %dn", 
  1060.   result, *data);
  1062. /* if we have a successful request, return the result */
  1063. if (result == 1) {
  1064. result = *data;
  1065. kfree(data);
  1066. return result;
  1067. } else {
  1068. kfree(data);
  1069. }
  1071. /* if we get a STALL, clear the stall */
  1072. if (result == -EPIPE) {
  1073. US_DEBUGP("clearing endpoint halt for pipe 0x%xn", pipe);
  1075. /* Use usb_clear_halt() because the state machine
  1076.  *  is not yet alive */
  1077. usb_clear_halt(us->pusb_dev, pipe);
  1078. }
  1080. /* return the default -- no LUNs */
  1081. return 0;
  1082. }
  1084. int usb_stor_Bulk_reset(struct us_data *us);
  1086. int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us)
  1087. {
  1088. struct bulk_cb_wrap *bcb;
  1089. struct bulk_cs_wrap *bcs;
  1090. int result;
  1091. int pipe;
  1092. int partial;
  1093. int ret = USB_STOR_TRANSPORT_ERROR;
  1095. bcb = kmalloc(sizeof *bcb, in_interrupt() ? GFP_ATOMIC : GFP_NOIO);
  1096. if (!bcb) {
  1097. return USB_STOR_TRANSPORT_ERROR;
  1098. }
  1099. bcs = kmalloc(sizeof *bcs, in_interrupt() ? GFP_ATOMIC : GFP_NOIO);
  1100. if (!bcs) {
  1101. kfree(bcb);
  1102. return USB_STOR_TRANSPORT_ERROR;
  1103. }
  1105. /* set up the command wrapper */
  1106. bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
  1107. bcb->DataTransferLength = cpu_to_le32(usb_stor_transfer_length(srb));
  1108. bcb->Flags = srb->sc_data_direction == SCSI_DATA_READ ? 1 << 7 : 0;
  1109. bcb->Tag = srb->serial_number;
  1110. bcb->Lun = srb->cmnd[1] >> 5;
  1111. if (us->flags & US_FL_SCM_MULT_TARG)
  1112. bcb->Lun |= srb->target << 4;
  1113. bcb->Length = srb->cmd_len;
  1115. /* construct the pipe handle */
  1116. pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
  1118. /* copy the command payload */
  1119. memset(bcb->CDB, 0, sizeof(bcb->CDB));
  1120. memcpy(bcb->CDB, srb->cmnd, bcb->Length);
  1122. /* send it to out endpoint */
  1123. US_DEBUGP("Bulk command S 0x%x T 0x%x Trg %d LUN %d L %d F %d CL %dn",
  1124.   le32_to_cpu(bcb->Signature), bcb->Tag,
  1125.   (bcb->Lun >> 4), (bcb->Lun & 0x0F), 
  1126.   bcb->DataTransferLength, bcb->Flags, bcb->Length);
  1127. result = usb_stor_bulk_msg(us, bcb, pipe, US_BULK_CB_WRAP_LEN, 
  1128.    &partial);
  1129. US_DEBUGP("Bulk command transfer result=%dn", result);
  1131. /* if the command was aborted, indicate that */
  1132. if (result == -ENOENT) {
  1133. ret = USB_STOR_TRANSPORT_ABORTED;
  1134. goto out;
  1135. }
  1137. /* if we stall, we need to clear it before we go on */
  1138. if (result == -EPIPE) {
  1139. US_DEBUGP("clearing endpoint halt for pipe 0x%xn", pipe);
  1140. result = usb_stor_clear_halt(us, pipe);
  1142. /* if the command was aborted, indicate that */
  1143. if (result == -ENOENT) {
  1144. ret = USB_STOR_TRANSPORT_ABORTED;
  1145. goto out;
  1146. }
  1147. result = -EPIPE;
  1148. } else if (result) {
  1149. /* unknown error -- we've got a problem */
  1150. ret = USB_STOR_TRANSPORT_ERROR;
  1151. goto out;
  1152. }
  1154. /* if the command transfered well, then we go to the data stage */
  1155. if (result == 0) {
  1156. /* send/receive data payload, if there is any */
  1157. if (bcb->DataTransferLength) {
  1158. usb_stor_transfer(srb, us);
  1159. result = srb->result;
  1160. US_DEBUGP("Bulk data transfer result 0x%xn", result);
  1162. /* if it was aborted, we need to indicate that */
  1163. if (result == US_BULK_TRANSFER_ABORTED) {
  1164. ret = USB_STOR_TRANSPORT_ABORTED;
  1165. goto out;
  1166. }
  1167. }
  1168. }
  1170. /* See flow chart on pg 15 of the Bulk Only Transport spec for
  1171.  * an explanation of how this code works.
  1172.  */
  1174. /* construct the pipe handle */
  1175. pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
  1177. /* get CSW for device status */
  1178. US_DEBUGP("Attempting to get CSW...n");
  1179. result = usb_stor_bulk_msg(us, bcs, pipe, US_BULK_CS_WRAP_LEN, 
  1180.    &partial);
  1182. /* if the command was aborted, indicate that */
  1183. if (result == -ENOENT) {
  1184. ret = USB_STOR_TRANSPORT_ABORTED;
  1185. goto out;
  1186. }
  1188. /* did the attempt to read the CSW fail? */
  1189. if (result == -EPIPE) {
  1190. US_DEBUGP("clearing endpoint halt for pipe 0x%xn", pipe);
  1191. result = usb_stor_clear_halt(us, pipe);
  1193. /* if the command was aborted, indicate that */
  1194. if (result == -ENOENT) {
  1195. ret = USB_STOR_TRANSPORT_ABORTED;
  1196. goto out;
  1197. }
  1199. /* get the status again */
  1200. US_DEBUGP("Attempting to get CSW (2nd try)...n");
  1201. result = usb_stor_bulk_msg(us, bcs, pipe,
  1202.    US_BULK_CS_WRAP_LEN, &partial);
  1204. /* if the command was aborted, indicate that */
  1205. if (result == -ENOENT) {
  1206. ret = USB_STOR_TRANSPORT_ABORTED;
  1207. goto out;
  1208. }
  1210. /* if it fails again, we need a reset and return an error*/
  1211. if (result == -EPIPE) {
  1212. US_DEBUGP("clearing halt for pipe 0x%xn", pipe);
  1213. result = usb_stor_clear_halt(us, pipe);
  1215. /* if the command was aborted, indicate that */
  1216. if (result == -ENOENT) {
  1217. ret = USB_STOR_TRANSPORT_ABORTED;
  1218. } else {
  1219. ret = USB_STOR_TRANSPORT_ERROR;
  1220. }
  1221. goto out;
  1222. }
  1223. }
  1225. /* if we still have a failure at this point, we're in trouble */
  1226. US_DEBUGP("Bulk status result = %dn", result);
  1227. if (result) {
  1228. ret = USB_STOR_TRANSPORT_ERROR;
  1229. goto out;
  1230. }
  1232. /* check bulk status */
  1233. US_DEBUGP("Bulk status Sig 0x%x T 0x%x R %d Stat 0x%xn",
  1234.   le32_to_cpu(bcs->Signature), bcs->Tag, 
  1235.   bcs->Residue, bcs->Status);
  1236. if (bcs->Signature != cpu_to_le32(US_BULK_CS_SIGN) || 
  1237.     bcs->Tag != bcb->Tag || 
  1238.     bcs->Status > US_BULK_STAT_PHASE || partial != 13) {
  1239. US_DEBUGP("Bulk logical errorn");
  1240. ret = USB_STOR_TRANSPORT_ERROR;
  1241. goto out;
  1242. }
  1244. /* based on the status code, we report good or bad */
  1245. switch (bcs->Status) {
  1246. case US_BULK_STAT_OK:
  1247. /* command good -- note that data could be short */
  1248. ret = USB_STOR_TRANSPORT_GOOD;
  1249. goto out;
  1251. case US_BULK_STAT_FAIL:
  1252. /* command failed */
  1253. ret = USB_STOR_TRANSPORT_FAILED;
  1254. goto out;
  1256. case US_BULK_STAT_PHASE:
  1257. /* phase error -- note that a transport reset will be
  1258.  * invoked by the invoke_transport() function
  1259.  */
  1260. ret = USB_STOR_TRANSPORT_ERROR;
  1261. goto out;
  1262. }
  1264. /* we should never get here, but if we do, we're in trouble */
  1266.  out:
  1267. kfree(bcb);
  1268. kfree(bcs);
  1269. return ret;
  1270. }
  1272. /***********************************************************************
  1273.  * Reset routines
  1274.  ***********************************************************************/
  1276. /* This issues a CB[I] Reset to the device in question
  1277.  */
  1278. int usb_stor_CB_reset(struct us_data *us)
  1279. {
  1280. unsigned char cmd[12];
  1281. int result;
  1283. US_DEBUGP("CB_reset() calledn");
  1285. /* if the device was removed, then we're already reset */
  1286. if (!us->pusb_dev)
  1287. return SUCCESS;
  1289. memset(cmd, 0xFF, sizeof(cmd));
  1290. cmd[0] = SEND_DIAGNOSTIC;
  1291. cmd[1] = 4;
  1292. result = usb_control_msg(us->pusb_dev, usb_sndctrlpipe(us->pusb_dev,0),
  1293.  US_CBI_ADSC, 
  1294.  USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  1295.  0, us->ifnum, cmd, sizeof(cmd), HZ*5);
  1297. if (result < 0) {
  1298. US_DEBUGP("CB[I] soft reset failed %dn", result);
  1299. return FAILED;
  1300. }
  1302. /* long wait for reset */
  1303. set_current_state(TASK_UNINTERRUPTIBLE);
  1304. schedule_timeout(HZ*6);
  1305. set_current_state(TASK_RUNNING);
  1307. US_DEBUGP("CB_reset: clearing endpoint haltn");
  1308. usb_stor_clear_halt(us,
  1309. usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
  1310. usb_stor_clear_halt(us,
  1311. usb_sndbulkpipe(us->pusb_dev, us->ep_out));
  1313. US_DEBUGP("CB_reset donen");
  1314. /* return a result code based on the result of the control message */
  1315. return SUCCESS;
  1316. }
  1318. /* This issues a Bulk-only Reset to the device in question, including
  1319.  * clearing the subsequent endpoint halts that may occur.
  1320.  */
  1321. int usb_stor_Bulk_reset(struct us_data *us)
  1322. {
  1323. int result;
  1325. US_DEBUGP("Bulk reset requestedn");
  1327. /* if the device was removed, then we're already reset */
  1328. if (!us->pusb_dev)
  1329. return SUCCESS;
  1331. result = usb_control_msg(us->pusb_dev, 
  1332.  usb_sndctrlpipe(us->pusb_dev,0), 
  1333.  US_BULK_RESET_REQUEST, 
  1334.  USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  1335.  0, us->ifnum, NULL, 0, HZ*5);
  1337. if (result < 0) {
  1338. US_DEBUGP("Bulk soft reset failed %dn", result);
  1339. return FAILED;
  1340. }
  1342. /* long wait for reset */
  1343. set_current_state(TASK_UNINTERRUPTIBLE);
  1344. schedule_timeout(HZ*6);
  1345. set_current_state(TASK_RUNNING);
  1347. usb_stor_clear_halt(us,
  1348. usb_rcvbulkpipe(us->pusb_dev, us->ep_in));
  1349. usb_stor_clear_halt(us,
  1350. usb_sndbulkpipe(us->pusb_dev, us->ep_out));
  1351. US_DEBUGP("Bulk soft reset completedn");
  1352. return SUCCESS;
  1353. }