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