[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 <linux/module.h>
#include <uapi/linux/pr.h>
#include <asm/unaligned.h>
#include <scsi/scsi_common.h>

MODULE_DESCRIPTION("SCSI functions used by both the initiator and the target code");
MODULE_LICENSE("GPL v2");

/* Command group 3 is reserved and should never be used.  */
const unsigned char scsi_command_size_tbl[8] = {
	6, 10, 10, 12, 16, 12, 10, 10
};
EXPORT_SYMBOL(scsi_command_size_tbl);

/* 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);

enum pr_type scsi_pr_type_to_block(enum scsi_pr_type type)
{
	switch (type) {
	case SCSI_PR_WRITE_EXCLUSIVE:
		return PR_WRITE_EXCLUSIVE;
	case SCSI_PR_EXCLUSIVE_ACCESS:
		return PR_EXCLUSIVE_ACCESS;
	case SCSI_PR_WRITE_EXCLUSIVE_REG_ONLY:
		return PR_WRITE_EXCLUSIVE_REG_ONLY;
	case SCSI_PR_EXCLUSIVE_ACCESS_REG_ONLY:
		return PR_EXCLUSIVE_ACCESS_REG_ONLY;
	case SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS:
		return PR_WRITE_EXCLUSIVE_ALL_REGS;
	case SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS:
		return PR_EXCLUSIVE_ACCESS_ALL_REGS;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(scsi_pr_type_to_block);

enum scsi_pr_type block_pr_type_to_scsi(enum pr_type type)
{
	switch (type) {
	case PR_WRITE_EXCLUSIVE:
		return SCSI_PR_WRITE_EXCLUSIVE;
	case PR_EXCLUSIVE_ACCESS:
		return SCSI_PR_EXCLUSIVE_ACCESS;
	case PR_WRITE_EXCLUSIVE_REG_ONLY:
		return SCSI_PR_WRITE_EXCLUSIVE_REG_ONLY;
	case PR_EXCLUSIVE_ACCESS_REG_ONLY:
		return SCSI_PR_EXCLUSIVE_ACCESS_REG_ONLY;
	case PR_WRITE_EXCLUSIVE_ALL_REGS:
		return SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS;
	case PR_EXCLUSIVE_ACCESS_ALL_REGS:
		return SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(block_pr_type_to_scsi);

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