1 /* 2 * SCSI functions used by both the initiator and the target code. 3 */ 4 5 #include <linux/bug.h> 6 #include <linux/kernel.h> 7 #include <linux/string.h> 8 #include <linux/errno.h> 9 #include <asm/unaligned.h> 10 #include <scsi/scsi_common.h> 11 12 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI. 13 * You may not alter any existing entry (although adding new ones is 14 * encouraged once assigned by ANSI/INCITS T10 15 */ 16 static const char *const scsi_device_types[] = { 17 "Direct-Access ", 18 "Sequential-Access", 19 "Printer ", 20 "Processor ", 21 "WORM ", 22 "CD-ROM ", 23 "Scanner ", 24 "Optical Device ", 25 "Medium Changer ", 26 "Communications ", 27 "ASC IT8 ", 28 "ASC IT8 ", 29 "RAID ", 30 "Enclosure ", 31 "Direct-Access-RBC", 32 "Optical card ", 33 "Bridge controller", 34 "Object storage ", 35 "Automation/Drive ", 36 "Security Manager ", 37 "Direct-Access-ZBC", 38 }; 39 40 /** 41 * scsi_device_type - Return 17 char string indicating device type. 42 * @type: type number to look up 43 */ 44 const char *scsi_device_type(unsigned type) 45 { 46 if (type == 0x1e) 47 return "Well-known LUN "; 48 if (type == 0x1f) 49 return "No Device "; 50 if (type >= ARRAY_SIZE(scsi_device_types)) 51 return "Unknown "; 52 return scsi_device_types[type]; 53 } 54 EXPORT_SYMBOL(scsi_device_type); 55 56 /** 57 * scsilun_to_int - convert a scsi_lun to an int 58 * @scsilun: struct scsi_lun to be converted. 59 * 60 * Description: 61 * Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered 62 * integer, and return the result. The caller must check for 63 * truncation before using this function. 64 * 65 * Notes: 66 * For a description of the LUN format, post SCSI-3 see the SCSI 67 * Architecture Model, for SCSI-3 see the SCSI Controller Commands. 68 * 69 * Given a struct scsi_lun of: d2 04 0b 03 00 00 00 00, this function 70 * returns the integer: 0x0b03d204 71 * 72 * This encoding will return a standard integer LUN for LUNs smaller 73 * than 256, which typically use a single level LUN structure with 74 * addressing method 0. 75 */ 76 u64 scsilun_to_int(struct scsi_lun *scsilun) 77 { 78 int i; 79 u64 lun; 80 81 lun = 0; 82 for (i = 0; i < sizeof(lun); i += 2) 83 lun = lun | (((u64)scsilun->scsi_lun[i] << ((i + 1) * 8)) | 84 ((u64)scsilun->scsi_lun[i + 1] << (i * 8))); 85 return lun; 86 } 87 EXPORT_SYMBOL(scsilun_to_int); 88 89 /** 90 * int_to_scsilun - reverts an int into a scsi_lun 91 * @lun: integer to be reverted 92 * @scsilun: struct scsi_lun to be set. 93 * 94 * Description: 95 * Reverts the functionality of the scsilun_to_int, which packed 96 * an 8-byte lun value into an int. This routine unpacks the int 97 * back into the lun value. 98 * 99 * Notes: 100 * Given an integer : 0x0b03d204, this function returns a 101 * struct scsi_lun of: d2 04 0b 03 00 00 00 00 102 * 103 */ 104 void int_to_scsilun(u64 lun, struct scsi_lun *scsilun) 105 { 106 int i; 107 108 memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun)); 109 110 for (i = 0; i < sizeof(lun); i += 2) { 111 scsilun->scsi_lun[i] = (lun >> 8) & 0xFF; 112 scsilun->scsi_lun[i+1] = lun & 0xFF; 113 lun = lun >> 16; 114 } 115 } 116 EXPORT_SYMBOL(int_to_scsilun); 117 118 /** 119 * scsi_normalize_sense - normalize main elements from either fixed or 120 * descriptor sense data format into a common format. 121 * 122 * @sense_buffer: byte array containing sense data returned by device 123 * @sb_len: number of valid bytes in sense_buffer 124 * @sshdr: pointer to instance of structure that common 125 * elements are written to. 126 * 127 * Notes: 128 * The "main elements" from sense data are: response_code, sense_key, 129 * asc, ascq and additional_length (only for descriptor format). 130 * 131 * Typically this function can be called after a device has 132 * responded to a SCSI command with the CHECK_CONDITION status. 133 * 134 * Return value: 135 * true if valid sense data information found, else false; 136 */ 137 bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len, 138 struct scsi_sense_hdr *sshdr) 139 { 140 if (!sense_buffer || !sb_len) 141 return false; 142 143 memset(sshdr, 0, sizeof(struct scsi_sense_hdr)); 144 145 sshdr->response_code = (sense_buffer[0] & 0x7f); 146 147 if (!scsi_sense_valid(sshdr)) 148 return false; 149 150 if (sshdr->response_code >= 0x72) { 151 /* 152 * descriptor format 153 */ 154 if (sb_len > 1) 155 sshdr->sense_key = (sense_buffer[1] & 0xf); 156 if (sb_len > 2) 157 sshdr->asc = sense_buffer[2]; 158 if (sb_len > 3) 159 sshdr->ascq = sense_buffer[3]; 160 if (sb_len > 7) 161 sshdr->additional_length = sense_buffer[7]; 162 } else { 163 /* 164 * fixed format 165 */ 166 if (sb_len > 2) 167 sshdr->sense_key = (sense_buffer[2] & 0xf); 168 if (sb_len > 7) { 169 sb_len = (sb_len < (sense_buffer[7] + 8)) ? 170 sb_len : (sense_buffer[7] + 8); 171 if (sb_len > 12) 172 sshdr->asc = sense_buffer[12]; 173 if (sb_len > 13) 174 sshdr->ascq = sense_buffer[13]; 175 } 176 } 177 178 return true; 179 } 180 EXPORT_SYMBOL(scsi_normalize_sense); 181 182 /** 183 * scsi_sense_desc_find - search for a given descriptor type in descriptor sense data format. 184 * @sense_buffer: byte array of descriptor format sense data 185 * @sb_len: number of valid bytes in sense_buffer 186 * @desc_type: value of descriptor type to find 187 * (e.g. 0 -> information) 188 * 189 * Notes: 190 * only valid when sense data is in descriptor format 191 * 192 * Return value: 193 * pointer to start of (first) descriptor if found else NULL 194 */ 195 const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len, 196 int desc_type) 197 { 198 int add_sen_len, add_len, desc_len, k; 199 const u8 * descp; 200 201 if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7]))) 202 return NULL; 203 if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73)) 204 return NULL; 205 add_sen_len = (add_sen_len < (sb_len - 8)) ? 206 add_sen_len : (sb_len - 8); 207 descp = &sense_buffer[8]; 208 for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) { 209 descp += desc_len; 210 add_len = (k < (add_sen_len - 1)) ? descp[1]: -1; 211 desc_len = add_len + 2; 212 if (descp[0] == desc_type) 213 return descp; 214 if (add_len < 0) // short descriptor ?? 215 break; 216 } 217 return NULL; 218 } 219 EXPORT_SYMBOL(scsi_sense_desc_find); 220 221 /** 222 * scsi_build_sense_buffer - build sense data in a buffer 223 * @desc: Sense format (non zero == descriptor format, 224 * 0 == fixed format) 225 * @buf: Where to build sense data 226 * @key: Sense key 227 * @asc: Additional sense code 228 * @ascq: Additional sense code qualifier 229 * 230 **/ 231 void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq) 232 { 233 if (desc) { 234 buf[0] = 0x72; /* descriptor, current */ 235 buf[1] = key; 236 buf[2] = asc; 237 buf[3] = ascq; 238 buf[7] = 0; 239 } else { 240 buf[0] = 0x70; /* fixed, current */ 241 buf[2] = key; 242 buf[7] = 0xa; 243 buf[12] = asc; 244 buf[13] = ascq; 245 } 246 } 247 EXPORT_SYMBOL(scsi_build_sense_buffer); 248 249 /** 250 * scsi_set_sense_information - set the information field in a 251 * formatted sense data buffer 252 * @buf: Where to build sense data 253 * @buf_len: buffer length 254 * @info: 64-bit information value to be set 255 * 256 * Return value: 257 * 0 on success or EINVAL for invalid sense buffer length 258 **/ 259 int scsi_set_sense_information(u8 *buf, int buf_len, u64 info) 260 { 261 if ((buf[0] & 0x7f) == 0x72) { 262 u8 *ucp, len; 263 264 len = buf[7]; 265 ucp = (char *)scsi_sense_desc_find(buf, len + 8, 0); 266 if (!ucp) { 267 buf[7] = len + 0xc; 268 ucp = buf + 8 + len; 269 } 270 271 if (buf_len < len + 0xc) 272 /* Not enough room for info */ 273 return -EINVAL; 274 275 ucp[0] = 0; 276 ucp[1] = 0xa; 277 ucp[2] = 0x80; /* Valid bit */ 278 ucp[3] = 0; 279 put_unaligned_be64(info, &ucp[4]); 280 } else if ((buf[0] & 0x7f) == 0x70) { 281 /* 282 * Only set the 'VALID' bit if we can represent the value 283 * correctly; otherwise just fill out the lower bytes and 284 * clear the 'VALID' flag. 285 */ 286 if (info <= 0xffffffffUL) 287 buf[0] |= 0x80; 288 else 289 buf[0] &= 0x7f; 290 put_unaligned_be32((u32)info, &buf[3]); 291 } 292 293 return 0; 294 } 295 EXPORT_SYMBOL(scsi_set_sense_information); 296 297 /** 298 * scsi_set_sense_field_pointer - set the field pointer sense key 299 * specific information in a formatted sense data buffer 300 * @buf: Where to build sense data 301 * @buf_len: buffer length 302 * @fp: field pointer to be set 303 * @bp: bit pointer to be set 304 * @cd: command/data bit 305 * 306 * Return value: 307 * 0 on success or EINVAL for invalid sense buffer length 308 */ 309 int scsi_set_sense_field_pointer(u8 *buf, int buf_len, u16 fp, u8 bp, bool cd) 310 { 311 u8 *ucp, len; 312 313 if ((buf[0] & 0x7f) == 0x72) { 314 len = buf[7]; 315 ucp = (char *)scsi_sense_desc_find(buf, len + 8, 2); 316 if (!ucp) { 317 buf[7] = len + 8; 318 ucp = buf + 8 + len; 319 } 320 321 if (buf_len < len + 8) 322 /* Not enough room for info */ 323 return -EINVAL; 324 325 ucp[0] = 2; 326 ucp[1] = 6; 327 ucp[4] = 0x80; /* Valid bit */ 328 if (cd) 329 ucp[4] |= 0x40; 330 if (bp < 0x8) 331 ucp[4] |= 0x8 | bp; 332 put_unaligned_be16(fp, &ucp[5]); 333 } else if ((buf[0] & 0x7f) == 0x70) { 334 len = buf[7]; 335 if (len < 18) 336 buf[7] = 18; 337 338 buf[15] = 0x80; 339 if (cd) 340 buf[15] |= 0x40; 341 if (bp < 0x8) 342 buf[15] |= 0x8 | bp; 343 put_unaligned_be16(fp, &buf[16]); 344 } 345 346 return 0; 347 } 348 EXPORT_SYMBOL(scsi_set_sense_field_pointer); 349