cmd/luxadm/qlgcupdate.c

/*
 * 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.
 */

/*
 * I18N message number ranges
 *  This file: 21000 - 21499
 *  Shared common messages: 1 - 1999
 */

/*
 * Functions to support the download of FCode to PCI HBAs
 * Qlogic ISP21XX/22XX boards: FC100/P single port, ISP2200 dual port
 * and Emulex cards
 */
#include <errno.h>
#include <ctype.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <limits.h>
#include <signal.h>
#include <dirent.h>
#include <nl_types.h>
#include <utmpx.h>
#include <sys/mnttab.h>
#include <sys/file.h>
#include <sys/mtio.h>
#include <sys/scsi/impl/uscsi.h>
#include <sys/fibre-channel/fcio.h>
#include <stgcom.h>
#include <sys/scsi/adapters/ifpio.h>
#include <libdevinfo.h>
#include "luxadm.h"

/* Error codes - used by the fcode_load_file routine */
#define	FCODE_SUCCESS	    0	/* successful completion */
#define	FCODE_LOAD_FAILURE  1	/* general failure */
#define	FCODE_IOCTL_FAILURE 2	/* FCODE ioctl download failure */

#define	HBA_MAX	128
#define	FCODE_HDR 200
#define	MAX_RETRIES	3
#define	MAX_WAIT_TIME	30

/*
 * EMULEX Fcode attributes
 */
#define	EMULEX_FCODE_VERSION_LENGTH	16
#define	EMULEX_READ_BUFFER_SIZE		128

/* Emulex specific error codes */
#define	EMLX_ERRNO_START	0x100

/* Diagnostic error codes */
#define	EMLX_TEST_FAILED	(EMLX_ERRNO_START + 0)

/* Download image contains bad data */
#define	EMLX_IMAGE_BAD		(EMLX_ERRNO_START + 1)
/* Download image not compatible with current hardware */
#define	EMLX_IMAGE_INCOMPATIBLE	(EMLX_ERRNO_START + 2)
/* Unable to take adapter offline */
#define	EMLX_IMAGE_FAILED	(EMLX_ERRNO_START + 3)
/* Image download failed */
#define	EMLX_OFFLINE_FAILED	(EMLX_ERRNO_START + 4)


/*
 * This is just a random value chosen to identify Sbus Fcodes. Sbus FCode
 * for Ivory is based on a 2200 chip but this value does not reflect that.
 */
#define	SBUS_CHIP_ID	0x1969
#define	IVORY_BUS	"/sbus@"
#define	IVORY_DRVR	"/SUNW,qlc@"

/*	Global variables	*/
static char	fc_trans[] = "SUNW,ifp";	/* fibre channel transport */
static char	fp_trans[] = "SUNW,qlc";	/* fca layer driver	   */
static char	fp_trans_id[] = "fp@";		/* transport layer id	   */
static char	qlgc2100[] = "FC100/P";		/* product name for 2100   */
static char	qlgc2200[] = "ISP2200";		/* product name for 2200   */
static char	qlgc2300[] = "ISP2300";		/* product name for 2300   */
static char	qlgc2312[] = "ISP2312";		/* product name for 2312   */
/*
 * The variable qlgc2200Sbus represents the string which is always the
 * starting string of the version information in an ISP2200 Sbus Fcode.
 */
static char	qlgc2200Sbus[] = "ISP2200 Sbus FC-AL Host Adapter Driver";
static char	pcibus_list[HBA_MAX][PATH_MAX];
/*	Internal functions	*/
static int	q_load_file(int, char *);
static int	q_getbootdev(uchar_t *);
static int	q_getdevctlpath(char *, int *);
static int	q_warn(int);
static int	q_findversion(int, int, uchar_t *, uint16_t *);
static int	q_findfileversion(char *, uchar_t *, uint16_t *, int, int *);
static int	q_findSbusfile(int, int *);
static int	memstrstr(char *, char *, int, int);
static int	fcode_load_file(int, char *, int *);

/*
 * Functions to support Fcode download for Emulex HBAs
 */
static int	emulex_fcodeversion(di_node_t, uchar_t *);
static void	handle_emulex_error(int, char *);

/*
 * Searches for and updates the cards.	This is the "main" function
 * and will give the output to the user by calling the subfunctions.
 * args: FCode file; if NULL only the current FCode version is printed
 */
int
q_qlgc_update(unsigned int verbose, char *file)
/*ARGSUSED*/
{
	int fd, fcode_fd = -1, errnum = 0, devcnt = 0, retval = 0, isSbus = 0;
	int sbus_off;
	uint_t i, fflag = 0;
	uint16_t chip_id = 0, file_id = 0;
	uchar_t fcode_buf[FCODE_HDR];
	static uchar_t	bootpath[PATH_MAX];
	static uchar_t	version[MAXNAMELEN], version_file[MAXNAMELEN];
	char devpath[PATH_MAX], tmppath[PATH_MAX];
	void	(*sigint)(); /* to store default SIGTERM setting */
	static struct	utmpx *utmpp = NULL; /* pointer for getutxent() */
	char *ptr1, *ptr2;
	char phys_path[PATH_MAX];
	/*
	 * The variables port1 and port2 are used to store the bus id
	 * e.g. the bus id for this path:
	 * /devices/sbus@12,0/SUNW,qlc@2,30000/fp@0,0:devctl
	 * is "sbus@12". They are initialized to a random value and are
	 * set such that they are not equal initially.
	 */
	static char port1[MAXNAMELEN] = {NULL};
	static char port2[MAXNAMELEN] = {NULL};

	if (file) {
		fflag++;

		/* check for a valid file */
		if ((fcode_fd = open(file, O_RDONLY)) < 0) {
			(void) fprintf(stderr,
			    MSGSTR(21000, "Error: Could not open %s\n"), file);
			return (1);
		}
		if (read(fcode_fd, fcode_buf, FCODE_HDR) != FCODE_HDR) {
			perror(MSGSTR(21001, "read"));
			(void) close(fcode_fd);
			return (1);
		}

		/*
		 * Check if it's SBUS FCode by calling q_findSbusfile
		 * if it is then isSbus will be 1, if not it will be 0
		 * in case of an error, it will be -1
		 */
		isSbus = q_findSbusfile(fcode_fd, &sbus_off);
		if (isSbus == -1) {
			(void) close(fcode_fd);
			return (1);
		}

		/*
		 * FCode header check - make sure it's PCI FCode
		 * Structure of FCode header (byte# refers to byte numbering
		 * in FCode spec, not the byte# of our fcode_buf buffer):
		 * header	byte 00	   0x55	 prom signature byte one
		 *		byte 01	   0xaa	 prom signature byte two
		 * data		byte 00-03 P C I R
		 * OR
		 * header	byte 32	   0x55
		 *		byte 33	   0xaa
		 * data		byte 60-63 P C I R
		 * The second format with an offset of 32 is used for ifp prom
		 */
		if (!(((fcode_buf[0x00] == 0x55) &&
		    (fcode_buf[0x01] == 0xaa) &&
		    (fcode_buf[0x1c] == 'P') &&
		    (fcode_buf[0x1d] == 'C') &&
		    (fcode_buf[0x1e] == 'I') &&
		    (fcode_buf[0x1f] == 'R')) ||

		    ((fcode_buf[0x20] == 0x55) &&
		    (fcode_buf[0x21] == 0xaa) &&
		    (fcode_buf[0x3c] == 'P') &&
		    (fcode_buf[0x3d] == 'C') &&
		    (fcode_buf[0x3e] == 'I') &&
		    (fcode_buf[0x3f] == 'R')) ||

		    (isSbus))) {
			(void) fprintf(stderr, MSGSTR(21002,
			    "Error: %s is not a valid FC100/P, "
			    "ISP2200, ISP23xx FCode file.\n"),
			    file);
			(void) close(fcode_fd);
			return (1);
		}

		/* check for single user mode */
		while ((utmpp = getutxent()) != NULL) {
			if (strstr(utmpp->ut_line, "run-level") &&
			    (strcmp(utmpp->ut_line, "run-level S") &&
				strcmp(utmpp->ut_line, "run-level 1"))) {
				if (q_warn(1)) {
					(void) endutxent();
					(void) close(fcode_fd);
					return (1);
				}
				break;
			}
		}
		(void) endutxent();

		/* get bootpath */
		if (!q_getbootdev((uchar_t *)&bootpath[0]) &&
		    getenv("_LUX_D_DEBUG") != NULL) {
			(void) fprintf(stdout, "  Bootpath: %s\n", bootpath);
		}
	}
	/*
	 * Get count of, and names of PCI slots with ifp device control
	 * (devctl) nodes.  Search /devices.
	 */
	(void) strcpy(devpath, "/devices");
	if (q_getdevctlpath(devpath, (int *)&devcnt) == 0) {
		(void) fprintf(stdout, MSGSTR(21003,
		"\n  Found Path to %d FC100/P, ISP2200, ISP23xx Devices\n"),
			devcnt);
	} else {
		(void) fprintf(stderr, MSGSTR(21004,
		"Error: Could not get /devices path to FC100/P,"
		"ISP2200, ISP23xx Cards.\n"));
		retval++;
	}

	for (i = 0; i < devcnt; i++) {

		(void) strncpy((char *)phys_path, &pcibus_list[i][0],
				strlen(&pcibus_list[i][0]));
		if (fflag && (strstr((char *)bootpath,
		    strtok((char *)phys_path, ":")) != NULL)) {
			(void) fprintf(stderr,
			    MSGSTR(21005, "Ignoring %s (bootpath)\n"),
			    &pcibus_list[i][0]);
			continue;
		}

		(void) fprintf(stdout,
		MSGSTR(21006, "\n  Opening Device: %s\n"), &pcibus_list[i][0]);
		/* Check if the device is valid */
		if ((fd = open(&pcibus_list[i][0], O_RDWR)) < 0) {
			(void) fprintf(stderr,
			    MSGSTR(21000, "Error: Could not open %s\n"),
			    &pcibus_list[i][0]);
			retval++;
			continue;
		}
		(void) close(fd);
		/*
		 * Check FCode version present on the adapter (at last boot)
		 */
		if (q_findversion(verbose, i, (uchar_t *)&version[0],
		    &chip_id) == 0) {
			if (strlen((char *)version) == 0) {
				(void) fprintf(stdout, MSGSTR(21007,
	"  Detected FCode Version:\tNo version available for this FCode\n"));
			} else {
			(void) fprintf(stdout, MSGSTR(21008,
			    "  Detected FCode Version:\t%s\n"), version);
			}
		} else {
			chip_id = 0x0;
		}

		if (fflag) {
			/*
			 * For ISP2200, Sbus HBA, do just 1 download
			 * for both the ports (dual port HBA)
			 * Here it is assumed that readdir() always
			 * returns the paths in pcibus_list[] in the
			 * sorted order.
			 */
			(void) strcpy(tmppath, pcibus_list[i]);
			if (ptr1 = strstr(tmppath, IVORY_BUS)) {
				if (ptr2 = strstr(ptr1, IVORY_DRVR)) {
					ptr2 = strchr(ptr2, ',');
					if (ptr2 = strchr(++ptr2, ',')) {
						*ptr2 = '\0';
					}
				}
				(void) strcpy(port2, ptr1);
				if (strcmp(port1, port2) == 0) {
				    (void) fprintf(stdout, MSGSTR(21037,
				    "/n New FCode has already been downloaded "
				    "to this ISP2200 SBus HBA Card.\n"
				    "It is sufficient to download to one "
				    "port of the ISP2200 SBus HBA Card. "
				    "Moving on...\n"));
					continue;
				}
			}
			/*
			 * Check version of the supplied FCode file (once)
			 */
			if ((file_id != 0 && version_file != NULL) ||
			    (q_findfileversion((char *)
			    &fcode_buf[0], (uchar_t *)&version_file[0],
			    &file_id, isSbus, &sbus_off) == 0)) {
				(void) fprintf(stdout, MSGSTR(21009,
				    "  New FCode Version:\t\t%s\n"),
				    version_file);
			} else {
				(void) close(fcode_fd);
				return (1);
			}

			/*
			 * Load the New FCode
			 * Give warning if file doesn't appear to be correct
			 *
			 */
			if (chip_id == 0) {
				errnum = 2; /* can't get chip_id */
				retval++;
			} else if (chip_id - file_id != 0) {
				errnum = 3; /* file/card mismatch */
				retval++;
			} else {
				errnum = 0; /* everything is ok */
			}

			if (!q_warn(errnum)) {
				/* Disable user-interrupt Control-C */
				sigint =
				    (void (*)(int)) signal(SIGINT, SIG_IGN);

				/* Load FCode */
				(void) fprintf(stdout, MSGSTR(21010,
				    "  Loading FCode: %s\n"), file);

				if (q_load_file(fcode_fd,
				    &pcibus_list[i][0]) == 0) {
					(void) fprintf(stdout, MSGSTR(21011,
					"  Successful FCode download: %s\n"),
					    &pcibus_list[i][0]);
					(void) strcpy(port1, port2);
				} else {
					(void) fprintf(stderr, MSGSTR(21012,
					"Error: FCode download failed: %s\n"),
							&pcibus_list[i][0]);
					retval++;
				}
				/* Restore SIGINT (user interrupt) setting */
				(void) signal(SIGINT, sigint);
			}
		}
	}
	(void) fprintf(stdout, "  ");
	(void) fprintf(stdout, MSGSTR(125, "Complete\n"));
	if (fcode_fd != -1)
		(void) close(fcode_fd);
	return (retval);
}


/*
 * Retrieve the version banner from the card
 *    uses ioctl: FCIO_FCODE_MCODE_VERSION	FCode revision
 */
static int
q_findversion(int verbose, int index, uchar_t *version, uint16_t *chip_id)
/*ARGSUSED*/
{
	int fd, ntries;
	struct	ifp_fm_version *version_buffer = NULL;
	char	prom_ver[100] = {NULL};
	char	mcode_ver[100] = {NULL};
	fcio_t	fcio;

	if (strstr(&pcibus_list[index][0], fc_trans)) {

	if ((fd = open(&pcibus_list[index][0], O_RDWR)) < 0) {
		(void) fprintf(stderr,
		    MSGSTR(21000, "Error: Could not open %s\n"),
		    &pcibus_list[index][0]);
		return (1);
	}

	if ((version_buffer = (struct ifp_fm_version *)malloc(
		sizeof (struct ifp_fm_version))) == NULL) {
		(void) fprintf(stderr,
		    MSGSTR(21013, "Error: Memory allocation failed\n"));
		(void) close(fd);
		return (1);
	}

	version_buffer->fcode_ver = (char *)version;
	version_buffer->mcode_ver = mcode_ver;
	version_buffer->prom_ver = prom_ver;
	version_buffer->fcode_ver_len = MAXNAMELEN - 1;
	version_buffer->mcode_ver_len = 100;
	version_buffer->prom_ver_len = 100;

	if (ioctl(fd, FCIO_FCODE_MCODE_VERSION, version_buffer) < 0) {
		(void) fprintf(stderr, MSGSTR(21014,
		"Error: Driver interface FCIO_FCODE_MCODE_VERSION failed\n"));
		free(version_buffer);
		(void) close(fd);
		return (1);
	}
	version[version_buffer->fcode_ver_len] = '\0';

	/* Need a way to get card MCODE (firmware) to track certain HW bugs */
	if (getenv("_LUX_D_DEBUG") != NULL) {
		(void) fprintf(stdout, "  Device %i: QLGC chip_id %x\n",
		    index+1, *chip_id);
		(void) fprintf(stdout, "  FCode:%s\n  MCODE:%s\n  PROM:%s\n",
		    (char *)version, mcode_ver, prom_ver);
	}
	free(version_buffer);

	} else if (strstr(&pcibus_list[index][0], fp_trans)) {
		/*
		 * Get the fcode and prom's fw version
		 * using the fp ioctls. Currently, we pass
		 * only the fcode version to the calling function
		 * and ignore the FW version (using the existing
		 * implementation).
		 */

		if ((fd = open(&pcibus_list[index][0], O_RDWR)) < 0) {
			(void) fprintf(stderr,
			    MSGSTR(4511, "Could not open %s\n"),
			    &pcibus_list[index][0]);
			(void) close(fd);
			return (1);
		}
		/* Get the fcode version */
		bzero(version, sizeof (version));
		fcio.fcio_cmd = FCIO_GET_FCODE_REV;
		/* Information read operation */
		fcio.fcio_xfer = FCIO_XFER_READ;
		fcio.fcio_obuf = (caddr_t)version;
		fcio.fcio_olen = MAXNAMELEN;

		for (ntries = 0; ntries < MAX_RETRIES; ntries++) {
			if (ioctl(fd, FCIO_CMD, &fcio) != 0) {
				if ((errno == EAGAIN) &&
				    (ntries+1 < MAX_RETRIES)) {
					/* wait 30 secs */
					(void) sleep(MAX_WAIT_TIME);
					continue;
				}
				(void) close(fd);
				return (L_FCIO_GET_FCODE_REV_FAIL);
			}
			break;
		}
		version[MAXNAMELEN-1] = '\0';
	}

	/* Get type of card from product name in FCode version banner */
	if (strstr((char *)version, qlgc2100)) {
		*chip_id = 0x2100;
	} else if (strstr((char *)version, qlgc2200)) {
		*chip_id = 0x2200;
		if (strstr((char *)version, "Sbus")) {
			*chip_id = SBUS_CHIP_ID;
		}
	} else if (strstr((char *)version, qlgc2300)) {
		*chip_id = 0x2300;
	} else if (strstr((char *)version, qlgc2312)) {
		*chip_id = 0x2312;
	} else {
		*chip_id = 0x0;
	}

	(void) close(fd);
	return (0);
}

/*
 * Retrieve the version banner and file type (2100 or 2200) from the file
 */
static int
q_findfileversion(char *dl_fcode, uchar_t *version_file, uint16_t *file_id,
		    int isSbus, int *sbus_offset)
{
	int mark;
	int qlc_offset = 0;
	char temp[4] = {NULL};


	/*
	 * Get file version from FCode for 2100 or 2202
	 */
	if (isSbus) {
		*file_id = SBUS_CHIP_ID;
	} else {
		if ((dl_fcode[0x23] == 0x22) ||
		    (dl_fcode[0x23] == 0x23)) {
			*file_id = dl_fcode[0x22] & 0xff;
			*file_id |= (dl_fcode[0x23] << 8) & 0xff00;
		} else {
			*file_id = dl_fcode[0x42] & 0xff;
			*file_id |= (dl_fcode[0x43] << 8) & 0xff00;
		}
	}

	/*
	 * Ok, we're just checking for 2200 here. If it is we need
	 * to offset to find the banner.
	 */
	if ((*file_id == 0x2200) ||
	    (*file_id == 0x2300) ||
	    (*file_id == 0x2312)) {
		qlc_offset = -32;
	}

	/*
	 * If this is an ISP2200 Sbus Fcode file, then search for the string
	 * "ISP2200 FC-AL Host Adapter Driver" in the whole fcode file
	 */
	if (isSbus) {
		*file_id = SBUS_CHIP_ID;
		qlc_offset = *sbus_offset;
		/* Subtract 111 from the offset we add below for PCI Fcodes */
		qlc_offset -= 111;
	}

	/* Banner length varies; grab banner to end of date marker yr/mo/da */
	version_file[0] = '\0';
	for (mark = (111 + qlc_offset); mark < (191 + qlc_offset); mark++) {
		(void) strncpy(temp, (char *)&dl_fcode[mark], 4);
		if ((strncmp(&temp[0], "/", 1) == 0) &&
		    (strncmp(&temp[3], "/", 1) == 0)) {
			(void) strncat((char *)version_file,
			    (char *)&dl_fcode[mark], 6);
			break;
		}
		(void) strncat((char *)version_file, temp, 1);
	}
	return (0);
}

/*
 * Find if the FCode file is a ISP2200 SBUS Fcode file
 */
static int
q_findSbusfile(int fd, int *sbus_offset)
{
	static int file_size;
	char *sbus_info;
	struct stat statinfo;

	if (lseek(fd, 0, SEEK_SET) == -1) {
		perror(MSGSTR(21022, "seek"));
		return (-1);
	}
	if (fstat(fd, &statinfo)) {
		perror(MSGSTR(21023, "fstat"));
		return (-1);
	}
	file_size = statinfo.st_size;

	if ((sbus_info = (char *)malloc(file_size)) == NULL) {
		(void) fprintf(stderr,
		    MSGSTR(21013, "Error: Memory allocation failed\n"));
		return (-1);
	}

	if (read(fd, sbus_info, file_size) < 0) {
		perror(MSGSTR(21001, "read"));
		free(sbus_info);
		return (-1);
	}

	/*
	 * Search for the version string in the whole file
	 */
	if ((*sbus_offset = memstrstr((char *)sbus_info, qlgc2200Sbus,
			    file_size, strlen(qlgc2200Sbus))) != -1) {
		free(sbus_info);
		return (1);
	} else {
		free(sbus_info);
		return (0);
	}
}


/*
 * Build a list of all the devctl entries for all the 2100/2200 based adapters
 */
static int
q_getdevctlpath(char *devpath, int *devcnt)
{
	struct stat	statbuf;
	struct dirent	*dirp = NULL;
	DIR		*dp = NULL;
	char		*ptr = NULL;
	int		err = 0;
	int		testopen;

	if (lstat(devpath, &statbuf) < 0) {
		(void) fprintf(stderr,
		    MSGSTR(21016, "Error: %s lstat() error\n"), devpath);
		return (1);
	}

	if ((strstr(devpath, fc_trans) ||
	    (strstr(devpath, fp_trans_id) && strstr(devpath, fp_trans))) &&
	    strstr(devpath, "devctl")) {
		/* Verify the path is valid */
		if ((testopen = open(devpath, O_RDONLY)) >= 0) {
			(void) close(testopen);
			(void) strcpy(pcibus_list[*devcnt], devpath);
			*devcnt += 1;
			return (0);
		}
	}

	if (S_ISDIR(statbuf.st_mode) == 0) {
		/*
		 * not a directory so
		 * we don't care about it - return
		 */
		return (0);
	}

	/*
	 * It's a directory. Call ourself to
	 * traverse the path(s)
	 */
	ptr = devpath + strlen(devpath);
	*ptr++ = '/';
	*ptr = 0;

	/* Forget the /devices/pseudo/ directory */
	if (strcmp(devpath, "/devices/pseudo/") == 0) {
		return (0);
	}

	if ((dp = opendir(devpath)) == NULL) {
		(void) fprintf(stderr,
		    MSGSTR(21017, "Error: %s Can't read directory\n"), devpath);
		return (1);
	}

	while ((dirp = readdir(dp)) != NULL) {

		if (strcmp(dirp->d_name, ".") == 0 ||
		    strcmp(dirp->d_name, "..") == 0) {
			continue;
		}
		(void) strcpy(ptr, dirp->d_name); /* append name */
		err = q_getdevctlpath(devpath, devcnt);
	}

	if (closedir(dp) < 0) {
		(void) fprintf(stderr,
		MSGSTR(21018, "Error: Can't close directory %s\n"), devpath);
		return (1);
	}
	return (err);
}

/*
 * Get the boot device.	 Cannot load FCode to current boot device.
 * Boot devices under volume management will prompt a warning.
 */
static int
q_getbootdev(uchar_t *bootpath)
{
	struct mnttab mp;
	struct mnttab mpref;
	FILE *fp = NULL;
	static char buf[BUFSIZ];
	char *p = NULL, *p1 = NULL;  /* p = full device, p1 = chunk to rm */
	char *slot = ":devctl";
	char *root = "/";

	if ((fp = fopen(MNTTAB, "r")) == NULL) {
		(void) fprintf(stderr,
		    MSGSTR(21000, "Error: Could not open %s\n"), MNTTAB);
		return (1);
	}

	mntnull(&mpref);
	mpref.mnt_mountp = (char *)root;

	if (getmntany(fp, &mp, &mpref) != 0 ||
	    mpref.mnt_mountp == NULL) {
		(void) fprintf(stderr, MSGSTR(21019,
		    "Error: Cannot get boot device, check %s.\n"), MNTTAB);
		(void) fclose(fp);
		return (1);
	}
	(void) fclose(fp);

	/*
	 * If we can't get a link, we may be dealing with a volume mgr
	 * so give a warning.  If a colon is present, we likely have a
	 * non-local disk or cd-rom, so no warning is necessary.
	 * e.g. /devices/pci@1f,4000/scsi@3/sd@6,0:b (cdrom, no link) or
	 *	storage-e4:/blah/blah remote boot server
	 */
	if (readlink(mp.mnt_special, buf, BUFSIZ) < 0) {
		if (strstr(mp.mnt_special, ":") == NULL) {
			(void) fprintf(stderr, MSGSTR(21020,
	"\nWarning: Cannot read boot device link, check %s.\n"), MNTTAB);
			(void) fprintf(stderr, MSGSTR(21021,
	"Do not upgrade FCode on adapters controlling the boot device.\n"));
		}
		return (1);
	}
	/*
	 * Copy boot device path to bootpath.  First remove leading
	 * path junk (../../..) then if it's an ifp device, chop off
	 * the disk and add the devctl to the end of the path.
	 */
	if (p = strstr(buf, "/devices")) {
		if (strstr(buf, fc_trans) != NULL) {
			p1 = strrchr(p, '/');
			*p1 = '\0';
		}
	}
	(void) strcpy((char *)bootpath, (char *)p);
	if (p1) {
		(void) strcat((char *)bootpath, slot);
	}
	return (0);
}

/*
 * Load FCode to card.
 *    uses ioctl: IFPIO_FCODE_DOWNLOAD
 */
static int
q_load_file(int fcode_fd, char *device)
{
	static int	dev_fd, fcode_size;
	struct stat	stat;
	ifp_download_t	*download_p = NULL;
	fcio_t		fcio;
	uint16_t	file_id = 0;
	uchar_t		*bin;

	if (lseek(fcode_fd, 0, SEEK_SET) == -1) {
		perror(MSGSTR(21022, "seek"));
		(void) close(fcode_fd);
		return (1);
	}
	if (fstat(fcode_fd, &stat) == -1) {
		perror(MSGSTR(21023, "fstat"));
		(void) close(fcode_fd);
		return (1);
	}

	fcode_size = stat.st_size;

	if (strstr(device, fc_trans)) {
		if ((download_p = (ifp_download_t *)malloc(
			sizeof (ifp_download_t) + fcode_size)) == NULL) {
			(void) fprintf(stderr,
			    MSGSTR(21013, "Error: Memory allocation failed\n"));
			(void) close(fcode_fd);
			return (1);
		}
	} else {
		if ((bin = (uchar_t *)malloc(fcode_size)) == NULL) {
			(void) fprintf(stderr,
			    MSGSTR(21013, "Error: Memory allocation failed\n"));
			(void) close(fcode_fd);
			return (1);
		}
	}

	if (strstr(device, fc_trans)) {
		if (read(fcode_fd, download_p->dl_fcode, fcode_size)
		    != fcode_size) {
			perror(MSGSTR(21001, "read"));
			free(download_p);
			(void) close(fcode_fd);
			return (1);
		}
	} else {
		if (read(fcode_fd, bin, fcode_size)
		    != fcode_size) {
			perror(MSGSTR(21001, "read"));
			free(bin);
			(void) close(fcode_fd);
			return (1);
		}
	}


	if ((dev_fd = open(device, O_RDWR|O_EXCL)) < 0) {
		(void) fprintf(stderr,
		    MSGSTR(21000, "Error: Could not open %s\n"), device);
		free(download_p);
		return (1);
	}
	if (strstr(device, fc_trans)) {
		download_p->dl_fcode_len = fcode_size;
		file_id = download_p->dl_fcode[0x42] & 0xff;
		file_id |= (download_p->dl_fcode[0x43] << 8) & 0xff00;
		download_p->dl_chip_id = file_id;
		if (ioctl(dev_fd, IFPIO_FCODE_DOWNLOAD, download_p) < 0) {
			(void) fprintf(stderr, MSGSTR(21024,
		    "Error: Driver interface IFPIO_FCODE_DOWNLOAD failed\n"));
			free(download_p);
			(void) close(dev_fd);
			return (1);
		}
		free(download_p);
	} else if (strstr(device, fp_trans)) {
		fcio.fcio_cmd = FCIO_DOWNLOAD_FCODE;
		/* Information read operation */
		fcio.fcio_xfer = FCIO_XFER_WRITE;
		fcio.fcio_ibuf = (caddr_t)bin;
		fcio.fcio_ilen = fcode_size;

		if (ioctl(dev_fd, FCIO_CMD, &fcio) != 0) {
			(void) fprintf(stderr, MSGSTR(21036,
		    "Error: Driver interface FCIO_DOWNLOAD_FCODE failed\n"));
			free(download_p);
			(void) close(dev_fd);
			return (1);
		}
		free(bin);
	}
	(void) close(dev_fd);
	return (0);
}

/*
 * Issue warning strings and loop for Yes/No user interaction
 *    err# 0 -- we're ok, warn for pending FCode load
 *	   1 -- not in single user mode
 *	   2 -- can't get chip_id
 *	   3 -- card and file do not have same type (2100/2200)
 */
static int
q_warn(int errnum)
{
	char input[1024];
	input[0] = '\0';

	if (errnum == 1) {
		(void) fprintf(stderr, MSGSTR(21025,
		    "\nWarning: System is not in single-user mode.\n"));
		(void) fprintf(stderr, MSGSTR(21026,
	"Loading FCode will reset the adapter and terminate I/O activity\n"));
	} else {
		if (errnum == 2) {
			(void) fprintf(stderr, MSGSTR(21027,
			"  Warning: FCode is missing or existing FCode has"
			" unrecognized version.\n"));
			return (1);
		} else if (errnum == 3) {
			(void) fprintf(stderr, MSGSTR(21028,
			"  Warning: New FCode file version does not match this"
			" board type. Skipping...\n"));
			return (1);
		}
		(void) fprintf(stderr, MSGSTR(21029,
		"\nWARNING!! This program will update the FCode in this"
		" FC100/PCI, ISP2200/PCI, ISP23xx/PCI "
		" and Emulex devices.\n"));
		(void) fprintf(stderr, MSGSTR(21030,
		"This may take a few (5) minutes. Please be patient.\n"));
	}

loop1:
	(void) fprintf(stderr, MSGSTR(21031,
		"Do you wish to continue ? (y/n) "));

	(void) gets(input);

	if ((strcmp(input, MSGSTR(21032, "y")) == 0) ||
			(strcmp(input, MSGSTR(40, "yes")) == 0)) {
		return (0);
	} else if ((strcmp(input, MSGSTR(21033, "n")) == 0) ||
			(strcmp(input, MSGSTR(45, "no")) == 0)) {
		(void) fprintf(stderr,
		    MSGSTR(21034, "Not Downloading FCode\n"));
		return (1);
	} else {
		(void) fprintf(stderr, MSGSTR(21035, "Invalid input\n"));
		goto loop1;
	}
}

/*
 * Name	   : memstrstr
 * Input   : pointer to buf1, pointer to buf2, size of buf1, size of buf2
 * Returns :
 *	Offset of the start of contents-of-buf2 in buf1 if it is found
 *	-1 if buf1 does not contain contents of buf2
 * Synopsis:
 * This function works similar to strstr(). The difference is that null
 * characters in the buffer are treated like any other character. So, buf1
 * and buf2 can have embedded null characters in them.
 */
static int
memstrstr(char *s1, char *s2, int size1, int size2)
{
	int count1, count2;
	char *s1_ptr, *s2_ptr;

	count1 = size1; count2 = size2;
	s1_ptr = s1; s2_ptr = s2;

	if ((size2 == 0)||(size1 == 0))
		return (-1);

	for (count1 = 0; count1 < (size1 - size2 + 1); count1++) {
		if (*s1_ptr++ == *s2_ptr++) {
			if (--count2 == 0) {
				return (count1 - size2 + 1);
			}
			continue;
		}
		count2 = size2;
		s2_ptr = s2;
	}

	return (-1);
}

/*
 * generic fcode load file routine.  given a file descriptor to a fcode file
 * this routine will issue the FCIO_DOWNLOAD_FCODE ioctl to the given
 * device.  Any ioctl errors will be returned in fcio_errno
 *
 * Arguments:
 *	fcode_fd    file descriptor to a fcode file
 *	device	    path to the device we will be downloading the fcode onto
 *	fcio_errno  pointer to an int that will be used to return any errors
 *			back to the caller
 * Retrurn Values:
 *	0	    successful download
 *	>0	    otherwise
 */
static int
fcode_load_file(int fcode_fd, char *device, int *fcio_errno)
{

	fcio_t		fcio;
	static int	dev_fd, fcode_size;
	uchar_t		*bin;
	struct stat	stat;

	if (device == NULL || fcio_errno == NULL) {
		return (FCODE_LOAD_FAILURE);
	}

	*fcio_errno = 0;
	if (lseek(fcode_fd, 0, SEEK_SET) == -1) {
		perror(MSGSTR(21022, "seek"));
		return (FCODE_LOAD_FAILURE);
	}

	if (fstat(fcode_fd, &stat) == -1) {
		perror(MSGSTR(21023, "fstat"));
		return (FCODE_LOAD_FAILURE);
	}

	fcode_size = stat.st_size;

	if ((bin = (uchar_t *)malloc(fcode_size)) == NULL) {
		(void) fprintf(stderr,
		    MSGSTR(21013, "Error: Memory allocation failed\n"));
		return (FCODE_LOAD_FAILURE);
	}

	if (read(fcode_fd, bin, fcode_size)
	    != fcode_size) {
		perror(MSGSTR(21001, "read"));
		free(bin);
		return (FCODE_LOAD_FAILURE);
	}

	if ((dev_fd = open(device, O_RDWR|O_EXCL)) < 0) {
		(void) fprintf(stderr,
		    MSGSTR(21122, "Error: Could not open %s, failed "
			    "with errno %d\n"), device, errno);
		free(bin);
		return (FCODE_LOAD_FAILURE);
	}

	fcio.fcio_cmd = FCIO_DOWNLOAD_FCODE;
	fcio.fcio_xfer = FCIO_XFER_WRITE;
	fcio.fcio_ibuf = (caddr_t)bin;
	fcio.fcio_ilen = fcode_size;

	if (ioctl(dev_fd, FCIO_CMD, &fcio) != 0) {
		(void) close(dev_fd);
		*fcio_errno = fcio.fcio_errno;
		free(bin);
		return (FCODE_IOCTL_FAILURE);
	}

	free(bin);
	(void) close(dev_fd);
	return (FCODE_SUCCESS);
}

/*
 * Searches for and updates the fcode for Emulex HBA cards
 * args: FCode file; if NULL only the current FCode
 * version is printed
 */

int
emulex_update(char *file)
{

	int		fd, retval = 0;
	int		devcnt = 0;
	uint_t		state = 0, fflag = 0;
	static uchar_t	bootpath[PATH_MAX];
	int		fcode_fd = -1;
	static struct	utmpx *utmpp = NULL;
	di_node_t	root;
	di_node_t	node, sib_node, count_node;
	di_minor_t	minor_node;
	char		phys_path[PATH_MAX], *path;
	int		errnum = 0, fcio_errno = 0;
	static uchar_t	prom_ver_data[MAXNAMELEN];
	static char	ver_file[EMULEX_FCODE_VERSION_LENGTH];
	void		(*sigint)();
	int		prop_entries = -1;
	int		*port_data = NULL;

	if (file) {
		/* set the fcode download flag */
		fflag++;

		/* check for a valid file */
		if ((fcode_fd = open(file, O_RDONLY)) < 0) {
			(void) fprintf(stderr,
			    MSGSTR(21118, "Error: Could not open %s, failed "
				    "with errno %d\n"), file, errno);
			return (1);
		}

		/* check for single user mode */
		while ((utmpp = getutxent()) != NULL) {
			if (strstr(utmpp->ut_line, "run-level") &&
				(strcmp(utmpp->ut_line, "run-level S") &&
				strcmp(utmpp->ut_line, "run-level 1"))) {
				if (q_warn(1)) {
					(void) endutxent();
					(void) close(fcode_fd);
					return (1);
				}
				break;
			}
		}
		(void) endutxent();

		/* get bootpath */
		if (!q_getbootdev((uchar_t *)&bootpath[0]) &&
		    getenv("_LUX_D_DEBUG") != NULL) {
			(void) fprintf(stdout, "  Bootpath: %s\n", bootpath);
		}
	}

	/*
	 * Download the Fcode to all the emulex cards found
	 */

	/* Create a snapshot of the kernel device tree */
	if ((root = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
		(void) fprintf(stderr, MSGSTR(21114,
		"Error: Could not get /devices path to "
		"Emulex Devices.\n"));
		retval++;
	}

	/* point to first node which matches emulex driver */
	node = di_drv_first_node("emlxs", root);

	if (node == DI_NODE_NIL) {
		/*
		 * Could not find any emulex cards
		 */
		(void) di_fini(root);
		(void) fprintf(stderr, MSGSTR(21115,
		"\n  Found Path to %d Emulex Devices.\n"), devcnt);
		retval++;
	} else {
		count_node = node;
		while (count_node != DI_NODE_NIL) {
			state = di_state(count_node);
			if ((state & DI_DRIVER_DETACHED)
			    != DI_DRIVER_DETACHED) {
				sib_node = di_child_node(count_node);
				while (sib_node != DI_NODE_NIL) {
					state = di_state(sib_node);
					if ((state & DI_DRIVER_DETACHED) !=
					    DI_DRIVER_DETACHED) {
						/* Found an attached node */
						prop_entries =
						    di_prop_lookup_ints(
						    DDI_DEV_T_ANY, sib_node,
						    "port", &port_data);
						if (prop_entries != -1) {
							devcnt++;
							break;
						}
					}

					sib_node = di_sibling_node(sib_node);
				}
			}
			count_node = di_drv_next_node(count_node);
		}
		(void) fprintf(stdout, MSGSTR(21116,
		"\n  Found Path to %d Emulex Devices.\n"), devcnt);
	}


	/*
	 * Traverse device tree to find all emulex cards
	 */
	while (node != DI_NODE_NIL) {

		state = di_state(node);
		if ((state & DI_DRIVER_DETACHED) == DI_DRIVER_DETACHED) {
			node = di_drv_next_node(node);
			continue;
		}

		sib_node = di_child_node(node);
		while (sib_node != DI_NODE_NIL) {
			state = di_state(sib_node);
			if ((state & DI_DRIVER_DETACHED) !=
			    DI_DRIVER_DETACHED) {

				/* Found an attached node */
				prop_entries = di_prop_lookup_ints(
				    DDI_DEV_T_ANY, sib_node,
				    "port", &port_data);
				if (prop_entries != -1) {

					/* Found a node with "port" property */
					minor_node = di_minor_next(sib_node,
					    DI_MINOR_NIL);
					break;
				}
			}
			sib_node = di_sibling_node(sib_node);
		}

		if (sib_node == DI_NODE_NIL) {
			goto try_next;
		}

		path = di_devfs_path(sib_node);
		(void) strcpy(phys_path, "/devices");
		(void) strncat(phys_path, path, strlen(path));
		di_devfs_path_free(path);

		if (fflag && (strstr((char *)bootpath,
		    (char *)phys_path) != NULL)) {
			(void) fprintf(stderr,
			    MSGSTR(21117, "Ignoring %s (bootpath)\n"),
			    phys_path);
			node = di_drv_next_node(node);
			continue;
		}

		if (minor_node) {
			(void) strncat(phys_path, ":", 1);
			(void) strncat(phys_path,
				di_minor_name(minor_node),
				strlen(di_minor_name(minor_node)));
		}

		(void) fprintf(stdout,
				MSGSTR(21107, "\n  Opening Device: %s\n"),
				phys_path);

		/* Check if the device is valid */
		if ((fd = open(phys_path, O_RDWR)) < 0) {
			(void) fprintf(stderr,
			    MSGSTR(21121, "Error: Could not open %s, failed "
				    "with errno %d\n"), phys_path, errno);
			retval++;
			node = di_drv_next_node(node);
			continue;
		}

		(void) close(fd);

		/*
		 * Check FCode version present on the adapter
		 * (at last boot)
		 */
		memset(prom_ver_data, 0, sizeof (prom_ver_data));
		if (emulex_fcodeversion(node, (uchar_t *)&prom_ver_data[0])
		    == 0) {
			errnum = 0;
			if (strlen((char *)prom_ver_data) == 0) {
				(void) fprintf(stdout, MSGSTR(21108,
	"  Detected FCode Version:\tNo version available for this FCode\n"));
			} else {
				(void) fprintf(stdout, MSGSTR(21109,
				    "  Detected FCode Version:\t%s\n"),
				    prom_ver_data);
			}
		} else {
			errnum = 2; /* can't get prom properties */
			retval++;
		}

		if (fflag) {

			memset(ver_file, 0, sizeof (ver_file));
			if (emulex_fcode_reader(fcode_fd, "fcode-version",
				    ver_file, sizeof (ver_file)) == 0) {
				(void) fprintf(stdout, MSGSTR(21110,
					    "  New FCode Version:\t\t%s\n"),
					    ver_file);
			} else {
				di_fini(root);
				(void) close(fcode_fd);
				return (1);
			}

			/*
			 * Load the New FCode
			 * Give warning if file doesn't appear to be correct
			 */
			if (!q_warn(errnum)) {
				/* Disable user-interrupt Control-C */
				sigint =
				    (void (*)(int)) signal(SIGINT, SIG_IGN);
				/* Load FCode */
				(void) fprintf(stdout, MSGSTR(21111,
					"  Loading FCode: %s\n"), file);
				if (fcode_load_file(fcode_fd, phys_path,
					    &fcio_errno) == FCODE_SUCCESS) {
					(void) fprintf(stdout, MSGSTR(21112,
					"  Successful FCode download: %s\n"),
					phys_path);
				} else {
					handle_emulex_error(fcio_errno,
					    phys_path);
					retval++;
				}

				/* Restore SIGINT (user interrupt) setting */
				(void) signal(SIGINT, sigint);
			}
		}

	try_next:
		node = di_drv_next_node(node);
	}

	di_fini(root);
	(void) fprintf(stdout, "  ");
	(void) fprintf(stdout, MSGSTR(125, "Complete\n"));
	if (fcode_fd != -1)
		(void) close(fcode_fd);
	return (retval);

}

/*
 * Retrieve the version from the card.
 *    uses PROM properties
 */
static int
emulex_fcodeversion(di_node_t node, uchar_t *ver) {
	di_prom_prop_t	    promprop;
	di_prom_handle_t    ph;
	char		    *promname;
	uchar_t		    *ver_data = NULL;
	int		    size, found = 0;

	/* check to make sure ver is not NULL */
	if (ver == NULL) {
		return (1);
	}

	if ((ph = di_prom_init()) == DI_PROM_HANDLE_NIL) {
		return (1);
	}

	for (promprop = di_prom_prop_next(ph, node,
		DI_PROM_PROP_NIL);
		promprop != DI_PROM_PROP_NIL;
		promprop = di_prom_prop_next(ph, node, promprop)) {
		if (((promname = di_prom_prop_name(
			promprop)) != NULL) &&
			(strcmp(promname, "fcode-version") == 0)) {
			size = di_prom_prop_data(promprop, &ver_data);
			(void) memset(ver, NULL, size);
			(void) memcpy(ver, ver_data, size);
			found = 1;
		}
	}

	if (found) {
		return (0);
	} else {
		return (1);
	}
}

/*
 * Retrieves information from the Emulex fcode
 *
 * Given a pattern, this routine will look for this pattern in the fcode
 * file and if found will return the pattern value
 *
 * possible patterns are manufacturer and fcode-version
 */
int
emulex_fcode_reader(int fcode_fd, char *pattern, char *pattern_value,
    uint32_t pattern_value_size) {
	int32_t i = 0;
	uint32_t n = 0;
	uint32_t b = 0;
	char byte1;
	char byte2;
	char byte3;
	char byte4;
	char buffer1[EMULEX_READ_BUFFER_SIZE];
	char buffer2[EMULEX_READ_BUFFER_SIZE];
	uint32_t plen, image_size;
	struct stat	stat;
	uchar_t		*image;

	/* Check the arguments */
	if (!fcode_fd || !pattern_value || pattern_value_size < 8) {
		return (1);
	}

	if (fstat(fcode_fd, &stat) == -1) {
		perror(MSGSTR(21023, "fstat"));
		return (1);
	}
	image_size = stat.st_size;
	if (image_size < 2) {
		return (1);
	}
	if ((image = (uchar_t *)calloc(image_size, 1)) == NULL) {
		(void) fprintf(stderr,
		    MSGSTR(21013, "Error: Memory allocation failed\n"));
		return (1);
	}

	/* Read the fcode image file */
	lseek(fcode_fd, 0, SEEK_SET);
	read(fcode_fd, image, image_size);

	/* Initialize */
	bzero(buffer1, sizeof (buffer1));
	bzero(buffer2, sizeof (buffer2));
	/* Default pattern_value string */
	strcpy((char *)pattern_value, "<unknown>");
	plen = strlen(pattern);
	n = 0;
	b = 0;
	i = 0;

	/* Search entire image for pattern string */
	while (i <= (image_size - 2)) {
		/* Read next two bytes */
		byte1 = image[i++];
		byte2 = image[i++];

		/* Check second byte first due to endianness */

		/* Save byte in circular buffer */
		buffer1[b++] = byte2;
		if (b == sizeof (buffer1)) {
			b = 0;
		}

		/* Check byte for pattern match */
		if (pattern[n++] != byte2) {
			/* If no match, then reset pattern */
			n = 0;
		} else {
			/*
			 * If complete pattern has been matched then
			 * exit loop
			 */
			if (n == plen) {
				goto found;
			}
		}


		/* Check first byte second due to endianness */
		/* Save byte in circular buffer */
		buffer1[b++] = byte1;
		if (b == sizeof (buffer1)) {
			b = 0;
		}
		/* Check byte for pattern match */
		if (pattern[n++] != byte1) {
			/* If no match, then reset pattern */
			n = 0;
		} else {
			/*
			 * If complete pattern has been matched
			 * then exit loop
			 */
			if (n == plen) {
				goto found;
			}
		}
	}

	/* Not found.  Try again with different endianess */

	/* Initialize */
	bzero(buffer1, sizeof (buffer1));
	bzero(buffer2, sizeof (buffer2));
	n = 0;
	b = 0;
	i = 0;

	/* Search entire 32bit endian image for pattern string */
	while (i <= (image_size - 4)) {
		/* Read next four bytes */
		byte1 = image[i++];
		byte2 = image[i++];
		byte3 = image[i++];
		byte4 = image[i++];

		/* Save byte in circular buffer */
		buffer1[b++] = byte4;
		if (b == sizeof (buffer1)) {
			b = 0;
		}

		/* Check byte for pattern match */
		if (pattern[n++] != byte4) {
			/* If no match, then reset pattern */
			n = 0;
		} else {
			/*
			 * If complete pattern has been matched then exit loop
			 */
			if (n == plen) {
				goto found;
			}
		}

		/* Save byte in circular buffer */
		buffer1[b++] = byte3;
		if (b == sizeof (buffer1)) {
			b = 0;
		}

		/* Check byte for pattern match */
		if (pattern[n++] != byte3) {
			/* If no match, then reset pattern */
			n = 0;
		} else {
			/*
			 * If complete pattern has been matched then exit loop
			 */
			if (n == plen) {
				goto found;
			}
		}

		/* Save byte in circular buffer */
		buffer1[b++] = byte2;
		if (b == sizeof (buffer1)) {
			b = 0;
		}

		/* Check byte for pattern match */
		if (pattern[n++] != byte2) {
			/* If no match, then reset pattern */
			n = 0;
		} else {
			/*
			 * If complete pattern has been matched then exit loop
			 */
			if (n == plen) {
				goto found;
			}
		}

		/* Save byte in circular buffer */
		buffer1[b++] = byte1;
		if (b == sizeof (buffer1)) {
			b = 0;
		}

		/* Check byte for pattern match */
		if (pattern[n++] != byte1) {
			/* If no match, then reset pattern */
			n = 0;
		} else {
			/*
			 * If complete pattern has been matched then exit loop
			 */
			if (n == plen) {
				goto found;
			}
		}
	}

	free(image);
	return (1);

found:
	free(image);

	/* Align buffer and eliminate non-printable characters */
	for (i = 0; i < (sizeof (buffer1)-plen); i++) {
		byte1 = buffer1[b++];
		if (b == sizeof (buffer1)) {
			b = 0;
		}
		/* Zero any non-printable characters */
		if (byte1 >= 33 && byte1 <= 126) {
			buffer2[i] = byte1;
		} else {
			buffer2[i] = 0;
		}
	}

	/*
	 *  Scan backwards for first non-zero string. This will be the
	 *  version string
	 */
	for (i = sizeof (buffer1)-plen-1; i >= 0; i--) {
		if (buffer2[i] != 0) {
			for (; i >= 0; i--) {
				if (buffer2[i] == 0) {
					i++;
					strncpy((char *)pattern_value,
					    &buffer2[i], pattern_value_size);
					break;
				}
			}
			break;
		}
	}
	return (0);
}

/*
 * error handling routine to handle emulex error conditions
 */
static void
handle_emulex_error(int fcio_errno, char *phys_path) {
	if (fcio_errno == EMLX_IMAGE_BAD) {
		fprintf(stderr, MSGSTR(21119,
			    "Error: Fcode download failed.  "
			    "Bad fcode image.\n"));
	} else if (fcio_errno == EMLX_IMAGE_INCOMPATIBLE) {
		fprintf(stderr, MSGSTR(21120,
			    "Error: Fcode download failed.  Fcode is not "
			    "compatible with card.\n"));
	} else {
		(void) fprintf(stderr, MSGSTR(21036,
		    "Error: Driver interface FCIO_DOWNLOAD_FCODE failed\n"));
		(void) fprintf(stderr,
			MSGSTR(21113,
				"Error: FCode download failed: %s\n"),
				phys_path);
	}
}