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 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 for (; srb->cmd_len < 12; srb->cmd_len++) 55 srb->cmnd[srb->cmd_len] = 0; 56 57 /* send the command to the transport layer */ 58 usb_stor_invoke_transport(srb, us); 59 } 60 61 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 for (; srb->cmd_len < 12; srb->cmd_len++) 73 srb->cmnd[srb->cmd_len] = 0; 74 75 /* set command length to 12 bytes (this affects the transport layer) */ 76 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 switch (srb->cmnd[0]) { 82 83 /* for INQUIRY, UFI devices only ever return 36 bytes */ 84 case INQUIRY: 85 srb->cmnd[4] = 36; 86 break; 87 88 /* again, for MODE_SENSE_10, we get the minimum (8) */ 89 case MODE_SENSE_10: 90 srb->cmnd[7] = 0; 91 srb->cmnd[8] = 8; 92 break; 93 94 /* for REQUEST_SENSE, UFI devices only ever return 18 bytes */ 95 case REQUEST_SENSE: 96 srb->cmnd[4] = 18; 97 break; 98 } /* end switch on cmnd[0] */ 99 100 /* send the command to the transport layer */ 101 usb_stor_invoke_transport(srb, us); 102 } 103 104 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 usb_stor_invoke_transport(srb, us); 109 } 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 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 struct scatterlist *sg = *sgptr; 127 struct sg_mapping_iter miter; 128 unsigned int nents = scsi_sg_count(srb); 129 130 if (sg) 131 nents = sg_nents(sg); 132 else 133 sg = scsi_sglist(srb); 134 135 sg_miter_start(&miter, sg, nents, dir == FROM_XFER_BUF ? 136 SG_MITER_FROM_SG: SG_MITER_TO_SG); 137 138 if (!sg_miter_skip(&miter, *offset)) 139 return cnt; 140 141 while (sg_miter_next(&miter) && cnt < buflen) { 142 unsigned int len = min_t(unsigned int, miter.length, 143 buflen - cnt); 144 145 if (dir == FROM_XFER_BUF) 146 memcpy(buffer + cnt, miter.addr, len); 147 else 148 memcpy(miter.addr, buffer + cnt, len); 149 150 if (*offset + len < miter.piter.sg->length) { 151 *offset += len; 152 *sgptr = miter.piter.sg; 153 } else { 154 *offset = 0; 155 *sgptr = sg_next(miter.piter.sg); 156 } 157 cnt += len; 158 } 159 sg_miter_stop(&miter); 160 161 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 void usb_stor_set_xfer_buf(unsigned char *buffer, 170 unsigned int buflen, struct scsi_cmnd *srb) 171 { 172 unsigned int offset = 0; 173 struct scatterlist *sg = NULL; 174 175 buflen = min(buflen, scsi_bufflen(srb)); 176 buflen = usb_stor_access_xfer_buf(buffer, buflen, srb, &sg, &offset, 177 TO_XFER_BUF); 178 if (buflen < scsi_bufflen(srb)) 179 scsi_set_resid(srb, scsi_bufflen(srb) - buflen); 180 } 181 EXPORT_SYMBOL_GPL(usb_stor_set_xfer_buf); 182