[mirror_ubuntu-artful-kernel.git] / drivers / scsi / scsi_common.c

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