xref: /illumos-gate/usr/src/uts/common/io/fibre-channel/impl/fp.c (revision 257873cf)

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * NOT a DDI compliant Sun Fibre Channel port driver(fp)
 *
 */

#include <sys/types.h>
#include <sys/varargs.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/uio.h>
#include <sys/buf.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/file.h>
#include <sys/kmem.h>
#include <sys/poll.h>
#include <sys/conf.h>
#include <sys/thread.h>
#include <sys/var.h>
#include <sys/cmn_err.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/promif.h>
#include <sys/nvpair.h>
#include <sys/byteorder.h>
#include <sys/scsi/scsi.h>
#include <sys/fibre-channel/fc.h>
#include <sys/fibre-channel/impl/fc_ulpif.h>
#include <sys/fibre-channel/impl/fc_fcaif.h>
#include <sys/fibre-channel/impl/fctl_private.h>
#include <sys/fibre-channel/impl/fc_portif.h>
#include <sys/fibre-channel/impl/fp.h>

/* These are defined in fctl.c! */
extern int did_table_size;
extern int pwwn_table_size;

static struct cb_ops fp_cb_ops = {
	fp_open,			/* open */
	fp_close,			/* close */
	nodev,				/* strategy */
	nodev,				/* print */
	nodev,				/* dump */
	nodev,				/* read */
	nodev,				/* write */
	fp_ioctl,			/* ioctl */
	nodev,				/* devmap */
	nodev,				/* mmap */
	nodev,				/* segmap */
	nochpoll,			/* chpoll */
	ddi_prop_op,			/* cb_prop_op */
	0,				/* streamtab */
	D_NEW | D_MP | D_HOTPLUG,	/* cb_flag */
	CB_REV,				/* rev */
	nodev,				/* aread */
	nodev				/* awrite */
};

static struct dev_ops fp_ops = {
	DEVO_REV,	/* build revision */
	0,		/* reference count */
	fp_getinfo,	/* getinfo */
	nulldev,	/* identify - Obsoleted */
	nulldev,	/* probe */
	fp_attach,	/* attach */
	fp_detach,	/* detach */
	nodev,		/* reset */
	&fp_cb_ops,	/* cb_ops */
	NULL,		/* bus_ops */
	fp_power	/* power */
};

#define	FP_VERSION		"1.96"
#define	FP_NAME_VERSION		"SunFC Port v" FP_VERSION

char *fp_version = FP_NAME_VERSION;

static struct modldrv modldrv = {
	&mod_driverops,			/* Type of Module */
	FP_NAME_VERSION,		/* Name/Version of fp */
	&fp_ops				/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1,	/* Rev of the loadable modules system */
	&modldrv,	/* NULL terminated list of */
	NULL		/* Linkage structures */
};



static uint16_t ns_reg_cmds[] = {
	NS_RPN_ID,
	NS_RNN_ID,
	NS_RCS_ID,
	NS_RFT_ID,
	NS_RPT_ID,
	NS_RSPN_ID,
	NS_RSNN_NN
};

struct fp_xlat {
	uchar_t	xlat_state;
	int	xlat_rval;
} fp_xlat [] = {
	{ FC_PKT_SUCCESS,	FC_SUCCESS },
	{ FC_PKT_REMOTE_STOP,	FC_FAILURE },
	{ FC_PKT_LOCAL_RJT,	FC_FAILURE },
	{ FC_PKT_NPORT_RJT,	FC_ELS_PREJECT },
	{ FC_PKT_FABRIC_RJT,	FC_ELS_FREJECT },
	{ FC_PKT_LOCAL_BSY,	FC_TRAN_BUSY },
	{ FC_PKT_TRAN_BSY,	FC_TRAN_BUSY },
	{ FC_PKT_NPORT_BSY,	FC_PBUSY },
	{ FC_PKT_FABRIC_BSY,	FC_FBUSY },
	{ FC_PKT_LS_RJT,	FC_FAILURE },
	{ FC_PKT_BA_RJT,	FC_FAILURE },
	{ FC_PKT_TIMEOUT,	FC_FAILURE },
	{ FC_PKT_TRAN_ERROR,	FC_TRANSPORT_ERROR },
	{ FC_PKT_FAILURE,	FC_FAILURE },
	{ FC_PKT_PORT_OFFLINE,	FC_OFFLINE }
};

static uchar_t fp_valid_alpas[] = {
	0x01, 0x02, 0x04, 0x08, 0x0F, 0x10, 0x17, 0x18, 0x1B,
	0x1D, 0x1E, 0x1F, 0x23, 0x25, 0x26, 0x27, 0x29, 0x2A,
	0x2B, 0x2C, 0x2D, 0x2E, 0x31, 0x32, 0x33, 0x34, 0x35,
	0x36, 0x39, 0x3A, 0x3C, 0x43, 0x45, 0x46, 0x47, 0x49,
	0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x51, 0x52, 0x53, 0x54,
	0x55, 0x56, 0x59, 0x5A, 0x5C, 0x63, 0x65, 0x66, 0x67,
	0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73,
	0x74, 0x75, 0x76, 0x79, 0x7A, 0x7C, 0x80, 0x81, 0x82,
	0x84, 0x88, 0x8F, 0x90, 0x97, 0x98, 0x9B, 0x9D, 0x9E,
	0x9F, 0xA3, 0xA5, 0xA6, 0xA7, 0xA9, 0xAA, 0xAB, 0xAC,
	0xAD, 0xAE, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB9,
	0xBA, 0xBC, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB,
	0xCC, 0xCD, 0xCE, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
	0xD9, 0xDA, 0xDC, 0xE0, 0xE1, 0xE2, 0xE4, 0xE8, 0xEF
};

static struct fp_perms {
	uint16_t	fp_ioctl_cmd;
	uchar_t		fp_open_flag;
} fp_perm_list [] = {
	{ FCIO_GET_NUM_DEVS, 		FP_OPEN },
	{ FCIO_GET_DEV_LIST,		FP_OPEN },
	{ FCIO_GET_SYM_PNAME,		FP_OPEN },
	{ FCIO_GET_SYM_NNAME,		FP_OPEN },
	{ FCIO_SET_SYM_PNAME,		FP_EXCL },
	{ FCIO_SET_SYM_NNAME,		FP_EXCL },
	{ FCIO_GET_LOGI_PARAMS,		FP_OPEN },
	{ FCIO_DEV_LOGIN,		FP_EXCL },
	{ FCIO_DEV_LOGOUT,		FP_EXCL },
	{ FCIO_GET_STATE,		FP_OPEN },
	{ FCIO_DEV_REMOVE,		FP_EXCL },
	{ FCIO_GET_FCODE_REV,		FP_OPEN },
	{ FCIO_GET_FW_REV,		FP_OPEN },
	{ FCIO_GET_DUMP_SIZE,		FP_OPEN },
	{ FCIO_FORCE_DUMP,		FP_EXCL },
	{ FCIO_GET_DUMP,		FP_OPEN },
	{ FCIO_GET_TOPOLOGY,		FP_OPEN },
	{ FCIO_RESET_LINK,		FP_EXCL },
	{ FCIO_RESET_HARD,		FP_EXCL },
	{ FCIO_RESET_HARD_CORE,		FP_EXCL },
	{ FCIO_DIAG,			FP_OPEN },
	{ FCIO_NS,			FP_EXCL },
	{ FCIO_DOWNLOAD_FW,		FP_EXCL },
	{ FCIO_DOWNLOAD_FCODE,		FP_EXCL },
	{ FCIO_LINK_STATUS,		FP_OPEN },
	{ FCIO_GET_HOST_PARAMS,		FP_OPEN },
	{ FCIO_GET_NODE_ID,		FP_OPEN },
	{ FCIO_SET_NODE_ID,		FP_EXCL },
	{ FCIO_SEND_NODE_ID,		FP_OPEN },
	{ FCIO_GET_ADAPTER_ATTRIBUTES,	FP_OPEN },
	{ FCIO_GET_OTHER_ADAPTER_PORTS,	FP_OPEN },
	{ FCIO_GET_ADAPTER_PORT_ATTRIBUTES,	FP_OPEN },
	{ FCIO_GET_DISCOVERED_PORT_ATTRIBUTES,	FP_OPEN },
	{ FCIO_GET_PORT_ATTRIBUTES,	FP_OPEN },
	{ FCIO_GET_ADAPTER_PORT_STATS,	FP_OPEN },
	{ FCIO_GET_ADAPTER_PORT_NPIV_ATTRIBUTES, FP_OPEN },
	{ FCIO_GET_NPIV_PORT_LIST, FP_OPEN },
	{ FCIO_DELETE_NPIV_PORT, FP_OPEN },
	{ FCIO_GET_NPIV_ATTRIBUTES, FP_OPEN },
	{ FCIO_CREATE_NPIV_PORT, FP_OPEN },
	{ FCIO_NPIV_GET_ADAPTER_ATTRIBUTES, FP_OPEN }
};

static char *fp_pm_comps[] = {
	"NAME=FC Port",
	"0=Port Down",
	"1=Port Up"
};


#ifdef	_LITTLE_ENDIAN
#define	MAKE_BE_32(x)	{ \
	uint32_t	*ptr1, i; \
		ptr1 = (uint32_t *)(x); \
		for (i = 0; i < sizeof (*(x)) / sizeof (uint32_t); i++) { \
			*ptr1 = BE_32(*ptr1); \
			ptr1++; \
		} \
	}
#else
#define	MAKE_BE_32(x)
#endif

static uchar_t fp_verbosity = (FP_WARNING_MESSAGES | FP_FATAL_MESSAGES);
static uint32_t fp_options = 0;

static int fp_cmd_wait_cnt = FP_CMDWAIT_DELAY;
static int fp_retry_delay = FP_RETRY_DELAY;	/* retry after this delay */
static int fp_retry_count = FP_RETRY_COUNT;	/* number of retries */
unsigned int fp_offline_ticker;			/* seconds */

/*
 * Driver global variable to anchor the list of soft state structs for
 * all fp driver instances.  Used with the Solaris DDI soft state functions.
 */
static void *fp_driver_softstate;

static clock_t	fp_retry_ticks;
static clock_t	fp_offline_ticks;

static int fp_retry_ticker;
static uint32_t fp_unsol_buf_count = FP_UNSOL_BUF_COUNT;
static uint32_t fp_unsol_buf_size = FP_UNSOL_BUF_SIZE;

static int		fp_log_size = FP_LOG_SIZE;
static int		fp_trace = FP_TRACE_DEFAULT;
static fc_trace_logq_t	*fp_logq = NULL;

int fp_get_adapter_paths(char *pathList, int count);
static void fp_log_port_event(fc_local_port_t *port, char *subclass);
static void fp_log_target_event(fc_local_port_t *port, char *subclass,
	    la_wwn_t tgt_pwwn, uint32_t port_id);
static uint32_t fp_map_remote_port_state(uint32_t rm_state);
static void fp_init_symbolic_names(fc_local_port_t *port);


/*
 * Perform global initialization
 */
int
_init(void)
{
	int ret;

	if ((ret = ddi_soft_state_init(&fp_driver_softstate,
	    sizeof (struct fc_local_port), 8)) != 0) {
		return (ret);
	}

	if ((ret = scsi_hba_init(&modlinkage)) != 0) {
		ddi_soft_state_fini(&fp_driver_softstate);
		return (ret);
	}

	fp_logq = fc_trace_alloc_logq(fp_log_size);

	if ((ret = mod_install(&modlinkage)) != 0) {
		fc_trace_free_logq(fp_logq);
		ddi_soft_state_fini(&fp_driver_softstate);
		scsi_hba_fini(&modlinkage);
	}

	return (ret);
}


/*
 * Prepare for driver unload
 */
int
_fini(void)
{
	int ret;

	if ((ret = mod_remove(&modlinkage)) == 0) {
		fc_trace_free_logq(fp_logq);
		ddi_soft_state_fini(&fp_driver_softstate);
		scsi_hba_fini(&modlinkage);
	}

	return (ret);
}


/*
 * Request mod_info() to handle all cases
 */
int
_info(struct modinfo *modinfo)
{
	return (mod_info(&modlinkage, modinfo));
}


/*
 * fp_attach:
 *
 * The respective cmd handlers take care of performing
 * ULP related invocations
 */
static int
fp_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int rval;

	/*
	 * We check the value of fp_offline_ticker at this
	 * point. The variable is global for the driver and
	 * not specific to an instance.
	 *
	 * If there is no user-defined value found in /etc/system
	 * or fp.conf, then we use 90 seconds (FP_OFFLINE_TICKER).
	 * The minimum setting for this offline timeout according
	 * to the FC-FS2 standard (Fibre Channel Framing and
	 * Signalling-2, see www.t11.org) is R_T_TOV == 100msec.
	 *
	 * We do not recommend setting the value to less than 10
	 * seconds (RA_TOV) or more than 90 seconds. If this
	 * variable is greater than 90 seconds then drivers above
	 * fp (fcp, sd, scsi_vhci, vxdmp et al) might complain.
	 */

	fp_offline_ticker = ddi_prop_get_int(DDI_DEV_T_ANY,
	    dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "fp_offline_ticker",
	    FP_OFFLINE_TICKER);

	if ((fp_offline_ticker < 10) ||
	    (fp_offline_ticker > 90)) {
		cmn_err(CE_WARN, "Setting fp_offline_ticker to "
		    "%d second(s). This is outside the "
		    "recommended range of 10..90 seconds",
		    fp_offline_ticker);
	}

	/*
	 * Tick every second when there are commands to retry.
	 * It should tick at the least granular value of pkt_timeout
	 * (which is one second)
	 */
	fp_retry_ticker = 1;

	fp_retry_ticks = drv_usectohz(fp_retry_ticker * 1000 * 1000);
	fp_offline_ticks = drv_usectohz(fp_offline_ticker * 1000 * 1000);

	switch (cmd) {
	case DDI_ATTACH:
		rval = fp_attach_handler(dip);
		break;

	case DDI_RESUME:
		rval = fp_resume_handler(dip);
		break;

	default:
		rval = DDI_FAILURE;
		break;
	}
	return (rval);
}


/*
 * fp_detach:
 *
 * If a ULP fails to handle cmd request converse of
 * cmd is invoked for ULPs that previously succeeded
 * cmd request.
 */
static int
fp_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int 			rval = DDI_FAILURE;
	fc_local_port_t 	*port;
	fc_attach_cmd_t 	converse;
	uint8_t			cnt;

	if ((port = ddi_get_soft_state(fp_driver_softstate,
	    ddi_get_instance(dip))) == NULL) {
		return (DDI_FAILURE);
	}

	mutex_enter(&port->fp_mutex);

	if (port->fp_ulp_attach) {
		mutex_exit(&port->fp_mutex);
		return (DDI_FAILURE);
	}

	switch (cmd) {
	case DDI_DETACH:
		if (port->fp_task != FP_TASK_IDLE) {
			mutex_exit(&port->fp_mutex);
			return (DDI_FAILURE);
		}

		/* Let's attempt to quit the job handler gracefully */
		port->fp_soft_state |= FP_DETACH_INPROGRESS;

		mutex_exit(&port->fp_mutex);
		converse = FC_CMD_ATTACH;
		if (fctl_detach_ulps(port, FC_CMD_DETACH,
		    &modlinkage) != FC_SUCCESS) {
			mutex_enter(&port->fp_mutex);
			port->fp_soft_state &= ~FP_DETACH_INPROGRESS;
			mutex_exit(&port->fp_mutex);
			rval = DDI_FAILURE;
			break;
		}

		mutex_enter(&port->fp_mutex);
		for (cnt = 0; (port->fp_job_head) && (cnt < fp_cmd_wait_cnt);
		    cnt++) {
			mutex_exit(&port->fp_mutex);
			delay(drv_usectohz(1000000));
			mutex_enter(&port->fp_mutex);
		}

		if (port->fp_job_head) {
			mutex_exit(&port->fp_mutex);
			rval = DDI_FAILURE;
			break;
		}
		mutex_exit(&port->fp_mutex);

		rval = fp_detach_handler(port);
		break;

	case DDI_SUSPEND:
		mutex_exit(&port->fp_mutex);
		converse = FC_CMD_RESUME;
		if (fctl_detach_ulps(port, FC_CMD_SUSPEND,
		    &modlinkage) != FC_SUCCESS) {
			rval = DDI_FAILURE;
			break;
		}
		if ((rval = fp_suspend_handler(port)) != DDI_SUCCESS) {
			(void) callb_generic_cpr(&port->fp_cpr_info,
			    CB_CODE_CPR_RESUME);
		}
		break;

	default:
		mutex_exit(&port->fp_mutex);
		break;
	}

	/*
	 * Use softint to perform reattach.  Mark fp_ulp_attach so we
	 * don't attempt to do this repeatedly on behalf of some persistent
	 * caller.
	 */
	if (rval != DDI_SUCCESS) {
		mutex_enter(&port->fp_mutex);
		port->fp_ulp_attach = 1;

		/*
		 * If the port is in the low power mode then there is
		 * possibility that fca too could be in low power mode.
		 * Try to raise the power before calling attach ulps.
		 */

		if ((port->fp_soft_state & FP_SOFT_POWER_DOWN) &&
		    (!(port->fp_soft_state & FP_SOFT_NO_PMCOMP))) {
			mutex_exit(&port->fp_mutex);
			(void) pm_raise_power(port->fp_port_dip,
			    FP_PM_COMPONENT, FP_PM_PORT_UP);
		} else {
			mutex_exit(&port->fp_mutex);
		}


		fp_attach_ulps(port, converse);

		mutex_enter(&port->fp_mutex);
		while (port->fp_ulp_attach) {
			cv_wait(&port->fp_attach_cv, &port->fp_mutex);
		}

		port->fp_soft_state &= ~FP_DETACH_INPROGRESS;

		/*
		 * Mark state as detach failed so asynchronous ULP attach
		 * events (downstream, not the ones we're initiating with
		 * the call to fp_attach_ulps) are not honored.  We're
		 * really still in pending detach.
		 */
		port->fp_soft_state |= FP_DETACH_FAILED;

		mutex_exit(&port->fp_mutex);
	}

	return (rval);
}


/*
 * fp_getinfo:
 *   Given the device number, return either the
 *   dev_info_t pointer or the instance number.
 */

/* ARGSUSED */
static int
fp_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
	int 		rval;
	minor_t		instance;
	fc_local_port_t *port;

	rval = DDI_SUCCESS;
	instance = getminor((dev_t)arg);

	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if ((port = ddi_get_soft_state(fp_driver_softstate,
		    instance)) == NULL) {
			rval = DDI_FAILURE;
			break;
		}
		*result = (void *)port->fp_port_dip;
		break;

	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)(uintptr_t)instance;
		break;

	default:
		rval = DDI_FAILURE;
		break;
	}

	return (rval);
}


/*
 * Entry point for power up and power down request from kernel
 */
static int
fp_power(dev_info_t *dip, int comp, int level)
{
	int		rval = DDI_FAILURE;
	fc_local_port_t	*port;

	port = ddi_get_soft_state(fp_driver_softstate, ddi_get_instance(dip));
	if (port == NULL || comp != FP_PM_COMPONENT) {
		return (rval);
	}

	switch (level) {
	case FP_PM_PORT_UP:
		rval = DDI_SUCCESS;

		/*
		 * If the port is DDI_SUSPENDed, let the DDI_RESUME
		 * code complete the rediscovery.
		 */
		mutex_enter(&port->fp_mutex);
		if (port->fp_soft_state & FP_SOFT_SUSPEND) {
			port->fp_soft_state &= ~FP_SOFT_POWER_DOWN;
			port->fp_pm_level = FP_PM_PORT_UP;
			mutex_exit(&port->fp_mutex);
			fctl_attach_ulps(port, FC_CMD_POWER_UP, &modlinkage);
			break;
		}

		if (port->fp_soft_state & FP_SOFT_POWER_DOWN) {
			ASSERT(port->fp_pm_level == FP_PM_PORT_DOWN);

			port->fp_pm_level = FP_PM_PORT_UP;
			rval = fp_power_up(port);
			if (rval != DDI_SUCCESS) {
				port->fp_pm_level = FP_PM_PORT_DOWN;
			}
		} else {
			port->fp_pm_level = FP_PM_PORT_UP;
		}
		mutex_exit(&port->fp_mutex);
		break;

	case FP_PM_PORT_DOWN:
		mutex_enter(&port->fp_mutex);

		ASSERT(!(port->fp_soft_state & FP_SOFT_NO_PMCOMP));
		if (port->fp_soft_state & FP_SOFT_NO_PMCOMP) {
			/*
			 * PM framework goofed up. We have don't
			 * have any PM components. Let's never go down.
			 */
			mutex_exit(&port->fp_mutex);
			break;

		}

		if (port->fp_ulp_attach) {
			/* We shouldn't let the power go down */
			mutex_exit(&port->fp_mutex);
			break;
		}

		/*
		 * Not a whole lot to do if we are detaching
		 */
		if (port->fp_soft_state & FP_SOFT_IN_DETACH) {
			port->fp_pm_level = FP_PM_PORT_DOWN;
			mutex_exit(&port->fp_mutex);
			rval = DDI_SUCCESS;
			break;
		}

		if (!port->fp_pm_busy && !port->fp_pm_busy_nocomp) {
			port->fp_pm_level = FP_PM_PORT_DOWN;

			rval = fp_power_down(port);
			if (rval != DDI_SUCCESS) {
				port->fp_pm_level = FP_PM_PORT_UP;
				ASSERT(!(port->fp_soft_state &
				    FP_SOFT_POWER_DOWN));
			} else {
				ASSERT(port->fp_soft_state &
				    FP_SOFT_POWER_DOWN);
			}
		}
		mutex_exit(&port->fp_mutex);
		break;

	default:
		break;
	}

	return (rval);
}


/*
 * Open FC port devctl node
 */
static int
fp_open(dev_t *devp, int flag, int otype, cred_t *credp)
{
	int 		instance;
	fc_local_port_t *port;

	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	/*
	 * This is not a toy to play with. Allow only powerful
	 * users (hopefully knowledgeable) to access the port
	 * (A hacker potentially could download a sick binary
	 * file into FCA)
	 */
	if (drv_priv(credp)) {
		return (EPERM);
	}

	instance = (int)getminor(*devp);

	port = ddi_get_soft_state(fp_driver_softstate, instance);
	if (port == NULL) {
		return (ENXIO);
	}

	mutex_enter(&port->fp_mutex);
	if (port->fp_flag & FP_EXCL) {
		/*
		 * It is already open for exclusive access.
		 * So shut the door on this caller.
		 */
		mutex_exit(&port->fp_mutex);
		return (EBUSY);
	}

	if (flag & FEXCL) {
		if (port->fp_flag & FP_OPEN) {
			/*
			 * Exclusive operation not possible
			 * as it is already opened
			 */
			mutex_exit(&port->fp_mutex);
			return (EBUSY);
		}
		port->fp_flag |= FP_EXCL;
	}
	port->fp_flag |= FP_OPEN;
	mutex_exit(&port->fp_mutex);

	return (0);
}


/*
 * The driver close entry point is called on the last close()
 * of a device. So it is perfectly alright to just clobber the
 * open flag and reset it to idle (instead of having to reset
 * each flag bits). For any confusion, check out close(9E).
 */

/* ARGSUSED */
static int
fp_close(dev_t dev, int flag, int otype, cred_t *credp)
{
	int 		instance;
	fc_local_port_t *port;

	if (otype != OTYP_CHR) {
		return (EINVAL);
	}

	instance = (int)getminor(dev);

	port = ddi_get_soft_state(fp_driver_softstate, instance);
	if (port == NULL) {
		return (ENXIO);
	}

	mutex_enter(&port->fp_mutex);
	if ((port->fp_flag & FP_OPEN) == 0) {
		mutex_exit(&port->fp_mutex);
		return (ENODEV);
	}
	port->fp_flag = FP_IDLE;
	mutex_exit(&port->fp_mutex);

	return (0);
}

/*
 * Handle IOCTL requests
 */

/* ARGSUSED */
static int
fp_ioctl(dev_t dev, int cmd, intptr_t data, int mode, cred_t *credp, int *rval)
{
	int 		instance;
	int		ret = 0;
	fcio_t		fcio;
	fc_local_port_t *port;

	instance = (int)getminor(dev);

	port = ddi_get_soft_state(fp_driver_softstate, instance);
	if (port == NULL) {
		return (ENXIO);
	}

	mutex_enter(&port->fp_mutex);
	if ((port->fp_flag & FP_OPEN) == 0) {
		mutex_exit(&port->fp_mutex);
		return (ENXIO);
	}

	if (port->fp_soft_state & FP_SOFT_SUSPEND) {
		mutex_exit(&port->fp_mutex);
		return (ENXIO);
	}

	mutex_exit(&port->fp_mutex);

	/* this will raise power if necessary */
	ret = fctl_busy_port(port);
	if (ret != 0) {
		return (ret);
	}

	ASSERT(port->fp_pm_level == FP_PM_PORT_UP);


	switch (cmd) {
	case FCIO_CMD: {
#ifdef	_MULTI_DATAMODEL
		switch (ddi_model_convert_from(mode & FMODELS)) {
		case DDI_MODEL_ILP32: {
			struct fcio32 fcio32;

			if (ddi_copyin((void *)data, (void *)&fcio32,
			    sizeof (struct fcio32), mode)) {
				ret = EFAULT;
				break;
			}
			fcio.fcio_xfer = fcio32.fcio_xfer;
			fcio.fcio_cmd = fcio32.fcio_cmd;
			fcio.fcio_flags = fcio32.fcio_flags;
			fcio.fcio_cmd_flags = fcio32.fcio_cmd_flags;
			fcio.fcio_ilen = (size_t)fcio32.fcio_ilen;
			fcio.fcio_ibuf =
				(caddr_t)(uintptr_t)fcio32.fcio_ibuf;
			fcio.fcio_olen = (size_t)fcio32.fcio_olen;
			fcio.fcio_obuf =
				(caddr_t)(uintptr_t)fcio32.fcio_obuf;
			fcio.fcio_alen = (size_t)fcio32.fcio_alen;
			fcio.fcio_abuf =
				(caddr_t)(uintptr_t)fcio32.fcio_abuf;
			fcio.fcio_errno = fcio32.fcio_errno;
			break;
		}

		case DDI_MODEL_NONE:
			if (ddi_copyin((void *)data, (void *)&fcio,
			    sizeof (fcio_t), mode)) {
				ret = EFAULT;
			}
			break;
		}
#else	/* _MULTI_DATAMODEL */
		if (ddi_copyin((void *)data, (void *)&fcio,
		sizeof (fcio_t), mode)) {
			ret = EFAULT;
			break;
		}
#endif	/* _MULTI_DATAMODEL */
		if (!ret) {
			ret = fp_fciocmd(port, data, mode, &fcio);
		}
		break;
	}

	default:
		ret = fctl_ulp_port_ioctl(port, dev, cmd, data,
		    mode, credp, rval);
	}

	fctl_idle_port(port);

	return (ret);
}


/*
 * Init Symbolic Port Name and Node Name
 * LV will try to get symbolic names from FCA driver
 * and register these to name server,
 * if LV fails to get these,
 * LV will register its default symbolic names to name server.
 * The Default symbolic node name format is :
 * 	<hostname>:<hba driver name>(instance)
 * The Default symbolic port name format is :
 * 	<fp path name>
 */
static void
fp_init_symbolic_names(fc_local_port_t *port)
{
	const char *vendorname = ddi_driver_name(port->fp_fca_dip);
	char *sym_name;
	char fcaname[50] = {0};
	int hostnlen, fcanlen;

	if (port->fp_sym_node_namelen == 0) {
		hostnlen = strlen(utsname.nodename);
		(void) snprintf(fcaname, sizeof (fcaname),
		    "%s%d", vendorname, ddi_get_instance(port->fp_fca_dip));
		fcanlen = strlen(fcaname);

		sym_name = kmem_zalloc(hostnlen + fcanlen + 2, KM_SLEEP);
		(void) sprintf(sym_name, "%s:%s", utsname.nodename, fcaname);
		port->fp_sym_node_namelen = strlen(sym_name);
		if (port->fp_sym_node_namelen >= FCHBA_SYMB_NAME_LEN) {
			port->fp_sym_node_namelen = FCHBA_SYMB_NAME_LEN;
		}
		(void) strncpy(port->fp_sym_node_name, sym_name,
		    port->fp_sym_node_namelen);
		kmem_free(sym_name, hostnlen + fcanlen + 2);
	}

	if (port->fp_sym_port_namelen == 0) {
		char *pathname = kmem_zalloc(MAXPATHLEN, KM_SLEEP);

		(void) ddi_pathname(port->fp_port_dip, pathname);
		port->fp_sym_port_namelen = strlen(pathname);
		if (port->fp_sym_port_namelen >= FCHBA_SYMB_NAME_LEN) {
			port->fp_sym_port_namelen = FCHBA_SYMB_NAME_LEN;
		}
		(void) strncpy(port->fp_sym_port_name, pathname,
		    port->fp_sym_port_namelen);
		kmem_free(pathname, MAXPATHLEN);
	}
}


/*
 * Perform port attach
 */
static int
fp_attach_handler(dev_info_t *dip)
{
	int			rval;
	int			instance;
	int 			port_num;
	int			port_len;
	char 			name[30];
	char			i_pwwn[17];
	fp_cmd_t		*pkt;
	uint32_t		ub_count;
	fc_local_port_t 	*port;
	job_request_t 		*job;
	fc_local_port_t *phyport = NULL;
	int portpro1;
	char pwwn[17], nwwn[17];

	instance = ddi_get_instance(dip);

	port_len = sizeof (port_num);

	rval = ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "port",
	    (caddr_t)&port_num, &port_len);

	if (rval != DDI_SUCCESS) {
		cmn_err(CE_WARN, "fp(%d): No port property in devinfo",
		    instance);
		return (DDI_FAILURE);
	}

	if (ddi_create_minor_node(dip, "devctl", S_IFCHR, instance,
	    DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "fp(%d): failed to create devctl minor node",
		    instance);
		return (DDI_FAILURE);
	}

	if (ddi_create_minor_node(dip, "fc", S_IFCHR, instance,
	    DDI_NT_FC_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "fp(%d): failed to create fc attachment"
		    " point minor node", instance);
		ddi_remove_minor_node(dip, NULL);
		return (DDI_FAILURE);
	}

	if (ddi_soft_state_zalloc(fp_driver_softstate, instance)
	    != DDI_SUCCESS) {
		cmn_err(CE_WARN, "fp(%d): failed to alloc soft state",
		    instance);
		ddi_remove_minor_node(dip, NULL);
		return (DDI_FAILURE);
	}
	port = ddi_get_soft_state(fp_driver_softstate, instance);

	(void) sprintf(port->fp_ibuf, "fp(%d)", instance);

	port->fp_instance = instance;
	port->fp_ulp_attach = 1;
	port->fp_port_num = port_num;
	port->fp_verbose = fp_verbosity;
	port->fp_options = fp_options;

	port->fp_fca_dip = ddi_get_parent(dip);
	port->fp_port_dip = dip;
	port->fp_fca_tran = (fc_fca_tran_t *)
	    ddi_get_driver_private(port->fp_fca_dip);

	port->fp_task = port->fp_last_task = FP_TASK_IDLE;

	/*
	 * Init the starting value of fp_rscn_count. Note that if
	 * FC_INVALID_RSCN_COUNT is 0 (which is what it currently is), the
	 * actual # of RSCNs will be (fp_rscn_count - 1)
	 */
	port->fp_rscn_count = FC_INVALID_RSCN_COUNT + 1;

	mutex_init(&port->fp_mutex, NULL, MUTEX_DRIVER, NULL);
	cv_init(&port->fp_cv, NULL, CV_DRIVER, NULL);
	cv_init(&port->fp_attach_cv, NULL, CV_DRIVER, NULL);

	(void) sprintf(name, "fp%d_cache", instance);

	if ((portpro1 = ddi_prop_get_int(DDI_DEV_T_ANY,
	    dip, DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
	    "phyport-instance", -1)) != -1) {
		phyport = ddi_get_soft_state(fp_driver_softstate, portpro1);
		fc_wwn_to_str(&phyport->fp_service_params.nport_ww_name, pwwn);
		fc_wwn_to_str(&phyport->fp_service_params.node_ww_name, nwwn);
		port->fp_npiv_type = FC_NPIV_PORT;
	}

	/*
	 * Allocate the pool of fc_packet_t structs to be used with
	 * this fp instance.
	 */
	port->fp_pkt_cache = kmem_cache_create(name,
	    (port->fp_fca_tran->fca_pkt_size) + sizeof (fp_cmd_t), 8,
	    fp_cache_constructor, fp_cache_destructor, NULL, (void *)port,
	    NULL, 0);

	if (port->fp_pkt_cache == NULL) {
		goto cache_alloc_failed;
	}


	/*
	 * Allocate the d_id and pwwn hash tables for all remote ports
	 * connected to this local port.
	 */
	port->fp_did_table = kmem_zalloc(did_table_size *
	    sizeof (struct d_id_hash), KM_SLEEP);

	port->fp_pwwn_table = kmem_zalloc(pwwn_table_size *
	    sizeof (struct pwwn_hash), KM_SLEEP);

	port->fp_taskq = taskq_create("fp_ulp_callback", 1,
	    MINCLSYSPRI, 1, 16, 0);

	/* Indicate that don't have the pm components yet */
	port->fp_soft_state |=  FP_SOFT_NO_PMCOMP;

	/*
	 * Bind the callbacks with the FCA driver. This will open the gate
	 * for asynchronous callbacks, so after this call the fp_mutex
	 * must be held when updating the fc_local_port_t struct.
	 *
	 * This is done _before_ setting up the job thread so we can avoid
	 * cleaning up after the thread_create() in the error path. This
	 * also means fp will be operating with fp_els_resp_pkt set to NULL.
	 */
	if (fp_bind_callbacks(port) != DDI_SUCCESS) {
		goto bind_callbacks_failed;
	}

	if (phyport) {
		mutex_enter(&phyport->fp_mutex);
		if (phyport->fp_port_next) {
			phyport->fp_port_next->fp_port_prev = port;
			port->fp_port_next =  phyport->fp_port_next;
			phyport->fp_port_next = port;
			port->fp_port_prev = phyport;
		} else {
			phyport->fp_port_next = port;
			phyport->fp_port_prev = port;
			port->fp_port_next =  phyport;
			port->fp_port_prev = phyport;
		}
		mutex_exit(&phyport->fp_mutex);
	}

	/*
	 * Init Symbolic Names
	 */
	fp_init_symbolic_names(port);

	pkt = fp_alloc_pkt(port, sizeof (la_els_logi_t), sizeof (la_els_logi_t),
	    KM_SLEEP, NULL);

	if (pkt == NULL) {
		cmn_err(CE_WARN, "fp(%d): failed to allocate ELS packet",
		    instance);
		goto alloc_els_packet_failed;
	}

	(void) thread_create(NULL, 0, fp_job_handler, port, 0, &p0, TS_RUN,
	    v.v_maxsyspri - 2);

	fc_wwn_to_str(&port->fp_service_params.nport_ww_name, i_pwwn);
	if (ddi_prop_update_string(DDI_DEV_T_NONE, dip, "initiator-port",
	    i_pwwn) != DDI_PROP_SUCCESS) {
		fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
		    "fp(%d): Updating 'initiator-port' property"
		    " on fp dev_info node failed", instance);
	}

	fc_wwn_to_str(&port->fp_service_params.node_ww_name, i_pwwn);
	if (ddi_prop_update_string(DDI_DEV_T_NONE, dip, "initiator-node",
	    i_pwwn) != DDI_PROP_SUCCESS) {
		fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
		    "fp(%d): Updating 'initiator-node' property"
		    " on fp dev_info node failed", instance);
	}

	mutex_enter(&port->fp_mutex);
	port->fp_els_resp_pkt = pkt;
	mutex_exit(&port->fp_mutex);

	/*
	 * Determine the count of unsolicited buffers this FCA can support
	 */
	fp_retrieve_caps(port);

	/*
	 * Allocate unsolicited buffer tokens
	 */
	if (port->fp_ub_count) {
		ub_count = port->fp_ub_count;
		port->fp_ub_tokens = kmem_zalloc(ub_count *
		    sizeof (*port->fp_ub_tokens), KM_SLEEP);
		/*
		 * Do not fail the attach if unsolicited buffer allocation
		 * fails; Just try to get along with whatever the FCA can do.
		 */
		if (fc_ulp_uballoc(port, &ub_count, fp_unsol_buf_size,
		    FC_TYPE_EXTENDED_LS, port->fp_ub_tokens) !=
		    FC_SUCCESS || ub_count != port->fp_ub_count) {
			cmn_err(CE_WARN, "fp(%d): failed to allocate "
			    " Unsolicited buffers. proceeding with attach...",
			    instance);
			kmem_free(port->fp_ub_tokens,
			    sizeof (*port->fp_ub_tokens) * port->fp_ub_count);
			port->fp_ub_tokens = NULL;
		}
	}

	fp_load_ulp_modules(dip, port);

	/*
	 * Enable DDI_SUSPEND and DDI_RESUME for this instance.
	 */
	(void) ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
	    "pm-hardware-state", "needs-suspend-resume",
	    strlen("needs-suspend-resume") + 1);

	/*
	 * fctl maintains a list of all port handles, so
	 * help fctl add this one to its list now.
	 */
	mutex_enter(&port->fp_mutex);
	fctl_add_port(port);

	/*
	 * If a state change is already in progress, set the bind state t
	 * OFFLINE as well, so further state change callbacks into ULPs
	 * will pass the appropriate states
	 */
	if (FC_PORT_STATE_MASK(port->fp_bind_state) == FC_STATE_OFFLINE ||
	    port->fp_statec_busy) {
		port->fp_bind_state = FC_STATE_OFFLINE;
		mutex_exit(&port->fp_mutex);

		fp_startup_done((opaque_t)port, FC_PKT_SUCCESS);
	} else {
		/*
		 * Without dropping the mutex, ensure that the port
		 * startup happens ahead of state change callback
		 * processing
		 */
		ASSERT(port->fp_job_tail == NULL && port->fp_job_head == NULL);

		port->fp_last_task = port->fp_task;
		port->fp_task = FP_TASK_PORT_STARTUP;

		job = fctl_alloc_job(JOB_PORT_STARTUP, JOB_TYPE_FCTL_ASYNC,
		    fp_startup_done, (opaque_t)port, KM_SLEEP);

		port->fp_job_head = port->fp_job_tail = job;

		cv_signal(&port->fp_cv);

		mutex_exit(&port->fp_mutex);
	}

	mutex_enter(&port->fp_mutex);
	while (port->fp_ulp_attach) {
		cv_wait(&port->fp_attach_cv, &port->fp_mutex);
	}
	mutex_exit(&port->fp_mutex);

	if (ddi_prop_update_string_array(DDI_DEV_T_NONE, dip,
	    "pm-components", fp_pm_comps,
	    sizeof (fp_pm_comps) / sizeof (fp_pm_comps[0])) !=
	    DDI_PROP_SUCCESS) {
		FP_TRACE(FP_NHEAD2(9, 0), "Failed to create PM"
		    " components property, PM disabled on this port.");
		mutex_enter(&port->fp_mutex);
		port->fp_pm_level = FP_PM_PORT_UP;
		mutex_exit(&port->fp_mutex);
	} else {
		if (pm_raise_power(dip, FP_PM_COMPONENT,
		    FP_PM_PORT_UP) != DDI_SUCCESS) {
			FP_TRACE(FP_NHEAD2(9, 0), "Failed to raise"
			    " power level");
			mutex_enter(&port->fp_mutex);
			port->fp_pm_level = FP_PM_PORT_UP;
			mutex_exit(&port->fp_mutex);
		}

		/*
		 * Don't unset the FP_SOFT_NO_PMCOMP flag until after
		 * the call to pm_raise_power.  The PM framework can't
		 * handle multiple threads calling into it during attach.
		 */

		mutex_enter(&port->fp_mutex);
		port->fp_soft_state &=  ~FP_SOFT_NO_PMCOMP;
		mutex_exit(&port->fp_mutex);
	}

	ddi_report_dev(dip);

	fp_log_port_event(port, ESC_SUNFC_PORT_ATTACH);

	return (DDI_SUCCESS);

	/*
	 * Unwind any/all preceeding allocations in the event of an error.
	 */

alloc_els_packet_failed:

	if (port->fp_fca_handle != NULL) {
		port->fp_fca_tran->fca_unbind_port(port->fp_fca_handle);
		port->fp_fca_handle = NULL;
	}

	if (port->fp_ub_tokens != NULL) {
		(void) fc_ulp_ubfree(port, port->fp_ub_count,
		    port->fp_ub_tokens);
		kmem_free(port->fp_ub_tokens,
		    port->fp_ub_count * sizeof (*port->fp_ub_tokens));
		port->fp_ub_tokens = NULL;
	}

	if (port->fp_els_resp_pkt != NULL) {
		fp_free_pkt(port->fp_els_resp_pkt);
		port->fp_els_resp_pkt = NULL;
	}

bind_callbacks_failed:

	if (port->fp_taskq != NULL) {
		taskq_destroy(port->fp_taskq);
	}

	if (port->fp_pwwn_table != NULL) {
		kmem_free(port->fp_pwwn_table,
		    pwwn_table_size * sizeof (struct pwwn_hash));
		port->fp_pwwn_table = NULL;
	}

	if (port->fp_did_table != NULL) {
		kmem_free(port->fp_did_table,
		    did_table_size * sizeof (struct d_id_hash));
		port->fp_did_table = NULL;
	}

	if (port->fp_pkt_cache != NULL) {
		kmem_cache_destroy(port->fp_pkt_cache);
		port->fp_pkt_cache = NULL;
	}

cache_alloc_failed:

	cv_destroy(&port->fp_attach_cv);
	cv_destroy(&port->fp_cv);
	mutex_destroy(&port->fp_mutex);
	ddi_remove_minor_node(port->fp_port_dip, NULL);
	ddi_soft_state_free(fp_driver_softstate, instance);
	ddi_prop_remove_all(dip);

	return (DDI_FAILURE);
}


/*
 * Handle DDI_RESUME request
 */
static int
fp_resume_handler(dev_info_t *dip)
{
	int		rval;
	fc_local_port_t *port;

	port = ddi_get_soft_state(fp_driver_softstate, ddi_get_instance(dip));

	ASSERT(port != NULL);

#ifdef	DEBUG
	mutex_enter(&port->fp_mutex);
	ASSERT(port->fp_soft_state & FP_SOFT_SUSPEND);
	mutex_exit(&port->fp_mutex);
#endif

	/*
	 * If the port was power suspended, raise the power level
	 */
	mutex_enter(&port->fp_mutex);
	if ((port->fp_soft_state & FP_SOFT_POWER_DOWN) &&
	    (!(port->fp_soft_state & FP_SOFT_NO_PMCOMP))) {
		ASSERT(port->fp_pm_level == FP_PM_PORT_DOWN);

		mutex_exit(&port->fp_mutex);
		if (pm_raise_power(dip, FP_PM_COMPONENT,
		    FP_PM_PORT_UP) != DDI_SUCCESS) {
			FP_TRACE(FP_NHEAD2(9, 0),
			    "Failed to raise the power level");
			return (DDI_FAILURE);
		}
		mutex_enter(&port->fp_mutex);
	}
	port->fp_soft_state &= ~FP_SOFT_SUSPEND;
	mutex_exit(&port->fp_mutex);

	/*
	 * All the discovery is initiated and handled by per-port thread.
	 * Further all the discovery is done in handled in callback mode
	 * (not polled mode); In a specific case such as this, the discovery
	 * is required to happen in polled mode. The easiest way out is
	 * to bail out port thread and get started. Come back and fix this
	 * to do on demand discovery initiated by ULPs. ULPs such as FCP
	 * will do on-demand discovery during pre-power-up busctl handling
	 * which will only be possible when SCSA provides a new HBA vector
	 * for sending down the PM busctl requests.
	 */
	(void) callb_generic_cpr(&port->fp_cpr_info, CB_CODE_CPR_RESUME);

	rval = fp_resume_all(port, FC_CMD_RESUME);
	if (rval != DDI_SUCCESS) {
		mutex_enter(&port->fp_mutex);
		port->fp_soft_state |= FP_SOFT_SUSPEND;
		mutex_exit(&port->fp_mutex);
		(void) callb_generic_cpr(&port->fp_cpr_info,
		    CB_CODE_CPR_CHKPT);
	}

	return (rval);
}

/*
 * Perform FC Port power on initialization
 */
static int
fp_power_up(fc_local_port_t *port)
{
	int	rval;

	ASSERT(MUTEX_HELD(&port->fp_mutex));

	ASSERT((port->fp_soft_state & FP_SOFT_SUSPEND) == 0);
	ASSERT(port->fp_soft_state & FP_SOFT_POWER_DOWN);

	port->fp_soft_state &= ~FP_SOFT_POWER_DOWN;

	mutex_exit(&port->fp_mutex);

	rval = fp_resume_all(port, FC_CMD_POWER_UP);
	if (rval != DDI_SUCCESS) {
		mutex_enter(&port->fp_mutex);
		port->fp_soft_state |= FP_SOFT_POWER_DOWN;
	} else {
		mutex_enter(&port->fp_mutex);
	}

	return (rval);
}


/*
 * It is important to note that the power may possibly be removed between
 * SUSPEND and the ensuing RESUME operation. In such a context the underlying
 * FC port hardware would have gone through an OFFLINE to ONLINE transition
 * (hardware state). In this case, the port driver may need to rediscover the
 * topology, perform LOGINs, register with the name server again and perform
 * any such port initialization procedures. To perform LOGINs, the driver could
 * use the port device handle to see if a LOGIN needs to be performed and use
 * the D_ID and WWN in it. The LOGINs may fail (if the hardware is reconfigured
 * or removed) which will be reflected in the map the ULPs will see.
 */
static int
fp_resume_all(fc_local_port_t *port, fc_attach_cmd_t cmd)
{

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	if (fp_bind_callbacks(port) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	mutex_enter(&port->fp_mutex);

	/*
	 * If there are commands queued for delayed retry, instead of
	 * working the hard way to figure out which ones are good for
	 * restart and which ones not (ELSs are definitely not good
	 * as the port will have to go through a new spin of rediscovery
	 * now), so just flush them out.
	 */
	if (port->fp_restore & FP_RESTORE_WAIT_TIMEOUT) {
		fp_cmd_t	*cmd;

		port->fp_restore &= ~FP_RESTORE_WAIT_TIMEOUT;

		mutex_exit(&port->fp_mutex);
		while ((cmd = fp_deque_cmd(port)) != NULL) {
			cmd->cmd_pkt.pkt_state = FC_PKT_TRAN_ERROR;
			fp_iodone(cmd);
		}
		mutex_enter(&port->fp_mutex);
	}

	if (FC_PORT_STATE_MASK(port->fp_bind_state) == FC_STATE_OFFLINE) {
		if ((port->fp_restore & FP_RESTORE_OFFLINE_TIMEOUT) ||
		    port->fp_dev_count) {
			port->fp_restore &= ~FP_RESTORE_OFFLINE_TIMEOUT;
			port->fp_offline_tid = timeout(fp_offline_timeout,
			    (caddr_t)port, fp_offline_ticks);
		}
		if (port->fp_job_head) {
			cv_signal(&port->fp_cv);
		}
		mutex_exit(&port->fp_mutex);
		fctl_attach_ulps(port, cmd, &modlinkage);
	} else {
		struct job_request *job;

		/*
		 * If an OFFLINE timer was running at the time of
		 * suspending, there is no need to restart it as
		 * the port is ONLINE now.
		 */
		port->fp_restore &= ~FP_RESTORE_OFFLINE_TIMEOUT;
		if (port->fp_statec_busy == 0) {
			port->fp_soft_state |= FP_SOFT_IN_STATEC_CB;
		}
		port->fp_statec_busy++;
		mutex_exit(&port->fp_mutex);

		job = fctl_alloc_job(JOB_PORT_ONLINE,
		    JOB_CANCEL_ULP_NOTIFICATION, NULL, NULL, KM_SLEEP);
		fctl_enque_job(port, job);

		fctl_jobwait(job);
		fctl_remove_oldies(port);

		fctl_attach_ulps(port, cmd, &modlinkage);
		fctl_dealloc_job(job);
	}

	return (DDI_SUCCESS);
}


/*
 * At this time, there shouldn't be any I/O requests on this port.
 * But the unsolicited callbacks from the underlying FCA port need
 * to be handled very carefully. The steps followed to handle the
 * DDI_DETACH are:
 *	+ 	Grab the port driver mutex, check if the unsolicited
 *		callback is currently under processing. If true, fail
 *		the DDI_DETACH request by printing a message; If false
 *		mark the DDI_DETACH as under progress, so that any
 *		further unsolicited callbacks get bounced.
 *	+	Perform PRLO/LOGO if necessary, cleanup all the data
 *		structures.
 *	+	Get the job_handler thread to gracefully exit.
 *	+	Unregister callbacks with the FCA port.
 *	+	Now that some peace is found, notify all the ULPs of
 *		DDI_DETACH request (using ulp_port_detach entry point)
 *	+	Free all mutexes, semaphores, conditional variables.
 *	+	Free the soft state, return success.
 *
 * Important considerations:
 *		Port driver de-registers state change and unsolicited
 *		callbacks before taking up the task of notifying ULPs
 *		and performing PRLO and LOGOs.
 *
 *		A port may go offline at the time PRLO/LOGO is being
 *		requested. It is expected of all FCA drivers to fail
 *		such requests either immediately with a FC_OFFLINE
 *		return code to fc_fca_transport() or return the packet
 *		asynchronously with pkt state set to FC_PKT_PORT_OFFLINE
 */
static int
fp_detach_handler(fc_local_port_t *port)
{
	job_request_t 	*job;
	uint32_t	delay_count;
	fc_orphan_t	*orp, *tmporp;

	/*
	 * In a Fabric topology with many host ports connected to
	 * a switch, another detaching instance of fp might have
	 * triggered a LOGO (which is an unsolicited request to
	 * this instance). So in order to be able to successfully
	 * detach by taking care of such cases a delay of about
	 * 30 seconds is introduced.
	 */
	delay_count = 0;
	mutex_enter(&port->fp_mutex);
	while ((port->fp_soft_state &
	    (FP_SOFT_IN_STATEC_CB | FP_SOFT_IN_UNSOL_CB)) &&
	    (delay_count < 30)) {
		mutex_exit(&port->fp_mutex);
		delay_count++;
		delay(drv_usectohz(1000000));
		mutex_enter(&port->fp_mutex);
	}

	if (port->fp_soft_state &
	    (FP_SOFT_IN_STATEC_CB | FP_SOFT_IN_UNSOL_CB)) {
		port->fp_soft_state &= ~FP_DETACH_INPROGRESS;
		mutex_exit(&port->fp_mutex);
		cmn_err(CE_WARN, "fp(%d): FCA callback in progress: "
		    " Failing detach", port->fp_instance);
		return (DDI_FAILURE);
	}

	port->fp_soft_state |= FP_SOFT_IN_DETACH;
	port->fp_soft_state &= ~FP_DETACH_INPROGRESS;
	mutex_exit(&port->fp_mutex);

	/*
	 * If we're powered down, we need to raise power prior to submitting
	 * the JOB_PORT_SHUTDOWN job.  Otherwise, the job handler will never
	 * process the shutdown job.
	 */
	if (fctl_busy_port(port) != 0) {
		cmn_err(CE_WARN, "fp(%d): fctl_busy_port failed",
		    port->fp_instance);
		mutex_enter(&port->fp_mutex);
		port->fp_soft_state &= ~FP_SOFT_IN_DETACH;
		mutex_exit(&port->fp_mutex);
		return (DDI_FAILURE);
	}

	/*
	 * This will deallocate data structs and cause the "job" thread
	 * to exit, in preparation for DDI_DETACH on the instance.
	 * This can sleep for an arbitrary duration, since it waits for
	 * commands over the wire, timeout(9F) callbacks, etc.
	 *
	 * CAUTION: There is still a race here, where the "job" thread
	 * can still be executing code even tho the fctl_jobwait() call
	 * below has returned to us.  In theory the fp driver could even be
	 * modunloaded even tho the job thread isn't done executing.
	 * without creating the race condition.
	 */
	job = fctl_alloc_job(JOB_PORT_SHUTDOWN, 0, NULL,
	    (opaque_t)port, KM_SLEEP);
	fctl_enque_job(port, job);
	fctl_jobwait(job);
	fctl_dealloc_job(job);


	(void) pm_lower_power(port->fp_port_dip, FP_PM_COMPONENT,
	    FP_PM_PORT_DOWN);

	if (port->fp_taskq) {
		taskq_destroy(port->fp_taskq);
	}

	ddi_prop_remove_all(port->fp_port_dip);

	ddi_remove_minor_node(port->fp_port_dip, NULL);

	fctl_remove_port(port);

	fp_free_pkt(port->fp_els_resp_pkt);

	if (port->fp_ub_tokens) {
		if (fc_ulp_ubfree(port, port->fp_ub_count,
		    port->fp_ub_tokens) != FC_SUCCESS) {
			cmn_err(CE_WARN, "fp(%d): couldn't free "
			    " unsolicited buffers", port->fp_instance);
		}
		kmem_free(port->fp_ub_tokens,
		    sizeof (*port->fp_ub_tokens) * port->fp_ub_count);
		port->fp_ub_tokens = NULL;
	}

	if (port->fp_pkt_cache != NULL) {
		kmem_cache_destroy(port->fp_pkt_cache);
	}

	port->fp_fca_tran->fca_unbind_port(port->fp_fca_handle);

	mutex_enter(&port->fp_mutex);
	if (port->fp_did_table) {
		kmem_free(port->fp_did_table, did_table_size *
			sizeof (struct d_id_hash));
	}

	if (port->fp_pwwn_table) {
		kmem_free(port->fp_pwwn_table, pwwn_table_size *
		    sizeof (struct pwwn_hash));
	}
	orp = port->fp_orphan_list;
	while (orp) {
		tmporp = orp;
		orp = orp->orp_next;
		kmem_free(tmporp, sizeof (*orp));
	}

	mutex_exit(&port->fp_mutex);

	fp_log_port_event(port, ESC_SUNFC_PORT_DETACH);

	mutex_destroy(&port->fp_mutex);
	cv_destroy(&port->fp_attach_cv);
	cv_destroy(&port->fp_cv);
	ddi_soft_state_free(fp_driver_softstate, port->fp_instance);

	return (DDI_SUCCESS);
}


/*
 * Steps to perform DDI_SUSPEND operation on a FC port
 *
 *	- If already suspended return DDI_FAILURE
 *	- If already power-suspended return DDI_SUCCESS
 *	- If an unsolicited callback or state change handling is in
 *	    in progress, throw a warning message, return DDI_FAILURE
 *	- Cancel timeouts
 *	- SUSPEND the job_handler thread (means do nothing as it is
 *          taken care of by the CPR frame work)
 */
static int
fp_suspend_handler(fc_local_port_t *port)
{
	uint32_t	delay_count;

	mutex_enter(&port->fp_mutex);

	/*
	 * The following should never happen, but
	 * let the driver be more defensive here
	 */
	if (port->fp_soft_state & FP_SOFT_SUSPEND) {
		mutex_exit(&port->fp_mutex);
		return (DDI_FAILURE);
	}

	/*
	 * If the port is already power suspended, there
	 * is nothing else to do, So return DDI_SUCCESS,
	 * but mark the SUSPEND bit in the soft state
	 * before leaving.
	 */
	if (port->fp_soft_state & FP_SOFT_POWER_DOWN) {
		port->fp_soft_state |= FP_SOFT_SUSPEND;
		mutex_exit(&port->fp_mutex);
		return (DDI_SUCCESS);
	}

	/*
	 * Check if an unsolicited callback or state change handling is
	 * in progress. If true, fail the suspend operation; also throw
	 * a warning message notifying the failure. Note that Sun PCI
	 * hotplug spec recommends messages in cases of failure (but
	 * not flooding the console)
	 *
	 * Busy waiting for a short interval (500 millisecond ?) to see
	 * if the callback processing completes may be another idea. Since
	 * most of the callback processing involves a lot of work, it
	 * is safe to just fail the SUSPEND operation. It is definitely
	 * not bad to fail the SUSPEND operation if the driver is busy.
	 */
	delay_count = 0;
	while ((port->fp_soft_state & (FP_SOFT_IN_STATEC_CB |
	    FP_SOFT_IN_UNSOL_CB)) && (delay_count < 30)) {
		mutex_exit(&port->fp_mutex);
		delay_count++;
		delay(drv_usectohz(1000000));
		mutex_enter(&port->fp_mutex);
	}

	if (port->fp_soft_state & (FP_SOFT_IN_STATEC_CB |
	    FP_SOFT_IN_UNSOL_CB)) {
		mutex_exit(&port->fp_mutex);
		cmn_err(CE_WARN, "fp(%d): FCA callback in progress: "
		    " Failing suspend", port->fp_instance);
		return (DDI_FAILURE);
	}

	/*
	 * Check of FC port thread is busy
	 */
	if (port->fp_job_head) {
		mutex_exit(&port->fp_mutex);
		FP_TRACE(FP_NHEAD2(9, 0),
		    "FC port thread is busy: Failing suspend");
		return (DDI_FAILURE);
	}
	port->fp_soft_state |= FP_SOFT_SUSPEND;

	fp_suspend_all(port);
	mutex_exit(&port->fp_mutex);

	return (DDI_SUCCESS);
}


/*
 * Prepare for graceful power down of a FC port
 */
static int
fp_power_down(fc_local_port_t *port)
{
	ASSERT(MUTEX_HELD(&port->fp_mutex));

	/*
	 * Power down request followed by a DDI_SUSPEND should
	 * never happen; If it does return DDI_SUCCESS
	 */
	if (port->fp_soft_state & FP_SOFT_SUSPEND) {
		port->fp_soft_state |= FP_SOFT_POWER_DOWN;
		return (DDI_SUCCESS);
	}

	/*
	 * If the port is already power suspended, there
	 * is nothing else to do, So return DDI_SUCCESS,
	 */
	if (port->fp_soft_state & FP_SOFT_POWER_DOWN) {
		return (DDI_SUCCESS);
	}

	/*
	 * Check if an unsolicited callback or state change handling
	 * is in progress. If true, fail the PM suspend operation.
	 * But don't print a message unless the verbosity of the
	 * driver desires otherwise.
	 */
	if ((port->fp_soft_state & FP_SOFT_IN_STATEC_CB) ||
	    (port->fp_soft_state & FP_SOFT_IN_UNSOL_CB)) {
		FP_TRACE(FP_NHEAD2(9, 0),
		    "Unsolicited callback in progress: Failing power down");
		return (DDI_FAILURE);
	}

	/*
	 * Check of FC port thread is busy
	 */
	if (port->fp_job_head) {
		FP_TRACE(FP_NHEAD2(9, 0),
		    "FC port thread is busy: Failing power down");
		return (DDI_FAILURE);
	}
	port->fp_soft_state |= FP_SOFT_POWER_DOWN;

	/*
	 * check if the ULPs are ready for power down
	 */
	mutex_exit(&port->fp_mutex);
	if (fctl_detach_ulps(port, FC_CMD_POWER_DOWN,
	    &modlinkage) != FC_SUCCESS) {
		mutex_enter(&port->fp_mutex);
		port->fp_soft_state &= ~FP_SOFT_POWER_DOWN;
		mutex_exit(&port->fp_mutex);

		/*
		 * Power back up the obedient ULPs that went down
		 */
		fp_attach_ulps(port, FC_CMD_POWER_UP);

		FP_TRACE(FP_NHEAD2(9, 0),
		    "ULP(s) busy, detach_ulps failed. Failing power down");
		mutex_enter(&port->fp_mutex);
		return (DDI_FAILURE);
	}
	mutex_enter(&port->fp_mutex);

	fp_suspend_all(port);

	return (DDI_SUCCESS);
}


/*
 * Suspend the entire FC port
 */
static void
fp_suspend_all(fc_local_port_t *port)
{
	int			index;
	struct pwwn_hash 	*head;
	fc_remote_port_t 	*pd;

	ASSERT(MUTEX_HELD(&port->fp_mutex));

	if (port->fp_wait_tid != 0) {
		timeout_id_t 	tid;

		tid = port->fp_wait_tid;
		port->fp_wait_tid = (timeout_id_t)NULL;
		mutex_exit(&port->fp_mutex);
		(void) untimeout(tid);
		mutex_enter(&port->fp_mutex);
		port->fp_restore |= FP_RESTORE_WAIT_TIMEOUT;
	}

	if (port->fp_offline_tid) {
		timeout_id_t 	tid;

		tid = port->fp_offline_tid;
		port->fp_offline_tid = (timeout_id_t)NULL;
		mutex_exit(&port->fp_mutex);
		(void) untimeout(tid);
		mutex_enter(&port->fp_mutex);
		port->fp_restore |= FP_RESTORE_OFFLINE_TIMEOUT;
	}
	mutex_exit(&port->fp_mutex);
	port->fp_fca_tran->fca_unbind_port(port->fp_fca_handle);
	mutex_enter(&port->fp_mutex);

	/*
	 * Mark all devices as OLD, and reset the LOGIN state as well
	 * (this will force the ULPs to perform a LOGIN after calling
	 * fc_portgetmap() during RESUME/PM_RESUME)
	 */
	for (index = 0; index < pwwn_table_size; index++) {
		head = &port->fp_pwwn_table[index];
		pd = head->pwwn_head;
		while (pd != NULL) {
			mutex_enter(&pd->pd_mutex);
			fp_remote_port_offline(pd);
			fctl_delist_did_table(port, pd);
			pd->pd_state = PORT_DEVICE_VALID;
			pd->pd_login_count = 0;
			mutex_exit(&pd->pd_mutex);
			pd = pd->pd_wwn_hnext;
		}
	}
}


/*
 * fp_cache_constructor: Constructor function for kmem_cache_create(9F).
 * Performs intializations for fc_packet_t structs.
 * Returns 0 for success or -1 for failure.
 *
 * This function allocates DMA handles for both command and responses.
 * Most of the ELSs used have both command and responses so it is strongly
 * desired to move them to cache constructor routine.
 *
 * Context: Can sleep iff called with KM_SLEEP flag.
 */
static int
fp_cache_constructor(void *buf, void *cdarg, int kmflags)
{
	int 		(*cb) (caddr_t);
	fc_packet_t 	*pkt;
	fp_cmd_t 	*cmd = (fp_cmd_t *)buf;
	fc_local_port_t *port = (fc_local_port_t *)cdarg;

	cb = (kmflags == KM_SLEEP) ? DDI_DMA_SLEEP : DDI_DMA_DONTWAIT;

	cmd->cmd_next = NULL;
	cmd->cmd_flags = 0;
	cmd->cmd_dflags = 0;
	cmd->cmd_job = NULL;
	cmd->cmd_port = port;
	pkt = &cmd->cmd_pkt;

	if (ddi_dma_alloc_handle(port->fp_fca_dip,
	    port->fp_fca_tran->fca_dma_attr, cb, NULL,
	    &pkt->pkt_cmd_dma) != DDI_SUCCESS) {
		return (-1);
	}

	if (ddi_dma_alloc_handle(port->fp_fca_dip,
	    port->fp_fca_tran->fca_dma_attr, cb, NULL,
	    &pkt->pkt_resp_dma) != DDI_SUCCESS) {
		ddi_dma_free_handle(&pkt->pkt_cmd_dma);
		return (-1);
	}

	pkt->pkt_cmd_acc = pkt->pkt_resp_acc = NULL;
	pkt->pkt_cmd_cookie_cnt = pkt->pkt_resp_cookie_cnt =
	    pkt->pkt_data_cookie_cnt = 0;
	pkt->pkt_cmd_cookie = pkt->pkt_resp_cookie =
	    pkt->pkt_data_cookie = NULL;
	pkt->pkt_fca_private = (caddr_t)buf + sizeof (fp_cmd_t);

	return (0);
}


/*
 * fp_cache_destructor: Destructor function for kmem_cache_create().
 * Performs un-intializations for fc_packet_t structs.
 */
/* ARGSUSED */
static void
fp_cache_destructor(void *buf, void *cdarg)
{
	fp_cmd_t 	*cmd = (fp_cmd_t *)buf;
	fc_packet_t	*pkt;

	pkt = &cmd->cmd_pkt;
	if (pkt->pkt_cmd_dma) {
		ddi_dma_free_handle(&pkt->pkt_cmd_dma);
	}

	if (pkt->pkt_resp_dma) {
		ddi_dma_free_handle(&pkt->pkt_resp_dma);
	}
}


/*
 * Packet allocation for ELS and any other port driver commands
 *
 * Some ELSs like FLOGI and PLOGI are critical for topology and
 * device discovery and a system's inability to allocate memory
 * or DVMA resources while performing some of these critical ELSs
 * cause a lot of problem. While memory allocation failures are
 * rare, DVMA resource failures are common as the applications
 * are becoming more and more powerful on huge servers.  So it
 * is desirable to have a framework support to reserve a fragment
 * of DVMA. So until this is fixed the correct way, the suffering
 * is huge whenever a LIP happens at a time DVMA resources are
 * drained out completely - So an attempt needs to be made to
 * KM_SLEEP while requesting for these resources, hoping that
 * the requests won't hang forever.
 *
 * The fc_remote_port_t argument is stored into the pkt_pd field in the
 * fc_packet_t struct prior to the fc_ulp_init_packet() call.  This
 * ensures that the pd_ref_count for the fc_remote_port_t is valid.
 * If there is no fc_remote_port_t associated with the fc_packet_t, then
 * fp_alloc_pkt() must be called with pd set to NULL.
 */

static fp_cmd_t *
fp_alloc_pkt(fc_local_port_t *port, int cmd_len, int resp_len, int kmflags,
    fc_remote_port_t *pd)
{
	int		rval;
	ulong_t		real_len;
	fp_cmd_t 	*cmd;
	fc_packet_t	*pkt;
	int 		(*cb) (caddr_t);
	ddi_dma_cookie_t	pkt_cookie;
	ddi_dma_cookie_t	*cp;
	uint32_t		cnt;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	cb = (kmflags == KM_SLEEP) ? DDI_DMA_SLEEP : DDI_DMA_DONTWAIT;

	cmd = (fp_cmd_t *)kmem_cache_alloc(port->fp_pkt_cache, kmflags);
	if (cmd == NULL) {
		return (cmd);
	}

	cmd->cmd_ulp_pkt = NULL;
	cmd->cmd_flags = 0;
	pkt = &cmd->cmd_pkt;
	ASSERT(cmd->cmd_dflags == 0);

	pkt->pkt_datalen = 0;
	pkt->pkt_data = NULL;
	pkt->pkt_state = 0;
	pkt->pkt_action = 0;
	pkt->pkt_reason = 0;
	pkt->pkt_expln = 0;

	/*
	 * Init pkt_pd with the given pointer; this must be done _before_
	 * the call to fc_ulp_init_packet().
	 */
	pkt->pkt_pd = pd;

	/* Now call the FCA driver to init its private, per-packet fields */
	if (fc_ulp_init_packet((opaque_t)port, pkt, kmflags) != FC_SUCCESS) {
		goto alloc_pkt_failed;
	}

	if (cmd_len) {
		ASSERT(pkt->pkt_cmd_dma != NULL);

		rval = ddi_dma_mem_alloc(pkt->pkt_cmd_dma, cmd_len,
		    port->fp_fca_tran->fca_acc_attr, DDI_DMA_CONSISTENT,
		    cb, NULL, (caddr_t *)&pkt->pkt_cmd, &real_len,
		    &pkt->pkt_cmd_acc);

		if (rval != DDI_SUCCESS) {
			goto alloc_pkt_failed;
		}
		cmd->cmd_dflags |= FP_CMD_VALID_DMA_MEM;

		if (real_len < cmd_len) {
			goto alloc_pkt_failed;
		}

		rval = ddi_dma_addr_bind_handle(pkt->pkt_cmd_dma, NULL,
		    pkt->pkt_cmd, real_len, DDI_DMA_WRITE |
		    DDI_DMA_CONSISTENT, cb, NULL,
		    &pkt_cookie, &pkt->pkt_cmd_cookie_cnt);

		if (rval != DDI_DMA_MAPPED) {
			goto alloc_pkt_failed;
		}

		cmd->cmd_dflags |= FP_CMD_VALID_DMA_BIND;

		if (pkt->pkt_cmd_cookie_cnt >
		    port->fp_fca_tran->fca_dma_attr->dma_attr_sgllen) {
			goto alloc_pkt_failed;
		}

		ASSERT(pkt->pkt_cmd_cookie_cnt != 0);

		cp = pkt->pkt_cmd_cookie = (ddi_dma_cookie_t *)kmem_alloc(
		    pkt->pkt_cmd_cookie_cnt * sizeof (pkt_cookie),
		    KM_NOSLEEP);

		if (cp == NULL) {
			goto alloc_pkt_failed;
		}

		*cp = pkt_cookie;
		cp++;
		for (cnt = 1; cnt < pkt->pkt_cmd_cookie_cnt; cnt++, cp++) {
			ddi_dma_nextcookie(pkt->pkt_cmd_dma, &pkt_cookie);
			*cp = pkt_cookie;
		}
	}

	if (resp_len) {
		ASSERT(pkt->pkt_resp_dma != NULL);

		rval = ddi_dma_mem_alloc(pkt->pkt_resp_dma, resp_len,
		    port->fp_fca_tran->fca_acc_attr,
		    DDI_DMA_CONSISTENT, cb, NULL,
		    (caddr_t *)&pkt->pkt_resp, &real_len,
		    &pkt->pkt_resp_acc);

		if (rval != DDI_SUCCESS) {
			goto alloc_pkt_failed;
		}
		cmd->cmd_dflags |= FP_RESP_VALID_DMA_MEM;

		if (real_len < resp_len) {
			goto alloc_pkt_failed;
		}

		rval = ddi_dma_addr_bind_handle(pkt->pkt_resp_dma, NULL,
		    pkt->pkt_resp, real_len, DDI_DMA_READ |
		    DDI_DMA_CONSISTENT, cb, NULL,
		    &pkt_cookie, &pkt->pkt_resp_cookie_cnt);

		if (rval != DDI_DMA_MAPPED) {
			goto alloc_pkt_failed;
		}

		cmd->cmd_dflags |= FP_RESP_VALID_DMA_BIND;

		if (pkt->pkt_resp_cookie_cnt >
		    port->fp_fca_tran->fca_dma_attr->dma_attr_sgllen) {
			goto alloc_pkt_failed;
		}

		ASSERT(pkt->pkt_cmd_cookie_cnt != 0);

		cp = pkt->pkt_resp_cookie = (ddi_dma_cookie_t *)kmem_alloc(
		    pkt->pkt_resp_cookie_cnt * sizeof (pkt_cookie),
		    KM_NOSLEEP);

		if (cp == NULL) {
			goto alloc_pkt_failed;
		}

		*cp = pkt_cookie;
		cp++;
		for (cnt = 1; cnt < pkt->pkt_resp_cookie_cnt; cnt++, cp++) {
			ddi_dma_nextcookie(pkt->pkt_resp_dma, &pkt_cookie);
			*cp = pkt_cookie;
		}
	}

	pkt->pkt_cmdlen = cmd_len;
	pkt->pkt_rsplen = resp_len;
	pkt->pkt_ulp_private = cmd;

	return (cmd);

alloc_pkt_failed:

	fp_free_dma(cmd);

	if (pkt->pkt_cmd_cookie != NULL) {
		kmem_free(pkt->pkt_cmd_cookie,
		    pkt->pkt_cmd_cookie_cnt * sizeof (ddi_dma_cookie_t));
		pkt->pkt_cmd_cookie = NULL;
	}

	if (pkt->pkt_resp_cookie != NULL) {
		kmem_free(pkt->pkt_resp_cookie,
		    pkt->pkt_resp_cookie_cnt * sizeof (ddi_dma_cookie_t));
		pkt->pkt_resp_cookie = NULL;
	}

	kmem_cache_free(port->fp_pkt_cache, cmd);

	return (NULL);
}


/*
 * Free FC packet
 */
static void
fp_free_pkt(fp_cmd_t *cmd)
{
	fc_local_port_t *port;
	fc_packet_t 	*pkt;

	ASSERT(!MUTEX_HELD(&cmd->cmd_port->fp_mutex));

	cmd->cmd_next = NULL;
	cmd->cmd_job = NULL;
	pkt = &cmd->cmd_pkt;
	pkt->pkt_ulp_private = 0;
	pkt->pkt_tran_flags = 0;
	pkt->pkt_tran_type = 0;
	port = cmd->cmd_port;

	if (pkt->pkt_cmd_cookie != NULL) {
		kmem_free(pkt->pkt_cmd_cookie, pkt->pkt_cmd_cookie_cnt *
		    sizeof (ddi_dma_cookie_t));
		pkt->pkt_cmd_cookie = NULL;
	}

	if (pkt->pkt_resp_cookie != NULL) {
		kmem_free(pkt->pkt_resp_cookie, pkt->pkt_resp_cookie_cnt *
		    sizeof (ddi_dma_cookie_t));
		pkt->pkt_resp_cookie = NULL;
	}

	fp_free_dma(cmd);
	(void) fc_ulp_uninit_packet((opaque_t)port, pkt);
	kmem_cache_free(port->fp_pkt_cache, (void *)cmd);
}


/*
 * Release DVMA resources
 */
static void
fp_free_dma(fp_cmd_t *cmd)
{
	fc_packet_t *pkt = &cmd->cmd_pkt;

	pkt->pkt_cmdlen = 0;
	pkt->pkt_rsplen = 0;
	pkt->pkt_tran_type = 0;
	pkt->pkt_tran_flags = 0;

	if (cmd->cmd_dflags & FP_CMD_VALID_DMA_BIND) {
		(void) ddi_dma_unbind_handle(pkt->pkt_cmd_dma);
	}

	if (cmd->cmd_dflags & FP_CMD_VALID_DMA_MEM) {
		if (pkt->pkt_cmd_acc) {
			ddi_dma_mem_free(&pkt->pkt_cmd_acc);
		}
	}

	if (cmd->cmd_dflags & FP_RESP_VALID_DMA_BIND) {
		(void) ddi_dma_unbind_handle(pkt->pkt_resp_dma);
	}

	if (cmd->cmd_dflags & FP_RESP_VALID_DMA_MEM) {
		if (pkt->pkt_resp_acc) {
			ddi_dma_mem_free(&pkt->pkt_resp_acc);
		}
	}
	cmd->cmd_dflags = 0;
}


/*
 * Dedicated thread to perform various activities.  One thread for
 * each fc_local_port_t (driver soft state) instance.
 * Note, this effectively works out to one thread for each local
 * port, but there are also some Solaris taskq threads in use on a per-local
 * port basis; these also need to be taken into consideration.
 */
static void
fp_job_handler(fc_local_port_t *port)
{
	int			rval;
	uint32_t		*d_id;
	fc_remote_port_t 	*pd;
	job_request_t 		*job;

#ifndef	__lock_lint
	/*
	 * Solaris-internal stuff for proper operation of kernel threads
	 * with Solaris CPR.
	 */
	CALLB_CPR_INIT(&port->fp_cpr_info, &port->fp_mutex,
	    callb_generic_cpr, "fp_job_handler");
#endif


	/* Loop forever waiting for work to do */
	for (;;) {

		mutex_enter(&port->fp_mutex);

		/*
		 * Sleep if no work to do right now, or if we want
		 * to suspend or power-down.
		 */
		while (port->fp_job_head == NULL ||
		    (port->fp_soft_state & (FP_SOFT_POWER_DOWN |
		    FP_SOFT_SUSPEND))) {
			CALLB_CPR_SAFE_BEGIN(&port->fp_cpr_info);
			cv_wait(&port->fp_cv, &port->fp_mutex);
			CALLB_CPR_SAFE_END(&port->fp_cpr_info, &port->fp_mutex);
		}

		/*
		 * OK, we've just been woken up, so retrieve the next entry
		 * from the head of the job queue for this local port.
		 */
		job = fctl_deque_job(port);

		/*
		 * Handle all the fp driver's supported job codes here
		 * in this big honkin' switch.
		 */
		switch (job->job_code) {
		case JOB_PORT_SHUTDOWN:
			/*
			 * fp_port_shutdown() is only called from here. This
			 * will prepare the local port instance (softstate)
			 * for detaching.  This cancels timeout callbacks,
			 * executes LOGOs with remote ports, cleans up tables,
			 * and deallocates data structs.
			 */
			fp_port_shutdown(port, job);

			/*
			 * This will exit the job thread.
			 */
#ifndef __lock_lint
			CALLB_CPR_EXIT(&(port->fp_cpr_info));
#else
			mutex_exit(&port->fp_mutex);
#endif
			fctl_jobdone(job);
			thread_exit();

			/* NOTREACHED */

		case JOB_ATTACH_ULP: {
			/*
			 * This job is spawned in response to a ULP calling
			 * fc_ulp_add().
			 */

			boolean_t do_attach_ulps = B_TRUE;

			/*
			 * If fp is detaching, we don't want to call
			 * fp_startup_done as this asynchronous
			 * notification may interfere with the re-attach.
			 */

			if (port->fp_soft_state & (FP_DETACH_INPROGRESS |
			    FP_SOFT_IN_DETACH | FP_DETACH_FAILED)) {
				do_attach_ulps = B_FALSE;
			} else {
				/*
				 * We are going to force the transport
				 * to attach to the ULPs, so set
				 * fp_ulp_attach.  This will keep any
				 * potential detach from occurring until
				 * we are done.
				 */
				port->fp_ulp_attach = 1;
			}

			mutex_exit(&port->fp_mutex);

			/*
			 * NOTE: Since we just dropped the mutex, there is now
			 * a race window where the fp_soft_state check above
			 * could change here.  This race is covered because an
			 * additional check was added in the functions hidden
			 * under fp_startup_done().
			 */
			if (do_attach_ulps == B_TRUE) {
				/*
				 * This goes thru a bit of a convoluted call
				 * chain before spawning off a DDI taskq
				 * request to perform the actual attach
				 * operations. Blocking can occur at a number
				 * of points.
				 */
				fp_startup_done((opaque_t)port, FC_PKT_SUCCESS);
			}
			job->job_result = FC_SUCCESS;
			fctl_jobdone(job);
			break;
		}

		case JOB_ULP_NOTIFY: {
			/*
			 * Pass state change notifications up to any/all
			 * registered ULPs.
			 */
			uint32_t statec;

			statec = job->job_ulp_listlen;
			if (statec == FC_STATE_RESET_REQUESTED) {
				port->fp_last_task = port->fp_task;
				port->fp_task = FP_TASK_OFFLINE;
				fp_port_offline(port, 0);
				port->fp_task = port->fp_last_task;
				port->fp_last_task = FP_TASK_IDLE;
			}

			if (--port->fp_statec_busy == 0) {
				port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
			}

			mutex_exit(&port->fp_mutex);

			job->job_result = fp_ulp_notify(port, statec, KM_SLEEP);
			fctl_jobdone(job);
			break;
		}

		case JOB_PLOGI_ONE:
			/*
			 * Issue a PLOGI to a single remote port. Multiple
			 * PLOGIs to different remote ports may occur in
			 * parallel.
			 * This can create the fc_remote_port_t if it does not
			 * already exist.
			 */

			mutex_exit(&port->fp_mutex);
			d_id = (uint32_t *)job->job_private;
			pd = fctl_get_remote_port_by_did(port, *d_id);

			if (pd) {
				mutex_enter(&pd->pd_mutex);
				if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
					pd->pd_login_count++;
					mutex_exit(&pd->pd_mutex);
					job->job_result = FC_SUCCESS;
					fctl_jobdone(job);
					break;
				}
				mutex_exit(&pd->pd_mutex);
			} else {
				mutex_enter(&port->fp_mutex);
				if (FC_IS_TOP_SWITCH(port->fp_topology)) {
					mutex_exit(&port->fp_mutex);
					pd = fp_create_remote_port_by_ns(port,
					    *d_id, KM_SLEEP);
					if (pd == NULL) {
						job->job_result = FC_FAILURE;
						fctl_jobdone(job);
						break;
					}
				} else {
					mutex_exit(&port->fp_mutex);
				}
			}

			job->job_flags |= JOB_TYPE_FP_ASYNC;
			job->job_counter = 1;

			rval = fp_port_login(port, *d_id, job,
			    FP_CMD_PLOGI_RETAIN, KM_SLEEP, pd, NULL);

			if (rval != FC_SUCCESS) {
				job->job_result = rval;
				fctl_jobdone(job);
			}
			break;

		case JOB_LOGO_ONE: {
			/*
			 * Issue a PLOGO to a single remote port. Multiple
			 * PLOGOs to different remote ports may occur in
			 * parallel.
			 */
			fc_remote_port_t *pd;

#ifndef	__lock_lint
			ASSERT(job->job_counter > 0);
#endif

			pd = (fc_remote_port_t *)job->job_ulp_pkts;

			mutex_enter(&pd->pd_mutex);
			if (pd->pd_state != PORT_DEVICE_LOGGED_IN) {
				mutex_exit(&pd->pd_mutex);
				job->job_result = FC_LOGINREQ;
				mutex_exit(&port->fp_mutex);
				fctl_jobdone(job);
				break;
			}
			if (pd->pd_login_count > 1) {
				pd->pd_login_count--;
				mutex_exit(&pd->pd_mutex);
				job->job_result = FC_SUCCESS;
				mutex_exit(&port->fp_mutex);
				fctl_jobdone(job);
				break;
			}
			mutex_exit(&pd->pd_mutex);
			mutex_exit(&port->fp_mutex);
			job->job_flags |= JOB_TYPE_FP_ASYNC;
			(void) fp_logout(port, pd, job);
			break;
		}

		case JOB_FCIO_LOGIN:
			/*
			 * PLOGI initiated at ioctl request.
			 */
			mutex_exit(&port->fp_mutex);
			job->job_result =
			    fp_fcio_login(port, job->job_private, job);
			fctl_jobdone(job);
			break;

		case JOB_FCIO_LOGOUT:
			/*
			 * PLOGO initiated at ioctl request.
			 */
			mutex_exit(&port->fp_mutex);
			job->job_result =
			    fp_fcio_logout(port, job->job_private, job);
			fctl_jobdone(job);
			break;

		case JOB_PORT_GETMAP:
		case JOB_PORT_GETMAP_PLOGI_ALL: {
			port->fp_last_task = port->fp_task;
			port->fp_task = FP_TASK_GETMAP;

			switch (port->fp_topology) {
			case FC_TOP_PRIVATE_LOOP:
				job->job_counter = 1;

				fp_get_loopmap(port, job);
				mutex_exit(&port->fp_mutex);
				fp_jobwait(job);
				fctl_fillout_map(port,
				    (fc_portmap_t **)job->job_private,
				    (uint32_t *)job->job_arg, 1, 0, 0);
				fctl_jobdone(job);
				mutex_enter(&port->fp_mutex);
				break;

			case FC_TOP_PUBLIC_LOOP:
			case FC_TOP_FABRIC:
				mutex_exit(&port->fp_mutex);
				job->job_counter = 1;

				job->job_result = fp_ns_getmap(port,
				    job, (fc_portmap_t **)job->job_private,
				    (uint32_t *)job->job_arg,
				    FCTL_GAN_START_ID);
				fctl_jobdone(job);
				mutex_enter(&port->fp_mutex);
				break;

			case FC_TOP_PT_PT:
				mutex_exit(&port->fp_mutex);
				fctl_fillout_map(port,
				    (fc_portmap_t **)job->job_private,
				    (uint32_t *)job->job_arg, 1, 0, 0);
				fctl_jobdone(job);
				mutex_enter(&port->fp_mutex);
				break;

			default:
				mutex_exit(&port->fp_mutex);
				fctl_jobdone(job);
				mutex_enter(&port->fp_mutex);
				break;
			}
			port->fp_task = port->fp_last_task;
			port->fp_last_task = FP_TASK_IDLE;
			mutex_exit(&port->fp_mutex);
			break;
		}

		case JOB_PORT_OFFLINE: {
			fp_log_port_event(port, ESC_SUNFC_PORT_OFFLINE);

			port->fp_last_task = port->fp_task;
			port->fp_task = FP_TASK_OFFLINE;

			if (port->fp_statec_busy > 2) {
				job->job_flags |= JOB_CANCEL_ULP_NOTIFICATION;
				fp_port_offline(port, 0);
				if (--port->fp_statec_busy == 0) {
					port->fp_soft_state &=
					    ~FP_SOFT_IN_STATEC_CB;
				}
			} else {
				fp_port_offline(port, 1);
			}

			port->fp_task = port->fp_last_task;
			port->fp_last_task = FP_TASK_IDLE;

			mutex_exit(&port->fp_mutex);

			fctl_jobdone(job);
			break;
		}

		case JOB_PORT_STARTUP: {
			if ((rval = fp_port_startup(port, job)) != FC_SUCCESS) {
				if (port->fp_statec_busy > 1) {
					mutex_exit(&port->fp_mutex);
					break;
				}
				mutex_exit(&port->fp_mutex);

				FP_TRACE(FP_NHEAD2(9, rval),
				    "Topology discovery failed");
				break;
			}

			/*
			 * Attempt building device handles in case
			 * of private Loop.
			 */
			if (port->fp_topology == FC_TOP_PRIVATE_LOOP) {
				job->job_counter = 1;

				fp_get_loopmap(port, job);
				mutex_exit(&port->fp_mutex);
				fp_jobwait(job);
				mutex_enter(&port->fp_mutex);
				if (port->fp_lilp_map.lilp_magic < MAGIC_LIRP) {
					ASSERT(port->fp_total_devices == 0);
					port->fp_total_devices =
					    port->fp_dev_count;
				}
			} else if (FC_IS_TOP_SWITCH(port->fp_topology)) {
				/*
				 * Hack to avoid state changes going up early
				 */
				port->fp_statec_busy++;
				port->fp_soft_state |= FP_SOFT_IN_STATEC_CB;

				job->job_flags |= JOB_CANCEL_ULP_NOTIFICATION;
				fp_fabric_online(port, job);
				job->job_flags &= ~JOB_CANCEL_ULP_NOTIFICATION;
			}
			mutex_exit(&port->fp_mutex);
			fctl_jobdone(job);
			break;
		}

		case JOB_PORT_ONLINE: {
			char 		*newtop;
			char 		*oldtop;
			uint32_t	old_top;

			fp_log_port_event(port, ESC_SUNFC_PORT_ONLINE);

			/*
			 * Bail out early if there are a lot of
			 * state changes in the pipeline
			 */
			if (port->fp_statec_busy > 1) {
				--port->fp_statec_busy;
				mutex_exit(&port->fp_mutex);
				fctl_jobdone(job);
				break;
			}

			switch (old_top = port->fp_topology) {
			case FC_TOP_PRIVATE_LOOP:
				oldtop = "Private Loop";
				break;

			case FC_TOP_PUBLIC_LOOP:
				oldtop = "Public Loop";
				break;

			case FC_TOP_PT_PT:
				oldtop = "Point to Point";
				break;

			case FC_TOP_FABRIC:
				oldtop = "Fabric";
				break;

			default:
				oldtop = NULL;
				break;
			}

			port->fp_last_task = port->fp_task;
			port->fp_task = FP_TASK_ONLINE;

			if ((rval = fp_port_startup(port, job)) != FC_SUCCESS) {

				port->fp_task = port->fp_last_task;
				port->fp_last_task = FP_TASK_IDLE;

				if (port->fp_statec_busy > 1) {
					--port->fp_statec_busy;
					mutex_exit(&port->fp_mutex);
					break;
				}

				port->fp_state = FC_STATE_OFFLINE;

				FP_TRACE(FP_NHEAD2(9, rval),
				    "Topology discovery failed");

				if (--port->fp_statec_busy == 0) {
					port->fp_soft_state &=
					    ~FP_SOFT_IN_STATEC_CB;
				}

				if (port->fp_offline_tid == NULL) {
					port->fp_offline_tid =
					    timeout(fp_offline_timeout,
					    (caddr_t)port, fp_offline_ticks);
				}

				mutex_exit(&port->fp_mutex);
				break;
			}

			switch (port->fp_topology) {
			case FC_TOP_PRIVATE_LOOP:
				newtop = "Private Loop";
				break;

			case FC_TOP_PUBLIC_LOOP:
				newtop = "Public Loop";
				break;

			case FC_TOP_PT_PT:
				newtop = "Point to Point";
				break;

			case FC_TOP_FABRIC:
				newtop = "Fabric";
				break;

			default:
				newtop = NULL;
				break;
			}

			if (oldtop && newtop && strcmp(oldtop, newtop)) {
				fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
				    "Change in FC Topology old = %s new = %s",
				    oldtop, newtop);
			}

			switch (port->fp_topology) {
			case FC_TOP_PRIVATE_LOOP: {
				int orphan = (old_top == FC_TOP_FABRIC ||
				    old_top == FC_TOP_PUBLIC_LOOP) ? 1 : 0;

				mutex_exit(&port->fp_mutex);
				fp_loop_online(port, job, orphan);
				break;
			}

			case FC_TOP_PUBLIC_LOOP:
				/* FALLTHROUGH */
			case FC_TOP_FABRIC:
				fp_fabric_online(port, job);
				mutex_exit(&port->fp_mutex);
				break;

			case FC_TOP_PT_PT:
				fp_p2p_online(port, job);
				mutex_exit(&port->fp_mutex);
				break;

			default:
				if (--port->fp_statec_busy != 0) {
					/*
					 * Watch curiously at what the next
					 * state transition can do.
					 */
					mutex_exit(&port->fp_mutex);
					break;
				}

				FP_TRACE(FP_NHEAD2(9, 0),
				    "Topology Unknown, Offlining the port..");

				port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
				port->fp_state = FC_STATE_OFFLINE;

				if (port->fp_offline_tid == NULL) {
					port->fp_offline_tid =
					    timeout(fp_offline_timeout,
					    (caddr_t)port, fp_offline_ticks);
				}
				mutex_exit(&port->fp_mutex);
				break;
			}

			mutex_enter(&port->fp_mutex);

			port->fp_task = port->fp_last_task;
			port->fp_last_task = FP_TASK_IDLE;

			mutex_exit(&port->fp_mutex);

			fctl_jobdone(job);
			break;
		}

		case JOB_PLOGI_GROUP: {
			mutex_exit(&port->fp_mutex);
			fp_plogi_group(port, job);
			break;
		}

		case JOB_UNSOL_REQUEST: {
			mutex_exit(&port->fp_mutex);
			fp_handle_unsol_buf(port,
			    (fc_unsol_buf_t *)job->job_private, job);
			fctl_dealloc_job(job);
			break;
		}

		case JOB_NS_CMD: {
			fctl_ns_req_t *ns_cmd;

			mutex_exit(&port->fp_mutex);

			job->job_flags |= JOB_TYPE_FP_ASYNC;
			ns_cmd = (fctl_ns_req_t *)job->job_private;
			if (ns_cmd->ns_cmd_code < NS_GA_NXT ||
			    ns_cmd->ns_cmd_code > NS_DA_ID) {
				job->job_result = FC_BADCMD;
				fctl_jobdone(job);
				break;
			}

			if (FC_IS_CMD_A_REG(ns_cmd->ns_cmd_code)) {
				if (ns_cmd->ns_pd != NULL) {
					job->job_result = FC_BADOBJECT;
					fctl_jobdone(job);
					break;
				}

				job->job_counter = 1;

				rval = fp_ns_reg(port, ns_cmd->ns_pd,
				    ns_cmd->ns_cmd_code, job, 0, KM_SLEEP);

				if (rval != FC_SUCCESS) {
					job->job_result = rval;
					fctl_jobdone(job);
				}
				break;
			}
			job->job_result = FC_SUCCESS;
			job->job_counter = 1;

			rval = fp_ns_query(port, ns_cmd, job, 0, KM_SLEEP);
			if (rval != FC_SUCCESS) {
				fctl_jobdone(job);
			}
			break;
		}

		case JOB_LINK_RESET: {
			la_wwn_t *pwwn;
			uint32_t topology;

			pwwn = (la_wwn_t *)job->job_private;
			ASSERT(pwwn != NULL);

			topology = port->fp_topology;
			mutex_exit(&port->fp_mutex);

			if (fctl_is_wwn_zero(pwwn) == FC_SUCCESS ||
			    topology == FC_TOP_PRIVATE_LOOP) {
				job->job_flags |= JOB_TYPE_FP_ASYNC;
				rval = port->fp_fca_tran->fca_reset(
				    port->fp_fca_handle, FC_FCA_LINK_RESET);
				job->job_result = rval;
				fp_jobdone(job);
			} else {
				ASSERT((job->job_flags &
				    JOB_TYPE_FP_ASYNC) == 0);

				if (FC_IS_TOP_SWITCH(topology)) {
					rval = fp_remote_lip(port, pwwn,
					    KM_SLEEP, job);
				} else {
					rval = FC_FAILURE;
				}
				if (rval != FC_SUCCESS) {
					job->job_result = rval;
				}
				fctl_jobdone(job);
			}
			break;
		}

		default:
			mutex_exit(&port->fp_mutex);
			job->job_result = FC_BADCMD;
			fctl_jobdone(job);
			break;
		}
	}
	/* NOTREACHED */
}


/*
 * Perform FC port bring up initialization
 */
static int
fp_port_startup(fc_local_port_t *port, job_request_t *job)
{
	int		rval;
	uint32_t	state;
	uint32_t	src_id;
	fc_lilpmap_t 	*lilp_map;

	ASSERT(MUTEX_HELD(&port->fp_mutex));
	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

	FP_DTRACE(FP_NHEAD1(2, 0), "Entering fp_port_startup;"
	    " port=%p, job=%p", port, job);

	port->fp_topology = FC_TOP_UNKNOWN;
	port->fp_port_id.port_id = 0;
	state = FC_PORT_STATE_MASK(port->fp_state);

	if (state == FC_STATE_OFFLINE) {
		port->fp_port_type.port_type = FC_NS_PORT_UNKNOWN;
		job->job_result = FC_OFFLINE;
		mutex_exit(&port->fp_mutex);
		fctl_jobdone(job);
		mutex_enter(&port->fp_mutex);
		return (FC_OFFLINE);
	}

	if (state == FC_STATE_LOOP) {
		port->fp_port_type.port_type = FC_NS_PORT_NL;
		mutex_exit(&port->fp_mutex);

		lilp_map = &port->fp_lilp_map;
		if ((rval = fp_get_lilpmap(port, lilp_map)) != FC_SUCCESS) {
			job->job_result = FC_FAILURE;
			fctl_jobdone(job);

			FP_TRACE(FP_NHEAD1(9, rval),
			    "LILP map Invalid or not present");
			mutex_enter(&port->fp_mutex);
			return (FC_FAILURE);
		}

		if (lilp_map->lilp_length == 0) {
			job->job_result = FC_NO_MAP;
			fctl_jobdone(job);
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
			    "LILP map length zero");
			mutex_enter(&port->fp_mutex);
			return (FC_NO_MAP);
		}
		src_id = lilp_map->lilp_myalpa & 0xFF;
	} else {
		fc_remote_port_t	*pd;
		fc_fca_pm_t		pm;
		fc_fca_p2p_info_t	p2p_info;
		int			pd_recepient;

		/*
		 * Get P2P remote port info if possible
		 */
		bzero((caddr_t)&pm, sizeof (pm));

		pm.pm_cmd_flags = FC_FCA_PM_READ;
		pm.pm_cmd_code = FC_PORT_GET_P2P_INFO;
		pm.pm_data_len = sizeof (fc_fca_p2p_info_t);
		pm.pm_data_buf = (caddr_t)&p2p_info;

		rval = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		if (rval == FC_SUCCESS) {
			port->fp_port_id.port_id = p2p_info.fca_d_id;
			port->fp_port_type.port_type = FC_NS_PORT_N;
			port->fp_topology = FC_TOP_PT_PT;
			port->fp_total_devices = 1;
			pd_recepient = fctl_wwn_cmp(
			    &port->fp_service_params.nport_ww_name,
			    &p2p_info.pwwn) < 0 ?
			    PD_PLOGI_RECEPIENT : PD_PLOGI_INITIATOR;
			mutex_exit(&port->fp_mutex);
			pd = fctl_create_remote_port(port,
			    &p2p_info.nwwn,
			    &p2p_info.pwwn,
			    p2p_info.d_id,
			    pd_recepient, KM_NOSLEEP);
			FP_DTRACE(FP_NHEAD1(2, 0), "Exiting fp_port_startup;"
			    " P2P port=%p pd=%p", port, pd);
			mutex_enter(&port->fp_mutex);
			return (FC_SUCCESS);
		}
		port->fp_port_type.port_type = FC_NS_PORT_N;
		mutex_exit(&port->fp_mutex);
		src_id = 0;
	}

	job->job_counter = 1;
	job->job_result = FC_SUCCESS;

	if ((rval = fp_fabric_login(port, src_id, job, FP_CMD_PLOGI_DONT_CARE,
	    KM_SLEEP)) != FC_SUCCESS) {
		port->fp_port_type.port_type = FC_NS_PORT_UNKNOWN;
		job->job_result = FC_FAILURE;
		fctl_jobdone(job);

		mutex_enter(&port->fp_mutex);
		if (port->fp_statec_busy <= 1) {
			mutex_exit(&port->fp_mutex);
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, rval, NULL,
			    "Couldn't transport FLOGI");
			mutex_enter(&port->fp_mutex);
		}
		return (FC_FAILURE);
	}

	fp_jobwait(job);

	mutex_enter(&port->fp_mutex);
	if (job->job_result == FC_SUCCESS) {
		if (FC_IS_TOP_SWITCH(port->fp_topology)) {
			mutex_exit(&port->fp_mutex);
			fp_ns_init(port, job, KM_SLEEP);
			mutex_enter(&port->fp_mutex);
		}
	} else {
		if (state == FC_STATE_LOOP) {
			port->fp_topology = FC_TOP_PRIVATE_LOOP;
			port->fp_port_id.port_id =
			    port->fp_lilp_map.lilp_myalpa & 0xFF;
		}
	}

	FP_DTRACE(FP_NHEAD1(2, 0), "Exiting fp_port_startup; port=%p, job=%p",
	    port, job);

	return (FC_SUCCESS);
}


/*
 * Perform ULP invocations following FC port startup
 */
/* ARGSUSED */
static void
fp_startup_done(opaque_t arg, uchar_t result)
{
	fc_local_port_t *port = arg;

	fp_attach_ulps(port, FC_CMD_ATTACH);

	FP_DTRACE(FP_NHEAD1(2, 0), "fp_startup almost complete; port=%p", port);
}


/*
 * Perform ULP port attach
 */
static void
fp_ulp_port_attach(void *arg)
{
	fp_soft_attach_t *att = (fp_soft_attach_t *)arg;
	fc_local_port_t	 *port = att->att_port;

	FP_DTRACE(FP_NHEAD1(1, 0), "port attach of"
	    " ULPs begin; port=%p, cmd=%x", port, att->att_cmd);

	fctl_attach_ulps(att->att_port, att->att_cmd, &modlinkage);

	if (att->att_need_pm_idle == B_TRUE) {
		fctl_idle_port(port);
	}

	FP_DTRACE(FP_NHEAD1(1, 0), "port attach of"
	    " ULPs end; port=%p, cmd=%x", port, att->att_cmd);

	mutex_enter(&att->att_port->fp_mutex);
	att->att_port->fp_ulp_attach = 0;

	port->fp_task = port->fp_last_task;
	port->fp_last_task = FP_TASK_IDLE;

	cv_signal(&att->att_port->fp_attach_cv);

	mutex_exit(&att->att_port->fp_mutex);

	kmem_free(att, sizeof (fp_soft_attach_t));
}

/*
 * Entry point to funnel all requests down to FCAs
 */
static int
fp_sendcmd(fc_local_port_t *port, fp_cmd_t *cmd, opaque_t fca_handle)
{
	int rval;

	mutex_enter(&port->fp_mutex);
	if (port->fp_statec_busy > 1 || (cmd->cmd_ulp_pkt != NULL &&
	    (port->fp_statec_busy || FC_PORT_STATE_MASK(port->fp_state) ==
	    FC_STATE_OFFLINE))) {
		/*
		 * This means there is more than one state change
		 * at this point of time - Since they are processed
		 * serially, any processing of the current one should
		 * be failed, failed and move up in processing the next
		 */
		cmd->cmd_pkt.pkt_state = FC_PKT_ELS_IN_PROGRESS;
		cmd->cmd_pkt.pkt_reason = FC_REASON_OFFLINE;
		if (cmd->cmd_job) {
			/*
			 * A state change that is going to be invalidated
			 * by another one already in the port driver's queue
			 * need not go up to all ULPs. This will minimize
			 * needless processing and ripples in ULP modules
			 */
			cmd->cmd_job->job_flags |= JOB_CANCEL_ULP_NOTIFICATION;
		}
		mutex_exit(&port->fp_mutex);
		return (FC_STATEC_BUSY);
	}

	if (FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) {
		cmd->cmd_pkt.pkt_state = FC_PKT_PORT_OFFLINE;
		cmd->cmd_pkt.pkt_reason = FC_REASON_OFFLINE;
		mutex_exit(&port->fp_mutex);

		return (FC_OFFLINE);
	}
	mutex_exit(&port->fp_mutex);

	rval = cmd->cmd_transport(fca_handle, &cmd->cmd_pkt);
	if (rval != FC_SUCCESS) {
		if (rval == FC_TRAN_BUSY) {
			cmd->cmd_retry_interval = fp_retry_delay;
			rval = fp_retry_cmd(&cmd->cmd_pkt);
			if (rval == FC_FAILURE) {
				cmd->cmd_pkt.pkt_state = FC_PKT_TRAN_BSY;
			}
		}
	}

	return (rval);
}


/*
 * Each time a timeout kicks in, walk the wait queue, decrement the
 * the retry_interval, when the retry_interval becomes less than
 * or equal to zero, re-transport the command: If the re-transport
 * fails with BUSY, enqueue the command in the wait queue.
 *
 * In order to prevent looping forever because of commands enqueued
 * from within this function itself, save the current tail pointer
 * (in cur_tail) and exit the loop after serving this command.
 */
static void
fp_resendcmd(void *port_handle)
{
	int		rval;
	fc_local_port_t	*port;
	fp_cmd_t 	*cmd;
	fp_cmd_t	*cur_tail;

	port = port_handle;
	mutex_enter(&port->fp_mutex);
	cur_tail = port->fp_wait_tail;
	mutex_exit(&port->fp_mutex);

	while ((cmd = fp_deque_cmd(port)) != NULL) {
		cmd->cmd_retry_interval -= fp_retry_ticker;
		/* Check if we are detaching */
		if (port->fp_soft_state &
		    (FP_SOFT_IN_DETACH | FP_DETACH_INPROGRESS)) {
			cmd->cmd_pkt.pkt_state = FC_PKT_TRAN_ERROR;
			cmd->cmd_pkt.pkt_reason = 0;
			fp_iodone(cmd);
		} else if (cmd->cmd_retry_interval <= 0) {
			rval = cmd->cmd_transport(port->fp_fca_handle,
			    &cmd->cmd_pkt);

			if (rval != FC_SUCCESS) {
				if (cmd->cmd_pkt.pkt_state == FC_PKT_TRAN_BSY) {
					if (--cmd->cmd_retry_count) {
						fp_enque_cmd(port, cmd);
						if (cmd == cur_tail) {
							break;
						}
						continue;
					}
					cmd->cmd_pkt.pkt_state =
					    FC_PKT_TRAN_BSY;
				} else {
					cmd->cmd_pkt.pkt_state =
					    FC_PKT_TRAN_ERROR;
				}
				cmd->cmd_pkt.pkt_reason = 0;
				fp_iodone(cmd);
			}
		} else {
			fp_enque_cmd(port, cmd);
		}

		if (cmd == cur_tail) {
			break;
		}
	}

	mutex_enter(&port->fp_mutex);
	if (port->fp_wait_head) {
		timeout_id_t tid;

		mutex_exit(&port->fp_mutex);
		tid = timeout(fp_resendcmd, (caddr_t)port,
		    fp_retry_ticks);
		mutex_enter(&port->fp_mutex);
		port->fp_wait_tid = tid;
	} else {
		port->fp_wait_tid = NULL;
	}
	mutex_exit(&port->fp_mutex);
}


/*
 * Handle Local, Fabric, N_Port, Transport (whatever that means) BUSY here.
 *
 * Yes, as you can see below, cmd_retry_count is used here too.  That means
 * the retries for BUSY are less if there were transport failures (transport
 * failure means fca_transport failure). The goal is not to exceed overall
 * retries set in the cmd_retry_count (whatever may be the reason for retry)
 *
 * Return Values:
 *	FC_SUCCESS
 *	FC_FAILURE
 */
static int
fp_retry_cmd(fc_packet_t *pkt)
{
	fp_cmd_t *cmd;

	cmd = pkt->pkt_ulp_private;

	if (--cmd->cmd_retry_count) {
		fp_enque_cmd(cmd->cmd_port, cmd);
		return (FC_SUCCESS);
	} else {
		return (FC_FAILURE);
	}
}


/*
 * Queue up FC packet for deferred retry
 */
static void
fp_enque_cmd(fc_local_port_t *port, fp_cmd_t *cmd)
{
	timeout_id_t tid;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

#ifdef	DEBUG
	fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, &cmd->cmd_pkt,
	    "Retrying ELS for %x", cmd->cmd_pkt.pkt_cmd_fhdr.d_id);
#endif

	mutex_enter(&port->fp_mutex);
	if (port->fp_wait_tail) {
		port->fp_wait_tail->cmd_next = cmd;
		port->fp_wait_tail = cmd;
	} else {
		ASSERT(port->fp_wait_head == NULL);
		port->fp_wait_head = port->fp_wait_tail = cmd;
		if (port->fp_wait_tid == NULL) {
			mutex_exit(&port->fp_mutex);
			tid = timeout(fp_resendcmd, (caddr_t)port,
			    fp_retry_ticks);
			mutex_enter(&port->fp_mutex);
			port->fp_wait_tid = tid;
		}
	}
	mutex_exit(&port->fp_mutex);
}


/*
 * Handle all RJT codes
 */
static int
fp_handle_reject(fc_packet_t *pkt)
{
	int 		rval = FC_FAILURE;
	uchar_t		next_class;
	fp_cmd_t 	*cmd;
	fc_local_port_t *port;

	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

	switch (pkt->pkt_state) {
	case FC_PKT_FABRIC_RJT:
	case FC_PKT_NPORT_RJT:
		if (pkt->pkt_reason == FC_REASON_CLASS_NOT_SUPP) {
			next_class = fp_get_nextclass(cmd->cmd_port,
			    FC_TRAN_CLASS(pkt->pkt_tran_flags));

			if (next_class == FC_TRAN_CLASS_INVALID) {
				return (rval);
			}
			pkt->pkt_tran_flags = FC_TRAN_INTR | next_class;
			pkt->pkt_tran_type = FC_PKT_EXCHANGE;

			rval = fp_sendcmd(cmd->cmd_port, cmd,
			    cmd->cmd_port->fp_fca_handle);

			if (rval != FC_SUCCESS) {
				pkt->pkt_state = FC_PKT_TRAN_ERROR;
			}
		}
			break;

	case FC_PKT_LS_RJT:
	case FC_PKT_BA_RJT:
		if ((pkt->pkt_reason == FC_REASON_LOGICAL_ERROR) ||
		    (pkt->pkt_reason == FC_REASON_LOGICAL_BSY)) {
			cmd->cmd_retry_interval = fp_retry_delay;
			rval = fp_retry_cmd(pkt);
		}
		break;

	case FC_PKT_FS_RJT:
		if (pkt->pkt_reason == FC_REASON_FS_LOGICAL_BUSY) {
			cmd->cmd_retry_interval = fp_retry_delay;
			rval = fp_retry_cmd(pkt);
		}
		break;

	case FC_PKT_LOCAL_RJT:
		if (pkt->pkt_reason == FC_REASON_QFULL) {
			cmd->cmd_retry_interval = fp_retry_delay;
			rval = fp_retry_cmd(pkt);
		}
		break;

	default:
		FP_TRACE(FP_NHEAD1(1, 0),
		    "fp_handle_reject(): Invalid pkt_state");
		break;
	}

	return (rval);
}


/*
 * Return the next class of service supported by the FCA
 */
static uchar_t
fp_get_nextclass(fc_local_port_t *port, uchar_t cur_class)
{
	uchar_t next_class;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	switch (cur_class) {
	case FC_TRAN_CLASS_INVALID:
		if (port->fp_cos & FC_NS_CLASS1) {
			next_class = FC_TRAN_CLASS1;
			break;
		}
		/* FALLTHROUGH */

	case FC_TRAN_CLASS1:
		if (port->fp_cos & FC_NS_CLASS2) {
			next_class = FC_TRAN_CLASS2;
			break;
		}
		/* FALLTHROUGH */

	case FC_TRAN_CLASS2:
		if (port->fp_cos & FC_NS_CLASS3) {
			next_class = FC_TRAN_CLASS3;
			break;
		}
		/* FALLTHROUGH */

	case FC_TRAN_CLASS3:
	default:
		next_class = FC_TRAN_CLASS_INVALID;
		break;
	}

	return (next_class);
}


/*
 * Determine if a class of service is supported by the FCA
 */
static int
fp_is_class_supported(uint32_t cos, uchar_t tran_class)
{
	int rval;

	switch (tran_class) {
	case FC_TRAN_CLASS1:
		if (cos & FC_NS_CLASS1) {
			rval = FC_SUCCESS;
		} else {
			rval = FC_FAILURE;
		}
		break;

	case FC_TRAN_CLASS2:
		if (cos & FC_NS_CLASS2) {
			rval = FC_SUCCESS;
		} else {
			rval = FC_FAILURE;
		}
		break;

	case FC_TRAN_CLASS3:
		if (cos & FC_NS_CLASS3) {
			rval = FC_SUCCESS;
		} else {
			rval = FC_FAILURE;
		}
		break;

	default:
		rval = FC_FAILURE;
		break;
	}

	return (rval);
}


/*
 * Dequeue FC packet for retry
 */
static fp_cmd_t *
fp_deque_cmd(fc_local_port_t *port)
{
	fp_cmd_t *cmd;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	mutex_enter(&port->fp_mutex);

	if (port->fp_wait_head == NULL) {
		/*
		 * To avoid races, NULL the fp_wait_tid as
		 * we are about to exit the timeout thread.
		 */
		port->fp_wait_tid = NULL;
		mutex_exit(&port->fp_mutex);
		return (NULL);
	}

	cmd = port->fp_wait_head;
	port->fp_wait_head = cmd->cmd_next;
	cmd->cmd_next = NULL;

	if (port->fp_wait_head == NULL) {
		port->fp_wait_tail = NULL;
	}
	mutex_exit(&port->fp_mutex);

	return (cmd);
}


/*
 * Wait for job completion
 */
static void
fp_jobwait(job_request_t *job)
{
	sema_p(&job->job_port_sema);
}


/*
 * Convert FC packet state to FC errno
 */
int
fp_state_to_rval(uchar_t state)
{
	int count;

	for (count = 0; count < sizeof (fp_xlat) /
	sizeof (fp_xlat[0]); count++) {
		if (fp_xlat[count].xlat_state == state) {
			return (fp_xlat[count].xlat_rval);
		}
	}

	return (FC_FAILURE);
}


/*
 * For Synchronous I/O requests, the caller is
 * expected to do fctl_jobdone(if necessary)
 *
 * We want to preserve at least one failure in the
 * job_result if it happens.
 *
 */
static void
fp_iodone(fp_cmd_t *cmd)
{
	fc_packet_t		*ulp_pkt = cmd->cmd_ulp_pkt;
	job_request_t 		*job = cmd->cmd_job;
	fc_remote_port_t 	*pd = cmd->cmd_pkt.pkt_pd;

	ASSERT(job != NULL);
	ASSERT(cmd->cmd_port != NULL);
	ASSERT(&cmd->cmd_pkt != NULL);

	mutex_enter(&job->job_mutex);
	if (job->job_result == FC_SUCCESS) {
		job->job_result = fp_state_to_rval(cmd->cmd_pkt.pkt_state);
	}
	mutex_exit(&job->job_mutex);

	if (pd) {
		mutex_enter(&pd->pd_mutex);
		pd->pd_flags = PD_IDLE;
		mutex_exit(&pd->pd_mutex);
	}

	if (ulp_pkt) {
		if (pd && cmd->cmd_flags & FP_CMD_DELDEV_ON_ERROR &&
		    FP_IS_PKT_ERROR(ulp_pkt)) {
			fc_local_port_t 	*port;
			fc_remote_node_t	*node;

			port = cmd->cmd_port;

			mutex_enter(&pd->pd_mutex);
			pd->pd_state = PORT_DEVICE_INVALID;
			pd->pd_ref_count--;
			node = pd->pd_remote_nodep;
			mutex_exit(&pd->pd_mutex);

			ASSERT(node != NULL);
			ASSERT(port != NULL);

			if (fctl_destroy_remote_port(port, pd) == 0) {
				fctl_destroy_remote_node(node);
			}

			ulp_pkt->pkt_pd = NULL;
		}

		ulp_pkt->pkt_comp(ulp_pkt);
	}

	fp_free_pkt(cmd);
	fp_jobdone(job);
}


/*
 * Job completion handler
 */
static void
fp_jobdone(job_request_t *job)
{
	mutex_enter(&job->job_mutex);
	ASSERT(job->job_counter > 0);

	if (--job->job_counter != 0) {
		mutex_exit(&job->job_mutex);
		return;
	}

	if (job->job_ulp_pkts) {
		ASSERT(job->job_ulp_listlen > 0);
		kmem_free(job->job_ulp_pkts,
		    sizeof (fc_packet_t *) * job->job_ulp_listlen);
	}

	if (job->job_flags & JOB_TYPE_FP_ASYNC) {
		mutex_exit(&job->job_mutex);
		fctl_jobdone(job);
	} else {
		mutex_exit(&job->job_mutex);
		sema_v(&job->job_port_sema);
	}
}


/*
 * Try to perform shutdown of a port during a detach. No return
 * value since the detach should not fail because the port shutdown
 * failed.
 */
static void
fp_port_shutdown(fc_local_port_t *port, job_request_t *job)
{
	int			index;
	int			count;
	int			flags;
	fp_cmd_t 		*cmd;
	struct pwwn_hash 	*head;
	fc_remote_port_t 	*pd;

	ASSERT(MUTEX_HELD(&port->fp_mutex));

	job->job_result = FC_SUCCESS;

	if (port->fp_taskq) {
		/*
		 * We must release the mutex here to ensure that other
		 * potential jobs can complete their processing.  Many
		 * also need this mutex.
		 */
		mutex_exit(&port->fp_mutex);
		taskq_wait(port->fp_taskq);
		mutex_enter(&port->fp_mutex);
	}

	if (port->fp_offline_tid) {
		timeout_id_t tid;

		tid = port->fp_offline_tid;
		port->fp_offline_tid = NULL;
		mutex_exit(&port->fp_mutex);
		(void) untimeout(tid);
		mutex_enter(&port->fp_mutex);
	}

	if (port->fp_wait_tid) {
		timeout_id_t tid;

		tid = port->fp_wait_tid;
		port->fp_wait_tid = NULL;
		mutex_exit(&port->fp_mutex);
		(void) untimeout(tid);
	} else {
		mutex_exit(&port->fp_mutex);
	}

	/*
	 * While we cancel the timeout, let's also return the
	 * the outstanding requests back to the callers.
	 */
	while ((cmd = fp_deque_cmd(port)) != NULL) {
		ASSERT(cmd->cmd_job != NULL);
		cmd->cmd_job->job_result = FC_OFFLINE;
		fp_iodone(cmd);
	}

	/*
	 * Gracefully LOGO with all the devices logged in.
	 */
	mutex_enter(&port->fp_mutex);

	for (count = index = 0; index < pwwn_table_size; index++) {
		head = &port->fp_pwwn_table[index];
		pd = head->pwwn_head;
		while (pd != NULL) {
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
				count++;
			}
			mutex_exit(&pd->pd_mutex);
			pd = pd->pd_wwn_hnext;
		}
	}

	if (job->job_flags & JOB_TYPE_FP_ASYNC) {
		flags = job->job_flags;
		job->job_flags &= ~JOB_TYPE_FP_ASYNC;
	} else {
		flags = 0;
	}
	if (count) {
		job->job_counter = count;

		for (index = 0; index < pwwn_table_size; index++) {
			head = &port->fp_pwwn_table[index];
			pd = head->pwwn_head;
			while (pd != NULL) {
				mutex_enter(&pd->pd_mutex);
				if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
					ASSERT(pd->pd_login_count > 0);
					/*
					 * Force the counter to ONE in order
					 * for us to really send LOGO els.
					 */
					pd->pd_login_count = 1;
					mutex_exit(&pd->pd_mutex);
					mutex_exit(&port->fp_mutex);
					(void) fp_logout(port, pd, job);
					mutex_enter(&port->fp_mutex);
				} else {
					mutex_exit(&pd->pd_mutex);
				}
				pd = pd->pd_wwn_hnext;
			}
		}
		mutex_exit(&port->fp_mutex);
		fp_jobwait(job);
	} else {
		mutex_exit(&port->fp_mutex);
	}

	if (job->job_result != FC_SUCCESS) {
		FP_TRACE(FP_NHEAD1(9, 0),
		    "Can't logout all devices. Proceeding with"
		    " port shutdown");
		job->job_result = FC_SUCCESS;
	}

	fctl_destroy_all_remote_ports(port);

	mutex_enter(&port->fp_mutex);
	if (FC_IS_TOP_SWITCH(port->fp_topology)) {
		mutex_exit(&port->fp_mutex);
		fp_ns_fini(port, job);
	} else {
		mutex_exit(&port->fp_mutex);
	}

	if (flags) {
		job->job_flags = flags;
	}

	mutex_enter(&port->fp_mutex);

}


/*
 * Build the port driver's data structures based on the AL_PA list
 */
static void
fp_get_loopmap(fc_local_port_t *port, job_request_t *job)
{
	int 			rval;
	int			flag;
	int 			count;
	uint32_t		d_id;
	fc_remote_port_t 	*pd;
	fc_lilpmap_t 		*lilp_map;

	ASSERT(MUTEX_HELD(&port->fp_mutex));

	if (FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) {
		job->job_result = FC_OFFLINE;
		mutex_exit(&port->fp_mutex);
		fp_jobdone(job);
		mutex_enter(&port->fp_mutex);
		return;
	}

	if (port->fp_lilp_map.lilp_length == 0) {
		mutex_exit(&port->fp_mutex);
		job->job_result = FC_NO_MAP;
		fp_jobdone(job);
		mutex_enter(&port->fp_mutex);
		return;
	}
	mutex_exit(&port->fp_mutex);

	lilp_map = &port->fp_lilp_map;
	job->job_counter = lilp_map->lilp_length;

	if (job->job_code == JOB_PORT_GETMAP_PLOGI_ALL) {
		flag = FP_CMD_PLOGI_RETAIN;
	} else {
		flag = FP_CMD_PLOGI_DONT_CARE;
	}

	for (count = 0; count < lilp_map->lilp_length; count++) {
		d_id = lilp_map->lilp_alpalist[count];

		if (d_id == (lilp_map->lilp_myalpa & 0xFF)) {
			fp_jobdone(job);
			continue;
		}

		pd = fctl_get_remote_port_by_did(port, d_id);
		if (pd) {
			mutex_enter(&pd->pd_mutex);
			if (flag == FP_CMD_PLOGI_DONT_CARE ||
			    pd->pd_state == PORT_DEVICE_LOGGED_IN) {
				mutex_exit(&pd->pd_mutex);
				fp_jobdone(job);
				continue;
			}
			mutex_exit(&pd->pd_mutex);
		}

		rval = fp_port_login(port, d_id, job, flag,
		    KM_SLEEP, pd, NULL);
		if (rval != FC_SUCCESS) {
			fp_jobdone(job);
		}
	}

	mutex_enter(&port->fp_mutex);
}


/*
 * Perform loop ONLINE processing
 */
static void
fp_loop_online(fc_local_port_t *port, job_request_t *job, int orphan)
{
	int			count;
	int			rval;
	uint32_t		d_id;
	uint32_t		listlen;
	fc_lilpmap_t		*lilp_map;
	fc_remote_port_t	*pd;
	fc_portmap_t		*changelist;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	FP_TRACE(FP_NHEAD1(1, 0), "fp_loop_online begin; port=%p, job=%p",
	    port, job);

	lilp_map = &port->fp_lilp_map;

	if (lilp_map->lilp_length) {
		mutex_enter(&port->fp_mutex);
		if (port->fp_soft_state & FP_SOFT_IN_FCA_RESET) {
			port->fp_soft_state &= ~FP_SOFT_IN_FCA_RESET;
			mutex_exit(&port->fp_mutex);
			delay(drv_usectohz(PLDA_RR_TOV * 1000 * 1000));
		} else {
			mutex_exit(&port->fp_mutex);
		}

		job->job_counter = lilp_map->lilp_length;

		for (count = 0; count < lilp_map->lilp_length; count++) {
			d_id = lilp_map->lilp_alpalist[count];

			if (d_id == (lilp_map->lilp_myalpa & 0xFF)) {
				fp_jobdone(job);
				continue;
			}

			pd = fctl_get_remote_port_by_did(port, d_id);
			if (pd != NULL) {
#ifdef	DEBUG
				mutex_enter(&pd->pd_mutex);
				if (pd->pd_recepient == PD_PLOGI_INITIATOR) {
					ASSERT(pd->pd_type != PORT_DEVICE_OLD);
				}
				mutex_exit(&pd->pd_mutex);
#endif
				fp_jobdone(job);
				continue;
			}

			rval = fp_port_login(port, d_id, job,
			    FP_CMD_PLOGI_DONT_CARE, KM_SLEEP, pd, NULL);

			if (rval != FC_SUCCESS) {
				fp_jobdone(job);
			}
		}
		fp_jobwait(job);
	}
	listlen = 0;
	changelist = NULL;

	if ((job->job_flags & JOB_CANCEL_ULP_NOTIFICATION) == 0) {
		mutex_enter(&port->fp_mutex);
		ASSERT(port->fp_statec_busy > 0);
		if (port->fp_statec_busy == 1) {
			mutex_exit(&port->fp_mutex);
			fctl_fillout_map(port, &changelist, &listlen,
			    1, 0, orphan);

			mutex_enter(&port->fp_mutex);
			if (port->fp_lilp_map.lilp_magic < MAGIC_LIRP) {
				ASSERT(port->fp_total_devices == 0);
				port->fp_total_devices = port->fp_dev_count;
			}
		} else {
			job->job_flags |= JOB_CANCEL_ULP_NOTIFICATION;
		}
		mutex_exit(&port->fp_mutex);
	}

	if ((job->job_flags & JOB_CANCEL_ULP_NOTIFICATION) == 0) {
		(void) fp_ulp_statec_cb(port, FC_STATE_ONLINE, changelist,
		    listlen, listlen, KM_SLEEP);
	} else {
		mutex_enter(&port->fp_mutex);
		if (--port->fp_statec_busy == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
		}
		ASSERT(changelist == NULL && listlen == 0);
		mutex_exit(&port->fp_mutex);
	}

	FP_TRACE(FP_NHEAD1(1, 0), "fp_loop_online end; port=%p, job=%p",
	    port, job);
}


/*
 * Get an Arbitrated Loop map from the underlying FCA
 */
static int
fp_get_lilpmap(fc_local_port_t *port, fc_lilpmap_t *lilp_map)
{
	int rval;

	FP_TRACE(FP_NHEAD1(1, 0), "fp_get_lilpmap Begin; port=%p, map=%p",
	    port, lilp_map);

	bzero((caddr_t)lilp_map, sizeof (fc_lilpmap_t));
	rval = port->fp_fca_tran->fca_getmap(port->fp_fca_handle, lilp_map);
	lilp_map->lilp_magic &= 0xFF;	/* Ignore upper byte */

	if (rval != FC_SUCCESS) {
		rval = FC_NO_MAP;
	} else if (lilp_map->lilp_length == 0 &&
	    (lilp_map->lilp_magic >= MAGIC_LISM &&
	    lilp_map->lilp_magic < MAGIC_LIRP)) {
		uchar_t lilp_length;

		/*
		 * Since the map length is zero, provide all
		 * the valid AL_PAs for NL_ports discovery.
		 */
		lilp_length = sizeof (fp_valid_alpas) /
		    sizeof (fp_valid_alpas[0]);
		lilp_map->lilp_length = lilp_length;
		bcopy(fp_valid_alpas, lilp_map->lilp_alpalist,
		    lilp_length);
	} else {
		rval = fp_validate_lilp_map(lilp_map);

		if (rval == FC_SUCCESS) {
			mutex_enter(&port->fp_mutex);
			port->fp_total_devices = lilp_map->lilp_length - 1;
			mutex_exit(&port->fp_mutex);
		}
	}

	mutex_enter(&port->fp_mutex);
	if (rval != FC_SUCCESS && !(port->fp_soft_state & FP_SOFT_BAD_LINK)) {
		port->fp_soft_state |= FP_SOFT_BAD_LINK;
		mutex_exit(&port->fp_mutex);

		if (port->fp_fca_tran->fca_reset(port->fp_fca_handle,
		    FC_FCA_RESET_CORE) != FC_SUCCESS) {
			FP_TRACE(FP_NHEAD1(9, 0),
			    "FCA reset failed after LILP map was found"
			    " to be invalid");
		}
	} else if (rval == FC_SUCCESS) {
		port->fp_soft_state &= ~FP_SOFT_BAD_LINK;
		mutex_exit(&port->fp_mutex);
	} else {
		mutex_exit(&port->fp_mutex);
	}

	FP_TRACE(FP_NHEAD1(1, 0), "fp_get_lilpmap End; port=%p, map=%p", port,
	    lilp_map);

	return (rval);
}


/*
 * Perform Fabric Login:
 *
 * Return Values:
 *		FC_SUCCESS
 *		FC_FAILURE
 *		FC_NOMEM
 *		FC_TRANSPORT_ERROR
 *		and a lot others defined in fc_error.h
 */
static int
fp_fabric_login(fc_local_port_t *port, uint32_t s_id, job_request_t *job,
    int flag, int sleep)
{
	int		rval;
	fp_cmd_t 	*cmd;
	uchar_t 	class;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	FP_TRACE(FP_NHEAD1(1, 0), "fp_fabric_login Begin; port=%p, job=%p",
	    port, job);

	class = fp_get_nextclass(port, FC_TRAN_CLASS_INVALID);
	if (class == FC_TRAN_CLASS_INVALID) {
		return (FC_ELS_BAD);
	}

	cmd = fp_alloc_pkt(port, sizeof (la_els_logi_t),
	    sizeof (la_els_logi_t), sleep, NULL);
	if (cmd == NULL) {
		return (FC_NOMEM);
	}

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = flag;
	cmd->cmd_retry_count = fp_retry_count;
	cmd->cmd_ulp_pkt = NULL;

	fp_xlogi_init(port, cmd, s_id, 0xFFFFFE, fp_flogi_intr,
	    job, LA_ELS_FLOGI);

	rval = fp_sendcmd(port, cmd, port->fp_fca_handle);
	if (rval != FC_SUCCESS) {
		fp_free_pkt(cmd);
	}

	FP_TRACE(FP_NHEAD1(1, 0), "fp_fabric_login End; port=%p, job=%p",
	    port, job);

	return (rval);
}


/*
 * In some scenarios such as private loop device discovery period
 * the fc_remote_port_t data structure isn't allocated. The allocation
 * is done when the PLOGI is successful. In some other scenarios
 * such as Fabric topology, the fc_remote_port_t is already created
 * and initialized with appropriate values (as the NS provides
 * them)
 */
static int
fp_port_login(fc_local_port_t *port, uint32_t d_id, job_request_t *job,
    int cmd_flag, int sleep, fc_remote_port_t *pd, fc_packet_t *ulp_pkt)
{
	uchar_t class;
	fp_cmd_t *cmd;
	uint32_t src_id;
	fc_remote_port_t *tmp_pd;
	int relogin;
	int found = 0;

#ifdef	DEBUG
	if (pd == NULL) {
		ASSERT(fctl_get_remote_port_by_did(port, d_id) == NULL);
	}
#endif
	ASSERT(job->job_counter > 0);

	class = fp_get_nextclass(port, FC_TRAN_CLASS_INVALID);
	if (class == FC_TRAN_CLASS_INVALID) {
		return (FC_ELS_BAD);
	}

	mutex_enter(&port->fp_mutex);
	tmp_pd = fctl_lookup_pd_by_did(port, d_id);
	mutex_exit(&port->fp_mutex);

	relogin = 1;
	if (tmp_pd) {
		mutex_enter(&tmp_pd->pd_mutex);
		if ((tmp_pd->pd_aux_flags & PD_DISABLE_RELOGIN) &&
		    !(tmp_pd->pd_aux_flags & PD_LOGGED_OUT)) {
			tmp_pd->pd_state = PORT_DEVICE_LOGGED_IN;
			relogin = 0;
		}
		mutex_exit(&tmp_pd->pd_mutex);
	}

	if (!relogin) {
		mutex_enter(&tmp_pd->pd_mutex);
		if (tmp_pd->pd_state == PORT_DEVICE_LOGGED_IN) {
			cmd_flag |= FP_CMD_PLOGI_RETAIN;
		}
		mutex_exit(&tmp_pd->pd_mutex);

		cmd = fp_alloc_pkt(port, sizeof (la_els_adisc_t),
		    sizeof (la_els_adisc_t), sleep, tmp_pd);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}

		cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | class;
		cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
		cmd->cmd_flags = cmd_flag;
		cmd->cmd_retry_count = fp_retry_count;
		cmd->cmd_ulp_pkt = ulp_pkt;

		mutex_enter(&port->fp_mutex);
		mutex_enter(&tmp_pd->pd_mutex);
		fp_adisc_init(cmd, job);
		mutex_exit(&tmp_pd->pd_mutex);
		mutex_exit(&port->fp_mutex);

		cmd->cmd_pkt.pkt_cmdlen = sizeof (la_els_adisc_t);
		cmd->cmd_pkt.pkt_rsplen = sizeof (la_els_adisc_t);

	} else {
		cmd = fp_alloc_pkt(port, sizeof (la_els_logi_t),
		    sizeof (la_els_logi_t), sleep, pd);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}

		cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | class;
		cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
		cmd->cmd_flags = cmd_flag;
		cmd->cmd_retry_count = fp_retry_count;
		cmd->cmd_ulp_pkt = ulp_pkt;

		mutex_enter(&port->fp_mutex);
		src_id = port->fp_port_id.port_id;
		mutex_exit(&port->fp_mutex);

		fp_xlogi_init(port, cmd, src_id, d_id, fp_plogi_intr,
		    job, LA_ELS_PLOGI);
	}

	if (pd) {
		mutex_enter(&pd->pd_mutex);
		pd->pd_flags = PD_ELS_IN_PROGRESS;
		mutex_exit(&pd->pd_mutex);
	}

	/* npiv check to make sure we don't log into ourself */
	if (relogin && (port->fp_topology == FC_TOP_FABRIC)) {
		if ((d_id & 0xffff00) ==
		    (port->fp_port_id.port_id & 0xffff00)) {
			found = 1;
		}
	}

	if (found ||
	    (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS)) {
		if (found) {
			fc_packet_t *pkt = &cmd->cmd_pkt;
			pkt->pkt_state = FC_PKT_NPORT_RJT;
		}
		if (pd) {
			mutex_enter(&pd->pd_mutex);
			pd->pd_flags = PD_IDLE;
			mutex_exit(&pd->pd_mutex);
		}

		if (ulp_pkt) {
			fc_packet_t *pkt = &cmd->cmd_pkt;

			ulp_pkt->pkt_state = pkt->pkt_state;
			ulp_pkt->pkt_reason = pkt->pkt_reason;
			ulp_pkt->pkt_action = pkt->pkt_action;
			ulp_pkt->pkt_expln = pkt->pkt_expln;
		}

		fp_iodone(cmd);
	}

	return (FC_SUCCESS);
}


/*
 * Register the LOGIN parameters with a port device
 */
static void
fp_register_login(ddi_acc_handle_t *handle, fc_remote_port_t *pd,
    la_els_logi_t *acc, uchar_t class)
{
	fc_remote_node_t 	*node;

	ASSERT(pd != NULL);

	mutex_enter(&pd->pd_mutex);
	node = pd->pd_remote_nodep;
	if (pd->pd_login_count == 0) {
		pd->pd_login_count++;
	}

	if (handle) {
		ddi_rep_get8(*handle, (uint8_t *)&pd->pd_csp,
		    (uint8_t *)&acc->common_service,
		    sizeof (acc->common_service), DDI_DEV_AUTOINCR);
		ddi_rep_get8(*handle, (uint8_t *)&pd->pd_clsp1,
		    (uint8_t *)&acc->class_1, sizeof (acc->class_1),
		    DDI_DEV_AUTOINCR);
		ddi_rep_get8(*handle, (uint8_t *)&pd->pd_clsp2,
		    (uint8_t *)&acc->class_2, sizeof (acc->class_2),
		    DDI_DEV_AUTOINCR);
		ddi_rep_get8(*handle, (uint8_t *)&pd->pd_clsp3,
		    (uint8_t *)&acc->class_3, sizeof (acc->class_3),
		    DDI_DEV_AUTOINCR);
	} else {
		pd->pd_csp = acc->common_service;
		pd->pd_clsp1 = acc->class_1;
		pd->pd_clsp2 = acc->class_2;
		pd->pd_clsp3 = acc->class_3;
	}

	pd->pd_state = PORT_DEVICE_LOGGED_IN;
	pd->pd_login_class = class;
	mutex_exit(&pd->pd_mutex);

#ifndef	__lock_lint
	ASSERT(fctl_get_remote_port_by_did(pd->pd_port,
	    pd->pd_port_id.port_id) == pd);
#endif

	mutex_enter(&node->fd_mutex);
	if (handle) {
		ddi_rep_get8(*handle, (uint8_t *)node->fd_vv,
		    (uint8_t *)acc->vendor_version, sizeof (node->fd_vv),
		    DDI_DEV_AUTOINCR);
	} else {
		bcopy(acc->vendor_version, node->fd_vv, sizeof (node->fd_vv));
	}
	mutex_exit(&node->fd_mutex);
}


/*
 * Mark the remote port as OFFLINE
 */
static void
fp_remote_port_offline(fc_remote_port_t *pd)
{
	ASSERT(MUTEX_HELD(&pd->pd_mutex));
	if (pd->pd_login_count &&
	    ((pd->pd_aux_flags & PD_DISABLE_RELOGIN) == 0)) {
		bzero((caddr_t)&pd->pd_csp, sizeof (struct common_service));
		bzero((caddr_t)&pd->pd_clsp1, sizeof (struct service_param));
		bzero((caddr_t)&pd->pd_clsp2, sizeof (struct service_param));
		bzero((caddr_t)&pd->pd_clsp3, sizeof (struct service_param));
		pd->pd_login_class = 0;
	}
	pd->pd_type = PORT_DEVICE_OLD;
	pd->pd_flags = PD_IDLE;
	fctl_tc_reset(&pd->pd_logo_tc);
}


/*
 * Deregistration of a port device
 */
static void
fp_unregister_login(fc_remote_port_t *pd)
{
	fc_remote_node_t *node;

	ASSERT(pd != NULL);

	mutex_enter(&pd->pd_mutex);
	pd->pd_login_count = 0;
	bzero((caddr_t)&pd->pd_csp, sizeof (struct common_service));
	bzero((caddr_t)&pd->pd_clsp1, sizeof (struct service_param));
	bzero((caddr_t)&pd->pd_clsp2, sizeof (struct service_param));
	bzero((caddr_t)&pd->pd_clsp3, sizeof (struct service_param));

	pd->pd_state = PORT_DEVICE_VALID;
	pd->pd_login_class = 0;
	node = pd->pd_remote_nodep;
	mutex_exit(&pd->pd_mutex);

	mutex_enter(&node->fd_mutex);
	bzero(node->fd_vv, sizeof (node->fd_vv));
	mutex_exit(&node->fd_mutex);
}


/*
 * Handle OFFLINE state of an FCA port
 */
static void
fp_port_offline(fc_local_port_t *port, int notify)
{
	int			index;
	int			statec;
	timeout_id_t		tid;
	struct pwwn_hash 	*head;
	fc_remote_port_t 	*pd;

	ASSERT(MUTEX_HELD(&port->fp_mutex));

	for (index = 0; index < pwwn_table_size; index++) {
		head = &port->fp_pwwn_table[index];
		pd = head->pwwn_head;
		while (pd != NULL) {
			mutex_enter(&pd->pd_mutex);
			fp_remote_port_offline(pd);
			fctl_delist_did_table(port, pd);
			mutex_exit(&pd->pd_mutex);
			pd = pd->pd_wwn_hnext;
		}
	}
	port->fp_total_devices = 0;

	statec = 0;
	if (notify) {
		/*
		 * Decrement the statec busy counter as we
		 * are almost done with handling the state
		 * change
		 */
		ASSERT(port->fp_statec_busy > 0);
		if (--port->fp_statec_busy == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
		}
		mutex_exit(&port->fp_mutex);
		(void) fp_ulp_statec_cb(port, FC_STATE_OFFLINE, NULL,
		    0, 0, KM_SLEEP);
		mutex_enter(&port->fp_mutex);

		if (port->fp_statec_busy) {
			statec++;
		}
	} else if (port->fp_statec_busy > 1) {
		statec++;
	}

	if ((tid = port->fp_offline_tid) != NULL) {
		mutex_exit(&port->fp_mutex);
		(void) untimeout(tid);
		mutex_enter(&port->fp_mutex);
	}

	if (!statec) {
		port->fp_offline_tid = timeout(fp_offline_timeout,
		    (caddr_t)port, fp_offline_ticks);
	}
}


/*
 * Offline devices and send up a state change notification to ULPs
 */
static void
fp_offline_timeout(void *port_handle)
{
	int		ret;
	fc_local_port_t *port = port_handle;
	uint32_t	listlen = 0;
	fc_portmap_t 	*changelist = NULL;

	mutex_enter(&port->fp_mutex);

	if ((FC_PORT_STATE_MASK(port->fp_state) != FC_STATE_OFFLINE) ||
	    (port->fp_soft_state &
	    (FP_SOFT_IN_DETACH | FP_SOFT_SUSPEND | FP_SOFT_POWER_DOWN)) ||
	    port->fp_dev_count == 0 || port->fp_statec_busy) {
		port->fp_offline_tid = NULL;
		mutex_exit(&port->fp_mutex);
		return;
	}

	mutex_exit(&port->fp_mutex);

	FP_TRACE(FP_NHEAD2(9, 0), "OFFLINE timeout");

	if (port->fp_options & FP_CORE_ON_OFFLINE_TIMEOUT) {
		if ((ret = port->fp_fca_tran->fca_reset(port->fp_fca_handle,
		    FC_FCA_CORE)) != FC_SUCCESS) {
			FP_TRACE(FP_NHEAD1(9, ret),
			    "Failed to force adapter dump");
		} else {
			FP_TRACE(FP_NHEAD1(9, 0),
			    "Forced adapter dump successfully");
		}
	} else if (port->fp_options & FP_RESET_CORE_ON_OFFLINE_TIMEOUT) {
		if ((ret = port->fp_fca_tran->fca_reset(port->fp_fca_handle,
		    FC_FCA_RESET_CORE)) != FC_SUCCESS) {
			FP_TRACE(FP_NHEAD1(9, ret),
			    "Failed to force adapter dump and reset");
		} else {
			FP_TRACE(FP_NHEAD1(9, 0),
			    "Forced adapter dump and reset successfully");
		}
	}

	fctl_fillout_map(port, &changelist, &listlen, 1, 0, 0);
	(void) fp_ulp_statec_cb(port, FC_STATE_OFFLINE, changelist,
	    listlen, listlen, KM_SLEEP);

	mutex_enter(&port->fp_mutex);
	port->fp_offline_tid = NULL;
	mutex_exit(&port->fp_mutex);
}


/*
 * Perform general purpose ELS request initialization
 */
static void
fp_els_init(fp_cmd_t *cmd, uint32_t s_id, uint32_t d_id,
    void (*comp) (), job_request_t *job)
{
	fc_packet_t *pkt;

	pkt = &cmd->cmd_pkt;
	cmd->cmd_job = job;

	pkt->pkt_cmd_fhdr.r_ctl = R_CTL_ELS_REQ;
	pkt->pkt_cmd_fhdr.d_id = d_id;
	pkt->pkt_cmd_fhdr.s_id = s_id;
	pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
	pkt->pkt_cmd_fhdr.f_ctl = F_CTL_SEQ_INITIATIVE | F_CTL_FIRST_SEQ;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl  = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = 0xffff;
	pkt->pkt_cmd_fhdr.rx_id = 0xffff;
	pkt->pkt_cmd_fhdr.ro = 0;
	pkt->pkt_cmd_fhdr.rsvd = 0;
	pkt->pkt_comp = comp;
	pkt->pkt_timeout = FP_ELS_TIMEOUT;
}


/*
 * Initialize PLOGI/FLOGI ELS request
 */
static void
fp_xlogi_init(fc_local_port_t *port, fp_cmd_t *cmd, uint32_t s_id,
    uint32_t d_id, void (*intr) (), job_request_t *job, uchar_t ls_code)
{
	ls_code_t	payload;

	fp_els_init(cmd, s_id, d_id, intr, job);
	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;

	payload.ls_code = ls_code;
	payload.mbz = 0;

	ddi_rep_put8(cmd->cmd_pkt.pkt_cmd_acc,
	    (uint8_t *)&port->fp_service_params,
	    (uint8_t *)cmd->cmd_pkt.pkt_cmd, sizeof (port->fp_service_params),
	    DDI_DEV_AUTOINCR);

	ddi_rep_put8(cmd->cmd_pkt.pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)cmd->cmd_pkt.pkt_cmd, sizeof (payload),
	    DDI_DEV_AUTOINCR);
}


/*
 * Initialize LOGO ELS request
 */
static void
fp_logo_init(fc_remote_port_t *pd, fp_cmd_t *cmd, job_request_t *job)
{
	fc_local_port_t	*port;
	fc_packet_t	*pkt;
	la_els_logo_t 	payload;

	port = pd->pd_port;
	pkt = &cmd->cmd_pkt;
	ASSERT(MUTEX_HELD(&port->fp_mutex));
	ASSERT(MUTEX_HELD(&pd->pd_mutex));

	fp_els_init(cmd, port->fp_port_id.port_id, pd->pd_port_id.port_id,
	    fp_logo_intr, job);

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;

	pkt->pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
	pkt->pkt_tran_type = FC_PKT_EXCHANGE;

	payload.ls_code.ls_code = LA_ELS_LOGO;
	payload.ls_code.mbz = 0;
	payload.nport_ww_name = port->fp_service_params.nport_ww_name;
	payload.nport_id = port->fp_port_id;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}

/*
 * Initialize RNID ELS request
 */
static void
fp_rnid_init(fp_cmd_t *cmd, uint16_t flag, job_request_t *job)
{
	fc_local_port_t	*port;
	fc_packet_t	*pkt;
	la_els_rnid_t 	payload;
	fc_remote_port_t	*pd;

	pkt = &cmd->cmd_pkt;
	pd = pkt->pkt_pd;
	port = pd->pd_port;

	ASSERT(MUTEX_HELD(&port->fp_mutex));
	ASSERT(MUTEX_HELD(&pd->pd_mutex));

	fp_els_init(cmd, port->fp_port_id.port_id, pd->pd_port_id.port_id,
	    fp_rnid_intr, job);

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	pkt->pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
	pkt->pkt_tran_type = FC_PKT_EXCHANGE;

	payload.ls_code.ls_code = LA_ELS_RNID;
	payload.ls_code.mbz = 0;
	payload.data_format = flag;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}

/*
 * Initialize RLS ELS request
 */
static void
fp_rls_init(fp_cmd_t *cmd, job_request_t *job)
{
	fc_local_port_t	*port;
	fc_packet_t	*pkt;
	la_els_rls_t 	payload;
	fc_remote_port_t	*pd;

	pkt = &cmd->cmd_pkt;
	pd = pkt->pkt_pd;
	port = pd->pd_port;

	ASSERT(MUTEX_HELD(&port->fp_mutex));
	ASSERT(MUTEX_HELD(&pd->pd_mutex));

	fp_els_init(cmd, port->fp_port_id.port_id, pd->pd_port_id.port_id,
	    fp_rls_intr, job);

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	pkt->pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
	pkt->pkt_tran_type = FC_PKT_EXCHANGE;

	payload.ls_code.ls_code = LA_ELS_RLS;
	payload.ls_code.mbz = 0;
	payload.rls_portid = port->fp_port_id;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}


/*
 * Initialize an ADISC ELS request
 */
static void
fp_adisc_init(fp_cmd_t *cmd, job_request_t *job)
{
	fc_local_port_t *port;
	fc_packet_t	*pkt;
	la_els_adisc_t 	payload;
	fc_remote_port_t	*pd;

	pkt = &cmd->cmd_pkt;
	pd = pkt->pkt_pd;
	port = pd->pd_port;

	ASSERT(MUTEX_HELD(&pd->pd_mutex));
	ASSERT(MUTEX_HELD(&pd->pd_port->fp_mutex));

	fp_els_init(cmd, port->fp_port_id.port_id, pd->pd_port_id.port_id,
	    fp_adisc_intr, job);

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	pkt->pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
	pkt->pkt_tran_type = FC_PKT_EXCHANGE;

	payload.ls_code.ls_code = LA_ELS_ADISC;
	payload.ls_code.mbz = 0;
	payload.nport_id = port->fp_port_id;
	payload.port_wwn = port->fp_service_params.nport_ww_name;
	payload.node_wwn = port->fp_service_params.node_ww_name;
	payload.hard_addr = port->fp_hard_addr;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}


/*
 * Send up a state change notification to ULPs.
 * Spawns a call to fctl_ulp_statec_cb in a taskq thread.
 */
static int
fp_ulp_statec_cb(fc_local_port_t *port, uint32_t state,
    fc_portmap_t *changelist, uint32_t listlen, uint32_t alloc_len, int sleep)
{
	fc_port_clist_t		*clist;
	fc_remote_port_t	*pd;
	int 			count;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	clist = kmem_zalloc(sizeof (*clist), sleep);
	if (clist == NULL) {
		kmem_free(changelist, alloc_len * sizeof (*changelist));
		return (FC_NOMEM);
	}

	clist->clist_state = state;

	mutex_enter(&port->fp_mutex);
	clist->clist_flags = port->fp_topology;
	mutex_exit(&port->fp_mutex);

	clist->clist_port = (opaque_t)port;
	clist->clist_len = listlen;
	clist->clist_size = alloc_len;
	clist->clist_map = changelist;

	/*
	 * Bump the reference count of each fc_remote_port_t in this changelist.
	 * This is necessary since these devices will be sitting in a taskq
	 * and referenced later.  When the state change notification is
	 * complete, the reference counts will be decremented.
	 */
	for (count = 0; count < clist->clist_len; count++) {
		pd = clist->clist_map[count].map_pd;

		if (pd != NULL) {
			mutex_enter(&pd->pd_mutex);
			ASSERT((pd->pd_ref_count >= 0) ||
			    (pd->pd_aux_flags & PD_GIVEN_TO_ULPS));
			pd->pd_ref_count++;

			if (clist->clist_map[count].map_state !=
			    PORT_DEVICE_INVALID) {
				pd->pd_aux_flags |= PD_GIVEN_TO_ULPS;
			}

			mutex_exit(&pd->pd_mutex);
		}
	}

#ifdef	DEBUG
	/*
	 * Sanity check for presence of OLD devices in the hash lists
	 */
	if (clist->clist_size) {
		ASSERT(clist->clist_map != NULL);
		for (count = 0; count < clist->clist_len; count++) {
			if (clist->clist_map[count].map_state ==
			    PORT_DEVICE_INVALID) {
				la_wwn_t 	pwwn;
				fc_portid_t 	d_id;

				pd = clist->clist_map[count].map_pd;
				ASSERT(pd != NULL);

				mutex_enter(&pd->pd_mutex);
				pwwn = pd->pd_port_name;
				d_id = pd->pd_port_id;
				mutex_exit(&pd->pd_mutex);

				pd = fctl_get_remote_port_by_pwwn(port, &pwwn);
				ASSERT(pd != clist->clist_map[count].map_pd);

				pd = fctl_get_remote_port_by_did(port,
				    d_id.port_id);
				ASSERT(pd != clist->clist_map[count].map_pd);
			}
		}
	}
#endif

	mutex_enter(&port->fp_mutex);

	if (state == FC_STATE_ONLINE) {
		if (--port->fp_statec_busy == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
		}
	}
	mutex_exit(&port->fp_mutex);

	(void) taskq_dispatch(port->fp_taskq, fctl_ulp_statec_cb,
	    clist, KM_SLEEP);

	FP_TRACE(FP_NHEAD1(4, 0), "fp_ulp_statec fired; Port=%p,"
	    "state=%x, len=%d", port, state, listlen);

	return (FC_SUCCESS);
}


/*
 * Send up a FC_STATE_DEVICE_CHANGE state notification to ULPs
 */
static int
fp_ulp_devc_cb(fc_local_port_t *port, fc_portmap_t *changelist,
    uint32_t listlen, uint32_t alloc_len, int sleep, int sync)
{
	int		ret;
	fc_port_clist_t *clist;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	clist = kmem_zalloc(sizeof (*clist), sleep);
	if (clist == NULL) {
		kmem_free(changelist, alloc_len * sizeof (*changelist));
		return (FC_NOMEM);
	}

	clist->clist_state = FC_STATE_DEVICE_CHANGE;

	mutex_enter(&port->fp_mutex);
	clist->clist_flags = port->fp_topology;
	mutex_exit(&port->fp_mutex);

	clist->clist_port = (opaque_t)port;
	clist->clist_len = listlen;
	clist->clist_size = alloc_len;
	clist->clist_map = changelist;

	/* Send sysevents for target state changes */

	if (clist->clist_size) {
		int 			count;
		fc_remote_port_t	*pd;

		ASSERT(clist->clist_map != NULL);
		for (count = 0; count < clist->clist_len; count++) {
			pd = clist->clist_map[count].map_pd;

			/*
			 * Bump reference counts on all fc_remote_port_t
			 * structs in this list.  We don't know when the task
			 * will fire, and we don't need these fc_remote_port_t
			 * structs going away behind our back.
			 */
			if (pd) {
				mutex_enter(&pd->pd_mutex);
				ASSERT((pd->pd_ref_count >= 0) ||
				    (pd->pd_aux_flags & PD_GIVEN_TO_ULPS));
				pd->pd_ref_count++;
				mutex_exit(&pd->pd_mutex);
			}

			if (clist->clist_map[count].map_state ==
			    PORT_DEVICE_VALID) {
				if (clist->clist_map[count].map_type ==
				    PORT_DEVICE_NEW) {
					/* Update our state change counter */
					mutex_enter(&port->fp_mutex);
					port->fp_last_change++;
					mutex_exit(&port->fp_mutex);

					/* Additions */
					fp_log_target_event(port,
					    ESC_SUNFC_TARGET_ADD,
					    clist->clist_map[count].map_pwwn,
					    clist->clist_map[count].map_did.
					    port_id);
				}

			} else if ((clist->clist_map[count].map_type ==
			    PORT_DEVICE_OLD) &&
			    (clist->clist_map[count].map_state ==
			    PORT_DEVICE_INVALID)) {
				/* Update our state change counter */
				mutex_enter(&port->fp_mutex);
				port->fp_last_change++;
				mutex_exit(&port->fp_mutex);

				/*
				 * For removals, we don't decrement
				 * pd_ref_count until after the ULP's
				 * state change callback function has
				 * completed.
				 */

				/* Removals */
				fp_log_target_event(port,
				    ESC_SUNFC_TARGET_REMOVE,
				    clist->clist_map[count].map_pwwn,
				    clist->clist_map[count].map_did.port_id);
			}

			if (clist->clist_map[count].map_state !=
			    PORT_DEVICE_INVALID) {
				/*
				 * Indicate that the ULPs are now aware of
				 * this device.
				 */

				mutex_enter(&pd->pd_mutex);
				pd->pd_aux_flags |= PD_GIVEN_TO_ULPS;
				mutex_exit(&pd->pd_mutex);
			}

#ifdef	DEBUG
			/*
			 * Sanity check for OLD devices in the hash lists
			 */
			if (pd && clist->clist_map[count].map_state ==
			    PORT_DEVICE_INVALID) {
				la_wwn_t 	pwwn;
				fc_portid_t 	d_id;

				mutex_enter(&pd->pd_mutex);
				pwwn = pd->pd_port_name;
				d_id = pd->pd_port_id;
				mutex_exit(&pd->pd_mutex);

				/*
				 * This overwrites the 'pd' local variable.
				 * Beware of this if 'pd' ever gets
				 * referenced below this block.
				 */
				pd = fctl_get_remote_port_by_pwwn(port, &pwwn);
				ASSERT(pd != clist->clist_map[count].map_pd);

				pd = fctl_get_remote_port_by_did(port,
				    d_id.port_id);
				ASSERT(pd != clist->clist_map[count].map_pd);
			}
#endif
		}
	}

	if (sync) {
		clist->clist_wait = 1;
		mutex_init(&clist->clist_mutex, NULL, MUTEX_DRIVER, NULL);
		cv_init(&clist->clist_cv, NULL, CV_DRIVER, NULL);
	}

	ret = taskq_dispatch(port->fp_taskq, fctl_ulp_statec_cb, clist, sleep);
	if (sync && ret) {
		mutex_enter(&clist->clist_mutex);
		while (clist->clist_wait) {
			cv_wait(&clist->clist_cv, &clist->clist_mutex);
		}
		mutex_exit(&clist->clist_mutex);

		mutex_destroy(&clist->clist_mutex);
		cv_destroy(&clist->clist_cv);
		kmem_free(clist, sizeof (*clist));
	}

	if (!ret) {
		FP_TRACE(FP_NHEAD1(4, 0), "fp_ulp_devc dispatch failed; "
		    "port=%p", port);
		kmem_free(clist->clist_map,
		    sizeof (*(clist->clist_map)) * clist->clist_size);
		kmem_free(clist, sizeof (*clist));
	} else {
		FP_TRACE(FP_NHEAD1(4, 0), "fp_ulp_devc fired; port=%p, len=%d",
		    port, listlen);
	}

	return (FC_SUCCESS);
}


/*
 * Perform PLOGI to the group of devices for ULPs
 */
static void
fp_plogi_group(fc_local_port_t *port, job_request_t *job)
{
	int			offline;
	int 			count;
	int			rval;
	uint32_t		listlen;
	uint32_t		done;
	uint32_t		d_id;
	fc_remote_node_t	*node;
	fc_remote_port_t 	*pd;
	fc_remote_port_t	*tmp_pd;
	fc_packet_t		*ulp_pkt;
	la_els_logi_t		*els_data;
	ls_code_t		ls_code;

	FP_TRACE(FP_NHEAD1(1, 0), "fp_plogi_group begin; port=%p, job=%p",
	    port, job);

	done = 0;
	listlen = job->job_ulp_listlen;
	job->job_counter = job->job_ulp_listlen;

	mutex_enter(&port->fp_mutex);
	offline = (port->fp_statec_busy ||
	    FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) ? 1 : 0;
	mutex_exit(&port->fp_mutex);

	for (count = 0; count < listlen; count++) {
		ASSERT(job->job_ulp_pkts[count]->pkt_rsplen >=
		    sizeof (la_els_logi_t));

		ulp_pkt = job->job_ulp_pkts[count];
		pd = ulp_pkt->pkt_pd;
		d_id = ulp_pkt->pkt_cmd_fhdr.d_id;

		if (offline) {
			done++;

			ulp_pkt->pkt_state = FC_PKT_PORT_OFFLINE;
			ulp_pkt->pkt_reason = FC_REASON_OFFLINE;
			ulp_pkt->pkt_pd = NULL;
			ulp_pkt->pkt_comp(ulp_pkt);

			job->job_ulp_pkts[count] = NULL;

			fp_jobdone(job);
			continue;
		}

		if (pd == NULL) {
			pd = fctl_get_remote_port_by_did(port, d_id);
			if (pd == NULL) { /* reset later */
				ulp_pkt->pkt_state = FC_PKT_FAILURE;
				continue;
			}
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_flags == PD_ELS_IN_PROGRESS) {
				mutex_exit(&pd->pd_mutex);
				ulp_pkt->pkt_state = FC_PKT_ELS_IN_PROGRESS;
				done++;
				ulp_pkt->pkt_comp(ulp_pkt);
				job->job_ulp_pkts[count] = NULL;
				fp_jobdone(job);
			} else {
				ulp_pkt->pkt_state = FC_PKT_FAILURE;
				mutex_exit(&pd->pd_mutex);
			}
			continue;
		}

		switch (ulp_pkt->pkt_state) {
		case FC_PKT_ELS_IN_PROGRESS:
			ulp_pkt->pkt_reason = FC_REASON_OFFLINE;
			/* FALLTHRU */
		case FC_PKT_LOCAL_RJT:
			done++;
			ulp_pkt->pkt_comp(ulp_pkt);
			job->job_ulp_pkts[count] = NULL;
			fp_jobdone(job);
			continue;
		default:
			break;
		}

		/*
		 * Validate the pd corresponding to the d_id passed
		 * by the ULPs
		 */
		tmp_pd = fctl_get_remote_port_by_did(port, d_id);
		if ((tmp_pd == NULL) || (pd != tmp_pd)) {
			done++;
			ulp_pkt->pkt_state = FC_PKT_FAILURE;
			ulp_pkt->pkt_reason = FC_REASON_NO_CONNECTION;
			ulp_pkt->pkt_pd = NULL;
			ulp_pkt->pkt_comp(ulp_pkt);
			job->job_ulp_pkts[count] = NULL;
			fp_jobdone(job);
			continue;
		}

		FP_TRACE(FP_NHEAD1(3, 0), "fp_plogi_group contd; "
		    "port=%p, pd=%p", port, pd);

		mutex_enter(&pd->pd_mutex);

		if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
			done++;
			els_data = (la_els_logi_t *)ulp_pkt->pkt_resp;

			ls_code.ls_code = LA_ELS_ACC;
			ls_code.mbz = 0;

			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&ls_code, (uint8_t *)&els_data->ls_code,
			    sizeof (ls_code_t), DDI_DEV_AUTOINCR);

			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&pd->pd_csp,
			    (uint8_t *)&els_data->common_service,
			    sizeof (pd->pd_csp), DDI_DEV_AUTOINCR);

			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&pd->pd_port_name,
			    (uint8_t *)&els_data->nport_ww_name,
			    sizeof (pd->pd_port_name), DDI_DEV_AUTOINCR);

			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&pd->pd_clsp1,
			    (uint8_t *)&els_data->class_1,
			    sizeof (pd->pd_clsp1), DDI_DEV_AUTOINCR);

			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&pd->pd_clsp2,
			    (uint8_t *)&els_data->class_2,
			    sizeof (pd->pd_clsp2), DDI_DEV_AUTOINCR);

			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&pd->pd_clsp3,
			    (uint8_t *)&els_data->class_3,
			    sizeof (pd->pd_clsp3), DDI_DEV_AUTOINCR);

			node = pd->pd_remote_nodep;
			pd->pd_login_count++;
			pd->pd_flags = PD_IDLE;
			ulp_pkt->pkt_pd = pd;
			mutex_exit(&pd->pd_mutex);

			mutex_enter(&node->fd_mutex);
			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&node->fd_node_name,
			    (uint8_t *)(&els_data->node_ww_name),
			    sizeof (node->fd_node_name), DDI_DEV_AUTOINCR);


			ddi_rep_put8(ulp_pkt->pkt_resp_acc,
			    (uint8_t *)&node->fd_vv,
			    (uint8_t *)(&els_data->vendor_version),
			    sizeof (node->fd_vv), DDI_DEV_AUTOINCR);

			mutex_exit(&node->fd_mutex);
			ulp_pkt->pkt_state = FC_PKT_SUCCESS;
		} else {

			ulp_pkt->pkt_state = FC_PKT_FAILURE; /* reset later */
			mutex_exit(&pd->pd_mutex);
		}

		if (ulp_pkt->pkt_state != FC_PKT_FAILURE) {
			ulp_pkt->pkt_comp(ulp_pkt);
			job->job_ulp_pkts[count] = NULL;
			fp_jobdone(job);
		}
	}

	if (done == listlen) {
		fp_jobwait(job);
		fctl_jobdone(job);
		return;
	}

	job->job_counter = listlen - done;

	for (count = 0; count < listlen; count++) {
		int cmd_flags;

		if ((ulp_pkt = job->job_ulp_pkts[count]) == NULL) {
			continue;
		}

		ASSERT(ulp_pkt->pkt_state == FC_PKT_FAILURE);

		cmd_flags = FP_CMD_PLOGI_RETAIN;

		d_id = ulp_pkt->pkt_cmd_fhdr.d_id;
		ASSERT(d_id != 0);

		pd = fctl_get_remote_port_by_did(port, d_id);
		ulp_pkt->pkt_pd = pd;

		if (pd != NULL) {
			mutex_enter(&pd->pd_mutex);
			d_id = pd->pd_port_id.port_id;
			pd->pd_flags = PD_ELS_IN_PROGRESS;
			mutex_exit(&pd->pd_mutex);
		} else {
			d_id = ulp_pkt->pkt_cmd_fhdr.d_id;
#ifdef	DEBUG
			pd = fctl_get_remote_port_by_did(port, d_id);
			ASSERT(pd == NULL);
#endif
			/*
			 * In the Fabric topology, use NS to create
			 * port device, and if that fails still try
			 * with PLOGI - which will make yet another
			 * attempt to create after successful PLOGI
			 */
			mutex_enter(&port->fp_mutex);
			if (FC_IS_TOP_SWITCH(port->fp_topology)) {
				mutex_exit(&port->fp_mutex);
				pd = fp_create_remote_port_by_ns(port,
				    d_id, KM_SLEEP);
				if (pd) {
					cmd_flags |= FP_CMD_DELDEV_ON_ERROR;

					mutex_enter(&pd->pd_mutex);
					pd->pd_flags = PD_ELS_IN_PROGRESS;
					mutex_exit(&pd->pd_mutex);

					FP_TRACE(FP_NHEAD1(3, 0),
					    "fp_plogi_group;"
					    " NS created PD port=%p, job=%p,"
					    " pd=%p", port, job, pd);
				}
			} else {
				mutex_exit(&port->fp_mutex);
			}
			if ((ulp_pkt->pkt_pd == NULL) && (pd != NULL)) {
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_plogi_group;"
				    "ulp_pkt's pd is NULL, get a pd %p",
				    pd);
				mutex_enter(&pd->pd_mutex);
				pd->pd_ref_count++;
				mutex_exit(&pd->pd_mutex);
			}
			ulp_pkt->pkt_pd = pd;
		}

		rval = fp_port_login(port, d_id, job, cmd_flags,
		    KM_SLEEP, pd, ulp_pkt);

		if (rval == FC_SUCCESS) {
			continue;
		}

		if (rval == FC_STATEC_BUSY) {
			ulp_pkt->pkt_state = FC_PKT_PORT_OFFLINE;
			ulp_pkt->pkt_reason = FC_REASON_OFFLINE;
		} else {
			ulp_pkt->pkt_state = FC_PKT_FAILURE;
		}

		if (pd) {
			mutex_enter(&pd->pd_mutex);
			pd->pd_flags = PD_IDLE;
			mutex_exit(&pd->pd_mutex);
		}

		if (cmd_flags & FP_CMD_DELDEV_ON_ERROR) {
			ASSERT(pd != NULL);

			FP_TRACE(FP_NHEAD1(3, 0), "fp_plogi_group: NS created,"
			    " PD removed; port=%p, job=%p", port, job);

			mutex_enter(&pd->pd_mutex);
			pd->pd_ref_count--;
			node = pd->pd_remote_nodep;
			mutex_exit(&pd->pd_mutex);

			ASSERT(node != NULL);

			if (fctl_destroy_remote_port(port, pd) == 0) {
				fctl_destroy_remote_node(node);
			}
			ulp_pkt->pkt_pd = NULL;
		}
		ulp_pkt->pkt_comp(ulp_pkt);
		fp_jobdone(job);
	}

	fp_jobwait(job);
	fctl_jobdone(job);

	FP_TRACE(FP_NHEAD1(1, 0), "fp_plogi_group end: port=%p, job=%p",
	    port, job);
}


/*
 * Name server request initialization
 */
static void
fp_ns_init(fc_local_port_t *port, job_request_t *job, int sleep)
{
	int rval;
	int count;
	int size;

	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

	job->job_counter = 1;
	job->job_result = FC_SUCCESS;

	rval = fp_port_login(port, 0xFFFFFC, job, FP_CMD_PLOGI_RETAIN,
	    KM_SLEEP, NULL, NULL);

	if (rval != FC_SUCCESS) {
		mutex_enter(&port->fp_mutex);
		port->fp_topology = FC_TOP_NO_NS;
		mutex_exit(&port->fp_mutex);
		return;
	}

	fp_jobwait(job);

	if (job->job_result != FC_SUCCESS) {
		mutex_enter(&port->fp_mutex);
		port->fp_topology = FC_TOP_NO_NS;
		mutex_exit(&port->fp_mutex);
		return;
	}

	/*
	 * At this time, we'll do NS registration for objects in the
	 * ns_reg_cmds (see top of this file) array.
	 *
	 * Each time a ULP module registers with the transport, the
	 * appropriate fc4 bit is set fc4 types and registered with
	 * the NS for this support. Also, ULPs and FC admin utilities
	 * may do registration for objects like IP address, symbolic
	 * port/node name, Initial process associator at run time.
	 */
	size = sizeof (ns_reg_cmds) / sizeof (ns_reg_cmds[0]);
	job->job_counter = size;
	job->job_result = FC_SUCCESS;

	for (count = 0; count < size; count++) {
		if (fp_ns_reg(port, NULL, ns_reg_cmds[count],
		    job, 0, sleep) != FC_SUCCESS) {
			fp_jobdone(job);
		}
	}
	if (size) {
		fp_jobwait(job);
	}

	job->job_result = FC_SUCCESS;

	(void) fp_ns_get_devcount(port, job, 0, KM_SLEEP);

	if (port->fp_dev_count < FP_MAX_DEVICES) {
		(void) fp_ns_get_devcount(port, job, 1, KM_SLEEP);
	}

	job->job_counter = 1;

	if (fp_ns_scr(port, job, FC_SCR_FULL_REGISTRATION,
	    sleep) == FC_SUCCESS) {
		fp_jobwait(job);
	}
}


/*
 * Name server finish:
 *	Unregister for RSCNs
 * 	Unregister all the host port objects in the Name Server
 * 	Perform LOGO with the NS;
 */
static void
fp_ns_fini(fc_local_port_t *port, job_request_t *job)
{
	fp_cmd_t 	*cmd;
	uchar_t		class;
	uint32_t	s_id;
	fc_packet_t	*pkt;
	la_els_logo_t 	payload;

	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

	job->job_counter = 1;

	if (fp_ns_scr(port, job, FC_SCR_CLEAR_REGISTRATION, KM_SLEEP) !=
	    FC_SUCCESS) {
		fp_jobdone(job);
	}
	fp_jobwait(job);

	job->job_counter = 1;

	if (fp_ns_reg(port, NULL, NS_DA_ID, job, 0, KM_SLEEP) != FC_SUCCESS) {
		fp_jobdone(job);
	}
	fp_jobwait(job);

	job->job_counter = 1;

	cmd = fp_alloc_pkt(port, sizeof (la_els_logo_t),
		FP_PORT_IDENTIFIER_LEN, KM_SLEEP, NULL);
	pkt = &cmd->cmd_pkt;

	mutex_enter(&port->fp_mutex);
	class = port->fp_ns_login_class;
	s_id = port->fp_port_id.port_id;
	payload.nport_id = port->fp_port_id;
	mutex_exit(&port->fp_mutex);

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = FP_CMD_PLOGI_DONT_CARE;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	if (port->fp_npiv_type == FC_NPIV_PORT) {
		fp_els_init(cmd, s_id, 0xFFFFFE, fp_logo_intr, job);
	} else {
		fp_els_init(cmd, s_id, 0xFFFFFC, fp_logo_intr, job);
	}

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;

	payload.ls_code.ls_code = LA_ELS_LOGO;
	payload.ls_code.mbz = 0;
	payload.nport_ww_name = port->fp_service_params.nport_ww_name;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);

	if (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS) {
		fp_iodone(cmd);
	}
	fp_jobwait(job);
}


/*
 * NS Registration function.
 *
 *	It should be seriously noted that FC-GS-2 currently doesn't support
 *	an Object Registration by a D_ID other than the owner of the object.
 *	What we are aiming at currently is to at least allow Symbolic Node/Port
 *	Name registration for any N_Port Identifier by the host software.
 *
 *	Anyway, if the second argument (fc_remote_port_t *) is NULL, this
 *	function treats the request as Host NS Object.
 */
static int
fp_ns_reg(fc_local_port_t *port, fc_remote_port_t *pd, uint16_t cmd_code,
    job_request_t *job, int polled, int sleep)
{
	int 		rval;
	fc_portid_t	s_id;
	fc_packet_t 	*pkt;
	fp_cmd_t 	*cmd;

	if (pd == NULL) {
		mutex_enter(&port->fp_mutex);
		s_id = port->fp_port_id;
		mutex_exit(&port->fp_mutex);
	} else {
		mutex_enter(&pd->pd_mutex);
		s_id = pd->pd_port_id;
		mutex_exit(&pd->pd_mutex);
	}

	if (polled) {
		job->job_counter = 1;
	}

	switch (cmd_code) {
	case NS_RPN_ID:
	case NS_RNN_ID: {
		ns_rxn_req_t rxn;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
		    sizeof (ns_rxn_req_t), sizeof (fc_reg_resp_t), sleep, NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}
		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);
		pkt = &cmd->cmd_pkt;

		if (pd == NULL) {
			rxn.rxn_xname = (cmd_code == NS_RPN_ID) ?
			    (port->fp_service_params.nport_ww_name) :
			    (port->fp_service_params.node_ww_name);
		} else {
			if (cmd_code == NS_RPN_ID) {
				mutex_enter(&pd->pd_mutex);
				rxn.rxn_xname = pd->pd_port_name;
				mutex_exit(&pd->pd_mutex);
			} else {
				fc_remote_node_t *node;

				mutex_enter(&pd->pd_mutex);
				node = pd->pd_remote_nodep;
				mutex_exit(&pd->pd_mutex);

				mutex_enter(&node->fd_mutex);
				rxn.rxn_xname = node->fd_node_name;
				mutex_exit(&node->fd_mutex);
			}
		}
		rxn.rxn_port_id = s_id;

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&rxn,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (rxn), DDI_DEV_AUTOINCR);

		break;
	}

	case NS_RCS_ID: {
		ns_rcos_t rcos;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
		    sizeof (ns_rcos_t), sizeof (fc_reg_resp_t), sleep, NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}
		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);
		pkt = &cmd->cmd_pkt;

		if (pd == NULL) {
			rcos.rcos_cos = port->fp_cos;
		} else {
			mutex_enter(&pd->pd_mutex);
			rcos.rcos_cos = pd->pd_cos;
			mutex_exit(&pd->pd_mutex);
		}
		rcos.rcos_port_id = s_id;

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&rcos,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (rcos), DDI_DEV_AUTOINCR);

		break;
	}

	case NS_RFT_ID: {
		ns_rfc_type_t rfc;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
		    sizeof (ns_rfc_type_t), sizeof (fc_reg_resp_t), sleep,
		    NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}
		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);
		pkt = &cmd->cmd_pkt;

		if (pd == NULL) {
			mutex_enter(&port->fp_mutex);
			bcopy(port->fp_fc4_types, rfc.rfc_types,
			    sizeof (port->fp_fc4_types));
			mutex_exit(&port->fp_mutex);
		} else {
			mutex_enter(&pd->pd_mutex);
			bcopy(pd->pd_fc4types, rfc.rfc_types,
			    sizeof (pd->pd_fc4types));
			mutex_exit(&pd->pd_mutex);
		}
		rfc.rfc_port_id = s_id;

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&rfc,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (rfc), DDI_DEV_AUTOINCR);

		break;
	}

	case NS_RSPN_ID: {
		uchar_t 	name_len;
		int 		pl_size;
		fc_portid_t 	spn;

		if (pd == NULL) {
			mutex_enter(&port->fp_mutex);
			name_len = port->fp_sym_port_namelen;
			mutex_exit(&port->fp_mutex);
		} else {
			mutex_enter(&pd->pd_mutex);
			name_len = pd->pd_spn_len;
			mutex_exit(&pd->pd_mutex);
		}

		pl_size = sizeof (fc_portid_t) + name_len + 1;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) + pl_size,
			sizeof (fc_reg_resp_t), sleep, NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}

		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);

		pkt = &cmd->cmd_pkt;

		spn = s_id;

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&spn, (uint8_t *)
		    (pkt->pkt_cmd + sizeof (fc_ct_header_t)), sizeof (spn),
		    DDI_DEV_AUTOINCR);
		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&name_len,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)
		    + sizeof (fc_portid_t)), 1, DDI_DEV_AUTOINCR);

		if (pd == NULL) {
			mutex_enter(&port->fp_mutex);
			ddi_rep_put8(pkt->pkt_cmd_acc,
			    (uint8_t *)port->fp_sym_port_name, (uint8_t *)
			    (pkt->pkt_cmd + sizeof (fc_ct_header_t) +
			    sizeof (spn) + 1), name_len, DDI_DEV_AUTOINCR);
			mutex_exit(&port->fp_mutex);
		} else {
			mutex_enter(&pd->pd_mutex);
			ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)pd->pd_spn,
			    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t) +
			    sizeof (spn) + 1), name_len, DDI_DEV_AUTOINCR);
			mutex_exit(&pd->pd_mutex);
		}
		break;
	}

	case NS_RPT_ID: {
		ns_rpt_t rpt;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
		    sizeof (ns_rpt_t), sizeof (fc_reg_resp_t), sleep, NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}
		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);
		pkt = &cmd->cmd_pkt;

		if (pd == NULL) {
			rpt.rpt_type = port->fp_port_type;
		} else {
			mutex_enter(&pd->pd_mutex);
			rpt.rpt_type = pd->pd_porttype;
			mutex_exit(&pd->pd_mutex);
		}
		rpt.rpt_port_id = s_id;

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&rpt,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (rpt), DDI_DEV_AUTOINCR);

		break;
	}

	case NS_RIP_NN: {
		ns_rip_t rip;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
		    sizeof (ns_rip_t), sizeof (fc_reg_resp_t), sleep, NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}
		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);
		pkt = &cmd->cmd_pkt;

		if (pd == NULL) {
			rip.rip_node_name =
			    port->fp_service_params.node_ww_name;
			bcopy(port->fp_ip_addr, rip.rip_ip_addr,
			    sizeof (port->fp_ip_addr));
		} else {
			fc_remote_node_t *node;

			/*
			 * The most correct implementation should have the IP
			 * address in the fc_remote_node_t structure; I believe
			 * Node WWN and IP address should have one to one
			 * correlation (but guess what this is changing in
			 * FC-GS-2 latest draft)
			 */
			mutex_enter(&pd->pd_mutex);
			node = pd->pd_remote_nodep;
			bcopy(pd->pd_ip_addr, rip.rip_ip_addr,
			    sizeof (pd->pd_ip_addr));
			mutex_exit(&pd->pd_mutex);

			mutex_enter(&node->fd_mutex);
			rip.rip_node_name = node->fd_node_name;
			mutex_exit(&node->fd_mutex);
		}

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&rip,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (rip), DDI_DEV_AUTOINCR);

		break;
	}

	case NS_RIPA_NN: {
		ns_ipa_t ipa;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
		    sizeof (ns_ipa_t), sizeof (fc_reg_resp_t), sleep, NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}
		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);
		pkt = &cmd->cmd_pkt;

		if (pd == NULL) {
			ipa.ipa_node_name =
			    port->fp_service_params.node_ww_name;
			bcopy(port->fp_ipa, ipa.ipa_value,
			    sizeof (port->fp_ipa));
		} else {
			fc_remote_node_t *node;

			mutex_enter(&pd->pd_mutex);
			node = pd->pd_remote_nodep;
			mutex_exit(&pd->pd_mutex);

			mutex_enter(&node->fd_mutex);
			ipa.ipa_node_name = node->fd_node_name;
			bcopy(node->fd_ipa, ipa.ipa_value,
			    sizeof (node->fd_ipa));
			mutex_exit(&node->fd_mutex);
		}

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&ipa,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (ipa), DDI_DEV_AUTOINCR);

		break;
	}

	case NS_RSNN_NN: {
		uchar_t 		name_len;
		int 			pl_size;
		la_wwn_t 		snn;
		fc_remote_node_t	*node = NULL;

		if (pd == NULL) {
			mutex_enter(&port->fp_mutex);
			name_len = port->fp_sym_node_namelen;
			mutex_exit(&port->fp_mutex);
		} else {
			mutex_enter(&pd->pd_mutex);
			node = pd->pd_remote_nodep;
			mutex_exit(&pd->pd_mutex);

			mutex_enter(&node->fd_mutex);
			name_len = node->fd_snn_len;
			mutex_exit(&node->fd_mutex);
		}

		pl_size = sizeof (la_wwn_t) + name_len + 1;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
			pl_size, sizeof (fc_reg_resp_t), sleep, NULL);
		if (cmd == NULL) {
			return (FC_NOMEM);
		}
		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);

		pkt = &cmd->cmd_pkt;

		bcopy(&port->fp_service_params.node_ww_name,
		    &snn, sizeof (la_wwn_t));

		if (pd == NULL) {
			mutex_enter(&port->fp_mutex);
			ddi_rep_put8(pkt->pkt_cmd_acc,
			    (uint8_t *)port->fp_sym_node_name, (uint8_t *)
			    (pkt->pkt_cmd + sizeof (fc_ct_header_t) +
			    sizeof (snn) + 1), name_len, DDI_DEV_AUTOINCR);
			mutex_exit(&port->fp_mutex);
		} else {
			ASSERT(node != NULL);
			mutex_enter(&node->fd_mutex);
			ddi_rep_put8(pkt->pkt_cmd_acc,
			    (uint8_t *)node->fd_snn,
			    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t) +
			    sizeof (snn) + 1), name_len, DDI_DEV_AUTOINCR);
			mutex_exit(&node->fd_mutex);
		}

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&snn,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (snn), DDI_DEV_AUTOINCR);
		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&name_len,
		    (uint8_t *)(pkt->pkt_cmd
		    + sizeof (fc_ct_header_t) + sizeof (snn)),
		    1, DDI_DEV_AUTOINCR);

		break;
	}

	case NS_DA_ID: {
		ns_remall_t rall;
		char tmp[4] = {0};
		char *ptr;

		cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
		    sizeof (ns_remall_t), sizeof (fc_reg_resp_t), sleep, NULL);

		if (cmd == NULL) {
			return (FC_NOMEM);
		}

		fp_ct_init(port, cmd, NULL, cmd_code, NULL, 0, 0, job);
		pkt = &cmd->cmd_pkt;

		ptr = (char *)(&s_id);
		tmp[3] = *ptr++;
		tmp[2] = *ptr++;
		tmp[1] = *ptr++;
		tmp[0] = *ptr;
#if defined(_BIT_FIELDS_LTOH)
		bcopy((caddr_t)tmp, (caddr_t)(&rall.rem_port_id), 4);
#else
		rall.rem_port_id = s_id;
#endif
		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&rall,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    sizeof (rall), DDI_DEV_AUTOINCR);

		break;
	}

	default:
		return (FC_FAILURE);
	}

	rval = fp_sendcmd(port, cmd, port->fp_fca_handle);

	if (rval != FC_SUCCESS) {
		job->job_result = rval;
		fp_iodone(cmd);
	}

	if (polled) {
		ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);
		fp_jobwait(job);
	} else {
		rval = FC_SUCCESS;
	}

	return (rval);
}


/*
 * Common interrupt handler
 */
static int
fp_common_intr(fc_packet_t *pkt, int iodone)
{
	int		rval = FC_FAILURE;
	fp_cmd_t 	*cmd;
	fc_local_port_t	*port;

	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

	/*
	 * Fail fast the upper layer requests if
	 * a state change has occurred amidst.
	 */
	mutex_enter(&port->fp_mutex);
	if (cmd->cmd_ulp_pkt != NULL && port->fp_statec_busy) {
		mutex_exit(&port->fp_mutex);
		cmd->cmd_ulp_pkt->pkt_state = FC_PKT_PORT_OFFLINE;
		cmd->cmd_ulp_pkt->pkt_reason = FC_REASON_OFFLINE;
	} else if (!(port->fp_soft_state &
	    (FP_SOFT_IN_DETACH | FP_DETACH_INPROGRESS))) {
		mutex_exit(&port->fp_mutex);

		switch (pkt->pkt_state) {
		case FC_PKT_LOCAL_BSY:
		case FC_PKT_FABRIC_BSY:
		case FC_PKT_NPORT_BSY:
		case FC_PKT_TIMEOUT:
			cmd->cmd_retry_interval = (pkt->pkt_state ==
			    FC_PKT_TIMEOUT) ? 0 : fp_retry_delay;
			rval = fp_retry_cmd(pkt);
			break;

		case FC_PKT_FABRIC_RJT:
		case FC_PKT_NPORT_RJT:
		case FC_PKT_LOCAL_RJT:
		case FC_PKT_LS_RJT:
		case FC_PKT_FS_RJT:
		case FC_PKT_BA_RJT:
			rval = fp_handle_reject(pkt);
			break;

		default:
			if (pkt->pkt_resp_resid) {
				cmd->cmd_retry_interval = 0;
				rval = fp_retry_cmd(pkt);
			}
			break;
		}
	} else {
		mutex_exit(&port->fp_mutex);
	}

	if (rval != FC_SUCCESS && iodone) {
		fp_iodone(cmd);
		rval = FC_SUCCESS;
	}

	return (rval);
}


/*
 * Some not so long winding theory on point to point topology:
 *
 *	In the ACC payload, if the D_ID is ZERO and the common service
 *	parameters indicate N_Port, then the topology is POINT TO POINT.
 *
 *	In a point to point topology with an N_Port, during Fabric Login,
 *	the destination N_Port will check with our WWN and decide if it
 * 	needs to issue PLOGI or not. That means, FLOGI could potentially
 *	trigger an unsolicited PLOGI from an N_Port. The Unsolicited
 *	PLOGI creates the device handles.
 *
 *	Assuming that the host port WWN is greater than the other N_Port
 *	WWN, then we become the master (be aware that this isn't the word
 *	used in the FC standards) and initiate the PLOGI.
 *
 */
static void
fp_flogi_intr(fc_packet_t *pkt)
{
	int			state;
	int			f_port;
	uint32_t		s_id;
	uint32_t		d_id;
	fp_cmd_t 		*cmd;
	fc_local_port_t 	*port;
	la_wwn_t		*swwn;
	la_wwn_t		dwwn;
	la_wwn_t		nwwn;
	fc_remote_port_t	*pd;
	la_els_logi_t 		*acc;
	com_svc_t		csp;
	ls_code_t		resp;

	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

	FP_TRACE(FP_NHEAD1(1, 0), "fp_flogi_intr; port=%p, pkt=%p, state=%x",
	    port, pkt, pkt->pkt_state);

	if (FP_IS_PKT_ERROR(pkt)) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	/*
	 * Currently, we don't need to swap bytes here because qlc is faking the
	 * response for us and so endianness is getting taken care of. But we
	 * have to fix this and generalize this at some point
	 */
	acc = (la_els_logi_t *)pkt->pkt_resp;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&resp, (uint8_t *)acc,
	    sizeof (resp), DDI_DEV_AUTOINCR);

	ASSERT(resp.ls_code == LA_ELS_ACC);
	if (resp.ls_code != LA_ELS_ACC) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&csp,
	    (uint8_t *)&acc->common_service, sizeof (csp), DDI_DEV_AUTOINCR);

	f_port = FP_IS_F_PORT(csp.cmn_features) ? 1 : 0;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	mutex_enter(&port->fp_mutex);
	state = FC_PORT_STATE_MASK(port->fp_state);
	mutex_exit(&port->fp_mutex);

	if (pkt->pkt_resp_fhdr.d_id == 0) {
		if (f_port == 0 && state != FC_STATE_LOOP) {
			swwn = &port->fp_service_params.nport_ww_name;

			ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&dwwn,
			    (uint8_t *)&acc->nport_ww_name, sizeof (la_wwn_t),
			    DDI_DEV_AUTOINCR);

			ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&nwwn,
			    (uint8_t *)&acc->node_ww_name, sizeof (la_wwn_t),
			    DDI_DEV_AUTOINCR);

			mutex_enter(&port->fp_mutex);

			port->fp_topology = FC_TOP_PT_PT;
			port->fp_total_devices = 1;
			if (fctl_wwn_cmp(swwn, &dwwn) >= 0) {
				port->fp_ptpt_master = 1;
				/*
				 * Let us choose 'X' as S_ID and 'Y'
				 * as D_ID and that'll work; hopefully
				 * If not, it will get changed.
				 */
				s_id = port->fp_instance + FP_DEFAULT_SID;
				d_id = port->fp_instance + FP_DEFAULT_DID;
				port->fp_port_id.port_id = s_id;
				mutex_exit(&port->fp_mutex);

				pd = fctl_create_remote_port(port,
				    &nwwn, &dwwn, d_id, PD_PLOGI_INITIATOR,
				    KM_NOSLEEP);
				if (pd == NULL) {
					fp_printf(port, CE_NOTE, FP_LOG_ONLY,
					    0, NULL, "couldn't create device"
					    " d_id=%X", d_id);
					fp_iodone(cmd);
					return;
				}

				cmd->cmd_pkt.pkt_tran_flags =
				    pkt->pkt_tran_flags;
				cmd->cmd_pkt.pkt_tran_type = pkt->pkt_tran_type;
				cmd->cmd_flags = FP_CMD_PLOGI_RETAIN;
				cmd->cmd_retry_count = fp_retry_count;

				fp_xlogi_init(port, cmd, s_id, d_id,
				    fp_plogi_intr, cmd->cmd_job, LA_ELS_PLOGI);

				(&cmd->cmd_pkt)->pkt_pd = pd;

				/*
				 * We've just created this fc_remote_port_t, and
				 * we're about to use it to send a PLOGI, so
				 * bump the reference count right now.  When
				 * the packet is freed, the reference count will
				 * be decremented.  The ULP may also start using
				 * it, so mark it as given away as well.
				 */
				pd->pd_ref_count++;
				pd->pd_aux_flags |= PD_GIVEN_TO_ULPS;

				if (fp_sendcmd(port, cmd,
				    port->fp_fca_handle) == FC_SUCCESS) {
					return;
				}
			} else {
				/*
				 * The device handles will be created when the
				 * unsolicited PLOGI is completed successfully
				 */
				port->fp_ptpt_master = 0;
				mutex_exit(&port->fp_mutex);
			}
		}
		pkt->pkt_state = FC_PKT_FAILURE;
	} else {
		if (f_port) {
			mutex_enter(&port->fp_mutex);
			if (state == FC_STATE_LOOP) {
				port->fp_topology = FC_TOP_PUBLIC_LOOP;
			} else {
				port->fp_topology = FC_TOP_FABRIC;

				ddi_rep_get8(pkt->pkt_resp_acc,
				    (uint8_t *)&port->fp_fabric_name,
				    (uint8_t *)&acc->node_ww_name,
				    sizeof (la_wwn_t),
				    DDI_DEV_AUTOINCR);
			}
			port->fp_port_id.port_id = pkt->pkt_resp_fhdr.d_id;
			mutex_exit(&port->fp_mutex);
		} else {
			pkt->pkt_state = FC_PKT_FAILURE;
		}
	}
	fp_iodone(cmd);
}


/*
 * Handle solicited PLOGI response
 */
static void
fp_plogi_intr(fc_packet_t *pkt)
{
	int			nl_port;
	int			bailout;
	uint32_t		d_id;
	fp_cmd_t 		*cmd;
	la_els_logi_t		*acc;
	fc_local_port_t		*port;
	fc_remote_port_t 	*pd;
	la_wwn_t		nwwn;
	la_wwn_t		pwwn;
	ls_code_t		resp;

	nl_port = 0;
	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;
	d_id = pkt->pkt_cmd_fhdr.d_id;

#ifndef	__lock_lint
	ASSERT(cmd->cmd_job && cmd->cmd_job->job_counter);
#endif

	FP_TRACE(FP_NHEAD1(3, 0), "fp_plogi_intr: port=%p, job=%p, d_id=%x,"
	    " jcount=%d pkt=%p, state=%x", port, cmd->cmd_job, d_id,
	    cmd->cmd_job->job_counter, pkt, pkt->pkt_state);

	/*
	 * Bail out early on ULP initiated requests if the
	 * state change has occurred
	 */
	mutex_enter(&port->fp_mutex);
	bailout = ((port->fp_statec_busy ||
	    FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) &&
	    cmd->cmd_ulp_pkt) ? 1 : 0;
	mutex_exit(&port->fp_mutex);

	if (FP_IS_PKT_ERROR(pkt) || bailout) {
		int skip_msg = 0;
		int giveup = 0;

		if (cmd->cmd_ulp_pkt) {
			cmd->cmd_ulp_pkt->pkt_state = pkt->pkt_state;
			cmd->cmd_ulp_pkt->pkt_reason = pkt->pkt_reason;
			cmd->cmd_ulp_pkt->pkt_action = pkt->pkt_action;
			cmd->cmd_ulp_pkt->pkt_expln = pkt->pkt_expln;
		}

		/*
		 * If an unsolicited cross login already created
		 * a device speed up the discovery by not retrying
		 * the command mindlessly.
		 */
		if (pkt->pkt_pd == NULL &&
		    fctl_get_remote_port_by_did(port, d_id) != NULL) {
			fp_iodone(cmd);
			return;
		}

		if (pkt->pkt_pd != NULL) {
			giveup = (pkt->pkt_pd->pd_recepient ==
			    PD_PLOGI_RECEPIENT) ? 1 : 0;
			if (giveup) {
				/*
				 * This pd is marked as plogi
				 * recipient, stop retrying
				 */
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_plogi_intr: stop retry as"
				    " a cross login was accepted"
				    " from d_id=%x, port=%p.",
				    d_id, port);
				fp_iodone(cmd);
				return;
			}
		}

		if (fp_common_intr(pkt, 0) == FC_SUCCESS) {
			return;
		}

		if ((pd = fctl_get_remote_port_by_did(port, d_id)) != NULL) {
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
				skip_msg++;
			}
			mutex_exit(&pd->pd_mutex);
		}

		mutex_enter(&port->fp_mutex);
		if (!bailout && !(skip_msg && port->fp_statec_busy) &&
		    port->fp_statec_busy <= 1 &&
		    pkt->pkt_reason != FC_REASON_FCAL_OPN_FAIL) {
			mutex_exit(&port->fp_mutex);
			/*
			 * In case of Login Collisions, JNI HBAs returns the
			 * FC pkt back to the Initiator with the state set to
			 * FC_PKT_LS_RJT and reason to FC_REASON_LOGICAL_ERROR.
			 * QLC HBAs handles such cases in the FW and doesnot
			 * return the LS_RJT with Logical error when
			 * login collision happens.
			 */
			if ((pkt->pkt_state != FC_PKT_LS_RJT) ||
			    (pkt->pkt_reason != FC_REASON_LOGICAL_ERROR)) {
				fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, pkt,
				    "PLOGI to %x failed", d_id);
			}
			FP_TRACE(FP_NHEAD2(9, 0),
			    "PLOGI to %x failed. state=%x reason=%x.",
			    d_id, pkt->pkt_state, pkt->pkt_reason);
		} else {
			mutex_exit(&port->fp_mutex);
		}

		fp_iodone(cmd);
		return;
	}

	acc = (la_els_logi_t *)pkt->pkt_resp;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&resp, (uint8_t *)acc,
	    sizeof (resp), DDI_DEV_AUTOINCR);

	ASSERT(resp.ls_code == LA_ELS_ACC);
	if (resp.ls_code != LA_ELS_ACC) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	if (d_id == FS_NAME_SERVER || d_id == FS_FABRIC_CONTROLLER) {
		mutex_enter(&port->fp_mutex);
		port->fp_ns_login_class = FC_TRAN_CLASS(pkt->pkt_tran_flags);
		mutex_exit(&port->fp_mutex);
		fp_iodone(cmd);
		return;
	}

	ASSERT(acc == (la_els_logi_t *)pkt->pkt_resp);

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&pwwn,
	    (uint8_t *)&acc->nport_ww_name, sizeof (la_wwn_t),
	    DDI_DEV_AUTOINCR);

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&nwwn,
	    (uint8_t *)&acc->node_ww_name, sizeof (la_wwn_t),
	    DDI_DEV_AUTOINCR);

	ASSERT(fctl_is_wwn_zero(&pwwn) == FC_FAILURE);
	ASSERT(fctl_is_wwn_zero(&nwwn) == FC_FAILURE);

	if ((pd = pkt->pkt_pd) == NULL) {
		pd = fctl_get_remote_port_by_pwwn(port, &pwwn);
		if (pd == NULL) {
			pd = fctl_create_remote_port(port, &nwwn, &pwwn, d_id,
			    PD_PLOGI_INITIATOR, KM_NOSLEEP);
			if (pd == NULL) {
				fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
				    "couldn't create port device handles"
				    " d_id=%x", d_id);
				fp_iodone(cmd);
				return;
			}
		} else {
			fc_remote_port_t *tmp_pd;

			tmp_pd = fctl_get_remote_port_by_did(port, d_id);
			if (tmp_pd != NULL) {
				fp_iodone(cmd);
				return;
			}

			mutex_enter(&port->fp_mutex);
			mutex_enter(&pd->pd_mutex);
			if ((pd->pd_state == PORT_DEVICE_LOGGED_IN) ||
			    (pd->pd_aux_flags & PD_LOGGED_OUT)) {
				cmd->cmd_flags |= FP_CMD_PLOGI_RETAIN;
			}

			if (pd->pd_type == PORT_DEVICE_OLD) {
				if (pd->pd_port_id.port_id != d_id) {
					fctl_delist_did_table(port, pd);
					pd->pd_type = PORT_DEVICE_CHANGED;
					pd->pd_port_id.port_id = d_id;
				} else {
					pd->pd_type = PORT_DEVICE_NOCHANGE;
				}
			}

			if (pd->pd_aux_flags & PD_IN_DID_QUEUE) {
				char ww_name[17];

				fc_wwn_to_str(&pd->pd_port_name, ww_name);

				mutex_exit(&pd->pd_mutex);
				mutex_exit(&port->fp_mutex);
				FP_TRACE(FP_NHEAD2(9, 0),
				    "Possible Duplicate name or address"
				    " identifiers in the PLOGI response"
				    " D_ID=%x, PWWN=%s: Please check the"
				    " configuration", d_id, ww_name);
				fp_iodone(cmd);
				return;
			}
			fctl_enlist_did_table(port, pd);
			pd->pd_aux_flags &= ~PD_LOGGED_OUT;
			mutex_exit(&pd->pd_mutex);
			mutex_exit(&port->fp_mutex);
		}
	} else {
		fc_remote_port_t *tmp_pd, *new_wwn_pd;

		tmp_pd = fctl_get_remote_port_by_did(port, d_id);
		new_wwn_pd = fctl_get_remote_port_by_pwwn(port, &pwwn);

		mutex_enter(&port->fp_mutex);
		mutex_enter(&pd->pd_mutex);
		if (fctl_wwn_cmp(&pd->pd_port_name, &pwwn) == 0) {
			FP_TRACE(FP_NHEAD1(3, 0), "fp_plogi_intr: d_id=%x,"
			    " pd_state=%x pd_type=%x", d_id, pd->pd_state,
			    pd->pd_type);
			if ((pd->pd_state == PORT_DEVICE_LOGGED_IN &&
			    pd->pd_type == PORT_DEVICE_OLD) ||
				(pd->pd_aux_flags & PD_LOGGED_OUT)) {
				pd->pd_type = PORT_DEVICE_NOCHANGE;
			} else if (pd->pd_state != PORT_DEVICE_LOGGED_IN) {
				pd->pd_type = PORT_DEVICE_NEW;
			}
		} else {
			char 	old_name[17];
			char 	new_name[17];

			fc_wwn_to_str(&pd->pd_port_name, old_name);
			fc_wwn_to_str(&pwwn, new_name);

			FP_TRACE(FP_NHEAD1(9, 0),
			    "fp_plogi_intr: PWWN of a device with D_ID=%x "
			    "changed. New PWWN = %s, OLD PWWN = %s ; tmp_pd:%p "
			    "pd:%p new_wwn_pd:%p, cmd_ulp_pkt:%p, bailout:0x%x",
			    d_id, new_name, old_name, tmp_pd, pd, new_wwn_pd,
			    cmd->cmd_ulp_pkt, bailout);

			FP_TRACE(FP_NHEAD2(9, 0),
			    "PWWN of a device with D_ID=%x changed."
			    " New PWWN = %s, OLD PWWN = %s", d_id,
			    new_name, old_name);

			if (cmd->cmd_ulp_pkt && !bailout) {
				fc_remote_node_t	*rnodep;
				fc_portmap_t	*changelist;
				fc_portmap_t	*listptr;
				int		len = 1;
						/* # entries in changelist */

				fctl_delist_pwwn_table(port, pd);

				/*
				 * Lets now check if there already is a pd with
				 * this new WWN in the table. If so, we'll mark
				 * it as invalid
				 */

				if (new_wwn_pd) {
					/*
					 * There is another pd with in the pwwn
					 * table with the same WWN that we got
					 * in the PLOGI payload. We have to get
					 * it out of the pwwn table, update the
					 * pd's state (fp_fillout_old_map does
					 * this for us) and add it to the
					 * changelist that goes up to ULPs.
					 *
					 * len is length of changelist and so
					 * increment it.
					 */
					len++;

					if (tmp_pd != pd) {
						/*
						 * Odd case where pwwn and did
						 * tables are out of sync but
						 * we will handle that too. See
						 * more comments below.
						 *
						 * One more device that ULPs
						 * should know about and so len
						 * gets incremented again.
						 */
						len++;
					}

					listptr = changelist = kmem_zalloc(len *
					    sizeof (*changelist), KM_SLEEP);

					mutex_enter(&new_wwn_pd->pd_mutex);
					rnodep = new_wwn_pd->pd_remote_nodep;
					mutex_exit(&new_wwn_pd->pd_mutex);

					/*
					 * Hold the fd_mutex since
					 * fctl_copy_portmap_held expects it.
					 * Preserve lock hierarchy by grabbing
					 * fd_mutex before pd_mutex
					 */
					if (rnodep) {
						mutex_enter(&rnodep->fd_mutex);
					}
					mutex_enter(&new_wwn_pd->pd_mutex);
					fp_fillout_old_map_held(listptr++,
					    new_wwn_pd, 0);
					mutex_exit(&new_wwn_pd->pd_mutex);
					if (rnodep) {
						mutex_exit(&rnodep->fd_mutex);
					}

					/*
					 * Safety check :
					 * Lets ensure that the pwwn and did
					 * tables are in sync. Ideally, we
					 * should not find that these two pd's
					 * are different.
					 */
					if (tmp_pd != pd) {
						mutex_enter(&tmp_pd->pd_mutex);
						rnodep =
						    tmp_pd->pd_remote_nodep;
						mutex_exit(&tmp_pd->pd_mutex);

						/* As above grab fd_mutex */
						if (rnodep) {
							mutex_enter(&rnodep->
							    fd_mutex);
						}
						mutex_enter(&tmp_pd->pd_mutex);

						fp_fillout_old_map_held(
						    listptr++, tmp_pd, 0);

						mutex_exit(&tmp_pd->pd_mutex);
						if (rnodep) {
							mutex_exit(&rnodep->
							    fd_mutex);
						}

						/*
						 * Now add "pd" (not tmp_pd)
						 * to fp_did_table to sync it up
						 * with fp_pwwn_table
						 *
						 * pd->pd_mutex is already held
						 * at this point
						 */
						fctl_enlist_did_table(port, pd);
					}
				} else {
					listptr = changelist = kmem_zalloc(
					    sizeof (*changelist), KM_SLEEP);
				}

				ASSERT(changelist != NULL);

				fp_fillout_changed_map(listptr, pd, &d_id,
					&pwwn);
				fctl_enlist_pwwn_table(port, pd);

				mutex_exit(&pd->pd_mutex);
				mutex_exit(&port->fp_mutex);

				fp_iodone(cmd);

				(void) fp_ulp_devc_cb(port, changelist, len,
						len, KM_NOSLEEP, 0);

				return;
			}
		}

		if (pd->pd_porttype.port_type == FC_NS_PORT_NL) {
			nl_port = 1;
		}
		if (pd->pd_aux_flags & PD_DISABLE_RELOGIN)
			pd->pd_aux_flags &= ~PD_LOGGED_OUT;

		mutex_exit(&pd->pd_mutex);
		mutex_exit(&port->fp_mutex);

		if (tmp_pd == NULL) {
			mutex_enter(&port->fp_mutex);
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_aux_flags & PD_IN_DID_QUEUE) {
				char ww_name[17];

				fc_wwn_to_str(&pd->pd_port_name, ww_name);
				mutex_exit(&pd->pd_mutex);
				mutex_exit(&port->fp_mutex);
				FP_TRACE(FP_NHEAD2(9, 0),
				    "Possible Duplicate name or address"
				    " identifiers in the PLOGI response"
				    " D_ID=%x, PWWN=%s: Please check the"
				    " configuration", d_id, ww_name);
				fp_iodone(cmd);
				return;
			}
			fctl_enlist_did_table(port, pd);
			pd->pd_aux_flags &= ~PD_LOGGED_OUT;
			mutex_exit(&pd->pd_mutex);
			mutex_exit(&port->fp_mutex);
		}
	}
	fp_register_login(&pkt->pkt_resp_acc, pd, acc,
	    FC_TRAN_CLASS(pkt->pkt_tran_flags));

	if (cmd->cmd_ulp_pkt) {
		cmd->cmd_ulp_pkt->pkt_state = pkt->pkt_state;
		cmd->cmd_ulp_pkt->pkt_action = pkt->pkt_action;
		cmd->cmd_ulp_pkt->pkt_expln = pkt->pkt_expln;
		if (cmd->cmd_ulp_pkt->pkt_pd == NULL) {
			if (pd != NULL) {
				FP_TRACE(FP_NHEAD1(9, 0),
				    "fp_plogi_intr;"
				    "ulp_pkt's pd is NULL, get a pd %p",
				    pd);
				mutex_enter(&pd->pd_mutex);
				pd->pd_ref_count++;
				mutex_exit(&pd->pd_mutex);
			}
			cmd->cmd_ulp_pkt->pkt_pd = pd;
		}
		bcopy((caddr_t)&pkt->pkt_resp_fhdr,
		    (caddr_t)&cmd->cmd_ulp_pkt->pkt_resp_fhdr,
		    sizeof (fc_frame_hdr_t));
		bcopy((caddr_t)pkt->pkt_resp,
		    (caddr_t)cmd->cmd_ulp_pkt->pkt_resp,
		    sizeof (la_els_logi_t));
	}

	mutex_enter(&port->fp_mutex);
	if (port->fp_topology == FC_TOP_PRIVATE_LOOP || nl_port) {
		mutex_enter(&pd->pd_mutex);

		cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
		cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
		cmd->cmd_retry_count = fp_retry_count;

		/*
		 * If the fc_remote_port_t pointer is not set in the given
		 * fc_packet_t, then this fc_remote_port_t must have just
		 * been created.  Save the pointer and also increment the
		 * fc_remote_port_t reference count.
		 */
		if (pkt->pkt_pd == NULL) {
			pkt->pkt_pd = pd;
			pd->pd_ref_count++;	/* It's in use! */
		}

		fp_adisc_init(cmd, cmd->cmd_job);

		pkt->pkt_cmdlen = sizeof (la_els_adisc_t);
		pkt->pkt_rsplen = sizeof (la_els_adisc_t);

		mutex_exit(&pd->pd_mutex);
		mutex_exit(&port->fp_mutex);

		if (fp_sendcmd(port, cmd, port->fp_fca_handle) == FC_SUCCESS) {
			return;
		}
	} else {
		mutex_exit(&port->fp_mutex);
	}

	if ((cmd->cmd_flags & FP_CMD_PLOGI_RETAIN) == 0) {
		mutex_enter(&port->fp_mutex);
		mutex_enter(&pd->pd_mutex);

		cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
		cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
		cmd->cmd_retry_count = fp_retry_count;

		fp_logo_init(pd, cmd, cmd->cmd_job);

		pkt->pkt_cmdlen = sizeof (la_els_logo_t);
		pkt->pkt_rsplen = FP_PORT_IDENTIFIER_LEN;

		mutex_exit(&pd->pd_mutex);
		mutex_exit(&port->fp_mutex);

		if (fp_sendcmd(port, cmd, port->fp_fca_handle) == FC_SUCCESS) {
			return;
		}

	}
	fp_iodone(cmd);
}


/*
 * Handle solicited ADISC response
 */
static void
fp_adisc_intr(fc_packet_t *pkt)
{
	int			rval;
	int			bailout;
	fp_cmd_t		*cmd;
	fc_local_port_t		*port;
	fc_remote_port_t	*pd;
	la_els_adisc_t 		*acc;
	ls_code_t		resp;
	fc_hardaddr_t		ha;
	fc_portmap_t		*changelist;
	int			initiator, adiscfail = 0;

	pd = pkt->pkt_pd;
	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

#ifndef	__lock_lint
	ASSERT(cmd->cmd_job && cmd->cmd_job->job_counter);
#endif

	ASSERT(pd != NULL && port != NULL && cmd != NULL);

	mutex_enter(&port->fp_mutex);
	bailout = ((port->fp_statec_busy ||
	    FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) &&
	    cmd->cmd_ulp_pkt) ? 1 : 0;
	mutex_exit(&port->fp_mutex);

	if (bailout) {
		fp_iodone(cmd);
		return;
	}

	if (pkt->pkt_state == FC_PKT_SUCCESS && pkt->pkt_resp_resid == 0) {
		acc = (la_els_adisc_t *)pkt->pkt_resp;

		ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&resp,
		    (uint8_t *)acc, sizeof (resp), DDI_DEV_AUTOINCR);

		if (resp.ls_code == LA_ELS_ACC) {
			int	is_private;

			ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&ha,
			    (uint8_t *)&acc->hard_addr, sizeof (ha),
			    DDI_DEV_AUTOINCR);

			mutex_enter(&port->fp_mutex);

			is_private =
			    (port->fp_topology == FC_TOP_PRIVATE_LOOP) ? 1 : 0;

			mutex_enter(&pd->pd_mutex);
			if ((pd->pd_aux_flags & PD_IN_DID_QUEUE) == 0) {
				fctl_enlist_did_table(port, pd);
			}
			mutex_exit(&pd->pd_mutex);

			mutex_exit(&port->fp_mutex);

			mutex_enter(&pd->pd_mutex);
			if (pd->pd_type != PORT_DEVICE_NEW) {
				if (is_private && (pd->pd_hard_addr.hard_addr !=
				    ha.hard_addr)) {
					pd->pd_type = PORT_DEVICE_CHANGED;
				} else {
					pd->pd_type = PORT_DEVICE_NOCHANGE;
				}
			}

			if (is_private && (ha.hard_addr &&
			    pd->pd_port_id.port_id != ha.hard_addr)) {
				char ww_name[17];

				fc_wwn_to_str(&pd->pd_port_name, ww_name);

				fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
				    "NL_Port Identifier %x doesn't match"
				    " with Hard Address %x, Will use Port"
				    " WWN %s", pd->pd_port_id.port_id,
				    ha.hard_addr, ww_name);

				pd->pd_hard_addr.hard_addr = 0;
			} else {
				pd->pd_hard_addr.hard_addr = ha.hard_addr;
			}
			mutex_exit(&pd->pd_mutex);
		} else {
			if (fp_common_intr(pkt, 0) == FC_SUCCESS) {
				return;
			}
		}
	} else {
		if (fp_common_intr(pkt, 0) == FC_SUCCESS) {
			return;
		}

		mutex_enter(&port->fp_mutex);
		if (port->fp_statec_busy <= 1) {
			mutex_exit(&port->fp_mutex);
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, pkt,
			    "ADISC to %x failed, cmd_flags=%x",
			    pkt->pkt_cmd_fhdr.d_id, cmd->cmd_flags);
			cmd->cmd_flags &= ~FP_CMD_PLOGI_RETAIN;
			adiscfail = 1;
		} else {
			mutex_exit(&port->fp_mutex);
		}
	}

	if (cmd->cmd_ulp_pkt) {
		cmd->cmd_ulp_pkt->pkt_state = pkt->pkt_state;
		cmd->cmd_ulp_pkt->pkt_action = pkt->pkt_action;
		cmd->cmd_ulp_pkt->pkt_expln = pkt->pkt_expln;
		if (cmd->cmd_ulp_pkt->pkt_pd == NULL) {
			cmd->cmd_ulp_pkt->pkt_pd = pd;
			FP_TRACE(FP_NHEAD1(9, 0),
			    "fp_adisc__intr;"
			    "ulp_pkt's pd is NULL, get a pd %p",
			    pd);

		}
		bcopy((caddr_t)&pkt->pkt_resp_fhdr,
		    (caddr_t)&cmd->cmd_ulp_pkt->pkt_resp_fhdr,
		    sizeof (fc_frame_hdr_t));
		bcopy((caddr_t)pkt->pkt_resp,
		    (caddr_t)cmd->cmd_ulp_pkt->pkt_resp,
		    sizeof (la_els_logi_t));
	}

	if ((cmd->cmd_flags & FP_CMD_PLOGI_RETAIN) == 0) {
		FP_TRACE(FP_NHEAD1(9, 0),
		    "fp_adisc_intr: Perform LOGO.cmd_flags=%x, "
		    "fp_retry_count=%x, ulp_pkt=%p",
		    cmd->cmd_flags, fp_retry_count, cmd->cmd_ulp_pkt);

		mutex_enter(&port->fp_mutex);
		mutex_enter(&pd->pd_mutex);

		cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
		cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
		cmd->cmd_retry_count = fp_retry_count;

		fp_logo_init(pd, cmd, cmd->cmd_job);

		pkt->pkt_cmdlen = sizeof (la_els_logo_t);
		pkt->pkt_rsplen = FP_PORT_IDENTIFIER_LEN;

		mutex_exit(&pd->pd_mutex);
		mutex_exit(&port->fp_mutex);

		rval = fp_sendcmd(port, cmd, port->fp_fca_handle);
		if (adiscfail) {
			mutex_enter(&pd->pd_mutex);
			initiator =
			    (pd->pd_recepient == PD_PLOGI_INITIATOR) ? 1 : 0;
			pd->pd_state = PORT_DEVICE_VALID;
			pd->pd_aux_flags |= PD_LOGGED_OUT;
			if (pd->pd_aux_flags & PD_DISABLE_RELOGIN)
				pd->pd_type = PORT_DEVICE_NEW;
			else
				pd->pd_type = PORT_DEVICE_NOCHANGE;
			mutex_exit(&pd->pd_mutex);

			changelist =
			    kmem_zalloc(sizeof (*changelist), KM_SLEEP);

			if (initiator) {
				fp_unregister_login(pd);
				fctl_copy_portmap(changelist, pd);
			} else {
				fp_fillout_old_map(changelist, pd, 0);
			}

			FP_TRACE(FP_NHEAD1(9, 0),
			    "fp_adisc_intr: Dev change notification "
			    "to ULP port=%p, pd=%p, map_type=%x map_state=%x "
			    "map_flags=%x initiator=%d", port, pd,
			    changelist->map_type, changelist->map_state,
			    changelist->map_flags, initiator);

			(void) fp_ulp_devc_cb(port, changelist,
			    1, 1, KM_SLEEP, 0);
		}
		if (rval == FC_SUCCESS) {
			return;
		}
	}
	fp_iodone(cmd);
}


/*
 * Handle solicited LOGO response
 */
static void
fp_logo_intr(fc_packet_t *pkt)
{
	ls_code_t	resp;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&resp,
	    (uint8_t *)pkt->pkt_resp, sizeof (resp), DDI_DEV_AUTOINCR);

	if (FP_IS_PKT_ERROR(pkt)) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	ASSERT(resp.ls_code == LA_ELS_ACC);
	if (resp.ls_code != LA_ELS_ACC) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	if (pkt->pkt_pd != NULL) {
		fp_unregister_login(pkt->pkt_pd);
	}
	fp_iodone(pkt->pkt_ulp_private);
}


/*
 * Handle solicited RNID response
 */
static void
fp_rnid_intr(fc_packet_t *pkt)
{
	ls_code_t		resp;
	job_request_t		*job;
	fp_cmd_t		*cmd;
	la_els_rnid_acc_t	*acc;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&resp,
	    (uint8_t *)pkt->pkt_resp, sizeof (resp), DDI_DEV_AUTOINCR);

	cmd = pkt->pkt_ulp_private;
	job = cmd->cmd_job;
	ASSERT(job->job_private != NULL);

	/* If failure or LS_RJT then retry the packet, if needed */
	if (pkt->pkt_state != FC_PKT_SUCCESS || resp.ls_code != LA_ELS_ACC) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	/* Save node_id memory allocated in ioctl code */
	acc = (la_els_rnid_acc_t *)pkt->pkt_resp;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)job->job_private,
	    (uint8_t *)acc, sizeof (la_els_rnid_acc_t), DDI_DEV_AUTOINCR);

	/* wakeup the ioctl thread and free the pkt */
	fp_iodone(cmd);
}


/*
 * Handle solicited RLS response
 */
static void
fp_rls_intr(fc_packet_t *pkt)
{
	ls_code_t		resp;
	job_request_t		*job;
	fp_cmd_t		*cmd;
	la_els_rls_acc_t	*acc;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&resp,
	    (uint8_t *)pkt->pkt_resp, sizeof (resp), DDI_DEV_AUTOINCR);

	cmd = pkt->pkt_ulp_private;
	job = cmd->cmd_job;
	ASSERT(job->job_private != NULL);

	/* If failure or LS_RJT then retry the packet, if needed */
	if (FP_IS_PKT_ERROR(pkt) || resp.ls_code != LA_ELS_ACC) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	/* Save link error status block in memory allocated in ioctl code */
	acc = (la_els_rls_acc_t *)pkt->pkt_resp;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)job->job_private,
	    (uint8_t *)&acc->rls_link_params, sizeof (fc_rls_acc_t),
	    DDI_DEV_AUTOINCR);

	/* wakeup the ioctl thread and free the pkt */
	fp_iodone(cmd);
}


/*
 * A solicited command completion interrupt (mostly for commands
 * that require almost no post processing such as SCR ELS)
 */
static void
fp_intr(fc_packet_t *pkt)
{
	if (FP_IS_PKT_ERROR(pkt)) {
		(void) fp_common_intr(pkt, 1);
		return;
	}
	fp_iodone(pkt->pkt_ulp_private);
}


/*
 * Handle the underlying port's state change
 */
static void
fp_statec_cb(opaque_t port_handle, uint32_t state)
{
	fc_local_port_t *port = port_handle;
	job_request_t 	*job;

	/*
	 * If it is not possible to process the callbacks
	 * just drop the callback on the floor; Don't bother
	 * to do something that isn't safe at this time
	 */
	mutex_enter(&port->fp_mutex);
	if ((port->fp_soft_state &
	    (FP_SOFT_IN_DETACH | FP_SOFT_SUSPEND | FP_SOFT_POWER_DOWN)) ||
	    (FC_PORT_STATE_MASK(port->fp_state) == FC_PORT_STATE_MASK(state))) {
		mutex_exit(&port->fp_mutex);
		return;
	}

	if (port->fp_statec_busy == 0) {
		port->fp_soft_state |= FP_SOFT_IN_STATEC_CB;
#ifdef	DEBUG
	} else {
		ASSERT(port->fp_soft_state & FP_SOFT_IN_STATEC_CB);
#endif
	}

	port->fp_statec_busy++;

	/*
	 * For now, force the trusted method of device authentication (by
	 * PLOGI) when LIPs do not involve OFFLINE to ONLINE transition.
	 */
	if (FC_PORT_STATE_MASK(state) == FC_STATE_LIP ||
	    FC_PORT_STATE_MASK(state) == FC_STATE_LIP_LBIT_SET) {
		state = FC_PORT_SPEED_MASK(port->fp_state) | FC_STATE_LOOP;
		fp_port_offline(port, 0);
	}
	mutex_exit(&port->fp_mutex);

	switch (FC_PORT_STATE_MASK(state)) {
	case FC_STATE_OFFLINE:
		job = fctl_alloc_job(JOB_PORT_OFFLINE,
		    JOB_TYPE_FCTL_ASYNC, NULL, NULL, KM_NOSLEEP);
		if (job == NULL) {
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
			    " fp_statec_cb() couldn't submit a job "
			    " to the thread: failing..");
			mutex_enter(&port->fp_mutex);
			if (--port->fp_statec_busy == 0) {
				port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
			}
			mutex_exit(&port->fp_mutex);
			return;
		}
		mutex_enter(&port->fp_mutex);
		/*
		 * Zero out this field so that we do not retain
		 * the fabric name as its no longer valid
		 */
		bzero(&port->fp_fabric_name, sizeof (la_wwn_t));
		port->fp_state = state;
		mutex_exit(&port->fp_mutex);

		fctl_enque_job(port, job);
		break;

	case FC_STATE_ONLINE:
	case FC_STATE_LOOP:
		mutex_enter(&port->fp_mutex);
		port->fp_state = state;

		if (port->fp_offline_tid) {
			timeout_id_t tid;

			tid = port->fp_offline_tid;
			port->fp_offline_tid = NULL;
			mutex_exit(&port->fp_mutex);
			(void) untimeout(tid);
		} else {
			mutex_exit(&port->fp_mutex);
		}

		job = fctl_alloc_job(JOB_PORT_ONLINE,
		    JOB_TYPE_FCTL_ASYNC, NULL, NULL, KM_NOSLEEP);
		if (job == NULL) {
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
			    "fp_statec_cb() couldn't submit a job "
			    "to the thread: failing..");

			mutex_enter(&port->fp_mutex);
			if (--port->fp_statec_busy == 0) {
				port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
			}
			mutex_exit(&port->fp_mutex);
			return;
		}
		fctl_enque_job(port, job);
		break;

	case FC_STATE_RESET_REQUESTED:
		mutex_enter(&port->fp_mutex);
		port->fp_state = FC_STATE_OFFLINE;
		port->fp_soft_state |= FP_SOFT_IN_FCA_RESET;
		mutex_exit(&port->fp_mutex);
		/* FALLTHROUGH */

	case FC_STATE_RESET:
		job = fctl_alloc_job(JOB_ULP_NOTIFY,
		    JOB_TYPE_FCTL_ASYNC, NULL, NULL, KM_NOSLEEP);
		if (job == NULL) {
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
			    "fp_statec_cb() couldn't submit a job"
			    " to the thread: failing..");

			mutex_enter(&port->fp_mutex);
			if (--port->fp_statec_busy == 0) {
				port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
			}
			mutex_exit(&port->fp_mutex);
			return;
		}

		/* squeeze into some field in the job structure */
		job->job_ulp_listlen = FC_PORT_STATE_MASK(state);
		fctl_enque_job(port, job);
		break;

	case FC_STATE_TARGET_PORT_RESET:
		(void) fp_ulp_notify(port, state, KM_NOSLEEP);
		/* FALLTHROUGH */

	case FC_STATE_NAMESERVICE:
		/* FALLTHROUGH */

	default:
		mutex_enter(&port->fp_mutex);
		if (--port->fp_statec_busy == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
		}
		mutex_exit(&port->fp_mutex);
		break;
	}
}


/*
 * Register with the Name Server for RSCNs
 */
static int
fp_ns_scr(fc_local_port_t *port, job_request_t *job, uchar_t scr_func,
    int sleep)
{
	uint32_t	s_id;
	uchar_t		class;
	fc_scr_req_t 	payload;
	fp_cmd_t 	*cmd;
	fc_packet_t 	*pkt;

	mutex_enter(&port->fp_mutex);
	s_id = port->fp_port_id.port_id;
	class = port->fp_ns_login_class;
	mutex_exit(&port->fp_mutex);

	cmd = fp_alloc_pkt(port, sizeof (fc_scr_req_t),
	    sizeof (fc_scr_resp_t), sleep, NULL);
	if (cmd == NULL) {
		return (FC_NOMEM);
	}

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = fp_retry_count;
	cmd->cmd_ulp_pkt = NULL;

	pkt = &cmd->cmd_pkt;
	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;

	fp_els_init(cmd, s_id, 0xFFFFFD, fp_intr, job);

	payload.ls_code.ls_code = LA_ELS_SCR;
	payload.ls_code.mbz = 0;
	payload.scr_rsvd = 0;
	payload.scr_func = scr_func;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);

	job->job_counter = 1;

	if (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS) {
		fp_iodone(cmd);
	}

	return (FC_SUCCESS);
}


/*
 * There are basically two methods to determine the total number of
 * devices out in the NS database; Reading the details of the two
 * methods described below, it shouldn't be hard to identify which
 * of the two methods is better.
 *
 *	Method 1.
 *		Iteratively issue GANs until all ports identifiers are walked
 *
 *	Method 2.
 *		Issue GID_PT (get port Identifiers) with Maximum residual
 *		field in the request CT HEADER set to accommodate only the
 *		CT HEADER in the response frame. And if FC-GS2 has been
 *		carefully read, the NS here has a chance to FS_ACC the
 *		request and indicate the residual size in the FS_ACC.
 *
 *	Method 2 is wonderful, although it's not mandatory for the NS
 *	to update the Maximum/Residual Field as can be seen in 4.3.1.6
 *	(note with particular care the use of the auxiliary verb 'may')
 *
 */
static int
fp_ns_get_devcount(fc_local_port_t *port, job_request_t *job, int create,
    int sleep)
{
	int		flags;
	int		rval;
	uint32_t	src_id;
	fctl_ns_req_t	*ns_cmd;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	mutex_enter(&port->fp_mutex);
	src_id = port->fp_port_id.port_id;
	mutex_exit(&port->fp_mutex);

	if (!create && (port->fp_options & FP_NS_SMART_COUNT)) {
		ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gid_pt_t),
		    sizeof (ns_resp_gid_pt_t), 0,
		    (FCTL_NS_GET_DEV_COUNT | FCTL_NS_NO_DATA_BUF), sleep);

		if (ns_cmd == NULL) {
			return (FC_NOMEM);
		}

		ns_cmd->ns_cmd_code = NS_GID_PT;
		((ns_req_gid_pt_t *)(ns_cmd->ns_cmd_buf))->port_type.port_type
		    = FC_NS_PORT_NX;	/* All port types */
		((ns_req_gid_pt_t *)(ns_cmd->ns_cmd_buf))->port_type.rsvd = 0;

	} else {
		uint32_t ns_flags;

		ns_flags = FCTL_NS_GET_DEV_COUNT | FCTL_NS_NO_DATA_BUF;
		if (create) {
			ns_flags |= FCTL_NS_CREATE_DEVICE;
		}
		ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gan_t),
		    sizeof (ns_resp_gan_t), sizeof (int), ns_flags, sleep);

		if (ns_cmd == NULL) {
			return (FC_NOMEM);
		}
		ns_cmd->ns_gan_index = 0;
		ns_cmd->ns_gan_sid = FCTL_GAN_START_ID;
		ns_cmd->ns_cmd_code = NS_GA_NXT;
		ns_cmd->ns_gan_max = 0xFFFF;

		((ns_req_gan_t *)(ns_cmd->ns_cmd_buf))->pid.port_id = src_id;
		((ns_req_gan_t *)(ns_cmd->ns_cmd_buf))->pid.priv_lilp_posit = 0;
	}

	flags = job->job_flags;
	job->job_flags &= ~JOB_TYPE_FP_ASYNC;
	job->job_counter = 1;

	rval = fp_ns_query(port, ns_cmd, job, 1, sleep);
	job->job_flags = flags;

	if (!create && (port->fp_options & FP_NS_SMART_COUNT)) {
		uint16_t max_resid;

		/*
		 * Revert to scanning the NS if NS_GID_PT isn't
		 * helping us figure out total number of devices.
		 */
		if (job->job_result != FC_SUCCESS ||
		    ns_cmd->ns_resp_hdr.ct_cmdrsp != FS_ACC_IU) {
			mutex_enter(&port->fp_mutex);
			port->fp_options &= ~FP_NS_SMART_COUNT;
			mutex_exit(&port->fp_mutex);

			fctl_free_ns_cmd(ns_cmd);
			return (fp_ns_get_devcount(port, job, create, sleep));
		}

		mutex_enter(&port->fp_mutex);
		port->fp_total_devices = 1;
		max_resid = ns_cmd->ns_resp_hdr.ct_aiusize;
		if (max_resid) {
			/*
			 * Since port identifier is 4 bytes and max_resid
			 * is also in WORDS, max_resid simply indicates
			 * the total number of port identifiers	not
			 * transferred
			 */
			port->fp_total_devices += max_resid;
		}
		mutex_exit(&port->fp_mutex);
	}
	mutex_enter(&port->fp_mutex);
	port->fp_total_devices = *((int *)ns_cmd->ns_data_buf);
	mutex_exit(&port->fp_mutex);
	fctl_free_ns_cmd(ns_cmd);

	return (rval);
}

/*
 * One heck of a function to serve userland.
 */
static int
fp_fciocmd(fc_local_port_t *port, intptr_t data, int mode, fcio_t *fcio)
{
	int 		rval = 0;
	int		jcode;
	uint32_t	ret;
	uchar_t		open_flag;
	fcio_t		*kfcio;
	job_request_t 	*job;
	boolean_t	use32 = B_FALSE;

#ifdef _MULTI_DATAMODEL
	switch (ddi_model_convert_from(mode & FMODELS)) {
	case DDI_MODEL_ILP32:
		use32 = B_TRUE;
		break;

	case DDI_MODEL_NONE:
	default:
		break;
	}
#endif

	mutex_enter(&port->fp_mutex);
	if (port->fp_soft_state & (FP_SOFT_IN_STATEC_CB |
	    FP_SOFT_IN_UNSOL_CB)) {
		fcio->fcio_errno = FC_STATEC_BUSY;
		mutex_exit(&port->fp_mutex);
		rval = EAGAIN;
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
		return (rval);
	}
	open_flag = port->fp_flag;
	mutex_exit(&port->fp_mutex);

	if (fp_check_perms(open_flag, fcio->fcio_cmd) != FC_SUCCESS) {
		fcio->fcio_errno = FC_FAILURE;
		rval = EACCES;
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
		return (rval);
	}

	/*
	 * If an exclusive open was demanded during open, don't let
	 * either innocuous or devil threads to share the file
	 * descriptor and fire down exclusive access commands
	 */
	mutex_enter(&port->fp_mutex);
	if (port->fp_flag & FP_EXCL) {
		if (port->fp_flag & FP_EXCL_BUSY) {
			mutex_exit(&port->fp_mutex);
			fcio->fcio_errno = FC_FAILURE;
			return (EBUSY);
		}
		port->fp_flag |= FP_EXCL_BUSY;
	}
	mutex_exit(&port->fp_mutex);

	switch (fcio->fcio_cmd) {
	case FCIO_GET_HOST_PARAMS: {
		fc_port_dev_t	*val;
		fc_port_dev32_t	*val32;
		int		index;
		int		lilp_device_count;
		fc_lilpmap_t	*lilp_map;
		uchar_t		*alpa_list;

		if (use32 == B_TRUE) {
			if (fcio->fcio_olen != sizeof (*val32) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		} else {
			if (fcio->fcio_olen != sizeof (*val) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		}

		val = kmem_zalloc(sizeof (*val), KM_SLEEP);

		mutex_enter(&port->fp_mutex);
		val->dev_did = port->fp_port_id;
		val->dev_hard_addr = port->fp_hard_addr;
		val->dev_pwwn = port->fp_service_params.nport_ww_name;
		val->dev_nwwn = port->fp_service_params.node_ww_name;
		val->dev_state = port->fp_state;

		lilp_map = &port->fp_lilp_map;
		alpa_list = &lilp_map->lilp_alpalist[0];
		lilp_device_count = lilp_map->lilp_length;
		for (index = 0; index < lilp_device_count; index++) {
			uint32_t d_id;

			d_id = alpa_list[index];
			if (d_id == port->fp_port_id.port_id) {
				break;
			}
		}
		val->dev_did.priv_lilp_posit = (uint8_t)(index & 0xff);

		bcopy(port->fp_fc4_types, val->dev_type,
		    sizeof (port->fp_fc4_types));
		mutex_exit(&port->fp_mutex);

		if (use32 == B_TRUE) {
			val32 = kmem_zalloc(sizeof (*val32), KM_SLEEP);

			val32->dev_did = val->dev_did;
			val32->dev_hard_addr = val->dev_hard_addr;
			val32->dev_pwwn = val->dev_pwwn;
			val32->dev_nwwn = val->dev_nwwn;
			val32->dev_state = val->dev_state;
			val32->dev_did.priv_lilp_posit =
			    val->dev_did.priv_lilp_posit;

			bcopy(val->dev_type, val32->dev_type,
			    sizeof (port->fp_fc4_types));

			if (fp_copyout((void *)val32, (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}

			kmem_free(val32, sizeof (*val32));
		} else {
			if (fp_copyout((void *)val, (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		}

		/* need to free "val" here */
		kmem_free(val, sizeof (*val));
		break;
	}

	case FCIO_GET_OTHER_ADAPTER_PORTS: {
		uint32_t    index;
		char	    *tmpPath;
		fc_local_port_t   *tmpPort;

		if (fcio->fcio_olen < MAXPATHLEN ||
		    fcio->fcio_ilen != sizeof (uint32_t)) {
			rval = EINVAL;
			break;
		}
		if (ddi_copyin(fcio->fcio_ibuf, &index, sizeof (index), mode)) {
			rval = EFAULT;
			break;
		}

		tmpPort = fctl_get_adapter_port_by_index(port, index);
		if (tmpPort == NULL) {
			FP_TRACE(FP_NHEAD1(9, 0),
			    "User supplied index out of range");
			fcio->fcio_errno = FC_BADPORT;
			rval = EFAULT;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}

		tmpPath = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
		(void) ddi_pathname(tmpPort->fp_port_dip, tmpPath);
		if (fp_copyout((void *)tmpPath, (void *)fcio->fcio_obuf,
		    MAXPATHLEN, mode) == 0) {
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		} else {
			rval = EFAULT;
		}
		kmem_free(tmpPath, MAXPATHLEN);
		break;
	}

	case FCIO_NPIV_GET_ADAPTER_ATTRIBUTES:
	case FCIO_GET_ADAPTER_ATTRIBUTES: {
		fc_hba_adapter_attributes_t	*val;
		fc_hba_adapter_attributes32_t	*val32;

		if (use32 == B_TRUE) {
			if (fcio->fcio_olen < sizeof (*val32) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		} else {
			if (fcio->fcio_olen < sizeof (*val) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		}

		val = kmem_zalloc(sizeof (*val), KM_SLEEP);
		val->version = FC_HBA_ADAPTER_ATTRIBUTES_VERSION;
		mutex_enter(&port->fp_mutex);
		bcopy(port->fp_hba_port_attrs.manufacturer,
			val->Manufacturer,
			sizeof (val->Manufacturer));
		bcopy(port->fp_hba_port_attrs.serial_number,
			val->SerialNumber,
			sizeof (val->SerialNumber));
		bcopy(port->fp_hba_port_attrs.model,
			val->Model,
			sizeof (val->Model));
		bcopy(port->fp_hba_port_attrs.model_description,
			val->ModelDescription,
			sizeof (val->ModelDescription));
		bcopy(port->fp_sym_node_name, val->NodeSymbolicName,
		    sizeof (val->NodeSymbolicName));
		bcopy(port->fp_hba_port_attrs.hardware_version,
			val->HardwareVersion,
			sizeof (val->HardwareVersion));
		bcopy(port->fp_hba_port_attrs.option_rom_version,
			val->OptionROMVersion,
			sizeof (val->OptionROMVersion));
		bcopy(port->fp_hba_port_attrs.firmware_version,
			val->FirmwareVersion,
			sizeof (val->FirmwareVersion));
		val->VendorSpecificID =
			port->fp_hba_port_attrs.vendor_specific_id;
		bcopy(&port->fp_service_params.node_ww_name.raw_wwn,
			&val->NodeWWN.raw_wwn,
			sizeof (val->NodeWWN.raw_wwn));


		bcopy(port->fp_hba_port_attrs.driver_name,
			val->DriverName,
			sizeof (val->DriverName));
		bcopy(port->fp_hba_port_attrs.driver_version,
			val->DriverVersion,
			sizeof (val->DriverVersion));
		mutex_exit(&port->fp_mutex);

		if (fcio->fcio_cmd == FCIO_GET_ADAPTER_ATTRIBUTES) {
			val->NumberOfPorts = fctl_count_fru_ports(port, 0);
		} else {
			val->NumberOfPorts = fctl_count_fru_ports(port, 1);
		}

		if (use32 == B_TRUE) {
			val32 = kmem_zalloc(sizeof (*val32), KM_SLEEP);
			val32->version = val->version;
			bcopy(val->Manufacturer, val32->Manufacturer,
				sizeof (val->Manufacturer));
			bcopy(val->SerialNumber, val32->SerialNumber,
				sizeof (val->SerialNumber));
			bcopy(val->Model, val32->Model,
				sizeof (val->Model));
			bcopy(val->ModelDescription, val32->ModelDescription,
				sizeof (val->ModelDescription));
			bcopy(val->NodeSymbolicName, val32->NodeSymbolicName,
			    sizeof (val->NodeSymbolicName));
			bcopy(val->HardwareVersion, val32->HardwareVersion,
				sizeof (val->HardwareVersion));
			bcopy(val->OptionROMVersion, val32->OptionROMVersion,
				sizeof (val->OptionROMVersion));
			bcopy(val->FirmwareVersion, val32->FirmwareVersion,
				sizeof (val->FirmwareVersion));
			val32->VendorSpecificID = val->VendorSpecificID;
			bcopy(&val->NodeWWN.raw_wwn, &val32->NodeWWN.raw_wwn,
				sizeof (val->NodeWWN.raw_wwn));
			bcopy(val->DriverName, val32->DriverName,
				sizeof (val->DriverName));
			bcopy(val->DriverVersion, val32->DriverVersion,
				sizeof (val->DriverVersion));

			val32->NumberOfPorts = val->NumberOfPorts;

			if (fp_copyout((void *)val32, (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}

			kmem_free(val32, sizeof (*val32));
		} else {
			if (fp_copyout((void *)val, (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		}

		kmem_free(val, sizeof (*val));
		break;
	}

	case FCIO_GET_NPIV_ATTRIBUTES: {
		fc_hba_npiv_attributes_t *attrs;

		attrs = kmem_zalloc(sizeof (*attrs), KM_SLEEP);
		mutex_enter(&port->fp_mutex);
		bcopy(&port->fp_service_params.node_ww_name.raw_wwn,
		    &attrs->NodeWWN.raw_wwn,
		    sizeof (attrs->NodeWWN.raw_wwn));
		bcopy(&port->fp_service_params.nport_ww_name.raw_wwn,
		    &attrs->PortWWN.raw_wwn,
		    sizeof (attrs->PortWWN.raw_wwn));
		mutex_exit(&port->fp_mutex);
		if (fp_copyout((void *)attrs, (void *)fcio->fcio_obuf,
		    fcio->fcio_olen, mode) == 0) {
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		} else {
			rval = EFAULT;
		}
		kmem_free(attrs, sizeof (*attrs));
		break;
	}

	case FCIO_DELETE_NPIV_PORT: {
		fc_local_port_t *tmpport;
		char	ww_pname[17];
		la_wwn_t	vwwn[1];

		FP_TRACE(FP_NHEAD1(1, 0), "Delete NPIV Port");
		if (ddi_copyin(fcio->fcio_ibuf,
		    &vwwn, sizeof (la_wwn_t), mode)) {
			rval = EFAULT;
			break;
		}

		fc_wwn_to_str(&vwwn[0], ww_pname);
		FP_TRACE(FP_NHEAD1(3, 0),
		    "Delete NPIV Port %s", ww_pname);
		tmpport = fc_delete_npiv_port(port, &vwwn[0]);
		if (tmpport == NULL) {
			FP_TRACE(FP_NHEAD1(3, 0),
			    "Delete NPIV Port : no found");
			rval = EFAULT;
		} else {
			fc_local_port_t *nextport = tmpport->fp_port_next;
			fc_local_port_t *prevport = tmpport->fp_port_prev;
			int portlen, portindex, ret;

			portlen = sizeof (portindex);
			ret = ddi_prop_op(DDI_DEV_T_ANY,
			    tmpport->fp_port_dip, PROP_LEN_AND_VAL_BUF,
			    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "port",
			    (caddr_t)&portindex, &portlen);
			if (ret != DDI_SUCCESS) {
				rval = EFAULT;
				break;
			}
			if (ndi_devi_offline(tmpport->fp_port_dip,
			    NDI_DEVI_REMOVE) != DDI_SUCCESS) {
				FP_TRACE(FP_NHEAD1(1, 0),
				    "Delete NPIV Port failed");
				mutex_enter(&port->fp_mutex);
				tmpport->fp_npiv_state = 0;
				mutex_exit(&port->fp_mutex);
				rval = EFAULT;
			} else {
				mutex_enter(&port->fp_mutex);
				nextport->fp_port_prev = prevport;
				prevport->fp_port_next = nextport;
				if (port == port->fp_port_next) {
					port->fp_port_next =
					    port->fp_port_prev = NULL;
				}
				port->fp_npiv_portnum--;
				FP_TRACE(FP_NHEAD1(3, 0),
				    "Delete NPIV Port %d", portindex);
				port->fp_npiv_portindex[portindex-1] = 0;
				mutex_exit(&port->fp_mutex);
			}
		}
		break;
	}

	case FCIO_CREATE_NPIV_PORT: {
		char ww_nname[17], ww_pname[17];
		la_npiv_create_entry_t entrybuf;
		uint32_t vportindex = 0;
		int npiv_ret = 0;
		char *portname, *fcaname;

		portname = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
		(void) ddi_pathname(port->fp_port_dip, portname);
		fcaname = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
		(void) ddi_pathname(port->fp_fca_dip, fcaname);
		FP_TRACE(FP_NHEAD1(1, 0),
		    "Create NPIV port %s %s %s", portname, fcaname,
		    ddi_driver_name(port->fp_fca_dip));
		kmem_free(portname, MAXPATHLEN);
		kmem_free(fcaname, MAXPATHLEN);
		if (ddi_copyin(fcio->fcio_ibuf,
		    &entrybuf, sizeof (la_npiv_create_entry_t), mode)) {
			rval = EFAULT;
			break;
		}

		fc_wwn_to_str(&entrybuf.VNodeWWN, ww_nname);
		fc_wwn_to_str(&entrybuf.VPortWWN, ww_pname);
		vportindex = entrybuf.vindex;
		FP_TRACE(FP_NHEAD1(3, 0),
		    "Create NPIV Port %s %s %d",
		    ww_nname, ww_pname, vportindex);

		if (fc_get_npiv_port(port, &entrybuf.VPortWWN)) {
			rval = EFAULT;
			break;
		}
		npiv_ret = fctl_fca_create_npivport(port->fp_fca_dip,
		    port->fp_port_dip, ww_nname, ww_pname, &vportindex);
		if (npiv_ret == NDI_SUCCESS) {
			mutex_enter(&port->fp_mutex);
			port->fp_npiv_portnum++;
			mutex_exit(&port->fp_mutex);
			if (fp_copyout((void *)&vportindex,
			    (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		} else {
			rval = EFAULT;
		}
		FP_TRACE(FP_NHEAD1(3, 0),
		    "Create NPIV Port %d %d", npiv_ret, vportindex);
		break;
	}

	case FCIO_GET_NPIV_PORT_LIST: {
		fc_hba_npiv_port_list_t *list;
		int count;

		if ((fcio->fcio_xfer != FCIO_XFER_READ) ||
		    (fcio->fcio_olen == 0) || (fcio->fcio_obuf == 0)) {
			rval = EINVAL;
			break;
		}

		list = kmem_zalloc(fcio->fcio_olen, KM_SLEEP);
		list->version = FC_HBA_LIST_VERSION;
		/* build npiv port list */
		count = fc_ulp_get_npiv_port_list(port, (char *)list->hbaPaths);
		if (count < 0) {
			rval = ENXIO;
			FP_TRACE(FP_NHEAD1(1, 0), "Build NPIV Port List error");
			kmem_free(list, fcio->fcio_olen);
			break;
		}
		list->numAdapters = count;

		if (fp_copyout((void *)list, (void *)fcio->fcio_obuf,
		    fcio->fcio_olen, mode) == 0) {
			if (fp_fcio_copyout(fcio, data, mode)) {
				FP_TRACE(FP_NHEAD1(1, 0),
				    "Copy NPIV Port data error");
				rval = EFAULT;
			}
		} else {
			FP_TRACE(FP_NHEAD1(1, 0), "Copy NPIV Port List error");
			rval = EFAULT;
		}
		kmem_free(list, fcio->fcio_olen);
		break;
	}

	case FCIO_GET_ADAPTER_PORT_NPIV_ATTRIBUTES: {
		fc_hba_port_npiv_attributes_t   *val;

		val = kmem_zalloc(sizeof (*val), KM_SLEEP);
		val->version = FC_HBA_PORT_NPIV_ATTRIBUTES_VERSION;

		mutex_enter(&port->fp_mutex);
		val->npivflag = port->fp_npiv_flag;
		val->lastChange = port->fp_last_change;
		bcopy(&port->fp_service_params.nport_ww_name.raw_wwn,
		    &val->PortWWN.raw_wwn,
		    sizeof (val->PortWWN.raw_wwn));
		bcopy(&port->fp_service_params.node_ww_name.raw_wwn,
		    &val->NodeWWN.raw_wwn,
		    sizeof (val->NodeWWN.raw_wwn));
		mutex_exit(&port->fp_mutex);

		val->NumberOfNPIVPorts = fc_ulp_get_npiv_port_num(port);
		if (port->fp_npiv_type != FC_NPIV_PORT) {
			val->MaxNumberOfNPIVPorts =
			    port->fp_fca_tran->fca_num_npivports;
		} else {
			val->MaxNumberOfNPIVPorts = 0;
		}

		if (fp_copyout((void *)val, (void *)fcio->fcio_obuf,
		    fcio->fcio_olen, mode) == 0) {
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		} else {
			rval = EFAULT;
		}
		kmem_free(val, sizeof (*val));
		break;
	}

	case FCIO_GET_ADAPTER_PORT_ATTRIBUTES: {
		fc_hba_port_attributes_t	*val;
		fc_hba_port_attributes32_t	*val32;

		if (use32 == B_TRUE) {
			if (fcio->fcio_olen < sizeof (*val32) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		} else {
			if (fcio->fcio_olen < sizeof (*val) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		}

		val = kmem_zalloc(sizeof (*val), KM_SLEEP);
		val->version = FC_HBA_PORT_ATTRIBUTES_VERSION;
		mutex_enter(&port->fp_mutex);
		val->lastChange = port->fp_last_change;
		val->fp_minor = port->fp_instance;

		bcopy(&port->fp_service_params.nport_ww_name.raw_wwn,
		    &val->PortWWN.raw_wwn,
		    sizeof (val->PortWWN.raw_wwn));
		bcopy(&port->fp_service_params.node_ww_name.raw_wwn,
		    &val->NodeWWN.raw_wwn,
		    sizeof (val->NodeWWN.raw_wwn));
		bcopy(&port->fp_fabric_name, &val->FabricName.raw_wwn,
		    sizeof (val->FabricName.raw_wwn));

		val->PortFcId = port->fp_port_id.port_id;

		switch (FC_PORT_STATE_MASK(port->fp_state)) {
		case FC_STATE_OFFLINE:
		    val->PortState = FC_HBA_PORTSTATE_OFFLINE;
		    break;
		case FC_STATE_ONLINE:
		case FC_STATE_LOOP:
		case FC_STATE_NAMESERVICE:
		    val->PortState = FC_HBA_PORTSTATE_ONLINE;
		    break;
		default:
		    val->PortState = FC_HBA_PORTSTATE_UNKNOWN;
		    break;
		}

		/* Translate from LV to FC-HBA port type codes */
		switch (port->fp_port_type.port_type) {
		case FC_NS_PORT_N:
		    val->PortType = FC_HBA_PORTTYPE_NPORT;
		    break;
		case FC_NS_PORT_NL: /* Actually means loop for us */
		    val->PortType = FC_HBA_PORTTYPE_LPORT;
		    break;
		case FC_NS_PORT_F:
		    val->PortType = FC_HBA_PORTTYPE_FPORT;
		    break;
		case FC_NS_PORT_FL:
		    val->PortType = FC_HBA_PORTTYPE_FLPORT;
		    break;
		case FC_NS_PORT_E:
		    val->PortType = FC_HBA_PORTTYPE_EPORT;
		    break;
		default:
		    val->PortType = FC_HBA_PORTTYPE_OTHER;
		    break;
		}


		/*
		 * If fp has decided that the topology is public loop,
		 * we will indicate that using the appropriate
		 * FC HBA API constant.
		 */
		switch (port->fp_topology) {
		case FC_TOP_PUBLIC_LOOP:
			val->PortType = FC_HBA_PORTTYPE_NLPORT;
			break;

		case FC_TOP_PT_PT:
			val->PortType = FC_HBA_PORTTYPE_PTP;
			break;

		case FC_TOP_UNKNOWN:
			/*
			 * This should cover the case where nothing is connected
			 * to the port. Crystal+ is p'bly an exception here.
			 * For Crystal+, port 0 will come up as private loop
			 * (i.e fp_bind_state will be FC_STATE_LOOP) even when
			 * nothing is connected to it.
			 * Current plan is to let userland handle this.
			 */
			if (port->fp_bind_state == FC_STATE_OFFLINE)
				val->PortType = FC_HBA_PORTTYPE_UNKNOWN;
			break;

		default:
			/*
			 * Do Nothing.
			 * Unused:
			 *   val->PortType = FC_HBA_PORTTYPE_GPORT;
			 */
			break;
		}

		val->PortSupportedClassofService =
			port->fp_hba_port_attrs.supported_cos;
		val->PortSupportedFc4Types[0] = 0;
		bcopy(port->fp_fc4_types, val->PortActiveFc4Types,
		    sizeof (val->PortActiveFc4Types));
		bcopy(port->fp_sym_port_name, val->PortSymbolicName,
		    sizeof (val->PortSymbolicName));
		val->PortSupportedSpeed =
			port->fp_hba_port_attrs.supported_speed;

		switch (FC_PORT_SPEED_MASK(port->fp_state)) {
		case FC_STATE_1GBIT_SPEED:
		    val->PortSpeed = FC_HBA_PORTSPEED_1GBIT;
		    break;
		case FC_STATE_2GBIT_SPEED:
		    val->PortSpeed = FC_HBA_PORTSPEED_2GBIT;
		    break;
		case FC_STATE_4GBIT_SPEED:
		    val->PortSpeed = FC_HBA_PORTSPEED_4GBIT;
		    break;
		case FC_STATE_8GBIT_SPEED:
		    val->PortSpeed = FC_HBA_PORTSPEED_8GBIT;
		    break;
		case FC_STATE_10GBIT_SPEED:
		    val->PortSpeed = FC_HBA_PORTSPEED_10GBIT;
		    break;
		case FC_STATE_16GBIT_SPEED:
		    val->PortSpeed = FC_HBA_PORTSPEED_16GBIT;
		    break;
		default:
		    val->PortSpeed = FC_HBA_PORTSPEED_UNKNOWN;
		    break;
		}
		val->PortMaxFrameSize = port->fp_hba_port_attrs.max_frame_size;
		val->NumberofDiscoveredPorts = port->fp_dev_count;
		mutex_exit(&port->fp_mutex);

		if (use32 == B_TRUE) {
			val32 = kmem_zalloc(sizeof (*val32), KM_SLEEP);
			val32->version = val->version;
			val32->lastChange = val->lastChange;
			val32->fp_minor = val->fp_minor;

			bcopy(&val->PortWWN.raw_wwn, &val32->PortWWN.raw_wwn,
				sizeof (val->PortWWN.raw_wwn));
			bcopy(&val->NodeWWN.raw_wwn, &val32->NodeWWN.raw_wwn,
				sizeof (val->NodeWWN.raw_wwn));
			val32->PortFcId = val->PortFcId;
			val32->PortState = val->PortState;
			val32->PortType = val->PortType;

			val32->PortSupportedClassofService =
			    val->PortSupportedClassofService;
			bcopy(val->PortActiveFc4Types,
			    val32->PortActiveFc4Types,
			    sizeof (val->PortActiveFc4Types));
			bcopy(val->PortSymbolicName, val32->PortSymbolicName,
			    sizeof (val->PortSymbolicName));
			bcopy(&val->FabricName, &val32->FabricName,
			    sizeof (val->FabricName.raw_wwn));
			val32->PortSupportedSpeed = val->PortSupportedSpeed;
			val32->PortSpeed = val->PortSpeed;

			val32->PortMaxFrameSize = val->PortMaxFrameSize;
			val32->NumberofDiscoveredPorts =
			    val->NumberofDiscoveredPorts;

			if (fp_copyout((void *)val32, (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}

			kmem_free(val32, sizeof (*val32));
		} else {
			if (fp_copyout((void *)val, (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		}

		kmem_free(val, sizeof (*val));
		break;
	}

	case FCIO_GET_DISCOVERED_PORT_ATTRIBUTES: {
		fc_hba_port_attributes_t	*val;
		fc_hba_port_attributes32_t	*val32;
		uint32_t	index = 0;
		fc_remote_port_t *tmp_pd;

		if (use32 == B_TRUE) {
			if (fcio->fcio_olen < sizeof (*val32) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		} else {
			if (fcio->fcio_olen < sizeof (*val) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		}

		if (ddi_copyin(fcio->fcio_ibuf, &index, sizeof (index), mode)) {
			rval = EFAULT;
			break;
		}

		if (index >= port->fp_dev_count) {
			FP_TRACE(FP_NHEAD1(9, 0),
			    "User supplied index out of range");
			fcio->fcio_errno = FC_OUTOFBOUNDS;
			rval = EINVAL;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}

		val = kmem_zalloc(sizeof (*val), KM_SLEEP);
		val->version = FC_HBA_PORT_ATTRIBUTES_VERSION;

		mutex_enter(&port->fp_mutex);
		tmp_pd = fctl_lookup_pd_by_index(port, index);

		if (tmp_pd == NULL) {
			fcio->fcio_errno = FC_BADPORT;
			rval = EINVAL;
		} else {
			val->lastChange = port->fp_last_change;
			val->fp_minor = port->fp_instance;

			mutex_enter(&tmp_pd->pd_mutex);
			bcopy(&tmp_pd->pd_port_name.raw_wwn,
			    &val->PortWWN.raw_wwn,
			    sizeof (val->PortWWN.raw_wwn));
			bcopy(&tmp_pd->pd_remote_nodep->fd_node_name.raw_wwn,
			    &val->NodeWWN.raw_wwn,
			    sizeof (val->NodeWWN.raw_wwn));
			val->PortFcId = tmp_pd->pd_port_id.port_id;
			bcopy(tmp_pd->pd_spn, val->PortSymbolicName,
			    sizeof (val->PortSymbolicName));
			val->PortSupportedClassofService = tmp_pd->pd_cos;
			/*
			 * we will assume the sizeof these pd_fc4types and
			 * portActiveFc4Types will remain the same.  we could
			 * add in a check for it, but we decided it was unneeded
			 */
			bcopy((caddr_t)tmp_pd->pd_fc4types,
			    val->PortActiveFc4Types,
			    sizeof (tmp_pd->pd_fc4types));
			val->PortState =
			    fp_map_remote_port_state(tmp_pd->pd_state);
			mutex_exit(&tmp_pd->pd_mutex);

			val->PortType = FC_HBA_PORTTYPE_UNKNOWN;
			val->PortSupportedFc4Types[0] = 0;
			val->PortSupportedSpeed = FC_HBA_PORTSPEED_UNKNOWN;
			val->PortSpeed = FC_HBA_PORTSPEED_UNKNOWN;
			val->PortMaxFrameSize = 0;
			val->NumberofDiscoveredPorts = 0;

			if (use32 == B_TRUE) {
				val32 = kmem_zalloc(sizeof (*val32), KM_SLEEP);
				val32->version = val->version;
				val32->lastChange = val->lastChange;
				val32->fp_minor = val->fp_minor;

				bcopy(&val->PortWWN.raw_wwn,
				    &val32->PortWWN.raw_wwn,
				    sizeof (val->PortWWN.raw_wwn));
				bcopy(&val->NodeWWN.raw_wwn,
				    &val32->NodeWWN.raw_wwn,
				    sizeof (val->NodeWWN.raw_wwn));
				val32->PortFcId = val->PortFcId;
				bcopy(val->PortSymbolicName,
				    val32->PortSymbolicName,
				    sizeof (val->PortSymbolicName));
				val32->PortSupportedClassofService =
				    val->PortSupportedClassofService;
				bcopy(val->PortActiveFc4Types,
				    val32->PortActiveFc4Types,
				    sizeof (tmp_pd->pd_fc4types));

				val32->PortType = val->PortType;
				val32->PortState = val->PortState;
				val32->PortSupportedFc4Types[0] =
				    val->PortSupportedFc4Types[0];
				val32->PortSupportedSpeed =
				    val->PortSupportedSpeed;
				val32->PortSpeed = val->PortSpeed;
				val32->PortMaxFrameSize =
				    val->PortMaxFrameSize;
				val32->NumberofDiscoveredPorts =
				    val->NumberofDiscoveredPorts;

				if (fp_copyout((void *)val32,
				    (void *)fcio->fcio_obuf,
				    fcio->fcio_olen, mode) == 0) {
					    if (fp_fcio_copyout(fcio,
						data, mode)) {
						    rval = EFAULT;
					    }
				} else {
					rval = EFAULT;
				}

				kmem_free(val32, sizeof (*val32));
			} else {
				if (fp_copyout((void *)val,
				    (void *)fcio->fcio_obuf,
				    fcio->fcio_olen, mode) == 0) {
					if (fp_fcio_copyout(fcio, data, mode)) {
						rval = EFAULT;
					}
				} else {
					rval = EFAULT;
				}
			}
		}

		mutex_exit(&port->fp_mutex);
		kmem_free(val, sizeof (*val));
		break;
	}

	case FCIO_GET_PORT_ATTRIBUTES: {
		fc_hba_port_attributes_t    *val;
		fc_hba_port_attributes32_t  *val32;
		la_wwn_t		    wwn;
		fc_remote_port_t	    *tmp_pd;

		if (use32 == B_TRUE) {
			if (fcio->fcio_olen < sizeof (*val32) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		} else {
			if (fcio->fcio_olen < sizeof (*val) ||
			    fcio->fcio_xfer != FCIO_XFER_READ) {
				rval = EINVAL;
				break;
			}
		}

		if (ddi_copyin(fcio->fcio_ibuf, &wwn, sizeof (wwn), mode)) {
			rval = EFAULT;
			break;
		}

		val = kmem_zalloc(sizeof (*val), KM_SLEEP);
		val->version = FC_HBA_PORT_ATTRIBUTES_VERSION;

		mutex_enter(&port->fp_mutex);
		tmp_pd = fctl_lookup_pd_by_wwn(port, wwn);
		val->lastChange = port->fp_last_change;
		val->fp_minor = port->fp_instance;
		mutex_exit(&port->fp_mutex);

		if (tmp_pd == NULL) {
			fcio->fcio_errno = FC_BADWWN;
			rval = EINVAL;
		} else {
			mutex_enter(&tmp_pd->pd_mutex);
			bcopy(&tmp_pd->pd_port_name.raw_wwn,
			    &val->PortWWN.raw_wwn,
			    sizeof (val->PortWWN.raw_wwn));
			bcopy(&tmp_pd->pd_remote_nodep->fd_node_name.raw_wwn,
			    &val->NodeWWN.raw_wwn,
			    sizeof (val->NodeWWN.raw_wwn));
			val->PortFcId = tmp_pd->pd_port_id.port_id;
			bcopy(tmp_pd->pd_spn, val->PortSymbolicName,
			    sizeof (val->PortSymbolicName));
			val->PortSupportedClassofService = tmp_pd->pd_cos;
			val->PortType = FC_HBA_PORTTYPE_UNKNOWN;
			val->PortState =
			    fp_map_remote_port_state(tmp_pd->pd_state);
			val->PortSupportedFc4Types[0] = 0;
			/*
			 * we will assume the sizeof these pd_fc4types and
			 * portActiveFc4Types will remain the same.  we could
			 * add in a check for it, but we decided it was unneeded
			 */
			bcopy((caddr_t)tmp_pd->pd_fc4types,
			    val->PortActiveFc4Types,
			    sizeof (tmp_pd->pd_fc4types));
			val->PortSupportedSpeed = FC_HBA_PORTSPEED_UNKNOWN;
			val->PortSpeed = FC_HBA_PORTSPEED_UNKNOWN;
			val->PortMaxFrameSize = 0;
			val->NumberofDiscoveredPorts = 0;
			mutex_exit(&tmp_pd->pd_mutex);

			if (use32 == B_TRUE) {
				val32 = kmem_zalloc(sizeof (*val32), KM_SLEEP);
				val32->version = val->version;
				val32->lastChange = val->lastChange;
				val32->fp_minor = val->fp_minor;
				bcopy(&val->PortWWN.raw_wwn,
				    &val32->PortWWN.raw_wwn,
				    sizeof (val->PortWWN.raw_wwn));
				bcopy(&val->NodeWWN.raw_wwn,
				    &val32->NodeWWN.raw_wwn,
				    sizeof (val->NodeWWN.raw_wwn));
				val32->PortFcId = val->PortFcId;
				bcopy(val->PortSymbolicName,
				    val32->PortSymbolicName,
				    sizeof (val->PortSymbolicName));
				val32->PortSupportedClassofService =
				    val->PortSupportedClassofService;
				val32->PortType = val->PortType;
				val32->PortState = val->PortState;
				val32->PortSupportedFc4Types[0] =
				    val->PortSupportedFc4Types[0];
				bcopy(val->PortActiveFc4Types,
				    val32->PortActiveFc4Types,
				    sizeof (tmp_pd->pd_fc4types));
				val32->PortSupportedSpeed =
				    val->PortSupportedSpeed;
				val32->PortSpeed = val->PortSpeed;
				val32->PortMaxFrameSize = val->PortMaxFrameSize;
				val32->NumberofDiscoveredPorts =
				    val->NumberofDiscoveredPorts;

				if (fp_copyout((void *)val32,
				    (void *)fcio->fcio_obuf,
				    fcio->fcio_olen, mode) == 0) {
					if (fp_fcio_copyout(fcio, data, mode)) {
						rval = EFAULT;
					}
				} else {
					rval = EFAULT;
				}

				kmem_free(val32, sizeof (*val32));
			} else {
				if (fp_copyout((void *)val,
				    (void *)fcio->fcio_obuf,
				    fcio->fcio_olen, mode) == 0) {
					if (fp_fcio_copyout(fcio, data, mode)) {
						rval = EFAULT;
					}
				} else {
					rval = EFAULT;
				}
			}
		}
		kmem_free(val, sizeof (*val));
		break;
	}

	case FCIO_GET_NUM_DEVS: {
		int num_devices;

		if (fcio->fcio_olen != sizeof (num_devices) ||
		    fcio->fcio_xfer != FCIO_XFER_READ) {
			rval = EINVAL;
			break;
		}

		mutex_enter(&port->fp_mutex);
		switch (port->fp_topology) {
		case FC_TOP_PRIVATE_LOOP:
		case FC_TOP_PT_PT:
			num_devices = port->fp_total_devices;
			fcio->fcio_errno = FC_SUCCESS;
			break;

		case FC_TOP_PUBLIC_LOOP:
		case FC_TOP_FABRIC:
			mutex_exit(&port->fp_mutex);
			job = fctl_alloc_job(JOB_NS_CMD, 0, NULL,
			    NULL, KM_SLEEP);
			ASSERT(job != NULL);

			/*
			 * In FC-GS-2 the Name Server doesn't send out
			 * RSCNs for any Name Server Database updates
			 * When it is finally fixed there is no need
			 * to probe as below and should be removed.
			 */
			(void) fp_ns_get_devcount(port, job, 0, KM_SLEEP);
			fctl_dealloc_job(job);

			mutex_enter(&port->fp_mutex);
			num_devices = port->fp_total_devices;
			fcio->fcio_errno = FC_SUCCESS;
			break;

		case FC_TOP_NO_NS:
			/* FALLTHROUGH */
		case FC_TOP_UNKNOWN:
			/* FALLTHROUGH */
		default:
			num_devices = 0;
			fcio->fcio_errno = FC_SUCCESS;
			break;
		}
		mutex_exit(&port->fp_mutex);

		if (fp_copyout((void *)&num_devices,
		    (void *)fcio->fcio_obuf, fcio->fcio_olen,
		    mode) == 0) {
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		} else {
			rval = EFAULT;
		}
		break;
	}

	case FCIO_GET_DEV_LIST: {
		int num_devices;
		int new_count;
		int map_size;

		if (fcio->fcio_xfer != FCIO_XFER_READ ||
		    fcio->fcio_alen != sizeof (new_count)) {
			rval = EINVAL;
			break;
		}

		num_devices = fcio->fcio_olen / sizeof (fc_port_dev_t);

		mutex_enter(&port->fp_mutex);
		if (num_devices < port->fp_total_devices) {
			fcio->fcio_errno = FC_TOOMANY;
			new_count = port->fp_total_devices;
			mutex_exit(&port->fp_mutex);

			if (fp_copyout((void *)&new_count,
			    (void *)fcio->fcio_abuf,
			    sizeof (new_count), mode)) {
				rval = EFAULT;
				break;
			}

			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
				break;
			}
			rval = EINVAL;
			break;
		}

		if (port->fp_total_devices <= 0) {
			fcio->fcio_errno = FC_NO_MAP;
			new_count = port->fp_total_devices;
			mutex_exit(&port->fp_mutex);

			if (fp_copyout((void *)&new_count,
			    (void *)fcio->fcio_abuf,
			    sizeof (new_count), mode)) {
				rval = EFAULT;
				break;
			}

			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
				break;
			}
			rval = EINVAL;
			break;
		}

		switch (port->fp_topology) {
		case FC_TOP_PRIVATE_LOOP:
			if (fp_fillout_loopmap(port, fcio,
			    mode) != FC_SUCCESS) {
				rval = EFAULT;
				break;
			}
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;

		case FC_TOP_PT_PT:
			if (fp_fillout_p2pmap(port, fcio,
			    mode) != FC_SUCCESS) {
				rval = EFAULT;
				break;
			}
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;

		case FC_TOP_PUBLIC_LOOP:
		case FC_TOP_FABRIC: {
			fctl_ns_req_t *ns_cmd;

			map_size =
			    sizeof (fc_port_dev_t) * port->fp_total_devices;

			mutex_exit(&port->fp_mutex);

			ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gan_t),
			    sizeof (ns_resp_gan_t), map_size,
			    (FCTL_NS_FILL_NS_MAP | FCTL_NS_BUF_IS_USERLAND),
			    KM_SLEEP);
			ASSERT(ns_cmd != NULL);

			ns_cmd->ns_gan_index = 0;
			ns_cmd->ns_gan_sid = FCTL_GAN_START_ID;
			ns_cmd->ns_cmd_code = NS_GA_NXT;
			ns_cmd->ns_gan_max = map_size / sizeof (fc_port_dev_t);

			job = fctl_alloc_job(JOB_PORT_GETMAP, 0, NULL,
			    NULL, KM_SLEEP);
			ASSERT(job != NULL);

			ret = fp_ns_query(port, ns_cmd, job, 1, KM_SLEEP);

			if (ret != FC_SUCCESS ||
			    job->job_result != FC_SUCCESS) {
				fctl_free_ns_cmd(ns_cmd);

				fcio->fcio_errno = job->job_result;
				new_count = 0;
				if (fp_copyout((void *)&new_count,
				    (void *)fcio->fcio_abuf,
				    sizeof (new_count), mode)) {
					fctl_dealloc_job(job);
					mutex_enter(&port->fp_mutex);
					rval = EFAULT;
					break;
				}

				if (fp_fcio_copyout(fcio, data, mode)) {
					fctl_dealloc_job(job);
					mutex_enter(&port->fp_mutex);
					rval = EFAULT;
					break;
				}
				rval = EIO;
				mutex_enter(&port->fp_mutex);
				break;
			}
			fctl_dealloc_job(job);

			new_count = ns_cmd->ns_gan_index;
			if (fp_copyout((void *)&new_count,
			    (void *)fcio->fcio_abuf, sizeof (new_count),
			    mode)) {
				rval = EFAULT;
				fctl_free_ns_cmd(ns_cmd);
				mutex_enter(&port->fp_mutex);
				break;
			}

			if (fp_copyout((void *)ns_cmd->ns_data_buf,
			    (void *)fcio->fcio_obuf, sizeof (fc_port_dev_t) *
			    ns_cmd->ns_gan_index, mode)) {
				rval = EFAULT;
				fctl_free_ns_cmd(ns_cmd);
				mutex_enter(&port->fp_mutex);
				break;
			}
			fctl_free_ns_cmd(ns_cmd);

			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			mutex_enter(&port->fp_mutex);
			break;
		}

		case FC_TOP_NO_NS:
			/* FALLTHROUGH */
		case FC_TOP_UNKNOWN:
			/* FALLTHROUGH */
		default:
			fcio->fcio_errno = FC_NO_MAP;
			num_devices = port->fp_total_devices;

			if (fp_copyout((void *)&new_count,
			    (void *)fcio->fcio_abuf,
			    sizeof (new_count), mode)) {
				rval = EFAULT;
				break;
			}

			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
				break;
			}
			rval = EINVAL;
			break;
		}
		mutex_exit(&port->fp_mutex);
		break;
	}

	case FCIO_GET_SYM_PNAME: {
		rval = ENOTSUP;
		break;
	}

	case FCIO_GET_SYM_NNAME: {
		rval = ENOTSUP;
		break;
	}

	case FCIO_SET_SYM_PNAME: {
		rval = ENOTSUP;
		break;
	}

	case FCIO_SET_SYM_NNAME: {
		rval = ENOTSUP;
		break;
	}

	case FCIO_GET_LOGI_PARAMS: {
		la_wwn_t		pwwn;
		la_wwn_t		*my_pwwn;
		la_els_logi_t		*params;
		la_els_logi32_t		*params32;
		fc_remote_node_t	*node;
		fc_remote_port_t	*pd;

		if (fcio->fcio_ilen != sizeof (la_wwn_t) ||
		    (fcio->fcio_xfer & FCIO_XFER_READ) == 0 ||
		    (fcio->fcio_xfer & FCIO_XFER_WRITE) == 0) {
			rval = EINVAL;
			break;
		}

		if (use32 == B_TRUE) {
			if (fcio->fcio_olen != sizeof (la_els_logi32_t)) {
				rval = EINVAL;
				break;
			}
		} else {
			if (fcio->fcio_olen != sizeof (la_els_logi_t)) {
				rval = EINVAL;
				break;
			}
		}

		if (ddi_copyin(fcio->fcio_ibuf, &pwwn, sizeof (pwwn), mode)) {
			rval = EFAULT;
			break;
		}

		pd = fctl_hold_remote_port_by_pwwn(port, &pwwn);
		if (pd == NULL) {
			mutex_enter(&port->fp_mutex);
			my_pwwn = &port->fp_service_params.nport_ww_name;
			mutex_exit(&port->fp_mutex);

			if (fctl_wwn_cmp(&pwwn, my_pwwn) != 0) {
				rval = ENXIO;
				break;
			}

			params = kmem_zalloc(sizeof (*params), KM_SLEEP);
			mutex_enter(&port->fp_mutex);
			*params = port->fp_service_params;
			mutex_exit(&port->fp_mutex);
		} else {
			params = kmem_zalloc(sizeof (*params), KM_SLEEP);

			mutex_enter(&pd->pd_mutex);
			params->ls_code.mbz = params->ls_code.ls_code = 0;
			params->common_service = pd->pd_csp;
			params->nport_ww_name = pd->pd_port_name;
			params->class_1 = pd->pd_clsp1;
			params->class_2 = pd->pd_clsp2;
			params->class_3 = pd->pd_clsp3;
			node = pd->pd_remote_nodep;
			mutex_exit(&pd->pd_mutex);

			bzero(params->reserved, sizeof (params->reserved));

			mutex_enter(&node->fd_mutex);
			bcopy(node->fd_vv, params->vendor_version,
			    sizeof (node->fd_vv));
			params->node_ww_name = node->fd_node_name;
			mutex_exit(&node->fd_mutex);

			fctl_release_remote_port(pd);
		}

		if (use32 == B_TRUE) {
			params32 = kmem_zalloc(sizeof (*params32), KM_SLEEP);

			params32->ls_code.mbz = params->ls_code.mbz;
			params32->common_service = params->common_service;
			params32->nport_ww_name = params->nport_ww_name;
			params32->class_1 = params->class_1;
			params32->class_2 = params->class_2;
			params32->class_3 = params->class_3;
			bzero(params32->reserved, sizeof (params32->reserved));
			bcopy(params->vendor_version, params32->vendor_version,
			    sizeof (node->fd_vv));
			params32->node_ww_name = params->node_ww_name;

			if (ddi_copyout((void *)params32,
			    (void *)fcio->fcio_obuf,
			    sizeof (*params32), mode)) {
				rval = EFAULT;
			}

			kmem_free(params32, sizeof (*params32));
		} else {
			if (ddi_copyout((void *)params, (void *)fcio->fcio_obuf,
			    sizeof (*params), mode)) {
				rval = EFAULT;
			}
		}

		kmem_free(params, sizeof (*params));
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
		break;
	}

	case FCIO_DEV_LOGOUT:
	case FCIO_DEV_LOGIN:
		if (fcio->fcio_ilen != sizeof (la_wwn_t) ||
		    fcio->fcio_xfer != FCIO_XFER_WRITE) {
			rval = EINVAL;

			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}

		if (fcio->fcio_cmd == FCIO_DEV_LOGIN) {
			jcode = JOB_FCIO_LOGIN;
		} else {
			jcode = JOB_FCIO_LOGOUT;
		}

		kfcio = kmem_zalloc(sizeof (*kfcio), KM_SLEEP);
		bcopy(fcio, kfcio, sizeof (*fcio));

		if (kfcio->fcio_ilen) {
			kfcio->fcio_ibuf = kmem_zalloc(kfcio->fcio_ilen,
			    KM_SLEEP);

			if (ddi_copyin((void *)fcio->fcio_ibuf,
			    (void *)kfcio->fcio_ibuf, kfcio->fcio_ilen,
			    mode)) {
				rval = EFAULT;

				kmem_free(kfcio->fcio_ibuf, kfcio->fcio_ilen);
				kmem_free(kfcio, sizeof (*kfcio));
				fcio->fcio_errno = job->job_result;
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
				break;
			}
		}

		job = fctl_alloc_job(jcode, 0, NULL, NULL, KM_SLEEP);
		job->job_private = kfcio;

		fctl_enque_job(port, job);
		fctl_jobwait(job);

		rval = job->job_result;

		fcio->fcio_errno = kfcio->fcio_errno;
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}

		kmem_free(kfcio->fcio_ibuf, kfcio->fcio_ilen);
		kmem_free(kfcio, sizeof (*kfcio));
		fctl_dealloc_job(job);
		break;

	case FCIO_GET_STATE: {
		la_wwn_t		pwwn;
		uint32_t		state;
		fc_remote_port_t 	*pd;
		fctl_ns_req_t		*ns_cmd;

		if (fcio->fcio_ilen != sizeof (la_wwn_t) ||
		    fcio->fcio_olen != sizeof (state) ||
		    (fcio->fcio_xfer & FCIO_XFER_WRITE) == 0 ||
		    (fcio->fcio_xfer & FCIO_XFER_READ) == 0) {
			rval = EINVAL;
			break;
		}

		if (ddi_copyin(fcio->fcio_ibuf, &pwwn, sizeof (pwwn), mode)) {
			rval = EFAULT;
			break;
		}
		fcio->fcio_errno = 0;

		pd = fctl_hold_remote_port_by_pwwn(port, &pwwn);
		if (pd == NULL) {
			mutex_enter(&port->fp_mutex);
			if (FC_IS_TOP_SWITCH(port->fp_topology)) {
				mutex_exit(&port->fp_mutex);
				job = fctl_alloc_job(JOB_PLOGI_ONE, 0,
				    NULL, NULL, KM_SLEEP);

				job->job_counter = 1;
				job->job_result = FC_SUCCESS;

				ns_cmd = fctl_alloc_ns_cmd(
				    sizeof (ns_req_gid_pn_t),
				    sizeof (ns_resp_gid_pn_t),
				    sizeof (ns_resp_gid_pn_t),
				    FCTL_NS_BUF_IS_USERLAND, KM_SLEEP);
				ASSERT(ns_cmd != NULL);

				ns_cmd->ns_cmd_code = NS_GID_PN;
				((ns_req_gid_pn_t *)
				    (ns_cmd->ns_cmd_buf))->pwwn = pwwn;

				ret = fp_ns_query(port, ns_cmd, job,
				    1, KM_SLEEP);

				if (ret != FC_SUCCESS || job->job_result !=
				    FC_SUCCESS) {
					if (ret != FC_SUCCESS) {
						fcio->fcio_errno = ret;
					} else {
						fcio->fcio_errno =
						    job->job_result;
					}
					rval = EIO;
				} else {
					state = PORT_DEVICE_INVALID;
				}
				fctl_free_ns_cmd(ns_cmd);
				fctl_dealloc_job(job);
			} else {
				mutex_exit(&port->fp_mutex);
				fcio->fcio_errno = FC_BADWWN;
				rval = ENXIO;
			}
		} else {
			mutex_enter(&pd->pd_mutex);
			state = pd->pd_state;
			mutex_exit(&pd->pd_mutex);

			fctl_release_remote_port(pd);
		}

		if (!rval) {
			if (ddi_copyout((void *)&state,
			    (void *)fcio->fcio_obuf, sizeof (state),
			    mode)) {
				rval = EFAULT;
			}
		}
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
		break;
	}

	case FCIO_DEV_REMOVE: {
		la_wwn_t	pwwn;
		fc_portmap_t	*changelist;
		fc_remote_port_t *pd;

		if (fcio->fcio_ilen != sizeof (la_wwn_t) ||
		    fcio->fcio_xfer != FCIO_XFER_WRITE) {
			rval = EINVAL;
			break;
		}

		if (ddi_copyin(fcio->fcio_ibuf, &pwwn, sizeof (pwwn), mode)) {
			rval = EFAULT;
			break;
		}

		pd = fctl_hold_remote_port_by_pwwn(port, &pwwn);
		if (pd == NULL) {
			rval = ENXIO;
			fcio->fcio_errno = FC_BADWWN;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}

		mutex_enter(&pd->pd_mutex);
		if (pd->pd_ref_count > 1) {
			mutex_exit(&pd->pd_mutex);

			rval = EBUSY;
			fcio->fcio_errno = FC_FAILURE;
			fctl_release_remote_port(pd);

			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}
		mutex_exit(&pd->pd_mutex);

		changelist = kmem_zalloc(sizeof (*changelist), KM_SLEEP);

		fctl_copy_portmap(changelist, pd);
		changelist->map_type = PORT_DEVICE_USER_LOGOUT;
		(void) fp_ulp_devc_cb(port, changelist, 1, 1, KM_SLEEP, 1);

		fctl_release_remote_port(pd);
		break;
	}

	case FCIO_GET_FCODE_REV: {
		caddr_t 	fcode_rev;
		fc_fca_pm_t	pm;

		if (fcio->fcio_olen < FC_FCODE_REV_SIZE ||
		    fcio->fcio_xfer != FCIO_XFER_READ) {
			rval = EINVAL;
			break;
		}
		bzero((caddr_t)&pm, sizeof (pm));

		fcode_rev = kmem_zalloc(fcio->fcio_olen, KM_SLEEP);

		pm.pm_cmd_flags = FC_FCA_PM_READ;
		pm.pm_cmd_code = FC_PORT_GET_FCODE_REV;
		pm.pm_data_len = fcio->fcio_olen;
		pm.pm_data_buf = fcode_rev;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		if (ret == FC_SUCCESS) {
			if (ddi_copyout((void *)fcode_rev,
			    (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		} else {
			/*
			 * check if buffer was not large enough to obtain
			 * FCODE version.
			 */
			if (pm.pm_data_len > fcio->fcio_olen) {
				rval = ENOMEM;
			} else {
				rval = EIO;
			}
			fcio->fcio_errno = ret;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		kmem_free(fcode_rev, fcio->fcio_olen);
		break;
	}

	case FCIO_GET_FW_REV: {
		caddr_t 	fw_rev;
		fc_fca_pm_t	pm;

		if (fcio->fcio_olen < FC_FW_REV_SIZE ||
		    fcio->fcio_xfer != FCIO_XFER_READ) {
			rval = EINVAL;
			break;
		}
		bzero((caddr_t)&pm, sizeof (pm));

		fw_rev = kmem_zalloc(fcio->fcio_olen, KM_SLEEP);

		pm.pm_cmd_flags = FC_FCA_PM_READ;
		pm.pm_cmd_code = FC_PORT_GET_FW_REV;
		pm.pm_data_len = fcio->fcio_olen;
		pm.pm_data_buf = fw_rev;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		if (ret == FC_SUCCESS) {
			if (ddi_copyout((void *)fw_rev,
			    (void *)fcio->fcio_obuf,
			    fcio->fcio_olen, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		} else {
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			rval = EIO;
		}
		kmem_free(fw_rev, fcio->fcio_olen);
		break;
	}

	case FCIO_GET_DUMP_SIZE: {
		uint32_t 	dump_size;
		fc_fca_pm_t	pm;

		if (fcio->fcio_olen != sizeof (dump_size) ||
		    fcio->fcio_xfer != FCIO_XFER_READ) {
			rval = EINVAL;
			break;
		}
		bzero((caddr_t)&pm, sizeof (pm));
		pm.pm_cmd_flags = FC_FCA_PM_READ;
		pm.pm_cmd_code = FC_PORT_GET_DUMP_SIZE;
		pm.pm_data_len = sizeof (dump_size);
		pm.pm_data_buf = (caddr_t)&dump_size;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		if (ret == FC_SUCCESS) {
			if (ddi_copyout((void *)&dump_size,
			    (void *)fcio->fcio_obuf, sizeof (dump_size),
			    mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		} else {
			fcio->fcio_errno = ret;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		break;
	}

	case FCIO_DOWNLOAD_FW: {
		caddr_t		firmware;
		fc_fca_pm_t	pm;

		if (fcio->fcio_ilen <= 0 ||
		    fcio->fcio_xfer != FCIO_XFER_WRITE) {
			rval = EINVAL;
			break;
		}

		firmware = kmem_zalloc(fcio->fcio_ilen, KM_SLEEP);
		if (ddi_copyin(fcio->fcio_ibuf, firmware,
		    fcio->fcio_ilen, mode)) {
			rval = EFAULT;
			kmem_free(firmware, fcio->fcio_ilen);
			break;
		}

		bzero((caddr_t)&pm, sizeof (pm));
		pm.pm_cmd_flags = FC_FCA_PM_WRITE;
		pm.pm_cmd_code = FC_PORT_DOWNLOAD_FW;
		pm.pm_data_len = fcio->fcio_ilen;
		pm.pm_data_buf = firmware;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		kmem_free(firmware, fcio->fcio_ilen);

		if (ret != FC_SUCCESS) {
			fcio->fcio_errno = ret;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		break;
	}

	case FCIO_DOWNLOAD_FCODE: {
		caddr_t		fcode;
		fc_fca_pm_t	pm;

		if (fcio->fcio_ilen <= 0 ||
		    fcio->fcio_xfer != FCIO_XFER_WRITE) {
			rval = EINVAL;
			break;
		}

		fcode = kmem_zalloc(fcio->fcio_ilen, KM_SLEEP);
		if (ddi_copyin(fcio->fcio_ibuf, fcode,
		    fcio->fcio_ilen, mode)) {
			rval = EFAULT;
			kmem_free(fcode, fcio->fcio_ilen);
			break;
		}

		bzero((caddr_t)&pm, sizeof (pm));
		pm.pm_cmd_flags = FC_FCA_PM_WRITE;
		pm.pm_cmd_code = FC_PORT_DOWNLOAD_FCODE;
		pm.pm_data_len = fcio->fcio_ilen;
		pm.pm_data_buf = fcode;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		kmem_free(fcode, fcio->fcio_ilen);

		if (ret != FC_SUCCESS) {
			fcio->fcio_errno = ret;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		break;
	}

	case FCIO_FORCE_DUMP:
		ret = port->fp_fca_tran->fca_reset(
		    port->fp_fca_handle, FC_FCA_CORE);

		if (ret != FC_SUCCESS) {
			fcio->fcio_errno = ret;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		break;

	case FCIO_GET_DUMP: {
		caddr_t		dump;
		uint32_t 	dump_size;
		fc_fca_pm_t	pm;

		if (fcio->fcio_xfer != FCIO_XFER_READ) {
			rval = EINVAL;
			break;
		}
		bzero((caddr_t)&pm, sizeof (pm));

		pm.pm_cmd_flags = FC_FCA_PM_READ;
		pm.pm_cmd_code = FC_PORT_GET_DUMP_SIZE;
		pm.pm_data_len = sizeof (dump_size);
		pm.pm_data_buf = (caddr_t)&dump_size;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		if (ret != FC_SUCCESS) {
			fcio->fcio_errno = ret;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}
		if (fcio->fcio_olen != dump_size) {
			fcio->fcio_errno = FC_NOMEM;
			rval = EINVAL;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}

		dump = kmem_zalloc(dump_size, KM_SLEEP);

		bzero((caddr_t)&pm, sizeof (pm));
		pm.pm_cmd_flags = FC_FCA_PM_READ;
		pm.pm_cmd_code = FC_PORT_GET_DUMP;
		pm.pm_data_len = dump_size;
		pm.pm_data_buf = dump;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		if (ret == FC_SUCCESS) {
			if (ddi_copyout((void *)dump, (void *)fcio->fcio_obuf,
			    dump_size, mode) == 0) {
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		} else {
			fcio->fcio_errno = ret;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		kmem_free(dump, dump_size);
		break;
	}

	case FCIO_GET_TOPOLOGY: {
		uint32_t user_topology;

		if (fcio->fcio_xfer != FCIO_XFER_READ ||
		    fcio->fcio_olen != sizeof (user_topology)) {
			rval = EINVAL;
			break;
		}

		mutex_enter(&port->fp_mutex);
		if (FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) {
			user_topology = FC_TOP_UNKNOWN;
		} else {
			user_topology = port->fp_topology;
		}
		mutex_exit(&port->fp_mutex);

		if (ddi_copyout((void *)&user_topology,
		    (void *)fcio->fcio_obuf, sizeof (user_topology),
		    mode)) {
			rval = EFAULT;
		}
		break;
	}

	case FCIO_RESET_LINK: {
		la_wwn_t pwwn;

		/*
		 * Look at the output buffer field; if this field has zero
		 * bytes then attempt to reset the local link/loop. If the
		 * fcio_ibuf field points to a WWN, see if it's an NL_Port,
		 * and if yes, determine the LFA and reset the remote LIP
		 * by LINIT ELS.
		 */

		if (fcio->fcio_xfer != FCIO_XFER_WRITE ||
		    fcio->fcio_ilen != sizeof (pwwn)) {
			rval = EINVAL;
			break;
		}

		if (ddi_copyin(fcio->fcio_ibuf, &pwwn,
		    sizeof (pwwn), mode)) {
			rval = EFAULT;
			break;
		}

		mutex_enter(&port->fp_mutex);
		if (port->fp_soft_state & FP_SOFT_IN_LINK_RESET) {
			mutex_exit(&port->fp_mutex);
			break;
		}
		port->fp_soft_state |= FP_SOFT_IN_LINK_RESET;
		mutex_exit(&port->fp_mutex);

		job = fctl_alloc_job(JOB_LINK_RESET, 0, NULL, NULL, KM_SLEEP);
		if (job == NULL) {
			rval = ENOMEM;
			break;
		}
		job->job_counter = 1;
		job->job_private = (void *)&pwwn;

		fctl_enque_job(port, job);
		fctl_jobwait(job);

		mutex_enter(&port->fp_mutex);
		port->fp_soft_state &= ~FP_SOFT_IN_LINK_RESET;
		mutex_exit(&port->fp_mutex);

		if (job->job_result != FC_SUCCESS) {
			fcio->fcio_errno = job->job_result;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		fctl_dealloc_job(job);
		break;
	}

	case FCIO_RESET_HARD:
		ret = port->fp_fca_tran->fca_reset(
		    port->fp_fca_handle, FC_FCA_RESET);
		if (ret != FC_SUCCESS) {
			fcio->fcio_errno = ret;
			rval = EIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		break;

	case FCIO_RESET_HARD_CORE:
		ret = port->fp_fca_tran->fca_reset(
		    port->fp_fca_handle, FC_FCA_RESET_CORE);
		if (ret != FC_SUCCESS) {
			rval = EIO;
			fcio->fcio_errno = ret;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		}
		break;

	case FCIO_DIAG: {
		fc_fca_pm_t pm;

		bzero((caddr_t)&pm, sizeof (fc_fca_pm_t));

		/* Validate user buffer from ioctl call. */
		if (((fcio->fcio_ilen > 0) && (fcio->fcio_ibuf == NULL)) ||
		    ((fcio->fcio_ilen <= 0) && (fcio->fcio_ibuf != NULL)) ||
		    ((fcio->fcio_alen > 0) && (fcio->fcio_abuf == NULL)) ||
		    ((fcio->fcio_alen <= 0) && (fcio->fcio_abuf != NULL)) ||
		    ((fcio->fcio_olen > 0) && (fcio->fcio_obuf == NULL)) ||
		    ((fcio->fcio_olen <= 0) && (fcio->fcio_obuf != NULL))) {
			rval = EFAULT;
			break;
		}

		if ((pm.pm_cmd_len = fcio->fcio_ilen) > 0) {
			pm.pm_cmd_buf = kmem_zalloc(fcio->fcio_ilen, KM_SLEEP);
			if (ddi_copyin(fcio->fcio_ibuf, pm.pm_cmd_buf,
			    fcio->fcio_ilen, mode)) {
				rval = EFAULT;
				goto fp_fcio_diag_cleanup;
			}
		}

		if ((pm.pm_data_len = fcio->fcio_alen) > 0) {
			pm.pm_data_buf = kmem_zalloc(fcio->fcio_alen, KM_SLEEP);
			if (ddi_copyin(fcio->fcio_abuf, pm.pm_data_buf,
			    fcio->fcio_alen, mode)) {
				rval = EFAULT;
				goto fp_fcio_diag_cleanup;
			}
		}

		if ((pm.pm_stat_len = fcio->fcio_olen) > 0) {
			pm.pm_stat_buf = kmem_zalloc(fcio->fcio_olen, KM_SLEEP);
		}

		pm.pm_cmd_code = FC_PORT_DIAG;
		pm.pm_cmd_flags = fcio->fcio_cmd_flags;

		ret = port->fp_fca_tran->fca_port_manage(
		    port->fp_fca_handle, &pm);

		if (ret != FC_SUCCESS) {
			if (ret == FC_INVALID_REQUEST) {
				rval = ENOTTY;
			} else {
				rval = EIO;
			}

			fcio->fcio_errno = ret;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			goto fp_fcio_diag_cleanup;
		}

		/*
		 * pm_stat_len will contain the number of status bytes
		 * an FCA driver requires to return the complete status
		 * of the requested diag operation. If the user buffer
		 * is not large enough to hold the entire status, We
		 * copy only the portion of data the fits in the buffer and
		 * return a ENOMEM to the user application.
		 */
		if (pm.pm_stat_len > fcio->fcio_olen) {
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
			    "fp:FCIO_DIAG:status buffer too small\n");

			rval = ENOMEM;
			if (ddi_copyout(pm.pm_stat_buf, fcio->fcio_obuf,
			    fcio->fcio_olen, mode)) {
				rval = EFAULT;
				goto fp_fcio_diag_cleanup;
			}
		} else {
			/*
			 * Copy only data pm_stat_len bytes of data
			 */
			if (ddi_copyout(pm.pm_stat_buf, fcio->fcio_obuf,
			    pm.pm_stat_len, mode)) {
				rval = EFAULT;
				goto fp_fcio_diag_cleanup;
			}
		}

		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}

fp_fcio_diag_cleanup:
		if (pm.pm_cmd_buf != NULL) {
			kmem_free(pm.pm_cmd_buf, fcio->fcio_ilen);
		}
		if (pm.pm_data_buf != NULL) {
			kmem_free(pm.pm_data_buf, fcio->fcio_alen);
		}
		if (pm.pm_stat_buf != NULL) {
			kmem_free(pm.pm_stat_buf, fcio->fcio_olen);
		}

		break;
	}

	case FCIO_GET_NODE_ID: {
		/* validate parameters */
		if (fcio->fcio_xfer != FCIO_XFER_READ ||
		    fcio->fcio_olen < sizeof (fc_rnid_t)) {
			rval = EINVAL;
			break;
		}

		rval = fp_get_rnid(port, data, mode, fcio);

		/* ioctl handling is over */
		break;
	}

	case FCIO_SEND_NODE_ID: {
		la_wwn_t 		pwwn;

		/* validate parameters */
		if (fcio->fcio_ilen != sizeof (la_wwn_t) ||
		    fcio->fcio_xfer != FCIO_XFER_READ) {
			rval = EINVAL;
			break;
		}

		if (ddi_copyin(fcio->fcio_ibuf, &pwwn,
		    sizeof (la_wwn_t), mode)) {
			rval = EFAULT;
			break;
		}

		rval = fp_send_rnid(port, data, mode, fcio, &pwwn);

		/* ioctl handling is over */
		break;
	}

	case FCIO_SET_NODE_ID: {
		if (fcio->fcio_ilen != sizeof (fc_rnid_t) ||
		    (fcio->fcio_xfer != FCIO_XFER_WRITE)) {
			rval = EINVAL;
			break;
		}

		rval = fp_set_rnid(port, data, mode, fcio);
		break;
	}

	case FCIO_LINK_STATUS: {
		fc_portid_t		rls_req;
		fc_rls_acc_t		*rls_acc;
		fc_fca_pm_t		pm;
		uint32_t		dest, src_id;
		fp_cmd_t		*cmd;
		fc_remote_port_t	*pd;
		uchar_t			pd_flags;

		/* validate parameters */
		if (fcio->fcio_ilen != sizeof (fc_portid_t) ||
		    fcio->fcio_olen != sizeof (fc_rls_acc_t) ||
		    fcio->fcio_xfer != FCIO_XFER_RW) {
			rval = EINVAL;
			break;
		}

		if ((fcio->fcio_cmd_flags != FCIO_CFLAGS_RLS_DEST_FPORT) &&
		    (fcio->fcio_cmd_flags != FCIO_CFLAGS_RLS_DEST_NPORT)) {
			rval = EINVAL;
			break;
		}

		if (ddi_copyin((void *)fcio->fcio_ibuf, (void *)&rls_req,
		    sizeof (fc_portid_t), mode)) {
			rval = EFAULT;
			break;
		}


		/* Determine the destination of the RLS frame */
		if (fcio->fcio_cmd_flags == FCIO_CFLAGS_RLS_DEST_FPORT) {
			dest = FS_FABRIC_F_PORT;
		} else {
			dest = rls_req.port_id;
		}

		mutex_enter(&port->fp_mutex);
		src_id = port->fp_port_id.port_id;
		mutex_exit(&port->fp_mutex);

		/* If dest is zero OR same as FCA ID, then use port_manage() */
		if (dest == 0 || dest == src_id) {

			/* Allocate memory for link error status block */
			rls_acc = kmem_zalloc(sizeof (*rls_acc), KM_SLEEP);
			ASSERT(rls_acc != NULL);

			/* Prepare the port management structure */
			bzero((caddr_t)&pm, sizeof (pm));

			pm.pm_cmd_flags = FC_FCA_PM_READ;
			pm.pm_cmd_code  = FC_PORT_RLS;
			pm.pm_data_len  = sizeof (*rls_acc);
			pm.pm_data_buf  = (caddr_t)rls_acc;

			/* Get the adapter's link error status block */
			ret = port->fp_fca_tran->fca_port_manage(
			    port->fp_fca_handle, &pm);

			if (ret == FC_SUCCESS) {
				/* xfer link status block to userland */
				if (ddi_copyout((void *)rls_acc,
				    (void *)fcio->fcio_obuf,
				    sizeof (*rls_acc), mode) == 0) {
					if (fp_fcio_copyout(fcio, data,
					    mode)) {
						rval = EFAULT;
					}
				} else {
					rval = EFAULT;
				}
			} else {
				rval = EIO;
				fcio->fcio_errno = ret;
				if (fp_fcio_copyout(fcio, data, mode)) {
					rval = EFAULT;
				}
			}

			kmem_free(rls_acc, sizeof (*rls_acc));

			/* ioctl handling is over */
			break;
		}

		/*
		 * Send RLS to the destination port.
		 * Having RLS frame destination is as FPORT is not yet
		 * supported and will be implemented in future, if needed.
		 * Following call to get "pd" will fail if dest is FPORT
		 */
		pd = fctl_hold_remote_port_by_did(port, dest);
		if (pd == NULL) {
			fcio->fcio_errno = FC_BADOBJECT;
			rval = ENXIO;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}

		mutex_enter(&pd->pd_mutex);
		if (pd->pd_state != PORT_DEVICE_LOGGED_IN) {
			mutex_exit(&pd->pd_mutex);
			fctl_release_remote_port(pd);

			fcio->fcio_errno = FC_LOGINREQ;
			rval = EINVAL;
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}
		ASSERT(pd->pd_login_count >= 1);
		mutex_exit(&pd->pd_mutex);

		/*
		 * Allocate job structure and set job_code as DUMMY,
		 * because we will not go through the job thread.
		 * Instead fp_sendcmd() is called directly here.
		 */
		job = fctl_alloc_job(JOB_DUMMY, JOB_TYPE_FP_ASYNC,
		    NULL, NULL, KM_SLEEP);
		ASSERT(job != NULL);

		job->job_counter = 1;

		cmd = fp_alloc_pkt(port, sizeof (la_els_rls_t),
		    sizeof (la_els_rls_acc_t), KM_SLEEP, pd);
		if (cmd == NULL) {
			fcio->fcio_errno = FC_NOMEM;
			rval = ENOMEM;

			fctl_release_remote_port(pd);

			fctl_dealloc_job(job);
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
			break;
		}

		/* Allocate memory for link error status block */
		rls_acc = kmem_zalloc(sizeof (*rls_acc), KM_SLEEP);

		mutex_enter(&port->fp_mutex);
		mutex_enter(&pd->pd_mutex);

		cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
		cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
		cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
		cmd->cmd_retry_count = 1;
		cmd->cmd_ulp_pkt = NULL;

		fp_rls_init(cmd, job);

		job->job_private = (void *)rls_acc;

		pd_flags = pd->pd_flags;
		pd->pd_flags = PD_ELS_IN_PROGRESS;

		mutex_exit(&pd->pd_mutex);
		mutex_exit(&port->fp_mutex);

		if (fp_sendcmd(port, cmd, port->fp_fca_handle) == FC_SUCCESS) {
			fctl_jobwait(job);

			fcio->fcio_errno = job->job_result;
			if (job->job_result == FC_SUCCESS) {
				ASSERT(pd != NULL);
				/*
				 * link error status block is now available.
				 * Copy it to userland
				 */
				ASSERT(job->job_private == (void *)rls_acc);
				if (ddi_copyout((void *)rls_acc,
				    (void *)fcio->fcio_obuf,
				    sizeof (*rls_acc), mode) == 0) {
					if (fp_fcio_copyout(fcio, data,
					    mode)) {
						rval = EFAULT;
					}
				} else {
					rval = EFAULT;
				}
			} else {
				rval = EIO;
			}
		} else {
			rval = EIO;
			fp_free_pkt(cmd);
		}

		if (rval) {
			mutex_enter(&port->fp_mutex);
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_flags == PD_ELS_IN_PROGRESS) {
				pd->pd_flags = pd_flags;
			}
			mutex_exit(&pd->pd_mutex);
			mutex_exit(&port->fp_mutex);
		}

		fctl_release_remote_port(pd);
		fctl_dealloc_job(job);
		kmem_free(rls_acc, sizeof (*rls_acc));

		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
		break;
	}

	case FCIO_NS: {
		fc_ns_cmd_t 	*ns_req;
		fc_ns_cmd32_t 	*ns_req32;
		fctl_ns_req_t 	*ns_cmd;

		if (use32 == B_TRUE) {
			if (fcio->fcio_ilen != sizeof (*ns_req32)) {
				rval = EINVAL;
				break;
			}

			ns_req = kmem_zalloc(sizeof (*ns_req), KM_SLEEP);
			ns_req32 = kmem_zalloc(sizeof (*ns_req32), KM_SLEEP);

			if (ddi_copyin(fcio->fcio_ibuf, ns_req32,
			    sizeof (*ns_req32), mode)) {
				rval = EFAULT;
				kmem_free(ns_req, sizeof (*ns_req));
				kmem_free(ns_req32, sizeof (*ns_req32));
				break;
			}

			ns_req->ns_flags = ns_req32->ns_flags;
			ns_req->ns_cmd = ns_req32->ns_cmd;
			ns_req->ns_req_len = ns_req32->ns_req_len;
			ns_req->ns_req_payload = ns_req32->ns_req_payload;
			ns_req->ns_resp_len = ns_req32->ns_resp_len;
			ns_req->ns_resp_payload = ns_req32->ns_resp_payload;
			ns_req->ns_fctl_private = ns_req32->ns_fctl_private;
			ns_req->ns_resp_hdr = ns_req32->ns_resp_hdr;

			kmem_free(ns_req32, sizeof (*ns_req32));
		} else {
			if (fcio->fcio_ilen != sizeof (*ns_req)) {
				rval = EINVAL;
				break;
			}

			ns_req = kmem_zalloc(sizeof (*ns_req), KM_SLEEP);

			if (ddi_copyin(fcio->fcio_ibuf, ns_req,
			    sizeof (fc_ns_cmd_t), mode)) {
				rval = EFAULT;
				kmem_free(ns_req, sizeof (*ns_req));
				break;
			}
		}

		if (ns_req->ns_req_len <= 0) {
			rval = EINVAL;
			kmem_free(ns_req, sizeof (*ns_req));
			break;
		}

		job = fctl_alloc_job(JOB_NS_CMD, 0, NULL, NULL, KM_SLEEP);
		ASSERT(job != NULL);

		ns_cmd = fctl_alloc_ns_cmd(ns_req->ns_req_len,
		    ns_req->ns_resp_len, ns_req->ns_resp_len,
		    FCTL_NS_FILL_NS_MAP, KM_SLEEP);
		ASSERT(ns_cmd != NULL);
		ns_cmd->ns_cmd_code = ns_req->ns_cmd;

		if (ns_cmd->ns_cmd_code == NS_GA_NXT) {
			ns_cmd->ns_gan_max = 1;
			ns_cmd->ns_gan_index = 0;
			ns_cmd->ns_gan_sid = FCTL_GAN_START_ID;
		}

		if (ddi_copyin(ns_req->ns_req_payload,
		    ns_cmd->ns_cmd_buf, ns_req->ns_req_len, mode)) {
			rval = EFAULT;
			fctl_free_ns_cmd(ns_cmd);
			fctl_dealloc_job(job);
			kmem_free(ns_req, sizeof (*ns_req));
			break;
		}

		job->job_private = (void *)ns_cmd;
		fctl_enque_job(port, job);
		fctl_jobwait(job);
		rval = job->job_result;

		if (rval == FC_SUCCESS) {
			if (ns_req->ns_resp_len) {
				if (ddi_copyout(ns_cmd->ns_data_buf,
				    ns_req->ns_resp_payload,
				    ns_cmd->ns_data_len, mode)) {
					rval = EFAULT;
					fctl_free_ns_cmd(ns_cmd);
					fctl_dealloc_job(job);
					kmem_free(ns_req, sizeof (*ns_req));
					break;
				}
			}
		} else {
			rval = EIO;
		}
		ns_req->ns_resp_hdr = ns_cmd->ns_resp_hdr;
		fctl_free_ns_cmd(ns_cmd);
		fctl_dealloc_job(job);
		kmem_free(ns_req, sizeof (*ns_req));

		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
		break;
	}

	default:
		rval = ENOTTY;
		break;
	}

	/*
	 * If set, reset the EXCL busy bit to
	 * receive other exclusive access commands
	 */
	mutex_enter(&port->fp_mutex);
	if (port->fp_flag & FP_EXCL_BUSY) {
		port->fp_flag &= ~FP_EXCL_BUSY;
	}
	mutex_exit(&port->fp_mutex);

	return (rval);
}


/*
 * This function assumes that the response length
 * is same regardless of data model (LP32 or LP64)
 * which is true for all the ioctls currently
 * supported.
 */
static int
fp_copyout(void *from, void *to, size_t len, int mode)
{
	return (ddi_copyout(from, to, len, mode));
}

/*
 * This function does the set rnid
 */
static int
fp_set_rnid(fc_local_port_t *port, intptr_t data, int mode, fcio_t *fcio)
{
	int 		rval = 0;
	fc_rnid_t	*rnid;
	fc_fca_pm_t	pm;

	/* Allocate memory for node id block */
	rnid = kmem_zalloc(sizeof (fc_rnid_t), KM_SLEEP);

	if (ddi_copyin(fcio->fcio_ibuf, rnid, sizeof (fc_rnid_t), mode)) {
		FP_TRACE(FP_NHEAD1(3, 0), "fp_set_rnid: failed = %d", EFAULT);
		kmem_free(rnid, sizeof (fc_rnid_t));
		return (EFAULT);
	}

	/* Prepare the port management structure */
	bzero((caddr_t)&pm, sizeof (pm));

	pm.pm_cmd_flags = FC_FCA_PM_WRITE;
	pm.pm_cmd_code  = FC_PORT_SET_NODE_ID;
	pm.pm_data_len  = sizeof (*rnid);
	pm.pm_data_buf  = (caddr_t)rnid;

	/* Get the adapter's node data */
	rval = port->fp_fca_tran->fca_port_manage(
	    port->fp_fca_handle, &pm);

	if (rval != FC_SUCCESS) {
		fcio->fcio_errno = rval;
		rval = EIO;
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
	} else {
		mutex_enter(&port->fp_mutex);
		/* copy to the port structure */
		bcopy(rnid, &port->fp_rnid_params,
			sizeof (port->fp_rnid_params));
		mutex_exit(&port->fp_mutex);
	}

	kmem_free(rnid, sizeof (fc_rnid_t));

	if (rval != FC_SUCCESS) {
		FP_TRACE(FP_NHEAD1(3, 0), "fp_set_rnid: failed = %d", rval);
	}

	return (rval);
}

/*
 * This function does the local pwwn get rnid
 */
static int
fp_get_rnid(fc_local_port_t *port, intptr_t data, int mode, fcio_t *fcio)
{
	fc_rnid_t		*rnid;
	fc_fca_pm_t		pm;
	int 			rval = 0;
	uint32_t		ret;

	/* Allocate memory for rnid data block */
	rnid = kmem_zalloc(sizeof (fc_rnid_t), KM_SLEEP);

	mutex_enter(&port->fp_mutex);
	if (port->fp_rnid_init == 1) {
		bcopy(&port->fp_rnid_params, rnid, sizeof (fc_rnid_t));
		mutex_exit(&port->fp_mutex);
		/* xfer node info to userland */
		if (ddi_copyout((void *)rnid, (void *)fcio->fcio_obuf,
		    sizeof (*rnid), mode) == 0) {
			if (fp_fcio_copyout(fcio, data, mode)) {
				rval = EFAULT;
			}
		} else {
			rval = EFAULT;
		}

		kmem_free(rnid, sizeof (fc_rnid_t));

		if (rval != FC_SUCCESS) {
			FP_TRACE(FP_NHEAD1(3, 0), "fp_get_rnid: failed = %d",
			rval);
		}

		return (rval);
	}
	mutex_exit(&port->fp_mutex);

	/* Prepare the port management structure */
	bzero((caddr_t)&pm, sizeof (pm));

	pm.pm_cmd_flags = FC_FCA_PM_READ;
	pm.pm_cmd_code  = FC_PORT_GET_NODE_ID;
	pm.pm_data_len  = sizeof (fc_rnid_t);
	pm.pm_data_buf  = (caddr_t)rnid;

	/* Get the adapter's node data */
	ret = port->fp_fca_tran->fca_port_manage(
			port->fp_fca_handle,
			&pm);

	if (ret == FC_SUCCESS) {
		/* initialize in the port_info */
		mutex_enter(&port->fp_mutex);
		port->fp_rnid_init = 1;
		bcopy(rnid, &port->fp_rnid_params, sizeof (*rnid));
		mutex_exit(&port->fp_mutex);

		/* xfer node info to userland */
		if (ddi_copyout((void *)rnid,
				(void *)fcio->fcio_obuf,
				sizeof (*rnid), mode) == 0) {
			if (fp_fcio_copyout(fcio, data,
					mode)) {
				rval = EFAULT;
			}
		} else {
			rval = EFAULT;
		}
	} else {
		rval = EIO;
		fcio->fcio_errno = ret;
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}
	}

	kmem_free(rnid, sizeof (fc_rnid_t));

	if (rval != FC_SUCCESS) {
		FP_TRACE(FP_NHEAD1(3, 0), "fp_get_rnid: failed = %d", rval);
	}

	return (rval);
}

static int
fp_send_rnid(fc_local_port_t *port, intptr_t data, int mode, fcio_t *fcio,
	la_wwn_t *pwwn)
{
	int 			rval = 0;
	fc_remote_port_t	*pd;
	fp_cmd_t		*cmd;
	job_request_t 		*job;
	la_els_rnid_acc_t	*rnid_acc;

	pd = fctl_get_remote_port_by_pwwn(port, pwwn);
	if (pd == NULL) {
		/*
		 * We can safely assume that the destination port
		 * is logged in. Either the user land will explicitly
		 * login before issuing RNID ioctl or the device would
		 * have been configured, meaning already logged in.
		 */

		FP_TRACE(FP_NHEAD1(3, 0), "fp_send_rnid: failed = %d", ENXIO);

		return (ENXIO);
	}
	/*
	 * Allocate job structure and set job_code as DUMMY,
	 * because we will not go thorugh the job thread.
	 * Instead fp_sendcmd() is called directly here.
	 */
	job = fctl_alloc_job(JOB_DUMMY, JOB_TYPE_FP_ASYNC,
	    NULL, NULL, KM_SLEEP);

	ASSERT(job != NULL);

	job->job_counter = 1;

	cmd = fp_alloc_pkt(port, sizeof (la_els_rnid_t),
	    sizeof (la_els_rnid_acc_t), KM_SLEEP, pd);
	if (cmd == NULL) {
		fcio->fcio_errno = FC_NOMEM;
		rval = ENOMEM;

		fctl_dealloc_job(job);
		if (fp_fcio_copyout(fcio, data, mode)) {
			rval = EFAULT;
		}

		FP_TRACE(FP_NHEAD1(3, 0), "fp_send_rnid: failed = %d", rval);

		return (rval);
	}

	/* Allocate memory for node id accept block */
	rnid_acc = kmem_zalloc(sizeof (la_els_rnid_acc_t), KM_SLEEP);

	mutex_enter(&port->fp_mutex);
	mutex_enter(&pd->pd_mutex);

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	fp_rnid_init(cmd, fcio->fcio_cmd_flags, job);

	job->job_private = (void *)rnid_acc;

	pd->pd_flags = PD_ELS_IN_PROGRESS;

	mutex_exit(&pd->pd_mutex);
	mutex_exit(&port->fp_mutex);

	if (fp_sendcmd(port, cmd, port->fp_fca_handle) == FC_SUCCESS) {
		fctl_jobwait(job);
		fcio->fcio_errno = job->job_result;
		if (job->job_result == FC_SUCCESS) {
			int rnid_cnt;
			ASSERT(pd != NULL);
			/*
			 * node id block is now available.
			 * Copy it to userland
			 */
			ASSERT(job->job_private == (void *)rnid_acc);

			/* get the response length */
			rnid_cnt = sizeof (ls_code_t) + sizeof (fc_rnid_hdr_t) +
					rnid_acc->hdr.cmn_len +
					rnid_acc->hdr.specific_len;

			if (fcio->fcio_olen < rnid_cnt) {
				rval = EINVAL;
			} else if (ddi_copyout((void *)rnid_acc,
				(void *)fcio->fcio_obuf,
				rnid_cnt, mode) == 0) {
				if (fp_fcio_copyout(fcio, data,
					mode)) {
					rval = EFAULT;
				}
			} else {
				rval = EFAULT;
			}
		} else {
			rval = EIO;
		}
	} else {
		rval = EIO;
		if (pd) {
			mutex_enter(&pd->pd_mutex);
			pd->pd_flags = PD_IDLE;
			mutex_exit(&pd->pd_mutex);
		}
		fp_free_pkt(cmd);
	}

	fctl_dealloc_job(job);
	kmem_free(rnid_acc, sizeof (la_els_rnid_acc_t));

	if (fp_fcio_copyout(fcio, data, mode)) {
		rval = EFAULT;
	}

	if (rval != FC_SUCCESS) {
		FP_TRACE(FP_NHEAD1(3, 0), "fp_send_rnid: failed = %d", rval);
	}

	return (rval);
}

/*
 * Copy out to userland
 */
static int
fp_fcio_copyout(fcio_t *fcio, intptr_t data, int mode)
{
	int rval;

#ifdef	_MULTI_DATAMODEL
	switch (ddi_model_convert_from(mode & FMODELS)) {
	case DDI_MODEL_ILP32: {
		struct fcio32 fcio32;

		fcio32.fcio_xfer = fcio->fcio_xfer;
		fcio32.fcio_cmd = fcio->fcio_cmd;
		fcio32.fcio_flags = fcio->fcio_flags;
		fcio32.fcio_cmd_flags = fcio->fcio_cmd_flags;
		fcio32.fcio_ilen = fcio->fcio_ilen;
		fcio32.fcio_ibuf =
			(caddr32_t)(uintptr_t)fcio->fcio_ibuf;
		fcio32.fcio_olen = fcio->fcio_olen;
		fcio32.fcio_obuf =
			(caddr32_t)(uintptr_t)fcio->fcio_obuf;
		fcio32.fcio_alen = fcio->fcio_alen;
		fcio32.fcio_abuf =
			(caddr32_t)(uintptr_t)fcio->fcio_abuf;
		fcio32.fcio_errno = fcio->fcio_errno;

		rval = ddi_copyout((void *)&fcio32, (void *)data,
		    sizeof (struct fcio32), mode);
		break;
	}
	case DDI_MODEL_NONE:
		rval = ddi_copyout((void *)fcio, (void *)data,
		    sizeof (fcio_t), mode);
		break;
	}
#else
	rval = ddi_copyout((void *)fcio, (void *)data, sizeof (fcio_t), mode);
#endif

	return (rval);
}


static void
fp_p2p_online(fc_local_port_t *port, job_request_t *job)
{
	uint32_t		listlen;
	fc_portmap_t		*changelist;

	ASSERT(MUTEX_HELD(&port->fp_mutex));
	ASSERT(port->fp_topology == FC_TOP_PT_PT);
	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

	listlen = 0;
	changelist = NULL;

	if ((job->job_flags & JOB_CANCEL_ULP_NOTIFICATION) == 0) {
		if (port->fp_statec_busy > 1) {
			job->job_flags |= JOB_CANCEL_ULP_NOTIFICATION;
		}
	}
	mutex_exit(&port->fp_mutex);

	if ((job->job_flags & JOB_CANCEL_ULP_NOTIFICATION) == 0) {
		fctl_fillout_map(port, &changelist, &listlen, 1, 0, 0);
		(void) fp_ulp_statec_cb(port, FC_STATE_ONLINE, changelist,
		    listlen, listlen, KM_SLEEP);

		mutex_enter(&port->fp_mutex);
	} else {
		ASSERT(changelist == NULL && listlen == 0);
		mutex_enter(&port->fp_mutex);
		if (--port->fp_statec_busy == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
		}
	}
}

static int
fp_fillout_p2pmap(fc_local_port_t *port, fcio_t *fcio, int mode)
{
	int			rval;
	int			count;
	int			index;
	int			num_devices;
	fc_remote_node_t	*node;
	fc_port_dev_t 		*devlist;
	struct pwwn_hash 	*head;
	fc_remote_port_t 	*pd;

	ASSERT(MUTEX_HELD(&port->fp_mutex));

	num_devices = fcio->fcio_olen / sizeof (fc_port_dev_t);

	devlist = kmem_zalloc(sizeof (fc_port_dev_t) * num_devices, KM_SLEEP);

	for (count = index = 0; index < pwwn_table_size; index++) {
		head = &port->fp_pwwn_table[index];
		pd = head->pwwn_head;
		while (pd != NULL) {
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_state == PORT_DEVICE_INVALID) {
				mutex_exit(&pd->pd_mutex);
				pd = pd->pd_wwn_hnext;
				continue;
			}

			devlist[count].dev_state = pd->pd_state;
			devlist[count].dev_hard_addr = pd->pd_hard_addr;
			devlist[count].dev_did = pd->pd_port_id;
			devlist[count].dev_did.priv_lilp_posit =
			    (uint8_t)(index & 0xff);
			bcopy((caddr_t)pd->pd_fc4types,
			    (caddr_t)devlist[count].dev_type,
			    sizeof (pd->pd_fc4types));

			bcopy((caddr_t)&pd->pd_port_name,
			    (caddr_t)&devlist[count].dev_pwwn,
			    sizeof (la_wwn_t));

			node = pd->pd_remote_nodep;
			mutex_exit(&pd->pd_mutex);

			if (node) {
				mutex_enter(&node->fd_mutex);
				bcopy((caddr_t)&node->fd_node_name,
				    (caddr_t)&devlist[count].dev_nwwn,
				    sizeof (la_wwn_t));
				mutex_exit(&node->fd_mutex);
			}
			count++;
			if (count >= num_devices) {
				goto found;
			}
		}
	}
found:
	if (fp_copyout((void *)&count, (void *)fcio->fcio_abuf,
	    sizeof (count), mode)) {
		rval = FC_FAILURE;
	} else if (fp_copyout((void *)devlist, (void *)fcio->fcio_obuf,
	    sizeof (fc_port_dev_t) * num_devices, mode)) {
		rval = FC_FAILURE;
	} else {
		rval = FC_SUCCESS;
	}

	kmem_free(devlist, sizeof (fc_port_dev_t) * num_devices);

	return (rval);
}


/*
 * Handle Fabric ONLINE
 */
static void
fp_fabric_online(fc_local_port_t *port, job_request_t *job)
{
	int			index;
	int			rval;
	int			dbg_count;
	int			count = 0;
	char 			ww_name[17];
	uint32_t		d_id;
	uint32_t		listlen;
	fctl_ns_req_t		*ns_cmd;
	struct pwwn_hash	*head;
	fc_remote_port_t	*pd;
	fc_remote_port_t	*npd;
	fc_portmap_t		*changelist;

	ASSERT(MUTEX_HELD(&port->fp_mutex));
	ASSERT(FC_IS_TOP_SWITCH(port->fp_topology));
	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

	ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gid_pn_t),
	    sizeof (ns_resp_gid_pn_t), sizeof (ns_resp_gid_pn_t),
	    0, KM_SLEEP);

	ASSERT(ns_cmd != NULL);

	ns_cmd->ns_cmd_code = NS_GID_PN;

	/*
	 * Check if orphans are showing up now
	 */
	if (port->fp_orphan_count) {
		fc_orphan_t 	*orp;
		fc_orphan_t	*norp = NULL;
		fc_orphan_t	*prev = NULL;

		for (orp = port->fp_orphan_list; orp; orp = norp) {
			norp = orp->orp_next;
			mutex_exit(&port->fp_mutex);
			orp->orp_nscan++;

			job->job_counter = 1;
			job->job_result = FC_SUCCESS;

			((ns_req_gid_pn_t *)
			    (ns_cmd->ns_cmd_buf))->pwwn = orp->orp_pwwn;
			((ns_resp_gid_pn_t *)
			    ns_cmd->ns_data_buf)->pid.port_id = 0;
			((ns_resp_gid_pn_t *)
			    ns_cmd->ns_data_buf)->pid.priv_lilp_posit = 0;

			rval = fp_ns_query(port, ns_cmd, job, 1, KM_SLEEP);
			if (rval == FC_SUCCESS) {
				d_id =
				    BE_32(*((uint32_t *)ns_cmd->ns_data_buf));
				pd = fp_create_remote_port_by_ns(port,
				    d_id, KM_SLEEP);

				if (pd != NULL) {
					fc_wwn_to_str(&orp->orp_pwwn, ww_name);

					fp_printf(port, CE_WARN, FP_LOG_ONLY,
					    0, NULL, "N_x Port with D_ID=%x,"
					    " PWWN=%s reappeared in fabric",
					    d_id, ww_name);

					mutex_enter(&port->fp_mutex);
					if (prev) {
						prev->orp_next = orp->orp_next;
					} else {
						ASSERT(orp ==
						    port->fp_orphan_list);
						port->fp_orphan_list =
						    orp->orp_next;
					}
					port->fp_orphan_count--;
					mutex_exit(&port->fp_mutex);
					kmem_free(orp, sizeof (*orp));
					count++;

					mutex_enter(&pd->pd_mutex);
					pd->pd_flags = PD_ELS_MARK;

					mutex_exit(&pd->pd_mutex);
				} else {
					prev = orp;
				}
			} else {
				if (orp->orp_nscan == FC_ORPHAN_SCAN_LIMIT) {
					fc_wwn_to_str(&orp->orp_pwwn, ww_name);

					fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0,
					    NULL,
					    " Port WWN %s removed from orphan"
					    " list after %d scans", ww_name,
					    orp->orp_nscan);

					mutex_enter(&port->fp_mutex);
					if (prev) {
						prev->orp_next = orp->orp_next;
					} else {
						ASSERT(orp ==
						    port->fp_orphan_list);
						port->fp_orphan_list =
						    orp->orp_next;
					}
					port->fp_orphan_count--;
					mutex_exit(&port->fp_mutex);

					kmem_free(orp, sizeof (*orp));
				} else {
					prev = orp;
				}
			}
			mutex_enter(&port->fp_mutex);
		}
	}

	/*
	 * Walk the Port WWN hash table, reestablish LOGIN
	 * if a LOGIN is already performed on a particular
	 * device; Any failure to LOGIN should mark the
	 * port device OLD.
	 */
	for (index = 0; index < pwwn_table_size; index++) {
		head = &port->fp_pwwn_table[index];
		npd = head->pwwn_head;

		while ((pd = npd) != NULL) {
			la_wwn_t 	*pwwn;

			npd = pd->pd_wwn_hnext;

			/*
			 * Don't count in the port devices that are new
			 * unless the total number of devices visible
			 * through this port is less than FP_MAX_DEVICES
			 */
			mutex_enter(&pd->pd_mutex);
			if (port->fp_dev_count >= FP_MAX_DEVICES ||
			    (port->fp_options & FP_TARGET_MODE)) {
				if (pd->pd_type == PORT_DEVICE_NEW ||
				    pd->pd_flags == PD_ELS_MARK ||
				    pd->pd_recepient != PD_PLOGI_INITIATOR) {
					mutex_exit(&pd->pd_mutex);
					continue;
				}
			} else {
				if (pd->pd_flags == PD_ELS_MARK ||
				    pd->pd_recepient != PD_PLOGI_INITIATOR) {
					mutex_exit(&pd->pd_mutex);
					continue;
				}
				pd->pd_type = PORT_DEVICE_OLD;
			}
			count++;

			/*
			 * Consult with the name server about D_ID changes
			 */
			job->job_counter = 1;
			job->job_result = FC_SUCCESS;

			((ns_req_gid_pn_t *)
			    (ns_cmd->ns_cmd_buf))->pwwn = pd->pd_port_name;
			((ns_resp_gid_pn_t *)
			    ns_cmd->ns_data_buf)->pid.port_id = 0;

			((ns_resp_gid_pn_t *)ns_cmd->ns_data_buf)->
			    pid.priv_lilp_posit = 0;

			pwwn = &pd->pd_port_name;
			pd->pd_flags = PD_ELS_MARK;

			mutex_exit(&pd->pd_mutex);
			mutex_exit(&port->fp_mutex);

			rval = fp_ns_query(port, ns_cmd, job, 1, KM_SLEEP);
			if (rval != FC_SUCCESS) {
				fc_wwn_to_str(pwwn, ww_name);

				mutex_enter(&pd->pd_mutex);
				d_id = pd->pd_port_id.port_id;
				pd->pd_type = PORT_DEVICE_DELETE;
				mutex_exit(&pd->pd_mutex);

				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_fabric_online: PD "
				    "disappeared; d_id=%x, PWWN=%s",
				    d_id, ww_name);

				FP_TRACE(FP_NHEAD2(9, 0),
				    "N_x Port with D_ID=%x, PWWN=%s"
				    " disappeared from fabric", d_id,
				    ww_name);

				mutex_enter(&port->fp_mutex);
				continue;
			}

			d_id = BE_32(*((uint32_t *)ns_cmd->ns_data_buf));

			mutex_enter(&port->fp_mutex);
			mutex_enter(&pd->pd_mutex);
			if (d_id != pd->pd_port_id.port_id) {
				fctl_delist_did_table(port, pd);
				fc_wwn_to_str(pwwn, ww_name);

				FP_TRACE(FP_NHEAD2(9, 0),
				    "D_ID of a device with PWWN %s changed."
				    " New D_ID = %x, OLD D_ID = %x", ww_name,
				    d_id, pd->pd_port_id.port_id);

				pd->pd_port_id.port_id = BE_32(d_id);
				pd->pd_type = PORT_DEVICE_CHANGED;
				fctl_enlist_did_table(port, pd);
			}
			mutex_exit(&pd->pd_mutex);

		}
	}

	if (ns_cmd) {
		fctl_free_ns_cmd(ns_cmd);
	}

	listlen = 0;
	changelist = NULL;
	if (count) {
		if (port->fp_soft_state & FP_SOFT_IN_FCA_RESET) {
			port->fp_soft_state &= ~FP_SOFT_IN_FCA_RESET;
			mutex_exit(&port->fp_mutex);
			delay(drv_usectohz(FLA_RR_TOV * 1000 * 1000));
			mutex_enter(&port->fp_mutex);
		}

		dbg_count = 0;

		job->job_counter = count;

		for (index = 0; index < pwwn_table_size; index++) {
			head = &port->fp_pwwn_table[index];
			npd = head->pwwn_head;

			while ((pd = npd) != NULL) {
				npd = pd->pd_wwn_hnext;

				mutex_enter(&pd->pd_mutex);
				if (pd->pd_flags != PD_ELS_MARK) {
					mutex_exit(&pd->pd_mutex);
					continue;
				}

				dbg_count++;

				/*
				 * If it is already marked deletion, nothing
				 * else to do.
				 */
				if (pd->pd_type == PORT_DEVICE_DELETE) {
					pd->pd_type = PORT_DEVICE_OLD;

					mutex_exit(&pd->pd_mutex);
					mutex_exit(&port->fp_mutex);
					fp_jobdone(job);
					mutex_enter(&port->fp_mutex);

					continue;
				}

				/*
				 * If it is freshly discovered out of
				 * the orphan list, nothing else to do
				 */
				if (pd->pd_type == PORT_DEVICE_NEW) {
					pd->pd_flags = PD_IDLE;

					mutex_exit(&pd->pd_mutex);
					mutex_exit(&port->fp_mutex);
					fp_jobdone(job);
					mutex_enter(&port->fp_mutex);

					continue;
				}

				pd->pd_flags = PD_IDLE;
				d_id = pd->pd_port_id.port_id;

				/*
				 * Explicitly mark all devices OLD; successful
				 * PLOGI should reset this to either NO_CHANGE
				 * or CHANGED.
				 */
				if (pd->pd_type != PORT_DEVICE_CHANGED) {
					pd->pd_type = PORT_DEVICE_OLD;
				}

				mutex_exit(&pd->pd_mutex);
				mutex_exit(&port->fp_mutex);

				rval = fp_port_login(port, d_id, job,
				    FP_CMD_PLOGI_RETAIN, KM_SLEEP, pd, NULL);

				if (rval != FC_SUCCESS) {
					fp_jobdone(job);
				}
				mutex_enter(&port->fp_mutex);
			}
		}
		mutex_exit(&port->fp_mutex);

		ASSERT(dbg_count == count);
		fp_jobwait(job);

		mutex_enter(&port->fp_mutex);

		ASSERT(port->fp_statec_busy > 0);
		if ((job->job_flags & JOB_CANCEL_ULP_NOTIFICATION) == 0) {
			if (port->fp_statec_busy > 1) {
				job->job_flags |= JOB_CANCEL_ULP_NOTIFICATION;
			}
		}
		mutex_exit(&port->fp_mutex);
	} else {
		ASSERT(port->fp_statec_busy > 0);
		if (port->fp_statec_busy > 1) {
			job->job_flags |= JOB_CANCEL_ULP_NOTIFICATION;
		}
		mutex_exit(&port->fp_mutex);
	}

	if ((job->job_flags & JOB_CANCEL_ULP_NOTIFICATION) == 0) {
		fctl_fillout_map(port, &changelist, &listlen, 1, 0, 0);

		(void) fp_ulp_statec_cb(port, FC_STATE_ONLINE, changelist,
		    listlen, listlen, KM_SLEEP);

		mutex_enter(&port->fp_mutex);
	} else {
		ASSERT(changelist == NULL && listlen == 0);
		mutex_enter(&port->fp_mutex);
		if (--port->fp_statec_busy == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_STATEC_CB;
		}
	}
}


/*
 * Fill out device list for userland ioctl in private loop
 */
static int
fp_fillout_loopmap(fc_local_port_t *port, fcio_t *fcio, int mode)
{
	int			rval;
	int			count;
	int			index;
	int			num_devices;
	fc_remote_node_t	*node;
	fc_port_dev_t 		*devlist;
	int			lilp_device_count;
	fc_lilpmap_t		*lilp_map;
	uchar_t			*alpa_list;

	ASSERT(MUTEX_HELD(&port->fp_mutex));

	num_devices = fcio->fcio_olen / sizeof (fc_port_dev_t);
	if (port->fp_total_devices > port->fp_dev_count &&
	    num_devices >= port->fp_total_devices) {
		job_request_t 	*job;

		mutex_exit(&port->fp_mutex);
		job = fctl_alloc_job(JOB_PORT_GETMAP, 0, NULL, NULL, KM_SLEEP);
		job->job_counter = 1;

		mutex_enter(&port->fp_mutex);
		fp_get_loopmap(port, job);
		mutex_exit(&port->fp_mutex);

		fp_jobwait(job);
		fctl_dealloc_job(job);
	} else {
		mutex_exit(&port->fp_mutex);
	}
	devlist = kmem_zalloc(sizeof (*devlist) * num_devices, KM_SLEEP);

	mutex_enter(&port->fp_mutex);

	/*
	 * Applications are accustomed to getting the device list in
	 * LILP map order. The HBA firmware usually returns the device
	 * map in the LILP map order and diagnostic applications would
	 * prefer to receive in the device list in that order too
	 */
	lilp_map = &port->fp_lilp_map;
	alpa_list = &lilp_map->lilp_alpalist[0];

	/*
	 * the length field corresponds to the offset in the LILP frame
	 * which begins with 1. The thing to note here is that the
	 * lilp_device_count is 1 more than fp->fp_total_devices since
	 * the host adapter's alpa also shows up in the lilp map. We
	 * don't however return details of the host adapter since
	 * fctl_get_remote_port_by_did fails for the host adapter's ALPA
	 * and applications are required to issue the FCIO_GET_HOST_PARAMS
	 * ioctl to obtain details about the host adapter port.
	 */
	lilp_device_count = lilp_map->lilp_length;

	for (count = index = 0; index < lilp_device_count &&
	    count < num_devices; index++) {
		uint32_t d_id;
		fc_remote_port_t *pd;

		d_id = alpa_list[index];

		mutex_exit(&port->fp_mutex);
		pd = fctl_get_remote_port_by_did(port, d_id);
		mutex_enter(&port->fp_mutex);

		if (pd != NULL) {
			mutex_enter(&pd->pd_mutex);

			if (pd->pd_state == PORT_DEVICE_INVALID) {
				mutex_exit(&pd->pd_mutex);
				continue;
			}

			devlist[count].dev_state = pd->pd_state;
			devlist[count].dev_hard_addr = pd->pd_hard_addr;
			devlist[count].dev_did = pd->pd_port_id;
			devlist[count].dev_did.priv_lilp_posit =
						(uint8_t)(index & 0xff);
			bcopy((caddr_t)pd->pd_fc4types,
			    (caddr_t)devlist[count].dev_type,
			    sizeof (pd->pd_fc4types));

			bcopy((caddr_t)&pd->pd_port_name,
			    (caddr_t)&devlist[count].dev_pwwn,
			    sizeof (la_wwn_t));

			node = pd->pd_remote_nodep;
			mutex_exit(&pd->pd_mutex);

			if (node) {
				mutex_enter(&node->fd_mutex);
				bcopy((caddr_t)&node->fd_node_name,
				    (caddr_t)&devlist[count].dev_nwwn,
				    sizeof (la_wwn_t));
				mutex_exit(&node->fd_mutex);
			}
			count++;
		}
	}

	if (fp_copyout((void *)&count, (void *)fcio->fcio_abuf,
	    sizeof (count), mode)) {
		rval = FC_FAILURE;
	}

	if (fp_copyout((void *)devlist, (void *)fcio->fcio_obuf,
	    sizeof (fc_port_dev_t) * num_devices, mode)) {
		rval = FC_FAILURE;
	} else {
		rval = FC_SUCCESS;
	}

	kmem_free(devlist, sizeof (*devlist) * num_devices);
	ASSERT(MUTEX_HELD(&port->fp_mutex));

	return (rval);
}


/*
 * Completion function for responses to unsolicited commands
 */
static void
fp_unsol_intr(fc_packet_t *pkt)
{
	fp_cmd_t 	*cmd;
	fc_local_port_t *port;

	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

	if (pkt->pkt_state != FC_PKT_SUCCESS) {
		fp_printf(port, CE_WARN, FP_LOG_ONLY, 0, pkt,
		    "couldn't post response to unsolicited request;"
		    " ox_id=%x rx_id=%x", pkt->pkt_cmd_fhdr.ox_id,
		    pkt->pkt_resp_fhdr.rx_id);
	}

	if (cmd == port->fp_els_resp_pkt) {
		mutex_enter(&port->fp_mutex);
		port->fp_els_resp_pkt_busy = 0;
		mutex_exit(&port->fp_mutex);
		return;
	}

	fp_free_pkt(cmd);
}


/*
 * solicited LINIT ELS completion function
 */
static void
fp_linit_intr(fc_packet_t *pkt)
{
	fp_cmd_t		*cmd;
	job_request_t		*job;
	fc_linit_resp_t		acc;

	if (FP_IS_PKT_ERROR(pkt)) {
		(void) fp_common_intr(pkt, 1);
		return;
	}

	cmd = pkt->pkt_ulp_private;
	job = cmd->cmd_job;

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&acc,
	    (uint8_t *)pkt->pkt_resp, sizeof (acc), DDI_DEV_AUTOINCR);

	if (acc.status != FC_LINIT_SUCCESS) {
		job->job_result = FC_FAILURE;
	} else {
		job->job_result = FC_SUCCESS;
	}
	fp_iodone(cmd);
}


/*
 * Decode the unsolicited request; For FC-4 Device and Link data frames
 * notify the registered ULP of this FC-4 type right here. For Unsolicited
 * ELS requests, submit a request to the job_handler thread to work on it.
 * The intent is to act quickly on the FC-4 unsolicited link and data frames
 * and save much of the interrupt time processing of unsolicited ELS requests
 * and hand it off to the job_handler thread.
 */
static void
fp_unsol_cb(opaque_t port_handle, fc_unsol_buf_t *buf, uint32_t type)
{
	uchar_t		r_ctl;
	uchar_t		ls_code;
	uint32_t	s_id;
	uint32_t	rscn_count = FC_INVALID_RSCN_COUNT;
	uint32_t	cb_arg;
	fp_cmd_t	*cmd;
	fc_local_port_t *port;
	job_request_t	*job;
	fc_remote_port_t 	*pd;

	port = port_handle;

	FP_TRACE(FP_NHEAD1(1, 0), "fp_unsol_cb: s_id=%x,"
	    " d_id=%x, type=%x, r_ctl=%x, f_ctl=%x"
	    " seq_id=%x, df_ctl=%x, seq_cnt=%x, ox_id=%x, rx_id=%x"
	    " ro=%x, buffer[0]:%x", buf->ub_frame.s_id, buf->ub_frame.d_id,
	    buf->ub_frame.type, buf->ub_frame.r_ctl, buf->ub_frame.f_ctl,
	    buf->ub_frame.seq_id, buf->ub_frame.df_ctl, buf->ub_frame.seq_cnt,
	    buf->ub_frame.ox_id, buf->ub_frame.rx_id, buf->ub_frame.ro,
	    buf->ub_buffer[0]);

	if (type & 0x80000000) {
		/*
		 * Huh ? Nothing much can be done without
		 * a valid buffer. So just exit.
		 */
		return;
	}
	/*
	 * If the unsolicited interrupts arrive while it isn't
	 * safe to handle unsolicited callbacks; Drop them, yes,
	 * drop them on the floor
	 */
	mutex_enter(&port->fp_mutex);
	port->fp_active_ubs++;
	if ((port->fp_soft_state &
	    (FP_SOFT_IN_DETACH | FP_SOFT_SUSPEND | FP_SOFT_POWER_DOWN)) ||
	    FC_PORT_STATE_MASK(port->fp_state) == FC_STATE_OFFLINE) {

		FP_TRACE(FP_NHEAD1(3, 0), "fp_unsol_cb: port state is "
		    "not ONLINE. s_id=%x, d_id=%x, type=%x, "
		    "seq_id=%x, ox_id=%x, rx_id=%x"
		    "ro=%x", buf->ub_frame.s_id, buf->ub_frame.d_id,
		    buf->ub_frame.type, buf->ub_frame.seq_id,
		    buf->ub_frame.ox_id, buf->ub_frame.rx_id, buf->ub_frame.ro);

		ASSERT(port->fp_active_ubs > 0);
		if (--(port->fp_active_ubs) == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB;
		}

		mutex_exit(&port->fp_mutex);

		port->fp_fca_tran->fca_ub_release(port->fp_fca_handle,
		    1, &buf->ub_token);

		return;
	}

	r_ctl = buf->ub_frame.r_ctl;
	s_id = buf->ub_frame.s_id;
	if (port->fp_active_ubs == 1) {
		port->fp_soft_state |= FP_SOFT_IN_UNSOL_CB;
	}

	if (r_ctl == R_CTL_ELS_REQ && buf->ub_buffer[0] == LA_ELS_LOGO &&
	    port->fp_statec_busy) {
		mutex_exit(&port->fp_mutex);
		pd = fctl_get_remote_port_by_did(port, s_id);
		if (pd) {
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
				FP_TRACE(FP_NHEAD1(3, 0),
				    "LOGO for LOGGED IN D_ID %x",
				    buf->ub_frame.s_id);
				pd->pd_state = PORT_DEVICE_VALID;
			}
			mutex_exit(&pd->pd_mutex);
		}

		mutex_enter(&port->fp_mutex);
		ASSERT(port->fp_active_ubs > 0);
		if (--(port->fp_active_ubs) == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB;
		}
		mutex_exit(&port->fp_mutex);

		port->fp_fca_tran->fca_ub_release(port->fp_fca_handle,
		    1, &buf->ub_token);

		FP_TRACE(FP_NHEAD1(3, 0),
		    "fp_unsol_cb() bailing out LOGO for D_ID %x",
		    buf->ub_frame.s_id);
		return;
	}

	if (port->fp_els_resp_pkt_busy == 0) {
		if (r_ctl == R_CTL_ELS_REQ) {
			ls_code = buf->ub_buffer[0];

			switch (ls_code) {
			case LA_ELS_PLOGI:
			case LA_ELS_FLOGI:
				port->fp_els_resp_pkt_busy = 1;
				mutex_exit(&port->fp_mutex);
				fp_i_handle_unsol_els(port, buf);

				mutex_enter(&port->fp_mutex);
				ASSERT(port->fp_active_ubs > 0);
				if (--(port->fp_active_ubs) == 0) {
					port->fp_soft_state &=
					    ~FP_SOFT_IN_UNSOL_CB;
				}
				mutex_exit(&port->fp_mutex);
				port->fp_fca_tran->fca_ub_release(
				    port->fp_fca_handle, 1, &buf->ub_token);

				return;
			case LA_ELS_RSCN:
				if (++(port)->fp_rscn_count ==
				    FC_INVALID_RSCN_COUNT) {
					++(port)->fp_rscn_count;
				}
				rscn_count = port->fp_rscn_count;
				break;

			default:
				break;
			}
		}
	} else if ((r_ctl == R_CTL_ELS_REQ) &&
	    (buf->ub_buffer[0] == LA_ELS_RSCN)) {
		if (++port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			++port->fp_rscn_count;
		}
		rscn_count = port->fp_rscn_count;
	}

	mutex_exit(&port->fp_mutex);

	switch (r_ctl & R_CTL_ROUTING) {
	case R_CTL_DEVICE_DATA:
		/*
		 * If the unsolicited buffer is a CT IU,
		 * have the job_handler thread work on it.
		 */
		if (buf->ub_frame.type == FC_TYPE_FC_SERVICES) {
			break;
		}
		/* FALLTHROUGH */

	case R_CTL_FC4_SVC: {
		int sendup = 0;

		/*
		 * If a LOGIN isn't performed before this request
		 * shut the door on this port with a reply that a
		 * LOGIN is required. We make an exception however
		 * for IP broadcast packets and pass them through
		 * to the IP ULP(s) to handle broadcast requests.
		 * This is not a problem for private loop devices
		 * but for fabric topologies we don't log into the
		 * remote ports during port initialization and
		 * the ULPs need to log into requesting ports on
		 * demand.
		 */
		pd = fctl_get_remote_port_by_did(port, s_id);
		if (pd) {
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
				sendup++;
			}
			mutex_exit(&pd->pd_mutex);
		} else if ((pd == NULL) &&
		    (buf->ub_frame.type == FC_TYPE_IS8802_SNAP) &&
		    (buf->ub_frame.d_id == 0xffffff ||
		    buf->ub_frame.d_id == 0x00)) {
			/* brodacst IP frame - so sendup via job thread */
			break;
		}

		/*
		 * Send all FC4 services via job thread too
		 */
		if ((r_ctl & R_CTL_ROUTING) == R_CTL_FC4_SVC) {
			break;
		}

		if (sendup || !FC_IS_REAL_DEVICE(s_id)) {
			fctl_ulp_unsol_cb(port, buf, buf->ub_frame.type);
			return;
		}

		if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
			cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t),
			    0, KM_NOSLEEP, pd);
			if (cmd != NULL) {
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_LOGIN_REQUIRED, NULL);

				if (fp_sendcmd(port, cmd,
				    port->fp_fca_handle) != FC_SUCCESS) {
					fp_free_pkt(cmd);
				}
			}
		}

		mutex_enter(&port->fp_mutex);
		ASSERT(port->fp_active_ubs > 0);
		if (--(port->fp_active_ubs) == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB;
		}
		mutex_exit(&port->fp_mutex);
		port->fp_fca_tran->fca_ub_release(port->fp_fca_handle,
		    1, &buf->ub_token);

		return;
	}

	default:
		break;
	}

	/*
	 * Submit a Request to the job_handler thread to work
	 * on the unsolicited request. The potential side effect
	 * of this is that the unsolicited buffer takes a little
	 * longer to get released but we save interrupt time in
	 * the bargain.
	 */
	cb_arg = (rscn_count == FC_INVALID_RSCN_COUNT) ? NULL : rscn_count;

	/*
	 * One way that the rscn_count will get used is described below :
	 *
	 * 1. fp_unsol_cb() gets an RSCN and updates fp_rscn_count.
	 * 2. Before mutex is released, a copy of it is stored in rscn_count.
	 * 3. The count is passed to job thread as JOB_UNSOL_REQUEST (below)
	 *    by overloading the job_cb_arg to pass the rscn_count
	 * 4. When one of the routines processing the RSCN picks it up (ex:
	 *    fp_validate_rscn_page()), it passes this count in the map
	 *    structure (as part of the map_rscn_info structure member) to the
	 *    ULPs.
	 * 5. When ULPs make calls back to the transport (example interfaces for
	 *    this are fc_ulp_transport(), fc_ulp_login(), fc_issue_els()), they
	 *    can now pass back this count as part of the fc_packet's
	 *    pkt_ulp_rscn_count member. fcp does this currently.
	 * 6. When transport gets a call to transport a command on the wire, it
	 *    will check to see if there is a valid pkt_ulp_rsvd1 field in the
	 *    fc_packet. If there is, it will match that info with the current
	 *    rscn_count on that instance of the port. If they don't match up
	 *    then there was a newer RSCN. The ULP gets back an error code which
	 *    informs it about it - FC_DEVICE_BUSY_NEW_RSCN.
	 * 7. At this point the ULP is free to make up its own mind as to how to
	 *    handle this. Currently, fcp will reset its retry counters and keep
	 *    retrying the operation it was doing in anticipation of getting a
	 *    new state change call back for the new RSCN.
	 */
	job = fctl_alloc_job(JOB_UNSOL_REQUEST, 0, NULL,
	    (opaque_t)(uintptr_t)cb_arg, KM_NOSLEEP);
	if (job == NULL) {
		fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL, "fp_unsol_cb() "
		    "couldn't submit a job to the thread, failing..");

		mutex_enter(&port->fp_mutex);

		if (--port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			--port->fp_rscn_count;
		}

		ASSERT(port->fp_active_ubs > 0);
		if (--(port->fp_active_ubs) == 0) {
			port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB;
		}

		mutex_exit(&port->fp_mutex);
		port->fp_fca_tran->fca_ub_release(port->fp_fca_handle,
		    1, &buf->ub_token);

		return;
	}
	job->job_private = (void *)buf;
	fctl_enque_job(port, job);
}


/*
 * Handle unsolicited requests
 */
static void
fp_handle_unsol_buf(fc_local_port_t *port, fc_unsol_buf_t *buf,
    job_request_t *job)
{
	uchar_t			r_ctl;
	uchar_t			ls_code;
	uint32_t		s_id;
	fp_cmd_t		*cmd;
	fc_remote_port_t 	*pd;
	fp_unsol_spec_t		*ub_spec;

	r_ctl = buf->ub_frame.r_ctl;
	s_id = buf->ub_frame.s_id;

	switch (r_ctl & R_CTL_ROUTING) {
	case R_CTL_EXTENDED_SVC:
		if (r_ctl != R_CTL_ELS_REQ) {
			break;
		}

		ls_code = buf->ub_buffer[0];
		switch (ls_code) {
		case LA_ELS_LOGO:
		case LA_ELS_ADISC:
		case LA_ELS_PRLO:
			pd = fctl_get_remote_port_by_did(port, s_id);
			if (pd == NULL) {
				if (!FC_IS_REAL_DEVICE(s_id)) {
					break;
				}
				if (!FP_IS_CLASS_1_OR_2(buf->ub_class)) {
					break;
				}
				if ((cmd = fp_alloc_pkt(port,
				    sizeof (la_els_rjt_t), 0, KM_SLEEP,
				    NULL)) == NULL) {
					/*
					 * Can this actually fail when
					 * given KM_SLEEP?  (Could be used
					 * this way in a number of places.)
					 */
					break;
				}

				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_INVALID_LINK_CTRL, job);

				if (fp_sendcmd(port, cmd,
				    port->fp_fca_handle) != FC_SUCCESS) {
					fp_free_pkt(cmd);
				}

				break;
			}
			if (ls_code == LA_ELS_LOGO) {
				fp_handle_unsol_logo(port, buf, pd, job);
			} else if (ls_code == LA_ELS_ADISC) {
				fp_handle_unsol_adisc(port, buf, pd, job);
			} else {
				fp_handle_unsol_prlo(port, buf, pd, job);
			}
			break;

		case LA_ELS_PLOGI:
			fp_handle_unsol_plogi(port, buf, job, KM_SLEEP);
			break;

		case LA_ELS_FLOGI:
			fp_handle_unsol_flogi(port, buf, job, KM_SLEEP);
			break;

		case LA_ELS_RSCN:
			fp_handle_unsol_rscn(port, buf, job, KM_SLEEP);
			break;

		default:
			ub_spec = kmem_zalloc(sizeof (*ub_spec), KM_SLEEP);
			ub_spec->port = port;
			ub_spec->buf = buf;

			(void) taskq_dispatch(port->fp_taskq,
			    fp_ulp_unsol_cb, ub_spec, KM_SLEEP);
			return;
		}
		break;

	case R_CTL_BASIC_SVC:
		/*
		 * The unsolicited basic link services could be ABTS
		 * and RMC (Or even a NOP). Just BA_RJT them until
		 * such time there arises a need to handle them more
		 * carefully.
		 */
		if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
			cmd = fp_alloc_pkt(port, sizeof (la_ba_rjt_t),
			    0, KM_SLEEP, NULL);
			if (cmd != NULL) {
				fp_ba_rjt_init(port, cmd, buf, job);
				if (fp_sendcmd(port, cmd,
				    port->fp_fca_handle) != FC_SUCCESS) {
					fp_free_pkt(cmd);
				}
			}
		}
		break;

	case R_CTL_DEVICE_DATA:
		if (buf->ub_frame.type == FC_TYPE_FC_SERVICES) {
			/*
			 * Mostly this is of type FC_TYPE_FC_SERVICES.
			 * As we don't like any Unsolicited FC services
			 * requests, we would do well to RJT them as
			 * well.
			 */
			if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
				cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t),
				    0, KM_SLEEP, NULL);
				if (cmd != NULL) {
					fp_els_rjt_init(port, cmd, buf,
					    FC_ACTION_NON_RETRYABLE,
					    FC_REASON_INVALID_LINK_CTRL, job);

					if (fp_sendcmd(port, cmd,
					    port->fp_fca_handle) !=
					    FC_SUCCESS) {
						fp_free_pkt(cmd);
					}
				}
			}
			break;
		}
		/* FALLTHROUGH */

	case R_CTL_FC4_SVC:
		ub_spec = kmem_zalloc(sizeof (*ub_spec), KM_SLEEP);
		ub_spec->port = port;
		ub_spec->buf = buf;

		(void) taskq_dispatch(port->fp_taskq,
		    fp_ulp_unsol_cb, ub_spec, KM_SLEEP);
		return;

	case R_CTL_LINK_CTL:
		/*
		 * Turn deaf ear on unsolicited link control frames.
		 * Typical unsolicited link control Frame is an LCR
		 * (to reset End to End credit to the default login
		 * value and abort current sequences for all classes)
		 * An intelligent microcode/firmware should handle
		 * this transparently at its level and not pass all
		 * the way up here.
		 *
		 * Possible responses to LCR are R_RDY, F_RJT, P_RJT
		 * or F_BSY. P_RJT is chosen to be the most appropriate
		 * at this time.
		 */
		/* FALLTHROUGH */

	default:
		/*
		 * Just reject everything else as an invalid request.
		 */
		if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
			cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t),
			    0, KM_SLEEP, NULL);
			if (cmd != NULL) {
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_INVALID_LINK_CTRL, job);

				if (fp_sendcmd(port, cmd,
				    port->fp_fca_handle) != FC_SUCCESS) {
					fp_free_pkt(cmd);
				}
			}
		}
		break;
	}

	mutex_enter(&port->fp_mutex);
	ASSERT(port->fp_active_ubs > 0);
	if (--(port->fp_active_ubs) == 0) {
		port->fp_soft_state &= ~FP_SOFT_IN_UNSOL_CB;
	}
	mutex_exit(&port->fp_mutex);
	port->fp_fca_tran->fca_ub_release(port->fp_fca_handle,
	    1, &buf->ub_token);
}


/*
 * Prepare a BA_RJT and send it over.
 */
static void
fp_ba_rjt_init(fc_local_port_t *port, fp_cmd_t *cmd, fc_unsol_buf_t *buf,
    job_request_t *job)
{
	fc_packet_t	*pkt;
	la_ba_rjt_t 	payload;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	cmd->cmd_pkt.pkt_tran_flags = buf->ub_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_OUTBOUND;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	cmd->cmd_job = job;

	pkt = &cmd->cmd_pkt;

	fp_unsol_resp_init(pkt, buf, R_CTL_LS_BA_RJT, FC_TYPE_BASIC_LS);

	payload.reserved = 0;
	payload.reason_code = FC_REASON_CMD_UNSUPPORTED;
	payload.explanation = FC_EXPLN_NONE;
	payload.vendor = 0;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}


/*
 * Prepare an LS_RJT and send it over
 */
static void
fp_els_rjt_init(fc_local_port_t *port, fp_cmd_t *cmd, fc_unsol_buf_t *buf,
    uchar_t action, uchar_t reason, job_request_t *job)
{
	fc_packet_t	*pkt;
	la_els_rjt_t 	payload;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	cmd->cmd_pkt.pkt_tran_flags = buf->ub_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_OUTBOUND;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	cmd->cmd_job = job;

	pkt = &cmd->cmd_pkt;

	fp_unsol_resp_init(pkt, buf, R_CTL_ELS_RSP, FC_TYPE_EXTENDED_LS);

	payload.ls_code.ls_code = LA_ELS_RJT;
	payload.ls_code.mbz = 0;
	payload.action = action;
	payload.reason = reason;
	payload.reserved = 0;
	payload.vu = 0;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}

/*
 *     Function: fp_prlo_acc_init
 *
 *  Description: Initializes an Link Service Accept for a PRLO.
 *
 *    Arguments: *port		Local port through which the PRLO was
 *				received.
 *		 cmd		Command that will carry the accept.
 *		 *buf		Unsolicited buffer containing the PRLO
 *				request.
 *		 job		Job request.
 *		 sleep		Allocation mode.
 *
 * Return Value: *cmd		Command containing the response.
 *
 *      Context: Depends on the parameter sleep.
 */
fp_cmd_t *
fp_prlo_acc_init(fc_local_port_t *port, fc_remote_port_t *pd,
    fc_unsol_buf_t *buf, job_request_t *job, int sleep)
{
	fp_cmd_t	*cmd;
	fc_packet_t	*pkt;
	la_els_prlo_t	*req;
	size_t		len;
	uint16_t	flags;

	req = (la_els_prlo_t *)buf->ub_buffer;
	len = (size_t)ntohs(req->payload_length);

	/*
	 * The payload of the accept to a PRLO has to be the exact match of
	 * the payload of the request (at the exception of the code).
	 */
	cmd = fp_alloc_pkt(port, (int)len, 0, sleep, pd);

	if (cmd) {
		/*
		 * The fp command was successfully allocated.
		 */
		cmd->cmd_pkt.pkt_tran_flags = buf->ub_class;
		cmd->cmd_pkt.pkt_tran_type = FC_PKT_OUTBOUND;
		cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
		cmd->cmd_retry_count = 1;
		cmd->cmd_ulp_pkt = NULL;

		cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
		cmd->cmd_job = job;

		pkt = &cmd->cmd_pkt;

		fp_unsol_resp_init(pkt, buf, R_CTL_ELS_RSP,
		    FC_TYPE_EXTENDED_LS);

		/* The code is overwritten for the copy. */
		req->ls_code = LA_ELS_ACC;
		/* Response code is set. */
		flags = ntohs(req->flags);
		flags &= ~SP_RESP_CODE_MASK;
		flags |= SP_RESP_CODE_REQ_EXECUTED;
		req->flags = htons(flags);

		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)req,
		    (uint8_t *)pkt->pkt_cmd, len, DDI_DEV_AUTOINCR);
	}
	return (cmd);
}

/*
 * Prepare an ACC response to an ELS request
 */
static void
fp_els_acc_init(fc_local_port_t *port, fp_cmd_t *cmd, fc_unsol_buf_t *buf,
    job_request_t *job)
{
	fc_packet_t	*pkt;
	ls_code_t	payload;

	cmd->cmd_pkt.pkt_tran_flags = buf->ub_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_OUTBOUND;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	cmd->cmd_job = job;

	pkt = &cmd->cmd_pkt;

	fp_unsol_resp_init(pkt, buf, R_CTL_ELS_RSP, FC_TYPE_EXTENDED_LS);

	payload.ls_code = LA_ELS_ACC;
	payload.mbz = 0;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}

/*
 * Unsolicited PRLO handler
 *
 * A Process Logout should be handled by the ULP that established it.  However,
 * some devices send a PRLO to trigger a PLOGI followed by a PRLI.  This happens
 * when a device implicitly logs out an initiator (for whatever reason) and
 * tries to get that initiator to restablish the connection (PLOGI and PRLI).
 * The logical thing to do for the device would be to send a LOGO in response
 * to any FC4 frame sent by the initiator. Some devices choose, however, to send
 * a PRLO instead.
 *
 * From a Fibre Channel standpoint a PRLO calls for a PRLI. There's no reason to
 * think that the Port Login has been lost.  If we follow the Fibre Channel
 * protocol to the letter a PRLI should be sent after accepting the PRLO.  If
 * the Port Login has also been lost, the remote port will reject the PRLI
 * indicating that we must PLOGI first.  The initiator will then turn around and
 * send a PLOGI.  The way Leadville is layered and the way the ULP interface
 * is defined doesn't allow this scenario to be followed easily.  If FCP were to
 * handle the PRLO and attempt the PRLI, the reject indicating that a PLOGI is
 * needed would be received by FCP. FCP would have, then, to tell the transport
 * (fp) to PLOGI.  The problem is, the transport would still think the Port
 * Login is valid and there is no way for FCP to tell the transport: "PLOGI even
 * if you think it's not necessary".  To work around that difficulty, the PRLO
 * is treated by the transport as a LOGO.  The downside to it is a Port Login
 * may be disrupted (if a PLOGI wasn't actually needed) and another ULP (that
 * has nothing to do with the PRLO) may be impacted.  However, this is a
 * scenario very unlikely to happen.  As of today the only ULP in Leadville
 * using PRLI/PRLOs is FCP.  For a PRLO to disrupt another ULP (that would be
 * FCIP), a SCSI target would have to be running FCP and FCIP (which is very
 * unlikely).
 */
static void
fp_handle_unsol_prlo(fc_local_port_t *port, fc_unsol_buf_t *buf,
    fc_remote_port_t *pd, job_request_t *job)
{
	int		busy;
	int		rval;
	int		retain;
	fp_cmd_t	*cmd;
	fc_portmap_t 	*listptr;
	boolean_t	tolerance;
	la_els_prlo_t	*req;

	req = (la_els_prlo_t *)buf->ub_buffer;

	if ((ntohs(req->payload_length) !=
	    (sizeof (service_parameter_page_t) + sizeof (ls_code_t))) ||
	    (req->page_length != sizeof (service_parameter_page_t))) {
		/*
		 * We are being very restrictive.  Only on page per
		 * payload.  If it is not the case we reject the ELS although
		 * we should reply indicating we handle only single page
		 * per PRLO.
		 */
		goto fp_reject_prlo;
	}

	if (ntohs(req->payload_length) > buf->ub_bufsize) {
		/*
		 * This is in case the payload advertizes a size bigger than
		 * what it really is.
		 */
		goto fp_reject_prlo;
	}

	mutex_enter(&port->fp_mutex);
	busy = port->fp_statec_busy;
	mutex_exit(&port->fp_mutex);

	mutex_enter(&pd->pd_mutex);
	tolerance = fctl_tc_increment(&pd->pd_logo_tc);
	if (!busy) {
		if (pd->pd_state != PORT_DEVICE_LOGGED_IN ||
		    pd->pd_state == PORT_DEVICE_INVALID ||
		    pd->pd_flags == PD_ELS_IN_PROGRESS ||
		    pd->pd_type == PORT_DEVICE_OLD) {
			busy++;
		}
	}

	if (busy) {
		mutex_exit(&pd->pd_mutex);

		FP_TRACE(FP_NHEAD1(5, 0), "Logout; D_ID=%x,"
		    "pd=%p - busy",
		    pd->pd_port_id.port_id, pd);

		if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
			goto fp_reject_prlo;
		}
	} else {
		retain = (pd->pd_recepient == PD_PLOGI_INITIATOR) ? 1 : 0;

		if (tolerance) {
			fctl_tc_reset(&pd->pd_logo_tc);
			retain = 0;
			pd->pd_state = PORT_DEVICE_INVALID;
		}

		FP_TRACE(FP_NHEAD1(5, 0), "Accepting LOGO; d_id=%x, pd=%p,"
		    " tolerance=%d retain=%d", pd->pd_port_id.port_id, pd,
		    tolerance, retain);

		pd->pd_aux_flags |= PD_LOGGED_OUT;
		mutex_exit(&pd->pd_mutex);

		cmd = fp_prlo_acc_init(port, pd, buf, job, KM_SLEEP);
		if (cmd == NULL) {
			return;
		}

		rval = fp_sendcmd(port, cmd, port->fp_fca_handle);
		if (rval != FC_SUCCESS) {
			fp_free_pkt(cmd);
			return;
		}

		listptr = kmem_zalloc(sizeof (fc_portmap_t), KM_SLEEP);

		if (retain) {
			fp_unregister_login(pd);
			fctl_copy_portmap(listptr, pd);
		} else {
			uint32_t 	d_id;
			char 		ww_name[17];

			mutex_enter(&pd->pd_mutex);
			d_id = pd->pd_port_id.port_id;
			fc_wwn_to_str(&pd->pd_port_name, ww_name);
			mutex_exit(&pd->pd_mutex);

			FP_TRACE(FP_NHEAD2(9, 0),
			    "N_x Port with D_ID=%x, PWWN=%s logged out"
			    " %d times in %d us; Giving up", d_id, ww_name,
			    FC_LOGO_TOLERANCE_LIMIT,
			    FC_LOGO_TOLERANCE_TIME_LIMIT);

			fp_fillout_old_map(listptr, pd, 0);
			listptr->map_type = PORT_DEVICE_OLD;
		}

		(void) fp_ulp_devc_cb(port, listptr, 1, 1, KM_SLEEP, 0);
		return;
	}

fp_reject_prlo:

	cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t), 0, KM_SLEEP, pd);
	if (cmd != NULL) {
		fp_els_rjt_init(port, cmd, buf, FC_ACTION_NON_RETRYABLE,
		    FC_REASON_INVALID_LINK_CTRL, job);

		if (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS) {
			fp_free_pkt(cmd);
		}
	}
}

/*
 * Unsolicited LOGO handler
 */
static void
fp_handle_unsol_logo(fc_local_port_t *port, fc_unsol_buf_t *buf,
    fc_remote_port_t *pd, job_request_t *job)
{
	int		busy;
	int		rval;
	int		retain;
	fp_cmd_t	*cmd;
	fc_portmap_t 	*listptr;
	boolean_t	tolerance;

	mutex_enter(&port->fp_mutex);
	busy = port->fp_statec_busy;
	mutex_exit(&port->fp_mutex);

	mutex_enter(&pd->pd_mutex);
	tolerance = fctl_tc_increment(&pd->pd_logo_tc);
	if (!busy) {
		if (pd->pd_state != PORT_DEVICE_LOGGED_IN ||
		    pd->pd_state == PORT_DEVICE_INVALID ||
		    pd->pd_flags == PD_ELS_IN_PROGRESS ||
		    pd->pd_type == PORT_DEVICE_OLD) {
			busy++;
		}
	}

	if (busy) {
		mutex_exit(&pd->pd_mutex);

		FP_TRACE(FP_NHEAD1(5, 0), "Logout; D_ID=%x,"
		    "pd=%p - busy",
		    pd->pd_port_id.port_id, pd);

		if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
			cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t),
			    0, KM_SLEEP, pd);
			if (cmd != NULL) {
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_INVALID_LINK_CTRL, job);

				if (fp_sendcmd(port, cmd,
				    port->fp_fca_handle) != FC_SUCCESS) {
					fp_free_pkt(cmd);
				}
			}
		}
	} else {
		retain = (pd->pd_recepient == PD_PLOGI_INITIATOR) ? 1 : 0;

		if (tolerance) {
			fctl_tc_reset(&pd->pd_logo_tc);
			retain = 0;
			pd->pd_state = PORT_DEVICE_INVALID;
		}

		FP_TRACE(FP_NHEAD1(5, 0), "Accepting LOGO; d_id=%x, pd=%p,"
		    " tolerance=%d retain=%d", pd->pd_port_id.port_id, pd,
		    tolerance, retain);

		pd->pd_aux_flags |= PD_LOGGED_OUT;
		mutex_exit(&pd->pd_mutex);

		cmd = fp_alloc_pkt(port, FP_PORT_IDENTIFIER_LEN, 0,
		    KM_SLEEP, pd);
		if (cmd == NULL) {
			return;
		}

		fp_els_acc_init(port, cmd, buf, job);

		rval = fp_sendcmd(port, cmd, port->fp_fca_handle);
		if (rval != FC_SUCCESS) {
			fp_free_pkt(cmd);
			return;
		}

		listptr = kmem_zalloc(sizeof (fc_portmap_t), KM_SLEEP);

		if (retain) {
			job_request_t	*job;
			fctl_ns_req_t	*ns_cmd;

			/*
			 * when get LOGO, first try to get PID from nameserver
			 * if failed, then we do not need
			 * send PLOGI to that remote port
			 */
			job = fctl_alloc_job(
			    JOB_NS_CMD, 0, NULL, (opaque_t)port, KM_SLEEP);

			if (job != NULL) {
				ns_cmd = fctl_alloc_ns_cmd(
				    sizeof (ns_req_gid_pn_t),
				    sizeof (ns_resp_gid_pn_t),
				    sizeof (ns_resp_gid_pn_t),
				    0, KM_SLEEP);
				if (ns_cmd != NULL) {
					int ret;
					job->job_result = FC_SUCCESS;
					ns_cmd->ns_cmd_code = NS_GID_PN;
					((ns_req_gid_pn_t *)
					    (ns_cmd->ns_cmd_buf))->pwwn =
					    pd->pd_port_name;
					ret = fp_ns_query(
					    port, ns_cmd, job, 1, KM_SLEEP);
					if ((ret != FC_SUCCESS) ||
					    (job->job_result != FC_SUCCESS)) {
						fctl_free_ns_cmd(ns_cmd);
						fctl_dealloc_job(job);
						FP_TRACE(FP_NHEAD2(9, 0),
						    "NS query failed,",
						    " delete pd");
						goto delete_pd;
					}
					fctl_free_ns_cmd(ns_cmd);
				}
				fctl_dealloc_job(job);
			}
			fp_unregister_login(pd);
			fctl_copy_portmap(listptr, pd);
		} else {
			uint32_t 	d_id;
			char 		ww_name[17];

delete_pd:
			mutex_enter(&pd->pd_mutex);
			d_id = pd->pd_port_id.port_id;
			fc_wwn_to_str(&pd->pd_port_name, ww_name);
			mutex_exit(&pd->pd_mutex);

			FP_TRACE(FP_NHEAD2(9, 0),
			    "N_x Port with D_ID=%x, PWWN=%s logged out"
			    " %d times in %d us; Giving up", d_id, ww_name,
			    FC_LOGO_TOLERANCE_LIMIT,
			    FC_LOGO_TOLERANCE_TIME_LIMIT);

			fp_fillout_old_map(listptr, pd, 0);
			listptr->map_type = PORT_DEVICE_OLD;
		}

		(void) fp_ulp_devc_cb(port, listptr, 1, 1, KM_SLEEP, 0);
	}
}


/*
 * Perform general purpose preparation of a response to an unsolicited request
 */
static void
fp_unsol_resp_init(fc_packet_t *pkt, fc_unsol_buf_t *buf,
    uchar_t r_ctl, uchar_t type)
{
	pkt->pkt_cmd_fhdr.r_ctl = r_ctl;
	pkt->pkt_cmd_fhdr.d_id = buf->ub_frame.s_id;
	pkt->pkt_cmd_fhdr.s_id = buf->ub_frame.d_id;
	pkt->pkt_cmd_fhdr.type = type;
	pkt->pkt_cmd_fhdr.f_ctl = F_CTL_LAST_SEQ | F_CTL_XCHG_CONTEXT;
	pkt->pkt_cmd_fhdr.seq_id = buf->ub_frame.seq_id;
	pkt->pkt_cmd_fhdr.df_ctl  = buf->ub_frame.df_ctl;
	pkt->pkt_cmd_fhdr.seq_cnt = buf->ub_frame.seq_cnt;
	pkt->pkt_cmd_fhdr.ox_id = buf->ub_frame.ox_id;
	pkt->pkt_cmd_fhdr.rx_id = buf->ub_frame.rx_id;
	pkt->pkt_cmd_fhdr.ro = 0;
	pkt->pkt_cmd_fhdr.rsvd = 0;
	pkt->pkt_comp = fp_unsol_intr;
	pkt->pkt_timeout = FP_ELS_TIMEOUT;
}

/*
 * Immediate handling of unsolicited FLOGI and PLOGI requests. In the
 * early development days of public loop soc+ firmware, numerous problems
 * were encountered (the details are undocumented and history now) which
 * led to the birth of this function.
 *
 * If a pre-allocated unsolicited response packet is free, send out an
 * immediate response, otherwise submit the request to the port thread
 * to do the deferred processing.
 */
static void
fp_i_handle_unsol_els(fc_local_port_t *port, fc_unsol_buf_t *buf)
{
	int			sent;
	int 			f_port;
	int			do_acc;
	fp_cmd_t 		*cmd;
	la_els_logi_t 		*payload;
	fc_remote_port_t	*pd;
	char			dww_name[17];

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	cmd = port->fp_els_resp_pkt;

	mutex_enter(&port->fp_mutex);
	do_acc = (port->fp_statec_busy == 0) ? 1 : 0;
	mutex_exit(&port->fp_mutex);

	switch (buf->ub_buffer[0]) {
	case LA_ELS_PLOGI: {
		int small;

		payload = (la_els_logi_t *)buf->ub_buffer;

		f_port = FP_IS_F_PORT(payload->
		    common_service.cmn_features) ? 1 : 0;

		small = fctl_wwn_cmp(&port->fp_service_params.nport_ww_name,
		    &payload->nport_ww_name);
		pd = fctl_get_remote_port_by_pwwn(port,
		    &payload->nport_ww_name);
		if (pd) {
			mutex_enter(&pd->pd_mutex);
			sent = (pd->pd_flags == PD_ELS_IN_PROGRESS) ? 1 : 0;
			/*
			 * Most likely this means a cross login is in
			 * progress or a device about to be yanked out.
			 * Only accept the plogi if my wwn is smaller.
			 */
			if (pd->pd_type == PORT_DEVICE_OLD) {
				sent = 1;
			}
			/*
			 * Stop plogi request (if any)
			 * attempt from local side to speedup
			 * the discovery progress.
			 * Mark the pd as PD_PLOGI_RECEPIENT.
			 */
			if (f_port == 0 && small < 0) {
				pd->pd_recepient = PD_PLOGI_RECEPIENT;
			}
			fc_wwn_to_str(&pd->pd_port_name, dww_name);

			mutex_exit(&pd->pd_mutex);

			FP_TRACE(FP_NHEAD1(3, 0), "fp_i_handle_unsol_els: "
			    "Unsol PLOGI received. PD still exists in the "
			    "PWWN list. pd=%p PWWN=%s, sent=%x",
			    pd, dww_name, sent);

			if (f_port == 0 && small < 0) {
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_i_handle_unsol_els: Mark the pd"
				    " as plogi recipient, pd=%p, PWWN=%s"
				    ", sent=%x",
				    pd, dww_name, sent);
			}
		} else {
			sent = 0;
		}

		/*
		 * To avoid Login collisions, accept only if my WWN
		 * is smaller than the requester (A curious side note
		 * would be that this rule may not satisfy the PLOGIs
		 * initiated by the switch from not-so-well known
		 * ports such as 0xFFFC41)
		 */
		if ((f_port == 0 && small < 0) ||
		    (((small > 0 && do_acc) ||
		    FC_MUST_ACCEPT_D_ID(buf->ub_frame.s_id)) && sent == 0)) {
			if (fp_is_class_supported(port->fp_cos,
			    buf->ub_class) == FC_FAILURE) {
				if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
					cmd->cmd_pkt.pkt_cmdlen =
					    sizeof (la_els_rjt_t);
					cmd->cmd_pkt.pkt_rsplen = 0;
					fp_els_rjt_init(port, cmd, buf,
					    FC_ACTION_NON_RETRYABLE,
					    FC_REASON_CLASS_NOT_SUPP, NULL);
					FP_TRACE(FP_NHEAD1(3, 0),
					    "fp_i_handle_unsol_els: "
					    "Unsupported class. "
					    "Rejecting PLOGI");

				} else {
					mutex_enter(&port->fp_mutex);
					port->fp_els_resp_pkt_busy = 0;
					mutex_exit(&port->fp_mutex);
					return;
				}
			} else {
				cmd->cmd_pkt.pkt_cmdlen =
				    sizeof (la_els_logi_t);
				cmd->cmd_pkt.pkt_rsplen = 0;

				/*
				 * Sometime later, we should validate
				 * the service parameters instead of
				 * just accepting it.
				 */
				fp_login_acc_init(port, cmd, buf, NULL,
				    KM_NOSLEEP);
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_i_handle_unsol_els: Accepting PLOGI,"
				    " f_port=%d, small=%d, do_acc=%d,"
				    " sent=%d.", f_port, small, do_acc,
				    sent);
				/*
				 * If fp_port_id is zero and topology is
				 * Point-to-Point, get the local port id from
				 * the d_id in the PLOGI request.
				 * If the outgoing FLOGI hasn't been accepted,
				 * the topology will be unknown here. But it's
				 * still safe to save the d_id to fp_port_id,
				 * just because it will be overwritten later
				 * if the topology is not Point-to-Point.
				 */
				mutex_enter(&port->fp_mutex);
				if ((port->fp_port_id.port_id == 0) &&
				    (port->fp_topology == FC_TOP_PT_PT ||
				    port->fp_topology == FC_TOP_UNKNOWN)) {
					port->fp_port_id.port_id =
					    buf->ub_frame.d_id;
				}
				mutex_exit(&port->fp_mutex);
			}
		} else {
			if (FP_IS_CLASS_1_OR_2(buf->ub_class) ||
			    port->fp_options & FP_SEND_RJT) {
				cmd->cmd_pkt.pkt_cmdlen = sizeof (la_els_rjt_t);
				cmd->cmd_pkt.pkt_rsplen = 0;
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_LOGICAL_BSY, NULL);
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_i_handle_unsol_els: "
				    "Rejecting PLOGI with Logical Busy."
				    "Possible Login collision.");
			} else {
				mutex_enter(&port->fp_mutex);
				port->fp_els_resp_pkt_busy = 0;
				mutex_exit(&port->fp_mutex);
				return;
			}
		}
		break;
	}

	case LA_ELS_FLOGI:
		if (fp_is_class_supported(port->fp_cos,
		    buf->ub_class) == FC_FAILURE) {
			if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
				cmd->cmd_pkt.pkt_cmdlen = sizeof (la_els_rjt_t);
				cmd->cmd_pkt.pkt_rsplen = 0;
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_CLASS_NOT_SUPP, NULL);
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_i_handle_unsol_els: "
				    "Unsupported Class. Rejecting FLOGI.");
			} else {
				mutex_enter(&port->fp_mutex);
				port->fp_els_resp_pkt_busy = 0;
				mutex_exit(&port->fp_mutex);
				return;
			}
		} else {
			mutex_enter(&port->fp_mutex);
			if (FC_PORT_STATE_MASK(port->fp_state) !=
			    FC_STATE_ONLINE || (port->fp_port_id.port_id &&
			    buf->ub_frame.s_id == port->fp_port_id.port_id)) {
				mutex_exit(&port->fp_mutex);
				if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
					cmd->cmd_pkt.pkt_cmdlen =
					    sizeof (la_els_rjt_t);
					cmd->cmd_pkt.pkt_rsplen = 0;
					fp_els_rjt_init(port, cmd, buf,
					    FC_ACTION_NON_RETRYABLE,
					    FC_REASON_INVALID_LINK_CTRL,
					    NULL);
					FP_TRACE(FP_NHEAD1(3, 0),
					    "fp_i_handle_unsol_els: "
					    "Invalid Link Ctrl. "
					    "Rejecting FLOGI.");
				} else {
					mutex_enter(&port->fp_mutex);
					port->fp_els_resp_pkt_busy = 0;
					mutex_exit(&port->fp_mutex);
					return;
				}
			} else {
				mutex_exit(&port->fp_mutex);
				cmd->cmd_pkt.pkt_cmdlen =
				    sizeof (la_els_logi_t);
				cmd->cmd_pkt.pkt_rsplen = 0;
				/*
				 * Let's not aggressively validate the N_Port's
				 * service parameters until PLOGI. Suffice it
				 * to give a hint that we are an N_Port and we
				 * are game to some serious stuff here.
				 */
				fp_login_acc_init(port, cmd, buf,
				    NULL, KM_NOSLEEP);
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_i_handle_unsol_els: "
				    "Accepting FLOGI.");
			}
		}
		break;

	default:
		return;
	}

	if ((fp_sendcmd(port, cmd, port->fp_fca_handle)) != FC_SUCCESS) {
		mutex_enter(&port->fp_mutex);
		port->fp_els_resp_pkt_busy = 0;
		mutex_exit(&port->fp_mutex);
	}
}


/*
 * Handle unsolicited PLOGI request
 */
static void
fp_handle_unsol_plogi(fc_local_port_t *port, fc_unsol_buf_t *buf,
    job_request_t *job, int sleep)
{
	int			sent;
	int			small;
	int 			f_port;
	int			do_acc;
	fp_cmd_t		*cmd;
	la_wwn_t 		*swwn;
	la_wwn_t		*dwwn;
	la_els_logi_t 		*payload;
	fc_remote_port_t	*pd;
	char			dww_name[17];

	payload = (la_els_logi_t *)buf->ub_buffer;
	f_port = FP_IS_F_PORT(payload->common_service.cmn_features) ? 1 : 0;

	mutex_enter(&port->fp_mutex);
	do_acc = (port->fp_statec_busy == 0) ? 1 : 0;
	mutex_exit(&port->fp_mutex);

	FP_TRACE(FP_NHEAD1(3, 0), "fp_handle_unsol_plogi: s_id=%x, d_id=%x,"
	    "type=%x, f_ctl=%x"
	    " seq_id=%x, ox_id=%x, rx_id=%x"
	    " ro=%x", buf->ub_frame.s_id, buf->ub_frame.d_id,
	    buf->ub_frame.type, buf->ub_frame.f_ctl, buf->ub_frame.seq_id,
	    buf->ub_frame.ox_id, buf->ub_frame.rx_id, buf->ub_frame.ro);

	swwn = &port->fp_service_params.nport_ww_name;
	dwwn = &payload->nport_ww_name;
	small = fctl_wwn_cmp(swwn, dwwn);
	pd = fctl_get_remote_port_by_pwwn(port, dwwn);
	if (pd) {
		mutex_enter(&pd->pd_mutex);
		sent = (pd->pd_flags == PD_ELS_IN_PROGRESS) ? 1 : 0;
		/*
		 * Most likely this means a cross login is in
		 * progress or a device about to be yanked out.
		 * Only accept the plogi if my wwn is smaller.
		 */

		if (pd->pd_type == PORT_DEVICE_OLD) {
			sent = 1;
		}
		/*
		 * Stop plogi request (if any)
		 * attempt from local side to speedup
		 * the discovery progress.
		 * Mark the pd as PD_PLOGI_RECEPIENT.
		 */
		if (f_port == 0 && small < 0) {
			pd->pd_recepient = PD_PLOGI_RECEPIENT;
		}
		fc_wwn_to_str(&pd->pd_port_name, dww_name);

		mutex_exit(&pd->pd_mutex);

		FP_TRACE(FP_NHEAD1(3, 0), "fp_handle_unsol_plogi: Unsol PLOGI"
		    " received. PD still exists in the PWWN list. pd=%p "
		    "PWWN=%s, sent=%x", pd, dww_name, sent);

		if (f_port == 0 && small < 0) {
			FP_TRACE(FP_NHEAD1(3, 0),
			    "fp_handle_unsol_plogi: Mark the pd"
			    " as plogi recipient, pd=%p, PWWN=%s"
			    ", sent=%x",
			    pd, dww_name, sent);
		}
	} else {
		sent = 0;
	}

	/*
	 * Avoid Login collisions by accepting only if my WWN is smaller.
	 *
	 * A side note: There is no need to start a PLOGI from this end in
	 *	this context if login isn't going to be accepted for the
	 * 	above reason as either a LIP (in private loop), RSCN (in
	 *	fabric topology), or an FLOGI (in point to point - Huh ?
	 *	check FC-PH) would normally drive the PLOGI from this end.
	 *	At this point of time there is no need for an inbound PLOGI
	 *	to kick an outbound PLOGI when it is going to be rejected
	 *	for the reason of WWN being smaller. However it isn't hard
	 *	to do that either (when such a need arises, start a timer
	 *	for a duration that extends beyond a normal device discovery
	 *	time and check if an outbound PLOGI did go before that, if
	 *	none fire one)
	 *
	 *	Unfortunately, as it turned out, during booting, it is possible
	 *	to miss another initiator in the same loop as port driver
	 * 	instances are serially attached. While preserving the above
	 * 	comments for belly laughs, please kick an outbound PLOGI in
	 *	a non-switch environment (which is a pt pt between N_Ports or
	 *	a private loop)
	 *
	 *	While preserving the above comments for amusement, send an
	 *	ACC if the PLOGI is going to be rejected for WWN being smaller
	 *	when no discovery is in progress at this end. Turn around
	 *	and make the port device as the PLOGI initiator, so that
	 *	during subsequent link/loop initialization, this end drives
	 *	the PLOGI (In fact both ends do in this particular case, but
	 *	only one wins)
	 *
	 * Make sure the PLOGIs initiated by the switch from not-so-well-known
	 * ports (such as 0xFFFC41) are accepted too.
	 */
	if ((f_port == 0 && small < 0) || (((small > 0 && do_acc) ||
	    FC_MUST_ACCEPT_D_ID(buf->ub_frame.s_id)) && sent == 0)) {
		if (fp_is_class_supported(port->fp_cos,
		    buf->ub_class) == FC_FAILURE) {
			if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
				cmd = fp_alloc_pkt(port,
				    sizeof (la_els_logi_t), 0, sleep, pd);
				if (cmd == NULL) {
					return;
				}
				cmd->cmd_pkt.pkt_cmdlen = sizeof (la_els_rjt_t);
				cmd->cmd_pkt.pkt_rsplen = 0;
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_CLASS_NOT_SUPP, job);
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_handle_unsol_plogi: "
				    "Unsupported class. rejecting PLOGI");
			}
		} else {
			cmd = fp_alloc_pkt(port, sizeof (la_els_logi_t),
			    0, sleep, pd);
			if (cmd == NULL) {
				return;
			}
			cmd->cmd_pkt.pkt_cmdlen = sizeof (la_els_logi_t);
			cmd->cmd_pkt.pkt_rsplen = 0;

			/*
			 * Sometime later, we should validate the service
			 * parameters instead of just accepting it.
			 */
			fp_login_acc_init(port, cmd, buf, job, KM_SLEEP);
			FP_TRACE(FP_NHEAD1(3, 0), "fp_handle_unsol_plogi: "
			    "Accepting PLOGI, f_port=%d, small=%d, "
			    "do_acc=%d, sent=%d.", f_port, small, do_acc,
			    sent);

			/*
			 * If fp_port_id is zero and topology is
			 * Point-to-Point, get the local port id from
			 * the d_id in the PLOGI request.
			 * If the outgoing FLOGI hasn't been accepted,
			 * the topology will be unknown here. But it's
			 * still safe to save the d_id to fp_port_id,
			 * just because it will be overwritten later
			 * if the topology is not Point-to-Point.
			 */
			mutex_enter(&port->fp_mutex);
			if ((port->fp_port_id.port_id == 0) &&
			    (port->fp_topology == FC_TOP_PT_PT ||
			    port->fp_topology == FC_TOP_UNKNOWN)) {
				port->fp_port_id.port_id =
				    buf->ub_frame.d_id;
			}
			mutex_exit(&port->fp_mutex);
		}
	} else {
		if (FP_IS_CLASS_1_OR_2(buf->ub_class) ||
		    port->fp_options & FP_SEND_RJT) {
			cmd = fp_alloc_pkt(port, sizeof (la_els_logi_t),
			    0, sleep, pd);
			if (cmd == NULL) {
				return;
			}
			cmd->cmd_pkt.pkt_cmdlen = sizeof (la_els_rjt_t);
			cmd->cmd_pkt.pkt_rsplen = 0;
			/*
			 * Send out Logical busy to indicate
			 * the detection of PLOGI collision
			 */
			fp_els_rjt_init(port, cmd, buf,
			    FC_ACTION_NON_RETRYABLE,
			    FC_REASON_LOGICAL_BSY, job);

			fc_wwn_to_str(dwwn, dww_name);
			FP_TRACE(FP_NHEAD1(3, 0), "fp_handle_unsol_plogi: "
			    "Rejecting Unsol PLOGI with Logical Busy."
			    "possible PLOGI collision. PWWN=%s, sent=%x",
			    dww_name, sent);
		} else {
			return;
		}
	}

	if (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS) {
		fp_free_pkt(cmd);
	}
}


/*
 * Handle mischievous turning over of our own FLOGI requests back to
 * us by the SOC+ microcode. In other words, look at the class of such
 * bone headed requests, if 1 or 2, bluntly P_RJT them, if 3 drop them
 * on the floor
 */
static void
fp_handle_unsol_flogi(fc_local_port_t *port, fc_unsol_buf_t *buf,
	job_request_t *job, int sleep)
{
	uint32_t	state;
	uint32_t	s_id;
	fp_cmd_t 	*cmd;

	if (fp_is_class_supported(port->fp_cos, buf->ub_class) == FC_FAILURE) {
		if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
			cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t),
			    0, sleep, NULL);
			if (cmd == NULL) {
				return;
			}
			fp_els_rjt_init(port, cmd, buf,
			    FC_ACTION_NON_RETRYABLE,
			    FC_REASON_CLASS_NOT_SUPP, job);
		} else {
			return;
		}
	} else {

		FP_TRACE(FP_NHEAD1(3, 0), "fp_handle_unsol_flogi:"
		    " s_id=%x, d_id=%x, type=%x, f_ctl=%x"
		    " seq_id=%x, ox_id=%x, rx_id=%x, ro=%x",
		    buf->ub_frame.s_id, buf->ub_frame.d_id,
		    buf->ub_frame.type, buf->ub_frame.f_ctl,
		    buf->ub_frame.seq_id, buf->ub_frame.ox_id,
		    buf->ub_frame.rx_id, buf->ub_frame.ro);

		mutex_enter(&port->fp_mutex);
		state = FC_PORT_STATE_MASK(port->fp_state);
		s_id = port->fp_port_id.port_id;
		mutex_exit(&port->fp_mutex);

		if (state != FC_STATE_ONLINE ||
		    (s_id && buf->ub_frame.s_id == s_id)) {
			if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
				cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t),
				    0, sleep, NULL);
				if (cmd == NULL) {
					return;
				}
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_INVALID_LINK_CTRL, job);
				FP_TRACE(FP_NHEAD1(3, 0),
				    "fp_handle_unsol_flogi: "
				    "Rejecting PLOGI. Invalid Link CTRL");
			} else {
				return;
			}
		} else {
			cmd = fp_alloc_pkt(port, sizeof (la_els_logi_t),
			    0, sleep, NULL);
			if (cmd == NULL) {
				return;
			}
			/*
			 * Let's not aggressively validate the N_Port's
			 * service parameters until PLOGI. Suffice it
			 * to give a hint that we are an N_Port and we
			 * are game to some serious stuff here.
			 */
			fp_login_acc_init(port, cmd, buf, job, KM_SLEEP);
			FP_TRACE(FP_NHEAD1(3, 0), "fp_handle_unsol_flogi: "
			    "Accepting PLOGI");
		}
	}

	if (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS) {
		fp_free_pkt(cmd);
	}
}


/*
 * Perform PLOGI accept
 */
static void
fp_login_acc_init(fc_local_port_t *port, fp_cmd_t *cmd, fc_unsol_buf_t *buf,
    job_request_t *job, int sleep)
{
	fc_packet_t	*pkt;
	fc_portmap_t 	*listptr;
	la_els_logi_t	payload;

	ASSERT(buf != NULL);

	/*
	 * If we are sending ACC to PLOGI and we haven't already
	 * create port and node device handles, let's create them
	 * here.
	 */
	if (buf->ub_buffer[0] == LA_ELS_PLOGI &&
	    FC_IS_REAL_DEVICE(buf->ub_frame.s_id)) {
		int			small;
		int			do_acc;
		fc_remote_port_t	*pd;
		la_els_logi_t 		*req;

		req = (la_els_logi_t *)buf->ub_buffer;
		small = fctl_wwn_cmp(&port->fp_service_params.nport_ww_name,
		    &req->nport_ww_name);

		mutex_enter(&port->fp_mutex);
		do_acc = (port->fp_statec_busy == 0) ? 1 : 0;
		mutex_exit(&port->fp_mutex);

		pd = fctl_create_remote_port(port, &req->node_ww_name,
		    &req->nport_ww_name, buf->ub_frame.s_id,
		    PD_PLOGI_RECEPIENT, sleep);
		if (pd == NULL) {
			FP_TRACE(FP_NHEAD1(3, 0), "login_acc_init: "
			    "Couldn't create port device for d_id:0x%x",
			    buf->ub_frame.s_id);

			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
			    "couldn't create port device d_id=%x",
			    buf->ub_frame.s_id);
		} else {
			/*
			 * usoc currently returns PLOGIs inline and
			 * the maximum buffer size is 60 bytes or so.
			 * So attempt not to look beyond what is in
			 * the unsolicited buffer
			 *
			 * JNI also traverses this path sometimes
			 */
			if (buf->ub_bufsize >= sizeof (la_els_logi_t)) {
				fp_register_login(NULL, pd, req, buf->ub_class);
			} else {
				mutex_enter(&pd->pd_mutex);
				if (pd->pd_login_count == 0) {
					pd->pd_login_count++;
				}
				pd->pd_state = PORT_DEVICE_LOGGED_IN;
				pd->pd_login_class = buf->ub_class;
				mutex_exit(&pd->pd_mutex);
			}

			listptr = kmem_zalloc(sizeof (fc_portmap_t), sleep);
			if (listptr != NULL) {
				fctl_copy_portmap(listptr, pd);
				(void) fp_ulp_devc_cb(port, listptr,
				    1, 1, sleep, 0);
			}

			if (small > 0 && do_acc) {
				mutex_enter(&pd->pd_mutex);
				pd->pd_recepient = PD_PLOGI_INITIATOR;
				mutex_exit(&pd->pd_mutex);
			}
		}
	}

	cmd->cmd_pkt.pkt_tran_flags = buf->ub_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_OUTBOUND;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	cmd->cmd_job = job;

	pkt = &cmd->cmd_pkt;

	fp_unsol_resp_init(pkt, buf, R_CTL_ELS_RSP, FC_TYPE_EXTENDED_LS);

	payload = port->fp_service_params;
	payload.ls_code.ls_code = LA_ELS_ACC;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);

	FP_TRACE(FP_NHEAD1(3, 0), "login_acc_init: ELS:0x%x d_id:0x%x "
	    "bufsize:0x%x sizeof(la_els_logi):0x%x "
	    "port's wwn:0x%01x%03x%04x%08x requestor's wwn:0x%01x%03x%04x%08x "
	    "statec_busy:0x%x", buf->ub_buffer[0], buf->ub_frame.s_id,
	    buf->ub_bufsize, sizeof (la_els_logi_t),
	    port->fp_service_params.nport_ww_name.w.naa_id,
	    port->fp_service_params.nport_ww_name.w.nport_id,
	    port->fp_service_params.nport_ww_name.w.wwn_hi,
	    port->fp_service_params.nport_ww_name.w.wwn_lo,
	    ((la_els_logi_t *)buf->ub_buffer)->nport_ww_name.w.naa_id,
	    ((la_els_logi_t *)buf->ub_buffer)->nport_ww_name.w.nport_id,
	    ((la_els_logi_t *)buf->ub_buffer)->nport_ww_name.w.wwn_hi,
	    ((la_els_logi_t *)buf->ub_buffer)->nport_ww_name.w.wwn_lo,
	    port->fp_statec_busy);
}


#define	RSCN_EVENT_NAME_LEN	256

/*
 * Handle RSCNs
 */
static void
fp_handle_unsol_rscn(fc_local_port_t *port, fc_unsol_buf_t *buf,
    job_request_t *job, int sleep)
{
	uint32_t		mask;
	fp_cmd_t		*cmd;
	uint32_t		count;
	int			listindex;
	int16_t			len;
	fc_rscn_t		*payload;
	fc_portmap_t 		*listptr;
	fctl_ns_req_t		*ns_cmd;
	fc_affected_id_t 	*page;
	caddr_t			nvname;
	nvlist_t		*attr_list = NULL;

	mutex_enter(&port->fp_mutex);
	if (!FC_IS_TOP_SWITCH(port->fp_topology)) {
		if (--port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			--port->fp_rscn_count;
		}
		mutex_exit(&port->fp_mutex);
		return;
	}
	mutex_exit(&port->fp_mutex);

	cmd = fp_alloc_pkt(port, FP_PORT_IDENTIFIER_LEN, 0, sleep, NULL);
	if (cmd != NULL) {
		fp_els_acc_init(port, cmd, buf, job);
		if (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS) {
			fp_free_pkt(cmd);
		}
	}

	payload = (fc_rscn_t *)buf->ub_buffer;
	ASSERT(payload->rscn_code == LA_ELS_RSCN);
	ASSERT(payload->rscn_len == FP_PORT_IDENTIFIER_LEN);

	len = payload->rscn_payload_len - FP_PORT_IDENTIFIER_LEN;

	if (len <= 0) {
		mutex_enter(&port->fp_mutex);
		if (--port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			--port->fp_rscn_count;
		}
		mutex_exit(&port->fp_mutex);

		return;
	}

	ASSERT((len & 0x3) == 0);	/* Must be power of 4 */
	count = (len >> 2) << 1;	/* number of pages multiplied by 2 */

	listptr = kmem_zalloc(sizeof (fc_portmap_t) * count, sleep);
	page = (fc_affected_id_t *)(buf->ub_buffer + sizeof (fc_rscn_t));

	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

	ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gpn_id_t),
	    sizeof (ns_resp_gpn_id_t), sizeof (ns_resp_gpn_id_t),
	    0, sleep);
	if (ns_cmd == NULL) {
		kmem_free(listptr, sizeof (fc_portmap_t) * count);

		mutex_enter(&port->fp_mutex);
		if (--port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			--port->fp_rscn_count;
		}
		mutex_exit(&port->fp_mutex);

		return;
	}

	ns_cmd->ns_cmd_code = NS_GPN_ID;

	FP_TRACE(FP_NHEAD1(3, 0), "fp_handle_unsol_rscn: s_id=%x, d_id=%x,"
	    "type=%x, f_ctl=%x seq_id=%x, ox_id=%x, rx_id=%x"
	    " ro=%x", buf->ub_frame.s_id, buf->ub_frame.d_id,
	    buf->ub_frame.type, buf->ub_frame.f_ctl, buf->ub_frame.seq_id,
	    buf->ub_frame.ox_id, buf->ub_frame.rx_id, buf->ub_frame.ro);

	/* Only proceed if we can allocate nvname and the nvlist */
	if ((nvname = kmem_zalloc(RSCN_EVENT_NAME_LEN, KM_NOSLEEP)) != NULL &&
		nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE,
		KM_NOSLEEP) == DDI_SUCCESS) {
	    if (!(attr_list && nvlist_add_uint32(attr_list, "instance",
		    port->fp_instance) == DDI_SUCCESS &&
		    nvlist_add_byte_array(attr_list, "port-wwn",
		    port->fp_service_params.nport_ww_name.raw_wwn,
		    sizeof (la_wwn_t)) == DDI_SUCCESS)) {
		nvlist_free(attr_list);
		attr_list = NULL;
	    }
	}

	for (listindex = 0; len; len -= FP_PORT_IDENTIFIER_LEN, page++) {
		/* Add affected page to the event payload */
		if (attr_list != NULL) {
		    (void) snprintf(nvname, RSCN_EVENT_NAME_LEN,
			    "affected_page_%d", listindex);
		    if (attr_list && nvlist_add_uint32(attr_list, nvname,
			    ntohl(*(uint32_t *)page)) != DDI_SUCCESS) {
			/* We don't want to send a partial event, so dump it */
			nvlist_free(attr_list);
			attr_list = NULL;
		    }
		}
		/*
		 * Query the NS to get the Port WWN for this
		 * affected D_ID.
		 */
		mask = 0;
		switch (page->aff_format & FC_RSCN_ADDRESS_MASK) {
		case FC_RSCN_PORT_ADDRESS:
			fp_validate_rscn_page(port, page, job, ns_cmd,
			    listptr, &listindex, sleep);

			if (listindex == 0) {
				/*
				 * We essentially did not process this RSCN. So,
				 * ULPs are not going to be called and so we
				 * decrement the rscn_count
				 */
				mutex_enter(&port->fp_mutex);
				if (--port->fp_rscn_count ==
				    FC_INVALID_RSCN_COUNT) {
					--port->fp_rscn_count;
				}
				mutex_exit(&port->fp_mutex);
			}
			break;

		case FC_RSCN_AREA_ADDRESS:
			mask = 0xFFFF00;
			/* FALLTHROUGH */

		case FC_RSCN_DOMAIN_ADDRESS:
			if (!mask) {
				mask = 0xFF0000;
			}
			fp_validate_area_domain(port, page->aff_d_id, mask,
			    job, sleep);
			break;

		case FC_RSCN_FABRIC_ADDRESS:
			/*
			 * We need to discover all the devices on this
			 * port.
			 */
			fp_validate_area_domain(port, 0, 0, job, sleep);
			break;

		default:
			break;
		}
	}
	if (attr_list != NULL) {
	    (void) ddi_log_sysevent(port->fp_port_dip, DDI_VENDOR_SUNW,
		    EC_SUNFC, ESC_SUNFC_PORT_RSCN, attr_list,
		    NULL, DDI_SLEEP);
	    nvlist_free(attr_list);
	} else {
	    FP_TRACE(FP_NHEAD1(9, 0),
		"RSCN handled, but event not sent to userland");
	}
	if (nvname != NULL) {
	    kmem_free(nvname, RSCN_EVENT_NAME_LEN);
	}

	if (ns_cmd) {
		fctl_free_ns_cmd(ns_cmd);
	}

	if (listindex) {
#ifdef	DEBUG
		page = (fc_affected_id_t *)(buf->ub_buffer +
		    sizeof (fc_rscn_t));

		if (listptr->map_did.port_id != page->aff_d_id) {
			FP_TRACE(FP_NHEAD1(9, 0),
			    "PORT RSCN: processed=%x, reporting=%x",
			    listptr->map_did.port_id, page->aff_d_id);
		}
#endif

		(void) fp_ulp_devc_cb(port, listptr, listindex, count,
		    sleep, 0);
	} else {
		kmem_free(listptr, sizeof (fc_portmap_t) * count);
	}
}


/*
 * Fill out old map for ULPs with fp_mutex, fd_mutex and pd_mutex held
 */
static void
fp_fillout_old_map_held(fc_portmap_t *map, fc_remote_port_t *pd, uchar_t flag)
{
	int		is_switch;
	int		initiator;
	fc_local_port_t	*port;

	port = pd->pd_port;

	/* This function has the following bunch of assumptions */
	ASSERT(port != NULL);
	ASSERT(MUTEX_HELD(&port->fp_mutex));
	ASSERT(MUTEX_HELD(&pd->pd_remote_nodep->fd_mutex));
	ASSERT(MUTEX_HELD(&pd->pd_mutex));

	pd->pd_state = PORT_DEVICE_INVALID;
	pd->pd_type = PORT_DEVICE_OLD;
	initiator = (pd->pd_recepient == PD_PLOGI_INITIATOR) ? 1 : 0;
	is_switch = FC_IS_TOP_SWITCH(port->fp_topology);

	fctl_delist_did_table(port, pd);
	fctl_delist_pwwn_table(port, pd);

	FP_TRACE(FP_NHEAD1(6, 0), "fp_fillout_old_map_held: port=%p, d_id=%x"
	    " removed the PD=%p from DID and PWWN tables",
	    port, pd->pd_port_id.port_id, pd);

	if ((!flag) && port && initiator && is_switch) {
		(void) fctl_add_orphan_held(port, pd);
	}
	fctl_copy_portmap_held(map, pd);
	map->map_pd = pd;
}

/*
 * Fill out old map for ULPs
 */
static void
fp_fillout_old_map(fc_portmap_t *map, fc_remote_port_t *pd, uchar_t flag)
{
	int		is_switch;
	int		initiator;
	fc_local_port_t	*port;

	mutex_enter(&pd->pd_mutex);
	port = pd->pd_port;
	mutex_exit(&pd->pd_mutex);

	mutex_enter(&port->fp_mutex);
	mutex_enter(&pd->pd_mutex);

	pd->pd_state = PORT_DEVICE_INVALID;
	pd->pd_type = PORT_DEVICE_OLD;
	initiator = (pd->pd_recepient == PD_PLOGI_INITIATOR) ? 1 : 0;
	is_switch = FC_IS_TOP_SWITCH(port->fp_topology);

	fctl_delist_did_table(port, pd);
	fctl_delist_pwwn_table(port, pd);

	FP_TRACE(FP_NHEAD1(6, 0), "fp_fillout_old_map: port=%p, d_id=%x"
	    " removed the PD=%p from DID and PWWN tables",
	    port, pd->pd_port_id.port_id, pd);

	mutex_exit(&pd->pd_mutex);
	mutex_exit(&port->fp_mutex);

	ASSERT(port != NULL);
	if ((!flag) && port && initiator && is_switch) {
		(void) fctl_add_orphan(port, pd, KM_NOSLEEP);
	}
	fctl_copy_portmap(map, pd);
	map->map_pd = pd;
}


/*
 * Fillout Changed Map for ULPs
 */
static void
fp_fillout_changed_map(fc_portmap_t *map, fc_remote_port_t *pd,
    uint32_t *new_did, la_wwn_t *new_pwwn)
{
	ASSERT(MUTEX_HELD(&pd->pd_mutex));

	pd->pd_type = PORT_DEVICE_CHANGED;
	if (new_did) {
		pd->pd_port_id.port_id = *new_did;
	}
	if (new_pwwn) {
		pd->pd_port_name = *new_pwwn;
	}
	mutex_exit(&pd->pd_mutex);

	fctl_copy_portmap(map, pd);

	mutex_enter(&pd->pd_mutex);
	pd->pd_type = PORT_DEVICE_NOCHANGE;
}


/*
 * Fillout New Name Server map
 */
static void
fp_fillout_new_nsmap(fc_local_port_t *port, ddi_acc_handle_t *handle,
    fc_portmap_t *port_map, ns_resp_gan_t *gan_resp, uint32_t d_id)
{
	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	if (handle) {
		ddi_rep_get8(*handle, (uint8_t *)&port_map->map_pwwn,
		    (uint8_t *)&gan_resp->gan_pwwn, sizeof (gan_resp->gan_pwwn),
		    DDI_DEV_AUTOINCR);
		ddi_rep_get8(*handle, (uint8_t *)&port_map->map_nwwn,
		    (uint8_t *)&gan_resp->gan_nwwn, sizeof (gan_resp->gan_nwwn),
		    DDI_DEV_AUTOINCR);
		ddi_rep_get8(*handle, (uint8_t *)port_map->map_fc4_types,
		    (uint8_t *)gan_resp->gan_fc4types,
		    sizeof (gan_resp->gan_fc4types), DDI_DEV_AUTOINCR);
	} else {
		bcopy(&gan_resp->gan_pwwn, &port_map->map_pwwn,
		    sizeof (gan_resp->gan_pwwn));
		bcopy(&gan_resp->gan_nwwn, &port_map->map_nwwn,
		    sizeof (gan_resp->gan_nwwn));
		bcopy(gan_resp->gan_fc4types, port_map->map_fc4_types,
		    sizeof (gan_resp->gan_fc4types));
	}
	port_map->map_did.port_id = d_id;
	port_map->map_did.priv_lilp_posit = 0;
	port_map->map_hard_addr.hard_addr = 0;
	port_map->map_hard_addr.rsvd = 0;
	port_map->map_state = PORT_DEVICE_INVALID;
	port_map->map_type = PORT_DEVICE_NEW;
	port_map->map_flags = 0;
	port_map->map_pd = NULL;

	(void) fctl_remove_if_orphan(port, &port_map->map_pwwn);

	ASSERT(port != NULL);
}


/*
 * Perform LINIT ELS
 */
static int
fp_remote_lip(fc_local_port_t *port, la_wwn_t *pwwn, int sleep,
    job_request_t *job)
{
	int			rval;
	uint32_t		d_id;
	uint32_t		s_id;
	uint32_t		lfa;
	uchar_t			class;
	uint32_t		ret;
	fp_cmd_t		*cmd;
	fc_porttype_t		ptype;
	fc_packet_t		*pkt;
	fc_linit_req_t		payload;
	fc_remote_port_t 	*pd;

	rval = 0;

	ASSERT(job != NULL);
	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

	pd = fctl_get_remote_port_by_pwwn(port, pwwn);
	if (pd == NULL) {
		fctl_ns_req_t *ns_cmd;

		ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gid_pn_t),
		    sizeof (ns_resp_gid_pn_t), sizeof (ns_resp_gid_pn_t),
		    0, sleep);

		if (ns_cmd == NULL) {
			return (FC_NOMEM);
		}
		job->job_result = FC_SUCCESS;
		ns_cmd->ns_cmd_code = NS_GID_PN;
		((ns_req_gid_pn_t *)(ns_cmd->ns_cmd_buf))->pwwn = *pwwn;

		ret = fp_ns_query(port, ns_cmd, job, 1, sleep);
		if (ret != FC_SUCCESS || job->job_result != FC_SUCCESS) {
			fctl_free_ns_cmd(ns_cmd);
			return (FC_FAILURE);
		}
		bcopy(ns_cmd->ns_data_buf, (caddr_t)&d_id, sizeof (d_id));
		d_id = BE_32(*((uint32_t *)ns_cmd->ns_data_buf));

		fctl_free_ns_cmd(ns_cmd);
		lfa = d_id & 0xFFFF00;

		/*
		 * Given this D_ID, get the port type to see if
		 * we can do LINIT on the LFA
		 */
		ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gpt_id_t),
		    sizeof (ns_resp_gpt_id_t), sizeof (ns_resp_gpt_id_t),
		    0, sleep);

		if (ns_cmd == NULL) {
			return (FC_NOMEM);
		}

		job->job_result = FC_SUCCESS;
		ns_cmd->ns_cmd_code = NS_GPT_ID;

		((ns_req_gpt_id_t *)(ns_cmd->ns_cmd_buf))->pid.port_id = d_id;
		((ns_req_gpt_id_t *)
		    (ns_cmd->ns_cmd_buf))->pid.priv_lilp_posit = 0;

		ret = fp_ns_query(port, ns_cmd, job, 1, sleep);
		if (ret != FC_SUCCESS || job->job_result != FC_SUCCESS) {
			fctl_free_ns_cmd(ns_cmd);
			return (FC_FAILURE);
		}
		bcopy(ns_cmd->ns_data_buf, (caddr_t)&ptype, sizeof (ptype));

		fctl_free_ns_cmd(ns_cmd);

		switch (ptype.port_type) {
		case FC_NS_PORT_NL:
		case FC_NS_PORT_F_NL:
		case FC_NS_PORT_FL:
			break;

		default:
			return (FC_FAILURE);
		}
	} else {
		mutex_enter(&pd->pd_mutex);
		ptype = pd->pd_porttype;

		switch (pd->pd_porttype.port_type) {
		case FC_NS_PORT_NL:
		case FC_NS_PORT_F_NL:
		case FC_NS_PORT_FL:
			lfa = pd->pd_port_id.port_id & 0xFFFF00;
			break;

		default:
			mutex_exit(&pd->pd_mutex);
			return (FC_FAILURE);
		}
		mutex_exit(&pd->pd_mutex);
	}

	mutex_enter(&port->fp_mutex);
	s_id = port->fp_port_id.port_id;
	class = port->fp_ns_login_class;
	mutex_exit(&port->fp_mutex);

	cmd = fp_alloc_pkt(port, sizeof (fc_linit_req_t),
	    sizeof (fc_linit_resp_t), sleep, pd);
	if (cmd == NULL) {
		return (FC_NOMEM);
	}

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = fp_retry_count;
	cmd->cmd_ulp_pkt = NULL;

	pkt = &cmd->cmd_pkt;
	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;

	fp_els_init(cmd, s_id, lfa, fp_linit_intr, job);

	/*
	 * How does LIP work by the way ?
	 * 	If the L_Port receives three consecutive identical ordered
	 *	sets whose first two characters (fully decoded) are equal to
	 *	the values shown in Table 3 of FC-AL-2 then the L_Port shall
	 *	recognize a Loop Initialization Primitive sequence. The
	 *	character 3 determines the type of lip:
	 *		LIP(F7)		Normal LIP
	 *		LIP(F8)		Loop Failure LIP
	 *
	 * The possible combination for the 3rd and 4th bytes are:
	 *	F7, 	F7	Normal Lip 	- No valid AL_PA
	 *	F8, 	F8	Loop Failure	- No valid AL_PA
	 *	F7, 	AL_PS	Normal Lip	- Valid source AL_PA
	 *	F8, 	AL_PS	Loop Failure	- Valid source AL_PA
	 *	AL_PD	AL_PS	Loop reset of AL_PD originated by AL_PS
	 *			And Normal Lip for all other loop members
	 *	0xFF	AL_PS	Vendor specific reset of all loop members
	 *
	 * Now, it may not always be that we, at the source, may have an
	 * AL_PS (AL_PA of source) for 4th character slot, so we decide
	 * to do (Normal Lip, No Valid AL_PA), that means, in the LINIT
	 * payload we are going to set:
	 *	lip_b3 = 0xF7;		Normal LIP
	 *	lip_b4 = 0xF7;		No valid source AL_PA
	 */
	payload.ls_code.ls_code = LA_ELS_LINIT;
	payload.ls_code.mbz = 0;
	payload.rsvd = 0;
	payload.func = 0;		/* Let Fabric determine the best way */
	payload.lip_b3 = 0xF7;		/* Normal LIP */
	payload.lip_b4 = 0xF7;		/* No valid source AL_PA */

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);

	job->job_counter = 1;

	ret = fp_sendcmd(port, cmd, port->fp_fca_handle);
	if (ret == FC_SUCCESS) {
		fp_jobwait(job);
		rval = job->job_result;
	} else {
		rval = FC_FAILURE;
		fp_free_pkt(cmd);
	}

	return (rval);
}


/*
 * Fill out the device handles with GAN response
 */
static void
fp_stuff_device_with_gan(ddi_acc_handle_t *handle, fc_remote_port_t *pd,
    ns_resp_gan_t *gan_resp)
{
	fc_remote_node_t 	*node;
	fc_porttype_t		type;
	fc_local_port_t		*port;

	ASSERT(pd != NULL);
	ASSERT(handle != NULL);

	port = pd->pd_port;

	FP_TRACE(FP_NHEAD1(1, 0), "GAN PD stuffing; pd=%p,"
	    " port_id=%x, sym_len=%d fc4-type=%x",
	    pd, gan_resp->gan_type_id.rsvd,
	    gan_resp->gan_spnlen, gan_resp->gan_fc4types[0]);

	mutex_enter(&pd->pd_mutex);

	ddi_rep_get8(*handle, (uint8_t *)&type,
	    (uint8_t *)&gan_resp->gan_type_id, sizeof (type), DDI_DEV_AUTOINCR);

	pd->pd_porttype.port_type = type.port_type;
	pd->pd_porttype.rsvd = 0;

	pd->pd_spn_len = gan_resp->gan_spnlen;
	if (pd->pd_spn_len) {
		ddi_rep_get8(*handle, (uint8_t *)pd->pd_spn,
		    (uint8_t *)gan_resp->gan_spname, pd->pd_spn_len,
		    DDI_DEV_AUTOINCR);
	}

	ddi_rep_get8(*handle, (uint8_t *)pd->pd_ip_addr,
	    (uint8_t *)gan_resp->gan_ip, sizeof (pd->pd_ip_addr),
	    DDI_DEV_AUTOINCR);
	ddi_rep_get8(*handle, (uint8_t *)&pd->pd_cos,
	    (uint8_t *)&gan_resp->gan_cos, sizeof (pd->pd_cos),
	    DDI_DEV_AUTOINCR);
	ddi_rep_get8(*handle, (uint8_t *)pd->pd_fc4types,
	    (uint8_t *)gan_resp->gan_fc4types, sizeof (pd->pd_fc4types),
	    DDI_DEV_AUTOINCR);

	node = pd->pd_remote_nodep;
	mutex_exit(&pd->pd_mutex);

	mutex_enter(&node->fd_mutex);

	ddi_rep_get8(*handle, (uint8_t *)node->fd_ipa,
	    (uint8_t *)gan_resp->gan_ipa, sizeof (node->fd_ipa),
	    DDI_DEV_AUTOINCR);

	node->fd_snn_len = gan_resp->gan_snnlen;
	if (node->fd_snn_len) {
		ddi_rep_get8(*handle, (uint8_t *)node->fd_snn,
		    (uint8_t *)gan_resp->gan_snname, node->fd_snn_len,
		    DDI_DEV_AUTOINCR);
	}

	mutex_exit(&node->fd_mutex);
}


/*
 * Handles all NS Queries (also means that this function
 * doesn't handle NS object registration)
 */
static int
fp_ns_query(fc_local_port_t *port, fctl_ns_req_t *ns_cmd, job_request_t *job,
    int polled, int sleep)
{
	int 		rval;
	fp_cmd_t 	*cmd;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	if (ns_cmd->ns_cmd_size == 0) {
		return (FC_FAILURE);
	}

	cmd = fp_alloc_pkt(port, sizeof (fc_ct_header_t) +
	    ns_cmd->ns_cmd_size, sizeof (fc_ct_header_t) +
	    ns_cmd->ns_resp_size, sleep, NULL);
	if (cmd == NULL) {
		return (FC_NOMEM);
	}

	fp_ct_init(port, cmd, ns_cmd, ns_cmd->ns_cmd_code, ns_cmd->ns_cmd_buf,
	    ns_cmd->ns_cmd_size, ns_cmd->ns_resp_size, job);

	if (polled) {
		job->job_counter = 1;
		ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);
	}
	rval = fp_sendcmd(port, cmd, port->fp_fca_handle);
	if (rval != FC_SUCCESS) {
		job->job_result = rval;
		fp_iodone(cmd);
		if (polled == 0) {
			/*
			 * Return FC_SUCCESS to indicate that
			 * fp_iodone is performed already.
			 */
			rval = FC_SUCCESS;
		}
	}

	if (polled) {
		fp_jobwait(job);
		rval = job->job_result;
	}

	return (rval);
}


/*
 * Initialize Common Transport request
 */
static void
fp_ct_init(fc_local_port_t *port, fp_cmd_t *cmd, fctl_ns_req_t *ns_cmd,
    uint16_t cmd_code, caddr_t cmd_buf, uint16_t cmd_len,
    uint16_t resp_len, job_request_t *job)
{
	uint32_t	s_id;
	uchar_t		class;
	fc_packet_t 	*pkt;
	fc_ct_header_t 	ct;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	mutex_enter(&port->fp_mutex);
	s_id = port->fp_port_id.port_id;
	class = port->fp_ns_login_class;
	mutex_exit(&port->fp_mutex);

	cmd->cmd_job = job;
	cmd->cmd_private = ns_cmd;
	pkt = &cmd->cmd_pkt;

	ct.ct_rev = CT_REV;
	ct.ct_inid = 0;
	ct.ct_fcstype = FCSTYPE_DIRECTORY;
	ct.ct_fcssubtype = FCSSUB_DS_NAME_SERVER;
	ct.ct_options = 0;
	ct.ct_reserved1 = 0;
	ct.ct_cmdrsp = cmd_code;
	ct.ct_aiusize = resp_len >> 2;
	ct.ct_reserved2 = 0;
	ct.ct_reason = 0;
	ct.ct_expln = 0;
	ct.ct_vendor = 0;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&ct, (uint8_t *)pkt->pkt_cmd,
	    sizeof (ct), DDI_DEV_AUTOINCR);

	pkt->pkt_cmd_fhdr.r_ctl = R_CTL_UNSOL_CONTROL;
	pkt->pkt_cmd_fhdr.d_id = 0xFFFFFC;
	pkt->pkt_cmd_fhdr.s_id = s_id;
	pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
	pkt->pkt_cmd_fhdr.f_ctl = F_CTL_SEQ_INITIATIVE |
	    F_CTL_FIRST_SEQ | F_CTL_END_SEQ;
	pkt->pkt_cmd_fhdr.seq_id = 0;
	pkt->pkt_cmd_fhdr.df_ctl  = 0;
	pkt->pkt_cmd_fhdr.seq_cnt = 0;
	pkt->pkt_cmd_fhdr.ox_id = 0xffff;
	pkt->pkt_cmd_fhdr.rx_id = 0xffff;
	pkt->pkt_cmd_fhdr.ro = 0;
	pkt->pkt_cmd_fhdr.rsvd = 0;

	pkt->pkt_comp = fp_ns_intr;
	pkt->pkt_ulp_private = (opaque_t)cmd;
	pkt->pkt_timeout = FP_NS_TIMEOUT;

	if (cmd_buf) {
		ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)cmd_buf,
		    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
		    cmd_len, DDI_DEV_AUTOINCR);
	}

	cmd->cmd_transport = port->fp_fca_tran->fca_transport;

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = FP_CMD_PLOGI_DONT_CARE;
	cmd->cmd_retry_count = fp_retry_count;
	cmd->cmd_ulp_pkt = NULL;
}


/*
 * Name Server request interrupt routine
 */
static void
fp_ns_intr(fc_packet_t *pkt)
{
	fp_cmd_t	*cmd;
	fc_local_port_t	*port;
	fc_ct_header_t 	resp_hdr;
	fc_ct_header_t 	cmd_hdr;
	fctl_ns_req_t	*ns_cmd;

	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

	ddi_rep_get8(pkt->pkt_cmd_acc, (uint8_t *)&cmd_hdr,
	    (uint8_t *)pkt->pkt_cmd, sizeof (cmd_hdr), DDI_DEV_AUTOINCR);

	ns_cmd = (fctl_ns_req_t *)
	    (((fp_cmd_t *)(pkt->pkt_ulp_private))->cmd_private);

	if (!FP_IS_PKT_ERROR(pkt)) {
		ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&resp_hdr,
		    (uint8_t *)pkt->pkt_resp, sizeof (resp_hdr),
		    DDI_DEV_AUTOINCR);

		/*
		 * On x86 architectures, make sure the resp_hdr is big endian.
		 * This macro is a NOP on sparc architectures mainly because
		 * we don't want to end up wasting time since the end result
		 * is going to be the same.
		 */
		MAKE_BE_32(&resp_hdr);

		if (ns_cmd) {
			/*
			 * Always copy out the response CT_HDR
			 */
			bcopy(&resp_hdr, &ns_cmd->ns_resp_hdr,
			    sizeof (resp_hdr));
		}

		if (resp_hdr.ct_cmdrsp == FS_RJT_IU) {
			pkt->pkt_state = FC_PKT_FS_RJT;
			pkt->pkt_reason = resp_hdr.ct_reason;
			pkt->pkt_expln = resp_hdr.ct_expln;
		}
	}

	if (FP_IS_PKT_ERROR(pkt)) {
		if (ns_cmd) {
			if (ns_cmd->ns_flags & FCTL_NS_VALIDATE_PD) {
				ASSERT(ns_cmd->ns_pd != NULL);

				/* Mark it OLD if not already done */
				mutex_enter(&ns_cmd->ns_pd->pd_mutex);
				ns_cmd->ns_pd->pd_type = PORT_DEVICE_OLD;
				mutex_exit(&ns_cmd->ns_pd->pd_mutex);
			}

			if (ns_cmd->ns_flags & FCTL_NS_ASYNC_REQUEST) {
				fctl_free_ns_cmd(ns_cmd);
				((fp_cmd_t *)
				    (pkt->pkt_ulp_private))->cmd_private = NULL;
			}

		}

		FP_TRACE(FP_NHEAD1(4, 0), "NS failure; pkt state=%x reason=%x",
		    pkt->pkt_state, pkt->pkt_reason);

		(void) fp_common_intr(pkt, 1);

		return;
	}

	if (resp_hdr.ct_cmdrsp != FS_ACC_IU) {
		uint32_t	d_id;
		fc_local_port_t	*port;
		fp_cmd_t	*cmd;

		d_id = pkt->pkt_cmd_fhdr.d_id;
		cmd = pkt->pkt_ulp_private;
		port = cmd->cmd_port;
		FP_TRACE(FP_NHEAD2(9, 0),
		    "Bogus NS response received for D_ID=%x", d_id);
	}

	if (cmd_hdr.ct_cmdrsp == NS_GA_NXT) {
		fp_gan_handler(pkt, ns_cmd);
		return;
	}

	if (cmd_hdr.ct_cmdrsp >= NS_GPN_ID &&
	    cmd_hdr.ct_cmdrsp <= NS_GID_PT) {
		if (ns_cmd) {
			if ((ns_cmd->ns_flags & FCTL_NS_NO_DATA_BUF) == 0) {
				fp_ns_query_handler(pkt, ns_cmd);
				return;
			}
		}
	}

	fp_iodone(pkt->pkt_ulp_private);
}


/*
 * Process NS_GAN response
 */
static void
fp_gan_handler(fc_packet_t *pkt, fctl_ns_req_t *ns_cmd)
{
	int			my_did;
	fc_portid_t		d_id;
	fp_cmd_t		*cmd;
	fc_local_port_t		*port;
	fc_remote_port_t	*pd;
	ns_req_gan_t		gan_req;
	ns_resp_gan_t		*gan_resp;

	ASSERT(ns_cmd != NULL);

	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

	gan_resp = (ns_resp_gan_t *)(pkt->pkt_resp + sizeof (fc_ct_header_t));

	ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&d_id,
	    (uint8_t *)&gan_resp->gan_type_id, sizeof (d_id), DDI_DEV_AUTOINCR);

	*(uint32_t *)&d_id = BE_32(*(uint32_t *)&d_id);

	/*
	 * In this case the priv_lilp_posit field  in reality
	 * is actually represents the relative position on a private loop.
	 * So zero it while dealing with Port Identifiers.
	 */
	d_id.priv_lilp_posit = 0;
	pd = fctl_get_remote_port_by_did(port, d_id.port_id);
	if (ns_cmd->ns_gan_sid == d_id.port_id) {
		/*
		 * We've come a full circle; time to get out.
		 */
		fp_iodone(cmd);
		return;
	}

	if (ns_cmd->ns_gan_sid == FCTL_GAN_START_ID) {
		ns_cmd->ns_gan_sid = d_id.port_id;
	}

	mutex_enter(&port->fp_mutex);
	my_did = (d_id.port_id == port->fp_port_id.port_id) ? 1 : 0;
	mutex_exit(&port->fp_mutex);

	FP_TRACE(FP_NHEAD1(1, 0), "GAN response; port=%p, d_id=%x", port,
	    d_id.port_id);

	if (my_did == 0) {
		la_wwn_t pwwn;
		la_wwn_t nwwn;

		FP_TRACE(FP_NHEAD1(1, 0), "GAN response details; "
		    "port=%p, d_id=%x, type_id=%x, "
		    "pwwn=%x %x %x %x %x %x %x %x, "
		    "nwwn=%x %x %x %x %x %x %x %x",
		    port, d_id.port_id, gan_resp->gan_type_id,

		    gan_resp->gan_pwwn.raw_wwn[0],
		    gan_resp->gan_pwwn.raw_wwn[1],
		    gan_resp->gan_pwwn.raw_wwn[2],
		    gan_resp->gan_pwwn.raw_wwn[3],
		    gan_resp->gan_pwwn.raw_wwn[4],
		    gan_resp->gan_pwwn.raw_wwn[5],
		    gan_resp->gan_pwwn.raw_wwn[6],
		    gan_resp->gan_pwwn.raw_wwn[7],

		    gan_resp->gan_nwwn.raw_wwn[0],
		    gan_resp->gan_nwwn.raw_wwn[1],
		    gan_resp->gan_nwwn.raw_wwn[2],
		    gan_resp->gan_nwwn.raw_wwn[3],
		    gan_resp->gan_nwwn.raw_wwn[4],
		    gan_resp->gan_nwwn.raw_wwn[5],
		    gan_resp->gan_nwwn.raw_wwn[6],
		    gan_resp->gan_nwwn.raw_wwn[7]);

		ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&nwwn,
		    (uint8_t *)&gan_resp->gan_nwwn, sizeof (nwwn),
		    DDI_DEV_AUTOINCR);

		ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)&pwwn,
		    (uint8_t *)&gan_resp->gan_pwwn, sizeof (pwwn),
		    DDI_DEV_AUTOINCR);

		if (ns_cmd->ns_flags & FCTL_NS_CREATE_DEVICE && pd == NULL) {
			pd = fctl_create_remote_port(port, &nwwn, &pwwn,
			    d_id.port_id, PD_PLOGI_INITIATOR, KM_NOSLEEP);
		}
		if (pd != NULL) {
			fp_stuff_device_with_gan(&pkt->pkt_resp_acc,
			    pd, gan_resp);
		}

		if (ns_cmd->ns_flags & FCTL_NS_GET_DEV_COUNT) {
			*((int *)ns_cmd->ns_data_buf) += 1;
		}

		if (ns_cmd->ns_flags & FCTL_NS_FILL_NS_MAP) {
			ASSERT((ns_cmd->ns_flags & FCTL_NS_NO_DATA_BUF) == 0);

			if (ns_cmd->ns_flags & FCTL_NS_BUF_IS_USERLAND) {
				fc_port_dev_t *userbuf;

				userbuf = ((fc_port_dev_t *)
				    ns_cmd->ns_data_buf) +
				    ns_cmd->ns_gan_index++;

				userbuf->dev_did = d_id;

				ddi_rep_get8(pkt->pkt_resp_acc,
				    (uint8_t *)userbuf->dev_type,
				    (uint8_t *)gan_resp->gan_fc4types,
				    sizeof (userbuf->dev_type),
				    DDI_DEV_AUTOINCR);

				userbuf->dev_nwwn = nwwn;
				userbuf->dev_pwwn = pwwn;

				if (pd != NULL) {
					mutex_enter(&pd->pd_mutex);
					userbuf->dev_state = pd->pd_state;
					userbuf->dev_hard_addr =
					    pd->pd_hard_addr;
					mutex_exit(&pd->pd_mutex);
				} else {
					userbuf->dev_state =
					    PORT_DEVICE_INVALID;
				}
			} else if (ns_cmd->ns_flags &
			    FCTL_NS_BUF_IS_FC_PORTMAP) {
				fc_portmap_t *map;

				map = ((fc_portmap_t *)
				    ns_cmd->ns_data_buf) +
				    ns_cmd->ns_gan_index++;

				/*
				 * First fill it like any new map
				 * and update the port device info
				 * below.
				 */
				fp_fillout_new_nsmap(port, &pkt->pkt_resp_acc,
				    map, gan_resp, d_id.port_id);
				if (pd != NULL) {
					fctl_copy_portmap(map, pd);
				} else {
					map->map_state = PORT_DEVICE_INVALID;
					map->map_type = PORT_DEVICE_NOCHANGE;
				}
			} else {
				caddr_t dst_ptr;

				dst_ptr = ns_cmd->ns_data_buf +
				    (NS_GAN_RESP_LEN) * ns_cmd->ns_gan_index++;

				ddi_rep_get8(pkt->pkt_resp_acc,
				    (uint8_t *)dst_ptr, (uint8_t *)gan_resp,
				    NS_GAN_RESP_LEN, DDI_DEV_AUTOINCR);
			}
		} else {
			ns_cmd->ns_gan_index++;
		}
		if (ns_cmd->ns_gan_index >= ns_cmd->ns_gan_max) {
			fp_iodone(cmd);
			return;
		}
	}

	gan_req.pid = d_id;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&gan_req,
	    (uint8_t *)(pkt->pkt_cmd + sizeof (fc_ct_header_t)),
	    sizeof (gan_req), DDI_DEV_AUTOINCR);

	if (cmd->cmd_transport(port->fp_fca_handle, pkt) != FC_SUCCESS) {
		pkt->pkt_state = FC_PKT_TRAN_ERROR;
		fp_iodone(cmd);
	}
}


/*
 * Handle NS Query interrupt
 */
static void
fp_ns_query_handler(fc_packet_t *pkt, fctl_ns_req_t *ns_cmd)
{
	fp_cmd_t 	*cmd;
	fc_local_port_t	*port;
	caddr_t 	src_ptr;
	uint32_t 	xfer_len;

	cmd = pkt->pkt_ulp_private;
	port = cmd->cmd_port;

	xfer_len = ns_cmd->ns_resp_size;

	FP_TRACE(FP_NHEAD1(1, 0), "NS Query response, cmd_code=%x, xfer_len=%x",
	    ns_cmd->ns_cmd_code, xfer_len);

	if (ns_cmd->ns_cmd_code == NS_GPN_ID) {
		src_ptr = (caddr_t)pkt->pkt_resp + sizeof (fc_ct_header_t);

		FP_TRACE(FP_NHEAD1(6, 0), "GPN_ID results; %x %x %x %x %x",
		    src_ptr[0], src_ptr[1], src_ptr[2], src_ptr[3], src_ptr[4]);
	}

	if (xfer_len <= ns_cmd->ns_data_len) {
		src_ptr = (caddr_t)pkt->pkt_resp + sizeof (fc_ct_header_t);
		ddi_rep_get8(pkt->pkt_resp_acc, (uint8_t *)ns_cmd->ns_data_buf,
		    (uint8_t *)src_ptr, xfer_len, DDI_DEV_AUTOINCR);
	}

	if (ns_cmd->ns_flags & FCTL_NS_VALIDATE_PD) {
		ASSERT(ns_cmd->ns_pd != NULL);

		mutex_enter(&ns_cmd->ns_pd->pd_mutex);
		if (ns_cmd->ns_pd->pd_type == PORT_DEVICE_OLD) {
			ns_cmd->ns_pd->pd_type = PORT_DEVICE_NOCHANGE;
		}
		mutex_exit(&ns_cmd->ns_pd->pd_mutex);
	}

	if (ns_cmd->ns_flags & FCTL_NS_ASYNC_REQUEST) {
		fctl_free_ns_cmd(ns_cmd);
		((fp_cmd_t *)(pkt->pkt_ulp_private))->cmd_private = NULL;
	}
	fp_iodone(cmd);
}


/*
 * Handle unsolicited ADISC ELS request
 */
static void
fp_handle_unsol_adisc(fc_local_port_t *port, fc_unsol_buf_t *buf,
    fc_remote_port_t *pd, job_request_t *job)
{
	int		rval;
	fp_cmd_t	*cmd;

	FP_TRACE(FP_NHEAD1(5, 0), "ADISC; port=%p, D_ID=%x state=%x, pd=%p",
	    port, pd->pd_port_id.port_id, pd->pd_state, pd);
	mutex_enter(&pd->pd_mutex);
	if (pd->pd_state != PORT_DEVICE_LOGGED_IN) {
		mutex_exit(&pd->pd_mutex);
		if (FP_IS_CLASS_1_OR_2(buf->ub_class)) {
			cmd = fp_alloc_pkt(port, sizeof (la_els_rjt_t),
			    0, KM_SLEEP, pd);
			if (cmd != NULL) {
				fp_els_rjt_init(port, cmd, buf,
				    FC_ACTION_NON_RETRYABLE,
				    FC_REASON_INVALID_LINK_CTRL, job);

				if (fp_sendcmd(port, cmd,
				    port->fp_fca_handle) != FC_SUCCESS) {
					fp_free_pkt(cmd);
				}
			}
		}
	} else {
		mutex_exit(&pd->pd_mutex);
		/*
		 * Yes, yes, we don't have a hard address. But we
		 * we should still respond. Huh ? Visit 21.19.2
		 * of FC-PH-2 which essentially says that if an
		 * NL_Port doesn't have a hard address, or if a port
		 * does not have FC-AL capability, it shall report
		 * zeroes in this field.
		 */
		cmd = fp_alloc_pkt(port, sizeof (la_els_adisc_t),
		    0, KM_SLEEP, pd);
		if (cmd == NULL) {
			return;
		}
		fp_adisc_acc_init(port, cmd, buf, job);
		rval = fp_sendcmd(port, cmd, port->fp_fca_handle);
		if (rval != FC_SUCCESS) {
			fp_free_pkt(cmd);
		}
	}
}


/*
 * Initialize ADISC response.
 */
static void
fp_adisc_acc_init(fc_local_port_t *port, fp_cmd_t *cmd, fc_unsol_buf_t *buf,
    job_request_t *job)
{
	fc_packet_t	*pkt;
	la_els_adisc_t	payload;

	cmd->cmd_pkt.pkt_tran_flags = buf->ub_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_OUTBOUND;
	cmd->cmd_flags = FP_CMD_CFLAG_UNDEFINED;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	cmd->cmd_transport = port->fp_fca_tran->fca_els_send;
	cmd->cmd_job = job;

	pkt = &cmd->cmd_pkt;

	fp_unsol_resp_init(pkt, buf, R_CTL_ELS_RSP, FC_TYPE_EXTENDED_LS);

	payload.ls_code.ls_code = LA_ELS_ACC;
	payload.ls_code.mbz = 0;

	mutex_enter(&port->fp_mutex);
	payload.nport_id = port->fp_port_id;
	payload.hard_addr = port->fp_hard_addr;
	mutex_exit(&port->fp_mutex);

	payload.port_wwn = port->fp_service_params.nport_ww_name;
	payload.node_wwn = port->fp_service_params.node_ww_name;

	ddi_rep_put8(pkt->pkt_cmd_acc, (uint8_t *)&payload,
	    (uint8_t *)pkt->pkt_cmd, sizeof (payload), DDI_DEV_AUTOINCR);
}


/*
 * Hold and Install the requested ULP drivers
 */
static void
fp_load_ulp_modules(dev_info_t *dip, fc_local_port_t *port)
{
	int		len;
	int		count;
	int		data_len;
	major_t		ulp_major;
	caddr_t		ulp_name;
	caddr_t		data_ptr;
	caddr_t		data_buf;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	data_buf = NULL;
	if (ddi_getlongprop(DDI_DEV_T_ANY, dip,
	    DDI_PROP_DONTPASS, "load-ulp-list",
	    (caddr_t)&data_buf, &data_len) != DDI_PROP_SUCCESS) {
		return;
	}

	len = strlen(data_buf);
	port->fp_ulp_nload = fctl_atoi(data_buf, 10);

	data_ptr = data_buf + len + 1;
	for (count = 0; count < port->fp_ulp_nload; count++) {
		len = strlen(data_ptr) + 1;
		ulp_name = kmem_zalloc(len, KM_SLEEP);
		bcopy(data_ptr, ulp_name, len);

		ulp_major = ddi_name_to_major(ulp_name);

		if (ulp_major != (major_t)-1) {
			if (modload("drv", ulp_name) < 0) {
				fp_printf(port, CE_NOTE, FP_LOG_ONLY,
				    0, NULL, "failed to load %s",
				    ulp_name);
			}
		} else {
			fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
			    "%s isn't a valid driver", ulp_name);
		}

		kmem_free(ulp_name, len);
		data_ptr += len;	/* Skip to next field */
	}

	/*
	 * Free the memory allocated by DDI
	 */
	if (data_buf != NULL) {
		kmem_free(data_buf, data_len);
	}
}


/*
 * Perform LOGO operation
 */
static int
fp_logout(fc_local_port_t *port, fc_remote_port_t *pd, job_request_t *job)
{
	int		rval;
	fp_cmd_t 	*cmd;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));
	ASSERT(!MUTEX_HELD(&pd->pd_mutex));

	cmd = fp_alloc_pkt(port, sizeof (la_els_logo_t),
	    FP_PORT_IDENTIFIER_LEN, KM_SLEEP, pd);

	mutex_enter(&port->fp_mutex);
	mutex_enter(&pd->pd_mutex);

	ASSERT(pd->pd_state == PORT_DEVICE_LOGGED_IN);
	ASSERT(pd->pd_login_count == 1);

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = 0;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	fp_logo_init(pd, cmd, job);

	mutex_exit(&pd->pd_mutex);
	mutex_exit(&port->fp_mutex);

	rval = fp_sendcmd(port, cmd, port->fp_fca_handle);
	if (rval != FC_SUCCESS) {
		fp_iodone(cmd);
	}

	return (rval);
}


/*
 * Perform Port attach callbacks to registered ULPs
 */
static void
fp_attach_ulps(fc_local_port_t *port, fc_attach_cmd_t cmd)
{
	fp_soft_attach_t *att;

	att = kmem_zalloc(sizeof (*att), KM_SLEEP);
	att->att_cmd = cmd;
	att->att_port = port;

	/*
	 * We need to remember whether or not fctl_busy_port
	 * succeeded so we know whether or not to call
	 * fctl_idle_port when the task is complete.
	 */

	if (fctl_busy_port(port) == 0) {
		att->att_need_pm_idle = B_TRUE;
	} else {
		att->att_need_pm_idle = B_FALSE;
	}

	(void) taskq_dispatch(port->fp_taskq, fp_ulp_port_attach,
	    att, KM_SLEEP);
}


/*
 * Forward state change notifications on to interested ULPs.
 * Spawns a call to fctl_ulp_statec_cb() in a taskq thread to do all the
 * real work.
 */
static int
fp_ulp_notify(fc_local_port_t *port, uint32_t statec, int sleep)
{
	fc_port_clist_t *clist;

	clist = kmem_zalloc(sizeof (*clist), sleep);
	if (clist == NULL) {
		return (FC_NOMEM);
	}

	clist->clist_state = statec;

	mutex_enter(&port->fp_mutex);
	clist->clist_flags = port->fp_topology;
	mutex_exit(&port->fp_mutex);

	clist->clist_port = (opaque_t)port;
	clist->clist_len = 0;
	clist->clist_size = 0;
	clist->clist_map = NULL;

	(void) taskq_dispatch(port->fp_taskq, fctl_ulp_statec_cb,
	    clist, KM_SLEEP);

	return (FC_SUCCESS);
}


/*
 * Get name server map
 */
static int
fp_ns_getmap(fc_local_port_t *port, job_request_t *job, fc_portmap_t **map,
    uint32_t *len, uint32_t sid)
{
	int ret;
	fctl_ns_req_t *ns_cmd;

	/*
	 * Don't let the allocator do anything for response;
	 * we have have buffer ready to fillout.
	 */
	ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gan_t),
	    sizeof (ns_resp_gan_t), 0, (FCTL_NS_FILL_NS_MAP |
	    FCTL_NS_BUF_IS_FC_PORTMAP), KM_SLEEP);

	ns_cmd->ns_data_len = sizeof (**map) * (*len);
	ns_cmd->ns_data_buf = (caddr_t)*map;

	ASSERT(ns_cmd != NULL);

	ns_cmd->ns_gan_index = 0;
	ns_cmd->ns_gan_sid = sid;
	ns_cmd->ns_cmd_code = NS_GA_NXT;
	ns_cmd->ns_gan_max = *len;

	ret = fp_ns_query(port, ns_cmd, job, 1, KM_SLEEP);

	if (ns_cmd->ns_gan_index != *len) {
		*len = ns_cmd->ns_gan_index;
	}
	ns_cmd->ns_data_len = 0;
	ns_cmd->ns_data_buf = NULL;
	fctl_free_ns_cmd(ns_cmd);

	return (ret);
}


/*
 * Create a remote port in Fabric topology by using NS services
 */
static fc_remote_port_t *
fp_create_remote_port_by_ns(fc_local_port_t *port, uint32_t d_id, int sleep)
{
	int			rval;
	job_request_t 		*job;
	fctl_ns_req_t 		*ns_cmd;
	fc_remote_port_t	*pd;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	FP_TRACE(FP_NHEAD1(1, 0), "PD creation begin; port=%p, d_id=%x",
	    port, d_id);

#ifdef	DEBUG
	mutex_enter(&port->fp_mutex);
	ASSERT(FC_IS_TOP_SWITCH(port->fp_topology));
	mutex_exit(&port->fp_mutex);
#endif

	job = fctl_alloc_job(JOB_NS_CMD, 0, NULL, (opaque_t)port, sleep);
	if (job == NULL) {
		return (NULL);
	}

	ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gan_t),
	    sizeof (ns_resp_gan_t), 0, (FCTL_NS_CREATE_DEVICE |
	    FCTL_NS_NO_DATA_BUF), sleep);
	if (ns_cmd == NULL) {
		return (NULL);
	}

	job->job_result = FC_SUCCESS;
	ns_cmd->ns_gan_max = 1;
	ns_cmd->ns_cmd_code = NS_GA_NXT;
	ns_cmd->ns_gan_sid = FCTL_GAN_START_ID;
	((ns_req_gan_t *)(ns_cmd->ns_cmd_buf))->pid.port_id = d_id - 1;
	((ns_req_gan_t *)(ns_cmd->ns_cmd_buf))->pid.priv_lilp_posit = 0;

	ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);
	rval = fp_ns_query(port, ns_cmd, job, 1, KM_SLEEP);
	fctl_free_ns_cmd(ns_cmd);

	if (rval != FC_SUCCESS || job->job_result != FC_SUCCESS) {
		fctl_dealloc_job(job);
		return (NULL);
	}
	fctl_dealloc_job(job);

	pd = fctl_get_remote_port_by_did(port, d_id);

	FP_TRACE(FP_NHEAD1(1, 0), "PD creation end; port=%p, d_id=%x, pd=%p",
	    port, d_id, pd);

	return (pd);
}


/*
 * Check for the permissions on an ioctl command. If it is required to have an
 * EXCLUSIVE open performed, return a FAILURE to just shut the door on it. If
 * the ioctl command isn't in one of the list built, shut the door on that too.
 *
 * 	Certain ioctls perform hardware accesses in FCA drivers, and it needs
 *	to be made sure that users open the port for an exclusive access while
 *	performing those operations.
 *
 * 	This can prevent a casual user from inflicting damage on the port by
 *	sending these ioctls from multiple processes/threads (there is no good
 *	reason why one would need to do that) without actually realizing how
 *	expensive such commands could turn out to be.
 *
 *	It is also important to note that, even with an exclusive access,
 *	multiple threads can share the same file descriptor and fire down
 *	commands in parallel. To prevent that the driver needs to make sure
 *	that such commands aren't in progress already. This is taken care of
 *	in the FP_EXCL_BUSY bit of fp_flag.
 */
static int
fp_check_perms(uchar_t open_flag, uint16_t ioctl_cmd)
{
	int ret = FC_FAILURE;
	int count;

	for (count = 0;
	    count < sizeof (fp_perm_list) / sizeof (fp_perm_list[0]);
	    count++) {
		if (fp_perm_list[count].fp_ioctl_cmd == ioctl_cmd) {
			if (fp_perm_list[count].fp_open_flag & open_flag) {
				ret = FC_SUCCESS;
			}
			break;
		}
	}

	return (ret);
}


/*
 * Bind Port driver's unsolicited, state change callbacks
 */
static int
fp_bind_callbacks(fc_local_port_t *port)
{
	fc_fca_bind_info_t	bind_info = {0};
	fc_fca_port_info_t	*port_info;
	int		rval =  DDI_SUCCESS;
	uint16_t	class;
	int		node_namelen, port_namelen;
	char		*nname = NULL, *pname = NULL;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, port->fp_port_dip,
	    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
	    "node-name", &nname) != DDI_PROP_SUCCESS) {
		FP_TRACE(FP_NHEAD1(1, 0),
		    "fp_bind_callback fail to get node-name");
	}
	if (nname) {
		fc_str_to_wwn(nname, &(bind_info.port_nwwn));
	}

	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, port->fp_port_dip,
	    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS,
	    "port-name", &pname) != DDI_PROP_SUCCESS) {
		FP_TRACE(FP_NHEAD1(1, 0),
		    "fp_bind_callback fail to get port-name");
	}
	if (pname) {
		fc_str_to_wwn(pname, &(bind_info.port_pwwn));
	}

	if (port->fp_npiv_type == FC_NPIV_PORT) {
		bind_info.port_npiv = 1;
	}

	/*
	 * fca_bind_port returns the FCA driver's handle for the local
	 * port instance. If the port number isn't supported it returns NULL.
	 * It also sets up callback in the FCA for various
	 * things like state change, ELS etc..
	 */
	bind_info.port_statec_cb = fp_statec_cb;
	bind_info.port_unsol_cb = fp_unsol_cb;
	bind_info.port_num = port->fp_port_num;
	bind_info.port_handle = (opaque_t)port;

	port_info = kmem_zalloc(sizeof (*port_info), KM_SLEEP);

	/*
	 * Hold the port driver mutex as the callbacks are bound until the
	 * service parameters are properly filled in (in order to be able to
	 * properly respond to unsolicited ELS requests)
	 */
	mutex_enter(&port->fp_mutex);

	port->fp_fca_handle = port->fp_fca_tran->fca_bind_port(
	    port->fp_fca_dip, port_info, &bind_info);

	if (port->fp_fca_handle == NULL) {
		rval = DDI_FAILURE;
		goto exit;
	}

	port->fp_bind_state = port->fp_state = port_info->pi_port_state;
	port->fp_service_params = port_info->pi_login_params;
	port->fp_hard_addr = port_info->pi_hard_addr;

	/* Copy from the FCA structure to the FP structure */
	port->fp_hba_port_attrs = port_info->pi_attrs;

	if (port_info->pi_rnid_params.status == FC_SUCCESS) {
		port->fp_rnid_init = 1;
		bcopy(&port_info->pi_rnid_params.params,
		    &port->fp_rnid_params,
		    sizeof (port->fp_rnid_params));
	} else {
		port->fp_rnid_init = 0;
	}

	node_namelen = strlen((char *)&port_info->pi_attrs.sym_node_name);
	if (node_namelen) {
		bcopy(&port_info->pi_attrs.sym_node_name,
		    &port->fp_sym_node_name,
		    node_namelen);
		port->fp_sym_node_namelen = node_namelen;
	}
	port_namelen = strlen((char *)&port_info->pi_attrs.sym_port_name);
	if (port_namelen) {
		bcopy(&port_info->pi_attrs.sym_port_name,
		    &port->fp_sym_port_name,
		    port_namelen);
		port->fp_sym_port_namelen = port_namelen;
	}

	/* zero out the normally unused fields right away */
	port->fp_service_params.ls_code.mbz = 0;
	port->fp_service_params.ls_code.ls_code = 0;
	bzero(&port->fp_service_params.reserved,
	    sizeof (port->fp_service_params.reserved));

	class = port_info->pi_login_params.class_1.class_opt;
	port->fp_cos |= (class & 0x8000) ? FC_NS_CLASS1 : 0;

	class = port_info->pi_login_params.class_2.class_opt;
	port->fp_cos |= (class & 0x8000) ? FC_NS_CLASS2 : 0;

	class = port_info->pi_login_params.class_3.class_opt;
	port->fp_cos |= (class & 0x8000) ? FC_NS_CLASS3 : 0;

exit:
	if (nname) {
		ddi_prop_free(nname);
	}
	if (pname) {
		ddi_prop_free(pname);
	}
	mutex_exit(&port->fp_mutex);
	kmem_free(port_info, sizeof (*port_info));

	return (rval);
}


/*
 * Retrieve FCA capabilities
 */
static void
fp_retrieve_caps(fc_local_port_t *port)
{
	int			rval;
	int 			ub_count;
	fc_fcp_dma_t		fcp_dma;
	fc_reset_action_t	action;
	fc_dma_behavior_t	dma_behavior;

	ASSERT(!MUTEX_HELD(&port->fp_mutex));

	rval = port->fp_fca_tran->fca_get_cap(port->fp_fca_handle,
	    FC_CAP_UNSOL_BUF, &ub_count);

	switch (rval) {
	case FC_CAP_FOUND:
	case FC_CAP_SETTABLE:
		switch (ub_count) {
		case 0:
			break;

		case -1:
			ub_count = fp_unsol_buf_count;
			break;

		default:
			/* 1/4th of total buffers is my share */
			ub_count =
			    (ub_count / port->fp_fca_tran->fca_numports) >> 2;
			break;
		}
		break;

	default:
		ub_count = 0;
		break;
	}

	mutex_enter(&port->fp_mutex);
	port->fp_ub_count = ub_count;
	mutex_exit(&port->fp_mutex);

	rval = port->fp_fca_tran->fca_get_cap(port->fp_fca_handle,
	    FC_CAP_POST_RESET_BEHAVIOR, &action);

	switch (rval) {
	case FC_CAP_FOUND:
	case FC_CAP_SETTABLE:
		switch (action) {
		case FC_RESET_RETURN_NONE:
		case FC_RESET_RETURN_ALL:
		case FC_RESET_RETURN_OUTSTANDING:
			break;

		default:
			action = FC_RESET_RETURN_NONE;
			break;
		}
		break;

	default:
		action = FC_RESET_RETURN_NONE;
		break;
	}
	mutex_enter(&port->fp_mutex);
	port->fp_reset_action = action;
	mutex_exit(&port->fp_mutex);

	rval = port->fp_fca_tran->fca_get_cap(port->fp_fca_handle,
	    FC_CAP_NOSTREAM_ON_UNALIGN_BUF, &dma_behavior);

	switch (rval) {
	case FC_CAP_FOUND:
		switch (dma_behavior) {
		case FC_ALLOW_STREAMING:
			/* FALLTHROUGH */
		case FC_NO_STREAMING:
			break;

		default:
			/*
			 * If capability was found and the value
			 * was incorrect assume the worst
			 */
			dma_behavior = FC_NO_STREAMING;
			break;
		}
		break;

	default:
		/*
		 * If capability was not defined - allow streaming; existing
		 * FCAs should not be affected.
		 */
		dma_behavior = FC_ALLOW_STREAMING;
		break;
	}
	mutex_enter(&port->fp_mutex);
	port->fp_dma_behavior = dma_behavior;
	mutex_exit(&port->fp_mutex);

	rval = port->fp_fca_tran->fca_get_cap(port->fp_fca_handle,
	    FC_CAP_FCP_DMA, &fcp_dma);

	if (rval != FC_CAP_FOUND || (fcp_dma != FC_NO_DVMA_SPACE &&
	    fcp_dma != FC_DVMA_SPACE)) {
		fcp_dma = FC_DVMA_SPACE;
	}

	mutex_enter(&port->fp_mutex);
	port->fp_fcp_dma = fcp_dma;
	mutex_exit(&port->fp_mutex);
}


/*
 * Handle Domain, Area changes in the Fabric.
 */
static void
fp_validate_area_domain(fc_local_port_t *port, uint32_t id, uint32_t mask,
    job_request_t *job, int sleep)
{
#ifdef	DEBUG
	uint32_t		dcnt;
#endif
	int			rval;
	int			send;
	int			index;
	int			listindex;
	int			login;
	int			job_flags;
	char 			ww_name[17];
	uint32_t		d_id;
	uint32_t		count;
	fctl_ns_req_t		*ns_cmd;
	fc_portmap_t		*list;
	fc_orphan_t 		*orp;
	fc_orphan_t		*norp;
	fc_orphan_t		*prev;
	fc_remote_port_t 	*pd;
	fc_remote_port_t 	*npd;
	struct pwwn_hash 	*head;

	ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gid_pn_t),
	    sizeof (ns_resp_gid_pn_t), sizeof (ns_resp_gid_pn_t),
	    0, sleep);
	if (ns_cmd == NULL) {
		mutex_enter(&port->fp_mutex);
		if (--port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			--port->fp_rscn_count;
		}
		mutex_exit(&port->fp_mutex);

		return;
	}
	ns_cmd->ns_cmd_code = NS_GID_PN;

	/*
	 * We need to get a new count of devices from the
	 * name server, which will also create any new devices
	 * as needed.
	 */

	(void) fp_ns_get_devcount(port, job, 1, sleep);

	FP_TRACE(FP_NHEAD1(3, 0),
	    "fp_validate_area_domain: get_devcount found %d devices",
	    port->fp_total_devices);

	mutex_enter(&port->fp_mutex);

	for (count = index = 0; index < pwwn_table_size; index++) {
		head = &port->fp_pwwn_table[index];
		pd = head->pwwn_head;
		while (pd != NULL) {
			mutex_enter(&pd->pd_mutex);
			if (pd->pd_flags != PD_ELS_IN_PROGRESS) {
				if ((pd->pd_port_id.port_id & mask) == id &&
				    pd->pd_recepient == PD_PLOGI_INITIATOR) {
					count++;
					pd->pd_type = PORT_DEVICE_OLD;
					pd->pd_flags = PD_ELS_MARK;
				}
			}
			mutex_exit(&pd->pd_mutex);
			pd = pd->pd_wwn_hnext;
		}
	}

#ifdef	DEBUG
	dcnt = count;
#endif /* DEBUG */

	/*
	 * Since port->fp_orphan_count is declared an 'int' it is
	 * theoretically possible that the count could go negative.
	 *
	 * This would be bad and if that happens we really do want
	 * to know.
	 */

	ASSERT(port->fp_orphan_count >= 0);

	count += port->fp_orphan_count;

	/*
	 * We add the port->fp_total_devices value to the count
	 * in the case where our port is newly attached. This is
	 * because we haven't done any discovery and we don't have
	 * any orphans in the port's orphan list. If we do not do
	 * this addition to count then we won't alloc enough kmem
	 * to do discovery with.
	 */

	if (count == 0) {
		count += port->fp_total_devices;
		FP_TRACE(FP_NHEAD1(3, 0), "fp_validate_area_domain: "
		    "0x%x orphans found, using 0x%x",
		    port->fp_orphan_count, count);
	}

	mutex_exit(&port->fp_mutex);

	/*
	 * Allocate the change list
	 */

	list = kmem_zalloc(sizeof (fc_portmap_t) * count, sleep);
	if (list == NULL) {
		fp_printf(port, CE_NOTE, FP_LOG_ONLY, 0, NULL,
		    " Not enough memory to service RSCNs"
		    " for %d ports, continuing...", count);

		fctl_free_ns_cmd(ns_cmd);

		mutex_enter(&port->fp_mutex);
		if (--port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			--port->fp_rscn_count;
		}
		mutex_exit(&port->fp_mutex);

		return;
	}

	/*
	 * Attempt to validate or invalidate the devices that were
	 * already in the pwwn hash table.
	 */

	mutex_enter(&port->fp_mutex);
	for (listindex = 0, index = 0; index < pwwn_table_size; index++) {
		head = &port->fp_pwwn_table[index];
		npd = head->pwwn_head;

		while ((pd = npd) != NULL) {
			npd = pd->pd_wwn_hnext;

			mutex_enter(&pd->pd_mutex);
			if ((pd->pd_port_id.port_id & mask) == id &&
			    pd->pd_flags == PD_ELS_MARK) {
				la_wwn_t *pwwn;

				job->job_result = FC_SUCCESS;

				((ns_req_gid_pn_t *)
				    (ns_cmd->ns_cmd_buf))->pwwn =
				    pd->pd_port_name;

				pwwn = &pd->pd_port_name;
				d_id = pd->pd_port_id.port_id;

				mutex_exit(&pd->pd_mutex);
				mutex_exit(&port->fp_mutex);

				rval = fp_ns_query(port, ns_cmd, job, 1,
				    sleep);
				if (rval != FC_SUCCESS) {
					fc_wwn_to_str(pwwn, ww_name);

					FP_TRACE(FP_NHEAD1(3, 0),
					    "AREA RSCN: PD disappeared; "
					    "d_id=%x, PWWN=%s", d_id, ww_name);

					FP_TRACE(FP_NHEAD2(9, 0),
					    "N_x Port with D_ID=%x,"
					    " PWWN=%s disappeared from fabric",
					    d_id, ww_name);

					fp_fillout_old_map(list + listindex++,
					    pd, 1);
				} else {
					fctl_copy_portmap(list + listindex++,
					    pd);

					mutex_enter(&pd->pd_mutex);
					pd->pd_flags = PD_ELS_IN_PROGRESS;
					mutex_exit(&pd->pd_mutex);
				}

				mutex_enter(&port->fp_mutex);
			} else {
				mutex_exit(&pd->pd_mutex);
			}
		}
	}

	mutex_exit(&port->fp_mutex);

	ASSERT(listindex == dcnt);

	job->job_counter = listindex;
	job_flags = job->job_flags;
	job->job_flags |= JOB_TYPE_FP_ASYNC;

	/*
	 * Login (if we were the initiator) or validate devices in the
	 * port map.
	 */

	for (index = 0; index < listindex; index++) {
		pd = list[index].map_pd;

		mutex_enter(&pd->pd_mutex);
		ASSERT((pd->pd_port_id.port_id & mask) == id);

		if (pd->pd_flags != PD_ELS_IN_PROGRESS) {
			ASSERT(pd->pd_type == PORT_DEVICE_OLD);
			mutex_exit(&pd->pd_mutex);
			fp_jobdone(job);
			continue;
		}

		login = (pd->pd_state == PORT_DEVICE_LOGGED_IN) ? 1 : 0;
		send = (pd->pd_recepient == PD_PLOGI_INITIATOR) ? 1 : 0;
		d_id = pd->pd_port_id.port_id;
		mutex_exit(&pd->pd_mutex);

		if ((d_id & mask) == id && send) {
			if (login) {
				FP_TRACE(FP_NHEAD1(6, 0),
				    "RSCN and PLOGI request;"
				    " pd=%p, job=%p d_id=%x, index=%d", pd,
				    job, d_id, index);

				rval = fp_port_login(port, d_id, job,
				    FP_CMD_PLOGI_RETAIN, sleep, pd, NULL);
				if (rval != FC_SUCCESS) {
					mutex_enter(&pd->pd_mutex);
					pd->pd_flags = PD_IDLE;
					mutex_exit(&pd->pd_mutex);

					job->job_result = rval;
					fp_jobdone(job);
				}

				FP_TRACE(FP_NHEAD2(4, 0),
				    "PLOGI succeeded:no skip(1) for "
				    "D_ID %x", d_id);
				list[index].map_flags |=
				    PORT_DEVICE_NO_SKIP_DEVICE_DISCOVERY;
			} else {
				FP_TRACE(FP_NHEAD1(6, 0), "RSCN and NS request;"
				    " pd=%p, job=%p d_id=%x, index=%d", pd,
				    job, d_id, index);

				rval = fp_ns_validate_device(port, pd, job,
				    0, sleep);
				if (rval != FC_SUCCESS) {
					fp_jobdone(job);
				}
				mutex_enter(&pd->pd_mutex);
				pd->pd_flags = PD_IDLE;
				mutex_exit(&pd->pd_mutex);
			}
		} else {
			FP_TRACE(FP_NHEAD1(6, 0),
			    "RSCN and NO request sent; pd=%p,"
			    " d_id=%x, index=%d", pd, d_id, index);

			mutex_enter(&pd->pd_mutex);
			pd->pd_flags = PD_IDLE;
			mutex_exit(&pd->pd_mutex);

			fp_jobdone(job);
		}
	}

	if (listindex) {
		fctl_jobwait(job);
	}
	job->job_flags = job_flags;

	/*
	 * Orphan list validation.
	 */
	mutex_enter(&port->fp_mutex);
	for (prev = NULL, orp = port->fp_orphan_list; port->fp_orphan_count &&
	    orp != NULL; orp = norp) {
		norp = orp->orp_next;
		mutex_exit(&port->fp_mutex);

		job->job_counter = 1;
		job->job_result = FC_SUCCESS;
		ASSERT((job->job_flags & JOB_TYPE_FP_ASYNC) == 0);

		((ns_req_gid_pn_t *)ns_cmd->ns_cmd_buf)->pwwn = orp->orp_pwwn;

		((ns_resp_gid_pn_t *)ns_cmd->ns_data_buf)->pid.port_id = 0;
		((ns_resp_gid_pn_t *)
		    ns_cmd->ns_data_buf)->pid.priv_lilp_posit = 0;

		rval = fp_ns_query(port, ns_cmd, job, 1, KM_SLEEP);
		if (rval == FC_SUCCESS) {
			d_id = BE_32(*((uint32_t *)ns_cmd->ns_data_buf));
			pd = fp_create_remote_port_by_ns(port, d_id, KM_SLEEP);
			if (pd != NULL) {
				fc_wwn_to_str(&orp->orp_pwwn, ww_name);

				FP_TRACE(FP_NHEAD1(6, 0),
				    "RSCN and ORPHAN list "
				    "success; d_id=%x, PWWN=%s", d_id, ww_name);

				FP_TRACE(FP_NHEAD2(6, 0),
				    "N_x Port with D_ID=%x, PWWN=%s reappeared"
				    " in fabric", d_id, ww_name);

				mutex_enter(&port->fp_mutex);
				if (prev) {
					prev->orp_next = orp->orp_next;
				} else {
					ASSERT(orp == port->fp_orphan_list);
					port->fp_orphan_list = orp->orp_next;
				}
				port->fp_orphan_count--;
				mutex_exit(&port->fp_mutex);

				kmem_free(orp, sizeof (*orp));
				fctl_copy_portmap(list + listindex++, pd);
			} else {
				prev = orp;
			}
		} else {
			prev = orp;
		}
		mutex_enter(&port->fp_mutex);
	}
	mutex_exit(&port->fp_mutex);

	/*
	 * One more pass through the list to delist old devices from
	 * the d_id and pwwn tables and possibly add to the orphan list.
	 */

	for (index = 0; index < listindex; index++) {
		pd = list[index].map_pd;
		ASSERT(pd != NULL);

		/*
		 * Update PLOGI results; For NS validation
		 * of orphan list, it is redundant
		 *
		 * Take care to preserve PORT_DEVICE_NO_SKIP_DEVICE_DISCOVERY if
		 * appropriate as fctl_copy_portmap() will clear map_flags.
		 */
		if (list[index].map_flags &
		    PORT_DEVICE_NO_SKIP_DEVICE_DISCOVERY) {
			fctl_copy_portmap(list + index, pd);
			list[index].map_flags |=
			    PORT_DEVICE_NO_SKIP_DEVICE_DISCOVERY;
		} else {
			fctl_copy_portmap(list + index, pd);
		}

		FP_TRACE(FP_NHEAD1(6, 0), "RSCN with Area DOMAIN "
		    "results; pd=%p, d_id=%x pwwn=%x %x %x %x %x %x %x %x",
		    pd, pd->pd_port_id.port_id,
		    pd->pd_port_name.raw_wwn[0],
		    pd->pd_port_name.raw_wwn[1],
		    pd->pd_port_name.raw_wwn[2],
		    pd->pd_port_name.raw_wwn[3],
		    pd->pd_port_name.raw_wwn[4],
		    pd->pd_port_name.raw_wwn[5],
		    pd->pd_port_name.raw_wwn[6],
		    pd->pd_port_name.raw_wwn[7]);

		FP_TRACE(FP_NHEAD1(6, 0), "RSCN with Area DOMAIN "
		    "results continued, pd=%p type=%x, flags=%x, state=%x",
		    pd, pd->pd_type, pd->pd_flags, pd->pd_state);

		mutex_enter(&pd->pd_mutex);
		if (pd->pd_type == PORT_DEVICE_OLD) {
			int initiator;

			pd->pd_flags = PD_IDLE;
			initiator = (pd->pd_recepient ==
			    PD_PLOGI_INITIATOR) ? 1 : 0;

			mutex_exit(&pd->pd_mutex);

			mutex_enter(&port->fp_mutex);
			mutex_enter(&pd->pd_mutex);

			pd->pd_state = PORT_DEVICE_INVALID;
			fctl_delist_did_table(port, pd);
			fctl_delist_pwwn_table(port, pd);

			mutex_exit(&pd->pd_mutex);
			mutex_exit(&port->fp_mutex);

			if (initiator) {
				(void) fctl_add_orphan(port, pd, sleep);
			}
			list[index].map_pd = pd;
		} else {
			ASSERT(pd->pd_flags == PD_IDLE);
			if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
				/*
				 * Reset LOGO tolerance to zero
				 */
				fctl_tc_reset(&pd->pd_logo_tc);
			}
			mutex_exit(&pd->pd_mutex);
		}
	}

	if (ns_cmd) {
		fctl_free_ns_cmd(ns_cmd);
	}
	if (listindex) {
		(void) fp_ulp_devc_cb(port, list, listindex, count,
		    sleep, 0);
	} else {
		kmem_free(list, sizeof (*list) * count);

		mutex_enter(&port->fp_mutex);
		if (--port->fp_rscn_count == FC_INVALID_RSCN_COUNT) {
			--port->fp_rscn_count;
		}
		mutex_exit(&port->fp_mutex);
	}
}


/*
 * Work hard to make sense out of an RSCN page.
 */
static void
fp_validate_rscn_page(fc_local_port_t *port, fc_affected_id_t *page,
    job_request_t *job, fctl_ns_req_t *ns_cmd, fc_portmap_t *listptr,
    int *listindex, int sleep)
{
	int			rval;
	char 			ww_name[17];
	la_wwn_t		*pwwn;
	fc_remote_port_t	*pwwn_pd;
	fc_remote_port_t	*did_pd;

	did_pd = fctl_get_remote_port_by_did(port, page->aff_d_id);

	FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID page; "
	    "port=%p, d_id=%x, pd=%p, rscn_count:0x%x", port, page->aff_d_id,
	    did_pd, (uint32_t)(uintptr_t)job->job_cb_arg);

	if (did_pd != NULL) {
		mutex_enter(&did_pd->pd_mutex);
		if (did_pd->pd_flags != PD_IDLE) {
			mutex_exit(&did_pd->pd_mutex);
			FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID page: "
			    "PD is BUSY; port=%p, d_id=%x, pd=%p",
			    port, page->aff_d_id, did_pd);
			return;
		}
		did_pd->pd_flags = PD_ELS_IN_PROGRESS;
		mutex_exit(&did_pd->pd_mutex);
	}

	job->job_counter = 1;

	pwwn = &((ns_resp_gpn_id_t *)ns_cmd->ns_data_buf)->pwwn;

	((ns_req_gpn_id_t *)ns_cmd->ns_cmd_buf)->pid.port_id = page->aff_d_id;
	((ns_req_gpn_id_t *)ns_cmd->ns_cmd_buf)->pid.priv_lilp_posit = 0;

	bzero(ns_cmd->ns_data_buf, sizeof (la_wwn_t));
	rval = fp_ns_query(port, ns_cmd, job, 1, sleep);

	FP_TRACE(FP_NHEAD1(1, 0), "NS Query Response for D_ID page; rev=%x,"
	    " in_id=%x, cmdrsp=%x, reason=%x, expln=%x",
	    ns_cmd->ns_resp_hdr.ct_rev, ns_cmd->ns_resp_hdr.ct_inid,
	    ns_cmd->ns_resp_hdr.ct_cmdrsp, ns_cmd->ns_resp_hdr.ct_reason,
	    ns_cmd->ns_resp_hdr.ct_expln);

	job->job_counter = 1;

	if (rval != FC_SUCCESS || fctl_is_wwn_zero(pwwn) == FC_SUCCESS) {
		/*
		 * What this means is that the D_ID
		 * disappeared from the Fabric.
		 */
		if (did_pd == NULL) {
			FP_TRACE(FP_NHEAD1(1, 0), "RSCN with D_ID page;"
			    " NULL PD disappeared, rval=%x", rval);
			return;
		}

		fc_wwn_to_str(&did_pd->pd_port_name, ww_name);

		(listptr + *listindex)->map_rscn_info.ulp_rscn_count =
		    (uint32_t)(uintptr_t)job->job_cb_arg;

		fp_fillout_old_map(listptr + (*listindex)++, did_pd, 0);

		FP_TRACE(FP_NHEAD1(3, 0), "RSCN: PD disappeared; "
		    "d_id=%x, PWWN=%s", page->aff_d_id, ww_name);

		FP_TRACE(FP_NHEAD2(9, 0),
		    "GPN_ID for D_ID=%x failed", page->aff_d_id);

		FP_TRACE(FP_NHEAD2(9, 0),
		    "N_x Port with D_ID=%x, PWWN=%s disappeared from"
		    " fabric", page->aff_d_id, ww_name);

		mutex_enter(&did_pd->pd_mutex);
		did_pd->pd_flags = PD_IDLE;
		mutex_exit(&did_pd->pd_mutex);

		FP_TRACE(FP_NHEAD1(3, 0), "RSCN with D_ID (%x) page; "
		    "PD disappeared, pd=%p", page->aff_d_id, did_pd);

		return;
	}

	pwwn_pd = fctl_get_remote_port_by_pwwn(port, pwwn);

	if (did_pd != NULL && pwwn_pd != NULL && did_pd == pwwn_pd) {
		/*
		 * There is no change. Do PLOGI again and add it to
		 * ULP portmap baggage and return. Note: When RSCNs
		 * arrive with per page states, the need for PLOGI
		 * can be determined correctly.
		 */
		mutex_enter(&pwwn_pd->pd_mutex);
		pwwn_pd->pd_type = PORT_DEVICE_NOCHANGE;
		mutex_exit(&pwwn_pd->pd_mutex);

		(listptr + *listindex)->map_rscn_info.ulp_rscn_count =
		    (uint32_t)(uintptr_t)job->job_cb_arg;

		fctl_copy_portmap(listptr + (*listindex)++, pwwn_pd);

		mutex_enter(&pwwn_pd->pd_mutex);
		if ((pwwn_pd->pd_state == PORT_DEVICE_LOGGED_IN) ||
			(pwwn_pd->pd_aux_flags & PD_LOGGED_OUT)) {
			fc_wwn_to_str(&pwwn_pd->pd_port_name, ww_name);
			mutex_exit(&pwwn_pd->pd_mutex);

			rval = fp_port_login(port, page->aff_d_id, job,
			    FP_CMD_PLOGI_RETAIN, sleep, pwwn_pd, NULL);
			if (rval == FC_SUCCESS) {
				fp_jobwait(job);
				rval = job->job_result;

				/*
				 * Reset LOGO tolerance to zero
				 * Also we are the PLOGI initiator now.
				 */
				mutex_enter(&pwwn_pd->pd_mutex);
				fctl_tc_reset(&pwwn_pd->pd_logo_tc);
				pwwn_pd->pd_recepient = PD_PLOGI_INITIATOR;
				mutex_exit(&pwwn_pd->pd_mutex);
			}

			if (rval == FC_SUCCESS) {
				struct fc_portmap *map =
				    listptr + *listindex - 1;

				FP_TRACE(FP_NHEAD2(4, 0),
				    "PLOGI succeeded: no skip(2)"
				    " for D_ID %x", page->aff_d_id);
				map->map_flags |=
				    PORT_DEVICE_NO_SKIP_DEVICE_DISCOVERY;
			} else {
				FP_TRACE(FP_NHEAD2(9, rval),
				    "PLOGI to D_ID=%x failed", page->aff_d_id);

				FP_TRACE(FP_NHEAD2(9, 0),
				    "N_x Port with D_ID=%x, PWWN=%s"
				    " disappeared from fabric",
				    page->aff_d_id, ww_name);

				fp_fillout_old_map(listptr +
				    *listindex - 1, pwwn_pd, 0);
			}
		} else {
			mutex_exit(&pwwn_pd->pd_mutex);
		}

		mutex_enter(&did_pd->pd_mutex);
		did_pd->pd_flags = PD_IDLE;
		mutex_exit(&did_pd->pd_mutex);

		FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID (0x%x) page; "
		    "Case ONE, rval=%x, result=%x pd=%p", page->aff_d_id, rval,
		    job->job_result, pwwn_pd);

		return;
	}

	if (did_pd == NULL && pwwn_pd == NULL) {

		fc_orphan_t	*orp  = NULL;
		fc_orphan_t	*norp = NULL;
		fc_orphan_t	*prev = NULL;

		/*
		 * Hunt down the orphan list before giving up.
		 */

		mutex_enter(&port->fp_mutex);
		if (port->fp_orphan_count) {

			for (orp = port->fp_orphan_list; orp; orp = norp) {
				norp = orp->orp_next;

				if (fctl_wwn_cmp(&orp->orp_pwwn, pwwn) != 0) {
					prev = orp;
					continue;
				}

				if (prev) {
					prev->orp_next = orp->orp_next;
				} else {
					ASSERT(orp ==
					    port->fp_orphan_list);
					port->fp_orphan_list =
					    orp->orp_next;
				}
				port->fp_orphan_count--;
				break;
			}
		}

		mutex_exit(&port->fp_mutex);
		pwwn_pd = fp_create_remote_port_by_ns(port,
		    page->aff_d_id, sleep);

		if (pwwn_pd != NULL) {

			if (orp) {
				fc_wwn_to_str(&orp->orp_pwwn,
				    ww_name);

				FP_TRACE(FP_NHEAD2(9, 0),
				    "N_x Port with D_ID=%x,"
				    " PWWN=%s reappeared in fabric",
				    page->aff_d_id, ww_name);

				kmem_free(orp, sizeof (*orp));
			}

			(listptr + *listindex)->
			    map_rscn_info.ulp_rscn_count =
			    (uint32_t)(uintptr_t)job->job_cb_arg;

			fctl_copy_portmap(listptr +
			    (*listindex)++, pwwn_pd);
		}

		FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID (0x%x) page; "
		    "Case TWO", page->aff_d_id);

		return;
	}

	if (pwwn_pd != NULL && did_pd == NULL) {
		uint32_t old_d_id;
		uint32_t d_id = page->aff_d_id;

		/*
		 * What this means is there is a new D_ID for this
		 * Port WWN. Take out the port device off D_ID
		 * list and put it back with a new D_ID. Perform
		 * PLOGI if already logged in.
		 */
		mutex_enter(&port->fp_mutex);
		mutex_enter(&pwwn_pd->pd_mutex);

		old_d_id = pwwn_pd->pd_port_id.port_id;

		fctl_delist_did_table(port, pwwn_pd);

		(listptr + *listindex)->map_rscn_info.ulp_rscn_count =
		    (uint32_t)(uintptr_t)job->job_cb_arg;

		fp_fillout_changed_map(listptr + (*listindex)++, pwwn_pd,
		    &d_id, NULL);
		fctl_enlist_did_table(port, pwwn_pd);

		FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID page;"
		    " Case THREE, pd=%p,"
		    " state=%x", pwwn_pd, pwwn_pd->pd_state);

		if ((pwwn_pd->pd_state == PORT_DEVICE_LOGGED_IN) ||
			(pwwn_pd->pd_aux_flags & PD_LOGGED_OUT)) {
			fc_wwn_to_str(&pwwn_pd->pd_port_name, ww_name);

			mutex_exit(&pwwn_pd->pd_mutex);
			mutex_exit(&port->fp_mutex);

			FP_TRACE(FP_NHEAD2(9, 0),
			    "N_x Port with D_ID=%x, PWWN=%s has a new"
			    " D_ID=%x now", old_d_id, ww_name, d_id);

			rval = fp_port_login(port, page->aff_d_id, job,
			    FP_CMD_PLOGI_RETAIN, sleep, pwwn_pd, NULL);
			if (rval == FC_SUCCESS) {
				fp_jobwait(job);
				rval = job->job_result;
			}

			if (rval != FC_SUCCESS) {
				fp_fillout_old_map(listptr +
				    *listindex - 1, pwwn_pd, 0);
			}
		} else {
			mutex_exit(&pwwn_pd->pd_mutex);
			mutex_exit(&port->fp_mutex);
		}

		return;
	}

	if (pwwn_pd == NULL && did_pd != NULL) {
		fc_portmap_t	*ptr;
		uint32_t 	len = 1;
		char 		old_ww_name[17];

		mutex_enter(&did_pd->pd_mutex);
		fc_wwn_to_str(&did_pd->pd_port_name, old_ww_name);
		mutex_exit(&did_pd->pd_mutex);

		fc_wwn_to_str(pwwn, ww_name);

		(listptr + *listindex)->map_rscn_info.ulp_rscn_count =
		    (uint32_t)(uintptr_t)job->job_cb_arg;

		/*
		 * What this means is that there is a new Port WWN for
		 * this D_ID; Mark the Port device as old and provide
		 * the new PWWN and D_ID combination as new.
		 */
		fp_fillout_old_map(listptr + (*listindex)++, did_pd, 0);

		FP_TRACE(FP_NHEAD2(9, 0),
		    "N_x Port with D_ID=%x, PWWN=%s has a new PWWN=%s now",
		    page->aff_d_id, old_ww_name, ww_name);

		(listptr + *listindex)->map_rscn_info.ulp_rscn_count =
		    (uint32_t)(uintptr_t)job->job_cb_arg;

		ptr = listptr + (*listindex)++;

		job->job_counter = 1;

		if (fp_ns_getmap(port, job, &ptr, &len,
		    page->aff_d_id - 1) != FC_SUCCESS) {
			(*listindex)--;
		}

		mutex_enter(&did_pd->pd_mutex);
		did_pd->pd_flags = PD_IDLE;
		mutex_exit(&did_pd->pd_mutex);

		return;
	}

	/*
	 * A weird case of Port WWN and D_ID existence but not matching up
	 * between them. Trust your instincts - Take the port device handle
	 * off Port WWN list, fix it with new Port WWN and put it back, In
	 * the mean time mark the port device corresponding to the old port
	 * WWN as OLD.
	 */
	FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID page; Case WEIRD, pwwn_pd=%p,"
	    " did_pd=%p", pwwn_pd, did_pd);

	mutex_enter(&port->fp_mutex);
	mutex_enter(&pwwn_pd->pd_mutex);

	pwwn_pd->pd_type = PORT_DEVICE_OLD;
	pwwn_pd->pd_state = PORT_DEVICE_INVALID;
	fctl_delist_did_table(port, pwwn_pd);
	fctl_delist_pwwn_table(port, pwwn_pd);

	FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID page; case WEIRD continued,"
	    " pwwn-d_id=%x pwwn-wwn=%x %x %x %x %x %x %x %x",
	    pwwn_pd->pd_port_id.port_id,

	    pwwn_pd->pd_port_name.raw_wwn[0],
	    pwwn_pd->pd_port_name.raw_wwn[1],
	    pwwn_pd->pd_port_name.raw_wwn[2],
	    pwwn_pd->pd_port_name.raw_wwn[3],
	    pwwn_pd->pd_port_name.raw_wwn[4],
	    pwwn_pd->pd_port_name.raw_wwn[5],
	    pwwn_pd->pd_port_name.raw_wwn[6],
	    pwwn_pd->pd_port_name.raw_wwn[7]);

	mutex_exit(&pwwn_pd->pd_mutex);
	mutex_exit(&port->fp_mutex);

	(listptr + *listindex)->map_rscn_info.ulp_rscn_count =
	    (uint32_t)(uintptr_t)job->job_cb_arg;

	fctl_copy_portmap(listptr + (*listindex)++, pwwn_pd);

	mutex_enter(&port->fp_mutex);
	mutex_enter(&did_pd->pd_mutex);

	fctl_delist_pwwn_table(port, did_pd);

	(listptr + *listindex)->map_rscn_info.ulp_rscn_count =
	    (uint32_t)(uintptr_t)job->job_cb_arg;

	fp_fillout_changed_map(listptr + (*listindex)++, did_pd, NULL, pwwn);
	fctl_enlist_pwwn_table(port, did_pd);

	FP_TRACE(FP_NHEAD1(6, 0), "RSCN with D_ID page; case WEIRD continued,"
	    " d_id=%x, state=%x, did-wwn=%x %x %x %x %x %x %x %x",
	    did_pd->pd_port_id.port_id, did_pd->pd_state,

	    did_pd->pd_port_name.raw_wwn[0],
	    did_pd->pd_port_name.raw_wwn[1],
	    did_pd->pd_port_name.raw_wwn[2],
	    did_pd->pd_port_name.raw_wwn[3],
	    did_pd->pd_port_name.raw_wwn[4],
	    did_pd->pd_port_name.raw_wwn[5],
	    did_pd->pd_port_name.raw_wwn[6],
	    did_pd->pd_port_name.raw_wwn[7]);

	if ((did_pd->pd_state == PORT_DEVICE_LOGGED_IN) ||
		(did_pd->pd_aux_flags & PD_LOGGED_OUT)) {
		mutex_exit(&did_pd->pd_mutex);
		mutex_exit(&port->fp_mutex);

		rval = fp_port_login(port, page->aff_d_id, job,
		    FP_CMD_PLOGI_RETAIN, sleep, did_pd, NULL);
		if (rval == FC_SUCCESS) {
			fp_jobwait(job);
			if (job->job_result != FC_SUCCESS) {
				fp_fillout_old_map(listptr +
				    *listindex - 1, did_pd, 0);
			}
		} else {
			fp_fillout_old_map(listptr + *listindex - 1, did_pd, 0);
		}
	} else {
		mutex_exit(&did_pd->pd_mutex);
		mutex_exit(&port->fp_mutex);
	}

	mutex_enter(&did_pd->pd_mutex);
	did_pd->pd_flags = PD_IDLE;
	mutex_exit(&did_pd->pd_mutex);
}


/*
 * Check with NS for the presence of this port WWN
 */
static int
fp_ns_validate_device(fc_local_port_t *port, fc_remote_port_t *pd,
    job_request_t *job, int polled, int sleep)
{
	la_wwn_t	pwwn;
	uint32_t	flags;
	fctl_ns_req_t	*ns_cmd;

	flags = FCTL_NS_VALIDATE_PD | ((polled) ? 0: FCTL_NS_ASYNC_REQUEST);
	ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gid_pn_t),
	    sizeof (ns_resp_gid_pn_t), sizeof (ns_resp_gid_pn_t),
	    flags, sleep);
	if (ns_cmd == NULL) {
		return (FC_NOMEM);
	}

	mutex_enter(&pd->pd_mutex);
	pwwn = pd->pd_port_name;
	mutex_exit(&pd->pd_mutex);

	ns_cmd->ns_cmd_code = NS_GID_PN;
	ns_cmd->ns_pd = pd;
	((ns_req_gid_pn_t *)ns_cmd->ns_cmd_buf)->pwwn = pwwn;
	((ns_resp_gid_pn_t *)ns_cmd->ns_data_buf)->pid.port_id = 0;
	((ns_resp_gid_pn_t *)ns_cmd->ns_data_buf)->pid.priv_lilp_posit = 0;

	return (fp_ns_query(port, ns_cmd, job, polled, sleep));
}


/*
 * Sanity check the LILP map returned by FCA
 */
static int
fp_validate_lilp_map(fc_lilpmap_t *lilp_map)
{
	int	count;

	if (lilp_map->lilp_length == 0) {
		return (FC_FAILURE);
	}

	for (count = 0; count < lilp_map->lilp_length; count++) {
		if (fp_is_valid_alpa(lilp_map->lilp_alpalist[count]) !=
		    FC_SUCCESS) {
			return (FC_FAILURE);
		}
	}

	return (FC_SUCCESS);
}


/*
 * Sanity check if the AL_PA is a valid address
 */
static int
fp_is_valid_alpa(uchar_t al_pa)
{
	int 	count;

	for (count = 0; count < sizeof (fp_valid_alpas); count++) {
		if (al_pa == fp_valid_alpas[count] || al_pa == 0) {
			return (FC_SUCCESS);
		}
	}

	return (FC_FAILURE);
}


/*
 * Post unsolicited callbacks to ULPs
 */
static void
fp_ulp_unsol_cb(void *arg)
{
	fp_unsol_spec_t	*ub_spec = (fp_unsol_spec_t *)arg;

	fctl_ulp_unsol_cb(ub_spec->port, ub_spec->buf,
	    ub_spec->buf->ub_frame.type);
	kmem_free(ub_spec, sizeof (*ub_spec));
}


/*
 * Perform message reporting in a consistent manner. Unless there is
 * a strong reason NOT to use this function (which is very very rare)
 * all message reporting should go through this.
 */
static void
fp_printf(fc_local_port_t *port, int level, fp_mesg_dest_t dest, int fc_errno,
    fc_packet_t *pkt, const char *fmt, ...)
{
	caddr_t		buf;
	va_list		ap;

	switch (level) {
	case CE_NOTE:
		if ((port->fp_verbose & FP_WARNING_MESSAGES) == 0) {
			return;
		}
		break;

	case CE_WARN:
		if ((port->fp_verbose & FP_FATAL_MESSAGES) == 0) {
			return;
		}
		break;
	}

	buf = kmem_zalloc(256, KM_NOSLEEP);
	if (buf == NULL) {
		return;
	}

	(void) sprintf(buf, "fp(%d): ", port->fp_instance);

	va_start(ap, fmt);
	(void) vsprintf(buf + strlen(buf), fmt, ap);
	va_end(ap);

	if (fc_errno) {
		char *errmsg;

		(void) fc_ulp_error(fc_errno, &errmsg);
		(void) sprintf(buf + strlen(buf), " FC Error=%s", errmsg);
	} else {
		if (pkt) {
			caddr_t	state, reason, action, expln;

			(void) fc_ulp_pkt_error(pkt, &state, &reason,
			    &action, &expln);

			(void) sprintf(buf + strlen(buf),
			    " state=%s, reason=%s", state, reason);

			if (pkt->pkt_resp_resid) {
				(void) sprintf(buf + strlen(buf),
				    " resp resid=%x\n", pkt->pkt_resp_resid);
			}
		}
	}

	switch (dest) {
	case FP_CONSOLE_ONLY:
		cmn_err(level, "^%s", buf);
		break;

	case FP_LOG_ONLY:
		cmn_err(level, "!%s", buf);
		break;

	default:
		cmn_err(level, "%s", buf);
		break;
	}

	kmem_free(buf, 256);
}

static int
fp_fcio_login(fc_local_port_t *port, fcio_t *fcio, job_request_t *job)
{
	int			ret;
	uint32_t 		d_id;
	la_wwn_t		pwwn;
	fc_remote_port_t 	*pd = NULL;
	fc_remote_port_t 	*held_pd = NULL;
	fctl_ns_req_t		*ns_cmd;
	fc_portmap_t		*changelist;

	bcopy(fcio->fcio_ibuf, &pwwn, sizeof (pwwn));

	mutex_enter(&port->fp_mutex);
	if (FC_IS_TOP_SWITCH(port->fp_topology)) {
		mutex_exit(&port->fp_mutex);
		job->job_counter = 1;

		job->job_result = FC_SUCCESS;

		ns_cmd = fctl_alloc_ns_cmd(sizeof (ns_req_gid_pn_t),
		    sizeof (ns_resp_gid_pn_t), sizeof (ns_resp_gid_pn_t),
		    FCTL_NS_BUF_IS_USERLAND, KM_SLEEP);

		ASSERT(ns_cmd != NULL);

		ns_cmd->ns_cmd_code = NS_GID_PN;
		((ns_req_gid_pn_t *)(ns_cmd->ns_cmd_buf))->pwwn = pwwn;

		ret = fp_ns_query(port, ns_cmd, job, 1, KM_SLEEP);

		if (ret != FC_SUCCESS || job->job_result != FC_SUCCESS) {
			if (ret != FC_SUCCESS) {
				fcio->fcio_errno = ret;
			} else {
				fcio->fcio_errno = job->job_result;
			}
			fctl_free_ns_cmd(ns_cmd);
			return (EIO);
		}
		d_id = BE_32(*((uint32_t *)ns_cmd->ns_data_buf));
		fctl_free_ns_cmd(ns_cmd);
	} else {
		mutex_exit(&port->fp_mutex);

		held_pd = fctl_hold_remote_port_by_pwwn(port, &pwwn);
		if (held_pd == NULL) {
			fcio->fcio_errno = FC_BADWWN;
			return (EIO);
		}
		pd = held_pd;

		mutex_enter(&pd->pd_mutex);
		d_id = pd->pd_port_id.port_id;
		mutex_exit(&pd->pd_mutex);
	}

	job->job_counter = 1;

	pd = fctl_get_remote_port_by_did(port, d_id);

	if (pd) {
		mutex_enter(&pd->pd_mutex);
		if (pd->pd_state == PORT_DEVICE_LOGGED_IN) {
			pd->pd_login_count++;
			mutex_exit(&pd->pd_mutex);

			fcio->fcio_errno = FC_SUCCESS;
			if (held_pd) {
				fctl_release_remote_port(held_pd);
			}

			return (0);
		}
		mutex_exit(&pd->pd_mutex);
	} else {
		mutex_enter(&port->fp_mutex);
		if (FC_IS_TOP_SWITCH(port->fp_topology)) {
			mutex_exit(&port->fp_mutex);
			pd = fp_create_remote_port_by_ns(port, d_id, KM_SLEEP);
			if (pd == NULL) {
				fcio->fcio_errno = FC_FAILURE;
				if (held_pd) {
					fctl_release_remote_port(held_pd);
				}
				return (EIO);
			}
		} else {
			mutex_exit(&port->fp_mutex);
		}
	}

	job->job_flags &= ~JOB_TYPE_FP_ASYNC;
	job->job_counter = 1;

	ret = fp_port_login(port, d_id, job, FP_CMD_PLOGI_RETAIN,
	    KM_SLEEP, pd, NULL);

	if (ret != FC_SUCCESS) {
		fcio->fcio_errno = ret;
		if (held_pd) {
			fctl_release_remote_port(held_pd);
		}
		return (EIO);
	}
	fp_jobwait(job);

	fcio->fcio_errno = job->job_result;

	if (held_pd) {
		fctl_release_remote_port(held_pd);
	}

	if (job->job_result != FC_SUCCESS) {
		return (EIO);
	}

	pd = fctl_hold_remote_port_by_pwwn(port, &pwwn);
	if (pd == NULL) {
		fcio->fcio_errno = FC_BADDEV;
		return (ENODEV);
	}

	changelist = kmem_zalloc(sizeof (*changelist), KM_SLEEP);

	fctl_copy_portmap(changelist, pd);
	changelist->map_type = PORT_DEVICE_USER_LOGIN;

	(void) fp_ulp_devc_cb(port, changelist, 1, 1, KM_SLEEP, 1);

	mutex_enter(&pd->pd_mutex);
	pd->pd_type = PORT_DEVICE_NOCHANGE;
	mutex_exit(&pd->pd_mutex);

	fctl_release_remote_port(pd);

	return (0);
}


static int
fp_fcio_logout(fc_local_port_t *port, fcio_t *fcio, job_request_t *job)
{
	la_wwn_t		pwwn;
	fp_cmd_t		*cmd;
	fc_portmap_t		*changelist;
	fc_remote_port_t 	*pd;

	bcopy(fcio->fcio_ibuf, &pwwn, sizeof (pwwn));

	pd = fctl_hold_remote_port_by_pwwn(port, &pwwn);
	if (pd == NULL) {
		fcio->fcio_errno = FC_BADWWN;
		return (ENXIO);
	}

	mutex_enter(&pd->pd_mutex);
	if (pd->pd_state != PORT_DEVICE_LOGGED_IN) {
		fcio->fcio_errno = FC_LOGINREQ;
		mutex_exit(&pd->pd_mutex);

		fctl_release_remote_port(pd);

		return (EINVAL);
	}

	ASSERT(pd->pd_login_count >= 1);

	if (pd->pd_flags == PD_ELS_IN_PROGRESS) {
		fcio->fcio_errno = FC_FAILURE;
		mutex_exit(&pd->pd_mutex);

		fctl_release_remote_port(pd);

		return (EBUSY);
	}

	if (pd->pd_login_count > 1) {
		pd->pd_login_count--;
		fcio->fcio_errno = FC_SUCCESS;
		mutex_exit(&pd->pd_mutex);

		changelist = kmem_zalloc(sizeof (*changelist), KM_SLEEP);

		fctl_copy_portmap(changelist, pd);
		changelist->map_type = PORT_DEVICE_USER_LOGOUT;

		fctl_release_remote_port(pd);

		(void) fp_ulp_devc_cb(port, changelist, 1, 1, KM_SLEEP, 1);

		return (0);
	}

	pd->pd_flags = PD_ELS_IN_PROGRESS;
	mutex_exit(&pd->pd_mutex);

	job->job_counter = 1;

	cmd = fp_alloc_pkt(port, sizeof (la_els_logo_t),
	    FP_PORT_IDENTIFIER_LEN, KM_SLEEP, pd);
	if (cmd == NULL) {
		fcio->fcio_errno = FC_NOMEM;
		fctl_release_remote_port(pd);

		mutex_enter(&pd->pd_mutex);
		pd->pd_flags = PD_IDLE;
		mutex_exit(&pd->pd_mutex);

		return (ENOMEM);
	}

	mutex_enter(&port->fp_mutex);
	mutex_enter(&pd->pd_mutex);

	cmd->cmd_pkt.pkt_tran_flags = FC_TRAN_INTR | pd->pd_login_class;
	cmd->cmd_pkt.pkt_tran_type = FC_PKT_EXCHANGE;
	cmd->cmd_flags = FP_CMD_PLOGI_DONT_CARE;
	cmd->cmd_retry_count = 1;
	cmd->cmd_ulp_pkt = NULL;

	fp_logo_init(pd, cmd, job);

	mutex_exit(&pd->pd_mutex);
	mutex_exit(&port->fp_mutex);

	if (fp_sendcmd(port, cmd, port->fp_fca_handle) != FC_SUCCESS) {
		mutex_enter(&pd->pd_mutex);
		pd->pd_flags = PD_IDLE;
		mutex_exit(&pd->pd_mutex);

		fp_free_pkt(cmd);
		fctl_release_remote_port(pd);

		return (EIO);
	}

	fp_jobwait(job);

	fcio->fcio_errno = job->job_result;
	if (job->job_result != FC_SUCCESS) {
		mutex_enter(&pd->pd_mutex);
		pd->pd_flags = PD_IDLE;
		mutex_exit(&pd->pd_mutex);

		fctl_release_remote_port(pd);

		return (EIO);
	}

	ASSERT(pd != NULL);

	changelist = kmem_zalloc(sizeof (*changelist), KM_SLEEP);

	fctl_copy_portmap(changelist, pd);
	changelist->map_type = PORT_DEVICE_USER_LOGOUT;
	changelist->map_state = PORT_DEVICE_INVALID;

	mutex_enter(&port->fp_mutex);
	mutex_enter(&pd->pd_mutex);

	fctl_delist_did_table(port, pd);
	fctl_delist_pwwn_table(port, pd);
	pd->pd_flags = PD_IDLE;

	mutex_exit(&pd->pd_mutex);
	mutex_exit(&port->fp_mutex);

	(void) fp_ulp_devc_cb(port, changelist, 1, 1, KM_SLEEP, 1);

	fctl_release_remote_port(pd);

	return (0);
}



/*
 * Send a syslog event for adapter port level events.
 */
static void
fp_log_port_event(fc_local_port_t *port, char *subclass)
{
	nvlist_t *attr_list;

	if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE,
	    KM_SLEEP) != DDI_SUCCESS) {
		goto alloc_failed;
	}

	if (nvlist_add_uint32(attr_list, "instance",
	    port->fp_instance) != DDI_SUCCESS) {
		goto error;
	}

	if (nvlist_add_byte_array(attr_list, "port-wwn",
	    port->fp_service_params.nport_ww_name.raw_wwn,
	    sizeof (la_wwn_t)) != DDI_SUCCESS) {
		goto error;
	}

	(void) ddi_log_sysevent(port->fp_port_dip, DDI_VENDOR_SUNW, EC_SUNFC,
	    subclass, attr_list, NULL, DDI_SLEEP);

	nvlist_free(attr_list);
	return;

error:
	nvlist_free(attr_list);
alloc_failed:
	FP_TRACE(FP_NHEAD1(9, 0), "Unable to send %s event", subclass);
}


static void
fp_log_target_event(fc_local_port_t *port, char *subclass, la_wwn_t tgt_pwwn,
    uint32_t port_id)
{
	nvlist_t *attr_list;

	if (nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE,
	    KM_SLEEP) != DDI_SUCCESS) {
		goto alloc_failed;
	}

	if (nvlist_add_uint32(attr_list, "instance",
	    port->fp_instance) != DDI_SUCCESS) {
		goto error;
	}

	if (nvlist_add_byte_array(attr_list, "port-wwn",
	    port->fp_service_params.nport_ww_name.raw_wwn,
	    sizeof (la_wwn_t)) != DDI_SUCCESS) {
		goto error;
	}

	if (nvlist_add_byte_array(attr_list, "target-port-wwn",
	    tgt_pwwn.raw_wwn, sizeof (la_wwn_t)) != DDI_SUCCESS) {
		goto error;
	}

	if (nvlist_add_uint32(attr_list, "target-port-id",
	    port_id) != DDI_SUCCESS) {
		goto error;
	}

	(void) ddi_log_sysevent(port->fp_port_dip, DDI_VENDOR_SUNW, EC_SUNFC,
	    subclass, attr_list, NULL, DDI_SLEEP);

	nvlist_free(attr_list);
	return;

error:
	nvlist_free(attr_list);
alloc_failed:
	FP_TRACE(FP_NHEAD1(9, 0), "Unable to send %s event", subclass);
}

static uint32_t
fp_map_remote_port_state(uint32_t rm_state)
{
	switch (rm_state) {
		case PORT_DEVICE_LOGGED_IN:
			return (FC_HBA_PORTSTATE_ONLINE);
		case PORT_DEVICE_VALID:
		case PORT_DEVICE_INVALID:
		default:
			return (FC_HBA_PORTSTATE_UNKNOWN);
	}
}