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

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

/**
 * 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>
33ff4ce4	10	#include <linux/module.h>
7708c165	11	#include <asm/unaligned.h>
07e38420 BVA	12	#include <scsi/scsi_common.h>
07e38420 BVA	13
33ff4ce4 CH	14	MODULE_LICENSE("GPL v2");
33ff4ce4 CH	15
b69367df CH	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
07e38420 BVA	22	/* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
07e38420 BVA	23	* You may not alter any existing entry (although adding new ones is
749a1122	24	* encouraged once assigned by ANSI/INCITS T10).
07e38420 BVA	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	/**
749a1122	51	* scsi_device_type - Return 17-char string indicating device type.
07e38420 BVA	52	* @type: type number to look up
	53	*/
	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:
749a1122	71	* Convert @scsilun from a struct scsi_lun to a four-byte host byte-ordered
07e38420 BVA	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	*/
	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:
749a1122	110	* Given an integer : 0x0b03d204, this function returns a
07e38420 BVA	111	* struct scsi_lun of: d2 04 0b 03 00 00 00 00
	112	*
	113	*/
	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	*/
	147	bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
	148	struct scsi_sense_hdr *sshdr)
	149	{
148cff67 CH	150	memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
148cff67 CH	151
07e38420 BVA	152	if (!sense_buffer \|\| !sb_len)
	153	return false;
	154
07e38420 BVA	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);
7708c165 SG	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	*/
	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
749a1122	233	* @desc: Sense format (non-zero == descriptor format,
7708c165 SG	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	**/
	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
f5a8b3a7	263	* @buf_len: buffer length
7708c165 SG	264	* @info: 64-bit information value to be set
7708c165 SG	265	*
f5a8b3a7	266	* Return value:
749a1122	267	* 0 on success or -EINVAL for invalid sense buffer length
7708c165	268	**/
f5a8b3a7	269	int scsi_set_sense_information(u8 *buf, int buf_len, u64 info)
7708c165 SG	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) {
12306b42	277	buf[7] = len + 0xc;
7708c165 SG	278	ucp = buf + 8 + len;
7708c165 SG	279	}
f5a8b3a7 SG	280
	281	if (buf_len < len + 0xc)
	282	/* Not enough room for info */
	283	return -EINVAL;
	284
7708c165 SG	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) {
ba083116 HR	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]);
7708c165	301	}
f5a8b3a7 SG	302
f5a8b3a7 SG	303	return 0;
7708c165 SG	304	}
7708c165 SG	305	EXPORT_SYMBOL(scsi_set_sense_information);
78db6e30 HR	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:
749a1122	317	* 0 on success or -EINVAL for invalid sense buffer length
78db6e30 HR	318	*/
	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);