LCOV - code coverage report
Current view: top level - drivers/usb/storage - transport.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 336 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 21 0.0 %
Branches: 0 276 0.0 %

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

Generated by: LCOV version 1.14