[linux-2.6-block.git] / drivers / scsi / scsi_common.c

// SPDX-License-Identifier: GPL-2.0
/*
 * SCSI functions used by both the initiator and the target code.
 */

#include <linux/bug.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <asm/unaligned.h>
#include <scsi/scsi_common.h>

/* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
 * You may not alter any existing entry (although adding new ones is
 * encouraged once assigned by ANSI/INCITS T10).
 */
static const char *const scsi_device_types[] = {
	"Direct-Access    ",
	"Sequential-Access",
	"Printer          ",
	"Processor        ",
	"WORM             ",
	"CD-ROM           ",
	"Scanner          ",
	"Optical Device   ",
	"Medium Changer   ",
	"Communications   ",
	"ASC IT8          ",
	"ASC IT8          ",
	"RAID             ",
	"Enclosure        ",
	"Direct-Access-RBC",
	"Optical card     ",
	"Bridge controller",
	"Object storage   ",
	"Automation/Drive ",
	"Security Manager ",
	"Direct-Access-ZBC",
};

/**
 * scsi_device_type - Return 17-char string indicating device type.
 * @type: type number to look up
 */
const char *scsi_device_type(unsigned type)
{
	if (type == 0x1e)
		return "Well-known LUN   ";
	if (type == 0x1f)
		return "No Device        ";
	if (type >= ARRAY_SIZE(scsi_device_types))
		return "Unknown          ";
	return scsi_device_types[type];
}
EXPORT_SYMBOL(scsi_device_type);

/**
 * scsilun_to_int - convert a scsi_lun to an int
 * @scsilun:	struct scsi_lun to be converted.
 *
 * Description:
 *     Convert @scsilun from a struct scsi_lun to a four-byte host byte-ordered
 *     integer, and return the result. The caller must check for
 *     truncation before using this function.
 *
 * Notes:
 *     For a description of the LUN format, post SCSI-3 see the SCSI
 *     Architecture Model, for SCSI-3 see the SCSI Controller Commands.
 *
 *     Given a struct scsi_lun of: d2 04 0b 03 00 00 00 00, this function
 *     returns the integer: 0x0b03d204
 *
 *     This encoding will return a standard integer LUN for LUNs smaller
 *     than 256, which typically use a single level LUN structure with
 *     addressing method 0.
 */
u64 scsilun_to_int(struct scsi_lun *scsilun)
{
	int i;
	u64 lun;

	lun = 0;
	for (i = 0; i < sizeof(lun); i += 2)
		lun = lun | (((u64)scsilun->scsi_lun[i] << ((i + 1) * 8)) |
			     ((u64)scsilun->scsi_lun[i + 1] << (i * 8)));
	return lun;
}
EXPORT_SYMBOL(scsilun_to_int);

/**
 * int_to_scsilun - reverts an int into a scsi_lun
 * @lun:        integer to be reverted
 * @scsilun:	struct scsi_lun to be set.
 *
 * Description:
 *     Reverts the functionality of the scsilun_to_int, which packed
 *     an 8-byte lun value into an int. This routine unpacks the int
 *     back into the lun value.
 *
 * Notes:
 *     Given an integer : 0x0b03d204, this function returns a
 *     struct scsi_lun of: d2 04 0b 03 00 00 00 00
 *
 */
void int_to_scsilun(u64 lun, struct scsi_lun *scsilun)
{
	int i;

	memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));

	for (i = 0; i < sizeof(lun); i += 2) {
		scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
		scsilun->scsi_lun[i+1] = lun & 0xFF;
		lun = lun >> 16;
	}
}
EXPORT_SYMBOL(int_to_scsilun);

/**
 * scsi_normalize_sense - normalize main elements from either fixed or
 *			descriptor sense data format into a common format.
 *
 * @sense_buffer:	byte array containing sense data returned by device
 * @sb_len:		number of valid bytes in sense_buffer
 * @sshdr:		pointer to instance of structure that common
 *			elements are written to.
 *
 * Notes:
 *	The "main elements" from sense data are: response_code, sense_key,
 *	asc, ascq and additional_length (only for descriptor format).
 *
 *	Typically this function can be called after a device has
 *	responded to a SCSI command with the CHECK_CONDITION status.
 *
 * Return value:
 *	true if valid sense data information found, else false;
 */
bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
			  struct scsi_sense_hdr *sshdr)
{
	memset(sshdr, 0, sizeof(struct scsi_sense_hdr));

	if (!sense_buffer || !sb_len)
		return false;

	sshdr->response_code = (sense_buffer[0] & 0x7f);

	if (!scsi_sense_valid(sshdr))
		return false;

	if (sshdr->response_code >= 0x72) {
		/*
		 * descriptor format
		 */
		if (sb_len > 1)
			sshdr->sense_key = (sense_buffer[1] & 0xf);
		if (sb_len > 2)
			sshdr->asc = sense_buffer[2];
		if (sb_len > 3)
			sshdr->ascq = sense_buffer[3];
		if (sb_len > 7)
			sshdr->additional_length = sense_buffer[7];
	} else {
		/*
		 * fixed format
		 */
		if (sb_len > 2)
			sshdr->sense_key = (sense_buffer[2] & 0xf);
		if (sb_len > 7) {
			sb_len = (sb_len < (sense_buffer[7] + 8)) ?
					 sb_len : (sense_buffer[7] + 8);
			if (sb_len > 12)
				sshdr->asc = sense_buffer[12];
			if (sb_len > 13)
				sshdr->ascq = sense_buffer[13];
		}
	}

	return true;
}
EXPORT_SYMBOL(scsi_normalize_sense);

/**
 * scsi_sense_desc_find - search for a given descriptor type in	descriptor sense data format.
 * @sense_buffer:	byte array of descriptor format sense data
 * @sb_len:		number of valid bytes in sense_buffer
 * @desc_type:		value of descriptor type to find
 *			(e.g. 0 -> information)
 *
 * Notes:
 *	only valid when sense data is in descriptor format
 *
 * Return value:
 *	pointer to start of (first) descriptor if found else NULL
 */
const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,
				int desc_type)
{
	int add_sen_len, add_len, desc_len, k;
	const u8 * descp;

	if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7])))
		return NULL;
	if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73))
		return NULL;
	add_sen_len = (add_sen_len < (sb_len - 8)) ?
			add_sen_len : (sb_len - 8);
	descp = &sense_buffer[8];
	for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) {
		descp += desc_len;
		add_len = (k < (add_sen_len - 1)) ? descp[1]: -1;
		desc_len = add_len + 2;
		if (descp[0] == desc_type)
			return descp;
		if (add_len < 0) // short descriptor ??
			break;
	}
	return NULL;
}
EXPORT_SYMBOL(scsi_sense_desc_find);

/**
 * scsi_build_sense_buffer - build sense data in a buffer
 * @desc:	Sense format (non-zero == descriptor format,
 *              0 == fixed format)
 * @buf:	Where to build sense data
 * @key:	Sense key
 * @asc:	Additional sense code
 * @ascq:	Additional sense code qualifier
 *
 **/
void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq)
{
	if (desc) {
		buf[0] = 0x72;	/* descriptor, current */
		buf[1] = key;
		buf[2] = asc;
		buf[3] = ascq;
		buf[7] = 0;
	} else {
		buf[0] = 0x70;	/* fixed, current */
		buf[2] = key;
		buf[7] = 0xa;
		buf[12] = asc;
		buf[13] = ascq;
	}
}
EXPORT_SYMBOL(scsi_build_sense_buffer);

/**
 * scsi_set_sense_information - set the information field in a
 *		formatted sense data buffer
 * @buf:	Where to build sense data
 * @buf_len:    buffer length
 * @info:	64-bit information value to be set
 *
 * Return value:
 *	0 on success or -EINVAL for invalid sense buffer length
 **/
int scsi_set_sense_information(u8 *buf, int buf_len, u64 info)
{
	if ((buf[0] & 0x7f) == 0x72) {
		u8 *ucp, len;

		len = buf[7];
		ucp = (char *)scsi_sense_desc_find(buf, len + 8, 0);
		if (!ucp) {
			buf[7] = len + 0xc;
			ucp = buf + 8 + len;
		}

		if (buf_len < len + 0xc)
			/* Not enough room for info */
			return -EINVAL;

		ucp[0] = 0;
		ucp[1] = 0xa;
		ucp[2] = 0x80; /* Valid bit */
		ucp[3] = 0;
		put_unaligned_be64(info, &ucp[4]);
	} else if ((buf[0] & 0x7f) == 0x70) {
		/*
		 * Only set the 'VALID' bit if we can represent the value
		 * correctly; otherwise just fill out the lower bytes and
		 * clear the 'VALID' flag.
		 */
		if (info <= 0xffffffffUL)
			buf[0] |= 0x80;
		else
			buf[0] &= 0x7f;
		put_unaligned_be32((u32)info, &buf[3]);
	}

	return 0;
}
EXPORT_SYMBOL(scsi_set_sense_information);

/**
 * scsi_set_sense_field_pointer - set the field pointer sense key
 *		specific information in a formatted sense data buffer
 * @buf:	Where to build sense data
 * @buf_len:    buffer length
 * @fp:		field pointer to be set
 * @bp:		bit pointer to be set
 * @cd:		command/data bit
 *
 * Return value:
 *	0 on success or -EINVAL for invalid sense buffer length
 */
int scsi_set_sense_field_pointer(u8 *buf, int buf_len, u16 fp, u8 bp, bool cd)
{
	u8 *ucp, len;

	if ((buf[0] & 0x7f) == 0x72) {
		len = buf[7];
		ucp = (char *)scsi_sense_desc_find(buf, len + 8, 2);
		if (!ucp) {
			buf[7] = len + 8;
			ucp = buf + 8 + len;
		}

		if (buf_len < len + 8)
			/* Not enough room for info */
			return -EINVAL;

		ucp[0] = 2;
		ucp[1] = 6;
		ucp[4] = 0x80; /* Valid bit */
		if (cd)
			ucp[4] |= 0x40;
		if (bp < 0x8)
			ucp[4] |= 0x8 | bp;
		put_unaligned_be16(fp, &ucp[5]);
	} else if ((buf[0] & 0x7f) == 0x70) {
		len = buf[7];
		if (len < 18)
			buf[7] = 18;

		buf[15] = 0x80;
		if (cd)
			buf[15] |= 0x40;
		if (bp < 0x8)
			buf[15] |= 0x8 | bp;
		put_unaligned_be16(fp, &buf[16]);
	}

	return 0;
}
EXPORT_SYMBOL(scsi_set_sense_field_pointer);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
07e38420 BVA	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>
f5a8b3a7	9	#include <linux/errno.h>
7708c165	10	#include <asm/unaligned.h>
07e38420 BVA	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
749a1122	15	* encouraged once assigned by ANSI/INCITS T10).
07e38420 BVA	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	/**
749a1122	42	* scsi_device_type - Return 17-char string indicating device type.
07e38420 BVA	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:
749a1122	62	* Convert @scsilun from a struct scsi_lun to a four-byte host byte-ordered
07e38420 BVA	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:
749a1122	101	* Given an integer : 0x0b03d204, this function returns a
07e38420 BVA	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	{
148cff67 CH	141	memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
148cff67 CH	142
07e38420 BVA	143	if (!sense_buffer \|\| !sb_len)
	144	return false;
	145
07e38420 BVA	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);
7708c165 SG	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
749a1122	224	* @desc: Sense format (non-zero == descriptor format,
7708c165 SG	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
f5a8b3a7	254	* @buf_len: buffer length
7708c165 SG	255	* @info: 64-bit information value to be set
7708c165 SG	256	*
f5a8b3a7	257	* Return value:
749a1122	258	* 0 on success or -EINVAL for invalid sense buffer length
7708c165	259	**/
f5a8b3a7	260	int scsi_set_sense_information(u8 *buf, int buf_len, u64 info)
7708c165 SG	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) {
12306b42	268	buf[7] = len + 0xc;
7708c165 SG	269	ucp = buf + 8 + len;
7708c165 SG	270	}
f5a8b3a7 SG	271
	272	if (buf_len < len + 0xc)
	273	/* Not enough room for info */
	274	return -EINVAL;
	275
7708c165 SG	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) {
ba083116 HR	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]);
7708c165	292	}
f5a8b3a7 SG	293
f5a8b3a7 SG	294	return 0;
7708c165 SG	295	}
7708c165 SG	296	EXPORT_SYMBOL(scsi_set_sense_information);
78db6e30 HR	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:
749a1122	308	* 0 on success or -EINVAL for invalid sense buffer length
78db6e30 HR	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);