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