LCOV - code coverage report
Current view: top level - lkbce/drivers/usb/storage - protocol.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 80 0.0 %
Date: 2017-01-25 Functions: 0 5 0.0 %

          Line data    Source code
       1             : /* Driver for USB Mass Storage compliant devices
       2             :  *
       3             :  * Current development and maintenance by:
       4             :  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
       5             :  *
       6             :  * Developed with the assistance of:
       7             :  *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
       8             :  *   (c) 2002 Alan Stern (stern@rowland.org)
       9             :  *
      10             :  * Initial work by:
      11             :  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
      12             :  *
      13             :  * This driver is based on the 'USB Mass Storage Class' document. This
      14             :  * describes in detail the protocol used to communicate with such
      15             :  * devices.  Clearly, the designers had SCSI and ATAPI commands in
      16             :  * mind when they created this document.  The commands are all very
      17             :  * similar to commands in the SCSI-II and ATAPI specifications.
      18             :  *
      19             :  * It is important to note that in a number of cases this class
      20             :  * exhibits class-specific exemptions from the USB specification.
      21             :  * Notably the usage of NAK, STALL and ACK differs from the norm, in
      22             :  * that they are used to communicate wait, failed and OK on commands.
      23             :  *
      24             :  * Also, for certain devices, the interrupt endpoint is used to convey
      25             :  * status of a command.
      26             :  *
      27             :  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
      28             :  * information about this driver.
      29             :  *
      30             :  * This program is free software; you can redistribute it and/or modify it
      31             :  * under the terms of the GNU General Public License as published by the
      32             :  * Free Software Foundation; either version 2, or (at your option) any
      33             :  * later version.
      34             :  *
      35             :  * This program is distributed in the hope that it will be useful, but
      36             :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      37             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      38             :  * General Public License for more details.
      39             :  *
      40             :  * You should have received a copy of the GNU General Public License along
      41             :  * with this program; if not, write to the Free Software Foundation, Inc.,
      42             :  * 675 Mass Ave, Cambridge, MA 02139, USA.
      43             :  */
      44             : 
      45             : #include <linux/highmem.h>
      46             : #include <scsi/scsi.h>
      47             : #include <scsi/scsi_cmnd.h>
      48             : 
      49             : #include "usb.h"
      50             : #include "protocol.h"
      51             : #include "debug.h"
      52             : #include "scsiglue.h"
      53             : #include "transport.h"
      54             : 
      55             : /***********************************************************************
      56             :  * Protocol routines
      57             :  ***********************************************************************/
      58             : 
      59             : void usb_stor_pad12_command(struct scsi_cmnd *srb, struct us_data *us)
      60             : {
      61             :         /* Pad the SCSI command with zeros out to 12 bytes
      62             :          *
      63             :          * NOTE: This only works because a scsi_cmnd struct field contains
      64             :          * a unsigned char cmnd[16], so we know we have storage available
      65             :          */
      66           0 :         for (; srb->cmd_len<12; srb->cmd_len++)
      67           0 :                 srb->cmnd[srb->cmd_len] = 0;
      68           0 : 
      69             :         /* set command length to 12 bytes */
      70           0 :         srb->cmd_len = 12;
      71             : 
      72             :         /* send the command to the transport layer */
      73           0 :         usb_stor_invoke_transport(srb, us);
      74           0 : }
      75             : 
      76             : void usb_stor_ufi_command(struct scsi_cmnd *srb, struct us_data *us)
      77             : {
      78             :         /* fix some commands -- this is a form of mode translation
      79             :          * UFI devices only accept 12 byte long commands 
      80             :          *
      81             :          * NOTE: This only works because a scsi_cmnd struct field contains
      82             :          * a unsigned char cmnd[16], so we know we have storage available
      83             :          */
      84             : 
      85             :         /* Pad the ATAPI command with zeros */
      86           0 :         for (; srb->cmd_len<12; srb->cmd_len++)
      87           0 :                 srb->cmnd[srb->cmd_len] = 0;
      88           0 : 
      89             :         /* set command length to 12 bytes (this affects the transport layer) */
      90           0 :         srb->cmd_len = 12;
      91             : 
      92             :         /* XXX We should be constantly re-evaluating the need for these */
      93             : 
      94             :         /* determine the correct data length for these commands */
      95           0 :         switch (srb->cmnd[0]) {
      96           0 : 
      97             :                 /* for INQUIRY, UFI devices only ever return 36 bytes */
      98           0 :         case INQUIRY:
      99           0 :                 srb->cmnd[4] = 36;
     100           0 :                 break;
     101           0 : 
     102             :                 /* again, for MODE_SENSE_10, we get the minimum (8) */
     103           0 :         case MODE_SENSE_10:
     104           0 :                 srb->cmnd[7] = 0;
     105           0 :                 srb->cmnd[8] = 8;
     106           0 :                 break;
     107           0 : 
     108             :                 /* for REQUEST_SENSE, UFI devices only ever return 18 bytes */
     109           0 :         case REQUEST_SENSE:
     110           0 :                 srb->cmnd[4] = 18;
     111           0 :                 break;
     112           0 :         } /* end switch on cmnd[0] */
     113             : 
     114           0 :         /* send the command to the transport layer */
     115           0 :         usb_stor_invoke_transport(srb, us);
     116           0 : }
     117             : 
     118             : void usb_stor_transparent_scsi_command(struct scsi_cmnd *srb,
     119             :                                        struct us_data *us)
     120             : {
     121             :         /* send the command to the transport layer */
     122           0 :         usb_stor_invoke_transport(srb, us);
     123           0 : }
     124             : EXPORT_SYMBOL_GPL(usb_stor_transparent_scsi_command);
     125             : 
     126             : /***********************************************************************
     127             :  * Scatter-gather transfer buffer access routines
     128             :  ***********************************************************************/
     129             : 
     130             : /* Copy a buffer of length buflen to/from the srb's transfer buffer.
     131             :  * Update the **sgptr and *offset variables so that the next copy will
     132             :  * pick up from where this one left off.
     133             :  */
     134             : unsigned int usb_stor_access_xfer_buf(unsigned char *buffer,
     135             :         unsigned int buflen, struct scsi_cmnd *srb, struct scatterlist **sgptr,
     136             :         unsigned int *offset, enum xfer_buf_dir dir)
     137             : {
     138           0 :         unsigned int cnt;
     139           0 :         struct scatterlist *sg = *sgptr;
     140           0 : 
     141           0 :         /* We have to go through the list one entry
     142           0 :          * at a time.  Each s-g entry contains some number of pages, and
     143           0 :          * each page has to be kmap()'ed separately.  If the page is already
     144           0 :          * in kernel-addressable memory then kmap() will return its address.
     145           0 :          * If the page is not directly accessible -- such as a user buffer
     146           0 :          * located in high memory -- then kmap() will map it to a temporary
     147           0 :          * position in the kernel's virtual address space.
     148           0 :          */
     149             : 
     150           0 :         if (!sg)
     151           0 :                 sg = scsi_sglist(srb);
     152             : 
     153             :         /* This loop handles a single s-g list entry, which may
     154             :          * include multiple pages.  Find the initial page structure
     155             :          * and the starting offset within the page, and update
     156             :          * the *offset and **sgptr values for the next loop.
     157             :          */
     158           0 :         cnt = 0;
     159           0 :         while (cnt < buflen && sg) {
     160           0 :                 struct page *page = sg_page(sg) +
     161           0 :                                 ((sg->offset + *offset) >> PAGE_SHIFT);
     162           0 :                 unsigned int poff = (sg->offset + *offset) & (PAGE_SIZE-1);
     163           0 :                 unsigned int sglen = sg->length - *offset;
     164             : 
     165           0 :                 if (sglen > buflen - cnt) {
     166             : 
     167             :                         /* Transfer ends within this s-g entry */
     168           0 :                         sglen = buflen - cnt;
     169           0 :                         *offset += sglen;
     170             :                 } else {
     171             : 
     172             :                         /* Transfer continues to next s-g entry */
     173           0 :                         *offset = 0;
     174           0 :                         sg = sg_next(sg);
     175             :                 }
     176             : 
     177             :                 /* Transfer the data for all the pages in this
     178             :                         * s-g entry.  For each page: call kmap(), do the
     179             :                         * transfer, and call kunmap() immediately after. */
     180           0 :                 while (sglen > 0) {
     181           0 :                         unsigned int plen = min(sglen, (unsigned int)
     182           0 :                                         PAGE_SIZE - poff);
     183           0 :                         unsigned char *ptr = kmap(page);
     184             : 
     185           0 :                         if (dir == TO_XFER_BUF)
     186           0 :                                 memcpy(ptr + poff, buffer + cnt, plen);
     187           0 :                         else
     188           0 :                                 memcpy(buffer + cnt, ptr + poff, plen);
     189           0 :                         kunmap(page);
     190             : 
     191             :                         /* Start at the beginning of the next page */
     192           0 :                         poff = 0;
     193           0 :                         ++page;
     194           0 :                         cnt += plen;
     195           0 :                         sglen -= plen;
     196             :                 }
     197           0 :         }
     198           0 :         *sgptr = sg;
     199             : 
     200             :         /* Return the amount actually transferred */
     201           0 :         return cnt;
     202             : }
     203             : EXPORT_SYMBOL_GPL(usb_stor_access_xfer_buf);
     204             : 
     205             : /* Store the contents of buffer into srb's transfer buffer and set the
     206             :  * SCSI residue.
     207             :  */
     208             : void usb_stor_set_xfer_buf(unsigned char *buffer,
     209             :         unsigned int buflen, struct scsi_cmnd *srb)
     210           0 : {
     211           0 :         unsigned int offset = 0;
     212           0 :         struct scatterlist *sg = NULL;
     213           0 : 
     214           0 :         buflen = min(buflen, scsi_bufflen(srb));
     215           0 :         buflen = usb_stor_access_xfer_buf(buffer, buflen, srb, &sg, &offset,
     216           0 :                         TO_XFER_BUF);
     217           0 :         if (buflen < scsi_bufflen(srb))
     218           0 :                 scsi_set_resid(srb, scsi_bufflen(srb) - buflen);
     219           0 : }
     220             : EXPORT_SYMBOL_GPL(usb_stor_set_xfer_buf);

Generated by: LCOV version 1.10