xref: /titanic_51/usr/src/common/devid/devid_scsi.c (revision d4bc0535efa2c2219e9f83246a5f371dc7f94273)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * These functions are used to encode SCSI INQUIRY data into
 * Solaris devid / guid values.
 */

#ifndef _KERNEL
#include <stdio.h>
#endif /* _KERNEL */

#include <sys/inttypes.h>
#include <sys/types.h>
#include <sys/stropts.h>
#include <sys/debug.h>
#include <sys/isa_defs.h>
#include <sys/dditypes.h>
#include <sys/ddi_impldefs.h>
#include <sys/scsi/scsi.h>
#include "devid_impl.h"

#define	SCSI_INQUIRY_VID_POS			9
#define	SCSI_INQUIRY_VID_SUN			"SUN"
#define	SCSI_INQUIRY_VID_SUN_LEN		3
#define	SCSI_INQUIRY_VID_HITACHI		"HITACHI"
#define	SCSI_INQUIRY_VID_HITACHI_LEN		7
#define	SCSI_INQUIRY_PID_HITACHI_OPEN		"OPEN-"
#define	SCSI_INQUIRY_PID_HITACHI_OPEN_LEN	5
#define	SCSI_INQUIRY_VID_EMC			"EMC     "
#define	SCSI_INQUIRY_VID_EMC_LEN		8
#define	SCSI_INQUIRY_PID_EMC_SYMMETRIX		"SYMMETRIX       "
#define	SCSI_INQUIRY_PID_EMC_SYMMETRIX_LEN	16

#define	MSG_NOT_STANDARDS_COMPLIANT "!Page83 data not standards compliant "
#define	MSG_NOT_STANDARDS_COMPLIANT_SIZE	( \
	sizeof (MSG_NOT_STANDARDS_COMPLIANT) + \
	sizeof (((struct scsi_inquiry *)NULL)->inq_vid) + \
	sizeof (((struct scsi_inquiry *)NULL)->inq_pid) + \
	sizeof (((struct scsi_inquiry *)NULL)->inq_revision) + 4)

#define	IS_DEVID_GUID_TYPE(type) ((type == DEVID_SCSI3_WWN)	|| \
				(IS_DEVID_SCSI3_VPD_TYPE(type)))

#define	IS_DEVID_SCSI_TYPE(type) ((IS_DEVID_GUID_TYPE(type)) || \
				(type == DEVID_SCSI_SERIAL))

/*
 * The max inquiry page 83 size as expected in the code today
 * is 0xf0 bytes. Defining a constant to make it easy incase
 * this needs to be changed at a later time.
 */

#define	SCMD_MAX_INQUIRY_PAGE83_SIZE			0xFF
#define	SCMD_MIN_INQUIRY_PAGE83_SIZE			0x08
#define	SCMD_INQUIRY_PAGE83_HDR_SIZE			4
#define	SCSI_INQUIRY_PAGE83_EMC_SYMMETRIX_ID_LEN	16

#define	SCMD_MAX_INQUIRY_PAGE80_SIZE	0xFF
#define	SCMD_MIN_INQUIRY_PAGE80_SIZE	0x04

#define	SCMD_MIN_STANDARD_INQUIRY_SIZE	0x04

#define	SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE		4

#define	SCMD_INQUIRY_VPD_TYPE_T10	0x01
#define	SCMD_INQUIRY_VPD_TYPE_EUI	0x02
#define	SCMD_INQUIRY_VPD_TYPE_NAA	0x03
#define	SCMD_INQUIRY_VPD_TYPE_RTP	0x04
#define	SCMD_INQUIRY_VPD_TYPE_TPG	0x05
#define	SCMD_INQUIRY_VPD_TYPE_LUG	0x06
#define	SCMD_INQUIRY_VPD_TYPE_MD5	0x07
#define	SCMD_INQUIRY_VPD_TYPE_SSN	0x08

static int is_page83_data_valid(uchar_t *inq83, size_t inq83_len);
static int is_page80_data_valid(uchar_t *inq80, size_t inq80_len);
static int is_initialized_id(uchar_t *id, size_t id_len);

static void encode_scsi3_page83(int version, uchar_t *inq83,
    size_t inq83_len, uchar_t **id, size_t *id_len, ushort_t *id_type);
static void encode_scsi3_page83_emc(int version, uchar_t *inq83,
    size_t inq83_len, uchar_t **id, size_t *id_len, ushort_t *id_type);
static void encode_serialnum(int version, uchar_t *inq, uchar_t *inq80,
    size_t inq80_len, uchar_t **id, size_t *id_len, ushort_t *id_type);
static void encode_sun_serialnum(int version, uchar_t *inq,
    size_t inq_len, uchar_t **id, size_t *id_len, ushort_t *id_type);

static int devid_scsi_init(char *driver_name,
    uchar_t *raw_id, size_t raw_id_len, ushort_t raw_id_type,
    ddi_devid_t *ret_devid);

static char ctoi(char c);

/*
 *    Function: ddi_/devid_scsi_encode
 *
 * Description: This routine finds and encodes a unique devid
 *
 *   Arguments: version - id encode algorithm version
 *		driver_name - binding driver name (if ! known use NULL)
 *		inq - standard inquiry buffer
 *		inq_len - standard inquiry buffer length
 *		inq80 - serial number inquiry buffer
 *		inq80_len - serial number inquiry buffer length
 *		inq83 - vpd inquiry buffer
 *		inq83_len - vpd inquiry buffer length
 *		devid - id returned
 *
 * Return Code: DEVID_SUCCESS - success
 *		DEVID_FAILURE - failure
 *		DEVID_RETRY - LUN is in a transitional state.  A delay should
 *		occur and then this inquiry data should be re-acquired and
 *		this function should be called again.
 */
int
#ifdef _KERNEL
ddi_devid_scsi_encode(
#else /* ! _KERNEL */
devid_scsi_encode(
#endif /* _KERNEL */
    int version,	/* IN */
    char *driver_name,	/* IN */
    uchar_t *inq,	/* IN */
    size_t inq_len,	/* IN */
    uchar_t *inq80,	/* IN */
    size_t inq80_len,	/* IN */
    uchar_t *inq83,	/* IN */
    size_t inq83_len,	/* IN */
    ddi_devid_t *devid)	/* OUT */
{
	int			rval		= DEVID_FAILURE;
	uchar_t			*id		= NULL;
	size_t			id_len		= 0;
	ushort_t		id_type		= DEVID_NONE;
	struct scsi_inquiry	*inq_std	= (struct scsi_inquiry *)inq;
#ifdef	_KERNEL
	char			*msg		= NULL;
#endif	/* _KERNEL */

	DEVID_ASSERT(devid != NULL);

	/* verify valid version */
	if (version > DEVID_SCSI_ENCODE_VERSION_LATEST) {
		return (rval);
	}

	/* make sure minimum inquiry bytes are available */
	if (inq_len < SCMD_MIN_STANDARD_INQUIRY_SIZE) {
		return (rval);
	}

	/*
	 * If 0x83 is availible, that is the best choice.  Our next choice is
	 * 0x80.  If neither are availible, we leave it to the caller to
	 * determine possible alternate ID, although discouraged.  In the
	 * case of the target drivers they create a fabricated id which is
	 * stored in the acyl.  The HBA drivers should avoid using an
	 * alternate id.  Although has already created a hack of using the
	 * node wwn in some cases.  Which needs to be carried forward for
	 * legacy reasons.
	 */
	if (inq83 != NULL) {
		/*
		 * Perform page 83 validation tests and report offenders.
		 * We cannot enforce the page 83 specification because
		 * many Sun partners (ex. HDS) do not conform to the
		 * standards yet.
		 */
		if (is_page83_data_valid(inq83, inq83_len) ==
		    DEVID_RET_INVALID) {
			/*
			 * invalid page 83 data.  bug 4939576 introduced
			 * handling for EMC non-standard data.
			 */
			if ((bcmp(inq_std->inq_vid, SCSI_INQUIRY_VID_EMC,
			    SCSI_INQUIRY_VID_EMC_LEN) == 0) &&
			    (bcmp(inq_std->inq_pid,
			    SCSI_INQUIRY_PID_EMC_SYMMETRIX,
			    SCSI_INQUIRY_PID_EMC_SYMMETRIX_LEN) == 0)) {
				encode_scsi3_page83_emc(version, inq83,
				    inq83_len, &id, &id_len, &id_type);
			}
#ifdef	_KERNEL
			/*
			 * invalid page 83 data. Special hack for HDS
			 * specific device, to suppress the warning msg.
			 */
			if ((bcmp(inq_std->inq_vid, SCSI_INQUIRY_VID_HITACHI,
			    SCSI_INQUIRY_VID_HITACHI_LEN) != 0) ||
			    (bcmp(inq_std->inq_pid,
			    SCSI_INQUIRY_PID_HITACHI_OPEN,
			    SCSI_INQUIRY_PID_HITACHI_OPEN_LEN) != 0)) {
				/*
				 * report the page 0x83 standards violation.
				 */
				msg = kmem_alloc(
				    MSG_NOT_STANDARDS_COMPLIANT_SIZE,
				    KM_SLEEP);
				(void) strcpy(msg, MSG_NOT_STANDARDS_COMPLIANT);
				(void) strncat(msg, inq_std->inq_vid,
				    sizeof (inq_std->inq_vid));
				(void) strcat(msg, " ");
				(void) strncat(msg, inq_std->inq_pid,
				    sizeof (inq_std->inq_pid));
				(void) strcat(msg, " ");
				(void) strncat(msg, inq_std->inq_revision,
				    sizeof (inq_std->inq_revision));
				(void) strcat(msg, "\n");
				cmn_err(CE_WARN, msg);
				kmem_free(msg,
				    MSG_NOT_STANDARDS_COMPLIANT_SIZE);
			}
#endif	/* _KERNEL */
		}

		if (id_type == DEVID_NONE) {
			encode_scsi3_page83(version, inq83,
			    inq83_len, &id, &id_len, &id_type);
		}
	}

	/*
	 * If no vpd page is available at this point then we
	 * attempt to use a SCSI serial number from page 0x80.
	 */
	if ((id_type == DEVID_NONE) &&
	    (inq != NULL) &&
	    (inq80 != NULL)) {
		if (is_page80_data_valid(inq80, inq80_len) == DEVID_RET_VALID) {
			encode_serialnum(version, inq, inq80,
			    inq80_len, &id, &id_len, &id_type);
		}
	}

	/*
	 * If no vpd page  or serial is available at this point and
	 * it's a SUN disk it conforms to the disk qual. 850 specifications
	 * and we can fabricate a serial number id based on the standard
	 * inquiry page.
	 */
	if ((id_type == DEVID_NONE) &&
	    (inq != NULL)) {
		encode_sun_serialnum(version, inq, inq_len,
		    &id, &id_len, &id_type);
	}

	if (id_type != DEVID_NONE) {
		if (is_initialized_id(id, id_len) == DEVID_RET_VALID) {
			rval = devid_scsi_init(driver_name,
			    id, id_len, id_type, devid);
		} else {
			rval = DEVID_RETRY;
		}
		DEVID_FREE(id, id_len);
	}

	return (rval);
}


/*
 *    Function: is_page83_data_valid
 *
 * Description: This routine is used to validate the page 0x83 data
 *		passed in valid based on the standards specification.
 *
 *   Arguments: inq83 -
 *		inq83_len -
 *
 * Return Code: DEVID_RET_VALID
 *              DEVID_RET_INVALID
 *
 */
static int
is_page83_data_valid(uchar_t *inq83, size_t inq83_len)
{

	int 	covered_desc_len	= 0;
	int	dlen			= 0;
	uchar_t	*dblk			= NULL;

	DEVID_ASSERT(inq83 != NULL);

	/* if not large enough fail */
	if (inq83_len < SCMD_MIN_INQUIRY_PAGE83_SIZE)
		return (DEVID_RET_INVALID);

	/*
	 * Ensuring that the Peripheral device type(bits 0 - 4) has
	 * the valid settings - the value 0x1f indicates no device type.
	 * Only this value can be validated since all other fields are
	 * either used or reserved.
	 */
	if ((inq83[0] & DTYPE_MASK) == DTYPE_UNKNOWN) {
		/* failed-peripheral devtype */
		return (DEVID_RET_INVALID);
	}

	/*
	 * Ensure that the page length field - third and 4th bytes
	 * contain a non zero length value. Our implementation
	 * does not seem to expect more that 255 bytes of data...
	 * what is to be done if the reported size is > 255 bytes?
	 * Yes the device will return only 255 bytes as we provide
	 * buffer to house only that much data but the standards
	 * prevent the targets from reporting the truncated size
	 * in this field.
	 *
	 * Currently reporting sizes more than 255 as failure.
	 *
	 */

	if ((inq83[2] == 0) && (inq83[3] == 0)) {
		/* length field is 0! */
		return (DEVID_RET_INVALID);
	}
	if (inq83[3] > (SCMD_MAX_INQUIRY_PAGE83_SIZE - 3)) {
		/* length field exceeds expected size of 255 bytes */
		return (DEVID_RET_INVALID);
	}

	/*
	 * Validation of individual descriptor blocks are done in the
	 * following while loop. It is possible to have multiple
	 * descriptor blocks.
	 * the 'dblk' pointer will be pointing to the start of
	 * each entry of the descriptor block.
	 */
	covered_desc_len = 0;
	dblk = &inq83[4]; /* start of first decriptor blk */
	while (covered_desc_len < inq83[3]) {

		/*
		 * Ensure that the length field is non zero
		 * Further length validations will be done
		 * along with the 'identifier type' as some of
		 * the lengths are dependent on it.
		 */
		dlen = dblk[3];
		if (dlen == 0) {
			/* descr length is 0 */
			return (DEVID_RET_INVALID);
		}

		/*
		 * ensure that the size of the descriptor block does
		 * not claim to be larger than the entire page83
		 * data that has been received.
		 */
		if ((covered_desc_len + dlen) > inq83[3]) {
			/* failed-descr length */
			return (DEVID_RET_INVALID);
		}

		/*
		 * The spec says that if the PIV field is 0 OR the
		 * association field contains value other than 1 and 2,
		 * then the protocol identifier field should be ignored.
		 * If association field contains a value of 1 or 2
		 * and the PIV field is set, then the protocol identifier
		 * field has to be validated.
		 * The protocol identifier values 0 - f are either assigned
		 * or reserved. Nothing to validate here, hence skipping
		 * over to the next check.
		 */

		/*
		 * Check for valid code set values.
		 * All possible values are reserved or assigned. Nothing
		 * to validate - skipping over.
		 */

		/*
		 * Identifier Type validation
		 * All SPC3rev22 identified types and the expected lengths
		 * are validated.
		 */
		switch (dblk[1] & 0x0f) {
		case SCMD_INQUIRY_VPD_TYPE_T10: /* T10 vendor Id */
			/* No specific length validation required */
			break;

		case SCMD_INQUIRY_VPD_TYPE_EUI: /* EUI 64 ID */
			/* EUI-64: size is expected to be 8, 12, or 16 bytes */
			if ((dlen != 8) && (dlen != 12) && (dlen != 16)) {
				/* page83 validation failed-EIU64 */
				return (DEVID_RET_INVALID);
			}
			break;

		case SCMD_INQUIRY_VPD_TYPE_NAA: /* NAA Id type */

			/*
			 * the size for this varies -
			 * IEEE extended/registered is 8 bytes
			 * IEEE Registered extended is 16 bytes
			 */
			switch (dblk[4] & 0xf0) {

				case 0x20: /* IEEE Ext */
				case 0x50: /* IEEE Reg */
					if (dlen != 8) {
						/* failed-IEE E/R len */
						return (DEVID_RET_INVALID);
					}
					/*
					 * the codeSet for this MUST
					 * be set to 1
					 */
					if ((dblk[0] & 0x0f) != 1) {
						/*
						 * failed-IEEE E/R
						 * codeSet != 1.
						 */
						return (DEVID_RET_INVALID);
					}
				break;

				case 0x60: /* IEEE EXT REG */
					if (dlen != 16) {
						/* failed-IEEE ER len */
						return (DEVID_RET_INVALID);
					}
					/*
					 * the codeSet for this MUST
					 * be set to 1
					 */
					if ((dblk[0] & 0x0f) != 1) {
						/*
						 * failed-IEEE ER
						 * codeSet != 1.
						 */
						return (DEVID_RET_INVALID);
						}
				break;

				default:
					/* reserved values */
					break;
			}
			break;

		case SCMD_INQUIRY_VPD_TYPE_RTP: /* Relative Target port */
			if (dlen != 4) {
				/* failed-Rel target Port length */
				return (DEVID_RET_INVALID);
			}
			break;

		case SCMD_INQUIRY_VPD_TYPE_TPG: /* Target port group */
			if (dlen != 4) {
				/* failed-target Port group length */
				return (DEVID_RET_INVALID);
			}
			break;

		case SCMD_INQUIRY_VPD_TYPE_LUG: /* Logical unit group */
			if (dlen != 4) {
				/* failed-Logical Unit group length */
				return (DEVID_RET_INVALID);
			}
			break;

		case SCMD_INQUIRY_VPD_TYPE_MD5: /* MD5 unit group */
			if (dlen != 16) {
				/* failed-MD5 Unit grp */
				return (DEVID_RET_INVALID);
			}
			break;

		default:
			break;
		}

		/*
		 * Now lets advance to the next descriptor block
		 * and validate it.
		 * the descriptor block size is <descr Header> + <descr Data>
		 * <descr Header> is equal to 4 bytes
		 * <descr Data> is available in dlen or dblk[3].
		 */
		dblk = &dblk[4 + dlen];

		/*
		 * update the covered_desc_len so that we can ensure that
		 * the 'while' loop terminates.
		 */
		covered_desc_len += (dlen + 4);
	}
	return (DEVID_RET_VALID);
}


/*
 *    Function: is_initialized_id
 *
 * Description: Routine to ensure that the ID calculated is not a
 *		space or zero filled ID. Returning a space / zero
 *		filled ID when the luns on the target are not fully
 *		initialized is a valid response from the target as
 *		per the T10 spec. When a space/zero filled ID is
 *		found its information needs to be polled again
 *		after sometime time to see if the luns are fully
 *		initialized to return a valid guid information.
 *
 *   Arguments: id - raw id
 *              id_len - raw id len
 *
 * Return Code:	DEVID_VALID - indicates a non space/zero filled id
 *		DEVID_INVALID - indicates id contains uninitialized data
 *		and suggests retry of the collection commands.
 */
static int
is_initialized_id(uchar_t *id, size_t id_len)
{
	int idx;

	if ((id == NULL) ||
	    (id_len == 0)) {
		/* got id length as 0 fetch info again */
		return (DEVID_RET_INVALID);
	}

	/* First lets check if the guid is filled with spaces */
	for (idx = 0; idx < id_len; idx++) {
		if (id[idx] != ' ') {
			break;
		}
	}

	/*
	 * Lets exit if we find that it contains ALL spaces
	 * saying that it has an uninitialized guid
	 */
	if (idx >= id_len) {
		/* guid filled with spaces found */
		return (DEVID_RET_INVALID);
	}

	/*
	 * Since we have found that it is not filled with spaces
	 * now lets ensure that the guid is not filled with only
	 * zeros.
	 */
	for (idx = 0; idx < id_len; idx ++) {
		if (id[idx] != 0) {
			return (DEVID_RET_VALID);
		}
	}

	/* guid filled with zeros found */
	return (DEVID_RET_INVALID);
}


/*
 *    Function: is_page80_data_valid
 *
 * Description: This routine is used to validate the page 0x80 data
 *		passed in valid based on the standards specification.
 *
 *   Arguments: inq80 -
 *		inq80_len -
 *
 * Return Code: DEVID_RET_VALID
 *              DEVID_RET_INVALID
 *
 */
/* ARGSUSED */
static int
is_page80_data_valid(uchar_t *inq80, size_t inq80_len)
{
	DEVID_ASSERT(inq80);

	/* if not large enough fail */
	if (inq80_len < SCMD_MIN_INQUIRY_PAGE80_SIZE) {
		return (DEVID_RET_INVALID);
	}

	/*
	 * (inq80_len - 4) is the size of the buffer space available
	 * for the product serial number.  So inq80[3] (ie. product
	 * serial number) should be <= (inq80_len -4).
	 */
	if (inq80[3] > (inq80_len - 4)) {
		return (DEVID_RET_INVALID);
	}

	return (DEVID_RET_VALID);
}


/*
 *    Function: encode_devid_page
 *
 * Description: This routine finds the unique devid if available and
 *		fills the devid and length parameters.
 *
 *   Arguments: version - encode version
 *		inq83 - driver soft state (unit) structure
 *		inq83_len - length of raw inq83 data
 *		id - raw id
 *		id_len - len of raw id
 *		id_type - type of id
 *
 *        Note: DEVID_NONE is returned in the id_type field
 *		if no supported page 83 id is found.
 */
static void
encode_scsi3_page83(int version, uchar_t *inq83, size_t inq83_len,
    uchar_t **id, size_t *id_len, ushort_t *id_type)
{
	size_t	descriptor_bytes_left   = 0;
	size_t	offset			= 0;
	int	idx			= 0;
	size_t	offset_id_type[4];

	DEVID_ASSERT(inq83 != NULL);
	/* inq83 length was already validate in is_page83_valid */
	DEVID_ASSERT(id != NULL);
	DEVID_ASSERT(id_len != NULL);
	DEVID_ASSERT(id_type != NULL);

	/* preset defaults */
	*id = NULL;
	*id_len = 0;
	*id_type = DEVID_NONE;

	/* verify we have enough memory for a ident header */
	if (inq83_len < SCMD_INQUIRY_PAGE83_HDR_SIZE) {
		return;
	}

	/*
	 * Attempt to validate the page data.  Once validated, we'll walk
	 * the descriptors, looking for certain identifier types that will
	 * mark this device with a unique id/wwn.  Note the comment below
	 * for what we really want to receive.
	 */

	/*
	 * The format of the inq83 data (Device Identification VPD page) is
	 * a header (containing the total length of the page, from which
	 * descriptor_bytes_left is calculated), followed by a list of
	 * identification descriptors. Each identifcation descriptor has a
	 * header which includes the length of the individual identification
	 * descriptor).
	 *
	 * Set the offset to the beginning byte of the first identification
	 * descriptor.  We'll index everything from there.
	 */
	offset = SCMD_INQUIRY_PAGE83_HDR_SIZE;
	descriptor_bytes_left = (size_t)((inq83[2] << 8) | inq83[3]);

	/*
	 * If the raw data states that the data is larger
	 * than what is actually received abort encode.
	 * Otherwise we will run off into unknown memory
	 * on the decode.
	 */
	if ((descriptor_bytes_left + offset) > inq83_len) {
		return;
	}


	/* Zero out our offset array */
	bzero(offset_id_type, sizeof (offset_id_type));

	/*
	 * According to the scsi spec 8.4.3 SPC-2, there could be several
	 * descriptors associated with each lun.  Some we care about and some
	 * we don't.  This loop is set up to iterate through the descriptors.
	 * We want the 0x03 case which represents an FC-PH, FC-PH3 or FC-FS
	 * Name_Identifier.  The spec mentions nothing about ordering, so we
	 * don't assume any.
	 *
	 * We need to check if we've finished walking the list of descriptors,
	 * we also perform additional checks to be sure the newly calculated
	 * offset is within the bounds of the buffer, and the identifier length
	 * (as calculated by the length field in the header) is valid. This is
	 * done to protect against devices which return bad page83 data.
	 */
	while ((descriptor_bytes_left > 0) && (offset_id_type[3] == 0) &&
	    (offset + SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE <= inq83_len) &&
	    (offset + SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE +
	    (size_t)inq83[offset + 3] <= inq83_len)) {
		/*
		 * Inspect the Identification descriptor list. Store the
		 * offsets in the devid page separately for 0x03, 0x01 and
		 * 0x02.  Identifiers 0x00 and 0x04 are not useful as they
		 * don't represent unique identifiers for a lun.  We also
		 * check the association by masking with 0x3f because we want
		 * an association of 0x0 - indicating the identifier field is
		 * associated with the addressed physical or logical device
		 * and not the port.
		 */
		switch ((inq83[offset + 1] & 0x3f)) {
		case SCMD_INQUIRY_VPD_TYPE_T10:
			offset_id_type[SCMD_INQUIRY_VPD_TYPE_T10] = offset;
			break;
		case SCMD_INQUIRY_VPD_TYPE_EUI:
			offset_id_type[SCMD_INQUIRY_VPD_TYPE_EUI] = offset;
			break;
		case SCMD_INQUIRY_VPD_TYPE_NAA:
			offset_id_type[SCMD_INQUIRY_VPD_TYPE_NAA] = offset;
			break;
		default:
			/* Devid page undesired id type */
			break;
		}
		/*
		 * Calculate the descriptor bytes left and move to
		 * the beginning byte of the next id descriptor.
		 */
		descriptor_bytes_left -= (size_t)(inq83[offset + 3] +
		    SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE);
		offset += (SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE +
		    (size_t)inq83[offset + 3]);
	}

	offset = 0;

	/*
	 * We can't depend on an order from a device by identifier type, but
	 * once we have them, we'll walk them in the same order to prevent a
	 * firmware upgrade from breaking our algorithm.  Start with the one
	 * we want the most: id_offset_type[3].
	 */
	for (idx = 3; idx > 0; idx--) {
		if (offset_id_type[idx] > 0) {
			offset = offset_id_type[idx];
			break;
		}
	}

	/*
	 * We have a valid Device ID page, set the length of the
	 * identifier and copy the value into the wwn.
	 */
	if (offset > 0) {
		*id_len = (size_t)inq83[offset + 3];
		if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
			*id_len = 0;
			return;
		}
		bcopy(&inq83[offset + SCMD_INQUIRY_PAGE83_IDENT_DESC_HDR_SIZE],
		    *id, *id_len);

		/* set devid type */
		switch (version) {
		/* In version 1 all page 83 types were grouped */
		case DEVID_SCSI_ENCODE_VERSION1:
			*id_type = DEVID_SCSI3_WWN;
			break;
		/* In version 2 we break page 83 apart to be unique */
		case DEVID_SCSI_ENCODE_VERSION2:
			switch (idx) {
			case 3:
				*id_type = DEVID_SCSI3_VPD_NAA;
				break;
			case 2:
				*id_type = DEVID_SCSI3_VPD_EUI;
				break;
			case 1:
				*id_type = DEVID_SCSI3_VPD_T10;
				break;
			default:
				DEVID_FREE(*id, *id_len);
				*id_len = 0;
				break;
			}
			break;
		default:
			DEVID_FREE(*id, *id_len);
			*id_len = 0;
			break;
		}
	}
}


/*
 *    Function: encode_scsi3_page83_emc
 *
 * Description: Routine to handle proprietary page 83 of EMC Symmetrix
 *              device. Called by ssfcp_handle_page83()
 *
 *   Arguments: version - encode version
 *		inq83 - scsi page 83 buffer
 *		inq83_len - scsi page 83 buffer size
 *		id - raw emc id
 *		id_len - len of raw emc id
 *		id_type - type of emc id
 */
static void
encode_scsi3_page83_emc(int version, uchar_t *inq83,
    size_t inq83_len, uchar_t **id, size_t *id_len, ushort_t *id_type)
{
	uchar_t	*guidp	= NULL;

	DEVID_ASSERT(inq83 != NULL);
	DEVID_ASSERT(id != NULL);
	DEVID_ASSERT(id_len != NULL);
	DEVID_ASSERT(id_type != NULL);

	/* preset defaults */
	*id = NULL;
	*id_len = 0;
	*id_type = DEVID_NONE;

	/* The initial devid algorithm didn't use EMC page 83 data */
	if (version == DEVID_SCSI_ENCODE_VERSION1) {
		return;
	}

	/* EMC page 83 requires atleast 20 bytes */
	if (inq83_len < (SCMD_INQUIRY_PAGE83_HDR_SIZE +
	    SCSI_INQUIRY_PAGE83_EMC_SYMMETRIX_ID_LEN)) {
		return;
	}

	/*
	 * The 4th byte in the page 83 info returned is most likely
	 * indicating the length of the id - which 0x10(16 bytes)
	 * and the 5th byte is indicating that the id is of
	 * IEEE Registered Extended Name format(6). Validate
	 * these code prints before proceeding further as the
	 * following proprietary approach is tied to the specific
	 * device type and incase the EMC firmware changes, we will
	 * have to validate for the changed device before we start
	 * supporting such a device.
	 */
	if ((inq83[3] != 0x10) || (inq83[4] != 0x60)) {
		/* unsupported emc symtx device type */
		return;
	} else {
		guidp = &inq83[SCMD_INQUIRY_PAGE83_HDR_SIZE];
		/*
		 * The GUID returned by the EMC device is
		 * in the IEEE Registered Extended Name format(6)
		 * as a result it is of 16 bytes in length.
		 * An IEEE Registered Name format(5) will be of
		 * 8 bytes which is NOT what is being returned
		 * by the device type for which we are providing
		 * the support.
		 */
		*id_len = SCSI_INQUIRY_PAGE83_EMC_SYMMETRIX_ID_LEN;
		if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
			*id_len = 0;
			return;
		}
		bcopy(guidp, *id, *id_len);

		/* emc id matches type 3 */
		*id_type = DEVID_SCSI3_VPD_NAA;
	}
}


/*
 *    Function: encode_serialnum
 *
 * Description: This routine finds the unique devid from the inquiry page
 *		0x80, serial number page.  If available and fills the wwn
 *		and length parameters.
 *
 *   Arguments: version - encode version
 *		inq - standard inquiry data
 *		inq80 - serial inquiry data
 *		inq80_len - serial inquiry data len
 *		id - raw id
 *		id_len - raw id len
 *		id_type - raw id type
 */
/* ARGSUSED */
static void
encode_serialnum(int version, uchar_t *inq, uchar_t *inq80,
    size_t inq80_len, uchar_t **id, size_t *id_len, ushort_t *id_type)
{
	struct scsi_inquiry	*inq_std	= (struct scsi_inquiry *)inq;
	int			idx		= 0;

	DEVID_ASSERT(inq != NULL);
	DEVID_ASSERT(inq80 != NULL);
	DEVID_ASSERT(id != NULL);
	DEVID_ASSERT(id_len != NULL);
	DEVID_ASSERT(id_type != NULL);

	/* preset defaults */
	*id = NULL;
	*id_len = 0;
	*id_type = DEVID_NONE;

	/* verify inq80 buffer is large enough for a header */
	if (inq80_len < SCMD_MIN_INQUIRY_PAGE80_SIZE) {
		return;
	}

	/*
	 * Attempt to validate the page data.  Once validated, we'll check
	 * the serial number.
	 */
	*id_len = (size_t)inq80[3]; /* Store Product Serial Number length */

	/* verify buffer is large enough for serial number */
	if (inq80_len < (*id_len + SCMD_MIN_INQUIRY_PAGE80_SIZE)) {
		return;
	}

	/*
	 * Device returns ASCII space (20h) in all the bytes of successful data
	 * transfer, if the product serial number is not available.  So we end
	 * up having to check all the bytes for a space until we reach
	 * something else.
	 */
	for (idx = 0; idx < *id_len; idx++) {
		if (inq80[4 + idx] == ' ') {
			continue;
		}
		/*
		 * The serial number is valid, but since this is only vendor
		 * unique, we'll combine the inquiry vid and pid with the
		 * serial number.
		 */
		*id_len += sizeof (inq_std->inq_vid);
		*id_len += sizeof (inq_std->inq_pid);

		if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
			*id_len = 0;
			return;
		}

		bcopy(&inq_std->inq_vid, *id, sizeof (inq_std->inq_vid));
		bcopy(&inq_std->inq_pid, &(*id)[sizeof (inq_std->inq_vid)],
		    sizeof (inq_std->inq_pid));
		bcopy(&inq80[4], &(*id)[sizeof (inq_std->inq_vid) +
		    sizeof (inq_std->inq_pid)], inq80[3]);

		*id_type = DEVID_SCSI_SERIAL;
		break;
	}

	/*
	 * The spec suggests that the command could succeed but return all
	 * spaces if the product serial number is not available.  In this case
	 * we need to fail this routine. To accomplish this, we compare our
	 * length to the serial number length. If they are the same, then we
	 * never copied in the vid and updated the length. That being the case,
	 * we must not have found a valid serial number.
	 */
	if (*id_len == (size_t)inq80[3]) {
		/* empty unit serial number */
		if (*id != NULL) {
			DEVID_FREE(*id, *id_len);
		}
		*id = NULL;
		*id_len = 0;
	}
}


/*
 *    Function: encode_sun_serialnum
 *
 * Description: This routine finds the unique devid from the inquiry page
 *		0x80, serial number page.  If available and fills the wwn
 *		and length parameters.
 *
 *   Arguments: version - encode version
 *		inq - standard inquiry data
 *		inq_len - standard inquiry data len
 *		id - raw id
 *		id_len - raw id len
 *		id_type - raw id type
 *
 * Return Code: DEVID_SUCCESS
 *              DEVID_FAILURE
 */
/* ARGSUSED */
static void
encode_sun_serialnum(int version, uchar_t *inq,
    size_t inq_len, uchar_t **id, size_t *id_len, ushort_t *id_type)
{
	struct scsi_inquiry *inq_std = (struct scsi_inquiry *)inq;

	DEVID_ASSERT(inq != NULL);
	DEVID_ASSERT(id != NULL);
	DEVID_ASSERT(id_len != NULL);
	DEVID_ASSERT(id_type != NULL);

	/* verify enough buffer is available */
	if (inq_len < SCMD_MIN_STANDARD_INQUIRY_SIZE) {
		return;
	}

	/* sun qual drive */
	if ((inq_std != NULL) &&
	    (bcmp(&inq_std->inq_pid[SCSI_INQUIRY_VID_POS],
	    SCSI_INQUIRY_VID_SUN, SCSI_INQUIRY_VID_SUN_LEN) == 0)) {
		/*
		 * VPD pages 0x83 and 0x80 are unavailable. This
		 * is a Sun qualified disks as indicated by
		 * "SUN" in bytes 25-27 of the inquiry data
		 * (bytes 9-11 of the pid).  Devid's are created
		 * for Sun qualified disks by combining the
		 * vendor id with the product id with the serial
		 * number located in bytes 36-47 of the inquiry data.
		 */

		/* get data size */
		*id_len = sizeof (inq_std->inq_vid) +
		    sizeof (inq_std->inq_pid) +
		    sizeof (inq_std->inq_serial);

		if ((*id = DEVID_MALLOC(*id_len)) == NULL) {
			*id_len = 0;
			return;
		}

		/* copy the vid at the beginning */
		bcopy(&inq_std->inq_vid, *id,
		    sizeof (inq_std->inq_vid));
			/* copy the pid after the vid */
		bcopy(&inq_std->inq_pid,
		    &(*id)[sizeof (inq_std->inq_vid)],
		    sizeof (inq_std->inq_pid));
			/* copy the serial number after the vid and pid */
		bcopy(&inq_std->inq_serial,
		    &(*id)[sizeof (inq_std->inq_vid) +
		    sizeof (inq_std->inq_pid)],
		    sizeof (inq_std->inq_serial));
			/* devid formed from inquiry data */
		*id_type = DEVID_SCSI_SERIAL;
	}
}


/*
 *    Function: devid_scsi_init
 *
 * Description: This routine is used to create a devid for a scsi
 *		devid type.
 *
 *   Arguments: hint - driver soft state (unit) structure
 *		raw_id - pass by reference variable to hold wwn
 *		raw_id_len - wwn length
 *		raw_id_type -
 *		ret_devid -
 *
 * Return Code: DEVID_SUCCESS
 *              DEVID_FAILURE
 *
 */
static int
devid_scsi_init(
	char		*driver_name,
	uchar_t		*raw_id,
	size_t		raw_id_len,
	ushort_t	raw_id_type,
	ddi_devid_t	*ret_devid)
{
	impl_devid_t	*i_devid	= NULL;
	int		i_devid_len	= 0;
	int		driver_name_len	= 0;
	ushort_t	u_raw_id_len	= 0;

	DEVID_ASSERT(raw_id != NULL);
	DEVID_ASSERT(ret_devid != NULL);

	if (!IS_DEVID_SCSI_TYPE(raw_id_type)) {
		*ret_devid = NULL;
		return (DEVID_FAILURE);
	}

	i_devid_len = sizeof (*i_devid) + raw_id_len - sizeof (i_devid->did_id);
	if ((i_devid = DEVID_MALLOC(i_devid_len)) == NULL) {
		*ret_devid = NULL;
		return (DEVID_FAILURE);
	}

	i_devid->did_magic_hi = DEVID_MAGIC_MSB;
	i_devid->did_magic_lo = DEVID_MAGIC_LSB;
	i_devid->did_rev_hi = DEVID_REV_MSB;
	i_devid->did_rev_lo = DEVID_REV_LSB;
	DEVID_FORMTYPE(i_devid, raw_id_type);
	u_raw_id_len = raw_id_len;
	DEVID_FORMLEN(i_devid, u_raw_id_len);

	/* Fill in driver name hint */
	bzero(i_devid->did_driver, DEVID_HINT_SIZE);
	if (driver_name != NULL) {
		driver_name_len = strlen(driver_name);
		if (driver_name_len > DEVID_HINT_SIZE) {
			/* Pick up last four characters of driver name */
			driver_name += driver_name_len - DEVID_HINT_SIZE;
			driver_name_len = DEVID_HINT_SIZE;
		}
		bcopy(driver_name, i_devid->did_driver, driver_name_len);
	}

	bcopy(raw_id, i_devid->did_id, raw_id_len);

	/* return device id */
	*ret_devid = (ddi_devid_t)i_devid;
	return (DEVID_SUCCESS);
}


/*
 *    Function: devid_to_guid
 *
 * Description: This routine extracts a guid string form a devid.
 *		The common use of this guid is for a HBA driver
 *		to pass into mdi_pi_alloc().
 *
 *   Arguments: devid - devid to extract guid from
 *
 * Return Code: guid string - success
 *		NULL - failure
 */
char *
#ifdef  _KERNEL
ddi_devid_to_guid(ddi_devid_t devid)
#else   /* !_KERNEL */
devid_to_guid(ddi_devid_t devid)
#endif  /* _KERNEL */
{
	impl_devid_t	*id	= (impl_devid_t *)devid;
	int		len	= 0;
	int		idx	= 0;
	int		num	= 0;
	char		*guid	= NULL;
	char		*ptr	= NULL;
	char		*dp	= NULL;

	DEVID_ASSERT(devid != NULL);

	/* NULL devid -> NULL guid */
	if (devid == NULL)
		return (NULL);

	if (!IS_DEVID_GUID_TYPE(DEVID_GETTYPE(id)))
		return (NULL);

	/* guid is always converted to ascii, append NULL */
	len = DEVID_GETLEN(id);

	/* allocate guid string */
	if ((guid = DEVID_MALLOC((len * 2) + 1)) == NULL)
		return (NULL);

	/* perform encode of id to hex string */
	ptr = guid;
	for (idx = 0, dp = &id->did_id[0]; idx < len; idx++, dp++) {
		num = ((*dp) >> 4) & 0xF;
		*ptr++ = (num < 10) ? (num + '0') : (num + ('a' - 10));
		num = (*dp) & 0xF;
		*ptr++ = (num < 10) ? (num + '0') : (num + ('a' - 10));
	}
	*ptr = 0;

	return (guid);
}

/*
 *    Function: devid_free_guid
 *
 * Description: This routine frees a guid allocated by
 *		devid_to_guid().
 *
 *   Arguments: guid - guid to free
 */
void
#ifdef  _KERNEL
ddi_devid_free_guid(char *guid)
#else   /* !_KERNEL */
devid_free_guid(char *guid)
#endif  /* _KERNEL */
{
	if (guid != NULL) {
		DEVID_FREE(guid, strlen(guid) + 1);
	}
}

static char
ctoi(char c)
{
	if ((c >= '0') && (c <= '9'))
		c -= '0';
	else if ((c >= 'A') && (c <= 'F'))
		c = c - 'A' + 10;
	else if ((c >= 'a') && (c <= 'f'))
		c = c - 'a' + 10;
	else
		c = -1;
	return (c);
}

/* ====NOTE: The scsi_* interfaces are not related to devids :NOTE==== */

/*
 *    Function: scsi_wwnstr_to_wwn
 *
 * Description: This routine translates wwn from wwnstr string to uint64 wwn.
 *
 *   Arguments: wwnstr - the string wwn to be transformed
 *              wwnp - the pointer to 64 bit wwn
 */
int
scsi_wwnstr_to_wwn(const char *wwnstr, uint64_t *wwnp)
{
	int		i;
	char		cl, ch;
	uint64_t	tmp;

	if (wwnp == NULL)
		return (DDI_FAILURE);
	*wwnp = 0;

	if (wwnstr == NULL)
		return (DDI_FAILURE);

	/* Skip leading 'w' if wwnstr is in unit-address form */
	if (*wwnstr == 'w')
		wwnstr++;

	if (strlen(wwnstr) != 16)
		return (DDI_FAILURE);

	for (i = 0; i < 8; i++) {
		ch = ctoi(*wwnstr++);
		cl = ctoi(*wwnstr++);
		if (cl == -1 || ch == -1) {
			return (DDI_FAILURE);
		}
		tmp = (ch << 4) + cl;
		*wwnp = (*wwnp << 8) | tmp;
	}
	return (DDI_SUCCESS);
}

/*
 *    Function: scsi_wwn_to_wwnstr
 *
 * Description: This routine translates from a uint64 wwn to a wwnstr
 *
 *   Arguments:
 *              wwn - the 64 bit wwn
 *		unit_address_form - do we want a leading 'w'?
 *		wwnstr - allow caller to perform wwnstr allocation.
 *			If non-NULL, don't use scsi_free_wwnstr(),
 *			and make sure you provide 18/17 bytes of  space.
 */
char *
scsi_wwn_to_wwnstr(uint64_t wwn, int unit_address_form, char *wwnstr)
{
	int	len;

	/* make space for leading 'w' */
	if (unit_address_form)
		len = 1 + 16 + 1;	/* "w0123456789abcdef\0" */
	else
		len = 16 + 1;		/* "0123456789abcdef\0" */

	if (wwnstr == NULL) {
		/* We allocate, caller uses scsi_free_wwnstr(). */
		if ((wwnstr = DEVID_MALLOC(len)) == NULL)
			return (NULL);
	}

	if (unit_address_form)
		(void) snprintf(wwnstr, len, "w%016" PRIx64, wwn);
	else
		(void) snprintf(wwnstr, len, "%016" PRIx64, wwn);
	return (wwnstr);
}

/*
 *    Function: scsi_wwnstr_hexcase
 *
 * Description: This routine switches a wwnstr to upper/lower case hex
 *		(a wwnstr uses lower-case hex by default).
 *
 *   Arguments:
 *              wwnstr - the pointer to the wwnstr string.
 *		upper_case_hex - non-zero will convert to upper_case hex
 *			zero will convert to lower case hex.
 */
void
scsi_wwnstr_hexcase(char *wwnstr, int upper_case_hex)
{
	char	*s;
	char	c;

	for (s = wwnstr; *s; s++) {
		c = *s;
		if ((upper_case_hex != 0) &&
		    ((c >= 'a') && (c <= 'f')))
			c -= ('a' - 'A');	/* lower to upper */
		else if ((upper_case_hex == 0) &&
		    ((c >= 'A') && (c <= 'F')))
			c += ('a' - 'A');	/* upper to lower */
		*s = c;
	}
}

/*
 *    Function: scsi_wwnstr_free
 *
 * Description: This routine frees a wwnstr returned by a call
 *		to scsi_wwn_to_strwwn with a NULL wwnstr argument.
 *
 *   Arguments:
 *              wwnstr - the pointer to the wwnstr string to free.
 */
void
scsi_free_wwnstr(char *wwnstr)
{
#ifdef	_KERNEL
	kmem_free(wwnstr, strlen(wwnstr) + 1);
#else	/* _KERNEL */
	free(wwnstr);
#endif	/* _KERNEL */
}

/*
 *    Function: scsi_lun_to_lun64/scsi_lun64_to_lun
 *
 * Description: Convert between normalized (SCSI-3) LUN format, as
 *		described by scsi_lun_t, and a normalized lun64_t
 *              representation (used by Solaris SCSI_ADDR_PROP_LUN64
 *		"lun64" property). The normalized representation maps
 *		in a compatible way to SCSI-2 LUNs. See scsi_address.h
 *
 *              SCSI-3 LUNs are 64 bits. SCSI-2 LUNs are 3 bits (up to
 *              5 bits in non-compliant implementations). SCSI-3 will
 *              pass a (64-bit) scsi_lun_t, but we need a
 *              representation from which we can for example, make
 *              device names. For unit-address compatibility, we represent
 *		64-bit LUN numbers in such a way that they appear like they
 *		would have under SCSI-2. This means that the single level
 *              LUN number is in the lowest byte with the second,
 *              third, and fourth level LUNs represented in
 *              successively higher bytes. In particular, if (and only
 *              if) the first byte of a 64 bit LUN is zero, denoting
 *              "Peripheral Device Addressing Method" and "Bus
 *              Identifier" zero, then the target implements LUNs
 *              compatible in spirit with SCSI-2 LUNs (although under
 *              SCSI-3 there may be up to 256 of them). Under SCSI-3
 *              rules, a target is *required* to use this format if it
 *              contains 256 or fewer Logical Units, none of which are
 *              dependent logical units. These routines have knowledge
 *		of the structure and size of a scsi_lun_t.
 *
 * NOTE: We tolerate vendors that use "Single level LUN structure using
 * peripheral device addressing method" with a non-zero bus identifier
 * (spec says bus identifier must be zero).  Described another way, we let
 * the non-'addressing method' bits of sl_lun1_msb contribute to our lun64
 * value).
 */
scsi_lun64_t
scsi_lun_to_lun64(scsi_lun_t lun)
{
	scsi_lun64_t    lun64;

	/*
	 * Check to see if we have a single level lun that uses the
	 * "Peripheral Device" addressing method. If so, the lun64 value is
	 * kept in Solaris 'unit-address compatibility' form.
	 */
	if (((lun.sl_lun2_msb == 0) && (lun.sl_lun2_lsb == 0) &&
	    (lun.sl_lun3_msb == 0) && (lun.sl_lun3_lsb == 0) &&
	    (lun.sl_lun4_msb == 0) && (lun.sl_lun4_lsb == 0)) &&
	    ((lun.sl_lun1_msb & SCSI_LUN_AM_MASK) == SCSI_LUN_AM_PDEV)) {
		/*
		 * LUN has Solaris 'unit-address compatibility' form, construct
		 * lun64 value from non-'addressing method' bits of msb and lsb.
		 */
		lun64 = ((lun.sl_lun1_msb & ~SCSI_LUN_AM_MASK) << 8) |
		    lun.sl_lun1_lsb;
	} else {
		/*
		 * LUN does not have a Solaris 'unit-address compatibility'
		 * form, construct lun64 value in full 64 bit LUN format.
		 */
		lun64 =
		    ((scsi_lun64_t)lun.sl_lun1_msb << 56) |
		    ((scsi_lun64_t)lun.sl_lun1_lsb << 48) |
		    ((scsi_lun64_t)lun.sl_lun2_msb << 40) |
		    ((scsi_lun64_t)lun.sl_lun2_lsb << 32) |
		    ((scsi_lun64_t)lun.sl_lun3_msb << 24) |
		    ((scsi_lun64_t)lun.sl_lun3_lsb << 16) |
		    ((scsi_lun64_t)lun.sl_lun4_msb <<  8) |
		    (scsi_lun64_t)lun.sl_lun4_lsb;
	}
	return (lun64);
}

scsi_lun_t
scsi_lun64_to_lun(scsi_lun64_t lun64)
{
	scsi_lun_t	lun;

	if (lun64 <= (((0xFF & ~SCSI_LUN_AM_MASK) << 8) | 0xFF)) {
		/*
		 * lun64 is in Solaris 'unit-address compatibility' form.
		 */
		lun.sl_lun1_msb = SCSI_LUN_AM_PDEV | (lun64 >> 8);
		lun.sl_lun1_lsb = (uchar_t)lun64;
		lun.sl_lun2_msb = 0;
		lun.sl_lun2_lsb = 0;
		lun.sl_lun3_msb = 0;
		lun.sl_lun3_lsb = 0;
		lun.sl_lun4_msb = 0;
		lun.sl_lun4_lsb = 0;
	} else {
		/* lun64 is in full 64 bit LUN format. */
		lun.sl_lun1_msb = (uchar_t)(lun64 >> 56);
		lun.sl_lun1_lsb = (uchar_t)(lun64 >> 48);
		lun.sl_lun2_msb = (uchar_t)(lun64 >> 40);
		lun.sl_lun2_lsb = (uchar_t)(lun64 >> 32);
		lun.sl_lun3_msb = (uchar_t)(lun64 >> 24);
		lun.sl_lun3_lsb = (uchar_t)(lun64 >> 16);
		lun.sl_lun4_msb = (uchar_t)(lun64 >>  8);
		lun.sl_lun4_lsb = (uchar_t)(lun64);
	}
	return (lun);
}