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 <linux/export.h> 47 #include <scsi/scsi.h> 48 #include <scsi/scsi_cmnd.h> 49 50 #include "usb.h" 51 #include "protocol.h" 52 #include "debug.h" 53 #include "scsiglue.h" 54 #include "transport.h" 55 56 /*********************************************************************** 57 * Protocol routines 58 ***********************************************************************/ 59 60 void usb_stor_pad12_command(struct scsi_cmnd *srb, struct us_data *us) 61 { 62 /* 63 * Pad the SCSI command with zeros out to 12 bytes. If the 64 * command already is 12 bytes or longer, leave it alone. 65 * 66 * NOTE: This only works because a scsi_cmnd struct field contains 67 * a unsigned char cmnd[16], so we know we have storage available 68 */ 69 for (; srb->cmd_len < 12; srb->cmd_len++) 70 srb->cmnd[srb->cmd_len] = 0; 71 72 /* send the command to the transport layer */ 73 usb_stor_invoke_transport(srb, us); 74 } 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 for (; srb->cmd_len < 12; srb->cmd_len++) 87 srb->cmnd[srb->cmd_len] = 0; 88 89 /* set command length to 12 bytes (this affects the transport layer) */ 90 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 switch (srb->cmnd[0]) { 96 97 /* for INQUIRY, UFI devices only ever return 36 bytes */ 98 case INQUIRY: 99 srb->cmnd[4] = 36; 100 break; 101 102 /* again, for MODE_SENSE_10, we get the minimum (8) */ 103 case MODE_SENSE_10: 104 srb->cmnd[7] = 0; 105 srb->cmnd[8] = 8; 106 break; 107 108 /* for REQUEST_SENSE, UFI devices only ever return 18 bytes */ 109 case REQUEST_SENSE: 110 srb->cmnd[4] = 18; 111 break; 112 } /* end switch on cmnd[0] */ 113 114 /* send the command to the transport layer */ 115 usb_stor_invoke_transport(srb, us); 116 } 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 usb_stor_invoke_transport(srb, us); 123 } 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 unsigned int cnt = 0; 139 struct scatterlist *sg = *sgptr; 140 struct sg_mapping_iter miter; 141 unsigned int nents = scsi_sg_count(srb); 142 143 if (sg) 144 nents = sg_nents(sg); 145 else 146 sg = scsi_sglist(srb); 147 148 sg_miter_start(&miter, sg, nents, dir == FROM_XFER_BUF ? 149 SG_MITER_FROM_SG: SG_MITER_TO_SG); 150 151 if (!sg_miter_skip(&miter, *offset)) 152 return cnt; 153 154 while (sg_miter_next(&miter) && cnt < buflen) { 155 unsigned int len = min_t(unsigned int, miter.length, 156 buflen - cnt); 157 158 if (dir == FROM_XFER_BUF) 159 memcpy(buffer + cnt, miter.addr, len); 160 else 161 memcpy(miter.addr, buffer + cnt, len); 162 163 if (*offset + len < miter.piter.sg->length) { 164 *offset += len; 165 *sgptr = miter.piter.sg; 166 } else { 167 *offset = 0; 168 *sgptr = sg_next(miter.piter.sg); 169 } 170 cnt += len; 171 } 172 sg_miter_stop(&miter); 173 174 return cnt; 175 } 176 EXPORT_SYMBOL_GPL(usb_stor_access_xfer_buf); 177 178 /* Store the contents of buffer into srb's transfer buffer and set the 179 * SCSI residue. 180 */ 181 void usb_stor_set_xfer_buf(unsigned char *buffer, 182 unsigned int buflen, struct scsi_cmnd *srb) 183 { 184 unsigned int offset = 0; 185 struct scatterlist *sg = NULL; 186 187 buflen = min(buflen, scsi_bufflen(srb)); 188 buflen = usb_stor_access_xfer_buf(buffer, buflen, srb, &sg, &offset, 189 TO_XFER_BUF); 190 if (buflen < scsi_bufflen(srb)) 191 scsi_set_resid(srb, scsi_bufflen(srb) - buflen); 192 } 193 EXPORT_SYMBOL_GPL(usb_stor_set_xfer_buf); 194