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