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) 2002 Alan Stern (stern@rowland.org)
      11                 :            :  *
      12                 :            :  * Initial work by:
      13                 :            :  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
      14                 :            :  *
      15                 :            :  * This driver is based on the 'USB Mass Storage Class' document. This
      16                 :            :  * describes in detail the protocol used to communicate with such
      17                 :            :  * devices.  Clearly, the designers had SCSI and ATAPI commands in
      18                 :            :  * mind when they created this document.  The commands are all very
      19                 :            :  * similar to commands in the SCSI-II and ATAPI specifications.
      20                 :            :  *
      21                 :            :  * It is important to note that in a number of cases this class
      22                 :            :  * exhibits class-specific exemptions from the USB specification.
      23                 :            :  * Notably the usage of NAK, STALL and ACK differs from the norm, in
      24                 :            :  * that they are used to communicate wait, failed and OK on commands.
      25                 :            :  *
      26                 :            :  * Also, for certain devices, the interrupt endpoint is used to convey
      27                 :            :  * status of a command.
      28                 :            :  */
      29                 :            : 
      30                 :            : #include <linux/highmem.h>
      31                 :            : #include <linux/export.h>
      32                 :            : #include <scsi/scsi.h>
      33                 :            : #include <scsi/scsi_cmnd.h>
      34                 :            : 
      35                 :            : #include "usb.h"
      36                 :            : #include "protocol.h"
      37                 :            : #include "debug.h"
      38                 :            : #include "scsiglue.h"
      39                 :            : #include "transport.h"
      40                 :            : 
      41                 :            : /***********************************************************************
      42                 :            :  * Protocol routines
      43                 :            :  ***********************************************************************/
      44                 :            : 
      45                 :          0 : void usb_stor_pad12_command(struct scsi_cmnd *srb, struct us_data *us)
      46                 :            : {
      47                 :            :         /*
      48                 :            :          * Pad the SCSI command with zeros out to 12 bytes.  If the
      49                 :            :          * command already is 12 bytes or longer, leave it alone.
      50                 :            :          *
      51                 :            :          * NOTE: This only works because a scsi_cmnd struct field contains
      52                 :            :          * a unsigned char cmnd[16], so we know we have storage available
      53                 :            :          */
      54                 :          0 :         for (; srb->cmd_len < 12; srb->cmd_len++)
      55                 :          0 :                 srb->cmnd[srb->cmd_len] = 0;
      56                 :            : 
      57                 :            :         /* send the command to the transport layer */
      58                 :          0 :         usb_stor_invoke_transport(srb, us);
      59                 :          0 : }
      60                 :            : 
      61                 :          0 : void usb_stor_ufi_command(struct scsi_cmnd *srb, struct us_data *us)
      62                 :            : {
      63                 :            :         /*
      64                 :            :          * fix some commands -- this is a form of mode translation
      65                 :            :          * UFI devices only accept 12 byte long commands
      66                 :            :          *
      67                 :            :          * NOTE: This only works because a scsi_cmnd struct field contains
      68                 :            :          * a unsigned char cmnd[16], so we know we have storage available
      69                 :            :          */
      70                 :            : 
      71                 :            :         /* Pad the ATAPI command with zeros */
      72                 :          0 :         for (; srb->cmd_len < 12; srb->cmd_len++)
      73                 :          0 :                 srb->cmnd[srb->cmd_len] = 0;
      74                 :            : 
      75                 :            :         /* set command length to 12 bytes (this affects the transport layer) */
      76                 :          0 :         srb->cmd_len = 12;
      77                 :            : 
      78                 :            :         /* XXX We should be constantly re-evaluating the need for these */
      79                 :            : 
      80                 :            :         /* determine the correct data length for these commands */
      81                 :          0 :         switch (srb->cmnd[0]) {
      82                 :            : 
      83                 :            :                 /* for INQUIRY, UFI devices only ever return 36 bytes */
      84                 :            :         case INQUIRY:
      85                 :          0 :                 srb->cmnd[4] = 36;
      86                 :          0 :                 break;
      87                 :            : 
      88                 :            :                 /* again, for MODE_SENSE_10, we get the minimum (8) */
      89                 :            :         case MODE_SENSE_10:
      90                 :          0 :                 srb->cmnd[7] = 0;
      91                 :          0 :                 srb->cmnd[8] = 8;
      92                 :          0 :                 break;
      93                 :            : 
      94                 :            :                 /* for REQUEST_SENSE, UFI devices only ever return 18 bytes */
      95                 :            :         case REQUEST_SENSE:
      96                 :          0 :                 srb->cmnd[4] = 18;
      97                 :          0 :                 break;
      98                 :            :         } /* end switch on cmnd[0] */
      99                 :            : 
     100                 :            :         /* send the command to the transport layer */
     101                 :          0 :         usb_stor_invoke_transport(srb, us);
     102                 :          0 : }
     103                 :            : 
     104                 :          0 : void usb_stor_transparent_scsi_command(struct scsi_cmnd *srb,
     105                 :            :                                        struct us_data *us)
     106                 :            : {
     107                 :            :         /* send the command to the transport layer */
     108                 :          0 :         usb_stor_invoke_transport(srb, us);
     109                 :          0 : }
     110                 :            : EXPORT_SYMBOL_GPL(usb_stor_transparent_scsi_command);
     111                 :            : 
     112                 :            : /***********************************************************************
     113                 :            :  * Scatter-gather transfer buffer access routines
     114                 :            :  ***********************************************************************/
     115                 :            : 
     116                 :            : /*
     117                 :            :  * Copy a buffer of length buflen to/from the srb's transfer buffer.
     118                 :            :  * Update the **sgptr and *offset variables so that the next copy will
     119                 :            :  * pick up from where this one left off.
     120                 :            :  */
     121                 :          0 : unsigned int usb_stor_access_xfer_buf(unsigned char *buffer,
     122                 :            :         unsigned int buflen, struct scsi_cmnd *srb, struct scatterlist **sgptr,
     123                 :            :         unsigned int *offset, enum xfer_buf_dir dir)
     124                 :            : {
     125                 :            :         unsigned int cnt = 0;
     126                 :          0 :         struct scatterlist *sg = *sgptr;
     127                 :            :         struct sg_mapping_iter miter;
     128                 :            :         unsigned int nents = scsi_sg_count(srb);
     129                 :            : 
     130                 :          0 :         if (sg)
     131                 :          0 :                 nents = sg_nents(sg);
     132                 :            :         else
     133                 :            :                 sg = scsi_sglist(srb);
     134                 :            : 
     135                 :          0 :         sg_miter_start(&miter, sg, nents, dir == FROM_XFER_BUF ?
     136                 :            :                 SG_MITER_FROM_SG: SG_MITER_TO_SG);
     137                 :            : 
     138                 :          0 :         if (!sg_miter_skip(&miter, *offset))
     139                 :            :                 return cnt;
     140                 :            : 
     141                 :          0 :         while (sg_miter_next(&miter) && cnt < buflen) {
     142                 :          0 :                 unsigned int len = min_t(unsigned int, miter.length,
     143                 :            :                                 buflen - cnt);
     144                 :            : 
     145                 :          0 :                 if (dir == FROM_XFER_BUF)
     146                 :          0 :                         memcpy(buffer + cnt, miter.addr, len);
     147                 :            :                 else
     148                 :          0 :                         memcpy(miter.addr, buffer + cnt, len);
     149                 :            : 
     150                 :          0 :                 if (*offset + len < miter.piter.sg->length) {
     151                 :          0 :                         *offset += len;
     152                 :          0 :                         *sgptr = miter.piter.sg;
     153                 :            :                 } else {
     154                 :          0 :                         *offset = 0;
     155                 :          0 :                         *sgptr = sg_next(miter.piter.sg);
     156                 :            :                 }
     157                 :          0 :                 cnt += len;
     158                 :            :         }
     159                 :          0 :         sg_miter_stop(&miter);
     160                 :            : 
     161                 :          0 :         return cnt;
     162                 :            : }
     163                 :            : EXPORT_SYMBOL_GPL(usb_stor_access_xfer_buf);
     164                 :            : 
     165                 :            : /*
     166                 :            :  * Store the contents of buffer into srb's transfer buffer and set the
     167                 :            :  * SCSI residue.
     168                 :            :  */
     169                 :          0 : void usb_stor_set_xfer_buf(unsigned char *buffer,
     170                 :            :         unsigned int buflen, struct scsi_cmnd *srb)
     171                 :            : {
     172                 :          0 :         unsigned int offset = 0;
     173                 :          0 :         struct scatterlist *sg = NULL;
     174                 :            : 
     175                 :          0 :         buflen = min(buflen, scsi_bufflen(srb));
     176                 :          0 :         buflen = usb_stor_access_xfer_buf(buffer, buflen, srb, &sg, &offset,
     177                 :            :                         TO_XFER_BUF);
     178                 :          0 :         if (buflen < scsi_bufflen(srb))
     179                 :          0 :                 scsi_set_resid(srb, scsi_bufflen(srb) - buflen);
     180                 :          0 : }
     181                 :            : EXPORT_SYMBOL_GPL(usb_stor_set_xfer_buf);