Bring in the Broadcom/Emulex Fibre Channel driver, ocs_fc(4).

The ocs_fc(4) driver supports the following hardware:

Emulex 16/8G FC GEN 5 HBAS
	LPe15004 FC Host Bus Adapters
	LPe160XX FC Host Bus Adapters

Emulex 32/16G FC GEN 6 HBAS
	LPe3100X FC Host Bus Adapters
	LPe3200X FC Host Bus Adapters

The driver supports target and initiator mode, and also supports FC-Tape.

Note that the driver only currently works on little endian platforms.  It
is only included in the module build for amd64 and i386, and in GENERIC
on amd64 only.

Submitted by:	Ram Kishore Vegesna <ram.vegesna@broadcom.com>
Reviewed by:	mav
MFC after:	5 days
Relnotes:	yes
Sponsored by:	Broadcom
Differential Revision:	https://reviews.freebsd.org/D11423

55 files changed, 69390 insertions, 0 deletions

diff --git a/share/man/man4/Makefile b/share/man/man4/Makefile
index 007ca6df5da8..1ea40b109e9b 100644
--- a/share/man/man4/Makefile
+++ b/share/man/man4/Makefile
@@ -402,6 +402,7 @@ MAN=	aac.4 \
 	${_nvram2env.4} \
 	${_nxge.4} \
 	oce.4 \
+	ocs_fc.4\
 	ohci.4 \
 	orm.4 \
 	ow.4 \
diff --git a/share/man/man4/ocs_fc.4 b/share/man/man4/ocs_fc.4
new file mode 100644
index 000000000000..a2f13c483930
--- /dev/null
+++ b/share/man/man4/ocs_fc.4
@@ -0,0 +1,194 @@
+.\" Copyright (c) 2017 Broadcom. All rights reserved.
+.\" The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions are met:
+.\"
+.\" 1. Redistributions of source code must retain the above copyright notice,
+.\"    this list of conditions and the following disclaimer.
+.\"
+.\" 2. Redistributions in binary form must reproduce the above copyright notice,
+.\"    this list of conditions and the following disclaimer in the documentation
+.\"    and/or other materials provided with the distribution.
+.\"
+.\" 3. Neither the name of the copyright holder nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+.\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+.\" LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+.\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+.\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+.\" INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+.\" CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+.\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+.\" POSSIBILITY OF SUCH DAMAGE.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd March 30, 2018
+.Dt OCS_FC 4
+.Os
+.Sh NAME
+.Nm ocs_fc
+.Nd "Device driver for Emulex Fibre Channel Host Adapters"
+.Sh SYNOPSIS
+To compile this driver into the kernel, add this line to the
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device ocs_fc"
+.Ed
+.Pp
+To load the driver as a module at boot, add this line to
+.Xr loader.conf 5 :
+.Bd -literal -offset indent
+ocs_fc_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides access to Fibre Channel SCSI devices.
+.Pp
+The
+.Nm
+driver supports initiator and target modes.
+Support is available for Arbitrated loops, Point-to-Point,
+and Fabric connections.
+FC-Tape is highly recommended for connections to tape drives that support
+it.
+FC-Tape includes four elements from the T-10 FCP-4 specification:
+.Bl -bullet -offset indent
+.It
+Precise Delivery of Commands
+.It
+Confirmed Completion of FCP I/O Operations
+.It
+Retransmission of Unsuccessfully Transmitted IUs
+.It
+Task Retry Identification
+.El
+.Pp
+Together these features allow for link level error recovery with tape
+devices.
+Without link level error recovery, an initiator cannot, for instance, tell whether a tape write
+command that has timed out resulted in all, part, or none of the data going to
+the tape drive.
+FC-Tape is automatically enabled when both the controller and target support it.
+
+.Sh HARDWARE
+The
+.Nm
+driver supports these Fibre Channel adapters:
+.Bl -tag -width xxxxxx -offset indent
+.It Emulex 16/8G FC GEN 5 HBAS
+.Bd -literal -offset indent
+LPe15004 FC Host Bus Adapters
+LPe160XX FC Host Bus Adapters
+.Ed
+.It Emulex 32/16G FC GEN 6 HBAS
+.Bd -literal -offset indent
+LPe3100X FC Host Bus Adapters
+LPe3200X FC Host Bus Adapters
+.Ed
+.El
+.Sh UPDATING FIRMWARE
+Adapter firmware updates are persistent.
+.Pp
+Firmware can be updated by following these steps:
+.Bl -enum
+.It
+Copy this code to a
+.Pa Makefile :
+.Bd -literal -offset indent
+KMOD=ocsflash
+FIRMWS=imagename.grp:ocsflash
+\&.include <bsd.kmod.mk>
+.Ed
+.It
+Replace
+.Pa imagename
+with the name of the GRP file.
+.It
+Copy the
+.Pa Makefile
+and GRP file to a local directory
+.It
+Execute
+.Cm make
+and copy the generated
+.Pa ocsflash.ko
+file to
+.Pa /lib/modules
+.It
+.Cm sysctl dev.ocs_fc.<N>.fw_upgrade=ocsflash
+.It
+Check kernel messages regarding status of the operation
+.It
+Reboot the machine
+.El
+.Pp
+.Sh BOOT OPTIONS
+Options are controlled by setting values in
+.Pa /boot/device.hints .
+.Pp
+They are:
+.Bl -tag -width indent
+.It Va hint.ocs_fc.N.initiator
+Enable initiator functionality.
+Default 1 (enabled), 0 to disable.
+.It Va hint.ocs_fc.N.target
+Enable target functionality.
+Default 1 (enabled), 0 to disable.
+.It Va hint.ocs_fc.N.topology
+Topology: 0 for Auto, 1 for NPort only, 2 for Loop only.
+.It Va hint.ocs_fc.N.speed
+Link speed in megabits per second.
+Possible values include:
+0 Auto-speed negotiation (default), 4000 (4GFC), 8000 (8GFC), 16000 (16GFC).
+.El
+.Sh SYSCTL OPTIONS
+.Bl -tag -width indent
+.It Va dev.ocs_fc.N.port_state
+Port state (read/write).
+Valid values are
+.Li online
+and
+.Li offline .
+.It Va dev.ocs_fc.N.wwpn
+World Wide Port Name (read/write).
+.It Va dev.ocs_fc.N.wwnn
+World Wide Node Name (read/write).
+.It Va dev.ocs_fc.N.fwrev
+Firmware revision (read-only).
+.It Va dev.ocs_fc.N.sn
+Adapter serial number (read-only).
+.It Va dev.ocs_fc.N.configured_speed
+Configured Port Speed (read/write).
+Valid values are:
+0 Auto-speed negotiation (default), 4000 (4GFC), 8000 (8GFC), 16000 (16GFC).
+.It Va dev.ocs_fc.N.configured_topology
+Configured Port Topology (read/write).
+Valid values are:
+0-Auto; 1-NPort; 2-Loop.
+.It Va dev.ocs_fc.N.current_speed
+Current Port Speed (read-only).
+.It Va dev.ocs_fc.N.current_topology
+Current Port Topology (read-only).
+.El
+.Sh SUPPORT
+For general information and support,
+go to the Broadcom website at:
+.Pa http://www.broadcom.com/
+or E-Mail at
+.Pa ocs-driver-team.pdl@broadcom.com.
+.Sh SEE ALSO
+.Xr ifconfig 8
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Broadcom.
diff --git a/sys/amd64/conf/GENERIC b/sys/amd64/conf/GENERIC
index d1219b7c75bb..c57b7783c657 100644
--- a/sys/amd64/conf/GENERIC
+++ b/sys/amd64/conf/GENERIC
@@ -141,6 +141,7 @@ device		adw			# Advansys wide SCSI adapters
 device		aic			# Adaptec 15[012]x SCSI adapters, AIC-6[23]60.
 device		bt			# Buslogic/Mylex MultiMaster SCSI adapters
 device		isci			# Intel C600 SAS controller
+device		ocs_fc			# Emulex FC adapters
 
 # ATA/SCSI peripherals
 device		scbus			# SCSI bus (required for ATA/SCSI)
diff --git a/sys/conf/files b/sys/conf/files
index 0a0b6ac831cb..1c344e2d41b3 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -2578,6 +2578,27 @@ dev/oce/oce_mbox.c		optional oce pci
 dev/oce/oce_queue.c		optional oce pci
 dev/oce/oce_sysctl.c		optional oce pci
 dev/oce/oce_util.c		optional oce pci
+dev/ocs_fc/ocs_pci.c		optional ocs_fc pci
+dev/ocs_fc/ocs_ioctl.c		optional ocs_fc pci
+dev/ocs_fc/ocs_os.c		optional ocs_fc pci
+dev/ocs_fc/ocs_utils.c		optional ocs_fc pci
+dev/ocs_fc/ocs_hw.c		optional ocs_fc pci
+dev/ocs_fc/ocs_hw_queues.c	optional ocs_fc pci
+dev/ocs_fc/sli4.c		optional ocs_fc pci
+dev/ocs_fc/ocs_sm.c		optional ocs_fc pci
+dev/ocs_fc/ocs_device.c		optional ocs_fc pci
+dev/ocs_fc/ocs_xport.c		optional ocs_fc pci
+dev/ocs_fc/ocs_domain.c		optional ocs_fc pci
+dev/ocs_fc/ocs_sport.c		optional ocs_fc pci
+dev/ocs_fc/ocs_els.c		optional ocs_fc pci
+dev/ocs_fc/ocs_fabric.c		optional ocs_fc pci
+dev/ocs_fc/ocs_io.c		optional ocs_fc pci
+dev/ocs_fc/ocs_node.c		optional ocs_fc pci
+dev/ocs_fc/ocs_scsi.c		optional ocs_fc pci
+dev/ocs_fc/ocs_unsol.c		optional ocs_fc pci
+dev/ocs_fc/ocs_ddump.c		optional ocs_fc pci
+dev/ocs_fc/ocs_mgmt.c		optional ocs_fc pci
+dev/ocs_fc/ocs_cam.c		optional ocs_fc pci
 dev/ofw/ofw_bus_if.m		optional fdt
 dev/ofw/ofw_bus_subr.c		optional fdt
 dev/ofw/ofw_cpu.c		optional fdt
diff --git a/sys/dev/ocs_fc/ocs.h b/sys/dev/ocs_fc/ocs.h
new file mode 100644
index 000000000000..69db2b481363
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs.h
@@ -0,0 +1,261 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS bsd driver common include file
+ */
+
+
+#if !defined(__OCS_H__)
+#define __OCS_H__
+
+#include "ocs_os.h"
+#include "ocs_utils.h"
+
+#include "ocs_hw.h"
+#include "ocs_scsi.h"
+#include "ocs_io.h"
+
+#include "version.h"
+
+#define DRV_NAME			"ocs_fc"
+#define DRV_VERSION 							\
+	STR_BE_MAJOR "." STR_BE_MINOR "." STR_BE_BUILD "." STR_BE_BRANCH
+
+/**
+ * @brief Interrupt context
+ */
+typedef struct ocs_intr_ctx_s {
+	uint32_t	vec;		/** Zero based interrupt vector */
+	void		*softc;		/** software context for interrupt */
+	char		name[64];	/** label for this context */
+} ocs_intr_ctx_t;
+
+typedef struct ocs_fcport_s {
+	struct cam_sim          *sim;
+	struct cam_path         *path;
+	uint32_t                role;
+
+	ocs_tgt_resource_t      targ_rsrc_wildcard;
+	ocs_tgt_resource_t      targ_rsrc[OCS_MAX_LUN];
+	ocs_vport_spec_t	*vport;
+} ocs_fcport;
+
+#define FCPORT(ocs, chan)	(&((ocs_fcport *)(ocs)->fcports)[(chan)])
+
+/**
+ * @brief Driver's context
+ */
+
+struct ocs_softc {
+
+	device_t		dev;
+	struct cdev		*cdev;
+
+	ocs_pci_reg_t		reg[PCI_MAX_BAR];
+
+	uint32_t		instance_index;
+	const char		*desc;
+
+	uint32_t		irqid;
+	struct resource		*irq;
+	void			*tag;
+
+	ocs_intr_ctx_t		intr_ctx;
+	uint32_t		n_vec;
+
+	bus_dma_tag_t		dmat;	/** Parent DMA tag */
+	bus_dma_tag_t		buf_dmat;/** IO buffer DMA tag */
+	char display_name[OCS_DISPLAY_NAME_LENGTH];
+	uint16_t		pci_vendor;
+	uint16_t		pci_device;
+	uint16_t		pci_subsystem_vendor;
+	uint16_t		pci_subsystem_device;
+	char			businfo[16];
+	const char		*driver_version;
+	const char		*fw_version;
+	const char		*model;
+
+	ocs_hw_t hw;
+
+	ocs_rlock_t lock;	/**< device wide lock */
+
+	ocs_xport_e		ocs_xport;
+	ocs_xport_t *xport;	/**< pointer to transport object */
+	ocs_domain_t *domain;
+	ocs_list_t domain_list;
+	uint32_t domain_instance_count;
+	void (*domain_list_empty_cb)(ocs_t *ocs, void *arg);		
+	void *domain_list_empty_cb_arg;
+
+	uint8_t enable_ini;
+	uint8_t enable_tgt;
+	uint8_t fc_type;
+	int ctrlmask;
+	uint8_t explicit_buffer_list;
+	uint8_t external_loopback;
+	uint8_t skip_hw_teardown;
+	int speed;
+	int topology;
+	int ethernet_license;
+	int num_scsi_ios;
+	uint8_t enable_hlm;
+	uint32_t hlm_group_size;
+	uint32_t max_isr_time_msec;	/*>> Maximum ISR time */
+	uint32_t auto_xfer_rdy_size; /*>> Max sized write to use auto xfer rdy*/
+	uint8_t esoc;
+	int logmask;
+	char *hw_war_version;
+	uint32_t num_vports;
+	uint32_t target_io_timer_sec;
+	uint32_t hw_bounce;
+	uint8_t rq_threads;
+	uint8_t rq_selection_policy;
+	uint8_t rr_quanta;
+	char *filter_def;
+	uint32_t max_remote_nodes;
+
+	/*
+	 * tgt_rscn_delay - delay in kicking off RSCN processing 
+	 * (nameserver queries) after receiving an RSCN on the target. 
+	 * This prevents thrashing of nameserver requests due to a huge burst of
+	 * RSCNs received in a short period of time.
+	 * Note: this is only valid when target RSCN handling is enabled -- see 
+	 * ctrlmask.
+	 */
+	time_t tgt_rscn_delay_msec;	/*>> minimum target RSCN delay */
+
+	/*
+	 * tgt_rscn_period - determines maximum frequency when processing 
+	 * back-to-back RSCNs; e.g. if this value is 30, there will never be 
+	 * any more than 1 RSCN handling per 30s window. This prevents 
+	 * initiators on a faulty link generating many RSCN from causing the 
+	 * target to continually query the nameserver. 
+	 * Note: This is only valid when target RSCN handling is enabled
+	 */
+	time_t tgt_rscn_period_msec;	/*>> minimum target RSCN period */
+
+	uint32_t		enable_task_set_full;		
+	uint32_t		io_in_use;		
+	uint32_t		io_high_watermark; /**< used to send task set full */
+	struct mtx              sim_lock;
+	uint32_t		config_tgt:1,	/**< Configured to support target mode */
+				config_ini:1;	/**< Configured to support initiator mode */
+
+
+	uint32_t nodedb_mask;			/**< Node debugging mask */
+
+	char			modeldesc[64];
+	char			serialnum[64];
+	char			fwrev[64];
+	char			sli_intf[9];
+
+	ocs_ramlog_t		*ramlog;
+	ocs_textbuf_t		ddump_saved;
+
+	ocs_mgmt_functions_t	*mgmt_functions;
+	ocs_mgmt_functions_t	*tgt_mgmt_functions;
+	ocs_mgmt_functions_t	*ini_mgmt_functions;
+
+	ocs_err_injection_e err_injection;
+	uint32_t cmd_err_inject;
+	time_t delay_value_msec;
+
+	bool			attached;
+	struct mtx		dbg_lock;
+	
+	struct cam_devq		*devq;
+	ocs_fcport		*fcports;
+
+	void*			tgt_ocs;
+};
+
+static inline void
+ocs_device_lock_init(ocs_t *ocs)
+{
+	ocs_rlock_init(ocs, &ocs->lock, "ocsdevicelock");
+}
+
+static inline int32_t
+ocs_device_lock_try(ocs_t *ocs)
+{
+	return ocs_rlock_try(&ocs->lock);
+}
+
+static inline void
+ocs_device_lock(ocs_t *ocs)
+{
+	ocs_rlock_acquire(&ocs->lock);
+}
+
+static inline void
+ocs_device_unlock(ocs_t *ocs)
+{
+	ocs_rlock_release(&ocs->lock);
+}
+
+static inline void
+ocs_device_lock_free(ocs_t *ocs)
+{
+	ocs_rlock_free(&ocs->lock);
+}
+
+extern int32_t ocs_device_detach(ocs_t *ocs);
+
+extern int32_t ocs_device_attach(ocs_t *ocs);
+
+#define ocs_is_initiator_enabled()	(ocs->enable_ini)
+#define ocs_is_target_enabled()	(ocs->enable_tgt)
+
+#include "ocs_xport.h"
+#include "ocs_domain.h"
+#include "ocs_sport.h"
+#include "ocs_node.h"
+#include "ocs_unsol.h"
+#include "ocs_scsi.h"
+#include "ocs_ioctl.h"
+
+static inline ocs_io_t *
+ocs_io_alloc(ocs_t *ocs)
+{
+	return ocs_io_pool_io_alloc(ocs->xport->io_pool);
+}
+
+static inline void
+ocs_io_free(ocs_t *ocs, ocs_io_t *io)
+{
+	ocs_io_pool_io_free(ocs->xport->io_pool, io);
+}
+
+#endif /* __OCS_H__ */
diff --git a/sys/dev/ocs_fc/ocs_cam.c b/sys/dev/ocs_fc/ocs_cam.c
new file mode 100644
index 000000000000..d5e2e7578255
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_cam.c
@@ -0,0 +1,2640 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @defgroup scsi_api_target SCSI Target API
+ * @defgroup scsi_api_initiator SCSI Initiator API
+ * @defgroup cam_api Common Access Method (CAM) API
+ * @defgroup cam_io CAM IO
+ */
+
+/**
+ * @file
+ * Provides CAM functionality.
+ */
+
+#include "ocs.h"
+#include "ocs_scsi.h"
+#include "ocs_device.h"
+
+/* Default IO timeout value for initiators is 30 seconds */
+#define OCS_CAM_IO_TIMEOUT	30
+
+typedef struct {
+	ocs_scsi_sgl_t *sgl;
+	uint32_t sgl_max;
+	uint32_t sgl_count;
+	int32_t rc;
+} ocs_dmamap_load_arg_t;
+
+static void ocs_action(struct cam_sim *, union ccb *);
+static void ocs_poll(struct cam_sim *);
+
+static ocs_tgt_resource_t *ocs_tgt_resource_get(ocs_fcport *,
+					struct ccb_hdr *, uint32_t *);
+static int32_t ocs_tgt_resource_abort(struct ocs_softc *, ocs_tgt_resource_t *);
+static uint32_t ocs_abort_initiator_io(struct ocs_softc *ocs, union ccb *accb);
+static void ocs_abort_inot(struct ocs_softc *ocs, union ccb *ccb);
+static void ocs_abort_atio(struct ocs_softc *ocs, union ccb *ccb);
+static int32_t ocs_target_tmf_cb(ocs_io_t *, ocs_scsi_io_status_e, uint32_t, void *);
+static int32_t ocs_io_abort_cb(ocs_io_t *, ocs_scsi_io_status_e, uint32_t, void *);
+static int32_t ocs_task_set_full_or_busy(ocs_io_t *io);
+static int32_t ocs_initiator_tmf_cb(ocs_io_t *, ocs_scsi_io_status_e,
+		ocs_scsi_cmd_resp_t *, uint32_t, void *);
+static uint32_t
+ocs_fcp_change_role(struct ocs_softc *ocs, ocs_fcport *fcp, uint32_t new_role);
+
+static inline ocs_io_t *ocs_scsi_find_io(struct ocs_softc *ocs, uint32_t tag)
+{
+
+	return ocs_io_get_instance(ocs, tag);
+}
+
+static inline void ocs_target_io_free(ocs_io_t *io)
+{
+	io->tgt_io.state = OCS_CAM_IO_FREE;
+	io->tgt_io.flags = 0;
+	io->tgt_io.app = NULL;
+	ocs_scsi_io_complete(io);
+	if(io->ocs->io_in_use != 0)
+		atomic_subtract_acq_32(&io->ocs->io_in_use, 1);
+}
+
+static int32_t
+ocs_attach_port(ocs_t *ocs, int chan)
+{
+
+	struct cam_sim	*sim = NULL;
+	struct cam_path	*path = NULL;
+	uint32_t	max_io = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS);
+	ocs_fcport *fcp = FCPORT(ocs, chan);
+
+	if (NULL == (sim = cam_sim_alloc(ocs_action, ocs_poll, 
+				device_get_name(ocs->dev), ocs, 
+				device_get_unit(ocs->dev), &ocs->sim_lock,
+				max_io, max_io, ocs->devq))) {
+		device_printf(ocs->dev, "Can't allocate SIM\n");
+		return 1;
+	}
+
+	mtx_lock(&ocs->sim_lock);
+	if (CAM_SUCCESS != xpt_bus_register(sim, ocs->dev, chan)) {
+		device_printf(ocs->dev, "Can't register bus %d\n", 0);
+		mtx_unlock(&ocs->sim_lock);
+		cam_sim_free(sim, FALSE);
+		return 1;
+	}
+	mtx_unlock(&ocs->sim_lock);
+
+	if (CAM_REQ_CMP != xpt_create_path(&path, NULL, cam_sim_path(sim),
+				CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD)) {
+		device_printf(ocs->dev, "Can't create path\n");
+		xpt_bus_deregister(cam_sim_path(sim));
+		mtx_unlock(&ocs->sim_lock);
+		cam_sim_free(sim, FALSE);
+		return 1;
+	}
+
+	fcp->sim  = sim;
+	fcp->path = path;
+
+	return 0;
+
+}
+
+static int32_t
+ocs_detach_port(ocs_t *ocs, int32_t chan)
+{
+	ocs_fcport *fcp = NULL;
+	struct cam_sim	*sim = NULL;
+	struct cam_path	*path = NULL;
+	fcp = FCPORT(ocs, chan);
+
+	sim = fcp->sim;
+	path = fcp->path;
+
+	if (fcp->sim) {
+		mtx_lock(&ocs->sim_lock);
+			ocs_tgt_resource_abort(ocs, &fcp->targ_rsrc_wildcard);
+			if (path) {
+				xpt_async(AC_LOST_DEVICE, path, NULL);
+				xpt_free_path(path);
+				fcp->path = NULL;
+			}
+			xpt_bus_deregister(cam_sim_path(sim));
+
+			cam_sim_free(sim, FALSE);
+			fcp->sim = NULL;
+		mtx_unlock(&ocs->sim_lock);
+	}
+	
+	return 0;
+}
+
+int32_t
+ocs_cam_attach(ocs_t *ocs)
+{
+	struct cam_devq	*devq = NULL;
+	int	i = 0;
+	uint32_t	max_io = ocs_scsi_get_property(ocs, OCS_SCSI_MAX_IOS);
+
+	if (NULL == (devq = cam_simq_alloc(max_io))) {
+		device_printf(ocs->dev, "Can't allocate SIMQ\n");
+		return -1;
+	}
+
+	ocs->devq = devq;
+
+	if (mtx_initialized(&ocs->sim_lock) == 0) {
+		mtx_init(&ocs->sim_lock, "ocs_sim_lock", NULL, MTX_DEF);
+	}
+
+	for (i = 0; i < (ocs->num_vports + 1); i++) {
+		if (ocs_attach_port(ocs, i)) {
+			ocs_log_err(ocs, "Attach port failed for chan: %d\n", i);
+			goto detach_port;
+		}
+	}
+	
+	ocs->io_high_watermark = max_io;
+	ocs->io_in_use = 0;
+	return 0;
+
+detach_port:
+	while (--i >= 0) {
+		ocs_detach_port(ocs, i);
+	}
+
+	cam_simq_free(ocs->devq);
+
+	if (mtx_initialized(&ocs->sim_lock))
+		mtx_destroy(&ocs->sim_lock);
+
+	return 1;	
+}
+
+int32_t
+ocs_cam_detach(ocs_t *ocs)
+{
+	int i = 0;
+
+	for (i = (ocs->num_vports); i >= 0; i--) {
+		ocs_detach_port(ocs, i);
+	}
+
+	cam_simq_free(ocs->devq);
+
+	if (mtx_initialized(&ocs->sim_lock))
+		mtx_destroy(&ocs->sim_lock);
+
+	return 0;
+}
+
+/***************************************************************************
+ * Functions required by SCSI base driver API
+ */
+
+/**
+ * @ingroup scsi_api_target
+ * @brief Attach driver to the BSD SCSI layer (a.k.a CAM)
+ *
+ * Allocates + initializes CAM related resources and attaches to the CAM
+ *
+ * @param ocs the driver instance's software context
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+int32_t
+ocs_scsi_tgt_new_device(ocs_t *ocs)
+{
+	ocs->enable_task_set_full = ocs_scsi_get_property(ocs, 
+					OCS_SCSI_ENABLE_TASK_SET_FULL);
+	ocs_log_debug(ocs, "task set full processing is %s\n",
+		ocs->enable_task_set_full ? "enabled" : "disabled");
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief Tears down target members of ocs structure.
+ *
+ * Called by OS code when device is removed.
+ *
+ * @param ocs pointer to ocs
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_tgt_del_device(ocs_t *ocs)
+{
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief accept new domain notification
+ *
+ * Called by base drive when new domain is discovered.  A target-server
+ * will use this call to prepare for new remote node notifications
+ * arising from ocs_scsi_new_initiator().
+ *
+ * The domain context has an element <b>ocs_scsi_tgt_domain_t tgt_domain</b> 
+ * which is declared by the target-server code and is used for target-server 
+ * private data.
+ *
+ * This function will only be called if the base-driver has been enabled for 
+ * target capability.
+ *
+ * Note that this call is made to target-server backends, 
+ * the ocs_scsi_ini_new_domain() function is called to initiator-client backends.
+ *
+ * @param domain pointer to domain
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_tgt_new_domain(ocs_domain_t *domain)
+{
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief accept domain lost notification
+ *
+ * Called by base-driver when a domain goes away.  A target-server will
+ * use this call to clean up all domain scoped resources.
+ *
+ * Note that this call is made to target-server backends,
+ * the ocs_scsi_ini_del_domain() function is called to initiator-client backends.
+ *
+ * @param domain pointer to domain
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+void
+ocs_scsi_tgt_del_domain(ocs_domain_t *domain)
+{
+}
+
+
+/**
+ * @ingroup scsi_api_target
+ * @brief accept new sli port (sport) notification
+ *
+ * Called by base drive when new sport is discovered.  A target-server
+ * will use this call to prepare for new remote node notifications
+ * arising from ocs_scsi_new_initiator().
+ *
+ * The domain context has an element <b>ocs_scsi_tgt_sport_t tgt_sport</b> 
+ * which is declared by the target-server code and is used for
+ * target-server private data.
+ *
+ * This function will only be called if the base-driver has been enabled for 
+ * target capability.
+ *
+ * Note that this call is made to target-server backends,
+ * the ocs_scsi_tgt_new_domain() is called to initiator-client backends.
+ *
+ * @param sport pointer to SLI port
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_tgt_new_sport(ocs_sport_t *sport)
+{
+	ocs_t *ocs = sport->ocs;
+
+	if(!sport->is_vport) {
+		sport->tgt_data = FCPORT(ocs, 0);
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief accept SLI port gone notification
+ *
+ * Called by base-driver when a sport goes away.  A target-server will
+ * use this call to clean up all sport scoped resources.
+ *
+ * Note that this call is made to target-server backends,
+ * the ocs_scsi_ini_del_sport() is called to initiator-client backends.
+ *
+ * @param sport pointer to SLI port
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+void
+ocs_scsi_tgt_del_sport(ocs_sport_t *sport)
+{
+	return;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief receive notification of a new SCSI initiator node
+ *
+ * Sent by base driver to notify a target-server of the presense of a new
+ * remote initiator.   The target-server may use this call to prepare for
+ * inbound IO from this node.
+ *
+ * The ocs_node_t structure has and elment of type ocs_scsi_tgt_node_t named
+ * tgt_node that is declared and used by a target-server for private
+ * information.
+ *
+ * This function is only called if the target capability is enabled in driver.
+ *
+ * @param node pointer to new remote initiator node
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ *
+ * @note
+ */
+int32_t
+ocs_scsi_new_initiator(ocs_node_t *node)
+{
+	ocs_t	*ocs = node->ocs;
+	struct ac_contract ac;
+	struct ac_device_changed *adc;
+
+	ocs_fcport	*fcp = NULL;
+
+	fcp = node->sport->tgt_data;
+	if (fcp == NULL) {
+		ocs_log_err(ocs, "FCP is NULL \n");
+		return 1;
+	}	
+
+	/*
+	 * Update the IO watermark by decrementing it by the
+	 * number of IOs reserved for each initiator.
+	 */
+	atomic_subtract_acq_32(&ocs->io_high_watermark, OCS_RSVD_INI_IO);
+
+	ac.contract_number = AC_CONTRACT_DEV_CHG;
+	adc = (struct ac_device_changed *) ac.contract_data;
+	adc->wwpn = ocs_node_get_wwpn(node);
+	adc->port = node->rnode.fc_id;
+	adc->target = node->instance_index;
+	adc->arrived = 1;
+	xpt_async(AC_CONTRACT, fcp->path, &ac);
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief validate new initiator
+ *
+ * Sent by base driver to validate a remote initiatiator.   The target-server
+ * returns TRUE if this initiator should be accepted.
+ *
+ * This function is only called if the target capability is enabled in driver.
+ *
+ * @param node pointer to remote initiator node to validate
+ *
+ * @return TRUE if initiator should be accepted, FALSE if it should be rejected
+ *
+ * @note
+ */
+
+int32_t
+ocs_scsi_validate_initiator(ocs_node_t *node)
+{
+	return 1;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief Delete a SCSI initiator node
+ *
+ * Sent by base driver to notify a target-server that a remote initiator
+ * is now gone. The base driver will have terminated all outstanding IOs 
+ * and the target-server will receive appropriate completions.
+ *
+ * This function is only called if the base driver is enabled for
+ * target capability.
+ *
+ * @param node pointer node being deleted
+ * @param reason Reason why initiator is gone.
+ *
+ * @return OCS_SCSI_CALL_COMPLETE to indicate that all work was completed
+ *
+ * @note
+ */
+int32_t
+ocs_scsi_del_initiator(ocs_node_t *node, ocs_scsi_del_initiator_reason_e reason)
+{
+	ocs_t	*ocs = node->ocs;
+
+	struct ac_contract ac;
+	struct ac_device_changed *adc;
+	ocs_fcport	*fcp = NULL;
+
+	fcp = node->sport->tgt_data;
+	if (fcp == NULL) {
+		ocs_log_err(ocs, "FCP is NULL \n");
+		return 1;
+	}
+
+	ac.contract_number = AC_CONTRACT_DEV_CHG;
+	adc = (struct ac_device_changed *) ac.contract_data;
+	adc->wwpn = ocs_node_get_wwpn(node);
+	adc->port = node->rnode.fc_id;
+	adc->target = node->instance_index;
+	adc->arrived = 0;
+	xpt_async(AC_CONTRACT, fcp->path, &ac);
+
+
+	if (reason == OCS_SCSI_INITIATOR_MISSING) {
+		return OCS_SCSI_CALL_COMPLETE;
+	}
+
+	/*
+	 * Update the IO watermark by incrementing it by the
+	 * number of IOs reserved for each initiator.
+	 */
+	atomic_add_acq_32(&ocs->io_high_watermark, OCS_RSVD_INI_IO);
+
+	return OCS_SCSI_CALL_COMPLETE;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief receive FCP SCSI Command
+ *
+ * Called by the base driver when a new SCSI command has been received.   The
+ * target-server will process the command, and issue data and/or response phase
+ * requests to the base driver.
+ *
+ * The IO context (ocs_io_t) structure has and element of type 
+ * ocs_scsi_tgt_io_t named tgt_io that is declared and used by 
+ * a target-server for private information.
+ *
+ * @param io pointer to IO context
+ * @param lun LUN for this IO
+ * @param cdb pointer to SCSI CDB
+ * @param cdb_len length of CDB in bytes
+ * @param flags command flags
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t ocs_scsi_recv_cmd(ocs_io_t *io, uint64_t lun, uint8_t *cdb,
+				uint32_t cdb_len, uint32_t flags)
+{
+	ocs_t *ocs = io->ocs;
+	struct ccb_accept_tio *atio = NULL;
+	ocs_node_t	*node = io->node;
+	ocs_tgt_resource_t *trsrc = NULL;
+	int32_t		rc = -1;
+	ocs_fcport	*fcp = NULL;
+
+	fcp = node->sport->tgt_data;
+	if (fcp == NULL) {
+		ocs_log_err(ocs, "FCP is NULL \n");
+		return 1;
+	}
+
+	atomic_add_acq_32(&ocs->io_in_use, 1);
+
+	/* set target io timeout */
+	io->timeout = ocs->target_io_timer_sec;
+
+	if (ocs->enable_task_set_full && 
+		(ocs->io_in_use >= ocs->io_high_watermark)) {
+		return ocs_task_set_full_or_busy(io);
+	} else {
+		atomic_store_rel_32(&io->node->tgt_node.busy_sent, FALSE);
+	}
+
+	if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) {
+		trsrc = &fcp->targ_rsrc[lun];
+	} else if (fcp->targ_rsrc_wildcard.enabled) {
+		trsrc = &fcp->targ_rsrc_wildcard;
+	}
+
+	if (trsrc) {
+		atio = (struct ccb_accept_tio *)STAILQ_FIRST(&trsrc->atio);
+	}
+
+	if (atio) {
+
+		STAILQ_REMOVE_HEAD(&trsrc->atio, sim_links.stqe);
+
+		atio->ccb_h.status = CAM_CDB_RECVD;
+		atio->ccb_h.target_lun = lun;
+		atio->sense_len = 0;
+
+		atio->init_id = node->instance_index;
+		atio->tag_id = io->tag;
+		atio->ccb_h.ccb_io_ptr = io;
+
+		if (flags & OCS_SCSI_CMD_SIMPLE)
+			atio->tag_action = MSG_SIMPLE_Q_TAG;
+		else if (flags &  FCP_TASK_ATTR_HEAD_OF_QUEUE)
+			atio->tag_action = MSG_HEAD_OF_Q_TAG;
+		else if (flags & FCP_TASK_ATTR_ORDERED)
+			atio->tag_action = MSG_ORDERED_Q_TAG;
+		else
+			atio->tag_action = 0;
+
+		atio->cdb_len = cdb_len;
+		ocs_memcpy(atio->cdb_io.cdb_bytes, cdb, cdb_len);
+
+		io->tgt_io.flags = 0;
+		io->tgt_io.state = OCS_CAM_IO_COMMAND;
+		io->tgt_io.lun = lun;
+
+		xpt_done((union ccb *)atio);
+
+		rc = 0;
+	} else {
+		device_printf(
+			ocs->dev, "%s: no ATIO for LUN %lx (en=%s) OX_ID %#x\n",
+			__func__, (unsigned long)lun,
+			trsrc ? (trsrc->enabled ? "T" : "F") : "X",
+			be16toh(io->init_task_tag));
+
+		io->tgt_io.state = OCS_CAM_IO_MAX;
+		ocs_target_io_free(io);
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief receive FCP SCSI Command with first burst data.
+ *
+ * Receive a new FCP SCSI command from the base driver with first burst data.
+ *
+ * @param io pointer to IO context
+ * @param lun LUN for this IO
+ * @param cdb pointer to SCSI CDB
+ * @param cdb_len length of CDB in bytes
+ * @param flags command flags
+ * @param first_burst_buffers first burst buffers
+ * @param first_burst_buffer_count The number of bytes received in the first burst
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t ocs_scsi_recv_cmd_first_burst(ocs_io_t *io, uint64_t lun, uint8_t *cdb,
+		 			uint32_t cdb_len, uint32_t flags, 
+					ocs_dma_t first_burst_buffers[], 
+					uint32_t first_burst_buffer_count)
+{
+	return -1;
+}
+
+/**
+ * @ingroup scsi_api_target
+ * @brief receive a TMF command IO
+ *
+ * Called by the base driver when a SCSI TMF command has been received.   The
+ * target-server will process the command, aborting commands as needed, and post
+ * a response using ocs_scsi_send_resp()
+ *
+ * The IO context (ocs_io_t) structure has and element of type ocs_scsi_tgt_io_t named
+ * tgt_io that is declared and used by a target-server for private information.
+ *
+ * If the target-server walks the nodes active_ios linked list, and starts IO
+ * abort processing, the code <b>must</b> be sure not to abort the IO passed into the
+ * ocs_scsi_recv_tmf() command.
+ *
+ * @param tmfio pointer to IO context
+ * @param lun logical unit value
+ * @param cmd command request
+ * @param abortio pointer to IO object to abort for TASK_ABORT (NULL for all other TMF)
+ * @param flags flags
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t ocs_scsi_recv_tmf(ocs_io_t *tmfio, uint64_t lun, ocs_scsi_tmf_cmd_e cmd,
+				ocs_io_t *abortio, uint32_t flags)
+{
+	ocs_t *ocs = tmfio->ocs;
+	ocs_node_t *node = tmfio->node;
+	ocs_tgt_resource_t *trsrc = NULL;
+	struct ccb_immediate_notify *inot = NULL;
+	int32_t		rc = -1;
+	ocs_fcport	*fcp = NULL;
+
+	fcp = node->sport->tgt_data;
+	if (fcp == NULL) {
+		ocs_log_err(ocs, "FCP is NULL \n");
+		return 1;
+	}
+
+	if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) {
+		trsrc = &fcp->targ_rsrc[lun];
+	} else if (fcp->targ_rsrc_wildcard.enabled) {
+		trsrc = &fcp->targ_rsrc_wildcard;
+	}
+
+	device_printf(tmfio->ocs->dev, "%s: io=%p cmd=%#x LU=%lx en=%s\n",
+			__func__, tmfio, cmd, (unsigned long)lun,
+			trsrc ? (trsrc->enabled ? "T" : "F") : "X");
+	if (trsrc) {
+		inot = (struct ccb_immediate_notify *)STAILQ_FIRST(&trsrc->inot);
+	}
+
+        if (!inot) {
+		device_printf(
+			ocs->dev, "%s: no INOT for LUN %llx (en=%s) OX_ID %#x\n",
+			__func__, (unsigned long long)lun, trsrc ? (trsrc->enabled ? "T" : "F") : "X",
+			be16toh(tmfio->init_task_tag));
+
+		if (abortio) {
+			ocs_scsi_io_complete(abortio);
+		}
+		ocs_scsi_io_complete(tmfio);
+		goto ocs_scsi_recv_tmf_out;
+	}
+
+
+	tmfio->tgt_io.app = abortio;
+
+	STAILQ_REMOVE_HEAD(&trsrc->inot, sim_links.stqe);
+
+	inot->tag_id = tmfio->tag;
+	inot->seq_id = tmfio->tag;
+
+	if ((lun < OCS_MAX_LUN) && fcp->targ_rsrc[lun].enabled) {
+		inot->initiator_id = node->instance_index;
+	} else {
+		inot->initiator_id = CAM_TARGET_WILDCARD;
+	} 
+
+	inot->ccb_h.status = CAM_MESSAGE_RECV;
+	inot->ccb_h.target_lun = lun;
+
+	switch (cmd) {
+	case OCS_SCSI_TMF_ABORT_TASK:
+		inot->arg = MSG_ABORT_TASK;
+		inot->seq_id = abortio->tag;
+		device_printf(ocs->dev, "%s: ABTS IO.%#x st=%#x\n", 
+			__func__, abortio->tag,	abortio->tgt_io.state);
+		abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_RECV;
+		abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_NOTIFY;
+		break;
+	case OCS_SCSI_TMF_QUERY_TASK_SET:
+		device_printf(ocs->dev, 
+			"%s: OCS_SCSI_TMF_QUERY_TASK_SET not supported\n",
+				__func__);
+		STAILQ_INSERT_TAIL(&trsrc->inot, &inot->ccb_h, sim_links.stqe);
+		ocs_scsi_io_complete(tmfio);
+		goto ocs_scsi_recv_tmf_out;
+		break;
+	case OCS_SCSI_TMF_ABORT_TASK_SET:
+		inot->arg = MSG_ABORT_TASK_SET;
+		break;
+	case OCS_SCSI_TMF_CLEAR_TASK_SET:
+		inot->arg = MSG_CLEAR_TASK_SET;
+		break;
+	case OCS_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT:
+		inot->arg = MSG_QUERY_ASYNC_EVENT;
+		break;
+	case OCS_SCSI_TMF_LOGICAL_UNIT_RESET:
+		inot->arg = MSG_LOGICAL_UNIT_RESET;
+		break;
+	case OCS_SCSI_TMF_CLEAR_ACA:
+		inot->arg = MSG_CLEAR_ACA;
+		break;
+	case OCS_SCSI_TMF_TARGET_RESET:
+		inot->arg = MSG_TARGET_RESET;
+		break;
+	default:
+		device_printf(ocs->dev, "%s: unsupported TMF %#x\n",
+							 __func__, cmd);
+		STAILQ_INSERT_TAIL(&trsrc->inot, &inot->ccb_h, sim_links.stqe);
+		goto ocs_scsi_recv_tmf_out;
+	}
+
+	rc = 0;
+
+	xpt_print(inot->ccb_h.path, "%s: func=%#x stat=%#x id=%#x lun=%#x"
+			" flags=%#x tag=%#x seq=%#x ini=%#x arg=%#x\n", 
+			__func__, inot->ccb_h.func_code, inot->ccb_h.status,
+			inot->ccb_h.target_id, 
+			(unsigned int)inot->ccb_h.target_lun, inot->ccb_h.flags,
+			inot->tag_id, inot->seq_id, inot->initiator_id,
+			inot->arg);
+	xpt_done((union ccb *)inot);
+
+	if (abortio) {
+		abortio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_DEV;
+		rc = ocs_scsi_tgt_abort_io(abortio, ocs_io_abort_cb, tmfio);
+	}
+	
+ocs_scsi_recv_tmf_out:
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief Initializes any initiator fields on the ocs structure.
+ *
+ * Called by OS initialization code when a new device is discovered.
+ *
+ * @param ocs pointer to ocs
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_ini_new_device(ocs_t *ocs)
+{
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief Tears down initiator members of ocs structure.
+ *
+ * Called by OS code when device is removed.
+ *
+ * @param ocs pointer to ocs
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_scsi_ini_del_device(ocs_t *ocs)
+{
+
+	return 0;
+}
+
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief accept new domain notification
+ *
+ * Called by base drive when new domain is discovered.  An initiator-client
+ * will accept this call to prepare for new remote node notifications
+ * arising from ocs_scsi_new_target().
+ *
+ * The domain context has the element <b>ocs_scsi_ini_domain_t ini_domain</b>
+ * which is declared by the initiator-client code and is used for 
+ * initiator-client private data.
+ *
+ * This function will only be called if the base-driver has been enabled for 
+ * initiator capability.
+ *
+ * Note that this call is made to initiator-client backends, 
+ * the ocs_scsi_tgt_new_domain() function is called to target-server backends.
+ *
+ * @param domain pointer to domain
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_ini_new_domain(ocs_domain_t *domain)
+{
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief accept domain lost notification
+ *
+ * Called by base-driver when a domain goes away.  An initiator-client will
+ * use this call to clean up all domain scoped resources.
+ *
+ * This function will only be called if the base-driver has been enabled for
+ * initiator capability.
+ *
+ * Note that this call is made to initiator-client backends,
+ * the ocs_scsi_tgt_del_domain() function is called to target-server backends.
+ *
+ * @param domain pointer to domain
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+void
+ocs_scsi_ini_del_domain(ocs_domain_t *domain)
+{
+}
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief accept new sli port notification
+ *
+ * Called by base drive when new sli port (sport) is discovered.
+ * A target-server will use this call to prepare for new remote node
+ * notifications arising from ocs_scsi_new_initiator().
+ *
+ * This function will only be called if the base-driver has been enabled for
+ * target capability.
+ *
+ * Note that this call is made to target-server backends,
+ * the ocs_scsi_ini_new_sport() function is called to initiator-client backends.
+ *
+ * @param sport pointer to sport
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_ini_new_sport(ocs_sport_t *sport)
+{
+	ocs_t *ocs = sport->ocs;
+
+	if(!sport->is_vport) {
+		sport->tgt_data = FCPORT(ocs, 0);
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief accept sli port gone notification
+ *
+ * Called by base-driver when a sport goes away.  A target-server will
+ * use this call to clean up all sport scoped resources.
+ *
+ * Note that this call is made to target-server backends,
+ * the ocs_scsi_ini_del_sport() function is called to initiator-client backends.
+ *
+ * @param sport pointer to SLI port
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+void
+ocs_scsi_ini_del_sport(ocs_sport_t *sport)
+{
+}
+
+void 
+ocs_scsi_sport_deleted(ocs_sport_t *sport)
+{
+	ocs_t *ocs = sport->ocs;
+	ocs_fcport *fcp = NULL;
+
+	ocs_xport_stats_t value;
+
+	if (!sport->is_vport) {
+		return;
+	}
+
+	fcp = sport->tgt_data;
+
+	ocs_xport_status(ocs->xport, OCS_XPORT_PORT_STATUS, &value);
+
+	if (value.value == 0) {
+		ocs_log_debug(ocs, "PORT offline,.. skipping\n");
+		return;
+	}	
+
+	if ((fcp->role != KNOB_ROLE_NONE)) {
+		if(fcp->vport->sport != NULL) {
+			ocs_log_debug(ocs,"sport is not NULL, skipping\n");
+			return;
+		}
+
+		ocs_sport_vport_alloc(ocs->domain, fcp->vport);
+		return;
+	}
+
+}
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief receive notification of a new SCSI target node
+ *
+ * Sent by base driver to notify an initiator-client of the presense of a new
+ * remote target.   The initiator-server may use this call to prepare for
+ * inbound IO from this node.
+ *
+ * This function is only called if the base driver is enabled for
+ * initiator capability.
+ *
+ * @param node pointer to new remote initiator node
+ *
+ * @return none
+ *
+ * @note
+ */
+int32_t
+ocs_scsi_new_target(ocs_node_t *node)
+{
+	struct ocs_softc *ocs = node->ocs;
+	union ccb *ccb = NULL;
+	ocs_fcport	*fcp = NULL;
+
+	fcp = node->sport->tgt_data;
+	if (fcp == NULL) {
+		printf("%s:FCP is NULL \n", __func__);
+		return 0;
+	}
+
+	if (NULL == (ccb = xpt_alloc_ccb_nowait())) {
+		device_printf(ocs->dev, "%s: ccb allocation failed\n", __func__);
+		return -1;
+	}
+	
+	if (CAM_REQ_CMP != xpt_create_path(&ccb->ccb_h.path, xpt_periph,
+				cam_sim_path(fcp->sim),
+				node->instance_index, CAM_LUN_WILDCARD)) {
+		device_printf(
+			ocs->dev, "%s: target path creation failed\n", __func__);
+		xpt_free_ccb(ccb);
+		return -1;
+	}
+
+	xpt_rescan(ccb);
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_initiator
+ * @brief Delete a SCSI target node
+ *
+ * Sent by base driver to notify a initiator-client that a remote target 
+ * is now gone. The base driver will have terminated all  outstanding IOs 
+ * and the initiator-client will receive appropriate completions.
+ *
+ * The ocs_node_t structure has and elment of type ocs_scsi_ini_node_t named
+ * ini_node that is declared and used by a target-server for private
+ * information.
+ *
+ * This function is only called if the base driver is enabled for
+ * initiator capability.
+ *
+ * @param node pointer node being deleted
+ * @param reason reason for deleting the target
+ *
+ * @return Returns OCS_SCSI_CALL_ASYNC if target delete is queued for async 
+ * completion and OCS_SCSI_CALL_COMPLETE if call completed or error.
+ *
+ * @note
+ */
+int32_t
+ocs_scsi_del_target(ocs_node_t *node, ocs_scsi_del_target_reason_e reason)
+{
+	struct ocs_softc *ocs = node->ocs;
+	struct cam_path *cpath = NULL;
+	ocs_fcport	*fcp = NULL;
+
+	fcp = node->sport->tgt_data;
+	if (fcp == NULL) {
+		ocs_log_err(ocs,"FCP is NULL \n");
+		return 0;
+	}
+
+	if (!fcp->sim) { 
+		device_printf(ocs->dev, "%s: calling with NULL sim\n", __func__); 
+		return OCS_SCSI_CALL_COMPLETE; 
+	}
+	
+	if (CAM_REQ_CMP == xpt_create_path(&cpath, NULL, cam_sim_path(fcp->sim),
+				node->instance_index, CAM_LUN_WILDCARD)) {
+		xpt_async(AC_LOST_DEVICE, cpath, NULL);
+		
+		xpt_free_path(cpath);
+	}
+	return OCS_SCSI_CALL_COMPLETE;
+}
+
+/**
+ * @brief Initialize SCSI IO
+ *
+ * Initialize SCSI IO, this function is called once per IO during IO pool
+ * allocation so that the target server may initialize any of its own private
+ * data.
+ *
+ * @param io pointer to SCSI IO object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_tgt_io_init(ocs_io_t *io)
+{
+	return 0;
+}
+
+/**
+ * @brief Uninitialize SCSI IO
+ *
+ * Uninitialize target server private data in a SCSI io object
+ *
+ * @param io pointer to SCSI IO object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_tgt_io_exit(ocs_io_t *io)
+{
+	return 0;
+}
+
+/**
+ * @brief Initialize SCSI IO
+ *
+ * Initialize SCSI IO, this function is called once per IO during IO pool
+ * allocation so that the initiator client may initialize any of its own private
+ * data.
+ *
+ * @param io pointer to SCSI IO object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_ini_io_init(ocs_io_t *io)
+{
+	return 0;
+}
+
+/**
+ * @brief Uninitialize SCSI IO
+ *
+ * Uninitialize initiator client private data in a SCSI io object
+ *
+ * @param io pointer to SCSI IO object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_scsi_ini_io_exit(ocs_io_t *io)
+{
+	return 0;
+}
+/*
+ * End of functions required by SCSI base driver API
+ ***************************************************************************/
+
+static __inline void
+ocs_set_ccb_status(union ccb *ccb, cam_status status)
+{
+	ccb->ccb_h.status &= ~CAM_STATUS_MASK;
+	ccb->ccb_h.status |= status;
+}
+
+static int32_t
+ocs_task_set_full_or_busy_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status,
+						uint32_t flags, void *arg)
+{
+
+	ocs_target_io_free(io);
+
+	return 0;
+}
+
+/**
+ * @brief send SCSI task set full or busy status
+ *
+ * A SCSI task set full or busy response is sent depending on whether
+ * another IO is already active on the LUN.
+ *
+ * @param io pointer to IO context
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+static int32_t
+ocs_task_set_full_or_busy(ocs_io_t *io)
+{
+	ocs_scsi_cmd_resp_t rsp = { 0 };
+	ocs_t *ocs = io->ocs;
+
+	/*
+	 * If there is another command for the LUN, then send task set full,
+	 * if this is the first one, then send the busy status.
+	 *
+	 * if 'busy sent' is FALSE, set it to TRUE and send BUSY
+	 * otherwise send FULL
+	 */
+	if (atomic_cmpset_acq_32(&io->node->tgt_node.busy_sent, FALSE, TRUE)) {
+		rsp.scsi_status = SCSI_STATUS_BUSY; /* Busy */
+		printf("%s: busy [%s] tag=%x iiu=%d ihw=%d\n", __func__,
+				io->node->display_name, io->tag,
+				io->ocs->io_in_use, io->ocs->io_high_watermark);
+	} else {
+		rsp.scsi_status = SCSI_STATUS_TASK_SET_FULL; /* Task set full */
+		printf("%s: full tag=%x iiu=%d\n", __func__, io->tag,
+			io->ocs->io_in_use);
+	}
+
+	/* Log a message here indicating a busy or task set full state */
+	if (OCS_LOG_ENABLE_Q_FULL_BUSY_MSG(ocs)) {
+		/* Log Task Set Full */
+		if (rsp.scsi_status == SCSI_STATUS_TASK_SET_FULL) {
+			/* Task Set Full Message */
+			ocs_log_info(ocs, "OCS CAM TASK SET FULL. Tasks >= %d\n",
+			 		ocs->io_high_watermark);
+		}
+		else if (rsp.scsi_status == SCSI_STATUS_BUSY) {
+			/* Log Busy Message */
+			ocs_log_info(ocs, "OCS CAM SCSI BUSY\n");
+		}
+	}
+
+	/* Send the response */
+	return 
+	ocs_scsi_send_resp(io, 0, &rsp, ocs_task_set_full_or_busy_cb, NULL);
+}
+
+/**
+ * @ingroup cam_io
+ * @brief Process target IO completions
+ *
+ * @param io 
+ * @param scsi_status did the IO complete successfully
+ * @param flags 
+ * @param arg application specific pointer provided in the call to ocs_target_io()
+ *
+ * @todo
+ */
+static int32_t ocs_scsi_target_io_cb(ocs_io_t *io, 
+				ocs_scsi_io_status_e scsi_status,
+				uint32_t flags, void *arg)
+{
+	union ccb *ccb = arg;
+	struct ccb_scsiio *csio = &ccb->csio;
+	struct ocs_softc *ocs = csio->ccb_h.ccb_ocs_ptr;
+	uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK;
+	uint32_t io_is_done = 
+		(ccb->ccb_h.flags & CAM_SEND_STATUS) == CAM_SEND_STATUS;
+
+	ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
+
+	if (CAM_DIR_NONE != cam_dir) {
+		bus_dmasync_op_t op;
+
+		if (CAM_DIR_IN == cam_dir) {
+			op = BUS_DMASYNC_POSTREAD;
+		} else {
+			op = BUS_DMASYNC_POSTWRITE;
+		}
+		/* Synchronize the DMA memory with the CPU and free the mapping */
+		bus_dmamap_sync(ocs->buf_dmat, io->tgt_io.dmap, op);
+		if (io->tgt_io.flags & OCS_CAM_IO_F_DMAPPED) {
+			bus_dmamap_unload(ocs->buf_dmat, io->tgt_io.dmap);
+		}
+	}
+
+	if (io->tgt_io.sendresp) {
+		io->tgt_io.sendresp = 0;
+		ocs_scsi_cmd_resp_t  resp = { 0 };
+		io->tgt_io.state = OCS_CAM_IO_RESP;
+		resp.scsi_status = scsi_status;
+		if (ccb->ccb_h.flags & CAM_SEND_SENSE) {
+			resp.sense_data = (uint8_t *)&csio->sense_data;
+			resp.sense_data_length = csio->sense_len;
+		}
+		resp.residual = io->exp_xfer_len - io->transferred;
+
+		return ocs_scsi_send_resp(io, 0, &resp, ocs_scsi_target_io_cb, ccb);
+	}
+
+	switch (scsi_status) {
+	case OCS_SCSI_STATUS_GOOD:
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		break;
+	case OCS_SCSI_STATUS_ABORTED:
+		ocs_set_ccb_status(ccb, CAM_REQ_ABORTED);
+		break;
+	default:
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+	}
+
+	if (io_is_done) {
+		if ((io->tgt_io.flags & OCS_CAM_IO_F_ABORT_NOTIFY) == 0) {
+			ocs_target_io_free(io);
+		}
+	} else {
+		io->tgt_io.state = OCS_CAM_IO_DATA_DONE;
+		/*device_printf(ocs->dev, "%s: CTIO state=%d tag=%#x\n",
+				__func__, io->tgt_io.state, io->tag);*/
+	}
+
+	xpt_done(ccb);
+
+	return 0;
+}
+
+/**
+ * @note	1. Since the CCB is assigned to the ocs_io_t on an XPT_CONT_TARGET_IO
+ * 		   action, if an initiator aborts a command prior to the SIM receiving
+ * 		   a CTIO, the IO's CCB will be NULL.
+ */
+static int32_t
+ocs_io_abort_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
+{
+	struct ocs_softc *ocs = NULL;
+	ocs_io_t	*tmfio = arg;
+	ocs_scsi_tmf_resp_e tmf_resp = OCS_SCSI_TMF_FUNCTION_COMPLETE;
+	int32_t	rc = 0;
+
+	ocs = io->ocs;
+
+	io->tgt_io.flags &= ~OCS_CAM_IO_F_ABORT_DEV;
+
+	/* A good status indicates the IO was aborted and will be completed in
+	 * the IO's completion handler. Handle the other cases here. */
+	switch (scsi_status) {
+	case OCS_SCSI_STATUS_GOOD:
+		break;
+	case OCS_SCSI_STATUS_NO_IO:
+		break;
+	default:
+		device_printf(ocs->dev, "%s: unhandled status %d\n",
+				__func__, scsi_status);
+		tmf_resp = OCS_SCSI_TMF_FUNCTION_REJECTED;
+		rc = -1;
+	}
+
+	ocs_scsi_send_tmf_resp(tmfio, tmf_resp, NULL, ocs_target_tmf_cb, NULL);
+
+	return rc;
+}
+
+/**
+ * @ingroup cam_io
+ * @brief Process initiator IO completions
+ *
+ * @param io 
+ * @param scsi_status did the IO complete successfully
+ * @param rsp pointer to response buffer
+ * @param flags 
+ * @param arg application specific pointer provided in the call to ocs_target_io()
+ *
+ * @todo
+ */
+static int32_t ocs_scsi_initiator_io_cb(ocs_io_t *io,
+					ocs_scsi_io_status_e scsi_status,
+					ocs_scsi_cmd_resp_t *rsp,
+					uint32_t flags, void *arg)
+{
+	union ccb *ccb = arg;
+	struct ccb_scsiio *csio = &ccb->csio;
+	struct ocs_softc *ocs = csio->ccb_h.ccb_ocs_ptr;
+	uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK;
+	cam_status ccb_status= CAM_REQ_CMP_ERR;
+
+	if (CAM_DIR_NONE != cam_dir) {
+		bus_dmasync_op_t op;
+
+		if (CAM_DIR_IN == cam_dir) {
+			op = BUS_DMASYNC_POSTREAD;
+		} else {
+			op = BUS_DMASYNC_POSTWRITE;
+		}
+		/* Synchronize the DMA memory with the CPU and free the mapping */
+		bus_dmamap_sync(ocs->buf_dmat, io->tgt_io.dmap, op);
+		if (io->tgt_io.flags & OCS_CAM_IO_F_DMAPPED) {
+			bus_dmamap_unload(ocs->buf_dmat, io->tgt_io.dmap);
+		}
+	}
+
+	if (scsi_status == OCS_SCSI_STATUS_CHECK_RESPONSE) {
+		csio->scsi_status = rsp->scsi_status;
+		if (SCSI_STATUS_OK != rsp->scsi_status) {
+			ccb_status = CAM_SCSI_STATUS_ERROR;
+		}
+
+		csio->resid = rsp->residual;
+		if (rsp->residual > 0) {
+			uint32_t length = rsp->response_wire_length;
+			/* underflow */
+			if (csio->dxfer_len == (length + csio->resid)) {
+				ccb_status = CAM_REQ_CMP;
+			}
+		} else if (rsp->residual < 0) {
+			ccb_status = CAM_DATA_RUN_ERR;
+		}
+
+		if ((rsp->sense_data_length) &&
+			!(ccb->ccb_h.flags & (CAM_SENSE_PHYS | CAM_SENSE_PTR))) {
+			uint32_t	sense_len = 0;
+
+			ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
+			if (rsp->sense_data_length < csio->sense_len) {
+				csio->sense_resid = 
+					csio->sense_len - rsp->sense_data_length;
+				sense_len = rsp->sense_data_length;
+			} else {
+				csio->sense_resid = 0;
+				sense_len = csio->sense_len;
+			}
+			ocs_memcpy(&csio->sense_data, rsp->sense_data, sense_len);
+		}
+	} else if (scsi_status != OCS_SCSI_STATUS_GOOD) {
+		ccb_status = CAM_REQ_CMP_ERR;
+	} else {
+		ccb_status = CAM_REQ_CMP;
+	}
+
+	ocs_set_ccb_status(ccb, ccb_status);
+
+	ocs_scsi_io_free(io);
+
+	csio->ccb_h.ccb_io_ptr = NULL;
+	csio->ccb_h.ccb_ocs_ptr = NULL;
+	ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
+
+	xpt_done(ccb);
+
+	return 0;
+}
+
+/**
+ * @brief Load scatter-gather list entries into an IO
+ *
+ * This routine relies on the driver instance's software context pointer and
+ * the IO object pointer having been already assigned to hooks in the CCB.
+ * Although the routine does not return success/fail, callers can look at the
+ * n_sge member to determine if the mapping failed (0 on failure).
+ *
+ * @param arg pointer to the CAM ccb for this IO
+ * @param seg DMA address/length pairs
+ * @param nseg number of DMA address/length pairs
+ * @param error any errors while mapping the IO
+ */
+static void
+ocs_scsi_dmamap_load(void *arg, bus_dma_segment_t *seg, int nseg, int error)
+{
+	ocs_dmamap_load_arg_t *sglarg = (ocs_dmamap_load_arg_t*) arg;
+
+	if (error) {
+		printf("%s: seg=%p nseg=%d error=%d\n",
+				__func__, seg, nseg, error);
+		sglarg->rc = -1;
+	} else {
+		uint32_t i = 0;
+		uint32_t c = 0;
+
+		if ((sglarg->sgl_count + nseg) > sglarg->sgl_max) {
+			printf("%s: sgl_count=%d nseg=%d max=%d\n", __func__,
+				sglarg->sgl_count, nseg, sglarg->sgl_max);
+			sglarg->rc = -2;
+			return;
+		}
+
+		for (i = 0, c = sglarg->sgl_count; i < nseg; i++, c++) {
+			sglarg->sgl[c].addr = seg[i].ds_addr;
+			sglarg->sgl[c].len  = seg[i].ds_len;
+		}
+
+		sglarg->sgl_count = c;
+
+		sglarg->rc = 0;
+	}
+}
+
+/**
+ * @brief Build a scatter-gather list from a CAM CCB
+ *
+ * @param ocs the driver instance's software context
+ * @param ccb pointer to the CCB
+ * @param io pointer to the previously allocated IO object
+ * @param sgl pointer to SGL
+ * @param sgl_max number of entries in sgl
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_build_scsi_sgl(struct ocs_softc *ocs, union ccb *ccb, ocs_io_t *io,
+		ocs_scsi_sgl_t *sgl, uint32_t sgl_max)
+{
+	ocs_dmamap_load_arg_t dmaarg;
+	int32_t	err = 0;
+
+	if (!ocs || !ccb || !io || !sgl) {
+		printf("%s: bad param o=%p c=%p i=%p s=%p\n", __func__,
+				ocs, ccb, io, sgl);
+		return -1;
+	}
+
+	io->tgt_io.flags &= ~OCS_CAM_IO_F_DMAPPED;
+
+	dmaarg.sgl = sgl;
+	dmaarg.sgl_count = 0;
+	dmaarg.sgl_max = sgl_max;
+	dmaarg.rc = 0;
+
+	err = bus_dmamap_load_ccb(ocs->buf_dmat, io->tgt_io.dmap, ccb,
+			ocs_scsi_dmamap_load, &dmaarg, 0);
+
+	if (err || dmaarg.rc) {
+		device_printf(
+			ocs->dev, "%s: bus_dmamap_load_ccb error (%d %d)\n",
+				__func__, err, dmaarg.rc);
+		return -1;
+	}
+
+	io->tgt_io.flags |= OCS_CAM_IO_F_DMAPPED;
+	return dmaarg.sgl_count;
+}
+
+/**
+ * @ingroup cam_io
+ * @brief Send a target IO
+ *
+ * @param ocs the driver instance's software context
+ * @param ccb pointer to the CCB
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_target_io(struct ocs_softc *ocs, union ccb *ccb)
+{
+	struct ccb_scsiio *csio = &ccb->csio;
+	ocs_io_t *io = NULL;
+	uint32_t cam_dir = ccb->ccb_h.flags & CAM_DIR_MASK;
+	bool sendstatus = ccb->ccb_h.flags & CAM_SEND_STATUS;
+	uint32_t xferlen = csio->dxfer_len;
+	int32_t rc = 0;
+
+	io = ocs_scsi_find_io(ocs, csio->tag_id);
+	if (io == NULL) {
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+		panic("bad tag value");
+		return 1;
+	}
+
+	/* Received an ABORT TASK for this IO */
+	if (io->tgt_io.flags & OCS_CAM_IO_F_ABORT_RECV) {
+		/*device_printf(ocs->dev,
+			"%s: XPT_CONT_TARGET_IO state=%d tag=%#x xid=%#x flags=%#x\n",
+			__func__, io->tgt_io.state, io->tag, io->init_task_tag,
+			io->tgt_io.flags);*/
+		io->tgt_io.flags |= OCS_CAM_IO_F_ABORT_CAM;
+
+		if (ccb->ccb_h.flags & CAM_SEND_STATUS) {
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+			ocs_target_io_free(io);
+			return 1;
+		} 
+
+		ocs_set_ccb_status(ccb, CAM_REQ_ABORTED);
+
+		return 1;
+	}
+
+	io->tgt_io.app = ccb;
+
+	ocs_set_ccb_status(ccb, CAM_REQ_INPROG);
+	ccb->ccb_h.status |= CAM_SIM_QUEUED;
+
+	csio->ccb_h.ccb_ocs_ptr = ocs;
+	csio->ccb_h.ccb_io_ptr  = io;
+
+	if ((sendstatus && (xferlen == 0))) {
+		ocs_scsi_cmd_resp_t	resp = { 0 };
+
+		ocs_assert(ccb->ccb_h.flags & CAM_SEND_STATUS, -1);
+
+		io->tgt_io.state = OCS_CAM_IO_RESP;
+
+		resp.scsi_status = csio->scsi_status;
+
+		if (ccb->ccb_h.flags & CAM_SEND_SENSE) {
+			resp.sense_data = (uint8_t *)&csio->sense_data;
+			resp.sense_data_length = csio->sense_len;
+		}
+
+		resp.residual = io->exp_xfer_len - io->transferred;
+		rc = ocs_scsi_send_resp(io, 0, &resp, ocs_scsi_target_io_cb, ccb);
+
+	} else if (xferlen != 0) {
+		ocs_scsi_sgl_t sgl[OCS_FC_MAX_SGL];
+		int32_t sgl_count = 0;
+
+		io->tgt_io.state = OCS_CAM_IO_DATA;
+		
+		if (sendstatus)
+			io->tgt_io.sendresp = 1;
+
+		sgl_count = ocs_build_scsi_sgl(ocs, ccb, io, sgl, ARRAY_SIZE(sgl));
+		if (sgl_count > 0) {
+			if (cam_dir == CAM_DIR_IN) {
+				rc = ocs_scsi_send_rd_data(io, 0, NULL, sgl,
+						sgl_count, csio->dxfer_len,
+						ocs_scsi_target_io_cb, ccb);
+			} else if (cam_dir == CAM_DIR_OUT) {
+				rc = ocs_scsi_recv_wr_data(io, 0, NULL, sgl,
+						sgl_count, csio->dxfer_len,
+						ocs_scsi_target_io_cb, ccb);
+			} else {
+				device_printf(ocs->dev, "%s:"
+						" unknown CAM direction %#x\n",
+						__func__, cam_dir);
+				ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
+				rc = 1;
+			}
+		} else {
+			device_printf(ocs->dev, "%s: building SGL failed\n",
+						__func__);
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+			rc = 1;
+		}
+	} else {
+		device_printf(ocs->dev, "%s: Wrong value xfer and sendstatus"
+					" are 0 \n", __func__);
+		ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
+		rc = 1;
+
+	}
+
+	if (rc) {
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+		ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
+		io->tgt_io.state = OCS_CAM_IO_DATA_DONE;
+		device_printf(ocs->dev, "%s: CTIO state=%d tag=%#x\n",
+				__func__, io->tgt_io.state, io->tag);
+	if ((sendstatus && (xferlen == 0))) {
+			ocs_target_io_free(io);
+		}
+	}
+
+	return rc;
+}
+
+static int32_t
+ocs_target_tmf_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags,
+		void *arg)
+{
+
+	/*device_printf(io->ocs->dev, "%s: tag=%x io=%p s=%#x\n",
+			 __func__, io->tag, io, scsi_status);*/
+	ocs_scsi_io_complete(io);
+
+	return 0;
+}
+
+/**
+ * @ingroup cam_io
+ * @brief Send an initiator IO
+ *
+ * @param ocs the driver instance's software context
+ * @param ccb pointer to the CCB
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_initiator_io(struct ocs_softc *ocs, union ccb *ccb)
+{
+	int32_t rc;
+	struct ccb_scsiio *csio = &ccb->csio;
+	struct ccb_hdr *ccb_h = &csio->ccb_h;
+	ocs_node_t *node = NULL;
+	ocs_io_t *io = NULL;
+	ocs_scsi_sgl_t sgl[OCS_FC_MAX_SGL];
+	int32_t sgl_count;
+
+	node = ocs_node_get_instance(ocs, ccb_h->target_id);
+	if (node == NULL) {
+		device_printf(ocs->dev, "%s: no device %d\n", __func__,
+							ccb_h->target_id);
+		return CAM_DEV_NOT_THERE;
+	}
+
+	if (!node->targ) {
+                device_printf(ocs->dev, "%s: not target device %d\n", __func__,
+							ccb_h->target_id);
+                return CAM_DEV_NOT_THERE;
+        }
+
+	io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR);
+	if (io == NULL) {
+		device_printf(ocs->dev, "%s: unable to alloc IO\n", __func__);
+		return -1;
+	}
+
+	/* eventhough this is INI, use target structure as ocs_build_scsi_sgl
+	 * only references the tgt_io part of an ocs_io_t */
+	io->tgt_io.app = ccb;
+
+	csio->ccb_h.ccb_ocs_ptr = ocs;
+	csio->ccb_h.ccb_io_ptr  = io;
+
+	sgl_count = ocs_build_scsi_sgl(ocs, ccb, io, sgl, ARRAY_SIZE(sgl));
+	if (sgl_count < 0) {
+		ocs_scsi_io_free(io);
+		device_printf(ocs->dev, "%s: building SGL failed\n", __func__);
+		return -1;
+	}
+
+	if (ccb->ccb_h.timeout == CAM_TIME_INFINITY) {
+		io->timeout = 0;
+	} else if (ccb->ccb_h.timeout == CAM_TIME_DEFAULT) {
+		io->timeout = OCS_CAM_IO_TIMEOUT;
+	} else {
+		io->timeout = ccb->ccb_h.timeout;
+	}
+
+	switch (ccb->ccb_h.flags & CAM_DIR_MASK) {
+	case CAM_DIR_NONE:
+		rc = ocs_scsi_send_nodata_io(node, io, ccb_h->target_lun,
+				ccb->ccb_h.flags & CAM_CDB_POINTER ? 
+				csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes,
+				csio->cdb_len,
+				ocs_scsi_initiator_io_cb, ccb);
+               break;
+	case CAM_DIR_IN:
+		rc = ocs_scsi_send_rd_io(node, io, ccb_h->target_lun,
+				ccb->ccb_h.flags & CAM_CDB_POINTER ? 
+				csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes,
+				csio->cdb_len,
+				NULL,
+				sgl, sgl_count, csio->dxfer_len,
+				ocs_scsi_initiator_io_cb, ccb);
+		break;
+	case CAM_DIR_OUT:
+		rc = ocs_scsi_send_wr_io(node, io, ccb_h->target_lun,
+				ccb->ccb_h.flags & CAM_CDB_POINTER ? 
+				csio->cdb_io.cdb_ptr: csio->cdb_io.cdb_bytes,
+				csio->cdb_len,
+				NULL,
+				sgl, sgl_count, csio->dxfer_len,
+				ocs_scsi_initiator_io_cb, ccb);
+		break;
+	default:
+		panic("%s invalid data direction %08x\n", __func__, 
+							ccb->ccb_h.flags);
+		break;
+	}
+
+	return rc;
+}
+
+static uint32_t
+ocs_fcp_change_role(struct ocs_softc *ocs, ocs_fcport *fcp, uint32_t new_role)
+{
+
+	uint32_t rc = 0, was = 0, i = 0;
+	ocs_vport_spec_t *vport = fcp->vport;
+
+	for (was = 0, i = 0; i < (ocs->num_vports + 1); i++) {
+                if (FCPORT(ocs, i)->role != KNOB_ROLE_NONE)
+                        was++;
+        }
+
+	// Physical port	
+	if ((was == 0) || (vport == NULL)) { 
+		fcp->role = new_role;
+		if (vport == NULL) {
+			ocs->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
+			ocs->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
+		} else {
+			vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
+			vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
+		}
+
+		rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
+		if (rc) {
+			ocs_log_debug(ocs, "port offline failed : %d\n", rc);
+		}
+
+		rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+		if (rc) {
+			ocs_log_debug(ocs, "port online failed : %d\n", rc);
+		}
+		
+		return 0;
+	}
+	
+	if ((fcp->role != KNOB_ROLE_NONE)){
+		fcp->role = new_role;
+		vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
+		vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
+		/* New Sport will be created in sport deleted cb */
+		return ocs_sport_vport_del(ocs, ocs->domain, vport->wwpn, vport->wwnn);
+	}
+
+	fcp->role = new_role;
+	
+	vport->enable_ini = (new_role & KNOB_ROLE_INITIATOR)? 1:0;
+	vport->enable_tgt = (new_role & KNOB_ROLE_TARGET)? 1:0;
+
+        if (fcp->role != KNOB_ROLE_NONE) {
+		return ocs_sport_vport_alloc(ocs->domain, vport);
+	}
+
+	return (0);
+}
+
+/**
+ * @ingroup cam_api
+ * @brief Process CAM actions
+ *
+ * The driver supplies this routine to the CAM during intialization and
+ * is the main entry point for processing CAM Control Blocks (CCB)
+ *
+ * @param sim pointer to the SCSI Interface Module
+ * @param ccb CAM control block
+ *
+ * @todo
+ *  - populate path inquiry data via info retrieved from SLI port
+ */
+static void
+ocs_action(struct cam_sim *sim, union ccb *ccb)
+{
+	struct ocs_softc *ocs = (struct ocs_softc *)cam_sim_softc(sim);
+	struct ccb_hdr	*ccb_h = &ccb->ccb_h;
+
+	int32_t	rc, bus;
+	bus = cam_sim_bus(sim);
+
+	switch (ccb_h->func_code) {
+	case XPT_SCSI_IO:
+                 
+		if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0) {
+                        if ((ccb->ccb_h.flags & CAM_CDB_PHYS) != 0) {
+                                ccb->ccb_h.status = CAM_REQ_INVALID;
+				xpt_done(ccb);
+                                break;
+                        }
+                }
+
+		rc = ocs_initiator_io(ocs, ccb);
+		if (0 == rc) {
+			ocs_set_ccb_status(ccb, CAM_REQ_INPROG | CAM_SIM_QUEUED);
+			break;
+		} else {
+			ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
+			if (rc > 0) {
+				ocs_set_ccb_status(ccb, rc);
+			} else {
+				ocs_set_ccb_status(ccb, CAM_SEL_TIMEOUT);
+			}
+		}
+		xpt_done(ccb);
+		break;
+	case XPT_PATH_INQ:
+	{
+		struct ccb_pathinq *cpi = &ccb->cpi;
+		struct ccb_pathinq_settings_fc *fc = &cpi->xport_specific.fc;
+
+		uint64_t wwn = 0;
+		ocs_xport_stats_t value;
+
+		cpi->version_num = 1;
+
+		cpi->protocol = PROTO_SCSI;
+		cpi->protocol_version = SCSI_REV_SPC;
+
+		if (ocs->ocs_xport == OCS_XPORT_FC) {
+			cpi->transport = XPORT_FC;
+		} else {
+			cpi->transport = XPORT_UNKNOWN;
+		}
+
+		cpi->transport_version = 0;
+
+		/* Set the transport parameters of the SIM */
+		ocs_xport_status(ocs->xport, OCS_XPORT_LINK_SPEED, &value);
+		fc->bitrate = value.value * 1000;	/* speed in Mbps */
+
+		wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWPN));
+		fc->wwpn = be64toh(wwn);
+
+		wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs, OCS_SCSI_WWNN));
+		fc->wwnn = be64toh(wwn);
+
+		if (ocs->domain && ocs->domain->attached) {
+			fc->port = ocs->domain->sport->fc_id;
+		}
+
+		if (ocs->config_tgt) {
+			cpi->target_sprt =
+				PIT_PROCESSOR | PIT_DISCONNECT | PIT_TERM_IO;
+		}
+
+		cpi->hba_misc = PIM_NOBUSRESET | PIM_UNMAPPED;
+                cpi->hba_misc |= PIM_EXTLUNS | PIM_NOSCAN;
+
+		cpi->hba_inquiry = PI_TAG_ABLE; 
+		cpi->max_target = OCS_MAX_TARGETS;
+		cpi->initiator_id = ocs->max_remote_nodes + 1;
+
+		if (!ocs->enable_ini) {
+			cpi->hba_misc |= PIM_NOINITIATOR;
+		}
+
+		cpi->max_lun = OCS_MAX_LUN;
+		cpi->bus_id = cam_sim_bus(sim);
+
+		/* Need to supply a base transfer speed prior to linking up
+		 * Worst case, this would be FC 1Gbps */
+		cpi->base_transfer_speed = 1 * 1000 * 1000;
+
+		/* Calculate the max IO supported
+		 * Worst case would be an OS page per SGL entry */
+		cpi->maxio = PAGE_SIZE * 
+			(ocs_scsi_get_property(ocs, OCS_SCSI_MAX_SGL) - 1);
+
+		strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
+		strncpy(cpi->hba_vid, "Emulex", HBA_IDLEN);
+		strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
+		cpi->unit_number = cam_sim_unit(sim);
+
+		cpi->ccb_h.status = CAM_REQ_CMP;
+		xpt_done(ccb);
+		break;
+	}
+	case XPT_GET_TRAN_SETTINGS:
+	{
+		struct ccb_trans_settings *cts = &ccb->cts;
+		struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
+		struct ccb_trans_settings_fc *fc = &cts->xport_specific.fc;
+		ocs_xport_stats_t value;
+		ocs_node_t	*fnode = NULL;
+
+		if (ocs->ocs_xport != OCS_XPORT_FC) {
+			ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
+			xpt_done(ccb);
+			break;
+		}
+
+		fnode = ocs_node_get_instance(ocs, cts->ccb_h.target_id);
+		if (fnode == NULL) {
+			ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE);
+			xpt_done(ccb);
+			break;
+		}
+
+		cts->protocol = PROTO_SCSI;
+		cts->protocol_version = SCSI_REV_SPC2;
+		cts->transport = XPORT_FC;
+		cts->transport_version = 2;
+
+		scsi->valid = CTS_SCSI_VALID_TQ;
+		scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
+
+		/* speed in Mbps */
+		ocs_xport_status(ocs->xport, OCS_XPORT_LINK_SPEED, &value);
+		fc->bitrate = value.value * 100;
+
+		fc->wwpn = ocs_node_get_wwpn(fnode);
+
+		fc->wwnn = ocs_node_get_wwnn(fnode);
+
+		fc->port = fnode->rnode.fc_id;
+
+		fc->valid = CTS_FC_VALID_SPEED |
+			CTS_FC_VALID_WWPN |
+			CTS_FC_VALID_WWNN |
+			CTS_FC_VALID_PORT;
+
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		xpt_done(ccb);
+		break;
+	}
+	case XPT_SET_TRAN_SETTINGS:
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		xpt_done(ccb);
+		break;
+
+	case XPT_CALC_GEOMETRY:
+		cam_calc_geometry(&ccb->ccg, TRUE);
+		xpt_done(ccb);
+		break;
+
+	case XPT_GET_SIM_KNOB:
+	{
+		struct ccb_sim_knob *knob = &ccb->knob;
+		uint64_t wwn = 0;
+		ocs_fcport *fcp = FCPORT(ocs, bus);
+
+		if (ocs->ocs_xport != OCS_XPORT_FC) {
+			ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
+			xpt_done(ccb);
+			break;
+		}
+		
+		if (bus == 0) {
+			wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs,
+						OCS_SCSI_WWNN));
+			knob->xport_specific.fc.wwnn = be64toh(wwn);
+
+			wwn = *((uint64_t *)ocs_scsi_get_property_ptr(ocs,
+						OCS_SCSI_WWPN));
+			knob->xport_specific.fc.wwpn = be64toh(wwn);
+		} else {
+			knob->xport_specific.fc.wwnn = fcp->vport->wwnn;
+			knob->xport_specific.fc.wwpn = fcp->vport->wwpn;
+		}
+
+		knob->xport_specific.fc.role = fcp->role;
+		knob->xport_specific.fc.valid = KNOB_VALID_ADDRESS |
+						KNOB_VALID_ROLE;
+
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		xpt_done(ccb);
+		break;
+	}
+	case XPT_SET_SIM_KNOB:
+	{
+		struct ccb_sim_knob *knob = &ccb->knob;
+		bool role_changed = FALSE;
+		ocs_fcport *fcp = FCPORT(ocs, bus);
+
+		if (ocs->ocs_xport != OCS_XPORT_FC) {
+			ocs_set_ccb_status(ccb, CAM_REQ_INVALID);
+			xpt_done(ccb);
+			break;
+		}
+			
+		if (knob->xport_specific.fc.valid & KNOB_VALID_ADDRESS) {
+			device_printf(ocs->dev, 
+				"%s: XPT_SET_SIM_KNOB wwnn=%llx wwpn=%llx\n",
+					__func__,
+					(unsigned long long)knob->xport_specific.fc.wwnn,
+					(unsigned long long)knob->xport_specific.fc.wwpn);
+		}
+
+		if (knob->xport_specific.fc.valid & KNOB_VALID_ROLE) {
+			switch (knob->xport_specific.fc.role) {
+			case KNOB_ROLE_NONE:
+				if (fcp->role != KNOB_ROLE_NONE) {
+					role_changed = TRUE;
+				}
+				break;
+			case KNOB_ROLE_TARGET:
+				if (fcp->role != KNOB_ROLE_TARGET) {
+					role_changed = TRUE;
+				}
+				break;
+			case KNOB_ROLE_INITIATOR:
+				if (fcp->role != KNOB_ROLE_INITIATOR) {
+					role_changed = TRUE;
+				}
+				break;
+			case KNOB_ROLE_BOTH:
+				if (fcp->role != KNOB_ROLE_BOTH) {
+					role_changed = TRUE;
+				}
+				break;
+			default:
+				device_printf(ocs->dev,
+					"%s: XPT_SET_SIM_KNOB unsupported role: %d\n",
+					__func__, knob->xport_specific.fc.role);
+			}
+
+			if (role_changed) {
+				device_printf(ocs->dev,
+						"BUS:%d XPT_SET_SIM_KNOB old_role: %d new_role: %d\n",
+						bus, fcp->role, knob->xport_specific.fc.role);
+
+				ocs_fcp_change_role(ocs, fcp, knob->xport_specific.fc.role);
+			}
+		}
+
+		
+
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		xpt_done(ccb);
+		break;
+	}
+	case XPT_ABORT:
+	{
+		union ccb *accb = ccb->cab.abort_ccb;
+
+		switch (accb->ccb_h.func_code) {
+		case XPT_ACCEPT_TARGET_IO:
+			ocs_abort_atio(ocs, ccb);
+			break;
+		case XPT_IMMEDIATE_NOTIFY:
+			ocs_abort_inot(ocs, ccb);
+			break;
+		case XPT_SCSI_IO:
+			rc = ocs_abort_initiator_io(ocs, accb);
+			if (rc) {
+				ccb->ccb_h.status = CAM_UA_ABORT;
+			} else {
+				ccb->ccb_h.status = CAM_REQ_CMP;
+			}
+
+			break;
+		default:
+			printf("abort of unknown func %#x\n",
+					accb->ccb_h.func_code);
+			ccb->ccb_h.status = CAM_REQ_INVALID;
+			break;
+		}
+		break;
+	}
+	case XPT_RESET_BUS:
+		if (ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE) == 0) {
+			ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		} else {
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+		}
+		xpt_done(ccb);
+		break;
+	case XPT_RESET_DEV:
+	{
+		ocs_node_t	*node = NULL;
+		ocs_io_t	*io = NULL;
+		int32_t		rc = 0;
+
+		node = ocs_node_get_instance(ocs, ccb_h->target_id);
+		if (node == NULL) {
+			device_printf(ocs->dev, "%s: no device %d\n",
+						__func__, ccb_h->target_id);
+			ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE);
+			xpt_done(ccb);
+			break;
+		}
+
+		io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR);
+		if (io == NULL) {
+			device_printf(ocs->dev, "%s: unable to alloc IO\n",
+								 __func__);
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+			xpt_done(ccb);
+			break;
+		}
+
+		rc = ocs_scsi_send_tmf(node, io, NULL, ccb_h->target_lun,
+				OCS_SCSI_TMF_LOGICAL_UNIT_RESET,
+				NULL, 0, 0,	/* sgl, sgl_count, length */
+				ocs_initiator_tmf_cb, NULL/*arg*/);
+
+		if (rc) {
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+		} else {
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		}
+		
+        	if (node->fcp2device) {
+			ocs_reset_crn(node, ccb_h->target_lun);
+		}
+
+		xpt_done(ccb);
+		break;
+	}
+	case XPT_EN_LUN:	/* target support */
+	{
+		ocs_tgt_resource_t *trsrc = NULL;
+		uint32_t	status = 0;
+		ocs_fcport *fcp = FCPORT(ocs, bus);
+
+		device_printf(ocs->dev, "XPT_EN_LUN %sable %d:%d\n",
+				ccb->cel.enable ? "en" : "dis",
+				ccb->ccb_h.target_id,
+				(unsigned int)ccb->ccb_h.target_lun);
+
+		trsrc = ocs_tgt_resource_get(fcp, &ccb->ccb_h, &status);
+		if (trsrc) {
+			trsrc->enabled = ccb->cel.enable;
+
+			/* Abort all ATIO/INOT on LUN disable */
+			if (trsrc->enabled == FALSE) {
+				ocs_tgt_resource_abort(ocs, trsrc);
+			} else {
+				STAILQ_INIT(&trsrc->atio);
+				STAILQ_INIT(&trsrc->inot);
+			}
+			status = CAM_REQ_CMP;
+		}
+
+		ocs_set_ccb_status(ccb, status);
+		xpt_done(ccb);
+		break;
+	}
+	/*
+	 * The flow of target IOs in CAM is:
+	 *  - CAM supplies a number of CCBs to the driver used for received
+	 *    commands.
+	 *  - when the driver receives a command, it copies the relevant
+	 *    information to the CCB and returns it to the CAM using xpt_done()
+	 *  - after the target server processes the request, it creates
+	 *    a new CCB containing information on how to continue the IO and 
+	 *    passes that to the driver
+	 *  - the driver processes the "continue IO" (a.k.a CTIO) CCB
+	 *  - once the IO completes, the driver returns the CTIO to the CAM 
+	 *    using xpt_done()
+	 */
+	case XPT_ACCEPT_TARGET_IO:	/* used to inform upper layer of 
+						received CDB (a.k.a. ATIO) */
+	case XPT_IMMEDIATE_NOTIFY:	/* used to inform upper layer of other
+							 event (a.k.a. INOT) */
+	{
+		ocs_tgt_resource_t *trsrc = NULL;
+		uint32_t	status = 0;
+		ocs_fcport *fcp = FCPORT(ocs, bus);
+
+		/*printf("XPT_%s %p\n", ccb_h->func_code == XPT_ACCEPT_TARGET_IO ?
+				"ACCEPT_TARGET_IO" : "IMMEDIATE_NOTIFY", ccb);*/
+		trsrc = ocs_tgt_resource_get(fcp, &ccb->ccb_h, &status);
+		if (trsrc == NULL) {
+			ocs_set_ccb_status(ccb, CAM_DEV_NOT_THERE);
+			xpt_done(ccb);
+			break;
+		}
+
+		if (XPT_ACCEPT_TARGET_IO == ccb->ccb_h.func_code) {
+			struct ccb_accept_tio *atio = NULL;
+
+			atio = (struct ccb_accept_tio *)ccb;
+			atio->init_id = 0x0badbeef;
+			atio->tag_id  = 0xdeadc0de;
+
+			STAILQ_INSERT_TAIL(&trsrc->atio, &ccb->ccb_h, 
+					sim_links.stqe);
+		} else {
+			STAILQ_INSERT_TAIL(&trsrc->inot, &ccb->ccb_h, 
+					sim_links.stqe);
+		}
+		ccb->ccb_h.ccb_io_ptr  = NULL;
+		ccb->ccb_h.ccb_ocs_ptr = ocs;
+		ocs_set_ccb_status(ccb, CAM_REQ_INPROG);
+		/*
+		 * These actions give resources to the target driver.
+		 * If we didn't return here, this function would call
+		 * xpt_done(), signaling to the upper layers that an
+		 * IO or other event had arrived.
+		 */
+		break;
+	}
+	case XPT_NOTIFY_ACKNOWLEDGE:
+	{
+		ocs_io_t *io = NULL;
+		ocs_io_t *abortio = NULL;
+
+		/* Get the IO reference for this tag */
+		io = ocs_scsi_find_io(ocs, ccb->cna2.tag_id);
+		if (io == NULL) {
+			device_printf(ocs->dev,
+				"%s: XPT_NOTIFY_ACKNOWLEDGE no IO with tag %#x\n",
+					__func__, ccb->cna2.tag_id);
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP_ERR);
+			xpt_done(ccb);
+			break;
+		}
+
+		abortio = io->tgt_io.app;
+		if (abortio) {
+			abortio->tgt_io.flags &= ~OCS_CAM_IO_F_ABORT_NOTIFY;
+			device_printf(ocs->dev,
+				"%s: XPT_NOTIFY_ACK state=%d tag=%#x xid=%#x"
+				" flags=%#x\n",	__func__, abortio->tgt_io.state,
+				abortio->tag, abortio->init_task_tag,
+					abortio->tgt_io.flags);
+			/* TMF response was sent in abort callback */
+		} else {
+			ocs_scsi_send_tmf_resp(io, 
+					OCS_SCSI_TMF_FUNCTION_COMPLETE,
+					NULL, ocs_target_tmf_cb, NULL);
+		}
+
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		xpt_done(ccb);
+		break;
+	}
+	case XPT_CONT_TARGET_IO:	/* continue target IO, sending data/response (a.k.a. CTIO) */
+		if (ocs_target_io(ocs, ccb)) {
+			device_printf(ocs->dev, 
+				"XPT_CONT_TARGET_IO failed flags=%x tag=%#x\n",
+				ccb->ccb_h.flags, ccb->csio.tag_id);
+			xpt_done(ccb);
+		}
+		break;
+	default:
+		device_printf(ocs->dev, "unhandled func_code = %#x\n",
+				ccb_h->func_code);
+		ccb_h->status = CAM_REQ_INVALID;
+		xpt_done(ccb);
+		break;
+	}
+}
+
+/**
+ * @ingroup cam_api
+ * @brief Process events
+ *
+ * @param sim pointer to the SCSI Interface Module
+ *
+ */
+static void
+ocs_poll(struct cam_sim *sim)
+{
+	printf("%s\n", __func__);
+}
+
+static int32_t
+ocs_initiator_tmf_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status,
+		ocs_scsi_cmd_resp_t *rsp, uint32_t flags, void *arg)
+{
+	int32_t	rc = 0;
+
+	switch (scsi_status) {
+	case OCS_SCSI_STATUS_GOOD:
+	case OCS_SCSI_STATUS_NO_IO:
+		break;
+	case OCS_SCSI_STATUS_CHECK_RESPONSE:
+		if (rsp->response_data_length == 0) {
+			ocs_log_test(io->ocs, "check response without data?!?\n");
+			rc = -1;
+			break;
+		}
+
+		if (rsp->response_data[3] != 0) {
+			ocs_log_test(io->ocs, "TMF status %08x\n",
+				be32toh(*((uint32_t *)rsp->response_data)));
+			rc = -1;
+			break;
+		}
+		break;
+	default:
+		ocs_log_test(io->ocs, "status=%#x\n", scsi_status);
+		rc = -1;
+	}
+
+	ocs_scsi_io_free(io);
+
+	return rc;
+}
+
+/**
+ * @brief lookup target resource structure
+ *
+ * Arbitrarily support
+ *  - wildcard target ID + LU
+ *  - 0 target ID + non-wildcard LU
+ *
+ * @param ocs the driver instance's software context
+ * @param ccb_h pointer to the CCB header
+ * @param status returned status value
+ *
+ * @return pointer to the target resource, NULL if none available (e.g. if LU
+ * 	   is not enabled)
+ */
+static ocs_tgt_resource_t *ocs_tgt_resource_get(ocs_fcport *fcp, 
+				struct ccb_hdr *ccb_h, uint32_t *status)
+{
+	target_id_t	tid = ccb_h->target_id;
+	lun_id_t	lun = ccb_h->target_lun;
+
+	if (CAM_TARGET_WILDCARD == tid) {
+		if (CAM_LUN_WILDCARD != lun) {
+			*status = CAM_LUN_INVALID;
+			return NULL;
+		}
+		return &fcp->targ_rsrc_wildcard;
+	} else {
+		if (lun < OCS_MAX_LUN) {
+			return &fcp->targ_rsrc[lun];
+		} else {
+			*status = CAM_LUN_INVALID;
+			return NULL;
+		}
+	} 
+
+}
+
+static int32_t
+ocs_tgt_resource_abort(struct ocs_softc *ocs, ocs_tgt_resource_t *trsrc)
+{
+	union ccb *ccb = NULL;
+	uint32_t	count;
+
+	count = 0;
+	do {
+		ccb = (union ccb *)STAILQ_FIRST(&trsrc->atio);
+		if (ccb) {
+			STAILQ_REMOVE_HEAD(&trsrc->atio, sim_links.stqe);
+			ccb->ccb_h.status = CAM_REQ_ABORTED;
+			xpt_done(ccb);
+			count++;
+		}
+	} while (ccb);
+
+	count = 0;
+	do {
+		ccb = (union ccb *)STAILQ_FIRST(&trsrc->inot);
+		if (ccb) {
+			STAILQ_REMOVE_HEAD(&trsrc->inot, sim_links.stqe);
+			ccb->ccb_h.status = CAM_REQ_ABORTED;
+			xpt_done(ccb);
+			count++;
+		}
+	} while (ccb);
+
+	return 0;
+}
+
+static void
+ocs_abort_atio(struct ocs_softc *ocs, union ccb *ccb)
+{
+
+	ocs_io_t        *aio = NULL;
+	ocs_tgt_resource_t *trsrc = NULL;
+	uint32_t	status = CAM_REQ_INVALID;
+	struct ccb_hdr *cur = NULL;
+	union ccb *accb = ccb->cab.abort_ccb;
+
+	int bus = cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path));
+	ocs_fcport *fcp = FCPORT(ocs, bus); 
+
+	trsrc = ocs_tgt_resource_get(fcp, &accb->ccb_h, &status);
+	if (trsrc != NULL) {
+		STAILQ_FOREACH(cur, &trsrc->atio, sim_links.stqe) {
+			if (cur != &accb->ccb_h) 
+				continue;
+
+			STAILQ_REMOVE(&trsrc->atio, cur, ccb_hdr,
+							sim_links.stqe);
+			accb->ccb_h.status = CAM_REQ_ABORTED;
+			xpt_done(accb);
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+			return;
+		}
+	}
+
+	/* if the ATIO has a valid IO pointer, CAM is telling
+	 * the driver that the ATIO (which represents the entire
+	 * exchange) has been aborted. */
+
+	aio = accb->ccb_h.ccb_io_ptr;
+	if (aio == NULL) {
+		ccb->ccb_h.status = CAM_UA_ABORT;
+		return;
+	}
+
+	device_printf(ocs->dev,
+			"%s: XPT_ABORT ATIO state=%d tag=%#x"
+			" xid=%#x flags=%#x\n",	__func__, 
+			aio->tgt_io.state, aio->tag, 
+			aio->init_task_tag, aio->tgt_io.flags);
+	/* Expectations are:
+	 *  - abort task was received
+	 *  - already aborted IO in the DEVICE
+	 *  - already received NOTIFY ACKNOWLEDGE */
+
+	if ((aio->tgt_io.flags & OCS_CAM_IO_F_ABORT_RECV) == 0) {
+		device_printf(ocs->dev,	"%s: abort not received or io completed \n", __func__);
+		ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+		return;
+	}
+
+	aio->tgt_io.flags |= OCS_CAM_IO_F_ABORT_CAM;
+	ocs_target_io_free(aio);
+	ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+	
+	return;
+}
+
+static void
+ocs_abort_inot(struct ocs_softc *ocs, union ccb *ccb)
+{
+	ocs_tgt_resource_t *trsrc = NULL;
+	uint32_t	status = CAM_REQ_INVALID;
+	struct ccb_hdr *cur = NULL;
+	union ccb *accb = ccb->cab.abort_ccb;
+
+	int bus = cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path));
+	ocs_fcport *fcp = FCPORT(ocs, bus); 
+
+	trsrc = ocs_tgt_resource_get(fcp, &accb->ccb_h, &status);
+	if (trsrc) {
+		STAILQ_FOREACH(cur, &trsrc->inot, sim_links.stqe) {
+			if (cur != &accb->ccb_h) 
+				continue;
+
+			STAILQ_REMOVE(&trsrc->inot, cur, ccb_hdr,
+							sim_links.stqe);
+			accb->ccb_h.status = CAM_REQ_ABORTED;
+			xpt_done(accb);
+			ocs_set_ccb_status(ccb, CAM_REQ_CMP);
+			return;
+		}
+	}
+
+	ocs_set_ccb_status(ccb, CAM_UA_ABORT);
+	return;
+}
+
+static uint32_t
+ocs_abort_initiator_io(struct ocs_softc *ocs, union ccb *accb)
+{
+
+	ocs_node_t      *node = NULL;
+	ocs_io_t        *io = NULL;
+	int32_t		rc = 0;
+	struct ccb_scsiio *csio = &accb->csio;
+
+	node = ocs_node_get_instance(ocs, accb->ccb_h.target_id);
+	if (node == NULL) {
+		device_printf(ocs->dev, "%s: no device %d\n", 
+				__func__, accb->ccb_h.target_id);
+		ocs_set_ccb_status(accb, CAM_DEV_NOT_THERE);
+		xpt_done(accb);
+		return (-1);
+	}
+
+	io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_ORIGINATOR);
+	if (io == NULL) {
+		device_printf(ocs->dev,
+				"%s: unable to alloc IO\n", __func__);
+		ocs_set_ccb_status(accb, CAM_REQ_CMP_ERR);
+		xpt_done(accb);
+		return (-1);
+	}
+
+	rc = ocs_scsi_send_tmf(node, io, 
+			(ocs_io_t *)csio->ccb_h.ccb_io_ptr,
+			accb->ccb_h.target_lun,
+			OCS_SCSI_TMF_ABORT_TASK,
+			NULL, 0, 0,
+			ocs_initiator_tmf_cb, NULL/*arg*/);
+
+	return rc;
+}
+
+void
+ocs_scsi_ini_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj)
+{
+	switch(type) {
+	case OCS_SCSI_DDUMP_DEVICE: {
+		//ocs_t *ocs = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_DOMAIN: {
+		//ocs_domain_t *domain = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_SPORT: {
+		//ocs_sport_t *sport = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_NODE: {
+		//ocs_node_t *node = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_IO: {
+		//ocs_io_t *io = obj;
+		break;
+	}
+	default: {
+		break;
+	}
+	}
+}
+
+void
+ocs_scsi_tgt_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj)
+{
+	switch(type) {
+	case OCS_SCSI_DDUMP_DEVICE: {
+		//ocs_t *ocs = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_DOMAIN: {
+		//ocs_domain_t *domain = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_SPORT: {
+		//ocs_sport_t *sport = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_NODE: {
+		//ocs_node_t *node = obj;
+		break;
+	}
+	case OCS_SCSI_DDUMP_IO: {
+		ocs_io_t *io = obj;
+		char *state_str = NULL;
+
+		switch (io->tgt_io.state) {
+		case OCS_CAM_IO_FREE:
+			state_str = "FREE";
+			break;
+		case OCS_CAM_IO_COMMAND:
+			state_str = "COMMAND";
+			break;
+		case OCS_CAM_IO_DATA:
+			state_str = "DATA";
+			break;
+		case OCS_CAM_IO_DATA_DONE:
+			state_str = "DATA_DONE";
+			break;
+		case OCS_CAM_IO_RESP:
+			state_str = "RESP";
+			break;
+		default:
+			state_str = "xxx BAD xxx";
+		}
+		ocs_ddump_value(textbuf, "cam_st", "%s", state_str);
+		if (io->tgt_io.app) {
+			ocs_ddump_value(textbuf, "cam_flags", "%#x",
+				((union ccb *)(io->tgt_io.app))->ccb_h.flags);
+			ocs_ddump_value(textbuf, "cam_status", "%#x",
+				((union ccb *)(io->tgt_io.app))->ccb_h.status);
+		}
+
+		break;
+	}
+	default: {
+		break;
+	}
+	}
+}
+
+int32_t ocs_scsi_get_block_vaddr(ocs_io_t *io, uint64_t blocknumber,
+				ocs_scsi_vaddr_len_t addrlen[],
+				uint32_t max_addrlen, void **dif_vaddr)
+{
+	return -1;
+}
+
+uint32_t
+ocs_get_crn(ocs_node_t *node, uint8_t *crn, uint64_t lun)
+{
+	uint32_t idx;
+	struct ocs_lun_crn *lcrn = NULL;
+	idx = lun % OCS_MAX_LUN;
+
+	lcrn = node->ini_node.lun_crn[idx];
+
+	if (lcrn == NULL) {
+		lcrn = ocs_malloc(node->ocs, sizeof(struct ocs_lun_crn),
+					M_ZERO|M_NOWAIT);
+		if (lcrn == NULL) {
+			return (1);
+		}
+		
+		lcrn->lun = lun;
+		node->ini_node.lun_crn[idx] = lcrn;
+	}
+
+	if (lcrn->lun != lun) {
+		return (1);
+	}	
+	
+	if (lcrn->crnseed == 0)
+		lcrn->crnseed = 1;
+
+	*crn = lcrn->crnseed++;
+	return (0);
+}
+
+void
+ocs_del_crn(ocs_node_t *node)
+{
+	uint32_t i;
+	struct ocs_lun_crn *lcrn = NULL;
+	
+	for(i = 0; i < OCS_MAX_LUN; i++) {
+		lcrn = node->ini_node.lun_crn[i];
+		if (lcrn) {
+			ocs_free(node->ocs, lcrn, sizeof(*lcrn));
+		}
+	}
+
+	return;
+}
+
+void
+ocs_reset_crn(ocs_node_t *node, uint64_t lun)
+{
+	uint32_t idx;
+	struct ocs_lun_crn *lcrn = NULL;
+	idx = lun % OCS_MAX_LUN;
+
+	lcrn = node->ini_node.lun_crn[idx];
+	if (lcrn)
+		lcrn->crnseed = 0;
+
+	return;
+}
diff --git a/sys/dev/ocs_fc/ocs_cam.h b/sys/dev/ocs_fc/ocs_cam.h
new file mode 100644
index 000000000000..2de549fe8f6e
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_cam.h
@@ -0,0 +1,122 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef __OCS_CAM_H__
+#define __OCS_CAM_H__
+
+#include <cam/cam.h>
+#include <cam/cam_sim.h>
+#include <cam/cam_ccb.h>
+#include <cam/cam_periph.h>
+#include <cam/cam_xpt_sim.h>
+
+#include <cam/scsi/scsi_message.h>
+
+
+#define ccb_ocs_ptr     spriv_ptr0
+#define ccb_io_ptr      spriv_ptr1
+
+typedef STAILQ_HEAD(ocs_hdr_list_s, ccb_hdr) ocs_hdr_list_t;
+
+typedef struct ocs_tgt_resource_s {
+	ocs_hdr_list_t	atio;
+	ocs_hdr_list_t	inot;
+	uint8_t		enabled;
+
+	lun_id_t 	lun;
+} ocs_tgt_resource_t;
+
+/* Common SCSI Domain structure declarations */
+
+typedef struct {
+} ocs_scsi_tgt_domain_t;
+
+typedef struct {
+} ocs_scsi_ini_domain_t;
+
+/* Common SCSI SLI port structure declarations */
+
+typedef struct {
+} ocs_scsi_tgt_sport_t;
+
+typedef struct {
+} ocs_scsi_ini_sport_t;
+
+/* Common IO structure declarations */
+
+typedef enum {
+	OCS_CAM_IO_FREE,	/* IO unused		(SIM) */
+	OCS_CAM_IO_COMMAND,	/* ATIO returned to BE	(CTL) */
+	OCS_CAM_IO_DATA,	/* data phase		(SIM) */
+	OCS_CAM_IO_DATA_DONE,	/* CTIO returned to BE	(CTL) */
+	OCS_CAM_IO_RESP,	/* send response	(SIM) */
+	OCS_CAM_IO_MAX
+} ocs_cam_io_state_t;
+
+typedef struct {
+	bus_dmamap_t	dmap;
+	uint64_t lun;		/* target_lun */
+	void		*app;	/** application specific pointer */
+	ocs_cam_io_state_t state;
+        bool            sendresp;
+	uint32_t	flags;
+#define OCS_CAM_IO_F_DMAPPED		BIT(0)	/* associated buffer bus_dmamap'd */
+#define OCS_CAM_IO_F_ABORT_RECV		BIT(1)	/* received ABORT TASK */
+#define OCS_CAM_IO_F_ABORT_DEV		BIT(2)	/* abort WQE pending */
+#define OCS_CAM_IO_F_ABORT_TMF   	BIT(3)	/* TMF response sent */
+#define OCS_CAM_IO_F_ABORT_NOTIFY	BIT(4)	/* XPT_NOTIFY sent to CTL */
+#define OCS_CAM_IO_F_ABORT_CAM		BIT(5)	/* received ABORT or CTIO from CAM */
+} ocs_scsi_tgt_io_t;
+
+typedef struct {
+} ocs_scsi_ini_io_t;
+
+struct ocs_lun_crn {
+        uint64_t lun;                   /* target_lun */
+        uint8_t crnseed;                /* next command reference number */
+};
+
+/* Common NODE structure declarations */
+typedef struct {
+	struct ocs_lun_crn *lun_crn[OCS_MAX_LUN];
+} ocs_scsi_ini_node_t;
+
+typedef struct {
+	uint32_t	busy_sent;
+} ocs_scsi_tgt_node_t;
+
+extern int32_t ocs_cam_attach(ocs_t *ocs);
+extern int32_t ocs_cam_detach(ocs_t *ocs);
+
+#endif /* __OCS_CAM_H__ */
+
diff --git a/sys/dev/ocs_fc/ocs_common.h b/sys/dev/ocs_fc/ocs_common.h
new file mode 100644
index 000000000000..0d34a2d14704
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_common.h
@@ -0,0 +1,424 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Contains declarations shared between the alex layer and HW/SLI4
+ */
+
+
+#if !defined(__OCS_COMMON_H__)
+#define __OCS_COMMON_H__
+
+#include "ocs_sm.h"
+#include "ocs_utils.h"
+
+#define OCS_CTRLMASK_XPORT_DISABLE_AUTORSP_TSEND	(1U << 0)
+#define OCS_CTRLMASK_XPORT_DISABLE_AUTORSP_TRECEIVE	(1U << 1)
+#define OCS_CTRLMASK_XPORT_ENABLE_TARGET_RSCN		(1U << 3)
+#define OCS_CTRLMASK_TGT_ALWAYS_VERIFY_DIF		(1U << 4)
+#define OCS_CTRLMASK_TGT_SET_DIF_REF_TAG_CRC		(1U << 5)
+#define OCS_CTRLMASK_TEST_CHAINED_SGLS			(1U << 6)
+#define OCS_CTRLMASK_ISCSI_ISNS_ENABLE			(1U << 7)
+#define OCS_CTRLMASK_ENABLE_FABRIC_EMULATION		(1U << 8)
+#define OCS_CTRLMASK_INHIBIT_INITIATOR			(1U << 9)
+#define OCS_CTRLMASK_CRASH_RESET			(1U << 10)
+
+#define enable_target_rscn(ocs) \
+	((ocs->ctrlmask & OCS_CTRLMASK_XPORT_ENABLE_TARGET_RSCN) != 0)
+
+/* Used for error injection testing. */
+typedef enum {
+	NO_ERR_INJECT = 0,
+	INJECT_DROP_CMD,
+	INJECT_FREE_DROPPED,
+	INJECT_DROP_DATA,
+	INJECT_DROP_RESP,
+	INJECT_DELAY_CMD,
+} ocs_err_injection_e;
+
+#define MAX_OCS_DEVICES                 64
+
+typedef enum {OCS_XPORT_FC, OCS_XPORT_ISCSI} ocs_xport_e;
+
+#define OCS_SERVICE_PARMS_LENGTH		0x74
+#define OCS_DISPLAY_NAME_LENGTH			32
+#define OCS_DISPLAY_BUS_INFO_LENGTH		16
+
+#define OCS_WWN_LENGTH				32
+
+typedef struct ocs_hw_s ocs_hw_t;
+typedef struct ocs_domain_s ocs_domain_t;
+typedef struct ocs_sli_port_s ocs_sli_port_t;
+typedef struct ocs_sli_port_s ocs_sport_t;
+typedef struct ocs_remote_node_s ocs_remote_node_t;
+typedef struct ocs_remote_node_group_s ocs_remote_node_group_t;
+typedef struct ocs_node_s ocs_node_t;
+typedef struct ocs_io_s ocs_io_t;
+typedef struct ocs_xport_s ocs_xport_t;
+typedef struct ocs_node_cb_s ocs_node_cb_t;
+typedef struct ocs_ns_s ocs_ns_t;
+
+/* Node group data structure */
+typedef struct ocs_node_group_dir_s ocs_node_group_dir_t;
+
+#include "ocs_cam.h"
+
+/*--------------------------------------------------
+ * Shared HW/SLI objects
+ *
+ * Several objects used by the HW/SLI layers are communal; part of the
+ * object is for the sole use of the lower layers, but implementations
+ * are free to add their own fields if desired.
+ */
+
+/**
+ * @brief Description of discovered Fabric Domain
+ *
+ * @note Not all fields are valid for all mediums (FC/ethernet).
+ */
+typedef struct ocs_domain_record_s {
+	uint32_t	index;		/**< FCF table index (used in REG_FCFI) */
+	uint32_t	priority;	/**< FCF reported priority */
+	uint8_t		address[6];	/**< Switch MAC/FC address */
+	uint8_t		wwn[8];		/**< Switch WWN */
+	union {
+		uint8_t	vlan[512];	/**< bitmap of valid VLAN IDs */
+		uint8_t	loop[128];	/**< FC-AL position map */
+	} map;
+	uint32_t	speed;		/**< link speed */
+	uint32_t	fc_id;		/**< our ports fc_id */
+	uint32_t	is_fc:1,	/**< Connection medium is native FC */
+			is_ethernet:1,	/**< Connection medium is ethernet (FCoE) */
+			is_loop:1,	/**< Topology is FC-AL */
+			is_nport:1,	/**< Topology is N-PORT */
+			:28;
+} ocs_domain_record_t;
+
+/**
+ * @brief Node group directory entry
+ */
+struct ocs_node_group_dir_s {
+	uint32_t instance_index;		/*<< instance index */
+	ocs_sport_t *sport;			/*<< pointer to sport */
+	uint8_t service_params[OCS_SERVICE_PARMS_LENGTH];	/**< Login parameters */
+	ocs_list_link_t link;			/**< linked list link */
+	ocs_list_t node_group_list;		/**< linked list of node groups */
+	uint32_t node_group_list_count;		/**< current number of elements on the node group list */
+	uint32_t next_idx;			/*<< index of the next node group in list */
+};
+
+typedef enum {
+	OCS_SPORT_TOPOLOGY_UNKNOWN=0,
+	OCS_SPORT_TOPOLOGY_FABRIC,
+	OCS_SPORT_TOPOLOGY_P2P,
+	OCS_SPORT_TOPOLOGY_LOOP,
+} ocs_sport_topology_e;
+
+/**
+ * @brief SLI Port object
+ *
+ * The SLI Port object represents the connection between the driver and the
+ * FC/FCoE domain. In some topologies / hardware, it is possible to have
+ * multiple connections to the domain via different WWN. Each would require
+ * a separate SLI port object.
+ */
+struct ocs_sli_port_s {
+
+	ocs_t *ocs;				/**< pointer to ocs */
+	uint32_t tgt_id;			/**< target id */
+	uint32_t index;				/**< ??? */
+	uint32_t instance_index;
+	char display_name[OCS_DISPLAY_NAME_LENGTH]; /**< sport display name */
+	ocs_domain_t *domain;			/**< current fabric domain */
+	uint32_t	is_vport:1;		/**< this SPORT is a virtual port */
+	uint64_t	wwpn;			/**< WWPN from HW (host endian) */
+	uint64_t	wwnn;			/**< WWNN from HW (host endian) */
+	ocs_list_t node_list;			/**< list of nodes */
+	ocs_scsi_ini_sport_t ini_sport;		/**< initiator backend private sport data */
+	ocs_scsi_tgt_sport_t tgt_sport;		/**< target backend private sport data */
+	void	*tgt_data;			/**< target backend private pointer */
+	void	*ini_data;			/**< initiator backend private pointer */
+	ocs_mgmt_functions_t *mgmt_functions;
+
+	/*
+	 * Members private to HW/SLI
+	 */
+	ocs_sm_ctx_t	ctx;		/**< state machine context */
+	ocs_hw_t	*hw;		/**< pointer to HW */
+	uint32_t	indicator;	/**< VPI */
+	uint32_t	fc_id;		/**< FC address */
+	ocs_dma_t	dma;		/**< memory for Service Parameters */
+
+	uint8_t		wwnn_str[OCS_WWN_LENGTH];	/**< WWN (ASCII) */
+	uint64_t	sli_wwpn;	/**< WWPN (wire endian) */
+	uint64_t	sli_wwnn;	/**< WWNN (wire endian) */
+	uint32_t	sm_free_req_pending:1;	/**< Free request received while waiting for attach response */
+
+	/*
+	 * Implementation specific fields allowed here
+	 */
+	ocs_sm_ctx_t	sm;			/**< sport context state machine */
+	sparse_vector_t lookup;			/**< fc_id to node lookup object */
+	ocs_list_link_t link;
+	uint32_t	enable_ini:1,		/**< SCSI initiator enabled for this node */
+			enable_tgt:1,		/**< SCSI target enabled for this node */
+			enable_rscn:1,		/**< This SPORT will be expecting RSCN */
+			shutting_down:1,	/**< sport in process of shutting down */
+			p2p_winner:1;		/**< TRUE if we're the point-to-point winner */
+	ocs_sport_topology_e topology;		/**< topology: fabric/p2p/unknown */
+	uint8_t		service_params[OCS_SERVICE_PARMS_LENGTH]; /**< Login parameters */
+	uint32_t	p2p_remote_port_id;	/**< Remote node's port id for p2p */
+	uint32_t	p2p_port_id;		/**< our port's id */
+
+	/* List of remote node group directory entries (used by high login mode) */
+	ocs_lock_t	node_group_lock;
+	uint32_t	node_group_dir_next_instance; /**< HLM next node group directory instance value */
+	uint32_t	node_group_next_instance; /**< HLM next node group instance value */
+	ocs_list_t	node_group_dir_list;
+};
+
+/**
+ * @brief Fibre Channel domain object
+ *
+ * This object is a container for the various SLI components needed
+ * to connect to the domain of a FC or FCoE switch
+ */
+struct ocs_domain_s {
+
+	ocs_t *ocs;				/**< pointer back to ocs */
+	uint32_t instance_index;		/**< unique instance index value */
+	char display_name[OCS_DISPLAY_NAME_LENGTH]; /**< Node display name */
+	ocs_list_t sport_list;			/**< linked list of SLI ports */
+	ocs_scsi_ini_domain_t ini_domain;	/**< initiator backend private domain data */
+	ocs_scsi_tgt_domain_t tgt_domain;	/**< target backend private domain data */
+	ocs_mgmt_functions_t *mgmt_functions;
+
+	/* Declarations private to HW/SLI */
+	ocs_hw_t	*hw;		/**< pointer to HW */
+	ocs_sm_ctx_t	sm;		/**< state machine context */
+	uint32_t	fcf;		/**< FC Forwarder table index */
+	uint32_t	fcf_indicator;	/**< FCFI */
+	uint32_t	vlan_id;	/**< VLAN tag for this domain */
+	uint32_t	indicator;	/**< VFI */
+	ocs_dma_t	dma;		/**< memory for Service Parameters */
+	uint32_t	req_rediscover_fcf:1;	/**< TRUE if fcf rediscover is needed (in response
+						 * to Vlink Clear async event */
+
+	/* Declarations private to FC transport */
+	uint64_t	fcf_wwn;	/**< WWN for FCF/switch */
+	ocs_list_link_t link;
+	ocs_sm_ctx_t	drvsm;		/**< driver domain sm context */
+	uint32_t	attached:1,	/**< set true after attach completes */
+			is_fc:1,	/**< is FC */
+			is_loop:1,	/**< is loop topology */
+			is_nlport:1,	/**< is public loop */
+			domain_found_pending:1,	/**< A domain found is pending, drec is updated */
+			req_domain_free:1,	/**< True if domain object should be free'd */
+			req_accept_frames:1,	/**< set in domain state machine to enable frames */
+			domain_notify_pend:1;  /** Set in domain SM to avoid duplicate node event post */
+	ocs_domain_record_t pending_drec; /**< Pending drec if a domain found is pending */
+	uint8_t		service_params[OCS_SERVICE_PARMS_LENGTH]; /**< any sports service parameters */
+	uint8_t		flogi_service_params[OCS_SERVICE_PARMS_LENGTH]; /**< Fabric/P2p service parameters from FLOGI */
+	uint8_t		femul_enable;	/**< TRUE if Fabric Emulation mode is enabled */
+
+	/* Declarations shared with back-ends */
+	sparse_vector_t lookup;		/**< d_id to node lookup object */
+	ocs_lock_t	lookup_lock;
+
+	ocs_sli_port_t	*sport;		/**< Pointer to first (physical) SLI port (also at the head of sport_list) */
+	uint32_t	sport_instance_count; /**< count of sport instances */
+
+	/* Fabric Emulation */
+	ocs_bitmap_t *portid_pool;
+	ocs_ns_t *ocs_ns;			/*>> Directory(Name) services data */
+};
+
+/**
+ * @brief Remote Node object
+ *
+ * This object represents a connection between the SLI port and another
+ * Nx_Port on the fabric. Note this can be either a well known port such
+ * as a F_Port (i.e. ff:ff:fe) or another N_Port.
+ */
+struct ocs_remote_node_s {
+	/*
+	 * Members private to HW/SLI
+	 */
+	uint32_t	indicator;	/**< RPI */
+	uint32_t	index;
+	uint32_t	fc_id;		/**< FC address */
+
+	uint32_t	attached:1,	/**< true if attached */
+			node_group:1,	/**< true if in node group */
+			free_group:1;	/**< true if the node group should be free'd */
+
+	ocs_sli_port_t	*sport;		/**< associated SLI port */
+
+	/*
+	 * Implementation specific fields allowed here
+	 */
+	void *node;			/**< associated node */
+};
+
+struct ocs_remote_node_group_s {
+	/*
+	 * Members private to HW/SLI
+	 */
+	uint32_t	indicator;	/**< RPI */
+	uint32_t	index;
+
+	/*
+	 * Implementation specific fields allowed here
+	 */
+
+
+	uint32_t instance_index;		/*<< instance index */
+	ocs_node_group_dir_t *node_group_dir;	/*<< pointer to the node group directory */
+	ocs_list_link_t link;			/*<< linked list link */
+};
+
+typedef enum {
+	OCS_NODE_SHUTDOWN_DEFAULT = 0,
+	OCS_NODE_SHUTDOWN_EXPLICIT_LOGO,
+	OCS_NODE_SHUTDOWN_IMPLICIT_LOGO,
+} ocs_node_shutd_rsn_e;
+
+typedef enum {
+	OCS_NODE_SEND_LS_ACC_NONE = 0,
+	OCS_NODE_SEND_LS_ACC_PLOGI,
+	OCS_NODE_SEND_LS_ACC_PRLI,
+} ocs_node_send_ls_acc_e;
+
+/**
+ * @brief FC Node object
+ *
+ */
+struct ocs_node_s {
+
+	ocs_t *ocs;				/**< pointer back to ocs structure */
+	uint32_t instance_index;		/**< unique instance index value */
+	char display_name[OCS_DISPLAY_NAME_LENGTH]; /**< Node display name */
+	ocs_sport_t *sport;
+	uint32_t hold_frames:1;			/**< hold incoming frames if true */
+	ocs_rlock_t lock;			/**< node wide lock */
+	ocs_lock_t active_ios_lock;		/**< active SCSI and XPORT I/O's for this node */
+	ocs_list_t active_ios;			/**< active I/O's for this node */
+	uint32_t max_wr_xfer_size;		/**< Max write IO size per phase for the transport */
+	ocs_scsi_ini_node_t ini_node;		/**< backend initiator private node data */
+	ocs_scsi_tgt_node_t tgt_node;		/**< backend target private node data */
+	ocs_mgmt_functions_t *mgmt_functions;
+
+	/* Declarations private to HW/SLI */
+	ocs_remote_node_t	rnode;		/**< Remote node */
+
+	/* Declarations private to FC transport */
+	ocs_sm_ctx_t		sm;		/**< state machine context */
+	uint32_t		evtdepth;	/**< current event posting nesting depth */
+	uint32_t		req_free:1,	/**< this node is to be free'd */
+				attached:1,	/**< node is attached (REGLOGIN complete) */
+				fcp_enabled:1,	/**< node is enabled to handle FCP */
+				rscn_pending:1,	/**< for name server node RSCN is pending */
+				send_plogi:1,	/**< if initiator, send PLOGI at node initialization */
+				send_plogi_acc:1,/**< send PLOGI accept, upon completion of node attach */
+				io_alloc_enabled:1, /**< TRUE if ocs_scsi_io_alloc() and ocs_els_io_alloc() are enabled */
+				sent_prli:1;    /**< if initiator, sent prli. */
+	ocs_node_send_ls_acc_e	send_ls_acc;	/**< type of LS acc to send */
+	ocs_io_t		*ls_acc_io;	/**< SCSI IO for LS acc */
+	uint32_t		ls_acc_oxid;	/**< OX_ID for pending accept */
+	uint32_t		ls_acc_did;	/**< D_ID for pending accept */
+	ocs_node_shutd_rsn_e	shutdown_reason;/**< reason for node shutdown */
+	ocs_dma_t		sparm_dma_buf;	/**< service parameters buffer */
+	uint8_t			service_params[OCS_SERVICE_PARMS_LENGTH]; /**< plogi/acc frame from remote device */
+	ocs_lock_t		pend_frames_lock; /**< lock for inbound pending frames list */
+	ocs_list_t		pend_frames;	/**< inbound pending frames list */
+	uint32_t		pend_frames_processed;	/**< count of frames processed in hold frames interval */
+	uint32_t		ox_id_in_use;	/**< used to verify one at a time us of ox_id */
+	uint32_t		els_retries_remaining;	/**< for ELS, number of retries remaining */
+	uint32_t		els_req_cnt;	/**< number of outstanding ELS requests */
+	uint32_t		els_cmpl_cnt;	/**< number of outstanding ELS completions */
+	uint32_t		abort_cnt;	/**< Abort counter for debugging purpose */
+
+	char current_state_name[OCS_DISPLAY_NAME_LENGTH]; /**< current node state */
+	char prev_state_name[OCS_DISPLAY_NAME_LENGTH]; /**< previous node state */
+	ocs_sm_event_t		current_evt;	/**< current event */
+	ocs_sm_event_t		prev_evt;	/**< current event */
+	uint32_t		targ:1,		/**< node is target capable */
+				init:1,		/**< node is initiator capable */
+				refound:1,	/**< Handle node refound case when node is being deleted  */
+				fcp2device:1,    /* FCP2 device */
+				reserved:4,
+				fc_type:8;
+	ocs_list_t		els_io_pend_list;   /**< list of pending (not yet processed) ELS IOs */
+	ocs_list_t		els_io_active_list; /**< list of active (processed) ELS IOs */
+
+	ocs_sm_function_t	nodedb_state;	/**< Node debugging, saved state */
+
+	ocs_timer_t		gidpt_delay_timer;	/**< GIDPT delay timer */
+	time_t			time_last_gidpt_msec;	/**< Start time of last target RSCN GIDPT  */
+
+	/* WWN */
+	char wwnn[OCS_WWN_LENGTH];		/**< remote port WWN (uses iSCSI naming) */
+	char wwpn[OCS_WWN_LENGTH];		/**< remote port WWN (uses iSCSI naming) */
+
+	/* Statistics */
+	uint32_t		chained_io_count;	/**< count of IOs with chained SGL's */
+
+	ocs_list_link_t		link;		/**< node list link */
+
+	ocs_remote_node_group_t	*node_group;	/**< pointer to node group (if HLM enabled) */
+};
+
+/**
+ * @brief Virtual port specification
+ *
+ * Collection of the information required to restore a virtual port across
+ * link events
+ */
+
+typedef struct ocs_vport_spec_s ocs_vport_spec_t;
+struct ocs_vport_spec_s {
+	uint32_t domain_instance;		/*>> instance index of this domain for the sport */
+	uint64_t wwnn;				/*>> node name */
+	uint64_t wwpn;				/*>> port name */
+	uint32_t fc_id;				/*>> port id */
+	uint32_t enable_tgt:1,			/*>> port is a target */
+		enable_ini:1;			/*>> port is an initiator */
+	ocs_list_link_t link;			/*>> link */
+	void	*tgt_data;			/**< target backend pointer */
+	void	*ini_data;			/**< initiator backend pointer */
+	ocs_sport_t *sport;			/**< Used to match record after attaching for update */
+};
+
+
+#endif /* __OCS_COMMON_H__*/
diff --git a/sys/dev/ocs_fc/ocs_ddump.c b/sys/dev/ocs_fc/ocs_ddump.c
new file mode 100644
index 000000000000..4d452307480a
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_ddump.c
@@ -0,0 +1,881 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * generate FC ddump
+ *
+ */
+
+#include "ocs.h"
+#include "ocs_ddump.h"
+
+#define DEFAULT_SAVED_DUMP_SIZE		(4*1024*1024)
+
+void hw_queue_ddump(ocs_textbuf_t *textbuf, ocs_hw_t *hw);
+
+/**
+ * @brief Generate sli4 queue ddump
+ *
+ * Generates sli4 queue ddump data
+ *
+ * @param textbuf pointer to text buffer
+ * @param name name of SLI4 queue
+ * @param hw pointer HW context
+ * @param q pointer to SLI4 queues array
+ * @param q_count count of SLI4 queues
+ * @param qentries number of SLI4 queue entries to dump
+ *
+ * @return none
+ */
+
+static void
+ocs_ddump_sli4_queue(ocs_textbuf_t *textbuf, const char *name, ocs_hw_t *hw, sli4_queue_t *q, uint32_t q_count, uint32_t qentries)
+{
+	uint32_t i;
+
+	for (i = 0; i < q_count; i ++, q ++) {
+		ocs_ddump_section(textbuf, name, i);
+		ocs_ddump_value(textbuf, "index", "%d", q->index);
+		ocs_ddump_value(textbuf, "size", "%d", q->size);
+		ocs_ddump_value(textbuf, "length", "%d", q->length);
+		ocs_ddump_value(textbuf, "n_posted", "%d", q->n_posted);
+		ocs_ddump_value(textbuf, "id", "%d", q->id);
+		ocs_ddump_value(textbuf, "type", "%d", q->type);
+		ocs_ddump_value(textbuf, "proc_limit", "%d", q->proc_limit);
+		ocs_ddump_value(textbuf, "posted_limit", "%d", q->posted_limit);
+		ocs_ddump_value(textbuf, "max_num_processed", "%d", q->max_num_processed);
+		ocs_ddump_value(textbuf, "max_process_time", "%ld", (unsigned long)q->max_process_time);
+		ocs_ddump_value(textbuf, "virt_addr", "%p", q->dma.virt);
+		ocs_ddump_value(textbuf, "phys_addr", "%lx", (unsigned long)q->dma.phys);
+
+		/* queue-specific information */
+		switch (q->type) {
+		case SLI_QTYPE_MQ:
+			ocs_ddump_value(textbuf, "r_idx", "%d", q->u.r_idx);
+			break;
+		case SLI_QTYPE_CQ:
+			ocs_ddump_value(textbuf, "is_mq", "%d", q->u.flag.is_mq);
+			break;
+		case SLI_QTYPE_WQ:
+			break;
+		case SLI_QTYPE_RQ: {
+			uint32_t i;
+			uint32_t j;
+			uint32_t rqe_count = 0;
+			hw_rq_t *rq;
+
+			ocs_ddump_value(textbuf, "is_hdr", "%d", q->u.flag.is_hdr);
+			ocs_ddump_value(textbuf, "rq_batch", "%d", q->u.flag.rq_batch);
+
+			/* loop through RQ tracker to see how many RQEs were produced */
+			for (i = 0; i < hw->hw_rq_count; i++) {
+				rq = hw->hw_rq[i];
+				for (j = 0; j < rq->entry_count; j++) {
+					if (rq->rq_tracker[j] != NULL) {
+						rqe_count++;
+					}
+				}
+			}
+			ocs_ddump_value(textbuf, "rqes_produced", "%d", rqe_count);
+			break;
+		}
+		}
+		ocs_ddump_queue_entries(textbuf, q->dma.virt, q->size, q->length,
+					((q->type == SLI_QTYPE_MQ) ? q->u.r_idx : q->index),
+					qentries);
+		ocs_ddump_endsection(textbuf, name, i);
+	}
+}
+
+
+/**
+ * @brief Generate SLI4 ddump
+ *
+ * Generates sli4 ddump
+ *
+ * @param textbuf pointer to text buffer
+ * @param sli4 pointer SLI context
+ * @param qtype SLI4 queue type
+ *
+ * @return none
+ */
+
+static void
+ocs_ddump_sli_q_fields(ocs_textbuf_t *textbuf, sli4_t *sli4, sli4_qtype_e qtype)
+{
+	char * q_desc;
+
+	switch(qtype) {
+	case SLI_QTYPE_EQ: q_desc = "EQ"; break;
+	case SLI_QTYPE_CQ: q_desc = "CQ"; break;
+	case SLI_QTYPE_MQ: q_desc = "MQ"; break;
+	case SLI_QTYPE_WQ: q_desc = "WQ"; break;
+	case SLI_QTYPE_RQ: q_desc = "RQ"; break;
+	default: q_desc = "unknown"; break;
+	}
+
+	ocs_ddump_section(textbuf, q_desc, qtype);
+
+	ocs_ddump_value(textbuf, "max_qcount", "%d", sli4->config.max_qcount[qtype]);
+	ocs_ddump_value(textbuf, "max_qentries", "%d", sli4->config.max_qentries[qtype]);
+	ocs_ddump_value(textbuf, "qpage_count", "%d", sli4->config.qpage_count[qtype]);
+	ocs_ddump_endsection(textbuf, q_desc, qtype);
+}
+
+
+/**
+ * @brief Generate SLI4 ddump
+ *
+ * Generates sli4 ddump
+ *
+ * @param textbuf pointer to text buffer
+ * @param sli4 pointer SLI context
+ *
+ * @return none
+ */
+
+static void
+ocs_ddump_sli(ocs_textbuf_t *textbuf, sli4_t *sli4)
+{
+	sli4_sgl_chaining_params_t *cparams = &sli4->config.sgl_chaining_params;
+	const char *p;
+
+	ocs_ddump_section(textbuf, "sli4", 0);
+
+	ocs_ddump_value(textbuf, "sli_rev", "%d", sli4->sli_rev);
+	ocs_ddump_value(textbuf, "sli_family", "%d", sli4->sli_family);
+	ocs_ddump_value(textbuf, "if_type", "%d", sli4->if_type);
+
+	switch(sli4->asic_type) {
+	case SLI4_ASIC_TYPE_BE3:	p = "BE3"; break;
+	case SLI4_ASIC_TYPE_SKYHAWK:	p = "Skyhawk"; break;
+	case SLI4_ASIC_TYPE_LANCER:	p = "Lancer"; break;
+	case SLI4_ASIC_TYPE_LANCERG6:	p = "LancerG6"; break;
+	default:			p = "unknown"; break;
+	}
+	ocs_ddump_value(textbuf, "asic_type", "%s", p);
+
+	switch(sli4->asic_rev) {
+	case SLI4_ASIC_REV_FPGA:	p = "fpga"; break;
+	case SLI4_ASIC_REV_A0:		p = "A0"; break;
+	case SLI4_ASIC_REV_A1:		p = "A1"; break;
+	case SLI4_ASIC_REV_A2:		p = "A2"; break;
+	case SLI4_ASIC_REV_A3:		p = "A3"; break;
+	case SLI4_ASIC_REV_B0:		p = "B0"; break;
+	case SLI4_ASIC_REV_C0:		p = "C0"; break;
+	case SLI4_ASIC_REV_D0:		p = "D0"; break;
+	default:			p = "unknown"; break;
+	}
+	ocs_ddump_value(textbuf, "asic_rev", "%s", p);
+
+	ocs_ddump_value(textbuf, "e_d_tov", "%d", sli4->config.e_d_tov);
+	ocs_ddump_value(textbuf, "r_a_tov", "%d", sli4->config.r_a_tov);
+	ocs_ddump_value(textbuf, "link_module_type", "%d", sli4->config.link_module_type);
+	ocs_ddump_value(textbuf, "rq_batch", "%d", sli4->config.rq_batch);
+	ocs_ddump_value(textbuf, "topology", "%d", sli4->config.topology);
+	ocs_ddump_value(textbuf, "wwpn", "%02x%02x%02x%02x%02x%02x%02x%02x",
+			 sli4->config.wwpn[0],
+			 sli4->config.wwpn[1],
+			 sli4->config.wwpn[2],
+			 sli4->config.wwpn[3],
+			 sli4->config.wwpn[4],
+			 sli4->config.wwpn[5],
+			 sli4->config.wwpn[6],
+			 sli4->config.wwpn[7]);
+	ocs_ddump_value(textbuf, "wwnn", "%02x%02x%02x%02x%02x%02x%02x%02x",
+			 sli4->config.wwnn[0],
+			 sli4->config.wwnn[1],
+			 sli4->config.wwnn[2],
+			 sli4->config.wwnn[3],
+			 sli4->config.wwnn[4],
+			 sli4->config.wwnn[5],
+			 sli4->config.wwnn[6],
+			 sli4->config.wwnn[7]);
+	ocs_ddump_value(textbuf, "fw_rev0", "%d", sli4->config.fw_rev[0]);
+	ocs_ddump_value(textbuf, "fw_rev1", "%d", sli4->config.fw_rev[1]);
+	ocs_ddump_value(textbuf, "fw_name0", "%s", (char*)sli4->config.fw_name[0]);
+	ocs_ddump_value(textbuf, "fw_name1", "%s", (char*)sli4->config.fw_name[1]);
+	ocs_ddump_value(textbuf, "hw_rev0", "%x", sli4->config.hw_rev[0]);
+	ocs_ddump_value(textbuf, "hw_rev1", "%x", sli4->config.hw_rev[1]);
+	ocs_ddump_value(textbuf, "hw_rev2", "%x", sli4->config.hw_rev[2]);
+	ocs_ddump_value(textbuf, "sge_supported_length", "%x", sli4->config.sge_supported_length);
+	ocs_ddump_value(textbuf, "sgl_page_sizes", "%x", sli4->config.sgl_page_sizes);
+	ocs_ddump_value(textbuf, "max_sgl_pages", "%x", sli4->config.max_sgl_pages);
+	ocs_ddump_value(textbuf, "high_login_mode", "%x", sli4->config.high_login_mode);
+	ocs_ddump_value(textbuf, "sgl_pre_registered", "%x", sli4->config.sgl_pre_registered);
+	ocs_ddump_value(textbuf, "sgl_pre_registration_required", "%x", sli4->config.sgl_pre_registration_required);
+
+	ocs_ddump_value(textbuf, "sgl_chaining_capable", "%x", cparams->chaining_capable);
+	ocs_ddump_value(textbuf, "frag_num_field_offset", "%x", cparams->frag_num_field_offset);
+	ocs_ddump_value(textbuf, "frag_num_field_mask", "%016llx", (unsigned long long)cparams->frag_num_field_mask);
+	ocs_ddump_value(textbuf, "sgl_index_field_offset", "%x", cparams->sgl_index_field_offset);
+	ocs_ddump_value(textbuf, "sgl_index_field_mask", "%016llx", (unsigned long long)cparams->sgl_index_field_mask);
+	ocs_ddump_value(textbuf, "chain_sge_initial_value_lo", "%x", cparams->chain_sge_initial_value_lo);
+	ocs_ddump_value(textbuf, "chain_sge_initial_value_hi", "%x", cparams->chain_sge_initial_value_hi);
+
+	ocs_ddump_value(textbuf, "max_vfi", "%d", sli_get_max_rsrc(sli4, SLI_RSRC_FCOE_VFI));
+	ocs_ddump_value(textbuf, "max_vpi", "%d", sli_get_max_rsrc(sli4, SLI_RSRC_FCOE_VPI));
+	ocs_ddump_value(textbuf, "max_rpi", "%d", sli_get_max_rsrc(sli4, SLI_RSRC_FCOE_RPI));
+	ocs_ddump_value(textbuf, "max_xri", "%d", sli_get_max_rsrc(sli4, SLI_RSRC_FCOE_XRI));
+	ocs_ddump_value(textbuf, "max_fcfi", "%d", sli_get_max_rsrc(sli4, SLI_RSRC_FCOE_FCFI));
+
+	ocs_ddump_sli_q_fields(textbuf, sli4, SLI_QTYPE_EQ);
+	ocs_ddump_sli_q_fields(textbuf, sli4, SLI_QTYPE_CQ);
+	ocs_ddump_sli_q_fields(textbuf, sli4, SLI_QTYPE_MQ);
+	ocs_ddump_sli_q_fields(textbuf, sli4, SLI_QTYPE_WQ);
+	ocs_ddump_sli_q_fields(textbuf, sli4, SLI_QTYPE_RQ);
+
+	ocs_ddump_endsection(textbuf, "sli4", 0);
+}
+
+
+/**
+ * @brief Dump HW IO
+ *
+ * Dump HW IO
+ *
+ * @param textbuf pointer to text buffer
+ * @param io pointer to HW IO object
+ *
+ * @return none
+ */
+
+static void
+ocs_ddump_hw_io(ocs_textbuf_t *textbuf, ocs_hw_io_t *io)
+{
+	ocs_assert(io);
+
+	ocs_ddump_section(textbuf, "hw_io", io->indicator);
+
+	ocs_ddump_value(textbuf, "state", "%d", io->state);
+	ocs_ddump_value(textbuf, "xri", "0x%x", io->indicator);
+	ocs_ddump_value(textbuf, "tag", "0x%x", io->reqtag);
+	ocs_ddump_value(textbuf, "abort_reqtag", "0x%x", io->abort_reqtag);
+	ocs_ddump_value(textbuf, "ref_count", "%d", ocs_ref_read_count(&io->ref));
+
+	/* just to make it obvious, display abort bit from tag */
+	ocs_ddump_value(textbuf, "abort", "0x%x", io->abort_in_progress);
+	ocs_ddump_value(textbuf, "wq_index", "%d", (io->wq == NULL ? 0xffff : io->wq->instance));
+	ocs_ddump_value(textbuf, "type", "%d", io->type);
+	ocs_ddump_value(textbuf, "xbusy", "%d", io->xbusy);
+	ocs_ddump_value(textbuf, "active_wqe_link", "%d", ocs_list_on_list(&io->wqe_link));
+	ocs_ddump_value(textbuf, "def_sgl_count", "%d", io->def_sgl_count);
+	ocs_ddump_value(textbuf, "n_sge", "%d", io->n_sge);
+	ocs_ddump_value(textbuf, "has_ovfl_sgl", "%s", (io->ovfl_sgl != NULL ? "TRUE" : "FALSE"));
+	ocs_ddump_value(textbuf, "has_ovfl_io", "%s", (io->ovfl_io != NULL ? "TRUE" : "FALSE"));
+
+	ocs_ddump_endsection(textbuf, "hw_io", io->indicator);
+}
+
+#if defined(OCS_DEBUG_QUEUE_HISTORY)
+
+/**
+ * @brief Generate queue history ddump
+ *
+ * @param textbuf pointer to text buffer
+ * @param q_hist Pointer to queue history object.
+ */
+static void
+ocs_ddump_queue_history(ocs_textbuf_t *textbuf, ocs_hw_q_hist_t *q_hist)
+{
+	uint32_t x;
+
+	ocs_ddump_section(textbuf, "q_hist", 0);
+	ocs_ddump_value(textbuf, "count", "%ld", OCS_Q_HIST_SIZE);
+	ocs_ddump_value(textbuf, "index", "%d", q_hist->q_hist_index);
+
+	if (q_hist->q_hist == NULL) {
+		ocs_ddump_section(textbuf, "history", 0);
+		ocs_textbuf_printf(textbuf, "No history available\n");
+		ocs_ddump_endsection(textbuf, "history", 0);
+		ocs_ddump_endsection(textbuf, "q_hist", 0);
+		return;
+	}
+
+	/* start from last entry and go backwards */
+	ocs_textbuf_printf(textbuf, "<history>\n");
+	ocs_textbuf_printf(textbuf, "(newest first):\n");
+
+	ocs_lock(&q_hist->q_hist_lock);
+	x = ocs_queue_history_prev_index(q_hist->q_hist_index);
+	do {
+		int i;
+		ocs_q_hist_ftr_t ftr;
+		uint32_t mask;
+
+
+		/* footer's mask indicates what words were captured */
+		ftr.word = q_hist->q_hist[x];
+		mask = ftr.s.mask;
+		i = 0;
+
+		/* if we've encountered a mask of 0, must be done */
+		if (mask == 0) {
+			break;
+		}
+
+		/* display entry type */
+		ocs_textbuf_printf(textbuf, "%s:\n",
+				   ocs_queue_history_type_name(ftr.s.type));
+
+		if (ocs_queue_history_timestamp_enabled()) {
+			uint64_t tsc_value;
+			x = ocs_queue_history_prev_index(x);
+			tsc_value = ((q_hist->q_hist[x]) & 0x00000000FFFFFFFFull);
+			x = ocs_queue_history_prev_index(x);
+			tsc_value |= (((uint64_t)q_hist->q_hist[x] << 32) & 0xFFFFFFFF00000000ull);
+			ocs_textbuf_printf(textbuf, " t: %" PRIu64 "\n", tsc_value);
+		}
+
+		if (ocs_queue_history_q_info_enabled()) {
+			if (ftr.s.type == OCS_Q_HIST_TYPE_CWQE ||
+			    ftr.s.type == OCS_Q_HIST_TYPE_CXABT ||
+			    ftr.s.type == OCS_Q_HIST_TYPE_WQE) {
+				x = ocs_queue_history_prev_index(x);
+				ocs_textbuf_printf(textbuf, " qid=0x%x idx=0x%x\n",
+						   ((q_hist->q_hist[x] >> 16) & 0xFFFF),
+						   ((q_hist->q_hist[x] >> 0) & 0xFFFF));
+			}
+		}
+
+		while (mask) {
+			if ((mask & 1) && (x != q_hist->q_hist_index)){
+				/* get next word */
+				x = ocs_queue_history_prev_index(x);
+				ocs_textbuf_printf(textbuf, " [%d]=%x\n",
+						   i, q_hist->q_hist[x]);
+			}
+			mask = (mask >> 1UL);
+			i++;
+		}
+
+		/* go backwards to next element */
+		x = ocs_queue_history_prev_index(x);
+	} while (x != ocs_queue_history_prev_index(q_hist->q_hist_index));
+	ocs_unlock(&q_hist->q_hist_lock);
+
+	ocs_textbuf_printf(textbuf, "</history>\n");
+	ocs_ddump_endsection(textbuf, "q_hist", 0);
+}
+#endif
+
+/**
+ * @brief Generate hw ddump
+ *
+ * Generates hw ddump
+ *
+ * @param textbuf pointer to text buffer
+ * @param hw pointer HW context
+ * @param flags ddump flags
+ * @param qentries number of qentries to dump
+ *
+ * @return none
+ */
+
+static void
+ocs_ddump_hw(ocs_textbuf_t *textbuf, ocs_hw_t *hw, uint32_t flags, uint32_t qentries)
+{
+	ocs_t *ocs = hw->os;
+	uint32_t cnt = 0;
+	ocs_hw_io_t *io = NULL;
+	uint32_t i;
+	uint32_t j;
+	uint32_t max_rpi = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI);
+
+	ocs_assert(ocs);
+
+	ocs_ddump_section(textbuf, "hw", ocs->instance_index);
+
+	/* device specific information */
+	switch(hw->sli.if_type) {
+	case 0:
+		ocs_ddump_value(textbuf, "uerr_mask_hi", "%08x",
+				 sli_reg_read(&hw->sli, SLI4_REG_UERR_MASK_HI));
+		ocs_ddump_value(textbuf, "uerr_mask_lo", "%08x",
+				 sli_reg_read(&hw->sli, SLI4_REG_UERR_MASK_LO));
+		ocs_ddump_value(textbuf, "uerr_status_hi", "%08x",
+				 sli_reg_read(&hw->sli, SLI4_REG_UERR_STATUS_HI));
+		ocs_ddump_value(textbuf, "uerr_status_lo", "%08x",
+				 sli_reg_read(&hw->sli, SLI4_REG_UERR_STATUS_LO));
+		break;
+	case 2:
+		ocs_ddump_value(textbuf, "sliport_status", "%08x",
+				 sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_STATUS));
+		ocs_ddump_value(textbuf, "sliport_error1", "%08x",
+				 sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR1));
+		ocs_ddump_value(textbuf, "sliport_error2", "%08x",
+				 sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR2));
+		break;
+	}
+
+	ocs_ddump_value(textbuf, "link_status", "%d", hw->link.status);
+	ocs_ddump_value(textbuf, "link_speed", "%d", hw->link.speed);
+	ocs_ddump_value(textbuf, "link_topology", "%d", hw->link.topology);
+	ocs_ddump_value(textbuf, "state", "%d", hw->state);
+	ocs_ddump_value(textbuf, "io_alloc_failed_count", "%d", ocs_atomic_read(&hw->io_alloc_failed_count));
+	ocs_ddump_value(textbuf, "n_io", "%d", hw->config.n_io);
+
+	ocs_ddump_value(textbuf, "queue_topology", "%s", hw->config.queue_topology);
+	ocs_ddump_value(textbuf, "rq_selection_policy", "%d", hw->config.rq_selection_policy);
+	ocs_ddump_value(textbuf, "rr_quanta", "%d", hw->config.rr_quanta);
+	for (i = 0; i < ARRAY_SIZE(hw->config.filter_def); i++) {
+		ocs_ddump_value(textbuf, "filter_def", "%08X", hw->config.filter_def[i]);
+	}
+	ocs_ddump_value(textbuf, "n_eq", "%d", hw->eq_count);
+	ocs_ddump_value(textbuf, "n_cq", "%d", hw->cq_count);
+	ocs_ddump_value(textbuf, "n_mq", "%d", hw->mq_count);
+	ocs_ddump_value(textbuf, "n_rq", "%d", hw->rq_count);
+	ocs_ddump_value(textbuf, "n_wq", "%d", hw->wq_count);
+	ocs_ddump_value(textbuf, "n_sgl", "%d", hw->config.n_sgl);
+
+	ocs_ddump_sli(textbuf, &hw->sli);
+
+	ocs_ddump_sli4_queue(textbuf, "wq", hw, hw->wq, hw->wq_count,
+			((flags & OCS_DDUMP_FLAGS_WQES) ? qentries : 0));
+	ocs_ddump_sli4_queue(textbuf, "rq", hw, hw->rq, hw->rq_count,
+			((flags & OCS_DDUMP_FLAGS_RQES) ? qentries : 0));
+	ocs_ddump_sli4_queue(textbuf, "mq", hw, hw->mq, hw->mq_count,
+			((flags & OCS_DDUMP_FLAGS_MQES) ? qentries : 0));
+	ocs_ddump_sli4_queue(textbuf, "cq", hw, hw->cq, hw->cq_count,
+			((flags & OCS_DDUMP_FLAGS_CQES) ? qentries : 0));
+	ocs_ddump_sli4_queue(textbuf, "eq", hw, hw->eq, hw->eq_count,
+			((flags & OCS_DDUMP_FLAGS_EQES) ? qentries : 0));
+
+	/* dump the IO quarantine list */
+	for (i = 0; i < hw->wq_count; i++) {
+		ocs_ddump_section(textbuf, "io_quarantine", i);
+		ocs_ddump_value(textbuf, "quarantine_index", "%d", hw->hw_wq[i]->quarantine_info.quarantine_index);
+		for (j = 0; j < OCS_HW_QUARANTINE_QUEUE_DEPTH; j++) {
+			if (hw->hw_wq[i]->quarantine_info.quarantine_ios[j] != NULL) {
+				ocs_ddump_hw_io(textbuf, hw->hw_wq[i]->quarantine_info.quarantine_ios[j]);
+			}
+		}
+		ocs_ddump_endsection(textbuf, "io_quarantine", i);
+	}
+
+	ocs_ddump_section(textbuf, "workaround", ocs->instance_index);
+	ocs_ddump_value(textbuf, "fwrev", "%08llx", (unsigned long long)hw->workaround.fwrev);
+	ocs_ddump_endsection(textbuf, "workaround", ocs->instance_index);
+
+	ocs_lock(&hw->io_lock);
+		ocs_ddump_section(textbuf, "io_inuse", ocs->instance_index);
+		ocs_list_foreach(&hw->io_inuse, io) {
+			ocs_ddump_hw_io(textbuf, io);
+		}
+		ocs_ddump_endsection(textbuf, "io_inuse", ocs->instance_index);
+
+		ocs_ddump_section(textbuf, "io_wait_free", ocs->instance_index);
+		ocs_list_foreach(&hw->io_wait_free, io) {
+			ocs_ddump_hw_io(textbuf, io);
+		}
+		ocs_ddump_endsection(textbuf, "io_wait_free", ocs->instance_index);
+		ocs_ddump_section(textbuf, "io_free", ocs->instance_index);
+		ocs_list_foreach(&hw->io_free, io) {
+			if (io->xbusy) {
+				/* only display free ios if they're active */
+				ocs_ddump_hw_io(textbuf, io);
+			}
+			cnt++;
+		}
+		ocs_ddump_endsection(textbuf, "io_free", ocs->instance_index);
+		ocs_ddump_value(textbuf, "ios_free", "%d", cnt);
+
+	ocs_ddump_value(textbuf, "sec_hio_wait_count", "%d", hw->sec_hio_wait_count);
+	ocs_unlock(&hw->io_lock);
+
+	/* now check the IOs not in a list; i.e. sequence coalescing xris */
+	ocs_ddump_section(textbuf, "port_owned_ios", ocs->instance_index);
+	for (i = 0; i < hw->config.n_io; i++) {
+		io = hw->io[i];
+		if (!io)
+			continue;
+
+		if (ocs_hw_is_xri_port_owned(hw, io->indicator)) {
+			if (ocs_ref_read_count(&io->ref)) {
+				/* only display free ios if they're active */
+				ocs_ddump_hw_io(textbuf, io);
+			}
+		}
+	}
+	ocs_ddump_endsection(textbuf, "port_owned_ios", ocs->instance_index);
+
+	ocs_textbuf_printf(textbuf, "<rpi_ref>");
+	for (i = 0; i < max_rpi; i++) {
+		if (ocs_atomic_read(&hw->rpi_ref[i].rpi_attached) ||
+			ocs_atomic_read(&hw->rpi_ref[i].rpi_count) ) {
+			ocs_textbuf_printf(textbuf, "[%d] att=%d cnt=%d\n", i,
+				ocs_atomic_read(&hw->rpi_ref[i].rpi_attached),
+				ocs_atomic_read(&hw->rpi_ref[i].rpi_count));
+		}
+	}
+	ocs_textbuf_printf(textbuf, "</rpi_ref>");
+
+	for (i = 0; i < hw->wq_count; i++) {
+		ocs_ddump_value(textbuf, "wq_submit", "%d", hw->tcmd_wq_submit[i]);
+	}
+	for (i = 0; i < hw->wq_count; i++) {
+		ocs_ddump_value(textbuf, "wq_complete", "%d", hw->tcmd_wq_complete[i]);
+	}
+
+	hw_queue_ddump(textbuf, hw);
+
+	ocs_ddump_endsection(textbuf, "hw", ocs->instance_index);
+
+}
+
+void
+hw_queue_ddump(ocs_textbuf_t *textbuf, ocs_hw_t *hw)
+{
+	hw_eq_t *eq;
+	hw_cq_t *cq;
+	hw_q_t *q;
+	hw_mq_t *mq;
+	hw_wq_t *wq;
+	hw_rq_t *rq;
+
+	ocs_ddump_section(textbuf, "hw_queue", 0);
+	ocs_list_foreach(&hw->eq_list, eq) {
+		ocs_ddump_section(textbuf, "eq", eq->instance);
+		ocs_ddump_value(textbuf, "queue-id", "%d", eq->queue->id);
+		OCS_STAT(ocs_ddump_value(textbuf, "use_count", "%d", eq->use_count));
+		ocs_list_foreach(&eq->cq_list, cq) {
+			ocs_ddump_section(textbuf, "cq", cq->instance);
+			ocs_ddump_value(textbuf, "queue-id", "%d", cq->queue->id);
+			OCS_STAT(ocs_ddump_value(textbuf, "use_count", "%d", cq->use_count));
+			ocs_list_foreach(&cq->q_list, q) {
+				switch(q->type) {
+				case SLI_QTYPE_MQ:
+					mq = (hw_mq_t *) q;
+					ocs_ddump_section(textbuf, "mq", mq->instance);
+					ocs_ddump_value(textbuf, "queue-id", "%d", mq->queue->id);
+					OCS_STAT(ocs_ddump_value(textbuf, "use_count", "%d", mq->use_count));
+					ocs_ddump_endsection(textbuf, "mq", mq->instance);
+					break;
+				case SLI_QTYPE_WQ:
+					wq = (hw_wq_t *) q;
+					ocs_ddump_section(textbuf, "wq", wq->instance);
+					ocs_ddump_value(textbuf, "queue-id", "%d", wq->queue->id);
+					OCS_STAT(ocs_ddump_value(textbuf, "use_count", "%d", wq->use_count));
+					ocs_ddump_value(textbuf, "wqec_count", "%d", wq->wqec_count);
+					ocs_ddump_value(textbuf, "free_count", "%d", wq->free_count);
+					OCS_STAT(ocs_ddump_value(textbuf, "wq_pending_count", "%d",
+								 wq->wq_pending_count));
+					ocs_ddump_endsection(textbuf, "wq", wq->instance);
+					break;
+				case SLI_QTYPE_RQ:
+					rq = (hw_rq_t *) q;
+					ocs_ddump_section(textbuf, "rq", rq->instance);
+					OCS_STAT(ocs_ddump_value(textbuf, "use_count", "%d", rq->use_count));
+					ocs_ddump_value(textbuf, "filter_mask", "%d", rq->filter_mask);
+					if (rq->hdr != NULL) {
+						ocs_ddump_value(textbuf, "hdr-id", "%d", rq->hdr->id);
+						OCS_STAT(ocs_ddump_value(textbuf, "hdr_use_count", "%d", rq->hdr_use_count));
+					}
+					if (rq->first_burst != NULL) {
+						OCS_STAT(ocs_ddump_value(textbuf, "fb-id", "%d", rq->first_burst->id));
+						OCS_STAT(ocs_ddump_value(textbuf, "fb_use_count", "%d", rq->fb_use_count));
+					}
+					if (rq->data != NULL) {
+						OCS_STAT(ocs_ddump_value(textbuf, "payload-id", "%d", rq->data->id));
+						OCS_STAT(ocs_ddump_value(textbuf, "payload_use_count", "%d", rq->payload_use_count));
+					}
+					ocs_ddump_endsection(textbuf, "rq", rq->instance);
+					break;
+				default:
+					break;
+				}
+			}
+			ocs_ddump_endsection(textbuf, "cq", cq->instance);
+		}
+		ocs_ddump_endsection(textbuf, "eq", eq->instance);
+	}
+	ocs_ddump_endsection(textbuf, "hw_queue", 0);
+}
+
+/**
+ * @brief Initiate ddump
+ *
+ * Traverses the ocs/domain/port/node/io data structures to generate a driver
+ * dump.
+ *
+ * @param ocs pointer to device context
+ * @param textbuf pointer to text buffer
+ * @param flags ddump flags
+ * @param qentries number of queue entries to dump
+ *
+ * @return Returns 0 on success, or a negative value on failure.
+ */
+
+int
+ocs_ddump(ocs_t *ocs, ocs_textbuf_t *textbuf, uint32_t flags, uint32_t qentries)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_domain_t *domain;
+	uint32_t instance;
+	ocs_vport_spec_t *vport;
+	ocs_io_t *io;
+	int retval = 0;
+	uint32_t i;
+
+	ocs_ddump_startfile(textbuf);
+
+	ocs_ddump_section(textbuf, "ocs", ocs->instance_index);
+
+	ocs_ddump_section(textbuf, "ocs_os", ocs->instance_index);
+#ifdef OCS_ENABLE_NUMA_SUPPORT
+	ocs_ddump_value(textbuf, "numa_node", "%d", ocs->ocs_os.numa_node);
+#endif
+	ocs_ddump_endsection(textbuf, "ocs_os", ocs->instance_index);
+
+	ocs_ddump_value(textbuf, "drv_name", "%s", DRV_NAME);
+	ocs_ddump_value(textbuf, "drv_version", "%s", DRV_VERSION);
+	ocs_ddump_value(textbuf, "display_name", "%s", ocs->display_name);
+	ocs_ddump_value(textbuf, "enable_ini", "%d", ocs->enable_ini);
+	ocs_ddump_value(textbuf, "enable_tgt", "%d", ocs->enable_tgt);
+	ocs_ddump_value(textbuf, "nodes_count", "%d", xport->nodes_count);
+	ocs_ddump_value(textbuf, "enable_hlm", "%d", ocs->enable_hlm);
+	ocs_ddump_value(textbuf, "hlm_group_size", "%d", ocs->hlm_group_size);
+	ocs_ddump_value(textbuf, "auto_xfer_rdy_size", "%d", ocs->auto_xfer_rdy_size);
+	ocs_ddump_value(textbuf, "io_alloc_failed_count", "%d", ocs_atomic_read(&xport->io_alloc_failed_count));
+	ocs_ddump_value(textbuf, "io_active_count", "%d", ocs_atomic_read(&xport->io_active_count));
+	ocs_ddump_value(textbuf, "io_pending_count", "%d", ocs_atomic_read(&xport->io_pending_count));
+	ocs_ddump_value(textbuf, "io_total_alloc", "%d", ocs_atomic_read(&xport->io_total_alloc));
+	ocs_ddump_value(textbuf, "io_total_free", "%d", ocs_atomic_read(&xport->io_total_free));
+	ocs_ddump_value(textbuf, "io_total_pending", "%d", ocs_atomic_read(&xport->io_total_pending));
+	ocs_ddump_value(textbuf, "io_pending_recursing", "%d", ocs_atomic_read(&xport->io_pending_recursing));
+	ocs_ddump_value(textbuf, "max_isr_time_msec", "%d", ocs->max_isr_time_msec);
+	for (i = 0; i < SLI4_MAX_FCFI; i++) {
+		ocs_lock(&xport->fcfi[i].pend_frames_lock);
+		if (!ocs_list_empty(&xport->fcfi[i].pend_frames)) {
+			ocs_hw_sequence_t *frame;
+			ocs_ddump_section(textbuf, "pending_frames", i);
+			ocs_ddump_value(textbuf, "hold_frames", "%d", xport->fcfi[i].hold_frames);
+			ocs_list_foreach(&xport->fcfi[i].pend_frames, frame) {
+				fc_header_t *hdr;
+				char buf[128];
+
+				hdr = frame->header->dma.virt;
+				ocs_snprintf(buf, sizeof(buf), "%02x/%04x/%04x len %zu",
+				 hdr->r_ctl, ocs_be16toh(hdr->ox_id), ocs_be16toh(hdr->rx_id),
+				 frame->payload->dma.len);
+				ocs_ddump_value(textbuf, "frame", "%s", buf);
+			}
+			ocs_ddump_endsection(textbuf, "pending_frames", i);
+		}
+		ocs_unlock(&xport->fcfi[i].pend_frames_lock);
+	}
+
+	ocs_lock(&xport->io_pending_lock);
+		ocs_ddump_section(textbuf, "io_pending_list", ocs->instance_index);
+		ocs_list_foreach(&xport->io_pending_list, io) {
+			ocs_ddump_io(textbuf, io);
+		}
+		ocs_ddump_endsection(textbuf, "io_pending_list", ocs->instance_index);
+	ocs_unlock(&xport->io_pending_lock);
+
+#if defined(ENABLE_LOCK_DEBUG)
+	/* Dump the lock list */
+	ocs_ddump_section(textbuf, "locks", 0);
+	ocs_lock(&ocs->ocs_os.locklist_lock); {
+		ocs_lock_t *l;
+		uint32_t idx = 0;
+		ocs_list_foreach(&ocs->ocs_os.locklist, l) {
+			ocs_ddump_section(textbuf, "lock", idx);
+			ocs_ddump_value(textbuf, "name", "%s", l->name);
+			ocs_ddump_value(textbuf, "inuse", "%d", l->inuse);
+			ocs_ddump_value(textbuf, "caller", "%p", l->caller[0]);
+			ocs_ddump_value(textbuf, "pid", "%08x", l->pid.l);
+			ocs_ddump_endsection(textbuf, "lock", idx);
+			idx++;
+		}
+	} ocs_unlock(&ocs->ocs_os.locklist_lock);
+	ocs_ddump_endsection(textbuf, "locks", 0);
+#endif
+
+	/* Dump any pending vports */
+	if (ocs_device_lock_try(ocs) != TRUE) {
+		/* Didn't get the lock */
+		return -1;
+	}
+		instance = 0;
+		ocs_list_foreach(&xport->vport_list, vport) {
+			ocs_ddump_section(textbuf, "vport_spec", instance);
+			ocs_ddump_value(textbuf, "domain_instance", "%d", vport->domain_instance);
+			ocs_ddump_value(textbuf, "wwnn", "%llx", (unsigned long long)vport->wwnn);
+			ocs_ddump_value(textbuf, "wwpn", "%llx", (unsigned long long)vport->wwpn);
+			ocs_ddump_value(textbuf, "fc_id", "0x%x", vport->fc_id);
+			ocs_ddump_value(textbuf, "enable_tgt", "%d", vport->enable_tgt);
+			ocs_ddump_value(textbuf, "enable_ini", "%d" PRIx64, vport->enable_ini);
+			ocs_ddump_endsection(textbuf, "vport_spec", instance ++);
+		}
+	ocs_device_unlock(ocs);
+
+	/* Dump target and initiator private data */
+	ocs_scsi_ini_ddump(textbuf, OCS_SCSI_DDUMP_DEVICE, ocs);
+	ocs_scsi_tgt_ddump(textbuf, OCS_SCSI_DDUMP_DEVICE, ocs);
+
+	ocs_ddump_hw(textbuf, &ocs->hw, flags, qentries);
+
+	if (ocs_device_lock_try(ocs) != TRUE) {
+		/* Didn't get the lock */
+		return -1;
+	}
+		/* Here the device lock is held */
+		ocs_list_foreach(&ocs->domain_list, domain) {
+			retval = ocs_ddump_domain(textbuf, domain);
+			if (retval != 0) {
+				break;
+			}
+		}
+
+		/* Dump ramlog */
+		ocs_ddump_ramlog(textbuf, ocs->ramlog);
+	ocs_device_unlock(ocs);
+
+#if !defined(OCS_DEBUG_QUEUE_HISTORY)
+	ocs_ddump_section(textbuf, "q_hist", ocs->instance_index);
+	ocs_textbuf_printf(textbuf, "<history>\n");
+	ocs_textbuf_printf(textbuf, "No history available\n");
+	ocs_textbuf_printf(textbuf, "</history>\n");
+	ocs_ddump_endsection(textbuf, "q_hist", ocs->instance_index);
+#else
+	ocs_ddump_queue_history(textbuf, &ocs->hw.q_hist);
+#endif
+
+#if defined(OCS_DEBUG_MEMORY)
+	ocs_memory_allocated_ddump(textbuf);
+#endif
+
+	ocs_ddump_endsection(textbuf, "ocs", ocs->instance_index);
+
+	ocs_ddump_endfile(textbuf);
+
+	return retval;
+}
+
+/**
+ * @brief Capture and save ddump
+ *
+ * Captures and saves a ddump to the ocs_t structure to save the
+ * current state. The goal of this function is to save a ddump
+ * as soon as an issue is encountered. The saved ddump will be
+ * kept until the user reads it.
+ *
+ * @param ocs pointer to device context
+ * @param flags ddump flags
+ * @param qentries number of queue entries to dump
+ *
+ * @return 0 if ddump was saved; > 0 of one already exists; < 0
+ * error
+ */
+
+int32_t
+ocs_save_ddump(ocs_t *ocs, uint32_t flags, uint32_t qentries)
+{
+	if (ocs_textbuf_get_written(&ocs->ddump_saved) > 0) {
+		ocs_log_debug(ocs, "Saved ddump already exists\n");
+		return 1;
+	}
+
+	if (!ocs_textbuf_initialized(&ocs->ddump_saved)) {
+		ocs_log_err(ocs, "Saved ddump not allocated\n");
+		return -1;
+	}
+
+	ocs_log_debug(ocs, "Saving ddump\n");
+	ocs_ddump(ocs, &ocs->ddump_saved, flags, qentries);
+	ocs_log_debug(ocs, "Saved ddump: %d bytes written\n", ocs_textbuf_get_written(&ocs->ddump_saved));
+	return 0;
+}
+
+/**
+ * @brief Capture and save ddump for all OCS instances
+ *
+ * Calls ocs_save_ddump() for each OCS instance.
+ *
+ * @param flags ddump flags
+ * @param qentries number of queue entries to dump
+ * @param alloc_flag allocate dump buffer if not already allocated
+ *
+ * @return 0 if ddump was saved; > 0 of one already exists; < 0
+ * error
+ */
+
+int32_t
+ocs_save_ddump_all(uint32_t flags, uint32_t qentries, uint32_t alloc_flag)
+{
+	ocs_t *ocs;
+	uint32_t i;
+	int32_t rc = 0;
+
+	for (i = 0; (ocs = ocs_get_instance(i)) != NULL; i++) {
+		if (alloc_flag && (!ocs_textbuf_initialized(&ocs->ddump_saved))) {
+			rc = ocs_textbuf_alloc(ocs, &ocs->ddump_saved, DEFAULT_SAVED_DUMP_SIZE);
+			if (rc) {
+				break;
+			}
+		}
+
+		rc = ocs_save_ddump(ocs, flags, qentries);
+		if (rc < 0) {
+			break;
+		}
+	}
+	return rc;
+}
+
+/**
+ * @brief Clear saved ddump
+ *
+ * Clears saved ddump to make room for next one.
+ *
+ * @param ocs pointer to device context
+ *
+ * @return 0 if ddump was cleared; > 0 no saved ddump found
+ */
+
+int32_t
+ocs_clear_saved_ddump(ocs_t *ocs)
+{
+	/* if there's a saved ddump, copy to newly allocated textbuf */
+	if (ocs_textbuf_get_written(&ocs->ddump_saved)) {
+		ocs_log_debug(ocs, "saved ddump cleared\n");
+		ocs_textbuf_reset(&ocs->ddump_saved);
+		return 0;
+	} else {
+		ocs_log_debug(ocs, "no saved ddump found\n");
+		return 1;
+	}
+}
+
diff --git a/sys/dev/ocs_fc/ocs_ddump.h b/sys/dev/ocs_fc/ocs_ddump.h
new file mode 100644
index 000000000000..253a58b18f51
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_ddump.h
@@ -0,0 +1,60 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#if !defined(__OCS_DDUMP_H__)
+#define __OCS_DDUMP_H__
+
+#include "ocs_utils.h"
+
+#define OCS_DDUMP_FLAGS_WQES	(1U << 0)
+#define OCS_DDUMP_FLAGS_CQES	(1U << 1)
+#define OCS_DDUMP_FLAGS_MQES	(1U << 2)
+#define OCS_DDUMP_FLAGS_RQES	(1U << 3)
+#define OCS_DDUMP_FLAGS_EQES	(1U << 4)
+
+extern int ocs_ddump(ocs_t *ocs, ocs_textbuf_t *textbuf, uint32_t flags, uint32_t qentries);
+
+extern void ocs_ddump_startfile(ocs_textbuf_t *textbuf);
+extern void ocs_ddump_endfile(ocs_textbuf_t *textbuf);
+extern void ocs_ddump_section(ocs_textbuf_t *textbuf, const char *name, uint32_t instance);
+extern void ocs_ddump_endsection(ocs_textbuf_t *textbuf, const char *name, uint32_t instance);
+__attribute__((format(printf,3,4)))
+extern void ocs_ddump_value(ocs_textbuf_t *textbuf, const char *name, const char *fmt, ...);
+extern void ocs_ddump_buffer(ocs_textbuf_t *textbuf, const char *name, uint32_t instance, void *buffer, uint32_t size);
+extern int32_t ocs_save_ddump(ocs_t *ocs, uint32_t flags, uint32_t qentries);
+extern int32_t ocs_get_saved_ddump(ocs_t *ocs, ocs_textbuf_t *textbuf);
+extern int32_t ocs_save_ddump_all(uint32_t flags, uint32_t qentries, uint32_t alloc_flag);
+extern int32_t ocs_clear_saved_ddump(ocs_t *ocs);
+extern void ocs_ddump_queue_entries(ocs_textbuf_t *textbuf, void *q_addr, uint32_t size, uint32_t length, int32_t index, uint32_t qentries);
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_device.c b/sys/dev/ocs_fc/ocs_device.c
new file mode 100644
index 000000000000..a157ba801d22
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_device.c
@@ -0,0 +1,1929 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Implement remote device state machine for target and initiator.
+ */
+
+/*!
+@defgroup device_sm Node State Machine: Remote Device States
+*/
+
+#include "ocs.h"
+#include "ocs_device.h"
+#include "ocs_fabric.h"
+#include "ocs_els.h"
+
+static void *__ocs_d_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+static void *__ocs_d_wait_del_node(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+static void *__ocs_d_wait_del_ini_tgt(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+static int32_t ocs_process_abts(ocs_io_t *io, fc_header_t *hdr);
+
+/**
+ * @ingroup device_sm
+ * @brief Send response to PRLI.
+ *
+ * <h3 class="desc">Description</h3>
+ * For device nodes, this function sends a PRLI response.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id OX_ID of PRLI
+ *
+ * @return Returns None.
+ */
+
+void
+ocs_d_send_prli_rsp(ocs_io_t *io, uint16_t ox_id)
+{
+	ocs_t *ocs = io->ocs;
+	ocs_node_t *node = io->node;
+
+	/* If the back-end doesn't support the fc-type, we send an LS_RJT */
+	if (ocs->fc_type != node->fc_type) {
+		node_printf(node, "PRLI rejected by target-server, fc-type not supported\n");
+		ocs_send_ls_rjt(io, ox_id, FC_REASON_UNABLE_TO_PERFORM,
+				FC_EXPL_REQUEST_NOT_SUPPORTED, 0, NULL, NULL);
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+	}
+
+	/* If the back-end doesn't want to talk to this initiator, we send an LS_RJT */
+	if (node->sport->enable_tgt && (ocs_scsi_validate_initiator(node) == 0)) {
+		node_printf(node, "PRLI rejected by target-server\n");
+		ocs_send_ls_rjt(io, ox_id, FC_REASON_UNABLE_TO_PERFORM,
+				FC_EXPL_NO_ADDITIONAL, 0, NULL, NULL);
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+	} else {
+		/*sm:  process PRLI payload, send PRLI acc */
+		ocs_send_prli_acc(io, ox_id, ocs->fc_type, NULL, NULL);
+
+		/* Immediately go to ready state to avoid window where we're
+		 * waiting for the PRLI LS_ACC to complete while holding FCP_CMNDs
+		 */
+		ocs_node_transition(node, __ocs_d_device_ready, NULL);
+	}
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Initiate node shutdown
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_initiate_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		int32_t rc = OCS_SCSI_CALL_COMPLETE; /* assume no wait needed */
+
+		ocs_scsi_io_alloc_disable(node);
+
+		/* make necessary delete upcall(s) */
+		if (node->init && !node->targ) {
+			ocs_log_debug(node->ocs,
+				"[%s] delete (initiator) WWPN %s WWNN %s\n",
+				node->display_name, node->wwpn, node->wwnn);
+			ocs_node_transition(node, __ocs_d_wait_del_node, NULL);
+			if (node->sport->enable_tgt) {
+				rc = ocs_scsi_del_initiator(node,
+						OCS_SCSI_INITIATOR_DELETED);
+			}
+			if (rc == OCS_SCSI_CALL_COMPLETE) {
+				ocs_node_post_event(node,
+					OCS_EVT_NODE_DEL_INI_COMPLETE, NULL);
+			}
+		} else if (node->targ && !node->init) {
+			ocs_log_debug(node->ocs,
+				"[%s] delete (target)    WWPN %s WWNN %s\n",
+				node->display_name, node->wwpn, node->wwnn);
+			ocs_node_transition(node, __ocs_d_wait_del_node, NULL);
+			if (node->sport->enable_ini) {
+				rc = ocs_scsi_del_target(node,
+						OCS_SCSI_TARGET_DELETED);
+			}
+			if (rc == OCS_SCSI_CALL_COMPLETE) {
+				ocs_node_post_event(node,
+					OCS_EVT_NODE_DEL_TGT_COMPLETE, NULL);
+			}
+		} else if (node->init && node->targ) {
+			ocs_log_debug(node->ocs,
+				"[%s] delete (initiator+target) WWPN %s WWNN %s\n",
+				node->display_name, node->wwpn, node->wwnn);
+			ocs_node_transition(node, __ocs_d_wait_del_ini_tgt, NULL);
+			if (node->sport->enable_tgt) {
+				rc = ocs_scsi_del_initiator(node,
+						OCS_SCSI_INITIATOR_DELETED);
+			}
+			if (rc == OCS_SCSI_CALL_COMPLETE) {
+				ocs_node_post_event(node,
+					OCS_EVT_NODE_DEL_INI_COMPLETE, NULL);
+			}
+			rc = OCS_SCSI_CALL_COMPLETE; /* assume no wait needed */
+			if (node->sport->enable_ini) {
+				rc = ocs_scsi_del_target(node,
+						OCS_SCSI_TARGET_DELETED);
+			}
+			if (rc == OCS_SCSI_CALL_COMPLETE) {
+				ocs_node_post_event(node,
+					OCS_EVT_NODE_DEL_TGT_COMPLETE, NULL);
+			}
+		}
+
+		/* we've initiated the upcalls as needed, now kick off the node
+		 * detach to precipitate the aborting of outstanding exchanges
+		 * associated with said node
+		 *
+		 * Beware: if we've made upcall(s), we've already transitioned
+		 * to a new state by the time we execute this.
+		 * TODO: consider doing this before the upcalls...
+		 */
+		if (node->attached) {
+			/* issue hw node free; don't care if succeeds right away
+			 * or sometime later, will check node->attached later in
+			 * shutdown process
+			 */
+			rc = ocs_hw_node_detach(&ocs->hw, &node->rnode);
+			if (node->rnode.free_group) {
+				ocs_remote_node_group_free(node->node_group);
+				node->node_group = NULL;
+				node->rnode.free_group = FALSE;
+			}
+			if (rc != OCS_HW_RTN_SUCCESS &&
+				rc != OCS_HW_RTN_SUCCESS_SYNC) {
+				node_printf(node,
+					"Failed freeing HW node, rc=%d\n", rc);
+			}
+		}
+
+		/* if neither initiator nor target, proceed to cleanup */
+		if (!node->init && !node->targ){
+			/*
+			 * node has either been detached or is in the process
+			 * of being detached, call common node's initiate
+			 * cleanup function.
+			 */
+			ocs_node_initiate_cleanup(node);
+		}
+		break;
+	}
+	case OCS_EVT_ALL_CHILD_NODES_FREE:
+		/* Ignore, this can happen if an ELS is aborted,
+		 * while in a delay/retry state */
+		break;
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Common device event handler.
+ *
+ * <h3 class="desc">Description</h3>
+ * For device nodes, this event handler manages default and common events.
+ *
+ * @param funcname Function name text.
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+static void *
+__ocs_d_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_t *node = NULL;
+	ocs_t *ocs = NULL;
+	ocs_assert(ctx, NULL);
+	node = ctx->app;
+	ocs_assert(node, NULL);
+	ocs = node->ocs;
+	ocs_assert(ocs, NULL);
+
+	switch(evt) {
+
+	/* Handle shutdown events */
+	case OCS_EVT_SHUTDOWN:
+		ocs_log_debug(ocs, "[%s] %-20s %-20s\n", node->display_name, funcname, ocs_sm_event_name(evt));
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+		break;
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+		ocs_log_debug(ocs, "[%s] %-20s %-20s\n", node->display_name, funcname, ocs_sm_event_name(evt));
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_EXPLICIT_LOGO;
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+		break;
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		ocs_log_debug(ocs, "[%s] %-20s %-20s\n", node->display_name, funcname, ocs_sm_event_name(evt));
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_IMPLICIT_LOGO;
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+		break;
+
+	default:
+		/* call default event handler common to all nodes */
+		__ocs_node_common(funcname, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for a domain-attach completion in loop topology.
+ *
+ * <h3 class="desc">Description</h3>
+ * State waits for a domain-attached completion while in loop topology.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_loop(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_DOMAIN_ATTACH_OK: {
+		/* send PLOGI automatically if initiator */
+		ocs_node_init_device(node, TRUE);
+		break;
+	}
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+
+
+
+/**
+ * @ingroup device_sm
+ * @brief state: wait for node resume event
+ *
+ * State is entered when a node is in I+T mode and sends a delete initiator/target
+ * call to the target-server/initiator-client and needs to wait for that work to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg per event optional argument
+ *
+ * @return returns NULL
+ */
+
+void *
+__ocs_d_wait_del_ini_tgt(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		/* Fall through */
+
+	case OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
+	case OCS_EVT_ALL_CHILD_NODES_FREE:
+		/* These are expected events. */
+		break;
+
+	case OCS_EVT_NODE_DEL_INI_COMPLETE:
+	case OCS_EVT_NODE_DEL_TGT_COMPLETE:
+		ocs_node_transition(node, __ocs_d_wait_del_node, NULL);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+		/* Can happen as ELS IO IO's complete */
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		break;
+
+	/* ignore shutdown events as we're already in shutdown path */
+	case OCS_EVT_SHUTDOWN:
+		/* have default shutdown event take precedence */
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		/* fall through */
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		break;
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		/* don't care about domain_attach_ok */
+		break;
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+
+/**
+ * @ingroup device_sm
+ * @brief state: Wait for node resume event.
+ *
+ * State is entered when a node sends a delete initiator/target call to the
+ * target-server/initiator-client and needs to wait for that work to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_del_node(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		/* Fall through */
+
+	case OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
+	case OCS_EVT_ALL_CHILD_NODES_FREE:
+		/* These are expected events. */
+		break;
+
+	case OCS_EVT_NODE_DEL_INI_COMPLETE:
+	case OCS_EVT_NODE_DEL_TGT_COMPLETE:
+		/*
+		 * node has either been detached or is in the process of being detached,
+		 * call common node's initiate cleanup function
+		 */
+		ocs_node_initiate_cleanup(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+		/* Can happen as ELS IO IO's complete */
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		break;
+
+	/* ignore shutdown events as we're already in shutdown path */
+	case OCS_EVT_SHUTDOWN:
+		/* have default shutdown event take precedence */
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		/* fall through */
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		break;
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		/* don't care about domain_attach_ok */
+		break;
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+
+
+/**
+ * @brief Save the OX_ID for sending LS_ACC sometime later.
+ *
+ * <h3 class="desc">Description</h3>
+ * When deferring the response to an ELS request, the OX_ID of the request
+ * is saved using this function.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param hdr Pointer to the FC header.
+ * @param ls Defines the type of ELS to send: LS_ACC, LS_ACC for PLOGI;
+ * or LSS_ACC for PRLI.
+ *
+ * @return None.
+ */
+
+void
+ocs_send_ls_acc_after_attach(ocs_io_t *io, fc_header_t *hdr, ocs_node_send_ls_acc_e ls)
+{
+	ocs_node_t *node = io->node;
+	uint16_t ox_id = ocs_be16toh(hdr->ox_id);
+
+	ocs_assert(node->send_ls_acc == OCS_NODE_SEND_LS_ACC_NONE);
+
+	node->ls_acc_oxid = ox_id;
+	node->send_ls_acc = ls;
+	node->ls_acc_io = io;
+	node->ls_acc_did = fc_be24toh(hdr->d_id);
+}
+
+/**
+ * @brief Process the PRLI payload.
+ *
+ * <h3 class="desc">Description</h3>
+ * The PRLI payload is processed; the initiator/target capabilities of the
+ * remote node are extracted and saved in the node object.
+ *
+ * @param node Pointer to the node object.
+ * @param prli Pointer to the PRLI payload.
+ *
+ * @return None.
+ */
+
+void
+ocs_process_prli_payload(ocs_node_t *node, fc_prli_payload_t *prli)
+{
+	node->init = (ocs_be16toh(prli->service_params) & FC_PRLI_INITIATOR_FUNCTION) != 0;
+	node->targ = (ocs_be16toh(prli->service_params) & FC_PRLI_TARGET_FUNCTION) != 0;
+	node->fcp2device = (ocs_be16toh(prli->service_params) & FC_PRLI_RETRY) != 0;
+	node->fc_type = prli->type;
+}
+
+/**
+ * @brief Process the ABTS.
+ *
+ * <h3 class="desc">Description</h3>
+ * Common code to process a received ABTS. If an active IO can be found
+ * that matches the OX_ID of the ABTS request, a call is made to the
+ * backend. Otherwise, a BA_ACC is returned to the initiator.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param hdr Pointer to the FC header.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+static int32_t
+ocs_process_abts(ocs_io_t *io, fc_header_t *hdr)
+{
+	ocs_node_t *node = io->node;
+	ocs_t *ocs = node->ocs;
+	uint16_t ox_id = ocs_be16toh(hdr->ox_id);
+	uint16_t rx_id = ocs_be16toh(hdr->rx_id);
+	ocs_io_t *abortio;
+
+	abortio = ocs_io_find_tgt_io(ocs, node, ox_id, rx_id);
+
+	/* If an IO was found, attempt to take a reference on it */
+	if (abortio != NULL && (ocs_ref_get_unless_zero(&abortio->ref) != 0)) {
+
+		/* Got a reference on the IO. Hold it until backend is notified below */
+		node_printf(node, "Abort request: ox_id [%04x] rx_id [%04x]\n",
+			    ox_id, rx_id);
+
+		/*
+		 * Save the ox_id for the ABTS as the init_task_tag in our manufactured
+		 * TMF IO object
+		 */
+		io->display_name = "abts";
+		io->init_task_tag = ox_id;
+		/* don't set tgt_task_tag, don't want to confuse with XRI */
+
+		/*
+		 * Save the rx_id from the ABTS as it is needed for the BLS response,
+		 * regardless of the IO context's rx_id
+		 */
+		io->abort_rx_id = rx_id;
+
+		/* Call target server command abort */
+		io->tmf_cmd = OCS_SCSI_TMF_ABORT_TASK;
+		ocs_scsi_recv_tmf(io, abortio->tgt_io.lun, OCS_SCSI_TMF_ABORT_TASK, abortio, 0);
+
+		/*
+		 * Backend will have taken an additional reference on the IO if needed;
+		 * done with current reference.
+		 */
+		ocs_ref_put(&abortio->ref); /* ocs_ref_get(): same function */
+	} else {
+		/*
+		 * Either IO was not found or it has been freed between finding it
+		 * and attempting to get the reference,
+		 */
+		node_printf(node, "Abort request: ox_id [%04x], IO not found (exists=%d)\n",
+			    ox_id, (abortio != NULL));
+
+		/* Send a BA_ACC */
+		ocs_bls_send_acc_hdr(io, hdr);
+	}
+	return 0;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for the PLOGI accept to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_plogi_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_FAIL:
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_OK:	/* PLOGI ACC completions */
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		ocs_node_transition(node, __ocs_d_port_logged_in, NULL);
+		break;
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for the LOGO response.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_logo_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* TODO: may want to remove this; 
+		 * if we'll want to know about PLOGI */
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+		/* LOGO response received, sent shutdown */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_LOGO, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		node_printf(node, "LOGO sent (evt=%s), shutdown node\n", ocs_sm_event_name(evt));
+		/* sm: post explicit logout */
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+		break;
+
+	/* TODO: PLOGI: abort LOGO and process PLOGI? (SHUTDOWN_EXPLICIT/IMPLICIT_LOGO?) */
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for the PRLO response.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_prlo_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+		case OCS_EVT_ENTER:
+			ocs_node_hold_frames(node);
+			break;
+
+		case OCS_EVT_EXIT:
+			ocs_node_accept_frames(node);
+			break;
+
+		case OCS_EVT_SRRS_ELS_REQ_OK:
+		case OCS_EVT_SRRS_ELS_REQ_RJT:
+		case OCS_EVT_SRRS_ELS_REQ_FAIL:
+			if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PRLO, __ocs_d_common, __func__)) {
+				return NULL;
+			}
+			ocs_assert(node->els_req_cnt, NULL);
+			node->els_req_cnt--;
+			node_printf(node, "PRLO sent (evt=%s)\n", ocs_sm_event_name(evt));
+			ocs_node_transition(node, __ocs_d_port_logged_in, NULL);
+			break;
+
+		default:
+			__ocs_node_common(__func__, ctx, evt, arg);
+			return NULL;
+	}
+	return NULL;
+}
+
+
+/**
+ * @brief Initialize device node.
+ *
+ * Initialize device node. If a node is an initiator, then send a PLOGI and transition
+ * to __ocs_d_wait_plogi_rsp, otherwise transition to __ocs_d_init.
+ *
+ * @param node Pointer to the node object.
+ * @param send_plogi Boolean indicating to send PLOGI command or not.
+ *
+ * @return none
+ */
+
+void
+ocs_node_init_device(ocs_node_t *node, int send_plogi)
+{
+	node->send_plogi = send_plogi;
+	if ((node->ocs->nodedb_mask & OCS_NODEDB_PAUSE_NEW_NODES) && !FC_ADDR_IS_DOMAIN_CTRL(node->rnode.fc_id)) {
+		node->nodedb_state = __ocs_d_init;
+		ocs_node_transition(node, __ocs_node_paused, NULL);
+	} else {
+		ocs_node_transition(node, __ocs_d_init, NULL);
+	}
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Initial node state for an initiator or a target.
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered when a node is instantiated, either having been
+ * discovered from a name services query, or having received a PLOGI/FLOGI.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ * - OCS_EVT_ENTER: (uint8_t *) - 1 to send a PLOGI on
+ * entry (initiator-only); 0 indicates a PLOGI is
+ * not sent on entry (initiator-only). Not applicable for a target.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* check if we need to send PLOGI */
+		if (node->send_plogi) {
+			/* only send if we have initiator capability, and domain is attached */
+			if (node->sport->enable_ini && node->sport->domain->attached) {
+				ocs_send_plogi(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT,
+						OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+				ocs_node_transition(node, __ocs_d_wait_plogi_rsp, NULL);
+			} else {
+				node_printf(node, "not sending plogi sport.ini=%d, domain attached=%d\n",
+					    node->sport->enable_ini, node->sport->domain->attached);
+			}
+		}
+		break;
+	case OCS_EVT_PLOGI_RCVD: {
+		/* T, or I+T */
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		uint32_t d_id = fc_be24toh(hdr->d_id);
+
+		ocs_node_save_sparms(node, cbdata->payload->dma.virt);
+		ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PLOGI);
+
+		/* domain already attached */
+		if (node->sport->domain->attached) {
+			rc = ocs_node_attach(node);
+			ocs_node_transition(node, __ocs_d_wait_node_attach, NULL);
+			if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+				ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+			}
+			break;
+		}
+
+		/* domain not attached; several possibilities: */
+		switch (node->sport->topology) {
+		case OCS_SPORT_TOPOLOGY_P2P:
+			/* we're not attached and sport is p2p, need to attach */
+			ocs_domain_attach(node->sport->domain, d_id);
+			ocs_node_transition(node, __ocs_d_wait_domain_attach, NULL);
+			break;
+		case OCS_SPORT_TOPOLOGY_FABRIC:
+			/* we're not attached and sport is fabric, domain attach should have
+			 * already been requested as part of the fabric state machine, wait for it
+			 */
+			ocs_node_transition(node, __ocs_d_wait_domain_attach, NULL);
+			break;
+		case OCS_SPORT_TOPOLOGY_UNKNOWN:
+			/* Two possibilities:
+			 * 1. received a PLOGI before our FLOGI has completed (possible since
+			 *    completion comes in on another CQ), thus we don't know what we're
+			 *    connected to yet; transition to a state to wait for the fabric
+			 *    node to tell us;
+			 * 2. PLOGI received before link went down and we haven't performed
+			 *    domain attach yet.
+			 * Note: we cannot distinguish between 1. and 2. so have to assume PLOGI
+			 * was received after link back up.
+			 */
+			node_printf(node, "received PLOGI, with unknown topology did=0x%x\n", d_id);
+			ocs_node_transition(node, __ocs_d_wait_topology_notify, NULL);
+			break;
+		default:
+			node_printf(node, "received PLOGI, with unexpectd topology %d\n",
+				    node->sport->topology);
+			ocs_assert(FALSE, NULL);
+			break;
+		}
+		break;
+	}
+
+	case OCS_EVT_FDISC_RCVD: {
+		__ocs_d_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	case OCS_EVT_FLOGI_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+
+		/* this better be coming from an NPort */
+		ocs_assert(ocs_rnode_is_nport(cbdata->payload->dma.virt), NULL);
+
+		/* sm: save sparams, send FLOGI acc */
+		ocs_domain_save_sparms(node->sport->domain, cbdata->payload->dma.virt);
+
+		/* send FC LS_ACC response, override s_id */
+		ocs_fabric_set_topology(node, OCS_SPORT_TOPOLOGY_P2P);
+		ocs_send_flogi_p2p_acc(cbdata->io, ocs_be16toh(hdr->ox_id), fc_be24toh(hdr->d_id), NULL, NULL);
+		if (ocs_p2p_setup(node->sport)) {
+			node_printf(node, "p2p setup failed, shutting down node\n");
+			ocs_node_post_event(node, OCS_EVT_SHUTDOWN, NULL);
+		} else {
+			ocs_node_transition(node, __ocs_p2p_wait_flogi_acc_cmpl, NULL);
+		}
+
+		break;
+	}
+
+	case OCS_EVT_LOGO_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+
+		if (!node->sport->domain->attached) {
+			 /* most likely a frame left over from before a link down; drop and
+			  * shut node down w/ "explicit logout" so pending frames are processed */
+			node_printf(node, "%s domain not attached, dropping\n", ocs_sm_event_name(evt));
+			ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+			break;
+		}
+		ocs_send_logo_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		ocs_node_transition(node, __ocs_d_wait_logo_acc_cmpl, NULL);
+		break;
+	}
+
+	case OCS_EVT_PRLI_RCVD:
+	case OCS_EVT_PRLO_RCVD:
+	case OCS_EVT_PDISC_RCVD:
+	case OCS_EVT_ADISC_RCVD:
+	case OCS_EVT_RSCN_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		if (!node->sport->domain->attached) {
+			 /* most likely a frame left over from before a link down; drop and
+			  * shut node down w/ "explicit logout" so pending frames are processed */
+			node_printf(node, "%s domain not attached, dropping\n", ocs_sm_event_name(evt));
+			ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+			break;
+		}
+		node_printf(node, "%s received, sending reject\n", ocs_sm_event_name(evt));
+		ocs_send_ls_rjt(cbdata->io, ocs_be16toh(hdr->ox_id),
+			FC_REASON_UNABLE_TO_PERFORM, FC_EXPL_NPORT_LOGIN_REQUIRED, 0,
+			NULL, NULL);
+
+		break;
+	}
+
+	case OCS_EVT_FCP_CMD_RCVD: {
+		/* note: problem, we're now expecting an ELS REQ completion 
+		 * from both the LOGO and PLOGI */
+		if (!node->sport->domain->attached) {
+			 /* most likely a frame left over from before a link down; drop and
+			  * shut node down w/ "explicit logout" so pending frames are processed */
+			node_printf(node, "%s domain not attached, dropping\n", ocs_sm_event_name(evt));
+			ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+			break;
+		}
+
+		/* Send LOGO */
+		node_printf(node, "FCP_CMND received, send LOGO\n");
+		if (ocs_send_logo(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT, 0, NULL, NULL) == NULL) {
+			/* failed to send LOGO, go ahead and cleanup node anyways */
+			node_printf(node, "Failed to send LOGO\n");
+			ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+		} else {
+			/* sent LOGO, wait for response */
+			ocs_node_transition(node, __ocs_d_wait_logo_rsp, NULL);
+		}
+		break;
+	}
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		/* don't care about domain_attach_ok */
+		break;
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait on a response for a sent PLOGI.
+ *
+ * <h3 class="desc">Description</h3>
+ * State is entered when an initiator-capable node has sent
+ * a PLOGI and is waiting for a response.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_plogi_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_PLOGI_RCVD: {
+		/* T, or I+T */
+		/* received PLOGI with svc parms, go ahead and attach node
+		 * when PLOGI that was sent ultimately completes, it'll be a no-op
+		 */
+
+		/* TODO: there is an outstanding PLOGI sent, can we set a flag
+		 * to indicate that we don't want to retry it if it times out? */
+		ocs_node_save_sparms(node, cbdata->payload->dma.virt);
+		ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PLOGI);
+		/* sm: domain->attached / ocs_node_attach */
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_d_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+	}
+
+	case OCS_EVT_PRLI_RCVD:
+		/* I, or I+T */
+		/* sent PLOGI and before completion was seen, received the
+		 * PRLI from the remote node (WCQEs and RCQEs come in on
+		 * different queues and order of processing cannot be assumed)
+		 * Save OXID so PRLI can be sent after the attach and continue
+		 * to wait for PLOGI response
+		 */
+		ocs_process_prli_payload(node, cbdata->payload->dma.virt);
+		if (ocs->fc_type == node->fc_type) {
+			ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PRLI);
+			ocs_node_transition(node, __ocs_d_wait_plogi_rsp_recvd_prli, NULL);
+		} else {
+			/* TODO this need to be looked at. What do we do here ? */
+		}
+		break;
+
+	/* TODO this need to be looked at. we could very well be logged in */
+	case OCS_EVT_LOGO_RCVD: /* why don't we do a shutdown here?? */
+	case OCS_EVT_PRLO_RCVD:
+	case OCS_EVT_PDISC_RCVD:
+	case OCS_EVT_FDISC_RCVD:
+	case OCS_EVT_ADISC_RCVD:
+	case OCS_EVT_RSCN_RCVD:
+	case OCS_EVT_SCR_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		node_printf(node, "%s received, sending reject\n", ocs_sm_event_name(evt));
+		ocs_send_ls_rjt(cbdata->io, ocs_be16toh(hdr->ox_id),
+			FC_REASON_UNABLE_TO_PERFORM, FC_EXPL_NPORT_LOGIN_REQUIRED, 0,
+			NULL, NULL);
+
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_OK:	/* PLOGI response received */
+		/* Completion from PLOGI sent */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm:  save sparams, ocs_node_attach */
+		ocs_node_save_sparms(node, cbdata->els->els_rsp.virt);
+		ocs_display_sparams(node->display_name, "plogi rcvd resp", 0, NULL,
+			((uint8_t*)cbdata->els->els_rsp.virt) + 4);
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_d_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:	/* PLOGI response received */
+		/* PLOGI failed, shutdown the node */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN, NULL);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_RJT:	/* Our PLOGI was rejected, this is ok in some cases */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		break;
+
+	case OCS_EVT_FCP_CMD_RCVD: {
+		/* not logged in yet and outstanding PLOGI so don't send LOGO,
+		 * just drop
+		 */
+		node_printf(node, "FCP_CMND received, drop\n");
+		break;
+	}
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Waiting on a response for a
+ *	sent PLOGI.
+ *
+ * <h3 class="desc">Description</h3>
+ * State is entered when an initiator-capable node has sent
+ * a PLOGI and is waiting for a response. Before receiving the
+ * response, a PRLI was received, implying that the PLOGI was
+ * successful.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_plogi_rsp_recvd_prli(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/*
+		 * Since we've received a PRLI, we have a port login and will
+		 * just need to wait for the PLOGI response to do the node
+		 * attach and then we can send the LS_ACC for the PRLI. If,
+		 * during this time, we receive FCP_CMNDs (which is possible
+		 * since we've already sent a PRLI and our peer may have accepted).
+		 * At this time, we are not waiting on any other unsolicited
+		 * frames to continue with the login process. Thus, it will not
+		 * hurt to hold frames here.
+		 */
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_OK:	/* PLOGI response received */
+		/* Completion from PLOGI sent */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm:  save sparams, ocs_node_attach */
+		ocs_node_save_sparms(node, cbdata->els->els_rsp.virt);
+		ocs_display_sparams(node->display_name, "plogi rcvd resp", 0, NULL,
+			((uint8_t*)cbdata->els->els_rsp.virt) + 4);
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_d_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:	/* PLOGI response received */
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+		/* PLOGI failed, shutdown the node */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN, NULL);
+		break;
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for a domain attach.
+ *
+ * <h3 class="desc">Description</h3>
+ * Waits for a domain-attach complete ok event.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_domain_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		ocs_assert(node->sport->domain->attached, NULL);
+		/* sm: ocs_node_attach */
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_d_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for topology
+ *	notification
+ *
+ * <h3 class="desc">Description</h3>
+ * Waits for topology notification from fabric node, then
+ * attaches domain and node.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_topology_notify(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SPORT_TOPOLOGY_NOTIFY: {
+		ocs_sport_topology_e topology = (ocs_sport_topology_e)arg;
+		ocs_assert(!node->sport->domain->attached, NULL);
+		ocs_assert(node->send_ls_acc == OCS_NODE_SEND_LS_ACC_PLOGI, NULL);
+		node_printf(node, "topology notification, topology=%d\n", topology);
+
+		/* At the time the PLOGI was received, the topology was unknown,
+		 * so we didn't know which node would perform the domain attach:
+		 * 1. The node from which the PLOGI was sent (p2p) or
+		 * 2. The node to which the FLOGI was sent (fabric).
+		 */
+		if (topology == OCS_SPORT_TOPOLOGY_P2P) {
+			/* if this is p2p, need to attach to the domain using the
+			 * d_id from the PLOGI received
+			 */
+			ocs_domain_attach(node->sport->domain, node->ls_acc_did);
+		}
+		/* else, if this is fabric, the domain attach should be performed
+		 * by the fabric node (node sending FLOGI); just wait for attach
+		 * to complete
+		 */
+
+		ocs_node_transition(node, __ocs_d_wait_domain_attach, NULL);
+		break;
+	}
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		ocs_assert(node->sport->domain->attached, NULL);
+		node_printf(node, "domain attach ok\n");
+		/*sm:  ocs_node_attach */
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_d_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for a node attach when found by a remote node.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		switch (node->send_ls_acc) {
+		case OCS_NODE_SEND_LS_ACC_PLOGI: {
+			/* sm: send_plogi_acc is set / send PLOGI acc */
+			/* Normal case for T, or I+T */
+			ocs_send_plogi_acc(node->ls_acc_io, node->ls_acc_oxid, NULL, NULL);
+			ocs_node_transition(node, __ocs_d_wait_plogi_acc_cmpl, NULL);
+			node->send_ls_acc = OCS_NODE_SEND_LS_ACC_NONE;
+			node->ls_acc_io = NULL;
+			break;
+		}
+		case OCS_NODE_SEND_LS_ACC_PRLI: {
+			ocs_d_send_prli_rsp(node->ls_acc_io, node->ls_acc_oxid);
+			node->send_ls_acc = OCS_NODE_SEND_LS_ACC_NONE;
+			node->ls_acc_io = NULL;
+			break;
+		}
+		case OCS_NODE_SEND_LS_ACC_NONE:
+		default:
+			/* Normal case for I */
+			/* sm: send_plogi_acc is not set / send PLOGI acc */
+			ocs_node_transition(node, __ocs_d_port_logged_in, NULL);
+			break;
+		}
+		break;
+
+	case OCS_EVT_NODE_ATTACH_FAIL:
+		/* node attach failed, shutdown the node */
+		node->attached = FALSE;
+		node_printf(node, "node attach failed\n");
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+		break;
+
+	/* Handle shutdown events */
+	case OCS_EVT_SHUTDOWN:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_d_wait_attach_evt_shutdown, NULL);
+		break;
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_EXPLICIT_LOGO;
+		ocs_node_transition(node, __ocs_d_wait_attach_evt_shutdown, NULL);
+		break;
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_IMPLICIT_LOGO;
+		ocs_node_transition(node, __ocs_d_wait_attach_evt_shutdown, NULL);
+		break;
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for a node/domain
+ * attach then shutdown node.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_attach_evt_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	/* wait for any of these attach events and then shutdown */
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		node_printf(node, "Attach evt=%s, proceed to shutdown\n", ocs_sm_event_name(evt));
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_FAIL:
+		/* node attach failed, shutdown the node */
+		node->attached = FALSE;
+		node_printf(node, "Attach evt=%s, proceed to shutdown\n", ocs_sm_event_name(evt));
+		ocs_node_transition(node, __ocs_d_initiate_shutdown, NULL);
+		break;
+
+	/* ignore shutdown events as we're already in shutdown path */
+	case OCS_EVT_SHUTDOWN:
+		/* have default shutdown event take precedence */
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		/* fall through */
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		break;
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Port is logged in.
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered when a remote port has completed port login (PLOGI).
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process
+ * @param arg Per event optional argument
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_d_port_logged_in(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	/* TODO: I+T: what if PLOGI response not yet received ? */
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* Normal case for I or I+T */
+		if (node->sport->enable_ini && !FC_ADDR_IS_DOMAIN_CTRL(node->rnode.fc_id)
+				&& !node->sent_prli) {
+			/* sm: if enable_ini / send PRLI */
+			ocs_send_prli(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+			node->sent_prli = TRUE;
+			/* can now expect ELS_REQ_OK/FAIL/RJT */
+		}
+		break;
+
+	case OCS_EVT_FCP_CMD_RCVD: {
+		/* For target functionality send PRLO and drop the CMD frame. */
+		if (node->sport->enable_tgt) {
+			if (ocs_send_prlo(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT,
+				OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL)) {
+				ocs_node_transition(node, __ocs_d_wait_prlo_rsp, NULL);
+			}
+		}
+		break;
+	}
+
+	case OCS_EVT_PRLI_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+
+		/* Normal for T or I+T */
+
+		ocs_process_prli_payload(node, cbdata->payload->dma.virt);
+		ocs_d_send_prli_rsp(cbdata->io, ocs_be16toh(hdr->ox_id));
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_OK: {	/* PRLI response */
+		/* Normal case for I or I+T */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PRLI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm: process PRLI payload */
+		ocs_process_prli_payload(node, cbdata->els->els_rsp.virt);
+		ocs_node_transition(node, __ocs_d_device_ready, NULL);
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL: {	/* PRLI response failed */
+		/* I, I+T, assume some link failure, shutdown node */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PRLI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN, NULL);
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_RJT: {/* PRLI rejected by remote */
+		/* Normal for I, I+T (connected to an I) */
+		/* Node doesn't want to be a target, stay here and wait for a PRLI from the remote node
+		 * if it really wants to connect to us as target */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PRLI, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_CMPL_OK: {
+		/* Normal T, I+T, target-server rejected the process login */
+		/* This would be received only in the case where we sent LS_RJT for the PRLI, so
+		 * do nothing.   (note: as T only we could shutdown the node)
+		 */
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		break;
+	}
+
+	case OCS_EVT_PLOGI_RCVD: {
+		/* sm: save sparams, set send_plogi_acc, post implicit logout
+		 * Save plogi parameters */
+		ocs_node_save_sparms(node, cbdata->payload->dma.virt);
+		ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PLOGI);
+
+		/* Restart node attach with new service parameters, and send ACC */
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN_IMPLICIT_LOGO, NULL);
+		break;
+	}
+
+	case OCS_EVT_LOGO_RCVD: {
+		/* I, T, I+T */
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		node_printf(node, "%s received attached=%d\n", ocs_sm_event_name(evt), node->attached);
+		ocs_send_logo_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		ocs_node_transition(node, __ocs_d_wait_logo_acc_cmpl, NULL);
+		break;
+	}
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for a LOGO accept.
+ *
+ * <h3 class="desc">Description</h3>
+ * Waits for a LOGO accept completion.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process
+ * @param arg Per event optional argument
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_logo_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_OK:
+	case OCS_EVT_SRRS_ELS_CMPL_FAIL:
+		/* sm: / post explicit logout */
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+		break;
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Device is ready.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_device_ready(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	if (evt != OCS_EVT_FCP_CMD_RCVD) {
+		node_sm_trace();
+	}
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		node->fcp_enabled = TRUE;
+		if (node->init) {
+			device_printf(ocs->dev, "[%s] found  (initiator) WWPN %s WWNN %s\n", node->display_name,
+				node->wwpn, node->wwnn);
+			if (node->sport->enable_tgt)
+				ocs_scsi_new_initiator(node);
+		}
+		if (node->targ) {
+			device_printf(ocs->dev, "[%s] found  (target)    WWPN %s WWNN %s\n", node->display_name,
+				node->wwpn, node->wwnn);
+			if (node->sport->enable_ini)
+				ocs_scsi_new_target(node);
+		}
+		break;
+
+	case OCS_EVT_EXIT:
+		node->fcp_enabled = FALSE;
+		break;
+
+	case OCS_EVT_PLOGI_RCVD: {
+		/* sm: save sparams, set send_plogi_acc, post implicit logout
+		 * Save plogi parameters */
+		ocs_node_save_sparms(node, cbdata->payload->dma.virt);
+		ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PLOGI);
+
+		/* Restart node attach with new service parameters, and send ACC */
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN_IMPLICIT_LOGO, NULL);
+		break;
+	}
+
+
+	case OCS_EVT_PDISC_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		ocs_send_plogi_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		break;
+	}
+	
+	case OCS_EVT_PRLI_RCVD: {
+		/* T, I+T: remote initiator is slow to get started */
+		fc_header_t *hdr = cbdata->header->dma.virt;
+
+		ocs_process_prli_payload(node, cbdata->payload->dma.virt);
+
+		/* sm: send PRLI acc/reject */
+		if (ocs->fc_type == node->fc_type)
+			ocs_send_prli_acc(cbdata->io, ocs_be16toh(hdr->ox_id), ocs->fc_type, NULL, NULL);
+		else
+			ocs_send_ls_rjt(cbdata->io, ocs_be16toh(hdr->ox_id), FC_REASON_UNABLE_TO_PERFORM,
+				FC_EXPL_REQUEST_NOT_SUPPORTED, 0, NULL, NULL);
+		break;
+	}
+
+	case OCS_EVT_PRLO_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		fc_prlo_payload_t *prlo = cbdata->payload->dma.virt;
+
+		/* sm: send PRLO acc/reject */
+		if (ocs->fc_type == prlo->type)
+			ocs_send_prlo_acc(cbdata->io, ocs_be16toh(hdr->ox_id), ocs->fc_type, NULL, NULL);
+		else
+			ocs_send_ls_rjt(cbdata->io, ocs_be16toh(hdr->ox_id), FC_REASON_UNABLE_TO_PERFORM,
+				FC_EXPL_REQUEST_NOT_SUPPORTED, 0, NULL, NULL);
+		/*TODO: need implicit logout */
+		break;
+	}
+
+	case OCS_EVT_LOGO_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		node_printf(node, "%s received attached=%d\n", ocs_sm_event_name(evt), node->attached);
+		ocs_send_logo_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		ocs_node_transition(node, __ocs_d_wait_logo_acc_cmpl, NULL);
+		break;
+	}
+
+	case OCS_EVT_ADISC_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		ocs_send_adisc_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		break;
+	}
+
+	case OCS_EVT_RRQ_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		/* Send LS_ACC */
+		ocs_send_ls_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		break;
+	}
+
+	case OCS_EVT_ABTS_RCVD:
+		ocs_process_abts(cbdata->io, cbdata->header->dma.virt);
+		break;
+
+	case OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
+		break;
+
+	case OCS_EVT_NODE_REFOUND:
+		break;
+
+	case OCS_EVT_NODE_MISSING:
+		if (node->sport->enable_rscn) {
+			ocs_node_transition(node, __ocs_d_device_gone, NULL);
+		}
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_OK:
+		/* T, or I+T, PRLI accept completed ok */
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_FAIL:
+		/* T, or I+T, PRLI accept failed to complete */
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		node_printf(node, "Failed to send PRLI LS_ACC\n");
+		break;
+
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Node is gone (absent from GID_PT).
+ *
+ * <h3 class="desc">Description</h3>
+ * State entered when a node is detected as being gone (absent from GID_PT).
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process
+ * @param arg Per event optional argument
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_device_gone(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc = OCS_SCSI_CALL_COMPLETE;
+	int32_t rc_2 = OCS_SCSI_CALL_COMPLETE;
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		const char *labels[] = {"none", "initiator", "target", "initiator+target"};
+
+		device_printf(ocs->dev, "[%s] missing (%s)    WWPN %s WWNN %s\n", node->display_name,
+				labels[(node->targ << 1) | (node->init)], node->wwpn, node->wwnn);
+
+		switch(ocs_node_get_enable(node)) {
+		case OCS_NODE_ENABLE_T_TO_T:
+		case OCS_NODE_ENABLE_I_TO_T:
+		case OCS_NODE_ENABLE_IT_TO_T:
+			rc = ocs_scsi_del_target(node, OCS_SCSI_TARGET_MISSING);
+			break;
+
+		case OCS_NODE_ENABLE_T_TO_I:
+		case OCS_NODE_ENABLE_I_TO_I:
+		case OCS_NODE_ENABLE_IT_TO_I:
+			rc = ocs_scsi_del_initiator(node, OCS_SCSI_INITIATOR_MISSING);
+			break;
+
+		case OCS_NODE_ENABLE_T_TO_IT:
+			rc = ocs_scsi_del_initiator(node, OCS_SCSI_INITIATOR_MISSING);
+			break;
+
+		case OCS_NODE_ENABLE_I_TO_IT:
+			rc = ocs_scsi_del_target(node, OCS_SCSI_TARGET_MISSING);
+			break;
+
+		case OCS_NODE_ENABLE_IT_TO_IT:
+			rc = ocs_scsi_del_initiator(node, OCS_SCSI_INITIATOR_MISSING);
+			rc_2 = ocs_scsi_del_target(node, OCS_SCSI_TARGET_MISSING);
+			break;
+
+		default:
+			rc = OCS_SCSI_CALL_COMPLETE;
+			break;
+
+		}
+
+		if ((rc == OCS_SCSI_CALL_COMPLETE) && (rc_2 == OCS_SCSI_CALL_COMPLETE)) {
+			ocs_node_post_event(node, OCS_EVT_SHUTDOWN, NULL);
+		}
+
+		break;
+	}
+	case OCS_EVT_NODE_REFOUND:
+		/* two approaches, reauthenticate with PLOGI/PRLI, or ADISC */
+
+		/* reauthenticate with PLOGI/PRLI */
+		/* ocs_node_transition(node, __ocs_d_discovered, NULL); */
+
+		/* reauthenticate with ADISC 
+		 * sm: send ADISC */
+		ocs_send_adisc(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_d_wait_adisc_rsp, NULL);
+		break;
+
+	case OCS_EVT_PLOGI_RCVD: {
+		/* sm: save sparams, set send_plogi_acc, post implicit logout
+		 * Save plogi parameters */
+		ocs_node_save_sparms(node, cbdata->payload->dma.virt);
+		ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PLOGI);
+
+		/* Restart node attach with new service parameters, and send ACC */
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN_IMPLICIT_LOGO, NULL);
+		break;
+	}
+
+	case OCS_EVT_FCP_CMD_RCVD: {
+		/* most likely a stale frame (received prior to link down), if attempt
+		 * to send LOGO, will probably timeout and eat up 20s; thus, drop FCP_CMND
+		 */
+		node_printf(node, "FCP_CMND received, drop\n");
+		break;
+	}
+	case OCS_EVT_LOGO_RCVD: {
+		/* I, T, I+T */
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		node_printf(node, "%s received attached=%d\n", ocs_sm_event_name(evt), node->attached);
+		/* sm: send LOGO acc */
+		ocs_send_logo_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		ocs_node_transition(node, __ocs_d_wait_logo_acc_cmpl, NULL);
+		break;
+	}
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup device_sm
+ * @brief Device node state machine: Wait for the ADISC response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Waits for the ADISC response from the remote node.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_d_wait_adisc_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_ADISC, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_node_transition(node, __ocs_d_device_ready, NULL);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+		/* received an LS_RJT, in this case, send shutdown (explicit logo)
+		 * event which will unregister the node, and start over with PLOGI
+		 */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_ADISC, __ocs_d_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/*sm: post explicit logout */
+		ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+		break;
+
+	case OCS_EVT_LOGO_RCVD: {
+		/* In this case, we have the equivalent of an LS_RJT for the ADISC,
+		 * so we need to abort the ADISC, and re-login with PLOGI
+		 */
+		/*sm: request abort, send LOGO acc */
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		node_printf(node, "%s received attached=%d\n", ocs_sm_event_name(evt), node->attached);
+		ocs_send_logo_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		ocs_node_transition(node, __ocs_d_wait_logo_acc_cmpl, NULL);
+		break;
+	}
+	default:
+		__ocs_d_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
diff --git a/sys/dev/ocs_fc/ocs_device.h b/sys/dev/ocs_fc/ocs_device.h
new file mode 100644
index 000000000000..337737aeb944
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_device.h
@@ -0,0 +1,133 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Node state machine functions for remote device node sm
+ */
+
+#if !defined(__OCS_DEVICE_H__)
+#define __OCS_DEVICE_H__
+
+/***************************************************************************
+ * Receive queue configuration
+ */
+
+#ifndef OCS_FC_RQ_SIZE_DEFAULT
+#define OCS_FC_RQ_SIZE_DEFAULT			1024
+#endif
+
+
+/***************************************************************************
+ * IO Configuration
+ */
+
+/**
+ * @brief Defines the number of SGLs allocated on each IO object
+ */
+#ifndef OCS_FC_MAX_SGL
+#define OCS_FC_MAX_SGL		128
+#endif
+
+
+/***************************************************************************
+ * DIF Configuration
+ */
+
+/**
+ * @brief Defines the DIF seed value used for the CRC calculation.
+ */
+#ifndef OCS_FC_DIF_SEED
+#define OCS_FC_DIF_SEED		0
+#endif
+
+/***************************************************************************
+ * Timeouts
+ */
+#ifndef OCS_FC_ELS_SEND_DEFAULT_TIMEOUT
+#define OCS_FC_ELS_SEND_DEFAULT_TIMEOUT		0
+#endif
+
+#ifndef OCS_FC_ELS_CT_SEND_DEFAULT_TIMEOUT
+#define OCS_FC_ELS_CT_SEND_DEFAULT_TIMEOUT	5
+#endif
+
+#ifndef OCS_FC_ELS_DEFAULT_RETRIES
+#define OCS_FC_ELS_DEFAULT_RETRIES		3
+#endif
+
+#ifndef OCS_FC_FLOGI_TIMEOUT_SEC
+#define OCS_FC_FLOGI_TIMEOUT_SEC		5 /* shorter than default */
+#endif
+
+#ifndef OCS_FC_DOMAIN_SHUTDOWN_TIMEOUT_USEC
+#define OCS_FC_DOMAIN_SHUTDOWN_TIMEOUT_USEC	30000000 /* 30 seconds */
+#endif
+
+/***************************************************************************
+ * Watermark
+ */
+#ifndef OCS_WATERMARK_HIGH_PCT
+#define OCS_WATERMARK_HIGH_PCT			90
+#endif
+#ifndef OCS_WATERMARK_LOW_PCT
+#define OCS_WATERMARK_LOW_PCT			80
+#endif
+#ifndef OCS_IO_WATERMARK_PER_INITIATOR
+#define OCS_IO_WATERMARK_PER_INITIATOR		8
+#endif
+
+extern void ocs_node_init_device(ocs_node_t *node, int send_plogi);
+extern void ocs_process_prli_payload(ocs_node_t *node, fc_prli_payload_t *prli);
+extern void ocs_d_send_prli_rsp(ocs_io_t *io, uint16_t ox_id);
+extern void ocs_send_ls_acc_after_attach(ocs_io_t *io, fc_header_t *hdr, ocs_node_send_ls_acc_e ls);
+
+extern void*__ocs_d_wait_loop(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_plogi_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_plogi_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_plogi_rsp_recvd_prli(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_domain_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_topology_notify(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_attach_evt_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_initiate_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_port_logged_in(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_logo_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_device_ready(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_device_gone(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_adisc_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_logo_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void*__ocs_d_wait_prlo_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+#endif /* __OCS_DEVICE_H__ */
diff --git a/sys/dev/ocs_fc/ocs_domain.c b/sys/dev/ocs_fc/ocs_domain.c
new file mode 100644
index 000000000000..fe5489343d68
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_domain.c
@@ -0,0 +1,1585 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Handles the domain object callback from the HW.
+ */
+
+/*!
+@defgroup domain_sm Domain State Machine: States
+*/
+
+#include "ocs.h"
+
+#include "ocs_fabric.h"
+#include "ocs_device.h"
+
+#define domain_sm_trace(domain)  \
+	do { \
+		if (OCS_LOG_ENABLE_DOMAIN_SM_TRACE(domain->ocs)) \
+			ocs_log_info(domain->ocs, "[domain] %-20s %-20s\n", __func__, ocs_sm_event_name(evt)); \
+	} while (0)
+
+#define domain_trace(domain, fmt, ...) \
+	do { \
+		if (OCS_LOG_ENABLE_DOMAIN_SM_TRACE(domain ? domain->ocs : NULL)) \
+			ocs_log_info(domain ? domain->ocs : NULL, fmt, ##__VA_ARGS__); \
+	} while (0)
+
+#define domain_printf(domain, fmt, ...) \
+	do { \
+		ocs_log_info(domain ? domain->ocs : NULL, fmt, ##__VA_ARGS__); \
+	} while (0)
+
+void ocs_mgmt_domain_list(ocs_textbuf_t *textbuf, void *domain);
+void ocs_mgmt_domain_get_all(ocs_textbuf_t *textbuf, void *domain);
+int ocs_mgmt_domain_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *domain);
+int ocs_mgmt_domain_set(char *parent, char *name, char *value, void *domain);
+int ocs_mgmt_domain_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
+		void *arg_out, uint32_t arg_out_length, void *domain);
+
+static ocs_mgmt_functions_t domain_mgmt_functions = {
+	.get_list_handler = ocs_mgmt_domain_list,
+	.get_handler = ocs_mgmt_domain_get,
+	.get_all_handler = ocs_mgmt_domain_get_all,
+	.set_handler = ocs_mgmt_domain_set,
+	.exec_handler = ocs_mgmt_domain_exec,
+};
+
+
+
+/**
+ * @brief Accept domain callback events from the HW.
+ *
+ * <h3 class="desc">Description</h3>
+ * HW calls this function with various domain-related events.
+ *
+ * @param arg Application-specified argument.
+ * @param event Domain event.
+ * @param data Event specific data.
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+int32_t
+ocs_domain_cb(void *arg, ocs_hw_domain_event_e event, void *data)
+{
+	ocs_t *ocs = arg;
+	ocs_domain_t *domain = NULL;
+	int32_t rc = 0;
+
+	ocs_assert(data, -1);
+
+	if (event != OCS_HW_DOMAIN_FOUND) {
+		domain = data;
+	}
+
+	switch (event) {
+	case OCS_HW_DOMAIN_FOUND: {
+		uint64_t fcf_wwn = 0;
+		ocs_domain_record_t *drec = data;
+		ocs_assert(drec, -1);
+
+		/* extract the fcf_wwn */
+		fcf_wwn = ocs_be64toh(*((uint64_t*)drec->wwn));
+
+		/* lookup domain, or allocate a new one if one doesn't exist already */
+		domain = ocs_domain_find(ocs, fcf_wwn);
+		if (domain == NULL) {
+			domain = ocs_domain_alloc(ocs, fcf_wwn);
+			if (domain == NULL) {
+				ocs_log_err(ocs, "ocs_domain_alloc() failed\n");
+				rc = -1;
+				break;
+			}
+			ocs_sm_transition(&domain->drvsm, __ocs_domain_init, NULL);
+		}
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_FOUND, drec);
+		break;
+	}
+
+	case OCS_HW_DOMAIN_LOST:
+		domain_trace(domain, "OCS_HW_DOMAIN_LOST:\n");
+		ocs_domain_hold_frames(domain);
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_LOST, NULL);
+		break;
+
+	case OCS_HW_DOMAIN_ALLOC_OK: {
+		domain_trace(domain, "OCS_HW_DOMAIN_ALLOC_OK:\n");
+		domain->instance_index = 0;
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_ALLOC_OK, NULL);
+		break;
+	}
+
+	case OCS_HW_DOMAIN_ALLOC_FAIL:
+		domain_trace(domain, "OCS_HW_DOMAIN_ALLOC_FAIL:\n");
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_ALLOC_FAIL, NULL);
+		break;
+
+	case OCS_HW_DOMAIN_ATTACH_OK:
+		domain_trace(domain, "OCS_HW_DOMAIN_ATTACH_OK:\n");
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_ATTACH_OK, NULL);
+		break;
+
+	case OCS_HW_DOMAIN_ATTACH_FAIL:
+		domain_trace(domain, "OCS_HW_DOMAIN_ATTACH_FAIL:\n");
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_ATTACH_FAIL, NULL);
+		break;
+
+	case OCS_HW_DOMAIN_FREE_OK:
+		domain_trace(domain, "OCS_HW_DOMAIN_FREE_OK:\n");
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_FREE_OK, NULL);
+		break;
+
+	case OCS_HW_DOMAIN_FREE_FAIL:
+		domain_trace(domain, "OCS_HW_DOMAIN_FREE_FAIL:\n");
+		ocs_domain_post_event(domain, OCS_EVT_DOMAIN_FREE_FAIL, NULL);
+		break;
+
+	default:
+		ocs_log_warn(ocs, "unsupported event %#x\n", event);
+	}
+
+	return rc;
+}
+
+
+/**
+ * @brief Find the domain, given its FCF_WWN.
+ *
+ * <h3 class="desc">Description</h3>
+ * Search the domain_list to find a matching domain object.
+ *
+ * @param ocs Pointer to the OCS device.
+ * @param fcf_wwn FCF WWN to find.
+ *
+ * @return Returns the pointer to the domain if found; or NULL otherwise.
+ */
+
+ocs_domain_t *
+ocs_domain_find(ocs_t *ocs, uint64_t fcf_wwn)
+{
+	ocs_domain_t *domain = NULL;
+
+	/* Check to see if this domain is already allocated */
+	ocs_device_lock(ocs);
+		ocs_list_foreach(&ocs->domain_list, domain) {
+			if (fcf_wwn == domain->fcf_wwn) {
+				break;
+			}
+		}
+	ocs_device_unlock(ocs);
+	return domain;
+}
+
+/**
+ * @brief Allocate a domain object.
+ *
+ * <h3 class="desc">Description</h3>
+ * A domain object is allocated and initialized. It is associated with the
+ * \c ocs argument.
+ *
+ * @param ocs Pointer to the OCS device.
+ * @param fcf_wwn FCF WWN of the domain.
+ *
+ * @return Returns a pointer to the ocs_domain_t object; or NULL.
+ */
+
+ocs_domain_t *
+ocs_domain_alloc(ocs_t *ocs, uint64_t fcf_wwn)
+{
+	ocs_domain_t *domain;
+
+	ocs_assert(ocs, NULL);
+
+	domain = ocs_malloc(ocs, sizeof(*domain), OCS_M_NOWAIT | OCS_M_ZERO);
+	if (domain) {
+
+		domain->ocs = ocs;
+		domain->instance_index = ocs->domain_instance_count++;
+		domain->drvsm.app = domain;
+		ocs_domain_lock_init(domain);
+		ocs_lock_init(ocs, &domain->lookup_lock, "Domain lookup[%d]", domain->instance_index);
+
+		/* Allocate a sparse vector for sport FC_ID's */
+		domain->lookup = spv_new(ocs);
+		if (domain->lookup == NULL) {
+			ocs_log_err(ocs, "spv_new() failed\n");
+			ocs_free(ocs, domain, sizeof(*domain));
+			return NULL;
+		}
+
+		ocs_list_init(&domain->sport_list, ocs_sport_t, link);
+		domain->fcf_wwn = fcf_wwn;
+		ocs_log_debug(ocs, "Domain allocated: wwn %016" PRIX64 "\n", domain->fcf_wwn);
+		domain->femul_enable = (ocs->ctrlmask & OCS_CTRLMASK_ENABLE_FABRIC_EMULATION) != 0;
+
+		ocs_device_lock(ocs);
+			/* if this is the first domain, then assign it as the "root" domain */
+			if (ocs_list_empty(&ocs->domain_list)) {
+				ocs->domain = domain;
+			}
+			ocs_list_add_tail(&ocs->domain_list, domain);
+		ocs_device_unlock(ocs);
+
+		domain->mgmt_functions = &domain_mgmt_functions;
+	} else {
+		ocs_log_err(ocs, "domain allocation failed\n");
+	}
+
+
+	return domain;
+}
+
+/**
+ * @brief Free a domain object.
+ *
+ * <h3 class="desc">Description</h3>
+ * The domain object is freed.
+ *
+ * @param domain Domain object to free.
+ *
+ * @return None.
+ */
+
+void
+ocs_domain_free(ocs_domain_t *domain)
+{
+	ocs_t *ocs;
+
+	ocs_assert(domain);
+	ocs_assert(domain->ocs);
+
+	/* Hold frames to clear the domain pointer from the xport lookup */
+	ocs_domain_hold_frames(domain);
+
+	ocs = domain->ocs;
+
+	ocs_log_debug(ocs, "Domain free: wwn %016" PRIX64 "\n", domain->fcf_wwn);
+
+	spv_del(domain->lookup);
+	domain->lookup = NULL;
+
+	ocs_device_lock(ocs);
+		ocs_list_remove(&ocs->domain_list, domain);
+		if (domain == ocs->domain) {
+			/* set global domain to the new head */
+			ocs->domain = ocs_list_get_head(&ocs->domain_list);
+			if (ocs->domain) {
+				ocs_log_debug(ocs, "setting new domain, old=%p new=%p\n",
+						domain, ocs->domain);
+			}
+		}
+
+		if (ocs_list_empty(&ocs->domain_list) && ocs->domain_list_empty_cb ) {
+			(*ocs->domain_list_empty_cb)(ocs, ocs->domain_list_empty_cb_arg);
+		}
+	ocs_device_unlock(ocs);
+
+	ocs_lock_free(&domain->lookup_lock);
+
+	ocs_free(ocs, domain, sizeof(*domain));
+}
+
+/**
+ * @brief Free memory resources of a domain object.
+ *
+ * <h3 class="desc">Description</h3>
+ * After the domain object is freed, its child objects are also freed.
+ *
+ * @param domain Pointer to a domain object.
+ *
+ * @return None.
+ */
+
+void
+ocs_domain_force_free(ocs_domain_t *domain)
+{
+	ocs_sport_t *sport;
+	ocs_sport_t *next;
+
+	/* Shutdown domain sm */
+	ocs_sm_disable(&domain->drvsm);
+
+	ocs_scsi_notify_domain_force_free(domain);
+
+	ocs_domain_lock(domain);
+		ocs_list_foreach_safe(&domain->sport_list, sport, next) {
+			ocs_sport_force_free(sport);
+		}
+	ocs_domain_unlock(domain);
+	ocs_hw_domain_force_free(&domain->ocs->hw, domain);
+	ocs_domain_free(domain);
+}
+
+/**
+ * @brief Register a callback when the domain_list goes empty.
+ *
+ * <h3 class="desc">Description</h3>
+ * A function callback may be registered when the domain_list goes empty.
+ *
+ * @param ocs Pointer to a device object.
+ * @param callback Callback function.
+ * @param arg Callback argument.
+ *
+ * @return None.
+ */
+
+void
+ocs_register_domain_list_empty_cb(ocs_t *ocs, void (*callback)(ocs_t *ocs, void *arg), void *arg)
+{
+	ocs_device_lock(ocs);
+		ocs->domain_list_empty_cb = callback;
+		ocs->domain_list_empty_cb_arg = arg;
+		if (ocs_list_empty(&ocs->domain_list) && callback) {
+			(*callback)(ocs, arg);
+		}
+	ocs_device_unlock(ocs);
+}
+
+/**
+ * @brief Return a pointer to the domain, given the instance index.
+ *
+ * <h3 class="desc">Description</h3>
+ * A pointer to the domain context, given by the index, is returned.
+ *
+ * @param ocs Pointer to the driver instance context.
+ * @param index Instance index.
+ *
+ * @return Returns a pointer to the domain; or NULL.
+ */
+
+ocs_domain_t *
+ocs_domain_get_instance(ocs_t *ocs, uint32_t index)
+{
+	ocs_domain_t *domain = NULL;
+
+	if (index >= OCS_MAX_DOMAINS) {
+		ocs_log_err(ocs, "invalid index: %d\n", index);
+		return NULL;
+	}
+	ocs_device_lock(ocs);
+		ocs_list_foreach(&ocs->domain_list, domain) {
+			if (domain->instance_index == index) {
+				break;
+			}
+		}
+	ocs_device_unlock(ocs);
+	return domain;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Common event handler.
+ *
+ * <h3 class="desc">Description</h3>
+ * Common/shared events are handled here for the domain state machine.
+ *
+ * @param funcname Function name text.
+ * @param ctx Domain state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+static void *
+__ocs_domain_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_domain_t *domain = ctx->app;
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+	case OCS_EVT_REENTER:
+	case OCS_EVT_EXIT:
+	case OCS_EVT_ALL_CHILD_NODES_FREE:
+		/* this can arise if an FLOGI fails on the SPORT, and the SPORT is shutdown */
+		break;
+	default:
+		ocs_log_warn(domain->ocs, "%-20s %-20s not handled\n", funcname, ocs_sm_event_name(evt));
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Common shutdown.
+ *
+ * <h3 class="desc">Description</h3>
+ * Handles common shutdown events.
+ *
+ * @param funcname Function name text.
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+static void *
+__ocs_domain_common_shutdown(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_domain_t *domain = ctx->app;
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+	case OCS_EVT_REENTER:
+	case OCS_EVT_EXIT:
+		break;
+	case OCS_EVT_DOMAIN_FOUND:
+		ocs_assert(arg, NULL);
+		/* sm: / save drec, mark domain_found_pending */
+		ocs_memcpy(&domain->pending_drec, arg, sizeof(domain->pending_drec));
+		domain->domain_found_pending = TRUE;
+		break;
+	case OCS_EVT_DOMAIN_LOST: 
+		/* clear drec available
+		 * sm: unmark domain_found_pending */
+		domain->domain_found_pending = FALSE;
+		break;
+
+	default:
+		ocs_log_warn(domain->ocs, "%-20s %-20s not handled\n", funcname, ocs_sm_event_name(evt));
+		break;
+	}
+
+	return NULL;
+}
+
+#define std_domain_state_decl(...) \
+	ocs_domain_t *domain = NULL; \
+	ocs_t *ocs = NULL; \
+	\
+	ocs_assert(ctx, NULL); \
+	ocs_assert(ctx->app, NULL); \
+	domain = ctx->app; \
+	ocs_assert(domain->ocs, NULL); \
+	ocs = domain->ocs; \
+	ocs_assert(ocs->xport, NULL);
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Initial state.
+ *
+ * <h3 class="desc">Description</h3>
+ * The initial state for a domain. Each domain is initialized to
+ * this state at start of day (SOD).
+ *
+ * @param ctx Domain state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		domain->attached = 0;
+		break;
+
+	case OCS_EVT_DOMAIN_FOUND: {
+		int32_t		vlan = 0;
+		uint32_t	i;
+		ocs_domain_record_t *drec = arg;
+		ocs_sport_t *sport;
+
+		uint64_t	my_wwnn = ocs->xport->req_wwnn;
+		uint64_t	my_wwpn = ocs->xport->req_wwpn;
+		uint64_t	be_wwpn;
+
+		/* For now, user must specify both port name and node name, or we let firmware
+		 * pick both (same as for vports).
+		 * TODO: do we want to allow setting only port name or only node name?
+		 */
+		if ((my_wwpn == 0) || (my_wwnn == 0)) {
+			ocs_log_debug(ocs, "using default hardware WWN configuration \n");
+			my_wwpn = ocs_get_wwn(&ocs->hw, OCS_HW_WWN_PORT);
+			my_wwnn = ocs_get_wwn(&ocs->hw, OCS_HW_WWN_NODE);
+		}
+
+		ocs_log_debug(ocs, "Creating base sport using WWPN %016" PRIx64 " WWNN %016" PRIx64 "\n",
+			my_wwpn, my_wwnn);
+
+		/* Allocate a sport and transition to __ocs_sport_allocated */
+		sport = ocs_sport_alloc(domain, my_wwpn, my_wwnn, UINT32_MAX, ocs->enable_ini, ocs->enable_tgt);
+
+		if (sport == NULL) {
+			ocs_log_err(ocs, "ocs_sport_alloc() failed\n");
+			break;
+		}
+		ocs_sm_transition(&sport->sm, __ocs_sport_allocated, NULL);
+
+		/* If domain is ethernet, then fetch the vlan id value */
+		if (drec->is_ethernet) {
+			vlan = ocs_bitmap_search((void *)drec->map.vlan, TRUE, 512 * 8);
+			if (vlan < 0) {
+				ocs_log_err(ocs, "no VLAN id available (FCF=%d)\n",
+						drec->index);
+				break;
+			}
+		}
+
+		be_wwpn = ocs_htobe64(sport->wwpn);
+
+		/* allocate ocs_sli_port_t object for local port
+		 * Note: drec->fc_id is ALPA from read_topology only if loop
+		 */
+		if (ocs_hw_port_alloc(&ocs->hw, sport, NULL, (uint8_t *)&be_wwpn)) {
+			ocs_log_err(ocs, "Can't allocate port\n");
+			ocs_sport_free(sport);
+			break;
+		}
+
+		/* initialize domain object */
+		domain->is_loop = drec->is_loop;
+		domain->is_fc = drec->is_fc;
+
+		/*
+		 * If the loop position map includes ALPA == 0, then we are in a public loop (NL_PORT)
+		 * Note that the first element of the loopmap[] contains the count of elements, and if
+		 * ALPA == 0 is present, it will occupy the first location after the count.
+		 */
+		domain->is_nlport = drec->map.loop[1] == 0x00;
+
+		if (domain->is_loop) {
+			ocs_log_debug(ocs, "%s fc_id=%#x speed=%d\n",
+					drec->is_loop ? (domain->is_nlport ? "public-loop" : "loop") : "other",
+					drec->fc_id, drec->speed);
+
+			sport->fc_id = drec->fc_id;
+			sport->topology = OCS_SPORT_TOPOLOGY_LOOP;
+			ocs_snprintf(sport->display_name, sizeof(sport->display_name), "s%06x", drec->fc_id);
+
+			if (ocs->enable_ini) {
+				uint32_t count = drec->map.loop[0];
+				ocs_log_debug(ocs, "%d position map entries\n", count);
+				for (i = 1; i <= count; i++) {
+					if (drec->map.loop[i] != drec->fc_id) {
+						ocs_node_t *node;
+
+						ocs_log_debug(ocs, "%#x -> %#x\n",
+								drec->fc_id, drec->map.loop[i]);
+						node = ocs_node_alloc(sport, drec->map.loop[i], FALSE, TRUE);
+						if (node == NULL) {
+							ocs_log_err(ocs, "ocs_node_alloc() failed\n");
+							break;
+						}
+						ocs_node_transition(node, __ocs_d_wait_loop, NULL);
+					}
+				}
+			}
+		}
+
+		/* Initiate HW domain alloc */
+		if (ocs_hw_domain_alloc(&ocs->hw, domain, drec->index, vlan)) {
+			ocs_log_err(ocs, "Failed to initiate HW domain allocation\n");
+			break;
+		}
+		ocs_sm_transition(ctx, __ocs_domain_wait_alloc, arg);
+		break;
+	}
+	default:
+		__ocs_domain_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Wait for the domain allocation to complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * Waits for the domain state to be allocated. After the HW domain
+ * allocation process has been initiated, this state waits for
+ * that process to complete (i.e. a domain-alloc-ok event).
+ *
+ * @param ctx Domain state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_wait_alloc(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_sport_t *sport;
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_DOMAIN_ALLOC_OK: {
+		char prop_buf[32];
+		uint64_t wwn_bump = 0;
+		fc_plogi_payload_t *sp;
+
+		if (ocs_get_property("wwn_bump", prop_buf, sizeof(prop_buf)) == 0) {
+			wwn_bump = ocs_strtoull(prop_buf, 0, 0);
+		}
+
+		sport = domain->sport;
+		ocs_assert(sport, NULL);
+		sp = (fc_plogi_payload_t*) sport->service_params;
+
+		/* Save the domain service parameters */
+		ocs_memcpy(domain->service_params + 4, domain->dma.virt, sizeof(fc_plogi_payload_t) - 4);
+		ocs_memcpy(sport->service_params + 4, domain->dma.virt, sizeof(fc_plogi_payload_t) - 4);
+
+		/* If we're in fabric emulation mode, the flogi service parameters have not been setup yet,
+		 * so we need some reasonable BB credit value
+		 */
+		if (domain->femul_enable) {
+			ocs_memcpy(domain->flogi_service_params + 4, domain->service_params + 4, sizeof(fc_plogi_payload_t) - 4);
+		}
+
+		/* Update the sport's service parameters, user might have specified non-default names */
+		sp->port_name_hi = ocs_htobe32((uint32_t) (sport->wwpn >> 32ll));
+		sp->port_name_lo = ocs_htobe32((uint32_t) sport->wwpn);
+		sp->node_name_hi = ocs_htobe32((uint32_t) (sport->wwnn >> 32ll));
+		sp->node_name_lo = ocs_htobe32((uint32_t) sport->wwnn);
+
+		if (wwn_bump) {
+			sp->port_name_lo = ocs_htobe32(ocs_be32toh(sp->port_name_lo) ^ ((uint32_t)(wwn_bump)));
+			sp->port_name_hi = ocs_htobe32(ocs_be32toh(sp->port_name_hi) ^ ((uint32_t)(wwn_bump >> 32)));
+			sp->node_name_lo = ocs_htobe32(ocs_be32toh(sp->node_name_lo) ^ ((uint32_t)(wwn_bump)));
+			sp->node_name_hi = ocs_htobe32(ocs_be32toh(sp->node_name_hi) ^ ((uint32_t)(wwn_bump >> 32)));
+			ocs_log_info(ocs, "Overriding WWN\n");
+		}
+
+		/* Take the loop topology path, unless we are an NL_PORT (public loop) */
+		if (domain->is_loop && !domain->is_nlport) {
+			/*
+			 * For loop, we already have our FC ID and don't need fabric login.
+			 * Transition to the allocated state and post an event to attach to
+			 * the domain. Note that this breaks the normal action/transition
+			 * pattern here to avoid a race with the domain attach callback.
+			 */
+			/* sm: is_loop / domain_attach */
+			ocs_sm_transition(ctx, __ocs_domain_allocated, NULL);
+			__ocs_domain_attach_internal(domain, sport->fc_id);
+			break;
+		} else {
+			ocs_node_t *node;
+
+			/* alloc fabric node, send FLOGI */
+			node = ocs_node_find(sport, FC_ADDR_FABRIC);
+			if (node) {
+				ocs_log_err(ocs, "Hmmmm ... Fabric Controller node already exists\n");
+				break;
+			}
+			node = ocs_node_alloc(sport, FC_ADDR_FABRIC, FALSE, FALSE);
+			if (!node) {
+				ocs_log_err(ocs, "Error: ocs_node_alloc() failed\n");
+			} else {
+				if (ocs->nodedb_mask & OCS_NODEDB_PAUSE_FABRIC_LOGIN) {
+					ocs_node_pause(node, __ocs_fabric_init);
+				} else {
+					ocs_node_transition(node, __ocs_fabric_init, NULL);
+				}
+			}
+			/* Accept frames */
+			domain->req_accept_frames = 1;
+		}
+		/* sm: start fabric logins */
+		ocs_sm_transition(ctx, __ocs_domain_allocated, NULL);
+		break;
+	}
+
+	case OCS_EVT_DOMAIN_ALLOC_FAIL:
+		/* TODO: hw/device reset */
+		ocs_log_err(ocs, "%s recv'd waiting for DOMAIN_ALLOC_OK; shutting down domain\n",
+			ocs_sm_event_name(evt));
+		domain->req_domain_free = 1;
+		break;
+
+	case OCS_EVT_DOMAIN_FOUND:
+		/* Should not happen */
+		ocs_assert(evt, NULL);
+		break;
+
+	case OCS_EVT_DOMAIN_LOST:
+		ocs_log_debug(ocs, "%s received while waiting for ocs_hw_domain_alloc() to complete\n", ocs_sm_event_name(evt));
+		ocs_sm_transition(ctx, __ocs_domain_wait_domain_lost, NULL);
+		break;
+
+	default:
+		__ocs_domain_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Wait for the domain attach request.
+ *
+ * <h3 class="desc">Description</h3>
+ * In this state, the domain has been allocated and is waiting for a domain attach request.
+ * The attach request comes from a node instance completing the fabric login,
+ * or from a point-to-point negotiation and login.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc = 0;
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_DOMAIN_REQ_ATTACH: {
+		uint32_t fc_id;
+
+		ocs_assert(arg, NULL);
+
+		fc_id = *((uint32_t*)arg);
+		ocs_log_debug(ocs, "Requesting hw domain attach fc_id x%x\n", fc_id);
+		/* Update sport lookup */
+		ocs_lock(&domain->lookup_lock);
+			spv_set(domain->lookup, fc_id, domain->sport);
+		ocs_unlock(&domain->lookup_lock);
+
+		/* Update display name for the sport */
+		ocs_node_fcid_display(fc_id, domain->sport->display_name, sizeof(domain->sport->display_name));
+
+		/* Issue domain attach call */
+		rc = ocs_hw_domain_attach(&ocs->hw, domain, fc_id);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_hw_domain_attach failed: %d\n", rc);
+			return NULL;
+		}
+		/* sm: / domain_attach */
+		ocs_sm_transition(ctx, __ocs_domain_wait_attach, NULL);
+		break;
+	}
+
+	case OCS_EVT_DOMAIN_FOUND:
+		/* Should not happen */
+		ocs_assert(evt, NULL);
+		break;
+
+	case OCS_EVT_DOMAIN_LOST: {
+		int32_t rc;
+		ocs_log_debug(ocs, "%s received while waiting for OCS_EVT_DOMAIN_REQ_ATTACH\n",
+			ocs_sm_event_name(evt));
+		ocs_domain_lock(domain);
+		if (!ocs_list_empty(&domain->sport_list)) {
+			/* if there are sports, transition to wait state and
+			 * send shutdown to each sport */
+			ocs_sport_t	*sport = NULL;
+			ocs_sport_t	*sport_next = NULL;
+			ocs_sm_transition(ctx, __ocs_domain_wait_sports_free, NULL);
+			ocs_list_foreach_safe(&domain->sport_list, sport, sport_next) {
+				ocs_sm_post_event(&sport->sm, OCS_EVT_SHUTDOWN, NULL);
+			}
+			ocs_domain_unlock(domain);
+		} else {
+			ocs_domain_unlock(domain);
+			/* no sports exist, free domain */
+			ocs_sm_transition(ctx, __ocs_domain_wait_shutdown, NULL);
+			rc = ocs_hw_domain_free(&ocs->hw, domain);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_hw_domain_free() failed: %d\n", rc);
+				/* TODO: hw/device reset needed */
+			}
+		}
+
+		break;
+	}
+
+	default:
+		__ocs_domain_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Wait for the HW domain attach to complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * Waits for the HW domain attach to complete. Forwards attach ok event to the
+ * fabric node state machine.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_wait_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_DOMAIN_ATTACH_OK: {
+		ocs_node_t *node = NULL;
+		ocs_node_t *next_node = NULL;
+		ocs_sport_t *sport;
+		ocs_sport_t *next_sport;
+
+		/* Mark as attached */
+		domain->attached = 1;
+
+		/* Register with SCSI API */
+		if (ocs->enable_tgt)
+			ocs_scsi_tgt_new_domain(domain);
+		if (ocs->enable_ini)
+			ocs_scsi_ini_new_domain(domain);
+
+		/* Transition to ready */
+		/* sm: / forward event to all sports and nodes */
+		ocs_sm_transition(ctx, __ocs_domain_ready, NULL);
+
+		/* We have an FCFI, so we can accept frames */
+		domain->req_accept_frames = 1;
+		/* Set domain notify pending state to avoid duplicate domain event post */
+		domain->domain_notify_pend = 1;
+
+		/* Notify all nodes that the domain attach request has completed
+		 * Note: sport will have already received notification of sport attached
+		 * as a result of the HW's port attach.
+		 */
+		ocs_domain_lock(domain);
+			ocs_list_foreach_safe(&domain->sport_list, sport, next_sport) {
+				ocs_sport_lock(sport);
+					ocs_list_foreach_safe(&sport->node_list, node, next_node) {
+						ocs_node_post_event(node, OCS_EVT_DOMAIN_ATTACH_OK, NULL);
+					}
+				ocs_sport_unlock(sport);
+			}
+		ocs_domain_unlock(domain);
+		domain->domain_notify_pend = 0;
+		break;
+	}
+
+	case OCS_EVT_DOMAIN_ATTACH_FAIL:
+		ocs_log_debug(ocs, "%s received while waiting for hw attach to complete\n", ocs_sm_event_name(evt));
+		/* TODO: hw/device reset */
+		break;
+
+	case OCS_EVT_DOMAIN_FOUND:
+		/* Should not happen */
+		ocs_assert(evt, NULL);
+		break;
+
+	case OCS_EVT_DOMAIN_LOST:
+		/* Domain lost while waiting for an attach to complete, go to a state that waits for
+		 * the domain attach to complete, then handle domain lost
+		 */
+		ocs_sm_transition(ctx, __ocs_domain_wait_domain_lost, NULL);
+		break;
+
+	case OCS_EVT_DOMAIN_REQ_ATTACH:
+		/* In P2P we can get an attach request from the other FLOGI path, so drop this one */
+		break;
+
+	default:
+		__ocs_domain_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Ready state.
+ *
+ * <h3 class="desc">Description</h3>
+ * This is a domain ready state. It waits for a domain-lost event, and initiates shutdown.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_ready(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+
+		/* start any pending vports */
+		if (ocs_vport_start(domain)) {
+			ocs_log_debug(domain->ocs, "ocs_vport_start() did not start all vports\n");
+		}
+		break;
+	}
+	case OCS_EVT_DOMAIN_LOST: {
+		int32_t rc;
+		ocs_domain_lock(domain);
+		if (!ocs_list_empty(&domain->sport_list)) {
+			/* if there are sports, transition to wait state and send
+			* shutdown to each sport */
+			ocs_sport_t	*sport = NULL;
+			ocs_sport_t	*sport_next = NULL;
+			ocs_sm_transition(ctx, __ocs_domain_wait_sports_free, NULL);
+			ocs_list_foreach_safe(&domain->sport_list, sport, sport_next) {
+				ocs_sm_post_event(&sport->sm, OCS_EVT_SHUTDOWN, NULL);
+			}
+			ocs_domain_unlock(domain);
+		} else {
+			ocs_domain_unlock(domain);
+			/* no sports exist, free domain */
+			ocs_sm_transition(ctx, __ocs_domain_wait_shutdown, NULL);
+			rc = ocs_hw_domain_free(&ocs->hw, domain);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_hw_domain_free() failed: %d\n", rc);
+				/* TODO: hw/device reset needed */
+			}
+		}
+		break;
+	}
+
+	case OCS_EVT_DOMAIN_FOUND:
+		/* Should not happen */
+		ocs_assert(evt, NULL);
+		break;
+
+	case OCS_EVT_DOMAIN_REQ_ATTACH: {
+		/* can happen during p2p */
+		uint32_t fc_id;
+
+		ocs_assert(arg, NULL);
+		fc_id = *((uint32_t*)arg);
+
+		/* Assume that the domain is attached */
+		ocs_assert(domain->attached, NULL);
+
+		/* Verify that the requested FC_ID is the same as the one we're working with */
+		ocs_assert(domain->sport->fc_id == fc_id, NULL);
+		break;
+	}
+
+	default:
+		__ocs_domain_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Wait for nodes to free prior to the domain shutdown.
+ *
+ * <h3 class="desc">Description</h3>
+ * All nodes are freed, and ready for a domain shutdown.
+ *
+ * @param ctx Remote node sm context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_wait_sports_free(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_ALL_CHILD_NODES_FREE: {
+		int32_t rc;
+
+		/* sm: ocs_hw_domain_free */
+		ocs_sm_transition(ctx, __ocs_domain_wait_shutdown, NULL);
+
+		/* Request ocs_hw_domain_free and wait for completion */
+		rc = ocs_hw_domain_free(&ocs->hw, domain);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_hw_domain_free() failed: %d\n", rc);
+		}
+		break;
+	}
+	default:
+		__ocs_domain_common_shutdown(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Complete the domain shutdown.
+ *
+ * <h3 class="desc">Description</h3>
+ * Waits for a HW domain free to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_wait_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_DOMAIN_FREE_OK: {
+		if (ocs->enable_ini)
+			ocs_scsi_ini_del_domain(domain);
+		if (ocs->enable_tgt)
+			ocs_scsi_tgt_del_domain(domain);
+
+		/* sm: domain_free */
+		if (domain->domain_found_pending) {
+			/* save fcf_wwn and drec from this domain, free current domain and allocate
+			 * a new one with the same fcf_wwn
+			 * TODO: could use a SLI-4 "re-register VPI" operation here
+			 */
+			uint64_t fcf_wwn = domain->fcf_wwn;
+			ocs_domain_record_t drec = domain->pending_drec;
+
+			ocs_log_debug(ocs, "Reallocating domain\n");
+			domain->req_domain_free = 1;
+			domain = ocs_domain_alloc(ocs, fcf_wwn);
+
+			if (domain == NULL) {
+				ocs_log_err(ocs, "ocs_domain_alloc() failed\n");
+				/* TODO: hw/device reset needed */
+				return NULL;
+			}
+			/*
+			 * got a new domain; at this point, there are at least two domains
+			 * once the req_domain_free flag is processed, the associated domain
+			 * will be removed.
+			 */
+			ocs_sm_transition(&domain->drvsm, __ocs_domain_init, NULL);
+			ocs_sm_post_event(&domain->drvsm, OCS_EVT_DOMAIN_FOUND, &drec);
+		} else {
+			domain->req_domain_free = 1;
+		}
+		break;
+	}
+
+	default:
+		__ocs_domain_common_shutdown(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup domain_sm
+ * @brief Domain state machine: Wait for the domain alloc/attach completion
+ * after receiving a domain lost.
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered when receiving a domain lost while waiting for a domain alloc
+ * or a domain attach to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_domain_wait_domain_lost(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_domain_state_decl();
+
+	domain_sm_trace(domain);
+
+	switch(evt) {
+	case OCS_EVT_DOMAIN_ALLOC_OK:
+	case OCS_EVT_DOMAIN_ATTACH_OK: {
+		int32_t rc;
+		ocs_domain_lock(domain);
+		if (!ocs_list_empty(&domain->sport_list)) {
+			/* if there are sports, transition to wait state and send
+			* shutdown to each sport */
+			ocs_sport_t	*sport = NULL;
+			ocs_sport_t	*sport_next = NULL;
+			ocs_sm_transition(ctx, __ocs_domain_wait_sports_free, NULL);
+			ocs_list_foreach_safe(&domain->sport_list, sport, sport_next) {
+				ocs_sm_post_event(&sport->sm, OCS_EVT_SHUTDOWN, NULL);
+			}
+			ocs_domain_unlock(domain);
+		} else {
+			ocs_domain_unlock(domain);
+			/* no sports exist, free domain */
+			ocs_sm_transition(ctx, __ocs_domain_wait_shutdown, NULL);
+			rc = ocs_hw_domain_free(&ocs->hw, domain);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_hw_domain_free() failed: %d\n", rc);
+				/* TODO: hw/device reset needed */
+			}
+		}
+		break;
+	}
+	case OCS_EVT_DOMAIN_ALLOC_FAIL:
+	case OCS_EVT_DOMAIN_ATTACH_FAIL:
+		ocs_log_err(ocs, "[domain] %-20s: failed\n", ocs_sm_event_name(evt));
+		/* TODO: hw/device reset needed */
+		break;
+
+	default:
+		__ocs_domain_common_shutdown(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+
+
+/**
+ * @brief Save the port's service parameters.
+ *
+ * <h3 class="desc">Description</h3>
+ * Service parameters from the fabric FLOGI are saved in the domain's
+ * flogi_service_params array.
+ *
+ * @param domain Pointer to the domain.
+ * @param payload Service parameters to save.
+ *
+ * @return None.
+ */
+
+void
+ocs_domain_save_sparms(ocs_domain_t *domain, void *payload)
+{
+	ocs_memcpy(domain->flogi_service_params, payload, sizeof (fc_plogi_payload_t));
+}
+/**
+ * @brief Initiator domain attach. (internal call only)
+ *
+ * Assumes that the domain SM lock is already locked
+ *
+ * <h3 class="desc">Description</h3>
+ * The HW domain attach function is started.
+ *
+ * @param domain Pointer to the domain object.
+ * @param s_id FC_ID of which to register this domain.
+ *
+ * @return None.
+ */
+
+void
+__ocs_domain_attach_internal(ocs_domain_t *domain, uint32_t s_id)
+{
+	ocs_memcpy(domain->dma.virt, ((uint8_t*)domain->flogi_service_params)+4, sizeof (fc_plogi_payload_t) - 4);
+	(void)ocs_sm_post_event(&domain->drvsm, OCS_EVT_DOMAIN_REQ_ATTACH, &s_id);
+}
+
+/**
+ * @brief Initiator domain attach.
+ *
+ * <h3 class="desc">Description</h3>
+ * The HW domain attach function is started.
+ *
+ * @param domain Pointer to the domain object.
+ * @param s_id FC_ID of which to register this domain.
+ *
+ * @return None.
+ */
+
+void
+ocs_domain_attach(ocs_domain_t *domain, uint32_t s_id)
+{
+	__ocs_domain_attach_internal(domain, s_id);
+}
+
+int
+ocs_domain_post_event(ocs_domain_t *domain, ocs_sm_event_t event, void *arg)
+{
+	int rc;
+	int accept_frames;
+	int req_domain_free;
+
+	rc = ocs_sm_post_event(&domain->drvsm, event, arg);
+
+	req_domain_free = domain->req_domain_free;
+	domain->req_domain_free = 0;
+
+	accept_frames = domain->req_accept_frames;
+	domain->req_accept_frames = 0;
+
+	if (accept_frames) {
+		ocs_domain_accept_frames(domain);
+	}
+
+	if (req_domain_free) {
+		ocs_domain_free(domain);
+	}
+
+	return rc;
+}
+
+
+/**
+ * @brief Return the WWN as a uint64_t.
+ *
+ * <h3 class="desc">Description</h3>
+ * Calls the HW property function for the WWNN or WWPN, and returns the value
+ * as a uint64_t.
+ *
+ * @param hw Pointer to the HW object.
+ * @param prop HW property.
+ *
+ * @return Returns uint64_t request value.
+ */
+
+uint64_t
+ocs_get_wwn(ocs_hw_t *hw, ocs_hw_property_e prop)
+{
+	uint8_t *p = ocs_hw_get_ptr(hw, prop);
+	uint64_t value = 0;
+
+	if (p) {
+		uint32_t i;
+		for (i = 0; i < sizeof(value); i++) {
+			value = (value << 8) | p[i];
+		}
+	}
+	return value;
+}
+
+/**
+ * @brief Generate a domain ddump.
+ *
+ * <h3 class="desc">Description</h3>
+ * Generates a domain ddump.
+ *
+ * @param textbuf Pointer to the text buffer.
+ * @param domain Pointer to the domain context.
+ *
+ * @return Returns 0 on success, or a negative value on failure.
+ */
+
+int
+ocs_ddump_domain(ocs_textbuf_t *textbuf, ocs_domain_t *domain)
+{
+	ocs_sport_t *sport;
+	int retval = 0;
+
+	ocs_ddump_section(textbuf, "domain", domain->instance_index);
+	ocs_ddump_value(textbuf, "display_name", "%s", domain->display_name);
+
+	ocs_ddump_value(textbuf, "fcf", "%#x", domain->fcf);
+	ocs_ddump_value(textbuf, "fcf_indicator", "%#x", domain->fcf_indicator);
+	ocs_ddump_value(textbuf, "vlan_id", "%#x", domain->vlan_id);
+	ocs_ddump_value(textbuf, "indicator", "%#x", domain->indicator);
+	ocs_ddump_value(textbuf, "attached", "%d", domain->attached);
+	ocs_ddump_value(textbuf, "is_loop", "%d", domain->is_loop);
+	ocs_ddump_value(textbuf, "is_nlport", "%d", domain->is_nlport);
+
+	ocs_scsi_ini_ddump(textbuf, OCS_SCSI_DDUMP_DOMAIN, domain);
+	ocs_scsi_tgt_ddump(textbuf, OCS_SCSI_DDUMP_DOMAIN, domain);
+
+	ocs_display_sparams(NULL, "domain_sparms", 1, textbuf, domain->dma.virt);
+
+	if (ocs_domain_lock_try(domain) != TRUE) {
+		/* Didn't get the lock */
+		return -1;
+	}
+		ocs_list_foreach(&domain->sport_list, sport) {
+			retval = ocs_ddump_sport(textbuf, sport);
+			if (retval != 0) {
+				break;
+			}
+		}
+
+#if defined(ENABLE_FABRIC_EMULATION)
+		ocs_ddump_ns(textbuf, domain->ocs_ns);
+#endif
+
+	ocs_domain_unlock(domain);
+
+	ocs_ddump_endsection(textbuf, "domain", domain->instance_index);
+
+	return retval;
+}
+
+
+void
+ocs_mgmt_domain_list(ocs_textbuf_t *textbuf, void *object)
+{
+	ocs_sport_t *sport;
+	ocs_domain_t *domain = (ocs_domain_t *)object;
+
+	ocs_mgmt_start_section(textbuf, "domain", domain->instance_index);
+
+	/* Add my status values to textbuf */
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "fcf");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "fcf_indicator");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "vlan_id");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "indicator");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "attached");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "is_loop");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "display_name");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "num_sports");
+#if defined(ENABLE_FABRIC_EMULATION)
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RW, "femul_enable");
+#endif
+
+	if (ocs_domain_lock_try(domain) == TRUE) {
+
+
+		/* If we get here, then we are holding the domain lock */
+		ocs_list_foreach(&domain->sport_list, sport) {
+			if ((sport->mgmt_functions) && (sport->mgmt_functions->get_list_handler)) {
+				sport->mgmt_functions->get_list_handler(textbuf, sport);
+			}
+		}
+		ocs_domain_unlock(domain);
+	}
+
+	ocs_mgmt_end_section(textbuf, "domain", domain->instance_index);
+}
+
+int
+ocs_mgmt_domain_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
+{
+	ocs_sport_t *sport;
+	ocs_domain_t *domain = (ocs_domain_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	ocs_mgmt_start_section(textbuf, "domain", domain->instance_index);
+
+	snprintf(qualifier, sizeof(qualifier), "%s/domain[%d]", parent, domain->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = name + strlen(qualifier) +1;
+
+		/* See if it's a value I can supply */
+		if (ocs_strcmp(unqualified_name, "display_name") == 0) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", domain->display_name);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "fcf") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fcf", "%#x", domain->fcf);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "fcf_indicator") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fcf_indicator", "%#x", domain->fcf_indicator);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "vlan_id") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "vlan_id", "%#x", domain->vlan_id);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "indicator") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "indicator", "%#x", domain->indicator);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "attached") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "attached", domain->attached);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "is_loop") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_loop",  domain->is_loop);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "is_nlport") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_nlport",  domain->is_nlport);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "display_name") == 0) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", domain->display_name);
+			retval = 0;
+#if defined(ENABLE_FABRIC_EMULATION)
+		} else if (ocs_strcmp(unqualified_name, "femul_enable") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "femul_enable", "%d", domain->femul_enable);
+			retval = 0;
+#endif
+		} else if (ocs_strcmp(unqualified_name, "num_sports") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_sports", "%d", domain->sport_instance_count);
+			retval = 0;
+		} else {
+			/* If I didn't know the value of this status pass the request to each of my children */
+
+			ocs_domain_lock(domain);
+			ocs_list_foreach(&domain->sport_list, sport) {
+				if ((sport->mgmt_functions) && (sport->mgmt_functions->get_handler)) {
+					retval = sport->mgmt_functions->get_handler(textbuf, qualifier, name, sport);
+				}
+
+				if (retval == 0) {
+					break;
+				}
+
+			}
+			ocs_domain_unlock(domain);
+		}
+	}
+
+	ocs_mgmt_end_section(textbuf, "domain", domain->instance_index);
+	return retval;
+}
+
+void
+ocs_mgmt_domain_get_all(ocs_textbuf_t *textbuf, void *object)
+{
+	ocs_sport_t *sport;
+	ocs_domain_t *domain = (ocs_domain_t *)object;
+
+	ocs_mgmt_start_section(textbuf, "domain", domain->instance_index);
+
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", domain->display_name);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fcf", "%#x", domain->fcf);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fcf_indicator", "%#x", domain->fcf_indicator);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "vlan_id", "%#x", domain->vlan_id);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "indicator", "%#x", domain->indicator);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "attached", domain->attached);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_loop",  domain->is_loop);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_nlport",  domain->is_nlport);
+#if defined(ENABLE_FABRIC_EMULATION)
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "femul_enable", "%d", domain->femul_enable);
+#endif
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "num_sports",  "%d", domain->sport_instance_count);
+
+	ocs_domain_lock(domain);
+	ocs_list_foreach(&domain->sport_list, sport) {
+		if ((sport->mgmt_functions) && (sport->mgmt_functions->get_all_handler)) {
+			sport->mgmt_functions->get_all_handler(textbuf, sport);
+		}
+	}
+	ocs_domain_unlock(domain);
+
+
+	ocs_mgmt_end_unnumbered_section(textbuf, "domain");
+
+}
+
+int
+ocs_mgmt_domain_set(char *parent, char *name, char *value, void *object)
+{
+	ocs_sport_t *sport;
+	ocs_domain_t *domain = (ocs_domain_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	snprintf(qualifier, sizeof(qualifier), "%s/domain[%d]", parent, domain->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+
+		/* See if it's a value I can supply */
+
+		/* if (ocs_strcmp(unqualified_name, "display_name") == 0) {
+
+		} else */
+		{
+			/* If I didn't know the value of this status pass the request to each of my children */
+			ocs_domain_lock(domain);
+			ocs_list_foreach(&domain->sport_list, sport) {
+				if ((sport->mgmt_functions) && (sport->mgmt_functions->set_handler)) {
+					retval = sport->mgmt_functions->set_handler(qualifier, name, value, sport);
+				}
+
+				if (retval == 0) {
+					break;
+				}
+
+			}
+			ocs_domain_unlock(domain);
+		}
+	}
+
+	return retval;
+}
+
+int
+ocs_mgmt_domain_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
+			void *arg_out, uint32_t arg_out_length, void *object)
+{
+	ocs_sport_t *sport;
+	ocs_domain_t *domain = (ocs_domain_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	snprintf(qualifier, sizeof(qualifier), "%s.domain%d", parent, domain->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(action, qualifier, strlen(qualifier)) == 0) {
+
+		{
+			/* If I didn't know how to do this action pass the request to each of my children */
+			ocs_domain_lock(domain);
+			ocs_list_foreach(&domain->sport_list, sport) {
+				if ((sport->mgmt_functions) && (sport->mgmt_functions->exec_handler)) {
+					retval = sport->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length, arg_out, arg_out_length, sport);
+				}
+
+				if (retval == 0) {
+					break;
+				}
+
+			}
+			ocs_domain_unlock(domain);
+		}
+	}
+
+	return retval;
+}
diff --git a/sys/dev/ocs_fc/ocs_domain.h b/sys/dev/ocs_fc/ocs_domain.h
new file mode 100644
index 000000000000..1522a3c22687
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_domain.h
@@ -0,0 +1,91 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Declare driver's domain handler exported interface
+ */
+
+#if !defined(__OCS_DOMAIN_H__)
+#define __OCS_DOMAIN_H__
+extern int32_t ocs_domain_init(ocs_t *ocs, ocs_domain_t *domain);
+extern ocs_domain_t *ocs_domain_find(ocs_t *ocs, uint64_t fcf_wwn);
+extern ocs_domain_t *ocs_domain_alloc(ocs_t *ocs, uint64_t fcf_wwn);
+extern void ocs_domain_free(ocs_domain_t *domain);
+extern void ocs_domain_force_free(ocs_domain_t *domain);
+extern void ocs_register_domain_list_empty_cb(ocs_t *ocs, void (*callback)(ocs_t *ocs, void *arg), void *arg);
+extern uint64_t ocs_get_wwn(ocs_hw_t *hw, ocs_hw_property_e prop);
+
+static inline void
+ocs_domain_lock_init(ocs_domain_t *domain)
+{
+}
+
+static inline int32_t
+ocs_domain_lock_try(ocs_domain_t *domain)
+{
+	/* Use the device wide lock */
+	return ocs_device_lock_try(domain->ocs);
+}
+
+static inline void
+ocs_domain_lock(ocs_domain_t *domain)
+{
+	/* Use the device wide lock */
+	ocs_device_lock(domain->ocs);
+}
+
+static inline void
+ocs_domain_unlock(ocs_domain_t *domain)
+{
+	/* Use the device wide lock */
+	ocs_device_unlock(domain->ocs);
+}
+
+extern int32_t ocs_domain_cb(void *arg, ocs_hw_domain_event_e event, void *data);
+extern void *__ocs_domain_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_domain_wait_alloc(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_domain_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_domain_wait_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_domain_ready(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_domain_wait_sports_free(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_domain_wait_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_domain_wait_domain_lost(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern void ocs_domain_save_sparms(ocs_domain_t *domain, void *payload);
+extern void ocs_domain_attach(ocs_domain_t *domain, uint32_t s_id);
+extern int ocs_domain_post_event(ocs_domain_t *domain, ocs_sm_event_t, void *);
+
+extern int ocs_ddump_domain(ocs_textbuf_t *textbuf, ocs_domain_t *domain);
+extern void __ocs_domain_attach_internal(ocs_domain_t *domain, uint32_t s_id);;
+#endif
diff --git a/sys/dev/ocs_fc/ocs_drv_fc.h b/sys/dev/ocs_fc/ocs_drv_fc.h
new file mode 100644
index 000000000000..95684e30354f
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_drv_fc.h
@@ -0,0 +1,212 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS linux driver common include file
+ */
+
+
+#if !defined(__OCS_DRV_FC_H__)
+#define __OCS_DRV_FC_H__
+
+#define OCS_INCLUDE_FC
+
+#include "ocs_os.h"
+#include "ocs_debug.h"
+#include "ocs_common.h"
+#include "ocs_hw.h"
+#include "ocs_io.h"
+#include "ocs_pm.h"
+#include "ocs_xport.h"
+#include "ocs_stats.h"
+
+struct ocs_s {
+
+	ocs_os_t ocs_os;
+	char display_name[OCS_DISPLAY_NAME_LENGTH];
+	ocs_rlock_t lock;			/*>> Device wide lock */
+	ocs_list_t domain_list;			/*>> linked list of virtual fabric objects */
+	ocs_io_pool_t *io_pool;			/**< pointer to IO pool */
+	ocs_ramlog_t *ramlog;
+	ocs_drv_t drv_ocs;
+	ocs_scsi_tgt_t tgt_ocs;
+	ocs_scsi_ini_t ini_ocs;
+	ocs_xport_e ocs_xport;
+	ocs_xport_t *xport;			/*>> Pointer to transport object */
+	bool enable_ini;
+	bool enable_tgt;
+	uint8_t fc_type;
+	int ctrlmask;
+	int logmask;
+	uint32_t max_isr_time_msec;		/*>> Maximum ISR time */
+	char *hw_war_version;
+	ocs_pm_context_t pm_context;		/*<< power management context */
+	ocs_mgmt_functions_t *mgmt_functions;
+	ocs_mgmt_functions_t *tgt_mgmt_functions;
+	ocs_mgmt_functions_t *ini_mgmt_functions;
+	ocs_err_injection_e err_injection;	/**< for error injection testing */
+	uint32_t cmd_err_inject;		/**< specific cmd to inject error into */
+	time_t delay_value_msec;		/**< for injecting delays */
+
+	const char *desc;
+	uint32_t instance_index;
+	uint16_t pci_vendor;
+	uint16_t pci_device;
+	uint16_t pci_subsystem_vendor;
+	uint16_t pci_subsystem_device;
+	char businfo[OCS_DISPLAY_BUS_INFO_LENGTH];
+
+	const char *model;
+	const char *driver_version;
+	const char *fw_version;
+
+	ocs_hw_t hw;
+
+	ocs_domain_t *domain;			/*>> pointer to first (physical) domain (also on domain_list) */
+	uint32_t domain_instance_count;			/*>> domain instance count */
+	void (*domain_list_empty_cb)(ocs_t *ocs, void *arg); /*>> domain list empty callback */
+	void *domain_list_empty_cb_arg;                 /*>> domain list empty callback argument */
+
+	bool explicit_buffer_list;
+	bool external_loopback;
+	uint32_t num_vports;
+	uint32_t hw_bounce;
+	uint32_t rq_threads;
+	uint32_t rq_selection_policy;
+	uint32_t rr_quanta;
+	char *filter_def;
+	uint32_t max_remote_nodes;
+
+	bool soft_wwn_enable;
+
+	/*
+	 * tgt_rscn_delay - delay in kicking off RSCN processing (nameserver queries)
+	 * after receiving an RSCN on the target. This prevents thrashing of nameserver
+	 * requests due to a huge burst of RSCNs received in a short period of time
+	 * Note: this is only valid when target RSCN handling is enabled -- see ctrlmask.
+	 */
+	time_t tgt_rscn_delay_msec;		/*>> minimum target RSCN delay */
+
+	/*
+	 * tgt_rscn_period - determines maximum frequency when processing back-to-back
+	 * RSCNs; e.g. if this value is 30, there will never be any more than 1 RSCN
+	 * handling per 30s window. This prevents initiators on a faulty link generating
+	 * many RSCN from causing the target to continually query the nameserver. Note:
+	 * this is only valid when target RSCN handling is enabled
+	 */
+	time_t tgt_rscn_period_msec;		/*>> minimum target RSCN period */
+
+	/*
+	 * Target IO timer value:
+	 * Zero: target command timeout disabled.
+	 * Non-zero: Timeout value, in seconds, for target commands
+	 */
+	uint32_t target_io_timer_sec;
+
+	int speed;
+	int topology;
+	int ethernet_license;
+	int num_scsi_ios;
+	bool enable_hlm;			/*>> high login mode is enabled */
+	uint32_t hlm_group_size;		/*>> RPI count for high login mode */
+	char *wwn_bump;
+	uint32_t nodedb_mask;			/*>> Node debugging mask */
+
+	uint32_t auto_xfer_rdy_size;		/*>> Maximum sized write to use auto xfer rdy */
+        bool  esoc;
+	uint8_t ocs_req_fw_upgrade;
+
+	ocs_textbuf_t ddump_saved;
+
+};
+
+#define ocs_is_fc_initiator_enabled()	(ocs->enable_ini)
+#define ocs_is_fc_target_enabled()	(ocs->enable_tgt)
+
+static inline void
+ocs_device_lock_init(ocs_t *ocs)
+{
+	ocs_rlock_init(ocs, &ocs->lock, "ocsdevicelock");
+}
+static inline void
+ocs_device_lock_free(ocs_t *ocs)
+{
+	ocs_rlock_free(&ocs->lock);
+}
+static inline int32_t
+ocs_device_lock_try(ocs_t *ocs)
+{
+	return ocs_rlock_try(&ocs->lock);
+}
+static inline void
+ocs_device_lock(ocs_t *ocs)
+{
+	ocs_rlock_acquire(&ocs->lock);
+}
+static inline void
+ocs_device_unlock(ocs_t *ocs)
+{
+	ocs_rlock_release(&ocs->lock);
+}
+
+extern ocs_t *ocs_get_instance(uint32_t index);
+extern int32_t ocs_get_bus_dev_func(ocs_t *ocs, uint8_t* bus, uint8_t* dev, uint8_t* func);
+
+static inline ocs_io_t *
+ocs_io_alloc(ocs_t *ocs)
+{
+	return ocs_io_pool_io_alloc(ocs->xport->io_pool);
+}
+
+static inline void
+ocs_io_free(ocs_t *ocs, ocs_io_t *io)
+{
+	ocs_io_pool_io_free(ocs->xport->io_pool, io);
+}
+
+extern void ocs_stop_event_processing(ocs_os_t *ocs_os);
+extern int32_t ocs_start_event_processing(ocs_os_t *ocs_os);
+
+#include "ocs_domain.h"
+#include "ocs_sport.h"
+#include "ocs_node.h"
+#include "ocs_io.h"
+#include "ocs_unsol.h"
+#include "ocs_scsi.h"
+
+#include "ocs_ioctl.h"
+#include "ocs_elxu.h"
+
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_els.c b/sys/dev/ocs_fc/ocs_els.c
new file mode 100644
index 000000000000..6f19eaf15947
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_els.c
@@ -0,0 +1,2777 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Functions to build and send ELS/CT/BLS commands and responses.
+ */
+
+/*!
+@defgroup els_api ELS/BLS/CT Command and Response Functions
+*/
+
+#include "ocs.h"
+#include "ocs_els.h"
+#include "ocs_scsi.h"
+#include "ocs_device.h"
+
+#define ELS_IOFMT "[i:%04x t:%04x h:%04x]"
+#define ELS_IOFMT_ARGS(els) els->init_task_tag, els->tgt_task_tag, els->hw_tag
+
+#define node_els_trace()  \
+	do { \
+		if (OCS_LOG_ENABLE_ELS_TRACE(ocs)) \
+			ocs_log_info(ocs, "[%s] %-20s\n", node->display_name, __func__); \
+	} while (0)
+
+#define els_io_printf(els, fmt, ...) \
+	ocs_log_debug(els->node->ocs, "[%s]" ELS_IOFMT " %-8s " fmt, els->node->display_name, ELS_IOFMT_ARGS(els), els->display_name, ##__VA_ARGS__);
+
+static int32_t ocs_els_send(ocs_io_t *els, uint32_t reqlen, uint32_t timeout_sec, ocs_hw_srrs_cb_t cb);
+static int32_t ocs_els_send_rsp(ocs_io_t *els, uint32_t rsplen);
+static int32_t ocs_els_acc_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *arg);
+static ocs_io_t *ocs_bls_send_acc(ocs_io_t *io, uint32_t s_id, uint16_t ox_id, uint16_t rx_id);
+static int32_t ocs_bls_send_acc_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length,
+	int32_t status, uint32_t ext_status, void *app);
+static void ocs_io_transition(ocs_io_t *els, ocs_sm_function_t state, void *data);
+static ocs_io_t *ocs_els_abort_io(ocs_io_t *els, int send_abts);
+static void _ocs_els_io_free(void *arg);
+static void ocs_els_delay_timer_cb(void *arg);
+
+
+/**
+ * @ingroup els_api
+ * @brief ELS state machine transition wrapper.
+ *
+ * <h3 class="desc">Description</h3>
+ * This function is the transition wrapper for the ELS state machine. It grabs
+ * the node lock prior to making the transition to protect
+ * against multiple threads accessing a particular ELS. For example,
+ * one thread transitioning from __els_init to
+ * __ocs_els_wait_resp and another thread (tasklet) handling the
+ * completion of that ELS request.
+ *
+ * @param els Pointer to the IO context.
+ * @param state State to transition to.
+ * @param data Data to pass in with the transition.
+ *
+ * @return None.
+ */
+static void
+ocs_io_transition(ocs_io_t *els, ocs_sm_function_t state, void *data)
+{
+	/* protect ELS events with node lock */
+	ocs_node_t *node = els->node;
+	ocs_node_lock(node);
+		ocs_sm_transition(&els->els_sm, state, data);
+	ocs_node_unlock(node);
+}
+
+/**
+ * @ingroup els_api
+ * @brief ELS state machine post event wrapper.
+ *
+ * <h3 class="desc">Description</h3>
+ * Post an event wrapper for the ELS state machine. This function grabs
+ * the node lock prior to posting the event.
+ *
+ * @param els Pointer to the IO context.
+ * @param evt Event to process.
+ * @param data Data to pass in with the transition.
+ *
+ * @return None.
+ */
+void
+ocs_els_post_event(ocs_io_t *els, ocs_sm_event_t evt, void *data)
+{
+	/* protect ELS events with node lock */
+	ocs_node_t *node = els->node;
+	ocs_node_lock(node);
+		els->els_evtdepth ++;
+		ocs_sm_post_event(&els->els_sm, evt, data);
+		els->els_evtdepth --;
+	ocs_node_unlock(node);
+	if (els->els_evtdepth == 0 && els->els_req_free) {
+		ocs_els_io_free(els);
+	}
+}
+
+/**
+ * @ingroup els_api
+ * @brief Allocate an IO structure for an ELS IO context.
+ *
+ * <h3 class="desc">Description</h3>
+ * Allocate an IO for an ELS context.  Uses OCS_ELS_RSP_LEN as response size.
+ *
+ * @param node node to associate ELS IO with
+ * @param reqlen Length of ELS request
+ * @param role Role of ELS (originator/responder)
+ *
+ * @return pointer to IO structure allocated
+ */
+
+ocs_io_t *
+ocs_els_io_alloc(ocs_node_t *node, uint32_t reqlen, ocs_els_role_e role)
+{
+	return ocs_els_io_alloc_size(node, reqlen, OCS_ELS_RSP_LEN, role);
+}
+
+/**
+ * @ingroup els_api
+ * @brief Allocate an IO structure for an ELS IO context.
+ *
+ * <h3 class="desc">Description</h3>
+ * Allocate an IO for an ELS context, allowing the caller to specify the size of the response.
+ *
+ * @param node node to associate ELS IO with
+ * @param reqlen Length of ELS request
+ * @param rsplen Length of ELS response
+ * @param role Role of ELS (originator/responder)
+ *
+ * @return pointer to IO structure allocated
+ */
+
+ocs_io_t *
+ocs_els_io_alloc_size(ocs_node_t *node, uint32_t reqlen, uint32_t rsplen, ocs_els_role_e role)
+{
+
+	ocs_t *ocs;
+	ocs_xport_t *xport;
+	ocs_io_t *els;
+	ocs_assert(node, NULL);
+	ocs_assert(node->ocs, NULL);
+	ocs = node->ocs;
+	ocs_assert(ocs->xport, NULL);
+	xport = ocs->xport;
+
+	ocs_lock(&node->active_ios_lock);
+		if (!node->io_alloc_enabled) {
+			ocs_log_debug(ocs, "called with io_alloc_enabled = FALSE\n");
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		els = ocs_io_alloc(ocs);
+		if (els == NULL) {
+			ocs_atomic_add_return(&xport->io_alloc_failed_count, 1);
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		/* initialize refcount */
+		ocs_ref_init(&els->ref, _ocs_els_io_free, els);
+
+		switch (role) {
+		case OCS_ELS_ROLE_ORIGINATOR:
+			els->cmd_ini = TRUE;
+			els->cmd_tgt = FALSE;
+			break;
+		case OCS_ELS_ROLE_RESPONDER:
+			els->cmd_ini = FALSE;
+			els->cmd_tgt = TRUE;
+			break;
+		}
+
+		/* IO should not have an associated HW IO yet.  Assigned below. */
+		if (els->hio != NULL) {
+			ocs_log_err(ocs, "assertion failed.  HIO is not null\n");
+			ocs_io_free(ocs, els);
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		/* populate generic io fields */
+		els->ocs = ocs;
+		els->node = node;
+
+		/* set type and ELS-specific fields */
+		els->io_type = OCS_IO_TYPE_ELS;
+		els->display_name = "pending";
+
+		if (reqlen > OCS_ELS_REQ_LEN) {
+			ocs_log_err(ocs, "ELS command request len greater than allocated\n");
+			ocs_io_free(ocs, els);
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		if (rsplen > OCS_ELS_GID_PT_RSP_LEN) {
+			ocs_log_err(ocs, "ELS command response len: %d "
+				"greater than allocated\n", rsplen);
+			ocs_io_free(ocs, els);
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		els->els_req.size = reqlen;
+		els->els_rsp.size = rsplen;
+
+		if (els != NULL) {
+			ocs_memset(&els->els_sm, 0, sizeof(els->els_sm));
+			els->els_sm.app = els;
+
+			/* initialize fields */
+			els->els_retries_remaining = OCS_FC_ELS_DEFAULT_RETRIES;
+			els->els_evtdepth = 0;
+			els->els_pend = 0;
+			els->els_active = 0;
+
+			/* add els structure to ELS IO list */
+			ocs_list_add_tail(&node->els_io_pend_list, els);
+			els->els_pend = 1;
+		}
+	ocs_unlock(&node->active_ios_lock);
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Free IO structure for an ELS IO context.
+ *
+ * <h3 class="desc">Description</h3> Free IO for an ELS
+ * IO context
+ *
+ * @param els ELS IO structure for which IO is allocated
+ *
+ * @return None
+ */
+
+void
+ocs_els_io_free(ocs_io_t *els)
+{
+	ocs_ref_put(&els->ref);
+}
+
+/**
+ * @ingroup els_api
+ * @brief Free IO structure for an ELS IO context.
+ *
+ * <h3 class="desc">Description</h3> Free IO for an ELS
+ * IO context
+ *
+ * @param arg ELS IO structure for which IO is allocated
+ *
+ * @return None
+ */
+
+static void
+_ocs_els_io_free(void *arg)
+{
+	ocs_io_t *els = (ocs_io_t *)arg;
+	ocs_t *ocs;
+	ocs_node_t *node;
+	int send_empty_event = FALSE;
+
+	ocs_assert(els);
+	ocs_assert(els->node);
+	ocs_assert(els->node->ocs);
+	ocs = els->node->ocs;
+
+	node = els->node;
+	ocs = node->ocs;
+
+	ocs_lock(&node->active_ios_lock);
+		if (els->els_active) {
+			/* if active, remove from active list and check empty */
+			ocs_list_remove(&node->els_io_active_list, els);
+			/* Send list empty event if the IO allocator is disabled, and the list is empty
+			 * If node->io_alloc_enabled was not checked, the event would be posted continually
+			 */
+			send_empty_event = (!node->io_alloc_enabled) && ocs_list_empty(&node->els_io_active_list);
+			els->els_active = 0;
+		} else if (els->els_pend) {
+			/* if pending, remove from pending list; node shutdown isn't
+			 * gated off the pending list (only the active list), so no
+			 * need to check if pending list is empty
+			 */
+			ocs_list_remove(&node->els_io_pend_list, els);
+			els->els_pend = 0;
+		} else {
+			ocs_log_err(ocs, "assertion failed: niether els->els_pend nor els->active set\n");
+			ocs_unlock(&node->active_ios_lock);
+			return;
+		}
+
+	ocs_unlock(&node->active_ios_lock);
+
+	ocs_io_free(ocs, els);
+
+	if (send_empty_event) {
+		ocs_node_post_event(node, OCS_EVT_ALL_CHILD_NODES_FREE, NULL);
+	}
+
+	ocs_scsi_check_pending(ocs);
+}
+
+/**
+ * @ingroup els_api
+ * @brief Make ELS IO active
+ *
+ * @param els Pointer to the IO context to make active.
+ *
+ * @return Returns 0 on success; or a negative error code value on failure.
+ */
+
+static void
+ocs_els_make_active(ocs_io_t *els)
+{
+	ocs_node_t *node = els->node;
+
+	/* move ELS from pending list to active list */
+	ocs_lock(&node->active_ios_lock);
+		if (els->els_pend) {
+			if (els->els_active) {
+				ocs_log_err(node->ocs, "assertion failed: both els->els_pend and els->active set\n");
+				ocs_unlock(&node->active_ios_lock);
+				return;
+			} else {
+
+				/* remove from pending list */
+				ocs_list_remove(&node->els_io_pend_list, els);
+				els->els_pend = 0;
+
+				/* add els structure to ELS IO list */
+				ocs_list_add_tail(&node->els_io_active_list, els);
+				els->els_active = 1;
+			}
+		} else {
+			/* must be retrying; make sure it's already active */
+			if (!els->els_active) {
+				ocs_log_err(node->ocs, "assertion failed: niether els->els_pend nor els->active set\n");
+			}
+		}
+	ocs_unlock(&node->active_ios_lock);
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send the ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * The command, given by the \c els IO context, is sent to the node that the IO was
+ * configured with, using ocs_hw_srrs_send(). Upon completion,
+ * the \c cb callback is invoked,
+ * with the application-specific argument set to the \c els IO context.
+ *
+ * @param els Pointer to the IO context.
+ * @param reqlen Byte count in the payload to send.
+ * @param timeout_sec Command timeout, in seconds (0 -> 2*R_A_TOV).
+ * @param cb Completion callback.
+ *
+ * @return Returns 0 on success; or a negative error code value on failure.
+ */
+
+static int32_t
+ocs_els_send(ocs_io_t *els, uint32_t reqlen, uint32_t timeout_sec, ocs_hw_srrs_cb_t cb)
+{
+	ocs_node_t *node = els->node;
+
+	/* update ELS request counter */
+	node->els_req_cnt++;
+
+	/* move ELS from pending list to active list */
+	ocs_els_make_active(els);
+
+	els->wire_len = reqlen;
+	return ocs_scsi_io_dispatch(els, cb);
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send the ELS response.
+ *
+ * <h3 class="desc">Description</h3>
+ * The ELS response, given by the \c els IO context, is sent to the node
+ * that the IO was configured with, using ocs_hw_srrs_send().
+ *
+ * @param els Pointer to the IO context.
+ * @param rsplen Byte count in the payload to send.
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+static int32_t
+ocs_els_send_rsp(ocs_io_t *els, uint32_t rsplen)
+{
+	ocs_node_t *node = els->node;
+
+	/* increment ELS completion counter */
+	node->els_cmpl_cnt++;
+
+	/* move ELS from pending list to active list */
+	ocs_els_make_active(els);
+
+	els->wire_len = rsplen;
+	return ocs_scsi_io_dispatch(els, ocs_els_acc_cb);
+}
+
+/**
+ * @ingroup els_api
+ * @brief Handle ELS IO request completions.
+ *
+ * <h3 class="desc">Description</h3>
+ * This callback is used for several ELS send operations.
+ *
+ * @param hio Pointer to the HW IO context that completed.
+ * @param rnode Pointer to the remote node.
+ * @param length Length of the returned payload data.
+ * @param status Status of the completion.
+ * @param ext_status Extended status of the completion.
+ * @param arg Application-specific argument (generally a pointer to the ELS IO context).
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+static int32_t
+ocs_els_req_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *arg)
+{
+	ocs_io_t *els;
+	ocs_node_t *node;
+	ocs_t *ocs;
+	ocs_node_cb_t cbdata;
+	ocs_io_t *io;
+
+	ocs_assert(arg, -1);
+	io = arg;
+	els = io;
+	ocs_assert(els, -1);
+	ocs_assert(els->node, -1);
+	node = els->node;
+	ocs_assert(node->ocs, -1);
+	ocs = node->ocs;
+
+	ocs_assert(io->hio, -1);
+	ocs_assert(hio == io->hio, -1);
+
+	if (status != 0) {
+		els_io_printf(els, "status x%x ext x%x\n", status, ext_status);
+	}
+
+	/* set the response len element of els->rsp */
+	els->els_rsp.len = length;
+
+	cbdata.status = status;
+	cbdata.ext_status = ext_status;
+	cbdata.header = NULL;
+	cbdata.els = els;
+
+	/* FW returns the number of bytes received on the link in
+	 * the WCQE, not the amount placed in the buffer; use this info to
+	 * check if there was an overrun.
+	 */
+	if (length > els->els_rsp.size) {
+		ocs_log_warn(ocs, "ELS response returned len=%d > buflen=%zu\n",
+				length, els->els_rsp.size);
+		ocs_els_post_event(els, OCS_EVT_SRRS_ELS_REQ_FAIL, &cbdata);
+		return 0;
+	}
+
+	/* Post event to ELS IO object */
+	switch (status) {
+	case SLI4_FC_WCQE_STATUS_SUCCESS:
+		ocs_els_post_event(els, OCS_EVT_SRRS_ELS_REQ_OK, &cbdata);
+		break;
+
+	case SLI4_FC_WCQE_STATUS_LS_RJT:
+		ocs_els_post_event(els, OCS_EVT_SRRS_ELS_REQ_RJT, &cbdata);
+		break;
+
+
+	case SLI4_FC_WCQE_STATUS_LOCAL_REJECT:
+		switch (ext_status) {
+		case SLI4_FC_LOCAL_REJECT_SEQUENCE_TIMEOUT:
+			ocs_els_post_event(els, OCS_EVT_ELS_REQ_TIMEOUT, &cbdata);
+			break;
+		case SLI4_FC_LOCAL_REJECT_ABORT_REQUESTED:
+			ocs_els_post_event(els, OCS_EVT_ELS_REQ_ABORTED, &cbdata);
+			break;
+		default:
+			ocs_els_post_event(els, OCS_EVT_SRRS_ELS_REQ_FAIL, &cbdata);
+			break;
+		}
+		break;
+	default:
+		ocs_log_warn(ocs, "els req complete: failed status x%x, ext_status, x%x\n", status, ext_status);
+		ocs_els_post_event(els, OCS_EVT_SRRS_ELS_REQ_FAIL, &cbdata);
+		break;
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Handle ELS IO accept/response completions.
+ *
+ * <h3 class="desc">Description</h3>
+ * This callback is used for several ELS send operations.
+ *
+ * @param hio Pointer to the HW IO context that completed.
+ * @param rnode Pointer to the remote node.
+ * @param length Length of the returned payload data.
+ * @param status Status of the completion.
+ * @param ext_status Extended status of the completion.
+ * @param arg Application-specific argument (generally a pointer to the ELS IO context).
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+static int32_t
+ocs_els_acc_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *arg)
+{
+	ocs_io_t *els;
+	ocs_node_t *node;
+	ocs_t *ocs;
+	ocs_node_cb_t cbdata;
+	ocs_io_t *io;
+
+	ocs_assert(arg, -1);
+	io = arg;
+	els = io;
+	ocs_assert(els, -1);
+	ocs_assert(els->node, -1);
+	node = els->node;
+	ocs_assert(node->ocs, -1);
+	ocs = node->ocs;
+
+	ocs_assert(io->hio, -1);
+	ocs_assert(hio == io->hio, -1);
+
+	cbdata.status = status;
+	cbdata.ext_status = ext_status;
+	cbdata.header = NULL;
+	cbdata.els = els;
+
+	/* Post node event */
+	switch (status) {
+	case SLI4_FC_WCQE_STATUS_SUCCESS:
+		ocs_node_post_event(node, OCS_EVT_SRRS_ELS_CMPL_OK, &cbdata);
+		break;
+
+	default:
+		ocs_log_warn(ocs, "[%s] %-8s failed status x%x, ext_status x%x\n",
+			node->display_name, els->display_name, status, ext_status);
+		ocs_log_warn(ocs, "els acc complete: failed status x%x, ext_status, x%x\n", status, ext_status);
+		ocs_node_post_event(node, OCS_EVT_SRRS_ELS_CMPL_FAIL, &cbdata);
+		break;
+	}
+
+	/* If this IO has a callback, invoke it */
+	if (els->els_callback) {
+		(*els->els_callback)(node, &cbdata, els->els_callback_arg);
+	}
+
+	ocs_els_io_free(els);
+
+	return 0;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Format and send a PLOGI ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a PLOGI payload using the domain SLI port service parameters,
+ * and send to the \c node.
+ *
+ * @param node Node to which the PLOGI is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_plogi(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	void (*cb)(ocs_node_t *node, ocs_node_cb_t *cbdata, void *arg), void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fc_plogi_payload_t *plogi;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*plogi), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "plogi";
+
+		/* Build PLOGI request */
+		plogi = els->els_req.virt;
+
+		ocs_memcpy(plogi, node->sport->service_params, sizeof(*plogi));
+
+		plogi->command_code = FC_ELS_CMD_PLOGI;
+		plogi->resv1 = 0;
+
+		ocs_display_sparams(node->display_name, "plogi send req", 0, NULL, plogi->common_service_parameters);
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+
+		ocs_io_transition(els, __ocs_els_init, NULL);
+
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Format and send a FLOGI ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct an FLOGI payload, and send to the \c node.
+ *
+ * @param node Node to which the FLOGI is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_flogi(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs;
+	fc_plogi_payload_t *flogi;
+
+	ocs_assert(node, NULL);
+	ocs_assert(node->ocs, NULL);
+	ocs_assert(node->sport, NULL);
+	ocs = node->ocs;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*flogi), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "flogi";
+
+		/* Build FLOGI request */
+		flogi = els->els_req.virt;
+
+		ocs_memcpy(flogi, node->sport->service_params, sizeof(*flogi));
+		flogi->command_code = FC_ELS_CMD_FLOGI;
+		flogi->resv1 = 0;
+
+		/* Priority tagging support */
+		flogi->common_service_parameters[1] |= ocs_htobe32(1U << 23);
+
+		ocs_display_sparams(node->display_name, "flogi send req", 0, NULL, flogi->common_service_parameters);
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Format and send a FDISC ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct an FDISC payload, and send to the \c node.
+ *
+ * @param node Node to which the FDISC is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_fdisc(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs;
+	fc_plogi_payload_t *fdisc;
+
+	ocs_assert(node, NULL);
+	ocs_assert(node->ocs, NULL);
+	ocs = node->ocs;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*fdisc), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "fdisc";
+
+		/* Build FDISC request */
+		fdisc = els->els_req.virt;
+
+		ocs_memcpy(fdisc, node->sport->service_params, sizeof(*fdisc));
+		fdisc->command_code = FC_ELS_CMD_FDISC;
+		fdisc->resv1 = 0;
+
+		ocs_display_sparams(node->display_name, "fdisc send req", 0, NULL, fdisc->common_service_parameters);
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a PRLI ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a PRLI ELS command, and send to the \c node.
+ *
+ * @param node Node to which the PRLI is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_prli(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_t *ocs = node->ocs;
+	ocs_io_t *els;
+	fc_prli_payload_t *prli;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*prli), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "prli";
+
+		/* Build PRLI request */
+		prli = els->els_req.virt;
+
+		ocs_memset(prli, 0, sizeof(*prli));
+
+		prli->command_code = FC_ELS_CMD_PRLI;
+		prli->page_length = 16;
+		prli->payload_length = ocs_htobe16(sizeof(fc_prli_payload_t));
+		prli->type = FC_TYPE_FCP;
+		prli->type_ext = 0;
+		prli->flags = ocs_htobe16(FC_PRLI_ESTABLISH_IMAGE_PAIR);
+		prli->service_params = ocs_htobe16(FC_PRLI_READ_XRDY_DISABLED |
+			(node->sport->enable_ini ? FC_PRLI_INITIATOR_FUNCTION : 0) |
+			(node->sport->enable_tgt ? FC_PRLI_TARGET_FUNCTION : 0)); 
+
+		/* For Tape Drive support */
+		prli->service_params |= ocs_htobe16(FC_PRLI_CONFIRMED_COMPLETION | FC_PRLI_RETRY |
+				 FC_PRLI_TASK_RETRY_ID_REQ| FC_PRLI_REC_SUPPORT);
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a PRLO ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a PRLO ELS command, and send to the \c node.
+ *
+ * @param node Node to which the PRLO is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_prlo(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_t *ocs = node->ocs;
+	ocs_io_t *els;
+	fc_prlo_payload_t *prlo;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*prlo), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "prlo";
+
+		/* Build PRLO request */
+		prlo = els->els_req.virt;
+
+		ocs_memset(prlo, 0, sizeof(*prlo));
+		prlo->command_code = FC_ELS_CMD_PRLO;
+		prlo->page_length = 16;
+		prlo->payload_length = ocs_htobe16(sizeof(fc_prlo_payload_t));
+		prlo->type = FC_TYPE_FCP;
+		prlo->type_ext = 0;
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a LOGO ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Format a LOGO, and send to the \c node.
+ *
+ * @param node Node to which the LOGO is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_logo(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs;
+	fc_logo_payload_t *logo;
+	fc_plogi_payload_t *sparams;
+
+
+	ocs = node->ocs;
+
+	node_els_trace();
+
+	sparams = (fc_plogi_payload_t*) node->sport->service_params;
+
+	els = ocs_els_io_alloc(node, sizeof(*logo), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "logo";
+
+		/* Build LOGO request */
+
+		logo = els->els_req.virt;
+
+		ocs_memset(logo, 0, sizeof(*logo));
+		logo->command_code = FC_ELS_CMD_LOGO;
+		logo->resv1 = 0;
+		logo->port_id = fc_htobe24(node->rnode.sport->fc_id);
+		logo->port_name_hi = sparams->port_name_hi;
+		logo->port_name_lo = sparams->port_name_lo;
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send an ADISC ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct an ADISC ELS command, and send to the \c node.
+ *
+ * @param node Node to which the ADISC is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_adisc(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs;
+	fc_adisc_payload_t *adisc;
+	fc_plogi_payload_t *sparams;
+	ocs_sport_t *sport = node->sport;
+
+	ocs = node->ocs;
+
+	node_els_trace();
+
+	sparams = (fc_plogi_payload_t*) node->sport->service_params;
+
+	els = ocs_els_io_alloc(node, sizeof(*adisc), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "adisc";
+
+		/* Build ADISC request */
+
+		adisc = els->els_req.virt;
+		sparams = (fc_plogi_payload_t*) node->sport->service_params;
+
+		ocs_memset(adisc, 0, sizeof(*adisc));
+		adisc->command_code = FC_ELS_CMD_ADISC;
+		adisc->hard_address = fc_htobe24(sport->fc_id);
+		adisc->port_name_hi = sparams->port_name_hi;
+		adisc->port_name_lo = sparams->port_name_lo;
+		adisc->node_name_hi = sparams->node_name_hi;
+		adisc->node_name_lo = sparams->node_name_lo;
+		adisc->port_id = fc_htobe24(node->rnode.sport->fc_id);
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a PDISC ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a PDISC ELS command, and send to the \c node.
+ *
+ * @param node Node to which the PDISC is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_pdisc(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fc_plogi_payload_t *pdisc;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*pdisc), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "pdisc";
+
+		pdisc = els->els_req.virt;
+
+		ocs_memcpy(pdisc, node->sport->service_params, sizeof(*pdisc));
+
+		pdisc->command_code = FC_ELS_CMD_PDISC;
+		pdisc->resv1 = 0;
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send an SCR ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Format an SCR, and send to the \c node.
+ *
+ * @param node Node to which the SCR is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function
+ * @param cbarg Callback function arg
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_scr(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fc_scr_payload_t *req;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*req), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "scr";
+
+		req = els->els_req.virt;
+
+		ocs_memset(req, 0, sizeof(*req));
+		req->command_code = FC_ELS_CMD_SCR;
+		req->function = FC_SCR_REG_FULL;
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send an RRQ ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Format an RRQ, and send to the \c node.
+ *
+ * @param node Node to which the RRQ is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function
+ * @param cbarg Callback function arg
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_rrq(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fc_scr_payload_t *req;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*req), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "scr";
+
+		req = els->els_req.virt;
+
+		ocs_memset(req, 0, sizeof(*req));
+		req->command_code = FC_ELS_CMD_RRQ;
+		req->function = FC_SCR_REG_FULL;
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send an RSCN ELS command.
+ *
+ * <h3 class="desc">Description</h3>
+ * Format an RSCN, and send to the \c node.
+ *
+ * @param node Node to which the RRQ is sent.
+ * @param timeout_sec Command timeout, in seconds.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param port_ids Pointer to port IDs
+ * @param port_ids_count Count of port IDs
+ * @param cb Callback function
+ * @param cbarg Callback function arg
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+ocs_io_t *
+ocs_send_rscn(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	void *port_ids, uint32_t port_ids_count, els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fc_rscn_payload_t *req;
+	uint32_t payload_length = sizeof(fc_rscn_affected_port_id_page_t)*(port_ids_count - 1) +
+		sizeof(fc_rscn_payload_t);
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, payload_length, OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+		els->els_timeout_sec = timeout_sec;
+		els->els_retries_remaining = retries;
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "rscn";
+
+		req = els->els_req.virt;
+
+		req->command_code = FC_ELS_CMD_RSCN;
+		req->page_length = sizeof(fc_rscn_affected_port_id_page_t);
+		req->payload_length = ocs_htobe16(sizeof(*req) +
+			sizeof(fc_rscn_affected_port_id_page_t)*(port_ids_count-1));
+
+		els->hio_type = OCS_HW_ELS_REQ;
+		els->iparam.els.timeout = timeout_sec;
+
+		/* copy in the payload */
+		ocs_memcpy(req->port_list, port_ids, port_ids_count*sizeof(fc_rscn_affected_port_id_page_t));
+
+		/* Submit the request */
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @brief Send an LS_RJT ELS response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Send an LS_RJT ELS response.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange ID being responded to.
+ * @param reason_code Reason code value for LS_RJT.
+ * @param reason_code_expl Reason code explanation value for LS_RJT.
+ * @param vendor_unique Vendor-unique value for LS_RJT.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_ls_rjt(ocs_io_t *io, uint32_t ox_id, uint32_t reason_code, uint32_t reason_code_expl,
+		uint32_t vendor_unique, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_ls_rjt_payload_t *rjt;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "ls_rjt";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els.ox_id = ox_id;
+
+	rjt = io->els_req.virt;
+	ocs_memset(rjt, 0, sizeof(*rjt));
+
+	rjt->command_code = FC_ELS_CMD_RJT;
+	rjt->reason_code = reason_code;
+	rjt->reason_code_exp = reason_code_expl;
+
+	io->hio_type = OCS_HW_ELS_RSP;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*rjt)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a PLOGI accept response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a PLOGI LS_ACC, and send to the \c node, using the originator exchange ID
+ * \c ox_id.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange ID being responsed to.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+ocs_io_t *
+ocs_send_plogi_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_plogi_payload_t *plogi;
+	fc_plogi_payload_t *req = (fc_plogi_payload_t *)node->service_params;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "plog_acc";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els.ox_id = ox_id;
+
+	plogi = io->els_req.virt;
+
+	/* copy our port's service parameters to payload */
+	ocs_memcpy(plogi, node->sport->service_params, sizeof(*plogi));
+	plogi->command_code = FC_ELS_CMD_ACC;
+	plogi->resv1 = 0;
+	
+	/* Set Application header support bit if requested */
+	if (req->common_service_parameters[1] & ocs_htobe32(1U << 24)) {
+		plogi->common_service_parameters[1] |= ocs_htobe32(1U << 24);
+	}
+
+	/* Priority tagging support. */
+	if (req->common_service_parameters[1] & ocs_htobe32(1U << 23)) {
+		plogi->common_service_parameters[1] |= ocs_htobe32(1U << 23);
+	}
+
+	ocs_display_sparams(node->display_name, "plogi send resp", 0, NULL, plogi->common_service_parameters);
+
+	io->hio_type = OCS_HW_ELS_RSP;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*plogi)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send an FLOGI accept response for point-to-point negotiation.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct an FLOGI accept response, and send to the \c node using the originator
+ * exchange id \c ox_id. The \c s_id is used for the response frame source FC ID.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange ID for the response.
+ * @param s_id Source FC ID to be used in the response frame.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+ocs_io_t *
+ocs_send_flogi_p2p_acc(ocs_io_t *io, uint32_t ox_id, uint32_t s_id, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_plogi_payload_t *flogi;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "flogi_p2p_acc";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els_sid.ox_id = ox_id;
+	io->iparam.els_sid.s_id = s_id;
+
+	flogi = io->els_req.virt;
+
+	/* copy our port's service parameters to payload */
+	ocs_memcpy(flogi, node->sport->service_params, sizeof(*flogi));
+	flogi->command_code = FC_ELS_CMD_ACC;
+	flogi->resv1 = 0;
+	ocs_memset(flogi->class1_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+	ocs_memset(flogi->class2_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+	ocs_memset(flogi->class3_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+	ocs_memset(flogi->class4_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+
+	io->hio_type = OCS_HW_ELS_RSP_SID;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*flogi)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+ocs_io_t *
+ocs_send_flogi_acc(ocs_io_t *io, uint32_t ox_id, uint32_t is_fport, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_plogi_payload_t *flogi;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "flogi_acc";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els_sid.ox_id = ox_id;
+	io->iparam.els_sid.s_id = io->node->sport->fc_id;
+
+	flogi = io->els_req.virt;
+
+	/* copy our port's service parameters to payload */
+	ocs_memcpy(flogi, node->sport->service_params, sizeof(*flogi));
+
+	/* Set F_port */
+	if (is_fport) {
+		/* Set F_PORT and Multiple N_PORT_ID Assignment */
+		flogi->common_service_parameters[1] |= ocs_be32toh(3U << 28);
+	}
+
+	flogi->command_code = FC_ELS_CMD_ACC;
+	flogi->resv1 = 0;
+
+	ocs_display_sparams(node->display_name, "flogi send resp", 0, NULL, flogi->common_service_parameters);
+
+	ocs_memset(flogi->class1_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+	ocs_memset(flogi->class2_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+	ocs_memset(flogi->class3_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+	ocs_memset(flogi->class4_service_parameters, 0, sizeof(flogi->class1_service_parameters));
+
+	io->hio_type = OCS_HW_ELS_RSP_SID;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*flogi)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a PRLI accept response
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a PRLI LS_ACC response, and send to the \c node, using the originator
+ * \c ox_id exchange ID.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange ID.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_prli_acc(ocs_io_t *io, uint32_t ox_id, uint8_t fc_type, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_prli_payload_t *prli;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "prli_acc";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els.ox_id = ox_id;
+
+	prli = io->els_req.virt;
+	ocs_memset(prli, 0, sizeof(*prli));
+
+	prli->command_code = FC_ELS_CMD_ACC;
+	prli->page_length = 16;
+	prli->payload_length = ocs_htobe16(sizeof(fc_prli_payload_t));
+	prli->type = fc_type;
+	prli->type_ext = 0;
+	prli->flags = ocs_htobe16(FC_PRLI_ESTABLISH_IMAGE_PAIR | FC_PRLI_REQUEST_EXECUTED);
+
+	prli->service_params = ocs_htobe16(FC_PRLI_READ_XRDY_DISABLED |
+				(node->sport->enable_ini ? FC_PRLI_INITIATOR_FUNCTION : 0) |
+				(node->sport->enable_tgt ? FC_PRLI_TARGET_FUNCTION : 0)); 
+
+	io->hio_type = OCS_HW_ELS_RSP;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*prli)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a PRLO accept response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a PRLO LS_ACC response, and send to the \c node, using the originator
+ * exchange ID \c ox_id.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange ID.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_prlo_acc(ocs_io_t *io, uint32_t ox_id, uint8_t fc_type, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_prlo_acc_payload_t *prlo_acc;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "prlo_acc";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els.ox_id = ox_id;
+
+	prlo_acc = io->els_req.virt;
+	ocs_memset(prlo_acc, 0, sizeof(*prlo_acc));
+
+	prlo_acc->command_code = FC_ELS_CMD_ACC;
+	prlo_acc->page_length = 16;
+	prlo_acc->payload_length = ocs_htobe16(sizeof(fc_prlo_acc_payload_t));
+	prlo_acc->type = fc_type;
+	prlo_acc->type_ext = 0;
+	prlo_acc->response_code = FC_PRLO_REQUEST_EXECUTED;
+
+	io->hio_type = OCS_HW_ELS_RSP;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*prlo_acc)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a generic LS_ACC response without a payload.
+ *
+ * <h3 class="desc">Description</h3>
+ * A generic LS_ACC response is sent to the \c node using the originator exchange ID
+ * \c ox_id.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange id.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+ocs_io_t *
+ocs_send_ls_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_acc_payload_t *acc;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "ls_acc";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els.ox_id = ox_id;
+
+	acc = io->els_req.virt;
+	ocs_memset(acc, 0, sizeof(*acc));
+
+	acc->command_code = FC_ELS_CMD_ACC;
+
+	io->hio_type = OCS_HW_ELS_RSP;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*acc)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a LOGO accept response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a LOGO LS_ACC response, and send to the \c node, using the originator
+ * exchange ID \c ox_id.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange ID.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+ocs_io_t *
+ocs_send_logo_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	ocs_t *ocs = node->ocs;
+	fc_acc_payload_t *logo;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "logo_acc";
+	io->init_task_tag = ox_id;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els.ox_id = ox_id;
+
+	logo = io->els_req.virt;
+	ocs_memset(logo, 0, sizeof(*logo));
+
+	logo->command_code = FC_ELS_CMD_ACC;
+	logo->resv1 = 0;
+
+	io->hio_type = OCS_HW_ELS_RSP;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*logo)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send an ADISC accept response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct an ADISC LS__ACC, and send to the \c node, using the originator
+ * exchange id \c ox_id.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param ox_id Originator exchange ID.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_send_adisc_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	fc_adisc_payload_t *adisc;
+	fc_plogi_payload_t *sparams;
+	ocs_t *ocs;
+
+	ocs_assert(node, NULL);
+	ocs_assert(node->ocs, NULL);
+	ocs = node->ocs;
+
+	node_els_trace();
+
+	io->els_callback = cb;
+	io->els_callback_arg = cbarg;
+	io->display_name = "adisc_acc";
+	io->init_task_tag = ox_id;
+
+	/* Go ahead and send the ELS_ACC */
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.els.ox_id = ox_id;
+
+	sparams = (fc_plogi_payload_t*) node->sport->service_params;
+	adisc = io->els_req.virt;
+	ocs_memset(adisc, 0, sizeof(fc_adisc_payload_t));
+	adisc->command_code = FC_ELS_CMD_ACC;
+	adisc->hard_address = 0;
+	adisc->port_name_hi = sparams->port_name_hi;
+	adisc->port_name_lo = sparams->port_name_lo;
+	adisc->node_name_hi = sparams->node_name_hi;
+	adisc->node_name_lo = sparams->node_name_lo;
+	adisc->port_id = fc_htobe24(node->rnode.sport->fc_id);
+
+	io->hio_type = OCS_HW_ELS_RSP;
+	if ((rc = ocs_els_send_rsp(io, sizeof(*adisc)))) {
+		ocs_els_io_free(io);
+		io = NULL;
+	}
+
+	return io;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a RFTID CT request.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct an RFTID CT request, and send to the \c node.
+ *
+ * @param node Node to which the RFTID request is sent.
+ * @param timeout_sec Time, in seconds, to wait before timing out the ELS.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+ocs_io_t *
+ocs_ns_send_rftid(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fcct_rftid_req_t *rftid;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*rftid), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+
+		els->iparam.fc_ct.r_ctl = FC_RCTL_ELS;
+		els->iparam.fc_ct.type = FC_TYPE_GS;
+		els->iparam.fc_ct.df_ctl = 0;
+		els->iparam.fc_ct.timeout = timeout_sec;
+
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "rftid";
+
+		rftid = els->els_req.virt;
+
+		ocs_memset(rftid, 0, sizeof(*rftid));
+		fcct_build_req_header(&rftid->hdr, FC_GS_NAMESERVER_RFT_ID, (OCS_ELS_RSP_LEN - sizeof(rftid->hdr)));
+		rftid->port_id = ocs_htobe32(node->rnode.sport->fc_id);
+		rftid->fc4_types[FC_GS_TYPE_WORD(FC_TYPE_FCP)] = ocs_htobe32(1 << FC_GS_TYPE_BIT(FC_TYPE_FCP));
+
+		els->hio_type = OCS_HW_FC_CT;
+
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a RFFID CT request.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct an RFFID CT request, and send to the \c node.
+ *
+ * @param node Node to which the RFFID request is sent.
+ * @param timeout_sec Time, in seconds, to wait before timing out the ELS.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+ocs_io_t *
+ocs_ns_send_rffid(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fcct_rffid_req_t *rffid;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc(node, sizeof(*rffid), OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+
+		els->iparam.fc_ct.r_ctl = FC_RCTL_ELS;
+		els->iparam.fc_ct.type = FC_TYPE_GS;
+		els->iparam.fc_ct.df_ctl = 0;
+		els->iparam.fc_ct.timeout = timeout_sec;
+
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "rffid";
+
+		rffid = els->els_req.virt;
+
+		ocs_memset(rffid, 0, sizeof(*rffid));
+
+		fcct_build_req_header(&rffid->hdr, FC_GS_NAMESERVER_RFF_ID, (OCS_ELS_RSP_LEN - sizeof(rffid->hdr)));
+		rffid->port_id = ocs_htobe32(node->rnode.sport->fc_id);
+		if (node->sport->enable_ini) {
+			rffid->fc4_feature_bits |= FC4_FEATURE_INITIATOR;
+		}
+		if (node->sport->enable_tgt) {
+			rffid->fc4_feature_bits |= FC4_FEATURE_TARGET;
+		}
+		rffid->type = FC_TYPE_FCP;
+
+		els->hio_type = OCS_HW_FC_CT;
+
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+
+/**
+ * @ingroup els_api
+ * @brief Send a GIDPT CT request.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a GIDPT CT request, and send to the \c node.
+ *
+ * @param node Node to which the GIDPT request is sent.
+ * @param timeout_sec Time, in seconds, to wait before timing out the ELS.
+ * @param retries Number of times to retry errors before reporting a failure.
+ * @param cb Callback function.
+ * @param cbarg Callback function argument.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_ns_send_gidpt(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	els_cb_t cb, void *cbarg)
+{
+	ocs_io_t *els;
+	ocs_t *ocs = node->ocs;
+	fcct_gidpt_req_t *gidpt;
+
+	node_els_trace();
+
+	els = ocs_els_io_alloc_size(node, sizeof(*gidpt), OCS_ELS_GID_PT_RSP_LEN, OCS_ELS_ROLE_ORIGINATOR);
+	if (els == NULL) {
+		ocs_log_err(ocs, "IO alloc failed\n");
+	} else {
+
+		els->iparam.fc_ct.r_ctl = FC_RCTL_ELS;
+		els->iparam.fc_ct.type = FC_TYPE_GS;
+		els->iparam.fc_ct.df_ctl = 0;
+		els->iparam.fc_ct.timeout = timeout_sec;
+
+		els->els_callback = cb;
+		els->els_callback_arg = cbarg;
+		els->display_name = "gidpt";
+
+		gidpt = els->els_req.virt;
+
+		ocs_memset(gidpt, 0, sizeof(*gidpt));
+		fcct_build_req_header(&gidpt->hdr, FC_GS_NAMESERVER_GID_PT, (OCS_ELS_GID_PT_RSP_LEN - sizeof(gidpt->hdr)) );
+		gidpt->domain_id_scope = 0;
+		gidpt->area_id_scope = 0;
+		gidpt->port_type = 0x7f;
+
+		els->hio_type = OCS_HW_FC_CT;
+
+		ocs_io_transition(els, __ocs_els_init, NULL);
+	}
+	return els;
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a BA_ACC given the request's FC header
+ *
+ * <h3 class="desc">Description</h3>
+ * Using the S_ID/D_ID from the request's FC header, generate a BA_ACC.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param hdr Pointer to the FC header.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+ocs_io_t *
+ocs_bls_send_acc_hdr(ocs_io_t *io, fc_header_t *hdr)
+{
+	uint16_t ox_id = ocs_be16toh(hdr->ox_id);
+	uint16_t rx_id = ocs_be16toh(hdr->rx_id);
+	uint32_t d_id = fc_be24toh(hdr->d_id);
+
+	return ocs_bls_send_acc(io, d_id, ox_id, rx_id);
+}
+
+/**
+ * @ingroup els_api
+ * @brief Send a BLS BA_ACC response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Construct a BLS BA_ACC response, and send to the \c node.
+ *
+ * @param io Pointer to a SCSI IO object.
+ * @param s_id S_ID to use for the response. If UINT32_MAX, then use our SLI port
+ * (sport) S_ID.
+ * @param ox_id Originator exchange ID.
+ * @param rx_id Responder exchange ID.
+ *
+ * @return Returns pointer to IO object, or NULL if error.
+ */
+
+static ocs_io_t *
+ocs_bls_send_acc(ocs_io_t *io, uint32_t s_id, uint16_t ox_id, uint16_t rx_id)
+{
+	ocs_node_t *node = io->node;
+	int32_t rc;
+	fc_ba_acc_payload_t *acc;
+	ocs_t *ocs;
+
+	ocs_assert(node, NULL);
+	ocs_assert(node->ocs, NULL);
+	ocs = node->ocs;
+
+	if (node->rnode.sport->fc_id == s_id) {
+		s_id = UINT32_MAX;
+	}
+
+	/* fill out generic fields */
+	io->ocs = ocs;
+	io->node = node;
+	io->cmd_tgt = TRUE;
+
+	/* fill out BLS Response-specific fields */
+	io->io_type = OCS_IO_TYPE_BLS_RESP;
+	io->display_name = "ba_acc";
+	io->hio_type = OCS_HW_BLS_ACC_SID;
+	io->init_task_tag = ox_id;
+
+	/* fill out iparam fields */
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.bls_sid.s_id = s_id;
+	io->iparam.bls_sid.ox_id = ox_id;
+	io->iparam.bls_sid.rx_id = rx_id;
+
+	acc = (void *)io->iparam.bls_sid.payload;
+
+	ocs_memset(io->iparam.bls_sid.payload, 0, sizeof(io->iparam.bls_sid.payload));
+	acc->ox_id = io->iparam.bls_sid.ox_id;
+	acc->rx_id = io->iparam.bls_sid.rx_id;
+	acc->high_seq_cnt = UINT16_MAX;
+
+	if ((rc = ocs_scsi_io_dispatch(io, ocs_bls_send_acc_cb))) {
+		ocs_log_err(ocs, "ocs_scsi_io_dispatch() failed: %d\n", rc);
+		ocs_scsi_io_free(io);
+		io = NULL;
+	}
+	return io;
+}
+
+/**
+ * @brief Handle the BLS accept completion.
+ *
+ * <h3 class="desc">Description</h3>
+ * Upon completion of sending a BA_ACC, this callback is invoked by the HW.
+ *
+ * @param hio Pointer to the HW IO object.
+ * @param rnode Pointer to the HW remote node.
+ * @param length Length of the response payload, in bytes.
+ * @param status Completion status.
+ * @param ext_status Extended completion status.
+ * @param app Callback private argument.
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+static int32_t
+ocs_bls_send_acc_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *app)
+{
+	ocs_io_t *io = app;
+
+	ocs_assert(io, -1);
+
+	ocs_scsi_io_free(io);
+	return 0;
+}
+
+/**
+ * @brief ELS abort callback.
+ *
+ * <h3 class="desc">Description</h3>
+ * This callback is invoked by the HW when an ELS IO is aborted.
+ *
+ * @param hio Pointer to the HW IO object.
+ * @param rnode Pointer to the HW remote node.
+ * @param length Length of the response payload, in bytes.
+ * @param status Completion status.
+ * @param ext_status Extended completion status.
+ * @param app Callback private argument.
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+static int32_t
+ocs_els_abort_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *app)
+{
+	ocs_io_t *els;
+	ocs_io_t *abort_io = NULL; /* IO structure used to abort ELS */
+	ocs_t *ocs;
+
+	ocs_assert(app, -1);
+	abort_io = app;
+	els = abort_io->io_to_abort;
+	ocs_assert(els->node, -1);
+	ocs_assert(els->node->ocs, -1);
+
+	ocs = els->node->ocs;
+
+	if (status != 0) {
+		ocs_log_warn(ocs, "status x%x ext x%x\n", status, ext_status);
+	}
+
+	/* now free the abort IO */
+	ocs_io_free(ocs, abort_io);
+
+	/* send completion event to indicate abort process is complete
+	 * Note: The ELS SM will already be receiving ELS_REQ_OK/FAIL/RJT/ABORTED
+	 */
+	ocs_els_post_event(els, OCS_EVT_ELS_ABORT_CMPL, NULL);
+
+	/* done with ELS IO to abort */
+	ocs_ref_put(&els->ref); /* ocs_ref_get(): ocs_els_abort_io() */
+	return 0;
+}
+
+/**
+ * @brief Abort an ELS IO.
+ *
+ * <h3 class="desc">Description</h3>
+ * The ELS IO is aborted by making a HW abort IO request,
+ * optionally requesting that an ABTS is sent.
+ *
+ * \b Note: This function allocates a HW IO, and associates the HW IO
+ * with the ELS IO that it is aborting. It does not associate
+ * the HW IO with the node directly, like for ELS requests. The
+ * abort completion is propagated up to the node once the
+ * original WQE and the abort WQE are complete (the original WQE
+ * completion is not propagated up to node).
+ *
+ * @param els Pointer to the ELS IO.
+ * @param send_abts Boolean to indicate if hardware will automatically generate an ABTS.
+ *
+ * @return Returns pointer to Abort IO object, or NULL if error.
+ */
+
+static ocs_io_t *
+ocs_els_abort_io(ocs_io_t *els, int send_abts)
+{
+	ocs_t *ocs;
+	ocs_xport_t *xport;
+	int32_t rc;
+	ocs_io_t *abort_io = NULL;
+
+	ocs_assert(els, NULL);
+	ocs_assert(els->node, NULL);
+	ocs_assert(els->node->ocs, NULL);
+
+	ocs = els->node->ocs;
+	ocs_assert(ocs->xport, NULL);
+	xport = ocs->xport;
+
+	/* take a reference on IO being aborted */
+	if ((ocs_ref_get_unless_zero(&els->ref) == 0)) {
+		/* command no longer active */
+		ocs_log_debug(ocs, "els no longer active\n");
+		return NULL;
+	}
+
+	/* allocate IO structure to send abort */
+	abort_io = ocs_io_alloc(ocs);
+	if (abort_io == NULL) {
+		ocs_atomic_add_return(&xport->io_alloc_failed_count, 1);
+	} else {
+		ocs_assert(abort_io->hio == NULL, NULL);
+
+		/* set generic fields */
+		abort_io->ocs = ocs;
+		abort_io->node = els->node;
+		abort_io->cmd_ini = TRUE;
+
+		/* set type and ABORT-specific fields */
+		abort_io->io_type = OCS_IO_TYPE_ABORT;
+		abort_io->display_name = "abort_els";
+		abort_io->io_to_abort = els;
+		abort_io->send_abts = send_abts;
+
+		/* now dispatch IO */
+		if ((rc = ocs_scsi_io_dispatch_abort(abort_io, ocs_els_abort_cb))) {
+			ocs_log_err(ocs, "ocs_scsi_io_dispatch failed: %d\n", rc);
+			ocs_io_free(ocs, abort_io);
+			abort_io = NULL;
+		}
+	}
+
+	/* if something failed, put reference on ELS to abort */
+	if (abort_io == NULL) {
+		ocs_ref_put(&els->ref); /* ocs_ref_get(): same function */
+	}
+	return abort_io;
+}
+
+
+/*
+ * ELS IO State Machine
+ */
+
+#define std_els_state_decl(...) \
+	ocs_io_t *els = NULL; \
+	ocs_node_t *node = NULL; \
+	ocs_t *ocs = NULL; \
+	ocs_assert(ctx != NULL, NULL); \
+	els = ctx->app; \
+	ocs_assert(els != NULL, NULL); \
+	node = els->node; \
+	ocs_assert(node != NULL, NULL); \
+	ocs = node->ocs; \
+	ocs_assert(ocs != NULL, NULL);
+
+#define els_sm_trace(...) \
+	do { \
+		if (OCS_LOG_ENABLE_ELS_TRACE(ocs)) \
+			ocs_log_info(ocs, "[%s] %-8s %-20s %-20s\n", node->display_name, els->display_name, \
+				__func__, ocs_sm_event_name(evt)); \
+	} while (0)
+
+
+/**
+ * @brief Cleanup an ELS IO
+ *
+ * <h3 class="desc">Description</h3>
+ * Cleans up an ELS IO by posting the requested event to the owning node object;
+ * invoking the callback, if one is provided; and then freeing the
+ * ELS IO object.
+ *
+ * @param els Pointer to the ELS IO.
+ * @param node_evt Node SM event to post.
+ * @param arg Node SM event argument.
+ *
+ * @return None.
+ */
+
+void
+ocs_els_io_cleanup(ocs_io_t *els, ocs_sm_event_t node_evt, void *arg)
+{
+	ocs_assert(els);
+
+	/* don't want further events that could come; e.g. abort requests
+	 * from the node state machine; thus, disable state machine
+	 */
+	ocs_sm_disable(&els->els_sm);
+	ocs_node_post_event(els->node, node_evt, arg);
+
+	/* If this IO has a callback, invoke it */
+	if (els->els_callback) {
+		(*els->els_callback)(els->node, arg, els->els_callback_arg);
+	}
+	els->els_req_free = 1;
+}
+
+
+/**
+ * @brief Common event handler for the ELS IO state machine.
+ *
+ * <h3 class="desc">Description</h3>
+ * Provide handler for events for which default actions are desired.
+ *
+ * @param funcname Name of the calling function (for logging).
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_els_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_els_state_decl();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+	case OCS_EVT_REENTER:
+	case OCS_EVT_EXIT:
+		break;
+
+	/* If ELS_REQ_FAIL is not handled in state, then we'll terminate this ELS and
+	 * pass the event to the node
+	 */
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+		ocs_log_warn(els->node->ocs, "[%s] %-20s %-20s not handled - terminating ELS\n", node->display_name, funcname,
+			ocs_sm_event_name(evt));
+		ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_FAIL, arg);
+		break;
+	default:
+		ocs_log_warn(els->node->ocs, "[%s] %-20s %-20s not handled\n", node->display_name, funcname,
+			ocs_sm_event_name(evt));
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Initial ELS IO state
+ *
+ * <h3 class="desc">Description</h3>
+ * This is the initial ELS IO state. Upon entry, the requested ELS/CT is submitted to
+ * the hardware.
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_els_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc = 0;
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		rc = ocs_els_send(els, els->els_req.size, els->els_timeout_sec, ocs_els_req_cb);
+		if (rc) {
+			ocs_node_cb_t cbdata;
+			cbdata.status = cbdata.ext_status = (~0);
+			cbdata.els = els;
+			ocs_log_err(ocs, "ocs_els_send failed: %d\n", rc);
+			ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_FAIL, &cbdata);
+		} else {
+			ocs_io_transition(els, __ocs_els_wait_resp, NULL);
+		}
+		break;
+	}
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @brief Wait for the ELS request to complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * This is the ELS IO state that waits for the submitted ELS event to complete.
+ * If an error completion event is received, the requested ELS is aborted.
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_els_wait_resp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_io_t *io;
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK: {
+		ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_OK, arg);
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL: {
+		ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_FAIL, arg);
+		break;
+	}
+
+	case OCS_EVT_ELS_REQ_TIMEOUT: {
+		els_io_printf(els, "Timed out, retry (%d tries remaining)\n",
+				els->els_retries_remaining-1);
+		ocs_io_transition(els, __ocs_els_retry, NULL);
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_RJT: {
+		ocs_node_cb_t *cbdata = arg;
+		uint32_t reason_code = (cbdata->ext_status >> 16) & 0xff;
+
+		/* delay and retry if reason code is Logical Busy */
+		switch (reason_code) {
+		case FC_REASON_LOGICAL_BUSY:
+			els->node->els_req_cnt--;
+			els_io_printf(els, "LS_RJT Logical Busy response, delay and retry\n");
+			ocs_io_transition(els, __ocs_els_delay_retry, NULL);
+			break;
+		default:
+			ocs_els_io_cleanup(els, evt, arg);
+			break;
+		}
+		break;
+	}
+
+	case OCS_EVT_ABORT_ELS: {
+		/* request to abort this ELS without an ABTS */
+		els_io_printf(els, "ELS abort requested\n");
+		els->els_retries_remaining = 0;		/* Set retries to zero, we are done */
+		io = ocs_els_abort_io(els, FALSE);
+		if (io == NULL) {
+			ocs_log_err(ocs, "ocs_els_send failed\n");
+			ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_FAIL, arg);
+		} else {
+			ocs_io_transition(els, __ocs_els_aborting, NULL);
+		}
+		break;
+	}
+
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Wait for the ELS IO abort request to complete, and retry the ELS.
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered when waiting for an abort of an ELS
+ * request to complete so the request can be retried.
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_els_retry(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc = 0;
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		/* handle event for ABORT_XRI WQE
+		 * once abort is complete, retry if retries left;
+		 * don't need to wait for OCS_EVT_SRRS_ELS_REQ_* event because we got
+		 * by receiving OCS_EVT_ELS_REQ_TIMEOUT
+		 */
+		ocs_node_cb_t node_cbdata;
+		node_cbdata.status = node_cbdata.ext_status = (~0);
+		node_cbdata.els = els;
+		if (els->els_retries_remaining && --els->els_retries_remaining) {
+			/* Use a different XRI for the retry (would like a new oxid),
+			 * so free the HW IO (dispatch will allocate a new one). It's an
+			 * optimization to only free the HW IO here and not the ocs_io_t;
+			 * Freeing the ocs_io_t object would require copying all the necessary
+			 * info from the old ocs_io_t object to the * new one; and allocating
+			 * a new ocs_io_t could fail.
+			 */
+			ocs_assert(els->hio, NULL);
+			ocs_hw_io_free(&ocs->hw, els->hio);
+			els->hio = NULL;
+
+			/* result isn't propagated up to node sm, need to decrement req cnt */
+			ocs_assert(els->node->els_req_cnt, NULL);
+			els->node->els_req_cnt--;
+			rc = ocs_els_send(els, els->els_req.size, els->els_timeout_sec, ocs_els_req_cb);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_els_send failed: %d\n", rc);
+				ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_FAIL, &node_cbdata);
+			}
+			ocs_io_transition(els, __ocs_els_wait_resp, NULL);
+		} else {
+			els_io_printf(els, "Retries exhausted\n");
+			ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_FAIL, &node_cbdata);
+		}
+		break;
+	}
+
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Wait for a retry timer to expire having received an abort request
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered when waiting for a timer event, after having received
+ * an abort request, to avoid a race condition with the timer handler
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_els_aborted_delay_retry(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* mod/resched the timer for a short duration */
+		ocs_mod_timer(&els->delay_timer, 1);
+		break;
+	case OCS_EVT_TIMER_EXPIRED:
+		/* Cancel the timer, skip post node event, and free the io */
+		node->els_req_cnt++;
+		ocs_els_io_cleanup(els, OCS_EVT_SRRS_ELS_REQ_FAIL, arg);
+		break;
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Wait for a retry timer to expire
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered when waiting for a timer event, so that
+ * the ELS request can be retried.
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_els_delay_retry(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_setup_timer(ocs, &els->delay_timer, ocs_els_delay_timer_cb, els, 5000);
+		break;
+	case OCS_EVT_TIMER_EXPIRED:
+		/* Retry delay timer expired, retry the ELS request, Free the HW IO so
+		 * that a new oxid is used.
+		 */
+		if (els->hio != NULL) {
+			ocs_hw_io_free(&ocs->hw, els->hio);
+			els->hio = NULL;
+		}
+		ocs_io_transition(els, __ocs_els_init, NULL);
+		break;
+	case OCS_EVT_ABORT_ELS:
+		ocs_io_transition(els, __ocs_els_aborted_delay_retry, NULL);
+		break;
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Wait for the ELS IO abort request to complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered after we abort an ELS WQE and are
+ * waiting for either the original ELS WQE request or the abort
+ * to complete.
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_els_aborting(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+	case OCS_EVT_ELS_REQ_TIMEOUT:
+	case OCS_EVT_ELS_REQ_ABORTED: {
+		/* completion for ELS received first, transition to wait for abort cmpl */
+		els_io_printf(els, "request cmpl evt=%s\n", ocs_sm_event_name(evt));
+		ocs_io_transition(els, __ocs_els_aborting_wait_abort_cmpl, NULL);
+		break;
+	}
+	case OCS_EVT_ELS_ABORT_CMPL: {
+		/* completion for abort was received first, transition to wait for req cmpl */
+		els_io_printf(els, "abort cmpl evt=%s\n", ocs_sm_event_name(evt));
+		ocs_io_transition(els, __ocs_els_aborting_wait_req_cmpl, NULL);
+		break;
+	}
+	case OCS_EVT_ABORT_ELS:
+		/* nothing we can do but wait */
+		break;
+
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief cleanup ELS after abort
+ *
+ * @param els ELS IO to cleanup
+ *
+ * @return Returns None.
+ */
+
+static void
+ocs_els_abort_cleanup(ocs_io_t *els)
+{
+	/* handle event for ABORT_WQE
+	 * whatever state ELS happened to be in, propagate aborted event up
+	 * to node state machine in lieu of OCS_EVT_SRRS_ELS_* event
+	 */
+	ocs_node_cb_t cbdata;
+	cbdata.status = cbdata.ext_status = 0;
+	cbdata.els = els;
+	els_io_printf(els, "Request aborted\n");
+	ocs_els_io_cleanup(els, OCS_EVT_ELS_REQ_ABORTED, &cbdata);
+}
+
+/**
+ * @brief Wait for the ELS IO abort request to complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered after we abort an ELS WQE, we received
+ * the abort completion first and are waiting for the original
+ * ELS WQE request to complete.
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_els_aborting_wait_req_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+	case OCS_EVT_ELS_REQ_TIMEOUT:
+	case OCS_EVT_ELS_REQ_ABORTED: {
+		/* completion for ELS that was aborted */
+		ocs_els_abort_cleanup(els);
+		break;
+	}
+	case OCS_EVT_ABORT_ELS:
+		/* nothing we can do but wait */
+		break;
+
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Wait for the ELS IO abort request to complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * This state is entered after we abort an ELS WQE, we received
+ * the original ELS WQE request completion first and are waiting
+ * for the abort to complete.
+ *
+ * @param ctx Remote node SM context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_els_aborting_wait_abort_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_els_state_decl();
+
+	els_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ELS_ABORT_CMPL: {
+		ocs_els_abort_cleanup(els);
+		break;
+	}
+	case OCS_EVT_ABORT_ELS:
+		/* nothing we can do but wait */
+		break;
+
+	default:
+		__ocs_els_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Generate ELS context ddump data.
+ *
+ * <h3 class="desc">Description</h3>
+ * Generate the ddump data for an ELS context.
+ *
+ * @param textbuf Pointer to the text buffer.
+ * @param els Pointer to the ELS context.
+ *
+ * @return None.
+ */
+
+void
+ocs_ddump_els(ocs_textbuf_t *textbuf, ocs_io_t *els)
+{
+	ocs_ddump_section(textbuf, "els", -1);
+	ocs_ddump_value(textbuf, "req_free", "%d", els->els_req_free);
+	ocs_ddump_value(textbuf, "evtdepth", "%d", els->els_evtdepth);
+	ocs_ddump_value(textbuf, "pend", "%d", els->els_pend);
+	ocs_ddump_value(textbuf, "active", "%d", els->els_active);
+	ocs_ddump_io(textbuf, els);
+	ocs_ddump_endsection(textbuf, "els", -1);
+}
+
+
+/**
+ * @brief return TRUE if given ELS list is empty (while taking proper locks)
+ *
+ * Test if given ELS list is empty while holding the node->active_ios_lock.
+ *
+ * @param node pointer to node object
+ * @param list pointer to list
+ *
+ * @return TRUE if els_io_list is empty
+ */
+
+int32_t
+ocs_els_io_list_empty(ocs_node_t *node, ocs_list_t *list)
+{
+	int empty;
+	ocs_lock(&node->active_ios_lock);
+		empty = ocs_list_empty(list);
+	ocs_unlock(&node->active_ios_lock);
+	return empty;
+}
+
+/**
+ * @brief Handle CT send response completion
+ *
+ * Called when CT response completes, free IO
+ *
+ * @param hio Pointer to the HW IO context that completed.
+ * @param rnode Pointer to the remote node.
+ * @param length Length of the returned payload data.
+ * @param status Status of the completion.
+ * @param ext_status Extended status of the completion.
+ * @param arg Application-specific argument (generally a pointer to the ELS IO context).
+ *
+ * @return returns 0
+ */
+static int32_t
+ocs_ct_acc_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *arg)
+{
+	ocs_io_t *io = arg;
+
+	ocs_els_io_free(io);
+
+	return 0;
+}
+
+/**
+ * @brief Send CT response
+ *
+ * Sends a CT response frame with payload
+ *
+ * @param io Pointer to the IO context.
+ * @param ox_id Originator exchange ID
+ * @param ct_hdr Pointer to the CT IU
+ * @param cmd_rsp_code CT response code
+ * @param reason_code Reason code
+ * @param reason_code_explanation Reason code explanation
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_send_ct_rsp(ocs_io_t *io, uint32_t ox_id, fcct_iu_header_t *ct_hdr, uint32_t cmd_rsp_code, uint32_t reason_code, uint32_t reason_code_explanation)
+{
+	fcct_iu_header_t *rsp = io->els_rsp.virt;
+
+	io->io_type = OCS_IO_TYPE_CT_RESP;
+
+	*rsp = *ct_hdr;
+
+	fcct_build_req_header(rsp, cmd_rsp_code, 0);
+	rsp->reason_code = reason_code;
+	rsp->reason_code_explanation = reason_code_explanation;
+
+	io->display_name = "ct response";
+	io->init_task_tag = ox_id;
+	io->wire_len += sizeof(*rsp);
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+
+	io->io_type = OCS_IO_TYPE_CT_RESP;
+	io->hio_type = OCS_HW_FC_CT_RSP;
+	io->iparam.fc_ct_rsp.ox_id = ocs_htobe16(ox_id);
+	io->iparam.fc_ct_rsp.r_ctl = 3;
+	io->iparam.fc_ct_rsp.type = FC_TYPE_GS;
+	io->iparam.fc_ct_rsp.df_ctl = 0;
+	io->iparam.fc_ct_rsp.timeout = 5;
+
+	if (ocs_scsi_io_dispatch(io, ocs_ct_acc_cb) < 0) {
+		ocs_els_io_free(io);
+		return -1;
+	}
+	return 0;
+}
+
+
+/**
+ * @brief Handle delay retry timeout
+ *
+ * Callback is invoked when the delay retry timer expires.
+ *
+ * @param arg pointer to the ELS IO object
+ *
+ * @return none
+ */
+static void
+ocs_els_delay_timer_cb(void *arg)
+{
+	ocs_io_t *els = arg;
+	ocs_node_t *node = els->node;
+
+	/*
+	 * There is a potential deadlock here since is Linux executes timers
+	 * in a soft IRQ context. The lock may be aready locked by the interrupt
+	 * thread. Handle this case by attempting to take the node lock and reset the
+	 * timer if we fail to acquire the lock.
+	 *
+	 * Note: This code relies on the fact that the node lock is recursive.
+	 */
+	if (ocs_node_lock_try(node)) {
+		ocs_els_post_event(els, OCS_EVT_TIMER_EXPIRED, NULL);
+		ocs_node_unlock(node);
+	} else {
+		ocs_setup_timer(els->ocs, &els->delay_timer, ocs_els_delay_timer_cb, els, 1);
+	}
+}
diff --git a/sys/dev/ocs_fc/ocs_els.h b/sys/dev/ocs_fc/ocs_els.h
new file mode 100644
index 000000000000..b320c3fb0577
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_els.h
@@ -0,0 +1,110 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Declarations for the interface exported by ocs_els.
+ */
+
+#if !defined(__OCS_ELS_H__)
+#define __OCS_ELS_H__
+#include "ocs.h"
+
+#define OCS_ELS_RSP_LEN		1024
+#define OCS_ELS_GID_PT_RSP_LEN	8096 /* Enough for 2K remote target nodes */
+
+#define OCS_ELS_REQ_LEN		116 /*Max request length*/
+
+typedef enum {
+	OCS_ELS_ROLE_ORIGINATOR,
+	OCS_ELS_ROLE_RESPONDER,
+} ocs_els_role_e;
+
+extern ocs_io_t *ocs_els_io_alloc(ocs_node_t *node, uint32_t reqlen, ocs_els_role_e role);
+extern ocs_io_t *ocs_els_io_alloc_size(ocs_node_t *node, uint32_t reqlen, uint32_t rsplen, ocs_els_role_e role);
+extern void ocs_els_io_free(ocs_io_t *els);
+
+/* ELS command send */
+typedef void (*els_cb_t)(ocs_node_t *node, ocs_node_cb_t *cbdata, void *arg);
+extern ocs_io_t *ocs_send_plogi(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_flogi(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_fdisc(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_prli(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_prlo(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_logo(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_adisc(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_pdisc(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_scr(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_rrq(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_ns_send_rftid(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_ns_send_rffid(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_ns_send_gidpt(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_rscn(ocs_node_t *node, uint32_t timeout_sec, uint32_t retries,
+	void *port_ids, uint32_t port_ids_count, els_cb_t cb, void *cbarg);
+extern void ocs_els_io_cleanup(ocs_io_t *els, ocs_sm_event_t node_evt, void *arg);
+
+/* ELS acc send */
+extern ocs_io_t *ocs_send_ls_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_ls_rjt(ocs_io_t *io, uint32_t ox_id, uint32_t reason_cod, uint32_t reason_code_expl,
+		uint32_t vendor_unique, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_flogi_p2p_acc(ocs_io_t *io, uint32_t ox_id, uint32_t s_id, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_flogi_acc(ocs_io_t *io, uint32_t ox_id, uint32_t is_fport, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_plogi_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_prli_acc(ocs_io_t *io, uint32_t ox_id, uint8_t fc_type, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_logo_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_prlo_acc(ocs_io_t *io, uint32_t ox_id, uint8_t fc_type, els_cb_t cb, void *cbarg);
+extern ocs_io_t *ocs_send_adisc_acc(ocs_io_t *io, uint32_t ox_id, els_cb_t cb, void *cbarg);
+extern void ocs_ddump_els(ocs_textbuf_t *textbuf, ocs_io_t *els);
+
+/* BLS acc send */
+extern ocs_io_t *ocs_bls_send_acc_hdr(ocs_io_t *io, fc_header_t *hdr);
+
+/* ELS IO state machine */
+extern void ocs_els_post_event(ocs_io_t *els, ocs_sm_event_t evt, void *data);
+extern void *__ocs_els_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_els_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_els_wait_resp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_els_aborting(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_els_aborting_wait_req_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_els_aborting_wait_abort_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_els_retry(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void * __ocs_els_aborted_delay_retry(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_els_delay_retry(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+/* Misc */
+extern int32_t ocs_els_io_list_empty(ocs_node_t *node, ocs_list_t *list);
+
+/* CT */
+extern int32_t ocs_send_ct_rsp(ocs_io_t *io, uint32_t ox_id, fcct_iu_header_t *ct_hdr, uint32_t cmd_rsp_code, uint32_t reason_code, uint32_t reason_code_explanation);
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_fabric.c b/sys/dev/ocs_fc/ocs_fabric.c
new file mode 100644
index 000000000000..162dd558fc6d
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_fabric.c
@@ -0,0 +1,2046 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ * This file implements remote node state machines for:
+ * - Fabric logins.
+ * - Fabric controller events.
+ * - Name/directory services interaction.
+ * - Point-to-point logins.
+ */
+
+/*!
+@defgroup fabric_sm Node State Machine: Fabric States
+@defgroup ns_sm Node State Machine: Name/Directory Services States
+@defgroup p2p_sm Node State Machine: Point-to-Point Node States
+*/
+
+#include "ocs.h"
+#include "ocs_fabric.h"
+#include "ocs_els.h"
+#include "ocs_device.h"
+
+static void ocs_fabric_initiate_shutdown(ocs_node_t *node);
+static void * __ocs_fabric_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+static int32_t ocs_start_ns_node(ocs_sport_t *sport);
+static int32_t ocs_start_fabctl_node(ocs_sport_t *sport);
+static int32_t ocs_process_gidpt_payload(ocs_node_t *node, fcct_gidpt_acc_t *gidpt, uint32_t gidpt_len);
+static void ocs_process_rscn(ocs_node_t *node, ocs_node_cb_t *cbdata);
+static uint64_t ocs_get_wwpn(fc_plogi_payload_t *sp);
+static void gidpt_delay_timer_cb(void *arg);
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric node state machine: Initial state.
+ *
+ * @par Description
+ * Send an FLOGI to a well-known fabric.
+ *
+ * @param ctx Remote node sm context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_fabric_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_REENTER:	/* not sure why we're getting these ... */
+		ocs_log_debug(node->ocs, ">>> reenter !!\n");
+		/* fall through */
+	case OCS_EVT_ENTER:
+		/* sm: / send FLOGI */
+		ocs_send_flogi(node, OCS_FC_FLOGI_TIMEOUT_SEC, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_fabric_flogi_wait_rsp, NULL);
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Set sport topology.
+ *
+ * @par Description
+ * Set sport topology.
+ *
+ * @param node Pointer to the node for which the topology is set.
+ * @param topology Topology to set.
+ *
+ * @return Returns NULL.
+ */
+void
+ocs_fabric_set_topology(ocs_node_t *node, ocs_sport_topology_e topology)
+{
+	node->sport->topology = topology;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Notify sport topology.
+ * @par Description
+ * notify sport topology.
+ * @param node Pointer to the node for which the topology is set.
+ * @return Returns NULL.
+ */
+void
+ocs_fabric_notify_topology(ocs_node_t *node)
+{
+	ocs_node_t *tmp_node;
+	ocs_node_t *next;
+	ocs_sport_topology_e topology = node->sport->topology;
+
+	/* now loop through the nodes in the sport and send topology notification */
+	ocs_sport_lock(node->sport);
+	ocs_list_foreach_safe(&node->sport->node_list, tmp_node, next) {
+		if (tmp_node != node) {
+			ocs_node_post_event(tmp_node, OCS_EVT_SPORT_TOPOLOGY_NOTIFY, (void *)topology);
+		}
+	}
+	ocs_sport_unlock(node->sport);
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric node state machine: Wait for an FLOGI response.
+ *
+ * @par Description
+ * Wait for an FLOGI response event.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_fabric_flogi_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK: {
+
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_FLOGI, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+
+		ocs_domain_save_sparms(node->sport->domain, cbdata->els->els_rsp.virt);
+
+		ocs_display_sparams(node->display_name, "flogi rcvd resp", 0, NULL,
+			((uint8_t*)cbdata->els->els_rsp.virt) + 4);
+
+		/* Check to see if the fabric is an F_PORT or and N_PORT */
+		if (ocs_rnode_is_nport(cbdata->els->els_rsp.virt)) {
+			/* sm: if nport and p2p_winner / ocs_domain_attach */
+			ocs_fabric_set_topology(node, OCS_SPORT_TOPOLOGY_P2P);
+			if (ocs_p2p_setup(node->sport)) {
+				node_printf(node, "p2p setup failed, shutting down node\n");
+				node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+				ocs_fabric_initiate_shutdown(node);
+			} else {
+				if (node->sport->p2p_winner) {
+					ocs_node_transition(node, __ocs_p2p_wait_domain_attach, NULL);
+					if (!node->sport->domain->attached) {
+						node_printf(node, "p2p winner, domain not attached\n");
+						ocs_domain_attach(node->sport->domain, node->sport->p2p_port_id);
+					} else {
+						/* already attached, just send ATTACH_OK */
+						node_printf(node, "p2p winner, domain already attached\n");
+						ocs_node_post_event(node, OCS_EVT_DOMAIN_ATTACH_OK, NULL);
+					}
+				} else {
+					/* peer is p2p winner; PLOGI will be received on the
+					 * remote SID=1 node; this node has served its purpose
+					 */
+					node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+					ocs_fabric_initiate_shutdown(node);
+				}
+			}
+		} else {
+			/* sm: if not nport / ocs_domain_attach */
+			/* ext_status has the fc_id, attach domain */
+			ocs_fabric_set_topology(node, OCS_SPORT_TOPOLOGY_FABRIC);
+			ocs_fabric_notify_topology(node);
+			ocs_assert(!node->sport->domain->attached, NULL);
+			ocs_domain_attach(node->sport->domain, cbdata->ext_status);
+			ocs_node_transition(node, __ocs_fabric_wait_domain_attach, NULL);
+		}
+
+		break;
+	}
+
+	case OCS_EVT_ELS_REQ_ABORTED:
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+	case OCS_EVT_SRRS_ELS_REQ_FAIL: {
+		ocs_sport_t *sport = node->sport;
+		/*
+		 * with these errors, we have no recovery, so shutdown the sport, leave the link
+		 * up and the domain ready
+		 */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_FLOGI, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		node_printf(node, "FLOGI failed evt=%s, shutting down sport [%s]\n", ocs_sm_event_name(evt),
+			sport->display_name);
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_sm_post_event(&sport->sm, OCS_EVT_SHUTDOWN, NULL);
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric node state machine: Initial state for a virtual port.
+ *
+ * @par Description
+ * State entered when a virtual port is created. Send FDISC.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_vport_fabric_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* sm: send FDISC */
+		ocs_send_fdisc(node, OCS_FC_FLOGI_TIMEOUT_SEC, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_fabric_fdisc_wait_rsp, NULL);
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric node state machine: Wait for an FDISC response
+ *
+ * @par Description
+ * Used for a virtual port. Waits for an FDISC response. If OK, issue a HW port attach.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_fabric_fdisc_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK: {
+		/* fc_id is in ext_status */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_FDISC, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+
+		ocs_display_sparams(node->display_name, "fdisc rcvd resp", 0, NULL,
+			((uint8_t*)cbdata->els->els_rsp.virt) + 4);
+
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm: ocs_sport_attach */
+		ocs_sport_attach(node->sport, cbdata->ext_status);
+		ocs_node_transition(node, __ocs_fabric_wait_domain_attach, NULL);
+		break;
+
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+	case OCS_EVT_SRRS_ELS_REQ_FAIL: {
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_FDISC, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_log_err(ocs, "FDISC failed, shutting down sport\n");
+		/* sm: shutdown sport */
+		ocs_sm_post_event(&node->sport->sm, OCS_EVT_SHUTDOWN, NULL);
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric node state machine: Wait for a domain/sport attach event.
+ *
+ * @par Description
+ * Waits for a domain/sport attach event.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_fabric_wait_domain_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+	case OCS_EVT_SPORT_ATTACH_OK: {
+		int rc;
+
+		rc = ocs_start_ns_node(node->sport);
+		if (rc)
+			return NULL;
+
+		/* sm: if enable_ini / start fabctl node
+		 * Instantiate the fabric controller (sends SCR) */
+		if (node->sport->enable_rscn) {
+			rc = ocs_start_fabctl_node(node->sport);
+			if (rc)
+				return NULL;
+		}
+		ocs_node_transition(node, __ocs_fabric_idle, NULL);
+		break;
+	}
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric node state machine: Fabric node is idle.
+ *
+ * @par Description
+ * Wait for fabric node events.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_fabric_idle(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		break;
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Name services node state machine: Initialize.
+ *
+ * @par Description
+ * A PLOGI is sent to the well-known name/directory services node.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* sm: send PLOGI */
+		ocs_send_plogi(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_ns_plogi_wait_rsp, NULL);
+		break;
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Name services node state machine: Wait for a PLOGI response.
+ *
+ * @par Description
+ * Waits for a response from PLOGI to name services node, then issues a
+ * node attach request to the HW.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_plogi_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK: {
+		/* Save service parameters */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm: save sparams, ocs_node_attach */
+		ocs_node_save_sparms(node, cbdata->els->els_rsp.virt);
+		ocs_display_sparams(node->display_name, "plogi rcvd resp", 0, NULL,
+			((uint8_t*)cbdata->els->els_rsp.virt) + 4);
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_ns_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+	}
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Name services node state machine: Wait for a node attach completion.
+ *
+ * @par Description
+ * Waits for a node attach completion, then issues an RFTID name services
+ * request.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		/* sm: send RFTID */
+		ocs_ns_send_rftid(node, OCS_FC_ELS_CT_SEND_DEFAULT_TIMEOUT,
+				 OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_ns_rftid_wait_rsp, NULL);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_FAIL:
+		/* node attach failed, shutdown the node */
+		node->attached = FALSE;
+		node_printf(node, "Node attach failed\n");
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	case OCS_EVT_SHUTDOWN:
+		node_printf(node, "Shutdown event received\n");
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_fabric_wait_attach_evt_shutdown, NULL);
+		break;
+
+	/* if receive RSCN just ignore, 
+	 * we haven't sent GID_PT yet (ACC sent by fabctl node) */
+	case OCS_EVT_RSCN_RCVD:
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Wait for a domain/sport/node attach completion, then
+ * shutdown.
+ *
+ * @par Description
+ * Waits for a domain/sport/node attach completion, then shuts
+ * node down.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_fabric_wait_attach_evt_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	/* wait for any of these attach events and then shutdown */
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		node_printf(node, "Attach evt=%s, proceed to shutdown\n", ocs_sm_event_name(evt));
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_FAIL:
+		node->attached = FALSE;
+		node_printf(node, "Attach evt=%s, proceed to shutdown\n", ocs_sm_event_name(evt));
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	/* ignore shutdown event as we're already in shutdown path */
+	case OCS_EVT_SHUTDOWN:
+		node_printf(node, "Shutdown event received\n");
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Name services node state machine: Wait for an RFTID response event.
+ *
+ * @par Description
+ * Waits for an RFTID response event; if configured for an initiator operation,
+ * a GIDPT name services request is issued.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_rftid_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+		if (node_check_ns_req(ctx, evt, arg, FC_GS_NAMESERVER_RFT_ID, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/*sm: send RFFID */
+		ocs_ns_send_rffid(node, OCS_FC_ELS_CT_SEND_DEFAULT_TIMEOUT,
+				OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_ns_rffid_wait_rsp, NULL);
+		break;
+
+	/* if receive RSCN just ignore,
+	 * we haven't sent GID_PT yet (ACC sent by fabctl node) */
+	case OCS_EVT_RSCN_RCVD:
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Fabric node state machine: Wait for RFFID response event.
+ *
+ * @par Description
+ * Waits for an RFFID response event; if configured for an initiator operation,
+ * a GIDPT name services request is issued.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_rffid_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK:	{
+		if (node_check_ns_req(ctx, evt, arg, FC_GS_NAMESERVER_RFF_ID, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		if (node->sport->enable_rscn) {
+			/* sm: if enable_rscn / send GIDPT */
+			ocs_ns_send_gidpt(node, OCS_FC_ELS_CT_SEND_DEFAULT_TIMEOUT,
+					OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+			ocs_node_transition(node, __ocs_ns_gidpt_wait_rsp, NULL);
+		} else {
+			/* if 'T' only, we're done, go to idle */
+			ocs_node_transition(node, __ocs_ns_idle, NULL);
+		}
+		break;
+	}
+	/* if receive RSCN just ignore, 
+	 * we haven't sent GID_PT yet (ACC sent by fabctl node) */
+	case OCS_EVT_RSCN_RCVD:
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Name services node state machine: Wait for a GIDPT response.
+ *
+ * @par Description
+ * Wait for a GIDPT response from the name server. Process the FC_IDs that are
+ * reported by creating new remote ports, as needed.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_gidpt_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK:	{
+		if (node_check_ns_req(ctx, evt, arg, FC_GS_NAMESERVER_GID_PT, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm: / process GIDPT payload */
+		ocs_process_gidpt_payload(node, cbdata->els->els_rsp.virt, cbdata->els->els_rsp.len);
+		/* TODO: should we logout at this point or just go idle */
+		ocs_node_transition(node, __ocs_ns_idle, NULL);
+		break;
+	}
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:	{
+		/* not much we can do; will retry with the next RSCN */
+		node_printf(node, "GID_PT failed to complete\n");
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_node_transition(node, __ocs_ns_idle, NULL);
+		break;
+	}
+
+	/* if receive RSCN here, queue up another discovery processing */
+	case OCS_EVT_RSCN_RCVD: {
+		node_printf(node, "RSCN received during GID_PT processing\n");
+		node->rscn_pending = 1;
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+
+/**
+ * @ingroup ns_sm
+ * @brief Name services node state machine: Idle state.
+ *
+ * @par Description
+ * Idle. Waiting for RSCN received events (posted from the fabric controller), and
+ * restarts the GIDPT name services query and processing.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_idle(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		if (!node->rscn_pending) {
+			break;
+		}
+		node_printf(node, "RSCN pending, restart discovery\n");
+		node->rscn_pending = 0;
+
+			/* fall through */
+
+	case OCS_EVT_RSCN_RCVD: {
+		/* sm: / send GIDPT
+		 * If target RSCN processing is enabled, and this is target only
+		 * (not initiator), and tgt_rscn_delay is non-zero,
+		 * then we delay issuing the GID_PT
+		 */
+		if ((ocs->tgt_rscn_delay_msec != 0) && !node->sport->enable_ini && node->sport->enable_tgt &&
+			enable_target_rscn(ocs)) {
+			ocs_node_transition(node, __ocs_ns_gidpt_delay, NULL);
+		} else {
+			ocs_ns_send_gidpt(node, OCS_FC_ELS_CT_SEND_DEFAULT_TIMEOUT,
+					OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+			ocs_node_transition(node, __ocs_ns_gidpt_wait_rsp, NULL);
+		}
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @brief Handle GIDPT delay timer callback
+ *
+ * @par Description
+ * Post an OCS_EVT_GIDPT_DEIALY_EXPIRED event to the passed in node.
+ *
+ * @param arg Pointer to node.
+ *
+ * @return None.
+ */
+static void
+gidpt_delay_timer_cb(void *arg)
+{
+	ocs_node_t *node = arg;
+	int32_t rc;
+
+	ocs_del_timer(&node->gidpt_delay_timer);
+	rc = ocs_xport_control(node->ocs->xport, OCS_XPORT_POST_NODE_EVENT, node, OCS_EVT_GIDPT_DELAY_EXPIRED, NULL);
+	if (rc) {
+		ocs_log_err(node->ocs, "ocs_xport_control(OCS_XPORT_POST_NODE_EVENT) failed: %d\n", rc);
+	}
+}
+
+/**
+ * @ingroup ns_sm
+ * @brief Name services node state machine: Delayed GIDPT.
+ *
+ * @par Description
+ * Waiting for GIDPT delay to expire before submitting GIDPT to name server.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_ns_gidpt_delay(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		time_t delay_msec;
+
+		ocs_assert(ocs->tgt_rscn_delay_msec != 0, NULL);
+
+		/*
+		 * Compute the delay time.   Set to tgt_rscn_delay, if the time since last GIDPT
+		 * is less than tgt_rscn_period, then use tgt_rscn_period.
+		 */
+		delay_msec = ocs->tgt_rscn_delay_msec;
+		if ((ocs_msectime() - node->time_last_gidpt_msec) < ocs->tgt_rscn_period_msec) {
+			delay_msec = ocs->tgt_rscn_period_msec;
+		}
+
+		ocs_setup_timer(ocs, &node->gidpt_delay_timer, gidpt_delay_timer_cb, node, delay_msec);
+
+		break;
+	}
+
+	case OCS_EVT_GIDPT_DELAY_EXPIRED:
+		node->time_last_gidpt_msec = ocs_msectime();
+		ocs_ns_send_gidpt(node, OCS_FC_ELS_CT_SEND_DEFAULT_TIMEOUT,
+				OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_ns_gidpt_wait_rsp, NULL);
+		break;
+
+	case OCS_EVT_RSCN_RCVD: {
+		ocs_log_debug(ocs, "RSCN received while in GIDPT delay - no action\n");
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric controller node state machine: Initial state.
+ *
+ * @par Description
+ * Issue a PLOGI to a well-known fabric controller address.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_fabctl_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_t *node = ctx->app;
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* no need to login to fabric controller, just send SCR */
+		ocs_send_scr(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_fabctl_wait_scr_rsp, NULL);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric controller node state machine: Wait for a node attach request
+ * to complete.
+ *
+ * @par Description
+ * Wait for a node attach to complete. If successful, issue an SCR
+ * to the fabric controller, subscribing to all RSCN.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ *
+ */
+void *
+__ocs_fabctl_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		/* sm: / send SCR */
+		ocs_send_scr(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_fabctl_wait_scr_rsp, NULL);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_FAIL:
+		/* node attach failed, shutdown the node */
+		node->attached = FALSE;
+		node_printf(node, "Node attach failed\n");
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	case OCS_EVT_SHUTDOWN:
+		node_printf(node, "Shutdown event received\n");
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_fabric_wait_attach_evt_shutdown, NULL);
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric controller node state machine: Wait for an SCR response from the
+ * fabric controller.
+ *
+ * @par Description
+ * Waits for an SCR response from the fabric controller.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+void *
+__ocs_fabctl_wait_scr_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_SCR, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		ocs_node_transition(node, __ocs_fabctl_ready, NULL);
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric controller node state machine: Ready.
+ *
+ * @par Description
+ * In this state, the fabric controller sends a RSCN, which is received
+ * by this node and is forwarded to the name services node object; and
+ * the RSCN LS_ACC is sent.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_fabctl_ready(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_RSCN_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+
+		/* sm: / process RSCN (forward to name services node),
+		 * send LS_ACC */
+		ocs_process_rscn(node, cbdata);
+		ocs_send_ls_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+		ocs_node_transition(node, __ocs_fabctl_wait_ls_acc_cmpl, NULL);
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric controller node state machine: Wait for LS_ACC.
+ *
+ * @par Description
+ * Waits for the LS_ACC from the fabric controller.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_fabctl_wait_ls_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_OK:
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		ocs_node_transition(node, __ocs_fabctl_ready, NULL);
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Initiate fabric node shutdown.
+ *
+ * @param node Node for which shutdown is initiated.
+ *
+ * @return Returns None.
+ */
+
+static void
+ocs_fabric_initiate_shutdown(ocs_node_t *node)
+{
+	ocs_hw_rtn_e rc;
+	ocs_t *ocs = node->ocs;
+	ocs_scsi_io_alloc_disable(node);
+
+	if (node->attached) {
+		/* issue hw node free; don't care if succeeds right away
+		 * or sometime later, will check node->attached later in
+		 * shutdown process
+		 */
+		rc = ocs_hw_node_detach(&ocs->hw, &node->rnode);
+		if (node->rnode.free_group) {
+			ocs_remote_node_group_free(node->node_group);
+			node->node_group = NULL;
+			node->rnode.free_group = FALSE;
+		}
+		if (rc != OCS_HW_RTN_SUCCESS && rc != OCS_HW_RTN_SUCCESS_SYNC) {
+			node_printf(node, "Failed freeing HW node, rc=%d\n", rc);
+		}
+	}
+	/*
+	 * node has either been detached or is in the process of being detached,
+	 * call common node's initiate cleanup function
+	 */
+	ocs_node_initiate_cleanup(node);
+}
+
+/**
+ * @ingroup fabric_sm
+ * @brief Fabric node state machine: Handle the common fabric node events.
+ *
+ * @param funcname Function name text.
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+static void *
+__ocs_fabric_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_t *node = NULL;
+	ocs_assert(ctx, NULL);
+	ocs_assert(ctx->app, NULL);
+	node = ctx->app;
+
+	switch(evt) {
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		break;
+	case OCS_EVT_SHUTDOWN:
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	default:
+		/* call default event handler common to all nodes */
+		__ocs_node_common(funcname, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Return TRUE if the remote node is an NPORT.
+ *
+ * @par Description
+ * Examines the service parameters. Returns TRUE if the node reports itself as
+ * an NPORT.
+ *
+ * @param remote_sparms Remote node service parameters.
+ *
+ * @return Returns TRUE if NPORT.
+ */
+
+int32_t
+ocs_rnode_is_nport(fc_plogi_payload_t *remote_sparms)
+{
+	return (ocs_be32toh(remote_sparms->common_service_parameters[1]) & (1U << 28)) == 0;
+}
+
+/**
+ * @brief Return the node's WWPN as an uint64_t.
+ *
+ * @par Description
+ * The WWPN is computed from service parameters, and returned as a uint64_t.
+ *
+ * @param sp Pointer to service parameters.
+ *
+ * @return Returns WWPN.
+ *
+ */
+
+static uint64_t
+ocs_get_wwpn(fc_plogi_payload_t *sp)
+{
+	return (((uint64_t)ocs_be32toh(sp->port_name_hi) << 32ll) | (ocs_be32toh(sp->port_name_lo)));
+}
+
+/**
+ * @brief Return TRUE if the remote node is the point-to-point winner.
+ *
+ * @par Description
+ * Compares WWPNs. Returns TRUE if the remote node's WWPN is numerically
+ * higher than the local node's WWPN.
+ *
+ * @param sport Pointer to the sport object.
+ *
+ * @return
+ * - 0, if the remote node is the loser.
+ * - 1, if the remote node is the winner.
+ * - (-1), if remote node is neither the loser nor the winner
+ *   (WWPNs match)
+ */
+
+static int32_t
+ocs_rnode_is_winner(ocs_sport_t *sport)
+{
+	fc_plogi_payload_t *remote_sparms = (fc_plogi_payload_t*) sport->domain->flogi_service_params;
+	uint64_t remote_wwpn = ocs_get_wwpn(remote_sparms);
+	uint64_t local_wwpn = sport->wwpn;
+	char prop_buf[32];
+	uint64_t wwn_bump = 0;
+
+	if (ocs_get_property("wwn_bump", prop_buf, sizeof(prop_buf)) == 0) {
+		wwn_bump = ocs_strtoull(prop_buf, 0, 0);
+	}
+	local_wwpn ^= wwn_bump;
+
+	remote_wwpn = ocs_get_wwpn(remote_sparms);
+
+	ocs_log_debug(sport->ocs, "r: %08x %08x\n", ocs_be32toh(remote_sparms->port_name_hi), ocs_be32toh(remote_sparms->port_name_lo));
+	ocs_log_debug(sport->ocs, "l: %08x %08x\n", (uint32_t) (local_wwpn >> 32ll), (uint32_t) local_wwpn);
+
+	if (remote_wwpn == local_wwpn) {
+		ocs_log_warn(sport->ocs, "WWPN of remote node [%08x %08x] matches local WWPN\n",
+			(uint32_t) (local_wwpn >> 32ll), (uint32_t) local_wwpn);
+		return (-1);
+	}
+
+	return (remote_wwpn > local_wwpn);
+}
+
+/**
+ * @ingroup p2p_sm
+ * @brief Point-to-point state machine: Wait for the domain attach to complete.
+ *
+ * @par Description
+ * Once the domain attach has completed, a PLOGI is sent (if we're the
+ * winning point-to-point node).
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_p2p_wait_domain_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_DOMAIN_ATTACH_OK: {
+		ocs_sport_t *sport = node->sport;
+		ocs_node_t *rnode;
+
+		/* this transient node (SID=0 (recv'd FLOGI) or DID=fabric (sent FLOGI))
+		 * is the p2p winner, will use a separate node to send PLOGI to peer
+		 */
+		ocs_assert (node->sport->p2p_winner, NULL);
+
+		rnode = ocs_node_find(sport, node->sport->p2p_remote_port_id);
+		if (rnode != NULL) {
+			/* the "other" transient p2p node has already kicked off the
+			 * new node from which PLOGI is sent */
+			node_printf(node, "Node with fc_id x%x already exists\n", rnode->rnode.fc_id);
+			ocs_assert (rnode != node, NULL);
+		} else {
+			/* create new node (SID=1, DID=2) from which to send PLOGI */
+			rnode = ocs_node_alloc(sport, sport->p2p_remote_port_id, FALSE, FALSE);
+			if (rnode == NULL) {
+				ocs_log_err(ocs, "node alloc failed\n");
+				return NULL;
+			}
+
+			ocs_fabric_notify_topology(node);
+			/* sm: allocate p2p remote node */
+			ocs_node_transition(rnode, __ocs_p2p_rnode_init, NULL);
+		}
+
+		/* the transient node (SID=0 or DID=fabric) has served its purpose */
+		if (node->rnode.fc_id == 0) {
+			/* if this is the SID=0 node, move to the init state in case peer
+			 * has restarted FLOGI discovery and FLOGI is pending
+			 */
+			/* don't send PLOGI on ocs_d_init entry */
+			ocs_node_init_device(node, FALSE);
+		} else {
+			/* if this is the DID=fabric node (we initiated FLOGI), shut it down */
+			node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+			ocs_fabric_initiate_shutdown(node);
+		}
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup p2p_sm
+ * @brief Point-to-point state machine: Remote node initialization state.
+ *
+ * @par Description
+ * This state is entered after winning point-to-point, and the remote node
+ * is instantiated.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_p2p_rnode_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/* sm: / send PLOGI */
+		ocs_send_plogi(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT, OCS_FC_ELS_DEFAULT_RETRIES, NULL, NULL);
+		ocs_node_transition(node, __ocs_p2p_wait_plogi_rsp, NULL);
+		break;
+
+	case OCS_EVT_ABTS_RCVD:
+		/* sm: send BA_ACC */
+		ocs_bls_send_acc_hdr(cbdata->io, cbdata->header->dma.virt);
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup p2p_sm
+ * @brief Point-to-point node state machine: Wait for the FLOGI accept completion.
+ *
+ * @par Description
+ * Wait for the FLOGI accept completion.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_p2p_wait_flogi_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_OK:
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+
+		/* sm: if p2p_winner / domain_attach */
+		if (node->sport->p2p_winner) {
+			ocs_node_transition(node, __ocs_p2p_wait_domain_attach, NULL);
+			if (node->sport->domain->attached &&
+			    !(node->sport->domain->domain_notify_pend)) {
+				node_printf(node, "Domain already attached\n");
+				ocs_node_post_event(node, OCS_EVT_DOMAIN_ATTACH_OK, NULL);
+			}
+		} else {
+			/* this node has served its purpose; we'll expect a PLOGI on a separate
+			 * node (remote SID=0x1); return this node to init state in case peer
+			 * restarts discovery -- it may already have (pending frames may exist).
+			 */
+			/* don't send PLOGI on ocs_d_init entry */
+			ocs_node_init_device(node, FALSE);
+		}
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_FAIL:
+		/* LS_ACC failed, possibly due to link down; shutdown node and wait
+		 * for FLOGI discovery to restart */
+		node_printf(node, "FLOGI LS_ACC failed, shutting down\n");
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	case OCS_EVT_ABTS_RCVD: {
+		/* sm: / send BA_ACC */
+		ocs_bls_send_acc_hdr(cbdata->io, cbdata->header->dma.virt);
+		break;
+	}
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+
+/**
+ * @ingroup p2p_sm
+ * @brief Point-to-point node state machine: Wait for a PLOGI response
+ * as a point-to-point winner.
+ *
+ * @par Description
+ * Wait for a PLOGI response from the remote node as a point-to-point winner.
+ * Submit node attach request to the HW.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_p2p_wait_plogi_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_SRRS_ELS_REQ_OK: {
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm: / save sparams, ocs_node_attach */
+		ocs_node_save_sparms(node, cbdata->els->els_rsp.virt);
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_p2p_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+	}
+	case OCS_EVT_SRRS_ELS_REQ_FAIL: {
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		node_printf(node, "PLOGI failed, shutting down\n");
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_fabric_initiate_shutdown(node);
+		break;
+	}
+
+	case OCS_EVT_PLOGI_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		/* if we're in external loopback mode, just send LS_ACC */
+		if (node->ocs->external_loopback) {
+			ocs_send_plogi_acc(cbdata->io, ocs_be16toh(hdr->ox_id), NULL, NULL);
+			break;
+		} else{
+			/* if this isn't external loopback, pass to default handler */
+			__ocs_fabric_common(__func__, ctx, evt, arg);
+		}
+		break;
+	}
+	case OCS_EVT_PRLI_RCVD:
+		/* I, or I+T */
+		/* sent PLOGI and before completion was seen, received the
+		 * PRLI from the remote node (WCQEs and RCQEs come in on
+		 * different queues and order of processing cannot be assumed)
+		 * Save OXID so PRLI can be sent after the attach and continue
+		 * to wait for PLOGI response
+		 */
+		ocs_process_prli_payload(node, cbdata->payload->dma.virt);
+		ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PRLI);
+		ocs_node_transition(node, __ocs_p2p_wait_plogi_rsp_recvd_prli, NULL);
+		break;
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup p2p_sm
+ * @brief Point-to-point node state machine: Waiting on a response for a
+ *	sent PLOGI.
+ *
+ * @par Description
+ * State is entered when the point-to-point winner has sent
+ * a PLOGI and is waiting for a response. Before receiving the
+ * response, a PRLI was received, implying that the PLOGI was
+ * successful.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_p2p_wait_plogi_rsp_recvd_prli(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		/*
+		 * Since we've received a PRLI, we have a port login and will
+		 * just need to wait for the PLOGI response to do the node
+		 * attach and then we can send the LS_ACC for the PRLI. If,
+		 * during this time, we receive FCP_CMNDs (which is possible
+		 * since we've already sent a PRLI and our peer may have accepted).
+		 * At this time, we are not waiting on any other unsolicited
+		 * frames to continue with the login process. Thus, it will not
+		 * hurt to hold frames here.
+		 */
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_OK:	/* PLOGI response received */
+		/* Completion from PLOGI sent */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		/* sm: / save sparams, ocs_node_attach */
+		ocs_node_save_sparms(node, cbdata->els->els_rsp.virt);
+		ocs_display_sparams(node->display_name, "plogi rcvd resp", 0, NULL,
+			((uint8_t*)cbdata->els->els_rsp.virt) + 4);
+		rc = ocs_node_attach(node);
+		ocs_node_transition(node, __ocs_p2p_wait_node_attach, NULL);
+		if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+			ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+		}
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:	/* PLOGI response received */
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+		/* PLOGI failed, shutdown the node */
+		if (node_check_els_req(ctx, evt, arg, FC_ELS_CMD_PLOGI, __ocs_fabric_common, __func__)) {
+			return NULL;
+		}
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup p2p_sm
+ * @brief Point-to-point node state machine: Wait for a point-to-point node attach
+ * to complete.
+ *
+ * @par Description
+ * Waits for the point-to-point node attach to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_p2p_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_cb_t *cbdata = arg;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		switch (node->send_ls_acc) {
+		case OCS_NODE_SEND_LS_ACC_PRLI: {
+			ocs_d_send_prli_rsp(node->ls_acc_io, node->ls_acc_oxid);
+			node->send_ls_acc = OCS_NODE_SEND_LS_ACC_NONE;
+			node->ls_acc_io = NULL;
+			break;
+		}
+		case OCS_NODE_SEND_LS_ACC_PLOGI: /* Can't happen in P2P */
+		case OCS_NODE_SEND_LS_ACC_NONE:
+		default:
+			/* Normal case for I */
+			/* sm: send_plogi_acc is not set / send PLOGI acc */
+			ocs_node_transition(node, __ocs_d_port_logged_in, NULL);
+			break;
+		}
+		break;
+
+	case OCS_EVT_NODE_ATTACH_FAIL:
+		/* node attach failed, shutdown the node */
+		node->attached = FALSE;
+		node_printf(node, "Node attach failed\n");
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_fabric_initiate_shutdown(node);
+		break;
+
+	case OCS_EVT_SHUTDOWN:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		ocs_node_transition(node, __ocs_fabric_wait_attach_evt_shutdown, NULL);
+		break;
+	case OCS_EVT_PRLI_RCVD:
+		node_printf(node, "%s: PRLI received before node is attached\n", ocs_sm_event_name(evt));
+		ocs_process_prli_payload(node, cbdata->payload->dma.virt);
+		ocs_send_ls_acc_after_attach(cbdata->io, cbdata->header->dma.virt, OCS_NODE_SEND_LS_ACC_PRLI);
+		break;
+	default:
+		__ocs_fabric_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @brief Start up the name services node.
+ *
+ * @par Description
+ * Allocates and starts up the name services node.
+ *
+ * @param sport Pointer to the sport structure.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+static int32_t
+ocs_start_ns_node(ocs_sport_t *sport)
+{
+	ocs_node_t *ns;
+
+	/* Instantiate a name services node */
+	ns = ocs_node_find(sport, FC_ADDR_NAMESERVER);
+	if (ns == NULL) {
+		ns = ocs_node_alloc(sport, FC_ADDR_NAMESERVER, FALSE, FALSE);
+		if (ns == NULL) {
+			return -1;
+		}
+	}
+	/* TODO: for found ns, should we be transitioning from here?
+	 * breaks transition only 1. from within state machine or
+	 * 2. if after alloc 
+	 */
+	if (ns->ocs->nodedb_mask & OCS_NODEDB_PAUSE_NAMESERVER) {
+		ocs_node_pause(ns, __ocs_ns_init);
+	} else {
+		ocs_node_transition(ns, __ocs_ns_init, NULL);
+	}
+	return 0;
+}
+
+/**
+ * @brief Start up the fabric controller node.
+ *
+ * @par Description
+ * Allocates and starts up the fabric controller node.
+ *
+ * @param sport Pointer to the sport structure.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+static int32_t
+ocs_start_fabctl_node(ocs_sport_t *sport)
+{
+	ocs_node_t *fabctl;
+
+	fabctl = ocs_node_find(sport, FC_ADDR_CONTROLLER);
+	if (fabctl == NULL) {
+		fabctl = ocs_node_alloc(sport, FC_ADDR_CONTROLLER, FALSE, FALSE);
+		if (fabctl == NULL) {
+			return -1;
+		}
+	}
+	/* TODO: for found ns, should we be transitioning from here?
+	 * breaks transition only 1. from within state machine or
+	 * 2. if after alloc
+	 */
+	ocs_node_transition(fabctl, __ocs_fabctl_init, NULL);
+	return 0;
+}
+
+/**
+ * @brief Process the GIDPT payload.
+ *
+ * @par Description
+ * The GIDPT payload is parsed, and new nodes are created, as needed.
+ *
+ * @param node Pointer to the node structure.
+ * @param gidpt Pointer to the GIDPT payload.
+ * @param gidpt_len Payload length
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+static int32_t
+ocs_process_gidpt_payload(ocs_node_t *node, fcct_gidpt_acc_t *gidpt, uint32_t gidpt_len)
+{
+	uint32_t i;
+	uint32_t j;
+	ocs_node_t *newnode;
+	ocs_sport_t *sport = node->sport;
+	ocs_t *ocs = node->ocs;
+	uint32_t port_id;
+	uint32_t port_count;
+	ocs_node_t *n;
+	ocs_node_t **active_nodes;
+	uint32_t portlist_count;
+	uint16_t residual;
+
+	residual = ocs_be16toh(gidpt->hdr.max_residual_size);
+
+	if (residual != 0) {
+		ocs_log_debug(node->ocs, "residual is %u words\n", residual);
+	}
+
+	if (ocs_be16toh(gidpt->hdr.cmd_rsp_code) == FCCT_HDR_CMDRSP_REJECT) {
+		node_printf(node, "GIDPT request failed: rsn x%x rsn_expl x%x\n",
+			gidpt->hdr.reason_code, gidpt->hdr.reason_code_explanation);
+		return -1;
+	}
+
+	portlist_count = (gidpt_len - sizeof(fcct_iu_header_t)) / sizeof(gidpt->port_list);
+
+	/* Count the number of nodes */
+	port_count = 0;
+	ocs_sport_lock(sport);
+		ocs_list_foreach(&sport->node_list, n) {
+			port_count ++;
+		}
+
+		/* Allocate a buffer for all nodes */
+		active_nodes = ocs_malloc(node->ocs, port_count * sizeof(*active_nodes), OCS_M_NOWAIT | OCS_M_ZERO);
+		if (active_nodes == NULL) {
+			node_printf(node, "ocs_malloc failed\n");
+			ocs_sport_unlock(sport);
+			return -1;
+		}
+
+		/* Fill buffer with fc_id of active nodes */
+		i = 0;
+		ocs_list_foreach(&sport->node_list, n) {
+			port_id = n->rnode.fc_id;
+			switch (port_id) {
+			case FC_ADDR_FABRIC:
+			case FC_ADDR_CONTROLLER:
+			case FC_ADDR_NAMESERVER:
+				break;
+			default:
+				if (!FC_ADDR_IS_DOMAIN_CTRL(port_id)) {
+					active_nodes[i++] = n;
+				}
+				break;
+			}
+		}
+
+		/* update the active nodes buffer */
+		for (i = 0; i < portlist_count; i ++) {
+			port_id = fc_be24toh(gidpt->port_list[i].port_id);
+
+			for (j = 0; j < port_count; j ++) {
+				if ((active_nodes[j] != NULL) && (port_id == active_nodes[j]->rnode.fc_id)) {
+					active_nodes[j] = NULL;
+				}
+			}
+
+			if (gidpt->port_list[i].ctl & FCCT_GID_PT_LAST_ID)
+				break;
+		}
+
+		/* Those remaining in the active_nodes[] are now gone ! */
+		for (i = 0; i < port_count; i ++) {
+			/* if we're an initiator and the remote node is a target, then
+			 * post the node missing event.   if we're target and we have enabled
+			 * target RSCN, then post the node missing event.
+			 */
+			if (active_nodes[i] != NULL) {
+				if ((node->sport->enable_ini && active_nodes[i]->targ) ||
+				    (node->sport->enable_tgt && enable_target_rscn(ocs))) {
+					ocs_node_post_event(active_nodes[i], OCS_EVT_NODE_MISSING, NULL);
+				} else {
+					node_printf(node, "GID_PT: skipping non-tgt port_id x%06x\n",
+						active_nodes[i]->rnode.fc_id);
+				}
+			}
+		}
+		ocs_free(ocs, active_nodes, port_count * sizeof(*active_nodes));
+
+		for(i = 0; i < portlist_count; i ++) {
+			uint32_t port_id = fc_be24toh(gidpt->port_list[i].port_id);
+
+			/* node_printf(node, "GID_PT: port_id x%06x\n", port_id); */
+
+			/* Don't create node for ourselves or the associated NPIV ports */
+			if (port_id != node->rnode.sport->fc_id && !ocs_sport_find(sport->domain, port_id)) {
+				newnode = ocs_node_find(sport, port_id);
+				if (newnode) {
+					/* TODO: what if node deleted here?? */
+					if (node->sport->enable_ini && newnode->targ) {
+						ocs_node_post_event(newnode, OCS_EVT_NODE_REFOUND, NULL);
+					}
+					/* original code sends ADISC, has notion of "refound" */
+				} else {
+					if (node->sport->enable_ini) {
+						newnode = ocs_node_alloc(sport, port_id, 0, 0);
+						if (newnode == NULL) {
+							ocs_log_err(ocs, "ocs_node_alloc() failed\n");
+							ocs_sport_unlock(sport);
+							return -1;
+						}
+						/* send PLOGI automatically if initiator */
+						ocs_node_init_device(newnode, TRUE);
+					}
+				}
+			}
+
+			if (gidpt->port_list[i].ctl & FCCT_GID_PT_LAST_ID) {
+				break;
+			}
+		}
+	ocs_sport_unlock(sport);
+	return 0;
+}
+
+/**
+ * @brief Set up the domain point-to-point parameters.
+ *
+ * @par Description
+ * The remote node service parameters are examined, and various point-to-point
+ * variables are set.
+ *
+ * @param sport Pointer to the sport object.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int32_t
+ocs_p2p_setup(ocs_sport_t *sport)
+{
+	ocs_t *ocs = sport->ocs;
+	int32_t rnode_winner;
+	rnode_winner = ocs_rnode_is_winner(sport);
+
+	/* set sport flags to indicate p2p "winner" */
+	if (rnode_winner == 1) {
+		sport->p2p_remote_port_id = 0;
+		sport->p2p_port_id = 0;
+		sport->p2p_winner = FALSE;
+	} else if (rnode_winner == 0) {
+		sport->p2p_remote_port_id = 2;
+		sport->p2p_port_id = 1;
+		sport->p2p_winner = TRUE;
+	} else {
+		/* no winner; only okay if external loopback enabled */
+		if (sport->ocs->external_loopback) {
+			/*
+			 * External loopback mode enabled; local sport and remote node
+			 * will be registered with an NPortID = 1;
+			 */
+			ocs_log_debug(ocs, "External loopback mode enabled\n");
+			sport->p2p_remote_port_id = 1;
+			sport->p2p_port_id = 1;
+			sport->p2p_winner = TRUE;
+		} else {
+			ocs_log_warn(ocs, "failed to determine p2p winner\n");
+			return rnode_winner;
+		}
+	}
+	return 0;
+}
+
+/**
+ * @brief Process the FABCTL node RSCN.
+ *
+ * <h3 class="desc">Description</h3>
+ * Processes the FABCTL node RSCN payload, simply passes the event to the name server.
+ *
+ * @param node Pointer to the node structure.
+ * @param cbdata Callback data to pass forward.
+ *
+ * @return None.
+ */
+
+static void
+ocs_process_rscn(ocs_node_t *node, ocs_node_cb_t *cbdata)
+{
+	ocs_t *ocs = node->ocs;
+	ocs_sport_t *sport = node->sport;
+	ocs_node_t *ns;
+
+	/* Forward this event to the name-services node */
+	ns = ocs_node_find(sport, FC_ADDR_NAMESERVER);
+	if (ns != NULL)  {
+		ocs_node_post_event(ns, OCS_EVT_RSCN_RCVD, cbdata);
+	} else {
+		ocs_log_warn(ocs, "can't find name server node\n");
+	}
+}
diff --git a/sys/dev/ocs_fc/ocs_fabric.h b/sys/dev/ocs_fc/ocs_fabric.h
new file mode 100644
index 000000000000..57fad1390984
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_fabric.h
@@ -0,0 +1,82 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Declarations for the interface exported by ocs_fabric
+ */
+
+
+#if !defined(__OCS_FABRIC_H__)
+#define __OCS_FABRIC_H__
+extern void *__ocs_fabric_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabric_flogi_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabric_domain_attach_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabric_wait_domain_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern void *__ocs_vport_fabric_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabric_fdisc_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabric_wait_sport_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern void *__ocs_ns_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_plogi_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_rftid_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_rffid_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabric_wait_attach_evt_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_logo_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_gidpt_wait_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_idle(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_ns_gidpt_delay(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern void *__ocs_fabctl_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabctl_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabctl_wait_scr_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabctl_ready(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabctl_wait_ls_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_fabric_idle(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern void *__ocs_p2p_rnode_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_p2p_domain_attach_wait(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_p2p_wait_flogi_acc_cmpl(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_p2p_wait_plogi_rsp(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_p2p_wait_plogi_rsp_recvd_prli(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_p2p_wait_domain_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_p2p_wait_node_attach(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern int32_t ocs_rnode_is_nport(fc_plogi_payload_t *remote_sparms);
+extern int32_t ocs_p2p_setup(ocs_sport_t *sport);
+extern void ocs_fabric_set_topology(ocs_node_t *node, ocs_sport_topology_e topology);
+extern void ocs_fabric_notify_topology(ocs_node_t *node);
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_fcp.h b/sys/dev/ocs_fc/ocs_fcp.h
new file mode 100644
index 000000000000..8a95f596891c
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_fcp.h
@@ -0,0 +1,747 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Define Fibre Channel types and structures.
+ */
+
+#ifndef _OCS_FCP_H
+#define _OCS_FCP_H
+
+#define FC_ELS_CMD_RJT		0x01
+#define FC_ELS_CMD_ACC		0x02
+#define FC_ELS_CMD_PLOGI	0x03
+#define FC_ELS_CMD_FLOGI	0x04
+#define FC_ELS_CMD_LOGO		0x05
+#define FC_ELS_CMD_RRQ		0x12
+#define FC_ELS_CMD_PRLI		0x20
+#define FC_ELS_CMD_PRLO		0x21
+#define FC_ELS_CMD_PDISC	0x50
+#define FC_ELS_CMD_FDISC	0x51
+#define FC_ELS_CMD_ADISC	0x52
+#define FC_ELS_CMD_RSCN		0x61
+#define FC_ELS_CMD_SCR		0x62
+
+#define FC_TYPE_BASIC_LINK	0
+#define FC_TYPE_FCP		0x08
+#define FC_TYPE_GS		0x20
+#define FC_TYPE_SW		0x22
+
+#define FC_ADDR_FABRIC			0xfffffe	/** well known fabric address */
+#define FC_ADDR_CONTROLLER              0xfffffd        /** well known fabric controller address */
+#define FC_ADDR_IS_DOMAIN_CTRL(x)	(((x) & 0xffff00) == 0xfffc00)	/** is well known domain controller */
+#define FC_ADDR_GET_DOMAIN_CTRL(x)	((x) & 0x0000ff)	/** get domain controller number */
+#define FC_ADDR_NAMESERVER              0xfffffc        /** well known directory server address */
+
+#define FC_GS_TYPE_ALIAS_SERVICE		0xf8
+#define FC_GS_TYPE_MANAGEMENT_SERVICE		0xfa
+#define FC_GS_TYPE_DIRECTORY_SERVICE		0xfc
+
+#define FC_GS_SUBTYPE_NAME_SERVER		0x02
+
+/**
+ * Generic Services FC Type Bit mask macros:
+ */
+#define FC_GS_TYPE_WORD(type)	((type) >> 5)
+#define FC_GS_TYPE_BIT(type)	((type) & 0x1f)
+
+/**
+ * Generic Services Name Server Request Command codes:
+ */
+#define FC_GS_NAMESERVER_GPN_ID		0x0112
+#define FC_GS_NAMESERVER_GNN_ID		0x0113
+#define FC_GS_NAMESERVER_GFPN_ID	0x011c
+#define FC_GS_NAMESERVER_GFF_ID		0x011f
+#define FC_GS_NAMESERVER_GID_FT		0x0171
+#define FC_GS_NAMESERVER_GID_PT		0x01a1
+#define FC_GS_NAMESERVER_RHBA		0x0200
+#define FC_GS_NAMESERVER_RPA		0x0211
+#define FC_GS_NAMESERVER_RPN_ID		0x0212
+#define FC_GS_NAMESERVER_RNN_ID		0x0213
+#define FC_GS_NAMESERVER_RCS_ID		0x0214
+#define FC_GS_NAMESERVER_RFT_ID		0x0217
+#define FC_GS_NAMESERVER_RFF_ID		0x021f
+#define FC_GS_NAMESERVER_RSNN_NN	0x0239
+#define FC_GS_NAMESERVER_RSPN_ID	0x0218
+
+
+#define FC_GS_REVISION		0x03
+
+#define FC_GS_IO_PARAMS		{ .fc_ct.r_ctl = 0x02, \
+				.fc_ct.type = FC_TYPE_GS, \
+				.fc_ct.df_ctl = 0x00 }
+
+typedef struct fc_vft_header_s {
+	uint32_t	:1,
+			vf_id:12,
+			priority:3,
+			e:1,
+			:1,
+			type:4,
+			ver:2,
+			r_ctl:8;
+	uint32_t	:24,
+			hopct:8;
+} fc_vft_header_t;
+
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+static inline uint32_t fc_be24toh(uint32_t x) { return (ocs_be32toh(x) >> 8); }
+#else
+static inline uint32_t fc_be24toh(uint32_t x) { }
+#endif
+static inline uint32_t fc_htobe24(uint32_t x) { return fc_be24toh(x); }
+
+#define FC_SOFI3	0x2e
+#define FC_SOFn3	0x36
+#define FC_EOFN		0x41
+#define FC_EOFT		0x42
+
+/**
+ * @brief FC header in big-endian order
+ */
+typedef struct fc_header_s {
+	uint32_t	info:4,
+			r_ctl:4,
+			d_id:24;
+	uint32_t	cs_ctl:8,
+			s_id:24;
+	uint32_t	type:8,
+			f_ctl:24;
+	uint32_t	seq_id:8,
+			df_ctl:8,
+			seq_cnt:16;
+	uint32_t	ox_id:16,
+			rx_id:16;
+	uint32_t	parameter;
+} fc_header_t;
+
+
+/**
+ * @brief FC header in little-endian order
+ */
+typedef struct fc_header_le_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	d_id:24,
+			info:4,
+			r_ctl:4;
+	uint32_t	s_id:24,
+			cs_ctl:8;
+	uint32_t	f_ctl:24,
+			type:8;
+	uint32_t	seq_cnt:16,
+			df_ctl:8,
+			seq_id:8;
+	uint32_t	rx_id:16,
+			ox_id:16;
+	uint32_t	parameter;
+#else
+#error big endian version not defined
+#endif
+} fc_header_le_t;
+
+/**
+ * @brief FC VM header in big-endian order
+ */
+typedef struct fc_vm_header_s {
+	uint32_t	dst_vmid;
+	uint32_t	src_vmid;
+	uint32_t	rsvd0;
+	uint32_t	rsvd1;
+} fc_vm_header_t;
+
+#define FC_DFCTL_DEVICE_HDR_16_MASK	0x1
+#define FC_DFCTL_NETWORK_HDR_MASK	0x20	
+#define FC_DFCTL_ESP_HDR_MASK		0x40				
+#define FC_DFCTL_NETWORK_HDR_SIZE	16	
+#define FC_DFCTL_ESP_HDR_SIZE		0 //FIXME				
+
+#define FC_RCTL_FC4_DATA	0
+#define FC_RCTL_ELS		2
+#define FC_RCTL_BLS		8
+
+#define FC_RCTL_INFO_UNCAT	0
+#define FC_RCTL_INFO_SOL_DATA	1
+#define FC_RCTL_INFO_UNSOL_CTRL	2
+#define FC_RCTL_INFO_SOL_CTRL	3
+#define FC_RCTL_INFO_UNSOL_DATA	4
+#define FC_RCTL_INFO_DATA_DESC	5
+#define FC_RCTL_INFO_UNSOL_CMD	6
+#define FC_RCTL_INFO_CMD_STATUS	7
+
+#define FC_FCTL_EXCHANGE_RESPONDER	0x800000
+#define FC_FCTL_SEQUENCE_CONTEXT	0x400000
+#define FC_FCTL_FIRST_SEQUENCE		0x200000
+#define FC_FCTL_LAST_SEQUENCE		0x100000
+#define FC_FCTL_END_SEQUENCE		0x080000
+#define FC_FCTL_END_CONNECTION		0x040000
+#define FC_FCTL_PRIORITY_ENABLE		0x020000
+#define FC_FCTL_SEQUENCE_INITIATIVE	0x010000
+#define FC_FCTL_FILL_DATA_BYTES_MASK	0x000003
+
+/**
+ * Common BLS definitions:
+ */
+#define FC_INFO_NOP			0x0
+#define FC_INFO_ABTS			0x1
+#define FC_INFO_RMC			0x2
+/* reserved				0x3 */
+#define FC_INFO_BA_ACC			0x4
+#define FC_INFO_BA_RJT			0x5
+#define FC_INFO_PRMT			0x6
+
+/* (FC-LS) LS_RJT Reason Codes */
+#define FC_REASON_INVALID_COMMAND_CODE		0x01
+#define FC_REASON_LOGICAL_ERROR			0x03
+#define FC_REASON_LOGICAL_BUSY			0x05
+#define FC_REASON_PROTOCOL_ERROR		0x07
+#define FC_REASON_UNABLE_TO_PERFORM		0x09
+#define FC_REASON_COMMAND_NOT_SUPPORTED		0x0b
+#define FC_REASON_COMMAND_IN_PROGRESS   	0x0e
+#define FC_REASON_VENDOR_SPECIFIC		0xff
+
+/* (FC-LS) LS_RJT Reason Codes Explanations */
+#define FC_EXPL_NO_ADDITIONAL			0x00
+#define FC_EXPL_SPARAM_OPTIONS			0x01
+#define FC_EXPL_SPARAM_INITIATOR		0x03
+#define FC_EXPL_SPARAM_RECPIENT			0x05
+#define FC_EXPL_SPARM_DATA_SIZE			0x07
+#define FC_EXPL_SPARM_CONCURRENT		0x09
+#define FC_EXPL_SPARM_CREDIT			0x0b
+#define FC_EXPL_INV_PORT_NAME 			0x0d
+#define FC_EXPL_INV_NODE_NAME 			0x0e
+#define FC_EXPL_INV_COMMON_SPARAMS 		0x0f
+#define FC_EXPL_INV_ASSOC_HEADER		0x11
+#define FC_EXPL_ASSOC_HDR_REQUIRED		0x13
+#define FC_EXPL_INV_ORIGINATOR_S_ID		0x15
+#define FC_EXPL_INV_X_ID_COMBINATION		0x17
+#define FC_EXPL_COMMAND_IN_PROGRESS		0x19
+#define FC_EXPL_NPORT_LOGIN_REQUIRED		0x1e
+#define FC_EXPL_N_PORT_ID			0x1f
+#define FC_EXPL_INSUFFICIENT_RESOURCES		0x29
+#define FC_EXPL_UNABLE_TO_SUPPLY_DATA		0x2a
+#define FC_EXPL_REQUEST_NOT_SUPPORTED		0x2c
+#define FC_EXPL_INV_PAYLOAD_LEN			0x1d
+#define FC_EXPL_INV_PORT_NODE_NAME		0x44
+#define FC_EXPL_LOGIN_EXT_NOT_SUPPORTED		0x46
+#define FC_EXPL_AUTH_REQUIRED			0x48
+#define FC_EXPL_SCAN_VALUE_NOT_ALLOWED		0x50
+#define FC_EXPL_SCAN_VALUE_NOT_SUPPORTED 	0x51
+#define FC_EXPL_NO_RESOURCES_ASSIGNED		0x52
+#define FC_EXPL_MAC_ADDR_MODE_NOT_SUPPORTED	0x60
+#define FC_EXPL_MAC_ADDR_INCORRECTLY_FORMED	0x61
+#define FC_EXPL_VN2VN_PORT_NOT_IN_NEIGHBOR_SET	0x62
+
+#define FC_EXPL_INV_X_ID			0x03	/* invalid OX_ID - RX_ID combination */
+#define FC_EXPL_SEQUENCE_ABORTED		0x05
+
+typedef struct fc_ba_acc_payload_s {
+#define FC_SEQ_ID_VALID			0x80
+#define FC_SEQ_ID_INVALID		0x00
+	uint32_t	seq_id_validity:8,
+			seq_id:8,
+			:16;
+	uint32_t	ox_id:16,
+			rx_id:16;
+	uint32_t	low_seq_cnt:16,
+			high_seq_cnt:16;
+} fc_ba_acc_payload_t;
+
+typedef struct fc_ba_rjt_payload_s {
+	uint32_t	vendor_unique:8,
+			reason_explanation:8,
+			reason_code:8,
+			:8;
+} fc_ba_rjt_payload_t;
+
+typedef struct fc_els_gen_s {
+	uint32_t	command_code: 8,
+			resv1: 24;
+} fc_els_gen_t;
+
+typedef struct fc_plogi_playload_s {
+	uint32_t	command_code: 8,
+			resv1: 24;
+	uint32_t	common_service_parameters[4];
+	uint32_t	port_name_hi;
+	uint32_t	port_name_lo;
+	uint32_t	node_name_hi;
+	uint32_t	node_name_lo;
+	uint32_t	class1_service_parameters[4];
+	uint32_t	class2_service_parameters[4];
+	uint32_t	class3_service_parameters[4];
+	uint32_t	class4_service_parameters[4];
+	uint32_t	vendor_version_level[4];
+} fc_plogi_payload_t;
+
+typedef fc_plogi_payload_t fc_sparms_t;
+
+typedef struct fc_logo_payload_s {
+	uint32_t	command_code: 8,
+			resv1:24;
+	uint32_t	:8,
+			port_id:24;
+	uint32_t	port_name_hi;
+	uint32_t	port_name_lo;
+} fc_logo_payload_t;
+
+typedef struct fc_acc_payload_s {
+	uint32_t	command_code: 8,
+			resv1:24;
+} fc_acc_payload_t;
+
+
+typedef struct fc_ls_rjt_payload_s {
+	uint32_t	command_code:8,
+			resv1:24;
+	uint32_t	resv2:8,
+			reason_code:8,
+			reason_code_exp:8,
+			vendor_unique:8;
+} fc_ls_rjt_payload_t;
+
+typedef struct fc_prli_payload_s {
+	uint32_t	command_code:8,
+			page_length:8,
+			payload_length:16;
+	uint32_t	type:8,
+			type_ext:8,
+			flags:16;
+	uint32_t	originator_pa;
+	uint32_t	responder_pa;
+	uint32_t	:16,
+			service_params:16;
+} fc_prli_payload_t;
+
+typedef struct fc_prlo_payload_s {
+	uint32_t	command_code:8,
+			page_length:8,
+			payload_length:16;
+	uint32_t	type:8,
+			type_ext:8,
+			:16;
+	uint32_t	:32;
+	uint32_t	:32;
+	uint32_t	:32;
+} fc_prlo_payload_t;
+
+typedef struct fc_prlo_acc_payload_s {
+	uint32_t	command_code:8,
+			page_length:8,
+			payload_length:16;
+	uint32_t	type:8,
+			type_ext:8,
+			:4,
+			response_code:4,
+			:8;
+	uint32_t	:32;
+	uint32_t	:32;
+	uint32_t	:32;
+} fc_prlo_acc_payload_t;
+
+typedef struct fc_adisc_payload_s {
+	uint32_t	command_code:8,
+			payload_length:24;
+	uint32_t	:8,
+			hard_address:24;
+	uint32_t	port_name_hi;
+	uint32_t	port_name_lo;
+	uint32_t	node_name_hi;
+	uint32_t	node_name_lo;
+	uint32_t	:8,
+			port_id:24;
+} fc_adisc_payload_t;
+
+/* PRLI flags */
+#define FC_PRLI_ORIGINATOR_PA_VALID	0x8000
+#define FC_PRLI_RESPONDER_PA_VALID	0x4000
+#define FC_PRLI_ESTABLISH_IMAGE_PAIR	0x2000
+#define FC_PRLI_SERVICE_PARAM_INVALID	0x0800
+#define FC_PRLI_REQUEST_EXECUTED	0x0100
+
+/* PRLI Service Parameters */
+#define FC_PRLI_REC_SUPPORT		0x0400
+#define FC_PRLI_TASK_RETRY_ID_REQ	0x0200
+#define FC_PRLI_RETRY			0x0100
+#define FC_PRLI_CONFIRMED_COMPLETION	0x0080
+#define FC_PRLI_DATA_OVERLAY		0x0040
+#define FC_PRLI_INITIATOR_FUNCTION      0x0020
+#define FC_PRLI_TARGET_FUNCTION         0x0010
+#define FC_PRLI_READ_XRDY_DISABLED	0x0002
+#define FC_PRLI_WRITE_XRDY_DISABLED	0x0001
+
+/* PRLO Logout flags */
+#define FC_PRLO_REQUEST_EXECUTED	0x0001
+
+typedef struct fc_scr_payload_s {
+	uint32_t	command_code:8,
+			:24;
+	uint32_t	:24,
+			function:8;
+} fc_scr_payload_t;
+
+#define FC_SCR_REG_FABRIC		1
+#define FC_SCR_REG_NPORT		2
+#define FC_SCR_REG_FULL			3
+
+typedef struct {
+	uint32_t :2,
+		rscn_event_qualifier:4,
+		address_format:2,
+		port_id:24;
+} fc_rscn_affected_port_id_page_t;
+
+typedef struct fc_rscn_payload_s {
+	uint32_t	command_code:8,
+			page_length:8,
+			payload_length:16;
+	fc_rscn_affected_port_id_page_t port_list[1];
+} fc_rscn_payload_t;
+
+typedef struct fcct_iu_header_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	revision:8,
+			in_id:24;
+	uint32_t	gs_type:8,
+			gs_subtype:8,
+			options:8,
+			resv1:8;
+	uint32_t	cmd_rsp_code:16,
+			max_residual_size:16;
+	uint32_t	fragment_id:8,
+			reason_code:8,
+			reason_code_explanation:8,
+			vendor_specific:8;
+#else
+#error big endian version not defined
+#endif
+} fcct_iu_header_t;
+
+#define FCCT_REJECT_INVALID_COMMAND_CODE	1
+#define FCCT_REJECT_INVALID_VERSION_LEVEL	2
+#define FCCT_LOGICAL_ERROR			3
+#define FCCT_INVALID_CT_IU_SIZE			4
+#define FCCT_LOGICAL_BUSY			5
+#define FCCT_PROTOCOL_ERROR			7
+#define FCCT_UNABLE_TO_PERFORM			9
+#define FCCT_COMMAND_NOT_SUPPORTED		0x0b
+#define FCCT_FABRIC_PORT_NAME_NOT_REGISTERED	0x0c
+#define FCCT_SERVER_NOT_AVAILABLE		0x0d
+#define FCCT_SESSION_COULD_NOT_BE_ESTABLISHED	0x0e
+#define FCCT_VENDOR_SPECIFIC_ERROR		0xff
+
+#define FCCT_NO_ADDITIONAL_EXPLANATION		0
+#define FCCT_AUTHORIZATION_EXCEPTION		0xf0
+#define FCCT_AUTHENTICATION_EXCEPTION		0xf1
+#define FCCT_DATA_BASE_FULL			0xf2
+#define FCCT_DATA_BASE_EMPTY			0xf3
+#define FCCT_PROCESSING_REQUEST			0xf4
+#define FCCT_UNABLE_TO_VERIFY_CONNECTION	0xf5
+#define FCCT_DEVICES_NOT_IN_COMMON_ZONE		0xf6
+
+typedef struct {
+	fcct_iu_header_t hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	port_id;
+	uint32_t	fc4_types;
+#else
+#error big endian version not defined
+#endif
+} fcgs_rft_id_t;
+
+typedef struct {
+	fcct_iu_header_t hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	port_id;
+	uint32_t	:16,
+			fc4_features:8,
+			type_code:8;
+#else
+#error big endian version not defined
+#endif
+} fcgs_rff_id_t;
+
+#pragma pack(1)
+typedef struct {
+	fcct_iu_header_t hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	port_id;
+	uint64_t	port_name;
+#else
+#error big endian version not defined
+#endif
+} fcgs_rpn_id_t;
+#pragma pack()
+
+#pragma pack(1)
+typedef struct {
+	fcct_iu_header_t hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	port_id;
+	uint64_t	node_name;
+#else
+#error big endian version not defined
+#endif
+} fcgs_rnn_id_t;
+#pragma pack()
+
+#define FCCT_CLASS_OF_SERVICE_F	0x1
+#define FCCT_CLASS_OF_SERVICE_2	0x4
+#define FCCT_CLASS_OF_SERVICE_3	0x8
+#pragma pack(1)
+typedef struct {
+	fcct_iu_header_t hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	port_id;
+	uint32_t	class_of_srvc;
+#else
+#error big endian version not defined
+#endif
+} fcgs_rcs_id_t;
+#pragma pack()
+
+#pragma pack(1)
+typedef struct {
+	fcct_iu_header_t hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint64_t	node_name;
+	uint8_t		name_len;
+	char		sym_node_name[1];
+/*TODO: need name length and symbolic name */
+#else
+#error big endian version not defined
+#endif
+} fcgs_rsnn_nn_t;
+#pragma pack()
+
+#define FCCT_HDR_CMDRSP_ACCEPT	0x8002
+#define FCCT_HDR_CMDRSP_REJECT	0x8001
+
+static inline void fcct_build_req_header(fcct_iu_header_t *hdr, uint16_t cmd, uint16_t max_size)
+{
+	/* use old rev (1) to accommodate older switches */
+	hdr->revision = 1;
+	hdr->in_id = 0;
+	hdr->gs_type = FC_GS_TYPE_DIRECTORY_SERVICE;
+	hdr->gs_subtype = FC_GS_SUBTYPE_NAME_SERVER;
+	hdr->options = 0;
+	hdr->resv1 = 0;
+	hdr->cmd_rsp_code = ocs_htobe16(cmd);
+	hdr->max_residual_size = ocs_htobe16(max_size/(sizeof(uint32_t))); /* words */
+	hdr->fragment_id = 0;
+	hdr->reason_code = 0;
+	hdr->reason_code_explanation = 0;
+	hdr->vendor_specific = 0;
+}
+
+typedef struct fcct_rftid_req_s {
+	fcct_iu_header_t	hdr;
+	uint32_t		port_id;
+	uint32_t		fc4_types[8];
+} fcct_rftid_req_t;
+
+#define FC4_FEATURE_TARGET	(1U << 0)
+#define FC4_FEATURE_INITIATOR	(1U << 1)
+
+typedef struct fcct_rffid_req_s {
+	fcct_iu_header_t	hdr;
+	uint32_t		port_id;
+	uint32_t		:16,
+				fc4_feature_bits:8,
+				type:8;
+} fcct_rffid_req_t;
+
+typedef struct fcct_gnnid_req_s {
+	fcct_iu_header_t	hdr;
+	uint32_t		:8,
+				port_id:24;
+} fcct_gnnid_req_t;
+
+typedef struct fcct_gpnid_req_s {
+	fcct_iu_header_t	hdr;
+	uint32_t		:8,
+				port_id:24;
+} fcct_gpnid_req_t;
+
+typedef struct fcct_gffid_req_s {
+	fcct_iu_header_t	hdr;
+	uint32_t		:8,
+				port_id:24;
+} fcct_gffid_req_t;
+
+typedef struct fcct_gidft_req_s {
+	fcct_iu_header_t	hdr;
+	uint32_t		:8,
+				domain_id_scope:8,
+				area_id_scope:8,
+				type:8;
+} fcct_gidft_req_t;
+
+typedef struct fcct_gidpt_req_s {
+	fcct_iu_header_t	hdr;
+	uint32_t		port_type:8,
+				domain_id_scope:8,
+				area_id_scope:8,
+				flags:8;
+} fcct_gidpt_req_t;
+
+typedef struct fcct_gnnid_acc_s {
+	fcct_iu_header_t	hdr;
+	uint64_t		node_name;
+} fcct_gnnid_acc_t;
+
+typedef struct fcct_gpnid_acc_s {
+	fcct_iu_header_t	hdr;
+	uint64_t		port_name;
+} fcct_gpnid_acc_t;
+
+typedef struct fcct_gffid_acc_s {
+	fcct_iu_header_t	hdr;
+	uint8_t			fc4_feature_bits;
+} fcct_gffid_acc_t;
+
+typedef struct fcct_gidft_acc_s {
+	fcct_iu_header_t	hdr;
+	struct {
+		uint32_t	ctl:8,
+				port_id:24;
+	} port_list[1];
+} fcct_gidft_acc_t;
+
+typedef struct fcct_gidpt_acc_s {
+	fcct_iu_header_t	hdr;
+	struct {
+		uint32_t	ctl:8,
+				port_id:24;
+	} port_list[1];
+} fcct_gidpt_acc_t;
+
+#define FCCT_GID_PT_LAST_ID	0x80
+#define FCCT_GIDPT_ID_MASK	0x00ffffff
+
+typedef struct fcp_cmnd_iu_s {
+	uint8_t		fcp_lun[8];
+	uint8_t		command_reference_number;
+	uint8_t		task_attribute:3,
+			command_priority:4,
+			:1;
+	uint8_t		task_management_flags;
+	uint8_t		wrdata:1,
+			rddata:1,
+			additional_fcp_cdb_length:6;
+	uint8_t		fcp_cdb[16];
+	uint8_t		fcp_cdb_and_dl[20];	/* < May contain up to 16 bytes of CDB, followed by fcp_dl */
+} fcp_cmnd_iu_t;
+
+#define FCP_LUN_ADDRESS_METHOD_SHIFT	6
+#define FCP_LUN_ADDRESS_METHOD_MASK	0xc0
+#define FCP_LUN_ADDR_METHOD_PERIPHERAL	0x0
+#define FCP_LUN_ADDR_METHOD_FLAT	0x1
+#define FCP_LUN_ADDR_METHOD_LOGICAL	0x2
+#define FCP_LUN_ADDR_METHOD_EXTENDED	0x3
+
+#define FCP_LUN_ADDR_SIMPLE_MAX		0xff
+#define FCP_LUN_ADDR_FLAT_MAX		0x3fff
+
+#define FCP_TASK_ATTR_SIMPLE		0x0
+#define FCP_TASK_ATTR_HEAD_OF_QUEUE	0x1
+#define FCP_TASK_ATTR_ORDERED		0x2
+#define FCP_TASK_ATTR_ACA		0x4
+#define FCP_TASK_ATTR_UNTAGGED          0x5
+
+#define FCP_QUERY_TASK_SET		BIT(0)
+#define FCP_ABORT_TASK_SET		BIT(1)
+#define FCP_CLEAR_TASK_SET		BIT(2)
+#define FCP_QUERY_ASYNCHRONOUS_EVENT	BIT(3)
+#define FCP_LOGICAL_UNIT_RESET		BIT(4)
+#define FCP_TARGET_RESET		BIT(5)
+#define FCP_CLEAR_ACA			BIT(6)
+
+/* SPC-4 says that the maximum length of sense data is 252 bytes */
+#define FCP_MAX_SENSE_LEN		252
+#define FCP_MAX_RSP_LEN			  8
+/*
+ * FCP_RSP buffer will either have sense or response data, but not both
+ * so pick the larger.
+ */
+#define FCP_MAX_RSP_INFO_LEN		FCP_MAX_SENSE_LEN
+
+typedef struct fcp_rsp_iu_s {
+	uint8_t		rsvd[8];
+	uint8_t		status_qualifier[2];
+	uint8_t		flags;
+	uint8_t		scsi_status;
+	uint8_t		fcp_resid[4];
+	uint8_t		fcp_sns_len[4];
+	uint8_t		fcp_rsp_len[4];
+	uint8_t		data[FCP_MAX_RSP_INFO_LEN];
+} fcp_rsp_iu_t;
+
+/** Flag field defines: */
+#define FCP_RSP_LEN_VALID		BIT(0)
+#define FCP_SNS_LEN_VALID		BIT(1)
+#define FCP_RESID_OVER			BIT(2)
+#define FCP_RESID_UNDER			BIT(3)
+#define FCP_CONF_REQ			BIT(4)
+#define FCP_BIDI_READ_RESID_OVER	BIT(5)
+#define FCP_BIDI_READ_RESID_UNDER	BIT(6)
+#define FCP_BIDI_RSP			BIT(7)
+
+/** Status values: */
+#define FCP_TMF_COMPLETE		0x00
+#define FCP_DATA_LENGTH_MISMATCH	0x01
+#define FCP_INVALID_FIELD		0x02
+#define FCP_DATA_RO_MISMATCH		0x03
+#define FCP_TMF_REJECTED		0x04
+#define FCP_TMF_FAILED			0x05
+#define FCP_TMF_SUCCEEDED		0x08
+#define FCP_TMF_INCORRECT_LUN		0x09
+
+/** FCP-4 Table 28, TMF response information: */
+typedef struct fc_rsp_info_s {
+	uint8_t addl_rsp_info[3];
+	uint8_t rsp_code;
+	uint32_t :32;
+} fcp_rsp_info_t;
+
+typedef struct fcp_xfer_rdy_iu_s {
+	uint8_t		fcp_data_ro[4];
+	uint8_t		fcp_burst_len[4];
+	uint8_t		rsvd[4];
+} fcp_xfer_rdy_iu_t;
+
+#define MAX_ACC_REJECT_PAYLOAD (sizeof(fc_ls_rjt_payload_t) > sizeof(fc_acc_payload_t) ? sizeof(fc_ls_rjt_payload_t) : sizeof(fc_acc_payload_t))
+
+
+#endif /* !_OCS_FCP_H */
diff --git a/sys/dev/ocs_fc/ocs_hw.c b/sys/dev/ocs_fc/ocs_hw.c
new file mode 100644
index 000000000000..9cbb3f67e306
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_hw.c
@@ -0,0 +1,12551 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Defines and implements the Hardware Abstraction Layer (HW).
+ * All interaction with the hardware is performed through the HW, which abstracts
+ * the details of the underlying SLI-4 implementation.
+ */
+
+/**
+ * @defgroup devInitShutdown Device Initialization and Shutdown
+ * @defgroup domain Domain Functions
+ * @defgroup port Port Functions
+ * @defgroup node Remote Node Functions
+ * @defgroup io IO Functions
+ * @defgroup interrupt Interrupt handling
+ * @defgroup os OS Required Functions
+ */
+
+#include "ocs.h"
+#include "ocs_os.h"
+#include "ocs_hw.h"
+#include "ocs_hw_queues.h"
+
+#define OCS_HW_MQ_DEPTH	128
+#define OCS_HW_READ_FCF_SIZE	4096
+#define OCS_HW_DEFAULT_AUTO_XFER_RDY_IOS	256
+#define OCS_HW_WQ_TIMER_PERIOD_MS	500
+
+/* values used for setting the auto xfer rdy parameters */
+#define OCS_HW_AUTO_XFER_RDY_BLK_SIZE_DEFAULT		0 /* 512 bytes */
+#define OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA_DEFAULT	TRUE
+#define OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID_DEFAULT	FALSE
+#define OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE_DEFAULT	0
+#define OCS_HW_REQUE_XRI_REGTAG			65534
+/* max command and response buffer lengths -- arbitrary at the moment */
+#define OCS_HW_DMTF_CLP_CMD_MAX	256
+#define OCS_HW_DMTF_CLP_RSP_MAX	256
+
+/* HW global data */
+ocs_hw_global_t hw_global;
+
+static void ocs_hw_queue_hash_add(ocs_queue_hash_t *, uint16_t, uint16_t);
+static void ocs_hw_adjust_wqs(ocs_hw_t *hw);
+static uint32_t ocs_hw_get_num_chutes(ocs_hw_t *hw);
+static int32_t ocs_hw_cb_link(void *, void *);
+static int32_t ocs_hw_cb_fip(void *, void *);
+static int32_t ocs_hw_command_process(ocs_hw_t *, int32_t, uint8_t *, size_t);
+static int32_t ocs_hw_mq_process(ocs_hw_t *, int32_t, sli4_queue_t *);
+static int32_t ocs_hw_cb_read_fcf(ocs_hw_t *, int32_t, uint8_t *, void *);
+static int32_t ocs_hw_cb_node_attach(ocs_hw_t *, int32_t, uint8_t *, void *);
+static int32_t ocs_hw_cb_node_free(ocs_hw_t *, int32_t, uint8_t *, void *);
+static int32_t ocs_hw_cb_node_free_all(ocs_hw_t *, int32_t, uint8_t *, void *);
+static ocs_hw_rtn_e ocs_hw_setup_io(ocs_hw_t *);
+static ocs_hw_rtn_e ocs_hw_init_io(ocs_hw_t *);
+static int32_t ocs_hw_flush(ocs_hw_t *);
+static int32_t ocs_hw_command_cancel(ocs_hw_t *);
+static int32_t ocs_hw_io_cancel(ocs_hw_t *);
+static void ocs_hw_io_quarantine(ocs_hw_t *hw, hw_wq_t *wq, ocs_hw_io_t *io);
+static void ocs_hw_io_restore_sgl(ocs_hw_t *, ocs_hw_io_t *);
+static int32_t ocs_hw_io_ini_sge(ocs_hw_t *, ocs_hw_io_t *, ocs_dma_t *, uint32_t, ocs_dma_t *);
+static ocs_hw_rtn_e ocs_hw_firmware_write_lancer(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, int last, ocs_hw_fw_cb_t cb, void *arg);
+static int32_t ocs_hw_cb_fw_write(ocs_hw_t *, int32_t, uint8_t *, void  *);
+static int32_t ocs_hw_cb_sfp(ocs_hw_t *, int32_t, uint8_t *, void  *);
+static int32_t ocs_hw_cb_temp(ocs_hw_t *, int32_t, uint8_t *, void  *);
+static int32_t ocs_hw_cb_link_stat(ocs_hw_t *, int32_t, uint8_t *, void  *);
+static int32_t ocs_hw_cb_host_stat(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg);
+static void ocs_hw_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg);
+static int32_t ocs_hw_clp_resp_get_value(ocs_hw_t *hw, const char *keyword, char *value, uint32_t value_len, const char *resp, uint32_t resp_len);
+typedef void (*ocs_hw_dmtf_clp_cb_t)(ocs_hw_t *hw, int32_t status, uint32_t result_len, void *arg);
+static ocs_hw_rtn_e ocs_hw_exec_dmtf_clp_cmd(ocs_hw_t *hw, ocs_dma_t *dma_cmd, ocs_dma_t *dma_resp, uint32_t opts, ocs_hw_dmtf_clp_cb_t cb, void *arg);
+static void ocs_hw_linkcfg_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint32_t result_len, void *arg);
+
+static int32_t __ocs_read_topology_cb(ocs_hw_t *, int32_t, uint8_t *, void *);
+static ocs_hw_rtn_e ocs_hw_get_linkcfg(ocs_hw_t *, uint32_t, ocs_hw_port_control_cb_t, void *);
+static ocs_hw_rtn_e ocs_hw_get_linkcfg_lancer(ocs_hw_t *, uint32_t, ocs_hw_port_control_cb_t, void *);
+static ocs_hw_rtn_e ocs_hw_get_linkcfg_skyhawk(ocs_hw_t *, uint32_t, ocs_hw_port_control_cb_t, void *);
+static ocs_hw_rtn_e ocs_hw_set_linkcfg(ocs_hw_t *, ocs_hw_linkcfg_e, uint32_t, ocs_hw_port_control_cb_t, void *);
+static ocs_hw_rtn_e ocs_hw_set_linkcfg_lancer(ocs_hw_t *, ocs_hw_linkcfg_e, uint32_t, ocs_hw_port_control_cb_t, void *);
+static ocs_hw_rtn_e ocs_hw_set_linkcfg_skyhawk(ocs_hw_t *, ocs_hw_linkcfg_e, uint32_t, ocs_hw_port_control_cb_t, void *);
+static void ocs_hw_init_linkcfg_cb(int32_t status, uintptr_t value, void *arg);
+static ocs_hw_rtn_e ocs_hw_set_eth_license(ocs_hw_t *hw, uint32_t license);
+static ocs_hw_rtn_e ocs_hw_set_dif_seed(ocs_hw_t *hw);
+static ocs_hw_rtn_e ocs_hw_set_dif_mode(ocs_hw_t *hw);
+static void ocs_hw_io_free_internal(void *arg);
+static void ocs_hw_io_free_port_owned(void *arg);
+static ocs_hw_rtn_e ocs_hw_config_auto_xfer_rdy_t10pi(ocs_hw_t *hw, uint8_t *buf);
+static ocs_hw_rtn_e ocs_hw_config_set_fdt_xfer_hint(ocs_hw_t *hw, uint32_t fdt_xfer_hint);
+static void ocs_hw_wq_process_abort(void *arg, uint8_t *cqe, int32_t status);
+static int32_t ocs_hw_config_mrq(ocs_hw_t *hw, uint8_t, uint16_t, uint16_t);
+static ocs_hw_rtn_e ocs_hw_config_watchdog_timer(ocs_hw_t *hw);
+static ocs_hw_rtn_e ocs_hw_config_sli_port_health_check(ocs_hw_t *hw, uint8_t query, uint8_t enable);
+
+/* HW domain database operations */
+static int32_t ocs_hw_domain_add(ocs_hw_t *, ocs_domain_t *);
+static int32_t ocs_hw_domain_del(ocs_hw_t *, ocs_domain_t *);
+
+
+/* Port state machine */
+static void *__ocs_hw_port_alloc_init(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void *__ocs_hw_port_alloc_read_sparm64(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void *__ocs_hw_port_alloc_init_vpi(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void *__ocs_hw_port_done(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void *__ocs_hw_port_free_unreg_vpi(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+
+/* Domain state machine */
+static void *__ocs_hw_domain_init(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void *__ocs_hw_domain_alloc_reg_fcfi(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void * __ocs_hw_domain_alloc_init_vfi(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void *__ocs_hw_domain_free_unreg_vfi(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+static void *__ocs_hw_domain_free_unreg_fcfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data);
+static int32_t __ocs_hw_domain_cb(ocs_hw_t *, int32_t, uint8_t *, void *);
+static int32_t __ocs_hw_port_cb(ocs_hw_t *, int32_t, uint8_t *, void *);
+static int32_t __ocs_hw_port_realloc_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg);
+
+/* BZ 161832 */
+static void ocs_hw_check_sec_hio_list(ocs_hw_t *hw);
+
+/* WQE timeouts */
+static void target_wqe_timer_cb(void *arg);
+static void shutdown_target_wqe_timer(ocs_hw_t *hw);
+
+static inline void
+ocs_hw_add_io_timed_wqe(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	if (hw->config.emulate_tgt_wqe_timeout && io->tgt_wqe_timeout) {
+		/*
+		 * Active WQE list currently only used for
+		 * target WQE timeouts.
+		 */
+		ocs_lock(&hw->io_lock);
+			ocs_list_add_tail(&hw->io_timed_wqe, io);
+			io->submit_ticks = ocs_get_os_ticks();
+		ocs_unlock(&hw->io_lock);
+	}
+}
+
+static inline void
+ocs_hw_remove_io_timed_wqe(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	if (hw->config.emulate_tgt_wqe_timeout) {
+		/*
+		 * If target wqe timeouts are enabled,
+		 * remove from active wqe list.
+		 */
+		ocs_lock(&hw->io_lock);
+			if (ocs_list_on_list(&io->wqe_link)) {
+				ocs_list_remove(&hw->io_timed_wqe, io);
+			}
+		ocs_unlock(&hw->io_lock);
+	}
+}
+
+static uint8_t ocs_hw_iotype_is_originator(uint16_t io_type)
+{
+	switch (io_type) {
+	case OCS_HW_IO_INITIATOR_READ:
+	case OCS_HW_IO_INITIATOR_WRITE:
+	case OCS_HW_IO_INITIATOR_NODATA:
+	case OCS_HW_FC_CT:
+	case OCS_HW_ELS_REQ:
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+static uint8_t ocs_hw_wcqe_abort_needed(uint16_t status, uint8_t ext, uint8_t xb)
+{
+	/* if exchange not active, nothing to abort */
+	if (!xb) {
+		return FALSE;
+	}
+	if (status == SLI4_FC_WCQE_STATUS_LOCAL_REJECT) {
+		switch (ext) {
+		/* exceptions where abort is not needed */
+		case SLI4_FC_LOCAL_REJECT_INVALID_RPI: /* lancer returns this after unreg_rpi */
+		case SLI4_FC_LOCAL_REJECT_ABORT_REQUESTED: /* abort already in progress */
+			return FALSE;
+		default:
+			break;
+		}
+	}
+	return TRUE;
+}
+
+/**
+ * @brief Determine the number of chutes on the device.
+ *
+ * @par Description
+ * Some devices require queue resources allocated per protocol processor
+ * (chute). This function returns the number of chutes on this device.
+ *
+ * @param hw Hardware context allocated by the caller.
+ *
+ * @return Returns the number of chutes on the device for protocol.
+ */
+static uint32_t
+ocs_hw_get_num_chutes(ocs_hw_t *hw)
+{
+	uint32_t num_chutes = 1;
+
+	if (sli_get_is_dual_ulp_capable(&hw->sli) &&
+	    sli_get_is_ulp_enabled(&hw->sli, 0) &&
+	    sli_get_is_ulp_enabled(&hw->sli, 1)) {
+		num_chutes = 2;
+	}
+	return num_chutes;
+}
+
+static ocs_hw_rtn_e
+ocs_hw_link_event_init(ocs_hw_t *hw)
+{
+	if (hw == NULL) {
+		ocs_log_err(hw->os, "bad parameter hw=%p\n", hw);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	hw->link.status = SLI_LINK_STATUS_MAX;
+	hw->link.topology = SLI_LINK_TOPO_NONE;
+	hw->link.medium = SLI_LINK_MEDIUM_MAX;
+	hw->link.speed = 0;
+	hw->link.loop_map = NULL;
+	hw->link.fc_id = UINT32_MAX;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief If this is physical port 0, then read the max dump size.
+ *
+ * @par Description
+ * Queries the FW for the maximum dump size
+ *
+ * @param hw Hardware context allocated by the caller.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static ocs_hw_rtn_e
+ocs_hw_read_max_dump_size(ocs_hw_t *hw)
+{
+	uint8_t	buf[SLI4_BMBX_SIZE];
+	uint8_t bus, dev, func;
+	int 	rc;
+
+	/* lancer only */
+	if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) {
+		ocs_log_debug(hw->os, "Function only supported for I/F type 2\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Make sure the FW is new enough to support this command. If the FW
+	 * is too old, the FW will UE.
+	 */
+	if (hw->workaround.disable_dump_loc) {
+		ocs_log_test(hw->os, "FW version is too old for this feature\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* attempt to detemine the dump size for function 0 only. */
+	ocs_get_bus_dev_func(hw->os, &bus, &dev, &func);
+	if (func == 0) {
+		if (sli_cmd_common_set_dump_location(&hw->sli, buf,
+							SLI4_BMBX_SIZE, 1, 0, NULL, 0)) {
+			sli4_res_common_set_dump_location_t *rsp =
+				(sli4_res_common_set_dump_location_t *)
+				(buf + offsetof(sli4_cmd_sli_config_t,
+						payload.embed));
+
+			rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_test(hw->os, "set dump location command failed\n");
+				return rc;
+			} else {
+				hw->dump_size = rsp->buffer_length;
+				ocs_log_debug(hw->os, "Dump size %x\n", rsp->buffer_length);
+			}
+		}
+	}
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Set up the Hardware Abstraction Layer module.
+ *
+ * @par Description
+ * Calls set up to configure the hardware.
+ *
+ * @param hw Hardware context allocated by the caller.
+ * @param os Device abstraction.
+ * @param port_type Protocol type of port, such as FC and NIC.
+ *
+ * @todo Why is port_type a parameter?
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_setup(ocs_hw_t *hw, ocs_os_handle_t os, sli4_port_type_e port_type)
+{
+	uint32_t i;
+	char prop_buf[32];
+
+	if (hw == NULL) {
+		ocs_log_err(os, "bad parameter(s) hw=%p\n", hw);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->hw_setup_called) {
+		/* Setup run-time workarounds.
+		 * Call for each setup, to allow for hw_war_version
+		 */
+		ocs_hw_workaround_setup(hw);
+		return OCS_HW_RTN_SUCCESS;
+	}
+
+	/*
+	 * ocs_hw_init() relies on NULL pointers indicating that a structure
+	 * needs allocation. If a structure is non-NULL, ocs_hw_init() won't
+	 * free/realloc that memory
+	 */
+	ocs_memset(hw, 0, sizeof(ocs_hw_t));
+
+	hw->hw_setup_called = TRUE;
+
+	hw->os = os;
+
+	ocs_lock_init(hw->os, &hw->cmd_lock, "HW_cmd_lock[%d]", ocs_instance(hw->os));
+	ocs_list_init(&hw->cmd_head, ocs_command_ctx_t, link);
+	ocs_list_init(&hw->cmd_pending, ocs_command_ctx_t, link);
+	hw->cmd_head_count = 0;
+
+	ocs_lock_init(hw->os, &hw->io_lock, "HW_io_lock[%d]", ocs_instance(hw->os));
+	ocs_lock_init(hw->os, &hw->io_abort_lock, "HW_io_abort_lock[%d]", ocs_instance(hw->os));
+
+	ocs_atomic_init(&hw->io_alloc_failed_count, 0);
+
+	hw->config.speed = FC_LINK_SPEED_AUTO_16_8_4;
+	hw->config.dif_seed = 0;
+	hw->config.auto_xfer_rdy_blk_size_chip = OCS_HW_AUTO_XFER_RDY_BLK_SIZE_DEFAULT;
+	hw->config.auto_xfer_rdy_ref_tag_is_lba = OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA_DEFAULT;
+	hw->config.auto_xfer_rdy_app_tag_valid =  OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID_DEFAULT;
+	hw->config.auto_xfer_rdy_app_tag_value = OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE_DEFAULT;
+
+
+	if (sli_setup(&hw->sli, hw->os, port_type)) {
+		ocs_log_err(hw->os, "SLI setup failed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	ocs_memset(hw->domains, 0, sizeof(hw->domains));
+
+	ocs_memset(hw->fcf_index_fcfi, 0, sizeof(hw->fcf_index_fcfi));
+
+	ocs_hw_link_event_init(hw);
+
+	sli_callback(&hw->sli, SLI4_CB_LINK, ocs_hw_cb_link, hw);
+	sli_callback(&hw->sli, SLI4_CB_FIP, ocs_hw_cb_fip, hw);
+
+	/*
+	 * Set all the queue sizes to the maximum allowed. These values may
+	 * be changes later by the adjust and workaround functions.
+	 */
+	for (i = 0; i < ARRAY_SIZE(hw->num_qentries); i++) {
+		hw->num_qentries[i] = sli_get_max_qentries(&hw->sli, i);
+	}
+
+	/*
+	 * The RQ assignment for RQ pair mode.
+	 */
+	hw->config.rq_default_buffer_size = OCS_HW_RQ_SIZE_PAYLOAD;
+	hw->config.n_io = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI);
+	if (ocs_get_property("auto_xfer_rdy_xri_cnt", prop_buf, sizeof(prop_buf)) == 0) {
+		hw->config.auto_xfer_rdy_xri_cnt = ocs_strtoul(prop_buf, 0, 0);
+	}
+
+	/* by default, enable initiator-only auto-ABTS emulation */
+	hw->config.i_only_aab = TRUE;
+
+	/* Setup run-time workarounds */
+	ocs_hw_workaround_setup(hw);
+
+	/* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */
+	if (hw->workaround.override_fcfi) {
+		hw->first_domain_idx = -1;
+	}
+
+	/* Must be done after the workaround setup */
+	if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) {
+		(void)ocs_hw_read_max_dump_size(hw);
+	}
+
+	/* calculate the number of WQs required. */
+	ocs_hw_adjust_wqs(hw);
+
+	/* Set the default dif mode */
+	if (! sli_is_dif_inline_capable(&hw->sli)) {
+		ocs_log_test(hw->os, "not inline capable, setting mode to separate\n");
+		hw->config.dif_mode = OCS_HW_DIF_MODE_SEPARATE;
+	}
+	/* Workaround: BZ 161832 */
+	if (hw->workaround.use_dif_sec_xri) {
+		ocs_list_init(&hw->sec_hio_wait_list, ocs_hw_io_t, link);
+	}
+
+	/*
+	 * Figure out the starting and max ULP to spread the WQs across the
+	 * ULPs.
+	 */
+	if (sli_get_is_dual_ulp_capable(&hw->sli)) {
+		if (sli_get_is_ulp_enabled(&hw->sli, 0) &&
+		    sli_get_is_ulp_enabled(&hw->sli, 1)) {
+			hw->ulp_start = 0;
+			hw->ulp_max   = 1;
+		} else if (sli_get_is_ulp_enabled(&hw->sli, 0)) {
+			hw->ulp_start = 0;
+			hw->ulp_max   = 0;
+		} else {
+			hw->ulp_start = 1;
+			hw->ulp_max   = 1;
+		}
+	} else {
+		if (sli_get_is_ulp_enabled(&hw->sli, 0)) {
+			hw->ulp_start = 0;
+			hw->ulp_max   = 0;
+		} else {
+			hw->ulp_start = 1;
+			hw->ulp_max   = 1;
+		}
+	}
+	ocs_log_debug(hw->os, "ulp_start %d, ulp_max %d\n",
+		hw->ulp_start, hw->ulp_max);
+	hw->config.queue_topology = hw_global.queue_topology_string;
+
+	hw->qtop = ocs_hw_qtop_parse(hw, hw->config.queue_topology);
+
+	hw->config.n_eq = hw->qtop->entry_counts[QTOP_EQ];
+	hw->config.n_cq = hw->qtop->entry_counts[QTOP_CQ];
+	hw->config.n_rq = hw->qtop->entry_counts[QTOP_RQ];
+	hw->config.n_wq = hw->qtop->entry_counts[QTOP_WQ];
+	hw->config.n_mq = hw->qtop->entry_counts[QTOP_MQ];
+
+	/* Verify qtop configuration against driver supported configuration */
+	if (hw->config.n_rq > OCE_HW_MAX_NUM_MRQ_PAIRS) {
+		ocs_log_crit(hw->os, "Max supported MRQ pairs = %d\n",
+				OCE_HW_MAX_NUM_MRQ_PAIRS);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->config.n_eq > OCS_HW_MAX_NUM_EQ) {
+		ocs_log_crit(hw->os, "Max supported EQs = %d\n",
+				OCS_HW_MAX_NUM_EQ);
+		return OCS_HW_RTN_ERROR;
+	}
+	
+	if (hw->config.n_cq > OCS_HW_MAX_NUM_CQ) {
+		ocs_log_crit(hw->os, "Max supported CQs = %d\n",
+				OCS_HW_MAX_NUM_CQ);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->config.n_wq > OCS_HW_MAX_NUM_WQ) {
+		ocs_log_crit(hw->os, "Max supported WQs = %d\n",
+				OCS_HW_MAX_NUM_WQ);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->config.n_mq > OCS_HW_MAX_NUM_MQ) {
+		ocs_log_crit(hw->os, "Max supported MQs = %d\n",
+				OCS_HW_MAX_NUM_MQ);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Allocate memory structures to prepare for the device operation.
+ *
+ * @par Description
+ * Allocates memory structures needed by the device and prepares the device
+ * for operation.
+ * @n @n @b Note: This function may be called more than once (for example, at
+ * initialization and then after a reset), but the size of the internal resources
+ * may not be changed without tearing down the HW (ocs_hw_teardown()).
+ *
+ * @param hw Hardware context allocated by the caller.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_init(ocs_hw_t *hw)
+{
+	ocs_hw_rtn_e	rc;
+	uint32_t	i = 0;
+	uint8_t		buf[SLI4_BMBX_SIZE];
+	uint32_t	max_rpi;
+	int		rem_count;
+	int	        written_size = 0;
+	uint32_t	count;
+	char		prop_buf[32];
+	uint32_t ramdisc_blocksize = 512;
+	uint32_t q_count = 0;
+	/*
+	 * Make sure the command lists are empty. If this is start-of-day,
+	 * they'll be empty since they were just initialized in ocs_hw_setup.
+	 * If we've just gone through a reset, the command and command pending
+	 * lists should have been cleaned up as part of the reset (ocs_hw_reset()).
+	 */
+	ocs_lock(&hw->cmd_lock);
+		if (!ocs_list_empty(&hw->cmd_head)) {
+			ocs_log_test(hw->os, "command found on cmd list\n");
+			ocs_unlock(&hw->cmd_lock);
+			return OCS_HW_RTN_ERROR;
+		}
+		if (!ocs_list_empty(&hw->cmd_pending)) {
+			ocs_log_test(hw->os, "command found on pending list\n");
+			ocs_unlock(&hw->cmd_lock);
+			return OCS_HW_RTN_ERROR;
+		}
+	ocs_unlock(&hw->cmd_lock);
+
+	/* Free RQ buffers if prevously allocated */
+	ocs_hw_rx_free(hw);
+
+	/*
+	 * The IO queues must be initialized here for the reset case. The
+	 * ocs_hw_init_io() function will re-add the IOs to the free list.
+	 * The cmd_head list should be OK since we free all entries in
+	 * ocs_hw_command_cancel() that is called in the ocs_hw_reset().
+	 */
+
+	/* If we are in this function due to a reset, there may be stale items
+	 * on lists that need to be removed.  Clean them up.
+	 */
+	rem_count=0;
+	if (ocs_list_valid(&hw->io_wait_free)) {
+		while ((!ocs_list_empty(&hw->io_wait_free))) {
+			rem_count++;
+			ocs_list_remove_head(&hw->io_wait_free);
+		}
+		if (rem_count > 0) {
+			ocs_log_debug(hw->os, "removed %d items from io_wait_free list\n", rem_count);
+		}
+	}
+	rem_count=0;
+	if (ocs_list_valid(&hw->io_inuse)) {
+		while ((!ocs_list_empty(&hw->io_inuse))) {
+			rem_count++;
+			ocs_list_remove_head(&hw->io_inuse);
+		}
+		if (rem_count > 0) {
+			ocs_log_debug(hw->os, "removed %d items from io_inuse list\n", rem_count);
+		}
+	}
+	rem_count=0;
+	if (ocs_list_valid(&hw->io_free)) {
+		while ((!ocs_list_empty(&hw->io_free))) {
+			rem_count++;
+			ocs_list_remove_head(&hw->io_free);
+		}
+		if (rem_count > 0) {
+			ocs_log_debug(hw->os, "removed %d items from io_free list\n", rem_count);
+		}
+	}
+	if (ocs_list_valid(&hw->io_port_owned)) {
+		while ((!ocs_list_empty(&hw->io_port_owned))) {
+			ocs_list_remove_head(&hw->io_port_owned);
+		}
+	}
+	ocs_list_init(&hw->io_inuse, ocs_hw_io_t, link);
+	ocs_list_init(&hw->io_free, ocs_hw_io_t, link);
+	ocs_list_init(&hw->io_port_owned, ocs_hw_io_t, link);
+	ocs_list_init(&hw->io_wait_free, ocs_hw_io_t, link);
+	ocs_list_init(&hw->io_timed_wqe, ocs_hw_io_t, wqe_link);
+	ocs_list_init(&hw->io_port_dnrx, ocs_hw_io_t, dnrx_link);
+
+	/* If MRQ not required, Make sure we dont request feature. */
+	if (hw->config.n_rq == 1) {
+		hw->sli.config.features.flag.mrqp = FALSE;
+	}
+	
+	if (sli_init(&hw->sli)) {
+		ocs_log_err(hw->os, "SLI failed to initialize\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Enable the auto xfer rdy feature if requested.
+	 */
+	hw->auto_xfer_rdy_enabled = FALSE;
+	if (sli_get_auto_xfer_rdy_capable(&hw->sli) &&
+	    hw->config.auto_xfer_rdy_size > 0) {
+		if (hw->config.esoc){
+			if (ocs_get_property("ramdisc_blocksize", prop_buf, sizeof(prop_buf)) == 0) {
+				ramdisc_blocksize = ocs_strtoul(prop_buf, 0, 0);
+			}
+			written_size = sli_cmd_config_auto_xfer_rdy_hp(&hw->sli, buf, SLI4_BMBX_SIZE, hw->config.auto_xfer_rdy_size, 1, ramdisc_blocksize);
+		} else {
+			written_size = sli_cmd_config_auto_xfer_rdy(&hw->sli, buf, SLI4_BMBX_SIZE, hw->config.auto_xfer_rdy_size);
+		}
+		if (written_size) {
+			rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_err(hw->os, "config auto xfer rdy failed\n");
+				return rc;
+			}
+		}
+		hw->auto_xfer_rdy_enabled = TRUE;
+
+		if (hw->config.auto_xfer_rdy_t10_enable) {
+			rc = ocs_hw_config_auto_xfer_rdy_t10pi(hw, buf);
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_err(hw->os, "set parameters auto xfer rdy T10 PI failed\n");
+				return rc;
+			}
+		}
+	}
+
+	if(hw->sliport_healthcheck) {
+		rc = ocs_hw_config_sli_port_health_check(hw, 0, 1);
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(hw->os, "Enabling Sliport Health check failed \n");
+			return rc;
+		}
+	}
+
+	/*
+	 * Set FDT transfer hint, only works on Lancer
+	 */
+	if ((hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) && (OCS_HW_FDT_XFER_HINT != 0)) {
+		/*
+		 * Non-fatal error. In particular, we can disregard failure to set OCS_HW_FDT_XFER_HINT on
+		 * devices with legacy firmware that do not support OCS_HW_FDT_XFER_HINT feature.
+		 */
+		ocs_hw_config_set_fdt_xfer_hint(hw, OCS_HW_FDT_XFER_HINT);
+	}
+
+	/*
+	 * Verify that we have not exceeded any queue sizes
+	 */
+	q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_EQ),
+					OCS_HW_MAX_NUM_EQ);
+	if (hw->config.n_eq > q_count) {
+		ocs_log_err(hw->os, "requested %d EQ but %d allowed\n",
+			    hw->config.n_eq, q_count);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_CQ),
+					OCS_HW_MAX_NUM_CQ);
+	if (hw->config.n_cq > q_count) {
+		ocs_log_err(hw->os, "requested %d CQ but %d allowed\n",
+			    hw->config.n_cq, q_count);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_MQ),
+					OCS_HW_MAX_NUM_MQ);
+	if (hw->config.n_mq > q_count) {
+		ocs_log_err(hw->os, "requested %d MQ but %d allowed\n",
+			    hw->config.n_mq, q_count);
+		return OCS_HW_RTN_ERROR;
+	}
+	
+	q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_RQ),
+					OCS_HW_MAX_NUM_RQ);
+	if (hw->config.n_rq > q_count) {
+		ocs_log_err(hw->os, "requested %d RQ but %d allowed\n",
+			    hw->config.n_rq, q_count);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	q_count = MIN(sli_get_max_queue(&hw->sli, SLI_QTYPE_WQ),
+					OCS_HW_MAX_NUM_WQ);
+	if (hw->config.n_wq > q_count) {
+		ocs_log_err(hw->os, "requested %d WQ but %d allowed\n",
+			    hw->config.n_wq, q_count);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* zero the hashes */
+	ocs_memset(hw->cq_hash, 0, sizeof(hw->cq_hash));
+	ocs_log_debug(hw->os, "Max CQs %d, hash size = %d\n",
+			OCS_HW_MAX_NUM_CQ, OCS_HW_Q_HASH_SIZE);
+
+	ocs_memset(hw->rq_hash, 0, sizeof(hw->rq_hash));
+	ocs_log_debug(hw->os, "Max RQs %d, hash size = %d\n",
+			OCS_HW_MAX_NUM_RQ, OCS_HW_Q_HASH_SIZE);
+
+	ocs_memset(hw->wq_hash, 0, sizeof(hw->wq_hash));
+	ocs_log_debug(hw->os, "Max WQs %d, hash size = %d\n",
+			OCS_HW_MAX_NUM_WQ, OCS_HW_Q_HASH_SIZE);
+
+
+	rc = ocs_hw_init_queues(hw, hw->qtop);
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		return rc;
+	}
+
+	max_rpi = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI);
+	i = sli_fc_get_rpi_requirements(&hw->sli, max_rpi);
+	if (i) {
+		ocs_dma_t payload_memory;
+
+		rc = OCS_HW_RTN_ERROR;
+
+		if (hw->rnode_mem.size) {
+			ocs_dma_free(hw->os, &hw->rnode_mem);
+		}
+
+		if (ocs_dma_alloc(hw->os, &hw->rnode_mem, i, 4096)) {
+			ocs_log_err(hw->os, "remote node memory allocation fail\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+
+		payload_memory.size = 0;
+		if (sli_cmd_fcoe_post_hdr_templates(&hw->sli, buf, SLI4_BMBX_SIZE,
+					&hw->rnode_mem, UINT16_MAX, &payload_memory)) {
+			rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+
+			if (payload_memory.size != 0) {
+				/* The command was non-embedded - need to free the dma buffer */
+				ocs_dma_free(hw->os, &payload_memory);
+			}
+		}
+
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(hw->os, "header template registration failed\n");
+			return rc;
+		}
+	}
+
+	/* Allocate and post RQ buffers */
+	rc = ocs_hw_rx_allocate(hw);
+	if (rc) {
+		ocs_log_err(hw->os, "rx_allocate failed\n");
+		return rc;
+	}
+
+	/* Populate hw->seq_free_list */
+	if (hw->seq_pool == NULL) {
+		uint32_t count = 0;
+		uint32_t i;
+
+		/* Sum up the total number of RQ entries, to use to allocate the sequence object pool */
+		for (i = 0; i < hw->hw_rq_count; i++) {
+			count += hw->hw_rq[i]->entry_count;
+		}
+
+		hw->seq_pool = ocs_array_alloc(hw->os, sizeof(ocs_hw_sequence_t), count);
+		if (hw->seq_pool == NULL) {
+			ocs_log_err(hw->os, "malloc seq_pool failed\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+	}
+
+	if(ocs_hw_rx_post(hw)) {
+		ocs_log_err(hw->os, "WARNING - error posting RQ buffers\n");
+	}
+
+	/* Allocate rpi_ref if not previously allocated */
+	if (hw->rpi_ref == NULL) {
+		hw->rpi_ref = ocs_malloc(hw->os, max_rpi * sizeof(*hw->rpi_ref),
+					  OCS_M_ZERO | OCS_M_NOWAIT);
+		if (hw->rpi_ref == NULL) {
+			ocs_log_err(hw->os, "rpi_ref allocation failure (%d)\n", i);
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+	}
+
+	for (i = 0; i < max_rpi; i ++) {
+		ocs_atomic_init(&hw->rpi_ref[i].rpi_count, 0);
+		ocs_atomic_init(&hw->rpi_ref[i].rpi_attached, 0);
+	}
+
+	ocs_memset(hw->domains, 0, sizeof(hw->domains));
+
+	/* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */
+	if (hw->workaround.override_fcfi) {
+		hw->first_domain_idx = -1;
+	}
+
+	ocs_memset(hw->fcf_index_fcfi, 0, sizeof(hw->fcf_index_fcfi));
+
+	/* Register a FCFI to allow unsolicited frames to be routed to the driver */
+	if (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC) {
+
+		if (hw->hw_mrq_count) {
+			ocs_log_debug(hw->os, "using REG_FCFI MRQ\n");
+
+			rc = ocs_hw_config_mrq(hw, SLI4_CMD_REG_FCFI_SET_FCFI_MODE, 0, 0);
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_err(hw->os, "REG_FCFI_MRQ FCFI registration failed\n");
+				return rc;
+			}
+
+			rc = ocs_hw_config_mrq(hw, SLI4_CMD_REG_FCFI_SET_MRQ_MODE, 0, 0);
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_err(hw->os, "REG_FCFI_MRQ MRQ registration failed\n");
+				return rc;
+			}
+		} else {
+			sli4_cmd_rq_cfg_t rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG];
+
+			ocs_log_debug(hw->os, "using REG_FCFI standard\n");
+
+			/* Set the filter match/mask values from hw's filter_def values */
+			for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) {
+				rq_cfg[i].rq_id = 0xffff;
+				rq_cfg[i].r_ctl_mask =	(uint8_t)  hw->config.filter_def[i];
+				rq_cfg[i].r_ctl_match = (uint8_t) (hw->config.filter_def[i] >> 8);
+				rq_cfg[i].type_mask =	(uint8_t) (hw->config.filter_def[i] >> 16);
+				rq_cfg[i].type_match =	(uint8_t) (hw->config.filter_def[i] >> 24);
+			}
+
+			/*
+			 * Update the rq_id's of the FCF configuration (don't update more than the number
+			 * of rq_cfg elements)
+			 */
+			for (i = 0; i < OCS_MIN(hw->hw_rq_count, SLI4_CMD_REG_FCFI_NUM_RQ_CFG); i++) {
+				hw_rq_t *rq = hw->hw_rq[i];
+				uint32_t j;
+				for (j = 0; j < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; j++) {
+					uint32_t mask = (rq->filter_mask != 0) ? rq->filter_mask : 1;
+					if (mask & (1U << j)) {
+						rq_cfg[j].rq_id = rq->hdr->id;
+						ocs_log_debug(hw->os, "REG_FCFI: filter[%d] %08X -> RQ[%d] id=%d\n",
+							j, hw->config.filter_def[j], i, rq->hdr->id);
+					}
+				}
+			}
+
+			rc = OCS_HW_RTN_ERROR;
+
+			if (sli_cmd_reg_fcfi(&hw->sli, buf, SLI4_BMBX_SIZE, 0, rq_cfg, 0)) {
+				rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+			}
+
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_err(hw->os, "FCFI registration failed\n");
+				return rc;
+			}
+			hw->fcf_indicator = ((sli4_cmd_reg_fcfi_t *)buf)->fcfi;
+		}
+
+	}
+
+	/*
+	 * Allocate the WQ request tag pool, if not previously allocated (the request tag value is 16 bits,
+	 * thus the pool allocation size of 64k)
+	 */
+	rc = ocs_hw_reqtag_init(hw);
+	if (rc) {
+		ocs_log_err(hw->os, "ocs_pool_alloc hw_wq_callback_t failed: %d\n", rc);
+		return rc;
+	}
+
+	rc = ocs_hw_setup_io(hw);
+	if (rc) {
+		ocs_log_err(hw->os, "IO allocation failure\n");
+		return rc;
+	}
+
+	rc = ocs_hw_init_io(hw);
+	if (rc) {
+		ocs_log_err(hw->os, "IO initialization failure\n");
+		return rc;
+	}
+
+	ocs_queue_history_init(hw->os, &hw->q_hist);
+
+	/* get hw link config; polling, so callback will be called immediately */
+	hw->linkcfg = OCS_HW_LINKCFG_NA;
+	ocs_hw_get_linkcfg(hw, OCS_CMD_POLL, ocs_hw_init_linkcfg_cb, hw);
+
+	/* if lancer ethernet, ethernet ports need to be enabled */
+	if ((hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) &&
+	    (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_ETHERNET)) {
+		if (ocs_hw_set_eth_license(hw, hw->eth_license)) {
+			/* log warning but continue */
+			ocs_log_err(hw->os, "Failed to set ethernet license\n");
+		}
+	}
+
+	/* Set the DIF seed - only for lancer right now */
+	if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli) &&
+	    ocs_hw_set_dif_seed(hw) != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(hw->os, "Failed to set DIF seed value\n");
+		return rc;
+	}
+
+	/* Set the DIF mode - skyhawk only */
+	if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli) &&
+	    sli_get_dif_capable(&hw->sli)) {
+		rc = ocs_hw_set_dif_mode(hw);
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(hw->os, "Failed to set DIF mode value\n");
+			return rc;
+		}
+	}
+
+	/*
+	 * Arming the EQ allows (e.g.) interrupts when CQ completions write EQ entries
+	 */
+	for (i = 0; i < hw->eq_count; i++) {
+		sli_queue_arm(&hw->sli, &hw->eq[i], TRUE);
+	}
+
+	/*
+	 * Initialize RQ hash
+	 */
+	for (i = 0; i < hw->rq_count; i++) {
+		ocs_hw_queue_hash_add(hw->rq_hash, hw->rq[i].id, i);
+	}
+
+	/*
+	 * Initialize WQ hash
+	 */
+	for (i = 0; i < hw->wq_count; i++) {
+		ocs_hw_queue_hash_add(hw->wq_hash, hw->wq[i].id, i);
+	}
+
+	/*
+	 * Arming the CQ allows (e.g.) MQ completions to write CQ entries
+	 */
+	for (i = 0; i < hw->cq_count; i++) {
+		ocs_hw_queue_hash_add(hw->cq_hash, hw->cq[i].id, i);
+		sli_queue_arm(&hw->sli, &hw->cq[i], TRUE);
+	}
+
+	/* record the fact that the queues are functional */
+	hw->state = OCS_HW_STATE_ACTIVE;
+
+	/* Note: Must be after the IOs are setup and the state is active*/
+	if (ocs_hw_rqpair_init(hw)) {
+		ocs_log_err(hw->os, "WARNING - error initializing RQ pair\n");
+	}
+
+	/* finally kick off periodic timer to check for timed out target WQEs */
+	if (hw->config.emulate_tgt_wqe_timeout) {
+		ocs_setup_timer(hw->os, &hw->wqe_timer, target_wqe_timer_cb, hw,
+				OCS_HW_WQ_TIMER_PERIOD_MS);
+	}
+
+	/*
+	 * Allocate a HW IOs for send frame.  Allocate one for each Class 1 WQ, or if there
+	 * are none of those, allocate one for WQ[0]
+	 */
+	if ((count = ocs_varray_get_count(hw->wq_class_array[1])) > 0) {
+		for (i = 0; i < count; i++) {
+			hw_wq_t *wq = ocs_varray_iter_next(hw->wq_class_array[1]);
+			wq->send_frame_io = ocs_hw_io_alloc(hw);
+			if (wq->send_frame_io == NULL) {
+				ocs_log_err(hw->os, "ocs_hw_io_alloc for send_frame_io failed\n");
+			}
+		}
+	} else {
+		hw->hw_wq[0]->send_frame_io = ocs_hw_io_alloc(hw);
+		if (hw->hw_wq[0]->send_frame_io == NULL) {
+			ocs_log_err(hw->os, "ocs_hw_io_alloc for send_frame_io failed\n");
+		}
+	}
+
+	/* Initialize send frame frame sequence id */
+	ocs_atomic_init(&hw->send_frame_seq_id, 0);
+
+	/* Initialize watchdog timer if enabled by user */
+	hw->expiration_logged = 0;
+	if(hw->watchdog_timeout) {
+		if((hw->watchdog_timeout < 1) || (hw->watchdog_timeout > 65534)) {
+			ocs_log_err(hw->os, "watchdog_timeout out of range: Valid range is 1 - 65534\n");
+		}else if(!ocs_hw_config_watchdog_timer(hw)) {
+			ocs_log_info(hw->os, "watchdog timer configured with timeout = %d seconds \n", hw->watchdog_timeout); 
+		}
+	}
+
+	if (ocs_dma_alloc(hw->os, &hw->domain_dmem, 112, 4)) {
+	   ocs_log_err(hw->os, "domain node memory allocation fail\n");
+	   return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if (ocs_dma_alloc(hw->os, &hw->fcf_dmem, OCS_HW_READ_FCF_SIZE, OCS_HW_READ_FCF_SIZE)) {
+	   ocs_log_err(hw->os, "domain fcf memory allocation fail\n");
+	   return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if ((0 == hw->loop_map.size) &&	ocs_dma_alloc(hw->os, &hw->loop_map,
+				SLI4_MIN_LOOP_MAP_BYTES, 4)) {
+		ocs_log_err(hw->os, "Loop dma alloc failed size:%d \n", hw->loop_map.size);
+	}
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @brief Configure Multi-RQ
+ *
+ * @param hw	Hardware context allocated by the caller.
+ * @param mode	1 to set MRQ filters and 0 to set FCFI index
+ * @param vlanid    valid in mode 0
+ * @param fcf_index valid in mode 0
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_config_mrq(ocs_hw_t *hw, uint8_t mode, uint16_t vlanid, uint16_t fcf_index)
+{
+	uint8_t buf[SLI4_BMBX_SIZE], mrq_bitmask = 0;
+	hw_rq_t *rq;
+	sli4_cmd_reg_fcfi_mrq_t *rsp = NULL;
+	uint32_t i, j;
+	sli4_cmd_rq_cfg_t rq_filter[SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG];
+	int32_t rc;
+
+	if (mode == SLI4_CMD_REG_FCFI_SET_FCFI_MODE) {
+		goto issue_cmd;
+	}
+
+	/* Set the filter match/mask values from hw's filter_def values */
+	for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) {
+		rq_filter[i].rq_id = 0xffff;
+		rq_filter[i].r_ctl_mask  = (uint8_t)  hw->config.filter_def[i];
+		rq_filter[i].r_ctl_match = (uint8_t) (hw->config.filter_def[i] >> 8);
+		rq_filter[i].type_mask   = (uint8_t) (hw->config.filter_def[i] >> 16);
+		rq_filter[i].type_match  = (uint8_t) (hw->config.filter_def[i] >> 24);
+	}
+
+	/* Accumulate counts for each filter type used, build rq_ids[] list */
+	for (i = 0; i < hw->hw_rq_count; i++) {
+		rq = hw->hw_rq[i];
+		for (j = 0; j < SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG; j++) {
+			if (rq->filter_mask & (1U << j)) {
+				if (rq_filter[j].rq_id != 0xffff) {
+					/* Already used. Bailout ifts not RQset case */
+					if (!rq->is_mrq || (rq_filter[j].rq_id != rq->base_mrq_id)) {
+						ocs_log_err(hw->os, "Wrong queue topology.\n");
+						return OCS_HW_RTN_ERROR;
+					}
+					continue;
+				}
+
+				if (rq->is_mrq) {
+					rq_filter[j].rq_id = rq->base_mrq_id;
+					mrq_bitmask |= (1U << j);
+				} else {
+					rq_filter[j].rq_id = rq->hdr->id;
+				}
+			}
+		}
+	}
+
+issue_cmd:
+	/* Invoke REG_FCFI_MRQ */
+	rc = sli_cmd_reg_fcfi_mrq(&hw->sli,
+				 buf,					/* buf */
+				 SLI4_BMBX_SIZE,			/* size */
+				 mode,					/* mode 1 */
+				 fcf_index,				/* fcf_index */
+				 vlanid,				/* vlan_id */
+				 hw->config.rq_selection_policy,	/* RQ selection policy*/
+				 mrq_bitmask,				/* MRQ bitmask */
+				 hw->hw_mrq_count,			/* num_mrqs */
+				 rq_filter);				/* RQ filter */
+	if (rc == 0) {
+		ocs_log_err(hw->os, "sli_cmd_reg_fcfi_mrq() failed: %d\n", rc);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+
+	rsp = (sli4_cmd_reg_fcfi_mrq_t *)buf;
+
+	if ((rc != OCS_HW_RTN_SUCCESS) || (rsp->hdr.status)) {
+		ocs_log_err(hw->os, "FCFI MRQ registration failed. cmd = %x status = %x\n",
+			    rsp->hdr.command, rsp->hdr.status);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (mode == SLI4_CMD_REG_FCFI_SET_FCFI_MODE) {
+		hw->fcf_indicator = rsp->fcfi;
+	}
+	return 0;
+}
+
+/**
+ * @brief Callback function for getting linkcfg during HW initialization.
+ *
+ * @param status Status of the linkcfg get operation.
+ * @param value Link configuration enum to which the link configuration is set.
+ * @param arg Callback argument (ocs_hw_t *).
+ *
+ * @return None.
+ */
+static void
+ocs_hw_init_linkcfg_cb(int32_t status, uintptr_t value, void *arg)
+{
+	ocs_hw_t *hw = (ocs_hw_t *)arg;
+	if (status == 0) {
+		hw->linkcfg = (ocs_hw_linkcfg_e)value;
+	} else {
+		hw->linkcfg = OCS_HW_LINKCFG_NA;
+	}
+	ocs_log_debug(hw->os, "linkcfg=%d\n", hw->linkcfg);
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Tear down the Hardware Abstraction Layer module.
+ *
+ * @par Description
+ * Frees memory structures needed by the device, and shuts down the device. Does
+ * not free the HW context memory (which is done by the caller).
+ *
+ * @param hw Hardware context allocated by the caller.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_teardown(ocs_hw_t *hw)
+{
+	uint32_t	i = 0;
+	uint32_t	iters = 10;/*XXX*/
+	uint32_t	max_rpi;
+	uint32_t destroy_queues;
+	uint32_t free_memory;
+
+	if (!hw) {
+		ocs_log_err(NULL, "bad parameter(s) hw=%p\n", hw);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	destroy_queues = (hw->state == OCS_HW_STATE_ACTIVE);
+	free_memory = (hw->state != OCS_HW_STATE_UNINITIALIZED);
+
+	/* shutdown target wqe timer */
+	shutdown_target_wqe_timer(hw);
+
+	/* Cancel watchdog timer if enabled */
+	if(hw->watchdog_timeout) {
+		hw->watchdog_timeout = 0;
+		ocs_hw_config_watchdog_timer(hw);
+	}
+
+	/* Cancel Sliport Healthcheck */
+	if(hw->sliport_healthcheck) {
+		hw->sliport_healthcheck = 0;
+		ocs_hw_config_sli_port_health_check(hw, 0, 0);
+	}
+
+	if (hw->state != OCS_HW_STATE_QUEUES_ALLOCATED) {
+
+		hw->state = OCS_HW_STATE_TEARDOWN_IN_PROGRESS;
+
+		ocs_hw_flush(hw);
+
+		/* If there are outstanding commands, wait for them to complete */
+		while (!ocs_list_empty(&hw->cmd_head) && iters) {
+			ocs_udelay(10000);
+			ocs_hw_flush(hw);
+			iters--;
+		}
+
+		if (ocs_list_empty(&hw->cmd_head)) {
+			ocs_log_debug(hw->os, "All commands completed on MQ queue\n");
+		} else {
+			ocs_log_debug(hw->os, "Some commands still pending on MQ queue\n");
+		}
+
+		/* Cancel any remaining commands */
+		ocs_hw_command_cancel(hw);
+	} else {
+		hw->state = OCS_HW_STATE_TEARDOWN_IN_PROGRESS;
+	}
+
+	ocs_lock_free(&hw->cmd_lock);
+
+	/* Free unregistered RPI if workaround is in force */
+	if (hw->workaround.use_unregistered_rpi) {
+		sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, hw->workaround.unregistered_rid);
+	}
+
+	max_rpi = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI);
+	if (hw->rpi_ref) {
+		for (i = 0; i < max_rpi; i++) {
+			if (ocs_atomic_read(&hw->rpi_ref[i].rpi_count)) {
+				ocs_log_debug(hw->os, "non-zero ref [%d]=%d\n",
+						i, ocs_atomic_read(&hw->rpi_ref[i].rpi_count));
+			}
+		}
+		ocs_free(hw->os, hw->rpi_ref, max_rpi * sizeof(*hw->rpi_ref));
+		hw->rpi_ref = NULL;
+	}
+
+	ocs_dma_free(hw->os, &hw->rnode_mem);
+
+	if (hw->io) {
+		for (i = 0; i < hw->config.n_io; i++) {
+			if (hw->io[i] && (hw->io[i]->sgl != NULL) &&
+			    (hw->io[i]->sgl->virt != NULL)) {
+				if(hw->io[i]->is_port_owned) {
+					ocs_lock_free(&hw->io[i]->axr_lock);
+				}
+				ocs_dma_free(hw->os, hw->io[i]->sgl);
+			}
+			ocs_free(hw->os, hw->io[i], sizeof(ocs_hw_io_t));
+			hw->io[i] = NULL;
+		}
+		ocs_free(hw->os, hw->wqe_buffs, hw->config.n_io * hw->sli.config.wqe_size);
+		hw->wqe_buffs = NULL;
+		ocs_free(hw->os, hw->io, hw->config.n_io * sizeof(ocs_hw_io_t *));
+		hw->io = NULL;
+	}
+
+	ocs_dma_free(hw->os, &hw->xfer_rdy);
+	ocs_dma_free(hw->os, &hw->dump_sges);
+	ocs_dma_free(hw->os, &hw->loop_map);
+
+	ocs_lock_free(&hw->io_lock);
+	ocs_lock_free(&hw->io_abort_lock);
+
+
+	for (i = 0; i < hw->wq_count; i++) {
+		sli_queue_free(&hw->sli, &hw->wq[i], destroy_queues, free_memory);
+	}
+
+
+	for (i = 0; i < hw->rq_count; i++) {
+		sli_queue_free(&hw->sli, &hw->rq[i], destroy_queues, free_memory);
+	}
+
+	for (i = 0; i < hw->mq_count; i++) {
+		sli_queue_free(&hw->sli, &hw->mq[i], destroy_queues, free_memory);
+	}
+
+	for (i = 0; i < hw->cq_count; i++) {
+		sli_queue_free(&hw->sli, &hw->cq[i], destroy_queues, free_memory);
+	}
+
+	for (i = 0; i < hw->eq_count; i++) {
+		sli_queue_free(&hw->sli, &hw->eq[i], destroy_queues, free_memory);
+	}
+
+	ocs_hw_qtop_free(hw->qtop);
+
+	/* Free rq buffers */
+	ocs_hw_rx_free(hw);
+
+	hw_queue_teardown(hw);
+
+	ocs_hw_rqpair_teardown(hw);
+
+	if (sli_teardown(&hw->sli)) {
+		ocs_log_err(hw->os, "SLI teardown failed\n");
+	}
+
+	ocs_queue_history_free(&hw->q_hist);
+
+	/* record the fact that the queues are non-functional */
+	hw->state = OCS_HW_STATE_UNINITIALIZED;
+
+	/* free sequence free pool */
+	ocs_array_free(hw->seq_pool);
+	hw->seq_pool = NULL;
+
+	/* free hw_wq_callback pool */
+	ocs_pool_free(hw->wq_reqtag_pool);
+
+	ocs_dma_free(hw->os, &hw->domain_dmem);
+	ocs_dma_free(hw->os, &hw->fcf_dmem);
+	/* Mark HW setup as not having been called */
+	hw->hw_setup_called = FALSE;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+ocs_hw_rtn_e
+ocs_hw_reset(ocs_hw_t *hw, ocs_hw_reset_e reset)
+{
+	uint32_t	i;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint32_t	iters;
+	ocs_hw_state_e prev_state = hw->state;
+
+	if (hw->state != OCS_HW_STATE_ACTIVE) {
+		ocs_log_test(hw->os, "HW state %d is not active\n", hw->state);
+	}
+
+	hw->state = OCS_HW_STATE_RESET_IN_PROGRESS;
+
+	/* shutdown target wqe timer */
+	shutdown_target_wqe_timer(hw);
+
+	ocs_hw_flush(hw);
+
+	/*
+	 * If an mailbox command requiring a DMA is outstanding (i.e. SFP/DDM),
+	 * then the FW will UE when the reset is issued. So attempt to complete
+	 * all mailbox commands.
+	 */
+	iters = 10;
+	while (!ocs_list_empty(&hw->cmd_head) && iters) {
+		ocs_udelay(10000);
+		ocs_hw_flush(hw);
+		iters--;
+	}
+
+	if (ocs_list_empty(&hw->cmd_head)) {
+		ocs_log_debug(hw->os, "All commands completed on MQ queue\n");
+	} else {
+		ocs_log_debug(hw->os, "Some commands still pending on MQ queue\n");
+	}
+
+	/* Reset the chip */
+	switch(reset) {
+	case OCS_HW_RESET_FUNCTION:
+		ocs_log_debug(hw->os, "issuing function level reset\n");
+		if (sli_reset(&hw->sli)) {
+			ocs_log_err(hw->os, "sli_reset failed\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_RESET_FIRMWARE:
+		ocs_log_debug(hw->os, "issuing firmware reset\n");
+		if (sli_fw_reset(&hw->sli)) {
+			ocs_log_err(hw->os, "sli_soft_reset failed\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		/*
+		 * Because the FW reset leaves the FW in a non-running state,
+		 * follow that with a regular reset.
+		 */
+		ocs_log_debug(hw->os, "issuing function level reset\n");
+		if (sli_reset(&hw->sli)) {
+			ocs_log_err(hw->os, "sli_reset failed\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	default:
+		ocs_log_test(hw->os, "unknown reset type - no reset performed\n");
+		hw->state = prev_state;
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* Not safe to walk command/io lists unless they've been initialized */
+	if (prev_state != OCS_HW_STATE_UNINITIALIZED) {
+		ocs_hw_command_cancel(hw);
+
+		/* Clean up the inuse list, the free list and the wait free list */
+		ocs_hw_io_cancel(hw);
+
+		ocs_memset(hw->domains, 0, sizeof(hw->domains));
+		ocs_memset(hw->fcf_index_fcfi, 0, sizeof(hw->fcf_index_fcfi));
+
+		ocs_hw_link_event_init(hw);
+
+		ocs_lock(&hw->io_lock);
+			/* The io lists should be empty, but remove any that didn't get cleaned up. */
+			while (!ocs_list_empty(&hw->io_timed_wqe)) {
+				ocs_list_remove_head(&hw->io_timed_wqe);
+			}
+			/* Don't clean up the io_inuse list, the backend will do that when it finishes the IO */
+
+			while (!ocs_list_empty(&hw->io_free)) {
+				ocs_list_remove_head(&hw->io_free);
+			}
+			while (!ocs_list_empty(&hw->io_wait_free)) {
+				ocs_list_remove_head(&hw->io_wait_free);
+			}
+
+			/* Reset the request tag pool, the HW IO request tags are reassigned in ocs_hw_setup_io() */
+			ocs_hw_reqtag_reset(hw);
+
+		ocs_unlock(&hw->io_lock);
+	}
+
+	if (prev_state != OCS_HW_STATE_UNINITIALIZED) {
+		for (i = 0; i < hw->wq_count; i++) {
+			sli_queue_reset(&hw->sli, &hw->wq[i]);
+		}
+
+		for (i = 0; i < hw->rq_count; i++) {
+			sli_queue_reset(&hw->sli, &hw->rq[i]);
+		}
+
+		for (i = 0; i < hw->hw_rq_count; i++) {
+			hw_rq_t *rq = hw->hw_rq[i];
+			if (rq->rq_tracker != NULL) {
+				uint32_t j;
+
+				for (j = 0; j < rq->entry_count; j++) {
+					rq->rq_tracker[j] = NULL;
+				}
+			}
+		}
+
+		for (i = 0; i < hw->mq_count; i++) {
+			sli_queue_reset(&hw->sli, &hw->mq[i]);
+		}
+
+		for (i = 0; i < hw->cq_count; i++) {
+			sli_queue_reset(&hw->sli, &hw->cq[i]);
+		}
+
+		for (i = 0; i < hw->eq_count; i++) {
+			sli_queue_reset(&hw->sli, &hw->eq[i]);
+		}
+
+		/* Free rq buffers */
+		ocs_hw_rx_free(hw);
+
+		/* Teardown the HW queue topology */
+		hw_queue_teardown(hw);
+	} else {
+
+		/* Free rq buffers */
+		ocs_hw_rx_free(hw);
+	}
+
+	/*
+	 * Re-apply the run-time workarounds after clearing the SLI config
+	 * fields in sli_reset.
+	 */
+	ocs_hw_workaround_setup(hw);
+	hw->state = OCS_HW_STATE_QUEUES_ALLOCATED;
+
+	return rc;
+}
+
+int32_t
+ocs_hw_get_num_eq(ocs_hw_t *hw)
+{
+	return hw->eq_count;
+}
+
+static int32_t
+ocs_hw_get_fw_timed_out(ocs_hw_t *hw)
+{
+	/* The error values below are taken from LOWLEVEL_SET_WATCHDOG_TIMER_rev1.pdf
+	* No further explanation is given in the document.
+	* */
+	return (sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR1) == 0x2 &&
+		sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR2) == 0x10);
+}
+
+
+ocs_hw_rtn_e
+ocs_hw_get(ocs_hw_t *hw, ocs_hw_property_e prop, uint32_t *value)
+{
+	ocs_hw_rtn_e		rc = OCS_HW_RTN_SUCCESS;
+	int32_t			tmp;
+
+	if (!value) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	*value = 0;
+
+	switch (prop) {
+	case OCS_HW_N_IO:
+		*value = hw->config.n_io;
+		break;
+	case OCS_HW_N_SGL:
+		*value = (hw->config.n_sgl - SLI4_SGE_MAX_RESERVED);
+		break;
+	case OCS_HW_MAX_IO:
+		*value = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI);
+		break;
+	case OCS_HW_MAX_NODES:
+		*value = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI);
+		break;
+	case OCS_HW_MAX_RQ_ENTRIES:
+		*value = hw->num_qentries[SLI_QTYPE_RQ];
+		break;
+	case OCS_HW_RQ_DEFAULT_BUFFER_SIZE:
+		*value = hw->config.rq_default_buffer_size;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_CAPABLE:
+		*value = sli_get_auto_xfer_rdy_capable(&hw->sli);
+		break;
+	case OCS_HW_AUTO_XFER_RDY_XRI_CNT:
+		*value = hw->config.auto_xfer_rdy_xri_cnt;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_SIZE:
+		*value = hw->config.auto_xfer_rdy_size;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_BLK_SIZE:
+		switch (hw->config.auto_xfer_rdy_blk_size_chip) {
+		case 0:
+			*value = 512;
+			break;
+		case 1:
+			*value = 1024;
+			break;
+		case 2:
+			*value = 2048;
+			break;
+		case 3:
+			*value = 4096;
+			break;
+		case 4:
+			*value = 520;
+			break;
+		default:
+			*value = 0;
+			rc = OCS_HW_RTN_ERROR;
+			break;
+		}
+		break;
+	case OCS_HW_AUTO_XFER_RDY_T10_ENABLE:
+		*value = hw->config.auto_xfer_rdy_t10_enable;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_P_TYPE:
+		*value = hw->config.auto_xfer_rdy_p_type;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA:
+		*value = hw->config.auto_xfer_rdy_ref_tag_is_lba;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID:
+		*value = hw->config.auto_xfer_rdy_app_tag_valid;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE:
+		*value = hw->config.auto_xfer_rdy_app_tag_value;
+		break;
+	case OCS_HW_MAX_SGE:
+		*value = sli_get_max_sge(&hw->sli);
+		break;
+	case OCS_HW_MAX_SGL:
+		*value = sli_get_max_sgl(&hw->sli);
+		break;
+	case OCS_HW_TOPOLOGY:
+		/*
+		 * Infer link.status based on link.speed.
+		 * Report OCS_HW_TOPOLOGY_NONE if the link is down.
+		 */
+		if (hw->link.speed == 0) {
+			*value = OCS_HW_TOPOLOGY_NONE;
+			break;
+		}
+		switch (hw->link.topology) {
+		case SLI_LINK_TOPO_NPORT:
+			*value = OCS_HW_TOPOLOGY_NPORT;
+			break;
+		case SLI_LINK_TOPO_LOOP:
+			*value = OCS_HW_TOPOLOGY_LOOP;
+			break;
+		case SLI_LINK_TOPO_NONE:
+			*value = OCS_HW_TOPOLOGY_NONE;
+			break;
+		default:
+			ocs_log_test(hw->os, "unsupported topology %#x\n", hw->link.topology);
+			rc = OCS_HW_RTN_ERROR;
+			break;
+		}
+		break;
+	case OCS_HW_CONFIG_TOPOLOGY:
+		*value = hw->config.topology;
+		break;
+	case OCS_HW_LINK_SPEED:
+		*value = hw->link.speed;
+		break;
+	case OCS_HW_LINK_CONFIG_SPEED:
+		switch (hw->config.speed) {
+		case FC_LINK_SPEED_10G:
+			*value = 10000;
+			break;
+		case FC_LINK_SPEED_AUTO_16_8_4:
+			*value = 0;
+			break;
+		case FC_LINK_SPEED_2G:
+			*value = 2000;
+			break;
+		case FC_LINK_SPEED_4G:
+			*value = 4000;
+			break;
+		case FC_LINK_SPEED_8G:
+			*value = 8000;
+			break;
+		case FC_LINK_SPEED_16G:
+			*value = 16000;
+			break;
+		case FC_LINK_SPEED_32G:
+			*value = 32000;
+			break;
+		default:
+			ocs_log_test(hw->os, "unsupported speed %#x\n", hw->config.speed);
+			rc = OCS_HW_RTN_ERROR;
+			break;
+		}
+		break;
+	case OCS_HW_IF_TYPE:
+		*value = sli_get_if_type(&hw->sli);
+		break;
+	case OCS_HW_SLI_REV:
+		*value = sli_get_sli_rev(&hw->sli);
+		break;
+	case OCS_HW_SLI_FAMILY:
+		*value = sli_get_sli_family(&hw->sli);
+		break;
+	case OCS_HW_DIF_CAPABLE:
+		*value = sli_get_dif_capable(&hw->sli);
+		break;
+	case OCS_HW_DIF_SEED:
+		*value = hw->config.dif_seed;
+		break;
+	case OCS_HW_DIF_MODE:
+		*value = hw->config.dif_mode;
+		break;
+	case OCS_HW_DIF_MULTI_SEPARATE:
+		/* Lancer supports multiple DIF separates */
+		if (hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) {
+			*value = TRUE;
+		} else {
+			*value = FALSE;
+		}
+		break;
+	case OCS_HW_DUMP_MAX_SIZE:
+		*value = hw->dump_size;
+		break;
+	case OCS_HW_DUMP_READY:
+		*value = sli_dump_is_ready(&hw->sli);
+		break;
+	case OCS_HW_DUMP_PRESENT:
+		*value = sli_dump_is_present(&hw->sli);
+		break;
+	case OCS_HW_RESET_REQUIRED:
+		tmp = sli_reset_required(&hw->sli);
+		if(tmp < 0) {
+			rc = OCS_HW_RTN_ERROR;
+		} else {
+			*value = tmp;
+		}
+		break;
+	case OCS_HW_FW_ERROR:
+		*value = sli_fw_error_status(&hw->sli);
+		break;
+	case OCS_HW_FW_READY:
+		*value = sli_fw_ready(&hw->sli);
+		break;
+	case OCS_HW_FW_TIMED_OUT:
+		*value = ocs_hw_get_fw_timed_out(hw);
+		break;
+	case OCS_HW_HIGH_LOGIN_MODE:
+		*value = sli_get_hlm_capable(&hw->sli);
+		break;
+	case OCS_HW_PREREGISTER_SGL:
+		*value = sli_get_sgl_preregister_required(&hw->sli);
+		break;
+	case OCS_HW_HW_REV1:
+		*value = sli_get_hw_revision(&hw->sli, 0);
+		break;
+	case OCS_HW_HW_REV2:
+		*value = sli_get_hw_revision(&hw->sli, 1);
+		break;
+	case OCS_HW_HW_REV3:
+		*value = sli_get_hw_revision(&hw->sli, 2);
+		break;
+	case OCS_HW_LINKCFG:
+		*value = hw->linkcfg;
+		break;
+	case OCS_HW_ETH_LICENSE:
+		*value = hw->eth_license;
+		break;
+	case OCS_HW_LINK_MODULE_TYPE:
+		*value = sli_get_link_module_type(&hw->sli);
+		break;
+	case OCS_HW_NUM_CHUTES:
+		*value = ocs_hw_get_num_chutes(hw);
+		break;
+	case OCS_HW_DISABLE_AR_TGT_DIF:
+		*value = hw->workaround.disable_ar_tgt_dif;
+		break;
+	case OCS_HW_EMULATE_I_ONLY_AAB:
+		*value = hw->config.i_only_aab;
+		break;
+	case OCS_HW_EMULATE_TARGET_WQE_TIMEOUT:
+		*value = hw->config.emulate_tgt_wqe_timeout;
+		break;
+	case OCS_HW_VPD_LEN:
+		*value = sli_get_vpd_len(&hw->sli);
+		break;
+	case OCS_HW_SGL_CHAINING_CAPABLE:
+		*value = sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported;
+		break;
+	case OCS_HW_SGL_CHAINING_ALLOWED:
+		/*
+		 * SGL Chaining is allowed in the following cases:
+		 *   1. Lancer with host SGL Lists
+		 *   2. Skyhawk with pre-registered SGL Lists
+		 */
+		*value = FALSE;
+		if ((sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported) &&
+		    !sli_get_sgl_preregister(&hw->sli) &&
+		    SLI4_IF_TYPE_LANCER_FC_ETH  == sli_get_if_type(&hw->sli)) {
+			*value = TRUE;
+		}
+
+		if ((sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported) &&
+		    sli_get_sgl_preregister(&hw->sli) &&
+		    ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) ||
+			(SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli)))) {
+			*value = TRUE;
+		}
+		break;
+	case OCS_HW_SGL_CHAINING_HOST_ALLOCATED:
+		/* Only lancer supports host allocated SGL Chaining buffers. */
+		*value = ((sli_get_is_sgl_chaining_capable(&hw->sli) || hw->workaround.sglc_misreported) &&
+			  (SLI4_IF_TYPE_LANCER_FC_ETH  == sli_get_if_type(&hw->sli)));
+		break;
+	case OCS_HW_SEND_FRAME_CAPABLE:
+		if (hw->workaround.ignore_send_frame) {
+			*value = 0;
+		} else {
+			/* Only lancer is capable */
+			*value = sli_get_if_type(&hw->sli) == SLI4_IF_TYPE_LANCER_FC_ETH;
+		}
+		break;
+	case OCS_HW_RQ_SELECTION_POLICY:
+		*value = hw->config.rq_selection_policy;
+		break;
+	case OCS_HW_RR_QUANTA:
+		*value = hw->config.rr_quanta;
+		break;
+	case OCS_HW_MAX_VPORTS:
+		*value = sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_VPI);
+	default:
+		ocs_log_test(hw->os, "unsupported property %#x\n", prop);
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	return rc;
+}
+
+void *
+ocs_hw_get_ptr(ocs_hw_t *hw, ocs_hw_property_e prop)
+{
+	void	*rc = NULL;
+
+	switch (prop) {
+	case OCS_HW_WWN_NODE:
+		rc = sli_get_wwn_node(&hw->sli);
+		break;
+	case OCS_HW_WWN_PORT:
+		rc = sli_get_wwn_port(&hw->sli);
+		break;
+	case OCS_HW_VPD:
+		/* make sure VPD length is non-zero */
+		if (sli_get_vpd_len(&hw->sli)) {
+			rc = sli_get_vpd(&hw->sli);
+		}
+		break;
+	case OCS_HW_FW_REV:
+		rc = sli_get_fw_name(&hw->sli, 0);
+		break;
+	case OCS_HW_FW_REV2:
+		rc = sli_get_fw_name(&hw->sli, 1);
+		break;
+	case OCS_HW_IPL:
+		rc = sli_get_ipl_name(&hw->sli);
+		break;
+	case OCS_HW_PORTNUM:
+		rc = sli_get_portnum(&hw->sli);
+		break;
+	case OCS_HW_BIOS_VERSION_STRING:
+		rc = sli_get_bios_version_string(&hw->sli);
+		break;
+	default:
+		ocs_log_test(hw->os, "unsupported property %#x\n", prop);
+	}
+
+	return rc;
+}
+
+
+
+ocs_hw_rtn_e
+ocs_hw_set(ocs_hw_t *hw, ocs_hw_property_e prop, uint32_t value)
+{
+	ocs_hw_rtn_e		rc = OCS_HW_RTN_SUCCESS;
+
+	switch (prop) {
+	case OCS_HW_N_IO:
+		if (value > sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI) ||
+		    value == 0) {
+			ocs_log_test(hw->os, "IO value out of range %d vs %d\n",
+					value, sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_XRI));
+			rc = OCS_HW_RTN_ERROR;
+		} else {
+			hw->config.n_io = value;
+		}
+		break;
+	case OCS_HW_N_SGL:
+		value += SLI4_SGE_MAX_RESERVED;
+		if (value > sli_get_max_sgl(&hw->sli)) {
+			ocs_log_test(hw->os, "SGL value out of range %d vs %d\n",
+					value, sli_get_max_sgl(&hw->sli));
+			rc = OCS_HW_RTN_ERROR;
+		} else {
+			hw->config.n_sgl = value;
+		}
+		break;
+	case OCS_HW_TOPOLOGY:
+		if ((sli_get_medium(&hw->sli) != SLI_LINK_MEDIUM_FC) &&
+				(value != OCS_HW_TOPOLOGY_AUTO)) {
+			ocs_log_test(hw->os, "unsupported topology=%#x medium=%#x\n",
+					value, sli_get_medium(&hw->sli));
+			rc = OCS_HW_RTN_ERROR;
+			break;
+		}
+
+		switch (value) {
+		case OCS_HW_TOPOLOGY_AUTO:
+			if (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC) {
+				sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FC);
+			} else {
+				sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FCOE);
+			}
+			break;
+		case OCS_HW_TOPOLOGY_NPORT:
+			sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FC_DA);
+			break;
+		case OCS_HW_TOPOLOGY_LOOP:
+			sli_set_topology(&hw->sli, SLI4_READ_CFG_TOPO_FC_AL);
+			break;
+		default:
+			ocs_log_test(hw->os, "unsupported topology %#x\n", value);
+			rc = OCS_HW_RTN_ERROR;
+		}
+		hw->config.topology = value;
+		break;
+	case OCS_HW_LINK_SPEED:
+		if (sli_get_medium(&hw->sli) != SLI_LINK_MEDIUM_FC) {
+			switch (value) {
+			case 0: 	/* Auto-speed negotiation */
+			case 10000:	/* FCoE speed */
+				hw->config.speed = FC_LINK_SPEED_10G;
+				break;
+			default:
+				ocs_log_test(hw->os, "unsupported speed=%#x medium=%#x\n",
+						value, sli_get_medium(&hw->sli));
+				rc = OCS_HW_RTN_ERROR;
+			}
+			break;
+		}
+
+		switch (value) {
+		case 0:		/* Auto-speed negotiation */
+			hw->config.speed = FC_LINK_SPEED_AUTO_16_8_4;
+			break;
+		case 2000:	/* FC speeds */
+			hw->config.speed = FC_LINK_SPEED_2G;
+			break;
+		case 4000:
+			hw->config.speed = FC_LINK_SPEED_4G;
+			break;
+		case 8000:
+			hw->config.speed = FC_LINK_SPEED_8G;
+			break;
+		case 16000:
+			hw->config.speed = FC_LINK_SPEED_16G;
+			break;
+		case 32000:
+			hw->config.speed = FC_LINK_SPEED_32G;
+			break;
+		default:
+			ocs_log_test(hw->os, "unsupported speed %d\n", value);
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_DIF_SEED:
+		/* Set the DIF seed - only for lancer right now */
+		if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) {
+			ocs_log_test(hw->os, "DIF seed not supported for this device\n");
+			rc = OCS_HW_RTN_ERROR;
+		} else {
+			hw->config.dif_seed = value;
+		}
+		break;
+	case OCS_HW_DIF_MODE:
+		switch (value) {
+		case OCS_HW_DIF_MODE_INLINE:
+			/*
+			 *  Make sure we support inline DIF.
+			 *
+			 * Note: Having both bits clear means that we have old
+			 *	FW that doesn't set the bits.
+			 */
+			if (sli_is_dif_inline_capable(&hw->sli)) {
+				hw->config.dif_mode = value;
+			} else {
+				ocs_log_test(hw->os, "chip does not support DIF inline\n");
+				rc = OCS_HW_RTN_ERROR;
+			}
+			break;
+		case OCS_HW_DIF_MODE_SEPARATE:
+			/* Make sure we support DIF separates. */
+			if (sli_is_dif_separate_capable(&hw->sli)) {
+				hw->config.dif_mode = value;
+			} else {
+				ocs_log_test(hw->os, "chip does not support DIF separate\n");
+				rc = OCS_HW_RTN_ERROR;
+			}
+		}
+		break;
+	case OCS_HW_RQ_PROCESS_LIMIT: {
+		hw_rq_t *rq;
+		uint32_t i;
+
+		/* For each hw_rq object, set its parent CQ limit value */
+		for (i = 0; i < hw->hw_rq_count; i++) {
+			rq = hw->hw_rq[i];
+			hw->cq[rq->cq->instance].proc_limit = value;
+		}
+		break;
+	}
+	case OCS_HW_RQ_DEFAULT_BUFFER_SIZE:
+		hw->config.rq_default_buffer_size = value;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_XRI_CNT:
+		hw->config.auto_xfer_rdy_xri_cnt = value;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_SIZE:
+		hw->config.auto_xfer_rdy_size = value;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_BLK_SIZE:
+		switch (value) {
+		case 512:
+			hw->config.auto_xfer_rdy_blk_size_chip = 0;
+			break;
+		case 1024:
+			hw->config.auto_xfer_rdy_blk_size_chip = 1;
+			break;
+		case 2048:
+			hw->config.auto_xfer_rdy_blk_size_chip = 2;
+			break;
+		case 4096:
+			hw->config.auto_xfer_rdy_blk_size_chip = 3;
+			break;
+		case 520:
+			hw->config.auto_xfer_rdy_blk_size_chip = 4;
+			break;
+		default:
+			ocs_log_err(hw->os, "Invalid block size %d\n",
+				    value);
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_AUTO_XFER_RDY_T10_ENABLE:
+		hw->config.auto_xfer_rdy_t10_enable = value;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_P_TYPE:
+		hw->config.auto_xfer_rdy_p_type = value;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA:
+		hw->config.auto_xfer_rdy_ref_tag_is_lba = value;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID:
+		hw->config.auto_xfer_rdy_app_tag_valid = value;
+		break;
+	case OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE:
+		hw->config.auto_xfer_rdy_app_tag_value = value;
+		break;
+	case OCS_ESOC:
+		hw->config.esoc = value;
+	case OCS_HW_HIGH_LOGIN_MODE:
+		rc = sli_set_hlm(&hw->sli, value);
+		break;
+	case OCS_HW_PREREGISTER_SGL:
+		rc = sli_set_sgl_preregister(&hw->sli, value);
+		break;
+	case OCS_HW_ETH_LICENSE:
+		hw->eth_license = value;
+		break;
+	case OCS_HW_EMULATE_I_ONLY_AAB:
+		hw->config.i_only_aab = value;
+		break;
+	case OCS_HW_EMULATE_TARGET_WQE_TIMEOUT:
+		hw->config.emulate_tgt_wqe_timeout = value;
+		break;
+	case OCS_HW_BOUNCE:
+		hw->config.bounce = value;
+		break;
+	case OCS_HW_RQ_SELECTION_POLICY:
+		hw->config.rq_selection_policy = value;
+		break;
+	case OCS_HW_RR_QUANTA:
+		hw->config.rr_quanta = value;
+		break;
+	default:
+		ocs_log_test(hw->os, "unsupported property %#x\n", prop);
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	return rc;
+}
+
+
+ocs_hw_rtn_e
+ocs_hw_set_ptr(ocs_hw_t *hw, ocs_hw_property_e prop, void *value)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	switch (prop) {
+	case OCS_HW_WAR_VERSION:
+		hw->hw_war_version = value;
+		break;
+	case OCS_HW_FILTER_DEF: {
+		char *p = value;
+		uint32_t idx = 0;
+
+		for (idx = 0; idx < ARRAY_SIZE(hw->config.filter_def); idx++) {
+			hw->config.filter_def[idx] = 0;
+		}
+
+		for (idx = 0; (idx < ARRAY_SIZE(hw->config.filter_def)) && (p != NULL) && *p; ) {
+			hw->config.filter_def[idx++] = ocs_strtoul(p, 0, 0);
+			p = ocs_strchr(p, ',');
+			if (p != NULL) {
+				p++;
+			}
+		}
+
+		break;
+	}
+	default:
+		ocs_log_test(hw->os, "unsupported property %#x\n", prop);
+		rc = OCS_HW_RTN_ERROR;
+		break;
+	}
+	return rc;
+}
+/**
+ * @ingroup interrupt
+ * @brief Check for the events associated with the interrupt vector.
+ *
+ * @param hw Hardware context.
+ * @param vector Zero-based interrupt vector number.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+ocs_hw_event_check(ocs_hw_t *hw, uint32_t vector)
+{
+	int32_t rc = 0;
+
+	if (!hw) {
+		ocs_log_err(NULL, "HW context NULL?!?\n");
+		return -1;
+	}
+
+	if (vector > hw->eq_count) {
+		ocs_log_err(hw->os, "vector %d. max %d\n",
+				vector, hw->eq_count);
+		return -1;
+	}
+
+	/*
+	 * The caller should disable interrupts if they wish to prevent us
+	 * from processing during a shutdown. The following states are defined:
+	 *   OCS_HW_STATE_UNINITIALIZED - No queues allocated
+	 *   OCS_HW_STATE_QUEUES_ALLOCATED - The state after a chip reset,
+	 *                                    queues are cleared.
+	 *   OCS_HW_STATE_ACTIVE - Chip and queues are operational
+	 *   OCS_HW_STATE_RESET_IN_PROGRESS - reset, we still want completions
+	 *   OCS_HW_STATE_TEARDOWN_IN_PROGRESS - We still want mailbox
+	 *                                        completions.
+	 */
+	if (hw->state != OCS_HW_STATE_UNINITIALIZED) {
+		rc = sli_queue_is_empty(&hw->sli, &hw->eq[vector]);
+
+		/* Re-arm queue if there are no entries */
+		if (rc != 0) {
+			sli_queue_arm(&hw->sli, &hw->eq[vector], TRUE);
+		}
+	}
+	return rc;
+}
+
+void
+ocs_hw_unsol_process_bounce(void *arg)
+{
+	ocs_hw_sequence_t *seq = arg;
+	ocs_hw_t *hw = seq->hw;
+
+	ocs_hw_assert(hw != NULL);
+	ocs_hw_assert(hw->callback.unsolicited != NULL);
+
+	hw->callback.unsolicited(hw->args.unsolicited, seq);
+}
+
+int32_t
+ocs_hw_process(ocs_hw_t *hw, uint32_t vector, uint32_t max_isr_time_msec)
+{
+	hw_eq_t *eq;
+	int32_t rc = 0;
+
+	CPUTRACE("");
+
+	/*
+	 * The caller should disable interrupts if they wish to prevent us
+	 * from processing during a shutdown. The following states are defined:
+	 *   OCS_HW_STATE_UNINITIALIZED - No queues allocated
+	 *   OCS_HW_STATE_QUEUES_ALLOCATED - The state after a chip reset,
+	 *                                    queues are cleared.
+	 *   OCS_HW_STATE_ACTIVE - Chip and queues are operational
+	 *   OCS_HW_STATE_RESET_IN_PROGRESS - reset, we still want completions
+	 *   OCS_HW_STATE_TEARDOWN_IN_PROGRESS - We still want mailbox
+	 *                                        completions.
+	 */
+	if (hw->state == OCS_HW_STATE_UNINITIALIZED) {
+		return 0;
+	}
+
+	/* Get pointer to hw_eq_t */
+	eq = hw->hw_eq[vector];
+
+	OCS_STAT(eq->use_count++);
+
+	rc = ocs_hw_eq_process(hw, eq, max_isr_time_msec);
+
+	return rc;
+}
+
+/**
+ * @ingroup interrupt
+ * @brief Process events associated with an EQ.
+ *
+ * @par Description
+ * Loop termination:
+ * @n @n Without a mechanism to terminate the completion processing loop, it
+ * is possible under some workload conditions for the loop to never terminate
+ * (or at least take longer than the OS is happy to have an interrupt handler
+ * or kernel thread context hold a CPU without yielding).
+ * @n @n The approach taken here is to periodically check how much time
+ * we have been in this
+ * processing loop, and if we exceed a predetermined time (multiple seconds), the
+ * loop is terminated, and ocs_hw_process() returns.
+ *
+ * @param hw Hardware context.
+ * @param eq Pointer to HW EQ object.
+ * @param max_isr_time_msec Maximum time in msec to stay in this function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+ocs_hw_eq_process(ocs_hw_t *hw, hw_eq_t *eq, uint32_t max_isr_time_msec)
+{
+	uint8_t		eqe[sizeof(sli4_eqe_t)] = { 0 };
+	uint32_t	done = FALSE;
+	uint32_t	tcheck_count;
+	time_t		tstart;
+	time_t		telapsed;
+
+	tcheck_count = OCS_HW_TIMECHECK_ITERATIONS;
+	tstart = ocs_msectime();
+
+	CPUTRACE("");
+
+	while (!done && !sli_queue_read(&hw->sli, eq->queue, eqe)) {
+		uint16_t	cq_id = 0;
+		int32_t		rc;
+
+		rc = sli_eq_parse(&hw->sli, eqe, &cq_id);
+		if (unlikely(rc)) {
+			if (rc > 0) {
+				uint32_t i;
+
+				/*
+				 * Received a sentinel EQE indicating the EQ is full.
+				 * Process all CQs
+				 */
+				for (i = 0; i < hw->cq_count; i++) {
+					ocs_hw_cq_process(hw, hw->hw_cq[i]);
+				}
+				continue;
+			} else {
+				return rc;
+			}
+		} else {
+			int32_t index = ocs_hw_queue_hash_find(hw->cq_hash, cq_id);
+			if (likely(index >= 0)) {
+				ocs_hw_cq_process(hw, hw->hw_cq[index]);
+			} else {
+				ocs_log_err(hw->os, "bad CQ_ID %#06x\n", cq_id);
+			}
+		}
+
+
+		if (eq->queue->n_posted > (eq->queue->posted_limit)) {
+			sli_queue_arm(&hw->sli, eq->queue, FALSE);
+		}
+
+		if (tcheck_count && (--tcheck_count == 0)) {
+			tcheck_count = OCS_HW_TIMECHECK_ITERATIONS;
+			telapsed = ocs_msectime() - tstart;
+			if (telapsed >= max_isr_time_msec) {
+				done = TRUE;
+			}
+		}
+	}
+	sli_queue_eq_arm(&hw->sli, eq->queue, TRUE);
+
+	return 0;
+}
+
+/**
+ * @brief Submit queued (pending) mbx commands.
+ *
+ * @par Description
+ * Submit queued mailbox commands.
+ * --- Assumes that hw->cmd_lock is held ---
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+static int32_t
+ocs_hw_cmd_submit_pending(ocs_hw_t *hw)
+{
+	ocs_command_ctx_t *ctx;
+	int32_t rc = 0;
+
+	/* Assumes lock held */
+
+	/* Only submit MQE if there's room */
+	while (hw->cmd_head_count < (OCS_HW_MQ_DEPTH - 1)) {
+		ctx = ocs_list_remove_head(&hw->cmd_pending);
+		if (ctx == NULL) {
+			break;
+		}
+		ocs_list_add_tail(&hw->cmd_head, ctx);
+		hw->cmd_head_count++;
+		if (sli_queue_write(&hw->sli, hw->mq, ctx->buf) < 0) {
+			ocs_log_test(hw->os, "sli_queue_write failed: %d\n", rc);
+			rc = -1;
+			break;
+		}
+	}
+	return rc;
+}
+
+/**
+ * @ingroup io
+ * @brief Issue a SLI command.
+ *
+ * @par Description
+ * Send a mailbox command to the hardware, and either wait for a completion
+ * (OCS_CMD_POLL) or get an optional asynchronous completion (OCS_CMD_NOWAIT).
+ *
+ * @param hw Hardware context.
+ * @param cmd Buffer containing a formatted command and results.
+ * @param opts Command options:
+ *  - OCS_CMD_POLL - Command executes synchronously and busy-waits for the completion.
+ *  - OCS_CMD_NOWAIT - Command executes asynchronously. Uses callback.
+ * @param cb Function callback used for asynchronous mode. May be NULL.
+ * @n Prototype is <tt>(*cb)(void *arg, uint8_t *cmd)</tt>.
+ * @n @n @b Note: If the
+ * callback function pointer is NULL, the results of the command are silently
+ * discarded, allowing this pointer to exist solely on the stack.
+ * @param arg Argument passed to an asynchronous callback.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_command(ocs_hw_t *hw, uint8_t *cmd, uint32_t opts, void *cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+
+	/*
+	 * If the chip is in an error state (UE'd) then reject this mailbox
+	 *  command.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		uint32_t err1 = sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR1);
+		uint32_t err2 = sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_ERROR2);
+		if (hw->expiration_logged == 0 && err1 == 0x2 && err2 == 0x10) {
+			hw->expiration_logged = 1;
+			ocs_log_crit(hw->os,"Emulex: Heartbeat expired after %d seconds\n",
+					hw->watchdog_timeout);
+		}
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		ocs_log_crit(hw->os, "status=%#x error1=%#x error2=%#x\n",
+			sli_reg_read(&hw->sli, SLI4_REG_SLIPORT_STATUS),
+			err1, err2);
+
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (OCS_CMD_POLL == opts) {
+
+		ocs_lock(&hw->cmd_lock);
+		if (hw->mq->length && !sli_queue_is_empty(&hw->sli, hw->mq)) {
+			/*
+			 * Can't issue Boot-strap mailbox command with other
+			 * mail-queue commands pending as this interaction is
+			 * undefined
+			 */
+			rc = OCS_HW_RTN_ERROR;
+		} else {
+			void *bmbx = hw->sli.bmbx.virt;
+
+			ocs_memset(bmbx, 0, SLI4_BMBX_SIZE);
+			ocs_memcpy(bmbx, cmd, SLI4_BMBX_SIZE);
+
+			if (sli_bmbx_command(&hw->sli) == 0) {
+				rc = OCS_HW_RTN_SUCCESS;
+				ocs_memcpy(cmd, bmbx, SLI4_BMBX_SIZE);
+			}
+		}
+		ocs_unlock(&hw->cmd_lock);
+	} else if (OCS_CMD_NOWAIT == opts) {
+		ocs_command_ctx_t	*ctx = NULL;
+
+		ctx = ocs_malloc(hw->os, sizeof(ocs_command_ctx_t), OCS_M_ZERO | OCS_M_NOWAIT);
+		if (!ctx) {
+			ocs_log_err(hw->os, "can't allocate command context\n");
+			return OCS_HW_RTN_NO_RESOURCES;
+		}
+
+		if (hw->state != OCS_HW_STATE_ACTIVE) {
+			ocs_log_err(hw->os, "Can't send command, HW state=%d\n", hw->state);
+			ocs_free(hw->os, ctx, sizeof(*ctx));
+			return OCS_HW_RTN_ERROR;
+		}
+
+		if (cb) {
+			ctx->cb = cb;
+			ctx->arg = arg;
+		}
+		ctx->buf = cmd;
+		ctx->ctx = hw;
+
+		ocs_lock(&hw->cmd_lock);
+
+			/* Add to pending list */
+			ocs_list_add_tail(&hw->cmd_pending, ctx);
+
+			/* Submit as much of the pending list as we can */
+			if (ocs_hw_cmd_submit_pending(hw) == 0) {
+				rc = OCS_HW_RTN_SUCCESS;
+			}
+
+		ocs_unlock(&hw->cmd_lock);
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Register a callback for the given event.
+ *
+ * @param hw Hardware context.
+ * @param which Event of interest.
+ * @param func Function to call when the event occurs.
+ * @param arg Argument passed to the callback function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_callback(ocs_hw_t *hw, ocs_hw_callback_e which, void *func, void *arg)
+{
+
+	if (!hw || !func || (which >= OCS_HW_CB_MAX)) {
+		ocs_log_err(NULL, "bad parameter hw=%p which=%#x func=%p\n",
+			    hw, which, func);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	switch (which) {
+	case OCS_HW_CB_DOMAIN:
+		hw->callback.domain = func;
+		hw->args.domain = arg;
+		break;
+	case OCS_HW_CB_PORT:
+		hw->callback.port = func;
+		hw->args.port = arg;
+		break;
+	case OCS_HW_CB_UNSOLICITED:
+		hw->callback.unsolicited = func;
+		hw->args.unsolicited = arg;
+		break;
+	case OCS_HW_CB_REMOTE_NODE:
+		hw->callback.rnode = func;
+		hw->args.rnode = arg;
+		break;
+	case OCS_HW_CB_BOUNCE:
+		hw->callback.bounce = func;
+		hw->args.bounce = arg;
+		break;
+	default:
+		ocs_log_test(hw->os, "unknown callback %#x\n", which);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup port
+ * @brief Allocate a port object.
+ *
+ * @par Description
+ * This function allocates a VPI object for the port and stores it in the
+ * indicator field of the port object.
+ *
+ * @param hw Hardware context.
+ * @param sport SLI port object used to connect to the domain.
+ * @param domain Domain object associated with this port (may be NULL).
+ * @param wwpn Port's WWPN in big-endian order, or NULL to use default.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_port_alloc(ocs_hw_t *hw, ocs_sli_port_t *sport, ocs_domain_t *domain,
+		uint8_t *wwpn)
+{
+	uint8_t	*cmd = NULL;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint32_t index;
+
+	sport->indicator = UINT32_MAX;
+	sport->hw = hw;
+	sport->ctx.app = sport;
+	sport->sm_free_req_pending = 0;
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (wwpn) {
+		ocs_memcpy(&sport->sli_wwpn, wwpn, sizeof(sport->sli_wwpn));
+	}
+
+	if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_VPI, &sport->indicator, &index)) {
+		ocs_log_err(hw->os, "FCOE_VPI allocation failure\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (domain != NULL) {
+		ocs_sm_function_t	next = NULL;
+
+		cmd = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+		if (!cmd) {
+			ocs_log_err(hw->os, "command memory allocation failed\n");
+			rc = OCS_HW_RTN_NO_MEMORY;
+			goto ocs_hw_port_alloc_out;
+		}
+
+		/* If the WWPN is NULL, fetch the default WWPN and WWNN before
+		 * initializing the VPI
+		 */
+		if (!wwpn) {
+			next = __ocs_hw_port_alloc_read_sparm64;
+		} else {
+			next = __ocs_hw_port_alloc_init_vpi;
+		}
+
+		ocs_sm_transition(&sport->ctx, next, cmd);
+	} else if (!wwpn) {
+		/* This is the convention for the HW, not SLI */
+		ocs_log_test(hw->os, "need WWN for physical port\n");
+		rc = OCS_HW_RTN_ERROR;
+	} else {
+		/* domain NULL and wwpn non-NULL */
+		ocs_sm_transition(&sport->ctx, __ocs_hw_port_alloc_init, NULL);
+	}
+
+ocs_hw_port_alloc_out:
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_free(hw->os, cmd, SLI4_BMBX_SIZE);
+
+		sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator);
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup port
+ * @brief Attach a physical/virtual SLI port to a domain.
+ *
+ * @par Description
+ * This function registers a previously-allocated VPI with the
+ * device.
+ *
+ * @param hw Hardware context.
+ * @param sport Pointer to the SLI port object.
+ * @param fc_id Fibre Channel ID to associate with this port.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success, or an error code on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_port_attach(ocs_hw_t *hw, ocs_sli_port_t *sport, uint32_t fc_id)
+{
+	uint8_t	*buf = NULL;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	if (!hw || !sport) {
+		ocs_log_err(hw ? hw->os : NULL,
+			"bad parameter(s) hw=%p sport=%p\n", hw,
+			sport);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+	if (!buf) {
+		ocs_log_err(hw->os, "no buffer for command\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	sport->fc_id = fc_id;
+	ocs_sm_post_event(&sport->ctx, OCS_EVT_HW_PORT_REQ_ATTACH, buf);
+	return rc;
+}
+
+/**
+ * @brief Called when the port control command completes.
+ *
+ * @par Description
+ * We only need to free the mailbox command buffer.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_port_control(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	return 0;
+}
+
+/**
+ * @ingroup port
+ * @brief Control a port (initialize, shutdown, or set link configuration).
+ *
+ * @par Description
+ * This function controls a port depending on the @c ctrl parameter:
+ * - @b OCS_HW_PORT_INIT -
+ * Issues the CONFIG_LINK and INIT_LINK commands for the specified port.
+ * The HW generates an OCS_HW_DOMAIN_FOUND event when the link comes up.
+ * .
+ * - @b OCS_HW_PORT_SHUTDOWN -
+ * Issues the DOWN_LINK command for the specified port.
+ * The HW generates an OCS_HW_DOMAIN_LOST event when the link is down.
+ * .
+ * - @b OCS_HW_PORT_SET_LINK_CONFIG -
+ * Sets the link configuration.
+ *
+ * @param hw Hardware context.
+ * @param ctrl Specifies the operation:
+ * - OCS_HW_PORT_INIT
+ * - OCS_HW_PORT_SHUTDOWN
+ * - OCS_HW_PORT_SET_LINK_CONFIG
+ *
+ * @param value Operation-specific value.
+ * - OCS_HW_PORT_INIT - Selective reset AL_PA
+ * - OCS_HW_PORT_SHUTDOWN - N/A
+ * - OCS_HW_PORT_SET_LINK_CONFIG - An enum #ocs_hw_linkcfg_e value.
+ *
+ * @param cb Callback function to invoke the following operation.
+ * - OCS_HW_PORT_INIT/OCS_HW_PORT_SHUTDOWN - NULL (link events
+ * are handled by the OCS_HW_CB_DOMAIN callbacks).
+ * - OCS_HW_PORT_SET_LINK_CONFIG - Invoked after linkcfg mailbox command
+ * completes.
+ *
+ * @param arg Callback argument invoked after the command completes.
+ * - OCS_HW_PORT_INIT/OCS_HW_PORT_SHUTDOWN - NULL (link events
+ * are handled by the OCS_HW_CB_DOMAIN callbacks).
+ * - OCS_HW_PORT_SET_LINK_CONFIG - Invoked after linkcfg mailbox command
+ * completes.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_port_control(ocs_hw_t *hw, ocs_hw_port_e ctrl, uintptr_t value, ocs_hw_port_control_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+
+	switch (ctrl) {
+	case OCS_HW_PORT_INIT:
+	{
+		uint8_t	*init_link;
+		uint32_t speed = 0;
+		uint8_t reset_alpa = 0;
+
+		if (SLI_LINK_MEDIUM_FC == sli_get_medium(&hw->sli)) {
+			uint8_t	*cfg_link;
+
+			cfg_link = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+			if (cfg_link == NULL) {
+				ocs_log_err(hw->os, "no buffer for command\n");
+				return OCS_HW_RTN_NO_MEMORY;
+			}
+
+			if (sli_cmd_config_link(&hw->sli, cfg_link, SLI4_BMBX_SIZE)) {
+				rc = ocs_hw_command(hw, cfg_link, OCS_CMD_NOWAIT,
+							ocs_hw_cb_port_control, NULL);
+			}
+
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_free(hw->os, cfg_link, SLI4_BMBX_SIZE);
+				ocs_log_err(hw->os, "CONFIG_LINK failed\n");
+				break;
+			}
+			speed = hw->config.speed;
+			reset_alpa = (uint8_t)(value & 0xff);
+		} else {
+			speed = FC_LINK_SPEED_10G;
+		}
+
+		/*
+		 * Bring link up, unless FW version is not supported
+		 */
+		if (hw->workaround.fw_version_too_low) {
+			if (SLI4_IF_TYPE_LANCER_FC_ETH == hw->sli.if_type) {
+				ocs_log_err(hw->os, "Cannot bring up link.  Please update firmware to %s or later (current version is %s)\n",
+					OCS_FW_VER_STR(OCS_MIN_FW_VER_LANCER), (char *) sli_get_fw_name(&hw->sli,0));
+			} else {
+				ocs_log_err(hw->os, "Cannot bring up link.  Please update firmware to %s or later (current version is %s)\n",
+					OCS_FW_VER_STR(OCS_MIN_FW_VER_SKYHAWK), (char *) sli_get_fw_name(&hw->sli, 0));
+			}
+
+			return OCS_HW_RTN_ERROR;
+		}
+
+		rc = OCS_HW_RTN_ERROR;
+
+		/* Allocate a new buffer for the init_link command */
+		init_link = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+		if (init_link == NULL) {
+			ocs_log_err(hw->os, "no buffer for command\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+
+
+		if (sli_cmd_init_link(&hw->sli, init_link, SLI4_BMBX_SIZE, speed, reset_alpa)) {
+			rc = ocs_hw_command(hw, init_link, OCS_CMD_NOWAIT,
+						ocs_hw_cb_port_control, NULL);
+		}
+		/* Free buffer on error, since no callback is coming */
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_free(hw->os, init_link, SLI4_BMBX_SIZE);
+			ocs_log_err(hw->os, "INIT_LINK failed\n");
+		}
+		break;
+	}
+	case OCS_HW_PORT_SHUTDOWN:
+	{
+		uint8_t	*down_link;
+
+		down_link = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+		if (down_link == NULL) {
+			ocs_log_err(hw->os, "no buffer for command\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+		if (sli_cmd_down_link(&hw->sli, down_link, SLI4_BMBX_SIZE)) {
+			rc = ocs_hw_command(hw, down_link, OCS_CMD_NOWAIT,
+						ocs_hw_cb_port_control, NULL);
+		}
+		/* Free buffer on error, since no callback is coming */
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_free(hw->os, down_link, SLI4_BMBX_SIZE);
+			ocs_log_err(hw->os, "DOWN_LINK failed\n");
+		}
+		break;
+	}
+	case OCS_HW_PORT_SET_LINK_CONFIG:
+		rc = ocs_hw_set_linkcfg(hw, (ocs_hw_linkcfg_e)value, OCS_CMD_NOWAIT, cb, arg);
+		break;
+	default:
+		ocs_log_test(hw->os, "unhandled control %#x\n", ctrl);
+		break;
+	}
+
+	return rc;
+}
+
+
+/**
+ * @ingroup port
+ * @brief Free port resources.
+ *
+ * @par Description
+ * Issue the UNREG_VPI command to free the assigned VPI context.
+ *
+ * @param hw Hardware context.
+ * @param sport SLI port object used to connect to the domain.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_port_free(ocs_hw_t *hw, ocs_sli_port_t *sport)
+{
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_SUCCESS;
+
+	if (!hw || !sport) {
+		ocs_log_err(hw ? hw->os : NULL,
+			"bad parameter(s) hw=%p sport=%p\n", hw,
+			sport);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	ocs_sm_post_event(&sport->ctx, OCS_EVT_HW_PORT_REQ_FREE, NULL);
+	return rc;
+}
+
+/**
+ * @ingroup domain
+ * @brief Allocate a fabric domain object.
+ *
+ * @par Description
+ * This function starts a series of commands needed to connect to the domain, including
+ *   - REG_FCFI
+ *   - INIT_VFI
+ *   - READ_SPARMS
+ *   .
+ * @b Note: Not all SLI interface types use all of the above commands.
+ * @n @n Upon successful allocation, the HW generates a OCS_HW_DOMAIN_ALLOC_OK
+ * event. On failure, it generates a OCS_HW_DOMAIN_ALLOC_FAIL event.
+ *
+ * @param hw Hardware context.
+ * @param domain Pointer to the domain object.
+ * @param fcf FCF index.
+ * @param vlan VLAN ID.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_domain_alloc(ocs_hw_t *hw, ocs_domain_t *domain, uint32_t fcf, uint32_t vlan)
+{
+	uint8_t		*cmd = NULL;
+	uint32_t	index;
+
+	if (!hw || !domain || !domain->sport) {
+		ocs_log_err(NULL, "bad parameter(s) hw=%p domain=%p sport=%p\n",
+				hw, domain, domain ? domain->sport : NULL);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	cmd = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (!cmd) {
+		ocs_log_err(hw->os, "command memory allocation failed\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	domain->dma = hw->domain_dmem;
+
+	domain->hw = hw;
+	domain->sm.app = domain;
+	domain->fcf = fcf;
+	domain->fcf_indicator = UINT32_MAX;
+	domain->vlan_id = vlan;
+	domain->indicator = UINT32_MAX;
+
+	if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_VFI, &domain->indicator, &index)) {
+		ocs_log_err(hw->os, "FCOE_VFI allocation failure\n");
+
+		ocs_free(hw->os, cmd, SLI4_BMBX_SIZE);
+
+		return OCS_HW_RTN_ERROR;
+	}
+
+	ocs_sm_transition(&domain->sm, __ocs_hw_domain_init, cmd);
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup domain
+ * @brief Attach a SLI port to a domain.
+ *
+ * @param hw Hardware context.
+ * @param domain Pointer to the domain object.
+ * @param fc_id Fibre Channel ID to associate with this port.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_domain_attach(ocs_hw_t *hw, ocs_domain_t *domain, uint32_t fc_id)
+{
+	uint8_t	*buf = NULL;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	if (!hw || !domain) {
+		ocs_log_err(hw ? hw->os : NULL,
+			"bad parameter(s) hw=%p domain=%p\n",
+			hw, domain);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+	if (!buf) {
+		ocs_log_err(hw->os, "no buffer for command\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	domain->sport->fc_id = fc_id;
+	ocs_sm_post_event(&domain->sm, OCS_EVT_HW_DOMAIN_REQ_ATTACH, buf);
+	return rc;
+}
+
+/**
+ * @ingroup domain
+ * @brief Free a fabric domain object.
+ *
+ * @par Description
+ * Free both the driver and SLI port resources associated with the domain.
+ *
+ * @param hw Hardware context.
+ * @param domain Pointer to the domain object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_domain_free(ocs_hw_t *hw, ocs_domain_t *domain)
+{
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_SUCCESS;
+
+	if (!hw || !domain) {
+		ocs_log_err(hw ? hw->os : NULL,
+			"bad parameter(s) hw=%p domain=%p\n",
+			hw, domain);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	ocs_sm_post_event(&domain->sm, OCS_EVT_HW_DOMAIN_REQ_FREE, NULL);
+	return rc;
+}
+
+/**
+ * @ingroup domain
+ * @brief Free a fabric domain object.
+ *
+ * @par Description
+ * Free the driver resources associated with the domain. The difference between
+ * this call and ocs_hw_domain_free() is that this call assumes resources no longer
+ * exist on the SLI port, due to a reset or after some error conditions.
+ *
+ * @param hw Hardware context.
+ * @param domain Pointer to the domain object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_domain_force_free(ocs_hw_t *hw, ocs_domain_t *domain)
+{
+	if (!hw || !domain) {
+		ocs_log_err(NULL, "bad parameter(s) hw=%p domain=%p\n", hw, domain);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI, domain->indicator);
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup node
+ * @brief Allocate a remote node object.
+ *
+ * @param hw Hardware context.
+ * @param rnode Allocated remote node object to initialize.
+ * @param fc_addr FC address of the remote node.
+ * @param sport SLI port used to connect to remote node.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_node_alloc(ocs_hw_t *hw, ocs_remote_node_t *rnode, uint32_t fc_addr,
+		ocs_sli_port_t *sport)
+{
+	/* Check for invalid indicator */
+	if (UINT32_MAX != rnode->indicator) {
+		ocs_log_err(hw->os, "FCOE_RPI allocation failure addr=%#x rpi=%#x\n",
+				fc_addr, rnode->indicator);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* NULL SLI port indicates an unallocated remote node */
+	rnode->sport = NULL;
+
+	if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_RPI, &rnode->indicator, &rnode->index)) {
+		ocs_log_err(hw->os, "FCOE_RPI allocation failure addr=%#x\n",
+				fc_addr);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	rnode->fc_id = fc_addr;
+	rnode->sport = sport;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup node
+ * @brief Update a remote node object with the remote port's service parameters.
+ *
+ * @param hw Hardware context.
+ * @param rnode Allocated remote node object to initialize.
+ * @param sparms DMA buffer containing the remote port's service parameters.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_node_attach(ocs_hw_t *hw, ocs_remote_node_t *rnode, ocs_dma_t *sparms)
+{
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_ERROR;
+	uint8_t		*buf = NULL;
+	uint32_t	count = 0;
+
+	if (!hw || !rnode || !sparms) {
+		ocs_log_err(NULL, "bad parameter(s) hw=%p rnode=%p sparms=%p\n",
+			    hw, rnode, sparms);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+	if (!buf) {
+		ocs_log_err(hw->os, "no buffer for command\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/*
+	 * If the attach count is non-zero, this RPI has already been registered.
+	 * Otherwise, register the RPI
+	 */
+	if (rnode->index == UINT32_MAX) {
+		ocs_log_err(NULL, "bad parameter rnode->index invalid\n");
+		ocs_free(hw->os, buf, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_ERROR;
+	}
+	count = ocs_atomic_add_return(&hw->rpi_ref[rnode->index].rpi_count, 1);
+	if (count) {
+		/*
+		 * Can't attach multiple FC_ID's to a node unless High Login
+		 * Mode is enabled
+		 */
+		if (sli_get_hlm(&hw->sli) == FALSE) {
+			ocs_log_test(hw->os, "attach to already attached node HLM=%d count=%d\n",
+					sli_get_hlm(&hw->sli), count);
+			rc = OCS_HW_RTN_SUCCESS;
+		} else {
+			rnode->node_group = TRUE;
+			rnode->attached = ocs_atomic_read(&hw->rpi_ref[rnode->index].rpi_attached);
+			rc = rnode->attached  ? OCS_HW_RTN_SUCCESS_SYNC : OCS_HW_RTN_SUCCESS;
+		}
+	} else {
+		rnode->node_group = FALSE;
+
+		ocs_display_sparams("", "reg rpi", 0, NULL, sparms->virt);
+		if (sli_cmd_reg_rpi(&hw->sli, buf, SLI4_BMBX_SIZE, rnode->fc_id,
+					rnode->indicator, rnode->sport->indicator,
+					sparms, 0, (hw->auto_xfer_rdy_enabled && hw->config.auto_xfer_rdy_t10_enable))) {
+			rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT,
+					ocs_hw_cb_node_attach, rnode);
+		}
+	}
+
+	if (count || rc) {
+		if (rc < OCS_HW_RTN_SUCCESS) {
+			ocs_atomic_sub_return(&hw->rpi_ref[rnode->index].rpi_count, 1);
+			ocs_log_err(hw->os, "%s error\n", count ? "HLM" : "REG_RPI");
+		}
+		ocs_free(hw->os, buf, SLI4_BMBX_SIZE);
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup node
+ * @brief Free a remote node resource.
+ *
+ * @param hw Hardware context.
+ * @param rnode Remote node object to free.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_node_free_resources(ocs_hw_t *hw, ocs_remote_node_t *rnode)
+{
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_SUCCESS;
+
+	if (!hw || !rnode) {
+		ocs_log_err(NULL, "bad parameter(s) hw=%p rnode=%p\n",
+			    hw, rnode);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (rnode->sport) {
+		if (!rnode->attached) {
+			if (rnode->indicator != UINT32_MAX) {
+				if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, rnode->indicator)) {
+					ocs_log_err(hw->os, "FCOE_RPI free failure RPI %d addr=%#x\n",
+						    rnode->indicator, rnode->fc_id);
+					rc = OCS_HW_RTN_ERROR;
+				} else {
+					rnode->node_group = FALSE;
+					rnode->indicator = UINT32_MAX;
+					rnode->index = UINT32_MAX;
+					rnode->free_group = FALSE;
+				}
+			}
+		} else {
+			ocs_log_err(hw->os, "Error: rnode is still attached\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+	}
+
+	return rc;
+}
+
+
+/**
+ * @ingroup node
+ * @brief Free a remote node object.
+ *
+ * @param hw Hardware context.
+ * @param rnode Remote node object to free.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_node_detach(ocs_hw_t *hw, ocs_remote_node_t *rnode)
+{
+	uint8_t	*buf = NULL;
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_SUCCESS_SYNC;
+	uint32_t	index = UINT32_MAX;
+
+	if (!hw || !rnode) {
+		ocs_log_err(NULL, "bad parameter(s) hw=%p rnode=%p\n",
+			    hw, rnode);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	index = rnode->index;
+
+	if (rnode->sport) {
+		uint32_t	count = 0;
+		uint32_t	fc_id;
+
+		if (!rnode->attached) {
+			return OCS_HW_RTN_SUCCESS_SYNC;
+		}
+
+		buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+		if (!buf) {
+			ocs_log_err(hw->os, "no buffer for command\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+
+		count = ocs_atomic_sub_return(&hw->rpi_ref[index].rpi_count, 1);
+
+		if (count <= 1) {
+			/* There are no other references to this RPI
+			 * so unregister it and free the resource. */
+			fc_id = UINT32_MAX;
+			rnode->node_group = FALSE;
+			rnode->free_group = TRUE;
+		} else {
+			if (sli_get_hlm(&hw->sli) == FALSE) {
+				ocs_log_test(hw->os, "Invalid count with HLM disabled, count=%d\n",
+						count);
+			}
+			fc_id = rnode->fc_id & 0x00ffffff;
+		}
+
+		rc = OCS_HW_RTN_ERROR;
+
+		if (sli_cmd_unreg_rpi(&hw->sli, buf, SLI4_BMBX_SIZE, rnode->indicator,
+					SLI_RSRC_FCOE_RPI, fc_id)) {
+			rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_node_free, rnode);
+		}
+
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(hw->os, "UNREG_RPI failed\n");
+			ocs_free(hw->os, buf, SLI4_BMBX_SIZE);
+			rc = OCS_HW_RTN_ERROR;
+		}
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup node
+ * @brief Free all remote node objects.
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_node_free_all(ocs_hw_t *hw)
+{
+	uint8_t	*buf = NULL;
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_ERROR;
+
+	if (!hw) {
+		ocs_log_err(NULL, "bad parameter hw=%p\n", hw);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Check if the chip is in an error state (UE'd) before proceeding.
+	 */
+	if (sli_fw_error_status(&hw->sli) > 0) {
+		ocs_log_crit(hw->os, "Chip is in an error state - reset needed\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+	if (!buf) {
+		ocs_log_err(hw->os, "no buffer for command\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if (sli_cmd_unreg_rpi(&hw->sli, buf, SLI4_BMBX_SIZE, 0xffff,
+				SLI_RSRC_FCOE_FCFI, UINT32_MAX)) {
+		rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_node_free_all,
+				NULL);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(hw->os, "UNREG_RPI failed\n");
+		ocs_free(hw->os, buf, SLI4_BMBX_SIZE);
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	return rc;
+}
+
+ocs_hw_rtn_e
+ocs_hw_node_group_alloc(ocs_hw_t *hw, ocs_remote_node_group_t *ngroup)
+{
+
+	if (!hw || !ngroup) {
+		ocs_log_err(NULL, "bad parameter hw=%p ngroup=%p\n",
+				hw, ngroup);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_RPI, &ngroup->indicator,
+				&ngroup->index)) {
+		ocs_log_err(hw->os, "FCOE_RPI allocation failure addr=%#x\n",
+				ngroup->indicator);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+ocs_hw_rtn_e
+ocs_hw_node_group_attach(ocs_hw_t *hw, ocs_remote_node_group_t *ngroup, ocs_remote_node_t *rnode)
+{
+
+	if (!hw || !ngroup || !rnode) {
+		ocs_log_err(NULL, "bad parameter hw=%p ngroup=%p rnode=%p\n",
+			    hw, ngroup, rnode);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (rnode->attached) {
+		ocs_log_err(hw->os, "node already attached RPI=%#x addr=%#x\n",
+			    rnode->indicator, rnode->fc_id);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, rnode->indicator)) {
+		ocs_log_err(hw->os, "FCOE_RPI free failure RPI=%#x\n",
+				rnode->indicator);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	rnode->indicator = ngroup->indicator;
+	rnode->index = ngroup->index;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+ocs_hw_rtn_e
+ocs_hw_node_group_free(ocs_hw_t *hw, ocs_remote_node_group_t *ngroup)
+{
+	int	ref;
+
+	if (!hw || !ngroup) {
+		ocs_log_err(NULL, "bad parameter hw=%p ngroup=%p\n",
+				hw, ngroup);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	ref = ocs_atomic_read(&hw->rpi_ref[ngroup->index].rpi_count);
+	if (ref) {
+		/* Hmmm, the reference count is non-zero */
+		ocs_log_debug(hw->os, "node group reference=%d (RPI=%#x)\n",
+				ref, ngroup->indicator);
+
+		if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_RPI, ngroup->indicator)) {
+			ocs_log_err(hw->os, "FCOE_RPI free failure RPI=%#x\n",
+				    ngroup->indicator);
+			return OCS_HW_RTN_ERROR;
+		}
+
+		ocs_atomic_set(&hw->rpi_ref[ngroup->index].rpi_count, 0);
+	}
+
+	ngroup->indicator = UINT32_MAX;
+	ngroup->index = UINT32_MAX;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @brief Initialize IO fields on each free call.
+ *
+ * @n @b Note: This is done on each free call (as opposed to each
+ * alloc call) because port-owned XRIs are not
+ * allocated with ocs_hw_io_alloc() but are freed with this
+ * function.
+ *
+ * @param io Pointer to HW IO.
+ */
+static inline void
+ocs_hw_init_free_io(ocs_hw_io_t *io)
+{
+	/*
+	 * Set io->done to NULL, to avoid any callbacks, should
+	 * a completion be received for one of these IOs
+	 */
+	io->done = NULL;
+	io->abort_done = NULL;
+	io->status_saved = 0;
+	io->abort_in_progress = FALSE;
+	io->port_owned_abort_count = 0;
+	io->rnode = NULL;
+	io->type = 0xFFFF;
+	io->wq = NULL;
+	io->ul_io = NULL;
+	io->tgt_wqe_timeout = 0;
+}
+
+/**
+ * @ingroup io
+ * @brief Lockless allocate a HW IO object.
+ *
+ * @par Description
+ * Assume that hw->ocs_lock is held. This function is only used if
+ * use_dif_sec_xri workaround is being used.
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns a pointer to an object on success, or NULL on failure.
+ */
+static inline ocs_hw_io_t *
+_ocs_hw_io_alloc(ocs_hw_t *hw)
+{
+	ocs_hw_io_t	*io = NULL;
+
+	if (NULL != (io = ocs_list_remove_head(&hw->io_free))) {
+		ocs_list_add_tail(&hw->io_inuse, io);
+		io->state = OCS_HW_IO_STATE_INUSE;
+		io->quarantine = FALSE;
+		io->quarantine_first_phase = TRUE;
+		io->abort_reqtag = UINT32_MAX;
+		ocs_ref_init(&io->ref, ocs_hw_io_free_internal, io);
+	} else {
+		ocs_atomic_add_return(&hw->io_alloc_failed_count, 1);
+	}
+
+	return io;
+}
+/**
+ * @ingroup io
+ * @brief Allocate a HW IO object.
+ *
+ * @par Description
+ * @n @b Note: This function applies to non-port owned XRIs
+ * only.
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns a pointer to an object on success, or NULL on failure.
+ */
+ocs_hw_io_t *
+ocs_hw_io_alloc(ocs_hw_t *hw)
+{
+	ocs_hw_io_t	*io = NULL;
+
+	ocs_lock(&hw->io_lock);
+		io = _ocs_hw_io_alloc(hw);
+	ocs_unlock(&hw->io_lock);
+
+	return io;
+}
+
+/**
+ * @ingroup io
+ * @brief Allocate/Activate a port owned HW IO object.
+ *
+ * @par Description
+ * This function is called by the transport layer when an XRI is
+ * allocated by the SLI-Port. This will "activate" the HW IO
+ * associated with the XRI received from the SLI-Port to mirror
+ * the state of the XRI.
+ * @n @n @b Note: This function applies to port owned XRIs only.
+ *
+ * @param hw Hardware context.
+ * @param io Pointer HW IO to activate/allocate.
+ *
+ * @return Returns a pointer to an object on success, or NULL on failure.
+ */
+ocs_hw_io_t *
+ocs_hw_io_activate_port_owned(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	if (ocs_ref_read_count(&io->ref) > 0) {
+		ocs_log_err(hw->os, "Bad parameter: refcount > 0\n");
+		return NULL;
+	}
+
+	if (io->wq != NULL) {
+		ocs_log_err(hw->os, "XRI %x already in use\n", io->indicator);
+		return NULL;
+	}
+
+	ocs_ref_init(&io->ref, ocs_hw_io_free_port_owned, io);
+	io->xbusy = TRUE;
+
+	return io;
+}
+
+/**
+ * @ingroup io
+ * @brief When an IO is freed, depending on the exchange busy flag, and other
+ * workarounds, move it to the correct list.
+ *
+ * @par Description
+ * @n @b Note: Assumes that the hw->io_lock is held and the item has been removed
+ * from the busy or wait_free list.
+ *
+ * @param hw Hardware context.
+ * @param io Pointer to the IO object to move.
+ */
+static void
+ocs_hw_io_free_move_correct_list(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	if (io->xbusy) {
+		/* add to wait_free list and wait for XRI_ABORTED CQEs to clean up */
+		ocs_list_add_tail(&hw->io_wait_free, io);
+		io->state = OCS_HW_IO_STATE_WAIT_FREE;
+	} else {
+		/* IO not busy, add to free list */
+		ocs_list_add_tail(&hw->io_free, io);
+		io->state = OCS_HW_IO_STATE_FREE;
+	}
+
+	/* BZ 161832 workaround */
+	if (hw->workaround.use_dif_sec_xri) {
+		ocs_hw_check_sec_hio_list(hw);
+	}
+}
+
+/**
+ * @ingroup io
+ * @brief Free a HW IO object. Perform cleanup common to
+ * port and host-owned IOs.
+ *
+ * @param hw Hardware context.
+ * @param io Pointer to the HW IO object.
+ */
+static inline void
+ocs_hw_io_free_common(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	/* initialize IO fields */
+	ocs_hw_init_free_io(io);
+
+	/* Restore default SGL */
+	ocs_hw_io_restore_sgl(hw, io);
+}
+
+/**
+ * @ingroup io
+ * @brief Free a HW IO object associated with a port-owned XRI.
+ *
+ * @param arg Pointer to the HW IO object.
+ */
+static void
+ocs_hw_io_free_port_owned(void *arg)
+{
+	ocs_hw_io_t *io = (ocs_hw_io_t *)arg;
+	ocs_hw_t *hw = io->hw;
+
+	/*
+	 * For auto xfer rdy, if the dnrx bit is set, then add it to the list of XRIs
+	 * waiting for buffers.
+	 */
+	if (io->auto_xfer_rdy_dnrx) {
+		ocs_lock(&hw->io_lock);
+			/* take a reference count because we still own the IO until the buffer is posted */
+			ocs_ref_init(&io->ref, ocs_hw_io_free_port_owned, io);
+			ocs_list_add_tail(&hw->io_port_dnrx, io);
+		ocs_unlock(&hw->io_lock);
+	}
+
+	/* perform common cleanup */
+	ocs_hw_io_free_common(hw, io);
+}
+
+/**
+ * @ingroup io
+ * @brief Free a previously-allocated HW IO object. Called when
+ * IO refcount goes to zero (host-owned IOs only).
+ *
+ * @param arg Pointer to the HW IO object.
+ */
+static void
+ocs_hw_io_free_internal(void *arg)
+{
+	ocs_hw_io_t *io = (ocs_hw_io_t *)arg;
+	ocs_hw_t *hw = io->hw;
+
+	/* perform common cleanup */
+	ocs_hw_io_free_common(hw, io);
+
+	ocs_lock(&hw->io_lock);
+		/* remove from in-use list */
+		ocs_list_remove(&hw->io_inuse, io);
+		ocs_hw_io_free_move_correct_list(hw, io);
+	ocs_unlock(&hw->io_lock);
+}
+
+/**
+ * @ingroup io
+ * @brief Free a previously-allocated HW IO object.
+ *
+ * @par Description
+ * @n @b Note: This function applies to port and host owned XRIs.
+ *
+ * @param hw Hardware context.
+ * @param io Pointer to the HW IO object.
+ *
+ * @return Returns a non-zero value if HW IO was freed, 0 if references
+ * on the IO still exist, or a negative value if an error occurred.
+ */
+int32_t
+ocs_hw_io_free(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	/* just put refcount */
+	if (ocs_ref_read_count(&io->ref) <= 0) {
+		ocs_log_err(hw->os, "Bad parameter: refcount <= 0 xri=%x tag=%x\n",
+			    io->indicator, io->reqtag);
+		return -1;
+	}
+
+	return ocs_ref_put(&io->ref); /* ocs_ref_get(): ocs_hw_io_alloc() */
+}
+
+/**
+ * @ingroup io
+ * @brief Check if given HW IO is in-use
+ *
+ * @par Description
+ * This function returns TRUE if the given HW IO has been
+ * allocated and is in-use, and FALSE otherwise. It applies to
+ * port and host owned XRIs.
+ *
+ * @param hw Hardware context.
+ * @param io Pointer to the HW IO object.
+ *
+ * @return TRUE if an IO is in use, or FALSE otherwise.
+ */
+uint8_t
+ocs_hw_io_inuse(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	return (ocs_ref_read_count(&io->ref) > 0);
+}
+
+/**
+ * @brief Write a HW IO to a work queue.
+ *
+ * @par Description
+ * A HW IO is written to a work queue.
+ *
+ * @param wq Pointer to work queue.
+ * @param wqe Pointer to WQ entry.
+ *
+ * @n @b Note: Assumes the SLI-4 queue lock is held.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+static int32_t
+_hw_wq_write(hw_wq_t *wq, ocs_hw_wqe_t *wqe)
+{
+	int32_t rc;
+	int32_t queue_rc;
+
+	/* Every so often, set the wqec bit to generate comsummed completions */
+	if (wq->wqec_count) {
+		wq->wqec_count--;
+	}
+	if (wq->wqec_count == 0) {
+		sli4_generic_wqe_t *genwqe = (void*)wqe->wqebuf;
+		genwqe->wqec = 1;
+		wq->wqec_count = wq->wqec_set_count;
+	}
+
+	/* Decrement WQ free count */
+	wq->free_count--;
+
+	queue_rc = _sli_queue_write(&wq->hw->sli, wq->queue, wqe->wqebuf);
+
+	if (queue_rc < 0) {
+		rc = -1;
+	} else {
+		rc = 0;
+		ocs_queue_history_wq(&wq->hw->q_hist, (void *) wqe->wqebuf, wq->queue->id, queue_rc);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Write a HW IO to a work queue.
+ *
+ * @par Description
+ * A HW IO is written to a work queue.
+ *
+ * @param wq Pointer to work queue.
+ * @param wqe Pointer to WQE entry.
+ *
+ * @n @b Note: Takes the SLI-4 queue lock.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+hw_wq_write(hw_wq_t *wq, ocs_hw_wqe_t *wqe)
+{
+	int32_t rc = 0;
+
+	sli_queue_lock(wq->queue);
+		if ( ! ocs_list_empty(&wq->pending_list)) {
+			ocs_list_add_tail(&wq->pending_list, wqe);
+			OCS_STAT(wq->wq_pending_count++;)
+			while ((wq->free_count > 0) && ((wqe = ocs_list_remove_head(&wq->pending_list)) != NULL)) {
+				rc = _hw_wq_write(wq, wqe);
+				if (rc < 0) {
+					break;
+				}
+				if (wqe->abort_wqe_submit_needed) {
+					wqe->abort_wqe_submit_needed = 0;
+					sli_abort_wqe(&wq->hw->sli, wqe->wqebuf, wq->hw->sli.config.wqe_size, SLI_ABORT_XRI, 
+							wqe->send_abts, wqe->id, 0, wqe->abort_reqtag, SLI4_CQ_DEFAULT );
+					ocs_list_add_tail(&wq->pending_list, wqe);
+					OCS_STAT(wq->wq_pending_count++;)
+				}
+			}
+		} else {
+			if (wq->free_count > 0) {
+				rc = _hw_wq_write(wq, wqe);
+			} else {
+				ocs_list_add_tail(&wq->pending_list, wqe);
+				OCS_STAT(wq->wq_pending_count++;)
+			}
+		}
+
+	sli_queue_unlock(wq->queue);
+
+	return rc;
+
+}
+
+/**
+ * @brief Update free count and submit any pending HW IOs
+ *
+ * @par Description
+ * The WQ free count is updated, and any pending HW IOs are submitted that
+ * will fit in the queue.
+ *
+ * @param wq Pointer to work queue.
+ * @param update_free_count Value added to WQs free count.
+ *
+ * @return None.
+ */
+static void
+hw_wq_submit_pending(hw_wq_t *wq, uint32_t update_free_count)
+{
+	ocs_hw_wqe_t *wqe;
+
+	sli_queue_lock(wq->queue);
+
+		/* Update free count with value passed in */
+		wq->free_count += update_free_count;
+
+		while ((wq->free_count > 0) && ((wqe = ocs_list_remove_head(&wq->pending_list)) != NULL)) {
+			_hw_wq_write(wq, wqe);
+
+			if (wqe->abort_wqe_submit_needed) {
+				wqe->abort_wqe_submit_needed = 0;
+				sli_abort_wqe(&wq->hw->sli, wqe->wqebuf, wq->hw->sli.config.wqe_size, SLI_ABORT_XRI, 
+						wqe->send_abts, wqe->id, 0, wqe->abort_reqtag, SLI4_CQ_DEFAULT);
+				ocs_list_add_tail(&wq->pending_list, wqe);
+				OCS_STAT(wq->wq_pending_count++;)
+			}
+		}
+
+	sli_queue_unlock(wq->queue);
+}
+
+/**
+ * @brief Check to see if there are any BZ 161832 workaround waiting IOs
+ *
+ * @par Description
+ * Checks hw->sec_hio_wait_list, if an IO is waiting for a HW IO, then try
+ * to allocate a secondary HW io, and dispatch it.
+ *
+ * @n @b Note: hw->io_lock MUST be taken when called.
+ *
+ * @param hw pointer to HW object
+ *
+ * @return none
+ */
+static void
+ocs_hw_check_sec_hio_list(ocs_hw_t *hw)
+{
+	ocs_hw_io_t *io;
+	ocs_hw_io_t *sec_io;
+	int rc = 0;
+
+	while (!ocs_list_empty(&hw->sec_hio_wait_list)) {
+		uint16_t flags;
+
+		sec_io = _ocs_hw_io_alloc(hw);
+		if (sec_io == NULL) {
+			break;
+		}
+
+		io = ocs_list_remove_head(&hw->sec_hio_wait_list);
+		ocs_list_add_tail(&hw->io_inuse, io);
+		io->state = OCS_HW_IO_STATE_INUSE;
+		io->sec_hio = sec_io;
+
+		/* mark secondary XRI for second and subsequent data phase as quarantine */
+		if (io->xbusy) {
+			sec_io->quarantine = TRUE;
+		}
+
+		flags = io->sec_iparam.fcp_tgt.flags;
+		if (io->xbusy) {
+			flags |= SLI4_IO_CONTINUATION;
+		} else {
+			flags &= ~SLI4_IO_CONTINUATION;
+		}
+
+		io->tgt_wqe_timeout = io->sec_iparam.fcp_tgt.timeout;
+
+		/* Complete (continue) TRECV IO */
+		if (io->xbusy) {
+			if (sli_fcp_cont_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl,
+				io->first_data_sge,
+				io->sec_iparam.fcp_tgt.offset, io->sec_len, io->indicator, io->sec_hio->indicator,
+				io->reqtag, SLI4_CQ_DEFAULT,
+				io->sec_iparam.fcp_tgt.ox_id, io->rnode->indicator, io->rnode,
+				flags,
+				io->sec_iparam.fcp_tgt.dif_oper, io->sec_iparam.fcp_tgt.blk_size, io->sec_iparam.fcp_tgt.cs_ctl, io->sec_iparam.fcp_tgt.app_id)) {
+					ocs_log_test(hw->os, "TRECEIVE WQE error\n");
+					break;
+			}
+		} else {
+			if (sli_fcp_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl,
+				io->first_data_sge,
+				io->sec_iparam.fcp_tgt.offset, io->sec_len, io->indicator,
+				io->reqtag, SLI4_CQ_DEFAULT,
+				io->sec_iparam.fcp_tgt.ox_id, io->rnode->indicator, io->rnode,
+				flags,
+				io->sec_iparam.fcp_tgt.dif_oper, io->sec_iparam.fcp_tgt.blk_size,
+				io->sec_iparam.fcp_tgt.cs_ctl, io->sec_iparam.fcp_tgt.app_id)) {
+					ocs_log_test(hw->os, "TRECEIVE WQE error\n");
+					break;
+			}
+		}
+
+		if (io->wq == NULL) {
+			io->wq = ocs_hw_queue_next_wq(hw, io);
+			ocs_hw_assert(io->wq != NULL);
+		}
+		io->xbusy = TRUE;
+
+		/*
+		 * Add IO to active io wqe list before submitting, in case the
+		 * wcqe processing preempts this thread.
+		 */
+		ocs_hw_add_io_timed_wqe(hw, io);
+		rc = hw_wq_write(io->wq, &io->wqe);
+		if (rc >= 0) {
+			/* non-negative return is success */
+			rc = 0;
+		} else {
+			/* failed to write wqe, remove from active wqe list */
+			ocs_log_err(hw->os, "sli_queue_write failed: %d\n", rc);
+			io->xbusy = FALSE;
+			ocs_hw_remove_io_timed_wqe(hw, io);
+		}
+	}
+}
+
+/**
+ * @ingroup io
+ * @brief Send a Single Request/Response Sequence (SRRS).
+ *
+ * @par Description
+ * This routine supports communication sequences consisting of a single
+ * request and single response between two endpoints. Examples include:
+ *  - Sending an ELS request.
+ *  - Sending an ELS response - To send an ELS reponse, the caller must provide
+ * the OX_ID from the received request.
+ *  - Sending a FC Common Transport (FC-CT) request - To send a FC-CT request,
+ * the caller must provide the R_CTL, TYPE, and DF_CTL
+ * values to place in the FC frame header.
+ *  .
+ * @n @b Note: The caller is expected to provide both send and receive
+ * buffers for requests. In the case of sending a response, no receive buffer
+ * is necessary and the caller may pass in a NULL pointer.
+ *
+ * @param hw Hardware context.
+ * @param type Type of sequence (ELS request/response, FC-CT).
+ * @param io Previously-allocated HW IO object.
+ * @param send DMA memory holding data to send (for example, ELS request, BLS response).
+ * @param len Length, in bytes, of data to send.
+ * @param receive Optional DMA memory to hold a response.
+ * @param rnode Destination of data (that is, a remote node).
+ * @param iparam IO parameters (ELS response and FC-CT).
+ * @param cb Function call upon completion of sending the data (may be NULL).
+ * @param arg Argument to pass to IO completion function.
+ *
+ * @return Returns 0 on success, or a non-zero on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_srrs_send(ocs_hw_t *hw, ocs_hw_io_type_e type, ocs_hw_io_t *io,
+		  ocs_dma_t *send, uint32_t len, ocs_dma_t *receive,
+		  ocs_remote_node_t *rnode, ocs_hw_io_param_t *iparam,
+		  ocs_hw_srrs_cb_t cb, void *arg)
+{
+	sli4_sge_t	*sge = NULL;
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_SUCCESS;
+	uint16_t	local_flags = 0;
+
+	if (!hw || !io || !rnode || !iparam) {
+		ocs_log_err(NULL, "bad parm hw=%p io=%p send=%p receive=%p rnode=%p iparam=%p\n",
+			    hw, io, send, receive, rnode, iparam);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->state != OCS_HW_STATE_ACTIVE) {
+		ocs_log_test(hw->os, "cannot send SRRS, HW state=%d\n", hw->state);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (ocs_hw_is_xri_port_owned(hw, io->indicator)) {
+		/* We must set the XC bit for port owned XRIs */
+		local_flags |= SLI4_IO_CONTINUATION;
+	}
+	io->rnode = rnode;
+	io->type  = type;
+	io->done = cb;
+	io->arg  = arg;
+
+	sge = io->sgl->virt;
+
+	/* clear both SGE */
+	ocs_memset(io->sgl->virt, 0, 2 * sizeof(sli4_sge_t));
+
+	if (send) {
+		sge[0].buffer_address_high = ocs_addr32_hi(send->phys);
+		sge[0].buffer_address_low  = ocs_addr32_lo(send->phys);
+		sge[0].sge_type = SLI4_SGE_TYPE_DATA;
+		sge[0].buffer_length = len;
+	}
+
+	if ((OCS_HW_ELS_REQ == type) || (OCS_HW_FC_CT == type)) {
+		sge[1].buffer_address_high = ocs_addr32_hi(receive->phys);
+		sge[1].buffer_address_low  = ocs_addr32_lo(receive->phys);
+		sge[1].sge_type = SLI4_SGE_TYPE_DATA;
+		sge[1].buffer_length = receive->size;
+		sge[1].last = TRUE;
+	} else {
+		sge[0].last = TRUE;
+	}
+
+	switch (type) {
+	case OCS_HW_ELS_REQ:
+		if ( (!send) || sli_els_request64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->sgl,
+							*((uint8_t *)(send->virt)), /* req_type */
+							len, receive->size,
+							iparam->els.timeout, io->indicator, io->reqtag, SLI4_CQ_DEFAULT, rnode)) {
+			ocs_log_err(hw->os, "REQ WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_ELS_RSP:
+		if ( (!send) || sli_xmit_els_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, send, len,
+					   io->indicator, io->reqtag, SLI4_CQ_DEFAULT,
+					   iparam->els.ox_id,
+							rnode, local_flags, UINT32_MAX)) {
+			ocs_log_err(hw->os, "RSP WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_ELS_RSP_SID:
+		if ( (!send) || sli_xmit_els_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, send, len,
+					   io->indicator, io->reqtag, SLI4_CQ_DEFAULT,
+					   iparam->els_sid.ox_id,
+							rnode, local_flags, iparam->els_sid.s_id)) {
+			ocs_log_err(hw->os, "RSP (SID) WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_FC_CT:
+		if ( (!send) || sli_gen_request64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->sgl, len,
+					  receive->size, iparam->fc_ct.timeout, io->indicator,
+					  io->reqtag, SLI4_CQ_DEFAULT, rnode, iparam->fc_ct.r_ctl,
+					  iparam->fc_ct.type, iparam->fc_ct.df_ctl)) {
+			ocs_log_err(hw->os, "GEN WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_FC_CT_RSP:
+		if ( (!send) || sli_xmit_sequence64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->sgl, len,
+					  iparam->fc_ct_rsp.timeout, iparam->fc_ct_rsp.ox_id, io->indicator,
+					  io->reqtag, rnode, iparam->fc_ct_rsp.r_ctl,
+					  iparam->fc_ct_rsp.type, iparam->fc_ct_rsp.df_ctl)) {
+			ocs_log_err(hw->os, "XMIT SEQ WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_BLS_ACC:
+	case OCS_HW_BLS_RJT:
+	{
+		sli_bls_payload_t	bls;
+
+		if (OCS_HW_BLS_ACC == type) {
+			bls.type = SLI_BLS_ACC;
+			ocs_memcpy(&bls.u.acc, iparam->bls.payload, sizeof(bls.u.acc));
+		} else {
+			bls.type = SLI_BLS_RJT;
+			ocs_memcpy(&bls.u.rjt, iparam->bls.payload, sizeof(bls.u.rjt));
+		}
+
+		bls.ox_id = iparam->bls.ox_id;
+		bls.rx_id = iparam->bls.rx_id;
+
+		if (sli_xmit_bls_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &bls,
+					   io->indicator, io->reqtag,
+					   SLI4_CQ_DEFAULT,
+					   rnode, UINT32_MAX)) {
+			ocs_log_err(hw->os, "XMIT_BLS_RSP64 WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	}
+	case OCS_HW_BLS_ACC_SID:
+	{
+		sli_bls_payload_t	bls;
+
+		bls.type = SLI_BLS_ACC;
+		ocs_memcpy(&bls.u.acc, iparam->bls_sid.payload, sizeof(bls.u.acc));
+
+		bls.ox_id = iparam->bls_sid.ox_id;
+		bls.rx_id = iparam->bls_sid.rx_id;
+
+		if (sli_xmit_bls_rsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &bls,
+					   io->indicator, io->reqtag,
+					   SLI4_CQ_DEFAULT,
+					   rnode, iparam->bls_sid.s_id)) {
+			ocs_log_err(hw->os, "XMIT_BLS_RSP64 WQE SID error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	}
+	case OCS_HW_BCAST:
+		if ( (!send) || sli_xmit_bcast64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, send, len,
+					iparam->bcast.timeout, io->indicator, io->reqtag,
+					SLI4_CQ_DEFAULT, rnode,
+					iparam->bcast.r_ctl, iparam->bcast.type, iparam->bcast.df_ctl)) {
+			ocs_log_err(hw->os, "XMIT_BCAST64 WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	default:
+		ocs_log_err(hw->os, "bad SRRS type %#x\n", type);
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	if (OCS_HW_RTN_SUCCESS == rc) {
+		if (io->wq == NULL) {
+			io->wq = ocs_hw_queue_next_wq(hw, io);
+			ocs_hw_assert(io->wq != NULL);
+		}
+		io->xbusy = TRUE;
+
+		/*
+		 * Add IO to active io wqe list before submitting, in case the
+		 * wcqe processing preempts this thread.
+		 */
+		OCS_STAT(io->wq->use_count++);
+		ocs_hw_add_io_timed_wqe(hw, io);
+		rc = hw_wq_write(io->wq, &io->wqe);
+		if (rc >= 0) {
+			/* non-negative return is success */
+			rc = 0;
+		} else {
+			/* failed to write wqe, remove from active wqe list */
+			ocs_log_err(hw->os, "sli_queue_write failed: %d\n", rc);
+			io->xbusy = FALSE;
+			ocs_hw_remove_io_timed_wqe(hw, io);
+		}
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup io
+ * @brief Send a read, write, or response IO.
+ *
+ * @par Description
+ * This routine supports sending a higher-level IO (for example, FCP) between two endpoints
+ * as a target or initiator. Examples include:
+ *  - Sending read data and good response (target).
+ *  - Sending a response (target with no data or after receiving write data).
+ *  .
+ * This routine assumes all IOs use the SGL associated with the HW IO. Prior to
+ * calling this routine, the data should be loaded using ocs_hw_io_add_sge().
+ *
+ * @param hw Hardware context.
+ * @param type Type of IO (target read, target response, and so on).
+ * @param io Previously-allocated HW IO object.
+ * @param len Length, in bytes, of data to send.
+ * @param iparam IO parameters.
+ * @param rnode Destination of data (that is, a remote node).
+ * @param cb Function call upon completion of sending data (may be NULL).
+ * @param arg Argument to pass to IO completion function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ *
+ * @todo
+ *  - Support specifiying relative offset.
+ *  - Use a WQ other than 0.
+ */
+ocs_hw_rtn_e
+ocs_hw_io_send(ocs_hw_t *hw, ocs_hw_io_type_e type, ocs_hw_io_t *io,
+		uint32_t len, ocs_hw_io_param_t *iparam, ocs_remote_node_t *rnode,
+		void *cb, void *arg)
+{
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_SUCCESS;
+	uint32_t	rpi;
+	uint8_t		send_wqe = TRUE;
+
+	CPUTRACE("");
+
+	if (!hw || !io || !rnode || !iparam) {
+		ocs_log_err(NULL, "bad parm hw=%p io=%p iparam=%p rnode=%p\n",
+			    hw, io, iparam, rnode);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->state != OCS_HW_STATE_ACTIVE) {
+		ocs_log_err(hw->os, "cannot send IO, HW state=%d\n", hw->state);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	rpi = rnode->indicator;
+
+	if (hw->workaround.use_unregistered_rpi && (rpi == UINT32_MAX)) {
+		rpi = hw->workaround.unregistered_rid;
+		ocs_log_test(hw->os, "using unregistered RPI: %d\n", rpi);
+	}
+
+	/*
+	 * Save state needed during later stages
+	 */
+	io->rnode = rnode;
+	io->type  = type;
+	io->done  = cb;
+	io->arg   = arg;
+
+	/*
+	 * Format the work queue entry used to send the IO
+	 */
+	switch (type) {
+	case OCS_HW_IO_INITIATOR_READ:
+		/*
+		 * If use_dif_quarantine workaround is in effect, and dif_separates then mark the
+		 * initiator read IO for quarantine
+		 */
+		if (hw->workaround.use_dif_quarantine && (hw->config.dif_mode == OCS_HW_DIF_MODE_SEPARATE) &&
+		    (iparam->fcp_tgt.dif_oper != OCS_HW_DIF_OPER_DISABLED)) {
+			io->quarantine = TRUE;
+		}
+
+		ocs_hw_io_ini_sge(hw, io, iparam->fcp_ini.cmnd, iparam->fcp_ini.cmnd_size,
+				iparam->fcp_ini.rsp);
+
+		if (sli_fcp_iread64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge, len,
+					io->indicator, io->reqtag, SLI4_CQ_DEFAULT, rpi, rnode,
+					iparam->fcp_ini.dif_oper, iparam->fcp_ini.blk_size,
+					iparam->fcp_ini.timeout)) {
+			ocs_log_err(hw->os, "IREAD WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_IO_INITIATOR_WRITE:
+		ocs_hw_io_ini_sge(hw, io, iparam->fcp_ini.cmnd, iparam->fcp_ini.cmnd_size,
+				iparam->fcp_ini.rsp);
+
+		if (sli_fcp_iwrite64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge,
+					 len, iparam->fcp_ini.first_burst,
+					 io->indicator, io->reqtag,
+					SLI4_CQ_DEFAULT, rpi, rnode,
+					iparam->fcp_ini.dif_oper, iparam->fcp_ini.blk_size,
+					iparam->fcp_ini.timeout)) {
+			ocs_log_err(hw->os, "IWRITE WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_IO_INITIATOR_NODATA:
+		ocs_hw_io_ini_sge(hw, io, iparam->fcp_ini.cmnd, iparam->fcp_ini.cmnd_size,
+				iparam->fcp_ini.rsp);
+
+		if (sli_fcp_icmnd64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl,
+					io->indicator, io->reqtag, SLI4_CQ_DEFAULT,
+					rpi, rnode, iparam->fcp_ini.timeout)) {
+			ocs_log_err(hw->os, "ICMND WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+		break;
+	case OCS_HW_IO_TARGET_WRITE: {
+		uint16_t flags = iparam->fcp_tgt.flags;
+		fcp_xfer_rdy_iu_t *xfer = io->xfer_rdy.virt;
+
+		/*
+		 * Fill in the XFER_RDY for IF_TYPE 0 devices
+		 */
+		*((uint32_t *)xfer->fcp_data_ro) = ocs_htobe32(iparam->fcp_tgt.offset);
+		*((uint32_t *)xfer->fcp_burst_len) = ocs_htobe32(len);
+		*((uint32_t *)xfer->rsvd) = 0;
+
+		if (io->xbusy) {
+			flags |= SLI4_IO_CONTINUATION;
+		} else {
+			flags &= ~SLI4_IO_CONTINUATION;
+		}
+
+		io->tgt_wqe_timeout = iparam->fcp_tgt.timeout;
+
+		/*
+		 * If use_dif_quarantine workaround is in effect, and this is a DIF enabled IO
+		 * then mark the target write IO for quarantine
+		 */
+		if (hw->workaround.use_dif_quarantine && (hw->config.dif_mode == OCS_HW_DIF_MODE_SEPARATE) &&
+		    (iparam->fcp_tgt.dif_oper != OCS_HW_DIF_OPER_DISABLED)) {
+			io->quarantine = TRUE;
+		}
+
+		/*
+		 * BZ 161832 Workaround:
+		 * Check for use_dif_sec_xri workaround.  Note, even though the first dataphase
+		 * doesn't really need a secondary XRI, we allocate one anyway, as this avoids the
+		 * potential for deadlock where all XRI's are allocated as primaries to IOs that
+		 * are on hw->sec_hio_wait_list.   If this secondary XRI is not for the first
+		 * data phase, it is marked for quarantine.
+		 */
+		if (hw->workaround.use_dif_sec_xri && (iparam->fcp_tgt.dif_oper != OCS_HW_DIF_OPER_DISABLED)) {
+
+			/*
+			 * If we have allocated a chained SGL for skyhawk, then
+			 * we can re-use this for the sec_hio.
+			 */
+			if (io->ovfl_io != NULL) {
+				io->sec_hio = io->ovfl_io;
+				io->sec_hio->quarantine = TRUE;
+			} else {
+				io->sec_hio = ocs_hw_io_alloc(hw);
+			}
+			if (io->sec_hio == NULL) {
+				/* Failed to allocate, so save full request context and put
+				 * this IO on the wait list
+				 */
+				io->sec_iparam = *iparam;
+				io->sec_len = len;
+				ocs_lock(&hw->io_lock);
+					ocs_list_remove(&hw->io_inuse,  io);
+					ocs_list_add_tail(&hw->sec_hio_wait_list, io);
+					io->state = OCS_HW_IO_STATE_WAIT_SEC_HIO;
+					hw->sec_hio_wait_count++;
+				ocs_unlock(&hw->io_lock);
+				send_wqe = FALSE;
+				/* Done */
+				break;
+			}
+			/* We quarantine the secondary IO if this is the second or subsequent data phase */
+			if (io->xbusy) {
+				io->sec_hio->quarantine = TRUE;
+			}
+		}
+
+		/*
+		 * If not the first data phase, and io->sec_hio has been allocated, then issue
+		 * FCP_CONT_TRECEIVE64 WQE, otherwise use the usual FCP_TRECEIVE64 WQE
+		 */
+		if (io->xbusy && (io->sec_hio != NULL)) {
+			if (sli_fcp_cont_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge,
+						   iparam->fcp_tgt.offset, len, io->indicator, io->sec_hio->indicator,
+						   io->reqtag, SLI4_CQ_DEFAULT,
+						   iparam->fcp_tgt.ox_id, rpi, rnode,
+						   flags,
+						   iparam->fcp_tgt.dif_oper, iparam->fcp_tgt.blk_size,
+						   iparam->fcp_tgt.cs_ctl, iparam->fcp_tgt.app_id)) {
+				ocs_log_err(hw->os, "TRECEIVE WQE error\n");
+				rc = OCS_HW_RTN_ERROR;
+			}
+		} else {
+			if (sli_fcp_treceive64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge,
+						   iparam->fcp_tgt.offset, len, io->indicator, io->reqtag,
+						   SLI4_CQ_DEFAULT,
+						   iparam->fcp_tgt.ox_id, rpi, rnode,
+						   flags,
+						   iparam->fcp_tgt.dif_oper, iparam->fcp_tgt.blk_size,
+						   iparam->fcp_tgt.cs_ctl, iparam->fcp_tgt.app_id)) {
+				ocs_log_err(hw->os, "TRECEIVE WQE error\n");
+				rc = OCS_HW_RTN_ERROR;
+			}
+		}
+		break;
+	}
+	case OCS_HW_IO_TARGET_READ: {
+		uint16_t flags = iparam->fcp_tgt.flags;
+
+		if (io->xbusy) {
+			flags |= SLI4_IO_CONTINUATION;
+		} else {
+			flags &= ~SLI4_IO_CONTINUATION;
+		}
+
+		io->tgt_wqe_timeout = iparam->fcp_tgt.timeout;
+		if (sli_fcp_tsend64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, &io->def_sgl, io->first_data_sge,
+					iparam->fcp_tgt.offset, len, io->indicator, io->reqtag,
+					SLI4_CQ_DEFAULT,
+					iparam->fcp_tgt.ox_id, rpi, rnode,
+					flags,
+					iparam->fcp_tgt.dif_oper,
+					iparam->fcp_tgt.blk_size,
+					iparam->fcp_tgt.cs_ctl,
+					iparam->fcp_tgt.app_id)) {
+			ocs_log_err(hw->os, "TSEND WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		} else if (hw->workaround.retain_tsend_io_length) {
+			io->length = len;
+		}
+		break;
+	}
+	case OCS_HW_IO_TARGET_RSP: {
+		uint16_t flags = iparam->fcp_tgt.flags;
+
+		if (io->xbusy) {
+			flags |= SLI4_IO_CONTINUATION;
+		} else {
+			flags &= ~SLI4_IO_CONTINUATION;
+		}
+
+		/* post a new auto xfer ready buffer */
+		if (hw->auto_xfer_rdy_enabled && io->is_port_owned) {
+			if ((io->auto_xfer_rdy_dnrx = ocs_hw_rqpair_auto_xfer_rdy_buffer_post(hw, io, 1))) {
+				flags |= SLI4_IO_DNRX;
+			}
+		}
+
+		io->tgt_wqe_timeout = iparam->fcp_tgt.timeout;
+		if (sli_fcp_trsp64_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size,
+					&io->def_sgl,
+					len,
+					io->indicator, io->reqtag,
+					SLI4_CQ_DEFAULT,
+					iparam->fcp_tgt.ox_id,
+					rpi, rnode,
+					flags, iparam->fcp_tgt.cs_ctl,
+					io->is_port_owned,
+					iparam->fcp_tgt.app_id)) {
+			ocs_log_err(hw->os, "TRSP WQE error\n");
+			rc = OCS_HW_RTN_ERROR;
+		}
+
+		break;
+	}
+	default:
+		ocs_log_err(hw->os, "unsupported IO type %#x\n", type);
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	if (send_wqe && (OCS_HW_RTN_SUCCESS == rc)) {
+		if (io->wq == NULL) {
+			io->wq = ocs_hw_queue_next_wq(hw, io);
+			ocs_hw_assert(io->wq != NULL);
+		}
+
+		io->xbusy = TRUE;
+
+		/*
+		 * Add IO to active io wqe list before submitting, in case the
+		 * wcqe processing preempts this thread.
+		 */
+		OCS_STAT(hw->tcmd_wq_submit[io->wq->instance]++);
+		OCS_STAT(io->wq->use_count++);
+		ocs_hw_add_io_timed_wqe(hw, io);
+		rc = hw_wq_write(io->wq, &io->wqe);
+		if (rc >= 0) {
+			/* non-negative return is success */
+			rc = 0;
+		} else {
+			/* failed to write wqe, remove from active wqe list */
+			ocs_log_err(hw->os, "sli_queue_write failed: %d\n", rc);
+			io->xbusy = FALSE;
+			ocs_hw_remove_io_timed_wqe(hw, io);
+		}
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Send a raw frame
+ *
+ * @par Description
+ * Using the SEND_FRAME_WQE, a frame consisting of header and payload is sent.
+ *
+ * @param hw Pointer to HW object.
+ * @param hdr Pointer to a little endian formatted FC header.
+ * @param sof Value to use as the frame SOF.
+ * @param eof Value to use as the frame EOF.
+ * @param payload Pointer to payload DMA buffer.
+ * @param ctx Pointer to caller provided send frame context.
+ * @param callback Callback function.
+ * @param arg Callback function argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_send_frame(ocs_hw_t *hw, fc_header_le_t *hdr, uint8_t sof, uint8_t eof, ocs_dma_t *payload,
+		   ocs_hw_send_frame_context_t *ctx, void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg)
+{
+	int32_t rc;
+	ocs_hw_wqe_t *wqe;
+	uint32_t xri;
+	hw_wq_t *wq;
+
+	wqe = &ctx->wqe;
+
+	/* populate the callback object */
+	ctx->hw = hw;
+
+	/* Fetch and populate request tag */
+	ctx->wqcb = ocs_hw_reqtag_alloc(hw, callback, arg);
+	if (ctx->wqcb == NULL) {
+		ocs_log_err(hw->os, "can't allocate request tag\n");
+		return OCS_HW_RTN_NO_RESOURCES;
+	}
+
+	/* Choose a work queue, first look for a class[1] wq, otherwise just use wq[0] */
+	wq = ocs_varray_iter_next(hw->wq_class_array[1]);
+	if (wq == NULL) {
+		wq = hw->hw_wq[0];
+	}
+
+	/* Set XRI and RX_ID in the header based on which WQ, and which send_frame_io we are using */
+	xri = wq->send_frame_io->indicator;
+
+	/* Build the send frame WQE */
+	rc = sli_send_frame_wqe(&hw->sli, wqe->wqebuf, hw->sli.config.wqe_size, sof, eof, (uint32_t*) hdr, payload,
+				payload->len, OCS_HW_SEND_FRAME_TIMEOUT, xri, ctx->wqcb->instance_index);
+	if (rc) {
+		ocs_log_err(hw->os, "sli_send_frame_wqe failed: %d\n", rc);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* Write to WQ */
+	rc = hw_wq_write(wq, wqe);
+	if (rc) {
+		ocs_log_err(hw->os, "hw_wq_write failed: %d\n", rc);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	OCS_STAT(wq->use_count++);
+
+	return rc ? OCS_HW_RTN_ERROR : OCS_HW_RTN_SUCCESS;
+}
+
+ocs_hw_rtn_e
+ocs_hw_io_register_sgl(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_dma_t *sgl, uint32_t sgl_count)
+{
+	if (sli_get_sgl_preregister(&hw->sli)) {
+		ocs_log_err(hw->os, "can't use temporary SGL with pre-registered SGLs\n");
+		return OCS_HW_RTN_ERROR;
+	}
+	io->ovfl_sgl = sgl;
+	io->ovfl_sgl_count = sgl_count;
+	io->ovfl_io = NULL;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+static void
+ocs_hw_io_restore_sgl(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	/* Restore the default */
+	io->sgl = &io->def_sgl;
+	io->sgl_count = io->def_sgl_count;
+
+	/*
+	 * For skyhawk, we need to free the IO allocated for the chained
+	 * SGL. For all devices, clear the overflow fields on the IO.
+	 *
+	 * Note: For DIF IOs, we may be using the same XRI for the sec_hio and
+	 *       the chained SGLs. If so, then we clear the ovfl_io field
+	 *       when the sec_hio is freed.
+	 */
+	if (io->ovfl_io != NULL) {
+		ocs_hw_io_free(hw, io->ovfl_io);
+		io->ovfl_io = NULL;
+	}
+
+	/* Clear the overflow SGL */
+	io->ovfl_sgl = NULL;
+	io->ovfl_sgl_count = 0;
+	io->ovfl_lsp = NULL;
+}
+
+/**
+ * @ingroup io
+ * @brief Initialize the scatter gather list entries of an IO.
+ *
+ * @param hw Hardware context.
+ * @param io Previously-allocated HW IO object.
+ * @param type Type of IO (target read, target response, and so on).
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_io_init_sges(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_io_type_e type)
+{
+	sli4_sge_t	*data = NULL;
+	uint32_t	i = 0;
+	uint32_t	skips = 0;
+
+	if (!hw || !io) {
+		ocs_log_err(hw ? hw->os : NULL, "bad parameter hw=%p io=%p\n",
+			    hw, io);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* Clear / reset the scatter-gather list */
+	io->sgl = &io->def_sgl;
+	io->sgl_count = io->def_sgl_count;
+	io->first_data_sge = 0;
+
+	ocs_memset(io->sgl->virt, 0, 2 * sizeof(sli4_sge_t));
+	io->n_sge = 0;
+	io->sge_offset = 0;
+
+	io->type = type;
+
+	data = io->sgl->virt;
+
+	/*
+	 * Some IO types have underlying hardware requirements on the order
+	 * of SGEs. Process all special entries here.
+	 */
+	switch (type) {
+	case OCS_HW_IO_INITIATOR_READ:
+	case OCS_HW_IO_INITIATOR_WRITE:
+	case OCS_HW_IO_INITIATOR_NODATA:
+		/*
+		 * No skips, 2 special for initiator I/Os
+		 * The addresses and length are written later
+		 */
+		/* setup command pointer */
+		data->sge_type = SLI4_SGE_TYPE_DATA;
+		data++;
+
+		/* setup response pointer */
+		data->sge_type = SLI4_SGE_TYPE_DATA;
+
+		if (OCS_HW_IO_INITIATOR_NODATA == type) {
+			data->last = TRUE;
+		}
+		data++;
+
+		io->n_sge = 2;
+		break;
+	case OCS_HW_IO_TARGET_WRITE:
+#define OCS_TARGET_WRITE_SKIPS	2
+		skips = OCS_TARGET_WRITE_SKIPS;
+
+		/* populate host resident XFER_RDY buffer */
+		data->sge_type = SLI4_SGE_TYPE_DATA;
+		data->buffer_address_high = ocs_addr32_hi(io->xfer_rdy.phys);
+		data->buffer_address_low  = ocs_addr32_lo(io->xfer_rdy.phys);
+		data->buffer_length = io->xfer_rdy.size;
+		data++;
+
+		skips--;
+
+		io->n_sge = 1;
+		break;
+	case OCS_HW_IO_TARGET_READ:
+		/*
+		 * For FCP_TSEND64, the first 2 entries are SKIP SGE's
+		 */
+#define OCS_TARGET_READ_SKIPS	2
+		skips = OCS_TARGET_READ_SKIPS;
+		break;
+	case OCS_HW_IO_TARGET_RSP:
+		/*
+		 * No skips, etc. for FCP_TRSP64
+		 */
+		break;
+	default:
+		ocs_log_err(hw->os, "unsupported IO type %#x\n", type);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Write skip entries
+	 */
+	for (i = 0; i < skips; i++) {
+		data->sge_type = SLI4_SGE_TYPE_SKIP;
+		data++;
+	}
+
+	io->n_sge += skips;
+
+	/*
+	 * Set last
+	 */
+	data->last = TRUE;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup io
+ * @brief Add a T10 PI seed scatter gather list entry.
+ *
+ * @param hw Hardware context.
+ * @param io Previously-allocated HW IO object.
+ * @param dif_info Pointer to T10 DIF fields, or NULL if no DIF.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_io_add_seed_sge(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_dif_info_t *dif_info)
+{
+	sli4_sge_t	*data = NULL;
+	sli4_diseed_sge_t *dif_seed;
+
+	/* If no dif_info, or dif_oper is disabled, then just return success */
+	if ((dif_info == NULL) || (dif_info->dif_oper == OCS_HW_DIF_OPER_DISABLED)) {
+		return OCS_HW_RTN_SUCCESS;
+	}
+
+	if (!hw || !io) {
+		ocs_log_err(hw ? hw->os : NULL, "bad parameter hw=%p io=%p dif_info=%p\n",
+			    hw, io, dif_info);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	data = io->sgl->virt;
+	data += io->n_sge;
+
+	/* If we are doing T10 DIF add the DIF Seed SGE */
+	ocs_memset(data, 0, sizeof(sli4_diseed_sge_t));
+	dif_seed = (sli4_diseed_sge_t *)data;
+	dif_seed->ref_tag_cmp = dif_info->ref_tag_cmp;
+	dif_seed->ref_tag_repl = dif_info->ref_tag_repl;
+	dif_seed->app_tag_repl = dif_info->app_tag_repl;
+	dif_seed->repl_app_tag = dif_info->repl_app_tag;
+	if (SLI4_IF_TYPE_LANCER_FC_ETH != hw->sli.if_type) {
+		dif_seed->atrt = dif_info->disable_app_ref_ffff;
+		dif_seed->at = dif_info->disable_app_ffff;
+	}
+	dif_seed->sge_type = SLI4_SGE_TYPE_DISEED;
+	/* Workaround for SKH (BZ157233) */
+	if (((io->type == OCS_HW_IO_TARGET_WRITE) || (io->type == OCS_HW_IO_INITIATOR_READ)) &&
+		(SLI4_IF_TYPE_LANCER_FC_ETH != hw->sli.if_type) && dif_info->dif_separate) {
+		dif_seed->sge_type = SLI4_SGE_TYPE_SKIP;
+	}
+
+	dif_seed->app_tag_cmp = dif_info->app_tag_cmp;
+	dif_seed->dif_blk_size = dif_info->blk_size;
+	dif_seed->auto_incr_ref_tag = dif_info->auto_incr_ref_tag;
+	dif_seed->check_app_tag = dif_info->check_app_tag;
+	dif_seed->check_ref_tag = dif_info->check_ref_tag;
+	dif_seed->check_crc = dif_info->check_guard;
+	dif_seed->new_ref_tag = dif_info->repl_ref_tag;
+
+	switch(dif_info->dif_oper) {
+	case OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CRC;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CRC;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CRC_OUT_NODIF;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CRC_OUT_NODIF;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CRC;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CRC;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CHKSUM:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CHKSUM;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CRC_OUT_CHKSUM;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CRC:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CRC;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CRC;
+		break;
+	case OCS_HW_SGE_DIF_OP_IN_RAW_OUT_RAW:
+		dif_seed->dif_op_rx = SLI4_SGE_DIF_OP_IN_RAW_OUT_RAW;
+		dif_seed->dif_op_tx = SLI4_SGE_DIF_OP_IN_RAW_OUT_RAW;
+		break;
+	default:
+		ocs_log_err(hw->os, "unsupported DIF operation %#x\n",
+			    dif_info->dif_oper);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Set last, clear previous last
+	 */
+	data->last = TRUE;
+	if (io->n_sge) {
+		data[-1].last = FALSE;
+	}
+
+	io->n_sge++;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+static ocs_hw_rtn_e
+ocs_hw_io_overflow_sgl(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	sli4_lsp_sge_t *lsp;
+
+	/* fail if we're already pointing to the overflow SGL */
+	if (io->sgl == io->ovfl_sgl) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * For skyhawk, we can use another SGL to extend the SGL list. The
+	 * Chained entry must not be in the first 4 entries.
+	 *
+	 * Note: For DIF enabled IOs, we will use the ovfl_io for the sec_hio.
+	 */
+	if (sli_get_sgl_preregister(&hw->sli) &&
+	    io->def_sgl_count > 4 &&
+	    io->ovfl_io == NULL &&
+	    ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) ||
+		(SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli)))) {
+		io->ovfl_io = ocs_hw_io_alloc(hw);
+		if (io->ovfl_io != NULL) {
+			/*
+			 * Note: We can't call ocs_hw_io_register_sgl() here
+			 * because it checks that SGLs are not pre-registered
+			 * and for shyhawk, preregistered SGLs are required.
+			 */
+			io->ovfl_sgl = &io->ovfl_io->def_sgl;
+			io->ovfl_sgl_count = io->ovfl_io->def_sgl_count;
+		}
+	}
+
+	/* fail if we don't have an overflow SGL registered */
+	if (io->ovfl_sgl == NULL) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * Overflow, we need to put a link SGE in the last location of the current SGL, after
+	 * copying the the last SGE to the overflow SGL
+	 */
+
+	((sli4_sge_t*)io->ovfl_sgl->virt)[0] = ((sli4_sge_t*)io->sgl->virt)[io->n_sge - 1];
+
+	lsp = &((sli4_lsp_sge_t*)io->sgl->virt)[io->n_sge - 1];
+	ocs_memset(lsp, 0, sizeof(*lsp));
+
+	if ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) ||
+	    (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli))) {
+		sli_skh_chain_sge_build(&hw->sli,
+					(sli4_sge_t*)lsp,
+					io->ovfl_io->indicator,
+					0, /* frag_num */
+					0); /* offset */
+	} else {
+		lsp->buffer_address_high = ocs_addr32_hi(io->ovfl_sgl->phys);
+		lsp->buffer_address_low  = ocs_addr32_lo(io->ovfl_sgl->phys);
+		lsp->sge_type = SLI4_SGE_TYPE_LSP;
+		lsp->last = 0;
+		io->ovfl_lsp = lsp;
+		io->ovfl_lsp->segment_length = sizeof(sli4_sge_t);
+	}
+
+	/* Update the current SGL pointer, and n_sgl */
+	io->sgl = io->ovfl_sgl;
+	io->sgl_count = io->ovfl_sgl_count;
+	io->n_sge = 1;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup io
+ * @brief Add a scatter gather list entry to an IO.
+ *
+ * @param hw Hardware context.
+ * @param io Previously-allocated HW IO object.
+ * @param addr Physical address.
+ * @param length Length of memory pointed to by @c addr.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_io_add_sge(ocs_hw_t *hw, ocs_hw_io_t *io, uintptr_t addr, uint32_t length)
+{
+	sli4_sge_t	*data = NULL;
+
+	if (!hw || !io || !addr || !length) {
+		ocs_log_err(hw ? hw->os : NULL,
+			    "bad parameter hw=%p io=%p addr=%lx length=%u\n",
+			    hw, io, addr, length);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if ((length != 0) && (io->n_sge + 1) > io->sgl_count) {
+		if (ocs_hw_io_overflow_sgl(hw, io) != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(hw->os, "SGL full (%d)\n", io->n_sge);
+			return OCS_HW_RTN_ERROR;
+		}
+	}
+
+	if (length > sli_get_max_sge(&hw->sli)) {
+		ocs_log_err(hw->os, "length of SGE %d bigger than allowed %d\n",
+			    length, sli_get_max_sge(&hw->sli));
+		return OCS_HW_RTN_ERROR;
+	}
+
+	data = io->sgl->virt;
+	data += io->n_sge;
+
+	data->sge_type = SLI4_SGE_TYPE_DATA;
+	data->buffer_address_high = ocs_addr32_hi(addr);
+	data->buffer_address_low  = ocs_addr32_lo(addr);
+	data->buffer_length = length;
+	data->data_offset = io->sge_offset;
+	/*
+	 * Always assume this is the last entry and mark as such.
+	 * If this is not the first entry unset the "last SGE"
+	 * indication for the previous entry
+	 */
+	data->last = TRUE;
+	if (io->n_sge) {
+		data[-1].last = FALSE;
+	}
+
+	/* Set first_data_bde if not previously set */
+	if (io->first_data_sge == 0) {
+		io->first_data_sge = io->n_sge;
+	}
+
+	io->sge_offset += length;
+	io->n_sge++;
+
+	/* Update the linked segment length (only executed after overflow has begun) */
+	if (io->ovfl_lsp != NULL) {
+		io->ovfl_lsp->segment_length = io->n_sge * sizeof(sli4_sge_t);
+	}
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup io
+ * @brief Add a T10 DIF scatter gather list entry to an IO.
+ *
+ * @param hw Hardware context.
+ * @param io Previously-allocated HW IO object.
+ * @param addr DIF physical address.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_io_add_dif_sge(ocs_hw_t *hw, ocs_hw_io_t *io, uintptr_t addr)
+{
+	sli4_dif_sge_t	*data = NULL;
+
+	if (!hw || !io || !addr) {
+		ocs_log_err(hw ? hw->os : NULL,
+			    "bad parameter hw=%p io=%p addr=%lx\n",
+			    hw, io, addr);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if ((io->n_sge + 1) > hw->config.n_sgl) {
+		if (ocs_hw_io_overflow_sgl(hw, io) != OCS_HW_RTN_ERROR) {
+			ocs_log_err(hw->os, "SGL full (%d)\n", io->n_sge);
+			return OCS_HW_RTN_ERROR;
+		}
+	}
+
+	data = io->sgl->virt;
+	data += io->n_sge;
+
+	data->sge_type = SLI4_SGE_TYPE_DIF;
+	/* Workaround for SKH (BZ157233) */
+	if (((io->type == OCS_HW_IO_TARGET_WRITE) || (io->type == OCS_HW_IO_INITIATOR_READ)) &&
+		(SLI4_IF_TYPE_LANCER_FC_ETH != hw->sli.if_type)) {
+		data->sge_type = SLI4_SGE_TYPE_SKIP;
+	}
+
+	data->buffer_address_high = ocs_addr32_hi(addr);
+	data->buffer_address_low  = ocs_addr32_lo(addr);
+
+	/*
+	 * Always assume this is the last entry and mark as such.
+	 * If this is not the first entry unset the "last SGE"
+	 * indication for the previous entry
+	 */
+	data->last = TRUE;
+	if (io->n_sge) {
+		data[-1].last = FALSE;
+	}
+
+	io->n_sge++;
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup io
+ * @brief Abort a previously-started IO.
+ *
+ * @param hw Hardware context.
+ * @param io_to_abort The IO to abort.
+ * @param send_abts Boolean to have the hardware automatically
+ * generate an ABTS.
+ * @param cb Function call upon completion of the abort (may be NULL).
+ * @param arg Argument to pass to abort completion function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_io_abort(ocs_hw_t *hw, ocs_hw_io_t *io_to_abort, uint32_t send_abts, void *cb, void *arg)
+{
+	sli4_abort_type_e atype = SLI_ABORT_MAX;
+	uint32_t	id = 0, mask = 0;
+	ocs_hw_rtn_e	rc = OCS_HW_RTN_SUCCESS;
+	hw_wq_callback_t *wqcb;
+
+	if (!hw || !io_to_abort) {
+		ocs_log_err(hw ? hw->os : NULL,
+			    "bad parameter hw=%p io=%p\n",
+			    hw, io_to_abort);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->state != OCS_HW_STATE_ACTIVE) {
+		ocs_log_err(hw->os, "cannot send IO abort, HW state=%d\n",
+			    hw->state);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* take a reference on IO being aborted */
+	if (ocs_ref_get_unless_zero(&io_to_abort->ref) == 0) {
+		/* command no longer active */
+		ocs_log_test(hw ? hw->os : NULL,
+				"io not active xri=0x%x tag=0x%x\n",
+				io_to_abort->indicator, io_to_abort->reqtag);
+		return OCS_HW_RTN_IO_NOT_ACTIVE;
+	}
+
+	/* non-port owned XRI checks */
+	/* Must have a valid WQ reference */
+	if (io_to_abort->wq == NULL) {
+		ocs_log_test(hw->os, "io_to_abort xri=0x%x not active on WQ\n",
+				io_to_abort->indicator);
+		ocs_ref_put(&io_to_abort->ref); /* ocs_ref_get(): same function */
+		return OCS_HW_RTN_IO_NOT_ACTIVE;
+	}
+
+	/* Validation checks complete; now check to see if already being aborted */
+	ocs_lock(&hw->io_abort_lock);
+		if (io_to_abort->abort_in_progress) {
+			ocs_unlock(&hw->io_abort_lock);
+			ocs_ref_put(&io_to_abort->ref); /* ocs_ref_get(): same function */
+			ocs_log_debug(hw ? hw->os : NULL,
+				"io already being aborted xri=0x%x tag=0x%x\n",
+				io_to_abort->indicator, io_to_abort->reqtag);
+			return OCS_HW_RTN_IO_ABORT_IN_PROGRESS;
+		}
+
+		/*
+		 * This IO is not already being aborted. Set flag so we won't try to
+		 * abort it again. After all, we only have one abort_done callback.
+		 */
+		io_to_abort->abort_in_progress = 1;
+	ocs_unlock(&hw->io_abort_lock);
+
+	/*
+	 * If we got here, the possibilities are:
+	 * - host owned xri
+	 *	- io_to_abort->wq_index != UINT32_MAX
+	 *		- submit ABORT_WQE to same WQ
+	 * - port owned xri:
+	 *	- rxri: io_to_abort->wq_index == UINT32_MAX
+	 *		- submit ABORT_WQE to any WQ
+	 *	- non-rxri
+	 *		- io_to_abort->index != UINT32_MAX
+	 *			- submit ABORT_WQE to same WQ
+	 *		- io_to_abort->index == UINT32_MAX
+	 *			- submit ABORT_WQE to any WQ
+	 */
+	io_to_abort->abort_done = cb;
+	io_to_abort->abort_arg  = arg;
+
+	atype = SLI_ABORT_XRI;
+	id = io_to_abort->indicator;
+
+	/* Allocate a request tag for the abort portion of this IO */
+	wqcb = ocs_hw_reqtag_alloc(hw, ocs_hw_wq_process_abort, io_to_abort);
+	if (wqcb == NULL) {
+		ocs_log_err(hw->os, "can't allocate request tag\n");
+		return OCS_HW_RTN_NO_RESOURCES;
+	}
+	io_to_abort->abort_reqtag = wqcb->instance_index;
+
+	/*
+	 * If the wqe is on the pending list, then set this wqe to be
+	 * aborted when the IO's wqe is removed from the list.
+	 */
+	if (io_to_abort->wq != NULL) {
+		sli_queue_lock(io_to_abort->wq->queue);
+			if (ocs_list_on_list(&io_to_abort->wqe.link)) {
+				io_to_abort->wqe.abort_wqe_submit_needed = 1;
+				io_to_abort->wqe.send_abts = send_abts;
+				io_to_abort->wqe.id = id;
+				io_to_abort->wqe.abort_reqtag = io_to_abort->abort_reqtag;
+				sli_queue_unlock(io_to_abort->wq->queue);
+				return 0;
+		}
+		sli_queue_unlock(io_to_abort->wq->queue);
+	}
+
+	if (sli_abort_wqe(&hw->sli, io_to_abort->wqe.wqebuf, hw->sli.config.wqe_size, atype, send_abts, id, mask,
+			  io_to_abort->abort_reqtag, SLI4_CQ_DEFAULT)) {
+		ocs_log_err(hw->os, "ABORT WQE error\n");
+		io_to_abort->abort_reqtag = UINT32_MAX;
+		ocs_hw_reqtag_free(hw, wqcb);
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	if (OCS_HW_RTN_SUCCESS == rc) {
+		if (io_to_abort->wq == NULL) {
+			io_to_abort->wq = ocs_hw_queue_next_wq(hw, io_to_abort);
+			ocs_hw_assert(io_to_abort->wq != NULL);
+		}
+		/* ABORT_WQE does not actually utilize an XRI on the Port,
+		 * therefore, keep xbusy as-is to track the exchange's state,
+		 * not the ABORT_WQE's state
+		 */
+		rc = hw_wq_write(io_to_abort->wq, &io_to_abort->wqe);
+		if (rc > 0) {
+			/* non-negative return is success */
+			rc = 0;
+			/* can't abort an abort so skip adding to timed wqe list */
+		}
+	}
+
+	if (OCS_HW_RTN_SUCCESS != rc) {
+		ocs_lock(&hw->io_abort_lock);
+			io_to_abort->abort_in_progress = 0;
+		ocs_unlock(&hw->io_abort_lock);
+		ocs_ref_put(&io_to_abort->ref); /* ocs_ref_get(): same function */
+	}
+	return rc;
+}
+
+/**
+ * @ingroup io
+ * @brief Return the OX_ID/RX_ID of the IO.
+ *
+ * @param hw Hardware context.
+ * @param io HW IO object.
+ *
+ * @return Returns X_ID on success, or -1 on failure.
+ */
+int32_t
+ocs_hw_io_get_xid(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	if (!hw || !io) {
+		ocs_log_err(hw ? hw->os : NULL,
+			    "bad parameter hw=%p io=%p\n", hw, io);
+		return -1;
+	}
+
+	return io->indicator;
+}
+
+
+typedef struct ocs_hw_fw_write_cb_arg {
+	ocs_hw_fw_cb_t cb;
+	void *arg;
+} ocs_hw_fw_write_cb_arg_t;
+
+typedef struct ocs_hw_sfp_cb_arg {
+	ocs_hw_sfp_cb_t cb;
+	void *arg;
+	ocs_dma_t payload;
+} ocs_hw_sfp_cb_arg_t;
+
+typedef struct ocs_hw_temp_cb_arg {
+	ocs_hw_temp_cb_t cb;
+	void *arg;
+} ocs_hw_temp_cb_arg_t;
+
+typedef struct ocs_hw_link_stat_cb_arg {
+	ocs_hw_link_stat_cb_t cb;
+	void *arg;
+} ocs_hw_link_stat_cb_arg_t;
+
+typedef struct ocs_hw_host_stat_cb_arg {
+	ocs_hw_host_stat_cb_t cb;
+	void *arg;
+} ocs_hw_host_stat_cb_arg_t;
+
+typedef struct ocs_hw_dump_get_cb_arg {
+	ocs_hw_dump_get_cb_t cb;
+	void *arg;
+	void *mbox_cmd;
+} ocs_hw_dump_get_cb_arg_t;
+
+typedef struct ocs_hw_dump_clear_cb_arg {
+	ocs_hw_dump_clear_cb_t cb;
+	void *arg;
+	void *mbox_cmd;
+} ocs_hw_dump_clear_cb_arg_t;
+
+/**
+ * @brief Write a portion of a firmware image to the device.
+ *
+ * @par Description
+ * Calls the correct firmware write function based on the device type.
+ *
+ * @param hw Hardware context.
+ * @param dma DMA structure containing the firmware image chunk.
+ * @param size Size of the firmware image chunk.
+ * @param offset Offset, in bytes, from the beginning of the firmware image.
+ * @param last True if this is the last chunk of the image.
+ * Causes the image to be committed to flash.
+ * @param cb Pointer to a callback function that is called when the command completes.
+ * The callback function prototype is
+ * <tt>void cb(int32_t status, uint32_t bytes_written, void *arg)</tt>.
+ * @param arg Pointer to be passed to the callback function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_firmware_write(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, int last, ocs_hw_fw_cb_t cb, void *arg)
+{
+	if (hw->sli.if_type == SLI4_IF_TYPE_LANCER_FC_ETH) {
+		return ocs_hw_firmware_write_lancer(hw, dma, size, offset, last, cb, arg);
+	} else {
+		/* Write firmware_write for BE3/Skyhawk not supported */
+		return -1;
+	}
+}
+
+/**
+ * @brief Write a portion of a firmware image to the Emulex XE201 ASIC (Lancer).
+ *
+ * @par Description
+ * Creates a SLI_CONFIG mailbox command, fills it with the correct values to write a
+ * firmware image chunk, and then sends the command with ocs_hw_command(). On completion,
+ * the callback function ocs_hw_fw_write_cb() gets called to free the mailbox
+ * and to signal the caller that the write has completed.
+ *
+ * @param hw Hardware context.
+ * @param dma DMA structure containing the firmware image chunk.
+ * @param size Size of the firmware image chunk.
+ * @param offset Offset, in bytes, from the beginning of the firmware image.
+ * @param last True if this is the last chunk of the image. Causes the image to be committed to flash.
+ * @param cb Pointer to a callback function that is called when the command completes.
+ * The callback function prototype is
+ * <tt>void cb(int32_t status, uint32_t bytes_written, void *arg)</tt>.
+ * @param arg Pointer to be passed to the callback function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_firmware_write_lancer(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, int last, ocs_hw_fw_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	uint8_t *mbxdata;
+	ocs_hw_fw_write_cb_arg_t *cb_arg;
+	int noc=0;	/* No Commit bit - set to 1 for testing */
+
+	if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) {
+		ocs_log_test(hw->os, "Function only supported for I/F type 2\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_fw_write_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+
+	if (sli_cmd_common_write_object(&hw->sli, mbxdata, SLI4_BMBX_SIZE, noc, last,
+			size, offset, "/prg/", dma)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_fw_write, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "COMMON_WRITE_OBJECT failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t));
+	}
+
+	return rc;
+
+}
+
+/**
+ * @brief Called when the WRITE OBJECT command completes.
+ *
+ * @par Description
+ * Get the number of bytes actually written out of the response, free the mailbox
+ * that was malloc'd by ocs_hw_firmware_write(),
+ * then call the callback and pass the status and bytes written.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ * The callback function prototype is <tt>void cb(int32_t status, uint32_t bytes_written)</tt>.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_fw_write(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+
+	sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe;
+	sli4_res_common_write_object_t* wr_obj_rsp = (sli4_res_common_write_object_t*) &(mbox_rsp->payload.embed);
+	ocs_hw_fw_write_cb_arg_t *cb_arg = arg;
+	uint32_t bytes_written;
+	uint16_t mbox_status;
+	uint32_t change_status;
+
+	bytes_written = wr_obj_rsp->actual_write_length;
+	mbox_status = mbox_rsp->hdr.status;
+	change_status = wr_obj_rsp->change_status;
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	if (cb_arg) {
+		if (cb_arg->cb) {
+			if ((status == 0) && mbox_status) {
+				status = mbox_status;
+			}
+			cb_arg->cb(status, bytes_written, change_status, cb_arg->arg);
+		}
+
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t));
+	}
+
+	return 0;
+
+}
+
+/**
+ * @brief Called when the READ_TRANSCEIVER_DATA command completes.
+ *
+ * @par Description
+ * Get the number of bytes read out of the response, free the mailbox that was malloc'd
+ * by ocs_hw_get_sfp(), then call the callback and pass the status and bytes written.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ * The callback function prototype is
+ * <tt>void cb(int32_t status, uint32_t bytes_written, uint32_t *data, void *arg)</tt>.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_sfp(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+
+	ocs_hw_sfp_cb_arg_t *cb_arg = arg;
+	ocs_dma_t *payload = NULL;
+	sli4_res_common_read_transceiver_data_t* mbox_rsp = NULL;
+	uint32_t bytes_written;
+
+	if (cb_arg) {
+		payload = &(cb_arg->payload);
+		if (cb_arg->cb) {
+			mbox_rsp = (sli4_res_common_read_transceiver_data_t*) payload->virt;
+			bytes_written = mbox_rsp->hdr.response_length;
+			if ((status == 0) && mbox_rsp->hdr.status) {
+				status = mbox_rsp->hdr.status;
+			}
+			cb_arg->cb(hw->os, status, bytes_written, mbox_rsp->page_data, cb_arg->arg);
+		}
+
+		ocs_dma_free(hw->os, &cb_arg->payload);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_sfp_cb_arg_t));
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	return 0;
+}
+
+/**
+ * @ingroup io
+ * @brief Function to retrieve the SFP information.
+ *
+ * @param hw Hardware context.
+ * @param page The page of SFP data to retrieve (0xa0 or 0xa2).
+ * @param cb Function call upon completion of sending the data (may be NULL).
+ * @param arg Argument to pass to IO completion function.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY.
+ */
+ocs_hw_rtn_e
+ocs_hw_get_sfp(ocs_hw_t *hw, uint16_t page, ocs_hw_sfp_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	ocs_hw_sfp_cb_arg_t *cb_arg;
+	uint8_t *mbxdata;
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_sfp_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+
+	/* payload holds the non-embedded portion */
+	if (ocs_dma_alloc(hw->os, &cb_arg->payload, sizeof(sli4_res_common_read_transceiver_data_t),
+			  OCS_MIN_DMA_ALIGNMENT)) {
+		ocs_log_err(hw->os, "Failed to allocate DMA buffer\n");
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_sfp_cb_arg_t));
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* Send the HW command */
+	if (sli_cmd_common_read_transceiver_data(&hw->sli, mbxdata, SLI4_BMBX_SIZE, page,
+	    &cb_arg->payload)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_sfp, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "READ_TRANSCEIVER_DATA failed with status %d\n",
+				rc);
+		ocs_dma_free(hw->os, &cb_arg->payload);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_sfp_cb_arg_t));
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Function to retrieve the temperature information.
+ *
+ * @param hw Hardware context.
+ * @param cb Function call upon completion of sending the data (may be NULL).
+ * @param arg Argument to pass to IO completion function.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY.
+ */
+ocs_hw_rtn_e
+ocs_hw_get_temperature(ocs_hw_t *hw, ocs_hw_temp_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	ocs_hw_temp_cb_arg_t *cb_arg;
+	uint8_t *mbxdata;
+
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_temp_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+
+	if (sli_cmd_dump_type4(&hw->sli, mbxdata, SLI4_BMBX_SIZE,
+				SLI4_WKI_TAG_SAT_TEM)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_temp, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "DUMP_TYPE4 failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_temp_cb_arg_t));
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Called when the DUMP command completes.
+ *
+ * @par Description
+ * Get the temperature data out of the response, free the mailbox that was malloc'd
+ * by ocs_hw_get_temperature(), then call the callback and pass the status and data.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ * The callback function prototype is defined by ocs_hw_temp_cb_t.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_temp(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+
+	sli4_cmd_dump4_t* mbox_rsp = (sli4_cmd_dump4_t*) mqe;
+	ocs_hw_temp_cb_arg_t *cb_arg = arg;
+	uint32_t curr_temp = mbox_rsp->resp_data[0]; /* word 5 */
+	uint32_t crit_temp_thrshld = mbox_rsp->resp_data[1]; /* word 6*/
+	uint32_t warn_temp_thrshld = mbox_rsp->resp_data[2]; /* word 7 */
+	uint32_t norm_temp_thrshld = mbox_rsp->resp_data[3]; /* word 8 */
+	uint32_t fan_off_thrshld = mbox_rsp->resp_data[4];   /* word 9 */
+	uint32_t fan_on_thrshld = mbox_rsp->resp_data[5];    /* word 10 */
+
+	if (cb_arg) {
+		if (cb_arg->cb) {
+			if ((status == 0) && mbox_rsp->hdr.status) {
+				status = mbox_rsp->hdr.status;
+			}
+			cb_arg->cb(status,
+				   curr_temp,
+				   crit_temp_thrshld,
+				   warn_temp_thrshld,
+				   norm_temp_thrshld,
+				   fan_off_thrshld,
+				   fan_on_thrshld,
+				   cb_arg->arg);
+		}
+
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_temp_cb_arg_t));
+	}
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	return 0;
+}
+
+/**
+ * @brief Function to retrieve the link statistics.
+ *
+ * @param hw Hardware context.
+ * @param req_ext_counters If TRUE, then the extended counters will be requested.
+ * @param clear_overflow_flags If TRUE, then overflow flags will be cleared.
+ * @param clear_all_counters If TRUE, the counters will be cleared.
+ * @param cb Function call upon completion of sending the data (may be NULL).
+ * @param arg Argument to pass to IO completion function.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY.
+ */
+ocs_hw_rtn_e
+ocs_hw_get_link_stats(ocs_hw_t *hw,
+			uint8_t req_ext_counters,
+			uint8_t clear_overflow_flags,
+			uint8_t clear_all_counters,
+			ocs_hw_link_stat_cb_t cb,
+			void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	ocs_hw_link_stat_cb_arg_t *cb_arg;
+	uint8_t *mbxdata;
+
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_link_stat_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+
+	if (sli_cmd_read_link_stats(&hw->sli, mbxdata, SLI4_BMBX_SIZE,
+				    req_ext_counters,
+				    clear_overflow_flags,
+				    clear_all_counters)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_link_stat, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "READ_LINK_STATS failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_link_stat_cb_arg_t));
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Called when the READ_LINK_STAT command completes.
+ *
+ * @par Description
+ * Get the counters out of the response, free the mailbox that was malloc'd
+ * by ocs_hw_get_link_stats(), then call the callback and pass the status and data.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ * The callback function prototype is defined by ocs_hw_link_stat_cb_t.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_link_stat(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+
+	sli4_cmd_read_link_stats_t* mbox_rsp = (sli4_cmd_read_link_stats_t*) mqe;
+	ocs_hw_link_stat_cb_arg_t *cb_arg = arg;
+	ocs_hw_link_stat_counts_t counts[OCS_HW_LINK_STAT_MAX];
+	uint32_t num_counters = (mbox_rsp->gec ? 20 : 13);
+
+	ocs_memset(counts, 0, sizeof(ocs_hw_link_stat_counts_t) *
+		   OCS_HW_LINK_STAT_MAX);
+
+	counts[OCS_HW_LINK_STAT_LINK_FAILURE_COUNT].overflow = mbox_rsp->w02of;
+	counts[OCS_HW_LINK_STAT_LOSS_OF_SYNC_COUNT].overflow = mbox_rsp->w03of;
+	counts[OCS_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT].overflow = mbox_rsp->w04of;
+	counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT].overflow = mbox_rsp->w05of;
+	counts[OCS_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT].overflow = mbox_rsp->w06of;
+	counts[OCS_HW_LINK_STAT_CRC_COUNT].overflow = mbox_rsp->w07of;
+	counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT].overflow = mbox_rsp->w08of;
+	counts[OCS_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT].overflow = mbox_rsp->w09of;
+	counts[OCS_HW_LINK_STAT_ARB_TIMEOUT_COUNT].overflow = mbox_rsp->w10of;
+	counts[OCS_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT].overflow = mbox_rsp->w11of;
+	counts[OCS_HW_LINK_STAT_CURR_RCV_B2B_CREDIT].overflow = mbox_rsp->w12of;
+	counts[OCS_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT].overflow = mbox_rsp->w13of;
+	counts[OCS_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT].overflow = mbox_rsp->w14of;
+	counts[OCS_HW_LINK_STAT_RCV_EOFA_COUNT].overflow = mbox_rsp->w15of;
+	counts[OCS_HW_LINK_STAT_RCV_EOFDTI_COUNT].overflow = mbox_rsp->w16of;
+	counts[OCS_HW_LINK_STAT_RCV_EOFNI_COUNT].overflow = mbox_rsp->w17of;
+	counts[OCS_HW_LINK_STAT_RCV_SOFF_COUNT].overflow = mbox_rsp->w18of;
+	counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT].overflow = mbox_rsp->w19of;
+	counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT].overflow = mbox_rsp->w20of;
+	counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT].overflow = mbox_rsp->w21of;
+
+	counts[OCS_HW_LINK_STAT_LINK_FAILURE_COUNT].counter = mbox_rsp->link_failure_error_count;
+	counts[OCS_HW_LINK_STAT_LOSS_OF_SYNC_COUNT].counter = mbox_rsp->loss_of_sync_error_count;
+	counts[OCS_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT].counter = mbox_rsp->loss_of_signal_error_count;
+	counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT].counter = mbox_rsp->primitive_sequence_error_count;
+	counts[OCS_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT].counter = mbox_rsp->invalid_transmission_word_error_count;
+	counts[OCS_HW_LINK_STAT_CRC_COUNT].counter = mbox_rsp->crc_error_count;
+	counts[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT].counter = mbox_rsp->primitive_sequence_event_timeout_count;
+	counts[OCS_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT].counter = mbox_rsp->elastic_buffer_overrun_error_count;
+	counts[OCS_HW_LINK_STAT_ARB_TIMEOUT_COUNT].counter = mbox_rsp->arbitration_fc_al_timout_count;
+	counts[OCS_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT].counter = mbox_rsp->advertised_receive_bufftor_to_buffer_credit;
+	counts[OCS_HW_LINK_STAT_CURR_RCV_B2B_CREDIT].counter = mbox_rsp->current_receive_buffer_to_buffer_credit;
+	counts[OCS_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT].counter = mbox_rsp->advertised_transmit_buffer_to_buffer_credit;
+	counts[OCS_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT].counter = mbox_rsp->current_transmit_buffer_to_buffer_credit;
+	counts[OCS_HW_LINK_STAT_RCV_EOFA_COUNT].counter = mbox_rsp->received_eofa_count;
+	counts[OCS_HW_LINK_STAT_RCV_EOFDTI_COUNT].counter = mbox_rsp->received_eofdti_count;
+	counts[OCS_HW_LINK_STAT_RCV_EOFNI_COUNT].counter = mbox_rsp->received_eofni_count;
+	counts[OCS_HW_LINK_STAT_RCV_SOFF_COUNT].counter = mbox_rsp->received_soff_count;
+	counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT].counter = mbox_rsp->received_dropped_no_aer_count;
+	counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT].counter = mbox_rsp->received_dropped_no_available_rpi_resources_count;
+	counts[OCS_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT].counter = mbox_rsp->received_dropped_no_available_xri_resources_count;
+
+	if (cb_arg) {
+		if (cb_arg->cb) {
+			if ((status == 0) && mbox_rsp->hdr.status) {
+				status = mbox_rsp->hdr.status;
+			}
+			cb_arg->cb(status,
+				   num_counters,
+				   counts,
+				   cb_arg->arg);
+		}
+
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_link_stat_cb_arg_t));
+	}
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	return 0;
+}
+
+/**
+ * @brief Function to retrieve the link and host statistics.
+ *
+ * @param hw Hardware context.
+ * @param cc clear counters, if TRUE all counters will be cleared.
+ * @param cb Function call upon completion of receiving the data.
+ * @param arg Argument to pass to pointer fc hosts statistics structure.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS, OCS_HW_RTN_ERROR, or OCS_HW_RTN_NO_MEMORY.
+ */
+ocs_hw_rtn_e
+ocs_hw_get_host_stats(ocs_hw_t *hw, uint8_t cc, ocs_hw_host_stat_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	ocs_hw_host_stat_cb_arg_t *cb_arg;
+	uint8_t *mbxdata;
+
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_host_stat_cb_arg_t), 0);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	 }
+
+	 cb_arg->cb = cb;
+	 cb_arg->arg = arg;
+
+	 /* Send the HW command to get the host stats */
+	if (sli_cmd_read_status(&hw->sli, mbxdata, SLI4_BMBX_SIZE, cc)) {
+		 rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_cb_host_stat, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "READ_HOST_STATS failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_host_stat_cb_arg_t));
+	}
+
+	return rc;
+}
+
+
+/**
+ * @brief Called when the READ_STATUS command completes.
+ *
+ * @par Description
+ * Get the counters out of the response, free the mailbox that was malloc'd
+ * by ocs_hw_get_host_stats(), then call the callback and pass
+ * the status and data.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ * The callback function prototype is defined by
+ * ocs_hw_host_stat_cb_t.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_host_stat(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+
+	sli4_cmd_read_status_t* mbox_rsp = (sli4_cmd_read_status_t*) mqe;
+	ocs_hw_host_stat_cb_arg_t *cb_arg = arg;
+	ocs_hw_host_stat_counts_t counts[OCS_HW_HOST_STAT_MAX];
+	uint32_t num_counters = OCS_HW_HOST_STAT_MAX;
+
+	ocs_memset(counts, 0, sizeof(ocs_hw_host_stat_counts_t) *
+		   OCS_HW_HOST_STAT_MAX);
+
+	counts[OCS_HW_HOST_STAT_TX_KBYTE_COUNT].counter = mbox_rsp->transmit_kbyte_count;
+	counts[OCS_HW_HOST_STAT_RX_KBYTE_COUNT].counter = mbox_rsp->receive_kbyte_count;
+	counts[OCS_HW_HOST_STAT_TX_FRAME_COUNT].counter = mbox_rsp->transmit_frame_count;
+	counts[OCS_HW_HOST_STAT_RX_FRAME_COUNT].counter = mbox_rsp->receive_frame_count;
+	counts[OCS_HW_HOST_STAT_TX_SEQ_COUNT].counter = mbox_rsp->transmit_sequence_count;
+	counts[OCS_HW_HOST_STAT_RX_SEQ_COUNT].counter = mbox_rsp->receive_sequence_count;
+	counts[OCS_HW_HOST_STAT_TOTAL_EXCH_ORIG].counter = mbox_rsp->total_exchanges_originator;
+	counts[OCS_HW_HOST_STAT_TOTAL_EXCH_RESP].counter = mbox_rsp->total_exchanges_responder;
+	counts[OCS_HW_HOSY_STAT_RX_P_BSY_COUNT].counter = mbox_rsp->receive_p_bsy_count;
+	counts[OCS_HW_HOST_STAT_RX_F_BSY_COUNT].counter = mbox_rsp->receive_f_bsy_count;
+	counts[OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_RQ_BUF_COUNT].counter = mbox_rsp->dropped_frames_due_to_no_rq_buffer_count;
+	counts[OCS_HW_HOST_STAT_EMPTY_RQ_TIMEOUT_COUNT].counter = mbox_rsp->empty_rq_timeout_count;
+	counts[OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_XRI_COUNT].counter = mbox_rsp->dropped_frames_due_to_no_xri_count;
+	counts[OCS_HW_HOST_STAT_EMPTY_XRI_POOL_COUNT].counter = mbox_rsp->empty_xri_pool_count;
+
+
+	if (cb_arg) {
+		if (cb_arg->cb) {
+			if ((status == 0) && mbox_rsp->hdr.status) {
+				status = mbox_rsp->hdr.status;
+			}
+			cb_arg->cb(status,
+				   num_counters,
+				   counts,
+				   cb_arg->arg);
+		}
+
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_host_stat_cb_arg_t));
+	}
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	return 0;
+}
+
+/**
+ * @brief HW link configuration enum to the CLP string value mapping.
+ *
+ * This structure provides a mapping from the ocs_hw_linkcfg_e
+ * enum (enum exposed for the OCS_HW_PORT_SET_LINK_CONFIG port
+ * control) to the CLP string that is used
+ * in the DMTF_CLP_CMD mailbox command.
+ */
+typedef struct ocs_hw_linkcfg_map_s {
+	ocs_hw_linkcfg_e linkcfg;
+	const char *clp_str;
+} ocs_hw_linkcfg_map_t;
+
+/**
+ * @brief Mapping from the HW linkcfg enum to the CLP command value
+ * string.
+ */
+static ocs_hw_linkcfg_map_t linkcfg_map[] = {
+	{OCS_HW_LINKCFG_4X10G, "ELX_4x10G"},
+	{OCS_HW_LINKCFG_1X40G, "ELX_1x40G"},
+	{OCS_HW_LINKCFG_2X16G, "ELX_2x16G"},
+	{OCS_HW_LINKCFG_4X8G, "ELX_4x8G"},
+	{OCS_HW_LINKCFG_4X1G, "ELX_4x1G"},
+	{OCS_HW_LINKCFG_2X10G, "ELX_2x10G"},
+	{OCS_HW_LINKCFG_2X10G_2X8G, "ELX_2x10G_2x8G"}};
+
+/**
+ * @brief HW link configuration enum to Skyhawk link config ID mapping.
+ *
+ * This structure provides a mapping from the ocs_hw_linkcfg_e
+ * enum (enum exposed for the OCS_HW_PORT_SET_LINK_CONFIG port
+ * control) to the link config ID numbers used by Skyhawk
+ */
+typedef struct ocs_hw_skyhawk_linkcfg_map_s {
+	ocs_hw_linkcfg_e linkcfg;
+	uint32_t	config_id;
+} ocs_hw_skyhawk_linkcfg_map_t;
+
+/**
+ * @brief Mapping from the HW linkcfg enum to the Skyhawk link config IDs
+ */
+static ocs_hw_skyhawk_linkcfg_map_t skyhawk_linkcfg_map[] = {
+	{OCS_HW_LINKCFG_4X10G, 0x0a},
+	{OCS_HW_LINKCFG_1X40G, 0x09},
+};
+
+/**
+ * @brief Helper function for getting the HW linkcfg enum from the CLP
+ * string value
+ *
+ * @param clp_str CLP string value from OEMELX_LinkConfig.
+ *
+ * @return Returns the HW linkcfg enum corresponding to clp_str.
+ */
+static ocs_hw_linkcfg_e
+ocs_hw_linkcfg_from_clp(const char *clp_str)
+{
+	uint32_t i;
+	for (i = 0; i < ARRAY_SIZE(linkcfg_map); i++) {
+		if (ocs_strncmp(linkcfg_map[i].clp_str, clp_str, ocs_strlen(clp_str)) == 0) {
+			return linkcfg_map[i].linkcfg;
+		}
+	}
+	return OCS_HW_LINKCFG_NA;
+}
+
+/**
+ * @brief Helper function for getting the CLP string value from the HW
+ * linkcfg enum.
+ *
+ * @param linkcfg HW linkcfg enum.
+ *
+ * @return Returns the OEMELX_LinkConfig CLP string value corresponding to
+ * given linkcfg.
+ */
+static const char *
+ocs_hw_clp_from_linkcfg(ocs_hw_linkcfg_e linkcfg)
+{
+	uint32_t i;
+	for (i = 0; i < ARRAY_SIZE(linkcfg_map); i++) {
+		if (linkcfg_map[i].linkcfg == linkcfg) {
+			return linkcfg_map[i].clp_str;
+		}
+	}
+	return NULL;
+}
+
+/**
+ * @brief Helper function for getting a Skyhawk link config ID from the HW
+ * linkcfg enum.
+ *
+ * @param linkcfg HW linkcfg enum.
+ *
+ * @return Returns the Skyhawk link config ID corresponding to
+ * given linkcfg.
+ */
+static uint32_t
+ocs_hw_config_id_from_linkcfg(ocs_hw_linkcfg_e linkcfg)
+{
+	uint32_t i;
+	for (i = 0; i < ARRAY_SIZE(skyhawk_linkcfg_map); i++) {
+		if (skyhawk_linkcfg_map[i].linkcfg == linkcfg) {
+			return skyhawk_linkcfg_map[i].config_id;
+		}
+	}
+	return 0;
+}
+
+/**
+ * @brief Helper function for getting the HW linkcfg enum from a
+ * Skyhawk config ID.
+ *
+ * @param config_id Skyhawk link config ID.
+ *
+ * @return Returns the HW linkcfg enum corresponding to config_id.
+ */
+static ocs_hw_linkcfg_e
+ocs_hw_linkcfg_from_config_id(const uint32_t config_id)
+{
+	uint32_t i;
+	for (i = 0; i < ARRAY_SIZE(skyhawk_linkcfg_map); i++) {
+		if (skyhawk_linkcfg_map[i].config_id == config_id) {
+			return skyhawk_linkcfg_map[i].linkcfg;
+		}
+	}
+	return OCS_HW_LINKCFG_NA;
+}
+
+/**
+ * @brief Link configuration callback argument.
+ */
+typedef struct ocs_hw_linkcfg_cb_arg_s {
+	ocs_hw_port_control_cb_t cb;
+	void *arg;
+	uint32_t opts;
+	int32_t status;
+	ocs_dma_t dma_cmd;
+	ocs_dma_t dma_resp;
+	uint32_t result_len;
+} ocs_hw_linkcfg_cb_arg_t;
+
+/**
+ * @brief Set link configuration.
+ *
+ * @param hw Hardware context.
+ * @param value Link configuration enum to which the link configuration is
+ * set.
+ * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL).
+ * @param cb Callback function to invoke following mbx command.
+ * @param arg Callback argument.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_set_linkcfg(ocs_hw_t *hw, ocs_hw_linkcfg_e value, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg)
+{
+	if (!sli_link_is_configurable(&hw->sli)) {
+		ocs_log_debug(hw->os, "Function not supported\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) {
+		return ocs_hw_set_linkcfg_lancer(hw, value, opts, cb, arg);
+	} else if ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) ||
+		   (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli))) {
+		return ocs_hw_set_linkcfg_skyhawk(hw, value, opts, cb, arg);
+	} else {
+		ocs_log_test(hw->os, "Function not supported for this IF_TYPE\n");
+		return OCS_HW_RTN_ERROR;
+	}
+}
+
+/**
+ * @brief Set link configuration for Lancer
+ *
+ * @param hw Hardware context.
+ * @param value Link configuration enum to which the link configuration is
+ * set.
+ * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL).
+ * @param cb Callback function to invoke following mbx command.
+ * @param arg Callback argument.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_set_linkcfg_lancer(ocs_hw_t *hw, ocs_hw_linkcfg_e value, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg)
+{
+	char cmd[OCS_HW_DMTF_CLP_CMD_MAX];
+	ocs_hw_linkcfg_cb_arg_t *cb_arg;
+	const char *value_str = NULL;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* translate ocs_hw_linkcfg_e to CLP string */
+	value_str = ocs_hw_clp_from_linkcfg(value);
+
+	/* allocate memory for callback argument */
+	cb_arg = ocs_malloc(hw->os, sizeof(*cb_arg), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	ocs_snprintf(cmd, OCS_HW_DMTF_CLP_CMD_MAX, "set / OEMELX_LinkConfig=%s", value_str);
+	/* allocate DMA for command  */
+	if (ocs_dma_alloc(hw->os, &cb_arg->dma_cmd, ocs_strlen(cmd)+1, 4096)) {
+		ocs_log_err(hw->os, "malloc failed\n");
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+	ocs_memset(cb_arg->dma_cmd.virt, 0, ocs_strlen(cmd)+1);
+	ocs_memcpy(cb_arg->dma_cmd.virt, cmd, ocs_strlen(cmd));
+
+	/* allocate DMA for response */
+	if (ocs_dma_alloc(hw->os, &cb_arg->dma_resp, OCS_HW_DMTF_CLP_RSP_MAX, 4096)) {
+		ocs_log_err(hw->os, "malloc failed\n");
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+	cb_arg->opts = opts;
+
+	rc = ocs_hw_exec_dmtf_clp_cmd(hw, &cb_arg->dma_cmd, &cb_arg->dma_resp,
+					opts, ocs_hw_linkcfg_dmtf_clp_cb, cb_arg);
+
+	if (opts == OCS_CMD_POLL || rc != OCS_HW_RTN_SUCCESS) {
+		/* if failed, or polling, free memory here; if success and not
+		 * polling, will free in callback function
+		 */
+		if (rc) {
+			ocs_log_test(hw->os, "CLP cmd=\"%s\" failed\n",
+					(char *)cb_arg->dma_cmd.virt);
+		}
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_dma_free(hw->os, &cb_arg->dma_resp);
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+	}
+	return rc;
+}
+
+/**
+ * @brief Callback for ocs_hw_set_linkcfg_skyhawk
+ *
+ * @param hw Hardware context.
+ * @param status Status from the RECONFIG_GET_LINK_INFO command.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return none
+ */
+static void
+ocs_hw_set_active_link_config_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	ocs_hw_linkcfg_cb_arg_t *cb_arg = (ocs_hw_linkcfg_cb_arg_t *)arg;
+
+	if (status) {
+		ocs_log_test(hw->os, "SET_RECONFIG_LINK_ID failed, status=%d\n", status);
+	}
+
+	/* invoke callback */
+	if (cb_arg->cb) {
+		cb_arg->cb(status, 0, cb_arg->arg);
+	}
+
+	/* if polling, will free memory in calling function */
+	if (cb_arg->opts != OCS_CMD_POLL) {
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+	}
+}
+
+/**
+ * @brief Set link configuration for a Skyhawk
+ *
+ * @param hw Hardware context.
+ * @param value Link configuration enum to which the link configuration is
+ * set.
+ * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL).
+ * @param cb Callback function to invoke following mbx command.
+ * @param arg Callback argument.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_set_linkcfg_skyhawk(ocs_hw_t *hw, ocs_hw_linkcfg_e value, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_linkcfg_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint32_t config_id;
+
+	config_id = ocs_hw_config_id_from_linkcfg(value);
+
+	if (config_id == 0) {
+		ocs_log_test(hw->os, "Link config %d not supported by Skyhawk\n", value);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_linkcfg_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+
+	if (sli_cmd_common_set_reconfig_link_id(&hw->sli, mbxdata, SLI4_BMBX_SIZE, NULL, 0, config_id)) {
+		rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_set_active_link_config_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(hw->os, "SET_RECONFIG_LINK_ID failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t));
+	} else if (opts == OCS_CMD_POLL) {
+		/* if we're polling we have to call the callback here. */
+		ocs_hw_set_active_link_config_cb(hw, 0, mbxdata, cb_arg);
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t));
+	} else {
+		/* We weren't poling, so the callback got called */
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Get link configuration.
+ *
+ * @param hw Hardware context.
+ * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL).
+ * @param cb Callback function to invoke following mbx command.
+ * @param arg Callback argument.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_get_linkcfg(ocs_hw_t *hw, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg)
+{
+	if (!sli_link_is_configurable(&hw->sli)) {
+		ocs_log_debug(hw->os, "Function not supported\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) {
+		return ocs_hw_get_linkcfg_lancer(hw, opts, cb, arg);
+	} else if ((SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) ||
+		   (SLI4_IF_TYPE_BE3_SKH_VF == sli_get_if_type(&hw->sli))) {
+		return ocs_hw_get_linkcfg_skyhawk(hw, opts, cb, arg);
+	} else {
+		ocs_log_test(hw->os, "Function not supported for this IF_TYPE\n");
+		return OCS_HW_RTN_ERROR;
+	}
+}
+
+/**
+ * @brief Get link configuration for a Lancer
+ *
+ * @param hw Hardware context.
+ * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL).
+ * @param cb Callback function to invoke following mbx command.
+ * @param arg Callback argument.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_get_linkcfg_lancer(ocs_hw_t *hw, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg)
+{
+	char cmd[OCS_HW_DMTF_CLP_CMD_MAX];
+	ocs_hw_linkcfg_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* allocate memory for callback argument */
+	cb_arg = ocs_malloc(hw->os, sizeof(*cb_arg), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	ocs_snprintf(cmd, OCS_HW_DMTF_CLP_CMD_MAX, "show / OEMELX_LinkConfig");
+
+	/* allocate DMA for command  */
+	if (ocs_dma_alloc(hw->os, &cb_arg->dma_cmd, ocs_strlen(cmd)+1, 4096)) {
+		ocs_log_err(hw->os, "malloc failed\n");
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* copy CLP command to DMA command */
+	ocs_memset(cb_arg->dma_cmd.virt, 0, ocs_strlen(cmd)+1);
+	ocs_memcpy(cb_arg->dma_cmd.virt, cmd, ocs_strlen(cmd));
+
+	/* allocate DMA for response */
+	if (ocs_dma_alloc(hw->os, &cb_arg->dma_resp, OCS_HW_DMTF_CLP_RSP_MAX, 4096)) {
+		ocs_log_err(hw->os, "malloc failed\n");
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+	cb_arg->opts = opts;
+
+	rc = ocs_hw_exec_dmtf_clp_cmd(hw, &cb_arg->dma_cmd, &cb_arg->dma_resp,
+					opts, ocs_hw_linkcfg_dmtf_clp_cb, cb_arg);
+
+	if (opts == OCS_CMD_POLL || rc != OCS_HW_RTN_SUCCESS) {
+		/* if failed or polling, free memory here; if not polling and success,
+		 * will free in callback function
+		 */
+		if (rc) {
+			ocs_log_test(hw->os, "CLP cmd=\"%s\" failed\n",
+					(char *)cb_arg->dma_cmd.virt);
+		}
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_dma_free(hw->os, &cb_arg->dma_resp);
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+	}
+	return rc;
+}
+
+
+/**
+ * @brief Get the link configuration callback.
+ *
+ * @param hw Hardware context.
+ * @param status Status from the RECONFIG_GET_LINK_INFO command.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return none
+ */
+static void
+ocs_hw_get_active_link_config_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	ocs_hw_linkcfg_cb_arg_t *cb_arg = (ocs_hw_linkcfg_cb_arg_t *)arg;
+	sli4_res_common_get_reconfig_link_info_t *rsp = cb_arg->dma_cmd.virt;
+	ocs_hw_linkcfg_e value = OCS_HW_LINKCFG_NA;
+
+	if (status) {
+		ocs_log_test(hw->os, "GET_RECONFIG_LINK_INFO failed, status=%d\n", status);
+	} else {
+		/* Call was successful */
+		value = ocs_hw_linkcfg_from_config_id(rsp->active_link_config_id);
+	}
+
+	/* invoke callback */
+	if (cb_arg->cb) {
+		cb_arg->cb(status, value, cb_arg->arg);
+	}
+
+	/* if polling, will free memory in calling function */
+	if (cb_arg->opts != OCS_CMD_POLL) {
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+	}
+}
+
+/**
+ * @brief Get link configuration for a Skyhawk.
+ *
+ * @param hw Hardware context.
+ * @param opts Mailbox command options (OCS_CMD_NOWAIT/POLL).
+ * @param cb Callback function to invoke following mbx command.
+ * @param arg Callback argument.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_get_linkcfg_skyhawk(ocs_hw_t *hw, uint32_t opts, ocs_hw_port_control_cb_t cb, void *arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_linkcfg_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_linkcfg_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+	cb_arg->opts = opts;
+
+	/* dma_mem holds the non-embedded portion */
+	if (ocs_dma_alloc(hw->os, &cb_arg->dma_cmd, sizeof(sli4_res_common_get_reconfig_link_info_t), 4)) {
+		ocs_log_err(hw->os, "Failed to allocate DMA buffer\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if (sli_cmd_common_get_reconfig_link_info(&hw->sli, mbxdata, SLI4_BMBX_SIZE, &cb_arg->dma_cmd)) {
+		rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_get_active_link_config_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(hw->os, "GET_RECONFIG_LINK_INFO failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t));
+	} else if (opts == OCS_CMD_POLL) {
+		/* if we're polling we have to call the callback here. */
+		ocs_hw_get_active_link_config_cb(hw, 0, mbxdata, cb_arg);
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_linkcfg_cb_arg_t));
+	} else {
+		/* We weren't poling, so the callback got called */
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Sets the DIF seed value.
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_set_dif_seed(ocs_hw_t *hw)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint8_t buf[SLI4_BMBX_SIZE];
+	sli4_req_common_set_features_dif_seed_t seed_param;
+
+	ocs_memset(&seed_param, 0, sizeof(seed_param));
+	seed_param.seed = hw->config.dif_seed;
+
+	/* send set_features command */
+	if (sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE,
+					SLI4_SET_FEATURES_DIF_SEED,
+					4,
+					(uint32_t*)&seed_param)) {
+		rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+		if (rc) {
+			ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc);
+		} else {
+			ocs_log_debug(hw->os, "DIF seed set to 0x%x\n",
+					hw->config.dif_seed);
+		}
+	} else {
+		ocs_log_err(hw->os, "sli_cmd_common_set_features failed\n");
+		rc = OCS_HW_RTN_ERROR;
+	}
+	return rc;
+}
+
+
+/**
+ * @brief Sets the DIF mode value.
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_set_dif_mode(ocs_hw_t *hw)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint8_t buf[SLI4_BMBX_SIZE];
+	sli4_req_common_set_features_t10_pi_mem_model_t mode_param;
+
+	ocs_memset(&mode_param, 0, sizeof(mode_param));
+	mode_param.tmm = (hw->config.dif_mode == OCS_HW_DIF_MODE_INLINE ? 0 : 1);
+
+	/* send set_features command */
+	if (sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE,
+					SLI4_SET_FEATURES_DIF_MEMORY_MODE,
+					sizeof(mode_param),
+					(uint32_t*)&mode_param)) {
+		rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+		if (rc) {
+			ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc);
+		} else {
+			ocs_log_test(hw->os, "DIF mode set to %s\n",
+				(hw->config.dif_mode == OCS_HW_DIF_MODE_INLINE ? "inline" : "separate"));
+		}
+	} else {
+		ocs_log_err(hw->os, "sli_cmd_common_set_features failed\n");
+		rc = OCS_HW_RTN_ERROR;
+	}
+	return rc;
+}
+
+static void 
+ocs_hw_watchdog_timer_cb(void *arg)
+{
+	ocs_hw_t *hw = (ocs_hw_t *)arg;
+
+	ocs_hw_config_watchdog_timer(hw);
+	return;
+}
+
+static void
+ocs_hw_cb_cfg_watchdog(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	uint16_t timeout = hw->watchdog_timeout;
+
+	if (status != 0) {
+		ocs_log_err(hw->os, "config watchdog timer failed, rc = %d\n", status);
+	} else {
+		if(timeout != 0) {
+			/* keeping callback 500ms before timeout to keep heartbeat alive */
+			ocs_setup_timer(hw->os, &hw->watchdog_timer, ocs_hw_watchdog_timer_cb, hw, (timeout*1000 - 500) );
+		}else {
+			ocs_del_timer(&hw->watchdog_timer);
+		}
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	return;
+}
+
+/**
+ * @brief Set configuration parameters for watchdog timer feature.
+ *
+ * @param hw Hardware context.
+ * @param timeout Timeout for watchdog timer in seconds
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_config_watchdog_timer(ocs_hw_t *hw)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint8_t *buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+
+	sli4_cmd_lowlevel_set_watchdog(&hw->sli, buf, SLI4_BMBX_SIZE, hw->watchdog_timeout);
+	rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_cfg_watchdog, NULL);
+	if (rc) {
+		ocs_free(hw->os, buf, SLI4_BMBX_SIZE);
+		ocs_log_err(hw->os, "config watchdog timer failed, rc = %d\n", rc);
+	}
+	return rc;
+}
+
+/**
+ * @brief Set configuration parameters for auto-generate xfer_rdy T10 PI feature.
+ *
+ * @param hw Hardware context.
+ * @param buf Pointer to a mailbox buffer area.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_config_auto_xfer_rdy_t10pi(ocs_hw_t *hw, uint8_t *buf)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	sli4_req_common_set_features_xfer_rdy_t10pi_t param;
+
+	ocs_memset(&param, 0, sizeof(param));
+	param.rtc = (hw->config.auto_xfer_rdy_ref_tag_is_lba ? 0 : 1);
+	param.atv = (hw->config.auto_xfer_rdy_app_tag_valid ? 1 : 0);
+	param.tmm = ((hw->config.dif_mode == OCS_HW_DIF_MODE_INLINE) ? 0 : 1);
+	param.app_tag = hw->config.auto_xfer_rdy_app_tag_value;
+	param.blk_size = hw->config.auto_xfer_rdy_blk_size_chip;
+
+	switch (hw->config.auto_xfer_rdy_p_type) {
+	case 1:
+		param.p_type = 0;
+		break;
+	case 3:
+		param.p_type = 2;
+		break;
+	default:
+		ocs_log_err(hw->os, "unsupported p_type %d\n",
+			hw->config.auto_xfer_rdy_p_type);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* build the set_features command */
+	sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE,
+				    SLI4_SET_FEATURES_SET_CONFIG_AUTO_XFER_RDY_T10PI,
+				    sizeof(param),
+				    &param);
+
+
+	rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+	if (rc) {
+		ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc);
+	} else {
+		ocs_log_test(hw->os, "Auto XFER RDY T10 PI configured rtc:%d atv:%d p_type:%d app_tag:%x blk_size:%d\n",
+				param.rtc, param.atv, param.p_type,
+				param.app_tag, param.blk_size);
+	}
+
+	return rc;
+}
+
+
+/**
+ * @brief enable sli port health check
+ *
+ * @param hw Hardware context.
+ * @param buf Pointer to a mailbox buffer area.
+ * @param query current status of the health check feature enabled/disabled
+ * @param enable if 1: enable 0: disable
+ * @param buf Pointer to a mailbox buffer area.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_config_sli_port_health_check(ocs_hw_t *hw, uint8_t query, uint8_t enable)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint8_t buf[SLI4_BMBX_SIZE];
+	sli4_req_common_set_features_health_check_t param;
+
+	ocs_memset(&param, 0, sizeof(param));
+	param.hck = enable;
+	param.qry = query;
+
+	/* build the set_features command */
+	sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE,
+				    SLI4_SET_FEATURES_SLI_PORT_HEALTH_CHECK,
+				    sizeof(param),
+				    &param);
+
+	rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+	if (rc) {
+		ocs_log_err(hw->os, "ocs_hw_command returns %d\n", rc);
+	} else {
+		ocs_log_test(hw->os, "SLI Port Health Check is enabled \n");
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Set FTD transfer hint feature
+ *
+ * @param hw Hardware context.
+ * @param fdt_xfer_hint size in bytes where read requests are segmented.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_config_set_fdt_xfer_hint(ocs_hw_t *hw, uint32_t fdt_xfer_hint)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint8_t buf[SLI4_BMBX_SIZE];
+	sli4_req_common_set_features_set_fdt_xfer_hint_t param;
+
+	ocs_memset(&param, 0, sizeof(param));
+	param.fdt_xfer_hint = fdt_xfer_hint;
+	/* build the set_features command */
+	sli_cmd_common_set_features(&hw->sli, buf, SLI4_BMBX_SIZE,
+				    SLI4_SET_FEATURES_SET_FTD_XFER_HINT,
+				    sizeof(param),
+				    &param);
+
+
+	rc = ocs_hw_command(hw, buf, OCS_CMD_POLL, NULL, NULL);
+	if (rc) {
+		ocs_log_warn(hw->os, "set FDT hint %d failed: %d\n", fdt_xfer_hint, rc);
+	} else {
+		ocs_log_debug(hw->os, "Set FTD transfer hint to %d\n", param.fdt_xfer_hint);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Get the link configuration callback.
+ *
+ * @param hw Hardware context.
+ * @param status Status from the DMTF CLP command.
+ * @param result_len Length, in bytes, of the DMTF CLP result.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static void
+ocs_hw_linkcfg_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint32_t result_len, void *arg)
+{
+	int32_t rval;
+	char retdata_str[64];
+	ocs_hw_linkcfg_cb_arg_t *cb_arg = (ocs_hw_linkcfg_cb_arg_t *)arg;
+	ocs_hw_linkcfg_e linkcfg = OCS_HW_LINKCFG_NA;
+
+	if (status) {
+		ocs_log_test(hw->os, "CLP cmd failed, status=%d\n", status);
+	} else {
+		/* parse CLP response to get return data */
+		rval = ocs_hw_clp_resp_get_value(hw, "retdata", retdata_str,
+						  sizeof(retdata_str),
+						  cb_arg->dma_resp.virt,
+						  result_len);
+
+		if (rval <= 0) {
+			ocs_log_err(hw->os, "failed to get retdata %d\n", result_len);
+		} else {
+			/* translate string into hw enum */
+			linkcfg = ocs_hw_linkcfg_from_clp(retdata_str);
+		}
+	}
+
+	/* invoke callback */
+	if (cb_arg->cb) {
+		cb_arg->cb(status, linkcfg, cb_arg->arg);
+	}
+
+	/* if polling, will free memory in calling function */
+	if (cb_arg->opts != OCS_CMD_POLL) {
+		ocs_dma_free(hw->os, &cb_arg->dma_cmd);
+		ocs_dma_free(hw->os, &cb_arg->dma_resp);
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+	}
+}
+
+/**
+ * @brief Set the Lancer dump location
+ * @par Description
+ * This function tells a Lancer chip to use a specific DMA
+ * buffer as a dump location rather than the internal flash.
+ *
+ * @param hw Hardware context.
+ * @param num_buffers The number of DMA buffers to hold the dump (1..n).
+ * @param dump_buffers DMA buffers to hold the dump.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+ocs_hw_rtn_e
+ocs_hw_set_dump_location(ocs_hw_t *hw, uint32_t num_buffers, ocs_dma_t *dump_buffers, uint8_t fdb)
+{
+	uint8_t bus, dev, func;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint8_t	buf[SLI4_BMBX_SIZE];
+
+	/*
+	 * Make sure the FW is new enough to support this command. If the FW
+	 * is too old, the FW will UE.
+	 */
+	if (hw->workaround.disable_dump_loc) {
+		ocs_log_test(hw->os, "FW version is too old for this feature\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* This command is only valid for physical port 0 */
+	ocs_get_bus_dev_func(hw->os, &bus, &dev, &func);
+	if (fdb == 0 && func != 0) {
+		ocs_log_test(hw->os, "function only valid for pci function 0, %d passed\n",
+			     func);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/*
+	 * If a single buffer is used, then it may be passed as is to the chip. For multiple buffers,
+	 * We must allocate a SGL list and then pass the address of the list to the chip.
+	 */
+	if (num_buffers > 1) {
+		uint32_t sge_size = num_buffers * sizeof(sli4_sge_t);
+		sli4_sge_t *sge;
+		uint32_t i;
+
+		if (hw->dump_sges.size < sge_size) {
+			ocs_dma_free(hw->os, &hw->dump_sges);
+			if (ocs_dma_alloc(hw->os, &hw->dump_sges, sge_size, OCS_MIN_DMA_ALIGNMENT)) {
+				ocs_log_err(hw->os, "SGE DMA allocation failed\n");
+				return OCS_HW_RTN_NO_MEMORY;
+			}
+		}
+		/* build the SGE list */
+		ocs_memset(hw->dump_sges.virt, 0, hw->dump_sges.size);
+		hw->dump_sges.len = sge_size;
+		sge = hw->dump_sges.virt;
+		for (i = 0; i < num_buffers; i++) {
+			sge[i].buffer_address_high = ocs_addr32_hi(dump_buffers[i].phys);
+			sge[i].buffer_address_low = ocs_addr32_lo(dump_buffers[i].phys);
+			sge[i].last = (i == num_buffers - 1 ? 1 : 0);
+			sge[i].buffer_length = dump_buffers[i].size;
+		}
+		rc = sli_cmd_common_set_dump_location(&hw->sli, (void *)buf,
+						      SLI4_BMBX_SIZE, FALSE, TRUE,
+						      &hw->dump_sges, fdb);
+	} else {
+		dump_buffers->len = dump_buffers->size;
+		rc = sli_cmd_common_set_dump_location(&hw->sli, (void *)buf,
+						      SLI4_BMBX_SIZE, FALSE, FALSE,
+						      dump_buffers, fdb);
+	}
+
+	if (rc) {
+		rc = ocs_hw_command(hw, buf, OCS_CMD_POLL,
+				     NULL, NULL);
+		if (rc) {
+			ocs_log_err(hw->os, "ocs_hw_command returns %d\n",
+				rc);
+		}
+	} else {
+		ocs_log_err(hw->os,
+			"sli_cmd_common_set_dump_location failed\n");
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	return rc;
+}
+
+
+/**
+ * @brief Set the Ethernet license.
+ *
+ * @par Description
+ * This function sends the appropriate mailbox command (DMTF
+ * CLP) to set the Ethernet license to the given license value.
+ * Since it is used during the time of ocs_hw_init(), the mailbox
+ * command is sent via polling (the BMBX route).
+ *
+ * @param hw Hardware context.
+ * @param license 32-bit license value.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success.
+ */
+static ocs_hw_rtn_e
+ocs_hw_set_eth_license(ocs_hw_t *hw, uint32_t license)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	char cmd[OCS_HW_DMTF_CLP_CMD_MAX];
+	ocs_dma_t dma_cmd;
+	ocs_dma_t dma_resp;
+
+	/* only for lancer right now */
+	if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) {
+		ocs_log_test(hw->os, "Function only supported for I/F type 2\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	ocs_snprintf(cmd, OCS_HW_DMTF_CLP_CMD_MAX, "set / OEMELX_Ethernet_License=%X", license);
+	/* allocate DMA for command  */
+	if (ocs_dma_alloc(hw->os, &dma_cmd, ocs_strlen(cmd)+1, 4096)) {
+		ocs_log_err(hw->os, "malloc failed\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+	ocs_memset(dma_cmd.virt, 0, ocs_strlen(cmd)+1);
+	ocs_memcpy(dma_cmd.virt, cmd, ocs_strlen(cmd));
+
+	/* allocate DMA for response */
+	if (ocs_dma_alloc(hw->os, &dma_resp, OCS_HW_DMTF_CLP_RSP_MAX, 4096)) {
+		ocs_log_err(hw->os, "malloc failed\n");
+		ocs_dma_free(hw->os, &dma_cmd);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* send DMTF CLP command mbx and poll */
+	if (ocs_hw_exec_dmtf_clp_cmd(hw, &dma_cmd, &dma_resp, OCS_CMD_POLL, NULL, NULL)) {
+		ocs_log_err(hw->os, "CLP cmd=\"%s\" failed\n", (char *)dma_cmd.virt);
+		rc = OCS_HW_RTN_ERROR;
+	}
+
+	ocs_dma_free(hw->os, &dma_cmd);
+	ocs_dma_free(hw->os, &dma_resp);
+	return rc;
+}
+
+/**
+ * @brief Callback argument structure for the DMTF CLP commands.
+ */
+typedef struct ocs_hw_clp_cb_arg_s {
+	ocs_hw_dmtf_clp_cb_t cb;
+	ocs_dma_t *dma_resp;
+	int32_t status;
+	uint32_t opts;
+	void *arg;
+} ocs_hw_clp_cb_arg_t;
+
+/**
+ * @brief Execute the DMTF CLP command.
+ *
+ * @param hw Hardware context.
+ * @param dma_cmd DMA buffer containing the CLP command.
+ * @param dma_resp DMA buffer that will contain the response (if successful).
+ * @param opts Mailbox command options (such as OCS_CMD_NOWAIT and POLL).
+ * @param cb Callback function.
+ * @param arg Callback argument.
+ *
+ * @return Returns the number of bytes written to the response
+ * buffer on success, or a negative value if failed.
+ */
+static ocs_hw_rtn_e
+ocs_hw_exec_dmtf_clp_cmd(ocs_hw_t *hw, ocs_dma_t *dma_cmd, ocs_dma_t *dma_resp, uint32_t opts, ocs_hw_dmtf_clp_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	ocs_hw_clp_cb_arg_t *cb_arg;
+	uint8_t *mbxdata;
+
+	/* allocate DMA for mailbox */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* allocate memory for callback argument */
+	cb_arg = ocs_malloc(hw->os, sizeof(*cb_arg), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+	cb_arg->dma_resp = dma_resp;
+	cb_arg->opts = opts;
+
+	/* Send the HW command */
+	if (sli_cmd_dmtf_exec_clp_cmd(&hw->sli, mbxdata, SLI4_BMBX_SIZE,
+				      dma_cmd, dma_resp)) {
+		rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_dmtf_clp_cb, cb_arg);
+
+		if (opts == OCS_CMD_POLL && rc == OCS_HW_RTN_SUCCESS) {
+			/* if we're polling, copy response and invoke callback to
+			 * parse result */
+			ocs_memcpy(mbxdata, hw->sli.bmbx.virt, SLI4_BMBX_SIZE);
+			ocs_hw_dmtf_clp_cb(hw, 0, mbxdata, cb_arg);
+
+			/* set rc to resulting or "parsed" status */
+			rc = cb_arg->status;
+		}
+
+		/* if failed, or polling, free memory here */
+		if (opts == OCS_CMD_POLL || rc != OCS_HW_RTN_SUCCESS) {
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_test(hw->os, "ocs_hw_command failed\n");
+			}
+			ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+			ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+		}
+	} else {
+		ocs_log_test(hw->os, "sli_cmd_dmtf_exec_clp_cmd failed\n");
+		rc = OCS_HW_RTN_ERROR;
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+	}
+
+	return rc;
+}
+
+
+/**
+ * @brief Called when the DMTF CLP command completes.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return None.
+ *
+ */
+static void
+ocs_hw_dmtf_clp_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	int32_t cb_status = 0;
+	sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe;
+	sli4_res_dmtf_exec_clp_cmd_t *clp_rsp = (sli4_res_dmtf_exec_clp_cmd_t *) mbox_rsp->payload.embed;
+	ocs_hw_clp_cb_arg_t *cb_arg = arg;
+	uint32_t result_len = 0;
+	int32_t stat_len;
+	char stat_str[8];
+
+	/* there are several status codes here, check them all and condense
+	 * into a single callback status
+	 */
+	if (status || mbox_rsp->hdr.status || clp_rsp->clp_status) {
+		ocs_log_debug(hw->os, "status=x%x/x%x/x%x  addl=x%x clp=x%x detail=x%x\n",
+			status,
+			mbox_rsp->hdr.status,
+			clp_rsp->hdr.status,
+			clp_rsp->hdr.additional_status,
+			clp_rsp->clp_status,
+			clp_rsp->clp_detailed_status);
+		if (status) {
+			cb_status = status;
+		} else if (mbox_rsp->hdr.status) {
+			cb_status = mbox_rsp->hdr.status;
+		} else {
+			cb_status = clp_rsp->clp_status;
+		}
+	} else {
+		result_len = clp_rsp->resp_length;
+	}
+
+	if (cb_status) {
+		goto ocs_hw_cb_dmtf_clp_done;
+	}
+
+	if ((result_len == 0) || (cb_arg->dma_resp->size < result_len)) {
+		ocs_log_test(hw->os, "Invalid response length: resp_len=%zu result len=%d\n",
+			     cb_arg->dma_resp->size, result_len);
+		cb_status = -1;
+		goto ocs_hw_cb_dmtf_clp_done;
+	}
+
+	/* parse CLP response to get status */
+	stat_len = ocs_hw_clp_resp_get_value(hw, "status", stat_str,
+					      sizeof(stat_str),
+					      cb_arg->dma_resp->virt,
+					      result_len);
+
+	if (stat_len <= 0) {
+		ocs_log_test(hw->os, "failed to get status %d\n", stat_len);
+		cb_status = -1;
+		goto ocs_hw_cb_dmtf_clp_done;
+	}
+
+	if (ocs_strcmp(stat_str, "0") != 0) {
+		ocs_log_test(hw->os, "CLP status indicates failure=%s\n", stat_str);
+		cb_status = -1;
+		goto ocs_hw_cb_dmtf_clp_done;
+	}
+
+ocs_hw_cb_dmtf_clp_done:
+
+	/* save status in cb_arg for callers with NULL cb's + polling */
+	cb_arg->status = cb_status;
+	if (cb_arg->cb) {
+		cb_arg->cb(hw, cb_status, result_len, cb_arg->arg);
+	}
+	/* if polling, caller will free memory */
+	if (cb_arg->opts != OCS_CMD_POLL) {
+		ocs_free(hw->os, cb_arg, sizeof(*cb_arg));
+		ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	}
+}
+
+/**
+ * @brief Parse the CLP result and get the value corresponding to the given
+ * keyword.
+ *
+ * @param hw Hardware context.
+ * @param keyword CLP keyword for which the value is returned.
+ * @param value Location to which the resulting value is copied.
+ * @param value_len Length of the value parameter.
+ * @param resp Pointer to the response buffer that is searched
+ * for the keyword and value.
+ * @param resp_len Length of response buffer passed in.
+ *
+ * @return Returns the number of bytes written to the value
+ * buffer on success, or a negative vaue on failure.
+ */
+static int32_t
+ocs_hw_clp_resp_get_value(ocs_hw_t *hw, const char *keyword, char *value, uint32_t value_len, const char *resp, uint32_t resp_len)
+{
+	char *start = NULL;
+	char *end = NULL;
+
+	/* look for specified keyword in string */
+	start = ocs_strstr(resp, keyword);
+	if (start == NULL) {
+		ocs_log_test(hw->os, "could not find keyword=%s in CLP response\n",
+			     keyword);
+		return -1;
+	}
+
+	/* now look for '=' and go one past */
+	start = ocs_strchr(start, '=');
+	if (start == NULL) {
+		ocs_log_test(hw->os, "could not find \'=\' in CLP response for keyword=%s\n",
+			     keyword);
+		return -1;
+	}
+	start++;
+
+	/* \r\n terminates value */
+	end = ocs_strstr(start, "\r\n");
+	if (end == NULL) {
+		ocs_log_test(hw->os, "could not find \\r\\n for keyword=%s in CLP response\n",
+			     keyword);
+		return -1;
+	}
+
+	/* make sure given result array is big enough */
+	if ((end - start + 1) > value_len) {
+		ocs_log_test(hw->os, "value len=%d not large enough for actual=%ld\n",
+			     value_len, (end-start));
+		return -1;
+	}
+
+	ocs_strncpy(value, start, (end - start));
+	value[end-start] = '\0';
+	return (end-start+1);
+}
+
+/**
+ * @brief Cause chip to enter an unrecoverable error state.
+ *
+ * @par Description
+ * Cause chip to enter an unrecoverable error state. This is
+ * used when detecting unexpected FW behavior so that the FW can be
+ * hwted from the driver as soon as the error is detected.
+ *
+ * @param hw Hardware context.
+ * @param dump Generate dump as part of reset.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ *
+ */
+ocs_hw_rtn_e
+ocs_hw_raise_ue(ocs_hw_t *hw, uint8_t dump)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	if (sli_raise_ue(&hw->sli, dump) != 0) {
+		rc = OCS_HW_RTN_ERROR;
+	} else {
+		if (hw->state != OCS_HW_STATE_UNINITIALIZED) {
+			hw->state = OCS_HW_STATE_QUEUES_ALLOCATED;
+		}
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Called when the OBJECT_GET command completes.
+ *
+ * @par Description
+ * Get the number of bytes actually written out of the response, free the mailbox
+ * that was malloc'd by ocs_hw_dump_get(), then call the callback
+ * and pass the status and bytes read.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ * The callback function prototype is <tt>void cb(int32_t status, uint32_t bytes_read)</tt>.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_dump_get(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe;
+	sli4_res_common_read_object_t* rd_obj_rsp = (sli4_res_common_read_object_t*) mbox_rsp->payload.embed;
+	ocs_hw_dump_get_cb_arg_t *cb_arg = arg;
+	uint32_t bytes_read;
+	uint8_t eof;
+
+	bytes_read = rd_obj_rsp->actual_read_length;
+	eof = rd_obj_rsp->eof;
+
+	if (cb_arg) {
+		if (cb_arg->cb) {
+			if ((status == 0) && mbox_rsp->hdr.status) {
+				status = mbox_rsp->hdr.status;
+			}
+			cb_arg->cb(status, bytes_read, eof, cb_arg->arg);
+		}
+
+		ocs_free(hw->os, cb_arg->mbox_cmd, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_get_cb_arg_t));
+	}
+
+	return 0;
+}
+
+
+/**
+ * @brief Read a dump image to the host.
+ *
+ * @par Description
+ * Creates a SLI_CONFIG mailbox command, fills in the correct values to read a
+ * dump image chunk, then sends the command with the ocs_hw_command(). On completion,
+ * the callback function ocs_hw_cb_dump_get() gets called to free the mailbox
+ * and signal the caller that the read has completed.
+ *
+ * @param hw Hardware context.
+ * @param dma DMA structure to transfer the dump chunk into.
+ * @param size Size of the dump chunk.
+ * @param offset Offset, in bytes, from the beginning of the dump.
+ * @param cb Pointer to a callback function that is called when the command completes.
+ * The callback function prototype is
+ * <tt>void cb(int32_t status, uint32_t bytes_read, uint8_t eof, void *arg)</tt>.
+ * @param arg Pointer to be passed to the callback function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_dump_get(ocs_hw_t *hw, ocs_dma_t *dma, uint32_t size, uint32_t offset, ocs_hw_dump_get_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	uint8_t *mbxdata;
+	ocs_hw_dump_get_cb_arg_t *cb_arg;
+	uint32_t opts = (hw->state == OCS_HW_STATE_ACTIVE ? OCS_CMD_NOWAIT : OCS_CMD_POLL);
+
+	if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) {
+		ocs_log_test(hw->os, "Function only supported for I/F type 2\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (1 != sli_dump_is_present(&hw->sli)) {
+		ocs_log_test(hw->os, "No dump is present\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (1 == sli_reset_required(&hw->sli)) {
+		ocs_log_test(hw->os, "device reset required\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_dump_get_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+	cb_arg->mbox_cmd = mbxdata;
+
+	if (sli_cmd_common_read_object(&hw->sli, mbxdata, SLI4_BMBX_SIZE,
+			size, offset, "/dbg/dump.bin", dma)) {
+		rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_cb_dump_get, cb_arg);
+		if (rc == 0 && opts == OCS_CMD_POLL) {
+			ocs_memcpy(mbxdata, hw->sli.bmbx.virt, SLI4_BMBX_SIZE);
+			rc = ocs_hw_cb_dump_get(hw, 0, mbxdata, cb_arg);
+		}
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "COMMON_READ_OBJECT failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_get_cb_arg_t));
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Called when the OBJECT_DELETE command completes.
+ *
+ * @par Description
+ * Free the mailbox that was malloc'd
+ * by ocs_hw_dump_clear(), then call the callback and pass the status.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ * The callback function prototype is <tt>void cb(int32_t status, void *arg)</tt>.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_dump_clear(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	ocs_hw_dump_clear_cb_arg_t *cb_arg = arg;
+	sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe;
+
+	if (cb_arg) {
+		if (cb_arg->cb) {
+			if ((status == 0) && mbox_rsp->hdr.status) {
+				status = mbox_rsp->hdr.status;
+			}
+			cb_arg->cb(status, cb_arg->arg);
+		}
+
+		ocs_free(hw->os, cb_arg->mbox_cmd, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_clear_cb_arg_t));
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Clear a dump image from the device.
+ *
+ * @par Description
+ * Creates a SLI_CONFIG mailbox command, fills it with the correct values to clear
+ * the dump, then sends the command with ocs_hw_command(). On completion,
+ * the callback function ocs_hw_cb_dump_clear() gets called to free the mailbox
+ * and to signal the caller that the write has completed.
+ *
+ * @param hw Hardware context.
+ * @param cb Pointer to a callback function that is called when the command completes.
+ * The callback function prototype is
+ * <tt>void cb(int32_t status, uint32_t bytes_written, void *arg)</tt>.
+ * @param arg Pointer to be passed to the callback function.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_dump_clear(ocs_hw_t *hw, ocs_hw_dump_clear_cb_t cb, void *arg)
+{
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+	uint8_t *mbxdata;
+	ocs_hw_dump_clear_cb_arg_t *cb_arg;
+	uint32_t opts = (hw->state == OCS_HW_STATE_ACTIVE ? OCS_CMD_NOWAIT : OCS_CMD_POLL);
+
+	if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(&hw->sli)) {
+		ocs_log_test(hw->os, "Function only supported for I/F type 2\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_dump_clear_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = arg;
+	cb_arg->mbox_cmd = mbxdata;
+
+	if (sli_cmd_common_delete_object(&hw->sli, mbxdata, SLI4_BMBX_SIZE,
+			"/dbg/dump.bin")) {
+		rc = ocs_hw_command(hw, mbxdata, opts, ocs_hw_cb_dump_clear, cb_arg);
+		if (rc == 0 && opts == OCS_CMD_POLL) {
+			ocs_memcpy(mbxdata, hw->sli.bmbx.virt, SLI4_BMBX_SIZE);
+			rc = ocs_hw_cb_dump_clear(hw, 0, mbxdata, cb_arg);
+		}
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "COMMON_DELETE_OBJECT failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_dump_clear_cb_arg_t));
+	}
+
+	return rc;
+}
+
+typedef struct ocs_hw_get_port_protocol_cb_arg_s {
+	ocs_get_port_protocol_cb_t cb;
+	void *arg;
+	uint32_t pci_func;
+	ocs_dma_t payload;
+} ocs_hw_get_port_protocol_cb_arg_t;
+
+/**
+ * @brief Called for the completion of get_port_profile for a
+ *        user request.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE.
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_get_port_protocol_cb(ocs_hw_t *hw, int32_t status,
+			    uint8_t *mqe, void *arg)
+{
+	ocs_hw_get_port_protocol_cb_arg_t *cb_arg = arg;
+	ocs_dma_t *payload = &(cb_arg->payload);
+	sli4_res_common_get_profile_config_t* response = (sli4_res_common_get_profile_config_t*) payload->virt;
+	ocs_hw_port_protocol_e port_protocol;
+	int num_descriptors;
+	sli4_resource_descriptor_v1_t *desc_p;
+	sli4_pcie_resource_descriptor_v1_t *pcie_desc_p;
+	int i;
+
+	port_protocol = OCS_HW_PORT_PROTOCOL_OTHER;
+
+	num_descriptors = response->desc_count;
+	desc_p = (sli4_resource_descriptor_v1_t *)response->desc;
+	for (i=0; i<num_descriptors; i++) {
+		if (desc_p->descriptor_type == SLI4_RESOURCE_DESCRIPTOR_TYPE_PCIE) {
+			pcie_desc_p = (sli4_pcie_resource_descriptor_v1_t*) desc_p;
+			if (pcie_desc_p->pf_number == cb_arg->pci_func) {
+				switch(pcie_desc_p->pf_type) {
+				case 0x02:
+					port_protocol = OCS_HW_PORT_PROTOCOL_ISCSI;
+					break;
+				case 0x04:
+					port_protocol = OCS_HW_PORT_PROTOCOL_FCOE;
+					break;
+				case 0x10:
+					port_protocol = OCS_HW_PORT_PROTOCOL_FC;
+					break;
+				default:
+					port_protocol = OCS_HW_PORT_PROTOCOL_OTHER;
+					break;
+				}
+			}
+		}
+
+		desc_p = (sli4_resource_descriptor_v1_t *) ((uint8_t *)desc_p + desc_p->descriptor_length);
+	}
+
+	if (cb_arg->cb) {
+		cb_arg->cb(status, port_protocol, cb_arg->arg);
+
+	}
+
+	ocs_dma_free(hw->os, &cb_arg->payload);
+	ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_port_protocol_cb_arg_t));
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	return 0;
+}
+
+/**
+ * @ingroup io
+ * @brief  Get the current port protocol.
+ * @par Description
+ * Issues a SLI4 COMMON_GET_PROFILE_CONFIG mailbox.  When the
+ * command completes the provided mgmt callback function is
+ * called.
+ *
+ * @param hw Hardware context.
+ * @param pci_func PCI function to query for current protocol.
+ * @param cb Callback function to be called when the command completes.
+ * @param ul_arg An argument that is passed to the callback function.
+ *
+ * @return
+ * - OCS_HW_RTN_SUCCESS on success.
+ * - OCS_HW_RTN_NO_MEMORY if a malloc fails.
+ * - OCS_HW_RTN_NO_RESOURCES if unable to get a command
+ *   context.
+ * - OCS_HW_RTN_ERROR on any other error.
+ */
+ocs_hw_rtn_e
+ocs_hw_get_port_protocol(ocs_hw_t *hw, uint32_t pci_func,
+	ocs_get_port_protocol_cb_t cb, void* ul_arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_get_port_protocol_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* Only supported on Skyhawk */
+	if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_port_protocol_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = ul_arg;
+	cb_arg->pci_func = pci_func;
+
+	/* dma_mem holds the non-embedded portion */
+	if (ocs_dma_alloc(hw->os, &cb_arg->payload, 4096, 4)) {
+		ocs_log_err(hw->os, "Failed to allocate DMA buffer\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_port_protocol_cb_arg_t));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if (sli_cmd_common_get_profile_config(&hw->sli, mbxdata, SLI4_BMBX_SIZE, &cb_arg->payload)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_port_protocol_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "GET_PROFILE_CONFIG failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t));
+		ocs_dma_free(hw->os, &cb_arg->payload);
+	}
+
+	return rc;
+
+}
+
+typedef struct ocs_hw_set_port_protocol_cb_arg_s {
+	ocs_set_port_protocol_cb_t cb;
+	void *arg;
+	ocs_dma_t payload;
+	uint32_t new_protocol;
+	uint32_t pci_func;
+} ocs_hw_set_port_protocol_cb_arg_t;
+
+/**
+ * @brief Called for the completion of set_port_profile for a
+ *        user request.
+ *
+ * @par Description
+ * This is the second of two callbacks for the set_port_protocol
+ * function. The set operation is a read-modify-write. This
+ * callback is called when the write (SET_PROFILE_CONFIG)
+ * completes.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE.
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_hw_set_port_protocol_cb2(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_set_port_protocol_cb_arg_t *cb_arg = arg;
+
+	if (cb_arg->cb) {
+		cb_arg->cb( status, cb_arg->arg);
+	}
+
+	ocs_dma_free(hw->os, &(cb_arg->payload));
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	ocs_free(hw->os, arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t));
+
+	return 0;
+}
+
+/**
+ * @brief Called for the completion of set_port_profile for a
+ *        user request.
+ *
+ * @par Description
+ * This is the first of two callbacks for the set_port_protocol
+ * function.  The set operation is a read-modify-write.  This
+ * callback is called when the read completes
+ * (GET_PROFILE_CONFG).  It will updated the resource
+ * descriptors, then queue the write (SET_PROFILE_CONFIG).
+ *
+ * On entry there are three memory areas that were allocated by
+ * ocs_hw_set_port_protocol.  If a failure is detected in this
+ * function those need to be freed.  If this function succeeds
+ * it allocates three more areas.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return Returns 0 on success, or a non-zero value otherwise.
+ */
+static int32_t
+ocs_hw_set_port_protocol_cb1(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_set_port_protocol_cb_arg_t *cb_arg = arg;
+	ocs_dma_t *payload = &(cb_arg->payload);
+	sli4_res_common_get_profile_config_t* response = (sli4_res_common_get_profile_config_t*) payload->virt;
+	int num_descriptors;
+	sli4_resource_descriptor_v1_t *desc_p;
+	sli4_pcie_resource_descriptor_v1_t *pcie_desc_p;
+	int i;
+	ocs_hw_set_port_protocol_cb_arg_t *new_cb_arg;
+	ocs_hw_port_protocol_e new_protocol;
+	uint8_t *dst;
+	sli4_isap_resouce_descriptor_v1_t *isap_desc_p;
+	uint8_t *mbxdata;
+	int pci_descriptor_count;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	int num_fcoe_ports = 0;
+	int num_iscsi_ports = 0;
+
+	new_protocol = (ocs_hw_port_protocol_e)cb_arg->new_protocol;
+
+	num_descriptors = response->desc_count;
+
+	/* Count PCI descriptors */
+	pci_descriptor_count = 0;
+	desc_p = (sli4_resource_descriptor_v1_t *)response->desc;
+	for (i=0; i<num_descriptors; i++) {
+		if (desc_p->descriptor_type == SLI4_RESOURCE_DESCRIPTOR_TYPE_PCIE) {
+			++pci_descriptor_count;
+		}
+		desc_p = (sli4_resource_descriptor_v1_t *) ((uint8_t *)desc_p + desc_p->descriptor_length);
+	}
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	new_cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_port_protocol_cb_arg_t), OCS_M_NOWAIT);
+	if (new_cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	new_cb_arg->cb = cb_arg->cb;
+	new_cb_arg->arg = cb_arg->arg;
+
+	/* Allocate memory for the descriptors we're going to send.  This is
+	 * one for each PCI descriptor plus one ISAP descriptor. */
+	if (ocs_dma_alloc(hw->os, &new_cb_arg->payload, sizeof(sli4_req_common_set_profile_config_t) +
+			  (pci_descriptor_count * sizeof(sli4_pcie_resource_descriptor_v1_t)) +
+			  sizeof(sli4_isap_resouce_descriptor_v1_t), 4)) {
+		ocs_log_err(hw->os, "Failed to allocate DMA buffer\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, new_cb_arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	sli_cmd_common_set_profile_config(&hw->sli, mbxdata, SLI4_BMBX_SIZE,
+						   &new_cb_arg->payload,
+						   0, pci_descriptor_count+1, 1);
+
+	/* Point dst to the first descriptor entry in the SET_PROFILE_CONFIG command */
+	dst = (uint8_t *)&(((sli4_req_common_set_profile_config_t *) new_cb_arg->payload.virt)->desc);
+
+	/* Loop over all descriptors.  If the descriptor is a PCIe descriptor, copy it
+	 * to the SET_PROFILE_CONFIG command to be written back.  If it's the descriptor
+	 * that we're trying to change also set its pf_type.
+	 */
+	desc_p = (sli4_resource_descriptor_v1_t *)response->desc;
+	for (i=0; i<num_descriptors; i++) {
+		if (desc_p->descriptor_type == SLI4_RESOURCE_DESCRIPTOR_TYPE_PCIE) {
+			pcie_desc_p = (sli4_pcie_resource_descriptor_v1_t*) desc_p;
+			if (pcie_desc_p->pf_number == cb_arg->pci_func) {
+				/* This is the PCIe descriptor for this OCS instance.
+				 * Update it with the new pf_type */
+				switch(new_protocol) {
+				case OCS_HW_PORT_PROTOCOL_FC:
+					pcie_desc_p->pf_type = SLI4_PROTOCOL_FC;
+					break;
+				case OCS_HW_PORT_PROTOCOL_FCOE:
+					pcie_desc_p->pf_type = SLI4_PROTOCOL_FCOE;
+					break;
+				case OCS_HW_PORT_PROTOCOL_ISCSI:
+					pcie_desc_p->pf_type = SLI4_PROTOCOL_ISCSI;
+					break;
+				default:
+					pcie_desc_p->pf_type = SLI4_PROTOCOL_DEFAULT;
+					break;
+				}
+
+			}
+
+			if (pcie_desc_p->pf_type == SLI4_PROTOCOL_FCOE) {
+				++num_fcoe_ports;
+			}
+			if (pcie_desc_p->pf_type == SLI4_PROTOCOL_ISCSI) {
+				++num_iscsi_ports;
+			}
+			ocs_memcpy(dst, pcie_desc_p, sizeof(sli4_pcie_resource_descriptor_v1_t));
+			dst += sizeof(sli4_pcie_resource_descriptor_v1_t);
+		}
+
+		desc_p = (sli4_resource_descriptor_v1_t *) ((uint8_t *)desc_p + desc_p->descriptor_length);
+	}
+
+	/* Create an ISAP resource descriptor */
+	isap_desc_p = (sli4_isap_resouce_descriptor_v1_t*)dst;
+	isap_desc_p->descriptor_type = SLI4_RESOURCE_DESCRIPTOR_TYPE_ISAP;
+	isap_desc_p->descriptor_length = sizeof(sli4_isap_resouce_descriptor_v1_t);
+	if (num_iscsi_ports > 0) {
+		isap_desc_p->iscsi_tgt = 1;
+		isap_desc_p->iscsi_ini = 1;
+		isap_desc_p->iscsi_dif = 1;
+	}
+	if (num_fcoe_ports > 0) {
+		isap_desc_p->fcoe_tgt = 1;
+		isap_desc_p->fcoe_ini = 1;
+		isap_desc_p->fcoe_dif = 1;
+	}
+
+	/* At this point we're done with the memory allocated by ocs_port_set_protocol */
+	ocs_dma_free(hw->os, &cb_arg->payload);
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t));
+
+
+	/* Send a SET_PROFILE_CONFIG mailbox command with the new descriptors */
+	rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_port_protocol_cb2, new_cb_arg);
+	if (rc) {
+		ocs_log_err(hw->os, "Error posting COMMON_SET_PROFILE_CONFIG\n");
+		/* Call the upper level callback to report a failure */
+		if (new_cb_arg->cb) {
+			new_cb_arg->cb( rc, new_cb_arg->arg);
+		}
+
+		/* Free the memory allocated by this function */
+		ocs_dma_free(hw->os, &new_cb_arg->payload);
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, new_cb_arg, sizeof(ocs_hw_set_port_protocol_cb_arg_t));
+	}
+
+
+	return rc;
+}
+
+/**
+ * @ingroup io
+ * @brief  Set the port protocol.
+ * @par Description
+ * Setting the port protocol is a read-modify-write operation.
+ * This function submits a GET_PROFILE_CONFIG command to read
+ * the current settings.  The callback function will modify the
+ * settings and issue the write.
+ *
+ * On successful completion this function will have allocated
+ * two regular memory areas and one dma area which will need to
+ * get freed later in the callbacks.
+ *
+ * @param hw Hardware context.
+ * @param new_protocol New protocol to use.
+ * @param pci_func PCI function to configure.
+ * @param cb Callback function to be called when the command completes.
+ * @param ul_arg An argument that is passed to the callback function.
+ *
+ * @return
+ * - OCS_HW_RTN_SUCCESS on success.
+ * - OCS_HW_RTN_NO_MEMORY if a malloc fails.
+ * - OCS_HW_RTN_NO_RESOURCES if unable to get a command
+ *   context.
+ * - OCS_HW_RTN_ERROR on any other error.
+ */
+ocs_hw_rtn_e
+ocs_hw_set_port_protocol(ocs_hw_t *hw, ocs_hw_port_protocol_e new_protocol,
+		uint32_t pci_func, ocs_set_port_protocol_cb_t cb, void *ul_arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_set_port_protocol_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+
+	/* Only supported on Skyhawk */
+	if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_port_protocol_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = ul_arg;
+	cb_arg->new_protocol = new_protocol;
+	cb_arg->pci_func = pci_func;
+
+	/* dma_mem holds the non-embedded portion */
+	if (ocs_dma_alloc(hw->os, &cb_arg->payload, 4096, 4)) {
+		ocs_log_err(hw->os, "Failed to allocate DMA buffer\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_port_protocol_cb_arg_t));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if (sli_cmd_common_get_profile_config(&hw->sli, mbxdata, SLI4_BMBX_SIZE, &cb_arg->payload)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_port_protocol_cb1, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "GET_PROFILE_CONFIG failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_fw_write_cb_arg_t));
+		ocs_dma_free(hw->os, &cb_arg->payload);
+	}
+
+	return rc;
+}
+
+typedef struct ocs_hw_get_profile_list_cb_arg_s {
+	ocs_get_profile_list_cb_t cb;
+	void *arg;
+	ocs_dma_t payload;
+} ocs_hw_get_profile_list_cb_arg_t;
+
+/**
+ * @brief Called for the completion of get_profile_list for a
+ *        user request.
+ * @par Description
+ * This function is called when the COMMMON_GET_PROFILE_LIST
+ * mailbox completes.  The response will be in
+ * ctx->non_embedded_mem.virt.  This function parses the
+ * response and creates a ocs_hw_profile_list, then calls the
+ * mgmt_cb callback function and passes that list to it.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_get_profile_list_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_profile_list_t *list;
+	ocs_hw_get_profile_list_cb_arg_t *cb_arg = arg;
+	ocs_dma_t *payload = &(cb_arg->payload);
+	sli4_res_common_get_profile_list_t *response = (sli4_res_common_get_profile_list_t *)payload->virt;
+	int i;
+	int num_descriptors;
+
+	list = ocs_malloc(hw->os, sizeof(ocs_hw_profile_list_t), OCS_M_ZERO);
+	list->num_descriptors = response->profile_descriptor_count;
+
+	num_descriptors = list->num_descriptors;
+	if (num_descriptors > OCS_HW_MAX_PROFILES) {
+		num_descriptors = OCS_HW_MAX_PROFILES;
+	}
+
+	for (i=0; i<num_descriptors; i++) {
+		list->descriptors[i].profile_id = response->profile_descriptor[i].profile_id;
+		list->descriptors[i].profile_index = response->profile_descriptor[i].profile_index;
+		ocs_strcpy(list->descriptors[i].profile_description, (char *)response->profile_descriptor[i].profile_description);
+	}
+
+	if (cb_arg->cb) {
+		cb_arg->cb(status, list, cb_arg->arg);
+	} else {
+		ocs_free(hw->os, list, sizeof(*list));
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	ocs_dma_free(hw->os, &cb_arg->payload);
+	ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_profile_list_cb_arg_t));
+
+	return 0;
+}
+
+/**
+ * @ingroup io
+ * @brief  Get a list of available profiles.
+ * @par Description
+ * Issues a SLI-4 COMMON_GET_PROFILE_LIST mailbox.  When the
+ * command completes the provided mgmt callback function is
+ * called.
+ *
+ * @param hw Hardware context.
+ * @param cb Callback function to be called when the
+ *      	  command completes.
+ * @param ul_arg An argument that is passed to the callback
+ *      	 function.
+ *
+ * @return
+ * - OCS_HW_RTN_SUCCESS on success.
+ * - OCS_HW_RTN_NO_MEMORY if a malloc fails.
+ * - OCS_HW_RTN_NO_RESOURCES if unable to get a command
+ *   context.
+ * - OCS_HW_RTN_ERROR on any other error.
+ */
+ocs_hw_rtn_e
+ocs_hw_get_profile_list(ocs_hw_t *hw, ocs_get_profile_list_cb_t cb, void* ul_arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_get_profile_list_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* Only supported on Skyhawk */
+	if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_profile_list_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = ul_arg;
+
+	/* dma_mem holds the non-embedded portion */
+	if (ocs_dma_alloc(hw->os, &cb_arg->payload, sizeof(sli4_res_common_get_profile_list_t), 4)) {
+		ocs_log_err(hw->os, "Failed to allocate DMA buffer\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_profile_list_cb_arg_t));
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if (sli_cmd_common_get_profile_list(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 0, &cb_arg->payload)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_profile_list_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "GET_PROFILE_LIST failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_dma_free(hw->os, &cb_arg->payload);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_profile_list_cb_arg_t));
+	}
+
+	return rc;
+}
+
+typedef struct ocs_hw_get_active_profile_cb_arg_s {
+	ocs_get_active_profile_cb_t cb;
+	void *arg;
+} ocs_hw_get_active_profile_cb_arg_t;
+
+/**
+ * @brief Called for the completion of get_active_profile for a
+ *        user request.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_get_active_profile_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_get_active_profile_cb_arg_t *cb_arg = arg;
+	sli4_cmd_sli_config_t* mbox_rsp = (sli4_cmd_sli_config_t*) mqe;
+	sli4_res_common_get_active_profile_t* response = (sli4_res_common_get_active_profile_t*) mbox_rsp->payload.embed;
+	uint32_t active_profile;
+
+	active_profile = response->active_profile_id;
+
+	if (cb_arg->cb) {
+		cb_arg->cb(status, active_profile, cb_arg->arg);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_active_profile_cb_arg_t));
+
+	return 0;
+}
+
+/**
+ * @ingroup io
+ * @brief  Get the currently active profile.
+ * @par Description
+ * Issues a SLI-4 COMMON_GET_ACTIVE_PROFILE mailbox. When the
+ * command completes the provided mgmt callback function is
+ * called.
+ *
+ * @param hw Hardware context.
+ * @param cb Callback function to be called when the
+ *	     command completes.
+ * @param ul_arg An argument that is passed to the callback
+ *      	 function.
+ *
+ * @return
+ * - OCS_HW_RTN_SUCCESS on success.
+ * - OCS_HW_RTN_NO_MEMORY if a malloc fails.
+ * - OCS_HW_RTN_NO_RESOURCES if unable to get a command
+ *   context.
+ * - OCS_HW_RTN_ERROR on any other error.
+ */
+int32_t
+ocs_hw_get_active_profile(ocs_hw_t *hw, ocs_get_active_profile_cb_t cb, void* ul_arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_get_active_profile_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* Only supported on Skyhawk */
+	if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_active_profile_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = ul_arg;
+
+	if (sli_cmd_common_get_active_profile(&hw->sli, mbxdata, SLI4_BMBX_SIZE)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_active_profile_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "GET_ACTIVE_PROFILE failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_active_profile_cb_arg_t));
+	}
+
+	return rc;
+}
+
+typedef struct ocs_hw_get_nvparms_cb_arg_s {
+	ocs_get_nvparms_cb_t cb;
+	void *arg;
+} ocs_hw_get_nvparms_cb_arg_t;
+
+/**
+ * @brief Called for the completion of get_nvparms for a
+ *        user request.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE.
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_hw_get_nvparms_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_get_nvparms_cb_arg_t *cb_arg = arg;
+	sli4_cmd_read_nvparms_t* mbox_rsp = (sli4_cmd_read_nvparms_t*) mqe;
+
+	if (cb_arg->cb) {
+		cb_arg->cb(status, mbox_rsp->wwpn, mbox_rsp->wwnn, mbox_rsp->hard_alpa,
+				mbox_rsp->preferred_d_id, cb_arg->arg);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_nvparms_cb_arg_t));
+
+	return 0;
+}
+
+/**
+ * @ingroup io
+ * @brief  Read non-volatile parms.
+ * @par Description
+ * Issues a SLI-4 READ_NVPARMS mailbox. When the
+ * command completes the provided mgmt callback function is
+ * called.
+ *
+ * @param hw Hardware context.
+ * @param cb Callback function to be called when the
+ *	  command completes.
+ * @param ul_arg An argument that is passed to the callback
+ *	  function.
+ *
+ * @return
+ * - OCS_HW_RTN_SUCCESS on success.
+ * - OCS_HW_RTN_NO_MEMORY if a malloc fails.
+ * - OCS_HW_RTN_NO_RESOURCES if unable to get a command
+ *   context.
+ * - OCS_HW_RTN_ERROR on any other error.
+ */
+int32_t
+ocs_hw_get_nvparms(ocs_hw_t *hw, ocs_get_nvparms_cb_t cb, void* ul_arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_get_nvparms_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_get_nvparms_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = ul_arg;
+
+	if (sli_cmd_read_nvparms(&hw->sli, mbxdata, SLI4_BMBX_SIZE)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_get_nvparms_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "READ_NVPARMS failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_nvparms_cb_arg_t));
+	}
+
+	return rc;
+}
+
+typedef struct ocs_hw_set_nvparms_cb_arg_s {
+	ocs_set_nvparms_cb_t cb;
+	void *arg;
+} ocs_hw_set_nvparms_cb_arg_t;
+
+/**
+ * @brief Called for the completion of set_nvparms for a
+ *        user request.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE.
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_set_nvparms_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_set_nvparms_cb_arg_t *cb_arg = arg;
+
+	if (cb_arg->cb) {
+		cb_arg->cb(status, cb_arg->arg);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_nvparms_cb_arg_t));
+
+	return 0;
+}
+
+/**
+ * @ingroup io
+ * @brief  Write non-volatile parms.
+ * @par Description
+ * Issues a SLI-4 WRITE_NVPARMS mailbox. When the
+ * command completes the provided mgmt callback function is
+ * called.
+ *
+ * @param hw Hardware context.
+ * @param cb Callback function to be called when the
+ *	  command completes.
+ * @param wwpn Port's WWPN in big-endian order, or NULL to use default.
+ * @param wwnn Port's WWNN in big-endian order, or NULL to use default.
+ * @param hard_alpa A hard AL_PA address setting used during loop
+ * initialization. If no hard AL_PA is required, set to 0.
+ * @param preferred_d_id A preferred D_ID address setting
+ * that may be overridden with the CONFIG_LINK mailbox command.
+ * If there is no preference, set to 0.
+ * @param ul_arg An argument that is passed to the callback
+ *	  function.
+ *
+ * @return
+ * - OCS_HW_RTN_SUCCESS on success.
+ * - OCS_HW_RTN_NO_MEMORY if a malloc fails.
+ * - OCS_HW_RTN_NO_RESOURCES if unable to get a command
+ *   context.
+ * - OCS_HW_RTN_ERROR on any other error.
+ */
+int32_t
+ocs_hw_set_nvparms(ocs_hw_t *hw, ocs_set_nvparms_cb_t cb, uint8_t *wwpn,
+		uint8_t *wwnn, uint8_t hard_alpa, uint32_t preferred_d_id, void* ul_arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_set_nvparms_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_nvparms_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = ul_arg;
+
+	if (sli_cmd_write_nvparms(&hw->sli, mbxdata, SLI4_BMBX_SIZE, wwpn, wwnn, hard_alpa, preferred_d_id)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_nvparms_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "SET_NVPARMS failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_nvparms_cb_arg_t));
+	}
+
+	return rc;
+}
+
+
+
+/**
+ * @brief Called to obtain the count for the specified type.
+ *
+ * @param hw Hardware context.
+ * @param io_count_type IO count type (inuse, free, wait_free).
+ *
+ * @return Returns the number of IOs on the specified list type.
+ */
+uint32_t
+ocs_hw_io_get_count(ocs_hw_t *hw, ocs_hw_io_count_type_e io_count_type)
+{
+	ocs_hw_io_t *io = NULL;
+	uint32_t count = 0;
+
+	ocs_lock(&hw->io_lock);
+
+	switch (io_count_type) {
+	case OCS_HW_IO_INUSE_COUNT :
+		ocs_list_foreach(&hw->io_inuse, io) {
+			count++;
+		}
+		break;
+	case OCS_HW_IO_FREE_COUNT :
+		 ocs_list_foreach(&hw->io_free, io) {
+			 count++;
+		 }
+		 break;
+	case OCS_HW_IO_WAIT_FREE_COUNT :
+		 ocs_list_foreach(&hw->io_wait_free, io) {
+			 count++;
+		 }
+		 break;
+	case OCS_HW_IO_PORT_OWNED_COUNT:
+		 ocs_list_foreach(&hw->io_port_owned, io) {
+			 count++;
+		 }
+		 break;
+	case OCS_HW_IO_N_TOTAL_IO_COUNT :
+		count = hw->config.n_io;
+		break;
+	}
+
+	ocs_unlock(&hw->io_lock);
+
+	return count;
+}
+
+/**
+ * @brief Called to obtain the count of produced RQs.
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns the number of RQs produced.
+ */
+uint32_t
+ocs_hw_get_rqes_produced_count(ocs_hw_t *hw)
+{
+	uint32_t count = 0;
+	uint32_t i;
+	uint32_t j;
+
+	for (i = 0; i < hw->hw_rq_count; i++) {
+		hw_rq_t *rq = hw->hw_rq[i];
+		if (rq->rq_tracker != NULL) {
+			for (j = 0; j < rq->entry_count; j++) {
+				if (rq->rq_tracker[j] != NULL) {
+					count++;
+				}
+			}
+		}
+	}
+
+	return count;
+}
+
+typedef struct ocs_hw_set_active_profile_cb_arg_s {
+	ocs_set_active_profile_cb_t cb;
+	void *arg;
+} ocs_hw_set_active_profile_cb_arg_t;
+
+/**
+ * @brief Called for the completion of set_active_profile for a
+ *        user request.
+ *
+ * @param hw Hardware context.
+ * @param status The status from the MQE
+ * @param mqe Pointer to mailbox command buffer.
+ * @param arg Pointer to a callback argument.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_set_active_profile_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_set_active_profile_cb_arg_t *cb_arg = arg;
+
+	if (cb_arg->cb) {
+		cb_arg->cb(status, cb_arg->arg);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	ocs_free(hw->os, cb_arg, sizeof(ocs_hw_get_active_profile_cb_arg_t));
+
+	return 0;
+}
+
+/**
+ * @ingroup io
+ * @brief  Set the currently active profile.
+ * @par Description
+ * Issues a SLI4 COMMON_GET_ACTIVE_PROFILE mailbox. When the
+ * command completes the provided mgmt callback function is
+ * called.
+ *
+ * @param hw Hardware context.
+ * @param profile_id Profile ID to activate.
+ * @param cb Callback function to be called when the command completes.
+ * @param ul_arg An argument that is passed to the callback function.
+ *
+ * @return
+ * - OCS_HW_RTN_SUCCESS on success.
+ * - OCS_HW_RTN_NO_MEMORY if a malloc fails.
+ * - OCS_HW_RTN_NO_RESOURCES if unable to get a command
+ *   context.
+ * - OCS_HW_RTN_ERROR on any other error.
+ */
+int32_t
+ocs_hw_set_active_profile(ocs_hw_t *hw, ocs_set_active_profile_cb_t cb, uint32_t profile_id, void* ul_arg)
+{
+	uint8_t *mbxdata;
+	ocs_hw_set_active_profile_cb_arg_t *cb_arg;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+
+	/* Only supported on Skyhawk */
+	if (sli_get_if_type(&hw->sli) != SLI4_IF_TYPE_BE3_SKH_PF) {
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* mbxdata holds the header of the command */
+	mbxdata = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mbxdata == NULL) {
+		ocs_log_err(hw->os, "failed to malloc mbox\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+
+	/* cb_arg holds the data that will be passed to the callback on completion */
+	cb_arg = ocs_malloc(hw->os, sizeof(ocs_hw_set_active_profile_cb_arg_t), OCS_M_NOWAIT);
+	if (cb_arg == NULL) {
+		ocs_log_err(hw->os, "failed to malloc cb_arg\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	cb_arg->cb = cb;
+	cb_arg->arg = ul_arg;
+
+	if (sli_cmd_common_set_active_profile(&hw->sli, mbxdata, SLI4_BMBX_SIZE, 0, profile_id)) {
+		rc = ocs_hw_command(hw, mbxdata, OCS_CMD_NOWAIT, ocs_hw_set_active_profile_cb, cb_arg);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "SET_ACTIVE_PROFILE failed\n");
+		ocs_free(hw->os, mbxdata, SLI4_BMBX_SIZE);
+		ocs_free(hw->os, cb_arg, sizeof(ocs_hw_set_active_profile_cb_arg_t));
+	}
+
+	return rc;
+}
+
+
+
+/*
+ * Private functions
+ */
+
+/**
+ * @brief Update the queue hash with the ID and index.
+ *
+ * @param hash Pointer to hash table.
+ * @param id ID that was created.
+ * @param index The index into the hash object.
+ */
+static void
+ocs_hw_queue_hash_add(ocs_queue_hash_t *hash, uint16_t id, uint16_t index)
+{
+	uint32_t	hash_index = id & (OCS_HW_Q_HASH_SIZE - 1);
+
+	/*
+	 * Since the hash is always bigger than the number of queues, then we
+	 * never have to worry about an infinite loop.
+	 */
+	while(hash[hash_index].in_use) {
+		hash_index = (hash_index + 1) & (OCS_HW_Q_HASH_SIZE - 1);
+	}
+
+	/* not used, claim the entry */
+	hash[hash_index].id = id;
+	hash[hash_index].in_use = 1;
+	hash[hash_index].index = index;
+}
+
+/**
+ * @brief Find index given queue ID.
+ *
+ * @param hash Pointer to hash table.
+ * @param id ID to find.
+ *
+ * @return Returns the index into the HW cq array or -1 if not found.
+ */
+int32_t
+ocs_hw_queue_hash_find(ocs_queue_hash_t *hash, uint16_t id)
+{
+	int32_t	rc = -1;
+	int32_t	index = id & (OCS_HW_Q_HASH_SIZE - 1);
+
+	/*
+	 * Since the hash is always bigger than the maximum number of Qs, then we
+	 * never have to worry about an infinite loop. We will always find an
+	 * unused entry.
+	 */
+	do {
+		if (hash[index].in_use &&
+		    hash[index].id == id) {
+			rc = hash[index].index;
+		} else {
+			index = (index + 1) & (OCS_HW_Q_HASH_SIZE - 1);
+		}
+	} while(rc == -1 && hash[index].in_use);
+
+	return rc;
+}
+
+static int32_t
+ocs_hw_domain_add(ocs_hw_t *hw, ocs_domain_t *domain)
+{
+	int32_t		rc = OCS_HW_RTN_ERROR;
+	uint16_t	fcfi = UINT16_MAX;
+
+	if ((hw == NULL) || (domain == NULL)) {
+		ocs_log_err(NULL, "bad parameter hw=%p domain=%p\n",
+				hw, domain);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	fcfi = domain->fcf_indicator;
+
+	if (fcfi < SLI4_MAX_FCFI) {
+		uint16_t	fcf_index = UINT16_MAX;
+
+		ocs_log_debug(hw->os, "adding domain %p @ %#x\n",
+				domain, fcfi);
+		hw->domains[fcfi] = domain;
+
+		/* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */
+		if (hw->workaround.override_fcfi) {
+			if (hw->first_domain_idx < 0) {
+				hw->first_domain_idx = fcfi;
+			}
+		}
+
+		fcf_index = domain->fcf;
+
+		if (fcf_index < SLI4_MAX_FCF_INDEX) {
+			ocs_log_debug(hw->os, "adding map of FCF index %d to FCFI %d\n",
+				      fcf_index, fcfi);
+			hw->fcf_index_fcfi[fcf_index] = fcfi;
+			rc = OCS_HW_RTN_SUCCESS;
+		} else {
+			ocs_log_test(hw->os, "FCF index %d out of range (max %d)\n",
+				     fcf_index, SLI4_MAX_FCF_INDEX);
+			hw->domains[fcfi] = NULL;
+		}
+	} else {
+		ocs_log_test(hw->os, "FCFI %#x out of range (max %#x)\n",
+				fcfi, SLI4_MAX_FCFI);
+	}
+
+	return rc;
+}
+
+static int32_t
+ocs_hw_domain_del(ocs_hw_t *hw, ocs_domain_t *domain)
+{
+	int32_t		rc = OCS_HW_RTN_ERROR;
+	uint16_t	fcfi = UINT16_MAX;
+
+	if ((hw == NULL) || (domain == NULL)) {
+		ocs_log_err(NULL, "bad parameter hw=%p domain=%p\n",
+				hw, domain);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	fcfi = domain->fcf_indicator;
+
+	if (fcfi < SLI4_MAX_FCFI) {
+		uint16_t	fcf_index = UINT16_MAX;
+
+		ocs_log_debug(hw->os, "deleting domain %p @ %#x\n",
+				domain, fcfi);
+
+		if (domain != hw->domains[fcfi]) {
+			ocs_log_test(hw->os, "provided domain %p does not match stored domain %p\n",
+				     domain, hw->domains[fcfi]);
+			return OCS_HW_RTN_ERROR;
+		}
+
+		hw->domains[fcfi] = NULL;
+
+		/* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */
+		if (hw->workaround.override_fcfi) {
+			if (hw->first_domain_idx == fcfi) {
+				hw->first_domain_idx = -1;
+			}
+		}
+
+		fcf_index = domain->fcf;
+
+		if (fcf_index < SLI4_MAX_FCF_INDEX) {
+			if (hw->fcf_index_fcfi[fcf_index] == fcfi) {
+				hw->fcf_index_fcfi[fcf_index] = 0;
+				rc = OCS_HW_RTN_SUCCESS;
+			} else {
+				ocs_log_test(hw->os, "indexed FCFI %#x doesn't match provided %#x @ %d\n",
+					     hw->fcf_index_fcfi[fcf_index], fcfi, fcf_index);
+			}
+		} else {
+			ocs_log_test(hw->os, "FCF index %d out of range (max %d)\n",
+				     fcf_index, SLI4_MAX_FCF_INDEX);
+		}
+	} else {
+		ocs_log_test(hw->os, "FCFI %#x out of range (max %#x)\n",
+				fcfi, SLI4_MAX_FCFI);
+	}
+
+	return rc;
+}
+
+ocs_domain_t *
+ocs_hw_domain_get(ocs_hw_t *hw, uint16_t fcfi)
+{
+
+	if (hw == NULL) {
+		ocs_log_err(NULL, "bad parameter hw=%p\n", hw);
+		return NULL;
+	}
+
+	if (fcfi < SLI4_MAX_FCFI) {
+		return hw->domains[fcfi];
+	} else {
+		ocs_log_test(hw->os, "FCFI %#x out of range (max %#x)\n",
+				fcfi, SLI4_MAX_FCFI);
+		return NULL;
+	}
+}
+
+static ocs_domain_t *
+ocs_hw_domain_get_indexed(ocs_hw_t *hw, uint16_t fcf_index)
+{
+
+	if (hw == NULL) {
+		ocs_log_err(NULL, "bad parameter hw=%p\n", hw);
+		return NULL;
+	}
+
+	if (fcf_index < SLI4_MAX_FCF_INDEX) {
+		return ocs_hw_domain_get(hw, hw->fcf_index_fcfi[fcf_index]);
+	} else {
+		ocs_log_test(hw->os, "FCF index %d out of range (max %d)\n",
+			     fcf_index, SLI4_MAX_FCF_INDEX);
+		return NULL;
+	}
+}
+
+/**
+ * @brief Quaratine an IO by taking a reference count and adding it to the
+ *        quarantine list. When the IO is popped from the list then the
+ *        count is released and the IO MAY be freed depending on whether
+ *        it is still referenced by the IO.
+ *
+ *        @n @b Note: BZ 160124 - If this is a target write or an initiator read using
+ *        DIF, then we must add the XRI to a quarantine list until we receive
+ *        4 more completions of this same type.
+ *
+ * @param hw Hardware context.
+ * @param wq Pointer to the WQ associated with the IO object to quarantine.
+ * @param io Pointer to the io object to quarantine.
+ */
+static void
+ocs_hw_io_quarantine(ocs_hw_t *hw, hw_wq_t *wq, ocs_hw_io_t *io)
+{
+	ocs_quarantine_info_t *q_info = &wq->quarantine_info;
+	uint32_t	index;
+	ocs_hw_io_t	*free_io = NULL;
+
+	/* return if the QX bit was clear */
+	if (!io->quarantine) {
+		return;
+	}
+
+	/* increment the IO refcount to prevent it from being freed before the quarantine is over */
+	if (ocs_ref_get_unless_zero(&io->ref) == 0) {
+		/* command no longer active */
+		ocs_log_debug(hw ? hw->os : NULL,
+			      "io not active xri=0x%x tag=0x%x\n",
+			      io->indicator, io->reqtag);
+		return;
+	}
+
+	sli_queue_lock(wq->queue);
+		index = q_info->quarantine_index;
+		free_io = q_info->quarantine_ios[index];
+		q_info->quarantine_ios[index] = io;
+		q_info->quarantine_index = (index + 1) % OCS_HW_QUARANTINE_QUEUE_DEPTH;
+	sli_queue_unlock(wq->queue);
+
+	if (free_io != NULL) {
+		ocs_ref_put(&free_io->ref); /* ocs_ref_get(): same function */
+	}
+}
+
+/**
+ * @brief Process entries on the given completion queue.
+ *
+ * @param hw Hardware context.
+ * @param cq Pointer to the HW completion queue object.
+ *
+ * @return None.
+ */
+void
+ocs_hw_cq_process(ocs_hw_t *hw, hw_cq_t *cq)
+{
+	uint8_t		cqe[sizeof(sli4_mcqe_t)];
+	uint16_t	rid = UINT16_MAX;
+	sli4_qentry_e	ctype;		/* completion type */
+	int32_t		status;
+	uint32_t	n_processed = 0;
+	time_t		tstart;
+	time_t		telapsed;
+
+	tstart = ocs_msectime();
+
+	while (!sli_queue_read(&hw->sli, cq->queue, cqe)) {
+		status = sli_cq_parse(&hw->sli, cq->queue, cqe, &ctype, &rid);
+		/*
+		 * The sign of status is significant. If status is:
+		 * == 0 : call completed correctly and the CQE indicated success
+		 *  > 0 : call completed correctly and the CQE indicated an error
+		 *  < 0 : call failed and no information is available about the CQE
+		 */
+		if (status < 0) {
+			if (status == -2) {
+				/* Notification that an entry was consumed, but not completed */
+				continue;
+			}
+
+			break;
+		}
+
+		switch (ctype) {
+		case SLI_QENTRY_ASYNC:
+			CPUTRACE("async");
+			sli_cqe_async(&hw->sli, cqe);
+			break;
+		case SLI_QENTRY_MQ:
+			/*
+			 * Process MQ entry. Note there is no way to determine
+			 * the MQ_ID from the completion entry.
+			 */
+			CPUTRACE("mq");
+			ocs_hw_mq_process(hw, status, hw->mq);
+			break;
+		case SLI_QENTRY_OPT_WRITE_CMD:
+			ocs_hw_rqpair_process_auto_xfr_rdy_cmd(hw, cq, cqe);
+			break;
+		case SLI_QENTRY_OPT_WRITE_DATA:
+			ocs_hw_rqpair_process_auto_xfr_rdy_data(hw, cq, cqe);
+			break;
+		case SLI_QENTRY_WQ:
+			CPUTRACE("wq");
+			ocs_hw_wq_process(hw, cq, cqe, status, rid);
+			break;
+		case SLI_QENTRY_WQ_RELEASE: {
+			uint32_t wq_id = rid;
+			uint32_t index = ocs_hw_queue_hash_find(hw->wq_hash, wq_id);
+			hw_wq_t *wq = hw->hw_wq[index];
+
+			/* Submit any HW IOs that are on the WQ pending list */
+			hw_wq_submit_pending(wq, wq->wqec_set_count);
+
+			break;
+		}
+
+		case SLI_QENTRY_RQ:
+			CPUTRACE("rq");
+			ocs_hw_rqpair_process_rq(hw, cq, cqe);
+			break;
+		case SLI_QENTRY_XABT: {
+			CPUTRACE("xabt");
+			ocs_hw_xabt_process(hw, cq, cqe, rid);
+			break;
+
+		}
+		default:
+			ocs_log_test(hw->os, "unhandled ctype=%#x rid=%#x\n", ctype, rid);
+			break;
+		}
+
+		n_processed++;
+		if (n_processed == cq->queue->proc_limit) {
+			break;
+		}
+
+		if (cq->queue->n_posted >= (cq->queue->posted_limit)) {
+			sli_queue_arm(&hw->sli, cq->queue, FALSE);
+		}
+	}
+
+	sli_queue_arm(&hw->sli, cq->queue, TRUE);
+
+	if (n_processed > cq->queue->max_num_processed) {
+		cq->queue->max_num_processed = n_processed;
+	}
+	telapsed = ocs_msectime() - tstart;
+	if (telapsed > cq->queue->max_process_time) {
+		cq->queue->max_process_time = telapsed;
+	}
+}
+
+/**
+ * @brief Process WQ completion queue entries.
+ *
+ * @param hw Hardware context.
+ * @param cq Pointer to the HW completion queue object.
+ * @param cqe Pointer to WQ completion queue.
+ * @param status Completion status.
+ * @param rid Resource ID (IO tag).
+ *
+ * @return none
+ */
+void
+ocs_hw_wq_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, int32_t status, uint16_t rid)
+{
+	hw_wq_callback_t *wqcb;
+
+	ocs_queue_history_cqe(&hw->q_hist, SLI_QENTRY_WQ, (void *)cqe, ((sli4_fc_wcqe_t *)cqe)->status, cq->queue->id,
+			      ((cq->queue->index - 1) & (cq->queue->length - 1)));
+
+	if(rid == OCS_HW_REQUE_XRI_REGTAG) {
+		if(status) {
+			ocs_log_err(hw->os, "reque xri failed, status = %d \n", status);
+		}
+		return;
+	}
+
+	wqcb = ocs_hw_reqtag_get_instance(hw, rid);
+	if (wqcb == NULL) {
+		ocs_log_err(hw->os, "invalid request tag: x%x\n", rid);
+		return;
+	}
+
+	if (wqcb->callback == NULL) {
+		ocs_log_err(hw->os, "wqcb callback is NULL\n");
+		return;
+	}
+
+	(*wqcb->callback)(wqcb->arg, cqe, status);
+}
+
+/**
+ * @brief Process WQ completions for IO requests
+ *
+ * @param arg Generic callback argument
+ * @param cqe Pointer to completion queue entry
+ * @param status Completion status
+ *
+ * @par Description
+ * @n @b Note:  Regarding io->reqtag, the reqtag is assigned once when HW IOs are initialized
+ * in ocs_hw_setup_io(), and don't need to be returned to the hw->wq_reqtag_pool.
+ *
+ * @return None.
+ */
+static void
+ocs_hw_wq_process_io(void *arg, uint8_t *cqe, int32_t status)
+{
+	ocs_hw_io_t *io = arg;
+	ocs_hw_t *hw = io->hw;
+	sli4_fc_wcqe_t *wcqe = (void *)cqe;
+	uint32_t	len = 0;
+	uint32_t ext = 0;
+	uint8_t out_of_order_axr_cmd = 0;
+	uint8_t out_of_order_axr_data = 0;
+	uint8_t lock_taken = 0;
+#if defined(OCS_DISC_SPIN_DELAY)
+	uint32_t delay = 0;
+	char prop_buf[32];
+#endif
+
+	/*
+	 * For the primary IO, this will also be used for the
+	 * response. So it is important to only set/clear this
+	 * flag on the first data phase of the IO because
+	 * subsequent phases will be done on the secondary XRI.
+	 */
+	if (io->quarantine && io->quarantine_first_phase) {
+		io->quarantine = (wcqe->qx == 1);
+		ocs_hw_io_quarantine(hw, io->wq, io);
+	}
+	io->quarantine_first_phase = FALSE;
+
+	/* BZ 161832 - free secondary HW IO */
+	if (io->sec_hio != NULL &&
+	    io->sec_hio->quarantine) {
+		/*
+		 * If the quarantine flag is set on the
+		 * IO, then set it on the secondary IO
+		 * based on the quarantine XRI (QX) bit
+		 * sent by the FW.
+		 */
+		io->sec_hio->quarantine = (wcqe->qx == 1);
+		/* use the primary io->wq because it is not set on the secondary IO. */
+		ocs_hw_io_quarantine(hw, io->wq, io->sec_hio);
+	}
+
+	ocs_hw_remove_io_timed_wqe(hw, io);
+
+	/* clear xbusy flag if WCQE[XB] is clear */
+	if (io->xbusy && wcqe->xb == 0) {
+		io->xbusy = FALSE;
+	}
+
+	/* get extended CQE status */
+	switch (io->type) {
+	case OCS_HW_BLS_ACC:
+	case OCS_HW_BLS_ACC_SID:
+		break;
+	case OCS_HW_ELS_REQ:
+		sli_fc_els_did(&hw->sli, cqe, &ext);
+		len = sli_fc_response_length(&hw->sli, cqe);
+		break;
+	case OCS_HW_ELS_RSP:
+	case OCS_HW_ELS_RSP_SID:
+	case OCS_HW_FC_CT_RSP:
+		break;
+	case OCS_HW_FC_CT:
+		len = sli_fc_response_length(&hw->sli, cqe);
+		break;
+	case OCS_HW_IO_TARGET_WRITE:
+		len = sli_fc_io_length(&hw->sli, cqe);
+#if defined(OCS_DISC_SPIN_DELAY)
+		if (ocs_get_property("disk_spin_delay", prop_buf, sizeof(prop_buf)) == 0) {
+			delay = ocs_strtoul(prop_buf, 0, 0);
+			ocs_udelay(delay);
+		}
+#endif
+		break;
+	case OCS_HW_IO_TARGET_READ:
+		len = sli_fc_io_length(&hw->sli, cqe);
+		/*
+		 * if_type == 2 seems to return 0 "total length placed" on
+		 * FCP_TSEND64_WQE completions. If this appears to happen,
+		 * use the CTIO data transfer length instead.
+		 */
+		if (hw->workaround.retain_tsend_io_length && !len && !status) {
+			len = io->length;
+		}
+
+		break;
+	case OCS_HW_IO_TARGET_RSP:
+		if(io->is_port_owned) {
+			ocs_lock(&io->axr_lock);
+			lock_taken = 1;
+			if(io->axr_buf->call_axr_cmd) {
+				out_of_order_axr_cmd = 1;
+			}
+			if(io->axr_buf->call_axr_data) {
+				out_of_order_axr_data = 1;
+			}
+		}
+		break;
+	case OCS_HW_IO_INITIATOR_READ:
+		len = sli_fc_io_length(&hw->sli, cqe);
+		break;
+	case OCS_HW_IO_INITIATOR_WRITE:
+		len = sli_fc_io_length(&hw->sli, cqe);
+		break;
+	case OCS_HW_IO_INITIATOR_NODATA:
+		break;
+	case OCS_HW_IO_DNRX_REQUEUE:
+		/* release the count for re-posting the buffer */
+		//ocs_hw_io_free(hw, io);
+		break;
+	default:
+		ocs_log_test(hw->os, "XXX unhandled io type %#x for XRI 0x%x\n",
+			     io->type, io->indicator);
+		break;
+	}
+	if (status) {
+		ext = sli_fc_ext_status(&hw->sli, cqe);
+		/* Emulate IAAB=0 for initiator WQEs only; i.e. automatically
+		 * abort exchange if an error occurred and exchange is still busy.
+		 */
+		if (hw->config.i_only_aab &&
+		    (ocs_hw_iotype_is_originator(io->type)) &&
+		    (ocs_hw_wcqe_abort_needed(status, ext, wcqe->xb))) {
+			ocs_hw_rtn_e rc;
+
+			ocs_log_debug(hw->os, "aborting xri=%#x tag=%#x\n",
+				      io->indicator, io->reqtag);
+			/*
+			 * Because the initiator will not issue another IO phase, then it is OK to to issue the
+			 * callback on the abort completion, but for consistency with the target, wait for the
+			 * XRI_ABORTED CQE to issue the IO callback.
+			 */
+			rc = ocs_hw_io_abort(hw, io, TRUE, NULL, NULL);
+
+			if (rc == OCS_HW_RTN_SUCCESS) {
+				/* latch status to return after abort is complete */
+				io->status_saved = 1;
+				io->saved_status = status;
+				io->saved_ext = ext;
+				io->saved_len = len;
+				goto exit_ocs_hw_wq_process_io;
+			} else if (rc == OCS_HW_RTN_IO_ABORT_IN_PROGRESS) {
+				/*
+				 * Already being aborted by someone else (ABTS
+				 * perhaps). Just fall through and return original
+				 * error.
+				 */
+				ocs_log_debug(hw->os, "abort in progress xri=%#x tag=%#x\n",
+					      io->indicator, io->reqtag);
+
+			} else {
+				/* Failed to abort for some other reason, log error */
+				ocs_log_test(hw->os, "Failed to abort xri=%#x tag=%#x rc=%d\n",
+					     io->indicator, io->reqtag, rc);
+			}
+		}
+
+		/*
+		 * If we're not an originator IO, and XB is set, then issue abort for the IO from within the HW
+		 */
+		if ( (! ocs_hw_iotype_is_originator(io->type)) && wcqe->xb) {
+			ocs_hw_rtn_e rc;
+
+			ocs_log_debug(hw->os, "aborting xri=%#x tag=%#x\n", io->indicator, io->reqtag);
+
+			/*
+			 * Because targets may send a response when the IO completes using the same XRI, we must
+			 * wait for the XRI_ABORTED CQE to issue the IO callback
+			 */
+			rc = ocs_hw_io_abort(hw, io, FALSE, NULL, NULL);
+			if (rc == OCS_HW_RTN_SUCCESS) {
+				/* latch status to return after abort is complete */
+				io->status_saved = 1;
+				io->saved_status = status;
+				io->saved_ext = ext;
+				io->saved_len = len;
+				goto exit_ocs_hw_wq_process_io;
+			} else if (rc == OCS_HW_RTN_IO_ABORT_IN_PROGRESS) {
+				/*
+				 * Already being aborted by someone else (ABTS
+				 * perhaps). Just fall through and return original
+				 * error.
+				 */
+				ocs_log_debug(hw->os, "abort in progress xri=%#x tag=%#x\n",
+					      io->indicator, io->reqtag);
+
+			} else {
+				/* Failed to abort for some other reason, log error */
+				ocs_log_test(hw->os, "Failed to abort xri=%#x tag=%#x rc=%d\n",
+					     io->indicator, io->reqtag, rc);
+			}
+		}
+	}
+	/* BZ 161832 - free secondary HW IO */
+	if (io->sec_hio != NULL) {
+		ocs_hw_io_free(hw, io->sec_hio);
+		io->sec_hio = NULL;
+	}
+
+	if (io->done != NULL) {
+		ocs_hw_done_t  done = io->done;
+		void		*arg = io->arg;
+
+		io->done = NULL;
+
+		if (io->status_saved) {
+			/* use latched status if exists */
+			status = io->saved_status;
+			len = io->saved_len;
+			ext = io->saved_ext;
+			io->status_saved = 0;
+		}
+
+		/* Restore default SGL */
+		ocs_hw_io_restore_sgl(hw, io);
+		done(io, io->rnode, len, status, ext, arg);
+	}
+
+	if(out_of_order_axr_cmd) {
+		/* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */
+		if (hw->config.bounce) {
+			fc_header_t *hdr = io->axr_buf->cmd_seq->header->dma.virt;
+			uint32_t s_id = fc_be24toh(hdr->s_id);
+			uint32_t d_id = fc_be24toh(hdr->d_id);
+			uint32_t ox_id =  ocs_be16toh(hdr->ox_id);
+			if (hw->callback.bounce != NULL) {
+				(*hw->callback.bounce)(ocs_hw_unsol_process_bounce, io->axr_buf->cmd_seq, s_id, d_id, ox_id);
+			}
+		}else {
+			hw->callback.unsolicited(hw->args.unsolicited, io->axr_buf->cmd_seq);
+		}
+
+		if(out_of_order_axr_data) {
+			/* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */
+			if (hw->config.bounce) {
+				fc_header_t *hdr = io->axr_buf->seq.header->dma.virt;
+				uint32_t s_id = fc_be24toh(hdr->s_id);
+				uint32_t d_id = fc_be24toh(hdr->d_id);
+				uint32_t ox_id =  ocs_be16toh(hdr->ox_id);
+				if (hw->callback.bounce != NULL) {
+					(*hw->callback.bounce)(ocs_hw_unsol_process_bounce, &io->axr_buf->seq, s_id, d_id, ox_id);
+				}
+			}else {
+				hw->callback.unsolicited(hw->args.unsolicited, &io->axr_buf->seq);
+			}
+		}
+	}
+
+exit_ocs_hw_wq_process_io:
+	if(lock_taken) {
+		ocs_unlock(&io->axr_lock);
+	}	
+}
+
+/**
+ * @brief Process WQ completions for abort requests.
+ *
+ * @param arg Generic callback argument.
+ * @param cqe Pointer to completion queue entry.
+ * @param status Completion status.
+ *
+ * @return None.
+ */
+static void
+ocs_hw_wq_process_abort(void *arg, uint8_t *cqe, int32_t status)
+{
+	ocs_hw_io_t *io = arg;
+	ocs_hw_t *hw = io->hw;
+	uint32_t ext = 0;
+	uint32_t len = 0;
+	hw_wq_callback_t *wqcb;
+
+	/*
+	 * For IOs that were aborted internally, we may need to issue the callback here depending
+	 * on whether a XRI_ABORTED CQE is expected ot not. If the status is Local Reject/No XRI, then
+	 * issue the callback now.
+	*/
+	ext = sli_fc_ext_status(&hw->sli, cqe);
+	if (status == SLI4_FC_WCQE_STATUS_LOCAL_REJECT &&
+	    ext == SLI4_FC_LOCAL_REJECT_NO_XRI &&
+		io->done != NULL) {
+		ocs_hw_done_t  done = io->done;
+		void		*arg = io->arg;
+
+		io->done = NULL;
+
+		/*
+		 * Use latched status as this is always saved for an internal abort
+		 *
+		 * Note: We wont have both a done and abort_done function, so don't worry about
+		 *       clobbering the len, status and ext fields.
+		 */
+		status = io->saved_status;
+		len = io->saved_len;
+		ext = io->saved_ext;
+		io->status_saved = 0;
+		done(io, io->rnode, len, status, ext, arg);
+	}
+
+	if (io->abort_done != NULL) {
+		ocs_hw_done_t  done = io->abort_done;
+		void		*arg = io->abort_arg;
+
+		io->abort_done = NULL;
+
+		done(io, io->rnode, len, status, ext, arg);
+	}
+	ocs_lock(&hw->io_abort_lock);
+		/* clear abort bit to indicate abort is complete */
+		io->abort_in_progress = 0;
+	ocs_unlock(&hw->io_abort_lock);
+
+	/* Free the WQ callback */
+	ocs_hw_assert(io->abort_reqtag != UINT32_MAX);
+	wqcb = ocs_hw_reqtag_get_instance(hw, io->abort_reqtag);
+	ocs_hw_reqtag_free(hw, wqcb);
+
+	/*
+	 * Call ocs_hw_io_free() because this releases the WQ reservation as
+	 * well as doing the refcount put. Don't duplicate the code here.
+	 */
+	(void)ocs_hw_io_free(hw, io);
+}
+
+/**
+ * @brief Process XABT completions
+ *
+ * @param hw Hardware context.
+ * @param cq Pointer to the HW completion queue object.
+ * @param cqe Pointer to WQ completion queue.
+ * @param rid Resource ID (IO tag).
+ *
+ *
+ * @return None.
+ */
+void
+ocs_hw_xabt_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, uint16_t rid)
+{
+	/* search IOs wait free list */
+	ocs_hw_io_t *io = NULL;
+
+	io = ocs_hw_io_lookup(hw, rid);
+
+	ocs_queue_history_cqe(&hw->q_hist, SLI_QENTRY_XABT, (void *)cqe, 0, cq->queue->id,
+			      ((cq->queue->index - 1) & (cq->queue->length - 1)));
+	if (io == NULL) {
+		/* IO lookup failure should never happen */
+		ocs_log_err(hw->os, "Error: xabt io lookup failed rid=%#x\n", rid);
+		return;
+	}
+
+	if (!io->xbusy) {
+		ocs_log_debug(hw->os, "xabt io not busy rid=%#x\n", rid);
+	} else {
+		/* mark IO as no longer busy */
+		io->xbusy = FALSE;
+	}
+
+       if (io->is_port_owned) {
+               ocs_lock(&hw->io_lock);
+               /* Take reference so that below callback will not free io before reque */
+               ocs_ref_get(&io->ref);
+               ocs_unlock(&hw->io_lock);
+       }
+
+
+
+	/* For IOs that were aborted internally, we need to issue any pending callback here. */
+	if (io->done != NULL) {
+		ocs_hw_done_t  done = io->done;
+		void		*arg = io->arg;
+
+		/* Use latched status as this is always saved for an internal abort */
+		int32_t status = io->saved_status;
+		uint32_t len = io->saved_len;
+		uint32_t ext = io->saved_ext;
+
+		io->done = NULL;
+		io->status_saved = 0;
+
+		done(io, io->rnode, len, status, ext, arg);
+	}
+
+	/* Check to see if this is a port owned XRI */
+	if (io->is_port_owned) {
+		ocs_lock(&hw->io_lock);
+		ocs_hw_reque_xri(hw, io);
+		ocs_unlock(&hw->io_lock);
+		/* Not hanlding reque xri completion, free io */
+		ocs_hw_io_free(hw, io);
+		return;
+	}
+
+	ocs_lock(&hw->io_lock);
+		if ((io->state == OCS_HW_IO_STATE_INUSE) || (io->state == OCS_HW_IO_STATE_WAIT_FREE)) {
+			/* if on wait_free list, caller has already freed IO;
+			 * remove from wait_free list and add to free list.
+			 * if on in-use list, already marked as no longer busy;
+			 * just leave there and wait for caller to free.
+			 */
+			if (io->state == OCS_HW_IO_STATE_WAIT_FREE) {
+				io->state = OCS_HW_IO_STATE_FREE;
+				ocs_list_remove(&hw->io_wait_free, io);
+				ocs_hw_io_free_move_correct_list(hw, io);
+			}
+		}
+	ocs_unlock(&hw->io_lock);
+}
+
+/**
+ * @brief Adjust the number of WQs and CQs within the HW.
+ *
+ * @par Description
+ * Calculates the number of WQs and associated CQs needed in the HW based on
+ * the number of IOs. Calculates the starting CQ index for each WQ, RQ and
+ * MQ.
+ *
+ * @param hw Hardware context allocated by the caller.
+ */
+static void
+ocs_hw_adjust_wqs(ocs_hw_t *hw)
+{
+	uint32_t max_wq_num = sli_get_max_queue(&hw->sli, SLI_QTYPE_WQ);
+	uint32_t max_wq_entries = hw->num_qentries[SLI_QTYPE_WQ];
+	uint32_t max_cq_entries = hw->num_qentries[SLI_QTYPE_CQ];
+
+	/*
+	 * possibly adjust the the size of the WQs so that the CQ is twice as
+	 * big as the WQ to allow for 2 completions per IO. This allows us to
+	 * handle multi-phase as well as aborts.
+	 */
+	if (max_cq_entries < max_wq_entries * 2) {
+		max_wq_entries = hw->num_qentries[SLI_QTYPE_WQ] = max_cq_entries / 2;
+	}
+
+	/*
+	 * Calculate the number of WQs to use base on the number of IOs.
+	 *
+	 * Note: We need to reserve room for aborts which must be sent down
+	 *       the same WQ as the IO. So we allocate enough WQ space to
+	 *       handle 2 times the number of IOs. Half of the space will be
+	 *       used for normal IOs and the other hwf is reserved for aborts.
+	 */
+	hw->config.n_wq = ((hw->config.n_io * 2) + (max_wq_entries - 1)) / max_wq_entries;
+
+	/*
+	 * For performance reasons, it is best to use use a minimum of 4 WQs
+	 * for BE3 and Skyhawk.
+	 */
+	if (hw->config.n_wq < 4 &&
+	    SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) {
+		hw->config.n_wq = 4;
+	}
+
+	/*
+	 * For dual-chute support, we need to have at least one WQ per chute.
+	 */
+	if (hw->config.n_wq < 2 &&
+	    ocs_hw_get_num_chutes(hw) > 1) {
+		hw->config.n_wq = 2;
+	}
+
+	/* make sure we haven't exceeded the max supported in the HW */
+	if (hw->config.n_wq > OCS_HW_MAX_NUM_WQ) {
+		hw->config.n_wq = OCS_HW_MAX_NUM_WQ;
+	}
+
+	/* make sure we haven't exceeded the chip maximum */
+	if (hw->config.n_wq > max_wq_num) {
+		hw->config.n_wq = max_wq_num;
+	}
+
+	/*
+	 * Using Queue Topology string, we divide by number of chutes
+	 */
+	hw->config.n_wq /= ocs_hw_get_num_chutes(hw);
+}
+
+static int32_t
+ocs_hw_command_process(ocs_hw_t *hw, int32_t status, uint8_t *mqe, size_t size)
+{
+	ocs_command_ctx_t *ctx = NULL;
+
+	ocs_lock(&hw->cmd_lock);
+		if (NULL == (ctx = ocs_list_remove_head(&hw->cmd_head))) {
+			ocs_log_err(hw->os, "XXX no command context?!?\n");
+			ocs_unlock(&hw->cmd_lock);
+			return -1;
+		}
+
+		hw->cmd_head_count--;
+
+		/* Post any pending requests */
+		ocs_hw_cmd_submit_pending(hw);
+
+	ocs_unlock(&hw->cmd_lock);
+
+	if (ctx->cb) {
+		if (ctx->buf) {
+			ocs_memcpy(ctx->buf, mqe, size);
+		}
+		ctx->cb(hw, status, ctx->buf, ctx->arg);
+	}
+
+	ocs_memset(ctx, 0, sizeof(ocs_command_ctx_t));
+	ocs_free(hw->os, ctx, sizeof(ocs_command_ctx_t));
+
+	return 0;
+}
+
+
+
+
+/**
+ * @brief Process entries on the given mailbox queue.
+ *
+ * @param hw Hardware context.
+ * @param status CQE status.
+ * @param mq Pointer to the mailbox queue object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_mq_process(ocs_hw_t *hw, int32_t status, sli4_queue_t *mq)
+{
+	uint8_t		mqe[SLI4_BMBX_SIZE];
+
+	if (!sli_queue_read(&hw->sli, mq, mqe)) {
+		ocs_hw_command_process(hw, status, mqe, mq->size);
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Read a FCF table entry.
+ *
+ * @param hw Hardware context.
+ * @param index Table index to read. Use SLI4_FCOE_FCF_TABLE_FIRST for the first
+ * read and the next_index field from the FCOE_READ_FCF_TABLE command
+ * for subsequent reads.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static ocs_hw_rtn_e
+ocs_hw_read_fcf(ocs_hw_t *hw, uint32_t index)
+{
+	uint8_t		*buf = NULL;
+	int32_t		rc = OCS_HW_RTN_ERROR;
+
+	buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+	if (!buf) {
+		ocs_log_err(hw->os, "no buffer for command\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	if (sli_cmd_fcoe_read_fcf_table(&hw->sli, buf, SLI4_BMBX_SIZE, &hw->fcf_dmem,
+			index)) {
+		rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, ocs_hw_cb_read_fcf, &hw->fcf_dmem);
+	}
+
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_test(hw->os, "FCOE_READ_FCF_TABLE failed\n");
+		ocs_free(hw->os, buf, SLI4_BMBX_SIZE);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Callback function for the FCOE_READ_FCF_TABLE command.
+ *
+ * @par Description
+ * Note that the caller has allocated:
+ *  - DMA memory to hold the table contents
+ *  - DMA memory structure
+ *  - Command/results buffer
+ *  .
+ * Each of these must be freed here.
+ *
+ * @param hw Hardware context.
+ * @param status Hardware status.
+ * @param mqe Pointer to the mailbox command/results buffer.
+ * @param arg Pointer to the DMA memory structure.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_cb_read_fcf(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_dma_t	*dma = arg;
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+
+	if (status || hdr->status) {
+		ocs_log_test(hw->os, "bad status cqe=%#x mqe=%#x\n",
+				status, hdr->status);
+	} else if (dma->virt) {
+		sli4_res_fcoe_read_fcf_table_t *read_fcf = dma->virt;
+
+		/* if FC or FCOE and FCF entry valid, process it */
+		if (read_fcf->fcf_entry.fc ||
+				(read_fcf->fcf_entry.val && !read_fcf->fcf_entry.sol)) {
+			if (hw->callback.domain != NULL) {
+				ocs_domain_record_t drec = {0};
+
+				if (read_fcf->fcf_entry.fc) {
+					/*
+					 * This is a pseudo FCF entry. Create a domain
+					 * record based on the read topology information
+					 */
+					drec.speed = hw->link.speed;
+					drec.fc_id = hw->link.fc_id;
+					drec.is_fc = TRUE;
+					if (SLI_LINK_TOPO_LOOP == hw->link.topology) {
+						drec.is_loop = TRUE;
+						ocs_memcpy(drec.map.loop, hw->link.loop_map,
+							   sizeof(drec.map.loop));
+					} else if (SLI_LINK_TOPO_NPORT == hw->link.topology) {
+						drec.is_nport = TRUE;
+					}
+				} else {
+					drec.index = read_fcf->fcf_entry.fcf_index;
+					drec.priority = read_fcf->fcf_entry.fip_priority;
+
+					/* copy address, wwn and vlan_bitmap */
+					ocs_memcpy(drec.address, read_fcf->fcf_entry.fcf_mac_address,
+						   sizeof(drec.address));
+					ocs_memcpy(drec.wwn, read_fcf->fcf_entry.fabric_name_id,
+						   sizeof(drec.wwn));
+					ocs_memcpy(drec.map.vlan, read_fcf->fcf_entry.vlan_bitmap,
+						   sizeof(drec.map.vlan));
+
+					drec.is_ethernet = TRUE;
+					drec.is_nport = TRUE;
+				}
+
+				hw->callback.domain(hw->args.domain,
+						OCS_HW_DOMAIN_FOUND,
+						&drec);
+			}
+		} else {
+			/* if FCOE and FCF is not valid, ignore it */
+			ocs_log_test(hw->os, "ignore invalid FCF entry\n");
+		}
+
+		if (SLI4_FCOE_FCF_TABLE_LAST != read_fcf->next_index) {
+			ocs_hw_read_fcf(hw, read_fcf->next_index);
+		}
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	//ocs_dma_free(hw->os, dma);
+	//ocs_free(hw->os, dma, sizeof(ocs_dma_t));
+
+	return 0;
+}
+
+/**
+ * @brief Callback function for the SLI link events.
+ *
+ * @par Description
+ * This function allocates memory which must be freed in its callback.
+ *
+ * @param ctx Hardware context pointer (that is, ocs_hw_t *).
+ * @param e Event structure pointer (that is, sli4_link_event_t *).
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_hw_cb_link(void *ctx, void *e)
+{
+	ocs_hw_t	*hw = ctx;
+	sli4_link_event_t *event = e;
+	ocs_domain_t	*d = NULL;
+	uint32_t	i = 0;
+	int32_t		rc = OCS_HW_RTN_ERROR;
+	ocs_t 		*ocs = hw->os;
+
+	ocs_hw_link_event_init(hw);
+
+	switch (event->status) {
+	case SLI_LINK_STATUS_UP:
+
+		hw->link = *event;
+
+		if (SLI_LINK_TOPO_NPORT == event->topology) {
+			device_printf(ocs->dev, "Link Up, NPORT, speed is %d\n", event->speed);
+			ocs_hw_read_fcf(hw, SLI4_FCOE_FCF_TABLE_FIRST);
+		} else if (SLI_LINK_TOPO_LOOP == event->topology) {
+			uint8_t	*buf = NULL;
+			device_printf(ocs->dev, "Link Up, LOOP, speed is %d\n", event->speed);
+
+			buf = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+			if (!buf) {
+				ocs_log_err(hw->os, "no buffer for command\n");
+				break;
+			}
+
+			if (sli_cmd_read_topology(&hw->sli, buf, SLI4_BMBX_SIZE, &hw->loop_map)) {
+				rc = ocs_hw_command(hw, buf, OCS_CMD_NOWAIT, __ocs_read_topology_cb, NULL);
+			}
+
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				ocs_log_test(hw->os, "READ_TOPOLOGY failed\n");
+				ocs_free(hw->os, buf, SLI4_BMBX_SIZE);
+			}
+		} else {
+			device_printf(ocs->dev, "Link Up, unsupported topology (%#x), speed is %d\n",
+					event->topology, event->speed);
+		}
+		break;
+	case SLI_LINK_STATUS_DOWN:
+		device_printf(ocs->dev, "Link Down\n");
+
+		hw->link.status = event->status;
+
+		for (i = 0; d = hw->domains[i], i < SLI4_MAX_FCFI; i++) {
+			if (d != NULL &&
+			    hw->callback.domain != NULL) {
+				hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, d);
+			}
+		}
+		break;
+	default:
+		ocs_log_test(hw->os, "unhandled link status %#x\n", event->status);
+		break;
+	}
+
+	return 0;
+}
+
+static int32_t
+ocs_hw_cb_fip(void *ctx, void *e)
+{
+	ocs_hw_t	*hw = ctx;
+	ocs_domain_t	*domain = NULL;
+	sli4_fip_event_t *event = e;
+
+	/* Find the associated domain object */
+	if (event->type == SLI4_FCOE_FIP_FCF_CLEAR_VLINK) {
+		ocs_domain_t *d = NULL;
+		uint32_t	i = 0;
+
+		/* Clear VLINK is different from the other FIP events as it passes back
+		 * a VPI instead of a FCF index. Check all attached SLI ports for a
+		 * matching VPI */
+		for (i = 0; d = hw->domains[i], i < SLI4_MAX_FCFI; i++) {
+			if (d != NULL) {
+				ocs_sport_t	*sport = NULL;
+
+				ocs_list_foreach(&d->sport_list, sport) {
+					if (sport->indicator == event->index) {
+						domain = d;
+						break;
+					}
+				}
+
+				if (domain != NULL) {
+					break;
+				}
+			}
+		}
+	} else {
+		domain = ocs_hw_domain_get_indexed(hw, event->index);
+	}
+
+	switch (event->type) {
+	case SLI4_FCOE_FIP_FCF_DISCOVERED:
+		ocs_hw_read_fcf(hw, event->index);
+		break;
+	case SLI4_FCOE_FIP_FCF_DEAD:
+		if (domain != NULL &&
+		    hw->callback.domain != NULL) {
+			hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, domain);
+		}
+		break;
+	case SLI4_FCOE_FIP_FCF_CLEAR_VLINK:
+		if (domain != NULL &&
+		    hw->callback.domain != NULL) {
+			/*
+			 * We will want to issue rediscover FCF when this domain is free'd  in order
+			 * to invalidate the FCF table
+			 */
+			domain->req_rediscover_fcf = TRUE;
+			hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, domain);
+		}
+		break;
+	case SLI4_FCOE_FIP_FCF_MODIFIED:
+		if (domain != NULL &&
+		    hw->callback.domain != NULL) {
+			hw->callback.domain(hw->args.domain, OCS_HW_DOMAIN_LOST, domain);
+		}
+
+		ocs_hw_read_fcf(hw, event->index);
+		break;
+	default:
+		ocs_log_test(hw->os, "unsupported event %#x\n", event->type);
+	}
+
+	return 0;
+}
+
+static int32_t
+ocs_hw_cb_node_attach(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_remote_node_t *rnode = arg;
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+	ocs_hw_remote_node_event_e	evt = 0;
+
+	if (status || hdr->status) {
+		ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n", status,
+				hdr->status);
+		ocs_atomic_sub_return(&hw->rpi_ref[rnode->index].rpi_count, 1);
+		rnode->attached = FALSE;
+		ocs_atomic_set(&hw->rpi_ref[rnode->index].rpi_attached, 0);
+		evt = OCS_HW_NODE_ATTACH_FAIL;
+	} else {
+		rnode->attached = TRUE;
+		ocs_atomic_set(&hw->rpi_ref[rnode->index].rpi_attached, 1);
+		evt = OCS_HW_NODE_ATTACH_OK;
+	}
+
+	if (hw->callback.rnode != NULL) {
+		hw->callback.rnode(hw->args.rnode, evt, rnode);
+	}
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	return 0;
+}
+
+static int32_t
+ocs_hw_cb_node_free(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_remote_node_t *rnode = arg;
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+	ocs_hw_remote_node_event_e	evt = OCS_HW_NODE_FREE_FAIL;
+	int32_t		rc = 0;
+
+	if (status || hdr->status) {
+		ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n", status,
+				hdr->status);
+
+		/*
+		 * In certain cases, a non-zero MQE status is OK (all must be true):
+		 *   - node is attached
+		 *   - if High Login Mode is enabled, node is part of a node group
+		 *   - status is 0x1400
+		 */
+		if (!rnode->attached || ((sli_get_hlm(&hw->sli) == TRUE) && !rnode->node_group) ||
+				(hdr->status != SLI4_MBOX_STATUS_RPI_NOT_REG)) {
+			rc = -1;
+		}
+	}
+
+	if (rc == 0) {
+		rnode->node_group = FALSE;
+		rnode->attached = FALSE;
+
+		if (ocs_atomic_read(&hw->rpi_ref[rnode->index].rpi_count) == 0) {
+			ocs_atomic_set(&hw->rpi_ref[rnode->index].rpi_attached, 0);
+		}
+
+		evt = OCS_HW_NODE_FREE_OK;
+	}
+
+	if (hw->callback.rnode != NULL) {
+		hw->callback.rnode(hw->args.rnode, evt, rnode);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	return rc;
+}
+
+static int32_t
+ocs_hw_cb_node_free_all(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+	ocs_hw_remote_node_event_e	evt = OCS_HW_NODE_FREE_FAIL;
+	int32_t		rc = 0;
+	uint32_t	i;
+
+	if (status || hdr->status) {
+		ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n", status,
+				hdr->status);
+	} else {
+		evt = OCS_HW_NODE_FREE_ALL_OK;
+	}
+
+	if (evt == OCS_HW_NODE_FREE_ALL_OK) {
+		for (i = 0; i < sli_get_max_rsrc(&hw->sli, SLI_RSRC_FCOE_RPI); i++) {
+			ocs_atomic_set(&hw->rpi_ref[i].rpi_count, 0);
+		}
+
+		if (sli_resource_reset(&hw->sli, SLI_RSRC_FCOE_RPI)) {
+			ocs_log_test(hw->os, "FCOE_RPI free all failure\n");
+			rc = -1;
+		}
+	}
+
+	if (hw->callback.rnode != NULL) {
+		hw->callback.rnode(hw->args.rnode, evt, NULL);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	return rc;
+}
+
+/**
+ * @brief Initialize the pool of HW IO objects.
+ *
+ * @param hw Hardware context.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static ocs_hw_rtn_e
+ocs_hw_setup_io(ocs_hw_t *hw)
+{
+	uint32_t	i = 0;
+	ocs_hw_io_t	*io = NULL;
+	uintptr_t	xfer_virt = 0;
+	uintptr_t	xfer_phys = 0;
+	uint32_t	index;
+	uint8_t		new_alloc = TRUE;
+
+	if (NULL == hw->io) {
+		hw->io = ocs_malloc(hw->os, hw->config.n_io * sizeof(ocs_hw_io_t *), OCS_M_ZERO | OCS_M_NOWAIT);
+
+		if (NULL == hw->io) {
+			ocs_log_err(hw->os, "IO pointer memory allocation failed, %d Ios at size %zu\n",
+				    hw->config.n_io,
+				    sizeof(ocs_hw_io_t *));
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+		for (i = 0; i < hw->config.n_io; i++) {
+			hw->io[i] = ocs_malloc(hw->os, sizeof(ocs_hw_io_t),
+						OCS_M_ZERO | OCS_M_NOWAIT);
+			if (hw->io[i] == NULL) {
+				ocs_log_err(hw->os, "IO(%d) memory allocation failed\n", i);
+				goto error;
+			}
+		}
+
+		/* Create WQE buffs for IO */
+		hw->wqe_buffs = ocs_malloc(hw->os, hw->config.n_io * hw->sli.config.wqe_size,
+				OCS_M_ZERO | OCS_M_NOWAIT);
+		if (NULL == hw->wqe_buffs) {
+			ocs_free(hw->os, hw->io, hw->config.n_io * sizeof(ocs_hw_io_t));
+			ocs_log_err(hw->os, "%s: IO WQE buff allocation failed, %d Ios at size %zu\n",
+					__func__, hw->config.n_io, hw->sli.config.wqe_size);
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+
+	} else {
+		/* re-use existing IOs, including SGLs */
+		new_alloc = FALSE;
+	}
+
+	if (new_alloc) {
+		if (ocs_dma_alloc(hw->os, &hw->xfer_rdy,
+					sizeof(fcp_xfer_rdy_iu_t) * hw->config.n_io,
+					4/*XXX what does this need to be? */)) {
+			ocs_log_err(hw->os, "XFER_RDY buffer allocation failed\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+	}
+	xfer_virt = (uintptr_t)hw->xfer_rdy.virt;
+	xfer_phys = hw->xfer_rdy.phys;
+
+	for (i = 0; i < hw->config.n_io; i++) {
+		hw_wq_callback_t *wqcb;
+
+		io = hw->io[i];
+
+		/* initialize IO fields */
+		io->hw = hw;
+
+		/* Assign a WQE buff */	
+		io->wqe.wqebuf = &hw->wqe_buffs[i * hw->sli.config.wqe_size]; 
+
+		/* Allocate the request tag for this IO */
+		wqcb = ocs_hw_reqtag_alloc(hw, ocs_hw_wq_process_io, io);
+		if (wqcb == NULL) {
+			ocs_log_err(hw->os, "can't allocate request tag\n");
+			return OCS_HW_RTN_NO_RESOURCES;
+		}
+		io->reqtag = wqcb->instance_index;
+
+		/* Now for the fields that are initialized on each free */
+		ocs_hw_init_free_io(io);
+
+		/* The XB flag isn't cleared on IO free, so initialize it to zero here */
+		io->xbusy = 0;
+
+		if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_XRI, &io->indicator, &index)) {
+			ocs_log_err(hw->os, "sli_resource_alloc failed @ %d\n", i);
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+
+		if (new_alloc && ocs_dma_alloc(hw->os, &io->def_sgl, hw->config.n_sgl * sizeof(sli4_sge_t), 64)) {
+			ocs_log_err(hw->os, "ocs_dma_alloc failed @ %d\n", i);
+			ocs_memset(&io->def_sgl, 0, sizeof(ocs_dma_t));
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+		io->def_sgl_count = hw->config.n_sgl;
+		io->sgl = &io->def_sgl;
+		io->sgl_count = io->def_sgl_count;
+
+		if (hw->xfer_rdy.size) {
+			io->xfer_rdy.virt = (void *)xfer_virt;
+			io->xfer_rdy.phys = xfer_phys;
+			io->xfer_rdy.size = sizeof(fcp_xfer_rdy_iu_t);
+
+			xfer_virt += sizeof(fcp_xfer_rdy_iu_t);
+			xfer_phys += sizeof(fcp_xfer_rdy_iu_t);
+		}
+	}
+
+	return OCS_HW_RTN_SUCCESS;
+error:
+	for (i = 0; i < hw->config.n_io && hw->io[i]; i++) {
+		ocs_free(hw->os, hw->io[i], sizeof(ocs_hw_io_t));
+		hw->io[i] = NULL;
+	}
+
+	return OCS_HW_RTN_NO_MEMORY;
+}
+
+static ocs_hw_rtn_e
+ocs_hw_init_io(ocs_hw_t *hw)
+{
+	uint32_t        i = 0, io_index = 0;
+	uint32_t        prereg = 0;
+	ocs_hw_io_t	*io = NULL;
+	uint8_t		cmd[SLI4_BMBX_SIZE];
+	ocs_hw_rtn_e rc = OCS_HW_RTN_SUCCESS;
+	uint32_t	nremaining;
+	uint32_t	n = 0;
+	uint32_t	sgls_per_request = 256;
+	ocs_dma_t	**sgls = NULL;
+	ocs_dma_t	reqbuf = { 0 };
+
+	prereg = sli_get_sgl_preregister(&hw->sli);
+
+	if (prereg) {
+		sgls = ocs_malloc(hw->os, sizeof(*sgls) * sgls_per_request, OCS_M_NOWAIT);
+		if (sgls == NULL) {
+			ocs_log_err(hw->os, "ocs_malloc sgls failed\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+
+		rc = ocs_dma_alloc(hw->os, &reqbuf, 32 + sgls_per_request*16, OCS_MIN_DMA_ALIGNMENT);
+		if (rc) {
+			ocs_log_err(hw->os, "ocs_dma_alloc reqbuf failed\n");
+			ocs_free(hw->os, sgls, sizeof(*sgls) * sgls_per_request);
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+	}
+
+	io = hw->io[io_index];
+	for (nremaining = hw->config.n_io; nremaining; nremaining -= n) {
+		if (prereg) {
+			/* Copy address of SGL's into local sgls[] array, break out if the xri
+			 * is not contiguous.
+			 */
+			for (n = 0; n < MIN(sgls_per_request, nremaining); n++) {
+				/* Check that we have contiguous xri values */
+				if (n > 0) {
+					if (hw->io[io_index + n]->indicator != (hw->io[io_index + n-1]->indicator+1)) {
+						break;
+					}
+				}
+				sgls[n] = hw->io[io_index + n]->sgl;
+			}
+
+			if (sli_cmd_fcoe_post_sgl_pages(&hw->sli, cmd, sizeof(cmd),
+						io->indicator, n, sgls, NULL, &reqbuf)) {
+				if (ocs_hw_command(hw, cmd, OCS_CMD_POLL, NULL, NULL)) {
+					rc = OCS_HW_RTN_ERROR;
+					ocs_log_err(hw->os, "SGL post failed\n");
+					break;
+				}
+			}
+		} else {
+			n = nremaining;
+		}
+
+		/* Add to tail if successful */
+		for (i = 0; i < n; i ++) {
+			io->is_port_owned = 0;
+			io->state = OCS_HW_IO_STATE_FREE;
+			ocs_list_add_tail(&hw->io_free, io);
+			io = hw->io[io_index+1];
+			io_index++;
+		}
+	}
+
+	if (prereg) {
+		ocs_dma_free(hw->os, &reqbuf);
+		ocs_free(hw->os, sgls, sizeof(*sgls) * sgls_per_request);
+	}
+
+	return rc;
+}
+
+static int32_t
+ocs_hw_flush(ocs_hw_t *hw)
+{
+	uint32_t	i = 0;
+
+	/* Process any remaining completions */
+	for (i = 0; i < hw->eq_count; i++) {
+		ocs_hw_process(hw, i, ~0);
+	}
+
+	return 0;
+}
+
+static int32_t
+ocs_hw_command_cancel(ocs_hw_t *hw)
+{
+
+	ocs_lock(&hw->cmd_lock);
+
+	/*
+	 * Manually clean up remaining commands. Note: since this calls
+	 * ocs_hw_command_process(), we'll also process the cmd_pending
+	 * list, so no need to manually clean that out.
+	 */
+	while (!ocs_list_empty(&hw->cmd_head)) {
+		uint8_t		mqe[SLI4_BMBX_SIZE] = { 0 };
+		ocs_command_ctx_t *ctx = ocs_list_get_head(&hw->cmd_head);
+
+		ocs_log_test(hw->os, "hung command %08x\n",
+				NULL == ctx ? UINT32_MAX :
+				(NULL == ctx->buf ? UINT32_MAX : *((uint32_t *)ctx->buf)));
+		ocs_unlock(&hw->cmd_lock);
+		ocs_hw_command_process(hw, -1/*Bad status*/, mqe, SLI4_BMBX_SIZE);
+		ocs_lock(&hw->cmd_lock);
+	}
+
+	ocs_unlock(&hw->cmd_lock);
+
+	return 0;
+}
+
+/**
+ * @brief Find IO given indicator (xri).
+ *
+ * @param hw Hal context.
+ * @param indicator Indicator (xri) to look for.
+ *
+ * @return Returns io if found, NULL otherwise.
+ */
+ocs_hw_io_t *
+ocs_hw_io_lookup(ocs_hw_t *hw, uint32_t xri)
+{
+	uint32_t ioindex;
+	ioindex = xri - hw->sli.config.extent[SLI_RSRC_FCOE_XRI].base[0];
+	return hw->io[ioindex];
+}
+
+/**
+ * @brief Issue any pending callbacks for an IO and remove off the timer and pending lists.
+ *
+ * @param hw Hal context.
+ * @param io Pointer to the IO to cleanup.
+ */
+static void
+ocs_hw_io_cancel_cleanup(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	ocs_hw_done_t  done = io->done;
+	ocs_hw_done_t  abort_done = io->abort_done;
+
+	/* first check active_wqe list and remove if there */
+	if (ocs_list_on_list(&io->wqe_link)) {
+		ocs_list_remove(&hw->io_timed_wqe, io);
+	}
+
+	/* Remove from WQ pending list */
+	if ((io->wq != NULL) && ocs_list_on_list(&io->wq->pending_list)) {
+		ocs_list_remove(&io->wq->pending_list, io);
+	}
+
+	if (io->done) {
+		void		*arg = io->arg;
+
+		io->done = NULL;
+		ocs_unlock(&hw->io_lock);
+		done(io, io->rnode, 0, SLI4_FC_WCQE_STATUS_SHUTDOWN, 0, arg);
+		ocs_lock(&hw->io_lock);
+	}
+
+	if (io->abort_done != NULL) {
+		void		*abort_arg = io->abort_arg;
+
+		io->abort_done = NULL;
+		ocs_unlock(&hw->io_lock);
+		abort_done(io, io->rnode, 0, SLI4_FC_WCQE_STATUS_SHUTDOWN, 0, abort_arg);
+		ocs_lock(&hw->io_lock);
+	}
+}
+
+static int32_t
+ocs_hw_io_cancel(ocs_hw_t *hw)
+{
+	ocs_hw_io_t	*io = NULL;
+	ocs_hw_io_t	*tmp_io = NULL;
+	uint32_t	iters = 100; /* One second limit */
+
+	/*
+	 * Manually clean up outstanding IO.
+	 * Only walk through list once: the backend will cleanup any IOs when done/abort_done is called.
+	 */
+	ocs_lock(&hw->io_lock);
+	ocs_list_foreach_safe(&hw->io_inuse, io, tmp_io) {
+		ocs_hw_done_t  done = io->done;
+		ocs_hw_done_t  abort_done = io->abort_done;
+
+		ocs_hw_io_cancel_cleanup(hw, io);
+
+		/*
+		 * Since this is called in a reset/shutdown
+		 * case, If there is no callback, then just
+		 * free the IO.
+		 *
+		 * Note: A port owned XRI cannot be on
+		 *       the in use list. We cannot call
+		 *       ocs_hw_io_free() because we already
+		 *       hold the io_lock.
+		 */
+		if (done == NULL &&
+		    abort_done == NULL) {
+			/*
+			 * Since this is called in a reset/shutdown
+			 * case, If there is no callback, then just
+			 * free the IO.
+			 */
+			ocs_hw_io_free_common(hw, io);
+			ocs_list_remove(&hw->io_inuse, io);
+			ocs_hw_io_free_move_correct_list(hw, io);
+		}
+	}
+
+	/*
+	 * For port owned XRIs, they are not on the in use list, so
+	 * walk though XRIs and issue any callbacks.
+	 */
+	ocs_list_foreach_safe(&hw->io_port_owned, io, tmp_io) {
+		/* check  list and remove if there */
+		if (ocs_list_on_list(&io->dnrx_link)) {
+			ocs_list_remove(&hw->io_port_dnrx, io);
+			ocs_ref_put(&io->ref); /* ocs_ref_get(): same function */
+		}
+		ocs_hw_io_cancel_cleanup(hw, io);
+		ocs_list_remove(&hw->io_port_owned, io);
+		ocs_hw_io_free_common(hw, io);
+	}
+	ocs_unlock(&hw->io_lock);
+
+	/* Give time for the callbacks to complete */
+	do {
+		ocs_udelay(10000);
+		iters--;
+	} while (!ocs_list_empty(&hw->io_inuse) && iters);
+
+	/* Leave a breadcrumb that cleanup is not yet complete. */
+	if (!ocs_list_empty(&hw->io_inuse)) {
+		ocs_log_test(hw->os, "io_inuse list is not empty\n");
+	}
+
+	return 0;
+}
+
+static int32_t
+ocs_hw_io_ini_sge(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_dma_t *cmnd, uint32_t cmnd_size,
+		ocs_dma_t *rsp)
+{
+	sli4_sge_t	*data = NULL;
+
+	if (!hw || !io) {
+		ocs_log_err(NULL, "bad parm hw=%p io=%p\n", hw, io);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	data = io->def_sgl.virt;
+
+	/* setup command pointer */
+	data->buffer_address_high = ocs_addr32_hi(cmnd->phys);
+	data->buffer_address_low  = ocs_addr32_lo(cmnd->phys);
+	data->buffer_length = cmnd_size;
+	data++;
+
+	/* setup response pointer */
+	data->buffer_address_high = ocs_addr32_hi(rsp->phys);
+	data->buffer_address_low  = ocs_addr32_lo(rsp->phys);
+	data->buffer_length = rsp->size;
+
+	return 0;
+}
+
+static int32_t
+__ocs_read_topology_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	sli4_cmd_read_topology_t *read_topo = (sli4_cmd_read_topology_t *)mqe;
+
+	if (status || read_topo->hdr.status) {
+		ocs_log_debug(hw->os, "bad status cqe=%#x mqe=%#x\n",
+				status, read_topo->hdr.status);
+		ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+		return -1;
+	}
+
+	switch (read_topo->attention_type) {
+	case SLI4_READ_TOPOLOGY_LINK_UP:
+		hw->link.status = SLI_LINK_STATUS_UP;
+		break;
+	case SLI4_READ_TOPOLOGY_LINK_DOWN:
+		hw->link.status = SLI_LINK_STATUS_DOWN;
+		break;
+	case SLI4_READ_TOPOLOGY_LINK_NO_ALPA:
+		hw->link.status = SLI_LINK_STATUS_NO_ALPA;
+		break;
+	default:
+		hw->link.status = SLI_LINK_STATUS_MAX;
+		break;
+	}
+
+	switch (read_topo->topology) {
+	case SLI4_READ_TOPOLOGY_NPORT:
+		hw->link.topology = SLI_LINK_TOPO_NPORT;
+		break;
+	case SLI4_READ_TOPOLOGY_FC_AL:
+		hw->link.topology = SLI_LINK_TOPO_LOOP;
+		if (SLI_LINK_STATUS_UP == hw->link.status) {
+			hw->link.loop_map = hw->loop_map.virt;
+		}
+		hw->link.fc_id = read_topo->acquired_al_pa;
+		break;
+	default:
+		hw->link.topology = SLI_LINK_TOPO_MAX;
+		break;
+	}
+
+	hw->link.medium = SLI_LINK_MEDIUM_FC;
+
+	switch (read_topo->link_current.link_speed) {
+	case SLI4_READ_TOPOLOGY_SPEED_1G:
+		hw->link.speed =  1 * 1000;
+		break;
+	case SLI4_READ_TOPOLOGY_SPEED_2G:
+		hw->link.speed =  2 * 1000;
+		break;
+	case SLI4_READ_TOPOLOGY_SPEED_4G:
+		hw->link.speed =  4 * 1000;
+		break;
+	case SLI4_READ_TOPOLOGY_SPEED_8G:
+		hw->link.speed =  8 * 1000;
+		break;
+	case SLI4_READ_TOPOLOGY_SPEED_16G:
+		hw->link.speed = 16 * 1000;
+		hw->link.loop_map = NULL;
+		break;
+	case SLI4_READ_TOPOLOGY_SPEED_32G:
+		hw->link.speed = 32 * 1000;
+		hw->link.loop_map = NULL;
+		break;
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+
+	ocs_hw_read_fcf(hw, SLI4_FCOE_FCF_TABLE_FIRST);
+
+	return 0;
+}
+
+static int32_t
+__ocs_hw_port_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_EXIT:
+		/* ignore */
+		break;
+
+	case OCS_EVT_HW_PORT_REQ_FREE:
+	case OCS_EVT_HW_PORT_REQ_ATTACH:
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		/* fall through */
+	default:
+		ocs_log_test(hw->os, "%s %-20s not handled\n", funcname, ocs_sm_event_name(evt));
+		break;
+	}
+
+	return 0;
+}
+
+static void *
+__ocs_hw_port_free_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		if (hw->callback.port != NULL) {
+			hw->callback.port(hw->args.port,
+					OCS_HW_PORT_FREE_FAIL, sport);
+		}
+		break;
+	default:
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_freed(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* free SLI resource */
+		if (sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator)) {
+			ocs_log_err(hw->os, "FCOE_VPI free failure addr=%#x\n", sport->fc_id);
+		}
+
+		/* free mailbox buffer */
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		if (hw->callback.port != NULL) {
+			hw->callback.port(hw->args.port,
+					OCS_HW_PORT_FREE_OK, sport);
+		}
+		break;
+	default:
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_attach_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* free SLI resource */
+		sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator);
+
+		/* free mailbox buffer */
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+
+		if (hw->callback.port != NULL) {
+			hw->callback.port(hw->args.port,
+					OCS_HW_PORT_ATTACH_FAIL, sport);
+		}
+		if (sport->sm_free_req_pending) {
+			ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL);
+		}
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_free_unreg_vpi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+	uint8_t		*cmd = NULL;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* allocate memory and send unreg_vpi */
+		cmd = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+		if (!cmd) {
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (0 == sli_cmd_unreg_vpi(&hw->sli, cmd, SLI4_BMBX_SIZE, sport->indicator,
+					   SLI4_UNREG_TYPE_PORT)) {
+			ocs_log_err(hw->os, "UNREG_VPI format failure\n");
+			ocs_free(hw->os, cmd, SLI4_BMBX_SIZE);
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (ocs_hw_command(hw, cmd, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) {
+			ocs_log_err(hw->os, "UNREG_VPI command failure\n");
+			ocs_free(hw->os, cmd, SLI4_BMBX_SIZE);
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		ocs_sm_transition(ctx, __ocs_hw_port_freed, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_port_free_report_fail, data);
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_free_nop(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* Forward to execute in mailbox completion processing context */
+		if (ocs_hw_async_call(hw, __ocs_hw_port_realloc_cb, sport)) {
+			ocs_log_err(hw->os, "ocs_hw_async_call failed\n");
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		ocs_sm_transition(ctx, __ocs_hw_port_freed, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_port_free_report_fail, data);
+		break;
+	default:
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_attached(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		if (hw->callback.port != NULL) {
+			hw->callback.port(hw->args.port,
+					OCS_HW_PORT_ATTACH_OK, sport);
+		}
+		if (sport->sm_free_req_pending) {
+			ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL);
+		}
+		break;
+	case OCS_EVT_HW_PORT_REQ_FREE:
+		/* virtual/physical port request free */
+		ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL);
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_attach_reg_vpi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (0 == sli_cmd_reg_vpi(&hw->sli, data, SLI4_BMBX_SIZE, sport, FALSE)) {
+			ocs_log_err(hw->os, "REG_VPI format failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) {
+			ocs_log_err(hw->os, "REG_VPI command failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		ocs_sm_transition(ctx, __ocs_hw_port_attached, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_port_attach_report_fail, data);
+		break;
+	case OCS_EVT_HW_PORT_REQ_FREE:
+		/* Wait for attach response and then free */
+		sport->sm_free_req_pending = 1;
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_done(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* free SLI resource */
+		sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator);
+
+		/* free mailbox buffer */
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		if (hw->callback.port != NULL) {
+			hw->callback.port(hw->args.port,
+					OCS_HW_PORT_ALLOC_OK, sport);
+		}
+		/* If there is a pending free request, then handle it now */
+		if (sport->sm_free_req_pending) {
+			ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL);
+		}
+		break;
+	case OCS_EVT_HW_PORT_REQ_ATTACH:
+		/* virtual port requests attach */
+		ocs_sm_transition(ctx, __ocs_hw_port_attach_reg_vpi, data);
+		break;
+	case OCS_EVT_HW_PORT_ATTACH_OK:
+		/* physical port attached (as part of attaching domain) */
+		ocs_sm_transition(ctx, __ocs_hw_port_attached, data);
+		break;
+	case OCS_EVT_HW_PORT_REQ_FREE:
+		/* virtual port request free */
+		if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(&hw->sli)) {
+			ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL);
+		} else {
+			/*
+			 * Note: BE3/Skyhawk will respond with a status of 0x20
+			 *       unless the reg_vpi has been issued, so we can
+			 *       skip the unreg_vpi for these adapters.
+			 *
+			 * Send a nop to make sure that free doesn't occur in
+			 * same context
+			 */
+			ocs_sm_transition(ctx, __ocs_hw_port_free_nop, NULL);
+		}
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_alloc_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* free SLI resource */
+		sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VPI, sport->indicator);
+
+		/* free mailbox buffer */
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+
+		if (hw->callback.port != NULL) {
+			hw->callback.port(hw->args.port,
+					OCS_HW_PORT_ALLOC_FAIL, sport);
+		}
+
+		/* If there is a pending free request, then handle it now */
+		if (sport->sm_free_req_pending) {
+			ocs_sm_transition(ctx, __ocs_hw_port_free_unreg_vpi, NULL);
+		}
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_alloc_read_sparm64(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+	uint8_t		*payload = NULL;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* allocate memory for the service parameters */
+		if (ocs_dma_alloc(hw->os, &sport->dma, 112, 4)) {
+			ocs_log_err(hw->os, "Failed to allocate DMA memory\n");
+			ocs_sm_transition(ctx, __ocs_hw_port_done, data);
+			break;
+		}
+
+		if (0 == sli_cmd_read_sparm64(&hw->sli, data, SLI4_BMBX_SIZE,
+					&sport->dma, sport->indicator)) {
+			ocs_log_err(hw->os, "READ_SPARM64 allocation failure\n");
+			ocs_dma_free(hw->os, &sport->dma);
+			ocs_sm_transition(ctx, __ocs_hw_port_done, data);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) {
+			ocs_log_err(hw->os, "READ_SPARM64 command failure\n");
+			ocs_dma_free(hw->os, &sport->dma);
+			ocs_sm_transition(ctx, __ocs_hw_port_done, data);
+			break;
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		payload = sport->dma.virt;
+
+		ocs_display_sparams(sport->display_name, "sport sparm64", 0, NULL, payload);
+
+		ocs_memcpy(&sport->sli_wwpn, payload + SLI4_READ_SPARM64_WWPN_OFFSET,
+				sizeof(sport->sli_wwpn));
+		ocs_memcpy(&sport->sli_wwnn, payload + SLI4_READ_SPARM64_WWNN_OFFSET,
+				sizeof(sport->sli_wwnn));
+
+		ocs_dma_free(hw->os, &sport->dma);
+		ocs_sm_transition(ctx, __ocs_hw_port_alloc_init_vpi, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_dma_free(hw->os, &sport->dma);
+		ocs_sm_transition(ctx, __ocs_hw_port_alloc_report_fail, data);
+		break;
+	case OCS_EVT_HW_PORT_REQ_FREE:
+		/* Wait for attach response and then free */
+		sport->sm_free_req_pending = 1;
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_alloc_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* no-op */
+		break;
+	case OCS_EVT_HW_PORT_ALLOC_OK:
+		ocs_sm_transition(ctx, __ocs_hw_port_allocated, NULL);
+		break;
+	case OCS_EVT_HW_PORT_ALLOC_FAIL:
+		ocs_sm_transition(ctx, __ocs_hw_port_alloc_report_fail, NULL);
+		break;
+	case OCS_EVT_HW_PORT_REQ_FREE:
+		/* Wait for attach response and then free */
+		sport->sm_free_req_pending = 1;
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_port_alloc_init_vpi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_sli_port_t	*sport = ctx->app;
+	ocs_hw_t	*hw = sport->hw;
+
+	smtrace("port");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* If there is a pending free request, then handle it now */
+		if (sport->sm_free_req_pending) {
+			ocs_sm_transition(ctx, __ocs_hw_port_freed, NULL);
+			return NULL;
+		}
+
+		/* TODO XXX transitioning to done only works if this is called
+		 * directly from ocs_hw_port_alloc BUT not if called from
+		 * read_sparm64. In the later case, we actually want to go
+		 * through report_ok/fail
+		 */
+		if (0 == sli_cmd_init_vpi(&hw->sli, data, SLI4_BMBX_SIZE,
+					sport->indicator, sport->domain->indicator)) {
+			ocs_log_err(hw->os, "INIT_VPI allocation failure\n");
+			ocs_sm_transition(ctx, __ocs_hw_port_done, data);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_port_cb, sport)) {
+			ocs_log_err(hw->os, "INIT_VPI command failure\n");
+			ocs_sm_transition(ctx, __ocs_hw_port_done, data);
+			break;
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		ocs_sm_transition(ctx, __ocs_hw_port_allocated, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_port_alloc_report_fail, data);
+		break;
+	case OCS_EVT_HW_PORT_REQ_FREE:
+		/* Wait for attach response and then free */
+		sport->sm_free_req_pending = 1;
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	default:
+		__ocs_hw_port_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static int32_t
+__ocs_hw_port_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_sli_port_t *sport = arg;
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+	ocs_sm_event_t	evt;
+
+	if (status || hdr->status) {
+		ocs_log_debug(hw->os, "bad status vpi=%#x st=%x hdr=%x\n",
+			      sport->indicator, status, hdr->status);
+		evt = OCS_EVT_ERROR;
+	} else {
+		evt = OCS_EVT_RESPONSE;
+	}
+
+	ocs_sm_post_event(&sport->ctx, evt, mqe);
+
+	return 0;
+}
+
+static int32_t
+__ocs_hw_port_realloc_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_sli_port_t *sport = arg;
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+	ocs_sm_event_t	evt;
+	uint8_t *mqecpy;
+
+	if (status || hdr->status) {
+		ocs_log_debug(hw->os, "bad status vpi=%#x st=%x hdr=%x\n",
+			      sport->indicator, status, hdr->status);
+		evt = OCS_EVT_ERROR;
+	} else {
+		evt = OCS_EVT_RESPONSE;
+	}
+
+	/*
+	 * In this case we have to malloc a mailbox command buffer, as it is reused
+	 * in the state machine post event call, and eventually freed
+	 */
+	mqecpy = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (mqecpy == NULL) {
+		ocs_log_err(hw->os, "malloc mqecpy failed\n");
+		return -1;
+	}
+	ocs_memcpy(mqecpy, mqe, SLI4_BMBX_SIZE);
+
+	ocs_sm_post_event(&sport->ctx, evt, mqecpy);
+
+	return 0;
+}
+
+/***************************************************************************
+ * Domain state machine
+ */
+
+static int32_t
+__ocs_hw_domain_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_EXIT:
+		/* ignore */
+		break;
+
+	default:
+		ocs_log_test(hw->os, "%s %-20s not handled\n", funcname, ocs_sm_event_name(evt));
+		break;
+	}
+
+	return 0;
+}
+
+static void *
+__ocs_hw_domain_alloc_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* free command buffer */
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		/* free SLI resources */
+		sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI, domain->indicator);
+		/* TODO how to free FCFI (or do we at all)? */
+
+		if (hw->callback.domain != NULL) {
+			hw->callback.domain(hw->args.domain,
+					OCS_HW_DOMAIN_ALLOC_FAIL,
+					domain);
+		}
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_attached(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* free mailbox buffer and send alloc ok to physical sport */
+		ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		ocs_sm_post_event(&domain->sport->ctx, OCS_EVT_HW_PORT_ATTACH_OK, NULL);
+
+		/* now inform registered callbacks */
+		if (hw->callback.domain != NULL) {
+			hw->callback.domain(hw->args.domain,
+					OCS_HW_DOMAIN_ATTACH_OK,
+					domain);
+		}
+		break;
+	case OCS_EVT_HW_DOMAIN_REQ_FREE:
+		ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_vfi, NULL);
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_attach_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (data != NULL) {
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		}
+		/* free SLI resources */
+		sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI, domain->indicator);
+		/* TODO how to free FCFI (or do we at all)? */
+
+		if (hw->callback.domain != NULL) {
+			hw->callback.domain(hw->args.domain,
+					OCS_HW_DOMAIN_ATTACH_FAIL,
+					domain);
+		}
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_attach_reg_vfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+
+		ocs_display_sparams("", "reg vpi", 0, NULL, domain->dma.virt);
+
+		if (0 == sli_cmd_reg_vfi(&hw->sli, data, SLI4_BMBX_SIZE, domain)) {
+			ocs_log_err(hw->os, "REG_VFI format failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) {
+			ocs_log_err(hw->os, "REG_VFI command failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		ocs_sm_transition(ctx, __ocs_hw_domain_attached, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_domain_attach_report_fail, data);
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* free mailbox buffer and send alloc ok to physical sport */
+		ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+		ocs_sm_post_event(&domain->sport->ctx, OCS_EVT_HW_PORT_ALLOC_OK, NULL);
+
+		ocs_hw_domain_add(hw, domain);
+
+		/* now inform registered callbacks */
+		if (hw->callback.domain != NULL) {
+			hw->callback.domain(hw->args.domain,
+					OCS_HW_DOMAIN_ALLOC_OK,
+					domain);
+		}
+		break;
+	case OCS_EVT_HW_DOMAIN_REQ_ATTACH:
+		ocs_sm_transition(ctx, __ocs_hw_domain_attach_reg_vfi, data);
+		break;
+	case OCS_EVT_HW_DOMAIN_REQ_FREE:
+		/* unreg_fcfi/vfi */
+		if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) {
+			ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_fcfi, NULL);
+		} else {
+			ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_vfi, NULL);
+		}
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_alloc_read_sparm64(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (0 == sli_cmd_read_sparm64(&hw->sli, data, SLI4_BMBX_SIZE,
+					&domain->dma, SLI4_READ_SPARM64_VPI_DEFAULT)) {
+			ocs_log_err(hw->os, "READ_SPARM64 format failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) {
+			ocs_log_err(hw->os, "READ_SPARM64 command failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	case OCS_EVT_RESPONSE:
+		ocs_display_sparams(domain->display_name, "domain sparm64", 0, NULL, domain->dma.virt);
+
+		ocs_sm_transition(ctx, __ocs_hw_domain_allocated, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_domain_alloc_report_fail, data);
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_alloc_init_vfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_sli_port_t	*sport = domain->sport;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (0 == sli_cmd_init_vfi(&hw->sli, data, SLI4_BMBX_SIZE, domain->indicator,
+					domain->fcf_indicator, sport->indicator)) {
+			ocs_log_err(hw->os, "INIT_VFI format failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) {
+			ocs_log_err(hw->os, "INIT_VFI command failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	case OCS_EVT_RESPONSE:
+		ocs_sm_transition(ctx, __ocs_hw_domain_alloc_read_sparm64, data);
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_domain_alloc_report_fail, data);
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_alloc_reg_fcfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER: {
+		sli4_cmd_rq_cfg_t rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG];
+		uint32_t i;
+
+		/* Set the filter match/mask values from hw's filter_def values */
+		for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) {
+			rq_cfg[i].rq_id = 0xffff;
+			rq_cfg[i].r_ctl_mask = (uint8_t) hw->config.filter_def[i];
+			rq_cfg[i].r_ctl_match = (uint8_t) (hw->config.filter_def[i] >> 8);
+			rq_cfg[i].type_mask = (uint8_t) (hw->config.filter_def[i] >> 16);
+			rq_cfg[i].type_match = (uint8_t) (hw->config.filter_def[i] >> 24);
+		}
+
+		/* Set the rq_id for each, in order of RQ definition */
+		for (i = 0; i < hw->hw_rq_count; i++) {
+			if (i >= ARRAY_SIZE(rq_cfg)) {
+				ocs_log_warn(hw->os, "more RQs than REG_FCFI filter entries\n");
+				break;
+			}
+			rq_cfg[i].rq_id = hw->hw_rq[i]->hdr->id;
+		}
+
+		if (!data) {
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (hw->hw_mrq_count) {
+			if (OCS_HW_RTN_SUCCESS != ocs_hw_config_mrq(hw, SLI4_CMD_REG_FCFI_SET_FCFI_MODE,
+				 domain->vlan_id, domain->fcf)) {
+				ocs_log_err(hw->os, "REG_FCFI_MRQ format failure\n");
+				ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+				break;
+			}
+
+		} else {
+			if (0 == sli_cmd_reg_fcfi(&hw->sli, data, SLI4_BMBX_SIZE, domain->fcf,
+						rq_cfg, domain->vlan_id)) {
+				ocs_log_err(hw->os, "REG_FCFI format failure\n");
+				ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+				break;
+			}
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) {
+			ocs_log_err(hw->os, "REG_FCFI command failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	}
+	case OCS_EVT_EXIT:
+		break;
+	case OCS_EVT_RESPONSE:
+		if (!data) {
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		domain->fcf_indicator = ((sli4_cmd_reg_fcfi_t *)data)->fcfi;
+
+		/*
+		 * IF_TYPE 0 devices do not support explicit VFI and VPI initialization
+		 * and instead rely on implicit initialization during VFI registration.
+		 * Short circuit normal processing here for those devices.
+		 */
+		if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(&hw->sli)) {
+			ocs_sm_transition(ctx, __ocs_hw_domain_alloc_read_sparm64, data);
+		} else {
+			ocs_sm_transition(ctx, __ocs_hw_domain_alloc_init_vfi, data);
+		}
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_domain_alloc_report_fail, data);
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC) {
+			/*
+			 * For FC, the HW alread registered a FCFI
+			 * Copy FCF information into the domain and jump to INIT_VFI
+			 */
+			domain->fcf_indicator = hw->fcf_indicator;
+			ocs_sm_transition(&domain->sm, __ocs_hw_domain_alloc_init_vfi, data);
+		} else {
+			ocs_sm_transition(&domain->sm, __ocs_hw_domain_alloc_reg_fcfi, data);
+		}
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_free_report_fail(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (domain != NULL) {
+			ocs_hw_t	*hw = domain->hw;
+
+			ocs_hw_domain_del(hw, domain);
+
+			if (hw->callback.domain != NULL) {
+				hw->callback.domain(hw->args.domain,
+						     OCS_HW_DOMAIN_FREE_FAIL,
+						     domain);
+			}
+		}
+
+		/* free command buffer */
+		if (data != NULL) {
+			ocs_free(domain != NULL ? domain->hw->os : NULL, data, SLI4_BMBX_SIZE);
+		}
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_freed(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* Free DMA and mailbox buffer */
+		if (domain != NULL) {
+			ocs_hw_t *hw = domain->hw;
+
+			/* free VFI resource */
+			sli_resource_free(&hw->sli, SLI_RSRC_FCOE_VFI,
+					  domain->indicator);
+
+			ocs_hw_domain_del(hw, domain);
+
+			/* inform registered callbacks */
+			if (hw->callback.domain != NULL) {
+				hw->callback.domain(hw->args.domain,
+						     OCS_HW_DOMAIN_FREE_OK,
+						     domain);
+			}
+		}
+		if (data != NULL) {
+			ocs_free(NULL, data, SLI4_BMBX_SIZE);
+		}
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+
+static void *
+__ocs_hw_domain_free_redisc_fcf(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		/* if we're in the middle of a teardown, skip sending rediscover */
+		if (hw->state == OCS_HW_STATE_TEARDOWN_IN_PROGRESS) {
+			ocs_sm_transition(ctx, __ocs_hw_domain_freed, data);
+			break;
+		}
+		if (0 == sli_cmd_fcoe_rediscover_fcf(&hw->sli, data, SLI4_BMBX_SIZE, domain->fcf)) {
+			ocs_log_err(hw->os, "REDISCOVER_FCF format failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) {
+			ocs_log_err(hw->os, "REDISCOVER_FCF command failure\n");
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+	case OCS_EVT_ERROR:
+		/* REDISCOVER_FCF can fail if none exist */
+		ocs_sm_transition(ctx, __ocs_hw_domain_freed, data);
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_free_unreg_fcfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+
+	smtrace("domain");
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (data == NULL) {
+			data = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+			if (!data) {
+				ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+				break;
+			}
+		}
+
+		if (0 == sli_cmd_unreg_fcfi(&hw->sli, data, SLI4_BMBX_SIZE, domain->fcf_indicator)) {
+			ocs_log_err(hw->os, "UNREG_FCFI format failure\n");
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) {
+			ocs_log_err(hw->os, "UNREG_FCFI command failure\n");
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		if (domain->req_rediscover_fcf) {
+			domain->req_rediscover_fcf = FALSE;
+			ocs_sm_transition(ctx, __ocs_hw_domain_free_redisc_fcf, data);
+		} else {
+			ocs_sm_transition(ctx, __ocs_hw_domain_freed, data);
+		}
+		break;
+	case OCS_EVT_ERROR:
+		ocs_sm_transition(ctx, __ocs_hw_domain_free_report_fail, data);
+		break;
+	case OCS_EVT_EXIT:
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+static void *
+__ocs_hw_domain_free_unreg_vfi(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	ocs_domain_t	*domain = ctx->app;
+	ocs_hw_t	*hw = domain->hw;
+	uint8_t		is_fc = FALSE;
+
+	smtrace("domain");
+
+	is_fc = (sli_get_medium(&hw->sli) == SLI_LINK_MEDIUM_FC);
+
+	switch (evt) {
+	case OCS_EVT_ENTER:
+		if (data == NULL) {
+			data = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+			if (!data) {
+				ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+				break;
+			}
+		}
+
+		if (0 == sli_cmd_unreg_vfi(&hw->sli, data, SLI4_BMBX_SIZE, domain,
+					SLI4_UNREG_TYPE_DOMAIN)) {
+			ocs_log_err(hw->os, "UNREG_VFI format failure\n");
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+
+		if (ocs_hw_command(hw, data, OCS_CMD_NOWAIT, __ocs_hw_domain_cb, domain)) {
+			ocs_log_err(hw->os, "UNREG_VFI command failure\n");
+			ocs_free(hw->os, data, SLI4_BMBX_SIZE);
+			ocs_sm_post_event(ctx, OCS_EVT_ERROR, NULL);
+			break;
+		}
+		break;
+	case OCS_EVT_ERROR:
+		if (is_fc) {
+			ocs_sm_transition(ctx, __ocs_hw_domain_free_report_fail, data);
+		} else {
+			ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_fcfi, data);
+		}
+		break;
+	case OCS_EVT_RESPONSE:
+		if (is_fc) {
+			ocs_sm_transition(ctx, __ocs_hw_domain_freed, data);
+		} else {
+			ocs_sm_transition(ctx, __ocs_hw_domain_free_unreg_fcfi, data);
+		}
+		break;
+	default:
+		__ocs_hw_domain_common(__func__, ctx, evt, data);
+		break;
+	}
+
+	return NULL;
+}
+
+/* callback for domain alloc/attach/free */
+static int32_t
+__ocs_hw_domain_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_domain_t	*domain = arg;
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+	ocs_sm_event_t	evt;
+
+	if (status || hdr->status) {
+		ocs_log_debug(hw->os, "bad status vfi=%#x st=%x hdr=%x\n",
+			      domain->indicator, status, hdr->status);
+		evt = OCS_EVT_ERROR;
+	} else {
+		evt = OCS_EVT_RESPONSE;
+	}
+
+	ocs_sm_post_event(&domain->sm, evt, mqe);
+
+	return 0;
+}
+
+static int32_t
+target_wqe_timer_nop_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_io_t *io = NULL;
+	ocs_hw_io_t *io_next = NULL;
+	uint64_t ticks_current = ocs_get_os_ticks();
+	uint32_t sec_elapsed;
+
+	sli4_mbox_command_header_t	*hdr = (sli4_mbox_command_header_t *)mqe;
+
+	if (status || hdr->status) {
+		ocs_log_debug(hw->os, "bad status st=%x hdr=%x\n",
+			      status, hdr->status);
+		/* go ahead and proceed with wqe timer checks... */
+	}
+
+	/* loop through active WQE list and check for timeouts */
+	ocs_lock(&hw->io_lock);
+		ocs_list_foreach_safe(&hw->io_timed_wqe, io, io_next) {
+			sec_elapsed = ((ticks_current - io->submit_ticks) / ocs_get_os_tick_freq());
+
+			/*
+			 * If elapsed time > timeout, abort it. No need to check type since
+			 * it wouldn't be on this list unless it was a target WQE
+			 */
+			if (sec_elapsed > io->tgt_wqe_timeout) {
+				ocs_log_test(hw->os, "IO timeout xri=0x%x tag=0x%x type=%d\n",
+					     io->indicator, io->reqtag, io->type);
+
+				/* remove from active_wqe list so won't try to abort again */
+				ocs_list_remove(&hw->io_timed_wqe, io);
+
+				/* save status of "timed out" for when abort completes */
+				io->status_saved = 1;
+				io->saved_status = SLI4_FC_WCQE_STATUS_TARGET_WQE_TIMEOUT;
+				io->saved_ext = 0;
+				io->saved_len = 0;
+
+				/* now abort outstanding IO */
+				ocs_hw_io_abort(hw, io, FALSE, NULL, NULL);
+			}
+			/*
+			 * need to go through entire list since each IO could have a
+			 * different timeout value
+			 */
+		}
+	ocs_unlock(&hw->io_lock);
+
+	/* if we're not in the middle of shutting down, schedule next timer */
+	if (!hw->active_wqe_timer_shutdown) {
+		ocs_setup_timer(hw->os, &hw->wqe_timer, target_wqe_timer_cb, hw, OCS_HW_WQ_TIMER_PERIOD_MS);
+	}
+	hw->in_active_wqe_timer = FALSE;
+	return 0;
+}
+
+static void
+target_wqe_timer_cb(void *arg)
+{
+	ocs_hw_t *hw = (ocs_hw_t *)arg;
+
+	/* delete existing timer; will kick off new timer after checking wqe timeouts */
+	hw->in_active_wqe_timer = TRUE;
+	ocs_del_timer(&hw->wqe_timer);
+
+	/* Forward timer callback to execute in the mailbox completion processing context */
+	if (ocs_hw_async_call(hw, target_wqe_timer_nop_cb, hw)) {
+		ocs_log_test(hw->os, "ocs_hw_async_call failed\n");
+	}
+}
+
+static void
+shutdown_target_wqe_timer(ocs_hw_t *hw)
+{
+	uint32_t	iters = 100;
+
+	if (hw->config.emulate_tgt_wqe_timeout) {
+		/* request active wqe timer shutdown, then wait for it to complete */
+		hw->active_wqe_timer_shutdown = TRUE;
+
+		/* delete WQE timer and wait for timer handler to complete (if necessary) */
+		ocs_del_timer(&hw->wqe_timer);
+
+		/* now wait for timer handler to complete (if necessary) */
+		while (hw->in_active_wqe_timer && iters) {
+			/*
+			 * if we happen to have just sent NOP mailbox command, make sure
+			 * completions are being processed
+			 */
+			ocs_hw_flush(hw);
+			iters--;
+		}
+
+		if (iters == 0) {
+			ocs_log_test(hw->os, "Failed to shutdown active wqe timer\n");
+		}
+	}
+}
+
+/**
+ * @brief Determine if HW IO is owned by the port.
+ *
+ * @par Description
+ * Determines if the given HW IO has been posted to the chip.
+ *
+ * @param hw Hardware context allocated by the caller.
+ * @param io HW IO.
+ *
+ * @return Returns TRUE if given HW IO is port-owned.
+ */
+uint8_t
+ocs_hw_is_io_port_owned(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	/* Check to see if this is a port owned XRI */
+	return io->is_port_owned;
+}
+
+/**
+ * @brief Return TRUE if exchange is port-owned.
+ *
+ * @par Description
+ * Test to see if the xri is a port-owned xri.
+ *
+ * @param hw Hardware context.
+ * @param xri Exchange indicator.
+ *
+ * @return Returns TRUE if XRI is a port owned XRI.
+ */
+
+uint8_t
+ocs_hw_is_xri_port_owned(ocs_hw_t *hw, uint32_t xri)
+{
+	ocs_hw_io_t *io = ocs_hw_io_lookup(hw, xri);
+	return (io == NULL ? FALSE : io->is_port_owned);
+}
+
+/**
+ * @brief Returns an XRI from the port owned list to the host.
+ *
+ * @par Description
+ * Used when the POST_XRI command fails as well as when the RELEASE_XRI completes.
+ *
+ * @param hw Hardware context.
+ * @param xri_base The starting XRI number.
+ * @param xri_count The number of XRIs to free from the base.
+ */
+static void
+ocs_hw_reclaim_xri(ocs_hw_t *hw, uint16_t xri_base, uint16_t xri_count)
+{
+	ocs_hw_io_t	*io;
+	uint32_t i;
+
+	for (i = 0; i < xri_count; i++) {
+		io = ocs_hw_io_lookup(hw, xri_base + i);
+
+		/*
+		 * if this is an auto xfer rdy XRI, then we need to release any
+		 * buffer attached to the XRI before moving the XRI back to the free pool.
+		 */
+		if (hw->auto_xfer_rdy_enabled) {
+			ocs_hw_rqpair_auto_xfer_rdy_move_to_host(hw, io);
+		}
+
+		ocs_lock(&hw->io_lock);
+			ocs_list_remove(&hw->io_port_owned, io);
+			io->is_port_owned = 0;
+			ocs_list_add_tail(&hw->io_free, io);
+		ocs_unlock(&hw->io_lock);
+	}
+}
+
+/**
+ * @brief Called when the POST_XRI command completes.
+ *
+ * @par Description
+ * Free the mailbox command buffer and reclaim the XRIs on failure.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_post_xri(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	sli4_cmd_post_xri_t	*post_xri = (sli4_cmd_post_xri_t*)mqe;
+
+	/* Reclaim the XRIs as host owned if the command fails */
+	if (status != 0) {
+		ocs_log_debug(hw->os, "Status 0x%x for XRI base 0x%x, cnt =x%x\n",
+			      status, post_xri->xri_base, post_xri->xri_count);
+		ocs_hw_reclaim_xri(hw, post_xri->xri_base, post_xri->xri_count);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	return 0;
+}
+
+/**
+ * @brief Issues a mailbox command to move XRIs from the host-controlled pool to the port.
+ *
+ * @param hw Hardware context.
+ * @param xri_start The starting XRI to post.
+ * @param num_to_post The number of XRIs to post.
+ *
+ * @return Returns OCS_HW_RTN_NO_MEMORY, OCS_HW_RTN_ERROR, or OCS_HW_RTN_SUCCESS.
+ */
+
+static ocs_hw_rtn_e
+ocs_hw_post_xri(ocs_hw_t *hw, uint32_t xri_start, uint32_t num_to_post)
+{
+	uint8_t	*post_xri;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+
+	/* Since we need to allocate for mailbox queue, just always allocate */
+	post_xri = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+	if (post_xri == NULL) {
+		ocs_log_err(hw->os, "no buffer for command\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* Register the XRIs */
+	if (sli_cmd_post_xri(&hw->sli, post_xri, SLI4_BMBX_SIZE,
+			     xri_start, num_to_post)) {
+		rc = ocs_hw_command(hw, post_xri, OCS_CMD_NOWAIT, ocs_hw_cb_post_xri, NULL);
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_free(hw->os, post_xri, SLI4_BMBX_SIZE);
+			ocs_log_err(hw->os, "post_xri failed\n");
+		}
+	}
+	return rc;
+}
+
+/**
+ * @brief Move XRIs from the host-controlled pool to the port.
+ *
+ * @par Description
+ * Removes IOs from the free list and moves them to the port.
+ *
+ * @param hw Hardware context.
+ * @param num_xri The number of XRIs being requested to move to the chip.
+ *
+ * @return Returns the number of XRIs that were moved.
+ */
+
+uint32_t
+ocs_hw_xri_move_to_port_owned(ocs_hw_t *hw, uint32_t num_xri)
+{
+	ocs_hw_io_t	*io;
+	uint32_t i;
+	uint32_t num_posted = 0;
+
+	/*
+	 * Note: We cannot use ocs_hw_io_alloc() because that would place the
+	 *       IO on the io_inuse list. We need to move from the io_free to
+	 *       the io_port_owned list.
+	 */
+	ocs_lock(&hw->io_lock);
+
+	for (i = 0; i < num_xri; i++) {
+
+		if (NULL != (io = ocs_list_remove_head(&hw->io_free))) {
+			ocs_hw_rtn_e rc;
+
+			/*
+			 * if this is an auto xfer rdy XRI, then we need to attach a
+			 * buffer to the XRI before submitting it to the chip. If a
+			 * buffer is unavailable, then we cannot post it, so return it
+			 * to the free pool.
+			 */
+			if (hw->auto_xfer_rdy_enabled) {
+				/* Note: uses the IO lock to get the auto xfer rdy buffer */
+				ocs_unlock(&hw->io_lock);
+				rc = ocs_hw_rqpair_auto_xfer_rdy_move_to_port(hw, io);
+				ocs_lock(&hw->io_lock);
+				if (rc != OCS_HW_RTN_SUCCESS) {
+					ocs_list_add_head(&hw->io_free, io);
+					break;
+				}
+			}
+			ocs_lock_init(hw->os, &io->axr_lock, "HW_axr_lock[%d]", io->indicator);
+			io->is_port_owned = 1;
+			ocs_list_add_tail(&hw->io_port_owned, io);
+
+			/* Post XRI */
+			if (ocs_hw_post_xri(hw, io->indicator, 1) != OCS_HW_RTN_SUCCESS ) {
+				ocs_hw_reclaim_xri(hw, io->indicator, i);
+				break;
+			}
+			num_posted++;
+		} else {
+			/* no more free XRIs */
+			break;
+		}
+	}
+	ocs_unlock(&hw->io_lock);
+
+	return num_posted;
+}
+
+/**
+ * @brief Called when the RELEASE_XRI command completes.
+ *
+ * @par Description
+ * Move the IOs back to the free pool on success.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_cb_release_xri(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	sli4_cmd_release_xri_t	*release_xri = (sli4_cmd_release_xri_t*)mqe;
+	uint8_t i;
+
+	/* Reclaim the XRIs as host owned if the command fails */
+	if (status != 0) {
+		ocs_log_err(hw->os, "Status 0x%x\n", status);
+	} else {
+		for (i = 0; i < release_xri->released_xri_count; i++) {
+			uint16_t xri = ((i & 1) == 0 ? release_xri->xri_tbl[i/2].xri_tag0 :
+					release_xri->xri_tbl[i/2].xri_tag1);
+			ocs_hw_reclaim_xri(hw, xri, 1);
+		}
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	return 0;
+}
+
+/**
+ * @brief Move XRIs from the port-controlled pool to the host.
+ *
+ * Requests XRIs from the FW to return to the host-owned pool.
+ *
+ * @param hw Hardware context.
+ * @param num_xri The number of XRIs being requested to moved from the chip.
+ *
+ * @return Returns 0 for success, or a negative error code value for failure.
+ */
+
+ocs_hw_rtn_e
+ocs_hw_xri_move_to_host_owned(ocs_hw_t *hw, uint8_t num_xri)
+{
+	uint8_t	*release_xri;
+	ocs_hw_rtn_e rc = OCS_HW_RTN_ERROR;
+
+	/* non-local buffer required for mailbox queue */
+	release_xri = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+	if (release_xri == NULL) {
+		ocs_log_err(hw->os, "no buffer for command\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	/* release the XRIs */
+	if (sli_cmd_release_xri(&hw->sli, release_xri, SLI4_BMBX_SIZE, num_xri)) {
+		rc = ocs_hw_command(hw, release_xri, OCS_CMD_NOWAIT, ocs_hw_cb_release_xri, NULL);
+		if (rc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(hw->os, "release_xri failed\n");
+		}
+	}
+	/* If we are polling or an error occurred, then free the mailbox buffer */
+	if (release_xri != NULL && rc != OCS_HW_RTN_SUCCESS) {
+		ocs_free(hw->os, release_xri, SLI4_BMBX_SIZE);
+	}
+	return rc;
+}
+
+
+/**
+ * @brief Allocate an ocs_hw_rx_buffer_t array.
+ *
+ * @par Description
+ * An ocs_hw_rx_buffer_t array is allocated, along with the required DMA memory.
+ *
+ * @param hw Pointer to HW object.
+ * @param rqindex RQ index for this buffer.
+ * @param count Count of buffers in array.
+ * @param size Size of buffer.
+ *
+ * @return Returns the pointer to the allocated ocs_hw_rq_buffer_t array.
+ */
+static ocs_hw_rq_buffer_t *
+ocs_hw_rx_buffer_alloc(ocs_hw_t *hw, uint32_t rqindex, uint32_t count, uint32_t size)
+{
+	ocs_t *ocs = hw->os;
+	ocs_hw_rq_buffer_t *rq_buf = NULL;
+	ocs_hw_rq_buffer_t *prq;
+	uint32_t i;
+
+	if (count != 0) {
+		rq_buf = ocs_malloc(hw->os, sizeof(*rq_buf) * count, OCS_M_NOWAIT | OCS_M_ZERO);
+		if (rq_buf == NULL) {
+			ocs_log_err(hw->os, "Failure to allocate unsolicited DMA trackers\n");
+			return NULL;
+		}
+
+		for (i = 0, prq = rq_buf; i < count; i ++, prq++) {
+			prq->rqindex = rqindex;
+			if (ocs_dma_alloc(ocs, &prq->dma, size, OCS_MIN_DMA_ALIGNMENT)) {
+				ocs_log_err(hw->os, "DMA allocation failed\n");
+				ocs_free(hw->os, rq_buf, sizeof(*rq_buf) * count);
+				rq_buf = NULL;
+				break;
+			}
+		}
+	}
+	return rq_buf;
+}
+
+/**
+ * @brief Free an ocs_hw_rx_buffer_t array.
+ *
+ * @par Description
+ * The ocs_hw_rx_buffer_t array is freed, along with allocated DMA memory.
+ *
+ * @param hw Pointer to HW object.
+ * @param rq_buf Pointer to ocs_hw_rx_buffer_t array.
+ * @param count Count of buffers in array.
+ *
+ * @return None.
+ */
+static void
+ocs_hw_rx_buffer_free(ocs_hw_t *hw, ocs_hw_rq_buffer_t *rq_buf, uint32_t count)
+{
+	ocs_t *ocs = hw->os;
+	uint32_t i;
+	ocs_hw_rq_buffer_t *prq;
+
+	if (rq_buf != NULL) {
+		for (i = 0, prq = rq_buf; i < count; i++, prq++) {
+			ocs_dma_free(ocs, &prq->dma);
+		}
+		ocs_free(hw->os, rq_buf, sizeof(*rq_buf) * count);
+	}
+}
+
+/**
+ * @brief Allocate the RQ data buffers.
+ *
+ * @param hw Pointer to HW object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_rx_allocate(ocs_hw_t *hw)
+{
+	ocs_t *ocs = hw->os;
+	uint32_t i;
+	int32_t rc = OCS_HW_RTN_SUCCESS;
+	uint32_t rqindex = 0;
+	hw_rq_t *rq;
+	uint32_t hdr_size = OCS_HW_RQ_SIZE_HDR;
+	uint32_t payload_size = hw->config.rq_default_buffer_size;
+
+	rqindex = 0;
+
+	for (i = 0; i < hw->hw_rq_count; i++) {
+		rq = hw->hw_rq[i];
+
+		/* Allocate header buffers */
+		rq->hdr_buf = ocs_hw_rx_buffer_alloc(hw, rqindex, rq->entry_count, hdr_size);
+		if (rq->hdr_buf == NULL) {
+			ocs_log_err(ocs, "ocs_hw_rx_buffer_alloc hdr_buf failed\n");
+			rc = OCS_HW_RTN_ERROR;
+			break;
+		}
+
+		ocs_log_debug(hw->os, "rq[%2d] rq_id %02d header  %4d by %4d bytes\n", i, rq->hdr->id,
+			      rq->entry_count, hdr_size);
+
+		rqindex++;
+
+		/* Allocate payload buffers */
+		rq->payload_buf = ocs_hw_rx_buffer_alloc(hw, rqindex, rq->entry_count, payload_size);
+		if (rq->payload_buf == NULL) {
+			ocs_log_err(ocs, "ocs_hw_rx_buffer_alloc fb_buf failed\n");
+			rc = OCS_HW_RTN_ERROR;
+			break;
+		}
+		ocs_log_debug(hw->os, "rq[%2d] rq_id %02d default %4d by %4d bytes\n", i, rq->data->id,
+			      rq->entry_count, payload_size);
+		rqindex++;
+	}
+
+	return rc ? OCS_HW_RTN_ERROR : OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @brief Post the RQ data buffers to the chip.
+ *
+ * @param hw Pointer to HW object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_rx_post(ocs_hw_t *hw)
+{
+	uint32_t i;
+	uint32_t idx;
+	uint32_t rq_idx;
+	int32_t rc = 0;
+
+	/*
+	 * In RQ pair mode, we MUST post the header and payload buffer at the
+	 * same time.
+	 */
+	for (rq_idx = 0, idx = 0; rq_idx < hw->hw_rq_count; rq_idx++) {
+		hw_rq_t *rq = hw->hw_rq[rq_idx];
+
+		for (i = 0; i < rq->entry_count-1; i++) {
+			ocs_hw_sequence_t *seq = ocs_array_get(hw->seq_pool, idx++);
+			ocs_hw_assert(seq != NULL);
+
+			seq->header = &rq->hdr_buf[i];
+
+			seq->payload = &rq->payload_buf[i];
+
+			rc = ocs_hw_sequence_free(hw, seq);
+			if (rc) {
+				break;
+			}
+		}
+		if (rc) {
+			break;
+		}
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Free the RQ data buffers.
+ *
+ * @param hw Pointer to HW object.
+ *
+ */
+void
+ocs_hw_rx_free(ocs_hw_t *hw)
+{
+	hw_rq_t *rq;
+	uint32_t i;
+
+	/* Free hw_rq buffers */
+	for (i = 0; i < hw->hw_rq_count; i++) {
+		rq = hw->hw_rq[i];
+		if (rq != NULL) {
+			ocs_hw_rx_buffer_free(hw, rq->hdr_buf, rq->entry_count);
+			rq->hdr_buf = NULL;
+			ocs_hw_rx_buffer_free(hw, rq->payload_buf, rq->entry_count);
+			rq->payload_buf = NULL;
+		}
+	}
+}
+
+/**
+ * @brief HW async call context structure.
+ */
+typedef struct {
+	ocs_hw_async_cb_t callback;
+	void *arg;
+	uint8_t cmd[SLI4_BMBX_SIZE];
+} ocs_hw_async_call_ctx_t;
+
+/**
+ * @brief HW async callback handler
+ *
+ * @par Description
+ * This function is called when the NOP mailbox command completes.  The callback stored
+ * in the requesting context is invoked.
+ *
+ * @param hw Pointer to HW object.
+ * @param status Completion status.
+ * @param mqe Pointer to mailbox completion queue entry.
+ * @param arg Caller-provided argument.
+ *
+ * @return None.
+ */
+static void
+ocs_hw_async_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_hw_async_call_ctx_t *ctx = arg;
+
+	if (ctx != NULL) {
+		if (ctx->callback != NULL) {
+			(*ctx->callback)(hw, status, mqe, ctx->arg);
+		}
+		ocs_free(hw->os, ctx, sizeof(*ctx));
+	}
+}
+
+/**
+ * @brief Make an async callback using NOP mailbox command
+ *
+ * @par Description
+ * Post a NOP mailbox command; the callback with argument is invoked upon completion
+ * while in the event processing context.
+ *
+ * @param hw Pointer to HW object.
+ * @param callback Pointer to callback function.
+ * @param arg Caller-provided callback.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_hw_async_call(ocs_hw_t *hw, ocs_hw_async_cb_t callback, void *arg)
+{
+	int32_t rc = 0;
+	ocs_hw_async_call_ctx_t *ctx;
+
+	/*
+	 * Allocate a callback context (which includes the mailbox command buffer), we need
+	 * this to be persistent as the mailbox command submission may be queued and executed later
+	 * execution.
+	 */
+	ctx = ocs_malloc(hw->os, sizeof(*ctx), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (ctx == NULL) {
+		ocs_log_err(hw->os, "failed to malloc async call context\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+	ctx->callback = callback;
+	ctx->arg = arg;
+
+	/* Build and send a NOP mailbox command */
+	if (sli_cmd_common_nop(&hw->sli, ctx->cmd, sizeof(ctx->cmd), 0) == 0) {
+		ocs_log_err(hw->os, "COMMON_NOP format failure\n");
+		ocs_free(hw->os, ctx, sizeof(*ctx));
+		rc = -1;
+	}
+
+	if (ocs_hw_command(hw, ctx->cmd, OCS_CMD_NOWAIT, ocs_hw_async_cb, ctx)) {
+		ocs_log_err(hw->os, "COMMON_NOP command failure\n");
+		ocs_free(hw->os, ctx, sizeof(*ctx));
+		rc = -1;
+	}
+	return rc;
+}
+
+/**
+ * @brief Initialize the reqtag pool.
+ *
+ * @par Description
+ * The WQ request tag pool is initialized.
+ *
+ * @param hw Pointer to HW object.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_reqtag_init(ocs_hw_t *hw)
+{
+	if (hw->wq_reqtag_pool == NULL) {
+		hw->wq_reqtag_pool = ocs_pool_alloc(hw->os, sizeof(hw_wq_callback_t), 65536, TRUE);
+		if (hw->wq_reqtag_pool == NULL) {
+			ocs_log_err(hw->os, "ocs_pool_alloc hw_wq_callback_t failed\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+	}
+	ocs_hw_reqtag_reset(hw);
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @brief Allocate a WQ request tag.
+ *
+ * Allocate and populate a WQ request tag from the WQ request tag pool.
+ *
+ * @param hw Pointer to HW object.
+ * @param callback Callback function.
+ * @param arg Pointer to callback argument.
+ *
+ * @return Returns pointer to allocated WQ request tag, or NULL if object cannot be allocated.
+ */
+hw_wq_callback_t *
+ocs_hw_reqtag_alloc(ocs_hw_t *hw, void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg)
+{
+	hw_wq_callback_t *wqcb;
+
+	ocs_hw_assert(callback != NULL);
+
+	wqcb = ocs_pool_get(hw->wq_reqtag_pool);
+	if (wqcb != NULL) {
+		ocs_hw_assert(wqcb->callback == NULL);
+		wqcb->callback = callback;
+		wqcb->arg = arg;
+	}
+	return wqcb;
+}
+
+/**
+ * @brief Free a WQ request tag.
+ *
+ * Free the passed in WQ request tag.
+ *
+ * @param hw Pointer to HW object.
+ * @param wqcb Pointer to WQ request tag object to free.
+ *
+ * @return None.
+ */
+void
+ocs_hw_reqtag_free(ocs_hw_t *hw, hw_wq_callback_t *wqcb)
+{
+	ocs_hw_assert(wqcb->callback != NULL);
+	wqcb->callback = NULL;
+	wqcb->arg = NULL;
+	ocs_pool_put(hw->wq_reqtag_pool, wqcb);
+}
+
+/**
+ * @brief Return WQ request tag by index.
+ *
+ * @par Description
+ * Return pointer to WQ request tag object given an index.
+ *
+ * @param hw Pointer to HW object.
+ * @param instance_index Index of WQ request tag to return.
+ *
+ * @return Pointer to WQ request tag, or NULL.
+ */
+hw_wq_callback_t *
+ocs_hw_reqtag_get_instance(ocs_hw_t *hw, uint32_t instance_index)
+{
+	hw_wq_callback_t *wqcb;
+
+	wqcb = ocs_pool_get_instance(hw->wq_reqtag_pool, instance_index);
+	if (wqcb == NULL) {
+		ocs_log_err(hw->os, "wqcb for instance %d is null\n", instance_index);
+	}
+	return wqcb;
+}
+
+/**
+ * @brief Reset the WQ request tag pool.
+ *
+ * @par Description
+ * Reset the WQ request tag pool, returning all to the free list.
+ *
+ * @param hw pointer to HW object.
+ *
+ * @return None.
+ */
+void
+ocs_hw_reqtag_reset(ocs_hw_t *hw)
+{
+	hw_wq_callback_t *wqcb;
+	uint32_t i;
+
+	/* Remove all from freelist */
+	while(ocs_pool_get(hw->wq_reqtag_pool) != NULL) {
+		;
+	}
+
+	/* Put them all back */
+	for (i = 0; ((wqcb = ocs_pool_get_instance(hw->wq_reqtag_pool, i)) != NULL); i++) {
+		wqcb->instance_index = i;
+		wqcb->callback = NULL;
+		wqcb->arg = NULL;
+		ocs_pool_put(hw->wq_reqtag_pool, wqcb);
+	}
+}
+
+/**
+ * @brief Handle HW assertion
+ *
+ * HW assert, display diagnostic message, and abort.
+ *
+ * @param cond string describing failing assertion condition
+ * @param filename file name
+ * @param linenum line number
+ *
+ * @return none
+ */
+void
+_ocs_hw_assert(const char *cond, const char *filename, int linenum)
+{
+	ocs_printf("%s(%d): HW assertion (%s) failed\n", filename, linenum, cond);
+	ocs_abort();
+		/* no return */
+}
+
+/**
+ * @brief Handle HW verify
+ *
+ * HW verify, display diagnostic message, dump stack and return.
+ *
+ * @param cond string describing failing verify condition
+ * @param filename file name
+ * @param linenum line number
+ *
+ * @return none
+ */
+void
+_ocs_hw_verify(const char *cond, const char *filename, int linenum)
+{
+	ocs_printf("%s(%d): HW verify (%s) failed\n", filename, linenum, cond);
+	ocs_print_stack();
+}
+
+/**
+ * @brief Reque XRI
+ *
+ * @par Description
+ * Reque XRI
+ *
+ * @param hw Pointer to HW object.
+ * @param io Pointer to HW IO
+ *
+ * @return Return 0 if successful else returns -1
+ */
+int32_t 
+ocs_hw_reque_xri( ocs_hw_t *hw, ocs_hw_io_t *io )
+{
+	int32_t rc = 0;
+
+	rc = ocs_hw_rqpair_auto_xfer_rdy_buffer_post(hw, io, 1);
+	if (rc) {
+		ocs_list_add_tail(&hw->io_port_dnrx, io);
+		rc = -1;
+		goto exit_ocs_hw_reque_xri;
+	}
+
+	io->auto_xfer_rdy_dnrx = 0;
+	io->type = OCS_HW_IO_DNRX_REQUEUE;
+	if (sli_requeue_xri_wqe(&hw->sli, io->wqe.wqebuf, hw->sli.config.wqe_size, io->indicator, OCS_HW_REQUE_XRI_REGTAG, SLI4_CQ_DEFAULT)) {
+		/* Clear buffer from XRI */
+		ocs_pool_put(hw->auto_xfer_rdy_buf_pool, io->axr_buf);
+		io->axr_buf = NULL;
+
+		ocs_log_err(hw->os, "requeue_xri WQE error\n");
+		ocs_list_add_tail(&hw->io_port_dnrx, io);
+
+		rc = -1;
+		goto exit_ocs_hw_reque_xri;
+	}
+
+	if (io->wq == NULL) {
+		io->wq = ocs_hw_queue_next_wq(hw, io);
+		ocs_hw_assert(io->wq != NULL);
+	}
+
+	/*
+	 * Add IO to active io wqe list before submitting, in case the
+	 * wcqe processing preempts this thread.
+	 */
+	OCS_STAT(hw->tcmd_wq_submit[io->wq->instance]++);
+	OCS_STAT(io->wq->use_count++);
+	
+	rc = hw_wq_write(io->wq, &io->wqe);
+	if (rc < 0) {
+		ocs_log_err(hw->os, "sli_queue_write reque xri failed: %d\n", rc);
+		rc = -1;
+	}
+
+exit_ocs_hw_reque_xri:
+	return 0;
+}
+
+uint32_t
+ocs_hw_get_def_wwn(ocs_t *ocs, uint32_t chan, uint64_t *wwpn, uint64_t *wwnn)
+{
+	sli4_t *sli4 = &ocs->hw.sli;
+	ocs_dma_t       dma;
+	uint8_t		*payload = NULL;
+
+	int indicator = sli4->config.extent[SLI_RSRC_FCOE_VPI].base[0] + chan;
+
+	/* allocate memory for the service parameters */
+	if (ocs_dma_alloc(ocs, &dma, 112, 4)) {
+		ocs_log_err(ocs, "Failed to allocate DMA memory\n");
+		return 1;
+	}
+
+	if (0 == sli_cmd_read_sparm64(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE,
+				&dma, indicator)) {
+		ocs_log_err(ocs, "READ_SPARM64 allocation failure\n");
+		ocs_dma_free(ocs, &dma);
+		return 1;
+	}
+
+	if (sli_bmbx_command(sli4)) {
+		ocs_log_err(ocs, "READ_SPARM64 command failure\n");
+		ocs_dma_free(ocs, &dma);
+		return 1;
+	}
+
+	payload = dma.virt;
+	ocs_memcpy(wwpn, payload + SLI4_READ_SPARM64_WWPN_OFFSET, sizeof(*wwpn));
+	ocs_memcpy(wwnn, payload + SLI4_READ_SPARM64_WWNN_OFFSET, sizeof(*wwnn));
+	ocs_dma_free(ocs, &dma);
+	return 0;
+}
+
+/**
+ * @page fc_hw_api_overview HW APIs
+ * - @ref devInitShutdown
+ * - @ref domain
+ * - @ref port
+ * - @ref node
+ * - @ref io
+ * - @ref interrupt
+ *
+ * <div class="overview">
+ * The Hardware Abstraction Layer (HW) insulates the higher-level code from the SLI-4
+ * message details, but the higher level code must still manage domains, ports,
+ * IT nexuses, and IOs. The HW API is designed to help the higher level manage
+ * these objects.<br><br>
+ *
+ * The HW uses function callbacks to notify the higher-level code of events
+ * that are received from the chip. There are currently three types of
+ * functions that may be registered:
+ *
+ * <ul><li>domain – This function is called whenever a domain event is generated
+ * within the HW. Examples include a new FCF is discovered, a connection
+ * to a domain is disrupted, and allocation callbacks.</li>
+ * <li>unsolicited – This function is called whenever new data is received in
+ * the SLI-4 receive queue.</li>
+ * <li>rnode – This function is called for remote node events, such as attach status
+ * and  allocation callbacks.</li></ul>
+ *
+ * Upper layer functions may be registered by using the ocs_hw_callback() function.
+ *
+ * <img src="elx_fc_hw.jpg" alt="FC/FCoE HW" title="FC/FCoE HW" align="right"/>
+ * <h2>FC/FCoE HW API</h2>
+ * The FC/FCoE HW component builds upon the SLI-4 component to establish a flexible
+ * interface for creating the necessary common objects and sending I/Os. It may be used
+ * “as is” in customer implementations or it can serve as an example of typical interactions
+ * between a driver and the SLI-4 hardware. The broad categories of functionality include:
+ *
+ * <ul><li>Setting-up and tearing-down of the HW.</li>
+ * <li>Allocating and using the common objects (SLI Port, domain, remote node).</li>
+ * <li>Sending and receiving I/Os.</li></ul>
+ *
+ * <h3>HW Setup</h3>
+ * To set up the HW:
+ *
+ * <ol>
+ * <li>Set up the HW object using ocs_hw_setup().<br>
+ * This step performs a basic configuration of the SLI-4 component and the HW to
+ * enable querying the hardware for its capabilities. At this stage, the HW is not
+ * capable of general operations (such as, receiving events or sending I/Os).</li><br><br>
+ * <li>Configure the HW according to the driver requirements.<br>
+ * The HW provides functions to discover hardware capabilities (ocs_hw_get()), as
+ * well as configures the amount of resources required (ocs_hw_set()). The driver
+ * must also register callback functions (ocs_hw_callback()) to receive notification of
+ * various asynchronous events.<br><br>
+ * @b Note: Once configured, the driver must initialize the HW (ocs_hw_init()). This
+ * step creates the underlying queues, commits resources to the hardware, and
+ * prepares the hardware for operation. While the hardware is operational, the
+ * port is not online, and cannot send or receive data.</li><br><br>
+ * <br><br>
+ * <li>Finally, the driver can bring the port online (ocs_hw_port_control()).<br>
+ * When the link comes up, the HW determines if a domain is present and notifies the
+ * driver using the domain callback function. This is the starting point of the driver's
+ * interaction with the common objects.<br><br>
+ * @b Note: For FCoE, there may be more than one domain available and, therefore,
+ * more than one callback.</li>
+ * </ol>
+ *
+ * <h3>Allocating and Using Common Objects</h3>
+ * Common objects provide a mechanism through which the various OneCore Storage
+ * driver components share and track information. These data structures are primarily
+ * used to track SLI component information but can be extended by other components, if
+ * needed. The main objects are:
+ *
+ * <ul><li>DMA – the ocs_dma_t object describes a memory region suitable for direct
+ * memory access (DMA) transactions.</li>
+ * <li>SCSI domain – the ocs_domain_t object represents the SCSI domain, including
+ * any infrastructure devices such as FC switches and FC forwarders. The domain
+ * object contains both an FCFI and a VFI.</li>
+ * <li>SLI Port (sport) – the ocs_sli_port_t object represents the connection between
+ * the driver and the SCSI domain. The SLI Port object contains a VPI.</li>
+ * <li>Remote node – the ocs_remote_node_t represents a connection between the SLI
+ * Port and another device in the SCSI domain. The node object contains an RPI.</li></ul>
+ *
+ * Before the driver can send I/Os, it must allocate the SCSI domain, SLI Port, and remote
+ * node common objects and establish the connections between them. The goal is to
+ * connect the driver to the SCSI domain to exchange I/Os with other devices. These
+ * common object connections are shown in the following figure, FC Driver Common Objects:
+ * <img src="elx_fc_common_objects.jpg"
+ * alt="FC Driver Common Objects" title="FC Driver Common Objects" align="center"/>
+ *
+ * The first step is to create a connection to the domain by allocating an SLI Port object.
+ * The SLI Port object represents a particular FC ID and must be initialized with one. With
+ * the SLI Port object, the driver can discover the available SCSI domain(s). On identifying
+ * a domain, the driver allocates a domain object and attaches to it using the previous SLI
+ * port object.<br><br>
+ *
+ * @b Note: In some cases, the driver may need to negotiate service parameters (that is,
+ * FLOGI) with the domain before attaching.<br><br>
+ *
+ * Once attached to the domain, the driver can discover and attach to other devices
+ * (remote nodes). The exact discovery method depends on the driver, but it typically
+ * includes using a position map, querying the fabric name server, or an out-of-band
+ * method. In most cases, it is necessary to log in with devices before performing I/Os.
+ * Prior to sending login-related ELS commands (ocs_hw_srrs_send()), the driver must
+ * allocate a remote node object (ocs_hw_node_alloc()). If the login negotiation is
+ * successful, the driver must attach the nodes (ocs_hw_node_attach()) to the SLI Port
+ * before exchanging FCP I/O.<br><br>
+ *
+ * @b Note: The HW manages both the well known fabric address and the name server as
+ * nodes in the domain. Therefore, the driver must allocate node objects prior to
+ * communicating with either of these entities.
+ *
+ * <h3>Sending and Receiving I/Os</h3>
+ * The HW provides separate interfaces for sending BLS/ ELS/ FC-CT and FCP, but the
+ * commands are conceptually similar. Since the commands complete asynchronously,
+ * the caller must provide a HW I/O object that maintains the I/O state, as well as
+ * provide a callback function. The driver may use the same callback function for all I/O
+ * operations, but each operation must use a unique HW I/O object. In the SLI-4
+ * architecture, there is a direct association between the HW I/O object and the SGL used
+ * to describe the data. Therefore, a driver typically performs the following operations:
+ *
+ * <ul><li>Allocates a HW I/O object (ocs_hw_io_alloc()).</li>
+ * <li>Formats the SGL, specifying both the HW I/O object and the SGL.
+ * (ocs_hw_io_init_sges() and ocs_hw_io_add_sge()).</li>
+ * <li>Sends the HW I/O (ocs_hw_io_send()).</li></ul>
+ *
+ * <h3>HW Tear Down</h3>
+ * To tear-down the HW:
+ *
+ * <ol><li>Take the port offline (ocs_hw_port_control()) to prevent receiving further
+ * data andevents.</li>
+ * <li>Destroy the HW object (ocs_hw_teardown()).</li>
+ * <li>Free any memory used by the HW, such as buffers for unsolicited data.</li></ol>
+ * <br>
+ * </div><!-- overview -->
+ *
+ */
+
+
+
+
+/**
+ * This contains all hw runtime workaround code.  Based on the asic type,
+ * asic revision, and range of fw revisions, a particular workaround may be enabled.
+ *
+ * A workaround may consist of overriding a particular HW/SLI4 value that was initialized
+ * during ocs_hw_setup() (for example the MAX_QUEUE overrides for mis-reported queue
+ * sizes). Or if required, elements of the ocs_hw_workaround_t structure may be set to
+ * control specific runtime behavior.
+ *
+ * It is intended that the controls in ocs_hw_workaround_t be defined functionally.  So we
+ * would have the driver look like:  "if (hw->workaround.enable_xxx) then ...", rather than
+ * what we might previously see as "if this is a BE3, then do xxx"
+ *
+ */
+
+
+#define HW_FWREV_ZERO		(0ull)
+#define HW_FWREV_MAX		(~0ull)
+
+#define SLI4_ASIC_TYPE_ANY	0
+#define SLI4_ASIC_REV_ANY	0
+
+/**
+ * @brief Internal definition of workarounds
+ */
+
+typedef enum {
+	HW_WORKAROUND_TEST = 1,
+	HW_WORKAROUND_MAX_QUEUE,	/**< Limits all queues */
+	HW_WORKAROUND_MAX_RQ,		/**< Limits only the RQ */
+	HW_WORKAROUND_RETAIN_TSEND_IO_LENGTH,
+	HW_WORKAROUND_WQE_COUNT_METHOD,
+	HW_WORKAROUND_RQE_COUNT_METHOD,
+	HW_WORKAROUND_USE_UNREGISTERD_RPI,
+	HW_WORKAROUND_DISABLE_AR_TGT_DIF, /**< Disable of auto-response target DIF */
+	HW_WORKAROUND_DISABLE_SET_DUMP_LOC,
+	HW_WORKAROUND_USE_DIF_QUARANTINE,
+	HW_WORKAROUND_USE_DIF_SEC_XRI,		/**< Use secondary xri for multiple data phases */
+	HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB,	/**< FCFI reported in SRB not correct, use "first" registered domain */
+	HW_WORKAROUND_FW_VERSION_TOO_LOW,	/**< The FW version is not the min version supported by this driver */
+	HW_WORKAROUND_SGLC_MISREPORTED,	/**< Chip supports SGL Chaining but SGLC is not set in SLI4_PARAMS */
+	HW_WORKAROUND_IGNORE_SEND_FRAME_CAPABLE,	/**< Don't use SEND_FRAME capable if FW version is too old */
+} hw_workaround_e;
+
+/**
+ * @brief Internal workaround structure instance
+ */
+
+typedef struct {
+	sli4_asic_type_e asic_type;
+	sli4_asic_rev_e asic_rev;
+	uint64_t fwrev_low;
+	uint64_t fwrev_high;
+
+	hw_workaround_e workaround;
+	uint32_t value;
+} hw_workaround_t;
+
+static hw_workaround_t hw_workarounds[] = {
+	{SLI4_ASIC_TYPE_ANY,	SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_TEST, 999},
+
+	/* Bug: 127585: if_type == 2 returns 0 for total length placed on
+	 * FCP_TSEND64_WQE completions.   Note, original driver code enables this
+	 * workaround for all asic types
+	 */
+	{SLI4_ASIC_TYPE_ANY,	SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_RETAIN_TSEND_IO_LENGTH, 0},
+
+	/* Bug: unknown, Lancer A0 has mis-reported max queue depth */
+	{SLI4_ASIC_TYPE_LANCER,	SLI4_ASIC_REV_A0, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_MAX_QUEUE, 2048},
+
+	/* Bug: 143399, BE3 has mis-reported max RQ queue depth */
+	{SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(4,6,293,0),
+		HW_WORKAROUND_MAX_RQ, 2048},
+
+	/* Bug: 143399, skyhawk has mis-reported max RQ queue depth */
+	{SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(10,0,594,0),
+		HW_WORKAROUND_MAX_RQ, 2048},
+
+	/* Bug: 103487, BE3 before f/w 4.2.314.0 has mis-reported WQE count method */
+	{SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(4,2,314,0),
+		HW_WORKAROUND_WQE_COUNT_METHOD, 1},
+
+	/* Bug: 103487, BE3 before f/w 4.2.314.0 has mis-reported RQE count method */
+	{SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(4,2,314,0),
+		HW_WORKAROUND_RQE_COUNT_METHOD, 1},
+
+	/* Bug: 142968, BE3 UE with RPI == 0xffff */
+	{SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_USE_UNREGISTERD_RPI, 0},
+
+	/* Bug: unknown, Skyhawk won't support auto-response on target T10-PI  */
+	{SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_DISABLE_AR_TGT_DIF, 0},
+
+	{SLI4_ASIC_TYPE_LANCER,	SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV(1,1,65,0),
+		HW_WORKAROUND_DISABLE_SET_DUMP_LOC, 0},
+
+	/* Bug: 160124, Skyhawk quarantine DIF XRIs  */
+	{SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_USE_DIF_QUARANTINE, 0},
+
+	/* Bug: 161832, Skyhawk use secondary XRI for multiple data phase TRECV */
+	{SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_USE_DIF_SEC_XRI, 0},
+
+	/* Bug: xxxxxx, FCFI reported in SRB not corrrect */
+	{SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB, 0},
+#if 0
+	/* Bug: 165642, FW version check for driver */
+	{SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_1(OCS_MIN_FW_VER_LANCER),
+		HW_WORKAROUND_FW_VERSION_TOO_LOW, 0},
+#endif
+	{SLI4_ASIC_TYPE_SKYHAWK, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_1(OCS_MIN_FW_VER_SKYHAWK),
+		HW_WORKAROUND_FW_VERSION_TOO_LOW, 0},
+
+	/* Bug 177061, Lancer FW does not set the SGLC bit */
+	{SLI4_ASIC_TYPE_LANCER, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_SGLC_MISREPORTED, 0},
+
+	/* BZ 181208/183914, enable this workaround for ALL revisions */
+	{SLI4_ASIC_TYPE_ANY, SLI4_ASIC_REV_ANY, HW_FWREV_ZERO, HW_FWREV_MAX,
+		HW_WORKAROUND_IGNORE_SEND_FRAME_CAPABLE, 0},
+};
+
+/**
+ * @brief Function prototypes
+ */
+
+static int32_t ocs_hw_workaround_match(ocs_hw_t *hw, hw_workaround_t *w);
+
+/**
+ * @brief Parse the firmware version (name)
+ *
+ * Parse a string of the form a.b.c.d, returning a uint64_t packed as defined
+ * by the HW_FWREV() macro
+ *
+ * @param fwrev_string pointer to the firmware string
+ *
+ * @return packed firmware revision value
+ */
+
+static uint64_t
+parse_fw_version(const char *fwrev_string)
+{
+	int v[4] = {0};
+	const char *p;
+	int i;
+
+	for (p = fwrev_string, i = 0; *p && (i < 4); i ++) {
+		v[i] = ocs_strtoul(p, 0, 0);
+		while(*p && *p != '.') {
+			p ++;
+		}
+		if (*p) {
+			p ++;
+		}
+	}
+
+	/* Special case for bootleg releases with f/w rev 0.0.9999.0, set to max value */
+	if (v[2] == 9999) {
+		return HW_FWREV_MAX;
+	} else {
+		return HW_FWREV(v[0], v[1], v[2], v[3]);
+	}
+}
+
+/**
+ * @brief Test for a workaround match
+ *
+ * Looks at the asic type, asic revision, and fw revision, and returns TRUE if match.
+ *
+ * @param hw Pointer to the HW structure
+ * @param w Pointer to a workaround structure entry
+ *
+ * @return Return TRUE for a match
+ */
+
+static int32_t
+ocs_hw_workaround_match(ocs_hw_t *hw, hw_workaround_t *w)
+{
+	return (((w->asic_type == SLI4_ASIC_TYPE_ANY) || (w->asic_type == hw->sli.asic_type)) &&
+		    ((w->asic_rev == SLI4_ASIC_REV_ANY) || (w->asic_rev == hw->sli.asic_rev)) &&
+		    (w->fwrev_low <= hw->workaround.fwrev) &&
+		    ((w->fwrev_high == HW_FWREV_MAX) || (hw->workaround.fwrev < w->fwrev_high)));
+}
+
+/**
+ * @brief Setup HW runtime workarounds
+ *
+ * The function is called at the end of ocs_hw_setup() to setup any runtime workarounds
+ * based on the HW/SLI setup.
+ *
+ * @param hw Pointer to HW structure
+ *
+ * @return none
+ */
+
+void
+ocs_hw_workaround_setup(struct ocs_hw_s *hw)
+{
+	hw_workaround_t *w;
+	sli4_t *sli4 = &hw->sli;
+	uint32_t i;
+
+	/* Initialize the workaround settings */
+	ocs_memset(&hw->workaround, 0, sizeof(hw->workaround));
+
+	/* If hw_war_version is non-null, then its a value that was set by a module parameter
+	 * (sorry for the break in abstraction, but workarounds are ... well, workarounds)
+	 */
+
+	if (hw->hw_war_version) {
+		hw->workaround.fwrev = parse_fw_version(hw->hw_war_version);
+	} else {
+		hw->workaround.fwrev = parse_fw_version((char*) sli4->config.fw_name[0]);
+	}
+
+	/* Walk the workaround list, if a match is found, then handle it */
+	for (i = 0, w = hw_workarounds; i < ARRAY_SIZE(hw_workarounds); i++, w++) {
+		if (ocs_hw_workaround_match(hw, w)) {
+			switch(w->workaround) {
+
+			case HW_WORKAROUND_TEST: {
+				ocs_log_debug(hw->os, "Override: test: %d\n", w->value);
+				break;
+			}
+
+			case HW_WORKAROUND_RETAIN_TSEND_IO_LENGTH: {
+				ocs_log_debug(hw->os, "HW Workaround: retain TSEND IO length\n");
+				hw->workaround.retain_tsend_io_length = 1;
+				break;
+			}
+			case HW_WORKAROUND_MAX_QUEUE: {
+				sli4_qtype_e q;
+
+				ocs_log_debug(hw->os, "HW Workaround: override max_qentries: %d\n", w->value);
+				for (q = SLI_QTYPE_EQ; q < SLI_QTYPE_MAX; q++) {
+					if (hw->num_qentries[q] > w->value) {
+						hw->num_qentries[q] = w->value;
+					}
+				}
+				break;
+			}
+			case HW_WORKAROUND_MAX_RQ: {
+				ocs_log_debug(hw->os, "HW Workaround: override RQ max_qentries: %d\n", w->value);
+				if (hw->num_qentries[SLI_QTYPE_RQ] > w->value) {
+					hw->num_qentries[SLI_QTYPE_RQ] = w->value;
+				}
+				break;
+			}
+			case HW_WORKAROUND_WQE_COUNT_METHOD: {
+				ocs_log_debug(hw->os, "HW Workaround: set WQE count method=%d\n", w->value);
+				sli4->config.count_method[SLI_QTYPE_WQ] = w->value;
+				sli_calc_max_qentries(sli4);
+				break;
+			}
+			case HW_WORKAROUND_RQE_COUNT_METHOD: {
+				ocs_log_debug(hw->os, "HW Workaround: set RQE count method=%d\n", w->value);
+				sli4->config.count_method[SLI_QTYPE_RQ] = w->value;
+				sli_calc_max_qentries(sli4);
+				break;
+			}
+			case HW_WORKAROUND_USE_UNREGISTERD_RPI:
+				ocs_log_debug(hw->os, "HW Workaround: use unreg'd RPI if rnode->indicator == 0xFFFF\n");
+				hw->workaround.use_unregistered_rpi = TRUE;
+				/*
+				 * Allocate an RPI that is never registered, to be used in the case where
+				 * a node has been unregistered, and its indicator (RPI) value is set to 0xFFFF
+				 */
+				if (sli_resource_alloc(&hw->sli, SLI_RSRC_FCOE_RPI, &hw->workaround.unregistered_rid,
+					&hw->workaround.unregistered_index)) {
+					ocs_log_err(hw->os, "sli_resource_alloc unregistered RPI failed\n");
+					hw->workaround.use_unregistered_rpi = FALSE;
+				}
+				break;
+			case HW_WORKAROUND_DISABLE_AR_TGT_DIF:
+				ocs_log_debug(hw->os, "HW Workaround: disable AR on T10-PI TSEND\n");
+				hw->workaround.disable_ar_tgt_dif = TRUE;
+				break;
+			case HW_WORKAROUND_DISABLE_SET_DUMP_LOC:
+				ocs_log_debug(hw->os, "HW Workaround: disable set_dump_loc\n");
+				hw->workaround.disable_dump_loc = TRUE;
+				break;
+			case HW_WORKAROUND_USE_DIF_QUARANTINE:
+				ocs_log_debug(hw->os, "HW Workaround: use DIF quarantine\n");
+				hw->workaround.use_dif_quarantine = TRUE;
+				break;
+			case HW_WORKAROUND_USE_DIF_SEC_XRI:
+				ocs_log_debug(hw->os, "HW Workaround: use DIF secondary xri\n");
+				hw->workaround.use_dif_sec_xri = TRUE;
+				break;
+			case HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB:
+				ocs_log_debug(hw->os, "HW Workaround: override FCFI in SRB\n");
+				hw->workaround.override_fcfi = TRUE;
+				break;
+
+			case HW_WORKAROUND_FW_VERSION_TOO_LOW:
+				ocs_log_debug(hw->os, "HW Workaround: fw version is below the minimum for this driver\n");
+				hw->workaround.fw_version_too_low = TRUE;
+				break;
+			case HW_WORKAROUND_SGLC_MISREPORTED:
+				ocs_log_debug(hw->os, "HW Workaround: SGLC misreported - chaining is enabled\n");
+				hw->workaround.sglc_misreported = TRUE;
+				break;
+			case HW_WORKAROUND_IGNORE_SEND_FRAME_CAPABLE:
+				ocs_log_debug(hw->os, "HW Workaround: not SEND_FRAME capable - disabled\n");
+				hw->workaround.ignore_send_frame = TRUE;
+				break;
+			} /* switch(w->workaround) */
+		}
+	}
+}
diff --git a/sys/dev/ocs_fc/ocs_hw.h b/sys/dev/ocs_fc/ocs_hw.h
new file mode 100644
index 000000000000..86a7d98c24d3
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_hw.h
@@ -0,0 +1,1547 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Defines the Hardware Abstraction Layer (HW) interface functions.
+ */
+
+#ifndef _OCS_HW_H
+#define _OCS_HW_H
+
+#include "sli4.h"
+#include "ocs_hw.h"
+#include "ocs_stats.h"
+#include "ocs_utils.h"
+
+typedef struct ocs_hw_io_s ocs_hw_io_t;
+
+
+#if defined(OCS_INCLUDE_DEBUG)
+#else
+#define ocs_queue_history_wq(...)
+#define ocs_queue_history_cqe(...)
+#define ocs_queue_history_init(...)
+#define ocs_queue_history_free(...)
+#endif
+
+/**
+ * @brief HW queue forward declarations
+ */
+typedef struct hw_eq_s hw_eq_t;
+typedef struct hw_cq_s hw_cq_t;
+typedef struct hw_mq_s hw_mq_t;
+typedef struct hw_wq_s hw_wq_t;
+typedef struct hw_rq_s hw_rq_t;
+typedef struct hw_rq_grp_s hw_rq_grp_t;
+
+/* HW asserts/verify
+ *
+ */
+
+extern void _ocs_hw_assert(const char *cond, const char *filename, int linenum);
+extern void _ocs_hw_verify(const char *cond, const char *filename, int linenum);
+
+#if defined(HW_NDEBUG)
+#define ocs_hw_assert(cond)
+#define ocs_hw_verify(cond, ...)
+#else
+#define ocs_hw_assert(cond) \
+	do { \
+		if ((!(cond))) { \
+			_ocs_hw_assert(#cond, __FILE__, __LINE__); \
+		} \
+	} while (0)
+
+#define ocs_hw_verify(cond, ...) \
+	do { \
+		if ((!(cond))) { \
+			_ocs_hw_verify(#cond, __FILE__, __LINE__); \
+			return __VA_ARGS__; \
+		} \
+	} while (0)
+#endif
+#define ocs_hw_verify_arg(cond)	ocs_hw_verify(cond, OCS_HW_RTN_INVALID_ARG)
+
+/*
+ * HW completion loop control parameters.
+ *
+ * The HW completion loop must terminate periodically to keep the OS happy.  The
+ * loop terminates when a predefined time has elapsed, but to keep the overhead of
+ * computing time down, the time is only checked after a number of loop iterations
+ * has completed.
+ *
+ * OCS_HW_TIMECHECK_ITERATIONS		number of loop iterations between time checks
+ *
+ */
+
+#define OCS_HW_TIMECHECK_ITERATIONS	100
+#define OCS_HW_MAX_NUM_MQ 1
+#define OCS_HW_MAX_NUM_RQ 32
+#define OCS_HW_MAX_NUM_EQ 16
+#define OCS_HW_MAX_NUM_WQ 32
+
+#define OCE_HW_MAX_NUM_MRQ_PAIRS 16
+
+#define OCS_HW_MAX_WQ_CLASS	4
+#define OCS_HW_MAX_WQ_CPU	128
+
+/*
+ * A CQ will be assinged to each WQ (CQ must have 2X entries of the WQ for abort
+ * processing), plus a separate one for each RQ PAIR and one for MQ
+ */
+#define OCS_HW_MAX_NUM_CQ ((OCS_HW_MAX_NUM_WQ*2) + 1 + (OCE_HW_MAX_NUM_MRQ_PAIRS * 2))
+
+/*
+ * Q hash - size is the maximum of all the queue sizes, rounded up to the next
+ * power of 2
+ */
+#define OCS_HW_Q_HASH_SIZE	B32_NEXT_POWER_OF_2(OCS_MAX(OCS_HW_MAX_NUM_MQ, OCS_MAX(OCS_HW_MAX_NUM_RQ, \
+				OCS_MAX(OCS_HW_MAX_NUM_EQ, OCS_MAX(OCS_HW_MAX_NUM_WQ, \
+				OCS_HW_MAX_NUM_CQ)))))
+
+#define OCS_HW_RQ_HEADER_SIZE	128
+#define OCS_HW_RQ_HEADER_INDEX	0
+
+/**
+ * @brief Options for ocs_hw_command().
+ */
+enum {
+	OCS_CMD_POLL,	/**< command executes synchronously and busy-waits for completion */
+	OCS_CMD_NOWAIT,	/**< command executes asynchronously. Uses callback */
+};
+
+typedef enum {
+	OCS_HW_RTN_SUCCESS = 0,
+	OCS_HW_RTN_SUCCESS_SYNC = 1,
+	OCS_HW_RTN_ERROR = -1,
+	OCS_HW_RTN_NO_RESOURCES = -2,
+	OCS_HW_RTN_NO_MEMORY = -3,
+	OCS_HW_RTN_IO_NOT_ACTIVE = -4,
+	OCS_HW_RTN_IO_ABORT_IN_PROGRESS = -5,
+	OCS_HW_RTN_IO_PORT_OWNED_ALREADY_ABORTED = -6,
+	OCS_HW_RTN_INVALID_ARG = -7,
+} ocs_hw_rtn_e;
+#define OCS_HW_RTN_IS_ERROR(e)	((e) < 0)
+
+typedef enum {
+	OCS_HW_RESET_FUNCTION,
+	OCS_HW_RESET_FIRMWARE,
+	OCS_HW_RESET_MAX
+} ocs_hw_reset_e;
+
+typedef enum {
+	OCS_HW_N_IO,
+	OCS_HW_N_SGL,
+	OCS_HW_MAX_IO,
+	OCS_HW_MAX_SGE,
+	OCS_HW_MAX_SGL,
+	OCS_HW_MAX_NODES,
+	OCS_HW_MAX_RQ_ENTRIES,
+	OCS_HW_TOPOLOGY,	/**< auto, nport, loop */
+	OCS_HW_WWN_NODE,
+	OCS_HW_WWN_PORT,
+	OCS_HW_FW_REV,
+	OCS_HW_FW_REV2,
+	OCS_HW_IPL,
+	OCS_HW_VPD,
+	OCS_HW_VPD_LEN,
+	OCS_HW_MODE,		/**< initiator, target, both */
+	OCS_HW_LINK_SPEED,
+	OCS_HW_IF_TYPE,
+	OCS_HW_SLI_REV,
+	OCS_HW_SLI_FAMILY,
+	OCS_HW_RQ_PROCESS_LIMIT,
+	OCS_HW_RQ_DEFAULT_BUFFER_SIZE,
+	OCS_HW_AUTO_XFER_RDY_CAPABLE,
+	OCS_HW_AUTO_XFER_RDY_XRI_CNT,
+	OCS_HW_AUTO_XFER_RDY_SIZE,
+	OCS_HW_AUTO_XFER_RDY_BLK_SIZE,
+	OCS_HW_AUTO_XFER_RDY_T10_ENABLE,
+	OCS_HW_AUTO_XFER_RDY_P_TYPE,
+	OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA,
+	OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID,
+	OCS_HW_AUTO_XFER_RDY_APP_TAG_VALUE,
+	OCS_HW_DIF_CAPABLE,
+	OCS_HW_DIF_SEED,
+	OCS_HW_DIF_MODE,
+	OCS_HW_DIF_MULTI_SEPARATE,
+	OCS_HW_DUMP_MAX_SIZE,
+	OCS_HW_DUMP_READY,
+	OCS_HW_DUMP_PRESENT,
+	OCS_HW_RESET_REQUIRED,
+	OCS_HW_FW_ERROR,
+	OCS_HW_FW_READY,
+	OCS_HW_HIGH_LOGIN_MODE,
+	OCS_HW_PREREGISTER_SGL,
+	OCS_HW_HW_REV1,
+	OCS_HW_HW_REV2,
+	OCS_HW_HW_REV3,
+	OCS_HW_LINKCFG,
+	OCS_HW_ETH_LICENSE,
+	OCS_HW_LINK_MODULE_TYPE,
+	OCS_HW_NUM_CHUTES,
+	OCS_HW_WAR_VERSION,
+	OCS_HW_DISABLE_AR_TGT_DIF,
+	OCS_HW_EMULATE_I_ONLY_AAB, /**< emulate IAAB=0 for initiator-commands only */
+	OCS_HW_EMULATE_TARGET_WQE_TIMEOUT, /**< enable driver timeouts for target WQEs */
+	OCS_HW_LINK_CONFIG_SPEED,
+	OCS_HW_CONFIG_TOPOLOGY,
+	OCS_HW_BOUNCE,
+	OCS_HW_PORTNUM,
+	OCS_HW_BIOS_VERSION_STRING,
+	OCS_HW_RQ_SELECT_POLICY,
+	OCS_HW_SGL_CHAINING_CAPABLE,
+	OCS_HW_SGL_CHAINING_ALLOWED,
+	OCS_HW_SGL_CHAINING_HOST_ALLOCATED,
+	OCS_HW_SEND_FRAME_CAPABLE,
+	OCS_HW_RQ_SELECTION_POLICY,
+	OCS_HW_RR_QUANTA,
+	OCS_HW_FILTER_DEF,
+	OCS_HW_MAX_VPORTS,
+	OCS_ESOC,
+	OCS_HW_FW_TIMED_OUT,
+} ocs_hw_property_e;
+
+enum {
+	OCS_HW_TOPOLOGY_AUTO,
+	OCS_HW_TOPOLOGY_NPORT,
+	OCS_HW_TOPOLOGY_LOOP,
+	OCS_HW_TOPOLOGY_NONE,
+	OCS_HW_TOPOLOGY_MAX
+};
+
+enum {
+	OCS_HW_MODE_INITIATOR,
+	OCS_HW_MODE_TARGET,
+	OCS_HW_MODE_BOTH,
+	OCS_HW_MODE_MAX
+};
+
+/**
+ * @brief Port protocols
+ */
+
+typedef enum {
+	OCS_HW_PORT_PROTOCOL_ISCSI,
+	OCS_HW_PORT_PROTOCOL_FCOE,
+	OCS_HW_PORT_PROTOCOL_FC,
+	OCS_HW_PORT_PROTOCOL_OTHER,
+} ocs_hw_port_protocol_e;
+
+#define OCS_HW_MAX_PROFILES	40
+/**
+ * @brief A Profile Descriptor
+ */
+typedef struct {
+	uint32_t	profile_index;
+	uint32_t	profile_id;
+	char		profile_description[512];
+} ocs_hw_profile_descriptor_t;
+
+/**
+ * @brief A Profile List
+ */
+typedef struct {
+	uint32_t			num_descriptors;
+	ocs_hw_profile_descriptor_t	descriptors[OCS_HW_MAX_PROFILES];
+} ocs_hw_profile_list_t;
+
+
+/**
+ * @brief Defines DIF operation modes
+ */
+enum {
+	OCS_HW_DIF_MODE_INLINE,
+	OCS_HW_DIF_MODE_SEPARATE,
+};
+
+/**
+ * @brief Defines the type of RQ buffer
+ */
+typedef enum {
+	OCS_HW_RQ_BUFFER_TYPE_HDR,
+	OCS_HW_RQ_BUFFER_TYPE_PAYLOAD,
+	OCS_HW_RQ_BUFFER_TYPE_MAX,
+} ocs_hw_rq_buffer_type_e;
+
+/**
+ * @brief Defines a wrapper for the RQ payload buffers so that we can place it
+ *        back on the proper queue.
+ */
+typedef struct {
+	uint16_t rqindex;
+	ocs_dma_t dma;
+} ocs_hw_rq_buffer_t;
+
+/**
+ * @brief T10 DIF operations.
+ */
+typedef enum {
+	OCS_HW_DIF_OPER_DISABLED,
+	OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC,
+	OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF,
+	OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM,
+	OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF,
+	OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC,
+	OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM,
+	OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CHKSUM,
+	OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CRC,
+	OCS_HW_SGE_DIF_OP_IN_RAW_OUT_RAW,
+} ocs_hw_dif_oper_e;
+
+#define OCS_HW_DIF_OPER_PASS_THRU	OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC
+#define OCS_HW_DIF_OPER_STRIP		OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF
+#define OCS_HW_DIF_OPER_INSERT		OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC
+
+/**
+ * @brief T10 DIF block sizes.
+ */
+typedef enum {
+	OCS_HW_DIF_BK_SIZE_512,
+	OCS_HW_DIF_BK_SIZE_1024,
+	OCS_HW_DIF_BK_SIZE_2048,
+	OCS_HW_DIF_BK_SIZE_4096,
+	OCS_HW_DIF_BK_SIZE_520,
+	OCS_HW_DIF_BK_SIZE_4104,
+	OCS_HW_DIF_BK_SIZE_NA = 0
+} ocs_hw_dif_blk_size_e;
+
+/**
+ * @brief Link configurations.
+ */
+typedef enum {
+	OCS_HW_LINKCFG_4X10G = 0,
+	OCS_HW_LINKCFG_1X40G,
+	OCS_HW_LINKCFG_2X16G,
+	OCS_HW_LINKCFG_4X8G,
+	OCS_HW_LINKCFG_4X1G,
+	OCS_HW_LINKCFG_2X10G,
+	OCS_HW_LINKCFG_2X10G_2X8G,
+
+	/* must be last */
+	OCS_HW_LINKCFG_NA,
+} ocs_hw_linkcfg_e;
+
+/**
+ * @brief link module types
+ *
+ * (note: these just happen to match SLI4 values)
+ */
+
+enum {
+	OCS_HW_LINK_MODULE_TYPE_1GB = 0x0004,
+	OCS_HW_LINK_MODULE_TYPE_2GB = 0x0008,
+	OCS_HW_LINK_MODULE_TYPE_4GB = 0x0040,
+	OCS_HW_LINK_MODULE_TYPE_8GB = 0x0080,
+	OCS_HW_LINK_MODULE_TYPE_10GB = 0x0100,
+	OCS_HW_LINK_MODULE_TYPE_16GB = 0x0200,
+	OCS_HW_LINK_MODULE_TYPE_32GB = 0x0400,
+};
+
+/**
+ * @brief T10 DIF information passed to the transport.
+ */
+typedef struct ocs_hw_dif_info_s {
+	ocs_hw_dif_oper_e dif_oper;
+	ocs_hw_dif_blk_size_e blk_size;
+	uint32_t ref_tag_cmp;
+	uint32_t ref_tag_repl;
+	uint32_t app_tag_cmp:16,
+		app_tag_repl:16;
+	uint32_t check_ref_tag:1,
+		check_app_tag:1,
+		check_guard:1,
+		auto_incr_ref_tag:1,
+		repl_app_tag:1,
+		repl_ref_tag:1,
+		dif:2,
+		dif_separate:1,
+
+		/* If the APP TAG is 0xFFFF, disable checking the REF TAG and CRC fields */
+		disable_app_ffff:1,
+
+		/* if the APP TAG is 0xFFFF and REF TAG is 0xFFFF_FFFF, disable checking the received CRC field. */
+		disable_app_ref_ffff:1,
+
+		:21;
+	uint16_t dif_seed;
+} ocs_hw_dif_info_t;
+typedef enum {
+	OCS_HW_ELS_REQ,	/**< ELS request */
+	OCS_HW_ELS_RSP,	/**< ELS response */
+	OCS_HW_ELS_RSP_SID,	/**< ELS response, override the S_ID */
+	OCS_HW_FC_CT,		/**< FC Common Transport */
+	OCS_HW_FC_CT_RSP,	/**< FC Common Transport Response */
+	OCS_HW_BLS_ACC,	/**< BLS accept (BA_ACC) */
+	OCS_HW_BLS_ACC_SID,	/**< BLS accept (BA_ACC), override the S_ID */
+	OCS_HW_BLS_RJT,	/**< BLS reject (BA_RJT) */
+	OCS_HW_BCAST,		/**< Class 3 broadcast sequence */
+	OCS_HW_IO_TARGET_READ,
+	OCS_HW_IO_TARGET_WRITE,
+	OCS_HW_IO_TARGET_RSP,
+	OCS_HW_IO_INITIATOR_READ,
+	OCS_HW_IO_INITIATOR_WRITE,
+	OCS_HW_IO_INITIATOR_NODATA,
+	OCS_HW_IO_DNRX_REQUEUE,
+	OCS_HW_IO_MAX,
+} ocs_hw_io_type_e;
+
+typedef enum {
+	OCS_HW_IO_STATE_FREE,
+	OCS_HW_IO_STATE_INUSE,
+	OCS_HW_IO_STATE_WAIT_FREE,
+	OCS_HW_IO_STATE_WAIT_SEC_HIO,
+} ocs_hw_io_state_e;
+
+/* Descriptive strings for the HW IO request types (note: these must always
+ * match up with the ocs_hw_io_type_e declaration) */
+#define OCS_HW_IO_TYPE_STRINGS \
+	"ELS request", \
+	"ELS response", \
+	"ELS response(set SID)", \
+	"FC CT request", \
+	"BLS accept", \
+	"BLS accept(set SID)", \
+	"BLS reject", \
+	"target read", \
+	"target write", \
+	"target response", \
+	"initiator read", \
+	"initiator write", \
+	"initiator nodata",
+
+/**
+ * @brief HW command context.
+ *
+ * Stores the state for the asynchronous commands sent to the hardware.
+ */
+typedef struct ocs_command_ctx_s {
+	ocs_list_t	link;
+	/**< Callback function */
+	int32_t		(*cb)(struct ocs_hw_s *, int32_t, uint8_t *, void *);
+	void		*arg;	/**< Argument for callback */
+	uint8_t		*buf;	/**< buffer holding command / results */
+	void		*ctx;	/**< upper layer context */
+} ocs_command_ctx_t;
+
+typedef struct ocs_hw_sgl_s {
+	uintptr_t	addr;
+	size_t		len;
+} ocs_hw_sgl_t;
+
+/**
+ * @brief HW callback type
+ *
+ * Typedef for HW "done" callback.
+ */
+typedef int32_t	(*ocs_hw_done_t)(struct ocs_hw_io_s *, ocs_remote_node_t *, uint32_t len, int32_t status, uint32_t ext, void *ul_arg);
+
+
+typedef union ocs_hw_io_param_u {
+	struct {
+		uint16_t ox_id;
+		uint16_t rx_id;
+		uint8_t  payload[12];	/**< big enough for ABTS BA_ACC */
+	} bls;
+	struct {
+		uint32_t s_id;
+		uint16_t ox_id;
+		uint16_t rx_id;
+		uint8_t  payload[12];	/**< big enough for ABTS BA_ACC */
+	} bls_sid;
+	struct {
+		uint8_t	r_ctl;
+		uint8_t	type;
+		uint8_t	df_ctl;
+		uint8_t timeout;
+	} bcast;
+	struct {
+		uint16_t ox_id;
+		uint8_t timeout;
+	} els;
+	struct {
+		uint32_t s_id;
+		uint16_t ox_id;
+		uint8_t timeout;
+	} els_sid;
+	struct {
+		uint8_t	r_ctl;
+		uint8_t	type;
+		uint8_t	df_ctl;
+		uint8_t timeout;
+	} fc_ct;
+	struct {
+		uint8_t	r_ctl;
+		uint8_t	type;
+		uint8_t	df_ctl;
+		uint8_t timeout;
+		uint16_t ox_id;
+	} fc_ct_rsp;
+	struct {
+		uint32_t offset;
+		uint16_t ox_id;
+		uint16_t flags;
+		uint8_t	cs_ctl;
+		ocs_hw_dif_oper_e dif_oper;
+		ocs_hw_dif_blk_size_e blk_size;
+		uint8_t	timeout;
+		uint32_t app_id;
+	} fcp_tgt;
+	struct {
+		ocs_dma_t	*cmnd;
+		ocs_dma_t	*rsp;
+		ocs_hw_dif_oper_e dif_oper;
+		ocs_hw_dif_blk_size_e blk_size;
+		uint32_t	cmnd_size;
+		uint16_t	flags;
+		uint8_t		timeout;
+		uint32_t	first_burst;
+	} fcp_ini;
+} ocs_hw_io_param_t;
+
+/**
+ * @brief WQ steering mode
+ */
+typedef enum {
+	OCS_HW_WQ_STEERING_CLASS,
+	OCS_HW_WQ_STEERING_REQUEST,
+	OCS_HW_WQ_STEERING_CPU,
+} ocs_hw_wq_steering_e;
+
+/**
+ * @brief HW wqe object
+ */
+typedef struct {
+	uint32_t	abort_wqe_submit_needed:1,	/**< set if abort wqe needs to be submitted */
+			send_abts:1,			/**< set to 1 to have hardware to automatically send ABTS */
+			auto_xfer_rdy_dnrx:1,		/**< TRUE if DNRX was set on this IO */
+			:29;
+	uint32_t	id;
+	uint32_t	abort_reqtag;
+	ocs_list_link_t link;
+	uint8_t 	*wqebuf;			/**< work queue entry buffer */
+} ocs_hw_wqe_t;
+
+/**
+ * @brief HW IO object.
+ *
+ * Stores the per-IO information necessary for both the lower (SLI) and upper
+ * layers (ocs).
+ */
+struct ocs_hw_io_s {
+	/* Owned by HW */
+	ocs_list_link_t	link;		/**< used for busy, wait_free, free lists */
+	ocs_list_link_t	wqe_link;	/**< used for timed_wqe list */
+	ocs_list_link_t	dnrx_link;	/**< used for io posted dnrx list */
+	ocs_hw_io_state_e state;	/**< state of IO: free, busy, wait_free */
+	ocs_hw_wqe_t	wqe;		/**< Work queue object, with link for pending */
+	ocs_lock_t	axr_lock;	/**< Lock to synchronize TRSP and AXT Data/Cmd Cqes */
+	ocs_hw_t	*hw;		/**< pointer back to hardware context */
+	ocs_remote_node_t	*rnode;
+	struct ocs_hw_auto_xfer_rdy_buffer_s *axr_buf;
+	ocs_dma_t	xfer_rdy;
+	uint16_t	type;
+	uint32_t	port_owned_abort_count; /**< IO abort count */
+	hw_wq_t	*wq;		/**< WQ assigned to the exchange */
+	uint32_t	xbusy;		/**< Exchange is active in FW */
+	ocs_hw_done_t  done;		/**< Function called on IO completion */
+	void		*arg;		/**< argument passed to "IO done" callback */
+	ocs_hw_done_t  abort_done;	/**< Function called on abort completion */
+	void		*abort_arg;	/**< argument passed to "abort done" callback */
+	ocs_ref_t	ref;		/**< refcount object */
+	size_t		length;		/**< needed for bug O127585: length of IO */
+	uint8_t		tgt_wqe_timeout; /**< timeout value for target WQEs */
+	uint64_t	submit_ticks;	/**< timestamp when current WQE was submitted */
+
+	uint32_t	status_saved:1, /**< if TRUE, latched status should be returned */
+			abort_in_progress:1, /**< if TRUE, abort is in progress */
+			quarantine:1,	/**< set if IO to be quarantined */
+			quarantine_first_phase:1,	/**< set if first phase of IO */
+			is_port_owned:1,	/**< set if POST_XRI was used to send XRI to th chip */
+			auto_xfer_rdy_dnrx:1,	/**< TRUE if DNRX was set on this IO */
+			:26;
+	uint32_t	saved_status;	/**< latched status */
+	uint32_t	saved_len;	/**< latched length */
+	uint32_t	saved_ext;	/**< latched extended status */
+
+	hw_eq_t	*eq;		/**< EQ that this HIO came up on */
+	ocs_hw_wq_steering_e	wq_steering;	/**< WQ steering mode request */
+	uint8_t		wq_class;	/**< WQ class if steering mode is Class */
+
+	/* Owned by SLI layer */
+	uint16_t	reqtag;		/**< request tag for this HW IO */
+	uint32_t	abort_reqtag;	/**< request tag for an abort of this HW IO (note: this is a 32 bit value
+					     to allow us to use UINT32_MAX as an uninitialized value) */
+	uint32_t	indicator;	/**< XRI */
+	ocs_dma_t	def_sgl;	/**< default scatter gather list */
+	uint32_t	def_sgl_count;	/**< count of SGEs in default SGL */
+	ocs_dma_t	*sgl;		/**< pointer to current active SGL */
+	uint32_t	sgl_count;	/**< count of SGEs in io->sgl */
+	uint32_t	first_data_sge;	/**< index of first data SGE */
+	ocs_dma_t	*ovfl_sgl;	/**< overflow SGL */
+	uint32_t	ovfl_sgl_count;	/**< count of SGEs in default SGL */
+	sli4_lsp_sge_t	*ovfl_lsp;	/**< pointer to overflow segment length */
+	ocs_hw_io_t	*ovfl_io;	/**< Used for SGL chaining on skyhawk */
+	uint32_t	n_sge;		/**< number of active SGEs */
+	uint32_t	sge_offset;
+
+	/* BZ 161832 Workaround: */
+	struct ocs_hw_io_s	*sec_hio; /**< Secondary HW IO context */
+	ocs_hw_io_param_t sec_iparam;	/**< Secondary HW IO context saved iparam */
+	uint32_t	sec_len;	/**< Secondary HW IO context saved len */
+
+	/* Owned by upper layer */
+	void		*ul_io;		/**< where upper layer can store reference to its IO */
+};
+
+typedef enum {
+	OCS_HW_PORT_INIT,
+	OCS_HW_PORT_SHUTDOWN,
+	OCS_HW_PORT_SET_LINK_CONFIG,
+} ocs_hw_port_e;
+
+/**
+ * @brief Fabric/Domain events
+ */
+typedef enum {
+	OCS_HW_DOMAIN_ALLOC_OK,	/**< domain successfully allocated */
+	OCS_HW_DOMAIN_ALLOC_FAIL,	/**< domain allocation failed */
+	OCS_HW_DOMAIN_ATTACH_OK,	/**< successfully attached to domain */
+	OCS_HW_DOMAIN_ATTACH_FAIL,	/**< domain attach failed */
+	OCS_HW_DOMAIN_FREE_OK,		/**< successfully freed domain */
+	OCS_HW_DOMAIN_FREE_FAIL,	/**< domain free failed */
+	OCS_HW_DOMAIN_LOST,		/**< previously discovered domain no longer available */
+	OCS_HW_DOMAIN_FOUND,		/**< new domain discovered */
+	OCS_HW_DOMAIN_CHANGED,		/**< previously discovered domain properties have changed */
+} ocs_hw_domain_event_e;
+
+typedef enum {
+	OCS_HW_PORT_ALLOC_OK,		/**< port successfully allocated */
+	OCS_HW_PORT_ALLOC_FAIL,	/**< port allocation failed */
+	OCS_HW_PORT_ATTACH_OK,		/**< successfully attached to port */
+	OCS_HW_PORT_ATTACH_FAIL,	/**< port attach failed */
+	OCS_HW_PORT_FREE_OK,		/**< successfully freed port */
+	OCS_HW_PORT_FREE_FAIL,		/**< port free failed */
+} ocs_hw_port_event_e;
+
+typedef enum {
+	OCS_HW_NODE_ATTACH_OK,
+	OCS_HW_NODE_ATTACH_FAIL,
+	OCS_HW_NODE_FREE_OK,
+	OCS_HW_NODE_FREE_FAIL,
+	OCS_HW_NODE_FREE_ALL_OK,
+	OCS_HW_NODE_FREE_ALL_FAIL,
+} ocs_hw_remote_node_event_e;
+
+typedef enum {
+	OCS_HW_CB_DOMAIN,
+	OCS_HW_CB_PORT,
+	OCS_HW_CB_REMOTE_NODE,
+	OCS_HW_CB_UNSOLICITED,
+	OCS_HW_CB_BOUNCE,
+	OCS_HW_CB_MAX,			/**< must be last */
+} ocs_hw_callback_e;
+
+/**
+ * @brief HW unsolicited callback status
+ */
+typedef enum {
+	OCS_HW_UNSOL_SUCCESS,
+	OCS_HW_UNSOL_ERROR,
+	OCS_HW_UNSOL_ABTS_RCVD,
+	OCS_HW_UNSOL_MAX,		/**< must be last */
+} ocs_hw_unsol_status_e;
+
+/**
+ * @brief Node group rpi reference
+ */
+typedef struct {
+	ocs_atomic_t rpi_count;
+	ocs_atomic_t rpi_attached;
+} ocs_hw_rpi_ref_t;
+
+/**
+ * @brief HW link stat types
+ */
+typedef enum {
+	OCS_HW_LINK_STAT_LINK_FAILURE_COUNT,
+	OCS_HW_LINK_STAT_LOSS_OF_SYNC_COUNT,
+	OCS_HW_LINK_STAT_LOSS_OF_SIGNAL_COUNT,
+	OCS_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT,
+	OCS_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT,
+	OCS_HW_LINK_STAT_CRC_COUNT,
+	OCS_HW_LINK_STAT_PRIMITIVE_SEQ_TIMEOUT_COUNT,
+	OCS_HW_LINK_STAT_ELASTIC_BUFFER_OVERRUN_COUNT,
+	OCS_HW_LINK_STAT_ARB_TIMEOUT_COUNT,
+	OCS_HW_LINK_STAT_ADVERTISED_RCV_B2B_CREDIT,
+	OCS_HW_LINK_STAT_CURR_RCV_B2B_CREDIT,
+	OCS_HW_LINK_STAT_ADVERTISED_XMIT_B2B_CREDIT,
+	OCS_HW_LINK_STAT_CURR_XMIT_B2B_CREDIT,
+	OCS_HW_LINK_STAT_RCV_EOFA_COUNT,
+	OCS_HW_LINK_STAT_RCV_EOFDTI_COUNT,
+	OCS_HW_LINK_STAT_RCV_EOFNI_COUNT,
+	OCS_HW_LINK_STAT_RCV_SOFF_COUNT,
+	OCS_HW_LINK_STAT_RCV_DROPPED_NO_AER_COUNT,
+	OCS_HW_LINK_STAT_RCV_DROPPED_NO_RPI_COUNT,
+	OCS_HW_LINK_STAT_RCV_DROPPED_NO_XRI_COUNT,
+	OCS_HW_LINK_STAT_MAX,		/**< must be last */
+} ocs_hw_link_stat_e;
+
+typedef enum {
+	OCS_HW_HOST_STAT_TX_KBYTE_COUNT,
+	OCS_HW_HOST_STAT_RX_KBYTE_COUNT,
+	OCS_HW_HOST_STAT_TX_FRAME_COUNT,
+	OCS_HW_HOST_STAT_RX_FRAME_COUNT,
+	OCS_HW_HOST_STAT_TX_SEQ_COUNT,
+	OCS_HW_HOST_STAT_RX_SEQ_COUNT,
+	OCS_HW_HOST_STAT_TOTAL_EXCH_ORIG,
+	OCS_HW_HOST_STAT_TOTAL_EXCH_RESP,
+	OCS_HW_HOSY_STAT_RX_P_BSY_COUNT,
+	OCS_HW_HOST_STAT_RX_F_BSY_COUNT,
+	OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_RQ_BUF_COUNT,
+	OCS_HW_HOST_STAT_EMPTY_RQ_TIMEOUT_COUNT,
+	OCS_HW_HOST_STAT_DROP_FRM_DUE_TO_NO_XRI_COUNT,
+	OCS_HW_HOST_STAT_EMPTY_XRI_POOL_COUNT,
+	OCS_HW_HOST_STAT_MAX /* MUST BE LAST */
+} ocs_hw_host_stat_e;
+
+typedef enum {
+	OCS_HW_STATE_UNINITIALIZED,		/* power-on, no allocations, no initializations */
+	OCS_HW_STATE_QUEUES_ALLOCATED,		/* chip is reset, allocations are complete (queues not registered) */
+	OCS_HW_STATE_ACTIVE,			/* chip is up an running */
+	OCS_HW_STATE_RESET_IN_PROGRESS,	/* chip is being reset */
+	OCS_HW_STATE_TEARDOWN_IN_PROGRESS,	/* teardown has been started */
+} ocs_hw_state_e;
+
+/**
+ * @brief Defines a general FC sequence object, consisting of a header, payload buffers
+ *	  and a HW IO in the case of port owned XRI
+ */
+typedef struct {
+	ocs_hw_t *hw;			/**< HW that owns this sequence */
+	/* sequence information */
+	uint8_t fcfi;		/**< FCFI associated with sequence */
+	uint8_t auto_xrdy;	/**< If auto XFER_RDY was generated */
+	uint8_t out_of_xris;	/**< If IO would have been assisted if XRIs were available */
+	ocs_hw_rq_buffer_t *header;
+	ocs_hw_rq_buffer_t *payload;	/**< received frame payload buffer */
+
+	/* other "state" information from the SRB (sequence coalescing) */
+	ocs_hw_unsol_status_e status;
+	uint32_t xri;		/**< XRI associated with sequence; sequence coalescing only */
+	ocs_hw_io_t *hio;	/**< HW IO */
+
+	ocs_list_link_t link;
+	void *hw_priv;		/**< HW private context */
+} ocs_hw_sequence_t;
+
+/**
+ * @brief Structure to track optimized write buffers posted to chip owned XRIs.
+ *
+ * Note: The rqindex will be set the following "fake" indexes. This will be used
+ *       when the buffer is returned via ocs_seq_free() to make the buffer available
+ *       for re-use on another XRI.
+ *
+ *       The dma->alloc pointer on the dummy header will be used to get back to this structure when the buffer is freed.
+ *
+ *       More of these object may be allocated on the fly if more XRIs are pushed to the chip.
+ */
+#define OCS_HW_RQ_INDEX_DUMMY_HDR	0xFF00
+#define OCS_HW_RQ_INDEX_DUMMY_DATA	0xFF01
+typedef struct ocs_hw_auto_xfer_rdy_buffer_s {
+	fc_header_t hdr;		/**< used to build a dummy data header for unsolicited processing */
+	ocs_hw_rq_buffer_t header;	/**< Points to the dummy data header */
+	ocs_hw_rq_buffer_t payload;	/**< received frame payload buffer */
+	ocs_hw_sequence_t seq;         /**< sequence for passing the buffers */
+	uint8_t data_cqe;
+	uint8_t cmd_cqe;
+
+	/* fields saved from the command header that are needed when the data arrives */
+	uint8_t fcfi;
+
+	/* To handle outof order completions save AXR cmd and data cqes */
+	uint8_t call_axr_cmd;
+	uint8_t call_axr_data;
+	ocs_hw_sequence_t *cmd_seq;
+} ocs_hw_auto_xfer_rdy_buffer_t;
+
+/**
+ * @brief Node group rpi reference
+ */
+typedef struct {
+	uint8_t overflow;
+	uint32_t counter;
+} ocs_hw_link_stat_counts_t;
+
+/**
+ * @brief HW object describing fc host stats
+ */
+typedef struct {
+	uint32_t counter;
+} ocs_hw_host_stat_counts_t;
+
+#define TID_HASH_BITS	8
+#define TID_HASH_LEN	(1U << TID_HASH_BITS)
+
+typedef struct ocs_hw_iopt_s {
+	char		name[32];
+	uint32_t	instance_index;
+	ocs_thread_t	iopt_thread;
+	ocs_cbuf_t	*iopt_free_queue;	/* multiple reader, multiple writer */
+	ocs_cbuf_t	*iopt_work_queue;
+	ocs_array_t	*iopt_cmd_array;
+} ocs_hw_iopt_t;
+
+typedef enum {
+	HW_CQ_HANDLER_LOCAL,
+	HW_CQ_HANDLER_THREAD,
+} hw_cq_handler_e;
+
+#include "ocs_hw_queues.h"
+
+/**
+ * @brief Stucture used for the hash lookup of queue IDs
+ */
+typedef struct {
+	uint32_t id:16,
+		in_use:1,
+		index:15;
+} ocs_queue_hash_t;
+
+/**
+ * @brief Define the fields required to implement the skyhawk DIF quarantine.
+ */
+#define OCS_HW_QUARANTINE_QUEUE_DEPTH	4
+
+typedef struct {
+	uint32_t	quarantine_index;
+	ocs_hw_io_t	*quarantine_ios[OCS_HW_QUARANTINE_QUEUE_DEPTH];
+} ocs_quarantine_info_t;
+
+/**
+ * @brief Define the WQ callback object
+ */
+typedef struct {
+	uint16_t instance_index;	/**< use for request tag */
+	void (*callback)(void *arg, uint8_t *cqe, int32_t status);
+	void *arg;
+} hw_wq_callback_t;
+
+typedef struct {
+	uint64_t fwrev;
+
+	/* Control Declarations here ...*/
+
+	uint8_t retain_tsend_io_length;
+
+	/* Use unregistered RPI */
+	uint8_t use_unregistered_rpi;
+	uint32_t unregistered_rid;
+	uint32_t unregistered_index;
+
+	uint8_t disable_ar_tgt_dif;	/* Disable auto response if target DIF */
+	uint8_t disable_dump_loc;
+	uint8_t use_dif_quarantine;
+	uint8_t use_dif_sec_xri;
+
+	uint8_t override_fcfi;
+
+	uint8_t fw_version_too_low;
+
+	uint8_t sglc_misreported;
+
+	uint8_t ignore_send_frame;
+
+} ocs_hw_workaround_t;
+
+
+
+/**
+ * @brief HW object
+ */
+struct ocs_hw_s {
+	ocs_os_handle_t	os;
+	sli4_t		sli;
+	uint16_t	ulp_start;
+	uint16_t	ulp_max;
+	uint32_t	dump_size;
+	ocs_hw_state_e state;
+	uint8_t		hw_setup_called;
+	uint8_t		sliport_healthcheck;
+	uint16_t        watchdog_timeout;
+	ocs_lock_t	watchdog_lock;
+
+	/** HW configuration, subject to ocs_hw_set()  */
+	struct {
+		uint32_t	n_eq; /**< number of event queues */
+		uint32_t	n_cq; /**< number of completion queues */
+		uint32_t	n_mq; /**< number of mailbox queues */
+		uint32_t	n_rq; /**< number of receive queues */
+		uint32_t	n_wq; /**< number of work queues */
+		uint32_t	n_io; /**< total number of IO objects */
+		uint32_t	n_sgl;/**< length of SGL */
+		uint32_t	speed;	/** requested link speed in Mbps */
+		uint32_t	topology;  /** requested link topology */
+		uint32_t	rq_default_buffer_size;	/** size of the buffers for first burst */
+		uint32_t	auto_xfer_rdy_xri_cnt;	/** Initial XRIs to post to chip at initialization */
+		uint32_t	auto_xfer_rdy_size;	/** max size IO to use with this feature */
+		uint8_t		auto_xfer_rdy_blk_size_chip;	/** block size to use with this feature */
+		uint8_t         esoc;
+		uint16_t	dif_seed; /** The seed for the DIF CRC calculation */
+		uint16_t	auto_xfer_rdy_app_tag_value;
+		uint8_t		dif_mode; /**< DIF mode to use */
+		uint8_t		i_only_aab; /** Enable initiator-only auto-abort */
+		uint8_t		emulate_tgt_wqe_timeout; /** Enable driver target wqe timeouts */
+		uint32_t	bounce:1;
+		const char	*queue_topology;		/**< Queue topology string */
+		uint8_t		auto_xfer_rdy_t10_enable;	/** Enable t10 PI for auto xfer ready */
+		uint8_t		auto_xfer_rdy_p_type;	/** p_type for auto xfer ready */
+		uint8_t		auto_xfer_rdy_ref_tag_is_lba;
+		uint8_t		auto_xfer_rdy_app_tag_valid;
+		uint8_t		rq_selection_policy;		/** MRQ RQ selection policy */
+		uint8_t		rr_quanta;			/** RQ quanta if rq_selection_policy == 2 */
+		uint32_t	filter_def[SLI4_CMD_REG_FCFI_NUM_RQ_CFG];
+	} config;
+
+	/* calculated queue sizes for each type */
+	uint32_t	num_qentries[SLI_QTYPE_MAX];
+
+	/* Storage for SLI queue objects */
+	sli4_queue_t	wq[OCS_HW_MAX_NUM_WQ];
+	sli4_queue_t	rq[OCS_HW_MAX_NUM_RQ];
+	uint16_t	hw_rq_lookup[OCS_HW_MAX_NUM_RQ];
+	sli4_queue_t	mq[OCS_HW_MAX_NUM_MQ];
+	sli4_queue_t	cq[OCS_HW_MAX_NUM_CQ];
+	sli4_queue_t	eq[OCS_HW_MAX_NUM_EQ];
+
+	/* HW queue */
+	uint32_t	eq_count;
+	uint32_t	cq_count;
+	uint32_t	mq_count;
+	uint32_t	wq_count;
+	uint32_t	rq_count;			/**< count of SLI RQs */
+	ocs_list_t	eq_list;
+
+	ocs_queue_hash_t cq_hash[OCS_HW_Q_HASH_SIZE];
+	ocs_queue_hash_t rq_hash[OCS_HW_Q_HASH_SIZE];
+	ocs_queue_hash_t wq_hash[OCS_HW_Q_HASH_SIZE];
+
+	/* Storage for HW queue objects */
+	hw_wq_t	*hw_wq[OCS_HW_MAX_NUM_WQ];
+	hw_rq_t	*hw_rq[OCS_HW_MAX_NUM_RQ];
+	hw_mq_t	*hw_mq[OCS_HW_MAX_NUM_MQ];
+	hw_cq_t	*hw_cq[OCS_HW_MAX_NUM_CQ];
+	hw_eq_t	*hw_eq[OCS_HW_MAX_NUM_EQ];
+	uint32_t	hw_rq_count;			/**< count of hw_rq[] entries */
+	uint32_t	hw_mrq_count;			/**< count of multirq RQs */
+
+	ocs_varray_t	*wq_class_array[OCS_HW_MAX_WQ_CLASS];	/**< pool per class WQs */
+	ocs_varray_t	*wq_cpu_array[OCS_HW_MAX_WQ_CPU];	/**< pool per CPU WQs */
+
+	/* Sequence objects used in incoming frame processing */
+	ocs_array_t	*seq_pool;
+
+	/* Auto XFER RDY Buffers - protect with io_lock */
+	uint32_t	auto_xfer_rdy_enabled:1,	/**< TRUE if auto xfer rdy is enabled */
+			:31;
+	ocs_pool_t	*auto_xfer_rdy_buf_pool;	/**< pool of ocs_hw_auto_xfer_rdy_buffer_t objects */
+
+	/** Maintain an ordered, linked list of outstanding HW commands. */
+	ocs_lock_t	cmd_lock;
+	ocs_list_t	cmd_head;
+	ocs_list_t	cmd_pending;
+	uint32_t	cmd_head_count;
+
+
+	sli4_link_event_t link;
+	ocs_hw_linkcfg_e linkcfg; /**< link configuration setting */
+	uint32_t eth_license;	   /**< Ethernet license; to enable FCoE on Lancer */
+
+	struct {
+		/**
+		 * Function + argument used to notify upper layer of domain events.
+		 *
+		 * The final argument to the callback is a generic data pointer:
+		 *  - ocs_domain_record_t on OCS_HW_DOMAIN_FOUND
+		 *  - ocs_domain_t on OCS_HW_DOMAIN_ALLOC_FAIL, OCS_HW_DOMAIN_ALLOC_OK,
+		 * OCS_HW_DOMAIN_FREE_FAIL, OCS_HW_DOMAIN_FREE_OK,
+		 * OCS_HW_DOMAIN_ATTACH_FAIL, OCS_HW_DOMAIN_ATTACH_OK, and
+		 * OCS_HW_DOMAIN_LOST.
+		 */
+		int32_t	(*domain)(void *, ocs_hw_domain_event_e, void *);
+		/**
+		 * Function + argument used to notify upper layers of port events.
+		 *
+		 * The final argument to the callback is a pointer to the effected
+		 * SLI port for all events.
+		 */
+		int32_t (*port)(void *, ocs_hw_port_event_e, void *);
+		/** Function + argument used to announce arrival of unsolicited frames */
+		int32_t (*unsolicited)(void *, ocs_hw_sequence_t *);
+		int32_t (*rnode)(void *, ocs_hw_remote_node_event_e, void *);
+		int32_t (*bounce)(void (*)(void *arg), void *arg, uint32_t s_id, uint32_t d_id, uint32_t ox_id);
+	} callback;
+	struct {
+		void *domain;
+		void *port;
+		void *unsolicited;
+		void *rnode;
+		void *bounce;
+	} args;
+
+	/* OCS domain objects index by FCFI */
+	int32_t		first_domain_idx;		/* Workaround for srb->fcfi == 0 */
+	ocs_domain_t	*domains[SLI4_MAX_FCFI];
+
+	/* Table of FCFI values index by FCF_index */
+	uint16_t	fcf_index_fcfi[SLI4_MAX_FCF_INDEX];
+
+	uint16_t	fcf_indicator;
+
+	ocs_hw_io_t	**io;		/**< pointer array of IO objects */
+	uint8_t		*wqe_buffs;	/**< array of WQE buffs mapped to IO objects */	
+
+	ocs_lock_t	io_lock;		/**< IO lock to synchronize list access */
+	ocs_lock_t	io_abort_lock;		/**< IO lock to synchronize IO aborting */
+	ocs_list_t	io_inuse;		/**< List of IO objects in use */
+	ocs_list_t	io_timed_wqe;		/**< List of IO objects with a timed target WQE */
+	ocs_list_t	io_wait_free;		/**< List of IO objects waiting to be freed */
+	ocs_list_t	io_free;		/**< List of IO objects available for allocation */
+	ocs_list_t	io_port_owned;		/**< List of IO objects posted for chip use */
+	ocs_list_t	io_port_dnrx;		/**< List of IO objects needing auto xfer rdy buffers */
+
+	ocs_dma_t	loop_map;
+
+	ocs_dma_t	xfer_rdy;
+
+	ocs_dma_t	dump_sges;
+
+	ocs_dma_t	rnode_mem;
+
+	ocs_dma_t	domain_dmem; 	/*domain dma mem for service params */
+	ocs_dma_t	fcf_dmem; 	/*dma men for fcf */
+
+	ocs_hw_rpi_ref_t *rpi_ref;
+
+	char		*hw_war_version;
+	ocs_hw_workaround_t workaround;
+
+	ocs_atomic_t io_alloc_failed_count;
+
+#if defined(OCS_DEBUG_QUEUE_HISTORY)
+	ocs_hw_q_hist_t q_hist;
+#endif
+
+	ocs_list_t	sec_hio_wait_list;	/**< BZ 161832 Workaround: Secondary HW IO context wait list */
+	uint32_t	sec_hio_wait_count;	/**< BZ 161832 Workaround: Count of IOs that were put on the
+						 * Secondary HW IO wait list
+						 */
+
+#define HW_MAX_TCMD_THREADS		16
+	ocs_hw_qtop_t	*qtop;					/**< pointer to queue topology */
+
+	uint32_t	tcmd_wq_submit[OCS_HW_MAX_NUM_WQ];	/**< stat: wq sumbit count */
+	uint32_t	tcmd_wq_complete[OCS_HW_MAX_NUM_WQ];	/**< stat: wq complete count */
+
+	ocs_timer_t	wqe_timer;		/**< Timer to periodically check for WQE timeouts */
+	ocs_timer_t	watchdog_timer;		/**< Timer for heartbeat */
+	bool            expiration_logged;
+	uint32_t	in_active_wqe_timer:1,	/**< TRUE if currently in active wqe timer handler */
+			active_wqe_timer_shutdown:1, /** TRUE if wqe timer is to be shutdown */
+			:30;
+
+	ocs_list_t	iopc_list;		/**< list of IO processing contexts */
+	ocs_lock_t	iopc_list_lock;		/**< lock for iopc_list */
+
+	ocs_pool_t	*wq_reqtag_pool;	/**< pool of hw_wq_callback_t objects */
+
+	ocs_atomic_t	send_frame_seq_id;	/**< send frame sequence ID */
+};
+
+
+typedef enum {
+	OCS_HW_IO_INUSE_COUNT,
+	OCS_HW_IO_FREE_COUNT,
+	OCS_HW_IO_WAIT_FREE_COUNT,
+	OCS_HW_IO_PORT_OWNED_COUNT,
+	OCS_HW_IO_N_TOTAL_IO_COUNT,
+} ocs_hw_io_count_type_e;
+
+typedef void (*tcmd_cq_handler)(ocs_hw_t *hw, uint32_t cq_idx, void *cq_handler_arg);
+
+/*
+ * HW queue data structures
+ */
+
+struct hw_eq_s {
+	ocs_list_link_t link;		/**< must be first */
+	sli4_qtype_e type;		/**< must be second */
+	uint32_t instance;
+	uint32_t entry_count;
+	uint32_t entry_size;
+	ocs_hw_t *hw;
+	sli4_queue_t *queue;
+	ocs_list_t cq_list;
+#if OCS_STAT_ENABLE
+	uint32_t use_count;
+#endif
+	ocs_varray_t *wq_array;		/*<< array of WQs */
+};
+
+struct hw_cq_s {
+	ocs_list_link_t link;		/*<< must be first */
+	sli4_qtype_e type;		/**< must be second */
+	uint32_t instance;		/*<< CQ instance (cq_idx) */
+	uint32_t entry_count;		/*<< Number of entries */
+	uint32_t entry_size;		/*<< entry size */
+	hw_eq_t *eq;			/*<< parent EQ */
+	sli4_queue_t *queue;		/**< pointer to SLI4 queue */
+	ocs_list_t q_list;		/**< list of children queues */
+
+#if OCS_STAT_ENABLE
+	uint32_t use_count;
+#endif
+};
+
+typedef struct {
+	ocs_list_link_t link;		/*<< must be first */
+	sli4_qtype_e type;		/*<< must be second */
+} hw_q_t;
+
+struct hw_mq_s {
+	ocs_list_link_t link;		/*<< must be first */
+	sli4_qtype_e type;		/*<< must be second */
+	uint32_t instance;
+
+	uint32_t entry_count;
+	uint32_t entry_size;
+	hw_cq_t *cq;
+	sli4_queue_t *queue;
+
+#if OCS_STAT_ENABLE
+	uint32_t use_count;
+#endif
+};
+
+struct hw_wq_s {
+	ocs_list_link_t link;		/*<< must be first */
+	sli4_qtype_e type;		/*<< must be second */
+	uint32_t instance;
+	ocs_hw_t *hw;
+
+	uint32_t entry_count;
+	uint32_t entry_size;
+	hw_cq_t *cq;
+	sli4_queue_t *queue;
+	uint32_t class;
+	uint8_t ulp;
+
+	/* WQ consumed */
+	uint32_t wqec_set_count;		/*<< how often IOs are submitted with wqce set */
+	uint32_t wqec_count;			/*<< current wqce counter */
+	uint32_t free_count;			/*<< free count */
+	uint32_t total_submit_count;		/*<< total submit count */
+	ocs_list_t pending_list;		/*<< list of IOs pending for this WQ */
+
+	/*
+	 * ---Skyhawk only ---
+	 * BZ 160124 - Driver must quarantine XRIs for target writes and
+	 * initiator read when using DIF separates. Throw them on a
+	 * queue until another 4 similar requests are completed to ensure they
+	 * are flushed from the internal chip cache before being re-used.
+	 * The must be a separate queue per CQ because the actual chip completion
+	 * order cannot be determined. Since each WQ has a separate CQ, use the wq
+	 * associated with the IO.
+	 *
+	 * Note: Protected by queue->lock
+	 */
+	ocs_quarantine_info_t quarantine_info;
+
+	/*
+	 * HW IO allocated for use with Send Frame
+	 */
+	ocs_hw_io_t *send_frame_io;
+
+	/* Stats */
+#if OCS_STAT_ENABLE
+	uint32_t use_count;			/*<< use count */
+	uint32_t wq_pending_count;		/*<< count of HW IOs that were queued on the WQ pending list */
+#endif
+};
+
+struct hw_rq_s {
+	ocs_list_link_t link;			/*<< must be first */
+	sli4_qtype_e type;			/*<< must be second */
+	uint32_t instance;
+
+	uint32_t entry_count;
+	uint32_t hdr_entry_size;
+	uint32_t first_burst_entry_size;
+	uint32_t data_entry_size;
+	uint8_t ulp;
+	bool is_mrq;
+	uint32_t base_mrq_id;
+
+	hw_cq_t *cq;
+
+	uint8_t filter_mask;			/* Filter mask value */
+	sli4_queue_t *hdr;
+	sli4_queue_t *first_burst;
+	sli4_queue_t *data;
+
+	ocs_hw_rq_buffer_t *hdr_buf;
+	ocs_hw_rq_buffer_t *fb_buf;
+	ocs_hw_rq_buffer_t *payload_buf;
+
+	ocs_hw_sequence_t **rq_tracker;	/* RQ tracker for this RQ */
+#if OCS_STAT_ENABLE
+	uint32_t use_count;
+	uint32_t hdr_use_count;
+	uint32_t fb_use_count;
+	uint32_t payload_use_count;
+#endif
+};
+
+typedef struct ocs_hw_global_s {
+	const char	*queue_topology_string;			/**< queue topology string */
+} ocs_hw_global_t;
+extern ocs_hw_global_t hw_global;
+
+extern hw_eq_t *hw_new_eq(ocs_hw_t *hw, uint32_t entry_count);
+extern hw_cq_t *hw_new_cq(hw_eq_t *eq, uint32_t entry_count);
+extern uint32_t hw_new_cq_set(hw_eq_t *eqs[], hw_cq_t *cqs[], uint32_t num_cqs, uint32_t entry_count);
+extern hw_mq_t *hw_new_mq(hw_cq_t *cq, uint32_t entry_count);
+extern hw_wq_t *hw_new_wq(hw_cq_t *cq, uint32_t entry_count, uint32_t class, uint32_t ulp);
+extern hw_rq_t *hw_new_rq(hw_cq_t *cq, uint32_t entry_count, uint32_t ulp);
+extern uint32_t hw_new_rq_set(hw_cq_t *cqs[], hw_rq_t *rqs[], uint32_t num_rq_pairs, uint32_t entry_count, uint32_t ulp);
+extern void hw_del_eq(hw_eq_t *eq);
+extern void hw_del_cq(hw_cq_t *cq);
+extern void hw_del_mq(hw_mq_t *mq);
+extern void hw_del_wq(hw_wq_t *wq);
+extern void hw_del_rq(hw_rq_t *rq);
+extern void hw_queue_dump(ocs_hw_t *hw);
+extern void hw_queue_teardown(ocs_hw_t *hw);
+extern int32_t hw_route_rqe(ocs_hw_t *hw, ocs_hw_sequence_t *seq);
+extern int32_t ocs_hw_queue_hash_find(ocs_queue_hash_t *, uint16_t);
+extern ocs_hw_rtn_e ocs_hw_setup(ocs_hw_t *, ocs_os_handle_t, sli4_port_type_e);
+extern ocs_hw_rtn_e ocs_hw_init(ocs_hw_t *);
+extern ocs_hw_rtn_e ocs_hw_teardown(ocs_hw_t *);
+extern ocs_hw_rtn_e ocs_hw_reset(ocs_hw_t *, ocs_hw_reset_e);
+extern int32_t ocs_hw_get_num_eq(ocs_hw_t *);
+extern ocs_hw_rtn_e ocs_hw_get(ocs_hw_t *, ocs_hw_property_e, uint32_t *);
+extern void *ocs_hw_get_ptr(ocs_hw_t *, ocs_hw_property_e);
+extern ocs_hw_rtn_e ocs_hw_set(ocs_hw_t *, ocs_hw_property_e, uint32_t);
+extern ocs_hw_rtn_e ocs_hw_set_ptr(ocs_hw_t *, ocs_hw_property_e, void*);
+extern int32_t ocs_hw_event_check(ocs_hw_t *, uint32_t);
+extern int32_t ocs_hw_process(ocs_hw_t *, uint32_t, uint32_t);
+extern ocs_hw_rtn_e ocs_hw_command(ocs_hw_t *, uint8_t *, uint32_t, void *, void *);
+extern ocs_hw_rtn_e ocs_hw_callback(ocs_hw_t *, ocs_hw_callback_e, void *, void *);
+extern ocs_hw_rtn_e ocs_hw_port_alloc(ocs_hw_t *, ocs_sli_port_t *, ocs_domain_t *, uint8_t *);
+extern ocs_hw_rtn_e ocs_hw_port_attach(ocs_hw_t *, ocs_sli_port_t *, uint32_t);
+typedef void (*ocs_hw_port_control_cb_t)(int32_t status, uintptr_t value, void *arg);
+extern ocs_hw_rtn_e ocs_hw_port_control(ocs_hw_t *, ocs_hw_port_e, uintptr_t, ocs_hw_port_control_cb_t, void *);
+extern ocs_hw_rtn_e ocs_hw_port_free(ocs_hw_t *, ocs_sli_port_t *);
+extern ocs_hw_rtn_e ocs_hw_domain_alloc(ocs_hw_t *, ocs_domain_t *, uint32_t, uint32_t);
+extern ocs_hw_rtn_e ocs_hw_domain_attach(ocs_hw_t *, ocs_domain_t *, uint32_t);
+extern ocs_hw_rtn_e ocs_hw_domain_free(ocs_hw_t *, ocs_domain_t *);
+extern ocs_hw_rtn_e ocs_hw_domain_force_free(ocs_hw_t *, ocs_domain_t *);
+extern ocs_domain_t * ocs_hw_domain_get(ocs_hw_t *, uint16_t);
+extern ocs_hw_rtn_e ocs_hw_node_alloc(ocs_hw_t *, ocs_remote_node_t *, uint32_t, ocs_sli_port_t *);
+extern ocs_hw_rtn_e ocs_hw_node_free_all(ocs_hw_t *);
+extern ocs_hw_rtn_e ocs_hw_node_attach(ocs_hw_t *, ocs_remote_node_t *, ocs_dma_t *);
+extern ocs_hw_rtn_e ocs_hw_node_detach(ocs_hw_t *, ocs_remote_node_t *);
+extern ocs_hw_rtn_e ocs_hw_node_free_resources(ocs_hw_t *, ocs_remote_node_t *);
+extern ocs_hw_rtn_e ocs_hw_node_group_alloc(ocs_hw_t *, ocs_remote_node_group_t *);
+extern ocs_hw_rtn_e ocs_hw_node_group_attach(ocs_hw_t *, ocs_remote_node_group_t *, ocs_remote_node_t *);
+extern ocs_hw_rtn_e ocs_hw_node_group_free(ocs_hw_t *, ocs_remote_node_group_t *);
+extern ocs_hw_io_t *ocs_hw_io_alloc(ocs_hw_t *);
+extern ocs_hw_io_t *ocs_hw_io_activate_port_owned(ocs_hw_t *, ocs_hw_io_t *);
+extern int32_t ocs_hw_io_free(ocs_hw_t *, ocs_hw_io_t *);
+extern uint8_t ocs_hw_io_inuse(ocs_hw_t *hw, ocs_hw_io_t *io);
+typedef int32_t (*ocs_hw_srrs_cb_t)(ocs_hw_io_t *io, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *arg);
+extern ocs_hw_rtn_e ocs_hw_srrs_send(ocs_hw_t *, ocs_hw_io_type_e, ocs_hw_io_t *, ocs_dma_t *, uint32_t, ocs_dma_t *, ocs_remote_node_t *, ocs_hw_io_param_t *, ocs_hw_srrs_cb_t, void *);
+extern ocs_hw_rtn_e ocs_hw_io_send(ocs_hw_t *, ocs_hw_io_type_e, ocs_hw_io_t *, uint32_t, ocs_hw_io_param_t *, ocs_remote_node_t *, void *, void *);
+extern ocs_hw_rtn_e _ocs_hw_io_send(ocs_hw_t *hw, ocs_hw_io_type_e type, ocs_hw_io_t *io,
+				      uint32_t len, ocs_hw_io_param_t *iparam, ocs_remote_node_t *rnode,
+				      void *cb, void *arg);
+extern ocs_hw_rtn_e ocs_hw_io_register_sgl(ocs_hw_t *, ocs_hw_io_t *, ocs_dma_t *, uint32_t);
+extern ocs_hw_rtn_e ocs_hw_io_init_sges(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_io_type_e type);
+extern ocs_hw_rtn_e ocs_hw_io_add_seed_sge(ocs_hw_t *hw, ocs_hw_io_t *io, ocs_hw_dif_info_t *dif_info);
+extern ocs_hw_rtn_e ocs_hw_io_add_sge(ocs_hw_t *, ocs_hw_io_t *, uintptr_t, uint32_t);
+extern ocs_hw_rtn_e ocs_hw_io_add_dif_sge(ocs_hw_t *hw, ocs_hw_io_t *io, uintptr_t addr);
+extern ocs_hw_rtn_e ocs_hw_io_abort(ocs_hw_t *, ocs_hw_io_t *, uint32_t, void *, void *);
+extern int32_t ocs_hw_io_get_xid(ocs_hw_t *, ocs_hw_io_t *);
+extern uint32_t ocs_hw_io_get_count(ocs_hw_t *, ocs_hw_io_count_type_e);
+extern uint32_t ocs_hw_get_rqes_produced_count(ocs_hw_t *hw);
+
+typedef void (*ocs_hw_fw_cb_t)(int32_t status, uint32_t bytes_written, uint32_t change_status, void *arg);
+extern ocs_hw_rtn_e ocs_hw_firmware_write(ocs_hw_t *, ocs_dma_t *, uint32_t, uint32_t, int, ocs_hw_fw_cb_t, void*);
+
+/* Function for retrieving SFP data */
+typedef void (*ocs_hw_sfp_cb_t)(void *, int32_t, uint32_t, uint32_t *, void *);
+extern ocs_hw_rtn_e ocs_hw_get_sfp(ocs_hw_t *, uint16_t, ocs_hw_sfp_cb_t, void *);
+
+/* Function for retrieving temperature data */
+typedef void (*ocs_hw_temp_cb_t)(int32_t status,
+				  uint32_t curr_temp,
+				  uint32_t crit_temp_thrshld,
+				  uint32_t warn_temp_thrshld,
+				  uint32_t norm_temp_thrshld,
+				  uint32_t fan_off_thrshld,
+				  uint32_t fan_on_thrshld,
+				  void *arg);
+extern ocs_hw_rtn_e ocs_hw_get_temperature(ocs_hw_t *, ocs_hw_temp_cb_t, void*);
+
+/* Function for retrieving link statistics */
+typedef void (*ocs_hw_link_stat_cb_t)(int32_t status,
+				       uint32_t num_counters,
+				       ocs_hw_link_stat_counts_t *counters,
+				       void *arg);
+extern ocs_hw_rtn_e ocs_hw_get_link_stats(ocs_hw_t *,
+					    uint8_t req_ext_counters,
+					    uint8_t clear_overflow_flags,
+					    uint8_t clear_all_counters,
+					    ocs_hw_link_stat_cb_t, void*);
+/* Function for retrieving host statistics */
+typedef void (*ocs_hw_host_stat_cb_t)(int32_t status,
+				       uint32_t num_counters,
+				       ocs_hw_host_stat_counts_t *counters,
+				       void *arg);
+extern ocs_hw_rtn_e ocs_hw_get_host_stats(ocs_hw_t *hw, uint8_t cc, ocs_hw_host_stat_cb_t, void *arg);
+
+extern ocs_hw_rtn_e ocs_hw_raise_ue(ocs_hw_t *, uint8_t);
+typedef void (*ocs_hw_dump_get_cb_t)(int32_t status, uint32_t bytes_read, uint8_t eof, void *arg);
+extern ocs_hw_rtn_e ocs_hw_dump_get(ocs_hw_t *, ocs_dma_t *, uint32_t, uint32_t, ocs_hw_dump_get_cb_t, void *);
+extern ocs_hw_rtn_e ocs_hw_set_dump_location(ocs_hw_t *, uint32_t, ocs_dma_t *, uint8_t);
+
+typedef void (*ocs_get_port_protocol_cb_t)(int32_t status, ocs_hw_port_protocol_e port_protocol, void *arg);
+extern ocs_hw_rtn_e ocs_hw_get_port_protocol(ocs_hw_t *hw, uint32_t pci_func, ocs_get_port_protocol_cb_t mgmt_cb, void* ul_arg);
+typedef void (*ocs_set_port_protocol_cb_t)(int32_t status,  void *arg);
+extern ocs_hw_rtn_e ocs_hw_set_port_protocol(ocs_hw_t *hw, ocs_hw_port_protocol_e profile,
+					       uint32_t pci_func, ocs_set_port_protocol_cb_t mgmt_cb,
+					       void* ul_arg);
+
+typedef void (*ocs_get_profile_list_cb_t)(int32_t status,  ocs_hw_profile_list_t*, void *arg);
+extern ocs_hw_rtn_e ocs_hw_get_profile_list(ocs_hw_t *hw, ocs_get_profile_list_cb_t mgmt_cb, void *arg);
+typedef void (*ocs_get_active_profile_cb_t)(int32_t status,  uint32_t active_profile, void *arg);
+extern ocs_hw_rtn_e ocs_hw_get_active_profile(ocs_hw_t *hw, ocs_get_active_profile_cb_t mgmt_cb, void *arg);
+typedef void (*ocs_set_active_profile_cb_t)(int32_t status, void *arg);
+extern ocs_hw_rtn_e ocs_hw_set_active_profile(ocs_hw_t *hw, ocs_set_active_profile_cb_t mgmt_cb,
+		uint32_t profile_id, void *arg);
+typedef void (*ocs_get_nvparms_cb_t)(int32_t status, uint8_t *wwpn, uint8_t *wwnn, uint8_t hard_alpa,
+		uint32_t preferred_d_id, void *arg);
+extern ocs_hw_rtn_e ocs_hw_get_nvparms(ocs_hw_t *hw, ocs_get_nvparms_cb_t mgmt_cb, void *arg);
+typedef void (*ocs_set_nvparms_cb_t)(int32_t status, void *arg);
+extern ocs_hw_rtn_e ocs_hw_set_nvparms(ocs_hw_t *hw, ocs_set_nvparms_cb_t mgmt_cb, uint8_t *wwpn,
+		uint8_t *wwnn, uint8_t hard_alpa, uint32_t preferred_d_id, void *arg);
+extern int32_t ocs_hw_eq_process(ocs_hw_t *hw, hw_eq_t *eq, uint32_t max_isr_time_msec);
+extern void ocs_hw_cq_process(ocs_hw_t *hw, hw_cq_t *cq);
+extern void ocs_hw_wq_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, int32_t status, uint16_t rid);
+extern void ocs_hw_xabt_process(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe, uint16_t rid);
+extern int32_t hw_wq_write(hw_wq_t *wq, ocs_hw_wqe_t *wqe);
+
+typedef void (*ocs_hw_dump_clear_cb_t)(int32_t status, void *arg);
+extern ocs_hw_rtn_e ocs_hw_dump_clear(ocs_hw_t *, ocs_hw_dump_clear_cb_t, void *);
+
+extern uint8_t ocs_hw_is_io_port_owned(ocs_hw_t *hw, ocs_hw_io_t *io);
+
+
+extern uint8_t ocs_hw_is_xri_port_owned(ocs_hw_t *hw, uint32_t xri);
+extern ocs_hw_io_t * ocs_hw_io_lookup(ocs_hw_t *hw, uint32_t indicator);
+extern uint32_t ocs_hw_xri_move_to_port_owned(ocs_hw_t *hw, uint32_t num_xri);
+extern ocs_hw_rtn_e ocs_hw_xri_move_to_host_owned(ocs_hw_t *hw, uint8_t num_xri);
+extern int32_t ocs_hw_reque_xri(ocs_hw_t *hw, ocs_hw_io_t *io);
+
+
+typedef struct {
+	/* structure elements used by HW */
+	ocs_hw_t *hw;			/**> pointer to HW */
+	hw_wq_callback_t *wqcb;	/**> WQ callback object, request tag */
+	ocs_hw_wqe_t wqe;		/**> WQE buffer object (may be queued on WQ pending list) */
+	void (*callback)(int32_t status, void *arg);	/**> final callback function */
+	void *arg;			/**> final callback argument */
+
+	/* General purpose elements */
+	ocs_hw_sequence_t *seq;
+	ocs_dma_t payload;		/**> a payload DMA buffer */
+} ocs_hw_send_frame_context_t;
+
+
+#define OCS_HW_OBJECT_G5              0xfeaa0001
+#define OCS_HW_OBJECT_G6              0xfeaa0003
+#define OCS_FILE_TYPE_GROUP            0xf7
+#define OCS_FILE_ID_GROUP              0xa2
+struct ocs_hw_grp_hdr {
+	uint32_t size;          
+	uint32_t magic_number;  
+	uint32_t word2;         
+	uint8_t rev_name[128];
+        uint8_t date[12];
+        uint8_t revision[32];
+};                              
+
+
+ocs_hw_rtn_e
+ocs_hw_send_frame(ocs_hw_t *hw, fc_header_le_t *hdr, uint8_t sof, uint8_t eof, ocs_dma_t *payload,
+		   ocs_hw_send_frame_context_t *ctx,
+		   void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg);
+
+/* RQ completion handlers for RQ pair mode */
+extern int32_t ocs_hw_rqpair_process_rq(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe);
+extern ocs_hw_rtn_e ocs_hw_rqpair_sequence_free(ocs_hw_t *hw, ocs_hw_sequence_t *seq);
+extern int32_t ocs_hw_rqpair_process_auto_xfr_rdy_cmd(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe);
+extern int32_t ocs_hw_rqpair_process_auto_xfr_rdy_data(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe);
+extern ocs_hw_rtn_e ocs_hw_rqpair_init(ocs_hw_t *hw);
+extern ocs_hw_rtn_e ocs_hw_rqpair_auto_xfer_rdy_buffer_alloc(ocs_hw_t *hw, uint32_t num_buffers);
+extern uint8_t ocs_hw_rqpair_auto_xfer_rdy_buffer_post(ocs_hw_t *hw, ocs_hw_io_t *io, int reuse_buf);
+extern ocs_hw_rtn_e ocs_hw_rqpair_auto_xfer_rdy_move_to_port(ocs_hw_t *hw, ocs_hw_io_t *io);
+extern void ocs_hw_rqpair_auto_xfer_rdy_move_to_host(ocs_hw_t *hw, ocs_hw_io_t *io);
+extern void ocs_hw_rqpair_teardown(ocs_hw_t *hw);
+
+extern ocs_hw_rtn_e ocs_hw_rx_allocate(ocs_hw_t *hw);
+extern ocs_hw_rtn_e ocs_hw_rx_post(ocs_hw_t *hw);
+extern void ocs_hw_rx_free(ocs_hw_t *hw);
+
+extern void ocs_hw_unsol_process_bounce(void *arg);
+
+typedef int32_t (*ocs_hw_async_cb_t)(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg);
+extern int32_t ocs_hw_async_call(ocs_hw_t *hw, ocs_hw_async_cb_t callback, void *arg);
+
+static inline void
+ocs_hw_sequence_copy(ocs_hw_sequence_t *dst, ocs_hw_sequence_t *src)
+{
+	/* Copy the src to dst, then zero out the linked list link */
+	*dst = *src;
+	ocs_memset(&dst->link, 0, sizeof(dst->link));
+}
+
+static inline ocs_hw_rtn_e
+ocs_hw_sequence_free(ocs_hw_t *hw, ocs_hw_sequence_t *seq)
+{
+	/* Only RQ pair mode is supported */
+	return ocs_hw_rqpair_sequence_free(hw, seq);
+}
+
+/* HW WQ request tag API */
+extern ocs_hw_rtn_e ocs_hw_reqtag_init(ocs_hw_t *hw);
+extern hw_wq_callback_t *ocs_hw_reqtag_alloc(ocs_hw_t *hw,
+					       void (*callback)(void *arg, uint8_t *cqe, int32_t status), void *arg);
+extern void ocs_hw_reqtag_free(ocs_hw_t *hw, hw_wq_callback_t *wqcb);
+extern hw_wq_callback_t *ocs_hw_reqtag_get_instance(ocs_hw_t *hw, uint32_t instance_index);
+extern void ocs_hw_reqtag_reset(ocs_hw_t *hw);
+
+
+extern uint32_t ocs_hw_dif_blocksize(ocs_hw_dif_info_t *dif_info);
+extern int32_t ocs_hw_dif_mem_blocksize(ocs_hw_dif_info_t *dif_info, int wiretomem);
+extern int32_t ocs_hw_dif_wire_blocksize(ocs_hw_dif_info_t *dif_info, int wiretomem);
+extern uint32_t ocs_hw_get_def_wwn(ocs_t *ocs, uint32_t chan, uint64_t *wwpn, uint64_t *wwnn);
+
+/* Uncomment to enable CPUTRACE */
+//#define ENABLE_CPUTRACE
+#ifdef ENABLE_CPUTRACE
+#define CPUTRACE(t) ocs_printf("trace: %-20s %2s %-16s cpu %2d\n", __func__, t, \
+	({ocs_thread_t *self = ocs_thread_self(); self != NULL ? self->name : "unknown";}), ocs_thread_getcpu());
+#else
+#define CPUTRACE(...)
+#endif
+
+
+/* Two levels of macro needed due to expansion */
+#define HW_FWREV(a,b,c,d) (((uint64_t)(a) << 48) | ((uint64_t)(b) << 32) | ((uint64_t)(c) << 16) | ((uint64_t)(d)))
+#define HW_FWREV_1(x) HW_FWREV(x)
+
+#define OCS_FW_VER_STR2(a,b,c,d) #a "." #b "." #c "." #d
+#define OCS_FW_VER_STR(x) OCS_FW_VER_STR2(x)
+
+#define OCS_MIN_FW_VER_LANCER 10,4,255,0
+#define OCS_MIN_FW_VER_SKYHAWK 10,4,255,0
+
+extern void ocs_hw_workaround_setup(struct ocs_hw_s *hw);
+
+
+/**
+ * @brief Defines the number of the RQ buffers for each RQ
+ */
+
+#ifndef OCS_HW_RQ_NUM_HDR
+#define OCS_HW_RQ_NUM_HDR		1024
+#endif
+
+#ifndef OCS_HW_RQ_NUM_PAYLOAD
+#define OCS_HW_RQ_NUM_PAYLOAD			1024
+#endif
+
+/**
+ * @brief Defines the size of the RQ buffers used for each RQ
+ */
+#ifndef OCS_HW_RQ_SIZE_HDR
+#define OCS_HW_RQ_SIZE_HDR		128
+#endif
+
+#ifndef OCS_HW_RQ_SIZE_PAYLOAD
+#define OCS_HW_RQ_SIZE_PAYLOAD		1024
+#endif
+
+/*
+ * @brief Define the maximum number of multi-receive queues
+ */
+#ifndef OCS_HW_MAX_MRQS
+#define OCS_HW_MAX_MRQS			8
+#endif
+
+/*
+ * @brief Define count of when to set the WQEC bit in a submitted
+ * WQE, causing a consummed/released completion to be posted.
+ */
+#ifndef OCS_HW_WQEC_SET_COUNT
+#define OCS_HW_WQEC_SET_COUNT			32
+#endif
+
+/*
+ * @brief Send frame timeout in seconds
+ */
+#ifndef OCS_HW_SEND_FRAME_TIMEOUT
+#define OCS_HW_SEND_FRAME_TIMEOUT		10
+#endif
+
+/*
+ * @brief FDT Transfer Hint value, reads greater than this value
+ * will be segmented to implement fairness.   A value of zero disables
+ * the feature.
+ */
+#ifndef OCS_HW_FDT_XFER_HINT
+#define OCS_HW_FDT_XFER_HINT			8192
+#endif
+
+#endif /* !_OCS_HW_H */
diff --git a/sys/dev/ocs_fc/ocs_hw_queues.c b/sys/dev/ocs_fc/ocs_hw_queues.c
new file mode 100644
index 000000000000..2527d72865a7
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_hw_queues.c
@@ -0,0 +1,2602 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ */
+
+#include "ocs_os.h"
+#include "ocs_hw.h"
+#include "ocs_hw_queues.h"
+
+#define HW_QTOP_DEBUG		0
+
+/**
+ * @brief Initialize queues
+ *
+ * Given the parsed queue topology spec, the SLI queues are created and
+ * initialized
+ *
+ * @param hw pointer to HW object
+ * @param qtop pointer to queue topology
+ *
+ * @return returns 0 for success, an error code value for failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_init_queues(ocs_hw_t *hw, ocs_hw_qtop_t *qtop)
+{
+	uint32_t i, j;
+	uint32_t default_lengths[QTOP_LAST], len;
+	uint32_t rqset_len = 0, rqset_ulp = 0, rqset_count = 0;
+	uint8_t rqset_filter_mask = 0;
+	hw_eq_t *eqs[hw->config.n_rq];
+	hw_cq_t *cqs[hw->config.n_rq];
+	hw_rq_t *rqs[hw->config.n_rq];
+	ocs_hw_qtop_entry_t *qt, *next_qt;
+	ocs_hw_mrq_t mrq;
+	bool use_mrq = FALSE;
+
+	hw_eq_t *eq = NULL;
+	hw_cq_t *cq = NULL;
+	hw_wq_t *wq = NULL;
+	hw_rq_t *rq = NULL;
+	hw_mq_t *mq = NULL;
+
+	mrq.num_pairs = 0;
+	default_lengths[QTOP_EQ] = 1024;
+	default_lengths[QTOP_CQ] = hw->num_qentries[SLI_QTYPE_CQ];
+	default_lengths[QTOP_WQ] = hw->num_qentries[SLI_QTYPE_WQ];
+	default_lengths[QTOP_RQ] = hw->num_qentries[SLI_QTYPE_RQ];
+	default_lengths[QTOP_MQ] = OCS_HW_MQ_DEPTH;
+
+	ocs_hw_verify(hw != NULL, OCS_HW_RTN_INVALID_ARG);
+
+	hw->eq_count = 0;
+	hw->cq_count = 0;
+	hw->mq_count = 0;
+	hw->wq_count = 0;
+	hw->rq_count = 0;
+	hw->hw_rq_count = 0;
+	ocs_list_init(&hw->eq_list, hw_eq_t, link);
+
+	/* If MRQ is requested, Check if it is supported by SLI. */
+	if ((hw->config.n_rq > 1 ) && !hw->sli.config.features.flag.mrqp) {
+		ocs_log_err(hw->os, "MRQ topology not supported by SLI4.\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	if (hw->config.n_rq > 1)
+		use_mrq = TRUE;
+
+	/* Allocate class WQ pools */
+	for (i = 0; i < ARRAY_SIZE(hw->wq_class_array); i++) {
+		hw->wq_class_array[i] = ocs_varray_alloc(hw->os, OCS_HW_MAX_NUM_WQ);
+		if (hw->wq_class_array[i] == NULL) {
+			ocs_log_err(hw->os, "ocs_varray_alloc for wq_class failed\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+	}
+
+	/* Allocate per CPU WQ pools */
+	for (i = 0; i < ARRAY_SIZE(hw->wq_cpu_array); i++) {
+		hw->wq_cpu_array[i] = ocs_varray_alloc(hw->os, OCS_HW_MAX_NUM_WQ);
+		if (hw->wq_cpu_array[i] == NULL) {
+			ocs_log_err(hw->os, "ocs_varray_alloc for wq_class failed\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+	}
+
+
+	ocs_hw_assert(qtop != NULL);
+
+	for (i = 0, qt = qtop->entries; i < qtop->inuse_count; i++, qt++) {
+		if (i == qtop->inuse_count - 1)
+			next_qt = NULL;
+		else
+			next_qt = qt + 1;
+
+		switch(qt->entry) {
+		case QTOP_EQ:
+			len = (qt->len) ? qt->len : default_lengths[QTOP_EQ];
+
+			if (qt->set_default) {
+				default_lengths[QTOP_EQ] = len;
+				break;
+			}
+
+			eq = hw_new_eq(hw, len);
+			if (eq == NULL) {
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_NO_MEMORY;
+			}
+			break;
+
+		case QTOP_CQ:
+			len = (qt->len) ? qt->len : default_lengths[QTOP_CQ];
+
+			if (qt->set_default) {
+				default_lengths[QTOP_CQ] = len;
+				break;
+			}
+
+			/* If this CQ is for MRQ, then delay the creation */
+			if (!use_mrq || next_qt->entry != QTOP_RQ) {
+				cq = hw_new_cq(eq, len);
+				if (cq == NULL) {
+					hw_queue_teardown(hw);
+					return OCS_HW_RTN_NO_MEMORY;
+				}
+			}
+			break;
+
+		case QTOP_WQ: {
+
+			len = (qt->len) ? qt->len : default_lengths[QTOP_WQ];
+			if (qt->set_default) {
+				default_lengths[QTOP_WQ] = len;
+				break;
+			}
+
+			if ((hw->ulp_start + qt->ulp) > hw->ulp_max) {
+				ocs_log_err(hw->os, "invalid ULP %d for WQ\n", qt->ulp);
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_NO_MEMORY;
+			}
+
+			wq = hw_new_wq(cq, len, qt->class, hw->ulp_start + qt->ulp);
+			if (wq == NULL) {
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_NO_MEMORY;
+			}
+
+			/* Place this WQ on the EQ WQ array */
+			if (ocs_varray_add(eq->wq_array, wq)) {
+				ocs_log_err(hw->os, "QTOP_WQ: EQ ocs_varray_add failed\n");
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_ERROR;
+			}
+
+			/* Place this WQ on the HW class array */
+			if (qt->class < ARRAY_SIZE(hw->wq_class_array)) {
+				if (ocs_varray_add(hw->wq_class_array[qt->class], wq)) {
+					ocs_log_err(hw->os, "HW wq_class_array ocs_varray_add failed\n");
+					hw_queue_teardown(hw);
+					return OCS_HW_RTN_ERROR;
+				}
+			} else {
+				ocs_log_err(hw->os, "Invalid class value: %d\n", qt->class);
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_ERROR;
+			}
+
+			/*
+			 * Place this WQ on the per CPU list, asumming that EQs are mapped to cpu given
+			 * by the EQ instance modulo number of CPUs
+			 */
+			if (ocs_varray_add(hw->wq_cpu_array[eq->instance % ocs_get_num_cpus()], wq)) {
+				ocs_log_err(hw->os, "HW wq_cpu_array ocs_varray_add failed\n");
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_ERROR;
+			}
+
+			break;
+		}
+		case QTOP_RQ: {
+			len = (qt->len) ? qt->len : default_lengths[QTOP_RQ];
+			if (qt->set_default) {
+				default_lengths[QTOP_RQ] = len;
+				break;
+			}
+
+			if ((hw->ulp_start + qt->ulp) > hw->ulp_max) {
+				ocs_log_err(hw->os, "invalid ULP %d for RQ\n", qt->ulp);
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_NO_MEMORY;
+			}
+
+			if (use_mrq) {
+				mrq.rq_cfg[mrq.num_pairs].len = len;
+				mrq.rq_cfg[mrq.num_pairs].ulp = hw->ulp_start + qt->ulp; 
+				mrq.rq_cfg[mrq.num_pairs].filter_mask = qt->filter_mask;
+				mrq.rq_cfg[mrq.num_pairs].eq = eq;
+				mrq.num_pairs ++;
+			} else {
+				rq = hw_new_rq(cq, len, hw->ulp_start + qt->ulp);
+				if (rq == NULL) {
+					hw_queue_teardown(hw);
+					return OCS_HW_RTN_NO_MEMORY;
+				}
+				rq->filter_mask = qt->filter_mask;
+			}
+			break;
+		}
+
+		case QTOP_MQ:
+			len = (qt->len) ? qt->len : default_lengths[QTOP_MQ];
+			if (qt->set_default) {
+				default_lengths[QTOP_MQ] = len;
+				break;
+			}
+
+			mq = hw_new_mq(cq, len);
+			if (mq == NULL) {
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_NO_MEMORY;
+			}
+			break;
+
+		default:
+			ocs_hw_assert(0);
+			break;
+		}
+	}
+
+	if (mrq.num_pairs) {
+		/* First create normal RQs. */
+		for (i = 0; i < mrq.num_pairs; i++) {
+			for (j = 0; j < mrq.num_pairs; j++) {
+				if ((i != j) && (mrq.rq_cfg[i].filter_mask == mrq.rq_cfg[j].filter_mask)) {
+					/* This should be created using set */
+					if (rqset_filter_mask && (rqset_filter_mask != mrq.rq_cfg[i].filter_mask)) {
+						ocs_log_crit(hw->os, "Cant create morethan one RQ Set\n");
+						hw_queue_teardown(hw);
+						return OCS_HW_RTN_ERROR;
+					} else if (!rqset_filter_mask){
+						rqset_filter_mask = mrq.rq_cfg[i].filter_mask;
+						rqset_len = mrq.rq_cfg[i].len;
+						rqset_ulp = mrq.rq_cfg[i].ulp;
+					}
+					eqs[rqset_count] = mrq.rq_cfg[i].eq;
+					rqset_count++;
+					break;
+				}
+			}
+			if (j == mrq.num_pairs) {
+				/* Normal RQ */
+				cq = hw_new_cq(mrq.rq_cfg[i].eq, default_lengths[QTOP_CQ]);
+				if (cq == NULL) {
+					hw_queue_teardown(hw);
+					return OCS_HW_RTN_NO_MEMORY;
+				}
+
+				rq = hw_new_rq(cq, mrq.rq_cfg[i].len, mrq.rq_cfg[i].ulp);
+				if (rq == NULL) {
+					hw_queue_teardown(hw);
+					return OCS_HW_RTN_NO_MEMORY;
+				}
+				rq->filter_mask = mrq.rq_cfg[i].filter_mask;
+			}
+		}
+
+		/* Now create RQ Set */
+		if (rqset_count) {
+			if (rqset_count > OCE_HW_MAX_NUM_MRQ_PAIRS) {
+				ocs_log_crit(hw->os,
+					     "Max Supported MRQ pairs = %d\n",
+					     OCE_HW_MAX_NUM_MRQ_PAIRS);
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_ERROR;
+			}
+
+			/* Create CQ set */
+			if (hw_new_cq_set(eqs, cqs, rqset_count, default_lengths[QTOP_CQ])) {
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_ERROR;
+			}
+
+			/* Create RQ set */
+			if (hw_new_rq_set(cqs, rqs, rqset_count, rqset_len, rqset_ulp)) {
+				hw_queue_teardown(hw);
+				return OCS_HW_RTN_ERROR;
+			}
+
+			for (i = 0; i < rqset_count ; i++) {
+				rqs[i]->filter_mask = rqset_filter_mask;
+				rqs[i]->is_mrq = TRUE;
+				rqs[i]->base_mrq_id = rqs[0]->hdr->id;
+			}
+
+			hw->hw_mrq_count = rqset_count;
+		}
+	}
+
+	return OCS_HW_RTN_SUCCESS;
+
+}
+
+/**
+ * @brief Allocate a new EQ object
+ *
+ * A new EQ object is instantiated
+ *
+ * @param hw pointer to HW object
+ * @param entry_count number of entries in the EQ
+ *
+ * @return pointer to allocated EQ object
+ */
+hw_eq_t*
+hw_new_eq(ocs_hw_t *hw, uint32_t entry_count)
+{
+	hw_eq_t *eq = ocs_malloc(hw->os, sizeof(*eq), OCS_M_ZERO | OCS_M_NOWAIT);
+
+	if (eq != NULL) {
+		eq->type = SLI_QTYPE_EQ;
+		eq->hw = hw;
+		eq->entry_count = entry_count;
+		eq->instance = hw->eq_count++;
+		eq->queue = &hw->eq[eq->instance];
+		ocs_list_init(&eq->cq_list, hw_cq_t, link);
+
+		eq->wq_array = ocs_varray_alloc(hw->os, OCS_HW_MAX_NUM_WQ);
+		if (eq->wq_array == NULL) {
+			ocs_free(hw->os, eq, sizeof(*eq));
+			eq = NULL;
+		} else {
+			if (sli_queue_alloc(&hw->sli, SLI_QTYPE_EQ, eq->queue, entry_count, NULL, 0)) {
+				ocs_log_err(hw->os, "EQ[%d] allocation failure\n", eq->instance);
+				ocs_free(hw->os, eq, sizeof(*eq));
+				eq = NULL;
+			} else {
+				sli_eq_modify_delay(&hw->sli, eq->queue, 1, 0, 8);
+				hw->hw_eq[eq->instance] = eq;
+				ocs_list_add_tail(&hw->eq_list, eq);
+				ocs_log_debug(hw->os, "create eq[%2d] id %3d len %4d\n", eq->instance, eq->queue->id,
+					eq->entry_count);
+			}
+		}
+	}
+	return eq;
+}
+
+/**
+ * @brief Allocate a new CQ object
+ *
+ * A new CQ object is instantiated
+ *
+ * @param eq pointer to parent EQ object
+ * @param entry_count number of entries in the CQ
+ *
+ * @return pointer to allocated CQ object
+ */
+hw_cq_t*
+hw_new_cq(hw_eq_t *eq, uint32_t entry_count)
+{
+	ocs_hw_t *hw = eq->hw;
+	hw_cq_t *cq = ocs_malloc(hw->os, sizeof(*cq), OCS_M_ZERO | OCS_M_NOWAIT);
+
+	if (cq != NULL) {
+		cq->eq = eq;
+		cq->type = SLI_QTYPE_CQ;
+		cq->instance = eq->hw->cq_count++;
+		cq->entry_count = entry_count;
+		cq->queue = &hw->cq[cq->instance];
+
+		ocs_list_init(&cq->q_list, hw_q_t, link);
+
+		if (sli_queue_alloc(&hw->sli, SLI_QTYPE_CQ, cq->queue, cq->entry_count, eq->queue, 0)) {
+			ocs_log_err(hw->os, "CQ[%d] allocation failure len=%d\n",
+				eq->instance,
+				eq->entry_count);
+			ocs_free(hw->os, cq, sizeof(*cq));
+			cq = NULL;
+		} else {
+			hw->hw_cq[cq->instance] = cq;
+			ocs_list_add_tail(&eq->cq_list, cq);
+			ocs_log_debug(hw->os, "create cq[%2d] id %3d len %4d\n", cq->instance, cq->queue->id,
+				cq->entry_count);
+		}
+	}
+	return cq;
+}
+
+/**
+ * @brief Allocate a new CQ Set of objects.
+ *
+ * @param eqs pointer to a set of EQ objects.
+ * @param cqs pointer to a set of CQ objects to be returned.
+ * @param num_cqs number of CQ queues in the set.
+ * @param entry_count number of entries in the CQ.
+ *
+ * @return 0 on success and -1 on failure.
+ */
+uint32_t
+hw_new_cq_set(hw_eq_t *eqs[], hw_cq_t *cqs[], uint32_t num_cqs, uint32_t entry_count)
+{
+	uint32_t i;
+	ocs_hw_t *hw = eqs[0]->hw;
+	sli4_t *sli4 = &hw->sli;
+	hw_cq_t *cq = NULL;
+	sli4_queue_t *qs[SLI_MAX_CQ_SET_COUNT], *assocs[SLI_MAX_CQ_SET_COUNT];
+
+	/* Initialise CQS pointers to NULL */
+	for (i = 0; i < num_cqs; i++) {
+		cqs[i] = NULL;
+	}
+
+	for (i = 0; i < num_cqs; i++) {
+		cq = ocs_malloc(hw->os, sizeof(*cq), OCS_M_ZERO | OCS_M_NOWAIT);
+		if (cq == NULL)
+			goto error;
+
+		cqs[i]          = cq;
+		cq->eq          = eqs[i];
+		cq->type        = SLI_QTYPE_CQ;
+		cq->instance    = hw->cq_count++;
+		cq->entry_count = entry_count;
+		cq->queue       = &hw->cq[cq->instance];
+		qs[i]           = cq->queue;
+		assocs[i]       = eqs[i]->queue;
+		ocs_list_init(&cq->q_list, hw_q_t, link);
+	}
+
+	if (sli_cq_alloc_set(sli4, qs, num_cqs, entry_count, assocs)) {
+		ocs_log_err(NULL, "Failed to create CQ Set. \n");
+		goto error;
+	}
+
+	for (i = 0; i < num_cqs; i++) {
+		hw->hw_cq[cqs[i]->instance] = cqs[i];
+		ocs_list_add_tail(&cqs[i]->eq->cq_list, cqs[i]);
+	}
+
+	return 0;
+
+error:
+	for (i = 0; i < num_cqs; i++) {
+		if (cqs[i]) {
+			ocs_free(hw->os, cqs[i], sizeof(*cqs[i]));
+			cqs[i] = NULL;
+		}
+	}
+	return -1;
+}
+
+
+/**
+ * @brief Allocate a new MQ object
+ *
+ * A new MQ object is instantiated
+ *
+ * @param cq pointer to parent CQ object
+ * @param entry_count number of entries in the MQ
+ *
+ * @return pointer to allocated MQ object
+ */
+hw_mq_t*
+hw_new_mq(hw_cq_t *cq, uint32_t entry_count)
+{
+	ocs_hw_t *hw = cq->eq->hw;
+	hw_mq_t *mq = ocs_malloc(hw->os, sizeof(*mq), OCS_M_ZERO | OCS_M_NOWAIT);
+
+	if (mq != NULL) {
+		mq->cq = cq;
+		mq->type = SLI_QTYPE_MQ;
+		mq->instance = cq->eq->hw->mq_count++;
+		mq->entry_count = entry_count;
+		mq->entry_size = OCS_HW_MQ_DEPTH;
+		mq->queue = &hw->mq[mq->instance];
+
+		if (sli_queue_alloc(&hw->sli, SLI_QTYPE_MQ,
+				    mq->queue,
+				    mq->entry_size,
+				    cq->queue, 0)) {
+			ocs_log_err(hw->os, "MQ allocation failure\n");
+			ocs_free(hw->os, mq, sizeof(*mq));
+			mq = NULL;
+		} else {
+			hw->hw_mq[mq->instance] = mq;
+			ocs_list_add_tail(&cq->q_list, mq);
+			ocs_log_debug(hw->os, "create mq[%2d] id %3d len %4d\n", mq->instance, mq->queue->id,
+				mq->entry_count);
+		}
+	}
+	return mq;
+}
+
+/**
+ * @brief Allocate a new WQ object
+ *
+ * A new WQ object is instantiated
+ *
+ * @param cq pointer to parent CQ object
+ * @param entry_count number of entries in the WQ
+ * @param class WQ class
+ * @param ulp index of chute
+ *
+ * @return pointer to allocated WQ object
+ */
+hw_wq_t*
+hw_new_wq(hw_cq_t *cq, uint32_t entry_count, uint32_t class, uint32_t ulp)
+{
+	ocs_hw_t *hw = cq->eq->hw;
+	hw_wq_t *wq = ocs_malloc(hw->os, sizeof(*wq), OCS_M_ZERO | OCS_M_NOWAIT);
+
+	if (wq != NULL) {
+		wq->hw = cq->eq->hw;
+		wq->cq = cq;
+		wq->type = SLI_QTYPE_WQ;
+		wq->instance = cq->eq->hw->wq_count++;
+		wq->entry_count = entry_count;
+		wq->queue = &hw->wq[wq->instance];
+		wq->ulp = ulp;
+		wq->wqec_set_count = OCS_HW_WQEC_SET_COUNT;
+		wq->wqec_count = wq->wqec_set_count;
+		wq->free_count = wq->entry_count - 1;
+		wq->class = class;
+		ocs_list_init(&wq->pending_list, ocs_hw_wqe_t, link);
+
+		if (sli_queue_alloc(&hw->sli, SLI_QTYPE_WQ, wq->queue, wq->entry_count, cq->queue, ulp)) {
+			ocs_log_err(hw->os, "WQ allocation failure\n");
+			ocs_free(hw->os, wq, sizeof(*wq));
+			wq = NULL;
+		} else {
+			hw->hw_wq[wq->instance] = wq;
+			ocs_list_add_tail(&cq->q_list, wq);
+			ocs_log_debug(hw->os, "create wq[%2d] id %3d len %4d cls %d ulp %d\n", wq->instance, wq->queue->id,
+				wq->entry_count, wq->class, wq->ulp);
+		}
+	}
+	return wq;
+}
+
+/**
+ * @brief Allocate a hw_rq_t object
+ *
+ * Allocate an RQ object, which encapsulates 2 SLI queues (for rq pair)
+ *
+ * @param cq pointer to parent CQ object
+ * @param entry_count number of entries in the RQs
+ * @param ulp ULP index for this RQ
+ *
+ * @return pointer to newly allocated hw_rq_t
+ */
+hw_rq_t*
+hw_new_rq(hw_cq_t *cq, uint32_t entry_count, uint32_t ulp)
+{
+	ocs_hw_t *hw = cq->eq->hw;
+	hw_rq_t *rq = ocs_malloc(hw->os, sizeof(*rq), OCS_M_ZERO | OCS_M_NOWAIT);
+	uint32_t max_hw_rq;
+
+	ocs_hw_get(hw, OCS_HW_MAX_RQ_ENTRIES, &max_hw_rq);
+
+
+	if (rq != NULL) {
+		rq->instance = hw->hw_rq_count++;
+		rq->cq = cq;
+		rq->type = SLI_QTYPE_RQ;
+		rq->ulp = ulp;
+
+		rq->entry_count = OCS_MIN(entry_count, OCS_MIN(max_hw_rq, OCS_HW_RQ_NUM_HDR));
+
+		/* Create the header RQ */
+		ocs_hw_assert(hw->rq_count < ARRAY_SIZE(hw->rq));
+		rq->hdr = &hw->rq[hw->rq_count];
+		rq->hdr_entry_size = OCS_HW_RQ_HEADER_SIZE;
+
+		if (sli_fc_rq_alloc(&hw->sli, rq->hdr,
+				    rq->entry_count,
+				    rq->hdr_entry_size,
+				    cq->queue,
+				    ulp, TRUE)) {
+			ocs_log_err(hw->os, "RQ allocation failure - header\n");
+			ocs_free(hw->os, rq, sizeof(*rq));
+			return NULL;
+		}
+		hw->hw_rq_lookup[hw->rq_count] = rq->instance;	/* Update hw_rq_lookup[] */
+		hw->rq_count++;
+		ocs_log_debug(hw->os, "create rq[%2d] id %3d len %4d hdr  size %4d ulp %d\n",
+			rq->instance, rq->hdr->id, rq->entry_count, rq->hdr_entry_size, rq->ulp);
+
+		/* Create the default data RQ */
+		ocs_hw_assert(hw->rq_count < ARRAY_SIZE(hw->rq));
+		rq->data = &hw->rq[hw->rq_count];
+		rq->data_entry_size = hw->config.rq_default_buffer_size;
+
+		if (sli_fc_rq_alloc(&hw->sli, rq->data,
+				    rq->entry_count,
+				    rq->data_entry_size,
+				    cq->queue,
+				    ulp, FALSE)) {
+			ocs_log_err(hw->os, "RQ allocation failure - first burst\n");
+			ocs_free(hw->os, rq, sizeof(*rq));
+			return NULL;
+		}
+		hw->hw_rq_lookup[hw->rq_count] = rq->instance;	/* Update hw_rq_lookup[] */
+		hw->rq_count++;
+		ocs_log_debug(hw->os, "create rq[%2d] id %3d len %4d data size %4d ulp %d\n", rq->instance,
+			rq->data->id, rq->entry_count, rq->data_entry_size, rq->ulp);
+
+		hw->hw_rq[rq->instance] = rq;
+		ocs_list_add_tail(&cq->q_list, rq);
+
+		rq->rq_tracker = ocs_malloc(hw->os, sizeof(ocs_hw_sequence_t*) *
+					    rq->entry_count, OCS_M_ZERO | OCS_M_NOWAIT);
+		if (rq->rq_tracker == NULL) {
+			ocs_log_err(hw->os, "RQ tracker buf allocation failure\n");
+			return NULL;
+		}
+	}
+	return rq;
+}
+
+
+/**
+ * @brief Allocate a hw_rq_t object SET
+ *
+ * Allocate an RQ object SET, where each element in set
+ * encapsulates 2 SLI queues (for rq pair)
+ *
+ * @param cqs pointers to be associated with RQs.
+ * @param rqs RQ pointers to be returned on success.
+ * @param num_rq_pairs number of rq pairs in the Set.
+ * @param entry_count number of entries in the RQs
+ * @param ulp ULP index for this RQ
+ *
+ * @return 0 in success and -1 on failure.
+ */
+uint32_t
+hw_new_rq_set(hw_cq_t *cqs[], hw_rq_t *rqs[], uint32_t num_rq_pairs, uint32_t entry_count, uint32_t ulp)
+{
+	ocs_hw_t *hw = cqs[0]->eq->hw;
+	hw_rq_t *rq = NULL;
+	sli4_queue_t *qs[SLI_MAX_RQ_SET_COUNT * 2] = { NULL };
+	uint32_t max_hw_rq, i, q_count;
+
+	ocs_hw_get(hw, OCS_HW_MAX_RQ_ENTRIES, &max_hw_rq);
+
+	/* Initialise RQS pointers */
+	for (i = 0; i < num_rq_pairs; i++) {
+		rqs[i] = NULL;
+	}
+
+	for (i = 0, q_count = 0; i < num_rq_pairs; i++, q_count += 2) {
+		rq = ocs_malloc(hw->os, sizeof(*rq), OCS_M_ZERO | OCS_M_NOWAIT);
+		if (rq == NULL)
+			goto error;
+
+		rqs[i] = rq;
+		rq->instance = hw->hw_rq_count++;
+		rq->cq = cqs[i];
+		rq->type = SLI_QTYPE_RQ;
+		rq->ulp = ulp;
+		rq->entry_count = OCS_MIN(entry_count, OCS_MIN(max_hw_rq, OCS_HW_RQ_NUM_HDR));
+
+		/* Header RQ */
+		rq->hdr = &hw->rq[hw->rq_count];
+		rq->hdr_entry_size = OCS_HW_RQ_HEADER_SIZE;
+		hw->hw_rq_lookup[hw->rq_count] = rq->instance;
+		hw->rq_count++;
+		qs[q_count] = rq->hdr;
+
+		/* Data RQ */
+		rq->data = &hw->rq[hw->rq_count];
+		rq->data_entry_size = hw->config.rq_default_buffer_size;
+		hw->hw_rq_lookup[hw->rq_count] = rq->instance;
+		hw->rq_count++;
+		qs[q_count + 1] = rq->data;
+
+		rq->rq_tracker = NULL;
+	}
+
+	if (sli_fc_rq_set_alloc(&hw->sli, num_rq_pairs, qs,
+			    cqs[0]->queue->id,
+			    rqs[0]->entry_count,
+			    rqs[0]->hdr_entry_size,
+			    rqs[0]->data_entry_size,
+			    ulp)) {
+		ocs_log_err(hw->os, "RQ Set allocation failure for base CQ=%d\n", cqs[0]->queue->id);
+		goto error;
+	}
+
+
+	for (i = 0; i < num_rq_pairs; i++) {
+		hw->hw_rq[rqs[i]->instance] = rqs[i];
+		ocs_list_add_tail(&cqs[i]->q_list, rqs[i]);
+		rqs[i]->rq_tracker = ocs_malloc(hw->os, sizeof(ocs_hw_sequence_t*) *
+					    rqs[i]->entry_count, OCS_M_ZERO | OCS_M_NOWAIT);
+		if (rqs[i]->rq_tracker == NULL) {
+			ocs_log_err(hw->os, "RQ tracker buf allocation failure\n");
+			goto error;
+		}
+	}
+
+	return 0;
+
+error:
+	for (i = 0; i < num_rq_pairs; i++) {
+		if (rqs[i] != NULL) {
+			if (rqs[i]->rq_tracker != NULL) {
+				ocs_free(hw->os, rq->rq_tracker,
+					 sizeof(ocs_hw_sequence_t*) * rq->entry_count);
+			}
+			ocs_free(hw->os, rqs[i], sizeof(*rqs[i]));
+		}
+	}
+
+	return -1;
+}
+
+
+/**
+ * @brief Free an EQ object
+ *
+ * The EQ object and any child queue objects are freed
+ *
+ * @param eq pointer to EQ object
+ *
+ * @return none
+ */
+void
+hw_del_eq(hw_eq_t *eq)
+{
+	if (eq != NULL) {
+		hw_cq_t *cq;
+		hw_cq_t *cq_next;
+
+		ocs_list_foreach_safe(&eq->cq_list, cq, cq_next) {
+			hw_del_cq(cq);
+		}
+		ocs_varray_free(eq->wq_array);
+		ocs_list_remove(&eq->hw->eq_list, eq);
+		eq->hw->hw_eq[eq->instance] = NULL;
+		ocs_free(eq->hw->os, eq, sizeof(*eq));
+	}
+}
+
+/**
+ * @brief Free a CQ object
+ *
+ * The CQ object and any child queue objects are freed
+ *
+ * @param cq pointer to CQ object
+ *
+ * @return none
+ */
+void
+hw_del_cq(hw_cq_t *cq)
+{
+	if (cq != NULL) {
+		hw_q_t *q;
+		hw_q_t *q_next;
+
+		ocs_list_foreach_safe(&cq->q_list, q, q_next) {
+			switch(q->type) {
+			case SLI_QTYPE_MQ:
+				hw_del_mq((hw_mq_t*) q);
+				break;
+			case SLI_QTYPE_WQ:
+				hw_del_wq((hw_wq_t*) q);
+				break;
+			case SLI_QTYPE_RQ:
+				hw_del_rq((hw_rq_t*) q);
+				break;
+			default:
+				break;
+			}
+		}
+		ocs_list_remove(&cq->eq->cq_list, cq);
+		cq->eq->hw->hw_cq[cq->instance] = NULL;
+		ocs_free(cq->eq->hw->os, cq, sizeof(*cq));
+	}
+}
+
+/**
+ * @brief Free a MQ object
+ *
+ * The MQ object is freed
+ *
+ * @param mq pointer to MQ object
+ *
+ * @return none
+ */
+void
+hw_del_mq(hw_mq_t *mq)
+{
+	if (mq != NULL) {
+		ocs_list_remove(&mq->cq->q_list, mq);
+		mq->cq->eq->hw->hw_mq[mq->instance] = NULL;
+		ocs_free(mq->cq->eq->hw->os, mq, sizeof(*mq));
+	}
+}
+
+/**
+ * @brief Free a WQ object
+ *
+ * The WQ object is freed
+ *
+ * @param wq pointer to WQ object
+ *
+ * @return none
+ */
+void
+hw_del_wq(hw_wq_t *wq)
+{
+	if (wq != NULL) {
+		ocs_list_remove(&wq->cq->q_list, wq);
+		wq->cq->eq->hw->hw_wq[wq->instance] = NULL;
+		ocs_free(wq->cq->eq->hw->os, wq, sizeof(*wq));
+	}
+}
+
+/**
+ * @brief Free an RQ object
+ *
+ * The RQ object is freed
+ *
+ * @param rq pointer to RQ object
+ *
+ * @return none
+ */
+void
+hw_del_rq(hw_rq_t *rq)
+{
+	ocs_hw_t *hw = rq->cq->eq->hw;
+
+	if (rq != NULL) {
+		/* Free RQ tracker */
+		if (rq->rq_tracker != NULL) {
+			ocs_free(hw->os, rq->rq_tracker, sizeof(ocs_hw_sequence_t*) * rq->entry_count);
+			rq->rq_tracker = NULL;
+		}
+		ocs_list_remove(&rq->cq->q_list, rq);
+		hw->hw_rq[rq->instance] = NULL;
+		ocs_free(hw->os, rq, sizeof(*rq));
+	}
+}
+
+/**
+ * @brief Display HW queue objects
+ *
+ * The HW queue objects are displayed using ocs_log
+ *
+ * @param hw pointer to HW object
+ *
+ * @return none
+ */
+void
+hw_queue_dump(ocs_hw_t *hw)
+{
+	hw_eq_t *eq;
+	hw_cq_t *cq;
+	hw_q_t *q;
+	hw_mq_t *mq;
+	hw_wq_t *wq;
+	hw_rq_t *rq;
+
+	ocs_list_foreach(&hw->eq_list, eq) {
+		ocs_printf("eq[%d] id %2d\n", eq->instance, eq->queue->id);
+		ocs_list_foreach(&eq->cq_list, cq) {
+			ocs_printf("  cq[%d] id %2d current\n", cq->instance, cq->queue->id);
+			ocs_list_foreach(&cq->q_list, q) {
+				switch(q->type) {
+				case SLI_QTYPE_MQ:
+					mq = (hw_mq_t *) q;
+					ocs_printf("    mq[%d] id %2d\n", mq->instance, mq->queue->id);
+					break;
+				case SLI_QTYPE_WQ:
+					wq = (hw_wq_t *) q;
+					ocs_printf("    wq[%d] id %2d\n", wq->instance, wq->queue->id);
+					break;
+				case SLI_QTYPE_RQ:
+					rq = (hw_rq_t *) q;
+					ocs_printf("    rq[%d] hdr id %2d\n", rq->instance, rq->hdr->id);
+					break;
+				default:
+					break;
+				}
+			}
+		}
+	}
+}
+
+/**
+ * @brief Teardown HW queue objects
+ *
+ * The HW queue objects are freed
+ *
+ * @param hw pointer to HW object
+ *
+ * @return none
+ */
+void
+hw_queue_teardown(ocs_hw_t *hw)
+{
+	uint32_t i;
+	hw_eq_t *eq;
+	hw_eq_t *eq_next;
+
+	if (ocs_list_valid(&hw->eq_list)) {
+		ocs_list_foreach_safe(&hw->eq_list, eq, eq_next) {
+			hw_del_eq(eq);
+		}
+	}
+	for (i = 0; i < ARRAY_SIZE(hw->wq_cpu_array); i++) {
+		ocs_varray_free(hw->wq_cpu_array[i]);
+		hw->wq_cpu_array[i] = NULL;
+	}
+	for (i = 0; i < ARRAY_SIZE(hw->wq_class_array); i++) {
+		ocs_varray_free(hw->wq_class_array[i]);
+		hw->wq_class_array[i] = NULL;
+	}
+}
+
+/**
+ * @brief Allocate a WQ to an IO object
+ *
+ * The next work queue index is used to assign a WQ to an IO.
+ *
+ * If wq_steering is OCS_HW_WQ_STEERING_CLASS, a WQ from io->wq_class is
+ * selected.
+ *
+ * If wq_steering is OCS_HW_WQ_STEERING_REQUEST, then a WQ from the EQ that
+ * the IO request came in on is selected.
+ *
+ * If wq_steering is OCS_HW_WQ_STEERING_CPU, then a WQ associted with the
+ * CPU the request is made on is selected.
+ *
+ * @param hw pointer to HW object
+ * @param io pointer to IO object
+ *
+ * @return Return pointer to next WQ
+ */
+hw_wq_t *
+ocs_hw_queue_next_wq(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	hw_eq_t *eq;
+	hw_wq_t *wq = NULL;
+
+	switch(io->wq_steering) {
+	case OCS_HW_WQ_STEERING_CLASS:
+		if (likely(io->wq_class < ARRAY_SIZE(hw->wq_class_array))) {
+			wq = ocs_varray_iter_next(hw->wq_class_array[io->wq_class]);
+		}
+		break;
+	case OCS_HW_WQ_STEERING_REQUEST:
+		eq = io->eq;
+		if (likely(eq != NULL)) {
+			wq = ocs_varray_iter_next(eq->wq_array);
+		}
+		break;
+	case OCS_HW_WQ_STEERING_CPU: {
+		uint32_t cpuidx = ocs_thread_getcpu();
+
+		if (likely(cpuidx < ARRAY_SIZE(hw->wq_cpu_array))) {
+			wq = ocs_varray_iter_next(hw->wq_cpu_array[cpuidx]);
+		}
+		break;
+	}
+	}
+
+	if (unlikely(wq == NULL)) {
+		wq = hw->hw_wq[0];
+	}
+
+	return wq;
+}
+
+/**
+ * @brief Return count of EQs for a queue topology object
+ *
+ * The EQ count for in the HWs queue topology (hw->qtop) object is returned
+ *
+ * @param hw pointer to HW object
+ *
+ * @return count of EQs
+ */
+uint32_t
+ocs_hw_qtop_eq_count(ocs_hw_t *hw)
+{
+	return hw->qtop->entry_counts[QTOP_EQ];
+}
+
+#define TOKEN_LEN		32
+
+/**
+ * @brief return string given a QTOP entry
+ *
+ * @param entry QTOP entry
+ *
+ * @return returns string or "unknown"
+ */
+#if HW_QTOP_DEBUG
+static char *
+qtopentry2s(ocs_hw_qtop_entry_e entry) {
+	switch(entry) {
+	#define P(x)	case x: return #x;
+	P(QTOP_EQ)
+	P(QTOP_CQ)
+	P(QTOP_WQ)
+	P(QTOP_RQ)
+	P(QTOP_MQ)
+	P(QTOP_THREAD_START)
+	P(QTOP_THREAD_END)
+	P(QTOP_LAST)
+	#undef P
+	}
+	return "unknown";
+}
+#endif
+
+/**
+ * @brief Declare token types
+ */
+typedef enum {
+	TOK_LPAREN = 1,
+	TOK_RPAREN,
+	TOK_COLON,
+	TOK_EQUALS,
+	TOK_QUEUE,
+	TOK_ATTR_NAME,
+	TOK_NUMBER,
+	TOK_NUMBER_VALUE,
+	TOK_NUMBER_LIST,
+} tok_type_e;
+
+/**
+ * @brief Declare token sub-types
+ */
+typedef enum {
+	TOK_SUB_EQ = 100,
+	TOK_SUB_CQ,
+	TOK_SUB_RQ,
+	TOK_SUB_MQ,
+	TOK_SUB_WQ,
+	TOK_SUB_LEN,
+	TOK_SUB_CLASS,
+	TOK_SUB_ULP,
+	TOK_SUB_FILTER,
+} tok_subtype_e;
+
+/**
+ * @brief convert queue subtype to QTOP entry
+ *
+ * @param q queue subtype
+ *
+ * @return QTOP entry or 0
+ */
+static ocs_hw_qtop_entry_e
+subtype2qtop(tok_subtype_e q)
+{
+	switch(q) {
+	case TOK_SUB_EQ:	return QTOP_EQ;
+	case TOK_SUB_CQ:	return QTOP_CQ;
+	case TOK_SUB_RQ:	return QTOP_RQ;
+	case TOK_SUB_MQ:	return QTOP_MQ;
+	case TOK_SUB_WQ:	return QTOP_WQ;
+	default:
+		break;
+	}
+	return 0;
+}
+
+/**
+ * @brief Declare token object
+ */
+typedef struct {
+	tok_type_e type;
+	tok_subtype_e subtype;
+	char string[TOKEN_LEN];
+} tok_t;
+
+/**
+ * @brief Declare token array object
+ */
+typedef struct {
+	tok_t *tokens;			/* Pointer to array of tokens */
+	uint32_t alloc_count;		/* Number of tokens in the array */
+	uint32_t inuse_count;		/* Number of tokens posted to array */
+	uint32_t iter_idx;		/* Iterator index */
+} tokarray_t;
+
+/**
+ * @brief Declare token match structure
+ */
+typedef struct {
+	char *s;
+	tok_type_e type;
+	tok_subtype_e subtype;
+} tokmatch_t;
+
+/**
+ * @brief test if character is ID start character
+ *
+ * @param c character to test
+ *
+ * @return TRUE if character is an ID start character
+ */
+static int32_t
+idstart(int c)
+{
+	return	isalpha(c) || (c == '_') || (c == '$');
+}
+
+/**
+ * @brief test if character is an ID character
+ *
+ * @param c character to test
+ *
+ * @return TRUE if character is an ID character
+ */
+static int32_t
+idchar(int c)
+{
+	return idstart(c) || ocs_isdigit(c);
+}
+
+/**
+ * @brief Declare single character matches
+ */
+static tokmatch_t cmatches[] = {
+	{"(", TOK_LPAREN},
+	{")", TOK_RPAREN},
+	{":", TOK_COLON},
+	{"=", TOK_EQUALS},
+};
+
+/**
+ * @brief Declare identifier match strings
+ */
+static tokmatch_t smatches[] = {
+	{"eq", TOK_QUEUE, TOK_SUB_EQ},
+	{"cq", TOK_QUEUE, TOK_SUB_CQ},
+	{"rq", TOK_QUEUE, TOK_SUB_RQ},
+	{"mq", TOK_QUEUE, TOK_SUB_MQ},
+	{"wq", TOK_QUEUE, TOK_SUB_WQ},
+	{"len", TOK_ATTR_NAME, TOK_SUB_LEN},
+	{"class", TOK_ATTR_NAME, TOK_SUB_CLASS},
+	{"ulp", TOK_ATTR_NAME, TOK_SUB_ULP},
+	{"filter", TOK_ATTR_NAME, TOK_SUB_FILTER},
+};
+
+/**
+ * @brief Scan string and return next token
+ *
+ * The string is scanned and the next token is returned
+ *
+ * @param s input string to scan
+ * @param tok pointer to place scanned token
+ *
+ * @return pointer to input string following scanned token, or NULL
+ */
+static const char *
+tokenize(const char *s, tok_t *tok)
+{
+	uint32_t i;
+
+	memset(tok, 0, sizeof(*tok));
+
+	/* Skip over whitespace */
+	while (*s && ocs_isspace(*s)) {
+		s++;
+	}
+
+	/* Return if nothing left in this string */
+	if (*s == 0) {
+		return NULL;
+	}
+
+	/* Look for single character matches */
+	for (i = 0; i < ARRAY_SIZE(cmatches); i++) {
+		if (cmatches[i].s[0] == *s) {
+			tok->type = cmatches[i].type;
+			tok->subtype = cmatches[i].subtype;
+			tok->string[0] = *s++;
+			return s;
+		}
+	}
+
+	/* Scan for a hex number or decimal */
+	if ((s[0] == '0') && ((s[1] == 'x') || (s[1] == 'X'))) {
+		char *p = tok->string;
+
+		tok->type = TOK_NUMBER;
+
+		*p++ = *s++;
+		*p++ = *s++;
+		while ((*s == '.') || ocs_isxdigit(*s)) {
+			if ((p - tok->string) < (int32_t)sizeof(tok->string)) {
+				*p++ = *s;
+			}
+			if (*s == ',') {
+				tok->type = TOK_NUMBER_LIST;
+			}
+			s++;
+		}
+		*p = 0;
+		return s;
+	} else if (ocs_isdigit(*s)) {
+		char *p = tok->string;
+
+		tok->type = TOK_NUMBER;
+		while ((*s == ',') || ocs_isdigit(*s)) {
+			if ((p - tok->string) < (int32_t)sizeof(tok->string)) {
+				*p++ = *s;
+			}
+			if (*s == ',') {
+				tok->type = TOK_NUMBER_LIST;
+			}
+			s++;
+		}
+		*p = 0;
+		return s;
+	}
+
+	/* Scan for an ID */
+	if (idstart(*s)) {
+		char *p = tok->string;
+
+		for (*p++ = *s++; idchar(*s); s++) {
+			if ((p - tok->string) < TOKEN_LEN) {
+				*p++ = *s;
+			}
+		}
+
+		/* See if this is a $ number value */
+		if (tok->string[0] == '$') {
+			tok->type = TOK_NUMBER_VALUE;
+		} else {
+			/* Look for a string match */
+			for (i = 0; i < ARRAY_SIZE(smatches); i++) {
+				if (strcmp(smatches[i].s, tok->string) == 0) {
+					tok->type = smatches[i].type;
+					tok->subtype = smatches[i].subtype;
+					return s;
+				}
+			}
+		}
+	}
+	return s;
+}
+
+/**
+ * @brief convert token type to string
+ *
+ * @param type token type
+ *
+ * @return string, or "unknown"
+ */
+static const char *
+token_type2s(tok_type_e type)
+{
+	switch(type) {
+	#define P(x)	case x: return #x;
+	P(TOK_LPAREN)
+	P(TOK_RPAREN)
+	P(TOK_COLON)
+	P(TOK_EQUALS)
+	P(TOK_QUEUE)
+	P(TOK_ATTR_NAME)
+	P(TOK_NUMBER)
+	P(TOK_NUMBER_VALUE)
+	P(TOK_NUMBER_LIST)
+	#undef P
+	}
+	return "unknown";
+}
+
+/**
+ * @brief convert token sub-type to string
+ *
+ * @param subtype token sub-type
+ *
+ * @return string, or "unknown"
+ */
+static const char *
+token_subtype2s(tok_subtype_e subtype)
+{
+	switch(subtype) {
+	#define P(x)	case x: return #x;
+	P(TOK_SUB_EQ)
+	P(TOK_SUB_CQ)
+	P(TOK_SUB_RQ)
+	P(TOK_SUB_MQ)
+	P(TOK_SUB_WQ)
+	P(TOK_SUB_LEN)
+	P(TOK_SUB_CLASS)
+	P(TOK_SUB_ULP)
+	P(TOK_SUB_FILTER)
+	#undef P
+	}
+	return "";
+}
+
+/**
+ * @brief Generate syntax error message
+ *
+ * A syntax error message is found, the input tokens are dumped up to and including
+ * the token that failed as indicated by the current iterator index.
+ *
+ * @param hw pointer to HW object
+ * @param tokarray pointer to token array object
+ *
+ * @return none
+ */
+static void
+tok_syntax(ocs_hw_t *hw, tokarray_t *tokarray)
+{
+	uint32_t i;
+	tok_t *tok;
+
+	ocs_log_test(hw->os, "Syntax error:\n");
+
+	for (i = 0, tok = tokarray->tokens; (i <= tokarray->inuse_count); i++, tok++) {
+		ocs_log_test(hw->os, "%s [%2d]    %-16s %-16s %s\n", (i == tokarray->iter_idx) ? ">>>" : "   ", i,
+			token_type2s(tok->type), token_subtype2s(tok->subtype), tok->string);
+	}
+}
+
+/**
+ * @brief parse a number
+ *
+ * Parses tokens of type TOK_NUMBER and TOK_NUMBER_VALUE, returning a numeric value
+ *
+ * @param hw pointer to HW object
+ * @param qtop pointer to QTOP object
+ * @param tok pointer to token to parse
+ *
+ * @return numeric value
+ */
+static uint32_t
+tok_getnumber(ocs_hw_t *hw, ocs_hw_qtop_t *qtop, tok_t *tok)
+{
+	uint32_t rval = 0;
+	uint32_t num_cpus = ocs_get_num_cpus();
+
+	switch(tok->type) {
+	case TOK_NUMBER_VALUE:
+		if (ocs_strcmp(tok->string, "$ncpu") == 0) {
+			rval = num_cpus;
+		} else if (ocs_strcmp(tok->string, "$ncpu1") == 0) {
+			rval = num_cpus - 1;
+		} else if (ocs_strcmp(tok->string, "$nwq") == 0) {
+			if (hw != NULL) {
+				rval = hw->config.n_wq;
+			}
+		} else if (ocs_strcmp(tok->string, "$maxmrq") == 0) {
+			rval = MIN(num_cpus, OCS_HW_MAX_MRQS);
+		} else if (ocs_strcmp(tok->string, "$nulp") == 0) {
+			rval = hw->ulp_max - hw->ulp_start + 1;
+		} else if ((qtop->rptcount_idx > 0) && ocs_strcmp(tok->string, "$rpt0") == 0) {
+			rval = qtop->rptcount[qtop->rptcount_idx-1];
+		} else if ((qtop->rptcount_idx > 1) && ocs_strcmp(tok->string, "$rpt1") == 0) {
+			rval = qtop->rptcount[qtop->rptcount_idx-2];
+		} else if ((qtop->rptcount_idx > 2) && ocs_strcmp(tok->string, "$rpt2") == 0) {
+			rval = qtop->rptcount[qtop->rptcount_idx-3];
+		} else if ((qtop->rptcount_idx > 3) && ocs_strcmp(tok->string, "$rpt3") == 0) {
+			rval = qtop->rptcount[qtop->rptcount_idx-4];
+		} else {
+			rval = ocs_strtoul(tok->string, 0, 0);
+		}
+		break;
+	case TOK_NUMBER:
+		rval = ocs_strtoul(tok->string, 0, 0);
+		break;
+	default:
+		break;
+	}
+	return rval;
+}
+
+
+/**
+ * @brief parse an array of tokens
+ *
+ * The tokens are semantically parsed, to generate QTOP entries.
+ *
+ * @param hw pointer to HW object
+ * @param tokarray array array of tokens
+ * @param qtop ouptut QTOP object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+static int32_t
+parse_topology(ocs_hw_t *hw, tokarray_t *tokarray, ocs_hw_qtop_t *qtop)
+{
+	ocs_hw_qtop_entry_t *qt = qtop->entries + qtop->inuse_count;
+	tok_t *tok;
+
+	for (; (tokarray->iter_idx < tokarray->inuse_count) &&
+	     ((tok = &tokarray->tokens[tokarray->iter_idx]) != NULL); ) {
+		if (qtop->inuse_count >= qtop->alloc_count) {
+			return -1;
+		}
+
+		qt = qtop->entries + qtop->inuse_count;
+
+		switch (tok[0].type)
+		{
+		case TOK_QUEUE:
+			qt->entry = subtype2qtop(tok[0].subtype);
+			qt->set_default = FALSE;
+			qt->len = 0;
+			qt->class = 0;
+			qtop->inuse_count++;
+
+			tokarray->iter_idx++;		/* Advance current token index */
+
+			/* Parse for queue attributes, possibly multiple instances */
+			while ((tokarray->iter_idx + 4) <= tokarray->inuse_count) {
+				tok = &tokarray->tokens[tokarray->iter_idx];
+				if(	(tok[0].type == TOK_COLON) &&
+					(tok[1].type == TOK_ATTR_NAME) &&
+					(tok[2].type == TOK_EQUALS) &&
+					((tok[3].type == TOK_NUMBER) ||
+					 (tok[3].type == TOK_NUMBER_VALUE) ||
+					 (tok[3].type == TOK_NUMBER_LIST))) {
+
+					switch (tok[1].subtype) {
+					case TOK_SUB_LEN:
+						qt->len = tok_getnumber(hw, qtop, &tok[3]);
+						break;
+
+					case TOK_SUB_CLASS:
+						qt->class = tok_getnumber(hw, qtop, &tok[3]);
+						break;
+
+					case TOK_SUB_ULP:
+						qt->ulp = tok_getnumber(hw, qtop, &tok[3]);
+						break;
+
+					case TOK_SUB_FILTER:
+						if (tok[3].type == TOK_NUMBER_LIST) {
+							uint32_t mask = 0;
+							char *p = tok[3].string;
+
+							while ((p != NULL) && *p) {
+								uint32_t v;
+
+								v = ocs_strtoul(p, 0, 0);
+								if (v < 32) {
+									mask |= (1U << v);
+								}
+
+								p = ocs_strchr(p, ',');
+								if (p != NULL) {
+									p++;
+								}
+							}
+							qt->filter_mask = mask;
+						} else {
+							qt->filter_mask = (1U << tok_getnumber(hw, qtop, &tok[3]));
+						}
+						break;
+					default:
+						break;
+					}
+					/* Advance current token index */
+					tokarray->iter_idx += 4;
+				} else {
+					break;
+				}
+			}
+			qtop->entry_counts[qt->entry]++;
+			break;
+
+		case TOK_ATTR_NAME:
+			if (	((tokarray->iter_idx + 5) <= tokarray->inuse_count) &&
+				(tok[1].type == TOK_COLON) &&
+				(tok[2].type == TOK_QUEUE) &&
+				(tok[3].type == TOK_EQUALS) &&
+				((tok[4].type == TOK_NUMBER) || (tok[4].type == TOK_NUMBER_VALUE))) {
+				qt->entry = subtype2qtop(tok[2].subtype);
+				qt->set_default = TRUE;
+				switch(tok[0].subtype) {
+				case TOK_SUB_LEN:
+					qt->len = tok_getnumber(hw, qtop, &tok[4]);
+					break;
+				case TOK_SUB_CLASS:
+					qt->class = tok_getnumber(hw, qtop, &tok[4]);
+					break;
+				case TOK_SUB_ULP:
+					qt->ulp = tok_getnumber(hw, qtop, &tok[4]);
+					break;
+				default:
+					break;
+				}
+				qtop->inuse_count++;
+				tokarray->iter_idx += 5;
+			} else {
+				tok_syntax(hw, tokarray);
+				return -1;
+			}
+			break;
+
+		case TOK_NUMBER:
+		case TOK_NUMBER_VALUE: {
+			uint32_t rpt_count = 1;
+			uint32_t i;
+
+			rpt_count = tok_getnumber(hw, qtop, tok);
+
+			if (tok[1].type == TOK_LPAREN) {
+				uint32_t iter_idx_save;
+
+				tokarray->iter_idx += 2;
+
+				/* save token array iteration index */
+				iter_idx_save = tokarray->iter_idx;
+
+				for (i = 0; i < rpt_count; i++) {
+					uint32_t rptcount_idx = qtop->rptcount_idx;
+
+					if (qtop->rptcount_idx < ARRAY_SIZE(qtop->rptcount)) {
+						qtop->rptcount[qtop->rptcount_idx++] = i;
+					}
+
+					/* restore token array iteration index */
+					tokarray->iter_idx = iter_idx_save;
+
+					/* parse, append to qtop */
+					parse_topology(hw, tokarray, qtop);
+
+					qtop->rptcount_idx = rptcount_idx;
+				}
+			}
+			break;
+		}
+
+		case TOK_RPAREN:
+			tokarray->iter_idx++;
+			return 0;
+
+		default:
+			tok_syntax(hw, tokarray);
+			return -1;
+		}
+	}
+	return 0;
+}
+
+/**
+ * @brief Parse queue topology string
+ *
+ * The queue topology object is allocated, and filled with the results of parsing the
+ * passed in queue topology string
+ *
+ * @param hw pointer to HW object
+ * @param qtop_string input queue topology string
+ *
+ * @return pointer to allocated QTOP object, or NULL if there was an error
+ */
+ocs_hw_qtop_t *
+ocs_hw_qtop_parse(ocs_hw_t *hw, const char *qtop_string)
+{
+	ocs_hw_qtop_t *qtop;
+	tokarray_t tokarray;
+	const char *s;
+#if HW_QTOP_DEBUG
+	uint32_t i;
+	ocs_hw_qtop_entry_t *qt;
+#endif
+
+	ocs_log_debug(hw->os, "queue topology: %s\n", qtop_string);
+
+	/* Allocate a token array */
+	tokarray.tokens = ocs_malloc(hw->os, MAX_TOKENS * sizeof(*tokarray.tokens), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (tokarray.tokens == NULL) {
+		return NULL;
+	}
+	tokarray.alloc_count = MAX_TOKENS;
+	tokarray.inuse_count = 0;
+	tokarray.iter_idx = 0;
+
+	/* Parse the tokens */
+	for (s = qtop_string; (tokarray.inuse_count < tokarray.alloc_count) &&
+	     ((s = tokenize(s, &tokarray.tokens[tokarray.inuse_count]))) != NULL; ) {
+		tokarray.inuse_count++;;
+	}
+
+	/* Allocate a queue topology structure */
+	qtop = ocs_malloc(hw->os, sizeof(*qtop), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (qtop == NULL) {
+		ocs_free(hw->os, tokarray.tokens, MAX_TOKENS * sizeof(*tokarray.tokens));
+		ocs_log_err(hw->os, "malloc qtop failed\n");
+		return NULL;
+	}
+	qtop->os = hw->os;
+
+	/* Allocate queue topology entries */
+	qtop->entries = ocs_malloc(hw->os, OCS_HW_MAX_QTOP_ENTRIES*sizeof(*qtop->entries), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (qtop->entries == NULL) {
+		ocs_log_err(hw->os, "malloc qtop entries failed\n");
+		ocs_free(hw->os, qtop, sizeof(*qtop));
+		ocs_free(hw->os, tokarray.tokens, MAX_TOKENS * sizeof(*tokarray.tokens));
+		return NULL;
+	}
+	qtop->alloc_count = OCS_HW_MAX_QTOP_ENTRIES;
+	qtop->inuse_count = 0;
+
+	/* Parse the tokens */
+	parse_topology(hw, &tokarray, qtop);
+#if HW_QTOP_DEBUG
+	for (i = 0, qt = qtop->entries; i < qtop->inuse_count; i++, qt++) {
+		ocs_log_debug(hw->os, "entry %s set_df %d len %4d class %d ulp %d\n", qtopentry2s(qt->entry), qt->set_default, qt->len,
+		       qt->class, qt->ulp);
+	}
+#endif
+
+	/* Free the tokens array */
+	ocs_free(hw->os, tokarray.tokens, MAX_TOKENS * sizeof(*tokarray.tokens));
+
+	return qtop;
+}
+
+/**
+ * @brief free queue topology object
+ *
+ * @param qtop pointer to QTOP object
+ *
+ * @return none
+ */
+void
+ocs_hw_qtop_free(ocs_hw_qtop_t *qtop)
+{
+	if (qtop != NULL) {
+		if (qtop->entries != NULL) {
+			ocs_free(qtop->os, qtop->entries, qtop->alloc_count*sizeof(*qtop->entries));
+		}
+		ocs_free(qtop->os, qtop, sizeof(*qtop));
+	}
+}
+
+/* Uncomment this to turn on RQ debug */
+// #define ENABLE_DEBUG_RQBUF
+
+static int32_t ocs_hw_rqpair_find(ocs_hw_t *hw, uint16_t rq_id);
+static ocs_hw_sequence_t * ocs_hw_rqpair_get(ocs_hw_t *hw, uint16_t rqindex, uint16_t bufindex);
+static int32_t ocs_hw_rqpair_put(ocs_hw_t *hw, ocs_hw_sequence_t *seq);
+static ocs_hw_rtn_e ocs_hw_rqpair_auto_xfer_rdy_buffer_sequence_reset(ocs_hw_t *hw, ocs_hw_sequence_t *seq);
+
+/**
+ * @brief Process receive queue completions for RQ Pair mode.
+ *
+ * @par Description
+ * RQ completions are processed. In RQ pair mode, a single header and single payload
+ * buffer are received, and passed to the function that has registered for unsolicited
+ * callbacks.
+ *
+ * @param hw Hardware context.
+ * @param cq Pointer to HW completion queue.
+ * @param cqe Completion queue entry.
+ *
+ * @return Returns 0 for success, or a negative error code value for failure.
+ */
+
+int32_t
+ocs_hw_rqpair_process_rq(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe)
+{
+	uint16_t rq_id;
+	uint32_t index;
+	int32_t rqindex;
+	int32_t	 rq_status;
+	uint32_t h_len;
+	uint32_t p_len;
+	ocs_hw_sequence_t *seq;
+
+	rq_status = sli_fc_rqe_rqid_and_index(&hw->sli, cqe, &rq_id, &index);
+	if (0 != rq_status) {
+		switch (rq_status) {
+		case SLI4_FC_ASYNC_RQ_BUF_LEN_EXCEEDED:
+		case SLI4_FC_ASYNC_RQ_DMA_FAILURE:
+			/* just get RQ buffer then return to chip */
+			rqindex = ocs_hw_rqpair_find(hw, rq_id);
+			if (rqindex < 0) {
+				ocs_log_test(hw->os, "status=%#x: rq_id lookup failed for id=%#x\n",
+					     rq_status, rq_id);
+				break;
+			}
+
+			/* get RQ buffer */
+			seq = ocs_hw_rqpair_get(hw, rqindex, index);
+
+			/* return to chip */
+			if (ocs_hw_rqpair_sequence_free(hw, seq)) {
+				ocs_log_test(hw->os, "status=%#x, failed to return buffers to RQ\n",
+					     rq_status);
+				break;
+			}
+			break;
+		case SLI4_FC_ASYNC_RQ_INSUFF_BUF_NEEDED:
+		case SLI4_FC_ASYNC_RQ_INSUFF_BUF_FRM_DISC:
+			/* since RQ buffers were not consumed, cannot return them to chip */
+			/* fall through */
+			ocs_log_debug(hw->os, "Warning: RCQE status=%#x, \n", rq_status);
+		default:
+			break;
+		}
+		return -1;
+	}
+
+	rqindex = ocs_hw_rqpair_find(hw, rq_id);
+	if (rqindex < 0) {
+		ocs_log_test(hw->os, "Error: rq_id lookup failed for id=%#x\n", rq_id);
+		return -1;
+	}
+
+	OCS_STAT({ hw_rq_t *rq = hw->hw_rq[hw->hw_rq_lookup[rqindex]]; rq->use_count++; rq->hdr_use_count++;
+		 rq->payload_use_count++;})
+
+	seq = ocs_hw_rqpair_get(hw, rqindex, index);
+	ocs_hw_assert(seq != NULL);
+
+	seq->hw = hw;
+	seq->auto_xrdy = 0;
+	seq->out_of_xris = 0;
+	seq->xri = 0;
+	seq->hio = NULL;
+
+	sli_fc_rqe_length(&hw->sli, cqe, &h_len, &p_len);
+	seq->header->dma.len = h_len;
+	seq->payload->dma.len = p_len;
+	seq->fcfi = sli_fc_rqe_fcfi(&hw->sli, cqe);
+	seq->hw_priv = cq->eq;
+
+	/* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */
+	if (hw->config.bounce) {
+		fc_header_t *hdr = seq->header->dma.virt;
+		uint32_t s_id = fc_be24toh(hdr->s_id);
+		uint32_t d_id = fc_be24toh(hdr->d_id);
+		uint32_t ox_id =  ocs_be16toh(hdr->ox_id);
+		if (hw->callback.bounce != NULL) {
+			(*hw->callback.bounce)(ocs_hw_unsol_process_bounce, seq, s_id, d_id, ox_id);
+		}
+	} else {
+		hw->callback.unsolicited(hw->args.unsolicited, seq);
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Process receive queue completions for RQ Pair mode - Auto xfer rdy
+ *
+ * @par Description
+ * RQ completions are processed. In RQ pair mode, a single header and single payload
+ * buffer are received, and passed to the function that has registered for unsolicited
+ * callbacks.
+ *
+ * @param hw Hardware context.
+ * @param cq Pointer to HW completion queue.
+ * @param cqe Completion queue entry.
+ *
+ * @return Returns 0 for success, or a negative error code value for failure.
+ */
+
+int32_t
+ocs_hw_rqpair_process_auto_xfr_rdy_cmd(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe)
+{
+	/* Seems silly to call a SLI function to decode - use the structure directly for performance */
+	sli4_fc_optimized_write_cmd_cqe_t *opt_wr = (sli4_fc_optimized_write_cmd_cqe_t*)cqe;
+	uint16_t rq_id;
+	uint32_t index;
+	int32_t rqindex;
+	int32_t	 rq_status;
+	uint32_t h_len;
+	uint32_t p_len;
+	ocs_hw_sequence_t *seq;
+	uint8_t axr_lock_taken = 0;
+#if defined(OCS_DISC_SPIN_DELAY)
+	uint32_t 	delay = 0;
+	char 		prop_buf[32];
+#endif
+
+	rq_status = sli_fc_rqe_rqid_and_index(&hw->sli, cqe, &rq_id, &index);
+	if (0 != rq_status) {
+		switch (rq_status) {
+		case SLI4_FC_ASYNC_RQ_BUF_LEN_EXCEEDED:
+		case SLI4_FC_ASYNC_RQ_DMA_FAILURE:
+			/* just get RQ buffer then return to chip */
+			rqindex = ocs_hw_rqpair_find(hw, rq_id);
+			if (rqindex < 0) {
+				ocs_log_err(hw->os, "status=%#x: rq_id lookup failed for id=%#x\n",
+					    rq_status, rq_id);
+				break;
+			}
+
+			/* get RQ buffer */
+			seq = ocs_hw_rqpair_get(hw, rqindex, index);
+
+			/* return to chip */
+			if (ocs_hw_rqpair_sequence_free(hw, seq)) {
+				ocs_log_err(hw->os, "status=%#x, failed to return buffers to RQ\n",
+					    rq_status);
+				break;
+			}
+			break;
+		case SLI4_FC_ASYNC_RQ_INSUFF_BUF_NEEDED:
+		case SLI4_FC_ASYNC_RQ_INSUFF_BUF_FRM_DISC:
+			/* since RQ buffers were not consumed, cannot return them to chip */
+			ocs_log_debug(hw->os, "Warning: RCQE status=%#x, \n", rq_status);
+			/* fall through */
+		default:
+			break;
+		}
+		return -1;
+	}
+
+	rqindex = ocs_hw_rqpair_find(hw, rq_id);
+	if (rqindex < 0) {
+		ocs_log_err(hw->os, "Error: rq_id lookup failed for id=%#x\n", rq_id);
+		return -1;
+	}
+
+	OCS_STAT({ hw_rq_t *rq = hw->hw_rq[hw->hw_rq_lookup[rqindex]]; rq->use_count++; rq->hdr_use_count++;
+		 rq->payload_use_count++;})
+
+	seq = ocs_hw_rqpair_get(hw, rqindex, index);
+	ocs_hw_assert(seq != NULL);
+
+	seq->hw = hw;
+	seq->auto_xrdy = opt_wr->agxr;
+	seq->out_of_xris = opt_wr->oox;
+	seq->xri = opt_wr->xri;
+	seq->hio = NULL;
+
+	sli_fc_rqe_length(&hw->sli, cqe, &h_len, &p_len);
+	seq->header->dma.len = h_len;
+	seq->payload->dma.len = p_len;
+	seq->fcfi = sli_fc_rqe_fcfi(&hw->sli, cqe);
+	seq->hw_priv = cq->eq;
+
+	if (seq->auto_xrdy) {
+		fc_header_t *fc_hdr = seq->header->dma.virt;
+
+		seq->hio = ocs_hw_io_lookup(hw, seq->xri);
+		ocs_lock(&seq->hio->axr_lock);
+		axr_lock_taken = 1;
+
+		/* save the FCFI, src_id, dest_id and ox_id because we need it for the sequence object when the data comes. */
+		seq->hio->axr_buf->fcfi = seq->fcfi;
+		seq->hio->axr_buf->hdr.ox_id = fc_hdr->ox_id;
+		seq->hio->axr_buf->hdr.s_id = fc_hdr->s_id;
+		seq->hio->axr_buf->hdr.d_id = fc_hdr->d_id;
+		seq->hio->axr_buf->cmd_cqe = 1;
+
+		/*
+		 * Since auto xfer rdy is used for this IO, then clear the sequence
+		 * initiative bit in the header so that the upper layers wait for the
+		 * data. This should flow exactly like the first burst case.
+		 */
+		fc_hdr->f_ctl &= fc_htobe24(~FC_FCTL_SEQUENCE_INITIATIVE);
+
+		/* If AXR CMD CQE came before previous TRSP CQE of same XRI */
+		if (seq->hio->type == OCS_HW_IO_TARGET_RSP) {
+			seq->hio->axr_buf->call_axr_cmd = 1;
+			seq->hio->axr_buf->cmd_seq = seq;
+			goto exit_ocs_hw_rqpair_process_auto_xfr_rdy_cmd;
+		}
+	}
+
+	/* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */
+	if (hw->config.bounce) {
+		fc_header_t *hdr = seq->header->dma.virt;
+		uint32_t s_id = fc_be24toh(hdr->s_id);
+		uint32_t d_id = fc_be24toh(hdr->d_id);
+		uint32_t ox_id =  ocs_be16toh(hdr->ox_id);
+		if (hw->callback.bounce != NULL) {
+			(*hw->callback.bounce)(ocs_hw_unsol_process_bounce, seq, s_id, d_id, ox_id);
+		}
+	} else {
+		hw->callback.unsolicited(hw->args.unsolicited, seq);
+	}
+
+	if (seq->auto_xrdy) {
+		/* If data cqe came before cmd cqe in out of order in case of AXR */
+		if(seq->hio->axr_buf->data_cqe == 1) {
+
+#if defined(OCS_DISC_SPIN_DELAY)
+			if (ocs_get_property("disk_spin_delay", prop_buf, sizeof(prop_buf)) == 0) {
+				delay = ocs_strtoul(prop_buf, 0, 0);
+				ocs_udelay(delay);
+			}
+#endif
+			/* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */
+			if (hw->config.bounce) {
+				fc_header_t *hdr = seq->header->dma.virt;
+				uint32_t s_id = fc_be24toh(hdr->s_id);
+				uint32_t d_id = fc_be24toh(hdr->d_id);
+				uint32_t ox_id =  ocs_be16toh(hdr->ox_id);
+				if (hw->callback.bounce != NULL) {
+					(*hw->callback.bounce)(ocs_hw_unsol_process_bounce, &seq->hio->axr_buf->seq, s_id, d_id, ox_id);
+				}
+			} else {
+				hw->callback.unsolicited(hw->args.unsolicited, &seq->hio->axr_buf->seq);
+			}
+		}
+	}
+
+exit_ocs_hw_rqpair_process_auto_xfr_rdy_cmd:
+	if(axr_lock_taken) {
+		ocs_unlock(&seq->hio->axr_lock);
+	}
+	return 0;
+}
+
+/**
+ * @brief Process CQ completions for Auto xfer rdy data phases.
+ *
+ * @par Description
+ * The data is DMA'd into the data buffer posted to the SGL prior to the XRI
+ * being assigned to an IO. When the completion is received, All of the data
+ * is in the single buffer.
+ *
+ * @param hw Hardware context.
+ * @param cq Pointer to HW completion queue.
+ * @param cqe Completion queue entry.
+ *
+ * @return Returns 0 for success, or a negative error code value for failure.
+ */
+
+int32_t
+ocs_hw_rqpair_process_auto_xfr_rdy_data(ocs_hw_t *hw, hw_cq_t *cq, uint8_t *cqe)
+{
+	/* Seems silly to call a SLI function to decode - use the structure directly for performance */
+	sli4_fc_optimized_write_data_cqe_t *opt_wr = (sli4_fc_optimized_write_data_cqe_t*)cqe;
+	ocs_hw_sequence_t *seq;
+	ocs_hw_io_t *io;
+	ocs_hw_auto_xfer_rdy_buffer_t *buf;
+#if defined(OCS_DISC_SPIN_DELAY)
+	uint32_t 	delay = 0;
+	char 		prop_buf[32];
+#endif
+	/* Look up the IO */
+	io = ocs_hw_io_lookup(hw, opt_wr->xri);
+	ocs_lock(&io->axr_lock);
+	buf = io->axr_buf;
+	buf->data_cqe = 1;
+	seq = &buf->seq;
+	seq->hw = hw;
+	seq->auto_xrdy = 1;
+	seq->out_of_xris = 0;
+	seq->xri = opt_wr->xri;
+	seq->hio = io;
+	seq->header = &buf->header;
+	seq->payload = &buf->payload;
+
+	seq->header->dma.len = sizeof(fc_header_t);
+	seq->payload->dma.len = opt_wr->total_data_placed;
+	seq->fcfi = buf->fcfi;
+	seq->hw_priv = cq->eq;
+
+
+	if (opt_wr->status == SLI4_FC_WCQE_STATUS_SUCCESS) {
+		seq->status = OCS_HW_UNSOL_SUCCESS;
+	} else if (opt_wr->status == SLI4_FC_WCQE_STATUS_REMOTE_STOP) {
+		seq->status = OCS_HW_UNSOL_ABTS_RCVD;
+	} else {
+		seq->status = OCS_HW_UNSOL_ERROR;
+	}
+
+ 	/* If AXR CMD CQE came before previous TRSP CQE of same XRI */
+	if(io->type == OCS_HW_IO_TARGET_RSP) {
+		io->axr_buf->call_axr_data = 1;
+		goto exit_ocs_hw_rqpair_process_auto_xfr_rdy_data;
+	}
+
+	if(!buf->cmd_cqe) {
+		/* if data cqe came before cmd cqe, return here, cmd cqe will handle */
+		goto exit_ocs_hw_rqpair_process_auto_xfr_rdy_data;
+	}
+#if defined(OCS_DISC_SPIN_DELAY)
+	if (ocs_get_property("disk_spin_delay", prop_buf, sizeof(prop_buf)) == 0) {
+		delay = ocs_strtoul(prop_buf, 0, 0);
+		ocs_udelay(delay);
+	}
+#endif
+
+	/* bounce enabled, single RQ, we snoop the ox_id to choose the cpuidx */
+	if (hw->config.bounce) {
+		fc_header_t *hdr = seq->header->dma.virt;
+		uint32_t s_id = fc_be24toh(hdr->s_id);
+		uint32_t d_id = fc_be24toh(hdr->d_id);
+		uint32_t ox_id =  ocs_be16toh(hdr->ox_id);
+		if (hw->callback.bounce != NULL) {
+			(*hw->callback.bounce)(ocs_hw_unsol_process_bounce, seq, s_id, d_id, ox_id);
+		}
+	} else {
+		hw->callback.unsolicited(hw->args.unsolicited, seq);
+	}
+
+exit_ocs_hw_rqpair_process_auto_xfr_rdy_data:
+	ocs_unlock(&io->axr_lock);
+	return 0;
+}
+
+/**
+ * @brief Return pointer to RQ buffer entry.
+ *
+ * @par Description
+ * Returns a pointer to the RQ buffer entry given by @c rqindex and @c bufindex.
+ *
+ * @param hw Hardware context.
+ * @param rqindex Index of the RQ that is being processed.
+ * @param bufindex Index into the RQ that is being processed.
+ *
+ * @return Pointer to the sequence structure, or NULL otherwise.
+ */
+static ocs_hw_sequence_t *
+ocs_hw_rqpair_get(ocs_hw_t *hw, uint16_t rqindex, uint16_t bufindex)
+{
+	sli4_queue_t *rq_hdr = &hw->rq[rqindex];
+	sli4_queue_t *rq_payload = &hw->rq[rqindex+1];
+	ocs_hw_sequence_t *seq = NULL;
+	hw_rq_t *rq = hw->hw_rq[hw->hw_rq_lookup[rqindex]];
+
+#if defined(ENABLE_DEBUG_RQBUF)
+	uint64_t rqbuf_debug_value = 0xdead0000 | ((rq->id & 0xf) << 12) | (bufindex & 0xfff);
+#endif
+
+	if (bufindex >= rq_hdr->length) {
+		ocs_log_err(hw->os, "RQ index %d bufindex %d exceed ring length %d for id %d\n",
+			    rqindex, bufindex, rq_hdr->length, rq_hdr->id);
+		return NULL;
+	}
+
+	sli_queue_lock(rq_hdr);
+	sli_queue_lock(rq_payload);
+
+#if defined(ENABLE_DEBUG_RQBUF)
+	/* Put a debug value into the rq, to track which entries are still valid */
+	_sli_queue_poke(&hw->sli, rq_hdr, bufindex, (uint8_t *)&rqbuf_debug_value);
+	_sli_queue_poke(&hw->sli, rq_payload, bufindex, (uint8_t *)&rqbuf_debug_value);
+#endif
+
+	seq = rq->rq_tracker[bufindex];
+	rq->rq_tracker[bufindex] = NULL;
+
+	if (seq == NULL ) {
+		ocs_log_err(hw->os, "RQ buffer NULL, rqindex %d, bufindex %d, current q index = %d\n",
+			    rqindex, bufindex, rq_hdr->index);
+	}
+
+	sli_queue_unlock(rq_payload);
+	sli_queue_unlock(rq_hdr);
+	return seq;
+}
+
+/**
+ * @brief Posts an RQ buffer to a queue and update the verification structures
+ *
+ * @param hw		hardware context
+ * @param seq Pointer to sequence object.
+ *
+ * @return Returns 0 on success, or a non-zero value otherwise.
+ */
+static int32_t
+ocs_hw_rqpair_put(ocs_hw_t *hw, ocs_hw_sequence_t *seq)
+{
+	sli4_queue_t *rq_hdr = &hw->rq[seq->header->rqindex];
+	sli4_queue_t *rq_payload = &hw->rq[seq->payload->rqindex];
+	uint32_t hw_rq_index = hw->hw_rq_lookup[seq->header->rqindex];
+	hw_rq_t *rq = hw->hw_rq[hw_rq_index];
+	uint32_t     phys_hdr[2];
+	uint32_t     phys_payload[2];
+	int32_t      qindex_hdr;
+	int32_t      qindex_payload;
+
+	/* Update the RQ verification lookup tables */
+	phys_hdr[0] = ocs_addr32_hi(seq->header->dma.phys);
+	phys_hdr[1] = ocs_addr32_lo(seq->header->dma.phys);
+	phys_payload[0] = ocs_addr32_hi(seq->payload->dma.phys);
+	phys_payload[1] = ocs_addr32_lo(seq->payload->dma.phys);
+
+	sli_queue_lock(rq_hdr);
+	sli_queue_lock(rq_payload);
+
+	/*
+	 * Note: The header must be posted last for buffer pair mode because
+	 *       posting on the header queue posts the payload queue as well.
+	 *       We do not ring the payload queue independently in RQ pair mode.
+	 */
+	qindex_payload = _sli_queue_write(&hw->sli, rq_payload, (void *)phys_payload);
+	qindex_hdr = _sli_queue_write(&hw->sli, rq_hdr, (void *)phys_hdr);
+	if (qindex_hdr < 0 ||
+	    qindex_payload < 0) {
+		ocs_log_err(hw->os, "RQ_ID=%#x write failed\n", rq_hdr->id);
+		sli_queue_unlock(rq_payload);
+		sli_queue_unlock(rq_hdr);
+		return OCS_HW_RTN_ERROR;
+	}
+
+	/* ensure the indexes are the same */
+	ocs_hw_assert(qindex_hdr == qindex_payload);
+
+	/* Update the lookup table */
+	if (rq->rq_tracker[qindex_hdr] == NULL) {
+		rq->rq_tracker[qindex_hdr] = seq;
+	} else {
+		ocs_log_test(hw->os, "expected rq_tracker[%d][%d] buffer to be NULL\n",
+			     hw_rq_index, qindex_hdr);
+	}
+
+	sli_queue_unlock(rq_payload);
+	sli_queue_unlock(rq_hdr);
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @brief Return RQ buffers (while in RQ pair mode).
+ *
+ * @par Description
+ * The header and payload buffers are returned to the Receive Queue.
+ *
+ * @param hw Hardware context.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS on success, or an error code value on failure.
+ */
+
+ocs_hw_rtn_e
+ocs_hw_rqpair_sequence_free(ocs_hw_t *hw, ocs_hw_sequence_t *seq)
+{
+	ocs_hw_rtn_e   rc = OCS_HW_RTN_SUCCESS;
+
+	/* Check for auto xfer rdy dummy buffers and call the proper release function. */
+	if (seq->header->rqindex == OCS_HW_RQ_INDEX_DUMMY_HDR) {
+		return ocs_hw_rqpair_auto_xfer_rdy_buffer_sequence_reset(hw, seq);
+	}
+
+	/*
+	 * Post the data buffer first. Because in RQ pair mode, ringing the
+	 * doorbell of the header ring will post the data buffer as well.
+	 */
+	if (ocs_hw_rqpair_put(hw, seq)) {
+		ocs_log_err(hw->os, "error writing buffers\n");
+		return OCS_HW_RTN_ERROR;
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Find the RQ index of RQ_ID.
+ *
+ * @param hw Hardware context.
+ * @param rq_id RQ ID to find.
+ *
+ * @return Returns the RQ index, or -1 if not found
+ */
+static inline int32_t
+ocs_hw_rqpair_find(ocs_hw_t *hw, uint16_t rq_id)
+{
+	return ocs_hw_queue_hash_find(hw->rq_hash, rq_id);
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Allocate auto xfer rdy buffers.
+ *
+ * @par Description
+ * Allocates the auto xfer rdy buffers and places them on the free list.
+ *
+ * @param hw Hardware context allocated by the caller.
+ * @param num_buffers Number of buffers to allocate.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_rqpair_auto_xfer_rdy_buffer_alloc(ocs_hw_t *hw, uint32_t num_buffers)
+{
+	ocs_hw_auto_xfer_rdy_buffer_t *buf;
+	uint32_t i;
+
+	hw->auto_xfer_rdy_buf_pool = ocs_pool_alloc(hw->os, sizeof(ocs_hw_auto_xfer_rdy_buffer_t), num_buffers, FALSE);
+	if (hw->auto_xfer_rdy_buf_pool == NULL) {
+		ocs_log_err(hw->os, "Failure to allocate auto xfer ready buffer pool\n");
+		return OCS_HW_RTN_NO_MEMORY;
+	}
+
+	for (i = 0; i < num_buffers; i++) {
+		/* allocate the wrapper object */
+		buf = ocs_pool_get_instance(hw->auto_xfer_rdy_buf_pool, i);
+		ocs_hw_assert(buf != NULL);
+
+		/* allocate the auto xfer ready buffer */
+		if (ocs_dma_alloc(hw->os, &buf->payload.dma, hw->config.auto_xfer_rdy_size, OCS_MIN_DMA_ALIGNMENT)) {
+			ocs_log_err(hw->os, "DMA allocation failed\n");
+			ocs_free(hw->os, buf, sizeof(*buf));
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+
+		/* build a fake data header in big endian */
+		buf->hdr.info = FC_RCTL_INFO_SOL_DATA;
+		buf->hdr.r_ctl = FC_RCTL_FC4_DATA;
+		buf->hdr.type = FC_TYPE_FCP;
+		buf->hdr.f_ctl = fc_htobe24(FC_FCTL_EXCHANGE_RESPONDER |
+					    FC_FCTL_FIRST_SEQUENCE |
+					    FC_FCTL_LAST_SEQUENCE |
+					    FC_FCTL_END_SEQUENCE |
+					    FC_FCTL_SEQUENCE_INITIATIVE);
+
+		/* build the fake header DMA object */
+		buf->header.rqindex = OCS_HW_RQ_INDEX_DUMMY_HDR;
+		buf->header.dma.virt = &buf->hdr;
+		buf->header.dma.alloc = buf;
+		buf->header.dma.size = sizeof(buf->hdr);
+		buf->header.dma.len = sizeof(buf->hdr);
+
+		buf->payload.rqindex = OCS_HW_RQ_INDEX_DUMMY_DATA;
+	}
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Post Auto xfer rdy buffers to the XRIs posted with DNRX.
+ *
+ * @par Description
+ * When new buffers are freed, check existing XRIs waiting for buffers.
+ *
+ * @param hw Hardware context allocated by the caller.
+ */
+static void
+ocs_hw_rqpair_auto_xfer_rdy_dnrx_check(ocs_hw_t *hw)
+{
+	ocs_hw_io_t *io;
+	int32_t rc;
+
+	ocs_lock(&hw->io_lock);
+
+	while (!ocs_list_empty(&hw->io_port_dnrx)) {
+		io = ocs_list_remove_head(&hw->io_port_dnrx);
+		rc = ocs_hw_reque_xri(hw, io);
+		if(rc) {
+			break;
+		}
+	}
+
+	ocs_unlock(&hw->io_lock);
+}
+
+/**
+ * @brief Called when the POST_SGL_PAGE command completes.
+ *
+ * @par Description
+ * Free the mailbox command buffer.
+ *
+ * @param hw Hardware context.
+ * @param status Status field from the mbox completion.
+ * @param mqe Mailbox response structure.
+ * @param arg Pointer to a callback function that signals the caller that the command is done.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_hw_rqpair_auto_xfer_rdy_move_to_port_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void  *arg)
+{
+	if (status != 0) {
+		ocs_log_debug(hw->os, "Status 0x%x\n", status);
+	}
+
+	ocs_free(hw->os, mqe, SLI4_BMBX_SIZE);
+	return 0;
+}
+
+/**
+ * @brief Prepares an XRI to move to the chip.
+ *
+ * @par Description
+ * Puts the data SGL into the SGL list for the IO object and possibly registers
+ * an SGL list for the XRI. Since both the POST_XRI and POST_SGL_PAGES commands are
+ * mailbox commands, we don't need to wait for completion before preceding.
+ *
+ * @param hw Hardware context allocated by the caller.
+ * @param io Pointer to the IO object.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS for success, or an error code value for failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_rqpair_auto_xfer_rdy_move_to_port(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	/* We only need to preregister the SGL if it has not yet been done. */
+	if (!sli_get_sgl_preregister(&hw->sli)) {
+		uint8_t	*post_sgl;
+		ocs_dma_t *psgls = &io->def_sgl;
+		ocs_dma_t **sgls = &psgls;
+
+		/* non-local buffer required for mailbox queue */
+		post_sgl = ocs_malloc(hw->os, SLI4_BMBX_SIZE, OCS_M_NOWAIT);
+		if (post_sgl == NULL) {
+			ocs_log_err(hw->os, "no buffer for command\n");
+			return OCS_HW_RTN_NO_MEMORY;
+		}
+		if (sli_cmd_fcoe_post_sgl_pages(&hw->sli, post_sgl, SLI4_BMBX_SIZE,
+						io->indicator, 1, sgls, NULL, NULL)) {
+			if (ocs_hw_command(hw, post_sgl, OCS_CMD_NOWAIT,
+					    ocs_hw_rqpair_auto_xfer_rdy_move_to_port_cb, NULL)) {
+				ocs_free(hw->os, post_sgl, SLI4_BMBX_SIZE);
+				ocs_log_err(hw->os, "SGL post failed\n");
+				return OCS_HW_RTN_ERROR;
+			}
+		}
+	}
+
+	ocs_lock(&hw->io_lock);
+	if (ocs_hw_rqpair_auto_xfer_rdy_buffer_post(hw, io, 0) != 0) { /* DNRX set - no buffer */
+		ocs_unlock(&hw->io_lock);
+		return OCS_HW_RTN_ERROR;
+	}
+	ocs_unlock(&hw->io_lock);
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @brief Prepares an XRI to move back to the host.
+ *
+ * @par Description
+ * Releases any attached buffer back to the pool.
+ *
+ * @param hw Hardware context allocated by the caller.
+ * @param io Pointer to the IO object.
+ */
+void
+ocs_hw_rqpair_auto_xfer_rdy_move_to_host(ocs_hw_t *hw, ocs_hw_io_t *io)
+{
+	if (io->axr_buf != NULL) {
+		ocs_lock(&hw->io_lock);
+			/* check  list and remove if there */
+			if (ocs_list_on_list(&io->dnrx_link)) {
+				ocs_list_remove(&hw->io_port_dnrx, io);
+				io->auto_xfer_rdy_dnrx = 0;
+
+				/* release the count for waiting for a buffer */
+				ocs_hw_io_free(hw, io);
+			}
+
+			ocs_pool_put(hw->auto_xfer_rdy_buf_pool, io->axr_buf);
+			io->axr_buf = NULL;
+		ocs_unlock(&hw->io_lock);
+
+		ocs_hw_rqpair_auto_xfer_rdy_dnrx_check(hw);
+	}
+	return;
+}
+
+
+/**
+ * @brief Posts an auto xfer rdy buffer to an IO.
+ *
+ * @par Description
+ * Puts the data SGL into the SGL list for the IO object
+ * @n @name
+ * @b Note: io_lock must be held.
+ *
+ * @param hw Hardware context allocated by the caller.
+ * @param io Pointer to the IO object.
+ *
+ * @return Returns the value of DNRX bit in the TRSP and ABORT WQEs.
+ */
+uint8_t
+ocs_hw_rqpair_auto_xfer_rdy_buffer_post(ocs_hw_t *hw, ocs_hw_io_t *io, int reuse_buf)
+{
+	ocs_hw_auto_xfer_rdy_buffer_t *buf;
+	sli4_sge_t	*data;
+
+	if(!reuse_buf) {
+		buf = ocs_pool_get(hw->auto_xfer_rdy_buf_pool);
+		io->axr_buf = buf;
+	}
+
+	data = io->def_sgl.virt;
+	data[0].sge_type = SLI4_SGE_TYPE_SKIP;
+	data[0].last = 0;
+
+	/*
+	 * Note: if we are doing DIF assists, then the SGE[1] must contain the
+	 * DI_SEED SGE. The host is responsible for programming:
+	 *   SGE Type (Word 2, bits 30:27)
+	 *   Replacement App Tag (Word 2 bits 15:0)
+	 *   App Tag (Word 3 bits 15:0)
+	 *   New Ref Tag (Word 3 bit 23)
+	 *   Metadata Enable (Word 3 bit 20)
+	 *   Auto-Increment RefTag (Word 3 bit 19)
+	 *   Block Size (Word 3 bits 18:16)
+	 * The following fields are managed by the SLI Port:
+	 *    Ref Tag Compare (Word 0)
+	 *    Replacement Ref Tag (Word 1) - In not the LBA
+	 *    NA (Word 2 bit 25)
+	 *    Opcode RX (Word 3 bits 27:24)
+	 *    Checksum Enable (Word 3 bit 22)
+	 *    RefTag Enable (Word 3 bit 21)
+	 *
+	 * The first two SGLs are cleared by ocs_hw_io_init_sges(), so assume eveything is cleared.
+	 */
+	if (hw->config.auto_xfer_rdy_p_type) {
+		sli4_diseed_sge_t *diseed = (sli4_diseed_sge_t*)&data[1];
+
+		diseed->sge_type = SLI4_SGE_TYPE_DISEED;
+		diseed->repl_app_tag = hw->config.auto_xfer_rdy_app_tag_value;
+		diseed->app_tag_cmp = hw->config.auto_xfer_rdy_app_tag_value;
+		diseed->check_app_tag = hw->config.auto_xfer_rdy_app_tag_valid;
+		diseed->auto_incr_ref_tag = TRUE; /* Always the LBA */
+		diseed->dif_blk_size = hw->config.auto_xfer_rdy_blk_size_chip;
+	} else {
+		data[1].sge_type = SLI4_SGE_TYPE_SKIP;
+		data[1].last = 0;
+	}
+
+	data[2].sge_type = SLI4_SGE_TYPE_DATA;
+	data[2].buffer_address_high = ocs_addr32_hi(io->axr_buf->payload.dma.phys);
+	data[2].buffer_address_low  = ocs_addr32_lo(io->axr_buf->payload.dma.phys);
+	data[2].buffer_length = io->axr_buf->payload.dma.size;
+	data[2].last = TRUE;
+	data[3].sge_type = SLI4_SGE_TYPE_SKIP;
+
+	return 0;
+}
+
+/**
+ * @brief Return auto xfer ready buffers (while in RQ pair mode).
+ *
+ * @par Description
+ * The header and payload buffers are returned to the auto xfer rdy pool.
+ *
+ * @param hw Hardware context.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns OCS_HW_RTN_SUCCESS for success, an error code value for failure.
+ */
+
+static ocs_hw_rtn_e
+ocs_hw_rqpair_auto_xfer_rdy_buffer_sequence_reset(ocs_hw_t *hw, ocs_hw_sequence_t *seq)
+{
+	ocs_hw_auto_xfer_rdy_buffer_t *buf = seq->header->dma.alloc;
+
+	buf->data_cqe = 0;
+	buf->cmd_cqe = 0;
+	buf->fcfi = 0;
+	buf->call_axr_cmd = 0;
+	buf->call_axr_data = 0;
+
+	/* build a fake data header in big endian */
+	buf->hdr.info = FC_RCTL_INFO_SOL_DATA;
+	buf->hdr.r_ctl = FC_RCTL_FC4_DATA;
+	buf->hdr.type = FC_TYPE_FCP;
+	buf->hdr.f_ctl = fc_htobe24(FC_FCTL_EXCHANGE_RESPONDER |
+					FC_FCTL_FIRST_SEQUENCE |
+					FC_FCTL_LAST_SEQUENCE |
+					FC_FCTL_END_SEQUENCE |
+					FC_FCTL_SEQUENCE_INITIATIVE);
+
+	/* build the fake header DMA object */
+	buf->header.rqindex = OCS_HW_RQ_INDEX_DUMMY_HDR;
+	buf->header.dma.virt = &buf->hdr;
+	buf->header.dma.alloc = buf;
+	buf->header.dma.size = sizeof(buf->hdr);
+	buf->header.dma.len = sizeof(buf->hdr);
+	buf->payload.rqindex = OCS_HW_RQ_INDEX_DUMMY_DATA;
+
+	ocs_hw_rqpair_auto_xfer_rdy_dnrx_check(hw);
+
+	return OCS_HW_RTN_SUCCESS;
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Free auto xfer rdy buffers.
+ *
+ * @par Description
+ * Frees the auto xfer rdy buffers.
+ *
+ * @param hw Hardware context allocated by the caller.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static void
+ocs_hw_rqpair_auto_xfer_rdy_buffer_free(ocs_hw_t *hw)
+{
+	ocs_hw_auto_xfer_rdy_buffer_t *buf;
+	uint32_t i;
+
+	if (hw->auto_xfer_rdy_buf_pool != NULL) {
+		ocs_lock(&hw->io_lock);
+			for (i = 0; i < ocs_pool_get_count(hw->auto_xfer_rdy_buf_pool); i++) {
+				buf = ocs_pool_get_instance(hw->auto_xfer_rdy_buf_pool, i);
+				if (buf != NULL) {
+					ocs_dma_free(hw->os, &buf->payload.dma);
+				}
+			}
+		ocs_unlock(&hw->io_lock);
+
+		ocs_pool_free(hw->auto_xfer_rdy_buf_pool);
+		hw->auto_xfer_rdy_buf_pool = NULL;
+	}
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Configure the rq_pair function from ocs_hw_init().
+ *
+ * @par Description
+ * Allocates the buffers to auto xfer rdy and posts initial XRIs for this feature.
+ *
+ * @param hw Hardware context allocated by the caller.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+ocs_hw_rtn_e
+ocs_hw_rqpair_init(ocs_hw_t *hw)
+{
+	ocs_hw_rtn_e	rc;
+	uint32_t xris_posted;
+
+	ocs_log_debug(hw->os, "RQ Pair mode\n");
+
+	/*
+	 * If we get this far, the auto XFR_RDY feature was enabled successfully, otherwise ocs_hw_init() would
+	 * return with an error. So allocate the buffers based on the initial XRI pool required to support this
+	 * feature.
+	 */
+	if (sli_get_auto_xfer_rdy_capable(&hw->sli) &&
+	    hw->config.auto_xfer_rdy_size > 0) {
+		if (hw->auto_xfer_rdy_buf_pool == NULL) {
+			/*
+			 * Allocate one more buffer than XRIs so that when all the XRIs are in use, we still have
+			 * one to post back for the case where the response phase is started in the context of
+			 * the data completion.
+			 */
+			rc = ocs_hw_rqpair_auto_xfer_rdy_buffer_alloc(hw, hw->config.auto_xfer_rdy_xri_cnt + 1);
+			if (rc != OCS_HW_RTN_SUCCESS) {
+				return rc;
+			}
+		} else {
+			ocs_pool_reset(hw->auto_xfer_rdy_buf_pool);
+		}
+
+		/* Post the auto XFR_RDY XRIs */
+		xris_posted = ocs_hw_xri_move_to_port_owned(hw, hw->config.auto_xfer_rdy_xri_cnt);
+		if (xris_posted != hw->config.auto_xfer_rdy_xri_cnt) {
+			ocs_log_err(hw->os, "post_xri failed, only posted %d XRIs\n", xris_posted);
+			return OCS_HW_RTN_ERROR;
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup devInitShutdown
+ * @brief Tear down the rq_pair function from ocs_hw_teardown().
+ *
+ * @par Description
+ * Frees the buffers to auto xfer rdy.
+ *
+ * @param hw Hardware context allocated by the caller.
+ */
+void
+ocs_hw_rqpair_teardown(ocs_hw_t *hw)
+{
+	/* We need to free any auto xfer ready buffers */
+	ocs_hw_rqpair_auto_xfer_rdy_buffer_free(hw);
+}
diff --git a/sys/dev/ocs_fc/ocs_hw_queues.h b/sys/dev/ocs_fc/ocs_hw_queues.h
new file mode 100644
index 000000000000..5005afe33592
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_hw_queues.h
@@ -0,0 +1,97 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ */
+
+#ifndef __OCS_HW_QUEUES_H__
+#define __OCS_HW_QUEUES_H__
+
+#define OCS_HW_MQ_DEPTH	128
+
+typedef enum {
+	QTOP_EQ = 0,
+	QTOP_CQ,
+	QTOP_WQ,
+	QTOP_RQ,
+	QTOP_MQ,
+	QTOP_LAST,
+} ocs_hw_qtop_entry_e;
+
+typedef struct {
+	ocs_hw_qtop_entry_e entry;
+	uint8_t set_default;
+	uint32_t len;
+	uint8_t class;
+	uint8_t ulp;
+	uint8_t filter_mask;
+} ocs_hw_qtop_entry_t;
+
+typedef struct {
+	struct rq_config {
+		hw_eq_t *eq;
+		uint32_t len;
+		uint8_t class;
+		uint8_t ulp;
+		uint8_t filter_mask;
+	} rq_cfg[16];
+	uint32_t num_pairs;
+} ocs_hw_mrq_t;
+
+
+#define MAX_TOKENS			256
+#define OCS_HW_MAX_QTOP_ENTRIES	200
+
+typedef struct {
+	ocs_os_handle_t os;
+	ocs_hw_qtop_entry_t *entries;
+	uint32_t alloc_count;
+	uint32_t inuse_count;
+	uint32_t entry_counts[QTOP_LAST];
+	uint32_t rptcount[10];
+	uint32_t rptcount_idx;
+} ocs_hw_qtop_t;
+
+extern ocs_hw_qtop_t *ocs_hw_qtop_parse(ocs_hw_t *hw, const char *qtop_string);
+extern void ocs_hw_qtop_free(ocs_hw_qtop_t *qtop);
+extern const char *ocs_hw_qtop_entry_name(ocs_hw_qtop_entry_e entry);
+extern uint32_t ocs_hw_qtop_eq_count(ocs_hw_t *hw);
+
+extern ocs_hw_rtn_e ocs_hw_init_queues(ocs_hw_t *hw, ocs_hw_qtop_t *qtop);
+extern void hw_thread_eq_handler(ocs_hw_t *hw, hw_eq_t *eq, uint32_t max_isr_time_msec);
+extern void hw_thread_cq_handler(ocs_hw_t *hw, hw_cq_t *cq);
+extern  hw_wq_t *ocs_hw_queue_next_wq(ocs_hw_t *hw, ocs_hw_io_t *io);
+
+#endif /* __OCS_HW_QUEUES_H__ */
diff --git a/sys/dev/ocs_fc/ocs_io.c b/sys/dev/ocs_fc/ocs_io.c
new file mode 100644
index 000000000000..2951500efc36
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_io.c
@@ -0,0 +1,491 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Provide IO object allocation.
+ */
+
+/*!
+ * @defgroup io_alloc IO allocation
+ */
+
+#include "ocs.h"
+#include "ocs_scsi.h"
+#include "ocs_els.h"
+#include "ocs_utils.h"
+
+void ocs_mgmt_io_list(ocs_textbuf_t *textbuf, void *io);
+void ocs_mgmt_io_get_all(ocs_textbuf_t *textbuf, void *io);
+int ocs_mgmt_io_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *io);
+
+static ocs_mgmt_functions_t io_mgmt_functions = {
+	.get_list_handler	=	ocs_mgmt_io_list,
+	.get_handler		=	ocs_mgmt_io_get,
+	.get_all_handler	=	ocs_mgmt_io_get_all,
+};
+
+/**
+ * @brief IO pool.
+ *
+ * Structure encapsulating a pool of IO objects.
+ *
+ */
+
+struct ocs_io_pool_s {
+	ocs_t *ocs;			/* Pointer to device object */
+	ocs_lock_t lock;		/* IO pool lock */
+	uint32_t io_num_ios;		/* Total IOs allocated */
+	ocs_pool_t *pool;
+};
+
+/**
+ * @brief Create a pool of IO objects.
+ *
+ * @par Description
+ * This function allocates memory in larger chucks called
+ * "slabs" which are a fixed size. It calculates the number of IO objects that
+ * fit within each "slab" and determines the number of "slabs" required to
+ * allocate the number of IOs requested. Each of the slabs is allocated and
+ * then it grabs each IO object within the slab and adds it to the free list.
+ * Individual command, response and SGL DMA buffers are allocated for each IO.
+ *
+ *           "Slabs"
+ *      +----------------+
+ *      |                |
+ *   +----------------+  |
+ *   |    IO          |  |
+ *   +----------------+  |
+ *   |    ...         |  |
+ *   +----------------+__+
+ *   |    IO          |
+ *   +----------------+
+ *
+ * @param ocs Driver instance's software context.
+ * @param num_io Number of IO contexts to allocate.
+ * @param num_sgl Number of SGL entries to allocate for each IO.
+ *
+ * @return Returns a pointer to a new ocs_io_pool_t on success,
+ *         or NULL on failure.
+ */
+
+ocs_io_pool_t *
+ocs_io_pool_create(ocs_t *ocs, uint32_t num_io, uint32_t num_sgl)
+{
+	uint32_t i = 0;
+	int32_t	rc = -1;
+	ocs_io_pool_t *io_pool;
+
+	/* Allocate the IO pool */
+	io_pool = ocs_malloc(ocs, sizeof(*io_pool), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (io_pool == NULL) {
+		ocs_log_err(ocs, "allocate of IO pool failed\n");
+		return NULL;;
+	}
+
+	io_pool->ocs = ocs;
+	io_pool->io_num_ios = num_io;
+
+	/* initialize IO pool lock */
+	ocs_lock_init(ocs, &io_pool->lock, "io_pool lock[%d]", ocs->instance_index);
+
+	io_pool->pool = ocs_pool_alloc(ocs, sizeof(ocs_io_t), io_pool->io_num_ios, FALSE);
+
+	for (i = 0; i < io_pool->io_num_ios; i++) {
+		ocs_io_t *io = ocs_pool_get_instance(io_pool->pool, i);
+
+		io->tag = i;
+		io->instance_index = i;
+		io->ocs = ocs;
+
+		/* allocate a command/response dma buffer */
+		if (ocs->enable_ini) {
+			rc = ocs_dma_alloc(ocs, &io->cmdbuf, SCSI_CMD_BUF_LENGTH, OCS_MIN_DMA_ALIGNMENT);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_dma_alloc cmdbuf failed\n");
+				ocs_io_pool_free(io_pool);
+				return NULL;
+			}
+		}
+
+		/* Allocate a response buffer */
+		rc = ocs_dma_alloc(ocs, &io->rspbuf, SCSI_RSP_BUF_LENGTH, OCS_MIN_DMA_ALIGNMENT);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_dma_alloc cmdbuf failed\n");
+			ocs_io_pool_free(io_pool);
+			return NULL;
+		}
+
+		/* Allocate SGL */
+		io->sgl = ocs_malloc(ocs, sizeof(*io->sgl) * num_sgl, OCS_M_NOWAIT | OCS_M_ZERO);
+		if (io->sgl == NULL) {
+			ocs_log_err(ocs, "malloc sgl's failed\n");
+			ocs_io_pool_free(io_pool);
+			return NULL;
+		}
+		io->sgl_allocated = num_sgl;
+		io->sgl_count = 0;
+
+		/* Make IO backend call to initialize IO */
+		ocs_scsi_tgt_io_init(io);
+		ocs_scsi_ini_io_init(io);
+		
+		rc = ocs_dma_alloc(ocs, &io->els_req, OCS_ELS_REQ_LEN, OCS_MIN_DMA_ALIGNMENT);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_dma_alloc els_req failed\n");
+			ocs_io_pool_free(io_pool);
+			return NULL;
+ 		}
+
+		rc = ocs_dma_alloc(ocs, &io->els_rsp, OCS_ELS_GID_PT_RSP_LEN, OCS_MIN_DMA_ALIGNMENT);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_dma_alloc els_rsp failed\n");
+			ocs_io_pool_free(io_pool);
+			return NULL;
+ 		}
+	}
+
+	return io_pool;
+}
+
+/**
+ * @brief Free IO objects pool
+ *
+ * @par Description
+ * The pool of IO objects are freed.
+ *
+ * @param io_pool Pointer to IO pool object.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_io_pool_free(ocs_io_pool_t *io_pool)
+{
+	ocs_t *ocs;
+	uint32_t i;
+	ocs_io_t *io;
+
+	if (io_pool != NULL) {
+		ocs = io_pool->ocs;
+		for (i = 0; i < io_pool->io_num_ios; i++) {
+			io = ocs_pool_get_instance(io_pool->pool, i);
+			if (!io)
+				continue;
+			ocs_scsi_tgt_io_exit(io);
+			ocs_scsi_ini_io_exit(io);
+			if (io->sgl) {
+				ocs_free(ocs, io->sgl, sizeof(*io->sgl) * io->sgl_allocated);
+			}
+			ocs_dma_free(ocs, &io->cmdbuf);
+			ocs_dma_free(ocs, &io->rspbuf);
+			ocs_dma_free(ocs, &io->els_req);
+			ocs_dma_free(ocs, &io->els_rsp);
+		}
+
+		if (io_pool->pool != NULL) {
+			ocs_pool_free(io_pool->pool);
+		}
+		ocs_lock_free(&io_pool->lock);
+		ocs_free(ocs, io_pool, sizeof(*io_pool));
+		ocs->xport->io_pool = NULL;
+	}
+
+	return 0;
+}
+
+uint32_t ocs_io_pool_allocated(ocs_io_pool_t *io_pool)
+{
+	return io_pool->io_num_ios;
+}
+
+/**
+ * @ingroup io_alloc
+ * @brief Allocate an object used to track an IO.
+ *
+ * @param io_pool Pointer to the IO pool.
+ *
+ * @return Returns the pointer to a new object, or NULL if none available.
+ */
+ocs_io_t *
+ocs_io_pool_io_alloc(ocs_io_pool_t *io_pool)
+{
+	ocs_io_t *io = NULL;
+	ocs_t *ocs;
+
+	ocs_assert(io_pool, NULL);
+
+	ocs = io_pool->ocs;
+
+	ocs_lock(&io_pool->lock);
+	if ((io = ocs_pool_get(io_pool->pool)) != NULL) {
+		ocs_unlock(&io_pool->lock);
+
+		io->io_type = OCS_IO_TYPE_MAX;
+		io->hio_type = OCS_HW_IO_MAX;
+		io->hio = NULL;
+		io->transferred = 0;
+		io->ocs = ocs;
+		io->timeout = 0;
+		io->sgl_count = 0;
+		io->tgt_task_tag = 0;
+		io->init_task_tag = 0;
+		io->hw_tag = 0;
+		io->display_name = "pending";
+		io->seq_init = 0;
+		io->els_req_free = 0;
+		io->mgmt_functions = &io_mgmt_functions;
+		io->io_free = 0;
+		ocs_atomic_add_return(&ocs->xport->io_active_count, 1);
+		ocs_atomic_add_return(&ocs->xport->io_total_alloc, 1);
+	} else {
+		ocs_unlock(&io_pool->lock);
+	}
+	return io;
+}
+
+/**
+ * @ingroup io_alloc
+ * @brief Free an object used to track an IO.
+ *
+ * @param io_pool Pointer to IO pool object.
+ * @param io Pointer to the IO object.
+ */
+void
+ocs_io_pool_io_free(ocs_io_pool_t *io_pool, ocs_io_t *io)
+{
+	ocs_t *ocs;
+	ocs_hw_io_t *hio = NULL;
+
+	ocs_assert(io_pool);
+
+	ocs = io_pool->ocs;
+
+	ocs_lock(&io_pool->lock);
+		hio = io->hio;
+		io->hio = NULL;
+		ocs_pool_put(io_pool->pool, io);
+	ocs_unlock(&io_pool->lock);
+
+	if (hio) {
+		ocs_hw_io_free(&ocs->hw, hio);
+	}
+	io->io_free = 1;
+	ocs_atomic_sub_return(&ocs->xport->io_active_count, 1);
+	ocs_atomic_add_return(&ocs->xport->io_total_free, 1);
+}
+
+/**
+ * @ingroup io_alloc
+ * @brief Find an I/O given it's node and ox_id.
+ *
+ * @param ocs Driver instance's software context.
+ * @param node Pointer to node.
+ * @param ox_id OX_ID to find.
+ * @param rx_id RX_ID to find (0xffff for unassigned).
+ */
+ocs_io_t *
+ocs_io_find_tgt_io(ocs_t *ocs, ocs_node_t *node, uint16_t ox_id, uint16_t rx_id)
+{
+	ocs_io_t	*io = NULL;
+
+	ocs_lock(&node->active_ios_lock);
+		ocs_list_foreach(&node->active_ios, io)
+			if ((io->cmd_tgt && (io->init_task_tag == ox_id)) &&
+			    ((rx_id == 0xffff) || (io->tgt_task_tag == rx_id))) {
+				break;
+			}
+	ocs_unlock(&node->active_ios_lock);
+	return io;
+}
+
+/**
+ * @ingroup io_alloc
+ * @brief Return IO context given the instance index.
+ *
+ * @par Description
+ * Returns a pointer to the IO context given by the instance index.
+ *
+ * @param ocs Pointer to driver structure.
+ * @param index IO instance index to return.
+ *
+ * @return Returns a pointer to the IO context, or NULL if not found.
+ */
+ocs_io_t *
+ocs_io_get_instance(ocs_t *ocs, uint32_t index)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_io_pool_t *io_pool = xport->io_pool;
+	return ocs_pool_get_instance(io_pool->pool, index);
+}
+
+/**
+ * @brief Generate IO context ddump data.
+ *
+ * The ddump data for an IO context is generated.
+ *
+ * @param textbuf Pointer to text buffer.
+ * @param io Pointer to IO context.
+ *
+ * @return None.
+ */
+
+void
+ocs_ddump_io(ocs_textbuf_t *textbuf, ocs_io_t *io)
+{
+	ocs_ddump_section(textbuf, "io", io->instance_index);
+	ocs_ddump_value(textbuf, "display_name", "%s", io->display_name);
+	ocs_ddump_value(textbuf, "node_name", "%s", io->node->display_name);
+
+	ocs_ddump_value(textbuf, "ref_count", "%d", ocs_ref_read_count(&io->ref));
+	ocs_ddump_value(textbuf, "io_type", "%d", io->io_type);
+	ocs_ddump_value(textbuf, "hio_type", "%d", io->hio_type);
+	ocs_ddump_value(textbuf, "cmd_tgt", "%d", io->cmd_tgt);
+	ocs_ddump_value(textbuf, "cmd_ini", "%d", io->cmd_ini);
+	ocs_ddump_value(textbuf, "send_abts", "%d", io->send_abts);
+	ocs_ddump_value(textbuf, "init_task_tag", "0x%x", io->init_task_tag);
+	ocs_ddump_value(textbuf, "tgt_task_tag", "0x%x", io->tgt_task_tag);
+	ocs_ddump_value(textbuf, "hw_tag", "0x%x", io->hw_tag);
+	ocs_ddump_value(textbuf, "tag", "0x%x", io->tag);
+	ocs_ddump_value(textbuf, "timeout", "%d", io->timeout);
+	ocs_ddump_value(textbuf, "tmf_cmd", "%d", io->tmf_cmd);
+	ocs_ddump_value(textbuf, "abort_rx_id", "0x%x", io->abort_rx_id);
+
+	ocs_ddump_value(textbuf, "busy", "%d", ocs_io_busy(io));
+	ocs_ddump_value(textbuf, "transferred", "%zu", io->transferred);
+	ocs_ddump_value(textbuf, "auto_resp", "%d", io->auto_resp);
+	ocs_ddump_value(textbuf, "exp_xfer_len", "%d", io->exp_xfer_len);
+	ocs_ddump_value(textbuf, "xfer_req", "%d", io->xfer_req);
+	ocs_ddump_value(textbuf, "seq_init", "%d", io->seq_init);
+
+	ocs_ddump_value(textbuf, "alloc_link", "%d", ocs_list_on_list(&io->io_alloc_link));
+	ocs_ddump_value(textbuf, "pending_link", "%d", ocs_list_on_list(&io->io_pending_link));
+	ocs_ddump_value(textbuf, "backend_link", "%d", ocs_list_on_list(&io->link));
+
+	if (io->hio) {
+		ocs_ddump_value(textbuf, "hw_tag", "%#x", io->hio->reqtag);
+		ocs_ddump_value(textbuf, "hw_xri", "%#x", io->hio->indicator);
+		ocs_ddump_value(textbuf, "hw_type", "%#x", io->hio->type);
+	} else {
+		ocs_ddump_value(textbuf, "hw_tag", "%s", "pending");
+		ocs_ddump_value(textbuf, "hw_xri", "%s", "pending");
+		ocs_ddump_value(textbuf, "hw_type", "%s", "pending");
+	}
+
+	ocs_scsi_ini_ddump(textbuf, OCS_SCSI_DDUMP_IO, io);
+	ocs_scsi_tgt_ddump(textbuf, OCS_SCSI_DDUMP_IO, io);
+
+	ocs_ddump_endsection(textbuf, "io", io->instance_index);
+}
+
+
+void
+ocs_mgmt_io_list(ocs_textbuf_t *textbuf, void *object)
+{
+
+	/* Readonly values */
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "display_name");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "init_task_tag");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "tag");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "transferred");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "auto_resp");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "exp_xfer_len");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "xfer_req");
+}
+
+int
+ocs_mgmt_io_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
+{
+	char qualifier[80];
+	int retval = -1;
+	ocs_io_t *io = (ocs_io_t *) object;
+
+	snprintf(qualifier, sizeof(qualifier), "%s/io[%d]", parent, io->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = name + strlen(qualifier) +1;
+
+		/* See if it's a value I can supply */
+		if (ocs_strcmp(unqualified_name, "display_name") == 0) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", io->display_name);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "init_task_tag") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "init_task_tag", "0x%x", io->init_task_tag);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "tgt_task_tag") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tgt_task_tag", "0x%x", io->tgt_task_tag);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "hw_tag") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_tag", "0x%x", io->hw_tag);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "tag") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tag", "0x%x", io->tag);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "transferred") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "transferred", "%zu", io->transferred);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "auto_resp") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "auto_resp", io->auto_resp);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "exp_xfer_len") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "exp_xfer_len", "%d", io->exp_xfer_len);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "xfer_req") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "xfer_req", "%d", io->xfer_req);
+			retval = 0;
+		}
+	}
+
+	return retval;
+}
+
+void
+ocs_mgmt_io_get_all(ocs_textbuf_t *textbuf, void *object)
+{
+	ocs_io_t *io = (ocs_io_t *) object;
+
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", io->display_name);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "init_task_tag", "0x%x", io->init_task_tag);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tgt_task_tag", "0x%x", io->tgt_task_tag);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_tag", "0x%x", io->hw_tag);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "tag", "0x%x", io->tag);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "transferred", "%zu", io->transferred);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "auto_resp", io->auto_resp);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "exp_xfer_len", "%d", io->exp_xfer_len);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "xfer_req", "%d", io->xfer_req);
+
+}
+
+
+
+
diff --git a/sys/dev/ocs_fc/ocs_io.h b/sys/dev/ocs_fc/ocs_io.h
new file mode 100644
index 000000000000..b5a9544ace09
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_io.h
@@ -0,0 +1,196 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS linux driver IO declarations
+ */
+
+#if !defined(__OCS_IO_H__)
+#define __OCS_IO_H__
+
+#define io_error_log(io, fmt, ...)  \
+	do { \
+		if (OCS_LOG_ENABLE_IO_ERRORS(io->ocs)) \
+			ocs_log_warn(io->ocs, fmt, ##__VA_ARGS__); \
+	} while (0)
+
+/**
+ * @brief FCP IO context
+ *
+ * This structure is used for transport and backend IO requests and responses.
+ */
+
+#define SCSI_CMD_BUF_LENGTH		48
+#define SCSI_RSP_BUF_LENGTH		sizeof(fcp_rsp_iu_t)
+
+/**
+ * @brief OCS IO types
+ */
+typedef enum {
+	OCS_IO_TYPE_IO = 0,
+	OCS_IO_TYPE_ELS,
+	OCS_IO_TYPE_CT,
+	OCS_IO_TYPE_CT_RESP,
+	OCS_IO_TYPE_BLS_RESP,
+	OCS_IO_TYPE_ABORT,
+
+	OCS_IO_TYPE_MAX,		/**< must be last */
+} ocs_io_type_e;
+
+struct ocs_io_s {
+
+	ocs_t *ocs;			/**< pointer back to ocs */
+	uint32_t instance_index;	/**< unique instance index value */
+	const char *display_name;	/**< display name */
+	ocs_node_t *node;		/**< pointer to node */
+	ocs_list_link_t io_alloc_link;	/**< (io_pool->io_free_list) free list link */
+	uint32_t init_task_tag;		/**< initiator task tag (OX_ID) for back-end and SCSI logging */
+	uint32_t tgt_task_tag;		/**< target task tag (RX_ID) - for back-end and SCSI logging */
+	uint32_t hw_tag;		/**< HW layer unique IO id - for back-end and SCSI logging */
+	uint32_t tag;			/**< unique IO identifier */
+	ocs_scsi_sgl_t *sgl;		/**< SGL */
+	uint32_t sgl_allocated;		/**< Number of allocated SGEs */
+	uint32_t sgl_count;		/**< Number of SGEs in this SGL */
+	ocs_scsi_ini_io_t ini_io;	/**< backend initiator private IO data */
+	ocs_scsi_tgt_io_t tgt_io;	/**< backend target private IO data */
+	uint32_t exp_xfer_len;		/**< expected data transfer length, based on FC or iSCSI header */
+	ocs_mgmt_functions_t *mgmt_functions;
+
+	/* Declarations private to HW/SLI */
+	void *hw_priv;			/**< HW private context */
+
+	/* Declarations private to FC Transport */
+	ocs_io_type_e io_type;		/**< indicates what this ocs_io_t structure is used for */
+	ocs_ref_t ref;			/**< refcount object */
+	void *dslab_item;		/**< pointer back to dslab allocation object */
+	ocs_hw_io_t *hio;		/**< HW IO context */
+	size_t transferred;		/**< Number of bytes transferred so far */
+	uint32_t auto_resp:1,		/**< set if auto_trsp was set */
+		 low_latency:1,		/**< set if low latency request */
+		 wq_steering:4,		/**< selected WQ steering request */
+		 wq_class:4;		/**< selected WQ class if steering is class */
+	uint32_t xfer_req;		/**< transfer size for current request */
+	ocs_scsi_rsp_io_cb_t scsi_ini_cb; /**< initiator callback function */
+	void *scsi_ini_cb_arg;		/**< initiator callback function argument */
+	ocs_scsi_io_cb_t scsi_tgt_cb;	/**< target callback function */
+	void *scsi_tgt_cb_arg;		/**< target callback function argument */
+	ocs_scsi_io_cb_t abort_cb;	/**< abort callback function */
+	void *abort_cb_arg;		/**< abort callback function argument */
+	ocs_scsi_io_cb_t bls_cb;	/**< BLS callback function */
+	void *bls_cb_arg;		/**< BLS callback function argument */
+	ocs_scsi_tmf_cmd_e tmf_cmd;	/**< TMF command being processed */
+	uint16_t abort_rx_id;		/**< rx_id from the ABTS that initiated the command abort */
+
+	uint32_t cmd_tgt:1,		/**< True if this is a Target command */
+		 send_abts:1,		/**< when aborting, indicates ABTS is to be sent */
+		 cmd_ini:1,		/**< True if this is an Initiator command */
+		 seq_init:1;		/**< True if local node has sequence initiative */
+	ocs_hw_io_param_t iparam;	/**< iparams for hw io send call */
+	ocs_hw_dif_info_t hw_dif;	/**< HW formatted DIF parameters */
+	ocs_scsi_dif_info_t scsi_dif_info;	/**< DIF info saved for DIF error recovery */
+	ocs_hw_io_type_e hio_type;	/**< HW IO type */
+	uint32_t wire_len;		/**< wire length */
+	void *hw_cb;			/**< saved HW callback */
+	ocs_list_link_t io_pending_link;/**< link list link pending */
+
+	ocs_dma_t ovfl_sgl;		/**< Overflow SGL */
+
+	/* for ELS requests/responses */
+	uint32_t els_pend:1,		/**< True if ELS is pending */
+		els_active:1;		/**< True if ELS is active */
+	ocs_dma_t els_req;		/**< ELS request payload buffer */
+	ocs_dma_t els_rsp;		/**< ELS response payload buffer */
+	ocs_sm_ctx_t els_sm;		/**< EIO IO state machine context */
+	uint32_t els_evtdepth;		/**< current event posting nesting depth */
+	uint32_t els_req_free:1;	/**< this els is to be free'd */
+	uint32_t els_retries_remaining;	/*<< Retries remaining */
+	void (*els_callback)(ocs_node_t *node, ocs_node_cb_t *cbdata, void *cbarg);
+	void *els_callback_arg;
+	uint32_t els_timeout_sec;	/**< timeout */
+
+	ocs_timer_t delay_timer;	/**< delay timer */
+
+	/* for abort handling */
+	ocs_io_t *io_to_abort;		/**< pointer to IO to abort */
+
+	ocs_list_link_t link;		/**< linked list link */
+	ocs_dma_t cmdbuf;		/**< SCSI Command buffer, used for CDB (initiator) */
+	ocs_dma_t rspbuf;		/**< SCSI Response buffer (i+t) */
+	uint32_t  timeout;		/**< Timeout value in seconds for this IO */
+	uint8_t   cs_ctl;		/**< CS_CTL priority for this IO */
+	uint8_t	  io_free;		/**< Is io object in freelist > */
+	uint32_t  app_id;		
+};
+
+/**
+ * @brief common IO callback argument
+ *
+ * Callback argument used as common I/O callback argument
+ */
+
+typedef struct {
+	int32_t status;				/**< completion status */
+	int32_t ext_status;			/**< extended completion status */
+	void *app;				/**< application argument */
+} ocs_io_cb_arg_t;
+
+/**
+ * @brief Test if IO object is busy
+ *
+ * Return True if IO object is busy.   Busy is defined as the IO object not being on
+ * the free list 
+ *
+ * @param io Pointer to IO object
+ *
+ * @return returns True if IO is busy
+ */
+
+static inline int32_t
+ocs_io_busy(ocs_io_t *io)
+{
+	return !(io->io_free);
+}
+
+typedef struct ocs_io_pool_s ocs_io_pool_t;
+
+extern ocs_io_pool_t *ocs_io_pool_create(ocs_t *ocs, uint32_t num_io, uint32_t num_sgl);
+extern int32_t ocs_io_pool_free(ocs_io_pool_t *io_pool);
+extern uint32_t ocs_io_pool_allocated(ocs_io_pool_t *io_pool);
+
+extern ocs_io_t *ocs_io_pool_io_alloc(ocs_io_pool_t *io_pool);
+extern void ocs_io_pool_io_free(ocs_io_pool_t *io_pool, ocs_io_t *io);
+extern ocs_io_t *ocs_io_find_tgt_io(ocs_t *ocs, ocs_node_t *node, uint16_t ox_id, uint16_t rx_id);
+extern void ocs_ddump_io(ocs_textbuf_t *textbuf, ocs_io_t *io);
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_ioctl.c b/sys/dev/ocs_fc/ocs_ioctl.c
new file mode 100644
index 000000000000..2a9157cfbc4e
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_ioctl.c
@@ -0,0 +1,1253 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#include "ocs.h"
+#include "ocs_utils.h"
+
+#include <sys/conf.h>
+#include <sys/sysctl.h>
+#include <sys/ioccom.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/linker.h>
+#include <sys/firmware.h>
+
+static d_open_t		ocs_open;
+static d_close_t	ocs_close;
+static d_ioctl_t	ocs_ioctl;
+
+static struct cdevsw ocs_cdevsw = {
+	.d_version =	D_VERSION,
+	.d_open =	ocs_open,
+	.d_close =	ocs_close,
+	.d_ioctl =	ocs_ioctl,
+	.d_name =	"ocs_fc"
+};
+
+int
+ocs_firmware_write(ocs_t *ocs, const uint8_t *buf, size_t buf_len, uint8_t *change_status);
+
+static int
+ocs_open(struct cdev *cdev, int flags, int fmt, struct thread *td)
+{
+#if 0
+	struct ocs_softc *ocs = cdev->si_drv1;
+
+	device_printf(ocs->dev, "%s\n", __func__);
+#endif
+	return 0;
+}
+
+static int
+ocs_close(struct cdev *cdev, int flag, int fmt, struct thread *td)
+{
+#if 0
+	struct ocs_softc *ocs = cdev->si_drv1;
+
+	device_printf(ocs->dev, "%s\n", __func__);
+#endif
+	return 0;
+}
+
+static int32_t
+__ocs_ioctl_mbox_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	struct ocs_softc *ocs = arg;
+
+	/* wait for the ioctl to sleep before calling wakeup */
+	mtx_lock(&ocs->dbg_lock);
+
+	mtx_unlock(&ocs->dbg_lock);
+
+	wakeup(arg);
+
+	return 0;
+}
+
+static int
+ocs_process_sli_config (ocs_t *ocs, ocs_ioctl_elxu_mbox_t *mcmd, ocs_dma_t *dma){
+
+	sli4_cmd_sli_config_t *sli_config = (sli4_cmd_sli_config_t *)mcmd->payload;
+
+	if (sli_config->emb) {
+		sli4_req_hdr_t	*req = (sli4_req_hdr_t *)sli_config->payload.embed;
+
+		switch (req->opcode) {
+		case SLI4_OPC_COMMON_READ_OBJECT:
+			if (mcmd->out_bytes) {
+				sli4_req_common_read_object_t *rdobj =
+					(sli4_req_common_read_object_t *)sli_config->payload.embed;
+
+				if (ocs_dma_alloc(ocs, dma, mcmd->out_bytes, 4096)) {
+					device_printf(ocs->dev, "%s: COMMON_READ_OBJECT - %lld allocation failed\n",
+							__func__, (unsigned long long)mcmd->out_bytes);
+					return ENXIO;
+				}
+
+				memset(dma->virt, 0, mcmd->out_bytes);
+
+				rdobj->host_buffer_descriptor[0].bde_type = SLI4_BDE_TYPE_BDE_64;
+				rdobj->host_buffer_descriptor[0].buffer_length = mcmd->out_bytes;
+				rdobj->host_buffer_descriptor[0].u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
+				rdobj->host_buffer_descriptor[0].u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+
+			}
+			break;
+		case SLI4_OPC_COMMON_WRITE_OBJECT:
+		{
+			sli4_req_common_write_object_t *wrobj =
+				(sli4_req_common_write_object_t *)sli_config->payload.embed;
+
+			if (ocs_dma_alloc(ocs, dma, wrobj->desired_write_length, 4096)) {
+				device_printf(ocs->dev, "%s: COMMON_WRITE_OBJECT - %d allocation failed\n",
+						__func__, wrobj->desired_write_length);
+				return ENXIO;
+			}
+			/* setup the descriptor */
+			wrobj->host_buffer_descriptor[0].bde_type = SLI4_BDE_TYPE_BDE_64;
+			wrobj->host_buffer_descriptor[0].buffer_length = wrobj->desired_write_length;
+			wrobj->host_buffer_descriptor[0].u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
+			wrobj->host_buffer_descriptor[0].u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+
+			/* copy the data into the DMA buffer */
+			copyin((void *)mcmd->in_addr, dma->virt, mcmd->in_bytes);
+		}
+			break;
+		case SLI4_OPC_COMMON_DELETE_OBJECT:
+			break;
+		case SLI4_OPC_COMMON_READ_OBJECT_LIST:
+			if (mcmd->out_bytes) {
+				sli4_req_common_read_object_list_t *rdobj =
+					(sli4_req_common_read_object_list_t *)sli_config->payload.embed;
+
+				if (ocs_dma_alloc(ocs, dma, mcmd->out_bytes, 4096)) {
+					device_printf(ocs->dev, "%s: COMMON_READ_OBJECT_LIST - %lld allocation failed\n",
+							__func__,(unsigned long long) mcmd->out_bytes);
+					return ENXIO;
+				}
+
+				memset(dma->virt, 0, mcmd->out_bytes);
+
+				rdobj->host_buffer_descriptor[0].bde_type = SLI4_BDE_TYPE_BDE_64;
+				rdobj->host_buffer_descriptor[0].buffer_length = mcmd->out_bytes;
+				rdobj->host_buffer_descriptor[0].u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
+				rdobj->host_buffer_descriptor[0].u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+
+			}
+			break;
+		case SLI4_OPC_COMMON_READ_TRANSCEIVER_DATA:
+			break;
+		default:
+			device_printf(ocs->dev, "%s: in=%p (%lld) out=%p (%lld)\n", __func__,
+					(void *)mcmd->in_addr, (unsigned long long)mcmd->in_bytes,
+					(void *)mcmd->out_addr, (unsigned long long)mcmd->out_bytes);
+			device_printf(ocs->dev, "%s: unknown (opc=%#x)\n", __func__,
+					req->opcode);
+			hexdump(mcmd, mcmd->size, NULL, 0);
+			break;
+		}
+	} else {
+		uint32_t max_bytes = max(mcmd->in_bytes, mcmd->out_bytes);
+		if (ocs_dma_alloc(ocs, dma, max_bytes, 4096)) {
+			device_printf(ocs->dev, "%s: non-embedded - %u allocation failed\n",
+					__func__, max_bytes);
+			return ENXIO;
+		}
+
+		copyin((void *)mcmd->in_addr, dma->virt, mcmd->in_bytes);
+
+		sli_config->payload.mem.address_low  = ocs_addr32_lo(dma->phys);
+		sli_config->payload.mem.address_high = ocs_addr32_hi(dma->phys);
+		sli_config->payload.mem.length       = max_bytes;
+	}
+
+	return 0;
+}
+
+static int
+ocs_process_mbx_ioctl(ocs_t *ocs, ocs_ioctl_elxu_mbox_t *mcmd)
+{
+	ocs_dma_t	dma = { 0 };
+
+	if ((ELXU_BSD_MAGIC != mcmd->magic) ||
+			(sizeof(ocs_ioctl_elxu_mbox_t) != mcmd->size)) {
+		device_printf(ocs->dev, "%s: malformed command m=%08x s=%08x\n",
+				__func__, mcmd->magic, mcmd->size);
+		return EINVAL;
+	}
+
+	switch(((sli4_mbox_command_header_t *)mcmd->payload)->command) {
+	case SLI4_MBOX_COMMAND_SLI_CONFIG:
+		if (ENXIO == ocs_process_sli_config(ocs, mcmd, &dma))
+			return ENXIO;
+		break;
+
+	case SLI4_MBOX_COMMAND_READ_REV:
+	case SLI4_MBOX_COMMAND_READ_STATUS:
+	case SLI4_MBOX_COMMAND_READ_LNK_STAT:
+		break;
+
+	default:
+		device_printf(ocs->dev, "command %d\n",((sli4_mbox_command_header_t *)mcmd->payload)->command);
+		device_printf(ocs->dev, "%s, command not support\n", __func__);
+		goto no_support;
+		break;
+
+	}
+
+	/*
+	 * The dbg_lock usage here insures the command completion code
+	 * (__ocs_ioctl_mbox_cb), which calls wakeup(), does not run until
+	 * after first calling msleep()
+	 *
+	 *  1. ioctl grabs dbg_lock
+	 *  2. ioctl issues command
+	 *       if the command completes before msleep(), the
+	 *       command completion code (__ocs_ioctl_mbox_cb) will spin
+	 *       on dbg_lock before calling wakeup()
+	 *  3. ioctl calls msleep which releases dbg_lock before sleeping
+	 *     and reacquires it before waking
+	 *  4. command completion handler acquires the dbg_lock, immediately
+	 *     releases it, and calls wakeup
+	 *  5. msleep returns, re-acquiring the lock
+	 *  6. ioctl code releases the lock
+	 */
+	mtx_lock(&ocs->dbg_lock);
+		ocs_hw_command(&ocs->hw, mcmd->payload, OCS_CMD_NOWAIT,
+				__ocs_ioctl_mbox_cb, ocs);
+		msleep(ocs, &ocs->dbg_lock, 0, "ocsmbx", 0);
+	mtx_unlock(&ocs->dbg_lock);
+
+	if( SLI4_MBOX_COMMAND_SLI_CONFIG == ((sli4_mbox_command_header_t *)mcmd->payload)->command
+	  		&& mcmd->out_bytes && dma.virt) {
+		copyout(dma.virt, (void *)mcmd->out_addr, mcmd->out_bytes);
+	}
+
+no_support:
+	ocs_dma_free(ocs, &dma);
+
+	return 0;
+}
+
+/**
+ * @brief perform requested Elx CoreDump helper function
+ *
+ * The Elx CoreDump facility used for BE3 diagnostics uses the OCS_IOCTL_CMD_ECD_HELPER
+ * ioctl function to execute requested "help" functions
+ *
+ * @param ocs pointer to ocs structure
+ * @param req pointer to helper function request
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+static int
+ocs_process_ecd_helper (ocs_t *ocs, ocs_ioctl_ecd_helper_t *req)
+{
+	int32_t rc = 0;
+	uint8_t v8;
+	uint16_t v16;
+	uint32_t v32;
+
+
+	/* Check the BAR read/write commands for valid bar */
+	switch(req->cmd) {
+	case OCS_ECD_HELPER_BAR_READ8:
+	case OCS_ECD_HELPER_BAR_READ16:
+	case OCS_ECD_HELPER_BAR_READ32:
+	case OCS_ECD_HELPER_BAR_WRITE8:
+	case OCS_ECD_HELPER_BAR_WRITE16:
+	case OCS_ECD_HELPER_BAR_WRITE32:
+		if (req->bar >= PCI_MAX_BAR) {
+			device_printf(ocs->dev, "Error: bar %d out of range\n", req->bar);
+			return -EFAULT;
+		}
+		if (ocs->reg[req->bar].res == NULL) {
+			device_printf(ocs->dev, "Error: bar %d not defined\n", req->bar);
+			return -EFAULT;
+		}
+		break;
+	default:
+		break;
+	}
+
+	switch(req->cmd) {
+	case OCS_ECD_HELPER_CFG_READ8:
+		v8 = ocs_config_read8(ocs, req->offset);
+		req->data = v8;
+		break;
+	case OCS_ECD_HELPER_CFG_READ16:
+		v16 = ocs_config_read16(ocs, req->offset);
+		req->data = v16;
+		break;
+	case OCS_ECD_HELPER_CFG_READ32:
+		v32 = ocs_config_read32(ocs, req->offset);
+		req->data = v32;
+		break;
+	case OCS_ECD_HELPER_CFG_WRITE8:
+		ocs_config_write8(ocs, req->offset, req->data);
+		break;
+	case OCS_ECD_HELPER_CFG_WRITE16:
+		ocs_config_write16(ocs, req->offset, req->data);
+		break;
+	case OCS_ECD_HELPER_CFG_WRITE32:
+		ocs_config_write32(ocs, req->offset, req->data);
+		break;
+	case OCS_ECD_HELPER_BAR_READ8:
+		req->data = ocs_reg_read8(ocs, req->bar, req->offset);
+		break;
+	case OCS_ECD_HELPER_BAR_READ16:
+		req->data = ocs_reg_read16(ocs, req->bar, req->offset);
+		break;
+	case OCS_ECD_HELPER_BAR_READ32:
+		req->data = ocs_reg_read32(ocs, req->bar, req->offset);
+		break;
+	case OCS_ECD_HELPER_BAR_WRITE8:
+		ocs_reg_write8(ocs, req->bar, req->offset, req->data);
+		break;
+	case OCS_ECD_HELPER_BAR_WRITE16:
+		ocs_reg_write16(ocs, req->bar, req->offset, req->data);
+		break;
+	case OCS_ECD_HELPER_BAR_WRITE32:
+		ocs_reg_write32(ocs, req->bar, req->offset, req->data);
+		break;
+	default:
+		device_printf(ocs->dev, "Invalid helper command=%d\n", req->cmd);
+		break;
+	}
+
+	return rc;
+}
+
+static int
+ocs_ioctl(struct cdev *cdev, u_long cmd, caddr_t addr, int flag, struct thread *td)
+{
+	int status = 0;
+	struct ocs_softc *ocs = cdev->si_drv1;
+	device_t dev = ocs->dev;
+
+	switch (cmd) {
+	case OCS_IOCTL_CMD_ELXU_MBOX: {
+		/* "copyin" done by kernel; thus, just dereference addr */
+		ocs_ioctl_elxu_mbox_t *mcmd = (void *)addr;
+		status = ocs_process_mbx_ioctl(ocs, mcmd);
+		break;
+	}
+	case OCS_IOCTL_CMD_ECD_HELPER: {
+		/* "copyin" done by kernel; thus, just dereference addr */
+		ocs_ioctl_ecd_helper_t *req = (void *)addr;
+		status = ocs_process_ecd_helper(ocs, req);
+		break;
+	}
+
+	case OCS_IOCTL_CMD_VPORT: {
+		int32_t rc = 0;
+		ocs_ioctl_vport_t *req = (ocs_ioctl_vport_t*) addr;
+		ocs_domain_t *domain;
+
+		domain = ocs_domain_get_instance(ocs, req->domain_index);
+		if (domain == NULL) {
+			device_printf(ocs->dev, "domain [%d] nod found\n",
+							req->domain_index);
+			return -EFAULT;
+		}
+
+		if (req->req_create) {
+			rc = ocs_sport_vport_new(domain, req->wwpn, req->wwnn, 
+						UINT32_MAX, req->enable_ini,
+					req->enable_tgt, NULL, NULL, TRUE);
+		} else {
+			rc = ocs_sport_vport_del(ocs, domain, req->wwpn, req->wwnn);
+		}
+
+		return rc;
+	}
+
+	case OCS_IOCTL_CMD_GET_DDUMP: {
+		ocs_ioctl_ddump_t *req = (ocs_ioctl_ddump_t*) addr;
+		ocs_textbuf_t textbuf;
+		int x;
+
+		/* Build a text buffer */
+		if (ocs_textbuf_alloc(ocs, &textbuf, req->user_buffer_len)) {
+			device_printf(ocs->dev, "Error: ocs_textbuf_alloc failed\n");
+			return -EFAULT;
+		}
+
+		switch (req->args.action) {
+		case OCS_IOCTL_DDUMP_GET:
+		case OCS_IOCTL_DDUMP_GET_SAVED: {
+			uint32_t remaining;
+			uint32_t written;
+			uint32_t idx;
+			int32_t n;
+			ocs_textbuf_t *ptbuf = NULL;
+			uint32_t flags = 0;
+
+			if (req->args.action == OCS_IOCTL_DDUMP_GET_SAVED) {
+				if (ocs_textbuf_initialized(&ocs->ddump_saved)) {
+					ptbuf = &ocs->ddump_saved;
+				}
+			} else {
+				if (ocs_textbuf_alloc(ocs, &textbuf, req->user_buffer_len)) {
+					ocs_log_err(ocs, "Error: ocs_textbuf_alloc failed\n");
+					return -EFAULT;
+				}
+
+				/* translate IOCTL ddump flags to ddump flags */
+				if (req->args.flags & OCS_IOCTL_DDUMP_FLAGS_WQES) {
+					flags |= OCS_DDUMP_FLAGS_WQES;
+				}
+				if (req->args.flags & OCS_IOCTL_DDUMP_FLAGS_CQES) {
+					flags |= OCS_DDUMP_FLAGS_CQES;
+				}
+				if (req->args.flags & OCS_IOCTL_DDUMP_FLAGS_MQES) {
+					flags |= OCS_DDUMP_FLAGS_MQES;
+				}
+				if (req->args.flags & OCS_IOCTL_DDUMP_FLAGS_RQES) {
+					flags |= OCS_DDUMP_FLAGS_RQES;
+				}
+				if (req->args.flags & OCS_IOCTL_DDUMP_FLAGS_EQES) {
+					flags |= OCS_DDUMP_FLAGS_EQES;
+				}
+
+				/* Try 3 times to get the dump */
+				for(x=0; x<3; x++) {
+					if (ocs_ddump(ocs, &textbuf, flags, req->args.q_entries) != 0) {
+						ocs_textbuf_reset(&textbuf);
+					} else {
+						/* Success */
+						x = 0;
+						break;
+					}
+				}
+				if (x != 0 ) {
+					/* Retries failed */
+					ocs_log_test(ocs, "ocs_ddump failed\n");
+				} else {
+					ptbuf = &textbuf;
+				}
+
+			}
+			written = 0;
+			if (ptbuf != NULL) {
+				/* Process each textbuf segment */
+				remaining = req->user_buffer_len;
+				for (idx = 0; remaining; idx++) {
+					n = ocs_textbuf_ext_get_written(ptbuf, idx);
+					if (n < 0) {
+						break;
+					}
+					if ((uint32_t)n >= remaining) {
+						n = (int32_t)remaining;
+					}
+					if (ocs_copy_to_user(req->user_buffer + written,
+						ocs_textbuf_ext_get_buffer(ptbuf, idx), n)) {
+						ocs_log_test(ocs, "Error: (%d) ocs_copy_to_user failed\n", __LINE__);
+					}
+					written += n;
+					remaining -= (uint32_t)n;
+				}
+			}
+			req->bytes_written = written;
+			if (ptbuf == &textbuf) {
+				ocs_textbuf_free(ocs, &textbuf);
+			}
+
+			break;
+		}
+		case OCS_IOCTL_DDUMP_CLR_SAVED:
+			ocs_clear_saved_ddump(ocs);
+			break;
+		default:
+			ocs_log_err(ocs, "Error: ocs_textbuf_alloc failed\n");
+			break;
+		}
+		break;
+	}
+	case OCS_IOCTL_CMD_DRIVER_INFO: {
+		ocs_ioctl_driver_info_t *req = (ocs_ioctl_driver_info_t*)addr;
+
+		ocs_memset(req, 0, sizeof(*req));
+
+		req->pci_vendor = ocs->pci_vendor;
+		req->pci_device = ocs->pci_device;
+		ocs_strncpy(req->businfo, ocs->businfo, sizeof(req->businfo));
+
+		req->sli_intf = ocs_config_read32(ocs, SLI4_INTF_REG);
+		ocs_strncpy(req->desc, device_get_desc(dev), sizeof(req->desc));
+		ocs_strncpy(req->fw_rev, ocs->fwrev, sizeof(req->fw_rev));
+		if (ocs->domain && ocs->domain->sport) {
+			*((uint64_t*)req->hw_addr.fc.wwnn) = ocs_htobe64(ocs->domain->sport->wwnn);
+			*((uint64_t*)req->hw_addr.fc.wwpn) = ocs_htobe64(ocs->domain->sport->wwpn);
+		}
+		ocs_strncpy(req->serialnum, ocs->serialnum, sizeof(req->serialnum));
+		break;
+	}
+
+	case OCS_IOCTL_CMD_MGMT_LIST: {
+		ocs_ioctl_mgmt_buffer_t* req = (ocs_ioctl_mgmt_buffer_t *)addr;
+		ocs_textbuf_t textbuf;
+
+		/* Build a text buffer */
+		if (ocs_textbuf_alloc(ocs, &textbuf, req->user_buffer_len)) {
+			ocs_log_err(ocs, "Error: ocs_textbuf_alloc failed\n");
+			return -EFAULT;
+		}
+
+		ocs_mgmt_get_list(ocs, &textbuf);
+
+		if (ocs_textbuf_get_written(&textbuf)) {
+			if (ocs_copy_to_user(req->user_buffer,
+				ocs_textbuf_get_buffer(&textbuf), 
+				ocs_textbuf_get_written(&textbuf))) {
+				ocs_log_test(ocs, "Error: (%d) ocs_copy_to_user failed\n", __LINE__);
+			}
+		}
+		req->bytes_written = ocs_textbuf_get_written(&textbuf);
+
+		ocs_textbuf_free(ocs, &textbuf);
+
+		break;
+
+	}
+
+	case OCS_IOCTL_CMD_MGMT_GET_ALL: {
+		ocs_ioctl_mgmt_buffer_t* req = (ocs_ioctl_mgmt_buffer_t *)addr;
+		ocs_textbuf_t textbuf;
+		int32_t n;
+		uint32_t idx;
+		uint32_t copied = 0;
+
+		/* Build a text buffer */
+		if (ocs_textbuf_alloc(ocs, &textbuf, req->user_buffer_len)) {
+			ocs_log_err(ocs, "Error: ocs_textbuf_alloc failed\n");
+			return -EFAULT;
+		}
+
+		ocs_mgmt_get_all(ocs, &textbuf);
+
+		for (idx = 0; (n = ocs_textbuf_ext_get_written(&textbuf, idx)) > 0; idx++) {
+			if(ocs_copy_to_user(req->user_buffer + copied, 
+					ocs_textbuf_ext_get_buffer(&textbuf, idx),
+					ocs_textbuf_ext_get_written(&textbuf, idx))) {
+
+					ocs_log_err(ocs, "Error: ocs_textbuf_alloc failed\n");
+			}
+			copied += n;
+		}
+		req->bytes_written = copied;
+
+		ocs_textbuf_free(ocs, &textbuf);
+
+		break;
+	}
+
+	case OCS_IOCTL_CMD_MGMT_GET: {
+		ocs_ioctl_cmd_get_t* req = (ocs_ioctl_cmd_get_t*)addr;
+		ocs_textbuf_t textbuf;
+		char name[OCS_MGMT_MAX_NAME];
+
+		/* Copy the name value in from user space */
+		if (ocs_copy_from_user(name, req->name, OCS_MGMT_MAX_NAME)) {
+			ocs_log_test(ocs, "ocs_copy_from_user failed\n");
+			ocs_ioctl_free(ocs, req, sizeof(ocs_ioctl_cmd_get_t));
+			return -EFAULT;
+		}
+
+		/* Build a text buffer */
+		if (ocs_textbuf_alloc(ocs, &textbuf, req->value_length)) {
+			ocs_log_err(ocs, "Error: ocs_textbuf_alloc failed\n");
+			return -EFAULT;
+		}
+
+		ocs_mgmt_get(ocs, name, &textbuf);
+
+		if (ocs_textbuf_get_written(&textbuf)) {
+			if (ocs_copy_to_user(req->value, 
+				ocs_textbuf_get_buffer(&textbuf), 
+				ocs_textbuf_get_written(&textbuf))) {
+				ocs_log_test(ocs, "Error: (%d) ocs_copy_to_user failed\n", __LINE__);
+
+		}
+		}
+		req->value_length = ocs_textbuf_get_written(&textbuf);
+
+		ocs_textbuf_free(ocs, &textbuf);
+
+		break;
+	}
+
+	case OCS_IOCTL_CMD_MGMT_SET: {
+		char name[OCS_MGMT_MAX_NAME];
+		char value[OCS_MGMT_MAX_VALUE];
+		ocs_ioctl_cmd_set_t* req = (ocs_ioctl_cmd_set_t*)addr;
+		
+		// Copy the name  in from user space
+		if (ocs_copy_from_user(name, req->name, OCS_MGMT_MAX_NAME)) {
+			ocs_log_test(ocs, "Error: copy from user failed\n");
+			ocs_ioctl_free(ocs, req, sizeof(*req));
+			return -EFAULT;
+		}
+
+		// Copy the  value in from user space
+		if (ocs_copy_from_user(value, req->value, OCS_MGMT_MAX_VALUE)) {
+			ocs_log_test(ocs, "Error: copy from user failed\n");
+			ocs_ioctl_free(ocs, req, sizeof(*req));
+			return -EFAULT;
+		}
+
+		req->result = ocs_mgmt_set(ocs, req->name, req->value);
+
+		break;
+	}
+
+	case OCS_IOCTL_CMD_MGMT_EXEC: {
+		ocs_ioctl_action_t* req = (ocs_ioctl_action_t*) addr;
+		char action_name[OCS_MGMT_MAX_NAME];
+
+		if (ocs_copy_from_user(action_name, req->name, sizeof(action_name))) {
+			ocs_log_test(ocs, "Error: copy req.name from user failed\n");
+			ocs_ioctl_free(ocs, req, sizeof(*req));
+			return -EFAULT;
+		}
+
+		req->result = ocs_mgmt_exec(ocs, action_name, req->arg_in, req->arg_in_length,
+				req->arg_out, req->arg_out_length);
+
+		break;
+	}
+
+	default:
+		ocs_log_test(ocs, "Error: unknown cmd %#lx\n", cmd);
+		status = -ENOTTY;
+		break;
+	}
+	return status;
+}
+
+static void
+ocs_fw_write_cb(int32_t status, uint32_t actual_write_length, 
+					uint32_t change_status, void *arg)
+{
+        ocs_mgmt_fw_write_result_t *result = arg;
+
+        result->status = status;
+        result->actual_xfer = actual_write_length;
+        result->change_status = change_status;
+
+        ocs_sem_v(&(result->semaphore));
+}
+
+int
+ocs_firmware_write(ocs_t *ocs, const uint8_t *buf, size_t buf_len, 
+						uint8_t *change_status)
+{
+        int rc = 0;
+        uint32_t bytes_left;
+        uint32_t xfer_size;
+        uint32_t offset;
+        ocs_dma_t dma;
+        int last = 0;
+        ocs_mgmt_fw_write_result_t result;
+
+        ocs_sem_init(&(result.semaphore), 0, "fw_write");
+
+        bytes_left = buf_len;
+        offset = 0;
+
+        if (ocs_dma_alloc(ocs, &dma, FW_WRITE_BUFSIZE, 4096)) {
+                ocs_log_err(ocs, "ocs_firmware_write: malloc failed\n");
+                return -ENOMEM;
+        }
+
+        while (bytes_left > 0) {
+
+                if (bytes_left > FW_WRITE_BUFSIZE) {
+                        xfer_size = FW_WRITE_BUFSIZE;
+                } else {
+                        xfer_size = bytes_left;
+                }
+
+                ocs_memcpy(dma.virt, buf + offset, xfer_size);
+
+                if (bytes_left == xfer_size) {
+                        last = 1;
+                }
+
+                ocs_hw_firmware_write(&ocs->hw, &dma, xfer_size, offset, 
+						last, ocs_fw_write_cb, &result);
+
+                if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+                        rc = -ENXIO;
+                        break;
+                }
+
+                if (result.actual_xfer == 0 || result.status != 0) {
+                        rc = -EFAULT;
+                        break;
+                }
+
+                if (last) {
+                        *change_status = result.change_status;
+                }
+
+                bytes_left -= result.actual_xfer;
+                offset += result.actual_xfer;
+        }
+
+        ocs_dma_free(ocs, &dma);
+        return rc;
+}
+
+static int
+ocs_sys_fwupgrade(SYSCTL_HANDLER_ARGS)
+{
+	char file_name[256] = {0};
+	char fw_change_status;
+	uint32_t rc = 1;
+        ocs_t *ocs  = (ocs_t *)arg1;
+        const struct firmware *fw;
+	const struct ocs_hw_grp_hdr *fw_image;
+
+        rc = sysctl_handle_string(oidp, file_name, sizeof(file_name), req);
+        if (rc || !req->newptr)
+                return rc;
+
+        fw = firmware_get(file_name);
+        if (fw == NULL) {
+                device_printf(ocs->dev, "Unable to get Firmware. "
+                        "Make sure %s is copied to /boot/modules\n", file_name);
+                return ENOENT;
+        }
+
+	fw_image = (const struct ocs_hw_grp_hdr *)fw->data;
+
+        /* Check if firmware provided is compatible with this particular
+         * Adapter of not*/
+        if ((ocs_be32toh(fw_image->magic_number) != OCS_HW_OBJECT_G5) &&
+                (ocs_be32toh(fw_image->magic_number) != OCS_HW_OBJECT_G6)) {
+                device_printf(ocs->dev,
+                        "Invalid FW image found Magic: 0x%x Size: %zu \n",
+                        ocs_be32toh(fw_image->magic_number), fw->datasize);
+                rc = -1;
+                goto exit;
+
+        }
+
+        if (!strncmp(ocs->fw_version, fw_image->revision, 
+					strnlen(fw_image->revision, 16))) {
+                device_printf(ocs->dev, "No update req. "
+				"Firmware is already up to date. \n");
+                rc = 0;
+                goto exit;
+        }
+
+	device_printf(ocs->dev, "Upgrading Firmware from %s to %s \n", 
+				ocs->fw_version, fw_image->revision);
+
+	rc = ocs_firmware_write(ocs, fw->data, fw->datasize, &fw_change_status);
+        if (rc) {
+                ocs_log_err(ocs, "Firmware update failed with status = %d\n", rc);
+        } else {
+                ocs_log_info(ocs, "Firmware updated successfully\n");
+                switch (fw_change_status) {
+                        case 0x00:
+                                device_printf(ocs->dev, 
+				"No reset needed, new firmware is active.\n");
+                                break;
+                        case 0x01:
+                                device_printf(ocs->dev,
+				"A physical device reset (host reboot) is "
+				"needed to activate the new firmware\n");
+                                break;
+                        case 0x02:
+                        case 0x03:
+                                device_printf(ocs->dev,
+				"firmware is resetting to activate the new "
+				"firmware, Host reboot is needed \n");
+                                break;
+                        default:
+                                ocs_log_warn(ocs,
+                                        "Unexected value change_status: %d\n",
+                                        fw_change_status);
+                                break;
+                }
+
+        }
+
+exit:
+        /* Release Firmware*/
+        firmware_put(fw, FIRMWARE_UNLOAD);
+
+        return rc;
+
+}
+
+static int
+ocs_sysctl_wwnn(SYSCTL_HANDLER_ARGS)
+{
+	uint32_t rc = 1;
+	ocs_t *ocs = oidp->oid_arg1;
+	char old[64];
+	char new[64];
+	uint64_t *wwnn = NULL;
+	ocs_xport_t *xport = ocs->xport;
+
+	if (xport->req_wwnn) {
+		wwnn = &xport->req_wwnn;
+		memset(old, 0, sizeof(old));
+		snprintf(old, sizeof(old), "0x%llx" , (unsigned long long) *wwnn);
+
+	} else {
+		wwnn = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_NODE);
+
+		memset(old, 0, sizeof(old));
+		snprintf(old, sizeof(old), "0x%llx" , (unsigned long long) ocs_htobe64(*wwnn));
+	}
+
+	/*Read wwnn*/
+	if (!req->newptr) {
+
+		return (sysctl_handle_string(oidp, old, sizeof(old), req));
+	}
+
+	/*Configure port wwn*/
+	rc = sysctl_handle_string(oidp, new, sizeof(new), req);
+	if (rc)
+		return (rc);
+
+	if (strncmp(old, new, strlen(old)) == 0) {
+		return 0;
+	}
+
+	return (set_req_wwnn(ocs, NULL, new));
+}
+
+static int
+ocs_sysctl_wwpn(SYSCTL_HANDLER_ARGS)
+{
+	uint32_t rc = 1;
+	ocs_t *ocs = oidp->oid_arg1;
+	char old[64];
+	char new[64];
+	uint64_t *wwpn = NULL;
+	ocs_xport_t *xport = ocs->xport;
+
+	if (xport->req_wwpn) {
+		wwpn = &xport->req_wwpn;
+		memset(old, 0, sizeof(old));
+		snprintf(old, sizeof(old), "0x%llx",(unsigned long long) *wwpn);
+	} else {
+		wwpn = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_PORT);
+		memset(old, 0, sizeof(old));
+		snprintf(old, sizeof(old), "0x%llx",(unsigned long long) ocs_htobe64(*wwpn));
+	}
+
+
+	/*Read wwpn*/
+	if (!req->newptr) {
+		return (sysctl_handle_string(oidp, old, sizeof(old), req));
+	}
+
+	/*Configure port wwn*/
+	rc = sysctl_handle_string(oidp, new, sizeof(new), req);
+	if (rc)
+		return (rc);
+
+	if (strncmp(old, new, strlen(old)) == 0) {
+		return 0;
+	}
+
+	return (set_req_wwpn(ocs, NULL, new));
+}
+
+static int
+ocs_sysctl_current_topology(SYSCTL_HANDLER_ARGS)
+{
+	ocs_t *ocs = oidp->oid_arg1;
+	uint32_t value;
+
+	ocs_hw_get(&ocs->hw, OCS_HW_TOPOLOGY, &value);
+
+	return (sysctl_handle_int(oidp, &value, 0, req));
+}
+
+static int
+ocs_sysctl_current_speed(SYSCTL_HANDLER_ARGS)
+{
+	ocs_t *ocs = oidp->oid_arg1;
+	uint32_t value;
+
+	ocs_hw_get(&ocs->hw, OCS_HW_LINK_SPEED, &value);
+
+	return (sysctl_handle_int(oidp, &value, 0, req));
+}
+
+static int
+ocs_sysctl_config_topology(SYSCTL_HANDLER_ARGS)
+{
+	uint32_t rc = 1;
+	ocs_t *ocs = oidp->oid_arg1;
+	uint32_t old_value;
+	uint32_t new_value;
+	char buf[64];
+
+	ocs_hw_get(&ocs->hw, OCS_HW_CONFIG_TOPOLOGY, &old_value);
+
+	/*Read topo*/
+	if (!req->newptr) {
+		return (sysctl_handle_int(oidp, &old_value, 0, req));
+	}
+
+	/*Configure port wwn*/
+	rc = sysctl_handle_int(oidp, &new_value, 0, req);
+	if (rc)
+		return (rc);
+
+	if (new_value == old_value) {
+		return 0;
+	}
+
+	snprintf(buf, sizeof(buf), "%d",new_value);
+	rc = set_configured_topology(ocs, NULL, buf);
+	return rc;
+}
+
+static int
+ocs_sysctl_config_speed(SYSCTL_HANDLER_ARGS)
+{
+	uint32_t rc = 1;
+	ocs_t *ocs = oidp->oid_arg1;
+	uint32_t old_value;
+	uint32_t new_value;
+	char buf[64];
+
+	ocs_hw_get(&ocs->hw, OCS_HW_LINK_CONFIG_SPEED, &old_value);
+
+	/*Read topo*/
+	if (!req->newptr) {
+		return (sysctl_handle_int(oidp, &old_value, 0, req));
+	}
+
+	/*Configure port wwn*/
+	rc = sysctl_handle_int(oidp, &new_value, 0, req);
+	if (rc)
+		return (rc);
+
+	if (new_value == old_value) {
+		return 0;
+	}
+
+	snprintf(buf, sizeof(buf), "%d",new_value);
+	rc = set_configured_speed(ocs, NULL,buf);
+	return rc;
+}
+
+static int
+ocs_sysctl_fcid(SYSCTL_HANDLER_ARGS)
+{
+	ocs_t *ocs = oidp->oid_arg1;
+	char buf[64];
+
+	memset(buf, 0, sizeof(buf));
+	if (ocs->domain && ocs->domain->attached) {
+		snprintf(buf, sizeof(buf), "0x%06x", 
+			ocs->domain->sport->fc_id);
+	}
+
+	return (sysctl_handle_string(oidp, buf, sizeof(buf), req));
+}
+
+
+static int
+ocs_sysctl_port_state(SYSCTL_HANDLER_ARGS)
+{
+
+	char new[256] = {0};
+	uint32_t rc = 1;
+	ocs_xport_stats_t old;
+	ocs_t *ocs  = (ocs_t *)arg1;
+
+	ocs_xport_status(ocs->xport, OCS_XPORT_CONFIG_PORT_STATUS, &old);
+
+	/*Read port state */
+	if (!req->newptr) {
+		snprintf(new, sizeof(new), "%s",
+			(old.value == OCS_XPORT_PORT_OFFLINE) ?
+					 "offline" : "online");	
+		return (sysctl_handle_string(oidp, new, sizeof(new), req));
+        }
+	
+	/*Configure port state*/
+	rc = sysctl_handle_string(oidp, new, sizeof(new), req);
+	if (rc)
+		return (rc);
+
+	if (ocs_strcasecmp(new, "offline") == 0) {
+		if (old.value == OCS_XPORT_PORT_OFFLINE) {
+			return (0);
+		}
+		ocs_log_debug(ocs, "Setting port to %s\n", new);
+		rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
+		if (rc != 0) {
+			ocs_log_err(ocs, "Setting port to offline failed\n");
+		}
+	} else if (ocs_strcasecmp(new, "online") == 0) {
+		if (old.value == OCS_XPORT_PORT_ONLINE) {
+			return (0);
+		}
+		ocs_log_debug(ocs, "Setting port to %s\n", new);
+		rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+		if (rc != 0) {
+			ocs_log_err(ocs, "Setting port to online failed\n");
+		}
+	} else {
+		ocs_log_err(ocs, "Unsupported link state %s\n", new);
+		rc = 1;
+	}
+
+	return (rc);	
+
+}
+
+static int
+ocs_sysctl_vport_wwpn(SYSCTL_HANDLER_ARGS)
+{
+	ocs_fcport *fcp = oidp->oid_arg1;
+	char str_wwpn[64];
+
+	memset(str_wwpn, 0, sizeof(str_wwpn));
+	snprintf(str_wwpn, sizeof(str_wwpn), "0x%llx", (unsigned long long)fcp->vport->wwpn);
+	
+	return (sysctl_handle_string(oidp, str_wwpn, sizeof(str_wwpn), req));
+}
+
+static int
+ocs_sysctl_vport_wwnn(SYSCTL_HANDLER_ARGS)
+{
+	ocs_fcport *fcp = oidp->oid_arg1;
+	char str_wwnn[64];
+
+	memset(str_wwnn, 0, sizeof(str_wwnn));
+	snprintf(str_wwnn, sizeof(str_wwnn), "0x%llx", (unsigned long long)fcp->vport->wwnn);
+
+	return (sysctl_handle_string(oidp, str_wwnn, sizeof(str_wwnn), req));
+}
+
+/**
+ * @brief Initialize sysctl
+ *
+ * Initialize sysctl so elxsdkutil can query device information.
+ *
+ * @param ocs pointer to ocs
+ * @return void
+ */
+static void
+ocs_sysctl_init(ocs_t *ocs)
+{
+	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(ocs->dev);
+	struct sysctl_oid *tree = device_get_sysctl_tree(ocs->dev);
+	struct sysctl_oid *vtree; 
+	const char *str = NULL;
+	char sli_intf[16], name[16];
+	uint32_t rev, if_type, family, i;
+	ocs_fcport *fcp = NULL;
+
+	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"devid", CTLFLAG_RD, NULL,
+			pci_get_devid(ocs->dev), "Device ID");
+
+	memset(ocs->modeldesc, 0, sizeof(ocs->modeldesc));
+	if (0 == pci_get_vpd_ident(ocs->dev, &str)) {
+		snprintf(ocs->modeldesc, sizeof(ocs->modeldesc), "%s", str);
+	}
+	SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"modeldesc", CTLFLAG_RD,
+			ocs->modeldesc,
+			0, "Model Description");
+
+	memset(ocs->serialnum, 0, sizeof(ocs->serialnum));
+	if (0 == pci_get_vpd_readonly(ocs->dev, "SN", &str)) {
+		snprintf(ocs->serialnum, sizeof(ocs->serialnum), "%s", str);
+	}
+	SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"sn", CTLFLAG_RD,
+			ocs->serialnum,
+			0, "Serial Number");
+
+	ocs_hw_get(&ocs->hw, OCS_HW_SLI_REV, &rev);
+	ocs_hw_get(&ocs->hw, OCS_HW_IF_TYPE, &if_type);
+	ocs_hw_get(&ocs->hw, OCS_HW_SLI_FAMILY, &family);
+
+	memset(ocs->fwrev, 0, sizeof(ocs->fwrev));
+	snprintf(ocs->fwrev, sizeof(ocs->fwrev), "%s, sli-%d:%d:%x",
+			(char *)ocs_hw_get_ptr(&ocs->hw, OCS_HW_FW_REV),
+			rev, if_type, family);
+	SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"fwrev", CTLFLAG_RD,
+			ocs->fwrev,
+			0, "Firmware Revision");
+
+	memset(ocs->sli_intf, 0, sizeof(ocs->sli_intf));
+	snprintf(ocs->sli_intf, sizeof(sli_intf), "%08x",
+		 ocs_config_read32(ocs, SLI4_INTF_REG));
+	SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			  "sli_intf", CTLFLAG_RD,
+			  ocs->sli_intf,
+			  0, "SLI Interface");
+
+        SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "fw_upgrade",
+                CTLTYPE_STRING | CTLFLAG_RW, (void *)ocs, 0,
+                ocs_sys_fwupgrade, "A", "Firmware grp file");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"wwnn", CTLTYPE_STRING | CTLFLAG_RW,
+			ocs, 0, ocs_sysctl_wwnn, "A",
+			"World Wide Node Name, wwnn should be in the format 0x<XXXXXXXXXXXXXXXX>");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"wwpn", CTLTYPE_STRING | CTLFLAG_RW,
+			ocs, 0, ocs_sysctl_wwpn, "A",
+			"World Wide Port Name, wwpn should be in the format 0x<XXXXXXXXXXXXXXXX>");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"current_topology", CTLTYPE_UINT | CTLFLAG_RD,
+			ocs, 0, ocs_sysctl_current_topology, "IU",
+			"Current Topology, 1-NPort; 2-Loop; 3-None");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"current_speed", CTLTYPE_UINT | CTLFLAG_RD,
+			ocs, 0, ocs_sysctl_current_speed, "IU",
+			"Current Speed");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"configured_topology", CTLTYPE_UINT | CTLFLAG_RW,
+			ocs, 0, ocs_sysctl_config_topology, "IU",
+			"Configured Topology, 0-Auto; 1-NPort; 2-Loop");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"configured_speed", CTLTYPE_UINT | CTLFLAG_RW,
+			ocs, 0, ocs_sysctl_config_speed, "IU",
+			"Configured Speed, 0-Auto, 2000, 4000, 8000, 16000, 32000");
+
+	SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"businfo", CTLFLAG_RD,
+			ocs->businfo,
+			0, "Bus Info");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"fcid", CTLTYPE_STRING | CTLFLAG_RD,
+			ocs, 0, ocs_sysctl_fcid, "A",
+			"Port FC ID");
+
+	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+			"port_state", CTLTYPE_STRING | CTLFLAG_RW,
+			ocs, 0, ocs_sysctl_port_state, "A",
+			"configured port state");
+
+	for (i	= 0; i < ocs->num_vports; i++) {
+		fcp = FCPORT(ocs, i+1);
+
+		memset(name, 0, sizeof(name));
+		snprintf(name, sizeof(name), "vport%d", i);
+		vtree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree),
+				OID_AUTO, name, CTLFLAG_RW, 0, "Virtual port");
+
+		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(vtree), OID_AUTO,
+			"wwnn", CTLTYPE_STRING | CTLFLAG_RW,
+			fcp, 0, ocs_sysctl_vport_wwnn, "A",
+			"World Wide Node Name");
+
+		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(vtree), OID_AUTO,
+			"wwpn", CTLTYPE_STRING | CTLFLAG_RW,
+			fcp, 0, ocs_sysctl_vport_wwpn, "A",
+			"World Wide Port Name");
+
+	}
+
+}
+
+/**
+ * @brief Initialize the debug module
+ *
+ * Parse device hints (similar to Linux module parameters) here. To use,
+ * run the command
+ *    kenv hint.ocs.U.P=V
+ * from the command line replacing U with the unit # (0,1,...),
+ * P with the parameter name (debug_mask), and V with the value
+ */
+void
+ocs_debug_attach(void *os)
+{
+	struct ocs_softc *ocs = os;
+	int error = 0;
+	char *resname = NULL;
+	int32_t	unit = INT32_MAX;
+	uint32_t ocs_debug_mask = 0;
+
+	resname = "debug_mask";
+	if (0 == (error = resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				resname, &ocs_debug_mask))) {
+		device_printf(ocs->dev, "setting %s to %010x\n", resname, ocs_debug_mask);
+		ocs_debug_enable(ocs_debug_mask);
+	}
+
+	unit = device_get_unit(ocs->dev);
+	ocs->cdev = make_dev(&ocs_cdevsw, unit, UID_ROOT, GID_OPERATOR, 0640,
+			"ocs%d", unit);
+	if (ocs->cdev) {
+		ocs->cdev->si_drv1 = ocs;
+	}
+
+	/* initialize sysctl interface */
+	ocs_sysctl_init(ocs);
+	mtx_init(&ocs->dbg_lock, "ocs_dbg_lock", NULL, MTX_DEF);
+}
+
+/**
+ * @brief Free the debug module
+ */
+void
+ocs_debug_detach(void *os)
+{
+	struct ocs_softc *ocs = os;
+
+	mtx_destroy(&ocs->dbg_lock);
+
+	if (ocs->cdev) {
+		ocs->cdev->si_drv1 = NULL;
+		destroy_dev(ocs->cdev);
+	}
+}
+
diff --git a/sys/dev/ocs_fc/ocs_ioctl.h b/sys/dev/ocs_fc/ocs_ioctl.h
new file mode 100644
index 000000000000..6ae5d36aeb3a
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_ioctl.h
@@ -0,0 +1,368 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Common declartaions for the driver's IOCTL interface
+ */
+
+#if !defined(__OCS_IOCTL_H__)
+#define __OCS_IOCTL_H__
+
+/**
+ * @brief OCS test ioctl
+ *
+ * Simple structure for testing the IOCTL interface
+ */
+
+typedef struct {
+	char string[32];		/**< fixed string buffer */
+} ocs_ioctl_test_t;
+
+/**
+ * @brief DRIVER_INFO ioctl structure
+ *
+ * Structure is returned whtn the OCS_IOCTL_CMD_DRIVER_INFO is issued by a user space program.
+ */
+
+typedef struct {
+	uint16_t pci_vendor;		/**< PCI vender ID value (binary) */
+	uint16_t pci_device;		/**< PCI device ID value (binary) */
+	char businfo[16];		/**< Bus information (text) */
+	uint32_t sli_intf;		/**< SLI_INTF register value (binary) */
+	char desc[64];			/**< description (text) */
+	char fw_rev[32];		/**< firmware revision (text) */
+        union {
+            struct {
+	        uint8_t	wwnn[8];		/**< WWNN (binary) */
+	        uint8_t	wwpn[8];		/**< WWPN (binary) */
+            } fc;
+            struct {
+	        uint8_t	mac_addr[6];		/**< MAC address (binary) */
+	        uint8_t	reserved[10];
+            } iscsi;
+        } hw_addr;
+	char serialnum[32];		/**< board serial number (text) */
+} ocs_ioctl_driver_info_t;
+
+#define ELXU_BSD_MAGIC  0x30584c45
+
+/**
+ * @brief IOCTL_CMD_IOCTL_ELXU_MBOX ioctl structure
+ *
+ * Structure used to submit elxsdkutil mailbox requests for firmware download and
+ * dump file retrieveal.
+ */
+
+typedef struct {
+    uint32_t    magic;			/**< magic number */
+    uint32_t    size;			/**< size of MBX command */
+    uint8_t	payload[256];		/**< MBX command in/out payload buffer */
+    uint64_t    in_addr;		/**< user space address of input buffer */
+    uint64_t    in_bytes;		/**< length of user space input buffer in bytes */
+    uint64_t    out_addr;		/**< user space address of output buffer */
+    uint64_t    out_bytes;		/**< length of user space output buffer in bytes */
+} ocs_ioctl_elxu_mbox_t;
+
+enum {
+	ocs_ioctl_scsi_cmd_loop,	/**< Start command loop */
+	ocs_ioctl_scsi_cmd_loop_wait,	/**< Start command loop and wait for completion */
+	ocs_ioctl_scsi_cmd_stop,	/**< Stop command loop */
+	ocs_ioctl_scsi_cmd,		/**< Start one command */
+	ocs_ioctl_scsi_cmd_wait,	/**< Wait for a command to complete */
+	ocs_ioctl_scsi_cmd_abort,	/**< Start an abort */
+	ocs_ioctl_scsi_cmd_tmf,		/**< Start a tmf */
+	ocs_ioctl_els_send,		/**< Start an ELS */
+	ocs_ioctl_tgt_logout,		/**< logout of a target */
+	ocs_ioctl_scsi_cmd_wait_any,	/**< Wait for any command to complete */
+};
+
+enum {
+	ocs_ioctl_scsi_cmd_rd = (1U << 0),	/**< direction is read */
+	ocs_ioctl_scsi_cmd_wr = (1U << 1),	/**< direction is write */
+};
+
+/**
+ * @brief OCS_IOCTL_CMD_SCSI_CMD ioctl command structure
+ */
+
+typedef enum {
+	DIF_OP_DISABLE = 0,
+	DIF_OP_IN_NODIF_OUT_CRC,
+        DIF_OP_IN_CRC_OUT_NODIF,
+        DIF_OP_IN_NODIF_OUT_CHKSUM,
+        DIF_OP_IN_CHKSUM_OUT_NODIF,
+        DIF_OP_IN_CRC_OUT_CRC,
+        DIF_OP_IN_CHKSUM_OUT_CHKSUM,
+        DIF_OP_IN_CRC_OUT_CHKSUM,
+        DIF_OP_IN_CHKSUM_OUT_CRC,
+        DIF_OP_IN_RAW_OUT_RAW,
+	} dif_op_t;
+
+#define DIF_OP_PASS_THRU		DIF_OP_IN_CRC_OUT_CRC
+#define DIF_OP_STRIP			DIF_OP_IN_CRC_OUT_NODIF
+#define DIF_OP_INSERT			DIF_OP_IN_NODIF_OUT_CRC
+
+typedef struct {
+	dif_op_t dif_op;
+	uint32_t
+		check_ref_tag:1,	/* check reference tag on initiator writes */
+		check_app_tag:1,	/* check application tag on initiator writes */
+		check_guard:1,		/* check CRC on initiator writes */
+		dif_separate:1;		/* use DIF separate transfers */
+	uint32_t ref_tag;		/* DIF reference tag */
+	uint16_t app_tag;		/* DIF application tag */
+	uint32_t blocksize;		/* DIF blocksize */
+} dif_info_t;
+
+typedef struct {
+	int command;			/**< SCSI command request command */
+	uint32_t target_idx;		/**< Target device index */
+	uint32_t dir;			/**< rd or wr */
+	uint32_t lun;			/**< lun value */
+	int32_t  tmf;			/**< TMF */
+	uint8_t cdb[32];		/**< SCSI CDB */
+	uint32_t cdb_len;		/**< SCSI CDB length in bytes */
+	uint32_t els_cmd;		/**< ELS command */
+	uint32_t flags;			/**< command flags */
+	uint32_t queue_depth;		/**< queue depth for command looping */
+	uint32_t payload_length;	/**< payload length for command */
+	uint32_t dif_payload_length;	/**< DIF payload length for command if separate */
+	uint32_t io_count;		/**< command count for looping */
+	uint32_t io_timeout;		/**< IO timeout in seconds (0 = no timeout) */
+
+	uint32_t directio;		/**< If set, DMA to and from user buffers */
+
+	uint32_t first_burst:1;		/**< If true send IO writes with first burst */
+	uint32_t first_burst_size;	/**< If first burst is enabled, then this size */
+
+	int32_t wait_timeout_usec;	/**< Wait timeout (usec) for wait, wait_any */
+
+	/* T10-PI */
+	dif_info_t dif;			/* DIF info */
+
+	/* user space buffers */
+	void *payload;			/**< pointer to user space payload buffer */
+	void *dif_payload;		/**< pointer to DIF block data if separate */
+	uint8_t scsi_status;		/**< SCSI status */
+	uint16_t scsi_status_qualifier; /**< SCSI status qualifier */
+	void *sense_data;		/**< pointer to sense data buffer */
+	uint32_t sense_data_length;	/**< length of sense data buffer (call=buffer leng, return=data written) */
+	int32_t residual;		/**< residual */
+	uint32_t tag_to_abort;		/**< tag to abort for an abort task request */
+
+	/* return value */
+	int32_t status;			/**< returned status */
+	uint32_t data_transferred;	/**< updated with data transferred */
+	uint32_t tag;			/**< returned unique I/O context tag */
+
+	/* for scsi loop */
+	uint32_t submit_count;		/**< count of submitted IOs */
+	uint32_t complete_count;	/**< count of completed IOs */
+} ocs_ioctl_scsi_cmd_t;
+
+/**
+ * @brief coredump helper function command values
+ */
+
+typedef enum {
+	OCS_ECD_HELPER_CFG_READ8,
+	OCS_ECD_HELPER_CFG_READ16,
+	OCS_ECD_HELPER_CFG_READ32,
+	OCS_ECD_HELPER_CFG_WRITE8,
+	OCS_ECD_HELPER_CFG_WRITE16,
+	OCS_ECD_HELPER_CFG_WRITE32,
+	OCS_ECD_HELPER_BAR_READ8,
+	OCS_ECD_HELPER_BAR_READ16,
+	OCS_ECD_HELPER_BAR_READ32,
+	OCS_ECD_HELPER_BAR_WRITE8,
+	OCS_ECD_HELPER_BAR_WRITE16,
+	OCS_ECD_HELPER_BAR_WRITE32,
+} ocs_ecd_helper_cmd_t;
+
+/**
+ * @brief OCS_IOCTL_CMD_ECD_HELPER ioctl structure
+ */
+
+typedef struct {
+	ocs_ecd_helper_cmd_t cmd;	/*<< coredump helper function command */
+	uint32_t bar;			/*<< BAR value to use */
+	uint32_t offset;		/*<< offset value to use */
+	uint32_t data;			/*<< 32 bit data value to write or return read data in */
+	int status;			/*<< status of helper function request */
+} ocs_ioctl_ecd_helper_t;
+
+/**
+ * @brief OCS_IOCTL_CMD_VPORT ioctl structure
+ */
+
+typedef struct {
+	uint32_t domain_index;		/*<< domain instance index */
+	uint32_t req_create:1,		/*<< 1 = create vport, zero = remove vport */
+		 enable_ini:1,		/*<< 1 = enable vport as an initiator */
+		 enable_tgt:1;		/*<< 1 = enable vport as a target */
+	uint64_t wwpn;			/*<< wwpn to create or delete */
+	uint64_t wwnn;			/*<< wwnn to create or delete */
+	int status;			/*<< status of helper function request */
+} ocs_ioctl_vport_t;
+
+/**
+ * @brief connection info ioctl structure
+ *
+ * Structure is returned when the OCS_IOCTL_CMD_CONNECTION_INFO is issued by a user space program.
+ */
+typedef struct {
+        uint32_t connection_handle;
+        uint16_t connection_id;
+        uint8_t source_ip_type;
+        uint8_t source_ip[16];
+        uint16_t source_port;
+        uint8_t dest_ip_type;
+        uint8_t dest_ip[16];
+        uint16_t dest_port;
+} ocs_ioctl_connection_info_t;
+
+typedef struct {
+        uint32_t max_connections;
+        uint32_t num_connections;
+        ocs_ioctl_connection_info_t *connections;
+} ocs_ioctl_connections_t;
+
+/**
+ * @brief driver-dump actions
+ */
+
+typedef enum {
+	OCS_IOCTL_DDUMP_GET,
+	OCS_IOCTL_DDUMP_GET_SAVED,
+	OCS_IOCTL_DDUMP_CLR_SAVED,
+} ocs_ddump_action_t;
+
+#define OCS_IOCTL_DDUMP_FLAGS_WQES	(1U << 0)
+#define OCS_IOCTL_DDUMP_FLAGS_CQES	(1U << 1)
+#define OCS_IOCTL_DDUMP_FLAGS_MQES	(1U << 2)
+#define OCS_IOCTL_DDUMP_FLAGS_RQES	(1U << 3)
+#define OCS_IOCTL_DDUMP_FLAGS_EQES	(1U << 4)
+
+typedef struct {
+	ocs_ddump_action_t action;
+	uint32_t flags;
+	uint32_t q_entries;
+} ocs_ioctl_ddump_arg_t;
+
+/**
+ * @brief OCS_CTL_CMD_GET_DDUMP ioctl structure
+ */
+
+typedef struct {
+	ocs_ioctl_ddump_arg_t args;	/*<< arguments for ddump */
+	uint8_t *user_buffer;		/*<< pointer to user space buffer */
+	uint32_t user_buffer_len;	/*<< length in bytes of user space buffer */
+	uint32_t bytes_written;		/*<< number of bytes written */
+} ocs_ioctl_ddump_t;
+
+/**
+ * @brief OCS_CTL_CMD_GET_STATUS, OCS_CTL_CMD_GET_CONFIG
+ */
+
+typedef struct {
+	uint8_t *user_buffer;		/*<< pointer to user space buffer */
+	uint32_t user_buffer_len;	/*<< length in bytes of user space buffer */
+	uint32_t bytes_written;		/*<< number of bytes written */
+} ocs_ioctl_mgmt_buffer_t;
+
+typedef struct {
+	uint8_t		*name;			/*<< Input: name of property to retrieve */
+	uint8_t		*value;			/*<< Output: user space buffer in which to place the response */
+	uint32_t	value_length;		/*<< Input: size of the user space buffer */
+} ocs_ioctl_cmd_get_t;
+
+typedef struct {
+	uint8_t		*name;			/*<< Input: name of property to set */
+	uint8_t		*value;			/*<< Input: user space buffer which contains the new value */
+	int32_t		result;			/*<< Output: result */
+} ocs_ioctl_cmd_set_t;
+
+typedef struct {
+	uint8_t		*name;			/*<< Input: name of action to execute */
+	void		*arg_in;		/*<< Input: pointer to argument in user space */
+	uint32_t	arg_in_length;		/*<< Input: size of arg_in in bytes */
+	void		*arg_out;		/*<< Output: pointer to argument from kernel to user */
+	uint32_t	arg_out_length;		/*<< Input: size of arg_out in bytes */
+	int32_t		result;			/*<< Output: result */
+} ocs_ioctl_action_t;
+
+#define FC_HEADER_LEN	24
+typedef struct {
+	uint8_t		fc_header[FC_HEADER_LEN]; /*<< FC Header to send */
+	uint8_t		*payload;		/*<< payload */
+	uint32_t	payload_len;		/*<< payload length (bytes) */
+	uint8_t		sof;			/*<< SOF value */
+	uint8_t		eof;			/*<< EOF Value */
+} ocs_ioctl_send_frame_t;
+
+/**
+ * @brief linkcfg strings
+ */
+#define OCS_CONFIG_LINKCFG_4X10G	"ETH_4x10G"
+#define OCS_CONFIG_LINKCFG_1X40G	"ETH_1x40G"
+#define OCS_CONFIG_LINKCFG_2X16G	"FC_2x16G"
+#define OCS_CONFIG_LINKCFG_4X8G		"FC_4x8G"
+#define OCS_CONFIG_LINKCFG_4X1G		"FC_4x1G"
+#define OCS_CONFIG_LINKCFG_2X10G	"ETH_2x10G"
+#define OCS_CONFIG_LINKCFG_2X10G_2X8G	"ETH_2x10G_FC_2x8G"
+#define OCS_CONFIG_LINKCFG_UNKNOWN	"UNKNOWN"
+
+#define OCS_IOCTL_CMD_BASE		'o'
+#define OCS_IOCTL_CMD_TEST		_IOWR(OCS_IOCTL_CMD_BASE, 1, ocs_ioctl_test_t)
+#define OCS_IOCTL_CMD_ELXU_MBOX		_IOWR(OCS_IOCTL_CMD_BASE, 2, ocs_ioctl_elxu_mbox_t)
+#define OCS_IOCTL_CMD_SCSI_CMD		_IOWR(OCS_IOCTL_CMD_BASE, 3, ocs_ioctl_scsi_cmd_t)
+#define OCS_IOCTL_CMD_DRIVER_INFO	_IOWR(OCS_IOCTL_CMD_BASE, 4, ocs_ioctl_driver_info_t)
+#define OCS_IOCTL_CMD_ECD_HELPER	_IOWR(OCS_IOCTL_CMD_BASE, 5, ocs_ioctl_ecd_helper_t)
+#define OCS_IOCTL_CMD_CONNECTION_INFO   _IOWR(OCS_IOCTL_CMD_BASE, 6, ocs_ioctl_connection_info_t)
+#define OCS_IOCTL_CMD_VPORT		_IOWR(OCS_IOCTL_CMD_BASE, 7, ocs_ioctl_vport_t)
+#define OCS_IOCTL_CMD_GET_DDUMP		_IOWR(OCS_IOCTL_CMD_BASE, 8, ocs_ioctl_ddump_t)
+#define OCS_IOCTL_CMD_MGMT_GET		_IOWR(OCS_IOCTL_CMD_BASE, 9, ocs_ioctl_cmd_get_t)
+#define OCS_IOCTL_CMD_MGMT_GET_ALL	_IOWR(OCS_IOCTL_CMD_BASE, 10, ocs_ioctl_mgmt_buffer_t)
+#define OCS_IOCTL_CMD_MGMT_SET		_IOWR(OCS_IOCTL_CMD_BASE, 11, ocs_ioctl_cmd_set_t)
+#define OCS_IOCTL_CMD_MGMT_LIST		_IOWR(OCS_IOCTL_CMD_BASE, 12, ocs_ioctl_mgmt_buffer_t)
+#define OCS_IOCTL_CMD_MGMT_EXEC		_IOWR(OCS_IOCTL_CMD_BASE, 13, ocs_ioctl_action_t)
+#define OCS_IOCTL_CMD_LINK_ONLINE	_IOWR(OCS_IOCTL_CMD_BASE, 16, int)
+#define OCS_IOCTL_CMD_GEN_DUMP		_IOWR(OCS_IOCTL_CMD_BASE, 17, int)
+#define OCS_IOCTL_CMD_UNLOAD		_IO(OCS_IOCTL_CMD_BASE, 18)
+#define OCS_IOCTL_CMD_SEND_FRAME	_IOWR(OCS_IOCTL_CMD_BASE, 19, ocs_ioctl_send_frame_t)
+
+
+extern void ocs_info_get_xport_address(ocs_t *ocs, ocs_ioctl_driver_info_t *info);
+extern int32_t ocs_device_ioctl_xport(ocs_t *ocs, unsigned int cmd, unsigned long arg);
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_list.h b/sys/dev/ocs_fc/ocs_list.h
new file mode 100644
index 000000000000..f94660fd2d74
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_list.h
@@ -0,0 +1,449 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ * OCS linked list API
+ *
+ */
+
+#if !defined(__OCS_LIST_H__)
+#define __OCS_LIST_H__
+
+#define OCS_LIST_DEBUG
+
+#if defined(OCS_LIST_DEBUG)
+
+
+#define ocs_list_magic_decl		uint32_t magic;
+#define OCS_LIST_LIST_MAGIC		0xcafe0000
+#define OCS_LIST_LINK_MAGIC		0xcafe0001
+#define ocs_list_set_list_magic		list->magic = OCS_LIST_LIST_MAGIC
+#define ocs_list_set_link_magic		list->magic = OCS_LIST_LINK_MAGIC
+
+#define ocs_list_assert(cond, ...) \
+	if (!(cond)) { \
+		return __VA_ARGS__; \
+	}
+#else
+#define ocs_list_magic_decl
+#define ocs_list_assert(cond, ...)
+#define ocs_list_set_list_magic
+#define ocs_list_set_link_magic
+#endif
+
+/**
+ * @brief list/link structure
+ *
+ * used for both the list object, and the link object(s).  offset
+ * is specified when the list is initialized; this implies that a list
+ * will always point to objects of the same type.  offset is not used
+ * when ocs_list_t is used as a link (ocs_list_link_t).
+ *
+ */
+
+typedef struct ocs_list_s ocs_list_t;
+struct ocs_list_s {
+	ocs_list_magic_decl			/*<< used if debugging is enabled */
+	ocs_list_t *next;			/*<< pointer to head of list (or next if link) */
+	ocs_list_t *prev;			/*<< pointer to tail of list (or previous if link) */
+	uint32_t offset;			/*<< offset in bytes to the link element of the objects in list */
+};
+typedef ocs_list_t ocs_list_link_t;
+
+/* item2link - return pointer to link given pointer to an item */
+#define item2link(list, item)	((ocs_list_t*) (((uint8_t*)(item)) + (list)->offset))
+
+/* link2item - return pointer to item given pointer to a link */
+#define link2item(list, link)	((void*) (((uint8_t*)(link)) - (list)->offset))
+
+/**
+ * @brief Initialize a list
+ *
+ * A list object is initialized.  Helper define is used to call _ocs_list_init() with
+ * offsetof(type, link)
+ *
+ * @param list Pointer to list
+ * @param offset Offset in bytes in item to the link element
+ *
+ * @return none
+ */
+static inline void
+_ocs_list_init(ocs_list_t *list, uint32_t offset)
+{
+	ocs_list_assert(list);
+	ocs_list_set_list_magic;
+
+	list->next = list;
+	list->prev = list;
+	list->offset = offset;
+}
+#define ocs_list_init(head, type, link)		_ocs_list_init(head, offsetof(type, link))
+
+
+/**
+ * @ingroup os
+ * @brief Test if a list is empty
+ *
+ * @param list Pointer to list head
+ *
+ * @return 1 if empty, 0 otherwise
+ */
+static inline int32_t
+ocs_list_empty(ocs_list_t *list)
+{
+	ocs_list_assert(list, 1);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC, 1);
+	return list->next == list;
+}
+
+/**
+ * @ingroup os
+ * @brief Test if a list is valid (ready for use)
+ *
+ * @param list Pointer to list head
+ *
+ * @return true if list is usable, false otherwise
+ */
+static inline int
+ocs_list_valid(ocs_list_t *list)
+{
+	return (list->magic == OCS_LIST_LIST_MAGIC);
+}
+
+/**
+ * @brief Insert link between two other links
+ *
+ * Inserts a link in between two other links
+ *
+ * @param a Pointer to first link
+ * @param b Pointer to next link
+ * @param c Pointer to link to insert between a and b
+ *
+ * @return none
+ */
+static inline void
+_ocs_list_insert_link(ocs_list_t *a, ocs_list_t *b, ocs_list_t *c)
+{
+	ocs_list_assert(a);
+	ocs_list_assert((a->magic == OCS_LIST_LIST_MAGIC) || (a->magic == OCS_LIST_LINK_MAGIC));
+	ocs_list_assert(a->next);
+	ocs_list_assert(a->prev);
+	ocs_list_assert(b);
+	ocs_list_assert((b->magic == OCS_LIST_LIST_MAGIC) || (b->magic == OCS_LIST_LINK_MAGIC));
+	ocs_list_assert(b->next);
+	ocs_list_assert(b->prev);
+	ocs_list_assert(c);
+	ocs_list_assert((c->magic == OCS_LIST_LIST_MAGIC) || (c->magic == OCS_LIST_LINK_MAGIC));
+	ocs_list_assert(!c->next);
+	ocs_list_assert(!c->prev);
+
+	ocs_list_assert(a->offset == b->offset);
+	ocs_list_assert(b->offset == c->offset);
+
+	c->next = a->next;
+	c->prev = b->prev;
+	a->next = c;
+	b->prev = c;
+}
+
+#if defined(OCS_LIST_DEBUG)
+/**
+ * @brief Initialize a list link for debug purposes
+ *
+ * For debugging a linked list link element has a magic number that is initialized,
+ * and the offset value initialzied and used for subsequent assertions.
+ *
+ *
+ * @param list Pointer to list head
+ * @param link Pointer to link to be initialized
+ *
+ * @return none
+ */
+static inline void
+ocs_list_init_link(ocs_list_t *list, ocs_list_t *link)
+{
+	ocs_list_assert(list);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC);
+	ocs_list_assert(link);
+
+	if (link->magic == 0) {
+		link->magic = OCS_LIST_LINK_MAGIC;
+		link->offset = list->offset;
+		link->next = NULL;
+		link->prev = NULL;
+	}
+}
+#else
+#define ocs_list_init_link(...)
+#endif
+
+/**
+ * @ingroup os
+ * @brief Add an item to the head of the list
+ *
+ * @param list Pointer to list head
+ * @param item Item to add
+ */
+static inline void
+ocs_list_add_head(ocs_list_t *list, void *item)
+{
+	ocs_list_t *link;
+
+	ocs_list_assert(list);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC);
+	ocs_list_assert(item);
+
+	link = item2link(list, item);
+	ocs_list_init_link(list, link);
+
+	ocs_list_assert(link->magic == OCS_LIST_LINK_MAGIC);
+	ocs_list_assert(link->offset == list->offset);
+	ocs_list_assert(link->next == NULL);
+	ocs_list_assert(link->prev == NULL);
+
+	_ocs_list_insert_link(list, list->next, item2link(list, item));
+}
+
+
+/**
+ * @ingroup os
+ * @brief Add an item to the tail of the list
+ *
+ * @param list Head of the list
+ * @param item Item to add
+ */
+static inline void
+ocs_list_add_tail(ocs_list_t *list, void *item)
+{
+	ocs_list_t *link;
+
+	ocs_list_assert(list);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC);
+	ocs_list_assert(item);
+
+	link = item2link(list, item);
+	ocs_list_init_link(list, link);
+
+	ocs_list_assert(link->magic == OCS_LIST_LINK_MAGIC);
+	ocs_list_assert(link->offset == list->offset);
+	ocs_list_assert(link->next == NULL);
+	ocs_list_assert(link->prev == NULL);
+
+	_ocs_list_insert_link(list->prev, list, link);
+}
+
+
+/**
+ * @ingroup os
+ * @brief Return the first item in the list
+ *
+ * @param list Head of the list
+ *
+ * @return pointer to the first item, NULL otherwise
+ */
+static inline void *
+ocs_list_get_head(ocs_list_t *list)
+{
+	ocs_list_assert(list, NULL);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC, NULL);
+	return ocs_list_empty(list) ? NULL : link2item(list, list->next);
+}
+
+/**
+ * @ingroup os
+ * @brief Return the first item in the list
+ *
+ * @param list head of the list
+ *
+ * @return pointer to the last item, NULL otherwise
+ */
+static inline void *
+ocs_list_get_tail(ocs_list_t *list)
+{
+	ocs_list_assert(list, NULL);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC, NULL);
+	return ocs_list_empty(list) ? NULL : link2item(list, list->prev);
+}
+
+/**
+ * @ingroup os
+ * @brief Return the last item in the list
+ *
+ * @param list Pointer to list head
+ *
+ * @return pointer to the last item, NULL otherwise
+ */
+static inline void *ocs_list_tail(ocs_list_t *list)
+{
+	ocs_list_assert(list, NULL);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC, NULL);
+	return ocs_list_empty(list) ? NULL : link2item(list, list->prev);
+}
+
+/**
+ * @ingroup os
+ * @brief Get the next item on the list
+ *
+ * @param list head of the list
+ * @param item current item
+ *
+ * @return pointer to the next item, NULL otherwise
+ */
+static inline void *ocs_list_next(ocs_list_t *list, void *item)
+{
+	ocs_list_t *link;
+
+	if (item == NULL) {
+		return NULL;
+	}
+
+	ocs_list_assert(list, NULL);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC, NULL);
+	ocs_list_assert(item, NULL);
+
+	link = item2link(list, item);
+
+	ocs_list_assert(link->magic == OCS_LIST_LINK_MAGIC, NULL);
+	ocs_list_assert(link->offset == list->offset, NULL);
+	ocs_list_assert(link->next, NULL);
+	ocs_list_assert(link->prev, NULL);
+
+	if ((link->next) == list) {
+		return NULL;
+	}
+
+	return link2item(list, link->next);
+}
+
+/**
+ * @ingroup os
+ * @brief Remove and return an item from the head of the list
+ *
+ * @param list head of the list
+ *
+ * @return pointer to returned item, or NULL if list is empty
+ */
+#define ocs_list_remove_head(list)		ocs_list_remove(list, ocs_list_get_head(list))
+
+/**
+ * @ingroup os
+ * @brief Remove an item from the list
+ *
+ * @param list Head of the list
+ * @param item Item to remove
+ *
+ * @return pointer to item, or NULL if item is not found.
+ */
+static inline void *ocs_list_remove(ocs_list_t *list, void *item)
+{
+	ocs_list_t *link;
+	ocs_list_t *prev;
+	ocs_list_t *next;
+
+	if (item == NULL) {
+		return NULL;
+	}
+	ocs_list_assert(list, NULL);
+	ocs_list_assert(list->magic == OCS_LIST_LIST_MAGIC, NULL);
+
+	link = item2link(list, item);
+
+	ocs_list_assert(link->magic == OCS_LIST_LINK_MAGIC, NULL);
+	ocs_list_assert(link->offset == list->offset, NULL);
+	ocs_list_assert(link->next, NULL);
+	ocs_list_assert(link->prev, NULL);
+
+	prev = link->prev;
+	next = link->next;
+
+	prev->next = next;
+	next->prev = prev;
+
+	link->next = link->prev = NULL;
+
+	return item;
+}
+
+/**
+ * @brief Iterate a linked list
+ *
+ * Iterate a linked list.
+ *
+ * @param list Pointer to list
+ * @param item Pointer to iterated item
+ *
+ * note, item is NULL after full list is traversed.
+
+ * @return none
+ */
+
+#define ocs_list_foreach(list, item) \
+	for (item = ocs_list_get_head((list)); item; item = ocs_list_next((list), item) )
+
+/**
+ * @brief Iterate a linked list safely
+ *
+ * Iterate a linked list safely, meaning that the iterated item
+ * may be safely removed from the list.
+ *
+ * @param list Pointer to list
+ * @param item Pointer to iterated item
+ * @param nxt Pointer to saveed iterated item
+ *
+ * note, item is NULL after full list is traversed.
+ *
+ * @return none
+ */
+
+#define ocs_list_foreach_safe(list, item, nxt) \
+	for (item = ocs_list_get_head(list), nxt = item ? ocs_list_next(list, item) : NULL; item; \
+		item = nxt, nxt = ocs_list_next(list, item))
+
+/**
+ * @brief Test if object is on a list
+ *
+ * Returns True if object is on a list
+ *
+ * @param link Pointer to list link
+ *
+ * @return returns True if object is on a list
+ */
+static inline int32_t
+ocs_list_on_list(ocs_list_link_t *link)
+{
+	return (link->next != NULL);
+}
+
+#endif /* __OCS_LIST_H__ */
diff --git a/sys/dev/ocs_fc/ocs_mgmt.c b/sys/dev/ocs_fc/ocs_mgmt.c
new file mode 100644
index 000000000000..170dff6e931c
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_mgmt.c
@@ -0,0 +1,2923 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * The ocs_mgmt top level functions for Fibre Channel.
+ */
+
+/**
+ * @defgroup mgmt Management Functions
+ */
+
+#include "ocs.h"
+#include "ocs_mgmt.h"
+#include "ocs_vpd.h"
+
+#define SFP_PAGE_SIZE 128
+
+/* Executables*/
+
+static int ocs_mgmt_firmware_write(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
+static int ocs_mgmt_firmware_reset(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
+static int ocs_mgmt_function_reset(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
+
+static void ocs_mgmt_fw_write_cb(int32_t status, uint32_t actual_write_length, uint32_t change_status, void *arg);
+static int ocs_mgmt_force_assert(ocs_t *ocs, char *, void *buf, uint32_t buf_len, void*, uint32_t);
+
+#if defined(OCS_INCLUDE_RAMD)
+static int32_t
+ocs_mgmt_read_phys(ocs_t *ocs, char *, void *, uint32_t , void *, uint32_t);
+#endif
+
+
+/* Getters */
+
+static void get_nodes_count(ocs_t *, char *, ocs_textbuf_t*);
+static void get_desc(ocs_t *, char *, ocs_textbuf_t*);
+static void get_fw_rev(ocs_t *, char *, ocs_textbuf_t*);
+static void get_fw_rev2(ocs_t *, char *, ocs_textbuf_t*);
+static void get_ipl(ocs_t *, char *, ocs_textbuf_t*);
+static void get_wwnn(ocs_t *, char *, ocs_textbuf_t*);
+static void get_wwpn(ocs_t *, char *, ocs_textbuf_t*);
+static void get_fcid(ocs_t *, char *, ocs_textbuf_t *);
+static void get_sn(ocs_t *, char *, ocs_textbuf_t*);
+static void get_pn(ocs_t *, char *, ocs_textbuf_t*);
+static void get_sli4_intf_reg(ocs_t *, char *, ocs_textbuf_t*);
+static void get_phy_port_num(ocs_t *, char *, ocs_textbuf_t*);
+static void get_asic_id(ocs_t *, char *, ocs_textbuf_t*);
+static void get_pci_vendor(ocs_t *, char *, ocs_textbuf_t*);
+static void get_pci_device(ocs_t *, char *, ocs_textbuf_t*);
+static void get_pci_subsystem_vendor(ocs_t *, char *, ocs_textbuf_t*);
+static void get_pci_subsystem_device(ocs_t *, char *, ocs_textbuf_t*);
+static void get_businfo(ocs_t *, char *, ocs_textbuf_t*);
+static void get_sfp_a0(ocs_t *, char *, ocs_textbuf_t*);
+static void get_sfp_a2(ocs_t *, char *, ocs_textbuf_t*);
+static void get_hw_rev1(ocs_t *, char *, ocs_textbuf_t*);
+static void get_hw_rev2(ocs_t *, char *, ocs_textbuf_t*);
+static void get_hw_rev3(ocs_t *, char *, ocs_textbuf_t*);
+static void get_debug_mq_dump(ocs_t*, char*, ocs_textbuf_t*);
+static void get_debug_cq_dump(ocs_t*, char*, ocs_textbuf_t*);
+static void get_debug_wq_dump(ocs_t*, char*, ocs_textbuf_t*);
+static void get_debug_eq_dump(ocs_t*, char*, ocs_textbuf_t*);
+static void get_logmask(ocs_t*, char*, ocs_textbuf_t*);
+static void get_current_speed(ocs_t*, char*, ocs_textbuf_t*);
+static void get_current_topology(ocs_t*, char*, ocs_textbuf_t*);
+static void get_current_link_state(ocs_t*, char*, ocs_textbuf_t*);
+static void get_configured_speed(ocs_t*, char*, ocs_textbuf_t*);
+static void get_configured_topology(ocs_t*, char*, ocs_textbuf_t*);
+static void get_configured_link_state(ocs_t*, char*, ocs_textbuf_t*);
+static void get_linkcfg(ocs_t*, char*, ocs_textbuf_t*);
+static void get_req_wwnn(ocs_t*, char*, ocs_textbuf_t*);
+static void get_req_wwpn(ocs_t*, char*, ocs_textbuf_t*);
+static void get_nodedb_mask(ocs_t*, char*, ocs_textbuf_t*);
+static void get_profile_list(ocs_t*, char*, ocs_textbuf_t*);
+static void get_active_profile(ocs_t*, char*, ocs_textbuf_t*);
+static void get_port_protocol(ocs_t*, char*, ocs_textbuf_t*);
+static void get_driver_version(ocs_t*, char*, ocs_textbuf_t*);
+static void get_chip_type(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_tgt_rscn_delay(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_tgt_rscn_period(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_inject_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_inject_free_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_inject_drop_data(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_inject_drop_resp(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_cmd_err_inject(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_cmd_delay_value(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_nv_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_nv_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_loglevel(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+static void get_node_abort_cnt(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+
+/* Setters */
+static int set_debug_mq_dump(ocs_t*, char*, char*);
+static int set_debug_cq_dump(ocs_t*, char*, char*);
+static int set_debug_wq_dump(ocs_t*, char*, char*);
+static int set_debug_eq_dump(ocs_t*, char*, char*);
+static int set_logmask(ocs_t*, char*, char*);
+static int set_configured_link_state(ocs_t*, char*, char*);
+static int set_linkcfg(ocs_t*, char*, char*);
+static int set_nodedb_mask(ocs_t*, char*, char*);
+static int set_port_protocol(ocs_t*, char*, char*);
+static int set_active_profile(ocs_t*, char*, char*);
+static int set_tgt_rscn_delay(ocs_t*, char*, char*);
+static int set_tgt_rscn_period(ocs_t*, char*, char*);
+static int set_inject_drop_cmd(ocs_t*, char*, char*);
+static int set_inject_free_drop_cmd(ocs_t*, char*, char*);
+static int set_inject_drop_data(ocs_t*, char*, char*);
+static int set_inject_drop_resp(ocs_t*, char*, char*);
+static int set_cmd_err_inject(ocs_t*, char*, char*);
+static int set_cmd_delay_value(ocs_t*, char*, char*);
+static int set_nv_wwn(ocs_t*, char*, char*);
+static int set_loglevel(ocs_t*, char*, char*);
+
+static void ocs_mgmt_linkcfg_cb(int32_t status, uintptr_t value, void *arg);
+#if defined(OCS_INCLUDE_RAMD)
+static void* find_address_in_target(ocs_ramdisc_t **ramdisc_array, uint32_t ramdisc_count, uintptr_t target_addr);
+#endif
+
+ocs_mgmt_table_entry_t mgmt_table[] = {
+		{"nodes_count", get_nodes_count, NULL, NULL},
+		{"desc", get_desc, NULL, NULL},
+		{"fw_rev", get_fw_rev, NULL, NULL},
+		{"fw_rev2", get_fw_rev2, NULL, NULL},
+		{"ipl", get_ipl, NULL, NULL},
+		{"hw_rev1", get_hw_rev1, NULL, NULL},
+		{"hw_rev2", get_hw_rev2, NULL, NULL},
+		{"hw_rev3", get_hw_rev3, NULL, NULL},
+		{"wwnn", get_wwnn, NULL, NULL},
+		{"wwpn", get_wwpn, NULL, NULL},
+		{"fc_id", get_fcid, NULL, NULL},
+		{"sn", get_sn, NULL, NULL},
+		{"pn", get_pn, NULL, NULL},
+		{"sli4_intf_reg", get_sli4_intf_reg, NULL, NULL},
+		{"phy_port_num", get_phy_port_num, NULL, NULL},
+		{"asic_id_reg", get_asic_id, NULL, NULL},
+		{"pci_vendor", get_pci_vendor, NULL, NULL},
+		{"pci_device", get_pci_device, NULL, NULL},
+		{"pci_subsystem_vendor", get_pci_subsystem_vendor, NULL, NULL},
+		{"pci_subsystem_device", get_pci_subsystem_device, NULL, NULL},
+		{"businfo", get_businfo, NULL, NULL},
+		{"sfp_a0", get_sfp_a0, NULL, NULL},
+		{"sfp_a2", get_sfp_a2, NULL, NULL},
+		{"profile_list", get_profile_list, NULL, NULL},
+		{"driver_version", get_driver_version, NULL, NULL},
+		{"current_speed", get_current_speed, NULL, NULL},
+		{"current_topology", get_current_topology, NULL, NULL},
+		{"current_link_state", get_current_link_state, NULL, NULL},
+		{"chip_type", get_chip_type, NULL, NULL},
+		{"configured_speed", get_configured_speed, set_configured_speed, NULL},
+		{"configured_topology", get_configured_topology, set_configured_topology, NULL},
+		{"configured_link_state", get_configured_link_state, set_configured_link_state, NULL},
+		{"debug_mq_dump", get_debug_mq_dump, set_debug_mq_dump, NULL},
+		{"debug_cq_dump", get_debug_cq_dump, set_debug_cq_dump, NULL},
+		{"debug_wq_dump", get_debug_wq_dump, set_debug_wq_dump, NULL},
+		{"debug_eq_dump", get_debug_eq_dump, set_debug_eq_dump, NULL},
+		{"logmask", get_logmask, set_logmask, NULL},
+		{"loglevel", get_loglevel, set_loglevel, NULL},
+		{"linkcfg", get_linkcfg, set_linkcfg, NULL},
+		{"requested_wwnn", get_req_wwnn, set_req_wwnn, NULL},
+		{"requested_wwpn", get_req_wwpn, set_req_wwpn, NULL},
+		{"nodedb_mask", get_nodedb_mask, set_nodedb_mask, NULL},
+		{"port_protocol", get_port_protocol, set_port_protocol, NULL},
+		{"active_profile", get_active_profile, set_active_profile, NULL},
+		{"firmware_write", NULL, NULL, ocs_mgmt_firmware_write},
+		{"firmware_reset", NULL, NULL, ocs_mgmt_firmware_reset},
+		{"function_reset", NULL, NULL, ocs_mgmt_function_reset},
+#if defined(OCS_INCLUDE_RAMD)
+		{"read_phys", NULL, NULL, ocs_mgmt_read_phys},
+#endif
+		{"force_assert", NULL, NULL, ocs_mgmt_force_assert},
+
+		{"tgt_rscn_delay", get_tgt_rscn_delay, set_tgt_rscn_delay, NULL},
+		{"tgt_rscn_period", get_tgt_rscn_period, set_tgt_rscn_period, NULL},
+		{"inject_drop_cmd", get_inject_drop_cmd, set_inject_drop_cmd, NULL},
+		{"inject_free_drop_cmd", get_inject_free_drop_cmd, set_inject_free_drop_cmd, NULL},
+		{"inject_drop_data", get_inject_drop_data, set_inject_drop_data, NULL},
+		{"inject_drop_resp", get_inject_drop_resp, set_inject_drop_resp, NULL},
+		{"cmd_err_inject", get_cmd_err_inject, set_cmd_err_inject, NULL},
+		{"cmd_delay_value", get_cmd_delay_value, set_cmd_delay_value, NULL},
+		{"nv_wwpn", get_nv_wwpn, NULL, NULL},
+		{"nv_wwnn", get_nv_wwnn, NULL, NULL},
+		{"nv_wwn", NULL, set_nv_wwn, NULL},
+		{"node_abort_cnt", get_node_abort_cnt, NULL, NULL},
+};
+
+/**
+ * @ingroup mgmt
+ * @brief Get a list of options supported by the driver.
+ *
+ * @par Description
+ * This is the top level "get list" handler for the driver. It
+ * performs the following:
+ *  - Adds entries to the textbuf for any actions supported by this level in the driver.
+ *  - Calls a back-end function to add any actions supported by the back-end.
+ *  - Calls a function on each child (domain) to recursively add supported actions.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param textbuf Pointer to an ocs_textbuf, which is used to accumulate the results.
+ *
+ * @return Returns 0 on success, or a negative value on failure.
+ */
+
+void
+ocs_mgmt_get_list(ocs_t *ocs, ocs_textbuf_t *textbuf)
+{
+	ocs_domain_t *domain;
+	uint32_t i;
+	int access;
+
+	ocs_mgmt_start_unnumbered_section(textbuf, "ocs");
+
+	for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
+		access = 0;
+		if (mgmt_table[i].get_handler) {
+			access |= MGMT_MODE_RD;
+		}
+		if (mgmt_table[i].set_handler) {
+			access |= MGMT_MODE_WR;
+		}
+		if (mgmt_table[i].action_handler) {
+			access |= MGMT_MODE_EX;
+		}
+		ocs_mgmt_emit_property_name(textbuf, access, mgmt_table[i].name);
+	}
+
+	if ((ocs->mgmt_functions) && (ocs->mgmt_functions->get_list_handler)) {
+		ocs->mgmt_functions->get_list_handler(textbuf, ocs);
+	}
+
+	if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->get_list_handler)) {
+		ocs->tgt_mgmt_functions->get_list_handler(textbuf, &(ocs->tgt_ocs));
+	}
+
+	/* Have each of my children add their actions */
+	if (ocs_device_lock_try(ocs) == TRUE) {
+
+		/* If we get here then we are holding the device lock */
+		ocs_list_foreach(&ocs->domain_list, domain) {
+			if ((domain->mgmt_functions) && (domain->mgmt_functions->get_list_handler)) {
+				domain->mgmt_functions->get_list_handler(textbuf, domain);
+			}
+		}
+		ocs_device_unlock(ocs);
+	}
+
+	ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
+
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Return the value of a management item.
+ *
+ * @par Description
+ * This is the top level "get" handler for the driver. It
+ * performs the following:
+ *  - Checks that the qualifier portion of the name begins with my qualifier (ocs).
+ *  - If the remaining part of the name matches a parameter that is known at this level,
+ *    writes the value into textbuf.
+ *  - If the name is not known, sends the request to the back-ends to fulfill (if possible).
+ *  - If the request has not been fulfilled by the back-end,
+ *    passes the request to each of the children (domains) to
+ *    have them (recursively) try to respond.
+ *
+ *  In passing the request to other entities, the request is considered to be answered
+ *  when a response has been written into textbuf, indicated by textbuf->buffer_written
+ *  being non-zero.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the status item to be retrieved.
+ * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
+ *
+ * @return Returns 0 if the value was found and returned, or -1 if an error occurred.
+ */
+
+
+int
+ocs_mgmt_get(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_domain_t *domain;
+	char qualifier[6];
+	int retval = -1;
+	uint32_t i;
+
+	ocs_mgmt_start_unnumbered_section(textbuf, "ocs");
+
+
+	snprintf(qualifier, sizeof(qualifier), "/ocs");
+
+	/* See if the name starts with my qualifier.  If not then this request isn't for me */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = name + strlen(qualifier) + 1;
+
+		for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
+			if (ocs_strcmp(unqualified_name, mgmt_table[i].name) == 0) {
+				if (mgmt_table[i].get_handler) {
+					mgmt_table[i].get_handler(ocs, name, textbuf);
+					ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
+					return 0;
+				}
+			}
+		}
+
+		if ((ocs->mgmt_functions) && (ocs->mgmt_functions->get_handler)) {
+			retval = ocs->mgmt_functions->get_handler(textbuf, qualifier, (char*)name, ocs);
+		}
+
+		if (retval != 0) {
+			if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->get_handler)) {
+				retval = ocs->tgt_mgmt_functions->get_handler(textbuf, qualifier,
+						(char*)name, &(ocs->tgt_ocs));
+			}
+		}
+
+		if (retval != 0) {
+			/* The driver didn't handle it, pass it to each domain */
+
+			ocs_device_lock(ocs);
+			ocs_list_foreach(&ocs->domain_list, domain) {
+				if ((domain->mgmt_functions) && (domain->mgmt_functions->get_handler)) {
+					retval = domain->mgmt_functions->get_handler(textbuf, qualifier, (char*)name, domain);
+				}
+
+				if (retval ==  0) {
+					break;
+				}
+
+
+			}
+			ocs_device_unlock(ocs);
+		}
+
+	}
+
+	ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
+
+	return retval;
+}
+
+
+/**
+ * @ingroup mgmt
+ * @brief Set the value of a mgmt item.
+ *
+ * @par Description
+ * This is the top level "set" handler for the driver. It
+ * performs the following:
+ *  - Checks that the qualifier portion of the name begins with my qualifier (ocs).
+ *  - If the remaining part of the name matches a parameter that is known at this level,
+ *    calls the correct function to change the configuration.
+ *  - If the name is not known, sends the request to the back-ends to fulfill (if possible).
+ *  - If the request has not been fulfilled by the back-end, passes the request to each of the
+ *    children (domains) to have them (recursively) try to respond.
+ *
+ *  In passing the request to other entities, the request is considered to be handled
+ *  if the function returns 0.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the property to be changed.
+ * @param value Requested new value of the property.
+ *
+ * @return Returns 0 if the configuration value was updated, or -1 otherwise.
+ */
+
+int
+ocs_mgmt_set(ocs_t *ocs, char *name, char *value)
+{
+	ocs_domain_t *domain;
+	int result = -1;
+	char qualifier[80];
+	uint32_t i;
+
+	snprintf(qualifier, sizeof(qualifier), "/ocs");
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = name + strlen(qualifier) +1;
+
+		/* See if it's a value I can set */
+		for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
+			if (ocs_strcmp(unqualified_name, mgmt_table[i].name) == 0) {
+				if (mgmt_table[i].set_handler) {
+					return mgmt_table[i].set_handler(ocs, name, value);
+				}
+			}
+		}
+
+		if ((ocs->mgmt_functions) && (ocs->mgmt_functions->set_handler)) {
+			result = ocs->mgmt_functions->set_handler(qualifier, name, (char *)value, ocs);
+		}
+
+		if (result != 0) {
+			if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->set_handler)) {
+				result = ocs->tgt_mgmt_functions->set_handler(qualifier, name,
+						(char *)value, &(ocs->tgt_ocs));
+			}
+		}
+
+		/* If I didn't know how to set this config value pass the request to each of my children */
+		if (result != 0) {
+			ocs_device_lock(ocs);
+			ocs_list_foreach(&ocs->domain_list, domain) {
+				if ((domain->mgmt_functions) && (domain->mgmt_functions->set_handler)) {
+					result = domain->mgmt_functions->set_handler(qualifier, name, (char*)value, domain);
+				}
+				if (result == 0) {
+					break;
+				}
+			}
+			ocs_device_unlock(ocs);
+		}
+
+
+	}
+
+	return result;
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Perform a management action.
+ *
+ * @par Description
+ * This is the top level "exec" handler for the driver. It
+ * performs the following:
+ *  - Checks that the qualifier portion of the name begins with my qualifier (ocs).
+ *  - If the remaining part of the name matches an action that is known at this level,
+ *    calls the correct function to perform the action.
+ *  - If the name is not known, sends the request to the back-ends to fulfill (if possible).
+ *  - If the request has not been fulfilled by the back-end, passes the request to each of the
+ *    children (domains) to have them (recursively) try to respond.
+ *
+ *  In passing the request to other entities, the request is considered to be handled
+ *  if the function returns 0.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param action Name of the action to be performed.
+ * @param arg_in Pointer to an argument being passed to the action.
+ * @param arg_in_length Length of the argument pointed to by @c arg_in.
+ * @param arg_out Pointer to an argument being passed to the action.
+ * @param arg_out_length Length of the argument pointed to by @c arg_out.
+ *
+ * @return Returns 0 if the action was completed, or -1 otherwise.
+ *
+ *
+ */
+
+int
+ocs_mgmt_exec(ocs_t *ocs, char *action, void *arg_in,
+		uint32_t arg_in_length, void *arg_out, uint32_t arg_out_length)
+{
+	ocs_domain_t *domain;
+	int result = -1;
+	char qualifier[80];
+	uint32_t i;
+
+	snprintf(qualifier, sizeof(qualifier), "/ocs");
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(action, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = action + strlen(qualifier) +1;
+
+		/* See if it's an action I can perform */
+		for (i=0;i<ARRAY_SIZE(mgmt_table); i++) {
+			if (ocs_strcmp(unqualified_name, mgmt_table[i].name) == 0) {
+				if (mgmt_table[i].action_handler) {
+					return mgmt_table[i].action_handler(ocs, action, arg_in, arg_in_length,
+							arg_out, arg_out_length);
+				}
+
+			}
+		}
+
+		if ((ocs->mgmt_functions) && (ocs->mgmt_functions->exec_handler)) {
+			result = ocs->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length,
+								   arg_out, arg_out_length, ocs);
+		}
+
+		if (result != 0) {
+			if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->exec_handler)) {
+				result = ocs->tgt_mgmt_functions->exec_handler(qualifier, action,
+						arg_in, arg_in_length, arg_out, arg_out_length,
+						&(ocs->tgt_ocs));
+			}
+		}
+
+		/* If I didn't know how to do this action pass the request to each of my children */
+		if (result != 0) {
+			ocs_device_lock(ocs);
+			ocs_list_foreach(&ocs->domain_list, domain) {
+				if ((domain->mgmt_functions) && (domain->mgmt_functions->exec_handler)) {
+					result = domain->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length, arg_out,
+							arg_out_length, domain);
+				}
+				if (result == 0) {
+					break;
+				}
+			}
+			ocs_device_unlock(ocs);
+		}
+
+	}
+
+	return result;
+}
+
+void
+ocs_mgmt_get_all(ocs_t *ocs, ocs_textbuf_t *textbuf)
+{
+	ocs_domain_t *domain;
+	uint32_t i;
+
+	ocs_mgmt_start_unnumbered_section(textbuf, "ocs");
+
+	for (i=0;i<ARRAY_SIZE(mgmt_table);i++) {
+		if (mgmt_table[i].get_handler) {
+			mgmt_table[i].get_handler(ocs, mgmt_table[i].name, textbuf);
+		} else if (mgmt_table[i].action_handler) {
+			/* No get_handler, but there's an action_handler. Just report
+			   the name */
+			ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, mgmt_table[i].name);
+		}
+	}
+
+	if ((ocs->mgmt_functions) && (ocs->mgmt_functions->get_all_handler)) {
+		ocs->mgmt_functions->get_all_handler(textbuf, ocs);
+	}
+
+	if ((ocs->tgt_mgmt_functions) && (ocs->tgt_mgmt_functions->get_all_handler)) {
+		ocs->tgt_mgmt_functions->get_all_handler(textbuf, &(ocs->tgt_ocs));
+	}
+
+	ocs_device_lock(ocs);
+	ocs_list_foreach(&ocs->domain_list, domain) {
+		if ((domain->mgmt_functions) && (domain->mgmt_functions->get_all_handler)) {
+			domain->mgmt_functions->get_all_handler(textbuf, domain);
+		}
+	}
+	ocs_device_unlock(ocs);
+
+	ocs_mgmt_end_unnumbered_section(textbuf, "ocs");
+}
+
+#if defined(OCS_INCLUDE_RAMD)
+static int32_t
+ocs_mgmt_read_phys(ocs_t *ocs, char *name, void *arg_in, uint32_t arg_in_length, void *arg_out, uint32_t arg_out_length)
+{
+        uint32_t length;
+        char addr_str[80];
+        uintptr_t target_addr;
+        void* vaddr = NULL;
+        ocs_ramdisc_t **ramdisc_array;
+        uint32_t ramdisc_count;
+
+
+        if ((arg_in == NULL) ||
+            (arg_in_length == 0) ||
+            (arg_out == NULL) ||
+            (arg_out_length == 0)) {
+                return -1;
+        }
+
+        if (arg_in_length > 80) {
+                arg_in_length = 80;
+        }
+
+        if (ocs_copy_from_user(addr_str, arg_in, arg_in_length)) {
+                ocs_log_test(ocs, "Failed to copy addr from user\n");
+                return -EFAULT;
+        }
+
+        target_addr = (uintptr_t)ocs_strtoul(addr_str, NULL, 0);
+        /* addr_str must be the physical address of a buffer that was reported
+         * in an SGL.  Search ramdiscs looking for a segment that contains that
+         * physical address
+         */
+
+        if (ocs->tgt_ocs.use_global_ramd) {
+                /* Only one target */
+                ramdisc_count = ocs->tgt_ocs.rdisc_count;
+                ramdisc_array = ocs->tgt_ocs.rdisc;
+                vaddr = find_address_in_target(ramdisc_array, ramdisc_count, target_addr);
+        } else {
+                /* Multiple targets.  Each target is on a sport */
+		uint32_t domain_idx;
+
+		for (domain_idx=0; domain_idx<ocs->domain_instance_count; domain_idx++) {
+			ocs_domain_t *domain;
+			uint32_t sport_idx;
+
+			domain = ocs_domain_get_instance(ocs, domain_idx);
+			for (sport_idx=0; sport_idx < domain->sport_instance_count; sport_idx++) {
+				ocs_sport_t *sport;
+
+				sport = ocs_sport_get_instance(domain, sport_idx);
+				ramdisc_count = sport->tgt_sport.rdisc_count;
+				ramdisc_array = sport->tgt_sport.rdisc;
+				vaddr = find_address_in_target(ramdisc_array, ramdisc_count, target_addr);
+
+				if (vaddr != NULL) {
+					break;
+				}
+			}
+                }
+        }
+
+
+
+
+        length = arg_out_length;
+
+        if (vaddr != NULL) {
+
+                if (ocs_copy_to_user(arg_out, vaddr, length)) {
+                        ocs_log_test(ocs, "Failed to copy buffer to user\n");
+                        return -EFAULT;
+                }
+
+                return 0;
+        } else {
+
+                return -EFAULT;
+	}
+
+}
+
+/*
+ * This function searches a target for a given physical address.
+ * The target is made up of a number of LUNs, each represented by
+ * a ocs_ramdisc_t.
+ */
+static void* find_address_in_target(ocs_ramdisc_t **ramdisc_array, uint32_t ramdisc_count, uintptr_t target_addr)
+{
+	void *vaddr = NULL;
+	uint32_t ramdisc_idx;
+
+	/* Check each ramdisc */
+	for (ramdisc_idx=0; ramdisc_idx<ramdisc_count; ramdisc_idx++) {
+		uint32_t segment_idx;
+		ocs_ramdisc_t *rdisc;
+		rdisc = ramdisc_array[ramdisc_idx];
+		/* Check each segment in the ramdisc */
+		for (segment_idx=0; segment_idx<rdisc->segment_count; segment_idx++) {
+			ramdisc_segment_t *segment = rdisc->segments[segment_idx];
+			uintptr_t segment_start;
+			uintptr_t segment_end;
+			uint32_t offset;
+
+			segment_start = segment->data_segment.phys;
+			segment_end = segment->data_segment.phys + segment->data_segment.size - 1;
+			if ((target_addr >= segment_start) && (target_addr <= segment_end)) {
+				/* Found the target address */
+				offset = target_addr - segment_start;
+				vaddr = (uint32_t*)segment->data_segment.virt + offset;
+			}
+
+			if (rdisc->dif_separate) {
+				segment_start = segment->dif_segment.phys;
+				segment_end = segment->data_segment.phys + segment->dif_segment.size - 1;
+				if ((target_addr >= segment_start) && (target_addr <= segment_end)) {
+					/* Found the target address */
+					offset = target_addr - segment_start;
+					vaddr = (uint32_t*)segment->dif_segment.virt + offset;
+				}
+			}
+
+			if (vaddr != NULL) {
+				break;
+			}
+
+		}
+
+		if (vaddr != NULL) {
+			break;
+		}
+
+
+	}
+
+	return vaddr;
+}
+#endif
+
+
+
+static int32_t
+ocs_mgmt_firmware_reset(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
+{
+	int rc = 0;
+	int index = 0;
+	uint8_t bus, dev, func;
+	ocs_t *other_ocs;
+
+	ocs_get_bus_dev_func(ocs, &bus, &dev, &func);
+
+	ocs_log_debug(ocs, "Resetting port\n");
+	if (ocs_hw_reset(&ocs->hw, OCS_HW_RESET_FIRMWARE)) {
+		ocs_log_test(ocs, "failed to reset port\n");
+		rc = -1;
+	} else {
+		ocs_log_debug(ocs, "successfully reset port\n");
+
+		/* now reset all functions on the same device */
+
+		while ((other_ocs = ocs_get_instance(index++)) != NULL) {
+			uint8_t other_bus, other_dev, other_func;
+
+			ocs_get_bus_dev_func(other_ocs, &other_bus, &other_dev, &other_func);
+
+			if ((bus == other_bus) && (dev == other_dev)) {
+				if (other_ocs->hw.state !=
+                                      OCS_HW_STATE_UNINITIALIZED) {
+                                        other_ocs->hw.state =
+                                                OCS_HW_STATE_QUEUES_ALLOCATED;
+                                }
+
+				ocs_device_detach(other_ocs);
+				if (ocs_device_attach(other_ocs)) {
+					ocs_log_err(other_ocs,
+						"device %d attach failed \n", index);
+					rc = -1;
+				}
+			}
+		}
+	}
+	return rc;
+}
+
+static int32_t
+ocs_mgmt_function_reset(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
+{
+	int32_t rc;
+
+	ocs_device_detach(ocs);
+	rc = ocs_device_attach(ocs);
+
+	return rc;
+}
+
+static int32_t
+ocs_mgmt_firmware_write(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
+{
+	int rc = 0;
+	uint32_t bytes_left;
+	uint32_t xfer_size;
+	uint32_t offset;
+	uint8_t *userp;
+	ocs_dma_t dma;
+	int last = 0;
+	ocs_mgmt_fw_write_result_t result;
+	uint32_t change_status = 0;
+        char status_str[80];
+
+	ocs_sem_init(&(result.semaphore), 0, "fw_write");
+
+	bytes_left = buf_len;
+	offset = 0;
+	userp = (uint8_t *)buf;
+
+	if (ocs_dma_alloc(ocs, &dma, FW_WRITE_BUFSIZE, 4096)) {
+		ocs_log_err(ocs, "ocs_mgmt_firmware_write: malloc failed");
+		return -ENOMEM;
+	}
+
+	while (bytes_left > 0) {
+
+
+		if (bytes_left > FW_WRITE_BUFSIZE) {
+			xfer_size = FW_WRITE_BUFSIZE;
+		} else {
+			xfer_size = bytes_left;
+		}
+
+		/* Copy xfer_size bytes from user space to kernel buffer */
+		if (ocs_copy_from_user(dma.virt, userp, xfer_size)) {
+			rc = -EFAULT;
+			break;
+		}
+
+		/* See if this is the last block */
+		if (bytes_left == xfer_size) {
+			last = 1;
+		}
+
+		/* Send the HW command */
+		ocs_hw_firmware_write(&ocs->hw, &dma, xfer_size, offset, last, ocs_mgmt_fw_write_cb, &result);
+
+		/* Wait for semaphore to be signaled when the command completes
+		 * TODO:  Should there be a timeout on this?  If so, how long? */
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			rc = -ENXIO;
+			break;
+		}
+
+		if (result.actual_xfer == 0) {
+			ocs_log_test(ocs, "actual_write_length is %d\n", result.actual_xfer);
+			rc = -EFAULT;
+			break;
+		}
+
+		/* Check status */
+		if (result.status != 0) {
+			ocs_log_test(ocs, "write returned status %d\n", result.status);
+			rc = -EFAULT;
+			break;
+		}
+
+		if (last) {
+			change_status = result.change_status;
+		}
+
+		bytes_left -= result.actual_xfer;
+		offset += result.actual_xfer;
+		userp += result.actual_xfer;
+
+	}
+
+	/* Create string with status and copy to userland */
+	if ((arg_out_length > 0) && (arg_out != NULL)) {
+		if (arg_out_length > sizeof(status_str)) {
+			arg_out_length = sizeof(status_str);
+		}
+		ocs_snprintf(status_str, arg_out_length, "%d", change_status);
+		if (ocs_copy_to_user(arg_out, status_str, arg_out_length)) {
+			ocs_log_test(ocs, "copy to user failed for change_status\n");
+		}
+	}
+
+
+	ocs_dma_free(ocs, &dma);
+
+	return rc;
+}
+
+static void
+ocs_mgmt_fw_write_cb(int32_t status, uint32_t actual_write_length, uint32_t change_status, void *arg)
+{
+	ocs_mgmt_fw_write_result_t *result = arg;
+
+	result->status = status;
+	result->actual_xfer = actual_write_length;
+	result->change_status = change_status;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+typedef struct ocs_mgmt_sfp_result {
+	ocs_sem_t semaphore;
+	ocs_lock_t cb_lock;
+	int32_t running;
+	int32_t status;
+	uint32_t bytes_read;
+	uint32_t page_data[32];
+} ocs_mgmt_sfp_result_t;
+
+static void
+ocs_mgmt_sfp_cb(void *os, int32_t status, uint32_t bytes_read, uint32_t *data, void *arg)
+{
+	ocs_mgmt_sfp_result_t *result = arg;
+	ocs_t *ocs = os;
+
+	ocs_lock(&(result->cb_lock));
+	result->running++;
+	if(result->running == 2) {
+		/* get_sfp() has timed out */
+		ocs_unlock(&(result->cb_lock));
+		ocs_free(ocs, result, sizeof(ocs_mgmt_sfp_result_t));
+		return;
+	}
+
+	result->status = status;
+	result->bytes_read = bytes_read;
+	ocs_memcpy(&result->page_data, data, SFP_PAGE_SIZE);
+
+	ocs_sem_v(&(result->semaphore));
+	ocs_unlock(&(result->cb_lock));
+}
+
+static int32_t
+ocs_mgmt_get_sfp(ocs_t *ocs, uint16_t page, void *buf, uint32_t buf_len)
+{
+	int rc = 0;
+	ocs_mgmt_sfp_result_t *result = ocs_malloc(ocs, sizeof(ocs_mgmt_sfp_result_t),  OCS_M_ZERO | OCS_M_NOWAIT);;
+
+	ocs_sem_init(&(result->semaphore), 0, "get_sfp");
+	ocs_lock_init(ocs, &(result->cb_lock), "get_sfp");
+
+	/* Send the HW command */
+	ocs_hw_get_sfp(&ocs->hw, page, ocs_mgmt_sfp_cb, result);
+
+	/* Wait for semaphore to be signaled when the command completes */
+	if (ocs_sem_p(&(result->semaphore), 5 * 1000 * 1000) != 0) {
+		/* Timed out, callback will free memory */
+		ocs_lock(&(result->cb_lock));
+		result->running++;
+		if(result->running == 1) {
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			ocs_unlock(&(result->cb_lock));
+			return (-ENXIO);
+		}
+		/* sfp_cb() has already executed, proceed as normal */
+		ocs_unlock(&(result->cb_lock));
+	}
+
+	/* Check status */
+	if (result->status != 0) {
+		ocs_log_test(ocs, "read_transceiver_data returned status %d\n",
+			     result->status);
+		rc = -EFAULT;
+	}
+
+	if (rc == 0) {
+		rc = (result->bytes_read > buf_len ? buf_len : result->bytes_read);
+		/* Copy the results back to the supplied buffer */
+		ocs_memcpy(buf, result->page_data, rc);
+	}
+
+	ocs_free(ocs, result, sizeof(ocs_mgmt_sfp_result_t));
+	return rc;
+}
+
+static int32_t
+ocs_mgmt_force_assert(ocs_t *ocs, char *name, void *buf, uint32_t buf_len, void *arg_out, uint32_t arg_out_length)
+{
+	ocs_assert(FALSE, 0);
+}
+
+static void
+get_nodes_count(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_xport_t *xport = ocs->xport;
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "nodes_count", "%d", xport->nodes_count);
+}
+
+static void
+get_driver_version(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "driver_version", ocs->driver_version);
+}
+
+static void
+get_desc(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "desc", ocs->desc);
+}
+
+static void
+get_fw_rev(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "fw_rev", ocs_hw_get_ptr(&ocs->hw, OCS_HW_FW_REV));
+}
+
+static void
+get_fw_rev2(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "fw_rev2", ocs_hw_get_ptr(&ocs->hw, OCS_HW_FW_REV2));
+}
+
+static void
+get_ipl(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "ipl", ocs_hw_get_ptr(&ocs->hw, OCS_HW_IPL));
+}
+
+static void
+get_hw_rev1(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t value;
+
+	ocs_hw_get(&ocs->hw, OCS_HW_HW_REV1, &value);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_rev1", "%u", value);
+}
+
+static void
+get_hw_rev2(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t value;
+
+	ocs_hw_get(&ocs->hw, OCS_HW_HW_REV2, &value);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_rev2", "%u", value);
+}
+
+static void
+get_hw_rev3(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t value;
+	ocs_hw_get(&ocs->hw, OCS_HW_HW_REV3, &value);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "hw_rev3", "%u", value);
+}
+
+static void
+get_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint64_t *wwnn;
+
+	wwnn = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_NODE);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwnn", "0x%llx", (unsigned long long)ocs_htobe64(*wwnn));
+}
+
+static void
+get_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint64_t *wwpn;
+
+	wwpn = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_PORT);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwpn", "0x%llx", (unsigned long long)ocs_htobe64(*wwpn));
+}
+
+static void
+get_fcid(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	if (ocs->domain && ocs->domain->attached) {
+		ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "0x%06x", 
+						ocs->domain->sport->fc_id);
+	} else {
+		ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "UNKNOWN"); 
+	}
+
+}
+
+static void
+get_sn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint8_t *pserial;
+	uint32_t len;
+	char sn_buf[256];
+
+	pserial = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_SERIALNUMBER);
+	if (pserial) {
+		len = *pserial ++;
+		strncpy(sn_buf, (char*)pserial, len);
+		sn_buf[len] = '\0';
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sn", sn_buf);
+	}
+}
+
+static void
+get_pn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint8_t *pserial;
+	uint32_t len;
+	char sn_buf[256];
+
+	pserial = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_PARTNUMBER);
+	if (pserial) {
+		len = *pserial ++;
+		strncpy(sn_buf, (char*)pserial, len);
+		sn_buf[len] = '\0';
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pn", sn_buf);
+	} else {
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pn", ocs->model);
+	}
+}
+
+static void
+get_sli4_intf_reg(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "sli4_intf_reg", "0x%04x",
+		ocs_config_read32(ocs, SLI4_INTF_REG));
+}
+
+static void
+get_phy_port_num(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	char *phy_port = NULL;
+
+	phy_port = ocs_scsi_get_property_ptr(ocs, OCS_SCSI_PORTNUM);
+	if (phy_port) {
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "phy_port_num", phy_port);
+	} else {
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "phy_port_num", "unknown");
+	}
+}
+static void
+get_asic_id(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "asic_id_reg", "0x%04x",
+		ocs_config_read32(ocs, SLI4_ASIC_ID_REG));
+}
+
+static void
+get_chip_type(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t family;
+	uint32_t asic_id;
+	uint32_t asic_gen_num;
+	uint32_t asic_rev_num;
+	uint32_t rev_id;
+	char result_buf[80];
+	char tmp_buf[80];
+
+	family = (ocs_config_read32(ocs, SLI4_INTF_REG) & 0x00000f00) >> 8;
+	asic_id = ocs_config_read32(ocs, SLI4_ASIC_ID_REG);
+	asic_rev_num = asic_id & 0xff;
+	asic_gen_num = (asic_id & 0xff00) >> 8;
+
+	rev_id = ocs_config_read32(ocs, SLI4_PCI_CLASS_REVISION) & 0xff;
+
+	switch(family) {
+	case 0x00:
+		/* BE2 */
+		ocs_strncpy(result_buf,  "BE2 A", sizeof(result_buf));
+		ocs_snprintf(tmp_buf, 2, "%d", rev_id);
+		strcat(result_buf, tmp_buf);
+		break;
+	case 0x01:
+		/* BE3 */
+		ocs_strncpy(result_buf, "BE3", sizeof(result_buf));
+		if (rev_id >= 0x10) {
+			strcat(result_buf, "-R");
+		}
+		ocs_snprintf(tmp_buf, 3, " %c", ((rev_id & 0xf0) >> 4) + 'A');
+		strcat(result_buf, tmp_buf);
+		ocs_snprintf(tmp_buf, 2, "%d", rev_id & 0x0f);
+		strcat(result_buf, tmp_buf);
+		break;
+	case 0x02:
+		/* Skyhawk A0 */
+		ocs_strncpy(result_buf, "Skyhawk A0", sizeof(result_buf));
+		break;
+	case 0x0a:
+		/* Lancer A0 */
+		ocs_strncpy(result_buf, "Lancer A", sizeof(result_buf));
+		ocs_snprintf(tmp_buf, 2, "%d", rev_id & 0x0f);
+		strcat(result_buf, tmp_buf);
+		break;
+	case 0x0b:
+		/* Lancer B0 or D0 */
+		ocs_strncpy(result_buf, "Lancer", sizeof(result_buf));
+		ocs_snprintf(tmp_buf, 3, " %c", ((rev_id & 0xf0) >> 4) + 'A');
+		strcat(result_buf, tmp_buf);
+		ocs_snprintf(tmp_buf, 2, "%d", rev_id & 0x0f);
+		strcat(result_buf, tmp_buf);
+		break;
+	case 0x0c:
+		ocs_strncpy(result_buf, "Lancer G6", sizeof(result_buf));
+		break;
+	case 0x0f:
+		/* Refer to ASIC_ID */
+		switch(asic_gen_num) {
+		case 0x00:
+			ocs_strncpy(result_buf, "BE2", sizeof(result_buf));
+			break;
+		case 0x03:
+			ocs_strncpy(result_buf, "BE3-R", sizeof(result_buf));
+			break;
+		case 0x04:
+			ocs_strncpy(result_buf, "Skyhawk-R", sizeof(result_buf));
+			break;
+		case 0x05:
+			ocs_strncpy(result_buf, "Corsair", sizeof(result_buf));
+			break;
+		case 0x0b:
+			ocs_strncpy(result_buf, "Lancer", sizeof(result_buf));
+			break;
+		case 0x0c:
+			ocs_strncpy(result_buf, "LancerG6", sizeof(result_buf));
+			break;
+		default:
+			ocs_strncpy(result_buf, "Unknown", sizeof(result_buf));
+		}
+		if (ocs_strcmp(result_buf, "Unknown") != 0) {
+			ocs_snprintf(tmp_buf, 3, " %c", ((asic_rev_num & 0xf0) >> 4) + 'A');
+			strcat(result_buf, tmp_buf);
+			ocs_snprintf(tmp_buf, 2, "%d", asic_rev_num & 0x0f);
+			strcat(result_buf, tmp_buf);
+		}
+		break;
+	default:
+		ocs_strncpy(result_buf, "Unknown", sizeof(result_buf));
+	}
+
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "chip_type", result_buf);
+
+}
+
+static void
+get_pci_vendor(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_vendor", "0x%04x", ocs->pci_vendor);
+}
+
+static void
+get_pci_device(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_device", "0x%04x", ocs->pci_device);
+}
+
+static void
+get_pci_subsystem_vendor(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_subsystem_vendor", "0x%04x", ocs->pci_subsystem_vendor);
+}
+
+static void
+get_pci_subsystem_device(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "pci_subsystem_device", "0x%04x", ocs->pci_subsystem_device);
+}
+
+static void
+get_tgt_rscn_delay(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "tgt_rscn_delay", "%ld", (unsigned long)ocs->tgt_rscn_delay_msec / 1000);
+}
+
+static void
+get_tgt_rscn_period(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "tgt_rscn_period", "%ld", (unsigned long)ocs->tgt_rscn_period_msec / 1000);
+}
+
+static void
+get_inject_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_drop_cmd", "%d",
+			(ocs->err_injection == INJECT_DROP_CMD ? 1:0));
+}
+
+static void
+get_inject_free_drop_cmd(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_free_drop_cmd", "%d",
+			(ocs->err_injection == INJECT_FREE_DROPPED ? 1:0));
+}
+
+static void
+get_inject_drop_data(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_drop_data", "%d",
+			(ocs->err_injection == INJECT_DROP_DATA ? 1:0));
+}
+
+static void
+get_inject_drop_resp(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "inject_drop_resp", "%d",
+			(ocs->err_injection == INJECT_DROP_RESP ? 1:0));
+}
+
+static void
+get_cmd_err_inject(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "cmd_err_inject", "0x%02x", ocs->cmd_err_inject);
+}
+
+static void
+get_cmd_delay_value(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "cmd_delay_value", "%ld", (unsigned long)ocs->delay_value_msec);
+}
+
+static void
+get_businfo(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "businfo", ocs->businfo);
+}
+
+static void
+get_sfp_a0(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint8_t *page_data;
+	char *buf;
+	int i;
+	int32_t bytes_read;
+
+	page_data = ocs_malloc(ocs, SFP_PAGE_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (page_data == NULL) {
+		return;
+	}
+
+	buf = ocs_malloc(ocs, (SFP_PAGE_SIZE * 3) + 1, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (buf == NULL) {
+		ocs_free(ocs, page_data, SFP_PAGE_SIZE);
+		return;
+	}
+
+	bytes_read = ocs_mgmt_get_sfp(ocs, 0xa0, page_data, SFP_PAGE_SIZE);
+
+	if (bytes_read <= 0) {
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a0", "(unknown)");
+	} else {
+		char *d = buf;
+		uint8_t *s = page_data;
+		int buffer_remaining = (SFP_PAGE_SIZE * 3) + 1;
+		int bytes_added;
+
+		for (i = 0; i < bytes_read; i++) {
+			bytes_added = ocs_snprintf(d, buffer_remaining, "%02x ", *s);
+			++s;
+			d += bytes_added;
+			buffer_remaining -= bytes_added;
+		}
+		*d = '\0';
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a0", buf);
+	}
+
+	ocs_free(ocs, page_data, SFP_PAGE_SIZE);
+	ocs_free(ocs, buf, (3 * SFP_PAGE_SIZE) + 1);
+}
+
+static void
+get_sfp_a2(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint8_t *page_data;
+	char *buf;
+	int i;
+	int32_t bytes_read;
+
+	page_data = ocs_malloc(ocs, SFP_PAGE_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (page_data == NULL) {
+		return;
+	}
+
+	buf = ocs_malloc(ocs, (SFP_PAGE_SIZE * 3) + 1, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (buf == NULL) {
+		ocs_free(ocs, page_data, SFP_PAGE_SIZE);
+		return;
+	}
+
+	bytes_read = ocs_mgmt_get_sfp(ocs, 0xa2, page_data, SFP_PAGE_SIZE);
+
+	if (bytes_read <= 0) {
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a2", "(unknown)");
+	} else {
+		char *d = buf;
+		uint8_t *s = page_data;
+		int buffer_remaining = (SFP_PAGE_SIZE * 3) + 1;
+		int bytes_added;
+
+		for (i=0; i < bytes_read; i++) {
+			bytes_added = ocs_snprintf(d, buffer_remaining, "%02x ", *s);
+			++s;
+			d += bytes_added;
+			buffer_remaining -= bytes_added;
+		}
+		*d = '\0';
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "sfp_a2", buf);
+	}
+
+	ocs_free(ocs, page_data, SFP_PAGE_SIZE);
+	ocs_free(ocs, buf, (3 * SFP_PAGE_SIZE) + 1);
+}
+
+static void
+get_debug_mq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_mq_dump",
+		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_MQ_DUMP));
+}
+
+static void
+get_debug_cq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_cq_dump",
+		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_CQ_DUMP));
+}
+
+static void
+get_debug_wq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_wq_dump",
+		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_WQ_DUMP));
+}
+
+static void
+get_debug_eq_dump(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RW, "debug_eq_dump",
+		ocs_debug_is_enabled(OCS_DEBUG_ENABLE_EQ_DUMP));
+}
+
+static void
+get_logmask(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "logmask", "0x%02x", ocs->logmask);
+
+}
+
+static void
+get_loglevel(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "loglevel", "%d", loglevel);
+
+}
+
+static void
+get_current_speed(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t value;
+
+	ocs_hw_get(&(ocs->hw), OCS_HW_LINK_SPEED, &value);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "current_speed", "%d", value);
+}
+
+static void
+get_configured_speed(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t value;
+
+	ocs_hw_get(&(ocs->hw), OCS_HW_LINK_CONFIG_SPEED, &value);
+	if (value == 0) {
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "configured_speed", "auto");
+	} else {
+		ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "configured_speed", "%d", value);
+	}
+
+}
+
+static void
+get_current_topology(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t value;
+
+	ocs_hw_get(&(ocs->hw), OCS_HW_TOPOLOGY, &value);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "current_topology", "%d", value);
+
+}
+
+static void
+get_configured_topology(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t value;
+
+	ocs_hw_get(&(ocs->hw), OCS_HW_CONFIG_TOPOLOGY, &value);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "configured_topology", "%d", value);
+
+}
+
+static void
+get_current_link_state(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_xport_stats_t value;
+
+	if (ocs_xport_status(ocs->xport, OCS_XPORT_PORT_STATUS, &value) == 0) {
+		if (value.value == OCS_XPORT_PORT_ONLINE) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "current_link_state", "online");
+		} else {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "current_link_state", "offline");
+		}
+	}
+}
+
+static void
+get_configured_link_state(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_xport_stats_t value;
+
+	if (ocs_xport_status(ocs->xport, OCS_XPORT_CONFIG_PORT_STATUS, &value) == 0) {
+		if (value.value == OCS_XPORT_PORT_ONLINE) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "configured_link_state", "online");
+		} else {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "configured_link_state", "offline");
+		}
+	}
+}
+
+/**
+ * @brief HW link config enum to mgmt string value mapping.
+ *
+ * This structure provides a mapping from the ocs_hw_linkcfg_e
+ * enum (enum exposed for the OCS_HW_PORT_SET_LINK_CONFIG port
+ * control) to the mgmt string that is passed in by the mgmt application
+ * (elxsdkutil).
+ */
+typedef struct ocs_mgmt_linkcfg_map_s {
+	ocs_hw_linkcfg_e linkcfg;
+	const char *mgmt_str;
+} ocs_mgmt_linkcfg_map_t;
+
+static ocs_mgmt_linkcfg_map_t mgmt_linkcfg_map[] = {
+	{OCS_HW_LINKCFG_4X10G, OCS_CONFIG_LINKCFG_4X10G},
+	{OCS_HW_LINKCFG_1X40G, OCS_CONFIG_LINKCFG_1X40G},
+	{OCS_HW_LINKCFG_2X16G, OCS_CONFIG_LINKCFG_2X16G},
+	{OCS_HW_LINKCFG_4X8G, OCS_CONFIG_LINKCFG_4X8G},
+	{OCS_HW_LINKCFG_4X1G, OCS_CONFIG_LINKCFG_4X1G},
+	{OCS_HW_LINKCFG_2X10G, OCS_CONFIG_LINKCFG_2X10G},
+	{OCS_HW_LINKCFG_2X10G_2X8G, OCS_CONFIG_LINKCFG_2X10G_2X8G}};
+
+/**
+ * @brief Get the HW linkcfg enum from the mgmt config string.
+ *
+ * @param mgmt_str mgmt string value.
+ *
+ * @return Returns the HW linkcfg enum corresponding to clp_str.
+ */
+static ocs_hw_linkcfg_e
+ocs_hw_linkcfg_from_mgmt(const char *mgmt_str)
+{
+	uint32_t i;
+	for (i = 0; i < ARRAY_SIZE(mgmt_linkcfg_map); i++) {
+		if (ocs_strncmp(mgmt_linkcfg_map[i].mgmt_str,
+				mgmt_str, ocs_strlen(mgmt_str)) == 0) {
+			return mgmt_linkcfg_map[i].linkcfg;
+		}
+	}
+	return OCS_HW_LINKCFG_NA;
+}
+
+/**
+ * @brief Get the mgmt string value from the HW linkcfg enum.
+ *
+ * @param linkcfg HW linkcfg enum.
+ *
+ * @return Returns the mgmt string value corresponding to the given HW linkcfg.
+ */
+static const char *
+ocs_mgmt_from_hw_linkcfg(ocs_hw_linkcfg_e linkcfg)
+{
+	uint32_t i;
+	for (i = 0; i < ARRAY_SIZE(mgmt_linkcfg_map); i++) {
+		if (mgmt_linkcfg_map[i].linkcfg == linkcfg) {
+			return mgmt_linkcfg_map[i].mgmt_str;
+		}
+	}
+	return OCS_CONFIG_LINKCFG_UNKNOWN;
+}
+
+/**
+ * @brief Link configuration callback argument
+ */
+typedef struct ocs_mgmt_linkcfg_arg_s {
+	ocs_sem_t semaphore;
+	int32_t status;
+	ocs_hw_linkcfg_e linkcfg;
+} ocs_mgmt_linkcfg_arg_t;
+
+/**
+ * @brief Get linkcfg config value
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param textbuf The textbuf to which the result is written.
+ *
+ * @return None.
+ */
+static void
+get_linkcfg(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	const char *linkcfg_str = NULL;
+	uint32_t value;
+	ocs_hw_linkcfg_e linkcfg;
+	ocs_hw_get(&ocs->hw, OCS_HW_LINKCFG, &value);
+	linkcfg = (ocs_hw_linkcfg_e)value;
+	linkcfg_str = ocs_mgmt_from_hw_linkcfg(linkcfg);
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "linkcfg", linkcfg_str);
+}
+
+/**
+ * @brief Get requested WWNN config value
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param textbuf The textbuf to which the result is written.
+ *
+ * @return None.
+ */
+static void
+get_req_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_xport_t *xport = ocs->xport;
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "requested_wwnn", "0x%llx", (unsigned long long)xport->req_wwnn);
+}
+
+/**
+ * @brief Get requested WWPN config value
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param textbuf The textbuf to which the result is written.
+ *
+ * @return None.
+ */
+static void
+get_req_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_xport_t *xport = ocs->xport;
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "requested_wwpn", "0x%llx", (unsigned long long)xport->req_wwpn);
+}
+
+/**
+ * @brief Get requested nodedb_mask config value
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param textbuf The textbuf to which the result is written.
+ *
+ * @return None.
+ */
+static void
+get_nodedb_mask(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RW, "nodedb_mask", "0x%08x", ocs->nodedb_mask);
+}
+
+/**
+ * @brief Set requested WWNN value.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param value Value to which the linkcfg is set.
+ *
+ * @return Returns 0 on success.
+ */
+
+int
+set_req_wwnn(ocs_t *ocs, char *name, char *value)
+{
+	int rc;
+	uint64_t wwnn;
+
+	if (ocs_strcasecmp(value, "default") == 0) {
+		wwnn = 0;
+	}
+	else if (parse_wwn(value, &wwnn) != 0) {
+		ocs_log_test(ocs, "Invalid WWNN: %s\n", value);
+		return 1;
+	}
+
+	rc = ocs_xport_control(ocs->xport, OCS_XPORT_WWNN_SET, wwnn);
+
+	if(rc) {
+		ocs_log_test(ocs, "OCS_XPORT_WWNN_SET failed: %d\n", rc);
+		return rc;
+	}
+
+	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
+	if (rc) {
+		ocs_log_test(ocs, "port offline failed : %d\n", rc);
+	}
+
+	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+	if (rc) {
+		ocs_log_test(ocs, "port online failed : %d\n", rc);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Set requested WWNP value.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param value Value to which the linkcfg is set.
+ *
+ * @return Returns 0 on success.
+ */
+
+int
+set_req_wwpn(ocs_t *ocs, char *name, char *value)
+{
+	int rc;
+	uint64_t wwpn;
+
+	if (ocs_strcasecmp(value, "default") == 0) {
+		wwpn = 0;
+	}
+	else if (parse_wwn(value, &wwpn) != 0) {
+		ocs_log_test(ocs, "Invalid WWPN: %s\n", value);
+		return 1;
+	}
+
+	rc = ocs_xport_control(ocs->xport, OCS_XPORT_WWPN_SET, wwpn);
+
+	if(rc) {
+		ocs_log_test(ocs, "OCS_XPORT_WWPN_SET failed: %d\n", rc);
+		return rc;
+	}
+
+	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
+	if (rc) {
+		ocs_log_test(ocs, "port offline failed : %d\n", rc);
+	}
+
+	rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+	if (rc) {
+		ocs_log_test(ocs, "port online failed : %d\n", rc);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Set node debug mask value
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param value Value to which the nodedb_mask is set.
+ *
+ * @return Returns 0 on success.
+ */
+static int
+set_nodedb_mask(ocs_t *ocs, char *name, char *value)
+{
+	ocs->nodedb_mask = ocs_strtoul(value, 0, 0);
+	return 0;
+}
+
+/**
+ * @brief Set linkcfg config value.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Not used.
+ * @param value Value to which the linkcfg is set.
+ *
+ * @return Returns 0 on success.
+ */
+static int
+set_linkcfg(ocs_t *ocs, char *name, char *value)
+{
+	ocs_hw_linkcfg_e linkcfg;
+	ocs_mgmt_linkcfg_arg_t cb_arg;
+	ocs_hw_rtn_e status;
+
+	ocs_sem_init(&cb_arg.semaphore, 0, "mgmt_linkcfg");
+
+	/* translate mgmt linkcfg string to HW linkcfg enum */
+	linkcfg = ocs_hw_linkcfg_from_mgmt(value);
+
+	/* set HW linkcfg */
+	status = ocs_hw_port_control(&ocs->hw, OCS_HW_PORT_SET_LINK_CONFIG,
+				      (uintptr_t)linkcfg, ocs_mgmt_linkcfg_cb, &cb_arg);
+	if (status) {
+		ocs_log_test(ocs, "ocs_hw_set_linkcfg failed\n");
+		return -1;
+	}
+
+	if (ocs_sem_p(&cb_arg.semaphore, OCS_SEM_FOREVER)) {
+		ocs_log_err(ocs, "ocs_sem_p failed\n");
+		return -1;
+	}
+
+	if (cb_arg.status) {
+		ocs_log_test(ocs, "failed to set linkcfg from HW status=%d\n",
+			     cb_arg.status);
+		return -1;
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Linkcfg callback
+ *
+ * @param status Result of the linkcfg get/set operation.
+ * @param value Resulting linkcfg value.
+ * @param arg Callback argument.
+ *
+ * @return None.
+ */
+static void
+ocs_mgmt_linkcfg_cb(int32_t status, uintptr_t value, void *arg)
+{
+	ocs_mgmt_linkcfg_arg_t *cb_arg = (ocs_mgmt_linkcfg_arg_t *)arg;
+	cb_arg->status = status;
+	cb_arg->linkcfg = (ocs_hw_linkcfg_e)value;
+	ocs_sem_v(&cb_arg->semaphore);
+}
+
+static int
+set_debug_mq_dump(ocs_t *ocs, char *name, char *value)
+{
+	int result;
+
+	if (ocs_strcasecmp(value, "false") == 0) {
+		ocs_debug_disable(OCS_DEBUG_ENABLE_MQ_DUMP);
+		result = 0;
+	} else if (ocs_strcasecmp(value, "true") == 0) {
+		ocs_debug_enable(OCS_DEBUG_ENABLE_MQ_DUMP);
+		result = 0;
+	} else {
+		result = -1;
+	}
+
+	return result;
+}
+
+static int
+set_debug_cq_dump(ocs_t *ocs, char *name, char *value)
+{
+	int result;
+
+	if (ocs_strcasecmp(value, "false") == 0) {
+		ocs_debug_disable(OCS_DEBUG_ENABLE_CQ_DUMP);
+		result = 0;
+	} else if (ocs_strcasecmp(value, "true") == 0) {
+		ocs_debug_enable(OCS_DEBUG_ENABLE_CQ_DUMP);
+		result = 0;
+	} else {
+		result = -1;
+	}
+
+	return result;
+}
+
+static int
+set_debug_wq_dump(ocs_t *ocs, char *name, char *value)
+{
+	int result;
+
+	if (ocs_strcasecmp(value, "false") == 0) {
+		ocs_debug_disable(OCS_DEBUG_ENABLE_WQ_DUMP);
+		result = 0;
+	} else if (ocs_strcasecmp(value, "true") == 0) {
+		ocs_debug_enable(OCS_DEBUG_ENABLE_WQ_DUMP);
+		result = 0;
+	} else {
+		result = -1;
+	}
+
+	return result;
+}
+
+static int
+set_debug_eq_dump(ocs_t *ocs, char *name, char *value)
+{
+	int result;
+
+	if (ocs_strcasecmp(value, "false") == 0) {
+		ocs_debug_disable(OCS_DEBUG_ENABLE_EQ_DUMP);
+		result = 0;
+	} else if (ocs_strcasecmp(value, "true") == 0) {
+		ocs_debug_enable(OCS_DEBUG_ENABLE_EQ_DUMP);
+		result = 0;
+	} else {
+		result = -1;
+	}
+
+	return result;
+}
+
+static int
+set_logmask(ocs_t *ocs, char *name, char *value)
+{
+
+	ocs->logmask = ocs_strtoul(value, NULL, 0);
+
+	return 0;
+}
+
+static int
+set_loglevel(ocs_t *ocs, char *name, char *value)
+{
+
+	loglevel = ocs_strtoul(value, NULL, 0);
+
+	return 0;
+}
+
+int
+set_configured_speed(ocs_t *ocs, char *name, char *value)
+{
+	int result = 0;
+	ocs_hw_rtn_e hw_rc;
+	int xport_rc;
+	uint32_t spd;
+
+	spd = ocs_strtoul(value, NULL, 0);
+
+	if ((spd != 0) && (spd != 2000) && (spd != 4000) &&
+		(spd != 8000) && (spd != 16000) && (spd != 32000)) {
+		ocs_log_test(ocs, "unsupported speed %d\n", spd);
+		return 1;
+	}
+
+	ocs_log_debug(ocs, "Taking port offline\n");
+	xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
+	if (xport_rc != 0) {
+		ocs_log_test(ocs, "Port offline failed\n");
+		result = 1;
+	} else {
+		ocs_log_debug(ocs, "Setting port to speed %d\n", spd);
+		hw_rc = ocs_hw_set(&ocs->hw, OCS_HW_LINK_SPEED, spd);
+		if (hw_rc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_test(ocs, "Speed set failed\n");
+			result = 1;
+		}
+
+		/* If we failed to set the speed we still want to try to bring
+		 * the port back online */
+
+		ocs_log_debug(ocs, "Bringing port online\n");
+		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+		if (xport_rc != 0) {
+			result = 1;
+		}
+	}
+
+	return result;
+}
+
+int
+set_configured_topology(ocs_t *ocs, char *name, char *value)
+{
+	int result = 0;
+	ocs_hw_rtn_e hw_rc;
+	int xport_rc;
+	uint32_t topo;
+
+	topo = ocs_strtoul(value, NULL, 0);
+	if (topo >= OCS_HW_TOPOLOGY_NONE) {
+		return 1;
+	}
+
+	ocs_log_debug(ocs, "Taking port offline\n");
+	xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
+	if (xport_rc != 0) {
+		ocs_log_test(ocs, "Port offline failed\n");
+		result = 1;
+	} else {
+		ocs_log_debug(ocs, "Setting port to topology %d\n", topo);
+		hw_rc = ocs_hw_set(&ocs->hw, OCS_HW_TOPOLOGY, topo);
+		if (hw_rc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_test(ocs, "Topology set failed\n");
+			result = 1;
+		}
+
+		/* If we failed to set the topology we still want to try to bring
+		 * the port back online */
+
+		ocs_log_debug(ocs, "Bringing port online\n");
+		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+		if (xport_rc != 0) {
+			result = 1;
+		}
+	}
+
+	return result;
+}
+
+static int
+set_configured_link_state(ocs_t *ocs, char *name, char *value)
+{
+	int result = 0;
+	int xport_rc;
+
+	if (ocs_strcasecmp(value, "offline") == 0) {
+		ocs_log_debug(ocs, "Setting port to %s\n", value);
+		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_OFFLINE);
+		if (xport_rc != 0) {
+			ocs_log_test(ocs, "Setting port to offline failed\n");
+			result = -1;
+		}
+	} else if (ocs_strcasecmp(value, "online") == 0) {
+		ocs_log_debug(ocs, "Setting port to %s\n", value);
+		xport_rc = ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE);
+		if (xport_rc != 0) {
+			ocs_log_test(ocs, "Setting port to online failed\n");
+			result = -1;
+		}
+	} else {
+		ocs_log_test(ocs, "Unsupported link state \"%s\"\n", value);
+		result = -1;
+	}
+
+	return result;
+}
+
+typedef struct ocs_mgmt_get_port_protocol_result {
+	ocs_sem_t semaphore;
+	int32_t status;
+	ocs_hw_port_protocol_e port_protocol;
+} ocs_mgmt_get_port_protocol_result_t;
+
+
+static void
+ocs_mgmt_get_port_protocol_cb(int32_t status,
+			      ocs_hw_port_protocol_e port_protocol,
+			      void    *arg)
+{
+	ocs_mgmt_get_port_protocol_result_t *result = arg;
+
+	result->status = status;
+	result->port_protocol = port_protocol;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+static void
+get_port_protocol(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_get_port_protocol_result_t result;
+	uint8_t bus;
+	uint8_t dev;
+	uint8_t func;
+
+	ocs_sem_init(&(result.semaphore), 0, "get_port_protocol");
+
+	ocs_get_bus_dev_func(ocs, &bus, &dev, &func);
+
+	if(ocs_hw_get_port_protocol(&ocs->hw, func, ocs_mgmt_get_port_protocol_cb, &result) == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+		}
+		if (result.status == 0) {
+			switch (result.port_protocol) {
+			case OCS_HW_PORT_PROTOCOL_ISCSI:
+				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "iSCSI");
+				break;
+			case OCS_HW_PORT_PROTOCOL_FCOE:
+				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "FCoE");
+				break;
+			case OCS_HW_PORT_PROTOCOL_FC:
+				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "FC");
+				break;
+			case OCS_HW_PORT_PROTOCOL_OTHER:
+				ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "Other");
+				break;
+			}
+		} else {
+			ocs_log_test(ocs, "getting port profile status 0x%x\n", result.status);
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "port_protocol", "Unknown");
+		}
+	}
+}
+
+typedef struct ocs_mgmt_set_port_protocol_result {
+	ocs_sem_t semaphore;
+	int32_t status;
+} ocs_mgmt_set_port_protocol_result_t;
+
+
+
+static void
+ocs_mgmt_set_port_protocol_cb(int32_t status,
+			      void    *arg)
+{
+	ocs_mgmt_get_port_protocol_result_t *result = arg;
+
+	result->status = status;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+/**
+ * @brief  Set port protocol
+ * @par Description
+ * This is a management action handler to set the current
+ * port protocol.  Input value should be one of iSCSI,
+ * FC, or FCoE.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param value The value to be assigned
+ *
+ * @return Returns 0 on success, non-zero on failure.
+ */
+static int32_t
+set_port_protocol(ocs_t *ocs, char *name, char *value)
+{
+	ocs_mgmt_set_port_protocol_result_t result;
+	int32_t rc = 0;
+	ocs_hw_port_protocol_e new_protocol;
+	uint8_t bus;
+	uint8_t dev;
+	uint8_t func;
+
+	ocs_get_bus_dev_func(ocs, &bus, &dev, &func);
+
+	ocs_sem_init(&(result.semaphore), 0, "set_port_protocol");
+
+	if (ocs_strcasecmp(value, "iscsi") == 0) {
+		new_protocol = OCS_HW_PORT_PROTOCOL_ISCSI;
+	} else if (ocs_strcasecmp(value, "fc") == 0) {
+		new_protocol = OCS_HW_PORT_PROTOCOL_FC;
+	} else if (ocs_strcasecmp(value, "fcoe") == 0) {
+		new_protocol = OCS_HW_PORT_PROTOCOL_FCOE;
+	} else {
+		return -1;
+	}
+
+	rc = ocs_hw_set_port_protocol(&ocs->hw, new_protocol, func,
+				       ocs_mgmt_set_port_protocol_cb, &result);
+	if (rc == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			rc = -ENXIO;
+		}
+		if (result.status == 0) {
+			/* Success. */
+			rc = 0;
+		} else {
+			rc = -1;
+			ocs_log_test(ocs, "setting active profile status 0x%x\n",
+				     result.status);
+		}
+	}
+
+	return rc;
+}
+
+typedef struct ocs_mgmt_get_profile_list_result_s {
+	ocs_sem_t semaphore;
+	int32_t status;
+	ocs_hw_profile_list_t *list;
+} ocs_mgmt_get_profile_list_result_t;
+
+static void
+ocs_mgmt_get_profile_list_cb(int32_t status, ocs_hw_profile_list_t *list, void *ul_arg)
+{
+	ocs_mgmt_get_profile_list_result_t *result = ul_arg;
+
+	result->status = status;
+	result->list = list;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+/**
+ * @brief  Get list of profiles
+ * @par Description
+ * This is a management action handler to get the list of
+ * profiles supported by the SLI port.  Although the spec says
+ * that all SLI platforms support this, only Skyhawk actually
+ * has a useful implementation.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
+ *
+ * @return none
+ */
+static void
+get_profile_list(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	ocs_mgmt_get_profile_list_result_t result;
+
+	ocs_sem_init(&(result.semaphore), 0, "get_profile_list");
+
+	if(ocs_hw_get_profile_list(&ocs->hw, ocs_mgmt_get_profile_list_cb, &result) == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+		}
+		if (result.status == 0) {
+			/* Success. */
+#define MAX_LINE_SIZE 520
+#define BUFFER_SIZE MAX_LINE_SIZE*40
+			char *result_buf;
+			char result_line[MAX_LINE_SIZE];
+			uint32_t bytes_left;
+			uint32_t i;
+
+			result_buf = ocs_malloc(ocs, BUFFER_SIZE, OCS_M_ZERO);
+			bytes_left = BUFFER_SIZE;
+
+			for (i=0; i<result.list->num_descriptors; i++) {
+				sprintf(result_line, "0x%02x:%s\n", result.list->descriptors[i].profile_id,
+					result.list->descriptors[i].profile_description);
+				if (strlen(result_line) < bytes_left) {
+					strcat(result_buf, result_line);
+					bytes_left -= strlen(result_line);
+				}
+			}
+
+
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "profile_list", result_buf);
+
+			ocs_free(ocs, result_buf, BUFFER_SIZE);
+			ocs_free(ocs, result.list, sizeof(ocs_hw_profile_list_t));
+		} else {
+			ocs_log_test(ocs, "getting profile list status 0x%x\n", result.status);
+		}
+	}
+}
+
+typedef struct ocs_mgmt_get_active_profile_result {
+	ocs_sem_t semaphore;
+	int32_t status;
+	uint32_t active_profile_id;
+} ocs_mgmt_get_active_profile_result_t;
+
+static void
+ocs_mgmt_get_active_profile_cb(int32_t status, uint32_t active_profile, void *ul_arg)
+{
+	ocs_mgmt_get_active_profile_result_t *result = ul_arg;
+
+	result->status = status;
+	result->active_profile_id = active_profile;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+#define MAX_PROFILE_LENGTH 5
+
+/**
+ * @brief  Get active profile
+ * @par Description
+ * This is a management action handler to get the currently
+ * active profile for an SLI port.  Although the spec says that
+ * all SLI platforms support this, only Skyhawk actually has a
+ * useful implementation.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
+ *
+ * @return none
+ */
+static void
+get_active_profile(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	char result_string[MAX_PROFILE_LENGTH];
+	ocs_mgmt_get_active_profile_result_t result;
+
+	ocs_sem_init(&(result.semaphore), 0, "get_active_profile");
+
+	if(ocs_hw_get_active_profile(&ocs->hw, ocs_mgmt_get_active_profile_cb, &result) == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+		}
+		if (result.status == 0) {
+			/* Success. */
+			sprintf(result_string, "0x%02x", result.active_profile_id);
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "active_profile", result_string);
+		} else {
+			ocs_log_test(ocs, "getting active profile status 0x%x\n", result.status);
+		}
+	}
+}
+
+typedef struct ocs_mgmt_set_active_profile_result {
+	ocs_sem_t semaphore;
+	int32_t status;
+} ocs_mgmt_set_active_profile_result_t;
+
+
+static void
+ocs_mgmt_set_active_profile_cb(int32_t status, void *ul_arg)
+{
+	ocs_mgmt_get_profile_list_result_t *result = ul_arg;
+
+	result->status = status;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+/**
+ * @brief  Set active profile
+ * @par Description
+ * This is a management action handler to set the currently
+ * active profile for an SLI port.  Although the spec says that
+ * all SLI platforms support this, only Skyhawk actually has a
+ * useful implementation.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param value Requested new value of the property.
+ *
+ * @return Returns 0 on success, non-zero on failure.
+ */
+static int32_t
+set_active_profile(ocs_t *ocs, char *name, char *value)
+{
+	ocs_mgmt_set_active_profile_result_t result;
+	int32_t rc = 0;
+	int32_t new_profile;
+
+	new_profile = ocs_strtoul(value, NULL, 0);
+
+	ocs_sem_init(&(result.semaphore), 0, "set_active_profile");
+
+	rc = ocs_hw_set_active_profile(&ocs->hw, ocs_mgmt_set_active_profile_cb, new_profile, &result);
+	if (rc == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			rc = -ENXIO;
+		}
+		if (result.status == 0) {
+			/* Success. */
+			rc = 0;
+		} else {
+			rc = -1;
+			ocs_log_test(ocs, "setting active profile status 0x%x\n", result.status);
+		}
+	}
+
+	return rc;
+}
+
+typedef struct ocs_mgmt_get_nvparms_result {
+	ocs_sem_t semaphore;
+	int32_t status;
+	uint8_t	wwpn[8];
+	uint8_t wwnn[8];
+	uint8_t hard_alpa;
+	uint32_t preferred_d_id;
+} ocs_mgmt_get_nvparms_result_t;
+
+static void
+ocs_mgmt_get_nvparms_cb(int32_t status, uint8_t *wwpn, uint8_t *wwnn, uint8_t hard_alpa,
+		uint32_t preferred_d_id, void *ul_arg)
+{
+	ocs_mgmt_get_nvparms_result_t *result = ul_arg;
+
+	result->status = status;
+	ocs_memcpy(result->wwpn, wwpn, sizeof(result->wwpn));
+	ocs_memcpy(result->wwnn, wwnn, sizeof(result->wwnn));
+	result->hard_alpa = hard_alpa;
+	result->preferred_d_id = preferred_d_id;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+/**
+ * @brief  Get wwpn
+ * @par Description
+ *
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
+ *
+ * @return none
+ */
+static void
+get_nv_wwpn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	char result_string[24];
+	static ocs_mgmt_get_nvparms_result_t result;
+
+	ocs_sem_init(&(result.semaphore), 0, "get_nv_wwpn");
+
+	if(ocs_hw_get_nvparms(&ocs->hw, ocs_mgmt_get_nvparms_cb, &result) == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			return;
+		}
+		if (result.status == 0) {
+			/* Success.  Copy wwpn from result struct to result string */
+			sprintf(result_string, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
+					result.wwpn[0], result.wwpn[1], result.wwpn[2],
+					result.wwpn[3], result.wwpn[4], result.wwpn[5],
+					result.wwpn[6], result.wwpn[7]);
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "nv_wwpn", result_string);
+		} else {
+			ocs_log_test(ocs, "getting wwpn status 0x%x\n", result.status);
+		}
+	}
+}
+
+/**
+ * @brief  Get wwnn
+ * @par Description
+ *
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
+ *
+ * @return none
+ */
+static void
+get_nv_wwnn(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	char result_string[24];
+	static ocs_mgmt_get_nvparms_result_t result;
+
+	ocs_sem_init(&(result.semaphore), 0, "get_nv_wwnn");
+
+	if(ocs_hw_get_nvparms(&ocs->hw, ocs_mgmt_get_nvparms_cb, &result) == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			return;
+		}
+		if (result.status == 0) {
+			/* Success. Copy wwnn from result struct to result string */
+			ocs_snprintf(result_string, sizeof(result_string), "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
+					result.wwnn[0], result.wwnn[1], result.wwnn[2],
+					result.wwnn[3], result.wwnn[4], result.wwnn[5],
+					result.wwnn[6], result.wwnn[7]);
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RW, "nv_wwnn", result_string);
+		} else {
+			ocs_log_test(ocs, "getting wwnn status 0x%x\n", result.status);
+		}
+	}
+}
+
+/**
+ * @brief Get accumulated node abort counts
+ * @par Description Get the sum of all nodes abort count.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param textbuf Pointer to an ocs_textbuf, which is used to return the results.
+ *
+ * @return None.
+ */
+static void
+get_node_abort_cnt(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf)
+{
+	uint32_t abort_counts = 0;
+	ocs_domain_t *domain;
+	ocs_sport_t *sport;
+	ocs_node_t *node;
+
+	if (ocs_device_lock_try(ocs) != TRUE) {
+		/* Didn't get the lock */
+		return;
+	}
+
+		/* Here the Device lock is held */
+		ocs_list_foreach(&ocs->domain_list, domain) {
+			if (ocs_domain_lock_try(domain) != TRUE) {
+				/* Didn't get the lock */
+				ocs_device_unlock(ocs);
+				return;
+			}
+
+				/* Here the Domain lock is held */
+				ocs_list_foreach(&domain->sport_list, sport) {
+					if (ocs_sport_lock_try(sport) != TRUE) {
+						/* Didn't get the lock */
+						ocs_domain_unlock(domain);
+						ocs_device_unlock(ocs);
+						return;
+					}
+
+						/* Here the sport lock is held */
+						ocs_list_foreach(&sport->node_list, node) {
+							abort_counts += node->abort_cnt;
+						}
+
+					ocs_sport_unlock(sport);
+				}
+
+			ocs_domain_unlock(domain);
+		}
+
+	ocs_device_unlock(ocs);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "node_abort_cnt", "%d" , abort_counts);
+}
+
+typedef struct ocs_mgmt_set_nvparms_result {
+	ocs_sem_t semaphore;
+	int32_t status;
+} ocs_mgmt_set_nvparms_result_t;
+
+
+static void
+ocs_mgmt_set_nvparms_cb(int32_t status, void *ul_arg)
+{
+	ocs_mgmt_get_profile_list_result_t *result = ul_arg;
+
+	result->status = status;
+
+	ocs_sem_v(&(result->semaphore));
+}
+
+/**
+ * @brief  Set wwn
+ * @par Description Sets the Non-volatile worldwide names,
+ * if provided.
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param name Name of the action being performed.
+ * @param wwn_p Requested new WWN values.
+ *
+ * @return Returns 0 on success, non-zero on failure.
+ */
+static int32_t
+set_nv_wwn(ocs_t *ocs, char *name, char *wwn_p)
+{
+	ocs_mgmt_get_nvparms_result_t result;
+	uint8_t new_wwpn[8];
+	uint8_t new_wwnn[8];
+	char *wwpn_p = NULL;
+	char *wwnn_p = NULL;
+	int32_t rc = -1;
+	int wwpn;
+	int wwnn;
+	int i;
+
+	/* This is a read-modify-write operation, so first we have to read
+	 * the current values
+	 */
+	ocs_sem_init(&(result.semaphore), 0, "set_nv_wwn1");
+
+	rc = ocs_hw_get_nvparms(&ocs->hw, ocs_mgmt_get_nvparms_cb, &result);
+
+	if (rc == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			return -ENXIO;
+		}
+		if (result.status != 0) {
+			ocs_log_test(ocs, "getting nvparms status 0x%x\n", result.status);
+			return -1;
+		}
+	}
+
+	/* wwn_p contains wwpn_p@wwnn_p values */
+	if (wwn_p != NULL) {
+		wwpn_p = ocs_strsep(&wwn_p, "@");
+		wwnn_p = wwn_p;
+	}
+
+	wwpn = ocs_strcmp(wwpn_p, "NA");
+	wwnn = ocs_strcmp(wwnn_p, "NA");
+
+	/* Parse the new WWPN */
+	if ((wwpn_p != NULL) && (wwpn != 0)) {
+		if (ocs_sscanf(wwpn_p, "%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx",
+				&(new_wwpn[0]), &(new_wwpn[1]), &(new_wwpn[2]),
+				&(new_wwpn[3]), &(new_wwpn[4]), &(new_wwpn[5]),
+				&(new_wwpn[6]), &(new_wwpn[7])) != 8) {
+			ocs_log_test(ocs, "can't parse WWPN %s\n", wwpn_p);
+			return -1;
+		}
+	}
+
+	/* Parse the new WWNN */
+	if ((wwnn_p != NULL) && (wwnn != 0 )) {
+		if (ocs_sscanf(wwnn_p, "%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx:%2hhx",
+				&(new_wwnn[0]), &(new_wwnn[1]), &(new_wwnn[2]),
+				&(new_wwnn[3]), &(new_wwnn[4]), &(new_wwnn[5]),
+				&(new_wwnn[6]), &(new_wwnn[7])) != 8) {
+			ocs_log_test(ocs, "can't parse WWNN %s\n", wwnn_p);
+			return -1;
+		}
+	}
+
+	for (i = 0; i < 8; i++) {
+		/* Use active wwpn, if new one is not provided */
+		if (wwpn == 0) {
+			new_wwpn[i] = result.wwpn[i];
+		}
+
+		/* Use active wwnn, if new one is not provided */
+		if (wwnn == 0) {
+			new_wwnn[i] = result.wwnn[i];
+		}
+	}
+
+	/* Modify the nv_wwnn and nv_wwpn, then write it back */
+	ocs_sem_init(&(result.semaphore), 0, "set_nv_wwn2");
+
+	rc = ocs_hw_set_nvparms(&ocs->hw, ocs_mgmt_set_nvparms_cb, new_wwpn,
+				 new_wwnn, result.hard_alpa, result.preferred_d_id,
+				 &result);
+	if (rc == OCS_HW_RTN_SUCCESS) {
+		if (ocs_sem_p(&(result.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_err(ocs, "ocs_sem_p failed\n");
+			return -ENXIO;
+		}
+		if (result.status != 0) {
+			ocs_log_test(ocs, "setting wwn status 0x%x\n", result.status);
+			return -1;
+		}
+	}
+
+	return rc;
+}
+
+static int
+set_tgt_rscn_delay(ocs_t *ocs, char *name, char *value)
+{
+	ocs->tgt_rscn_delay_msec = ocs_strtoul(value, NULL, 0) * 1000;
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+static int
+set_tgt_rscn_period(ocs_t *ocs, char *name, char *value)
+{
+	ocs->tgt_rscn_period_msec = ocs_strtoul(value, NULL, 0) * 1000;
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+static int
+set_inject_drop_cmd(ocs_t *ocs, char *name, char *value)
+{
+	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_DROP_CMD);
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+static int
+set_inject_free_drop_cmd(ocs_t *ocs, char *name, char *value)
+{
+	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_FREE_DROPPED);
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+static int
+set_inject_drop_data(ocs_t *ocs, char *name, char *value)
+{
+	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_DROP_DATA);
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+static int
+set_inject_drop_resp(ocs_t *ocs, char *name, char *value)
+{
+	ocs->err_injection = (ocs_strtoul(value, NULL, 0) == 0 ? NO_ERR_INJECT : INJECT_DROP_RESP);
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+static int
+set_cmd_err_inject(ocs_t *ocs, char *name, char *value)
+{
+	ocs->cmd_err_inject = ocs_strtoul(value, NULL, 0);
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+static int
+set_cmd_delay_value(ocs_t *ocs, char *name, char *value)
+{
+	ocs->delay_value_msec = ocs_strtoul(value, NULL, 0);
+	ocs->err_injection = (ocs->delay_value_msec == 0 ? NO_ERR_INJECT : INJECT_DELAY_CMD);
+	ocs_log_debug(ocs, "mgmt set: %s %s\n", name, value);
+	return 0;
+}
+
+/**
+ * @brief parse a WWN from a string into a 64-bit value
+ *
+ * Given a pointer to a string, parse the string into a 64-bit
+ * WWN value.  The format of the string must be xx:xx:xx:xx:xx:xx:xx:xx
+ *
+ * @param wwn_in pointer to the string to be parsed
+ * @param wwn_out pointer to uint64_t in which to put the parsed result
+ *
+ * @return 0 if successful, non-zero if the WWN is malformed and couldn't be parsed
+ */
+int
+parse_wwn(char *wwn_in, uint64_t *wwn_out)
+{
+	uint8_t byte0;
+	uint8_t byte1;
+	uint8_t byte2;
+	uint8_t byte3;
+	uint8_t byte4;
+	uint8_t byte5;
+	uint8_t byte6;
+	uint8_t byte7;
+	int rc;
+
+	rc = ocs_sscanf(wwn_in, "0x%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx%2hhx",
+				&byte0, &byte1, &byte2, &byte3,
+				&byte4, &byte5, &byte6, &byte7);
+
+	if (rc == 8) {
+		*wwn_out = ((uint64_t)byte0 << 56) |
+				((uint64_t)byte1 << 48) |
+				((uint64_t)byte2 << 40) |
+				((uint64_t)byte3 << 32) |
+				((uint64_t)byte4 << 24) |
+				((uint64_t)byte5 << 16) |
+				((uint64_t)byte6 <<  8) |
+				((uint64_t)byte7);
+		return 0;
+
+	} else {
+		return 1;
+	}
+}
+
+
+
+static char *mode_string(int mode);
+
+
+/**
+ * @ingroup mgmt
+ * @brief Generate the beginning of a numbered section in a management XML document.
+ *
+ * @par Description
+ * This function begins a section. The XML information is appended to
+ * the textbuf. This form of the function is used for sections that might have
+ * multiple instances, such as a node or a SLI Port (sport). The index number
+ * is appended to the name.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param name Name of the section.
+ * @param index Index number of this instance of the section.
+ *
+ * @return None.
+ */
+
+extern void ocs_mgmt_start_section(ocs_textbuf_t *textbuf, const char *name, int index)
+{
+	ocs_textbuf_printf(textbuf, "<%s instance=\"%d\">\n", name, index);
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Generate the beginning of an unnumbered section in a management XML document.
+ *
+ * @par Description
+ * This function begins a section. The XML information is appended to
+ * the textbuf. This form of the function is used for sections that have
+ * a single instance only. Therefore, no index number is needed.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param name Name of the section.
+ *
+ * @return None.
+ */
+
+extern void ocs_mgmt_start_unnumbered_section(ocs_textbuf_t *textbuf, const char *name)
+{
+	ocs_textbuf_printf(textbuf, "<%s>\n", name);
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Generate the end of a section in a management XML document.
+ *
+ * @par Description
+ * This function ends a section. The XML information is appended to
+ * the textbuf.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param name Name of the section.
+ *
+ * @return None.
+ */
+
+void ocs_mgmt_end_unnumbered_section(ocs_textbuf_t *textbuf, const char *name)
+{
+	ocs_textbuf_printf(textbuf, "</%s>\n", name);
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Generate the indexed end of a section in a management XML document.
+ *
+ * @par Description
+ * This function ends a section. The XML information is appended to
+ * the textbuf.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param name Name of the section.
+ * @param index Index number of this instance of the section.
+ *
+ * @return None.
+ */
+
+void ocs_mgmt_end_section(ocs_textbuf_t *textbuf, const char *name, int index)
+{
+
+	ocs_textbuf_printf(textbuf, "</%s>\n", name);
+
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Generate a property, with no value, in a management XML document.
+ *
+ * @par Description
+ * This function generates a property name. The XML information is appended to
+ * the textbuf. This form of the function is used by the list functions
+ * when the property name only (and not the current value) is given.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param mode Defines whether the property is read(r)/write(w)/executable(x).
+ * @param name Name of the property.
+ *
+ * @return None.
+ */
+
+void ocs_mgmt_emit_property_name(ocs_textbuf_t *textbuf, int mode, const char *name)
+{
+	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\"/>\n", name, mode_string(mode));
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Generate a property with a string value in a management XML document.
+ *
+ * @par Description
+ * This function generates a property name and a string value.
+ * The XML information is appended to the textbuf.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param mode Defines whether the property is read(r)/write(w)/executable(x).
+ * @param name Name of the property.
+ * @param value Value of the property.
+ *
+ * @return None.
+ */
+
+void ocs_mgmt_emit_string(ocs_textbuf_t *textbuf, int mode, const char *name, const char *value)
+{
+	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\">%s</%s>\n", name, mode_string(mode), value, name);
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Generate a property with an integer value in a management XML document.
+ *
+ * @par Description
+ * This function generates a property name and an integer value.
+ * The XML information is appended to the textbuf.
+ *
+ * @param textbuf Pointer to driver dump text buffer.
+ * @param mode Defines whether the property is read(r)/write(w)/executable(x).
+ * @param name Name of the property.
+ * @param fmt A printf format for formatting the integer value.
+ *
+ * @return none
+ */
+
+void ocs_mgmt_emit_int(ocs_textbuf_t *textbuf, int mode, const char *name, const char *fmt, ...)
+{
+	va_list ap;
+	char valuebuf[64];
+
+	va_start(ap, fmt);
+	ocs_vsnprintf(valuebuf, sizeof(valuebuf), fmt, ap);
+	va_end(ap);
+
+	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\">%s</%s>\n", name, mode_string(mode), valuebuf, name);
+}
+
+/**
+ * @ingroup mgmt
+ * @brief Generate a property with a boolean value in a management XML document.
+ *
+ * @par Description
+ * This function generates a property name and a boolean value.
+ * The XML information is appended to the textbuf.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param mode Defines whether the property is read(r)/write(w)/executable(x).
+ * @param name Name of the property.
+ * @param value Boolean value to be added to the textbuf.
+ *
+ * @return None.
+ */
+
+void ocs_mgmt_emit_boolean(ocs_textbuf_t *textbuf, int mode, const char *name, int value)
+{
+	char *valuebuf = value ? "true" : "false";
+
+	ocs_textbuf_printf(textbuf, "<%s mode=\"%s\">%s</%s>\n", name, mode_string(mode), valuebuf, name);
+}
+
+static char *mode_string(int mode)
+{
+	static char mode_str[4];
+
+	mode_str[0] = '\0';
+	if (mode & MGMT_MODE_RD) {
+		strcat(mode_str, "r");
+	}
+	if (mode & MGMT_MODE_WR) {
+		strcat(mode_str, "w");
+	}
+	if (mode & MGMT_MODE_EX) {
+		strcat(mode_str, "x");
+	}
+
+	return mode_str;
+
+}
diff --git a/sys/dev/ocs_fc/ocs_mgmt.h b/sys/dev/ocs_fc/ocs_mgmt.h
new file mode 100644
index 000000000000..a9717674cefa
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_mgmt.h
@@ -0,0 +1,121 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Declarations for the common functions used by ocs_mgmt.
+ */
+
+
+#if !defined(__OCS_MGMT_H__)
+#define __OCS_MGMT_H__
+
+#include "ocs_utils.h"
+
+#define OCS_MGMT_MAX_NAME 128
+#define OCS_MGMT_MAX_VALUE 128
+
+#define MGMT_MODE_RD	4
+#define MGMT_MODE_WR	2
+#define MGMT_MODE_EX	1
+#define MGMT_MODE_RW	(MGMT_MODE_RD | MGMT_MODE_WR)
+
+#define FW_WRITE_BUFSIZE 64*1024
+
+typedef struct ocs_mgmt_fw_write_result {
+	ocs_sem_t semaphore;
+	int32_t status;
+	uint32_t actual_xfer;
+	uint32_t change_status;
+} ocs_mgmt_fw_write_result_t;
+
+
+/*
+ * This structure is used in constructing a table of internal handler functions.
+ */
+typedef void (*ocs_mgmt_get_func)(ocs_t *, char *, ocs_textbuf_t*);
+typedef int (*ocs_mgmt_set_func)(ocs_t *, char *, char *);
+typedef int (*ocs_mgmt_action_func)(ocs_t *, char *, void *, uint32_t, void *, uint32_t);
+typedef struct ocs_mgmt_table_entry_s {
+	char *name;
+	ocs_mgmt_get_func get_handler;
+	ocs_mgmt_set_func set_handler;
+	ocs_mgmt_action_func action_handler;
+} ocs_mgmt_table_entry_t;
+
+/*
+ * This structure is used when defining the top level management handlers for
+ * different types of objects (sport, node, domain, etc)
+ */
+typedef void (*ocs_mgmt_get_list_handler)(ocs_textbuf_t *textbuf, void* object);
+typedef void (*ocs_mgmt_get_all_handler)(ocs_textbuf_t *textbuf, void* object);
+typedef int (*ocs_mgmt_get_handler)(ocs_textbuf_t *, char *parent, char *name, void *object);
+typedef int (*ocs_mgmt_set_handler)(char *parent, char *name, char *value, void *object);
+typedef int (*ocs_mgmt_exec_handler)(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
+				      void *arg_out, uint32_t arg_out_length, void *object);
+
+typedef struct ocs_mgmt_functions_s {
+	ocs_mgmt_get_list_handler	get_list_handler;
+	ocs_mgmt_get_handler		get_handler;
+	ocs_mgmt_get_all_handler	get_all_handler;
+	ocs_mgmt_set_handler		set_handler;
+	ocs_mgmt_exec_handler		exec_handler;
+} ocs_mgmt_functions_t;
+
+
+/* Helper functions */
+extern void ocs_mgmt_start_section(ocs_textbuf_t *textbuf, const char *name, int index);
+extern void ocs_mgmt_start_unnumbered_section(ocs_textbuf_t *textbuf, const char *name);
+extern void ocs_mgmt_end_section(ocs_textbuf_t *textbuf, const char *name, int index);
+extern void ocs_mgmt_end_unnumbered_section(ocs_textbuf_t *textbuf, const char *name);
+extern void ocs_mgmt_emit_property_name(ocs_textbuf_t *textbuf, int access, const char *name);
+extern void ocs_mgmt_emit_string(ocs_textbuf_t *textbuf, int access, const char *name, const char *value);
+__attribute__((format(printf,4,5)))
+extern void ocs_mgmt_emit_int(ocs_textbuf_t *textbuf, int access, const char *name, const char *fmt, ...);
+extern void ocs_mgmt_emit_boolean(ocs_textbuf_t *textbuf, int access, const char *name, const int value);
+extern int parse_wwn(char *wwn_in, uint64_t *wwn_out);
+
+/* Top level management functions - called by the ioctl */
+extern void ocs_mgmt_get_list(ocs_t *ocs, ocs_textbuf_t *textbuf);
+extern void ocs_mgmt_get_all(ocs_t *ocs, ocs_textbuf_t *textbuf);
+extern int ocs_mgmt_get(ocs_t *ocs, char *name, ocs_textbuf_t *textbuf);
+extern int ocs_mgmt_set(ocs_t *ocs, char *name, char *value);
+extern int ocs_mgmt_exec(ocs_t *ocs, char *action, void *arg_in, uint32_t arg_in_length,
+		void *arg_out, uint32_t arg_out_length);
+
+extern int set_req_wwnn(ocs_t*, char*, char*);
+extern int set_req_wwpn(ocs_t*, char*, char*);
+extern int set_configured_speed(ocs_t*, char*, char*);
+extern int set_configured_topology(ocs_t*, char*, char*);
+
+#endif
diff --git a/sys/dev/ocs_fc/ocs_node.c b/sys/dev/ocs_fc/ocs_node.c
new file mode 100644
index 000000000000..0e4b08369562
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_node.c
@@ -0,0 +1,2376 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS driver remote node handler.  This file contains code that is shared
+ * between fabric (ocs_fabric.c) and device (ocs_device.c) nodes.
+ */
+
+/*!
+ * @defgroup node_common Node common support
+ * @defgroup node_alloc Node allocation
+ */
+
+#include "ocs.h"
+#include "ocs_els.h"
+#include "ocs_device.h"
+
+#define SCSI_IOFMT "[%04x][i:%0*x t:%0*x h:%04x]"
+#define SCSI_ITT_SIZE(ocs)	((ocs->ocs_xport == OCS_XPORT_FC) ? 4 : 8)
+
+#define SCSI_IOFMT_ARGS(io) io->instance_index, SCSI_ITT_SIZE(io->ocs), io->init_task_tag, SCSI_ITT_SIZE(io->ocs), io->tgt_task_tag, io->hw_tag
+
+#define scsi_io_printf(io, fmt, ...) ocs_log_debug(io->ocs, "[%s]" SCSI_IOFMT fmt, \
+	io->node->display_name, SCSI_IOFMT_ARGS(io), ##__VA_ARGS__)
+
+void ocs_mgmt_node_list(ocs_textbuf_t *textbuf, void *node);
+void ocs_mgmt_node_get_all(ocs_textbuf_t *textbuf, void *node);
+int ocs_mgmt_node_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *node);
+int ocs_mgmt_node_set(char *parent, char *name, char *value, void *node);
+int ocs_mgmt_node_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
+		void *arg_out, uint32_t arg_out_length, void *node);
+static ocs_mgmt_functions_t node_mgmt_functions = {
+	.get_list_handler	=	ocs_mgmt_node_list,
+	.get_handler		=	ocs_mgmt_node_get,
+	.get_all_handler	=	ocs_mgmt_node_get_all,
+	.set_handler		=	ocs_mgmt_node_set,
+	.exec_handler		=	ocs_mgmt_node_exec,
+};
+
+
+/**
+ * @ingroup node_common
+ * @brief Device node state machine wait for all ELS's to
+ *        complete
+ *
+ * Abort all ELS's for given node.
+ *
+ * @param node node for which ELS's will be aborted
+ */
+
+void
+ocs_node_abort_all_els(ocs_node_t *node)
+{
+	ocs_io_t *els;
+	ocs_io_t *els_next;
+	ocs_node_cb_t cbdata = {0};
+
+	ocs_node_hold_frames(node);
+	ocs_lock(&node->active_ios_lock);
+		ocs_list_foreach_safe(&node->els_io_active_list, els, els_next) {
+			ocs_log_debug(node->ocs, "[%s] initiate ELS abort %s\n", node->display_name, els->display_name);
+			ocs_unlock(&node->active_ios_lock);
+			cbdata.els = els;
+			ocs_els_post_event(els, OCS_EVT_ABORT_ELS, &cbdata);
+			ocs_lock(&node->active_ios_lock);
+		}
+	ocs_unlock(&node->active_ios_lock);
+}
+
+/**
+ * @ingroup node_common
+ * @brief Handle remote node events from HW
+ *
+ * Handle remote node events from HW.   Essentially the HW event is translated into
+ * a node state machine event that is posted to the affected node.
+ *
+ * @param arg pointer to ocs
+ * @param event HW event to proceoss
+ * @param data application specific data (pointer to the affected node)
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_remote_node_cb(void *arg, ocs_hw_remote_node_event_e event, void *data)
+{
+	ocs_t *ocs = arg;
+	ocs_sm_event_t	sm_event = OCS_EVT_LAST;
+	ocs_remote_node_t *rnode = data;
+	ocs_node_t *node = rnode->node;
+
+	switch (event) {
+	case OCS_HW_NODE_ATTACH_OK:
+		sm_event = OCS_EVT_NODE_ATTACH_OK;
+		break;
+
+	case OCS_HW_NODE_ATTACH_FAIL:
+		sm_event = OCS_EVT_NODE_ATTACH_FAIL;
+		break;
+
+	case OCS_HW_NODE_FREE_OK:
+		sm_event = OCS_EVT_NODE_FREE_OK;
+		break;
+
+	case OCS_HW_NODE_FREE_FAIL:
+		sm_event = OCS_EVT_NODE_FREE_FAIL;
+		break;
+
+	default:
+		ocs_log_test(ocs, "unhandled event %#x\n", event);
+		return -1;
+	}
+
+	/* If we're using HLM, forward the NODE_ATTACH_OK/FAIL event to all nodes in the node group */
+	if ((node->node_group != NULL) &&
+			((sm_event == OCS_EVT_NODE_ATTACH_OK) || (sm_event == OCS_EVT_NODE_ATTACH_FAIL))) {
+		ocs_node_t *n = NULL;
+		uint8_t		attach_ok = sm_event == OCS_EVT_NODE_ATTACH_OK;
+
+		ocs_sport_lock(node->sport);
+		{
+			ocs_list_foreach(&node->sport->node_list, n) {
+				if (node == n) {
+					continue;
+				}
+				ocs_node_lock(n);
+					if ((!n->rnode.attached) && (node->node_group == n->node_group)) {
+						n->rnode.attached = attach_ok;
+						node_printf(n, "rpi[%d] deferred HLM node attach %s posted\n",
+								n->rnode.index, attach_ok ? "ok" : "fail");
+						ocs_node_post_event(n, sm_event, NULL);
+					}
+				ocs_node_unlock(n);
+			}
+		}
+
+		ocs_sport_unlock(node->sport);
+	}
+
+	ocs_node_post_event(node, sm_event, NULL);
+
+	return 0;
+}
+
+/**
+ * @ingroup node_alloc
+ * @brief Find an FC node structure given the FC port ID
+ *
+ * @param sport the SPORT to search
+ * @param port_id FC port ID
+ *
+ * @return pointer to the object or NULL if not found
+ */
+ocs_node_t *
+ocs_node_find(ocs_sport_t *sport, uint32_t port_id)
+{
+	ocs_node_t *node;
+
+	ocs_assert(sport->lookup, NULL);
+	ocs_sport_lock(sport);
+		node = spv_get(sport->lookup, port_id);
+	ocs_sport_unlock(sport);
+	return node;
+}
+
+/**
+ * @ingroup node_alloc
+ * @brief Find an FC node structure given the WWPN
+ *
+ * @param sport the SPORT to search
+ * @param wwpn the WWPN to search for (host endian)
+ *
+ * @return pointer to the object or NULL if not found
+ */
+ocs_node_t *
+ocs_node_find_wwpn(ocs_sport_t *sport, uint64_t wwpn)
+{
+	ocs_node_t *node = NULL;;
+
+	ocs_assert(sport, NULL);
+
+	ocs_sport_lock(sport);
+		ocs_list_foreach(&sport->node_list, node) {
+			if (ocs_node_get_wwpn(node) == wwpn) {
+				ocs_sport_unlock(sport);
+				return node;
+			}
+		}
+	ocs_sport_unlock(sport);
+	return NULL;
+}
+
+/**
+ * @ingroup node_alloc
+ * @brief allocate node object pool
+ *
+ * A pool of ocs_node_t objects is allocated.
+ *
+ * @param ocs pointer to driver instance context
+ * @param node_count count of nodes to allocate
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_node_create_pool(ocs_t *ocs, uint32_t node_count)
+{
+	ocs_xport_t *xport = ocs->xport;
+	uint32_t i;
+	ocs_node_t *node;
+	uint32_t max_sge;
+	uint32_t num_sgl;
+	uint64_t max_xfer_size;
+	int32_t rc;
+
+	xport->nodes_count = node_count;
+
+	xport->nodes = ocs_malloc(ocs, node_count * sizeof(ocs_node_t *), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (xport->nodes == NULL) {
+		ocs_log_err(ocs, "node ptrs allocation failed");
+		return -1;	
+	}
+
+	if (0 == ocs_hw_get(&ocs->hw, OCS_HW_MAX_SGE, &max_sge) &&
+	    0 == ocs_hw_get(&ocs->hw, OCS_HW_N_SGL, &num_sgl)) {
+		max_xfer_size = max_sge * num_sgl;
+	} else {
+		max_xfer_size = 65536;
+	}
+
+	if (max_xfer_size > 65536)
+		max_xfer_size = 65536;
+
+	ocs_list_init(&xport->nodes_free_list, ocs_node_t, link);
+
+
+	for (i = 0; i < node_count; i ++) {
+		node = ocs_malloc(ocs, sizeof(ocs_node_t), OCS_M_ZERO | OCS_M_NOWAIT);
+		if (node == NULL) {
+			ocs_log_err(ocs, "node allocation failed");
+			goto error;
+		}
+
+		/* Assign any persistent field values */
+		node->instance_index = i;
+		node->max_wr_xfer_size = max_xfer_size;
+		node->rnode.indicator = UINT32_MAX;
+
+		rc = ocs_dma_alloc(ocs, &node->sparm_dma_buf, 256, 16);
+		if (rc) {
+			ocs_free(ocs, node, sizeof(ocs_node_t));		
+			ocs_log_err(ocs, "ocs_dma_alloc failed: %d\n", rc);
+			goto error;
+		}
+
+		xport->nodes[i] = node;
+		ocs_list_add_tail(&xport->nodes_free_list, node);
+	}
+	return 0;
+
+error:
+	ocs_node_free_pool(ocs);
+	return -1;	
+}
+
+/**
+ * @ingroup node_alloc
+ * @brief free node object pool
+ *
+ * The pool of previously allocated node objects is freed
+ *
+ * @param ocs pointer to driver instance context
+ *
+ * @return none
+ */
+
+void
+ocs_node_free_pool(ocs_t *ocs)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_node_t *node;
+	uint32_t i;
+
+	if (!xport->nodes)
+		return;
+
+	ocs_device_lock(ocs);
+
+	for (i = 0; i < xport->nodes_count; i ++) {
+		node = xport->nodes[i];
+		if (node) {
+			/* free sparam_dma_buf */
+			ocs_dma_free(ocs, &node->sparm_dma_buf);
+			ocs_free(ocs, node, sizeof(ocs_node_t));
+		}
+		xport->nodes[i] = NULL;
+	}
+
+	ocs_free(ocs, xport->nodes, (xport->nodes_count * sizeof(ocs_node_t *)));
+
+	ocs_device_unlock(ocs);
+}
+
+/**
+ * @ingroup node_alloc
+ * @brief return pointer to node object given instance index
+ *
+ * A pointer to the node object given by an instance index is returned.
+ *
+ * @param ocs pointer to driver instance context
+ * @param index instance index
+ *
+ * @return returns pointer to node object, or NULL
+ */
+
+ocs_node_t *
+ocs_node_get_instance(ocs_t *ocs, uint32_t index)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_node_t *node = NULL;
+
+	if (index >= (xport->nodes_count)) {
+		ocs_log_test(ocs, "invalid index: %d\n", index);
+		return NULL;
+	}
+	node = xport->nodes[index];
+	return node->attached ? node : NULL;
+}
+
+/**
+ * @ingroup node_alloc
+ * @brief Allocate an fc node structure and add to node list
+ *
+ * @param sport pointer to the SPORT from which this node is allocated
+ * @param port_id FC port ID of new node
+ * @param init Port is an inititiator (sent a plogi)
+ * @param targ Port is potentially a target
+ *
+ * @return pointer to the object or NULL if none available
+ */
+
+ocs_node_t *
+ocs_node_alloc(ocs_sport_t *sport, uint32_t port_id, uint8_t init, uint8_t targ)
+{
+	int32_t rc;
+	ocs_node_t *node = NULL;
+	uint32_t instance_index;
+	uint32_t max_wr_xfer_size;
+	ocs_t *ocs = sport->ocs;
+	ocs_xport_t *xport = ocs->xport;
+	ocs_dma_t sparm_dma_buf;
+
+	ocs_assert(sport, NULL);
+
+	if (sport->shutting_down) {
+		ocs_log_debug(ocs, "node allocation when shutting down %06x", port_id);
+		return NULL;
+	}
+
+	ocs_device_lock(ocs);
+		node = ocs_list_remove_head(&xport->nodes_free_list);
+	ocs_device_unlock(ocs);
+	if (node == NULL) {
+		ocs_log_err(ocs, "node allocation failed %06x", port_id);
+		return NULL;
+	}
+
+	/* Save persistent values across memset zero */
+	instance_index = node->instance_index;
+	max_wr_xfer_size = node->max_wr_xfer_size;
+	sparm_dma_buf = node->sparm_dma_buf;
+
+	ocs_memset(node, 0, sizeof(*node));
+	node->instance_index = instance_index;
+	node->max_wr_xfer_size = max_wr_xfer_size;
+	node->sparm_dma_buf = sparm_dma_buf;
+	node->rnode.indicator = UINT32_MAX;
+
+	node->sport = sport;
+	ocs_sport_lock(sport);
+
+		node->ocs = ocs;
+		node->init = init;
+		node->targ = targ;
+
+		rc = ocs_hw_node_alloc(&ocs->hw, &node->rnode, port_id, sport);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_hw_node_alloc failed: %d\n", rc);
+			ocs_sport_unlock(sport);
+
+			/* Return back to pool. */
+			ocs_device_lock(ocs);
+			ocs_list_add_tail(&xport->nodes_free_list, node);
+			ocs_device_unlock(ocs);
+
+			return NULL;
+		}
+		ocs_list_add_tail(&sport->node_list, node);
+
+		ocs_node_lock_init(node);
+		ocs_lock_init(ocs, &node->pend_frames_lock, "pend_frames_lock[%d]", node->instance_index);
+		ocs_list_init(&node->pend_frames, ocs_hw_sequence_t, link);
+		ocs_lock_init(ocs, &node->active_ios_lock, "active_ios[%d]", node->instance_index);
+		ocs_list_init(&node->active_ios, ocs_io_t, link);
+		ocs_list_init(&node->els_io_pend_list, ocs_io_t, link);
+		ocs_list_init(&node->els_io_active_list, ocs_io_t, link);
+		ocs_scsi_io_alloc_enable(node);
+
+		/* zero the service parameters */
+		ocs_memset(node->sparm_dma_buf.virt, 0, node->sparm_dma_buf.size);
+
+		node->rnode.node = node;
+		node->sm.app = node;
+		node->evtdepth = 0;
+
+		ocs_node_update_display_name(node);
+
+		spv_set(sport->lookup, port_id, node);
+	ocs_sport_unlock(sport);
+	node->mgmt_functions = &node_mgmt_functions;
+
+	return node;
+}
+
+/**
+ * @ingroup node_alloc
+ * @brief free a node structure
+ *
+ * The node structure given by 'node' is free'd
+ *
+ * @param node the node to free
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_node_free(ocs_node_t *node)
+{
+	ocs_sport_t *sport;
+	ocs_t *ocs;
+	ocs_xport_t *xport;
+	ocs_hw_rtn_e rc = 0;
+	ocs_node_t *ns = NULL;
+	int post_all_free = FALSE;
+
+	ocs_assert(node, -1);
+	ocs_assert(node->sport, -1);
+	ocs_assert(node->ocs, -1);
+	sport = node->sport;
+	ocs_assert(sport, -1);
+	ocs = node->ocs;
+	ocs_assert(ocs->xport, -1);
+	xport = ocs->xport;
+
+	node_printf(node, "Free'd\n");
+
+	if(node->refound) {
+		/*
+		 * Save the name server node. We will send fake RSCN event at
+		 * the end to handle ignored RSCN event during node deletion
+		 */
+		ns = ocs_node_find(node->sport, FC_ADDR_NAMESERVER);
+	}
+
+	/* Remove from node list */
+	ocs_sport_lock(sport);
+		ocs_list_remove(&sport->node_list, node);
+
+		/* Free HW resources */
+		if (OCS_HW_RTN_IS_ERROR((rc = ocs_hw_node_free_resources(&ocs->hw, &node->rnode)))) {
+			ocs_log_test(ocs, "ocs_hw_node_free failed: %d\n", rc);
+			rc = -1;
+		}
+
+		/* if the gidpt_delay_timer is still running, then delete it */
+		if (ocs_timer_pending(&node->gidpt_delay_timer)) {
+			ocs_del_timer(&node->gidpt_delay_timer);
+		}
+
+		if (node->fcp2device) {
+			ocs_del_crn(node);
+		}
+
+		/* remove entry from sparse vector list */
+		if (sport->lookup == NULL) {
+			ocs_log_test(node->ocs, "assertion failed: sport lookup is NULL\n");
+			ocs_sport_unlock(sport);
+			return -1;
+		}
+
+		spv_set(sport->lookup, node->rnode.fc_id, NULL);
+
+		/*
+		 * If the node_list is empty, then post a ALL_CHILD_NODES_FREE event to the sport,
+		 * after the lock is released.  The sport may be free'd as a result of the event.
+		 */
+		if (ocs_list_empty(&sport->node_list)) {
+			post_all_free = TRUE;
+		}
+
+	ocs_sport_unlock(sport);
+
+	if (post_all_free) {
+		ocs_sm_post_event(&sport->sm, OCS_EVT_ALL_CHILD_NODES_FREE, NULL);
+	}
+
+	node->sport = NULL;
+	node->sm.current_state = NULL;
+
+	ocs_node_lock_free(node);
+	ocs_lock_free(&node->pend_frames_lock);
+	ocs_lock_free(&node->active_ios_lock);
+
+	/* return to free list */
+	ocs_device_lock(ocs);
+		ocs_list_add_tail(&xport->nodes_free_list, node);
+	ocs_device_unlock(ocs);
+
+	if(ns != NULL) {
+		/* sending fake RSCN event to name server node */
+		ocs_node_post_event(ns, OCS_EVT_RSCN_RCVD, NULL);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief free memory resources of a node object
+ *
+ * The node object's child objects are freed after which the
+ * node object is freed.
+ *
+ * @param node pointer to a node object
+ *
+ * @return none
+ */
+
+void
+ocs_node_force_free(ocs_node_t *node)
+{
+	ocs_io_t *io;
+	ocs_io_t *next;
+	ocs_io_t *els;
+	ocs_io_t *els_next;
+
+	/* shutdown sm processing */
+	ocs_sm_disable(&node->sm);
+	ocs_strncpy(node->prev_state_name, node->current_state_name, sizeof(node->prev_state_name));
+	ocs_strncpy(node->current_state_name, "disabled", sizeof(node->current_state_name));
+
+	/* Let the backend cleanup if needed */
+	ocs_scsi_notify_node_force_free(node);
+
+	ocs_lock(&node->active_ios_lock);
+		ocs_list_foreach_safe(&node->active_ios, io, next) {
+			ocs_list_remove(&io->node->active_ios, io);
+			ocs_io_free(node->ocs, io);
+		}
+	ocs_unlock(&node->active_ios_lock);
+
+	/* free all pending ELS IOs */
+	ocs_lock(&node->active_ios_lock);
+		ocs_list_foreach_safe(&node->els_io_pend_list, els, els_next) {
+			/* can't call ocs_els_io_free() because lock is held; cleanup manually */
+			ocs_list_remove(&node->els_io_pend_list, els);
+
+			ocs_io_free(node->ocs, els);
+		}
+	ocs_unlock(&node->active_ios_lock);
+
+	/* free all active ELS IOs */
+	ocs_lock(&node->active_ios_lock);
+		ocs_list_foreach_safe(&node->els_io_active_list, els, els_next) {
+			/* can't call ocs_els_io_free() because lock is held; cleanup manually */
+			ocs_list_remove(&node->els_io_active_list, els);
+
+			ocs_io_free(node->ocs, els);
+		}
+	ocs_unlock(&node->active_ios_lock);
+
+	/* manually purge pending frames (if any) */
+	ocs_node_purge_pending(node);
+
+	ocs_node_free(node);
+}
+
+/**
+ * @ingroup node_common
+ * @brief Perform HW call to attach a remote node
+ *
+ * @param node pointer to node object
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+int32_t
+ocs_node_attach(ocs_node_t *node)
+{
+	int32_t rc = 0;
+	ocs_sport_t *sport = node->sport;
+	ocs_domain_t *domain = sport->domain;
+	ocs_t *ocs = node->ocs;
+
+	if (!domain->attached) {
+		ocs_log_test(ocs, "Warning: ocs_node_attach with unattached domain\n");
+		return -1;
+	}
+	/* Update node->wwpn/wwnn */
+
+	ocs_node_build_eui_name(node->wwpn, sizeof(node->wwpn), ocs_node_get_wwpn(node));
+	ocs_node_build_eui_name(node->wwnn, sizeof(node->wwnn), ocs_node_get_wwnn(node));
+
+	if (ocs->enable_hlm) {
+		ocs_node_group_init(node);
+	}
+
+	ocs_dma_copy_in(&node->sparm_dma_buf, node->service_params+4, sizeof(node->service_params)-4);
+
+	/* take lock to protect node->rnode.attached */
+	ocs_node_lock(node);
+		rc = ocs_hw_node_attach(&ocs->hw, &node->rnode, &node->sparm_dma_buf);
+		if (OCS_HW_RTN_IS_ERROR(rc)) {
+			ocs_log_test(ocs, "ocs_hw_node_attach failed: %d\n", rc);
+		}
+	ocs_node_unlock(node);
+
+	return rc;
+}
+
+/**
+ * @ingroup node_common
+ * @brief Generate text for a node's fc_id
+ *
+ * The text for a nodes fc_id is generated, either as a well known name, or a 6 digit
+ * hex value.
+ *
+ * @param fc_id fc_id
+ * @param buffer text buffer
+ * @param buffer_length text buffer length in bytes
+ *
+ * @return none
+ */
+
+void
+ocs_node_fcid_display(uint32_t fc_id, char *buffer, uint32_t buffer_length)
+{
+	switch (fc_id) {
+	case FC_ADDR_FABRIC:
+		ocs_snprintf(buffer, buffer_length, "fabric");
+		break;
+	case FC_ADDR_CONTROLLER:
+		ocs_snprintf(buffer, buffer_length, "fabctl");
+		break;
+	case FC_ADDR_NAMESERVER:
+		ocs_snprintf(buffer, buffer_length, "nserve");
+		break;
+	default:
+		if (FC_ADDR_IS_DOMAIN_CTRL(fc_id)) {
+			ocs_snprintf(buffer, buffer_length, "dctl%02x",
+				FC_ADDR_GET_DOMAIN_CTRL(fc_id));
+		} else {
+			ocs_snprintf(buffer, buffer_length, "%06x", fc_id);
+		}
+		break;
+	}
+
+}
+
+/**
+ * @brief update the node's display name
+ *
+ * The node's display name is updated, sometimes needed because the sport part
+ * is updated after the node is allocated.
+ *
+ * @param node pointer to the node object
+ *
+ * @return none
+ */
+
+void
+ocs_node_update_display_name(ocs_node_t *node)
+{
+	uint32_t port_id = node->rnode.fc_id;
+	ocs_sport_t *sport = node->sport;
+	char portid_display[16];
+
+	ocs_assert(sport);
+
+	ocs_node_fcid_display(port_id, portid_display, sizeof(portid_display));
+
+	ocs_snprintf(node->display_name, sizeof(node->display_name), "%s.%s", sport->display_name, portid_display);
+}
+
+/**
+ * @brief cleans up an XRI for the pending link services accept by aborting the
+ *         XRI if required.
+ *
+ * <h3 class="desc">Description</h3>
+ * This function is called when the LS accept is not sent.
+ *
+ * @param node Node for which should be cleaned up
+ */
+
+void
+ocs_node_send_ls_io_cleanup(ocs_node_t *node)
+{
+	ocs_t *ocs = node->ocs;
+
+	if (node->send_ls_acc != OCS_NODE_SEND_LS_ACC_NONE) {
+		ocs_assert(node->ls_acc_io);
+		ocs_log_debug(ocs, "[%s] cleaning up LS_ACC oxid=0x%x\n",
+			node->display_name, node->ls_acc_oxid);
+
+		node->ls_acc_io->hio = NULL;
+		ocs_els_io_free(node->ls_acc_io);
+		node->send_ls_acc = OCS_NODE_SEND_LS_ACC_NONE;
+		node->ls_acc_io = NULL;
+	}
+}
+
+/**
+ * @ingroup node_common
+ * @brief state: shutdown a node
+ *
+ * A node is shutdown,
+ *
+ * @param ctx remote node sm context
+ * @param evt event to process
+ * @param arg per event optional argument
+ *
+ * @return returns NULL
+ *
+ * @note
+ */
+
+void *
+__ocs_node_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	int32_t rc;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		ocs_node_hold_frames(node);
+		ocs_assert(ocs_node_active_ios_empty(node), NULL);
+		ocs_assert(ocs_els_io_list_empty(node, &node->els_io_active_list), NULL);
+
+		/* by default, we will be freeing node after we unwind */
+		node->req_free = 1;
+
+		switch (node->shutdown_reason) {
+		case OCS_NODE_SHUTDOWN_IMPLICIT_LOGO:
+			/* sm: if shutdown reason is implicit logout / ocs_node_attach
+			 * Node shutdown b/c of PLOGI received when node already
+			 * logged in. We have PLOGI service parameters, so submit
+			 * node attach; we won't be freeing this node
+			 */
+
+			/* currently, only case for implicit logo is PLOGI recvd. Thus,
+			 * node's ELS IO pending list won't be empty (PLOGI will be on it)
+			 */
+			ocs_assert(node->send_ls_acc == OCS_NODE_SEND_LS_ACC_PLOGI, NULL);
+			node_printf(node, "Shutdown reason: implicit logout, re-authenticate\n");
+
+			ocs_scsi_io_alloc_enable(node);
+
+			/* Re-attach node with the same HW node resources */
+			node->req_free = 0;
+			rc = ocs_node_attach(node);
+			ocs_node_transition(node, __ocs_d_wait_node_attach, NULL);
+			if (rc == OCS_HW_RTN_SUCCESS_SYNC) {
+				ocs_node_post_event(node, OCS_EVT_NODE_ATTACH_OK, NULL);
+			}
+			break;
+		case OCS_NODE_SHUTDOWN_EXPLICIT_LOGO: {
+			int8_t pend_frames_empty;
+
+			/* cleanup any pending LS_ACC ELSs */
+			ocs_node_send_ls_io_cleanup(node);
+			ocs_assert(ocs_els_io_list_empty(node, &node->els_io_pend_list), NULL);
+
+			ocs_lock(&node->pend_frames_lock);
+				pend_frames_empty = ocs_list_empty(&node->pend_frames);
+			ocs_unlock(&node->pend_frames_lock);
+
+			/* there are two scenarios where we want to keep this node alive:
+			 * 1. there are pending frames that need to be processed or
+			 * 2. we're an initiator and the remote node is a target and we
+			 *    need to re-authenticate
+			 */
+			node_printf(node, "Shutdown: explicit logo pend=%d sport.ini=%d node.tgt=%d\n",
+				    !pend_frames_empty, node->sport->enable_ini, node->targ);
+
+			if((!pend_frames_empty) || (node->sport->enable_ini && node->targ)) {
+				uint8_t send_plogi = FALSE;
+				if (node->sport->enable_ini && node->targ) {
+					/* we're an initiator and node shutting down is a target; we'll
+					 * need to re-authenticate in initial state
+					 */
+					send_plogi = TRUE;
+				}
+
+				/* transition to __ocs_d_init (will retain HW node resources) */
+				ocs_scsi_io_alloc_enable(node);
+				node->req_free = 0;
+
+				/* either pending frames exist, or we're re-authenticating with PLOGI
+				 * (or both); in either case, return to initial state
+				 */
+				ocs_node_init_device(node, send_plogi);
+
+			}
+			/* else: let node shutdown occur */
+			break;
+		}
+		case OCS_NODE_SHUTDOWN_DEFAULT:
+		default:
+			/* shutdown due to link down, node going away (xport event) or
+			 * sport shutdown, purge pending and proceed to cleanup node
+			 */
+
+			/* cleanup any pending LS_ACC ELSs */
+			ocs_node_send_ls_io_cleanup(node);
+			ocs_assert(ocs_els_io_list_empty(node, &node->els_io_pend_list), NULL);
+
+			node_printf(node, "Shutdown reason: default, purge pending\n");
+			ocs_node_purge_pending(node);
+			break;
+		}
+
+		break;
+	}
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	default:
+		__ocs_node_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup common_node
+ * @brief Checks to see if ELS's have been quiesced
+ *
+ * Check if ELS's have been quiesced. If so, transition to the
+ * next state in the shutdown process.
+ *
+ * @param node Node for which ELS's are checked
+ *
+ * @return Returns 1 if ELS's have been quiesced, 0 otherwise.
+ */
+static int
+ocs_node_check_els_quiesced(ocs_node_t *node)
+{
+	ocs_assert(node, -1);
+
+	/* check to see if ELS requests, completions are quiesced */
+	if ((node->els_req_cnt == 0) && (node->els_cmpl_cnt == 0) &&
+	    ocs_els_io_list_empty(node, &node->els_io_active_list)) {
+		if (!node->attached) {
+			/* hw node detach already completed, proceed */
+			node_printf(node, "HW node not attached\n");
+			ocs_node_transition(node, __ocs_node_wait_ios_shutdown, NULL);
+		} else {
+			/* hw node detach hasn't completed, transition and wait */
+			node_printf(node, "HW node still attached\n");
+			ocs_node_transition(node, __ocs_node_wait_node_free, NULL);
+		}
+		return 1;
+	}
+	return 0;
+}
+
+/**
+ * @ingroup common_node
+ * @brief Initiate node IO cleanup.
+ *
+ * Note: this function must be called with a non-attached node
+ * or a node for which the node detach (ocs_hw_node_detach())
+ * has already been initiated.
+ *
+ * @param node Node for which shutdown is initiated
+ *
+ * @return Returns None.
+ */
+
+void
+ocs_node_initiate_cleanup(ocs_node_t *node)
+{
+	ocs_io_t *els;
+	ocs_io_t *els_next;
+	ocs_t *ocs;
+	ocs_assert(node);
+	ocs = node->ocs;
+
+	/* first cleanup ELS's that are pending (not yet active) */
+	ocs_lock(&node->active_ios_lock);
+		ocs_list_foreach_safe(&node->els_io_pend_list, els, els_next) {
+
+			/* skip the ELS IO for which a response will be sent after shutdown */
+			if ((node->send_ls_acc != OCS_NODE_SEND_LS_ACC_NONE) &&
+			    (els == node->ls_acc_io)) {
+				continue;
+			}
+			/* can't call ocs_els_io_free() because lock is held; cleanup manually */
+                        node_printf(node, "Freeing pending els %s\n", els->display_name);
+			ocs_list_remove(&node->els_io_pend_list, els);
+
+			ocs_io_free(node->ocs, els);
+		}
+	ocs_unlock(&node->active_ios_lock);
+
+	if (node->ls_acc_io && node->ls_acc_io->hio != NULL) {
+		/*
+		 * if there's an IO that will result in an LS_ACC after
+		 * shutdown and its HW IO is non-NULL, it better be an
+		 * implicit logout in vanilla sequence coalescing. In this
+		 * case, force the LS_ACC to go out on another XRI (hio)
+		 * since the previous will have been aborted by the UNREG_RPI
+		 */
+		ocs_assert(node->shutdown_reason == OCS_NODE_SHUTDOWN_IMPLICIT_LOGO);
+		ocs_assert(node->send_ls_acc == OCS_NODE_SEND_LS_ACC_PLOGI);
+		node_printf(node, "invalidating ls_acc_io due to implicit logo\n");
+
+		/* No need to abort because the unreg_rpi takes care of it, just free */
+		ocs_hw_io_free(&ocs->hw, node->ls_acc_io->hio);
+
+		/* NULL out hio to force the LS_ACC to grab a new XRI */
+		node->ls_acc_io->hio = NULL;
+	}
+
+	/*
+	 * if ELS's have already been quiesced, will move to next state
+	 * if ELS's have not been quiesced, abort them
+	 */
+	if (ocs_node_check_els_quiesced(node) == 0) {
+		/*
+		 * Abort all ELS's since ELS's won't be aborted by HW
+		 * node free.
+		 */
+		ocs_node_abort_all_els(node);
+		ocs_node_transition(node, __ocs_node_wait_els_shutdown, NULL);
+	}
+}
+
+/**
+ * @ingroup node_common
+ * @brief Node state machine: Wait for all ELSs to complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * State waits for all ELSs to complete after aborting all
+ * outstanding .
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_node_wait_els_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	uint8_t check_quiesce = FALSE;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+
+	case OCS_EVT_ENTER: {
+		ocs_node_hold_frames(node);
+		if (ocs_els_io_list_empty(node, &node->els_io_active_list)) {
+			node_printf(node, "All ELS IOs complete\n");
+			check_quiesce = TRUE;
+		}
+		break;
+	}
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+	case OCS_EVT_ELS_REQ_ABORTED:
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		check_quiesce = TRUE;
+		break;
+
+	case OCS_EVT_SRRS_ELS_CMPL_OK:
+	case OCS_EVT_SRRS_ELS_CMPL_FAIL:
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		check_quiesce = TRUE;
+		break;
+
+	case OCS_EVT_ALL_CHILD_NODES_FREE:
+		/* all ELS IO's complete */
+		node_printf(node, "All ELS IOs complete\n");
+		ocs_assert(ocs_els_io_list_empty(node, &node->els_io_active_list), NULL);
+		check_quiesce = TRUE;
+		break;
+
+	case OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
+		break;
+
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		/* don't care about domain_attach_ok */
+		break;
+
+	/* ignore shutdown events as we're already in shutdown path */
+	case OCS_EVT_SHUTDOWN:
+		/* have default shutdown event take precedence */
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		/* fall through */
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		break;
+
+	default:
+		__ocs_node_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	if (check_quiesce) {
+		ocs_node_check_els_quiesced(node);
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup node_command
+ * @brief Node state machine: Wait for a HW node free event to
+ * complete.
+ *
+ * <h3 class="desc">Description</h3>
+ * State waits for the node free event to be received from the HW.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_node_wait_node_free(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+		break;
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_NODE_FREE_OK:
+		/* node is officially no longer attached */
+		node->attached = FALSE;
+		ocs_node_transition(node, __ocs_node_wait_ios_shutdown, NULL);
+		break;
+
+	case OCS_EVT_ALL_CHILD_NODES_FREE:
+	case OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
+		/* As IOs and ELS IO's complete we expect to get these events */
+		break;
+
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		/* don't care about domain_attach_ok */
+		break;
+
+	/* ignore shutdown events as we're already in shutdown path */
+	case OCS_EVT_SHUTDOWN:
+		/* have default shutdown event take precedence */
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		/* Fall through */
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		node_printf(node, "%s received\n", ocs_sm_event_name(evt));
+		break;
+	default:
+		__ocs_node_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup node_common
+ * @brief state: initiate node shutdown
+ *
+ * State is entered when a node receives a shutdown event, and it's waiting
+ * for all the active IOs and ELS IOs associated with the node to complete.
+ *
+ * @param ctx remote node sm context
+ * @param evt event to process
+ * @param arg per event optional argument
+ *
+ * @return returns NULL
+ */
+
+void *
+__ocs_node_wait_ios_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_io_t *io;
+	ocs_io_t *next;
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		ocs_node_hold_frames(node);
+
+		/* first check to see if no ELS IOs are outstanding */
+		if (ocs_els_io_list_empty(node, &node->els_io_active_list)) {
+			/* If there are any active IOS, Free them. */
+			if (!ocs_node_active_ios_empty(node)) {
+				ocs_lock(&node->active_ios_lock);
+				ocs_list_foreach_safe(&node->active_ios, io, next) {
+					ocs_list_remove(&io->node->active_ios, io);
+					ocs_io_free(node->ocs, io);
+				}
+				ocs_unlock(&node->active_ios_lock);
+			}
+			ocs_node_transition(node, __ocs_node_shutdown, NULL);
+		}
+		break;
+
+	case OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY:
+	case OCS_EVT_ALL_CHILD_NODES_FREE: {
+		if (ocs_node_active_ios_empty(node) &&
+		    ocs_els_io_list_empty(node, &node->els_io_active_list)) {
+			ocs_node_transition(node, __ocs_node_shutdown, NULL);
+		}
+		break;
+	}
+
+	case OCS_EVT_EXIT:
+		ocs_node_accept_frames(node);
+		break;
+
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+		/* Can happen as ELS IO IO's complete */
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		break;
+
+	/* ignore shutdown events as we're already in shutdown path */
+	case OCS_EVT_SHUTDOWN:
+		/* have default shutdown event take precedence */
+		node->shutdown_reason = OCS_NODE_SHUTDOWN_DEFAULT;
+		/* fall through */
+	case OCS_EVT_SHUTDOWN_EXPLICIT_LOGO:
+	case OCS_EVT_SHUTDOWN_IMPLICIT_LOGO:
+		ocs_log_debug(ocs, "[%s] %-20s\n", node->display_name, ocs_sm_event_name(evt));
+		break;
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		/* don't care about domain_attach_ok */
+		break;
+	default:
+		__ocs_node_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup node_common
+ * @brief state: common node event handler
+ *
+ * Handle common/shared node events
+ *
+ * @param funcname calling function's name
+ * @param ctx remote node sm context
+ * @param evt event to process
+ * @param arg per event optional argument
+ *
+ * @return returns NULL
+ */
+
+void *
+__ocs_node_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	ocs_node_t *node = NULL;
+	ocs_t *ocs = NULL;
+	ocs_node_cb_t *cbdata = arg;
+	ocs_assert(ctx, NULL);
+	ocs_assert(ctx->app, NULL);
+	node = ctx->app;
+	ocs_assert(node->ocs, NULL);
+	ocs = node->ocs;
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+	case OCS_EVT_REENTER:
+	case OCS_EVT_EXIT:
+	case OCS_EVT_SPORT_TOPOLOGY_NOTIFY:
+	case OCS_EVT_NODE_MISSING:
+	case OCS_EVT_FCP_CMD_RCVD:
+		break;
+
+	case OCS_EVT_NODE_REFOUND:
+		node->refound = 1;
+		break;
+
+	/* node->attached must be set appropriately for all node attach/detach events */
+	case OCS_EVT_NODE_ATTACH_OK:
+		node->attached = TRUE;
+		break;
+
+	case OCS_EVT_NODE_FREE_OK:
+	case OCS_EVT_NODE_ATTACH_FAIL:
+		node->attached = FALSE;
+		break;
+
+	/* handle any ELS completions that other states either didn't care about
+	 * or forgot about
+	 */
+	case OCS_EVT_SRRS_ELS_CMPL_OK:
+	case OCS_EVT_SRRS_ELS_CMPL_FAIL:
+		ocs_assert(node->els_cmpl_cnt, NULL);
+		node->els_cmpl_cnt--;
+		break;
+
+	/* handle any ELS request completions that other states either didn't care about
+	 * or forgot about
+	 */
+	case OCS_EVT_SRRS_ELS_REQ_OK:
+	case OCS_EVT_SRRS_ELS_REQ_FAIL:
+	case OCS_EVT_SRRS_ELS_REQ_RJT:
+	case OCS_EVT_ELS_REQ_ABORTED:
+		ocs_assert(node->els_req_cnt, NULL);
+		node->els_req_cnt--;
+		break;
+
+	case OCS_EVT_ELS_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+
+		/* Unsupported ELS was received, send LS_RJT, command not supported */
+		ocs_log_debug(ocs, "[%s] (%s) ELS x%02x, LS_RJT not supported\n",
+			      node->display_name, funcname, ((uint8_t*)cbdata->payload->dma.virt)[0]);
+		ocs_send_ls_rjt(cbdata->io, ocs_be16toh(hdr->ox_id),
+			FC_REASON_COMMAND_NOT_SUPPORTED, FC_EXPL_NO_ADDITIONAL, 0,
+			NULL, NULL);
+		break;
+	}
+
+	case OCS_EVT_PLOGI_RCVD:
+	case OCS_EVT_FLOGI_RCVD:
+	case OCS_EVT_LOGO_RCVD:
+	case OCS_EVT_PRLI_RCVD:
+	case OCS_EVT_PRLO_RCVD:
+	case OCS_EVT_PDISC_RCVD:
+	case OCS_EVT_FDISC_RCVD:
+	case OCS_EVT_ADISC_RCVD:
+	case OCS_EVT_RSCN_RCVD:
+	case OCS_EVT_SCR_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		/* sm: / send ELS_RJT */
+		ocs_log_debug(ocs, "[%s] (%s) %s sending ELS_RJT\n",
+			      node->display_name, funcname, ocs_sm_event_name(evt));
+		/* if we didn't catch this in a state, send generic LS_RJT */
+		ocs_send_ls_rjt(cbdata->io, ocs_be16toh(hdr->ox_id),
+			FC_REASON_UNABLE_TO_PERFORM, FC_EXPL_NO_ADDITIONAL, 0,
+			NULL, NULL);
+
+		break;
+	}
+	case OCS_EVT_GID_PT_RCVD:
+	case OCS_EVT_RFT_ID_RCVD:
+	case OCS_EVT_RFF_ID_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		ocs_log_debug(ocs, "[%s] (%s) %s sending CT_REJECT\n",
+			      node->display_name, funcname, ocs_sm_event_name(evt));
+		ocs_send_ct_rsp(cbdata->io, hdr->ox_id, cbdata->payload->dma.virt, FCCT_HDR_CMDRSP_REJECT, FCCT_COMMAND_NOT_SUPPORTED, 0);
+		break;
+	}
+
+	case OCS_EVT_ABTS_RCVD: {
+		fc_header_t *hdr = cbdata->header->dma.virt;
+		ocs_log_debug(ocs, "[%s] (%s) %s sending BA_ACC\n",
+			      node->display_name, funcname, ocs_sm_event_name(evt));
+
+		/* sm: send BA_ACC */
+		ocs_bls_send_acc_hdr(cbdata->io, hdr);
+		break;
+	}
+
+	default:
+		ocs_log_test(node->ocs, "[%s] %-20s %-20s not handled\n", node->display_name, funcname,
+			ocs_sm_event_name(evt));
+		break;
+	}
+	return NULL;
+}
+
+
+/**
+ * @ingroup node_common
+ * @brief save node service parameters
+ *
+ * Service parameters are copyed into the node structure
+ *
+ * @param node pointer to node structure
+ * @param payload pointer to service parameters to save
+ *
+ * @return none
+ */
+
+void
+ocs_node_save_sparms(ocs_node_t *node, void *payload)
+{
+	ocs_memcpy(node->service_params, payload, sizeof(node->service_params));
+}
+
+/**
+ * @ingroup node_common
+ * @brief Post event to node state machine context
+ *
+ * This is used by the node state machine code to post events to the nodes.  Upon
+ * completion of the event posting, if the nesting depth is zero and we're not holding
+ * inbound frames, then the pending frames are processed.
+ *
+ * @param node pointer to node
+ * @param evt event to post
+ * @param arg event posting argument
+ *
+ * @return none
+ */
+
+void
+ocs_node_post_event(ocs_node_t *node, ocs_sm_event_t evt, void *arg)
+{
+	int free_node = FALSE;
+	ocs_assert(node);
+
+	ocs_node_lock(node);
+		node->evtdepth ++;
+
+		ocs_sm_post_event(&node->sm, evt, arg);
+
+		/* If our event call depth is one and we're not holding frames
+		 * then we can dispatch any pending frames.   We don't want to allow
+		 * the ocs_process_node_pending() call to recurse.
+		 */
+		if (!node->hold_frames && (node->evtdepth == 1)) {
+			ocs_process_node_pending(node);
+		}
+		node->evtdepth --;
+
+		/* Free the node object if so requested, and we're at an event
+		 * call depth of zero
+		 */
+		if ((node->evtdepth == 0) && node->req_free) {
+			free_node = TRUE;
+		}
+	ocs_node_unlock(node);
+
+	if (free_node) {
+		ocs_node_free(node);
+	}
+
+	return;
+}
+
+/**
+ * @ingroup node_common
+ * @brief transition state of a node
+ *
+ * The node's state is transitioned to the requested state.  Entry/Exit
+ * events are posted as needed.
+ *
+ * @param node pointer to node
+ * @param state state to transition to
+ * @param data transition data
+ *
+ * @return none
+ */
+
+void
+ocs_node_transition(ocs_node_t *node, ocs_sm_function_t state, void *data)
+{
+	ocs_sm_ctx_t *ctx = &node->sm;
+
+	ocs_node_lock(node);
+		if (ctx->current_state == state) {
+			ocs_node_post_event(node, OCS_EVT_REENTER, data);
+		} else {
+			ocs_node_post_event(node, OCS_EVT_EXIT, data);
+			ctx->current_state = state;
+			ocs_node_post_event(node, OCS_EVT_ENTER, data);
+		}
+	ocs_node_unlock(node);
+}
+
+/**
+ * @ingroup node_common
+ * @brief build EUI formatted WWN
+ *
+ * Build a WWN given the somewhat transport agnostic iScsi naming specification, for FC
+ * use the eui. format, an ascii string such as: "eui.10000000C9A19501"
+ *
+ * @param buffer buffer to place formatted name into
+ * @param buffer_len length in bytes of the buffer
+ * @param eui_name cpu endian 64 bit WWN value
+ *
+ * @return none
+ */
+
+void
+ocs_node_build_eui_name(char *buffer, uint32_t buffer_len, uint64_t eui_name)
+{
+	ocs_memset(buffer, 0, buffer_len);
+
+	ocs_snprintf(buffer, buffer_len, "eui.%016llx", (unsigned long long)eui_name);
+}
+
+/**
+ * @ingroup node_common
+ * @brief return nodes' WWPN as a uint64_t
+ *
+ * The WWPN is computed from service parameters and returned as a uint64_t
+ *
+ * @param node pointer to node structure
+ *
+ * @return WWPN
+ *
+ */
+
+uint64_t
+ocs_node_get_wwpn(ocs_node_t *node)
+{
+	fc_plogi_payload_t *sp = (fc_plogi_payload_t*) node->service_params;
+
+	return (((uint64_t)ocs_be32toh(sp->port_name_hi) << 32ll) | (ocs_be32toh(sp->port_name_lo)));
+}
+
+/**
+ * @ingroup node_common
+ * @brief return nodes' WWNN as a uint64_t
+ *
+ * The WWNN is computed from service parameters and returned as a uint64_t
+ *
+ * @param node pointer to node structure
+ *
+ * @return WWNN
+ *
+ */
+
+uint64_t
+ocs_node_get_wwnn(ocs_node_t *node)
+{
+	fc_plogi_payload_t *sp = (fc_plogi_payload_t*) node->service_params;
+
+	return (((uint64_t)ocs_be32toh(sp->node_name_hi) << 32ll) | (ocs_be32toh(sp->node_name_lo)));
+}
+
+/**
+ * @brief Generate node ddump data
+ *
+ * Generates the node ddumpdata
+ *
+ * @param textbuf pointer to text buffer
+ * @param node pointer to node context
+ *
+ * @return Returns 0 on success, or a negative value on failure.
+ */
+
+int
+ocs_ddump_node(ocs_textbuf_t *textbuf, ocs_node_t *node)
+{
+	ocs_io_t *io;
+	ocs_io_t *els;
+	int retval = 0;
+
+	ocs_ddump_section(textbuf, "node", node->instance_index);
+	ocs_ddump_value(textbuf, "display_name", "%s", node->display_name);
+	ocs_ddump_value(textbuf, "current_state", "%s", node->current_state_name);
+	ocs_ddump_value(textbuf, "prev_state", "%s", node->prev_state_name);
+	ocs_ddump_value(textbuf, "current_evt", "%s", ocs_sm_event_name(node->current_evt));
+	ocs_ddump_value(textbuf, "prev_evt", "%s", ocs_sm_event_name(node->prev_evt));
+
+	ocs_ddump_value(textbuf, "indicator", "%#x", node->rnode.indicator);
+	ocs_ddump_value(textbuf, "fc_id", "%#06x", node->rnode.fc_id);
+	ocs_ddump_value(textbuf, "attached", "%d", node->rnode.attached);
+
+	ocs_ddump_value(textbuf, "hold_frames", "%d", node->hold_frames);
+	ocs_ddump_value(textbuf, "io_alloc_enabled", "%d", node->io_alloc_enabled);
+	ocs_ddump_value(textbuf, "shutdown_reason", "%d", node->shutdown_reason);
+	ocs_ddump_value(textbuf, "send_ls_acc", "%d", node->send_ls_acc);
+	ocs_ddump_value(textbuf, "ls_acc_did", "%d", node->ls_acc_did);
+	ocs_ddump_value(textbuf, "ls_acc_oxid", "%#04x", node->ls_acc_oxid);
+	ocs_ddump_value(textbuf, "req_free", "%d", node->req_free);
+	ocs_ddump_value(textbuf, "els_req_cnt", "%d", node->els_req_cnt);
+	ocs_ddump_value(textbuf, "els_cmpl_cnt", "%d", node->els_cmpl_cnt);
+
+	ocs_ddump_value(textbuf, "targ", "%d", node->targ);
+	ocs_ddump_value(textbuf, "init", "%d", node->init);
+	ocs_ddump_value(textbuf, "wwnn", "%s", node->wwnn);
+	ocs_ddump_value(textbuf, "wwpn", "%s", node->wwpn);
+	ocs_ddump_value(textbuf, "login_state", "%d", (node->sm.current_state == __ocs_d_device_ready) ? 1 : 0);
+	ocs_ddump_value(textbuf, "chained_io_count", "%d", node->chained_io_count);
+	ocs_ddump_value(textbuf, "abort_cnt", "%d", node->abort_cnt);
+
+	ocs_display_sparams(NULL, "node_sparams", 1, textbuf, node->service_params+4);
+
+	ocs_lock(&node->pend_frames_lock);
+		if (!ocs_list_empty(&node->pend_frames)) {
+			ocs_hw_sequence_t *frame;
+			ocs_ddump_section(textbuf, "pending_frames", 0);
+			ocs_list_foreach(&node->pend_frames, frame) {
+				fc_header_t *hdr;
+				char buf[128];
+
+				hdr = frame->header->dma.virt;
+				ocs_snprintf(buf, sizeof(buf), "%02x/%04x/%04x len %zu",
+				 hdr->r_ctl, ocs_be16toh(hdr->ox_id), ocs_be16toh(hdr->rx_id),
+				 frame->payload->dma.len);
+				ocs_ddump_value(textbuf, "frame", "%s", buf);
+			}
+			ocs_ddump_endsection(textbuf, "pending_frames", 0);
+		}
+	ocs_unlock(&node->pend_frames_lock);
+
+	ocs_scsi_ini_ddump(textbuf, OCS_SCSI_DDUMP_NODE, node);
+	ocs_scsi_tgt_ddump(textbuf, OCS_SCSI_DDUMP_NODE, node);
+
+	ocs_lock(&node->active_ios_lock);
+		ocs_ddump_section(textbuf, "active_ios", 0);
+		ocs_list_foreach(&node->active_ios, io) {
+			ocs_ddump_io(textbuf, io);
+		}
+		ocs_ddump_endsection(textbuf, "active_ios", 0);
+
+		ocs_ddump_section(textbuf, "els_io_pend_list", 0);
+		ocs_list_foreach(&node->els_io_pend_list, els) {
+			ocs_ddump_els(textbuf, els);
+		}
+		ocs_ddump_endsection(textbuf, "els_io_pend_list", 0);
+
+		ocs_ddump_section(textbuf, "els_io_active_list", 0);
+		ocs_list_foreach(&node->els_io_active_list, els) {
+			ocs_ddump_els(textbuf, els);
+		}
+		ocs_ddump_endsection(textbuf, "els_io_active_list", 0);
+	ocs_unlock(&node->active_ios_lock);
+
+	ocs_ddump_endsection(textbuf, "node", node->instance_index);
+
+	return retval;
+}
+
+/**
+ * @brief check ELS request completion
+ *
+ * Check ELS request completion event to make sure it's for the
+ * ELS request we expect. If not, invoke given common event
+ * handler and return an error.
+ *
+ * @param ctx state machine context
+ * @param evt ELS request event
+ * @param arg event argument
+ * @param cmd ELS command expected
+ * @param node_common_func common event handler to call if ELS
+ *      		   doesn't match
+ * @param funcname function name that called this
+ *
+ * @return zero if ELS command matches, -1 otherwise
+ */
+int32_t
+node_check_els_req(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg, uint8_t cmd, ocs_node_common_func_t node_common_func, const char *funcname)
+{
+	ocs_node_t *node = NULL;
+	ocs_t *ocs = NULL;
+	ocs_node_cb_t *cbdata = arg;
+	fc_els_gen_t *els_gen = NULL;
+	ocs_assert(ctx, -1);
+	node = ctx->app;
+	ocs_assert(node, -1);
+	ocs = node->ocs;
+	ocs_assert(ocs, -1);
+	cbdata = arg;
+	ocs_assert(cbdata, -1);
+	ocs_assert(cbdata->els, -1);
+	els_gen = (fc_els_gen_t *)cbdata->els->els_req.virt;
+	ocs_assert(els_gen, -1);
+
+	if ((cbdata->els->hio_type != OCS_HW_ELS_REQ) || (els_gen->command_code != cmd)) {
+		if (cbdata->els->hio_type != OCS_HW_ELS_REQ) {
+			ocs_log_debug(node->ocs, "[%s] %-20s expecting ELS cmd=x%x received type=%d\n",
+				node->display_name, funcname, cmd, cbdata->els->hio_type);
+		} else {
+			ocs_log_debug(node->ocs, "[%s] %-20s expecting ELS cmd=x%x received cmd=x%x\n",
+				node->display_name, funcname, cmd, els_gen->command_code);
+		}
+		/* send event to common handler */
+		node_common_func(funcname, ctx, evt, arg);
+		return -1;
+	}
+	return 0;
+}
+
+/**
+ * @brief check NS request completion
+ *
+ * Check ELS request completion event to make sure it's for the
+ * nameserver request we expect. If not, invoke given common
+ * event handler and return an error.
+ *
+ * @param ctx state machine context
+ * @param evt ELS request event
+ * @param arg event argument
+ * @param cmd nameserver command expected
+ * @param node_common_func common event handler to call if
+ *      		   nameserver cmd doesn't match
+ * @param funcname function name that called this
+ *
+ * @return zero if NS command matches, -1 otherwise
+ */
+int32_t
+node_check_ns_req(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg, uint32_t cmd, ocs_node_common_func_t node_common_func, const char *funcname)
+{
+	ocs_node_t *node = NULL;
+	ocs_t *ocs = NULL;
+	ocs_node_cb_t *cbdata = arg;
+	fcct_iu_header_t *fcct = NULL;
+	ocs_assert(ctx, -1);
+	node = ctx->app;
+	ocs_assert(node, -1);
+	ocs = node->ocs;
+	ocs_assert(ocs, -1);
+	cbdata = arg;
+	ocs_assert(cbdata, -1);
+	ocs_assert(cbdata->els, -1);
+	fcct = (fcct_iu_header_t *)cbdata->els->els_req.virt;
+	ocs_assert(fcct, -1);
+
+	if ((cbdata->els->hio_type != OCS_HW_FC_CT) || fcct->cmd_rsp_code != ocs_htobe16(cmd)) {
+		if (cbdata->els->hio_type != OCS_HW_FC_CT) {
+			ocs_log_debug(node->ocs, "[%s] %-20s expecting NS cmd=x%x received type=%d\n",
+				node->display_name, funcname, cmd, cbdata->els->hio_type);
+		} else {
+			ocs_log_debug(node->ocs, "[%s] %-20s expecting NS cmd=x%x received cmd=x%x\n",
+				node->display_name, funcname, cmd, fcct->cmd_rsp_code);
+		}
+		/* send event to common handler */
+		node_common_func(funcname, ctx, evt, arg);
+		return -1;
+	}
+	return 0;
+}
+
+
+void
+ocs_mgmt_node_list(ocs_textbuf_t *textbuf, void *object)
+{
+	ocs_io_t *io;
+	ocs_node_t *node = (ocs_node_t *)object;
+
+	ocs_mgmt_start_section(textbuf, "node", node->instance_index);
+
+	/* Readonly values */
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "display_name");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "indicator");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "fc_id");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "attached");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "hold_frames");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "shutting_down");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "req_free");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ox_id");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "ox_id_in_use");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "abort_cnt");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "targ");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "init");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "wwpn");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "wwnn");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "pend_frames");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "chained_io_count");
+
+	/* Actions */
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "resume");
+
+	ocs_lock(&node->active_ios_lock);
+	ocs_list_foreach(&node->active_ios, io) {
+		if ((io->mgmt_functions) && (io->mgmt_functions->get_list_handler)) {
+			io->mgmt_functions->get_list_handler(textbuf, io);
+		}
+	}
+	ocs_unlock(&node->active_ios_lock);
+
+	ocs_mgmt_end_section(textbuf, "node", node->instance_index);
+}
+
+int
+ocs_mgmt_node_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
+{
+	ocs_io_t *io;
+	ocs_node_t *node = (ocs_node_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	ocs_mgmt_start_section(textbuf, "node", node->instance_index);
+
+	ocs_snprintf(qualifier, sizeof(qualifier), "%s/node[%d]", parent, node->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = name + strlen(qualifier) +1;
+
+		/* See if it's a value I can supply */
+		if (ocs_strcmp(unqualified_name, "display_name") == 0) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", node->display_name);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "indicator") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "indicator", "0x%x", node->rnode.indicator);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "fc_id") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "0x%06x", node->rnode.fc_id);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "attached") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "attached", node->rnode.attached);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "hold_frames") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "hold_frames", node->hold_frames);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "io_alloc_enabled") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "io_alloc_enabled", node->io_alloc_enabled);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "req_free") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "req_free", node->req_free);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "ls_acc_oxid") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ls_acc_oxid", "0x%#04x", node->ls_acc_oxid);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "ls_acc_did") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ls_acc_did", "0x%#04x", node->ls_acc_did);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "abort_cnt") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "abort_cnt", "%d", node->abort_cnt);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "targ") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "targ",  node->targ);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "init") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "init",  node->init);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "wwpn") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwpn", "%s", node->wwpn);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "wwnn") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwnn", "%s", node->wwnn);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "current_state") == 0) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "current_state", node->current_state_name);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "login_state") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "login_state", "%d", (node->sm.current_state == __ocs_d_device_ready) ? 1 : 0);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "pend_frames") == 0) {
+			ocs_hw_sequence_t *frame;
+			ocs_lock(&node->pend_frames_lock);
+				ocs_list_foreach(&node->pend_frames, frame) {
+					fc_header_t *hdr;
+					char buf[128];
+
+					hdr = frame->header->dma.virt;
+					ocs_snprintf(buf, sizeof(buf), "%02x/%04x/%04x len %zu", hdr->r_ctl,
+						 ocs_be16toh(hdr->ox_id), ocs_be16toh(hdr->rx_id),
+						 frame->payload->dma.len);
+					ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pend_frames", buf);
+				}
+			ocs_unlock(&node->pend_frames_lock);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "chained_io_count") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "chained_io_count", "%d", node->chained_io_count);
+			retval = 0;
+		} else {
+			/* If I didn't know the value of this status pass the request to each of my children */
+			ocs_lock(&node->active_ios_lock);
+				ocs_list_foreach(&node->active_ios, io) {
+					if ((io->mgmt_functions) && (io->mgmt_functions->get_handler)) {
+						retval = io->mgmt_functions->get_handler(textbuf, qualifier, name, io);
+					}
+
+					if (retval == 0) {
+						break;
+					}
+				}
+			ocs_unlock(&node->active_ios_lock);
+		}
+	}
+
+	ocs_mgmt_end_section(textbuf, "node", node->instance_index);
+
+	return retval;
+}
+
+void
+ocs_mgmt_node_get_all(ocs_textbuf_t *textbuf, void *object)
+{
+	ocs_io_t *io;
+	ocs_node_t *node = (ocs_node_t *)object;
+	ocs_hw_sequence_t *frame;
+
+	ocs_mgmt_start_section(textbuf, "node", node->instance_index);
+
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", node->display_name);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "indicator", "0x%x", node->rnode.indicator);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "0x%06x", node->rnode.fc_id);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "attached", node->rnode.attached);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "hold_frames", node->hold_frames);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "io_alloc_enabled", node->io_alloc_enabled);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "req_free", node->req_free);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ls_acc_oxid", "0x%#04x", node->ls_acc_oxid);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "ls_acc_did", "0x%#04x", node->ls_acc_did);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "abort_cnt", "%d", node->abort_cnt);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "targ",  node->targ);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "init",  node->init);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwpn", "%s", node->wwpn);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwnn", "%s", node->wwnn);
+
+	ocs_lock(&node->pend_frames_lock);
+	ocs_list_foreach(&node->pend_frames, frame) {
+		fc_header_t *hdr;
+		char buf[128];
+
+		hdr = frame->header->dma.virt;
+		ocs_snprintf(buf, sizeof(buf), "%02x/%04x/%04x len %zu", hdr->r_ctl,
+			     ocs_be16toh(hdr->ox_id), ocs_be16toh(hdr->rx_id),
+			     frame->payload->dma.len);
+		ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "pend_frames", buf);
+	}
+	ocs_unlock(&node->pend_frames_lock);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "chained_io_count", "%d", node->chained_io_count);
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_EX, "resume");
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "current_state", node->current_state_name);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "login_state", "%d", (node->sm.current_state == __ocs_d_device_ready) ? 1 : 0);
+
+	ocs_lock(&node->active_ios_lock);
+	ocs_list_foreach(&node->active_ios, io) {
+		if ((io->mgmt_functions) && (io->mgmt_functions->get_all_handler)) {
+			io->mgmt_functions->get_all_handler(textbuf,io);
+		}
+	}
+	ocs_unlock(&node->active_ios_lock);
+
+	ocs_mgmt_end_section(textbuf, "node", node->instance_index);
+}
+
+int
+ocs_mgmt_node_set(char *parent, char *name, char *value, void *object)
+{
+	ocs_io_t *io;
+	ocs_node_t *node = (ocs_node_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	ocs_snprintf(qualifier, sizeof(qualifier), "%s/node[%d]", parent, node->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+
+		ocs_lock(&node->active_ios_lock);
+		ocs_list_foreach(&node->active_ios, io) {
+			if ((io->mgmt_functions) && (io->mgmt_functions->set_handler)) {
+				retval = io->mgmt_functions->set_handler(qualifier, name, value, io);
+			}
+
+			if (retval == 0) {
+				break;
+			}
+
+		}
+		ocs_unlock(&node->active_ios_lock);
+
+	}
+
+	return retval;
+}
+
+int
+ocs_mgmt_node_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
+		   void *arg_out, uint32_t arg_out_length, void *object)
+{
+	ocs_io_t *io;
+	ocs_node_t *node = (ocs_node_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	ocs_snprintf(qualifier, sizeof(qualifier), "%s.node%d", parent, node->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(action, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = action + strlen(qualifier) +1;
+
+		if (ocs_strcmp(unqualified_name, "resume") == 0) {
+			ocs_node_post_event(node, OCS_EVT_RESUME, NULL);
+		}
+
+		{
+			/* If I didn't know how to do this action pass the request to each of my children */
+			ocs_lock(&node->active_ios_lock);
+				ocs_list_foreach(&node->active_ios, io) {
+					if ((io->mgmt_functions) && (io->mgmt_functions->exec_handler)) {
+						retval = io->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length,
+							arg_out, arg_out_length, io);
+					}
+
+					if (retval == 0) {
+						break;
+					}
+
+				}
+			ocs_unlock(&node->active_ios_lock);
+		}
+	}
+
+	return retval;
+}
+
+
+
+/**
+ * @brief Return TRUE if active ios list is empty
+ *
+ * Test if node->active_ios list is empty while holding the node->active_ios_lock.
+ *
+ * @param node pointer to node object
+ *
+ * @return TRUE if node active ios list is empty
+ */
+
+int
+ocs_node_active_ios_empty(ocs_node_t *node)
+{
+	int empty;
+
+	ocs_lock(&node->active_ios_lock);
+		empty = ocs_list_empty(&node->active_ios);
+	ocs_unlock(&node->active_ios_lock);
+	return empty;
+}
+
+/**
+ * @brief Pause a node
+ *
+ * The node is placed in the __ocs_node_paused state after saving the state
+ * to return to
+ *
+ * @param node Pointer to node object
+ * @param state State to resume to
+ *
+ * @return none
+ */
+
+void
+ocs_node_pause(ocs_node_t *node, ocs_sm_function_t state)
+{
+	node->nodedb_state = state;
+	ocs_node_transition(node, __ocs_node_paused, NULL);
+}
+
+/**
+ * @brief Paused node state
+ *
+ * This state is entered when a state is "paused". When resumed, the node
+ * is transitioned to a previously saved state (node->ndoedb_state)
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return returns NULL
+ */
+
+void *
+__ocs_node_paused(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_node_state_decl();
+
+	node_sm_trace();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+		node_printf(node, "Paused\n");
+		break;
+
+	case OCS_EVT_RESUME: {
+		ocs_sm_function_t pf = node->nodedb_state;
+
+		node->nodedb_state = NULL;
+		ocs_node_transition(node, pf, NULL);
+		break;
+	}
+
+	case OCS_EVT_DOMAIN_ATTACH_OK:
+		break;
+
+	case OCS_EVT_SHUTDOWN:
+		node->req_free = 1;
+		break;
+
+	default:
+		__ocs_node_common(__func__, ctx, evt, arg);
+		break;
+	}
+	return NULL;
+}
+
+/**
+ * @brief Resume a paused state
+ *
+ * Posts a resume event to the paused node.
+ *
+ * @param node Pointer to node object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_node_resume(ocs_node_t *node)
+{
+	ocs_assert(node != NULL, -1);
+
+	ocs_node_post_event(node, OCS_EVT_RESUME, NULL);
+
+	return 0;
+}
+
+/**
+ * @ingroup node_common
+ * @brief Dispatch a ELS frame.
+ *
+ * <h3 class="desc">Description</h3>
+ * An ELS frame is dispatched to the \c node state machine.
+ * RQ Pair mode: this function is always called with a NULL hw
+ * io.
+ *
+ * @param node Node that originated the frame.
+ * @param seq header/payload sequence buffers
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled and RX buffers need
+ * to be returned.
+ */
+
+int32_t
+ocs_node_recv_els_frame(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	struct {
+		uint32_t cmd;
+		ocs_sm_event_t evt;
+		uint32_t payload_size;
+	} els_cmd_list[] = {
+		{FC_ELS_CMD_PLOGI,	OCS_EVT_PLOGI_RCVD, 	sizeof(fc_plogi_payload_t)},
+		{FC_ELS_CMD_FLOGI,	OCS_EVT_FLOGI_RCVD, 	sizeof(fc_plogi_payload_t)},
+		{FC_ELS_CMD_LOGO,	OCS_EVT_LOGO_RCVD, 	sizeof(fc_acc_payload_t)},
+		{FC_ELS_CMD_RRQ,	OCS_EVT_RRQ_RCVD, 	sizeof(fc_acc_payload_t)},
+		{FC_ELS_CMD_PRLI, 	OCS_EVT_PRLI_RCVD, 	sizeof(fc_prli_payload_t)},
+		{FC_ELS_CMD_PRLO, 	OCS_EVT_PRLO_RCVD, 	sizeof(fc_prlo_payload_t)},
+		{FC_ELS_CMD_PDISC, 	OCS_EVT_PDISC_RCVD, 	MAX_ACC_REJECT_PAYLOAD},
+		{FC_ELS_CMD_FDISC, 	OCS_EVT_FDISC_RCVD, 	MAX_ACC_REJECT_PAYLOAD},
+		{FC_ELS_CMD_ADISC, 	OCS_EVT_ADISC_RCVD, 	sizeof(fc_adisc_payload_t)},
+		{FC_ELS_CMD_RSCN, 	OCS_EVT_RSCN_RCVD, 	MAX_ACC_REJECT_PAYLOAD},
+		{FC_ELS_CMD_SCR	, 	OCS_EVT_SCR_RCVD, 	MAX_ACC_REJECT_PAYLOAD},
+	};
+	ocs_t *ocs = node->ocs;
+	ocs_node_cb_t cbdata;
+	fc_header_t *hdr = seq->header->dma.virt;
+	uint8_t *buf = seq->payload->dma.virt;
+	ocs_sm_event_t evt = OCS_EVT_ELS_RCVD;
+	uint32_t payload_size = MAX_ACC_REJECT_PAYLOAD;
+	uint32_t i;
+
+	ocs_memset(&cbdata, 0, sizeof(cbdata));
+	cbdata.header = seq->header;
+	cbdata.payload = seq->payload;
+
+	/* find a matching event for the ELS command */
+	for (i = 0; i < ARRAY_SIZE(els_cmd_list); i ++) {
+		if (els_cmd_list[i].cmd == buf[0]) {
+			evt = els_cmd_list[i].evt;
+			payload_size = els_cmd_list[i].payload_size;
+			break;
+		}
+	}
+
+	switch(evt) {
+	case OCS_EVT_FLOGI_RCVD:
+		ocs_display_sparams(node->display_name, "flogi rcvd req", 0, NULL, ((uint8_t*)seq->payload->dma.virt)+4);
+		break;
+	case OCS_EVT_FDISC_RCVD:
+		ocs_display_sparams(node->display_name, "fdisc rcvd req", 0, NULL, ((uint8_t*)seq->payload->dma.virt)+4);
+		break;
+	case OCS_EVT_PLOGI_RCVD:
+		ocs_display_sparams(node->display_name, "plogi rcvd req", 0, NULL, ((uint8_t*)seq->payload->dma.virt)+4);
+		break;
+	default:
+		break;
+	}
+
+	cbdata.io = ocs_els_io_alloc(node, payload_size, OCS_ELS_ROLE_RESPONDER);
+
+	if (cbdata.io != NULL) {
+		cbdata.io->hw_priv = seq->hw_priv;
+		/* if we're here, sequence initiative has been transferred */
+		cbdata.io->seq_init = 1;
+
+		ocs_node_post_event(node, evt, &cbdata);
+	} else {
+		node_printf(node, "failure to allocate SCSI IO for ELS s_id %06x d_id %06x ox_id %04x rx_id %04x\n",
+			    fc_be24toh(hdr->s_id), fc_be24toh(hdr->d_id), ocs_be16toh(hdr->ox_id), ocs_be16toh(hdr->rx_id));
+	}
+	ocs_hw_sequence_free(&ocs->hw, seq);
+	return 0;
+}
+
+/**
+ * @ingroup node_common
+ * @brief Dispatch a ABTS frame (RQ Pair/sequence coalescing).
+ *
+ * <h3 class="desc">Description</h3>
+ * An ABTS frame is dispatched to the node state machine. This
+ * function is used for both RQ Pair and sequence coalescing.
+ *
+ * @param node Node that originated the frame.
+ * @param seq Header/payload sequence buffers
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled and RX buffers need
+ * to be returned.
+ */
+
+int32_t
+ocs_node_recv_abts_frame(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	ocs_t *ocs = node->ocs;
+	ocs_xport_t *xport = ocs->xport;
+	fc_header_t *hdr = seq->header->dma.virt;
+	uint16_t ox_id = ocs_be16toh(hdr->ox_id);
+	uint16_t rx_id = ocs_be16toh(hdr->rx_id);
+	ocs_node_cb_t cbdata;
+	int32_t rc = 0;
+
+	node->abort_cnt++;
+
+	/*
+	 * Check to see if the IO we want to abort is active, if it not active,
+	 * then we can send the BA_ACC using the send frame option
+	 */
+	if (ocs_io_find_tgt_io(ocs, node, ox_id, rx_id) == NULL) {
+		uint32_t send_frame_capable;
+
+		ocs_log_debug(ocs, "IO not found (ox_id %04x)\n", ox_id);
+
+		/* If we have SEND_FRAME capability, then use it to send BA_ACC */
+		rc = ocs_hw_get(&ocs->hw, OCS_HW_SEND_FRAME_CAPABLE, &send_frame_capable);
+		if ((rc == 0) && send_frame_capable) {
+			rc = ocs_sframe_send_bls_acc(node, seq);
+			if (rc) {
+				ocs_log_test(ocs, "ocs_bls_acc_send_frame failed\n");
+			}
+			return rc;
+		}
+		/* continuing */
+	}
+
+	ocs_memset(&cbdata, 0, sizeof(cbdata));
+	cbdata.header = seq->header;
+	cbdata.payload = seq->payload;
+
+	cbdata.io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_RESPONDER);
+	if (cbdata.io != NULL) {
+		cbdata.io->hw_priv = seq->hw_priv;
+		/* If we got this far, SIT=1 */
+		cbdata.io->seq_init = 1;
+
+		/* fill out generic fields */
+		cbdata.io->ocs = ocs;
+		cbdata.io->node = node;
+		cbdata.io->cmd_tgt = TRUE;
+
+		ocs_node_post_event(node, OCS_EVT_ABTS_RCVD, &cbdata);
+	} else {
+		ocs_atomic_add_return(&xport->io_alloc_failed_count, 1);
+		node_printf(node, "SCSI IO allocation failed for ABTS received s_id %06x d_id %06x ox_id %04x rx_id %04x\n",
+			    fc_be24toh(hdr->s_id), fc_be24toh(hdr->d_id), ocs_be16toh(hdr->ox_id), ocs_be16toh(hdr->rx_id));
+	}
+
+	/* ABTS processed, return RX buffer to the chip */
+	ocs_hw_sequence_free(&ocs->hw, seq);
+	return 0;
+}
+
+/**
+ * @ingroup node_common
+ * @brief Dispatch a CT frame.
+ *
+ * <h3 class="desc">Description</h3>
+ * A CT frame is dispatched to the \c node state machine.
+ * RQ Pair mode: this function is always called with a NULL hw
+ * io.
+ *
+ * @param node Node that originated the frame.
+ * @param seq header/payload sequence buffers
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled and RX buffers need
+ * to be returned.
+ */
+
+int32_t
+ocs_node_recv_ct_frame(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	ocs_t *ocs = node->ocs;
+	fc_header_t *hdr = seq->header->dma.virt;
+	fcct_iu_header_t *iu = seq->payload->dma.virt;
+	ocs_sm_event_t evt = OCS_EVT_ELS_RCVD;
+	uint32_t payload_size = MAX_ACC_REJECT_PAYLOAD;
+	uint16_t gscmd = ocs_be16toh(iu->cmd_rsp_code);
+	ocs_node_cb_t cbdata;
+	uint32_t i;
+	struct {
+		uint32_t cmd;
+		ocs_sm_event_t evt;
+		uint32_t payload_size;
+	} ct_cmd_list[] = {
+		{FC_GS_NAMESERVER_RFF_ID, OCS_EVT_RFF_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_RFT_ID, OCS_EVT_RFT_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_GNN_ID, OCS_EVT_GNN_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_GPN_ID, OCS_EVT_GPN_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_GFPN_ID, OCS_EVT_GFPN_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_GFF_ID, OCS_EVT_GFF_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_GID_FT, OCS_EVT_GID_FT_RCVD, 256},
+		{FC_GS_NAMESERVER_GID_PT, OCS_EVT_GID_PT_RCVD, 256},
+		{FC_GS_NAMESERVER_RPN_ID, OCS_EVT_RPN_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_RNN_ID, OCS_EVT_RNN_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_RCS_ID, OCS_EVT_RCS_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_RSNN_NN, OCS_EVT_RSNN_NN_RCVD, 100},
+		{FC_GS_NAMESERVER_RSPN_ID, OCS_EVT_RSPN_ID_RCVD, 100},
+		{FC_GS_NAMESERVER_RHBA, OCS_EVT_RHBA_RCVD, 100},
+		{FC_GS_NAMESERVER_RPA, OCS_EVT_RPA_RCVD, 100},
+	};
+
+	ocs_memset(&cbdata, 0, sizeof(cbdata));
+	cbdata.header = seq->header;
+	cbdata.payload = seq->payload;
+
+	/* find a matching event for the ELS/GS command */
+	for (i = 0; i < ARRAY_SIZE(ct_cmd_list); i ++) {
+		if (ct_cmd_list[i].cmd == gscmd) {
+			evt = ct_cmd_list[i].evt;
+			payload_size = ct_cmd_list[i].payload_size;
+			break;
+		}
+	}
+
+	/* Allocate an IO and send a reject */
+	cbdata.io = ocs_els_io_alloc(node, payload_size, OCS_ELS_ROLE_RESPONDER);
+	if (cbdata.io == NULL) {
+		node_printf(node, "GS IO failed for s_id %06x d_id %06x ox_id %04x rx_id %04x\n",
+			fc_be24toh(hdr->s_id), fc_be24toh(hdr->d_id),
+			ocs_be16toh(hdr->ox_id), ocs_be16toh(hdr->rx_id));
+		return -1;
+	}
+	cbdata.io->hw_priv = seq->hw_priv;
+	ocs_node_post_event(node, evt, &cbdata);
+
+	ocs_hw_sequence_free(&ocs->hw, seq);
+	return 0;
+}
+
+/**
+ * @ingroup node_common
+ * @brief Dispatch a FCP command frame when the node is not ready.
+ *
+ * <h3 class="desc">Description</h3>
+ * A frame is dispatched to the \c node state machine.
+ *
+ * @param node Node that originated the frame.
+ * @param seq header/payload sequence buffers
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled.
+ */
+
+int32_t
+ocs_node_recv_fcp_cmd(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	ocs_node_cb_t cbdata;
+	ocs_t *ocs = node->ocs;
+
+	ocs_memset(&cbdata, 0, sizeof(cbdata));
+	cbdata.header = seq->header;
+	cbdata.payload = seq->payload;
+	ocs_node_post_event(node, OCS_EVT_FCP_CMD_RCVD, &cbdata);
+	ocs_hw_sequence_free(&ocs->hw, seq);
+	return 0;
+}
+
+/**
+ * @ingroup node_common
+ * @brief Stub handler for non-ABTS BLS frames
+ *
+ * <h3 class="desc">Description</h3>
+ * Log message and drop. Customer can plumb it to their back-end as needed
+ *
+ * @param node Node that originated the frame.
+ * @param seq header/payload sequence buffers
+ *
+ * @return Returns 0
+ */
+
+int32_t
+ocs_node_recv_bls_no_sit(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	fc_header_t *hdr = seq->header->dma.virt;
+
+	node_printf(node, "Dropping frame hdr = %08x %08x %08x %08x %08x %08x\n",
+		    ocs_htobe32(((uint32_t *)hdr)[0]),
+		    ocs_htobe32(((uint32_t *)hdr)[1]),
+		    ocs_htobe32(((uint32_t *)hdr)[2]),
+		    ocs_htobe32(((uint32_t *)hdr)[3]),
+		    ocs_htobe32(((uint32_t *)hdr)[4]),
+		    ocs_htobe32(((uint32_t *)hdr)[5]));
+
+	return -1;
+}
diff --git a/sys/dev/ocs_fc/ocs_node.h b/sys/dev/ocs_fc/ocs_node.h
new file mode 100644
index 000000000000..d173c763bfd3
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_node.h
@@ -0,0 +1,240 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS linux driver remote node callback declarations
+ */
+
+#if !defined(__OCS_NODE_H__)
+#define __OCS_NODE_H__
+
+
+#define node_sm_trace()  \
+	do { \
+		if (OCS_LOG_ENABLE_SM_TRACE(node->ocs)) \
+			ocs_log_info(node->ocs, "[%s] %-20s\n", node->display_name, ocs_sm_event_name(evt)); \
+	} while (0)
+
+#define node_printf(node, fmt, ...) ocs_log_debug(node->ocs, "[%s] " fmt, node->display_name, ##__VA_ARGS__)
+
+#define std_node_state_decl(...) \
+	ocs_node_t *node = NULL; \
+	ocs_t *ocs = NULL; \
+	node = ctx->app; \
+	ocs_assert(node, NULL); \
+	ocs = node->ocs; \
+	ocs_assert(ocs, NULL); \
+	if (evt == OCS_EVT_ENTER) { \
+		ocs_strncpy(node->current_state_name, __func__, sizeof(node->current_state_name)); \
+	} else if (evt == OCS_EVT_EXIT) { \
+		ocs_strncpy(node->prev_state_name, node->current_state_name, sizeof(node->prev_state_name)); \
+		ocs_strncpy(node->current_state_name, "invalid", sizeof(node->current_state_name)); \
+	} \
+	node->prev_evt = node->current_evt; \
+	node->current_evt = evt;
+
+#define OCS_NODEDB_PAUSE_FABRIC_LOGIN		(1U << 0)
+#define OCS_NODEDB_PAUSE_NAMESERVER		(1U << 1)
+#define OCS_NODEDB_PAUSE_NEW_NODES		(1U << 2)
+
+/**
+ * @brief Node SM IO Context Callback structure
+ *
+ * Structure used as callback argument
+ */
+
+struct ocs_node_cb_s {
+	ocs_io_t *io;			/**< SCSI IO for sending response */
+	int32_t status;			/**< completion status */
+	int32_t ext_status;		/**< extended completion status */
+	ocs_hw_rq_buffer_t *header;	/**< completion header buffer */
+	ocs_hw_rq_buffer_t *payload;	/**< completion payload buffers */
+	ocs_io_t *els;			/**< ELS IO object */
+};
+
+/**
+ * @brief hold frames in pending frame list
+ *
+ * Unsolicited receive frames are held on the node pending frame list, rather than
+ * being processed.
+ *
+ * @param node pointer to node structure
+ *
+ * @return none
+ */
+
+static inline void
+ocs_node_hold_frames(ocs_node_t *node)
+{
+	ocs_assert(node);
+	node->hold_frames = TRUE;
+}
+
+/**
+ * @brief accept frames
+ *
+ * Unsolicited receive frames processed rather than being held on the node
+ * pending frame list.
+ *
+ * @param node pointer to node structure
+ *
+ * @return none
+ */
+
+static inline void
+ocs_node_accept_frames(ocs_node_t *node)
+{
+	ocs_assert(node);
+	node->hold_frames = FALSE;
+}
+
+extern int32_t ocs_node_create_pool(ocs_t *ocs, uint32_t node_count);
+extern void ocs_node_free_pool(ocs_t *ocs);
+extern ocs_node_t *ocs_node_get_instance(ocs_t *ocs, uint32_t index);
+
+static inline void
+ocs_node_lock_init(ocs_node_t *node)
+{
+	ocs_rlock_init(node->ocs, &node->lock, "node rlock");
+}
+
+static inline void
+ocs_node_lock_free(ocs_node_t *node)
+{
+	ocs_rlock_free(&node->lock);
+}
+
+static inline int32_t
+ocs_node_lock_try(ocs_node_t *node)
+{
+	return ocs_rlock_try(&node->lock);
+}
+
+static inline void
+ocs_node_lock(ocs_node_t *node)
+{
+	ocs_rlock_acquire(&node->lock);
+}
+static inline void
+ocs_node_unlock(ocs_node_t *node)
+{
+	ocs_rlock_release(&node->lock);
+}
+
+/**
+ * @brief Node initiator/target enable defines
+ *
+ * All combinations of the SLI port (sport) initiator/target enable, and remote
+ * node initiator/target enable are enumerated.
+ *
+ */
+
+typedef enum {
+	OCS_NODE_ENABLE_x_TO_x,
+	OCS_NODE_ENABLE_x_TO_T,
+	OCS_NODE_ENABLE_x_TO_I,
+	OCS_NODE_ENABLE_x_TO_IT,
+	OCS_NODE_ENABLE_T_TO_x,
+	OCS_NODE_ENABLE_T_TO_T,
+	OCS_NODE_ENABLE_T_TO_I,
+	OCS_NODE_ENABLE_T_TO_IT,
+	OCS_NODE_ENABLE_I_TO_x,
+	OCS_NODE_ENABLE_I_TO_T,
+	OCS_NODE_ENABLE_I_TO_I,
+	OCS_NODE_ENABLE_I_TO_IT,
+	OCS_NODE_ENABLE_IT_TO_x,
+	OCS_NODE_ENABLE_IT_TO_T,
+	OCS_NODE_ENABLE_IT_TO_I,
+	OCS_NODE_ENABLE_IT_TO_IT,
+} ocs_node_enable_e;
+
+static inline ocs_node_enable_e ocs_node_get_enable(ocs_node_t *node)
+{
+	uint32_t retval = 0;
+
+	if (node->sport->enable_ini) retval |= (1U << 3);
+	if (node->sport->enable_tgt) retval |= (1U << 2);
+	if (node->init) retval |= (1U << 1);
+	if (node->targ) retval |= (1U << 0);
+	return (ocs_node_enable_e) retval;
+}
+
+typedef void* (*ocs_node_common_func_t)(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern int32_t node_check_els_req(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg, uint8_t cmd, ocs_node_common_func_t node_common_func, const char *funcname);
+extern int32_t node_check_ns_req(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg, uint32_t cmd, ocs_node_common_func_t node_common_func, const char *funcname);
+extern int32_t ocs_remote_node_cb(void *arg, ocs_hw_remote_node_event_e event, void *data);
+extern int32_t ocs_node_attach(ocs_node_t *node);
+extern ocs_node_t *ocs_node_find(ocs_sport_t *sport, uint32_t port_id);
+extern ocs_node_t *ocs_node_find_wwpn(ocs_sport_t *sport, uint64_t wwpn);
+extern void ocs_node_dump(ocs_t *ocs);
+extern ocs_node_t *ocs_node_alloc(ocs_sport_t *sport, uint32_t port_id, uint8_t init, uint8_t targ);
+extern int32_t ocs_node_free(ocs_node_t *node);
+extern void ocs_node_force_free(ocs_node_t *node);
+extern void ocs_node_fcid_display(uint32_t fc_id, char *buffer, uint32_t buffer_length);
+extern void ocs_node_update_display_name(ocs_node_t *node);
+
+extern void *__ocs_node_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void * __ocs_node_wait_node_free(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_node_wait_els_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_node_wait_ios_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void ocs_node_save_sparms(ocs_node_t *node, void *payload);
+extern void ocs_node_post_event(ocs_node_t *node, ocs_sm_event_t evt, void *arg);
+extern void ocs_node_transition(ocs_node_t *node, ocs_sm_function_t state, void *data);
+extern void *__ocs_node_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+
+extern void ocs_node_initiate_cleanup(ocs_node_t *node);
+extern int ocs_ddump_node(ocs_textbuf_t *textbuf, ocs_node_t *node);
+
+extern void ocs_node_build_eui_name(char *buffer, uint32_t buffer_len, uint64_t eui_name);
+extern uint64_t ocs_node_get_wwpn(ocs_node_t *node);
+extern uint64_t ocs_node_get_wwnn(ocs_node_t *node);
+extern void ocs_node_abort_all_els(ocs_node_t *node);
+
+extern void ocs_node_pause(ocs_node_t *node, ocs_sm_function_t state);
+extern int32_t ocs_node_resume(ocs_node_t *node);
+extern void *__ocs_node_paused(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern int ocs_node_active_ios_empty(ocs_node_t *node);
+extern void ocs_node_send_ls_io_cleanup(ocs_node_t *node);
+
+extern int32_t ocs_node_recv_link_services_frame(ocs_node_t *node, ocs_hw_sequence_t *seq);
+extern int32_t ocs_node_recv_abts_frame(ocs_node_t *node, ocs_hw_sequence_t *seq);
+extern int32_t ocs_node_recv_els_frame(ocs_node_t *node, ocs_hw_sequence_t *seq);
+extern int32_t ocs_node_recv_ct_frame(ocs_node_t *node, ocs_hw_sequence_t *seq);
+extern int32_t ocs_node_recv_fcp_cmd(ocs_node_t *node, ocs_hw_sequence_t *seq);
+extern int32_t ocs_node_recv_bls_no_sit(ocs_node_t *node, ocs_hw_sequence_t *seq);
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_os.c b/sys/dev/ocs_fc/ocs_os.c
new file mode 100644
index 000000000000..9e9045edd215
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_os.c
@@ -0,0 +1,1046 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Implementation of common BSD OS abstraction functions
+ */
+
+#include "ocs.h"
+#include <sys/sysctl.h>
+#include <sys/malloc.h>
+#include <sys/linker.h>		/* for debug of memory allocations */
+
+static MALLOC_DEFINE(M_OCS, "OCS", "OneCore Storage data");
+
+#include <dev/pci/pcireg.h>
+#include <dev/pci/pcivar.h>
+
+#include <machine/bus.h>
+
+timeout_t	__ocs_callout;
+
+uint32_t
+ocs_config_read32(ocs_os_handle_t os, uint32_t reg)
+{
+	return pci_read_config(os->dev, reg, 4);
+}
+
+uint16_t
+ocs_config_read16(ocs_os_handle_t os, uint32_t reg)
+{
+	return pci_read_config(os->dev, reg, 2);
+}
+
+uint8_t
+ocs_config_read8(ocs_os_handle_t os, uint32_t reg)
+{
+	return pci_read_config(os->dev, reg, 1);
+}
+
+void
+ocs_config_write8(ocs_os_handle_t os, uint32_t reg, uint8_t val)
+{
+	return pci_write_config(os->dev, reg, val, 1);
+}
+
+void
+ocs_config_write16(ocs_os_handle_t os, uint32_t reg, uint16_t val)
+{
+	return pci_write_config(os->dev, reg, val, 2);
+}
+
+void
+ocs_config_write32(ocs_os_handle_t os, uint32_t reg, uint32_t val)
+{
+	return pci_write_config(os->dev, reg, val, 4);
+}
+
+/**
+ * @ingroup os
+ * @brief Read a 32bit PCI register
+ *
+ * The SLI documentation uses the term "register set" to describe one or more
+ * PCI BARs which form a logical address. For example, a 64-bit address uses
+ * two BARs, and thus constitute a register set.
+ *
+ * @param ocs Pointer to the driver's context
+ * @param rset Register Set to use
+ * @param off Offset from the base address of the Register Set
+ *
+ * @return register value
+ */
+uint32_t
+ocs_reg_read32(ocs_t *ocs, uint32_t rset, uint32_t off)
+{
+	ocs_pci_reg_t		*reg = NULL;
+
+	reg = &ocs->reg[rset];
+
+	return bus_space_read_4(reg->btag, reg->bhandle, off);
+}
+
+/**
+ * @ingroup os
+ * @brief Read a 16bit PCI register
+ *
+ * The SLI documentation uses the term "register set" to describe one or more
+ * PCI BARs which form a logical address. For example, a 64-bit address uses
+ * two BARs, and thus constitute a register set.
+ *
+ * @param ocs Pointer to the driver's context
+ * @param rset Register Set to use
+ * @param off Offset from the base address of the Register Set
+ *
+ * @return register value
+ */
+uint16_t
+ocs_reg_read16(ocs_t *ocs, uint32_t rset, uint32_t off)
+{
+	ocs_pci_reg_t		*reg = NULL;
+
+	reg = &ocs->reg[rset];
+
+	return bus_space_read_2(reg->btag, reg->bhandle, off);
+}
+
+/**
+ * @ingroup os
+ * @brief Read a 8bit PCI register
+ *
+ * The SLI documentation uses the term "register set" to describe one or more
+ * PCI BARs which form a logical address. For example, a 64-bit address uses
+ * two BARs, and thus constitute a register set.
+ *
+ * @param ocs Pointer to the driver's context
+ * @param rset Register Set to use
+ * @param off Offset from the base address of the Register Set
+ *
+ * @return register value
+ */
+uint8_t
+ocs_reg_read8(ocs_t *ocs, uint32_t rset, uint32_t off)
+{
+	ocs_pci_reg_t		*reg = NULL;
+
+	reg = &ocs->reg[rset];
+
+	return bus_space_read_1(reg->btag, reg->bhandle, off);
+}
+
+/**
+ * @ingroup os
+ * @brief Write a 32bit PCI register
+ *
+ * The SLI documentation uses the term "register set" to describe one or more
+ * PCI BARs which form a logical address. For example, a 64-bit address uses
+ * two BARs, and thus constitute a register set.
+ *
+ * @param ocs Pointer to the driver's context
+ * @param rset Register Set to use
+ * @param off Offset from the base address of the Register Set
+ * @param val Value to write
+ *
+ * @return none
+ */
+void
+ocs_reg_write32(ocs_t *ocs, uint32_t rset, uint32_t off, uint32_t val)
+{
+	ocs_pci_reg_t		*reg = NULL;
+
+	reg = &ocs->reg[rset];
+
+	return bus_space_write_4(reg->btag, reg->bhandle, off, val);
+}
+
+/**
+ * @ingroup os
+ * @brief Write a 16-bit PCI register
+ *
+ * The SLI documentation uses the term "register set" to describe one or more
+ * PCI BARs which form a logical address. For example, a 64-bit address uses
+ * two BARs, and thus constitute a register set.
+ *
+ * @param ocs Pointer to the driver's context
+ * @param rset Register Set to use
+ * @param off Offset from the base address of the Register Set
+ * @param val Value to write
+ *
+ * @return none
+ */
+void
+ocs_reg_write16(ocs_t *ocs, uint32_t rset, uint32_t off, uint16_t val)
+{
+	ocs_pci_reg_t		*reg = NULL;
+
+	reg = &ocs->reg[rset];
+
+	return bus_space_write_2(reg->btag, reg->bhandle, off, val);
+}
+
+/**
+ * @ingroup os
+ * @brief Write a 8-bit PCI register
+ *
+ * The SLI documentation uses the term "register set" to describe one or more
+ * PCI BARs which form a logical address. For example, a 64-bit address uses
+ * two BARs, and thus constitute a register set.
+ *
+ * @param ocs Pointer to the driver's context
+ * @param rset Register Set to use
+ * @param off Offset from the base address of the Register Set
+ * @param val Value to write
+ *
+ * @return none
+ */
+void
+ocs_reg_write8(ocs_t *ocs, uint32_t rset, uint32_t off, uint8_t val)
+{
+	ocs_pci_reg_t		*reg = NULL;
+
+	reg = &ocs->reg[rset];
+
+	return bus_space_write_1(reg->btag, reg->bhandle, off, val);
+}
+
+/**
+ * @ingroup os
+ * @brief Allocate host memory
+ *
+ * @param os OS handle
+ * @param size number of bytes to allocate
+ * @param flags additional options
+ *
+ * @return pointer to allocated memory, NULL otherwise
+ */
+void *
+ocs_malloc(ocs_os_handle_t os, size_t size, int32_t flags)
+{
+	if ((flags & OCS_M_NOWAIT) == 0) {
+		flags |= M_WAITOK;
+	}
+
+#ifndef OCS_DEBUG_MEMORY
+	return malloc(size, M_OCS, flags);
+#else
+	char nameb[80];
+	long offset = 0;
+	void *addr = malloc(size, M_OCS, flags);
+
+	linker_ddb_search_symbol_name(__builtin_return_address(1), nameb, sizeof(nameb), &offset);
+	printf("A: %p %ld @ %s+%#lx\n", addr, size, nameb, offset);
+
+	return addr;
+#endif
+}
+
+/**
+ * @ingroup os
+ * @brief Free host memory
+ *
+ * @param os OS handle
+ * @param addr pointer to memory
+ * @param size bytes to free
+ *
+ * @note size ignored in BSD
+ */
+void
+ocs_free(ocs_os_handle_t os, void *addr, size_t size)
+{
+#ifndef OCS_DEBUG_MEMORY
+	free(addr, M_OCS);
+#else
+	printf("F: %p %ld\n", addr, size);
+	free(addr, M_OCS);
+#endif
+}
+
+/**
+ * @brief Callback function provided to bus_dmamap_load
+ *
+ * Function loads the physical / bus address into the DMA descriptor. The caller
+ * can detect a mapping failure if a descriptor's phys element is zero.
+ *
+ * @param arg Argument provided to bus_dmamap_load is a ocs_dma_t
+ * @param seg Array of DMA segment(s), each describing segment's address and length
+ * @param nseg Number of elements in array
+ * @param error Indicates success (0) or failure of mapping
+ */
+static void
+ocs_dma_load(void *arg, bus_dma_segment_t *seg, int nseg, int error)
+{
+	ocs_dma_t	*dma = arg;
+
+	if (error) {
+		printf("%s: error=%d\n", __func__, error);
+		dma->phys = 0;
+	} else {
+		dma->phys = seg->ds_addr;
+	}
+}
+
+/**
+ * @ingroup os
+ * @brief Free a DMA capable block of memory
+ *
+ * @param os Device abstraction
+ * @param dma DMA descriptor for memory to be freed
+ *
+ * @return 0 if memory is de-allocated, -1 otherwise
+ */
+int32_t
+ocs_dma_free(ocs_os_handle_t os, ocs_dma_t *dma)
+{
+	struct ocs_softc	*ocs = os;
+
+	if (!dma) {
+		device_printf(ocs->dev, "%s: bad parameter(s) dma=%p\n", __func__, dma);
+		return -1;
+	}
+
+	if (dma->size == 0) {
+		return 0;
+	}
+
+	if (dma->map) {
+		bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_POSTREAD |
+				BUS_DMASYNC_POSTWRITE);
+		bus_dmamap_unload(dma->tag, dma->map);
+	}
+
+	if (dma->virt) {
+		bus_dmamem_free(dma->tag, dma->virt, dma->map);
+		bus_dmamap_destroy(dma->tag, dma->map);
+	}
+	bus_dma_tag_destroy(dma->tag);
+
+	bzero(dma, sizeof(ocs_dma_t));
+
+	return 0;
+}
+
+/**
+ * @ingroup os
+ * @brief Allocate a DMA capable block of memory
+ *
+ * @param os Device abstraction
+ * @param dma DMA descriptor containing results of memory allocation
+ * @param size Size in bytes of desired allocation
+ * @param align Alignment in bytes
+ *
+ * @return 0 on success, ENOMEM otherwise
+ */
+int32_t
+ocs_dma_alloc(ocs_os_handle_t os, ocs_dma_t *dma, size_t size, size_t align)
+{
+	struct ocs_softc	*ocs = os;
+
+	if (!dma || !size) {
+		device_printf(ocs->dev, "%s bad parameter(s) dma=%p size=%zd\n",
+				__func__, dma, size);
+		return ENOMEM;
+	}
+
+	bzero(dma, sizeof(ocs_dma_t));
+
+	/* create a "tag" that describes the desired memory allocation */
+	if (bus_dma_tag_create(ocs->dmat, align, 0, BUS_SPACE_MAXADDR,
+				BUS_SPACE_MAXADDR, NULL, NULL,
+				size, 1, size, 0, NULL, NULL, &dma->tag)) {
+		device_printf(ocs->dev, "DMA tag allocation failed\n");
+		return ENOMEM;
+	}
+
+	dma->size = size;
+
+	/* allocate the memory */
+	if (bus_dmamem_alloc(dma->tag, &dma->virt, BUS_DMA_NOWAIT | BUS_DMA_COHERENT,
+				&dma->map)) {
+		device_printf(ocs->dev, "DMA memory allocation failed s=%zd a=%zd\n", size, align);
+		ocs_dma_free(ocs, dma);
+		return ENOMEM;
+	}
+
+	dma->alloc = dma->virt;
+
+	/* map virtual address to device visible address */
+	if (bus_dmamap_load(dma->tag, dma->map, dma->virt, dma->size, ocs_dma_load,
+				dma, 0)) {
+		device_printf(ocs->dev, "DMA memory load failed\n");
+		ocs_dma_free(ocs, dma);
+		return ENOMEM;
+	}
+
+	/* if the DMA map load callback fails, it sets the physical address to zero */
+	if (0 == dma->phys) {
+		device_printf(ocs->dev, "ocs_dma_load failed\n");
+		ocs_dma_free(ocs, dma);
+		return ENOMEM;
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup os
+ * @brief Synchronize the DMA buffer memory
+ *
+ * Ensures memory coherency between the CPU and device
+ *
+ * @param dma DMA descriptor of memory to synchronize
+ * @param flags Describes direction of synchronization
+ *   See BUS_DMA(9) for details
+ *   - BUS_DMASYNC_PREWRITE
+ *   - BUS_DMASYNC_POSTREAD
+ */
+void
+ocs_dma_sync(ocs_dma_t *dma, uint32_t flags)
+{
+	bus_dmamap_sync(dma->tag, dma->map, flags);
+}
+
+int32_t
+ocs_dma_copy_in(ocs_dma_t *dma, void *buffer, uint32_t buffer_length)
+{
+	if (!dma)
+		return -1;
+	if (!buffer)
+		return -1;
+	if (buffer_length == 0)
+		return 0;
+	if (buffer_length > dma->size)
+		buffer_length = dma->size;
+	ocs_memcpy(dma->virt, buffer, buffer_length);
+	dma->len = buffer_length;
+	return buffer_length;
+}
+
+int32_t
+ocs_dma_copy_out(ocs_dma_t *dma, void *buffer, uint32_t buffer_length)
+{
+	if (!dma)
+		return -1;
+	if (!buffer)
+		return -1;
+	if (buffer_length == 0)
+		return 0;
+	if (buffer_length > dma->len)
+		buffer_length = dma->len;
+	ocs_memcpy(buffer, dma->virt, buffer_length);
+	return buffer_length;
+}
+
+/**
+ * @ingroup os
+ * @brief Initialize a lock
+ *
+ * @param lock lock to initialize
+ * @param name string identifier for the lock
+ */
+void
+ocs_lock_init(void *os, ocs_lock_t *lock, const char *name, ...)
+{
+	va_list ap;
+
+	va_start(ap, name);
+	ocs_vsnprintf(lock->name, MAX_LOCK_DESC_LEN, name, ap);
+	va_end(ap);
+
+	mtx_init(&lock->lock, lock->name, NULL, MTX_DEF);
+}
+
+/**
+ * @brief Allocate a bit map
+ *
+ * For BSD, this is a simple character string
+ *
+ * @param n_bits number of bits in bit map
+ *
+ * @return pointer to the bit map, NULL on error
+ */
+ocs_bitmap_t *
+ocs_bitmap_alloc(uint32_t n_bits)
+{
+
+	return malloc(bitstr_size(n_bits), M_OCS, M_ZERO | M_NOWAIT);
+}
+
+/**
+ * @brief Free a bit map
+ *
+ * @param bitmap pointer to previously allocated bit map
+ */
+void
+ocs_bitmap_free(ocs_bitmap_t *bitmap)
+{
+
+	free(bitmap, M_OCS);
+}
+
+/**
+ * @brief find next unset bit and set it
+ *
+ * @param bitmap bit map to search
+ * @param n_bits number of bits in map
+ *
+ * @return bit position or -1 if map is full
+ */
+int32_t
+ocs_bitmap_find(ocs_bitmap_t *bitmap, uint32_t n_bits)
+{
+	int32_t		position = -1;
+
+	bit_ffc(bitmap, n_bits, &position);
+
+	if (-1 != position) {
+		bit_set(bitmap, position);
+	}
+
+	return position;
+}
+
+/**
+ * @brief search for next (un)set bit
+ *
+ * @param bitmap bit map to search
+ * @param set search for a set or unset bit
+ * @param n_bits number of bits in map
+ *
+ * @return bit position or -1
+ */
+int32_t
+ocs_bitmap_search(ocs_bitmap_t *bitmap, uint8_t set, uint32_t n_bits)
+{
+	int32_t		position;
+
+	if (!bitmap) {
+		return -1;
+	}
+
+	if (set) {
+		bit_ffs(bitmap, n_bits, &position);
+	} else {
+		bit_ffc(bitmap, n_bits, &position);
+	}
+
+	return position;
+}
+
+/**
+ * @brief clear the specified bit
+ *
+ * @param bitmap pointer to bit map
+ * @param bit bit number to clear
+ */
+void
+ocs_bitmap_clear(ocs_bitmap_t *bitmap, uint32_t bit)
+{
+	bit_clear(bitmap, bit);
+}
+
+void _ocs_log(ocs_t *ocs, const char *func_name, int line, const char *fmt, ...)
+{
+	va_list ap;
+	char buf[256];
+	char *p = buf;
+
+	va_start(ap, fmt);
+
+	/* TODO: Add Current PID info here. */
+
+	p += snprintf(p, sizeof(buf) - (p - buf), "%s: ", DRV_NAME);
+	p += snprintf(p, sizeof(buf) - (p - buf), "%s:", func_name);
+	p += snprintf(p, sizeof(buf) - (p - buf), "%i:", line);
+	p += snprintf(p, sizeof(buf) - (p - buf), "%s:", (ocs != NULL) ? device_get_nameunit(ocs->dev) : "");
+	p += vsnprintf(p, sizeof(buf) - (p - buf), fmt, ap);
+
+	va_end(ap);
+
+	printf("%s", buf);
+}
+
+/**
+ * @brief Common thread call function
+ *
+ * This is the common function called whenever a thread instantiated by ocs_thread_create() is started.
+ * It captures the return value from the actual thread function and stashes it in the thread object, to
+ * be later retrieved by ocs_thread_get_retval(), and calls kthread_exit(), the proscribed method to terminate
+ * a thread.
+ *
+ * @param arg a pointer to the thread object
+ *
+ * @return none
+ */
+
+static void
+ocs_thread_call_fctn(void *arg)
+{
+	ocs_thread_t *thread = arg;
+	thread->retval = (*thread->fctn)(thread->arg);
+	ocs_free(NULL, thread->name, ocs_strlen(thread->name+1));
+	kthread_exit();
+}
+
+/**
+ * @brief Create a kernel thread
+ *
+ * Creates a kernel thread and optionally starts it.   If the thread is not immediately
+ * started, ocs_thread_start() should be called at some later point.
+ *
+ * @param os OS handle
+ * @param thread pointer to thread object
+ * @param fctn function for thread to be begin executing
+ * @param name text name to identify thread
+ * @param arg application specific argument passed to thread function
+ * @param start start option, OCS_THREAD_RUN will start the thread immediately,
+ *			OCS_THREAD_CREATE will create but not start the thread
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_thread_create(ocs_os_handle_t os, ocs_thread_t *thread, ocs_thread_fctn fctn, const char *name, void *arg, ocs_thread_start_e start)
+{
+	int32_t rc = 0;
+
+	ocs_memset(thread, 0, sizeof(thread));
+
+	thread->fctn = fctn;
+	thread->name = ocs_strdup(name);
+	if (thread->name == NULL) {
+		thread->name = "unknown";
+	}
+	thread->arg = arg;
+
+	ocs_atomic_set(&thread->terminate, 0);
+
+	rc = kthread_add(ocs_thread_call_fctn, thread, NULL, &thread->tcb, (start == OCS_THREAD_CREATE) ? RFSTOPPED : 0,
+		OCS_THREAD_DEFAULT_STACK_SIZE_PAGES, "%s", name);
+
+	return rc;
+}
+
+/**
+ * @brief Start a thread
+ *
+ * Starts a thread that was created with OCS_THREAD_CREATE rather than OCS_THREAD_RUN
+ *
+ * @param thread pointer to thread object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t ocs_thread_start(ocs_thread_t *thread)
+{
+	sched_add(thread->tcb, SRQ_BORING);
+	return 0;
+}
+
+/**
+ * @brief return thread argument
+ *
+ * Returns a pointer to the thread's application specific argument
+ *
+ * @param mythread pointer to the thread object
+ *
+ * @return pointer to application specific argument
+ */
+
+void *ocs_thread_get_arg(ocs_thread_t *mythread)
+{
+	return mythread->arg;
+}
+
+/**
+ * @brief Request thread stop
+ *
+ * A stop request is made to the thread.  This is a voluntary call, the thread needs
+ * to periodically query its terminate request using ocs_thread_terminate_requested()
+ *
+ * @param thread pointer to thread object
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_thread_terminate(ocs_thread_t *thread)
+{
+	ocs_atomic_set(&thread->terminate, 1);
+	return 0;
+}
+
+/**
+ * @brief See if a terminate request has been made
+ *
+ * Check to see if a stop request has been made to the current thread.  This
+ * function would be used by a thread to see if it should terminate.
+ *
+ * @return returns non-zero if a stop has been requested
+ */
+
+int32_t ocs_thread_terminate_requested(ocs_thread_t *thread)
+{
+	return ocs_atomic_read(&thread->terminate);
+}
+
+/**
+ * @brief Retrieve threads return value
+ *
+ * After a thread has terminated, it's return value may be retrieved with this function.
+ *
+ * @param thread pointer to thread object
+ *
+ * @return return value from thread function
+ */
+
+int32_t
+ocs_thread_get_retval(ocs_thread_t *thread)
+{
+	return thread->retval;
+}
+
+/**
+ * @brief Request that the currently running thread yield
+ *
+ * The currently running thread yields to the scheduler
+ *
+ * @param thread pointer to thread (ignored)
+ *
+ * @return none
+ */
+
+void
+ocs_thread_yield(ocs_thread_t *thread) {
+	pause("thread yield", 1);
+}
+
+ocs_thread_t *
+ocs_thread_self(void)
+{
+	ocs_printf(">>> %s not implemented\n", __func__);
+	ocs_abort();
+}
+
+int32_t
+ocs_thread_setcpu(ocs_thread_t *thread, uint32_t cpu)
+{
+	ocs_printf(">>> %s not implemented\n", __func__);
+	return -1;
+}
+
+int32_t
+ocs_thread_getcpu(void)
+{
+	return curcpu;
+}
+
+int
+ocs_sem_init(ocs_sem_t *sem, int val, const char *name, ...)
+{
+	va_list ap;
+
+	va_start(ap, name);
+	ocs_vsnprintf(sem->name, sizeof(sem->name), name, ap);
+	va_end(ap);
+
+	sema_init(&sem->sem, val, sem->name);
+	return 0;
+}
+
+/**
+ * @ingroup os
+ * @brief  Copy user arguments in to kernel space for an ioctl
+ * @par Description
+ * This function is called at the beginning of an ioctl function
+ * to copy the ioctl argument from user space to kernel space.
+ *
+ * BSD handles this for us - arg is already in kernel space,
+ * so we just return it.
+ *
+ * @param os OS handle
+ * @param arg The argument passed to the ioctl function
+ * @param size The size of the structure pointed to by arg
+ *
+ * @return A pointer to a kernel space copy of the argument on
+ *	success; NULL on failure
+ */
+void *ocs_ioctl_preprocess(ocs_os_handle_t os, void *arg, size_t size)
+{
+	 return arg;
+}
+
+/**
+ * @ingroup os
+ * @brief  Copy results of an ioctl back to user space
+ * @par Description
+ * This function is called at the end of ioctl processing to
+ * copy the argument back to user space.
+ *
+ * BSD handles this for us.
+ *
+ * @param os OS handle
+ * @param arg The argument passed to the ioctl function
+ * @param kern_ptr A pointer to the kernel space copy of the
+ *		   argument
+ * @param size The size of the structure pointed to by arg.
+ *
+ * @return Returns 0.
+ */
+int32_t ocs_ioctl_postprocess(ocs_os_handle_t os, void *arg, void *kern_ptr, size_t size)
+{
+	return 0;
+}
+
+/**
+ * @ingroup os
+ * @brief  Free memory allocated by ocs_ioctl_preprocess
+ * @par Description
+ * This function is called in the event of an error in ioctl
+ * processing.  For operating environments where ocs_ioctlpreprocess
+ * allocates memory, this call frees the memory without copying
+ * results back to user space.
+ *
+ * For BSD, because no memory was allocated in ocs_ioctl_preprocess,
+ * nothing needs to be done here.
+ *
+ * @param os OS handle
+ * @param kern_ptr A pointer to the kernel space copy of the
+ *		   argument
+ * @param size The size of the structure pointed to by arg.
+ *
+ * @return Returns nothing.
+ */
+void ocs_ioctl_free(ocs_os_handle_t os, void *kern_ptr, size_t size)
+{
+	return;
+}
+
+void ocs_intr_disable(ocs_os_handle_t os)
+{
+}
+
+void ocs_intr_enable(ocs_os_handle_t os)
+{
+}
+
+void ocs_print_stack(void)
+{
+	struct stack st;
+
+	stack_zero(&st);
+	stack_save(&st);
+	stack_print(&st);
+}
+
+void ocs_abort(void)
+{
+	panic(">>> abort/panic\n");
+}
+
+const char *
+ocs_pci_model(uint16_t vendor, uint16_t device)
+{
+	switch (device) {
+	case PCI_PRODUCT_EMULEX_OCE16002:	return "OCE16002";
+	case PCI_PRODUCT_EMULEX_OCE1600_VF:	return "OCE1600_VF";
+	case PCI_PRODUCT_EMULEX_OCE50102:	return "OCE50102";
+	case PCI_PRODUCT_EMULEX_OCE50102_VF:	return "OCE50102_VR";
+	default:
+		break;
+	}
+
+	return "unknown";
+}
+
+int32_t
+ocs_get_bus_dev_func(ocs_t *ocs, uint8_t* bus, uint8_t* dev, uint8_t* func)
+{
+	*bus = pci_get_bus(ocs->dev);
+	*dev = pci_get_slot(ocs->dev);
+	*func= pci_get_function(ocs->dev);
+	return 0;
+}
+
+/**
+ * @brief return CPU information
+ *
+ * This function populates the ocs_cpuinfo_t buffer with CPU information
+ *
+ * @param cpuinfo pointer to ocs_cpuinfo_t buffer
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+extern int mp_ncpus;
+int32_t
+ocs_get_cpuinfo(ocs_cpuinfo_t *cpuinfo)
+{
+	cpuinfo->num_cpus = mp_ncpus;
+	return 0;
+}
+
+uint32_t
+ocs_get_num_cpus(void)
+{
+	static ocs_cpuinfo_t cpuinfo;
+
+	if (cpuinfo.num_cpus == 0) {
+		ocs_get_cpuinfo(&cpuinfo);
+	}
+	return cpuinfo.num_cpus;
+}
+
+
+void
+__ocs_callout(void *t)
+{
+	ocs_timer_t *timer = t;
+
+	if (callout_pending(&timer->callout)) {
+		/* Callout was reset */
+		return;
+	}
+
+	if (!callout_active(&timer->callout)) {
+		/* Callout was stopped */
+		return;
+	}
+
+	callout_deactivate(&timer->callout);
+
+	if (timer->func) {
+		timer->func(timer->data);
+	}
+}
+
+int32_t
+ocs_setup_timer(ocs_os_handle_t os, ocs_timer_t *timer, void(*func)(void *arg), void *data, uint32_t timeout_ms)
+{
+	struct	timeval tv;
+	int	hz;
+
+	if (timer == NULL) {
+		ocs_log_err(NULL, "bad parameter\n");
+		return -1;
+	}
+
+	if (!mtx_initialized(&timer->lock)) {
+		mtx_init(&timer->lock, "ocs_timer", NULL, MTX_DEF);
+	}
+
+	callout_init_mtx(&timer->callout, &timer->lock, 0);
+
+	timer->func = func;
+	timer->data = data;
+
+	tv.tv_sec  = timeout_ms / 1000;
+	tv.tv_usec = (timeout_ms % 1000) * 1000;
+
+	hz = tvtohz(&tv);
+	if (hz < 0)
+		hz = INT32_MAX;
+	if (hz == 0)
+		hz = 1;
+
+	mtx_lock(&timer->lock);
+		callout_reset(&timer->callout, hz, __ocs_callout, timer);
+	mtx_unlock(&timer->lock);
+
+	return 0;
+}
+
+int32_t
+ocs_mod_timer(ocs_timer_t *timer, uint32_t timeout_ms)
+{
+	struct	timeval tv;
+	int	hz;
+
+	if (timer == NULL) {
+		ocs_log_err(NULL, "bad parameter\n");
+		return -1;
+	}
+
+	tv.tv_sec  = timeout_ms / 1000;
+	tv.tv_usec = (timeout_ms % 1000) * 1000;
+
+	hz = tvtohz(&tv);
+	if (hz < 0)
+		hz = INT32_MAX;
+	if (hz == 0)
+		hz = 1;
+
+	mtx_lock(&timer->lock);
+		callout_reset(&timer->callout, hz, __ocs_callout, timer);
+	mtx_unlock(&timer->lock);
+
+	return 0;
+}
+
+int32_t
+ocs_timer_pending(ocs_timer_t *timer)
+{
+	return callout_active(&timer->callout);
+}
+
+int32_t
+ocs_del_timer(ocs_timer_t *timer)
+{
+
+	mtx_lock(&timer->lock);
+		callout_stop(&timer->callout);
+	mtx_unlock(&timer->lock);
+
+	return 0;
+}
+
+char *
+ocs_strdup(const char *s)
+{
+	uint32_t l = strlen(s);
+	char *d;
+
+	d = ocs_malloc(NULL, l+1, OCS_M_NOWAIT);
+	if (d != NULL) {
+		ocs_strcpy(d, s);
+	}
+	return d;
+}
+
+void
+_ocs_assert(const char *cond, const char *filename, int linenum)
+{
+	const char *fn = strrchr(__FILE__, '/');
+
+	ocs_log_err(NULL, "%s(%d) assertion (%s) failed\n", (fn ? fn + 1 : filename), linenum, cond);
+	ocs_print_stack();
+	ocs_save_ddump_all(OCS_DDUMP_FLAGS_WQES|OCS_DDUMP_FLAGS_CQES|OCS_DDUMP_FLAGS_MQES, -1, TRUE);
+}
diff --git a/sys/dev/ocs_fc/ocs_os.h b/sys/dev/ocs_fc/ocs_os.h
new file mode 100644
index 000000000000..9c18f46ac1a5
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_os.h
@@ -0,0 +1,1406 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * bsd specific headers common to the driver
+ */
+
+#ifndef _OCS_OS_H
+#define _OCS_OS_H
+
+typedef struct ocs_softc ocs_t;
+
+/***************************************************************************
+ * OS specific includes
+ */
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/bus.h>
+#include <sys/rman.h>
+#include <sys/endian.h>
+#include <sys/stddef.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/taskqueue.h>
+#include <sys/bitstring.h>
+#include <sys/stack.h>
+
+#include <machine/atomic.h>
+#include <machine/bus.h>
+#include <machine/stdarg.h>
+
+#include <dev/pci/pcivar.h>
+
+#include <sys/sema.h>
+#include <sys/time.h>
+
+#include <sys/proc.h>
+#include <sys/kthread.h>
+#include <sys/unistd.h>
+#include <sys/sched.h>
+
+#include <sys/conf.h>
+#include <sys/sysctl.h>
+#include <sys/ioccom.h>
+#include <sys/ctype.h>
+
+/* OCS_OS_MAX_ISR_TIME_MSEC -  maximum time driver code should spend in an interrupt
+ * or kernel thread context without yielding
+ */
+#define OCS_OS_MAX_ISR_TIME_MSEC	1000
+
+/* BSD driver specific definitions */
+
+#define ARRAY_SIZE(x)   (sizeof(x) / sizeof((x)[0]))
+
+#define OCS_MAX_LUN			512
+#define OCS_NUM_UNSOLICITED_FRAMES	1024
+
+#define OCS_MAX_DOMAINS			1
+#define OCS_MAX_REMOTE_NODES		2048
+#define OCS_MAX_TARGETS			1024
+#define OCS_MAX_INITIATORS		1024
+/** Reserve this number of IO for each intiator to return FULL/BUSY status */
+#define OCS_RSVD_INI_IO			8
+
+#define OCS_MIN_DMA_ALIGNMENT		16
+#define OCS_MAX_DMA_ALLOC		(64*1024)	/* maxium DMA allocation that is expected to reliably succeed  */
+
+/*
+ * Macros used to size the CQ hash table. We want to round up to the next
+ * power of 2 for the hash.
+ */
+#define B2(x)   (   (x) | (   (x) >> 1) )
+#define B4(x)   ( B2(x) | ( B2(x) >> 2) )
+#define B8(x)   ( B4(x) | ( B4(x) >> 4) )
+#define B16(x)  ( B8(x) | ( B8(x) >> 8) )
+#define B32(x)  (B16(x) | (B16(x) >>16) )
+#define B32_NEXT_POWER_OF_2(x)      (B32((x)-1) + 1)
+
+/*
+ * likely/unlikely - branch prediction hint
+ */
+#define likely(x)               __builtin_expect(!!(x), 1)
+#define unlikely(x)             __builtin_expect(!!(x), 0)
+
+/***************************************************************************
+ * OS abstraction
+ */
+
+/**
+ * @brief Min/Max macros
+ *
+ */
+#define OCS_MAX(x, y)		((x) > (y) ? (x) : (y))
+#define OCS_MIN(x, y)		((x) < (y) ? (x) : (y))
+
+#define PRIX64	"lX"
+#define PRIx64	"lx"
+#define PRId64	"ld"
+#define PRIu64	"lu"
+
+/**
+ * Enable optional features
+ *  - OCS_INCLUDE_DEBUG include low-level SLI debug support
+ */
+#define OCS_INCLUDE_DEBUG
+
+/**
+ * @brief Set the Nth bit
+ *
+ * @todo move to a private file used internally?
+ */
+#ifndef BIT
+#define BIT(n)		(1U << (n))
+#endif
+
+/***************************************************************************
+ * Platform specific operations
+ */
+
+/**
+ * @ingroup os
+ * @typedef ocs_os_handle_t
+ * @brief OS specific handle or driver context
+ *
+ * This can be anything from a void * to some other OS specific type. The lower
+ * layers make no assumption about its value and pass it back as the first
+ * parameter to most OS functions.
+ */
+typedef ocs_t * ocs_os_handle_t;
+
+/**
+ * @ingroup os
+ * @brief return the lower 32-bits of a bus address
+ *
+ * @param addr Physical or bus address to convert
+ * @return lower 32-bits of a bus address
+ *
+ * @note this may be a good cadidate for an inline or macro
+ */
+static inline uint32_t ocs_addr32_lo(uintptr_t addr)
+{
+#if defined(__LP64__)
+	return (uint32_t)(addr & 0xffffffffUL);
+#else
+	return addr;
+#endif
+}
+
+/**
+ * @ingroup os
+ * @brief return the upper 32-bits of a bus address
+ *
+ * @param addr Physical or bus address to convert
+ * @return upper 32-bits of a bus address
+ *
+ * @note this may be a good cadidate for an inline or macro
+ */
+static inline uint32_t ocs_addr32_hi(uintptr_t addr)
+{
+#if defined(__LP64__)
+	return (uint32_t)(addr >> 32);
+#else
+	return 0;
+#endif
+}
+
+/**
+ * @ingroup os
+ * @brief return the log2(val)
+ *
+ * @param val number to use (assumed to be exact power of 2)
+ *
+ * @return log base 2 of val
+ */
+static inline uint32_t ocs_lg2(uint32_t val)
+{
+#if defined(__GNUC__)
+	/*
+	 * clz = "count leading zero's"
+	 *
+	 * Assuming val is an exact power of 2, the most significant bit
+	 * will be the log base 2 of val
+	 */
+	return 31 - __builtin_clz(val);
+#else
+#error You need to provide a non-GCC version of this function
+#endif
+}
+
+/**
+ * @ingroup os
+ * @brief optimization barrier
+ *
+ * Optimization barrier. Prevents compiler re-ordering
+ * instructions across barrier.
+ *
+ * @return none
+ */
+#define ocs_barrier()	 __asm __volatile("" : : : "memory");
+
+/**
+ * @ingroup os
+ * @brief convert a big endian 32 bit value to the host's native format
+ *
+ * @param val 32 bit big endian value
+ *
+ * @return value converted to the host's native endianness
+ */
+#define ocs_be32toh(val)	be32toh(val)
+
+/**
+ * @ingroup os
+ * @brief convert a 32 bit value from the host's native format to big endian
+ *
+ * @param val 32 bit native endian value
+ *
+ * @return value converted to big endian
+ */
+#define ocs_htobe32(val)	htobe32(val)
+
+/**
+ * @ingroup os
+ * @brief convert a 16 bit value from the host's native format to big endian
+ *
+ * @param v 16 bit native endian value
+ *
+ * @return value converted to big endian
+ */
+#define ocs_htobe16(v)	htobe16(v)
+#define ocs_be16toh(v)	be16toh(v)
+
+
+#define ocs_htobe64(v)	htobe64(v)
+#define ocs_be64toh(v)	be64toh(v)
+
+/**
+ * @ingroup os
+ * @brief Delay execution by the given number of micro-seconds
+ *
+ * @param usec number of micro-seconds to "busy-wait"
+ *
+ * @note The value of usec may be greater than 1,000,000
+ */
+#define ocs_udelay(usec) DELAY(usec)
+
+/**
+ * @ingroup os
+ * @brief Delay execution by the given number of milli-seconds
+ *
+ * @param msec number of milli-seconds to "busy-wait"
+ *
+ * @note The value of usec may be greater than 1,000,000
+ */
+#define ocs_msleep(msec) ocs_udelay((msec)*1000)
+
+/**
+ * @ingroup os
+ * @brief Get time of day in msec
+ *
+ * @return time of day in msec
+ */
+static inline time_t
+ocs_msectime(void)
+{
+	struct timeval tv;
+
+	getmicrotime(&tv);
+	return (tv.tv_sec*1000) + (tv.tv_usec / 1000);
+}
+
+/**
+ * @ingroup os
+ * @brief Copy length number of bytes from the source to destination address
+ *
+ * @param d pointer to the destination memory
+ * @param s pointer to the source memory
+ * @param l number of bytes to copy
+ *
+ * @return original value of dst pointer
+ */
+#define ocs_memcpy(d, s, l)		memcpy(d, s, l)
+
+#define ocs_strlen(s)			strlen(s)
+#define ocs_strcpy(d,s)			strcpy(d, s)
+#define ocs_strncpy(d,s, n)		strncpy(d, s, n)
+#define ocs_strcat(d, s)		strcat(d, s)
+#define ocs_strtoul(s,ep,b)		strtoul(s,ep,b)
+#define ocs_strtoull(s,ep,b)		((uint64_t)strtouq(s,ep,b))
+#define ocs_atoi(s)			strtol(s, 0, 0)
+#define ocs_strcmp(d,s)			strcmp(d,s)
+#define ocs_strcasecmp(d,s)		strcasecmp(d,s)
+#define ocs_strncmp(d,s,n)		strncmp(d,s,n)
+#define ocs_strstr(h,n)			strstr(h,n)
+#define ocs_strsep(h, n)		strsep(h, n)
+#define ocs_strchr(s,c)			strchr(s,c)
+#define ocs_copy_from_user(dst, src, n)	copyin(src, dst, n)
+#define ocs_copy_to_user(dst, src, n)	copyout(src, dst, n)
+#define ocs_snprintf(buf, n, fmt, ...)	snprintf(buf, n, fmt, ##__VA_ARGS__)
+#define ocs_vsnprintf(buf, n, fmt, ap)	vsnprintf((char*)buf, n, fmt, ap)
+#define ocs_sscanf(buf,fmt, ...)	sscanf(buf, fmt, ##__VA_ARGS__)
+#define ocs_printf			printf
+#define ocs_isspace(c)			isspace(c)
+#define ocs_isdigit(c)			isdigit(c)
+#define ocs_isxdigit(c)			isxdigit(c)
+
+extern uint64_t ocs_get_tsc(void);
+extern void *ocs_ioctl_preprocess(ocs_os_handle_t os, void *arg, size_t size);
+extern int32_t ocs_ioctl_postprocess(ocs_os_handle_t os, void *arg, void *kern_ptr, size_t size);
+extern void ocs_ioctl_free(ocs_os_handle_t os, void *kern_ptr, size_t size);
+extern char *ocs_strdup(const char *s);
+
+/**
+ * @ingroup os
+ * @brief Set the value of each byte in memory
+ *
+ * @param b pointer to the memory
+ * @param c value used to set memory
+ * @param l number of bytes to set
+ *
+ * @return original value of mem pointer
+ */
+#define ocs_memset(b, c, l) memset(b, c, l)
+
+#define LOG_CRIT	0
+#define LOG_ERR		1
+#define LOG_WARN	2
+#define LOG_INFO	3
+#define LOG_TEST	4
+#define LOG_DEBUG	5
+
+extern int loglevel;
+
+extern void _ocs_log(ocs_t *ocs, const char *func, int line, const char *fmt, ...);
+
+#define ocs_log_crit(os, fmt, ...)	ocs_log(os, LOG_CRIT, fmt, ##__VA_ARGS__);
+#define ocs_log_err(os, fmt, ...)	ocs_log(os, LOG_ERR, fmt, ##__VA_ARGS__);
+#define ocs_log_warn(os, fmt, ...)	ocs_log(os, LOG_WARN, fmt, ##__VA_ARGS__);
+#define ocs_log_info(os, fmt, ...)	ocs_log(os, LOG_INFO, fmt, ##__VA_ARGS__);
+#define ocs_log_test(os, fmt, ...)	ocs_log(os, LOG_TEST, fmt, ##__VA_ARGS__);
+#define ocs_log_debug(os, fmt, ...)	ocs_log(os, LOG_DEBUG, fmt, ##__VA_ARGS__);
+
+#define ocs_log(os, level, fmt, ...)                    \
+	do {                                            \
+		if (level <= loglevel) {                \
+			_ocs_log(os, __func__, __LINE__, fmt, ##__VA_ARGS__);   \
+		}                                       \
+	} while (0)
+
+static inline uint32_t ocs_roundup(uint32_t x, uint32_t y)
+{
+	return (((x + y - 1) / y) * y);
+}
+
+static inline uint32_t ocs_rounddown(uint32_t x, uint32_t y)
+{
+	return ((x / y) * y);
+}
+
+/***************************************************************************
+ * Memory allocation interfaces
+ */
+
+#define OCS_M_ZERO	M_ZERO
+#define OCS_M_NOWAIT	M_NOWAIT
+
+/**
+ * @ingroup os
+ * @brief Allocate host memory
+ *
+ * @param os OS handle
+ * @param size number of bytes to allocate
+ * @param flags additional options
+ *
+ * Flags include
+ *  - OCS_M_ZERO zero memory after allocating
+ *  - OCS_M_NOWAIT do not block/sleep waiting for an allocation request
+ *
+ * @return pointer to allocated memory, NULL otherwise
+ */
+extern void *ocs_malloc(ocs_os_handle_t os, size_t size, int32_t flags);
+
+/**
+ * @ingroup os
+ * @brief Free host memory
+ *
+ * @param os OS handle
+ * @param addr pointer to memory
+ * @param size bytes to free
+ */
+extern void ocs_free(ocs_os_handle_t os, void *addr, size_t size);
+
+/**
+ * @ingroup os
+ * @brief generic DMA memory descriptor for driver allocations
+ *
+ * Memory regions ultimately used by the hardware are described using
+ * this structure. All implementations must include the structure members
+ * defined in the first section, and they may also add their own structure
+ * members in the second section.
+ *
+ * Note that each region described by ocs_dma_s is assumed to be physically
+ * contiguous.
+ */
+typedef struct ocs_dma_s {
+	/*
+	 * OCS layer requires the following members
+	 */
+	void		*virt;	/**< virtual address of the memory used by the CPU */
+	void		*alloc;	/**< originally allocated virtual address used to restore virt if modified */
+	uintptr_t	phys;	/**< physical or bus address of the memory used by the hardware */
+	size_t		size;	/**< size in bytes of the memory */
+	/*
+	 * Implementation specific fields allowed here
+	 */
+	size_t		len;	/**< application specific length */
+	bus_dma_tag_t	tag;
+	bus_dmamap_t	map;
+} ocs_dma_t;
+
+/**
+ * @ingroup os
+ * @brief Returns maximum supported DMA allocation size
+ *
+ * @param os OS specific handle or driver context
+ * @param align alignment requirement for DMA allocation
+ *
+ * Return maximum supported DMA allocation size, given alignment
+ * requirement.
+ *
+ * @return maxiumum supported DMA allocation size
+ */
+static inline uint32_t ocs_max_dma_alloc(ocs_os_handle_t os, size_t align)
+{
+	return ~((uint32_t)0); /* no max */
+}
+
+/**
+ * @ingroup os
+ * @brief Allocate a DMA capable block of memory
+ *
+ * @param os OS specific handle or driver context
+ * @param dma DMA descriptor containing results of memory allocation
+ * @param size Size in bytes of desired allocation
+ * @param align Alignment in bytes of the requested allocation
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+extern int32_t ocs_dma_alloc(ocs_os_handle_t, ocs_dma_t *, size_t, size_t);
+
+/**
+ * @ingroup os
+ * @brief Free a DMA capable block of memory
+ *
+ * @param os OS specific handle or driver context
+ * @param dma DMA descriptor for memory to be freed
+ *
+ * @return 0 if memory is de-allocated, non-zero otherwise
+ */
+extern int32_t ocs_dma_free(ocs_os_handle_t, ocs_dma_t *);
+extern int32_t ocs_dma_copy_in(ocs_dma_t *dma, void *buffer, uint32_t buffer_length);
+extern int32_t ocs_dma_copy_out(ocs_dma_t *dma, void *buffer, uint32_t buffer_length);
+
+static inline int32_t ocs_dma_valid(ocs_dma_t *dma)
+{
+	return (dma->size != 0);
+}
+
+/**
+ * @ingroup os
+ * @brief Synchronize the DMA buffer memory
+ *
+ * Ensures memory coherency between the CPU and device
+ *
+ * @param dma DMA descriptor of memory to synchronize
+ * @param flags Describes direction of synchronization
+ *   - OCS_DMASYNC_PREREAD sync needed before hardware updates host memory
+ *   - OCS_DMASYNC_PREWRITE sync needed after CPU updates host memory but before hardware can access
+ *   - OCS_DMASYNC_POSTREAD sync needed after hardware updates host memory but before CPU can access
+ *   - OCS_DMASYNC_POSTWRITE sync needed after hardware updates host memory
+ */
+extern void ocs_dma_sync(ocs_dma_t *, uint32_t);
+
+#define OCS_DMASYNC_PREWRITE BUS_DMASYNC_PREWRITE
+#define OCS_DMASYNC_POSTREAD BUS_DMASYNC_POSTREAD
+
+
+/***************************************************************************
+ * Locking
+ */
+
+/**
+ * @ingroup os
+ * @typedef ocs_lock_t
+ * @brief Define the type used implement locking
+ */
+#define MAX_LOCK_DESC_LEN	64
+typedef struct ocs_lock_s {
+	struct	mtx lock;
+	char	name[MAX_LOCK_DESC_LEN];
+} ocs_lock_t;
+
+/**
+ * @ingroup os
+ * @brief Initialize a lock
+ *
+ * @param lock lock to initialize
+ * @param name string identifier for the lock
+ */
+extern void ocs_lock_init(void *os, ocs_lock_t *lock, const char *name, ...);
+
+/**
+ * @ingroup os
+ * @brief Free a previously allocated lock
+ *
+ * @param lock lock to free
+ */
+static inline void
+ocs_lock_free(ocs_lock_t *lock)
+{
+
+	if (mtx_initialized(&(lock)->lock)) {
+		mtx_assert(&(lock)->lock, MA_NOTOWNED);
+		mtx_destroy(&(lock)->lock);
+	} else {
+		panic("XXX trying to free with un-initialized mtx!?!?\n");
+	}
+}
+
+/**
+ * @ingroup os
+ * @brief Acquire a lock
+ *
+ * @param lock lock to obtain
+ */
+static inline void
+ocs_lock(ocs_lock_t *lock)
+{
+
+	if (mtx_initialized(&(lock)->lock)) {
+		mtx_assert(&(lock)->lock, MA_NOTOWNED);
+		mtx_lock(&(lock)->lock);
+	} else {
+		panic("XXX trying to lock with un-initialized mtx!?!?\n");
+	}
+}
+
+/**
+ * @ingroup os
+ * @brief Release a lock
+ *
+ * @param lock lock to release
+ */
+static inline void
+ocs_unlock(ocs_lock_t *lock)
+{
+
+	if (mtx_initialized(&(lock)->lock)) {
+		mtx_assert(&(lock)->lock, MA_OWNED | MA_NOTRECURSED);
+		mtx_unlock(&(lock)->lock);
+	} else {
+		panic("XXX trying to unlock with un-initialized mtx!?!?\n");
+	}
+}
+
+/**
+ * @ingroup os
+ * @typedef ocs_lock_t
+ * @brief Define the type used implement recursive locking
+ */
+typedef struct ocs_lock_s ocs_rlock_t;
+
+/**
+ * @ingroup os
+ * @brief Initialize a recursive lock
+ *
+ * @param ocs pointer to ocs structure
+ * @param lock lock to initialize
+ * @param name string identifier for the lock
+ */
+static inline void
+ocs_rlock_init(ocs_t *ocs, ocs_rlock_t *lock, const char *name)
+{
+	ocs_strncpy(lock->name, name, MAX_LOCK_DESC_LEN);
+	mtx_init(&(lock)->lock, lock->name, NULL, MTX_DEF | MTX_RECURSE | MTX_DUPOK);
+}
+
+/**
+ * @ingroup os
+ * @brief Free a previously allocated recursive lock
+ *
+ * @param lock lock to free
+ */
+static inline void
+ocs_rlock_free(ocs_rlock_t *lock)
+{
+	if (mtx_initialized(&(lock)->lock)) {
+		mtx_destroy(&(lock)->lock);
+	} else {
+		panic("XXX trying to free with un-initialized mtx!?!?\n");
+	}
+}
+
+/**
+ * @brief try to acquire a recursive lock
+ *
+ * Attempt to acquire a recursive lock, return TRUE if successful
+ *
+ * @param lock pointer to recursive lock
+ *
+ * @return TRUE if lock was acquired, FALSE if not
+ */
+static inline int32_t
+ocs_rlock_try(ocs_rlock_t *lock)
+{
+	int rc = mtx_trylock(&(lock)->lock);
+
+	return rc != 0;
+}
+
+/**
+ * @ingroup os
+ * @brief Acquire a recursive lock
+ *
+ * @param lock lock to obtain
+ */
+static inline void
+ocs_rlock_acquire(ocs_rlock_t *lock)
+{
+	if (mtx_initialized(&(lock)->lock)) {
+		mtx_lock(&(lock)->lock);
+	} else {
+		panic("XXX trying to lock with un-initialized mtx!?!?\n");
+	}
+}
+
+/**
+ * @ingroup os
+ * @brief Release a recursive lock
+ *
+ * @param lock lock to release
+ */
+static inline void
+ocs_rlock_release(ocs_rlock_t *lock)
+{
+	if (mtx_initialized(&(lock)->lock)) {
+		mtx_assert(&(lock)->lock, MA_OWNED);
+		mtx_unlock(&(lock)->lock);
+	} else {
+		panic("XXX trying to unlock with un-initialized mtx!?!?\n");
+	}
+}
+
+/**
+ * @brief counting semaphore
+ *
+ * Declaration of the counting semaphore object
+ *
+ */
+typedef struct {
+	char name[32];
+	struct sema sem;		/**< OS counting semaphore structure */
+} ocs_sem_t;
+
+#define OCS_SEM_FOREVER		(-1)
+#define OCS_SEM_TRY		(0)
+
+/**
+ * @brief Initialize a counting semaphore
+ *
+ * The semaphore is initiatlized to the value
+ *
+ * @param sem pointer to semaphore
+ * @param val initial value
+ * @param name label for the semaphore
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+extern int ocs_sem_init(ocs_sem_t *sem, int val, const char *name, ...) __attribute__((format(printf, 3, 4)));
+
+/**
+ * @brief execute a P (decrement) operation
+ *
+ * A P (decrement and block if negative) operation is performed on the semaphore.
+ *
+ * If timeout_usec is zero, the semaphore attempts one time and returns 0 if acquired.
+ * If timeout_usec is greater than zero, then the call will block until the semaphore
+ * is acquired, or a timeout occurred.  If timeout_usec is less than zero, then
+ * the call will block until the semaphore is acquired.
+ *
+ * @param sem pointer to semaphore
+ * @param timeout_usec timeout in microseconds
+ *
+ * @return returns 0 for success, negative value if the semaphore was not acquired.
+ */
+
+static inline int
+ocs_sem_p(ocs_sem_t *sem, int timeout_usec)
+{
+	int32_t rc = 0;
+
+	if (timeout_usec == 0) {
+		rc = sema_trywait(&sem->sem);
+		if (rc == 0) {
+			rc = -1;
+		}
+	} else if (timeout_usec > 0) {
+		struct timeval tv;
+		uint32_t ticks;
+
+		tv.tv_sec = timeout_usec / 1000000;
+		tv.tv_usec = timeout_usec % 1000000;
+		ticks = tvtohz(&tv);
+		if (ticks == 0) {
+			ticks ++;
+		}
+		rc = sema_timedwait(&sem->sem, ticks);
+		if (rc != 0) {
+			rc = -1;
+		}
+	} else {
+		sema_wait(&sem->sem);
+	}
+	if (rc)
+		rc = -1;
+
+	return rc;
+}
+
+/**
+ * @brief perform a V (increment) operation on a counting semaphore
+ *
+ * The semaphore is incremented, unblocking one thread that is waiting on the
+ * sempahore
+ *
+ * @param sem pointer to the semaphore
+ *
+ * @return none
+ */
+
+static inline void
+ocs_sem_v(ocs_sem_t *sem)
+{
+	sema_post(&sem->sem);
+}
+
+/***************************************************************************
+ * Bitmap
+ */
+
+/**
+ * @ingroup os
+ * @typedef ocs_bitmap_t
+ * @brief Define the type used implement bit-maps
+ */
+typedef bitstr_t ocs_bitmap_t;
+
+/**
+ * @ingroup os
+ * @brief Allocate a bitmap
+ *
+ * @param n_bits Minimum number of entries in the bit-map
+ *
+ * @return pointer to the bit-map or NULL on error
+ */
+extern ocs_bitmap_t *ocs_bitmap_alloc(uint32_t n_bits);
+
+/**
+ * @ingroup os
+ * @brief Free a bit-map
+ *
+ * @param bitmap Bit-map to free
+ */
+extern void ocs_bitmap_free(ocs_bitmap_t *bitmap);
+
+/**
+ * @ingroup os
+ * @brief Find next unset bit and set it
+ *
+ * @param bitmap bit map to search
+ * @param n_bits number of bits in map
+ *
+ * @return bit position or -1 if map is full
+ */
+extern int32_t ocs_bitmap_find(ocs_bitmap_t *bitmap, uint32_t n_bits);
+
+/**
+ * @ingroup os
+ * @brief search for next (un)set bit
+ *
+ * @param bitmap bit map to search
+ * @param set search for a set or unset bit
+ * @param n_bits number of bits in map
+ *
+ * @return bit position or -1
+ */
+extern int32_t ocs_bitmap_search(ocs_bitmap_t *bitmap, uint8_t set, uint32_t n_bits);
+
+/**
+ * @ingroup os
+ * @brief clear the specified bit
+ *
+ * @param bitmap pointer to bit map
+ * @param bit bit number to clear
+ */
+extern void ocs_bitmap_clear(ocs_bitmap_t *bitmap, uint32_t bit);
+
+extern int32_t ocs_get_property(const char *prop_name, char *buffer, uint32_t buffer_len);
+
+/***************************************************************************
+ * Timer Routines
+ *
+ * Functions for setting, querying and canceling timers.
+ */
+typedef struct {
+	struct callout	callout;
+	struct mtx	lock;
+
+	void	(*func)(void *);
+	void	*data;
+} ocs_timer_t;
+
+/**
+ * @ingroup os
+ * @brief Initialize and set a timer
+ *
+ * @param os OS handle
+ * @param timer    pointer to the structure allocated for this timer
+ * @param func     the function to call when the timer expires
+ * @param data     Data to pass to the provided timer function when the timer
+ *                 expires.
+ * @param timeout_ms the timeout in milliseconds
+ */
+extern int32_t ocs_setup_timer(ocs_os_handle_t os, ocs_timer_t *timer, void(*func)(void *arg),
+			       void *data, uint32_t timeout_ms);
+
+/**
+ * @ingroup os
+ * @brief Modify a timer's expiration
+ *
+ * @param timer    pointer to the structure allocated for this timer
+ * @param timeout_ms the timeout in milliseconds
+ */
+extern int32_t ocs_mod_timer(ocs_timer_t *timer, uint32_t timeout_ms);
+
+/**
+ * @ingroup os
+ * @brief Queries to see if a timer is pending.
+ *
+ * @param timer    pointer to the structure allocated for this timer
+ *
+ * @return non-zero if the timer is pending
+ */
+extern int32_t ocs_timer_pending(ocs_timer_t *timer);
+
+/**
+ * @ingroup os
+ * @brief Remove a pending timer
+ *
+ * @param timer    pointer to the structure allocated for this timer
+ *                 expires.
+ */
+extern int32_t ocs_del_timer(ocs_timer_t *timer);
+
+/***************************************************************************
+ * Atomics
+ *
+ */
+
+typedef uint32_t ocs_atomic_t;
+
+/**
+ * @ingroup os
+ * @brief initialize an atomic
+ *
+ * @param a    pointer to the atomic object
+ * @param v    initial value
+ *
+ * @return none
+ */
+#define ocs_atomic_init(a, v)	ocs_atomic_set(a, v)
+
+/**
+ * @ingroup os
+ * @brief adds an integer to an atomic value
+ *
+ * @param a    pointer to the atomic object
+ * @param v    value to increment
+ *
+ * @return the value of the atomic before incrementing.
+ */
+#define ocs_atomic_add_return(a, v)	atomic_fetchadd_32(a, v)
+
+/**
+ * @ingroup os
+ * @brief subtracts an integer to an atomic value
+ *
+ * @param a    pointer to the atomic object
+ * @param v    value to increment
+ *
+ * @return the value of the atomic before subtracting.
+ */
+#define ocs_atomic_sub_return(a, v)     atomic_fetchadd_32(a, (-(v)))
+
+/**
+ * @ingroup os
+ * @brief returns the current value of an atomic object
+ *
+ * @param a    pointer to the atomic object
+ *
+ * @return the value of the atomic.
+ */
+#define ocs_atomic_read(a)		atomic_load_acq_32(a)
+
+/**
+ * @ingroup os
+ * @brief sets the current value of an atomic object
+ *
+ * @param a    pointer to the atomic object
+ */
+#define ocs_atomic_set(a, v)		atomic_store_rel_32(a, v)
+
+/**
+ * @ingroup os
+ * @brief Sets atomic to 0, returns previous value
+ *
+ * @param a    pointer to the atomic object
+ *
+ * @return the value of the atomic before the operation.
+ */
+#define ocs_atomic_read_and_clear	atomic_readandclear_32(a)
+
+/**
+ * @brief OCS thread structure
+ *
+ */
+
+typedef struct ocs_thread_s ocs_thread_t;
+
+typedef int32_t (*ocs_thread_fctn)(ocs_thread_t *mythread);
+
+struct ocs_thread_s  {
+	struct thread *tcb;			/*<< thread control block */
+	ocs_thread_fctn fctn;			/*<< thread function */
+	char *name;				/*<< name of thread */
+	void *arg;				/*<< pointer to thread argument */
+	ocs_atomic_t terminate;			/*<< terminate request */
+	int32_t retval;				/*<< return value */
+	uint32_t cpu_affinity;			/*<< cpu affinity */
+};
+#define OCS_THREAD_DEFAULT_STACK_SIZE_PAGES	8
+
+/**
+ * @brief OCS thread start options
+ *
+ */
+
+typedef enum {
+	OCS_THREAD_RUN,				/*<< run immediately */
+	OCS_THREAD_CREATE,			/*<< create and wait for start request */
+} ocs_thread_start_e;
+
+
+extern int32_t ocs_thread_create(ocs_os_handle_t os, ocs_thread_t *thread, ocs_thread_fctn fctn,
+				 const char *name, void *arg, ocs_thread_start_e start_option);
+extern int32_t ocs_thread_start(ocs_thread_t *thread);
+extern void *ocs_thread_get_arg(ocs_thread_t *mythread);
+extern int32_t ocs_thread_terminate(ocs_thread_t *thread);
+extern int32_t ocs_thread_terminate_requested(ocs_thread_t *thread);
+extern int32_t ocs_thread_get_retval(ocs_thread_t *thread);
+extern void ocs_thread_yield(ocs_thread_t *thread);
+extern ocs_thread_t *ocs_thread_self(void);
+extern int32_t ocs_thread_setcpu(ocs_thread_t *thread, uint32_t cpu);
+extern int32_t ocs_thread_getcpu(void);
+
+
+/***************************************************************************
+ * PCI
+ *
+ * Several functions below refer to a "register set". This is one or
+ * more PCI BARs that constitute a PCI address. For example, if a MMIO
+ * region is described using both BAR[0] and BAR[1], the combination of
+ * BARs defines register set 0.
+ */
+
+/**
+ * @brief tracks mapped PCI memory regions
+ */
+typedef struct ocs_pci_reg_s {
+	uint32_t		rid;
+	struct resource		*res;
+	bus_space_tag_t		btag;
+	bus_space_handle_t	bhandle;
+} ocs_pci_reg_t;
+
+#define PCI_MAX_BAR				6
+#define PCI_64BIT_BAR0				0
+
+#define PCI_VENDOR_EMULEX       		0x10df		/* Emulex */
+
+#define PCI_PRODUCT_EMULEX_OCE16001		0xe200		/* OneCore 16Gb FC (lancer) */
+#define PCI_PRODUCT_EMULEX_OCE16002		0xe200		/* OneCore 16Gb FC (lancer) */
+#define PCI_PRODUCT_EMULEX_LPE31004		0xe300  /* LightPulse 16Gb x 4 FC (lancer-g6) */
+#define PCI_PRODUCT_EMULEX_LPE32002		0xe300  /* LightPulse 32Gb x 2 FC (lancer-g6) */
+#define PCI_PRODUCT_EMULEX_OCE1600_VF		0xe208
+#define PCI_PRODUCT_EMULEX_OCE50102		0xe260		/* OneCore FCoE (lancer) */
+#define PCI_PRODUCT_EMULEX_OCE50102_VF		0xe268
+
+/**
+ * @ingroup os
+ * @brief Get the PCI bus, device, and function values
+ *
+ * @param ocs OS specific handle or driver context
+ * @param bus Pointer to location to store the bus number.
+ * @param dev Pointer to location to store the device number.
+ * @param func Pointer to location to store the function number.
+ *
+ * @return Returns 0.
+ */
+extern int32_t
+ocs_get_bus_dev_func(ocs_t *ocs, uint8_t* bus, uint8_t* dev, uint8_t* func);
+
+extern ocs_t *ocs_get_instance(uint32_t index);
+extern uint32_t ocs_instance(void *os);
+
+
+/**
+ * @ingroup os
+ * @brief Read a 32 bit value from the specified configuration register
+ *
+ * @param os OS specific handle or driver context
+ * @param reg register offset
+ *
+ * @return The 32 bit value
+ */
+extern uint32_t ocs_config_read32(ocs_os_handle_t os, uint32_t reg);
+
+/**
+ * @ingroup os
+ * @brief Read a 16 bit value from the specified configuration
+ *        register
+ *
+ * @param os OS specific handle or driver context
+ * @param reg register offset
+ *
+ * @return The 16 bit value
+ */
+extern uint16_t ocs_config_read16(ocs_os_handle_t os, uint32_t reg);
+
+/**
+ * @ingroup os
+ * @brief Read a 8 bit value from the specified configuration
+ *        register
+ *
+ * @param os OS specific handle or driver context
+ * @param reg register offset
+ *
+ * @return The 8 bit value
+ */
+extern uint8_t ocs_config_read8(ocs_os_handle_t os, uint32_t reg);
+
+/**
+ * @ingroup os
+ * @brief Write a 8 bit value to the specified configuration
+ *        register
+ *
+ * @param os OS specific handle or driver context
+ * @param reg register offset
+ * @param val value to write
+ *
+ * @return None
+ */
+extern void ocs_config_write8(ocs_os_handle_t os, uint32_t reg, uint8_t val);
+
+/**
+ * @ingroup os
+ * @brief Write a 16 bit value to the specified configuration
+ *        register
+ *
+ * @param os OS specific handle or driver context
+ * @param reg register offset
+ * @param val value to write
+ *
+ * @return None
+ */
+extern void ocs_config_write16(ocs_os_handle_t os, uint32_t reg, uint16_t val);
+
+/**
+ * @ingroup os
+ * @brief Write a 32 bit value to the specified configuration
+ *        register
+ *
+ * @param os OS specific handle or driver context
+ * @param reg register offset
+ * @param val value to write
+ *
+ * @return None
+ */
+extern void ocs_config_write32(ocs_os_handle_t os, uint32_t reg, uint32_t val);
+
+/**
+ * @ingroup os
+ * @brief Read a PCI register
+ *
+ * @param os OS specific handle or driver context
+ * @param rset Which "register set" to use
+ * @param off  Register offset
+ *
+ * @return 32 bit conents of the register
+ */
+extern uint32_t ocs_reg_read32(ocs_os_handle_t os, uint32_t rset, uint32_t off);
+
+/**
+ * @ingroup os
+ * @brief Read a PCI register
+ *
+ * @param os OS specific handle or driver context
+ * @param rset Which "register set" to use
+ * @param off  Register offset
+ *
+ * @return 16 bit conents of the register
+ */
+extern uint16_t ocs_reg_read16(ocs_os_handle_t os, uint32_t rset, uint32_t off);
+
+/**
+ * @ingroup os
+ * @brief Read a PCI register
+ *
+ * @param os OS specific handle or driver context
+ * @param rset Which "register set" to use
+ * @param off  Register offset
+ *
+ * @return 8 bit conents of the register
+ */
+extern uint8_t ocs_reg_read8(ocs_os_handle_t os, uint32_t rset, uint32_t off);
+
+/**
+ * @ingroup os
+ * @brief Write a PCI register
+ *
+ * @param os OS specific handle or driver context
+ * @param rset Which "register set" to use
+ * @param off  Register offset
+ * @param val  32-bit value to write
+ */
+extern void ocs_reg_write32(ocs_os_handle_t os, uint32_t rset, uint32_t off, uint32_t val);
+
+/**
+ * @ingroup os
+ * @brief Write a PCI register
+ *
+ * @param os OS specific handle or driver context
+ * @param rset Which "register set" to use
+ * @param off  Register offset
+ * @param val  16-bit value to write
+ */
+extern void ocs_reg_write16(ocs_os_handle_t os, uint32_t rset, uint32_t off, uint16_t val);
+
+/**
+ * @ingroup os
+ * @brief Write a PCI register
+ *
+ * @param os OS specific handle or driver context
+ * @param rset Which "register set" to use
+ * @param off  Register offset
+ * @param val  8-bit value to write
+ */
+extern void ocs_reg_write8(ocs_os_handle_t os, uint32_t rset, uint32_t off, uint8_t val);
+
+/**
+ * @ingroup os
+ * @brief Disable interrupts
+ *
+ * @param os OS specific handle or driver context
+ */
+extern void ocs_intr_disable(ocs_os_handle_t os);
+
+/**
+ * @ingroup os
+ * @brief Enable interrupts
+ *
+ * @param os OS specific handle or driver context
+ */
+extern void ocs_intr_enable(ocs_os_handle_t os);
+
+/**
+ * @ingroup os
+ * @brief Return model string
+ *
+ * @param os OS specific handle or driver context
+ */
+extern const char *ocs_pci_model(uint16_t vendor, uint16_t device);
+
+extern void ocs_print_stack(void);
+
+extern void ocs_abort(void) __attribute__((noreturn));
+
+/***************************************************************************
+ * Reference counting
+ *
+ */
+
+/**
+ * @ingroup os
+ * @brief reference counter object
+ */
+typedef void (*ocs_ref_release_t)(void *arg);
+typedef struct ocs_ref_s {
+	ocs_ref_release_t release; /* release function to call */
+	void *arg;
+	uint32_t count;		/* ref count; no need to be atomic if we have a lock */
+} ocs_ref_t;
+
+/**
+ * @ingroup os
+ * @brief initialize given reference object
+ *
+ * @param ref Pointer to reference object
+ * @param release Function to be called when count is 0.
+ * @param arg Argument to be passed to release function.
+ */
+static inline void
+ocs_ref_init(ocs_ref_t *ref, ocs_ref_release_t release, void *arg)
+{
+	ref->release = release;
+	ref->arg = arg;
+	ocs_atomic_init(&ref->count, 1);
+}
+
+/**
+ * @ingroup os
+ * @brief Return reference count value
+ *
+ * @param ref Pointer to reference object
+ *
+ * @return Count value of given reference object
+ */
+static inline uint32_t
+ocs_ref_read_count(ocs_ref_t *ref)
+{
+	return ocs_atomic_read(&ref->count);
+}
+
+/**
+ * @ingroup os
+ * @brief Set count on given reference object to a value.
+ *
+ * @param ref Pointer to reference object
+ * @param i Set count to this value
+ */
+static inline void
+ocs_ref_set(ocs_ref_t *ref, int i)
+{
+	ocs_atomic_set(&ref->count, i);
+}
+
+/**
+ * @ingroup os
+ * @brief Take a reference on given object.
+ *
+ * @par Description
+ * This function takes a reference on an object.
+ *
+ * Note: this function should only be used if the caller can
+ * guarantee that the reference count is >= 1 and will stay >= 1
+ * for the duration of this call (i.e. won't go to zero). If it
+ * can't (the refcount may go to zero during this call),
+ * ocs_ref_get_unless_zero() should be used instead.
+ *
+ * @param ref Pointer to reference object
+ *
+ */
+static inline void
+ocs_ref_get(ocs_ref_t *ref)
+{
+	ocs_atomic_add_return(&ref->count, 1);
+}
+
+/**
+ * @ingroup os
+ * @brief Take a reference on given object if count is not zero.
+ *
+ * @par Description
+ * This function takes a reference on an object if and only if
+ * the given reference object is "active" or valid.
+ *
+ * @param ref Pointer to reference object
+ *
+ * @return non-zero if "get" succeeded; Return zero if ref count
+ * is zero.
+ */
+static inline uint32_t
+ocs_ref_get_unless_zero(ocs_ref_t *ref)
+{
+	uint32_t rc = 0;
+	rc = ocs_atomic_read(&ref->count);
+		if (rc != 0) {
+			ocs_atomic_add_return(&ref->count, 1);
+		}
+	return rc;
+}
+
+/**
+ * @ingroup os
+ * @brief Decrement reference on given object
+ *
+ * @par Description
+ * This function decrements the reference count on the given
+ * reference object. If the reference count becomes zero, the
+ * "release" function (set during "init" time) is called.
+ *
+ * @param ref Pointer to reference object
+ *
+ * @return non-zero if release function was called; zero
+ * otherwise.
+ */
+static inline uint32_t
+ocs_ref_put(ocs_ref_t *ref)
+{
+	uint32_t rc = 0;
+	if (ocs_atomic_sub_return(&ref->count, 1) == 1) {
+		ref->release(ref->arg);
+		rc = 1;
+	}
+	return rc;
+}
+
+/**
+ * @ingroup os
+ * @brief Get the OS system ticks
+ *
+ * @return number of ticks that have occurred since the system
+ * booted.
+ */
+static inline uint64_t
+ocs_get_os_ticks(void)
+{
+	return ticks;
+}
+
+/**
+ * @ingroup os
+ * @brief Get the OS system tick frequency
+ *
+ * @return frequency of system ticks.
+ */
+static inline uint32_t
+ocs_get_os_tick_freq(void)
+{
+	return hz;
+}
+
+/*****************************************************************************
+ *
+ * CPU topology API
+ */
+
+typedef struct {
+	uint32_t num_cpus;	/* Number of CPU cores */
+	uint8_t hyper;		/* TRUE if threaded CPUs */
+} ocs_cpuinfo_t;
+
+extern int32_t ocs_get_cpuinfo(ocs_cpuinfo_t *cpuinfo);
+extern uint32_t ocs_get_num_cpus(void);
+
+#include "ocs_list.h"
+#include "ocs_utils.h"
+#include "ocs_mgmt.h"
+#include "ocs_common.h"
+
+#endif /* !_OCS_OS_H */
diff --git a/sys/dev/ocs_fc/ocs_pci.c b/sys/dev/ocs_fc/ocs_pci.c
new file mode 100644
index 000000000000..03f1fa3d0cb0
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_pci.c
@@ -0,0 +1,963 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#define OCS_COPYRIGHT "Copyright (C) 2017 Broadcom. All rights reserved."
+
+/**
+ * @file
+ * Implementation of required FreeBSD PCI interface functions
+ */
+
+#include "ocs.h"
+#include "version.h"
+#include <sys/sysctl.h>
+#include <sys/malloc.h>
+
+static MALLOC_DEFINE(M_OCS, "OCS", "OneCore Storage data");
+
+#include <dev/pci/pcireg.h>
+#include <dev/pci/pcivar.h>
+
+#include <machine/bus.h>
+
+/**
+ * Tunable parameters for transport
+ */
+int logmask = 0;
+int ctrlmask = 2;
+int logdest = 1;
+int loglevel = LOG_INFO;
+int ramlog_size = 1*1024*1024;
+int ddump_saved_size = 0;
+static const char *queue_topology = "eq cq rq cq mq $nulp($nwq(cq wq:ulp=$rpt1)) cq wq:len=256:class=1";
+
+static void ocs_release_bus(struct ocs_softc *);
+static int32_t ocs_intr_alloc(struct ocs_softc *);
+static int32_t ocs_intr_setup(struct ocs_softc *);
+static int32_t ocs_intr_teardown(struct ocs_softc *);
+static int ocs_pci_intx_filter(void *);
+static void ocs_pci_intr(void *);
+static int32_t ocs_init_dma_tag(struct ocs_softc *ocs);
+
+static int32_t ocs_setup_fcports(ocs_t *ocs);
+
+ocs_t *ocs_devices[MAX_OCS_DEVICES];
+
+/**
+ * @brief Check support for the given device
+ *
+ * Determine support for a given device by examining the PCI vendor and
+ * device IDs
+ *
+ * @param dev device abstraction
+ *
+ * @return 0 if device is supported, ENXIO otherwise
+ */
+static int
+ocs_pci_probe(device_t dev)
+{
+	char	*desc = NULL;
+
+	if (pci_get_vendor(dev) != PCI_VENDOR_EMULEX) { 
+		return ENXIO;
+	}
+
+	switch (pci_get_device(dev)) {
+	case PCI_PRODUCT_EMULEX_OCE16001:
+		desc = "Emulex LightPulse FC Adapter";
+		break;
+	case PCI_PRODUCT_EMULEX_LPE31004:
+		desc = "Emulex LightPulse FC Adapter";
+		break;
+	case PCI_PRODUCT_EMULEX_OCE50102:
+		desc = "Emulex LightPulse 10GbE FCoE/NIC Adapter";
+		break;
+	default:
+		return ENXIO;
+	}
+
+	device_set_desc(dev, desc);
+
+	return BUS_PROBE_DEFAULT;
+}
+
+static int
+ocs_map_bars(device_t dev, struct ocs_softc *ocs)
+{
+
+	/*
+	 * Map PCI BAR0 register into the CPU's space.
+	 */
+
+	ocs->reg[0].rid = PCIR_BAR(PCI_64BIT_BAR0);
+	ocs->reg[0].res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
+			&ocs->reg[0].rid, RF_ACTIVE);
+
+	if (ocs->reg[0].res == NULL) {
+		device_printf(dev, "bus_alloc_resource failed rid=%#x\n",
+				ocs->reg[0].rid);
+		return ENXIO;
+	}
+
+	ocs->reg[0].btag = rman_get_bustag(ocs->reg[0].res);
+	ocs->reg[0].bhandle = rman_get_bushandle(ocs->reg[0].res);
+	return 0;
+}
+
+
+static int
+ocs_setup_params(struct ocs_softc *ocs)
+{
+	int32_t	i = 0;
+	const char	*hw_war_version;
+	/* Setup tunable parameters */
+	ocs->ctrlmask = ctrlmask;
+	ocs->speed = 0;
+	ocs->topology = 0;
+	ocs->ethernet_license = 0;
+	ocs->num_scsi_ios = 8192;
+	ocs->enable_hlm = 0;
+	ocs->hlm_group_size = 8;
+	ocs->logmask = logmask;
+
+	ocs->config_tgt = FALSE;
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"target", &i)) {
+		if (1 == i) {
+			ocs->config_tgt = TRUE;
+			device_printf(ocs->dev, "Enabling target\n");
+		}
+	}
+
+	ocs->config_ini = TRUE;
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"initiator", &i)) {
+		if (0 == i) {
+			ocs->config_ini = FALSE;
+			device_printf(ocs->dev, "Disabling initiator\n");
+		}
+	}
+	ocs->enable_ini = ocs->config_ini;
+
+	if (!ocs->config_ini && !ocs->config_tgt) {
+		device_printf(ocs->dev, "Unsupported, both initiator and target mode disabled.\n");
+		return 1;
+
+        }
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"logmask", &logmask)) {
+		device_printf(ocs->dev, "logmask = %#x\n", logmask);
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"logdest", &logdest)) {
+		device_printf(ocs->dev, "logdest = %#x\n", logdest);
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"loglevel", &loglevel)) {
+		device_printf(ocs->dev, "loglevel = %#x\n", loglevel);
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"ramlog_size", &ramlog_size)) {
+		device_printf(ocs->dev, "ramlog_size = %#x\n", ramlog_size);
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"ddump_saved_size", &ddump_saved_size)) {
+		device_printf(ocs->dev, "ddump_saved_size= %#x\n", ddump_saved_size);
+	}
+
+	/* If enabled, initailize a RAM logging buffer */
+	if (logdest & 2) {
+		ocs->ramlog = ocs_ramlog_init(ocs, ramlog_size/OCS_RAMLOG_DEFAULT_BUFFERS,
+			OCS_RAMLOG_DEFAULT_BUFFERS);
+		/* If NULL was returned, then we'll simply skip using the ramlog but */
+		/* set logdest to 1 to ensure that we at least get default logging.  */
+		if (ocs->ramlog == NULL) {
+			logdest = 1;
+		}
+	}
+
+	/* initialize a saved ddump */
+	if (ddump_saved_size) {
+		if (ocs_textbuf_alloc(ocs, &ocs->ddump_saved, ddump_saved_size)) {
+			ocs_log_err(ocs, "failed to allocate memory for saved ddump\n");
+		}
+	}
+
+	if (0 == resource_string_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"hw_war_version", &hw_war_version)) {
+		device_printf(ocs->dev, "hw_war_version = %s\n", hw_war_version);
+		ocs->hw_war_version = strdup(hw_war_version, M_OCS);
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				    "explicit_buffer_list", &i)) {
+		ocs->explicit_buffer_list = i;
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"ethernet_license", &i)) {
+		ocs->ethernet_license = i;
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"speed", &i)) {
+		device_printf(ocs->dev, "speed = %d Mbps\n", i);
+		ocs->speed = i;
+	}
+	ocs->desc = device_get_desc(ocs->dev);
+
+	ocs_device_lock_init(ocs);
+	ocs->driver_version = STR_BE_MAJOR "." STR_BE_MINOR "." STR_BE_BUILD "." STR_BE_BRANCH;
+	ocs->model = ocs_pci_model(ocs->pci_vendor, ocs->pci_device);
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				    "enable_hlm", &i)) {
+		device_printf(ocs->dev, "enable_hlm = %d\n", i);
+		ocs->enable_hlm = i;
+		if (ocs->enable_hlm) {
+			ocs->hlm_group_size = 8;
+
+			if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+						    "hlm_group_size", &i)) {
+				ocs->hlm_group_size = i;
+			}
+			device_printf(ocs->dev, "hlm_group_size = %d\n", i);
+		}
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"num_scsi_ios", &i)) {
+		ocs->num_scsi_ios = i;
+		device_printf(ocs->dev, "num_scsi_ios = %d\n", ocs->num_scsi_ios);
+	} else {
+		ocs->num_scsi_ios = 8192;
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+					"topology", &i)) {
+		ocs->topology = i;
+		device_printf(ocs->dev, "Setting topology=%#x\n", i);
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				    "num_vports", &i)) {
+		if (i >= 0 && i <= 254) {
+			device_printf(ocs->dev, "num_vports = %d\n", i);
+			ocs->num_vports = i;
+		} else {
+			device_printf(ocs->dev, "num_vports: %d not supported \n", i);
+		}
+	}
+
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				    "external_loopback", &i)) {
+		device_printf(ocs->dev, "external_loopback = %d\n", i);
+		ocs->external_loopback = i;
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				    "tgt_rscn_delay", &i)) {
+		device_printf(ocs->dev, "tgt_rscn_delay = %d\n", i);
+		ocs->tgt_rscn_delay_msec = i * 1000;
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				    "tgt_rscn_period", &i)) {
+		device_printf(ocs->dev, "tgt_rscn_period = %d\n", i);
+		ocs->tgt_rscn_period_msec = i * 1000;
+	}
+
+	if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev),
+				    "target_io_timer", &i)) {
+		device_printf(ocs->dev, "target_io_timer = %d\n", i);
+		ocs->target_io_timer_sec = i;
+	}
+
+	hw_global.queue_topology_string = queue_topology;
+	ocs->rq_selection_policy = 0;
+	ocs->rr_quanta = 1;
+	ocs->filter_def = "0,0,0,0";
+	
+	return 0;
+}
+
+static int32_t
+ocs_setup_fcports(ocs_t *ocs)
+{
+	uint32_t        i = 0, role = 0;
+	uint64_t sli_wwpn, sli_wwnn;
+	size_t size;
+	ocs_xport_t *xport = ocs->xport;
+	ocs_vport_spec_t *vport;
+	ocs_fcport *fcp = NULL;
+
+	size = sizeof(ocs_fcport) * (ocs->num_vports + 1);
+
+	ocs->fcports = ocs_malloc(ocs, size, M_ZERO|M_NOWAIT);
+	if (ocs->fcports == NULL) {
+		device_printf(ocs->dev, "Can't allocate fcport \n");
+		return 1;
+	}
+
+	role = (ocs->enable_ini)? KNOB_ROLE_INITIATOR: 0 |
+		(ocs->enable_tgt)? KNOB_ROLE_TARGET: 0;
+
+	fcp = FCPORT(ocs, i);
+	fcp->role = role;
+	i++;
+
+	ocs_list_foreach(&xport->vport_list, vport) {
+		fcp = FCPORT(ocs, i);
+		vport->tgt_data = fcp;
+		fcp->vport = vport;
+		fcp->role = role;
+
+		if (ocs_hw_get_def_wwn(ocs, i, &sli_wwpn, &sli_wwnn)) {
+			ocs_log_err(ocs, "Get default wwn failed \n");
+			i++;
+			continue;
+		}
+
+		vport->wwpn = ocs_be64toh(sli_wwpn);
+		vport->wwnn = ocs_be64toh(sli_wwnn);
+		i++;
+		ocs_log_debug(ocs, "VPort wwpn: %lx wwnn: %lx \n", vport->wwpn, vport->wwnn);
+	}
+
+	return 0;
+}
+
+int32_t
+ocs_device_attach(ocs_t *ocs)
+{
+        int32_t i;
+	ocs_io_t *io = NULL;
+
+        if (ocs->attached) {
+                ocs_log_warn(ocs, "%s: Device is already attached\n", __func__);
+                return -1;
+        } 
+
+	/* Allocate transport object and bring online */
+	ocs->xport = ocs_xport_alloc(ocs);
+	if (ocs->xport == NULL) {
+		device_printf(ocs->dev, "failed to allocate transport object\n");
+		return ENOMEM;
+	} else if (ocs_xport_attach(ocs->xport) != 0) {
+		device_printf(ocs->dev, "%s: failed to attach transport object\n", __func__);
+		goto fail_xport_attach;
+	} else if (ocs_xport_initialize(ocs->xport) != 0) {
+		device_printf(ocs->dev, "%s: failed to initialize transport object\n", __func__);
+		goto fail_xport_init;
+	}
+
+	if (ocs_init_dma_tag(ocs)) {
+		goto fail_intr_setup; 
+	}
+
+	for (i = 0; (io = ocs_io_get_instance(ocs, i)); i++) {
+		if (bus_dmamap_create(ocs->buf_dmat, 0, &io->tgt_io.dmap)) {
+			device_printf(ocs->dev, "%s: bad dma map create\n", __func__);
+		}
+
+		io->tgt_io.state = OCS_CAM_IO_FREE;
+	}
+
+	if (ocs_setup_fcports(ocs)) {
+		device_printf(ocs->dev, "FCports creation failed\n");
+		goto fail_intr_setup;
+	}
+
+	if(ocs_cam_attach(ocs)) {
+		device_printf(ocs->dev, "cam attach failed \n");
+		goto fail_intr_setup;
+	}
+
+	if (ocs_intr_setup(ocs)) {
+		device_printf(ocs->dev, "Interrupt setup failed\n");
+		goto fail_intr_setup;
+	}
+
+	if (ocs->enable_ini || ocs->enable_tgt) {
+		if (ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE)) {
+			device_printf(ocs->dev, "Can't init port\n");
+			goto fail_xport_online;
+		}
+	}
+
+	ocs->attached = true;
+	
+	return 0;
+
+fail_xport_online:
+	if (ocs_xport_control(ocs->xport, OCS_XPORT_SHUTDOWN)) {
+		device_printf(ocs->dev, "Transport Shutdown timed out\n");
+	}
+	ocs_intr_teardown(ocs);
+fail_intr_setup:
+fail_xport_init:
+	ocs_xport_detach(ocs->xport);
+	if (ocs->config_tgt)
+		ocs_scsi_tgt_del_device(ocs);
+
+	ocs_xport_free(ocs->xport);
+	ocs->xport = NULL;
+fail_xport_attach:
+	if (ocs->xport)	
+		ocs_free(ocs, ocs->xport, sizeof(*(ocs->xport)));
+	ocs->xport = NULL;
+	return ENXIO;
+}
+
+/**
+ * @brief Connect the driver to the given device
+ *
+ * If the probe routine is successful, the OS will give the driver
+ * the opportunity to connect itself to the device. This routine
+ * maps PCI resources (memory BARs and interrupts) and initialize a
+ * hardware object.
+ *
+ * @param dev device abstraction
+ *
+ * @return 0 if the driver attaches to the device, ENXIO otherwise
+ */
+
+static int
+ocs_pci_attach(device_t dev)
+{
+	struct ocs_softc	*ocs;
+	int			instance;
+
+	instance = device_get_unit(dev);
+	
+	ocs = (struct ocs_softc *)device_get_softc(dev);
+	if (NULL == ocs) {
+		device_printf(dev, "cannot allocate softc\n");
+		return ENOMEM;
+	}
+	memset(ocs, 0, sizeof(struct ocs_softc));
+
+	if (instance < ARRAY_SIZE(ocs_devices)) {
+		ocs_devices[instance] = ocs;
+	} else {
+		device_printf(dev, "got unexpected ocs instance number %d\n", instance);
+	}
+
+	ocs->instance_index = instance;
+
+	ocs->dev = dev;
+
+	pci_enable_io(dev, SYS_RES_MEMORY);
+	pci_enable_busmaster(dev);
+
+	ocs->pci_vendor = pci_get_vendor(dev);
+	ocs->pci_device = pci_get_device(dev);
+	snprintf(ocs->businfo, sizeof(ocs->businfo), "%02X:%02X:%02X",
+		pci_get_bus(dev), pci_get_slot(dev), pci_get_function(dev));
+
+	/* Map all memory BARs */
+        if (ocs_map_bars(dev, ocs)) {
+		device_printf(dev, "Failed to map pci bars\n");
+		goto release_bus;
+        }
+	
+	/* create a root DMA tag for the device */
+	if (bus_dma_tag_create(bus_get_dma_tag(dev),
+				1,		/* byte alignment */
+				0,		/* no boundary restrictions */
+				BUS_SPACE_MAXADDR, /* no minimum low address */
+				BUS_SPACE_MAXADDR, /* no maximum high address */
+				NULL,		/* no filter function */
+				NULL,		/* or arguments */
+				BUS_SPACE_MAXSIZE, /* max size covered by tag */
+				BUS_SPACE_UNRESTRICTED, /* no segment count restrictions */
+				BUS_SPACE_MAXSIZE, /* no segment length restrictions */
+				0,		/* flags */
+				NULL,		/* no lock manipulation function */
+				NULL,		/* or arguments */
+				&ocs->dmat)) {
+		device_printf(dev, "parent DMA tag allocation failed\n");
+		goto release_bus;
+	}
+
+	if (ocs_intr_alloc(ocs)) {
+		device_printf(dev, "Interrupt allocation failed\n");
+		goto release_bus;
+	}
+
+	if (PCIC_SERIALBUS == pci_get_class(dev) &&
+			PCIS_SERIALBUS_FC == pci_get_subclass(dev))
+		ocs->ocs_xport = OCS_XPORT_FC;
+	else {
+		device_printf(dev, "unsupported class (%#x : %#x)\n",
+				pci_get_class(dev),
+				pci_get_class(dev));
+		goto release_bus;
+	}
+
+	/* Setup tunable parameters */
+	if (ocs_setup_params(ocs)) {
+		device_printf(ocs->dev, "failed to setup params\n");
+		goto release_bus;
+	}
+
+	if (ocs_device_attach(ocs)) {
+		device_printf(ocs->dev, "failed to attach device\n");
+		goto release_params;
+	}
+
+	ocs->fc_type = FC_TYPE_FCP;
+
+	ocs_debug_attach(ocs);
+
+	return 0;
+
+release_params:
+	ocs_ramlog_free(ocs, ocs->ramlog);
+	ocs_device_lock_free(ocs);
+	free(ocs->hw_war_version, M_OCS);
+release_bus:
+	ocs_release_bus(ocs);
+	return ENXIO;
+}
+
+/**
+ * @brief free resources when pci device detach
+ *
+ * @param ocs pointer to ocs structure
+ *
+ * @return 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_device_detach(ocs_t *ocs)
+{
+        int32_t rc = 0, i;
+	ocs_io_t *io = NULL;
+
+        if (ocs != NULL) {
+                if (!ocs->attached) {
+                        ocs_log_warn(ocs, "%s: Device is not attached\n", __func__);
+                        return -1;
+                }
+
+                rc = ocs_xport_control(ocs->xport, OCS_XPORT_SHUTDOWN);
+                if (rc) {
+                        ocs_log_err(ocs, "%s: Transport Shutdown timed out\n", __func__);
+                }
+
+		ocs_intr_teardown(ocs);
+
+                if (ocs_xport_detach(ocs->xport) != 0) {
+                        ocs_log_err(ocs, "%s: Transport detach failed\n", __func__);
+                }
+
+		ocs_cam_detach(ocs);
+		ocs_free(ocs, ocs->fcports, sizeof(ocs->fcports));
+
+		for (i = 0; (io = ocs_io_get_instance(ocs, i)); i++) {
+			if (bus_dmamap_destroy(ocs->buf_dmat, io->tgt_io.dmap)) {
+				device_printf(ocs->dev, "%s: bad dma map destroy\n", __func__);
+			}
+		}
+		bus_dma_tag_destroy(ocs->dmat);
+                ocs_xport_free(ocs->xport);
+                ocs->xport = NULL;
+
+                ocs->attached = FALSE;
+
+        }
+
+        return 0;
+}
+
+
+/**
+ * @brief Detach the driver from the given device
+ *
+ * If the driver is a loadable module, this routine gets called at unload
+ * time. This routine will stop the device and free any allocated resources.
+ *
+ * @param dev device abstraction
+ *
+ * @return 0 if the driver detaches from the device, ENXIO otherwise
+ */
+static int
+ocs_pci_detach(device_t dev)
+{
+	struct ocs_softc	*ocs;
+
+	ocs = (struct ocs_softc *)device_get_softc(dev);
+	if (!ocs) {
+		device_printf(dev, "no driver context?!?\n");
+		return -1;
+	}
+
+	if (ocs->config_tgt && ocs->enable_tgt) {
+		device_printf(dev, "can't detach with target mode enabled\n");
+		return EBUSY;
+	}
+
+	ocs_device_detach(ocs);
+
+	/*
+	 * Workaround for OCS SCSI Transport quirk.
+	 *
+	 * CTL requires that target mode is disabled prior to unloading the
+	 * driver (ie ocs->enable_tgt = FALSE), but once the target is disabled,
+	 * the transport will not call ocs_scsi_tgt_del_device() which deallocates
+	 * CAM resources. The workaround is to explicitly make the call here.
+	 */
+	if (ocs->config_tgt)
+		ocs_scsi_tgt_del_device(ocs);
+        
+	/* free strdup created buffer.*/
+	free(ocs->hw_war_version, M_OCS);
+
+	ocs_device_lock_free(ocs);
+
+	ocs_debug_detach(ocs);
+
+	ocs_ramlog_free(ocs, ocs->ramlog);
+
+	ocs_release_bus(ocs);
+
+	return 0;
+}
+
+/**
+ * @brief Notify driver of system shutdown
+ *
+ * @param dev device abstraction
+ *
+ * @return 0 if the driver attaches to the device, ENXIO otherwise
+ */
+static int
+ocs_pci_shutdown(device_t dev)
+{
+	device_printf(dev, "%s\n", __func__);
+	return 0;
+}
+
+/**
+ * @brief Release bus resources allocated within the soft context
+ *
+ * @param ocs Pointer to the driver's context
+ *
+ * @return none
+ */
+static void
+ocs_release_bus(struct ocs_softc *ocs)
+{
+
+	if (NULL != ocs) {
+		uint32_t	i;
+
+		ocs_intr_teardown(ocs);
+
+		if (ocs->irq) {
+			bus_release_resource(ocs->dev, SYS_RES_IRQ,
+					rman_get_rid(ocs->irq), ocs->irq);
+
+			if (ocs->n_vec) {
+				pci_release_msi(ocs->dev);
+				ocs->n_vec = 0;
+			}
+
+			ocs->irq = NULL;
+		}
+
+		bus_dma_tag_destroy(ocs->dmat);
+
+		for (i = 0; i < PCI_MAX_BAR; i++) {
+			if (ocs->reg[i].res) {
+				bus_release_resource(ocs->dev, SYS_RES_MEMORY,
+						ocs->reg[i].rid,
+						ocs->reg[i].res);
+			}
+		}
+	}
+}
+
+/**
+ * @brief Allocate and initialize interrupts
+ *
+ * @param ocs Pointer to the driver's context
+ *
+ * @return none
+ */
+static int32_t
+ocs_intr_alloc(struct ocs_softc *ocs)
+{
+
+	ocs->n_vec = 1;
+	if (pci_alloc_msix(ocs->dev, &ocs->n_vec)) {
+		device_printf(ocs->dev, "MSI-X allocation failed\n");
+		if (pci_alloc_msi(ocs->dev, &ocs->n_vec)) {
+			device_printf(ocs->dev, "MSI allocation failed \n");
+			ocs->irqid = 0;
+			ocs->n_vec = 0;
+		} else 
+			ocs->irqid = 1;
+	} else {
+		ocs->irqid = 1;
+	}
+
+	ocs->irq = bus_alloc_resource_any(ocs->dev, SYS_RES_IRQ, &ocs->irqid,
+			RF_ACTIVE | RF_SHAREABLE);
+	if (NULL == ocs->irq) {
+		device_printf(ocs->dev, "could not allocate interrupt\n");
+		return -1;
+	}
+
+	ocs->intr_ctx.vec = 0;
+	ocs->intr_ctx.softc = ocs;
+	snprintf(ocs->intr_ctx.name, sizeof(ocs->intr_ctx.name),
+			"%s_intr_%d",
+			device_get_nameunit(ocs->dev),
+			ocs->intr_ctx.vec);
+
+	return 0;
+}
+
+/**
+ * @brief Create and attach an interrupt handler
+ *
+ * @param ocs Pointer to the driver's context
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_intr_setup(struct ocs_softc *ocs)
+{
+	driver_filter_t	*filter = NULL;
+
+	if (0 == ocs->n_vec) {
+		filter = ocs_pci_intx_filter;
+	}
+
+	if (bus_setup_intr(ocs->dev, ocs->irq, INTR_MPSAFE | INTR_TYPE_CAM,
+				filter, ocs_pci_intr, &ocs->intr_ctx,
+				&ocs->tag)) {
+		device_printf(ocs->dev, "could not initialize interrupt\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+/**
+ * @brief Detach an interrupt handler
+ *
+ * @param ocs Pointer to the driver's context
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_intr_teardown(struct ocs_softc *ocs)
+{
+
+	if (!ocs) {
+		printf("%s: bad driver context?!?\n", __func__);
+		return -1;
+	}
+
+	if (ocs->tag) {
+		bus_teardown_intr(ocs->dev, ocs->irq, ocs->tag);
+		ocs->tag = NULL;
+	}
+
+	return 0;
+}
+
+/**
+ * @brief PCI interrupt handler
+ *
+ * @param arg pointer to the driver's software context
+ *
+ * @return FILTER_HANDLED if interrupt is processed, FILTER_STRAY otherwise
+ */
+static int
+ocs_pci_intx_filter(void *arg)
+{
+	ocs_intr_ctx_t	*intr = arg;
+	struct ocs_softc *ocs = NULL;
+	uint16_t	val = 0;
+
+	if (NULL == intr) {
+		return FILTER_STRAY;
+	}
+
+	ocs = intr->softc;
+#ifndef PCIM_STATUS_INTR
+#define PCIM_STATUS_INTR	0x0008
+#endif
+	val = pci_read_config(ocs->dev, PCIR_STATUS, 2);
+	if (0xffff == val) {
+		device_printf(ocs->dev, "%s: pci_read_config(PCIR_STATUS) failed\n", __func__);
+		return FILTER_STRAY;
+	}
+	if (0 == (val & PCIM_STATUS_INTR)) {
+		return FILTER_STRAY;
+	}
+
+	val = pci_read_config(ocs->dev, PCIR_COMMAND, 2);
+	val |= PCIM_CMD_INTxDIS;
+	pci_write_config(ocs->dev, PCIR_COMMAND, val, 2);
+
+	return FILTER_SCHEDULE_THREAD;
+}
+
+/**
+ * @brief interrupt handler
+ *
+ * @param context pointer to the interrupt context
+ */
+static void
+ocs_pci_intr(void *context)
+{
+	ocs_intr_ctx_t	*intr = context;
+	struct ocs_softc *ocs = intr->softc;
+
+	mtx_lock(&ocs->sim_lock);
+		ocs_hw_process(&ocs->hw, intr->vec, OCS_OS_MAX_ISR_TIME_MSEC);
+	mtx_unlock(&ocs->sim_lock);
+}
+
+/**
+ * @brief Initialize DMA tag
+ *
+ * @param ocs the driver instance's software context
+ *
+ * @return 0 on success, non-zero otherwise
+ */
+static int32_t
+ocs_init_dma_tag(struct ocs_softc *ocs)
+{
+	uint32_t	max_sgl = 0;
+	uint32_t	max_sge = 0;
+
+	/*
+	 * IOs can't use the parent DMA tag and must create their
+	 * own, based primarily on a restricted number of DMA segments.
+	 * This is more of a BSD requirement than a SLI Port requirement
+	 */
+	ocs_hw_get(&ocs->hw, OCS_HW_N_SGL, &max_sgl);
+	ocs_hw_get(&ocs->hw, OCS_HW_MAX_SGE, &max_sge);
+
+	if (bus_dma_tag_create(ocs->dmat,
+				1,		/* byte alignment */
+				0,		/* no boundary restrictions */
+				BUS_SPACE_MAXADDR, /* no minimum low address */
+				BUS_SPACE_MAXADDR, /* no maximum high address */
+				NULL,		/* no filter function */
+				NULL,		/* or arguments */
+				BUS_SPACE_MAXSIZE, /* max size covered by tag */
+				max_sgl, 	/* segment count restrictions */
+				max_sge,	/* segment length restrictions */
+				0,		/* flags */
+				NULL,		/* no lock manipulation function */
+				NULL,		/* or arguments */
+				&ocs->buf_dmat)) {
+		device_printf(ocs->dev, "%s: bad bus_dma_tag_create(buf_dmat)\n", __func__);
+		return -1;
+	}
+	return 0;
+}
+
+int32_t
+ocs_get_property(const char *prop_name, char *buffer, uint32_t buffer_len)
+{
+	return -1;
+}
+
+/**
+ * @brief return pointer to ocs structure given instance index
+ *
+ * A pointer to an ocs structure is returned given an instance index.
+ *
+ * @param index index to ocs_devices array
+ *
+ * @return ocs pointer
+ */
+
+ocs_t *ocs_get_instance(uint32_t index)
+{
+	if (index < ARRAY_SIZE(ocs_devices)) {
+		return ocs_devices[index];
+	}
+	return NULL;
+}
+
+/**
+ * @brief Return instance index of an opaque ocs structure
+ *
+ * Returns the ocs instance index
+ *
+ * @param os pointer to ocs instance
+ *
+ * @return pointer to ocs instance index
+ */
+uint32_t
+ocs_instance(void *os)
+{
+	ocs_t *ocs = os;
+	return ocs->instance_index;
+}
+
+static device_method_t ocs_methods[] = {
+	DEVMETHOD(device_probe,		ocs_pci_probe),
+	DEVMETHOD(device_attach,	ocs_pci_attach),
+	DEVMETHOD(device_detach,	ocs_pci_detach),
+	DEVMETHOD(device_shutdown,	ocs_pci_shutdown),
+	{0, 0}
+};
+
+static driver_t ocs_driver = {
+	"ocs_fc",
+	ocs_methods,
+	sizeof(struct ocs_softc)
+};
+
+static devclass_t ocs_devclass;
+
+DRIVER_MODULE(ocs_fc, pci, ocs_driver, ocs_devclass, 0, 0);
+MODULE_VERSION(ocs_fc, 1);
+
diff --git a/sys/dev/ocs_fc/ocs_scsi.c b/sys/dev/ocs_fc/ocs_scsi.c
new file mode 100644
index 000000000000..20be08eddf05
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_scsi.c
@@ -0,0 +1,2960 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS Linux SCSI API base driver implementation.
+ */
+
+/**
+ * @defgroup scsi_api_base SCSI Base Target/Initiator
+ */
+ 
+ 
+#include "ocs.h"
+#include "ocs_els.h"
+#include "ocs_scsi.h"
+#if defined(OCS_ENABLE_VPD_SUPPORT)
+#include "ocs_vpd.h"
+#endif
+#include "ocs_utils.h"
+#include "ocs_device.h"
+
+#define SCSI_IOFMT "[%04x][i:%0*x t:%0*x h:%04x]"
+#define SCSI_ITT_SIZE(ocs)	((ocs->ocs_xport == OCS_XPORT_FC) ? 4 : 8)
+
+#define SCSI_IOFMT_ARGS(io) io->instance_index, SCSI_ITT_SIZE(io->ocs), io->init_task_tag, SCSI_ITT_SIZE(io->ocs), io->tgt_task_tag, io->hw_tag
+
+#define enable_tsend_auto_resp(ocs)		((ocs->ctrlmask & OCS_CTRLMASK_XPORT_DISABLE_AUTORSP_TSEND) == 0)
+#define enable_treceive_auto_resp(ocs)	((ocs->ctrlmask & OCS_CTRLMASK_XPORT_DISABLE_AUTORSP_TRECEIVE) == 0)
+
+#define scsi_io_printf(io, fmt, ...) ocs_log_info(io->ocs, "[%s]" SCSI_IOFMT fmt, \
+	io->node->display_name, SCSI_IOFMT_ARGS(io), ##__VA_ARGS__)
+
+#define scsi_io_trace(io, fmt, ...) \
+	do { \
+		if (OCS_LOG_ENABLE_SCSI_TRACE(io->ocs)) \
+			scsi_io_printf(io, fmt, ##__VA_ARGS__); \
+	} while (0)
+
+#define scsi_log(ocs, fmt, ...) \
+	do { \
+		if (OCS_LOG_ENABLE_SCSI_TRACE(ocs)) \
+			ocs_log_info(ocs, fmt, ##__VA_ARGS__); \
+	} while (0)
+
+static int32_t ocs_target_send_bls_resp(ocs_io_t *io, ocs_scsi_io_cb_t cb, void *arg);
+static int32_t ocs_scsi_abort_io_cb(struct ocs_hw_io_s *hio, ocs_remote_node_t *rnode, uint32_t len, int32_t status,
+	uint32_t ext, void *arg);
+
+static void ocs_scsi_io_free_ovfl(ocs_io_t *io);
+static uint32_t ocs_scsi_count_sgls(ocs_hw_dif_info_t *hw_dif, ocs_scsi_sgl_t *sgl, uint32_t sgl_count);
+static int ocs_scsi_dif_guard_is_crc(uint8_t direction, ocs_hw_dif_info_t *dif_info);
+static ocs_scsi_io_status_e ocs_scsi_dif_check_unknown(ocs_io_t *io, uint32_t length, uint32_t check_length, int is_crc);
+static uint32_t ocs_scsi_dif_check_guard(ocs_hw_dif_info_t *dif_info, ocs_scsi_vaddr_len_t addrlen[],
+	uint32_t addrlen_count, ocs_dif_t *dif, int is_crc);
+static uint32_t ocs_scsi_dif_check_app_tag(ocs_t *ocs, ocs_hw_dif_info_t *dif_info, uint16_t exp_app_tag, ocs_dif_t *dif);
+static uint32_t ocs_scsi_dif_check_ref_tag(ocs_t *ocs, ocs_hw_dif_info_t *dif_info, uint32_t exp_ref_tag, ocs_dif_t *dif);
+static int32_t ocs_scsi_convert_dif_info(ocs_t *ocs, ocs_scsi_dif_info_t *scsi_dif_info,
+	ocs_hw_dif_info_t *hw_dif_info);
+static int32_t ocs_scsi_io_dispatch_hw_io(ocs_io_t *io, ocs_hw_io_t *hio);
+static int32_t ocs_scsi_io_dispatch_no_hw_io(ocs_io_t *io);
+static void _ocs_scsi_io_free(void *arg);
+
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Returns a big-endian 32-bit value given a pointer.
+ *
+ * @param p Pointer to the 32-bit big-endian location.
+ *
+ * @return Returns the byte-swapped 32-bit value.
+ */
+
+static inline uint32_t
+ocs_fc_getbe32(void *p)
+{
+	return ocs_be32toh(*((uint32_t*)p));
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Enable IO allocation.
+ *
+ * @par Description
+ * The SCSI and Transport IO allocation functions are enabled. If the allocation functions
+ * are not enabled, then calls to ocs_scsi_io_alloc() (and ocs_els_io_alloc() for FC) will
+ * fail.
+ *
+ * @param node Pointer to node object.
+ *
+ * @return None.
+ */
+void
+ocs_scsi_io_alloc_enable(ocs_node_t *node)
+{
+	ocs_assert(node != NULL);
+	ocs_lock(&node->active_ios_lock);
+		node->io_alloc_enabled = TRUE;
+	ocs_unlock(&node->active_ios_lock);
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Disable IO allocation
+ *
+ * @par Description
+ * The SCSI and Transport IO allocation functions are disabled. If the allocation functions
+ * are not enabled, then calls to ocs_scsi_io_alloc() (and ocs_els_io_alloc() for FC) will
+ * fail.
+ *
+ * @param node Pointer to node object
+ *
+ * @return None.
+ */
+void
+ocs_scsi_io_alloc_disable(ocs_node_t *node)
+{
+	ocs_assert(node != NULL);
+	ocs_lock(&node->active_ios_lock);
+		node->io_alloc_enabled = FALSE;
+	ocs_unlock(&node->active_ios_lock);
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Allocate a SCSI IO context.
+ *
+ * @par Description
+ * A SCSI IO context is allocated and associated with a @c node. This function
+ * is called by an initiator-client when issuing SCSI commands to remote
+ * target devices. On completion, ocs_scsi_io_free() is called.
+ * @n @n
+ * The returned ocs_io_t structure has an element of type ocs_scsi_ini_io_t named
+ * &quot;ini_io&quot; that is declared and used by an initiator-client for private information.
+ *
+ * @param node Pointer to the associated node structure.
+ * @param role Role for IO (originator/responder).
+ *
+ * @return Returns the pointer to the IO context, or NULL.
+ *
+ */
+
+ocs_io_t *
+ocs_scsi_io_alloc(ocs_node_t *node, ocs_scsi_io_role_e role)
+{
+	ocs_t *ocs;
+	ocs_xport_t *xport;
+	ocs_io_t *io;
+
+	ocs_assert(node, NULL);
+	ocs_assert(node->ocs, NULL);
+
+	ocs = node->ocs;
+	ocs_assert(ocs->xport, NULL);
+	xport = ocs->xport;
+
+	ocs_lock(&node->active_ios_lock);
+
+		if (!node->io_alloc_enabled) {
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		io = ocs_io_alloc(ocs);
+		if (io == NULL) {
+			ocs_atomic_add_return(&xport->io_alloc_failed_count, 1);
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		/* initialize refcount */
+		ocs_ref_init(&io->ref, _ocs_scsi_io_free, io);
+
+		if (io->hio != NULL) {
+			ocs_log_err(node->ocs, "assertion failed: io->hio is not NULL\n");
+			ocs_unlock(&node->active_ios_lock);
+			return NULL;
+		}
+
+		/* set generic fields */
+		io->ocs = ocs;
+		io->node = node;
+
+		/* set type and name */
+		io->io_type = OCS_IO_TYPE_IO;
+		io->display_name = "scsi_io";
+
+		switch (role) {
+		case OCS_SCSI_IO_ROLE_ORIGINATOR:
+			io->cmd_ini = TRUE;
+			io->cmd_tgt = FALSE;
+			break;
+		case OCS_SCSI_IO_ROLE_RESPONDER:
+			io->cmd_ini = FALSE;
+			io->cmd_tgt = TRUE;
+			break;
+		}
+
+		/* Add to node's active_ios list */
+		ocs_list_add_tail(&node->active_ios, io);
+
+	ocs_unlock(&node->active_ios_lock);
+
+	return io;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Free a SCSI IO context (internal).
+ *
+ * @par Description
+ * The IO context previously allocated using ocs_scsi_io_alloc()
+ * is freed. This is called from within the transport layer,
+ * when the reference count goes to zero.
+ *
+ * @param arg Pointer to the IO context.
+ *
+ * @return None.
+ */
+static void
+_ocs_scsi_io_free(void *arg)
+{
+	ocs_io_t *io = (ocs_io_t *)arg;
+	ocs_t *ocs = io->ocs;
+	ocs_node_t *node = io->node;
+	int send_empty_event;
+
+	ocs_assert(io != NULL);
+
+	scsi_io_trace(io, "freeing io 0x%p %s\n", io, io->display_name);
+
+	ocs_assert(ocs_io_busy(io));
+
+	ocs_lock(&node->active_ios_lock);
+		ocs_list_remove(&node->active_ios, io);
+		send_empty_event = (!node->io_alloc_enabled) && ocs_list_empty(&node->active_ios);
+	ocs_unlock(&node->active_ios_lock);
+
+	if (send_empty_event) {
+		ocs_node_post_event(node, OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY, NULL);
+	}
+
+	io->node = NULL;
+	ocs_io_free(ocs, io);
+
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Free a SCSI IO context.
+ *
+ * @par Description
+ * The IO context previously allocated using ocs_scsi_io_alloc() is freed.
+ *
+ * @param io Pointer to the IO context.
+ *
+ * @return None.
+ */
+void
+ocs_scsi_io_free(ocs_io_t *io)
+{
+	scsi_io_trace(io, "freeing io 0x%p %s\n", io, io->display_name);
+	ocs_assert(ocs_ref_read_count(&io->ref) > 0);
+	ocs_ref_put(&io->ref); /* ocs_ref_get(): ocs_scsi_io_alloc() */
+}
+
+
+
+static int32_t
+ocs_scsi_send_io(ocs_hw_io_type_e type, ocs_node_t *node, ocs_io_t *io, uint64_t lun,
+	ocs_scsi_tmf_cmd_e tmf, uint8_t *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len, uint32_t first_burst,
+	ocs_scsi_rsp_io_cb_t cb, void *arg);
+
+/**
+ * @brief Target response completion callback.
+ *
+ * @par Description
+ * Function is called upon the completion of a target IO request.
+ *
+ * @param hio Pointer to the HW IO structure.
+ * @param rnode Remote node associated with the IO that is completing.
+ * @param length Length of the response payload.
+ * @param status Completion status.
+ * @param ext_status Extended completion status.
+ * @param app Application-specific data (generally a pointer to the IO context).
+ *
+ * @return None.
+ */
+
+static void
+ocs_target_io_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length,
+	int32_t status, uint32_t ext_status, void *app)
+{
+	ocs_io_t *io = app;
+	ocs_t *ocs;
+	ocs_scsi_io_status_e scsi_status = OCS_SCSI_STATUS_GOOD;
+	uint16_t additional_length;
+	uint8_t edir;
+	uint8_t tdpv;
+	ocs_hw_dif_info_t *dif_info = &io->hw_dif;
+	int is_crc;
+
+	ocs_assert(io);
+
+	scsi_io_trace(io, "status x%x ext_status x%x\n", status, ext_status);
+
+	ocs = io->ocs;
+	ocs_assert(ocs);
+
+	ocs_scsi_io_free_ovfl(io);
+
+	io->transferred += length;
+
+	/* Call target server completion */
+	if (io->scsi_tgt_cb) {
+		ocs_scsi_io_cb_t cb = io->scsi_tgt_cb;
+		uint32_t flags = 0;
+
+		/* Clear the callback before invoking the callback */
+		io->scsi_tgt_cb = NULL;
+
+		/* if status was good, and auto-good-response was set, then callback
+		 * target-server with IO_CMPL_RSP_SENT, otherwise send IO_CMPL
+		 */
+		if ((status == 0) && (io->auto_resp))
+			flags |= OCS_SCSI_IO_CMPL_RSP_SENT;
+		else
+			flags |= OCS_SCSI_IO_CMPL;
+
+		switch (status) {
+		case SLI4_FC_WCQE_STATUS_SUCCESS:
+			scsi_status = OCS_SCSI_STATUS_GOOD;
+			break;
+		case SLI4_FC_WCQE_STATUS_DI_ERROR:
+			if (ext_status & SLI4_FC_DI_ERROR_GE) {
+				scsi_status = OCS_SCSI_STATUS_DIF_GUARD_ERROR;
+			} else if (ext_status & SLI4_FC_DI_ERROR_AE) {
+				scsi_status = OCS_SCSI_STATUS_DIF_APP_TAG_ERROR;
+			} else if (ext_status & SLI4_FC_DI_ERROR_RE) {
+				scsi_status = OCS_SCSI_STATUS_DIF_REF_TAG_ERROR;
+			} else {
+				additional_length = ((ext_status >> 16) & 0xFFFF);
+
+				/* Capture the EDIR and TDPV bits as 0 or 1 for easier printing. */
+				edir = !!(ext_status & SLI4_FC_DI_ERROR_EDIR);
+				tdpv = !!(ext_status & SLI4_FC_DI_ERROR_TDPV);
+
+				is_crc = ocs_scsi_dif_guard_is_crc(edir, dif_info);
+
+				if (edir == 0) {
+					/* For reads, we have everything in memory.  Start checking from beginning. */
+					scsi_status = ocs_scsi_dif_check_unknown(io, 0, io->wire_len, is_crc);
+				} else {
+					/* For writes, use the additional length to determine where to look for the error.
+					 * The additional_length field is set to 0 if it is not supported.
+					 * The additional length field is valid if:
+					 *    . additional_length is not zero
+					 *    . Total Data Placed is valid
+					 *    . Error Direction is RX (1)
+					 *    . Operation is a pass thru (CRC or CKSUM on IN, and CRC or CHKSUM on OUT) (all pass-thru cases except raw)
+					 */
+					if ((additional_length != 0) && (tdpv != 0) &&
+					    (dif_info->dif == SLI4_DIF_PASS_THROUGH) && (dif_info->dif_oper != OCS_HW_SGE_DIF_OP_IN_RAW_OUT_RAW) ) {
+						scsi_status = ocs_scsi_dif_check_unknown(io, length, additional_length, is_crc);
+					} else {
+						/* If we can't do additional checking, then fall-back to guard error */
+						scsi_status = OCS_SCSI_STATUS_DIF_GUARD_ERROR;
+					}
+				}
+			}
+			break;
+		case SLI4_FC_WCQE_STATUS_LOCAL_REJECT:
+			switch (ext_status) {
+			case SLI4_FC_LOCAL_REJECT_INVALID_RELOFFSET:
+			case SLI4_FC_LOCAL_REJECT_ABORT_REQUESTED:
+				scsi_status = OCS_SCSI_STATUS_ABORTED;
+				break;
+			case SLI4_FC_LOCAL_REJECT_INVALID_RPI:
+				scsi_status = OCS_SCSI_STATUS_NEXUS_LOST;
+				break;
+			case SLI4_FC_LOCAL_REJECT_NO_XRI:
+				scsi_status = OCS_SCSI_STATUS_NO_IO;
+				break;
+			default:
+				/* TODO: we have seen 0x0d (TX_DMA_FAILED error) */
+				scsi_status = OCS_SCSI_STATUS_ERROR;
+				break;
+			}
+			break;
+
+		case SLI4_FC_WCQE_STATUS_TARGET_WQE_TIMEOUT:
+			/* target IO timed out */
+			scsi_status = OCS_SCSI_STATUS_TIMEDOUT_AND_ABORTED;
+			break;
+
+		case SLI4_FC_WCQE_STATUS_SHUTDOWN:
+			/* Target IO cancelled by HW */
+			scsi_status = OCS_SCSI_STATUS_SHUTDOWN;
+			break;
+
+		default:
+			scsi_status = OCS_SCSI_STATUS_ERROR;
+			break;
+		}
+
+		cb(io, scsi_status, flags, io->scsi_tgt_cb_arg);
+
+	}
+	ocs_scsi_check_pending(ocs);
+}
+
+/**
+ * @brief Determine if an IO is using CRC for DIF guard format.
+ *
+ * @param direction IO direction: 1 for write, 0 for read.
+ * @param dif_info Pointer to HW DIF info data.
+ *
+ * @return Returns TRUE if using CRC, FALSE if not.
+ */
+static int
+ocs_scsi_dif_guard_is_crc(uint8_t direction, ocs_hw_dif_info_t *dif_info)
+{
+	int is_crc;
+
+	if (direction) {
+		/* For writes, check if operation is "OUT_CRC" or not */
+		switch(dif_info->dif_oper) {
+			case OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC:
+			case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC:
+			case OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CRC:
+				is_crc = TRUE;
+				break;
+			default:
+				is_crc = FALSE;
+				break;
+		}
+	} else {
+		/* For reads, check if operation is "IN_CRC" or not */
+		switch(dif_info->dif_oper) {
+			case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF:
+			case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC:
+			case OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CHKSUM:
+				is_crc = TRUE;
+				break;
+			default:
+				is_crc = FALSE;
+				break;
+		}
+	}
+
+	return is_crc;
+}
+
+/**
+ * @brief Check a block and DIF data, computing the appropriate SCSI status
+ *
+ * @par Description
+ * This function is used to check blocks and DIF when given an unknown DIF
+ * status using the following logic:
+ *
+ * Given the address of the last good block, and a length of bytes that includes
+ * the block with the DIF error, find the bad block. If a block is found with an
+ * app_tag or ref_tag error, then return the appropriate error. No block is expected
+ * to have a block guard error since hardware "fixes" the crc. So if no block in the
+ * range of blocks has an error, then it is presumed to be a BLOCK GUARD error.
+ *
+ * @param io Pointer to the IO object.
+ * @param length Length of bytes covering the good blocks.
+ * @param check_length Length of bytes that covers the bad block.
+ * @param is_crc True if guard is using CRC format.
+ *
+ * @return Returns SCSI status.
+ */
+
+static ocs_scsi_io_status_e
+ocs_scsi_dif_check_unknown(ocs_io_t *io, uint32_t length, uint32_t check_length, int is_crc)
+{
+	uint32_t i;
+	ocs_t *ocs = io->ocs;
+	ocs_hw_dif_info_t *dif_info = &io->hw_dif;
+	ocs_scsi_io_status_e scsi_status = OCS_SCSI_STATUS_DIF_GUARD_ERROR;
+	uint32_t blocksize;			/* data block size */
+	uint64_t first_check_block;		/* first block following total data placed */
+	uint64_t last_check_block;		/* last block to check */
+	uint32_t check_count;			/* count of blocks to check */
+	ocs_scsi_vaddr_len_t addrlen[4];	/* address-length pairs returned from target */
+	int32_t addrlen_count;			/* count of address-length pairs */
+	ocs_dif_t *dif;				/* pointer to DIF block returned from target */
+	ocs_scsi_dif_info_t scsi_dif_info = io->scsi_dif_info;
+
+	blocksize = ocs_hw_dif_mem_blocksize(&io->hw_dif, TRUE);
+	first_check_block = length / blocksize;
+	last_check_block = ((length + check_length) / blocksize);
+	check_count = last_check_block - first_check_block;
+
+	ocs_log_debug(ocs, "blocksize %d first check_block %" PRId64 " last_check_block %" PRId64 " check_count %d\n",
+		blocksize, first_check_block, last_check_block, check_count);
+
+	for (i = first_check_block; i < last_check_block; i++) {
+		addrlen_count = ocs_scsi_get_block_vaddr(io, (scsi_dif_info.lba + i), addrlen, ARRAY_SIZE(addrlen), (void**) &dif);
+		if (addrlen_count < 0) {
+			ocs_log_test(ocs, "ocs_scsi_get_block_vaddr() failed: %d\n", addrlen_count);
+			scsi_status = OCS_SCSI_STATUS_DIF_UNKNOWN_ERROR;
+			break;
+		}
+
+		if (! ocs_scsi_dif_check_guard(dif_info, addrlen, addrlen_count, dif, is_crc)) {
+			ocs_log_debug(ocs, "block guard check error, lba %" PRId64 "\n", scsi_dif_info.lba + i);
+			scsi_status = OCS_SCSI_STATUS_DIF_GUARD_ERROR;
+			break;
+		}
+		if (! ocs_scsi_dif_check_app_tag(ocs, dif_info, scsi_dif_info.app_tag, dif)) {
+			ocs_log_debug(ocs, "app tag check error, lba %" PRId64 "\n", scsi_dif_info.lba + i);
+			scsi_status = OCS_SCSI_STATUS_DIF_APP_TAG_ERROR;
+			break;
+		}
+		if (! ocs_scsi_dif_check_ref_tag(ocs, dif_info, (scsi_dif_info.ref_tag + i), dif)) {
+			ocs_log_debug(ocs, "ref tag check error, lba %" PRId64 "\n", scsi_dif_info.lba + i);
+			scsi_status = OCS_SCSI_STATUS_DIF_REF_TAG_ERROR;
+			break;
+		}
+
+	}
+	return scsi_status;
+}
+
+/**
+ * @brief Check the block guard of block data
+ *
+ * @par Description
+ * Using the dif_info for the transfer, check the block guard value.
+ *
+ * @param dif_info Pointer to HW DIF info data.
+ * @param addrlen Array of address length pairs.
+ * @param addrlen_count Number of entries in the addrlen[] array.
+ * @param dif Pointer to the DIF data block being checked.
+ * @param is_crc True if guard is using CRC format.
+ *
+ * @return Returns TRUE if block guard check is ok.
+ */
+static uint32_t
+ocs_scsi_dif_check_guard(ocs_hw_dif_info_t *dif_info, ocs_scsi_vaddr_len_t addrlen[], uint32_t addrlen_count,
+	ocs_dif_t *dif, int is_crc)
+{
+	uint16_t crc = dif_info->dif_seed;
+	uint32_t i;
+	uint16_t checksum;
+
+	if ((dif == NULL)  || !dif_info->check_guard) {
+		return TRUE;
+	}
+
+	if (is_crc) {
+		for (i = 0; i < addrlen_count; i++) {
+			crc = ocs_scsi_dif_calc_crc(addrlen[i].vaddr, addrlen[i].length, crc);
+		}
+		return (crc == ocs_be16toh(dif->crc));
+	} else {
+		checksum = ocs_scsi_dif_calc_checksum(addrlen, addrlen_count);
+
+		return (checksum == dif->crc);
+	}
+}
+
+/**
+ * @brief Check the app tag of dif data
+ *
+ * @par Description
+ * Using the dif_info for the transfer, check the app tag.
+ *
+ * @param ocs Pointer to the ocs structure for logging.
+ * @param dif_info Pointer to HW DIF info data.
+ * @param exp_app_tag The value the app tag is expected to be.
+ * @param dif Pointer to the DIF data block being checked.
+ *
+ * @return Returns TRUE if app tag check is ok.
+ */
+static uint32_t
+ocs_scsi_dif_check_app_tag(ocs_t *ocs, ocs_hw_dif_info_t *dif_info, uint16_t exp_app_tag, ocs_dif_t *dif)
+{
+	if ((dif == NULL)  || !dif_info->check_app_tag) {
+		return TRUE;
+	}
+
+	ocs_log_debug(ocs, "expected app tag 0x%x,  actual 0x%x\n",
+		exp_app_tag, ocs_be16toh(dif->app_tag));
+
+	return (exp_app_tag == ocs_be16toh(dif->app_tag));
+}
+
+/**
+ * @brief Check the ref tag of dif data
+ *
+ * @par Description
+ * Using the dif_info for the transfer, check the app tag.
+ *
+ * @param ocs Pointer to the ocs structure for logging.
+ * @param dif_info Pointer to HW DIF info data.
+ * @param exp_ref_tag The value the ref tag is expected to be.
+ * @param dif Pointer to the DIF data block being checked.
+ *
+ * @return Returns TRUE if ref tag check is ok.
+ */
+static uint32_t
+ocs_scsi_dif_check_ref_tag(ocs_t *ocs, ocs_hw_dif_info_t *dif_info, uint32_t exp_ref_tag, ocs_dif_t *dif)
+{
+	if ((dif == NULL)  || !dif_info->check_ref_tag) {
+		return TRUE;
+	}
+
+	if (exp_ref_tag != ocs_be32toh(dif->ref_tag)) {
+		ocs_log_debug(ocs, "expected ref tag 0x%x, actual 0x%x\n",
+			exp_ref_tag, ocs_be32toh(dif->ref_tag));
+		return FALSE;
+	} else {
+		return TRUE;
+	}
+}
+
+/**
+ * @brief Return count of SGE's required for request
+ *
+ * @par Description
+ * An accurate count of SGEs is computed and returned.
+ *
+ * @param hw_dif Pointer to HW dif information.
+ * @param sgl Pointer to SGL from back end.
+ * @param sgl_count Count of SGEs in SGL.
+ *
+ * @return Count of SGEs.
+ */
+static uint32_t
+ocs_scsi_count_sgls(ocs_hw_dif_info_t *hw_dif, ocs_scsi_sgl_t *sgl, uint32_t sgl_count)
+{
+	uint32_t count = 0;
+	uint32_t i;
+
+	/* Convert DIF Information */
+	if (hw_dif->dif_oper != OCS_HW_DIF_OPER_DISABLED) {
+
+		/* If we're not DIF separate, then emit a seed SGE */
+		if (!hw_dif->dif_separate) {
+			count++;
+		}
+
+		for (i = 0; i < sgl_count; i++) {
+			/* If DIF is enabled, and DIF is separate, then append a SEED then DIF SGE */
+			if (hw_dif->dif_separate) {
+				count += 2;
+			}
+
+			count++;
+		}
+	} else {
+		count = sgl_count;
+	}
+	return count;
+}
+
+static int32_t
+ocs_scsi_build_sgls(ocs_hw_t *hw, ocs_hw_io_t *hio, ocs_hw_dif_info_t *hw_dif, ocs_scsi_sgl_t *sgl, uint32_t sgl_count, ocs_hw_io_type_e type)
+{
+	int32_t rc;
+	uint32_t i;
+	ocs_t *ocs = hw->os;
+	uint32_t blocksize = 0;
+	uint32_t blockcount;
+
+	ocs_assert(hio, -1);
+
+	/* Initialize HW SGL */
+	rc = ocs_hw_io_init_sges(hw, hio, type);
+	if (rc) {
+		ocs_log_err(ocs, "ocs_hw_io_init_sges failed: %d\n", rc);
+		return -1;
+	}
+
+	/* Convert DIF Information */
+	if (hw_dif->dif_oper != OCS_HW_DIF_OPER_DISABLED) {
+
+		/* If we're not DIF separate, then emit a seed SGE */
+		if (!hw_dif->dif_separate) {
+			rc = ocs_hw_io_add_seed_sge(hw, hio, hw_dif);
+			if (rc) {
+				return rc;
+			}
+		}
+
+		/* if we are doing DIF separate, then figure out the block size so that we
+		 * can update the ref tag in the DIF seed SGE.   Also verify that the
+		 * the sgl lengths are all multiples of the blocksize
+		 */
+		if (hw_dif->dif_separate) {
+			switch(hw_dif->blk_size) {
+			case OCS_HW_DIF_BK_SIZE_512:	blocksize = 512; break;
+			case OCS_HW_DIF_BK_SIZE_1024:	blocksize = 1024; break;
+			case OCS_HW_DIF_BK_SIZE_2048:	blocksize = 2048; break;
+			case OCS_HW_DIF_BK_SIZE_4096:	blocksize = 4096; break;
+			case OCS_HW_DIF_BK_SIZE_520:	blocksize = 520; break;
+			case OCS_HW_DIF_BK_SIZE_4104:	blocksize = 4104; break;
+			default:
+				ocs_log_test(hw->os, "Inavlid hw_dif blocksize %d\n", hw_dif->blk_size);
+				return -1;
+			}
+			for (i = 0; i < sgl_count; i++) {
+				if ((sgl[i].len % blocksize) != 0) {
+					ocs_log_test(hw->os, "sgl[%d] len of %ld is not multiple of blocksize\n",
+						     i, sgl[i].len);
+					return -1;
+				}
+			}
+		}
+
+		for (i = 0; i < sgl_count; i++) {
+			ocs_assert(sgl[i].addr, -1);
+			ocs_assert(sgl[i].len, -1);
+
+			/* If DIF is enabled, and DIF is separate, then append a SEED then DIF SGE */
+			if (hw_dif->dif_separate) {
+				rc = ocs_hw_io_add_seed_sge(hw, hio, hw_dif);
+				if (rc) {
+					return rc;
+				}
+				rc = ocs_hw_io_add_dif_sge(hw, hio, sgl[i].dif_addr);
+				if (rc) {
+					return rc;
+				}
+				/* Update the ref_tag for the next DIF seed SGE */
+				blockcount = sgl[i].len / blocksize;
+				if (hw_dif->dif_oper == OCS_HW_DIF_OPER_INSERT) {
+					hw_dif->ref_tag_repl += blockcount;
+				} else {
+					hw_dif->ref_tag_cmp += blockcount;
+				}
+			}
+
+			/* Add data SGE */
+			rc = ocs_hw_io_add_sge(hw, hio, sgl[i].addr, sgl[i].len);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_hw_io_add_sge failed: count=%d rc=%d\n",
+						sgl_count, rc);
+				return rc;
+			}
+		}
+	} else {
+		for (i = 0; i < sgl_count; i++) {
+			ocs_assert(sgl[i].addr, -1);
+			ocs_assert(sgl[i].len, -1);
+
+			/* Add data SGE */
+			rc = ocs_hw_io_add_sge(hw, hio, sgl[i].addr, sgl[i].len);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_hw_io_add_sge failed: count=%d rc=%d\n",
+						sgl_count, rc);
+				return rc;
+			}
+
+		}
+	}
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Convert SCSI API T10 DIF information into the FC HW format.
+ *
+ * @param ocs Pointer to the ocs structure for logging.
+ * @param scsi_dif_info Pointer to the SCSI API T10 DIF fields.
+ * @param hw_dif_info Pointer to the FC HW API T10 DIF fields.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static int32_t
+ocs_scsi_convert_dif_info(ocs_t *ocs, ocs_scsi_dif_info_t *scsi_dif_info, ocs_hw_dif_info_t *hw_dif_info)
+{
+	uint32_t dif_seed;
+	ocs_memset(hw_dif_info, 0, sizeof(ocs_hw_dif_info_t));
+
+	if (scsi_dif_info == NULL) {
+		hw_dif_info->dif_oper = OCS_HW_DIF_OPER_DISABLED;
+		hw_dif_info->blk_size =  OCS_HW_DIF_BK_SIZE_NA;
+		return 0;
+	}
+
+	/* Convert the DIF operation */
+	switch(scsi_dif_info->dif_oper) {
+	case OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CRC:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CRC;
+		hw_dif_info->dif = SLI4_DIF_INSERT;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_CRC_OUT_NODIF:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_CRC_OUT_NODIF;
+		hw_dif_info->dif = SLI4_DIF_STRIP;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CHKSUM:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM;
+		hw_dif_info->dif = SLI4_DIF_INSERT;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_NODIF:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF;
+		hw_dif_info->dif = SLI4_DIF_STRIP;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_CRC_OUT_CRC:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CRC;
+		hw_dif_info->dif = SLI4_DIF_PASS_THROUGH;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CHKSUM:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM;
+		hw_dif_info->dif = SLI4_DIF_PASS_THROUGH;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_CRC_OUT_CHKSUM:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_CRC_OUT_CHKSUM;
+		hw_dif_info->dif = SLI4_DIF_PASS_THROUGH;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CRC:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_CHKSUM_OUT_CRC;
+		hw_dif_info->dif = SLI4_DIF_PASS_THROUGH;
+		break;
+	case OCS_SCSI_DIF_OPER_IN_RAW_OUT_RAW:
+		hw_dif_info->dif_oper = OCS_HW_SGE_DIF_OP_IN_RAW_OUT_RAW;
+		hw_dif_info->dif = SLI4_DIF_PASS_THROUGH;
+		break;
+	default:
+		ocs_log_test(ocs, "unhandled SCSI DIF operation %d\n",
+			     scsi_dif_info->dif_oper);
+		return -1;
+	}
+
+	switch(scsi_dif_info->blk_size) {
+	case OCS_SCSI_DIF_BK_SIZE_512:
+		hw_dif_info->blk_size = OCS_HW_DIF_BK_SIZE_512;
+		break;
+	case OCS_SCSI_DIF_BK_SIZE_1024:
+		hw_dif_info->blk_size = OCS_HW_DIF_BK_SIZE_1024;
+		break;
+	case OCS_SCSI_DIF_BK_SIZE_2048:
+		hw_dif_info->blk_size = OCS_HW_DIF_BK_SIZE_2048;
+		break;
+	case OCS_SCSI_DIF_BK_SIZE_4096:
+		hw_dif_info->blk_size = OCS_HW_DIF_BK_SIZE_4096;
+		break;
+	case OCS_SCSI_DIF_BK_SIZE_520:
+		hw_dif_info->blk_size = OCS_HW_DIF_BK_SIZE_520;
+		break;
+	case OCS_SCSI_DIF_BK_SIZE_4104:
+		hw_dif_info->blk_size = OCS_HW_DIF_BK_SIZE_4104;
+		break;
+	default:
+		ocs_log_test(ocs, "unhandled SCSI DIF block size %d\n",
+			     scsi_dif_info->blk_size);
+		return -1;
+	}
+
+	/* If the operation is an INSERT the tags provided are the ones that should be
+	 * inserted, otherwise they're the ones to be checked against. */
+	if (hw_dif_info->dif == SLI4_DIF_INSERT ) {
+		hw_dif_info->ref_tag_repl = scsi_dif_info->ref_tag;
+		hw_dif_info->app_tag_repl = scsi_dif_info->app_tag;
+	} else {
+		hw_dif_info->ref_tag_cmp = scsi_dif_info->ref_tag;
+		hw_dif_info->app_tag_cmp = scsi_dif_info->app_tag;
+	}
+
+	hw_dif_info->check_ref_tag = scsi_dif_info->check_ref_tag;
+	hw_dif_info->check_app_tag = scsi_dif_info->check_app_tag;
+	hw_dif_info->check_guard = scsi_dif_info->check_guard;
+	hw_dif_info->auto_incr_ref_tag = 1;
+	hw_dif_info->dif_separate = scsi_dif_info->dif_separate;
+	hw_dif_info->disable_app_ffff = scsi_dif_info->disable_app_ffff;
+	hw_dif_info->disable_app_ref_ffff = scsi_dif_info->disable_app_ref_ffff;
+
+	ocs_hw_get(&ocs->hw, OCS_HW_DIF_SEED, &dif_seed);
+	hw_dif_info->dif_seed = dif_seed;
+
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief This function logs the SGLs for an IO.
+ *
+ * @param io Pointer to the IO context.
+ */
+static void ocs_log_sgl(ocs_io_t *io)
+{
+	ocs_hw_io_t *hio = io->hio;
+	sli4_sge_t *data = NULL;
+	uint32_t *dword = NULL;
+	uint32_t i;
+	uint32_t n_sge;
+
+	scsi_io_trace(io, "def_sgl at 0x%x 0x%08x\n",
+		      ocs_addr32_hi(hio->def_sgl.phys),
+		      ocs_addr32_lo(hio->def_sgl.phys));
+	n_sge = (hio->sgl == &hio->def_sgl ? hio->n_sge : hio->def_sgl_count);
+	for (i = 0, data = hio->def_sgl.virt; i < n_sge; i++, data++) {
+		dword = (uint32_t*)data;
+
+		scsi_io_trace(io, "SGL %2d 0x%08x 0x%08x 0x%08x 0x%08x\n",
+			 i, dword[0], dword[1], dword[2], dword[3]);
+
+		if (dword[2] & (1U << 31)) {
+			break;
+		}
+	}
+
+	if (hio->ovfl_sgl != NULL &&
+		hio->sgl == hio->ovfl_sgl) {
+		scsi_io_trace(io, "Overflow at 0x%x 0x%08x\n",
+			      ocs_addr32_hi(hio->ovfl_sgl->phys),
+			      ocs_addr32_lo(hio->ovfl_sgl->phys));
+		for (i = 0, data = hio->ovfl_sgl->virt; i < hio->n_sge; i++, data++) {
+			dword = (uint32_t*)data;
+
+			scsi_io_trace(io, "SGL %2d 0x%08x 0x%08x 0x%08x 0x%08x\n",
+				 i, dword[0], dword[1], dword[2], dword[3]);
+			if (dword[2] & (1U << 31)) {
+				break;
+			}
+		}
+	}
+
+}
+
+
+/**
+ * @brief Check pending error asynchronous callback function.
+ *
+ * @par Description
+ * Invoke the HW callback function for a given IO. This function is called
+ * from the NOP mailbox completion context.
+ *
+ * @param hw Pointer to HW object.
+ * @param status Completion status.
+ * @param mqe Mailbox completion queue entry.
+ * @param arg General purpose argument.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_scsi_check_pending_async_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_io_t *io = arg;
+
+	if (io != NULL) {
+		if (io->hw_cb != NULL) {
+			ocs_hw_done_t cb = io->hw_cb;
+
+			io->hw_cb = NULL;
+			cb(io->hio, NULL, 0, SLI4_FC_WCQE_STATUS_DISPATCH_ERROR, 0, io);
+		}
+	}
+	return 0;
+}
+
+/**
+ * @brief Check for pending IOs to dispatch.
+ *
+ * @par Description
+ * If there are IOs on the pending list, and a HW IO is available, then
+ * dispatch the IOs.
+ *
+ * @param ocs Pointer to the OCS structure.
+ *
+ * @return None.
+ */
+
+void
+ocs_scsi_check_pending(ocs_t *ocs)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_io_t *io;
+	ocs_hw_io_t *hio;
+	int32_t status;
+	int count = 0;
+	int dispatch;
+
+	/* Guard against recursion */
+	if (ocs_atomic_add_return(&xport->io_pending_recursing, 1)) {
+		/* This function is already running.  Decrement and return. */
+		ocs_atomic_sub_return(&xport->io_pending_recursing, 1);
+		return;
+	}
+
+	do {
+		ocs_lock(&xport->io_pending_lock);
+			status = 0;
+			hio = NULL;
+			io = ocs_list_remove_head(&xport->io_pending_list);
+			if (io != NULL) {
+				if (io->io_type == OCS_IO_TYPE_ABORT) {
+					hio = NULL;
+				} else {
+					hio = ocs_hw_io_alloc(&ocs->hw);
+					if (hio == NULL) {
+						/*
+						 * No HW IO available.
+						 * Put IO back on the front of pending list
+						 */
+						ocs_list_add_head(&xport->io_pending_list, io);
+						io = NULL;
+					} else {
+						hio->eq = io->hw_priv;
+					}
+				}
+			}
+		/* Must drop the lock before dispatching the IO */
+		ocs_unlock(&xport->io_pending_lock);
+
+		if (io != NULL) {
+			count++;
+
+			/*
+			 * We pulled an IO off the pending list,
+			 * and either got an HW IO or don't need one
+			 */
+			ocs_atomic_sub_return(&xport->io_pending_count, 1);
+			if (hio == NULL) {
+				status = ocs_scsi_io_dispatch_no_hw_io(io);
+			} else {
+				status = ocs_scsi_io_dispatch_hw_io(io, hio);
+			}
+			if (status) {
+				/*
+				 * Invoke the HW callback, but do so in the separate execution context,
+				 * provided by the NOP mailbox completion processing context by using
+				 * ocs_hw_async_call()
+				 */
+				if (ocs_hw_async_call(&ocs->hw, ocs_scsi_check_pending_async_cb, io)) {
+					ocs_log_test(ocs, "call to ocs_hw_async_call() failed\n");
+				}
+			}
+		}
+	} while (io != NULL);
+
+
+	/*
+	 * If nothing was removed from the list,
+	 * we might be in a case where we need to abort an
+	 * active IO and the abort is on the pending list.
+	 * Look for an abort we can dispatch.
+	 */
+	if (count == 0 ) {
+		dispatch = 0;
+
+		ocs_lock(&xport->io_pending_lock);
+			ocs_list_foreach(&xport->io_pending_list, io) {
+				if (io->io_type == OCS_IO_TYPE_ABORT) {
+					if (io->io_to_abort->hio != NULL) {
+						/* This IO has a HW IO, so it is active.  Dispatch the abort. */
+						dispatch = 1;
+					} else {
+						/* Leave this abort on the pending list and keep looking */
+						dispatch = 0;
+					}
+				}
+				if (dispatch) {
+					ocs_list_remove(&xport->io_pending_list, io);
+					ocs_atomic_sub_return(&xport->io_pending_count, 1);
+					break;
+				}
+			}
+		ocs_unlock(&xport->io_pending_lock);
+
+		if (dispatch) {
+			status = ocs_scsi_io_dispatch_no_hw_io(io);
+			if (status) {
+				if (ocs_hw_async_call(&ocs->hw, ocs_scsi_check_pending_async_cb, io)) {
+					ocs_log_test(ocs, "call to ocs_hw_async_call() failed\n");
+				}
+			}
+		}
+	}
+
+	ocs_atomic_sub_return(&xport->io_pending_recursing, 1);
+	return;
+}
+
+/**
+ * @brief Attempt to dispatch a non-abort IO
+ *
+ * @par Description
+ * An IO is dispatched:
+ * - if the pending list is not empty, add IO to pending list
+ *   and call a function to process the pending list.
+ * - if pending list is empty, try to allocate a HW IO. If none
+ *   is available, place this IO at the tail of the pending IO
+ *   list.
+ * - if HW IO is available, attach this IO to the HW IO and
+ *   submit it.
+ *
+ * @param io Pointer to IO structure.
+ * @param cb Callback function.
+ *
+ * @return Returns 0 on success, a negative error code value on failure.
+ */
+
+int32_t
+ocs_scsi_io_dispatch(ocs_io_t *io, void *cb)
+{
+	ocs_hw_io_t *hio;
+	ocs_t *ocs = io->ocs;
+	ocs_xport_t *xport = ocs->xport;
+
+	ocs_assert(io->cmd_tgt || io->cmd_ini, -1);
+	ocs_assert((io->io_type != OCS_IO_TYPE_ABORT), -1);
+	io->hw_cb = cb;
+
+	/*
+	 * if this IO already has a HW IO, then this is either not the first phase of
+	 * the IO. Send it to the HW.
+	 */
+	if (io->hio != NULL) {
+		return ocs_scsi_io_dispatch_hw_io(io, io->hio);
+	}
+
+	/*
+	 * We don't already have a HW IO associated with the IO. First check
+	 * the pending list. If not empty, add IO to the tail and process the
+	 * pending list.
+	 */
+	ocs_lock(&xport->io_pending_lock);
+		if (!ocs_list_empty(&xport->io_pending_list)) {
+			/*
+			 * If this is a low latency request, the put at the front of the IO pending
+			 * queue, otherwise put it at the end of the queue.
+			 */
+			if (io->low_latency) {
+				ocs_list_add_head(&xport->io_pending_list, io);
+			} else {
+				ocs_list_add_tail(&xport->io_pending_list, io);
+			}
+			ocs_unlock(&xport->io_pending_lock);
+			ocs_atomic_add_return(&xport->io_pending_count, 1);
+			ocs_atomic_add_return(&xport->io_total_pending, 1);
+
+			/* process pending list */
+			ocs_scsi_check_pending(ocs);
+			return 0;
+		}
+	ocs_unlock(&xport->io_pending_lock);
+
+	/*
+	 * We don't have a HW IO associated with the IO and there's nothing
+	 * on the pending list. Attempt to allocate a HW IO and dispatch it.
+	 */
+	hio = ocs_hw_io_alloc(&io->ocs->hw);
+	if (hio == NULL) {
+
+		/* Couldn't get a HW IO. Save this IO on the pending list */
+		ocs_lock(&xport->io_pending_lock);
+			ocs_list_add_tail(&xport->io_pending_list, io);
+		ocs_unlock(&xport->io_pending_lock);
+
+		ocs_atomic_add_return(&xport->io_total_pending, 1);
+		ocs_atomic_add_return(&xport->io_pending_count, 1);
+		return 0;
+	}
+
+	/* We successfully allocated a HW IO; dispatch to HW */
+	return ocs_scsi_io_dispatch_hw_io(io, hio);
+}
+
+/**
+ * @brief Attempt to dispatch an Abort IO.
+ *
+ * @par Description
+ * An Abort IO is dispatched:
+ * - if the pending list is not empty, add IO to pending list
+ *   and call a function to process the pending list.
+ * - if pending list is empty, send abort to the HW.
+ *
+ * @param io Pointer to IO structure.
+ * @param cb Callback function.
+ *
+ * @return Returns 0 on success, a negative error code value on failure.
+ */
+
+int32_t
+ocs_scsi_io_dispatch_abort(ocs_io_t *io, void *cb)
+{
+	ocs_t *ocs = io->ocs;
+	ocs_xport_t *xport = ocs->xport;
+
+	ocs_assert((io->io_type == OCS_IO_TYPE_ABORT), -1);
+	io->hw_cb = cb;
+
+	/*
+	 * For aborts, we don't need a HW IO, but we still want to pass through
+	 * the pending list to preserve ordering. Thus, if the pending list is
+	 * not empty, add this abort to the pending list and process the pending list.
+	 */
+	ocs_lock(&xport->io_pending_lock);
+		if (!ocs_list_empty(&xport->io_pending_list)) {
+			ocs_list_add_tail(&xport->io_pending_list, io);
+			ocs_unlock(&xport->io_pending_lock);
+			ocs_atomic_add_return(&xport->io_pending_count, 1);
+			ocs_atomic_add_return(&xport->io_total_pending, 1);
+
+			/* process pending list */
+			ocs_scsi_check_pending(ocs);
+			return 0;
+		}
+	ocs_unlock(&xport->io_pending_lock);
+
+	/* nothing on pending list, dispatch abort */
+	return ocs_scsi_io_dispatch_no_hw_io(io);
+
+}
+
+/**
+ * @brief Dispatch IO
+ *
+ * @par Description
+ * An IO and its associated HW IO is dispatched to the HW.
+ *
+ * @param io Pointer to IO structure.
+ * @param hio Pointer to HW IO structure from which IO will be
+ * dispatched.
+ *
+ * @return Returns 0 on success, a negative error code value on failure.
+ */
+
+static int32_t
+ocs_scsi_io_dispatch_hw_io(ocs_io_t *io, ocs_hw_io_t *hio)
+{
+	int32_t rc;
+	ocs_t *ocs = io->ocs;
+
+	/* Got a HW IO; update ini/tgt_task_tag with HW IO info and dispatch */
+	io->hio = hio;
+	if (io->cmd_tgt) {
+		io->tgt_task_tag = hio->indicator;
+	} else if (io->cmd_ini) {
+		io->init_task_tag = hio->indicator;
+	}
+	io->hw_tag = hio->reqtag;
+
+	hio->eq = io->hw_priv;
+
+	/* Copy WQ steering */
+	switch(io->wq_steering) {
+	case OCS_SCSI_WQ_STEERING_CLASS >> OCS_SCSI_WQ_STEERING_SHIFT:
+		hio->wq_steering = OCS_HW_WQ_STEERING_CLASS;
+		break;
+	case OCS_SCSI_WQ_STEERING_REQUEST >> OCS_SCSI_WQ_STEERING_SHIFT:
+		hio->wq_steering = OCS_HW_WQ_STEERING_REQUEST;
+		break;
+	case OCS_SCSI_WQ_STEERING_CPU >> OCS_SCSI_WQ_STEERING_SHIFT:
+		hio->wq_steering = OCS_HW_WQ_STEERING_CPU;
+		break;
+	}
+
+
+	switch (io->io_type) {
+	case OCS_IO_TYPE_IO: {
+		uint32_t max_sgl;
+		uint32_t total_count;
+		uint32_t host_allocated;
+
+		ocs_hw_get(&ocs->hw, OCS_HW_N_SGL, &max_sgl);
+		ocs_hw_get(&ocs->hw, OCS_HW_SGL_CHAINING_HOST_ALLOCATED, &host_allocated);
+
+		/*
+		 * If the requested SGL is larger than the default size, then we can allocate
+		 * an overflow SGL.
+		 */
+		total_count = ocs_scsi_count_sgls(&io->hw_dif, io->sgl, io->sgl_count);
+
+		/*
+		 * Lancer requires us to allocate the chained memory area, but
+		 * Skyhawk must use the SGL list associated with another XRI.
+		 */
+		if (host_allocated && total_count > max_sgl) {
+			/* Compute count needed, the number extra plus 1 for the link sge */
+			uint32_t count = total_count - max_sgl + 1;
+			rc = ocs_dma_alloc(ocs, &io->ovfl_sgl, count*sizeof(sli4_sge_t), 64);
+			if (rc) {
+				ocs_log_err(ocs, "ocs_dma_alloc overflow sgl failed\n");
+				break;
+			}
+			rc = ocs_hw_io_register_sgl(&ocs->hw, io->hio, &io->ovfl_sgl, count);
+			if (rc) {
+				ocs_scsi_io_free_ovfl(io);
+				ocs_log_err(ocs, "ocs_hw_io_register_sgl() failed\n");
+				break;
+			}
+			/* EVT: update chained_io_count */
+			io->node->chained_io_count++;
+		}
+
+		rc = ocs_scsi_build_sgls(&ocs->hw, io->hio, &io->hw_dif, io->sgl, io->sgl_count, io->hio_type);
+		if (rc) {
+			ocs_scsi_io_free_ovfl(io);
+			break;
+		}
+
+		if (OCS_LOG_ENABLE_SCSI_TRACE(ocs)) {
+			ocs_log_sgl(io);
+		}
+
+		if (io->app_id) {
+			io->iparam.fcp_tgt.app_id = io->app_id;
+		}
+
+		rc = ocs_hw_io_send(&io->ocs->hw, io->hio_type, io->hio, io->wire_len, &io->iparam, &io->node->rnode,
+			io->hw_cb, io);
+		break;
+	}
+	case OCS_IO_TYPE_ELS:
+	case OCS_IO_TYPE_CT: {
+		rc = ocs_hw_srrs_send(&ocs->hw, io->hio_type, io->hio,
+			&io->els_req, io->wire_len,
+			&io->els_rsp, &io->node->rnode, &io->iparam,
+			io->hw_cb, io);
+		break;
+	}
+	case OCS_IO_TYPE_CT_RESP: {
+		rc = ocs_hw_srrs_send(&ocs->hw, io->hio_type, io->hio,
+			&io->els_rsp, io->wire_len,
+			NULL, &io->node->rnode, &io->iparam,
+			io->hw_cb, io);
+		break;
+	}
+	case OCS_IO_TYPE_BLS_RESP: {
+		/* no need to update tgt_task_tag for BLS response since the RX_ID
+		 * will be specified by the payload, not the XRI */
+		rc = ocs_hw_srrs_send(&ocs->hw, io->hio_type, io->hio,
+			NULL, 0, NULL, &io->node->rnode, &io->iparam, io->hw_cb, io);
+		break;
+	}
+	default:
+		scsi_io_printf(io, "Unknown IO type=%d\n", io->io_type);
+		rc = -1;
+		break;
+	}
+	return rc;
+}
+
+/**
+ * @brief Dispatch IO
+ *
+ * @par Description
+ * An IO that does require a HW IO is dispatched to the HW.
+ *
+ * @param io Pointer to IO structure.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static int32_t
+ocs_scsi_io_dispatch_no_hw_io(ocs_io_t *io)
+{
+	int32_t rc;
+
+	switch (io->io_type) {
+	case OCS_IO_TYPE_ABORT: {
+		ocs_hw_io_t *hio_to_abort = NULL;
+		ocs_assert(io->io_to_abort, -1);
+		hio_to_abort = io->io_to_abort->hio;
+
+		if (hio_to_abort == NULL) {
+			/*
+			 * If "IO to abort" does not have an associated HW IO, immediately
+			 * make callback with success. The command must have been sent to
+			 * the backend, but the data phase has not yet started, so we don't
+			 * have a HW IO.
+			 *
+			 * Note: since the backend shims should be taking a reference
+			 * on io_to_abort, it should not be possible to have been completed
+			 * and freed by the backend before the abort got here.
+			 */
+			scsi_io_printf(io, "IO: " SCSI_IOFMT " not active\n",
+				       SCSI_IOFMT_ARGS(io->io_to_abort));
+			((ocs_hw_done_t)io->hw_cb)(io->hio, NULL, 0, SLI4_FC_WCQE_STATUS_SUCCESS, 0, io);
+			rc = 0;
+		} else {
+			/* HW IO is valid, abort it */
+			scsi_io_printf(io, "aborting " SCSI_IOFMT "\n", SCSI_IOFMT_ARGS(io->io_to_abort));
+			rc = ocs_hw_io_abort(&io->ocs->hw, hio_to_abort, io->send_abts,
+					      io->hw_cb, io);
+			if (rc) {
+				int status = SLI4_FC_WCQE_STATUS_SUCCESS;
+				if ((rc != OCS_HW_RTN_IO_NOT_ACTIVE) &&
+				    (rc != OCS_HW_RTN_IO_ABORT_IN_PROGRESS)) {
+					status = -1;
+					scsi_io_printf(io, "Failed to abort IO: " SCSI_IOFMT " status=%d\n",
+						       SCSI_IOFMT_ARGS(io->io_to_abort), rc);
+				}
+				((ocs_hw_done_t)io->hw_cb)(io->hio, NULL, 0, status, 0, io);
+				rc = 0;
+			}
+		}
+
+		break;
+	}
+	default:
+		scsi_io_printf(io, "Unknown IO type=%d\n", io->io_type);
+		rc = -1;
+		break;
+	}
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Send read/write data.
+ *
+ * @par Description
+ * This call is made by a target-server to initiate a SCSI read or write data phase, transferring
+ * data between the target to the remote initiator. The payload is specified by the
+ * scatter-gather list @c sgl of length @c sgl_count. The @c wire_len argument
+ * specifies the payload length (independent of the scatter-gather list cumulative length).
+ * @n @n
+ * The @c flags argument has one bit, OCS_SCSI_LAST_DATAPHASE, which is a hint to the base
+ * driver that it may use auto SCSI response features if the hardware supports it.
+ * @n @n
+ * Upon completion, the callback function @b cb is called with flags indicating that the
+ * IO has completed (OCS_SCSI_IO_COMPL) and another data phase or response may be sent;
+ * that the IO has completed and no response needs to be sent (OCS_SCSI_IO_COMPL_NO_RSP);
+ * or that the IO was aborted (OCS_SCSI_IO_ABORTED).
+ *
+ * @param io Pointer to the IO context.
+ * @param flags Flags controlling the sending of data.
+ * @param dif_info Pointer to T10 DIF fields, or NULL if no DIF.
+ * @param sgl Pointer to the payload scatter-gather list.
+ * @param sgl_count Count of the scatter-gather list elements.
+ * @param xwire_len Length of the payload on wire, in bytes.
+ * @param type HW IO type.
+ * @param enable_ar Enable auto-response if true.
+ * @param cb Completion callback.
+ * @param arg Application-supplied callback data.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static inline int32_t
+ocs_scsi_xfer_data(ocs_io_t *io, uint32_t flags,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t xwire_len,
+	ocs_hw_io_type_e type, int enable_ar,
+	ocs_scsi_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+	ocs_t *ocs;
+	uint32_t disable_ar_tgt_dif = FALSE;
+	size_t residual = 0;
+
+	if ((dif_info != NULL) && (dif_info->dif_oper == OCS_SCSI_DIF_OPER_DISABLED)) {
+		dif_info = NULL;
+	}
+
+	ocs_assert(io, -1);
+
+	if (dif_info != NULL) {
+		ocs_hw_get(&io->ocs->hw, OCS_HW_DISABLE_AR_TGT_DIF, &disable_ar_tgt_dif);
+		if (disable_ar_tgt_dif) {
+			enable_ar = FALSE;
+		}
+	}
+
+	io->sgl_count = sgl_count;
+
+	/* If needed, copy SGL */
+	if (sgl && (sgl != io->sgl)) {
+		ocs_assert(sgl_count <= io->sgl_allocated, -1);
+		ocs_memcpy(io->sgl, sgl, sgl_count*sizeof(*io->sgl));
+	}
+
+	ocs = io->ocs;
+	ocs_assert(ocs, -1);
+	ocs_assert(io->node, -1);
+
+	scsi_io_trace(io, "%s wire_len %d\n", (type == OCS_HW_IO_TARGET_READ) ? "send" : "recv", xwire_len);
+
+	ocs_assert(sgl, -1);
+	ocs_assert(sgl_count > 0, -1);
+	ocs_assert(io->exp_xfer_len > io->transferred, -1);
+
+	io->hio_type = type;
+
+	io->scsi_tgt_cb = cb;
+	io->scsi_tgt_cb_arg = arg;
+
+	rc = ocs_scsi_convert_dif_info(ocs, dif_info, &io->hw_dif);
+	if (rc) {
+		return rc;
+	}
+
+	/* If DIF is used, then save lba for error recovery */
+	if (dif_info) {
+		io->scsi_dif_info = *dif_info;
+	}
+
+	io->wire_len = MIN(xwire_len, io->exp_xfer_len - io->transferred);
+	residual = (xwire_len - io->wire_len);
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.fcp_tgt.ox_id = io->init_task_tag;
+	io->iparam.fcp_tgt.offset = io->transferred;
+	io->iparam.fcp_tgt.dif_oper = io->hw_dif.dif;
+	io->iparam.fcp_tgt.blk_size = io->hw_dif.blk_size;
+	io->iparam.fcp_tgt.cs_ctl = io->cs_ctl;
+	io->iparam.fcp_tgt.timeout = io->timeout;
+
+	/* if this is the last data phase and there is no residual, enable
+	 * auto-good-response
+	 */
+	if (enable_ar && (flags & OCS_SCSI_LAST_DATAPHASE) &&
+		(residual == 0) && ((io->transferred + io->wire_len) == io->exp_xfer_len) && (!(flags & OCS_SCSI_NO_AUTO_RESPONSE))) {
+		io->iparam.fcp_tgt.flags |= SLI4_IO_AUTO_GOOD_RESPONSE;
+		io->auto_resp = TRUE;
+	} else {
+		io->auto_resp = FALSE;
+	}
+
+	/* save this transfer length */
+	io->xfer_req = io->wire_len;
+
+	/* Adjust the transferred count to account for overrun
+	 * when the residual is calculated in ocs_scsi_send_resp
+	 */
+	io->transferred += residual;
+
+	/* Adjust the SGL size if there is overrun */
+
+	if (residual) {
+		ocs_scsi_sgl_t  *sgl_ptr = &io->sgl[sgl_count-1];
+
+		while (residual) {
+			size_t len = sgl_ptr->len;
+			if ( len > residual) {
+				sgl_ptr->len = len - residual;
+				residual = 0;
+			} else {
+				sgl_ptr->len = 0;
+				residual -= len;
+				io->sgl_count--;
+			}
+			sgl_ptr--;
+		}
+	}
+
+	/* Set latency and WQ steering */
+	io->low_latency = (flags & OCS_SCSI_LOW_LATENCY) != 0;
+	io->wq_steering = (flags & OCS_SCSI_WQ_STEERING_MASK) >> OCS_SCSI_WQ_STEERING_SHIFT;
+	io->wq_class = (flags & OCS_SCSI_WQ_CLASS_MASK) >> OCS_SCSI_WQ_CLASS_SHIFT;
+
+	return ocs_scsi_io_dispatch(io, ocs_target_io_cb);
+}
+
+
+int32_t
+ocs_scsi_send_rd_data(ocs_io_t *io, uint32_t flags,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t len,
+	ocs_scsi_io_cb_t cb, void *arg)
+{
+	return ocs_scsi_xfer_data(io, flags, dif_info, sgl, sgl_count, len, OCS_HW_IO_TARGET_READ,
+				  enable_tsend_auto_resp(io->ocs), cb, arg);
+}
+
+int32_t
+ocs_scsi_recv_wr_data(ocs_io_t *io, uint32_t flags,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t len,
+	ocs_scsi_io_cb_t cb, void *arg)
+{
+	return ocs_scsi_xfer_data(io, flags, dif_info, sgl, sgl_count, len, OCS_HW_IO_TARGET_WRITE,
+				  enable_treceive_auto_resp(io->ocs), cb, arg);
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Free overflow SGL.
+ *
+ * @par Description
+ * Free the overflow SGL if it is present.
+ *
+ * @param io Pointer to IO object.
+ *
+ * @return None.
+ */
+static void
+ocs_scsi_io_free_ovfl(ocs_io_t *io) {
+	if (io->ovfl_sgl.size) {
+		ocs_dma_free(io->ocs, &io->ovfl_sgl);
+	}
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Send response data.
+ *
+ * @par Description
+ * This function is used by a target-server to send the SCSI response data to a remote
+ * initiator node. The target-server populates the @c ocs_scsi_cmd_resp_t
+ * argument with scsi status, status qualifier, sense data, and response data, as
+ * needed.
+ * @n @n
+ * Upon completion, the callback function @c cb is invoked. The target-server will generally
+ * clean up its IO context resources and call ocs_scsi_io_complete().
+ *
+ * @param io Pointer to the IO context.
+ * @param flags Flags to control sending of the SCSI response.
+ * @param rsp Pointer to the response data populated by the caller.
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_scsi_send_resp(ocs_io_t *io, uint32_t flags, ocs_scsi_cmd_resp_t *rsp, ocs_scsi_io_cb_t cb, void *arg)
+{
+	ocs_t *ocs;
+	int32_t residual;
+	int auto_resp = TRUE;		/* Always try auto resp */
+	uint8_t scsi_status = 0;
+	uint16_t scsi_status_qualifier = 0;
+	uint8_t *sense_data = NULL;
+	uint32_t sense_data_length = 0;
+
+	ocs_assert(io, -1);
+
+	ocs = io->ocs;
+	ocs_assert(ocs, -1);
+
+	ocs_assert(io->node, -1);
+
+	ocs_scsi_convert_dif_info(ocs, NULL, &io->hw_dif);
+
+	if (rsp) {
+		scsi_status = rsp->scsi_status;
+		scsi_status_qualifier = rsp->scsi_status_qualifier;
+		sense_data = rsp->sense_data;
+		sense_data_length = rsp->sense_data_length;
+		residual = rsp->residual;
+	} else {
+		residual = io->exp_xfer_len - io->transferred;
+	}
+
+	io->wire_len = 0;
+	io->hio_type = OCS_HW_IO_TARGET_RSP;
+
+	io->scsi_tgt_cb = cb;
+	io->scsi_tgt_cb_arg = arg;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.fcp_tgt.ox_id = io->init_task_tag;
+	io->iparam.fcp_tgt.offset = 0;
+	io->iparam.fcp_tgt.cs_ctl = io->cs_ctl;
+	io->iparam.fcp_tgt.timeout = io->timeout;
+
+	/* Set low latency queueing request */
+	io->low_latency = (flags & OCS_SCSI_LOW_LATENCY) != 0;
+	io->wq_steering = (flags & OCS_SCSI_WQ_STEERING_MASK) >> OCS_SCSI_WQ_STEERING_SHIFT;
+	io->wq_class = (flags & OCS_SCSI_WQ_CLASS_MASK) >> OCS_SCSI_WQ_CLASS_SHIFT;
+
+	if ((scsi_status != 0) || residual || sense_data_length) {
+		fcp_rsp_iu_t *fcprsp = io->rspbuf.virt;
+
+		if (!fcprsp) {
+			ocs_log_err(ocs, "NULL response buffer\n");
+			return -1;
+		}
+
+		auto_resp = FALSE;
+
+		ocs_memset(fcprsp, 0, sizeof(*fcprsp));
+
+		io->wire_len += (sizeof(*fcprsp) - sizeof(fcprsp->data));
+
+		fcprsp->scsi_status = scsi_status;
+		*((uint16_t*)fcprsp->status_qualifier) = ocs_htobe16(scsi_status_qualifier);
+
+		/* set residual status if necessary */
+		if (residual != 0) {
+			/* FCP: if data transferred is less than the amount expected, then this is an
+			 * underflow.  If data transferred would have been greater than the amount expected
+			 * then this is an overflow
+			 */
+			if (residual > 0) {
+				fcprsp->flags |= FCP_RESID_UNDER;
+				*((uint32_t *)fcprsp->fcp_resid) = ocs_htobe32(residual);
+			} else {
+				fcprsp->flags |= FCP_RESID_OVER;
+				*((uint32_t *)fcprsp->fcp_resid) = ocs_htobe32(-residual);
+			}
+		}
+
+		if (sense_data && sense_data_length) {
+			ocs_assert(sense_data_length <= sizeof(fcprsp->data), -1);
+			fcprsp->flags |= FCP_SNS_LEN_VALID;
+			ocs_memcpy(fcprsp->data, sense_data, sense_data_length);
+			*((uint32_t*)fcprsp->fcp_sns_len) = ocs_htobe32(sense_data_length);
+			io->wire_len += sense_data_length;
+		}
+
+		io->sgl[0].addr = io->rspbuf.phys;
+		io->sgl[0].dif_addr = 0;
+		io->sgl[0].len = io->wire_len;
+		io->sgl_count = 1;
+	}
+
+	if (auto_resp) {
+		io->iparam.fcp_tgt.flags |= SLI4_IO_AUTO_GOOD_RESPONSE;
+	}
+
+	return ocs_scsi_io_dispatch(io, ocs_target_io_cb);
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Send TMF response data.
+ *
+ * @par Description
+ * This function is used by a target-server to send SCSI TMF response data to a remote
+ * initiator node.
+ * Upon completion, the callback function @c cb is invoked. The target-server will generally
+ * clean up its IO context resources and call ocs_scsi_io_complete().
+ *
+ * @param io Pointer to the IO context.
+ * @param rspcode TMF response code.
+ * @param addl_rsp_info Additional TMF response information (may be NULL for zero data).
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_scsi_send_tmf_resp(ocs_io_t *io, ocs_scsi_tmf_resp_e rspcode, uint8_t addl_rsp_info[3],
+		ocs_scsi_io_cb_t cb, void *arg)
+{
+	int32_t rc = -1;
+	ocs_t *ocs = NULL;
+	fcp_rsp_iu_t *fcprsp = NULL;
+	fcp_rsp_info_t *rspinfo = NULL;
+	uint8_t fcp_rspcode;
+
+	ocs_assert(io, -1);
+	ocs_assert(io->ocs, -1);
+	ocs_assert(io->node, -1);
+
+	ocs = io->ocs;
+
+	io->wire_len = 0;
+	ocs_scsi_convert_dif_info(ocs, NULL, &io->hw_dif);
+
+	switch(rspcode) {
+	case OCS_SCSI_TMF_FUNCTION_COMPLETE:
+		fcp_rspcode = FCP_TMF_COMPLETE;
+		break;
+	case OCS_SCSI_TMF_FUNCTION_SUCCEEDED:
+	case OCS_SCSI_TMF_FUNCTION_IO_NOT_FOUND:
+		fcp_rspcode = FCP_TMF_SUCCEEDED;
+		break;
+	case OCS_SCSI_TMF_FUNCTION_REJECTED:
+		fcp_rspcode = FCP_TMF_REJECTED;
+		break;
+	case OCS_SCSI_TMF_INCORRECT_LOGICAL_UNIT_NUMBER:
+		fcp_rspcode = FCP_TMF_INCORRECT_LUN;
+		break;
+	case OCS_SCSI_TMF_SERVICE_DELIVERY:
+		fcp_rspcode = FCP_TMF_FAILED;
+		break;
+	default:
+		fcp_rspcode = FCP_TMF_REJECTED;
+		break;
+	}
+
+	io->hio_type = OCS_HW_IO_TARGET_RSP;
+
+	io->scsi_tgt_cb = cb;
+	io->scsi_tgt_cb_arg = arg;
+
+	if (io->tmf_cmd == OCS_SCSI_TMF_ABORT_TASK) {
+		rc = ocs_target_send_bls_resp(io, cb, arg);
+		return rc;
+	}
+
+	/* populate the FCP TMF response */
+	fcprsp = io->rspbuf.virt;
+	ocs_memset(fcprsp, 0, sizeof(*fcprsp));
+
+	fcprsp->flags |= FCP_RSP_LEN_VALID;
+
+	rspinfo = (fcp_rsp_info_t*) fcprsp->data;
+	if (addl_rsp_info != NULL) {
+		ocs_memcpy(rspinfo->addl_rsp_info, addl_rsp_info, sizeof(rspinfo->addl_rsp_info));
+	}
+	rspinfo->rsp_code = fcp_rspcode;
+
+	io->wire_len = sizeof(*fcprsp) - sizeof(fcprsp->data) + sizeof(*rspinfo);
+
+	*((uint32_t*)fcprsp->fcp_rsp_len) = ocs_htobe32(sizeof(*rspinfo));
+
+	io->sgl[0].addr = io->rspbuf.phys;
+	io->sgl[0].dif_addr = 0;
+	io->sgl[0].len = io->wire_len;
+	io->sgl_count = 1;
+
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.fcp_tgt.ox_id = io->init_task_tag;
+	io->iparam.fcp_tgt.offset = 0;
+	io->iparam.fcp_tgt.cs_ctl = io->cs_ctl;
+	io->iparam.fcp_tgt.timeout = io->timeout;
+
+	rc = ocs_scsi_io_dispatch(io, ocs_target_io_cb);
+
+	return rc;
+}
+
+
+/**
+ * @brief Process target abort callback.
+ *
+ * @par Description
+ * Accepts HW abort requests.
+ *
+ * @param hio HW IO context.
+ * @param rnode Remote node.
+ * @param length Length of response data.
+ * @param status Completion status.
+ * @param ext_status Extended completion status.
+ * @param app Application-specified callback data.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static int32_t
+ocs_target_abort_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *app)
+{
+	ocs_io_t *io = app;
+	ocs_t *ocs;
+	ocs_scsi_io_status_e scsi_status;
+
+	ocs_assert(io, -1);
+	ocs_assert(io->ocs, -1);
+
+	ocs = io->ocs;
+
+	if (io->abort_cb) {
+		ocs_scsi_io_cb_t abort_cb = io->abort_cb;
+		void *abort_cb_arg = io->abort_cb_arg;
+
+		io->abort_cb = NULL;
+		io->abort_cb_arg = NULL;
+
+		switch (status) {
+		case SLI4_FC_WCQE_STATUS_SUCCESS:
+			scsi_status = OCS_SCSI_STATUS_GOOD;
+			break;
+		case SLI4_FC_WCQE_STATUS_LOCAL_REJECT:
+			switch (ext_status) {
+			case SLI4_FC_LOCAL_REJECT_NO_XRI:
+				scsi_status = OCS_SCSI_STATUS_NO_IO;
+				break;
+			case SLI4_FC_LOCAL_REJECT_ABORT_IN_PROGRESS:
+				scsi_status = OCS_SCSI_STATUS_ABORT_IN_PROGRESS;
+				break;
+			default:
+				/* TODO: we have seen 0x15 (abort in progress) */
+				scsi_status = OCS_SCSI_STATUS_ERROR;
+				break;
+			}
+			break;
+		case SLI4_FC_WCQE_STATUS_FCP_RSP_FAILURE:
+			scsi_status = OCS_SCSI_STATUS_CHECK_RESPONSE;
+			break;
+		default:
+			scsi_status = OCS_SCSI_STATUS_ERROR;
+			break;
+		}
+		/* invoke callback */
+		abort_cb(io->io_to_abort, scsi_status, 0, abort_cb_arg);
+	}
+
+	ocs_assert(io != io->io_to_abort, -1);
+
+	/* done with IO to abort */
+	ocs_ref_put(&io->io_to_abort->ref); /* ocs_ref_get(): ocs_scsi_tgt_abort_io() */
+
+	ocs_io_free(ocs, io);
+
+	ocs_scsi_check_pending(ocs);
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Abort a target IO.
+ *
+ * @par Description
+ * This routine is called from a SCSI target-server. It initiates an abort of a
+ * previously-issued target data phase or response request.
+ *
+ * @param io IO context.
+ * @param cb SCSI target server callback.
+ * @param arg SCSI target server supplied callback argument.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+ocs_scsi_tgt_abort_io(ocs_io_t *io, ocs_scsi_io_cb_t cb, void *arg)
+{
+	ocs_t *ocs;
+	ocs_xport_t *xport;
+	int32_t rc;
+
+	ocs_io_t *abort_io = NULL;
+	ocs_assert(io, -1);
+	ocs_assert(io->node, -1);
+	ocs_assert(io->ocs, -1);
+
+	ocs = io->ocs;
+	xport = ocs->xport;
+
+	/* take a reference on IO being aborted */
+	if ((ocs_ref_get_unless_zero(&io->ref) == 0)) {
+		/* command no longer active */
+		scsi_io_printf(io, "command no longer active\n");
+		return -1;
+	}
+
+	/*
+	 * allocate a new IO to send the abort request. Use ocs_io_alloc() directly, as
+	 * we need an IO object that will not fail allocation due to allocations being
+	 * disabled (in ocs_scsi_io_alloc())
+	 */
+	abort_io = ocs_io_alloc(ocs);
+	if (abort_io == NULL) {
+		ocs_atomic_add_return(&xport->io_alloc_failed_count, 1);
+		ocs_ref_put(&io->ref); /* ocs_ref_get(): same function */
+		return -1;
+	}
+
+	/* Save the target server callback and argument */
+	ocs_assert(abort_io->hio == NULL, -1);
+
+	/* set generic fields */
+	abort_io->cmd_tgt = TRUE;
+	abort_io->node = io->node;
+
+	/* set type and abort-specific fields */
+	abort_io->io_type = OCS_IO_TYPE_ABORT;
+	abort_io->display_name = "tgt_abort";
+	abort_io->io_to_abort = io;
+	abort_io->send_abts = FALSE;
+	abort_io->abort_cb = cb;
+	abort_io->abort_cb_arg = arg;
+
+	/* now dispatch IO */
+	rc = ocs_scsi_io_dispatch_abort(abort_io, ocs_target_abort_cb);
+	if (rc) {
+		ocs_ref_put(&io->ref); /* ocs_ref_get(): same function */
+	}
+	return rc;
+}
+
+/**
+ * @brief Process target BLS response callback.
+ *
+ * @par Description
+ * Accepts HW abort requests.
+ *
+ * @param hio HW IO context.
+ * @param rnode Remote node.
+ * @param length Length of response data.
+ * @param status Completion status.
+ * @param ext_status Extended completion status.
+ * @param app Application-specified callback data.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static int32_t
+ocs_target_bls_resp_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length, int32_t status, uint32_t ext_status, void *app)
+{
+	ocs_io_t *io = app;
+	ocs_t *ocs;
+	ocs_scsi_io_status_e bls_status;
+
+	ocs_assert(io, -1);
+	ocs_assert(io->ocs, -1);
+
+	ocs = io->ocs;
+
+	/* BLS isn't really a "SCSI" concept, but use SCSI status */
+	if (status) {
+		io_error_log(io, "s=%#x x=%#x\n", status, ext_status);
+		bls_status = OCS_SCSI_STATUS_ERROR;
+	} else {
+		bls_status = OCS_SCSI_STATUS_GOOD;
+	}
+
+	if (io->bls_cb) {
+		ocs_scsi_io_cb_t bls_cb = io->bls_cb;
+		void *bls_cb_arg = io->bls_cb_arg;
+
+		io->bls_cb = NULL;
+		io->bls_cb_arg = NULL;
+
+		/* invoke callback */
+		bls_cb(io, bls_status, 0, bls_cb_arg);
+	}
+
+	ocs_scsi_check_pending(ocs);
+	return 0;
+}
+
+/**
+ * @brief Complete abort request.
+ *
+ * @par Description
+ * An abort request is completed by posting a BA_ACC for the IO that requested the abort.
+ *
+ * @param io Pointer to the IO context.
+ * @param cb Callback function to invoke upon completion.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static int32_t
+ocs_target_send_bls_resp(ocs_io_t *io, ocs_scsi_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+	fc_ba_acc_payload_t *acc;
+
+	ocs_assert(io, -1);
+
+	/* fill out IO structure with everything needed to send BA_ACC */
+	ocs_memset(&io->iparam, 0, sizeof(io->iparam));
+	io->iparam.bls.ox_id = io->init_task_tag;
+	io->iparam.bls.rx_id = io->abort_rx_id;
+
+	acc = (void *)io->iparam.bls.payload;
+
+	ocs_memset(io->iparam.bls.payload, 0, sizeof(io->iparam.bls.payload));
+	acc->ox_id = io->iparam.bls.ox_id;
+	acc->rx_id = io->iparam.bls.rx_id;
+	acc->high_seq_cnt = UINT16_MAX;
+
+	/* generic io fields have already been populated */
+
+	/* set type and BLS-specific fields */
+	io->io_type = OCS_IO_TYPE_BLS_RESP;
+	io->display_name = "bls_rsp";
+	io->hio_type = OCS_HW_BLS_ACC;
+	io->bls_cb = cb;
+	io->bls_cb_arg = arg;
+
+	/* dispatch IO */
+	rc = ocs_scsi_io_dispatch(io, ocs_target_bls_resp_cb);
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Notify the base driver that the IO is complete.
+ *
+ * @par Description
+ * This function is called by a target-server to notify the base driver that an IO
+ * has completed, allowing for the base driver to free resources.
+ * @n
+ * @n @b Note: This function is not called by initiator-clients.
+ *
+ * @param io Pointer to IO context.
+ *
+ * @return None.
+ */
+void
+ocs_scsi_io_complete(ocs_io_t *io)
+{
+	ocs_assert(io);
+
+	if (!ocs_io_busy(io)) {
+		ocs_log_test(io->ocs, "Got completion for non-busy io with tag 0x%x\n", io->tag);
+		return;
+	}
+
+	scsi_io_trace(io, "freeing io 0x%p %s\n", io, io->display_name);
+	ocs_assert(ocs_ref_read_count(&io->ref) > 0);
+	ocs_ref_put(&io->ref); /* ocs_ref_get(): ocs_scsi_io_alloc() */
+}
+
+
+/**
+ * @brief Handle initiator IO completion.
+ *
+ * @par Description
+ * This callback is made upon completion of an initiator operation (initiator read/write command).
+ *
+ * @param hio HW IO context.
+ * @param rnode Remote node.
+ * @param length Length of completion data.
+ * @param status Completion status.
+ * @param ext_status Extended completion status.
+ * @param app Application-specified callback data.
+ *
+ * @return None.
+ */
+
+static void
+ocs_initiator_io_cb(ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t length,
+	int32_t status, uint32_t ext_status, void *app)
+{
+	ocs_io_t *io = app;
+	ocs_t *ocs;
+	ocs_scsi_io_status_e scsi_status;
+
+	ocs_assert(io);
+	ocs_assert(io->scsi_ini_cb);
+
+	scsi_io_trace(io, "status x%x ext_status x%x\n", status, ext_status);
+
+	ocs = io->ocs;
+	ocs_assert(ocs);
+
+	ocs_scsi_io_free_ovfl(io);
+
+	/* Call target server completion */
+	if (io->scsi_ini_cb) {
+		fcp_rsp_iu_t *fcprsp = io->rspbuf.virt;
+		ocs_scsi_cmd_resp_t rsp;
+		ocs_scsi_rsp_io_cb_t cb = io->scsi_ini_cb;
+		uint32_t flags = 0;
+		uint8_t *pd = fcprsp->data;
+
+		/* Clear the callback before invoking the callback */
+		io->scsi_ini_cb = NULL;
+
+		ocs_memset(&rsp, 0, sizeof(rsp));
+
+		/* Unless status is FCP_RSP_FAILURE, fcprsp is not filled in */
+		switch (status) {
+		case SLI4_FC_WCQE_STATUS_SUCCESS:
+			scsi_status = OCS_SCSI_STATUS_GOOD;
+			break;
+		case SLI4_FC_WCQE_STATUS_FCP_RSP_FAILURE:
+			scsi_status = OCS_SCSI_STATUS_CHECK_RESPONSE;
+			rsp.scsi_status = fcprsp->scsi_status;
+			rsp.scsi_status_qualifier = ocs_be16toh(*((uint16_t*)fcprsp->status_qualifier));
+
+			if (fcprsp->flags & FCP_RSP_LEN_VALID) {
+				rsp.response_data = pd;
+				rsp.response_data_length = ocs_fc_getbe32(fcprsp->fcp_rsp_len);
+				pd += rsp.response_data_length;
+			}
+			if (fcprsp->flags & FCP_SNS_LEN_VALID) {
+				uint32_t sns_len = ocs_fc_getbe32(fcprsp->fcp_sns_len);
+				rsp.sense_data = pd;
+				rsp.sense_data_length = sns_len;
+				pd += sns_len;
+			}
+			/* Set residual */
+			if (fcprsp->flags & FCP_RESID_OVER) {
+				rsp.residual = -ocs_fc_getbe32(fcprsp->fcp_resid);
+				rsp.response_wire_length = length;
+			} else	if (fcprsp->flags & FCP_RESID_UNDER) {
+				rsp.residual = ocs_fc_getbe32(fcprsp->fcp_resid);
+				rsp.response_wire_length = length;
+			}
+
+			/*
+			 * Note: The FCP_RSP_FAILURE can be returned for initiator IOs when the total data
+			 * placed does not match the requested length even if the status is good. If
+			 * the status is all zeroes, then we have to assume that a frame(s) were
+			 * dropped and change the status to LOCAL_REJECT/OUT_OF_ORDER_DATA
+			 */
+			if (length != io->wire_len) {
+				uint32_t rsp_len = ext_status;
+				uint8_t *rsp_bytes = io->rspbuf.virt;
+				uint32_t i;
+				uint8_t all_zeroes = (rsp_len > 0);
+				/* Check if the rsp is zero */
+				for (i = 0; i < rsp_len; i++) {
+					if (rsp_bytes[i] != 0) {
+						all_zeroes = FALSE;
+						break;
+					}
+				}
+				if (all_zeroes) {
+					scsi_status = OCS_SCSI_STATUS_ERROR;
+					ocs_log_test(io->ocs, "[%s]" SCSI_IOFMT "local reject=0x%02x\n",
+						     io->node->display_name, SCSI_IOFMT_ARGS(io),
+						     SLI4_FC_LOCAL_REJECT_OUT_OF_ORDER_DATA);
+				}
+			}
+			break;
+		case SLI4_FC_WCQE_STATUS_LOCAL_REJECT:
+			if (ext_status == SLI4_FC_LOCAL_REJECT_SEQUENCE_TIMEOUT) {
+				scsi_status = OCS_SCSI_STATUS_COMMAND_TIMEOUT;
+			} else {
+				scsi_status = OCS_SCSI_STATUS_ERROR;
+			}
+			break;
+		case SLI4_FC_WCQE_STATUS_DI_ERROR:
+			if (ext_status & 0x01) {
+				scsi_status = OCS_SCSI_STATUS_DIF_GUARD_ERROR;
+			} else if (ext_status & 0x02) {
+				scsi_status = OCS_SCSI_STATUS_DIF_APP_TAG_ERROR;
+			} else if (ext_status & 0x04) {
+				scsi_status = OCS_SCSI_STATUS_DIF_REF_TAG_ERROR;
+			} else {
+				scsi_status = OCS_SCSI_STATUS_DIF_UNKNOWN_ERROR;
+			}
+			break;
+		default:
+			scsi_status = OCS_SCSI_STATUS_ERROR;
+			break;
+		}
+
+		cb(io, scsi_status, &rsp, flags, io->scsi_ini_cb_arg);
+
+	}
+	ocs_scsi_check_pending(ocs);
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Initiate initiator read IO.
+ *
+ * @par Description
+ * This call is made by an initiator-client to send a SCSI read command. The payload
+ * for the command is given by a scatter-gather list @c sgl for @c sgl_count
+ * entries.
+ * @n @n
+ * Upon completion, the callback @b cb is invoked and passed request status.
+ * If the command completed successfully, the callback is given SCSI response data.
+ *
+ * @param node Pointer to the node.
+ * @param io Pointer to the IO context.
+ * @param lun LUN value.
+ * @param cdb Pointer to the CDB.
+ * @param cdb_len Length of the CDB.
+ * @param dif_info Pointer to the T10 DIF fields, or NULL if no DIF.
+ * @param sgl Pointer to the scatter-gather list.
+ * @param sgl_count Count of the scatter-gather list elements.
+ * @param wire_len Length of the payload.
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_scsi_send_rd_io(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len,
+	ocs_scsi_rsp_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+
+	rc = ocs_scsi_send_io(OCS_HW_IO_INITIATOR_READ, node, io, lun, 0, cdb, cdb_len, dif_info, sgl, sgl_count,
+			      wire_len, 0, cb, arg);
+
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Initiate initiator write IO.
+ *
+ * @par Description
+ * This call is made by an initiator-client to send a SCSI write command. The payload
+ * for the command is given by a scatter-gather list @c sgl for @c sgl_count
+ * entries.
+ * @n @n
+ * Upon completion, the callback @c cb is invoked and passed request status. If the command
+ * completed successfully, the callback is given SCSI response data.
+ *
+ * @param node Pointer to the node.
+ * @param io Pointer to IO context.
+ * @param lun LUN value.
+ * @param cdb Pointer to the CDB.
+ * @param cdb_len Length of the CDB.
+ * @param dif_info Pointer to the T10 DIF fields, or NULL if no DIF.
+ * @param sgl Pointer to the scatter-gather list.
+ * @param sgl_count Count of the scatter-gather list elements.
+ * @param wire_len Length of the payload.
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t ocs_scsi_send_wr_io(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len,
+	ocs_scsi_rsp_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+
+	rc = ocs_scsi_send_io(OCS_HW_IO_INITIATOR_WRITE, node, io, lun, 0, cdb, cdb_len, dif_info, sgl, sgl_count,
+			      wire_len, 0, cb, arg);
+
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Initiate initiator write IO.
+ *
+ * @par Description
+ * This call is made by an initiator-client to send a SCSI write command. The payload
+ * for the command is given by a scatter-gather list @c sgl for @c sgl_count
+ * entries.
+ * @n @n
+ * Upon completion, the callback @c cb is invoked and passed request status. If the command
+ * completed successfully, the callback is given SCSI response data.
+ *
+ * @param node Pointer to the node.
+ * @param io Pointer to IO context.
+ * @param lun LUN value.
+ * @param cdb Pointer to the CDB.
+ * @param cdb_len Length of the CDB.
+ * @param dif_info Pointer to the T10 DIF fields, or NULL if no DIF.
+ * @param sgl Pointer to the scatter-gather list.
+ * @param sgl_count Count of the scatter-gather list elements.
+ * @param wire_len Length of the payload.
+ * @param first_burst Number of first burst bytes to send.
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_scsi_send_wr_io_first_burst(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len, uint32_t first_burst,
+	ocs_scsi_rsp_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+
+	rc = ocs_scsi_send_io(OCS_HW_IO_INITIATOR_WRITE, node, io, lun, 0, cdb, cdb_len, dif_info, sgl, sgl_count,
+			      wire_len, 0, cb, arg);
+
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Initiate initiator SCSI command with no data.
+ *
+ * @par Description
+ * This call is made by an initiator-client to send a SCSI command with no data.
+ * @n @n
+ * Upon completion, the callback @c cb is invoked and passed request status. If the command
+ * completed successfully, the callback is given SCSI response data.
+ *
+ * @param node Pointer to the node.
+ * @param io Pointer to the IO context.
+ * @param lun LUN value.
+ * @param cdb Pointer to the CDB.
+ * @param cdb_len Length of the CDB.
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t ocs_scsi_send_nodata_io(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len,
+	ocs_scsi_rsp_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+
+	rc = ocs_scsi_send_io(OCS_HW_IO_INITIATOR_NODATA, node, io, lun, 0, cdb, cdb_len, NULL, NULL, 0, 0, 0, cb, arg);
+
+	return rc;
+}
+/**
+ * @ingroup scsi_api_base
+ * @brief Initiate initiator task management operation.
+ *
+ * @par Description
+ * This command is used to send a SCSI task management function command. If the command
+ * requires it (QUERY_TASK_SET for example), a payload may be associated with the command.
+ * If no payload is required, then @c sgl_count may be zero and @c sgl is ignored.
+ * @n @n
+ * Upon completion @c cb is invoked with status and SCSI response data.
+ *
+ * @param node Pointer to the node.
+ * @param io Pointer to the IO context.
+ * @param io_to_abort Pointer to the IO context to abort in the
+ * case of OCS_SCSI_TMF_ABORT_TASK. Note: this can point to the
+ * same the same ocs_io_t as @c io, provided that @c io does not
+ * have any outstanding work requests.
+ * @param lun LUN value.
+ * @param tmf Task management command.
+ * @param sgl Pointer to the scatter-gather list.
+ * @param sgl_count Count of the scatter-gather list elements.
+ * @param len Length of the payload.
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_scsi_send_tmf(ocs_node_t *node, ocs_io_t *io, ocs_io_t *io_to_abort, uint64_t lun, ocs_scsi_tmf_cmd_e tmf,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t len, ocs_scsi_rsp_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+	ocs_assert(io, -1);
+
+	if (tmf == OCS_SCSI_TMF_ABORT_TASK) {
+		ocs_assert(io_to_abort, -1);
+
+		/* take a reference on IO being aborted */
+		if ((ocs_ref_get_unless_zero(&io_to_abort->ref) == 0)) {
+			/* command no longer active */
+			scsi_io_printf(io, "command no longer active\n");
+			return -1;
+		}
+		/* generic io fields have already been populated */
+
+		/* abort-specific fields */
+		io->io_type = OCS_IO_TYPE_ABORT;
+		io->display_name = "abort_task";
+		io->io_to_abort = io_to_abort;
+		io->send_abts = TRUE;
+		io->scsi_ini_cb = cb;
+		io->scsi_ini_cb_arg = arg;
+
+		/* now dispatch IO */
+		rc = ocs_scsi_io_dispatch_abort(io, ocs_scsi_abort_io_cb);
+		if (rc) {
+			scsi_io_printf(io, "Failed to dispatch abort\n");
+			ocs_ref_put(&io->ref); /* ocs_ref_get(): same function */
+		}
+	} else {
+		io->display_name = "tmf";
+		rc = ocs_scsi_send_io(OCS_HW_IO_INITIATOR_READ, node, io, lun, tmf, NULL, 0, NULL,
+				      sgl, sgl_count, len, 0, cb, arg);
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Send an FCP IO.
+ *
+ * @par Description
+ * An FCP read/write IO command, with optional task management flags, is sent to @c node.
+ *
+ * @param type HW IO type to send.
+ * @param node Pointer to the node destination of the IO.
+ * @param io Pointer to the IO context.
+ * @param lun LUN value.
+ * @param tmf Task management command.
+ * @param cdb Pointer to the SCSI CDB.
+ * @param cdb_len Length of the CDB, in bytes.
+ * @param dif_info Pointer to the T10 DIF fields, or NULL if no DIF.
+ * @param sgl Pointer to the scatter-gather list.
+ * @param sgl_count Number of SGL entries in SGL.
+ * @param wire_len Payload length, in bytes, of data on wire.
+ * @param first_burst Number of first burst bytes to send.
+ * @param cb Completion callback.
+ * @param arg Application-specified completion callback argument.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+/* tc: could elminiate LUN, as it's part of the IO structure */
+
+static int32_t ocs_scsi_send_io(ocs_hw_io_type_e type, ocs_node_t *node, ocs_io_t *io, uint64_t lun,
+	ocs_scsi_tmf_cmd_e tmf, uint8_t *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len, uint32_t first_burst,
+	ocs_scsi_rsp_io_cb_t cb, void *arg)
+{
+	int32_t rc;
+	ocs_t *ocs;
+	fcp_cmnd_iu_t *cmnd;
+	uint32_t cmnd_bytes = 0;
+	uint32_t *fcp_dl;
+	uint8_t tmf_flags = 0;
+
+	ocs_assert(io->node, -1);
+	ocs_assert(io->node == node, -1);
+	ocs_assert(io, -1);
+	ocs = io->ocs;
+	ocs_assert(cb, -1);
+
+	io->sgl_count = sgl_count;
+
+	/* Copy SGL if needed */
+	if (sgl != io->sgl) {
+		ocs_assert(sgl_count <= io->sgl_allocated, -1);
+		ocs_memcpy(io->sgl, sgl, sizeof(*io->sgl) * sgl_count);
+	}
+
+	/* save initiator and target task tags for debugging */
+	io->tgt_task_tag = 0xffff;
+
+	io->wire_len = wire_len;
+	io->hio_type = type;
+
+	if (OCS_LOG_ENABLE_SCSI_TRACE(ocs)) {
+		char buf[80];
+		ocs_textbuf_t txtbuf;
+		uint32_t i;
+
+		ocs_textbuf_init(ocs, &txtbuf, buf, sizeof(buf));
+
+		ocs_textbuf_printf(&txtbuf, "cdb%d: ", cdb_len);
+		for (i = 0; i < cdb_len; i ++) {
+			ocs_textbuf_printf(&txtbuf, "%02X%s", cdb[i], (i == (cdb_len-1)) ? "" : " ");
+		}
+		scsi_io_printf(io, "%s len %d, %s\n", (io->hio_type == OCS_HW_IO_INITIATOR_READ) ? "read" :
+			(io->hio_type == OCS_HW_IO_INITIATOR_WRITE) ? "write" : "",  io->wire_len,
+			ocs_textbuf_get_buffer(&txtbuf));
+	}
+
+
+	ocs_assert(io->cmdbuf.virt, -1);
+
+	cmnd = io->cmdbuf.virt;
+
+	ocs_assert(sizeof(*cmnd) <= io->cmdbuf.size, -1);
+
+	ocs_memset(cmnd, 0, sizeof(*cmnd));
+
+	/* Default FCP_CMND IU doesn't include additional CDB bytes but does include FCP_DL */
+	cmnd_bytes = sizeof(fcp_cmnd_iu_t) - sizeof(cmnd->fcp_cdb_and_dl) + sizeof(uint32_t);
+
+	fcp_dl = (uint32_t*)(&(cmnd->fcp_cdb_and_dl));
+
+	if (cdb) {
+		if (cdb_len <= 16) {
+			ocs_memcpy(cmnd->fcp_cdb, cdb, cdb_len);
+		} else {
+			uint32_t addl_cdb_bytes;
+
+			ocs_memcpy(cmnd->fcp_cdb, cdb, 16);
+			addl_cdb_bytes = cdb_len - 16;
+			ocs_memcpy(cmnd->fcp_cdb_and_dl, &(cdb[16]), addl_cdb_bytes);
+			/* additional_fcp_cdb_length is in words, not bytes */
+			cmnd->additional_fcp_cdb_length = (addl_cdb_bytes + 3) / 4;
+			fcp_dl += cmnd->additional_fcp_cdb_length;
+
+			/* Round up additional CDB bytes */
+			cmnd_bytes += (addl_cdb_bytes + 3) & ~0x3;
+		}
+	}
+
+	be64enc(cmnd->fcp_lun, CAM_EXTLUN_BYTE_SWIZZLE(lun));
+	
+	if (node->fcp2device) {
+		if(ocs_get_crn(node, &cmnd->command_reference_number,
+					lun)) {
+			return -1;
+		}
+	}
+
+	switch (tmf) {
+	case OCS_SCSI_TMF_QUERY_TASK_SET:
+		tmf_flags = FCP_QUERY_TASK_SET;
+		break;
+	case OCS_SCSI_TMF_ABORT_TASK_SET:
+		tmf_flags = FCP_ABORT_TASK_SET;
+		break;
+	case OCS_SCSI_TMF_CLEAR_TASK_SET:
+		tmf_flags = FCP_CLEAR_TASK_SET;
+		break;
+	case OCS_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT:
+		tmf_flags = FCP_QUERY_ASYNCHRONOUS_EVENT;
+		break;
+	case OCS_SCSI_TMF_LOGICAL_UNIT_RESET:
+		tmf_flags = FCP_LOGICAL_UNIT_RESET;
+		break;
+	case OCS_SCSI_TMF_CLEAR_ACA:
+		tmf_flags = FCP_CLEAR_ACA;
+		break;
+	case OCS_SCSI_TMF_TARGET_RESET:
+		tmf_flags = FCP_TARGET_RESET;
+		break;
+	default:
+		tmf_flags = 0;
+	}
+	cmnd->task_management_flags = tmf_flags;
+
+	*fcp_dl = ocs_htobe32(io->wire_len);
+
+	switch (io->hio_type) {
+	case OCS_HW_IO_INITIATOR_READ:
+		cmnd->rddata = 1;
+		break;
+	case OCS_HW_IO_INITIATOR_WRITE:
+		cmnd->wrdata = 1;
+		break;
+	case  OCS_HW_IO_INITIATOR_NODATA:
+		/* sets neither */
+		break;
+	default:
+		ocs_log_test(ocs, "bad IO type %d\n", io->hio_type);
+		return -1;
+	}
+
+	rc = ocs_scsi_convert_dif_info(ocs, dif_info, &io->hw_dif);
+	if (rc) {
+		return rc;
+	}
+
+	io->scsi_ini_cb = cb;
+	io->scsi_ini_cb_arg = arg;
+
+	/* set command and response buffers in the iparam */
+	io->iparam.fcp_ini.cmnd = &io->cmdbuf;
+	io->iparam.fcp_ini.cmnd_size = cmnd_bytes;
+	io->iparam.fcp_ini.rsp = &io->rspbuf;
+	io->iparam.fcp_ini.flags = 0;
+	io->iparam.fcp_ini.dif_oper = io->hw_dif.dif;
+	io->iparam.fcp_ini.blk_size = io->hw_dif.blk_size;
+	io->iparam.fcp_ini.timeout = io->timeout;
+	io->iparam.fcp_ini.first_burst = first_burst;
+
+	return ocs_scsi_io_dispatch(io, ocs_initiator_io_cb);
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Callback for an aborted IO.
+ *
+ * @par Description
+ * Callback function invoked upon completion of an IO abort request.
+ *
+ * @param hio HW IO context.
+ * @param rnode Remote node.
+ * @param len Response length.
+ * @param status Completion status.
+ * @param ext_status Extended completion status.
+ * @param arg Application-specific callback, usually IO context.
+
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static int32_t
+ocs_scsi_abort_io_cb(struct ocs_hw_io_s *hio, ocs_remote_node_t *rnode, uint32_t len, int32_t status,
+	uint32_t ext_status, void *arg)
+{
+	ocs_io_t *io = arg;
+	ocs_t *ocs;
+	ocs_scsi_io_status_e scsi_status = OCS_SCSI_STATUS_GOOD;
+
+	ocs_assert(io, -1);
+	ocs_assert(ocs_io_busy(io), -1);
+	ocs_assert(io->ocs, -1);
+	ocs_assert(io->io_to_abort, -1);
+	ocs = io->ocs;
+
+	ocs_log_debug(ocs, "status %d ext %d\n", status, ext_status);
+
+	/* done with IO to abort */
+	ocs_ref_put(&io->io_to_abort->ref); /* ocs_ref_get(): ocs_scsi_send_tmf() */
+
+	ocs_scsi_io_free_ovfl(io);
+
+	switch (status) {
+	case SLI4_FC_WCQE_STATUS_SUCCESS:
+		scsi_status = OCS_SCSI_STATUS_GOOD;
+		break;
+	case SLI4_FC_WCQE_STATUS_LOCAL_REJECT:
+		if (ext_status == SLI4_FC_LOCAL_REJECT_ABORT_REQUESTED) {
+			scsi_status = OCS_SCSI_STATUS_ABORTED;
+		} else if (ext_status == SLI4_FC_LOCAL_REJECT_NO_XRI) {
+			scsi_status = OCS_SCSI_STATUS_NO_IO;
+		} else if (ext_status == SLI4_FC_LOCAL_REJECT_ABORT_IN_PROGRESS) {
+			scsi_status = OCS_SCSI_STATUS_ABORT_IN_PROGRESS;
+		} else {
+			ocs_log_test(ocs, "Unhandled local reject 0x%x/0x%x\n", status, ext_status);
+			scsi_status = OCS_SCSI_STATUS_ERROR;
+		}
+		break;
+	default:
+		scsi_status = OCS_SCSI_STATUS_ERROR;
+		break;
+	}
+
+	if (io->scsi_ini_cb) {
+		(*io->scsi_ini_cb)(io, scsi_status, NULL, 0, io->scsi_ini_cb_arg);
+	} else {
+		ocs_scsi_io_free(io);
+	}
+
+	ocs_scsi_check_pending(ocs);
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Return SCSI API integer valued property.
+ *
+ * @par Description
+ * This function is called by a target-server or initiator-client to
+ * retrieve an integer valued property.
+ *
+ * @param ocs Pointer to the ocs.
+ * @param prop Property value to return.
+ *
+ * @return Returns a value, or 0 if invalid property was requested.
+ */
+uint32_t
+ocs_scsi_get_property(ocs_t *ocs, ocs_scsi_property_e prop)
+{
+	ocs_xport_t *xport = ocs->xport;
+	uint32_t	val;
+
+	switch (prop) {
+	case OCS_SCSI_MAX_SGE:
+		if (0 == ocs_hw_get(&ocs->hw, OCS_HW_MAX_SGE, &val)) {
+			return val;
+		}
+		break;
+	case OCS_SCSI_MAX_SGL:
+		if (ocs->ctrlmask & OCS_CTRLMASK_TEST_CHAINED_SGLS) {
+			/*
+			 * If chain SGL test-mode is enabled, the number of HW SGEs
+			 * has been limited; report back original max.
+			 */
+			return (OCS_FC_MAX_SGL);
+		}
+		if (0 == ocs_hw_get(&ocs->hw, OCS_HW_N_SGL, &val)) {
+			return val;
+		}
+		break;
+	case OCS_SCSI_MAX_IOS:
+		return ocs_io_pool_allocated(xport->io_pool);
+	case OCS_SCSI_DIF_CAPABLE:
+	        if (0 == ocs_hw_get(&ocs->hw, OCS_HW_DIF_CAPABLE, &val)) {
+	                return val;
+	        }
+		break;
+	case OCS_SCSI_MAX_FIRST_BURST:
+		return 0;
+	case OCS_SCSI_DIF_MULTI_SEPARATE:
+	        if (ocs_hw_get(&ocs->hw, OCS_HW_DIF_MULTI_SEPARATE, &val) == 0) {
+	                return val;
+	        }
+		break;
+	case OCS_SCSI_ENABLE_TASK_SET_FULL:
+		/* Return FALSE if we are send frame capable */
+		if (ocs_hw_get(&ocs->hw, OCS_HW_SEND_FRAME_CAPABLE, &val) == 0) {
+			return ! val;
+		}
+		break;
+	default:
+		break;
+	}
+
+	ocs_log_debug(ocs, "invalid property request %d\n", prop);
+	return 0;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Return a property pointer.
+ *
+ * @par Description
+ * This function is called by a target-server or initiator-client to
+ * retrieve a pointer to the requested property.
+ *
+ * @param ocs Pointer to the ocs.
+ * @param prop Property value to return.
+ *
+ * @return Returns pointer to the requested property, or NULL otherwise.
+ */
+void *ocs_scsi_get_property_ptr(ocs_t *ocs, ocs_scsi_property_e prop)
+{
+	void *rc = NULL;
+
+	switch (prop) {
+	case OCS_SCSI_WWNN:
+		rc = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_NODE);
+		break;
+	case OCS_SCSI_WWPN:
+		rc = ocs_hw_get_ptr(&ocs->hw, OCS_HW_WWN_PORT);
+		break;
+	case OCS_SCSI_PORTNUM:
+		rc = ocs_hw_get_ptr(&ocs->hw, OCS_HW_PORTNUM);
+		break;
+	case OCS_SCSI_BIOS_VERSION_STRING:
+		rc = ocs_hw_get_ptr(&ocs->hw, OCS_HW_BIOS_VERSION_STRING);
+		break;
+#if defined(OCS_ENABLE_VPD_SUPPORT)
+	case OCS_SCSI_SERIALNUMBER:
+	{
+		uint8_t *pvpd;
+		uint32_t vpd_len;
+
+		if (ocs_hw_get(&ocs->hw, OCS_HW_VPD_LEN, &vpd_len)) {
+			ocs_log_test(ocs, "Can't get VPD length\n");
+			rc = "\012sn-unknown";
+			break;
+		}
+
+		pvpd = ocs_hw_get_ptr(&ocs->hw, OCS_HW_VPD);
+		if (pvpd) {
+			rc = ocs_find_vpd(pvpd, vpd_len, "SN");
+		}
+
+		if (rc == NULL ||
+		    ocs_strlen(rc) == 0) {
+			/* Note: VPD is missing, using wwnn for serial number */
+			scsi_log(ocs, "Note: VPD is missing, using wwnn for serial number\n");
+			/* Use the last 32 bits of the WWN */
+			if ((ocs == NULL) || (ocs->domain == NULL) || (ocs->domain->sport == NULL)) {
+				rc = "\011(Unknown)";
+			} else {
+				rc = &ocs->domain->sport->wwnn_str[8];
+			}
+		}
+		break;
+	}
+	case OCS_SCSI_PARTNUMBER:
+	{
+		uint8_t *pvpd;
+		uint32_t vpd_len;
+
+		if (ocs_hw_get(&ocs->hw, OCS_HW_VPD_LEN, &vpd_len)) {
+			ocs_log_test(ocs, "Can't get VPD length\n");
+			rc = "\012pn-unknown";
+			break;
+		}
+		pvpd = ocs_hw_get_ptr(&ocs->hw, OCS_HW_VPD);
+		if (pvpd) {
+			rc = ocs_find_vpd(pvpd, vpd_len, "PN");
+			if (rc == NULL) {
+				rc = "\012pn-unknown";
+			}
+		} else {
+			rc = "\012pn-unknown";
+		}
+		break;
+	}
+#endif
+	default:
+		break;
+	}
+
+	if (rc == NULL) {
+		ocs_log_debug(ocs, "invalid property request %d\n", prop);
+	}
+	return rc;
+}
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Notify that delete initiator is complete.
+ *
+ * @par Description
+ * Sent by the target-server to notify the base driver that the work started from
+ * ocs_scsi_del_initiator() is now complete and that it is safe for the node to
+ * release the rest of its resources.
+ *
+ * @param node Pointer to the node.
+ *
+ * @return None.
+ */
+void
+ocs_scsi_del_initiator_complete(ocs_node_t *node)
+{
+	/* Notify the node to resume */
+	ocs_node_post_event(node, OCS_EVT_NODE_DEL_INI_COMPLETE, NULL);
+}
+
+
+/**
+ * @ingroup scsi_api_base
+ * @brief Notify that delete target is complete.
+ *
+ * @par Description
+ * Sent by the initiator-client to notify the base driver that the work started from
+ * ocs_scsi_del_target() is now complete and that it is safe for the node to
+ * release the rest of its resources.
+ *
+ * @param node Pointer to the node.
+ *
+ * @return None.
+ */
+void
+ocs_scsi_del_target_complete(ocs_node_t *node)
+{
+	/* Notify the node to resume */
+	ocs_node_post_event(node, OCS_EVT_NODE_DEL_TGT_COMPLETE, NULL);
+}
+
+
+/**
+ * @brief Update transferred count
+ *
+ * @par Description
+ * Updates io->transferred, as required when using first burst, when the amount
+ * of first burst data processed differs from the amount of first burst
+ * data received.
+ *
+ * @param io Pointer to the io object.
+ * @param transferred Number of bytes transferred out of first burst buffers.
+ *
+ * @return None.
+ */
+void
+ocs_scsi_update_first_burst_transferred(ocs_io_t *io, uint32_t transferred)
+{
+	io->transferred = transferred;
+}
+
+/**
+ * @brief Register bounce callback for multi-threading.
+ *
+ * @par Description
+ * Register the back end bounce function.
+ *
+ * @param ocs Pointer to device object.
+ * @param fctn Function pointer of bounce function.
+ *
+ * @return None.
+ */
+void
+ocs_scsi_register_bounce(ocs_t *ocs, void(*fctn)(void(*fctn)(void *arg), void *arg, uint32_t s_id, uint32_t d_id,
+						 uint32_t ox_id))
+{
+	ocs_hw_rtn_e rc;
+
+	rc = ocs_hw_callback(&ocs->hw, OCS_HW_CB_BOUNCE, fctn, NULL);
+	if (rc) {
+		ocs_log_test(ocs, "ocs_hw_callback(OCS_HW_CB_BOUNCE) failed: %d\n", rc);
+	}
+}
diff --git a/sys/dev/ocs_fc/ocs_scsi.h b/sys/dev/ocs_fc/ocs_scsi.h
new file mode 100644
index 000000000000..dedd43efcbc2
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_scsi.h
@@ -0,0 +1,454 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS SCSI API declarations
+ *
+ */
+
+#if !defined(__OCS_SCSI_H__)
+#define __OCS_SCSI_H__
+
+#include "ocs_ddump.h"
+#include "ocs_mgmt.h"
+#include "ocs_utils.h"
+
+
+/* ocs_scsi_rcv_cmd() ocs_scsi_rcv_tmf() flags */
+#define OCS_SCSI_CMD_DIR_IN		(1U << 0)
+#define OCS_SCSI_CMD_DIR_OUT		(1U << 1)
+#define OCS_SCSI_CMD_SIMPLE		(1U << 2)
+#define OCS_SCSI_CMD_HEAD_OF_QUEUE	(1U << 3)
+#define OCS_SCSI_CMD_ORDERED		(1U << 4)
+#define OCS_SCSI_CMD_UNTAGGED		(1U << 5)
+#define OCS_SCSI_CMD_ACA		(1U << 6)
+#define OCS_SCSI_FIRST_BURST_ERR	(1U << 7)
+#define OCS_SCSI_FIRST_BURST_ABORTED	(1U << 8)
+
+/* ocs_scsi_send_rd_data/recv_wr_data/send_resp flags */
+#define OCS_SCSI_LAST_DATAPHASE		(1U << 0)
+#define OCS_SCSI_NO_AUTO_RESPONSE	(1U << 1)
+#define OCS_SCSI_LOW_LATENCY		(1U << 2)
+
+#define OCS_SCSI_WQ_STEERING_SHIFT	(16)
+#define OCS_SCSI_WQ_STEERING_MASK	(0xf << OCS_SCSI_WQ_STEERING_SHIFT)
+#define OCS_SCSI_WQ_STEERING_CLASS	(0 << OCS_SCSI_WQ_STEERING_SHIFT)
+#define OCS_SCSI_WQ_STEERING_REQUEST	(1 << OCS_SCSI_WQ_STEERING_SHIFT)
+#define OCS_SCSI_WQ_STEERING_CPU	(2 << OCS_SCSI_WQ_STEERING_SHIFT)
+
+#define OCS_SCSI_WQ_CLASS_SHIFT		(20)
+#define OCS_SCSI_WQ_CLASS_MASK		(0xf << OCS_SCSI_WQ_CLASS_SHIFT)
+#define OCS_SCSI_WQ_CLASS(x)		((x & OCS_SCSI_WQ_CLASS_MASK) << OCS_SCSI_WQ_CLASS_SHIFT)
+
+#define OCS_SCSI_WQ_CLASS_LOW_LATENCY	(1)
+
+/*!
+ * @defgroup scsi_api_base SCSI Base Target/Initiator
+ * @defgroup scsi_api_target SCSI Target
+ * @defgroup scsi_api_initiator SCSI Initiator
+ */
+
+/**
+ * @brief SCSI command response.
+ *
+ * This structure is used by target-servers to specify SCSI status and
+ * sense data.  In this case all but the @b residual element are used. For
+ * initiator-clients, this structure is used by the SCSI API to convey the
+ * response data for issued commands, including the residual element.
+ */
+typedef struct {
+	uint8_t scsi_status;			/**< SCSI status */
+	uint16_t scsi_status_qualifier;		/**< SCSI status qualifier */
+	uint8_t *response_data;			/**< pointer to response data buffer */
+	uint32_t response_data_length;		/**< length of response data buffer (bytes) */
+	uint8_t *sense_data;			/**< pointer to sense data buffer */
+	uint32_t sense_data_length;		/**< length of sense data buffer (bytes) */
+	int32_t residual;			/**< command residual (not used for target), positive value
+						  *  indicates an underflow, negative value indicates overflow
+						  */
+	uint32_t response_wire_length;		/**< Command response length received in wcqe */
+} ocs_scsi_cmd_resp_t;
+
+/* Status values returned by IO callbacks */
+typedef enum {
+	OCS_SCSI_STATUS_GOOD = 0,
+	OCS_SCSI_STATUS_ABORTED,
+	OCS_SCSI_STATUS_ERROR,
+	OCS_SCSI_STATUS_DIF_GUARD_ERROR,
+	OCS_SCSI_STATUS_DIF_REF_TAG_ERROR,
+	OCS_SCSI_STATUS_DIF_APP_TAG_ERROR,
+	OCS_SCSI_STATUS_DIF_UNKNOWN_ERROR,
+	OCS_SCSI_STATUS_PROTOCOL_CRC_ERROR,
+	OCS_SCSI_STATUS_NO_IO,
+	OCS_SCSI_STATUS_ABORT_IN_PROGRESS,
+	OCS_SCSI_STATUS_CHECK_RESPONSE,
+	OCS_SCSI_STATUS_COMMAND_TIMEOUT,
+	OCS_SCSI_STATUS_TIMEDOUT_AND_ABORTED,
+	OCS_SCSI_STATUS_SHUTDOWN,
+	OCS_SCSI_STATUS_NEXUS_LOST,
+
+} ocs_scsi_io_status_e;
+
+/* SCSI command status */
+#define SCSI_STATUS_GOOD				0x00
+#define SCSI_STATUS_CHECK_CONDITION			0x02
+#define SCSI_STATUS_CONDITION_MET			0x04
+#define SCSI_STATUS_BUSY				0x08
+#define SCSI_STATUS_RESERVATION_CONFLICT		0x18
+#define SCSI_STATUS_TASK_SET_FULL			0x28
+#define SCSI_STATUS_ACA_ACTIVE				0x30
+#define SCSI_STATUS_TASK_ABORTED			0x40
+
+
+
+/* Callback used by send_rd_data(), recv_wr_data(), send_resp() */
+typedef int32_t (*ocs_scsi_io_cb_t)(ocs_io_t *io, ocs_scsi_io_status_e status, uint32_t flags,
+	void *arg);
+
+/* Callback used by send_rd_io(), send_wr_io() */
+typedef int32_t (*ocs_scsi_rsp_io_cb_t)(ocs_io_t *io, ocs_scsi_io_status_e status, ocs_scsi_cmd_resp_t *rsp,
+	uint32_t flags, void *arg);
+
+/* ocs_scsi_cb_t flags */
+#define OCS_SCSI_IO_CMPL		(1U << 0)	/* IO completed */
+#define OCS_SCSI_IO_CMPL_RSP_SENT	(1U << 1)	/* IO completed, response sent */
+#define OCS_SCSI_IO_ABORTED		(1U << 2)	/* IO was aborted */
+
+/* ocs_scsi_recv_tmf() request values */
+typedef enum {
+	OCS_SCSI_TMF_ABORT_TASK = 1,
+	OCS_SCSI_TMF_QUERY_TASK_SET,
+	OCS_SCSI_TMF_ABORT_TASK_SET,
+	OCS_SCSI_TMF_CLEAR_TASK_SET,
+	OCS_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT,
+	OCS_SCSI_TMF_LOGICAL_UNIT_RESET,
+	OCS_SCSI_TMF_CLEAR_ACA,
+	OCS_SCSI_TMF_TARGET_RESET,
+} ocs_scsi_tmf_cmd_e;
+
+/* ocs_scsi_send_tmf_resp() response values */
+typedef enum {
+	OCS_SCSI_TMF_FUNCTION_COMPLETE = 1,
+	OCS_SCSI_TMF_FUNCTION_SUCCEEDED,
+	OCS_SCSI_TMF_FUNCTION_IO_NOT_FOUND,
+	OCS_SCSI_TMF_FUNCTION_REJECTED,
+	OCS_SCSI_TMF_INCORRECT_LOGICAL_UNIT_NUMBER,
+	OCS_SCSI_TMF_SERVICE_DELIVERY,
+} ocs_scsi_tmf_resp_e;
+
+/**
+ * @brief property names for ocs_scsi_get_property() functions
+ */
+
+typedef enum {
+	OCS_SCSI_MAX_SGE,
+	OCS_SCSI_MAX_SGL,
+	OCS_SCSI_WWNN,
+	OCS_SCSI_WWPN,
+	OCS_SCSI_SERIALNUMBER,
+	OCS_SCSI_PARTNUMBER,
+	OCS_SCSI_PORTNUM,
+	OCS_SCSI_BIOS_VERSION_STRING,
+	OCS_SCSI_MAX_IOS,
+	OCS_SCSI_DIF_CAPABLE,
+	OCS_SCSI_DIF_MULTI_SEPARATE,
+	OCS_SCSI_MAX_FIRST_BURST,
+	OCS_SCSI_ENABLE_TASK_SET_FULL,
+} ocs_scsi_property_e;
+
+#define DIF_SIZE		8
+
+/**
+ * @brief T10 DIF operations
+ *
+ *	WARNING: do not reorder or insert to this list without making appropriate changes in ocs_dif.c
+ */
+typedef enum {
+	OCS_SCSI_DIF_OPER_DISABLED,
+	OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CRC,
+	OCS_SCSI_DIF_OPER_IN_CRC_OUT_NODIF,
+	OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CHKSUM,
+	OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_NODIF,
+	OCS_SCSI_DIF_OPER_IN_CRC_OUT_CRC,
+	OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CHKSUM,
+	OCS_SCSI_DIF_OPER_IN_CRC_OUT_CHKSUM,
+	OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CRC,
+	OCS_SCSI_DIF_OPER_IN_RAW_OUT_RAW,
+} ocs_scsi_dif_oper_e;
+#define OCS_SCSI_DIF_OPER_PASS_THRU	OCS_SCSI_DIF_OPER_IN_CRC_OUT_CRC
+#define OCS_SCSI_DIF_OPER_STRIP		OCS_SCSI_DIF_OPER_IN_CRC_OUT_NODIF
+#define OCS_SCSI_DIF_OPER_INSERT	OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CRC
+
+/**
+ * @brief T10 DIF block sizes
+ */
+typedef enum {
+	OCS_SCSI_DIF_BK_SIZE_512,
+	OCS_SCSI_DIF_BK_SIZE_1024,
+	OCS_SCSI_DIF_BK_SIZE_2048,
+	OCS_SCSI_DIF_BK_SIZE_4096,
+	OCS_SCSI_DIF_BK_SIZE_520,
+	OCS_SCSI_DIF_BK_SIZE_4104
+} ocs_scsi_dif_blk_size_e;
+
+/**
+ * @brief generic scatter-gather list structure
+ */
+
+typedef struct ocs_scsi_sgl_s {
+	uintptr_t	addr;			/**< physical address */
+	uintptr_t	dif_addr;		/**< address of DIF segment, zero if DIF is interleaved */
+	size_t		len;			/**< length */
+} ocs_scsi_sgl_t;
+
+
+/**
+ * @brief T10 DIF information passed to the transport
+ */
+
+typedef struct ocs_scsi_dif_info_s {
+	ocs_scsi_dif_oper_e dif_oper;
+	ocs_scsi_dif_blk_size_e blk_size;
+	uint32_t ref_tag;
+	uint32_t app_tag:16,
+		check_ref_tag:1,
+		check_app_tag:1,
+		check_guard:1,
+		dif_separate:1,
+
+		/* If the APP TAG is 0xFFFF, disable checking the REF TAG and CRC fields */
+		disable_app_ffff:1,
+
+		/* if the APP TAG is 0xFFFF and REF TAG is 0xFFFF_FFFF, disable checking the received CRC field. */
+		disable_app_ref_ffff:1,
+		:10;
+	uint64_t lba;
+} ocs_scsi_dif_info_t;
+
+/* Return values for calls from base driver to target-server/initiator-client */
+#define OCS_SCSI_CALL_COMPLETE	0 /* All work is done */
+#define OCS_SCSI_CALL_ASYNC	1 /* Work will be completed asynchronously */
+
+/* Calls from target/initiator to base driver */
+
+typedef enum {
+	OCS_SCSI_IO_ROLE_ORIGINATOR,
+	OCS_SCSI_IO_ROLE_RESPONDER,
+} ocs_scsi_io_role_e;
+
+extern void ocs_scsi_io_alloc_enable(ocs_node_t *node);
+extern void ocs_scsi_io_alloc_disable(ocs_node_t *node);
+extern ocs_io_t *ocs_scsi_io_alloc(ocs_node_t *node, ocs_scsi_io_role_e role);
+extern void ocs_scsi_io_free(ocs_io_t *io);
+extern ocs_io_t *ocs_io_get_instance(ocs_t *ocs, uint32_t index);
+
+extern void ocs_scsi_register_bounce(ocs_t *ocs, void(*fctn)(void(*fctn)(void *arg), void *arg,
+							     uint32_t s_id, uint32_t d_id, uint32_t ox_id));
+
+/* Calls from base driver to target-server */
+
+extern int32_t ocs_scsi_tgt_driver_init(void);
+extern int32_t ocs_scsi_tgt_driver_exit(void);
+extern int32_t ocs_scsi_tgt_io_init(ocs_io_t *io);
+extern int32_t ocs_scsi_tgt_io_exit(ocs_io_t *io);
+extern int32_t ocs_scsi_tgt_new_device(ocs_t *ocs);
+extern int32_t ocs_scsi_tgt_del_device(ocs_t *ocs);
+extern int32_t ocs_scsi_tgt_new_domain(ocs_domain_t *domain);
+extern void ocs_scsi_tgt_del_domain(ocs_domain_t *domain);
+extern int32_t ocs_scsi_tgt_new_sport(ocs_sport_t *sport);
+extern void ocs_scsi_tgt_del_sport(ocs_sport_t *sport);
+extern void ocs_scsi_sport_deleted(ocs_sport_t *sport);
+extern int32_t ocs_scsi_validate_initiator(ocs_node_t *node);
+extern int32_t ocs_scsi_new_initiator(ocs_node_t *node);
+typedef enum {
+	OCS_SCSI_INITIATOR_DELETED,
+	OCS_SCSI_INITIATOR_MISSING,
+} ocs_scsi_del_initiator_reason_e;
+extern int32_t ocs_scsi_del_initiator(ocs_node_t *node, ocs_scsi_del_initiator_reason_e reason);
+extern int32_t ocs_scsi_recv_cmd(ocs_io_t *io, uint64_t lun, uint8_t *cdb, uint32_t cdb_len, uint32_t flags);
+extern int32_t ocs_scsi_recv_cmd_first_burst(ocs_io_t *io, uint64_t lun, uint8_t *cdb, uint32_t cdb_len, uint32_t flags,
+	ocs_dma_t first_burst_buffers[], uint32_t first_burst_bytes);
+extern int32_t ocs_scsi_recv_tmf(ocs_io_t *tmfio, uint64_t lun, ocs_scsi_tmf_cmd_e cmd, ocs_io_t *abortio,
+	uint32_t flags);
+extern ocs_sport_t *ocs_sport_get_instance(ocs_domain_t *domain, uint32_t index);
+extern ocs_domain_t *ocs_domain_get_instance(ocs_t *ocs, uint32_t index);
+
+
+/* Calls from target-server to base driver */
+
+extern int32_t ocs_scsi_send_rd_data(ocs_io_t *io, uint32_t flags,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count,
+	uint32_t wire_len, ocs_scsi_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_recv_wr_data(ocs_io_t *io, uint32_t flags,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count,
+	uint32_t wire_len, ocs_scsi_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_send_resp(ocs_io_t *io, uint32_t flags, ocs_scsi_cmd_resp_t *rsp,
+		ocs_scsi_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_send_tmf_resp(ocs_io_t *io, ocs_scsi_tmf_resp_e rspcode, uint8_t addl_rsp_info[3],
+		ocs_scsi_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_tgt_abort_io(ocs_io_t *io, ocs_scsi_io_cb_t cb, void *arg);
+extern void ocs_scsi_io_complete(ocs_io_t *io);
+extern uint32_t ocs_scsi_get_property(ocs_t *ocs, ocs_scsi_property_e prop);
+extern void *ocs_scsi_get_property_ptr(ocs_t *ocs, ocs_scsi_property_e prop);
+
+extern void ocs_scsi_del_initiator_complete(ocs_node_t *node);
+
+extern void ocs_scsi_update_first_burst_transferred(ocs_io_t *io, uint32_t transferred);
+
+/* Calls from base driver to initiator-client */
+
+extern int32_t ocs_scsi_ini_driver_init(void);
+extern int32_t ocs_scsi_ini_driver_exit(void);
+extern int32_t ocs_scsi_ini_io_init(ocs_io_t *io);
+extern int32_t ocs_scsi_ini_io_exit(ocs_io_t *io);
+extern int32_t ocs_scsi_ini_new_device(ocs_t *ocs);
+extern int32_t ocs_scsi_ini_del_device(ocs_t *ocs);
+extern int32_t ocs_scsi_ini_new_domain(ocs_domain_t *domain);
+extern void ocs_scsi_ini_del_domain(ocs_domain_t *domain);
+extern int32_t ocs_scsi_ini_new_sport(ocs_sport_t *sport);
+extern void ocs_scsi_ini_del_sport(ocs_sport_t *sport);
+extern int32_t ocs_scsi_new_target(ocs_node_t *node);
+
+typedef enum {
+	OCS_SCSI_TARGET_DELETED,
+	OCS_SCSI_TARGET_MISSING,
+} ocs_scsi_del_target_reason_e;
+extern int32_t ocs_scsi_del_target(ocs_node_t *node, ocs_scsi_del_target_reason_e reason);
+
+/* Calls from the initiator-client to the base driver */
+
+extern int32_t ocs_scsi_send_rd_io(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len, ocs_scsi_rsp_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_send_wr_io(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len, ocs_scsi_rsp_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_send_wr_io_first_burst(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len,
+	ocs_scsi_dif_info_t *dif_info,
+	ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t wire_len, uint32_t first_burst,
+	ocs_scsi_rsp_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_send_tmf(ocs_node_t *node, ocs_io_t *io, ocs_io_t *io_to_abort, uint64_t lun,
+	ocs_scsi_tmf_cmd_e tmf, ocs_scsi_sgl_t *sgl, uint32_t sgl_count, uint32_t len, ocs_scsi_rsp_io_cb_t cb, void *arg);
+extern int32_t ocs_scsi_send_nodata_io(ocs_node_t *node, ocs_io_t *io, uint64_t lun, void *cdb, uint32_t cdb_len, ocs_scsi_rsp_io_cb_t cb, void *arg);
+extern void ocs_scsi_del_target_complete(ocs_node_t *node);
+
+typedef enum {
+	OCS_SCSI_DDUMP_DEVICE,
+	OCS_SCSI_DDUMP_DOMAIN,
+	OCS_SCSI_DDUMP_SPORT,
+	OCS_SCSI_DDUMP_NODE,
+	OCS_SCSI_DDUMP_IO,
+} ocs_scsi_ddump_type_e;
+
+/* base driver to target/initiator */
+
+struct ocs_scsi_vaddr_len_s {
+	void *vaddr;
+	uint32_t length;
+} ;
+extern int32_t ocs_scsi_get_block_vaddr(ocs_io_t *io, uint64_t blocknumber, ocs_scsi_vaddr_len_t addrlen[],
+	uint32_t max_addrlen, void **dif_vaddr);
+
+extern void ocs_scsi_ini_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj);
+extern void ocs_scsi_tgt_ddump(ocs_textbuf_t *textbuf, ocs_scsi_ddump_type_e type, void *obj);
+
+/* Calls within base driver */
+extern int32_t ocs_scsi_io_dispatch(ocs_io_t *io, void *cb);
+extern int32_t ocs_scsi_io_dispatch_abort(ocs_io_t *io, void *cb);
+extern void ocs_scsi_check_pending(ocs_t *ocs);
+
+extern uint32_t ocs_scsi_dif_blocksize(ocs_scsi_dif_info_t *dif_info);
+extern int32_t ocs_scsi_dif_set_blocksize(ocs_scsi_dif_info_t *dif_info, uint32_t blocksize);
+extern int32_t ocs_scsi_dif_mem_blocksize(ocs_scsi_dif_info_t *dif_info, int wiretomem);
+extern int32_t ocs_scsi_dif_wire_blocksize(ocs_scsi_dif_info_t *dif_info, int wiretomem);
+
+
+uint32_t ocs_get_crn(ocs_node_t *node, uint8_t *crn, uint64_t lun);
+void ocs_del_crn(ocs_node_t *node);
+void ocs_reset_crn(ocs_node_t *node, uint64_t lun);
+
+/**
+ * @brief Notification from base driver that domain is in force-free path.
+ *
+ * @par Description Domain is forcefully going away.  Cleanup any resources associated with it.
+ *
+ * @param domain Pointer to domain being free'd.
+ *
+ * @return None.
+ */
+
+static inline void
+ocs_scsi_notify_domain_force_free(ocs_domain_t *domain)
+{
+	/* Nothing to do */
+	return;
+}
+
+/**
+ * @brief Notification from base driver that sport is in force-free path.
+ *
+ * @par Description Sport is forcefully going away.  Cleanup any resources associated with it.
+ *
+ * @param sport Pointer to sport being free'd.
+ *
+ * @return None.
+ */
+
+static inline void
+ocs_scsi_notify_sport_force_free(ocs_sport_t *sport)
+{
+	/* Nothing to do */
+	return;
+}
+
+
+/**
+ * @brief Notification from base driver that node is in force-free path.
+ *
+ * @par Description Node is forcefully going away.  Cleanup any resources associated with it.
+ *
+ * @param node Pointer to node being free'd.
+ *
+ * @return None.
+ */
+
+static inline void
+ocs_scsi_notify_node_force_free(ocs_node_t *node)
+{
+	/* Nothing to do */
+	return;
+}
+#endif /* __OCS_SCSI_H__ */
diff --git a/sys/dev/ocs_fc/ocs_sm.c b/sys/dev/ocs_fc/ocs_sm.c
new file mode 100644
index 000000000000..d56240d5343a
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_sm.c
@@ -0,0 +1,207 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Generic state machine framework.
+ */
+
+#include "ocs_os.h"
+#include "ocs_sm.h"
+
+const char *ocs_sm_id[] = {
+	"common",
+	"domain",
+	"login"
+};
+
+/**
+ * @brief Post an event to a context.
+ *
+ * @param ctx State machine context
+ * @param evt Event to post
+ * @param data Event-specific data (if any)
+ *
+ * @return 0 if successfully posted event; -1 if state machine
+ *         is disabled
+ */
+int
+ocs_sm_post_event(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *data)
+{
+	if (ctx->current_state) {
+		ctx->current_state(ctx, evt, data);
+		return 0;
+	} else {
+		return -1;
+	}
+}
+
+/**
+ * @brief Transition to a new state.
+ */
+void
+ocs_sm_transition(ocs_sm_ctx_t *ctx, ocs_sm_function_t state, void *data)
+{
+	if (ctx->current_state == state) {
+		ocs_sm_post_event(ctx, OCS_EVT_REENTER, data);
+	} else {
+		ocs_sm_post_event(ctx, OCS_EVT_EXIT, data);
+		ctx->current_state = state;
+		ocs_sm_post_event(ctx, OCS_EVT_ENTER, data);
+	}
+}
+
+/**
+ * @brief Disable further state machine processing.
+ */
+void
+ocs_sm_disable(ocs_sm_ctx_t *ctx)
+{
+	ctx->current_state = NULL;
+}
+
+const char *ocs_sm_event_name(ocs_sm_event_t evt)
+{
+	switch (evt) {
+	#define RETEVT(x)	case x:		return #x;
+	RETEVT(OCS_EVT_ENTER)
+	RETEVT(OCS_EVT_REENTER)
+	RETEVT(OCS_EVT_EXIT)
+	RETEVT(OCS_EVT_SHUTDOWN)
+	RETEVT(OCS_EVT_RESPONSE)
+	RETEVT(OCS_EVT_RESUME)
+	RETEVT(OCS_EVT_TIMER_EXPIRED)
+	RETEVT(OCS_EVT_ERROR)
+	RETEVT(OCS_EVT_SRRS_ELS_REQ_OK)
+	RETEVT(OCS_EVT_SRRS_ELS_CMPL_OK)
+	RETEVT(OCS_EVT_SRRS_ELS_REQ_FAIL)
+	RETEVT(OCS_EVT_SRRS_ELS_CMPL_FAIL)
+	RETEVT(OCS_EVT_SRRS_ELS_REQ_RJT)
+	RETEVT(OCS_EVT_NODE_ATTACH_OK)
+	RETEVT(OCS_EVT_NODE_ATTACH_FAIL)
+	RETEVT(OCS_EVT_NODE_FREE_OK)
+	RETEVT(OCS_EVT_ELS_REQ_TIMEOUT)
+	RETEVT(OCS_EVT_ELS_REQ_ABORTED)
+	RETEVT(OCS_EVT_ABORT_ELS)
+	RETEVT(OCS_EVT_ELS_ABORT_CMPL)
+
+	RETEVT(OCS_EVT_DOMAIN_FOUND)
+	RETEVT(OCS_EVT_DOMAIN_ALLOC_OK)
+	RETEVT(OCS_EVT_DOMAIN_ALLOC_FAIL)
+	RETEVT(OCS_EVT_DOMAIN_REQ_ATTACH)
+	RETEVT(OCS_EVT_DOMAIN_ATTACH_OK)
+	RETEVT(OCS_EVT_DOMAIN_ATTACH_FAIL)
+	RETEVT(OCS_EVT_DOMAIN_LOST)
+	RETEVT(OCS_EVT_DOMAIN_FREE_OK)
+	RETEVT(OCS_EVT_DOMAIN_FREE_FAIL)
+	RETEVT(OCS_EVT_HW_DOMAIN_REQ_ATTACH)
+	RETEVT(OCS_EVT_HW_DOMAIN_REQ_FREE)
+	RETEVT(OCS_EVT_ALL_CHILD_NODES_FREE)
+
+	RETEVT(OCS_EVT_SPORT_ALLOC_OK)
+	RETEVT(OCS_EVT_SPORT_ALLOC_FAIL)
+	RETEVT(OCS_EVT_SPORT_ATTACH_OK)
+	RETEVT(OCS_EVT_SPORT_ATTACH_FAIL)
+	RETEVT(OCS_EVT_SPORT_FREE_OK)
+	RETEVT(OCS_EVT_SPORT_FREE_FAIL)
+	RETEVT(OCS_EVT_SPORT_TOPOLOGY_NOTIFY)
+	RETEVT(OCS_EVT_HW_PORT_ALLOC_OK)
+	RETEVT(OCS_EVT_HW_PORT_ALLOC_FAIL)
+	RETEVT(OCS_EVT_HW_PORT_ATTACH_OK)
+	RETEVT(OCS_EVT_HW_PORT_REQ_ATTACH)
+	RETEVT(OCS_EVT_HW_PORT_REQ_FREE)
+	RETEVT(OCS_EVT_HW_PORT_FREE_OK)
+
+	RETEVT(OCS_EVT_NODE_FREE_FAIL)
+
+	RETEVT(OCS_EVT_ABTS_RCVD)
+
+	RETEVT(OCS_EVT_NODE_MISSING)
+	RETEVT(OCS_EVT_NODE_REFOUND)
+	RETEVT(OCS_EVT_SHUTDOWN_IMPLICIT_LOGO)
+	RETEVT(OCS_EVT_SHUTDOWN_EXPLICIT_LOGO)
+
+	RETEVT(OCS_EVT_ELS_FRAME)
+	RETEVT(OCS_EVT_PLOGI_RCVD)
+	RETEVT(OCS_EVT_FLOGI_RCVD)
+	RETEVT(OCS_EVT_LOGO_RCVD)
+	RETEVT(OCS_EVT_PRLI_RCVD)
+	RETEVT(OCS_EVT_PRLO_RCVD)
+	RETEVT(OCS_EVT_PDISC_RCVD)
+	RETEVT(OCS_EVT_FDISC_RCVD)
+	RETEVT(OCS_EVT_ADISC_RCVD)
+	RETEVT(OCS_EVT_RSCN_RCVD)
+	RETEVT(OCS_EVT_SCR_RCVD)
+	RETEVT(OCS_EVT_ELS_RCVD)
+	RETEVT(OCS_EVT_LAST)
+	RETEVT(OCS_EVT_FCP_CMD_RCVD)
+
+	RETEVT(OCS_EVT_RFT_ID_RCVD)
+	RETEVT(OCS_EVT_RFF_ID_RCVD)
+	RETEVT(OCS_EVT_GNN_ID_RCVD)
+	RETEVT(OCS_EVT_GPN_ID_RCVD)
+	RETEVT(OCS_EVT_GFPN_ID_RCVD)
+	RETEVT(OCS_EVT_GFF_ID_RCVD)
+	RETEVT(OCS_EVT_GID_FT_RCVD)
+	RETEVT(OCS_EVT_GID_PT_RCVD)
+	RETEVT(OCS_EVT_RPN_ID_RCVD)
+	RETEVT(OCS_EVT_RNN_ID_RCVD)
+	RETEVT(OCS_EVT_RCS_ID_RCVD)
+	RETEVT(OCS_EVT_RSNN_NN_RCVD)
+	RETEVT(OCS_EVT_RSPN_ID_RCVD)
+	RETEVT(OCS_EVT_RHBA_RCVD)
+	RETEVT(OCS_EVT_RPA_RCVD)
+
+	RETEVT(OCS_EVT_GIDPT_DELAY_EXPIRED)
+
+	RETEVT(OCS_EVT_ABORT_IO)
+	RETEVT(OCS_EVT_ABORT_IO_NO_RESP)
+	RETEVT(OCS_EVT_IO_CMPL)
+	RETEVT(OCS_EVT_IO_CMPL_ERRORS)
+	RETEVT(OCS_EVT_RESP_CMPL)
+	RETEVT(OCS_EVT_ABORT_CMPL)
+	RETEVT(OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY)
+	RETEVT(OCS_EVT_NODE_DEL_INI_COMPLETE)
+	RETEVT(OCS_EVT_NODE_DEL_TGT_COMPLETE)
+	RETEVT(OCS_EVT_IO_ABORTED_BY_TMF)
+	RETEVT(OCS_EVT_IO_ABORT_IGNORED)
+	RETEVT(OCS_EVT_IO_FIRST_BURST)
+	RETEVT(OCS_EVT_IO_FIRST_BURST_ERR)
+	RETEVT(OCS_EVT_IO_FIRST_BURST_ABORTED)
+
+	default:
+		break;
+	#undef RETEVT
+	}
+	return "unknown";
+}
diff --git a/sys/dev/ocs_fc/ocs_sm.h b/sys/dev/ocs_fc/ocs_sm.h
new file mode 100644
index 000000000000..190c2df253e6
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_sm.h
@@ -0,0 +1,203 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Generic state machine framework declarations.
+ */
+
+#ifndef _OCS_SM_H
+#define _OCS_SM_H
+
+/**
+ * State Machine (SM) IDs.
+ */
+enum {
+	OCS_SM_COMMON = 0,
+	OCS_SM_DOMAIN,
+	OCS_SM_PORT,
+	OCS_SM_LOGIN,
+	OCS_SM_LAST
+};
+
+#define OCS_SM_EVENT_SHIFT		24
+#define OCS_SM_EVENT_START(id)		((id) << OCS_SM_EVENT_SHIFT)
+
+extern const char *ocs_sm_id[];		/**< String format of the above enums. */
+
+/**
+ * State Machine events.
+ */
+typedef enum {
+	/* Common Events */
+	OCS_EVT_ENTER = OCS_SM_EVENT_START(OCS_SM_COMMON),
+	OCS_EVT_REENTER,
+	OCS_EVT_EXIT,
+	OCS_EVT_SHUTDOWN,
+	OCS_EVT_ALL_CHILD_NODES_FREE,
+	OCS_EVT_RESUME,
+	OCS_EVT_TIMER_EXPIRED,
+
+	/* Domain Events */
+	OCS_EVT_RESPONSE = OCS_SM_EVENT_START(OCS_SM_DOMAIN),
+	OCS_EVT_ERROR,
+
+	OCS_EVT_DOMAIN_FOUND,
+	OCS_EVT_DOMAIN_ALLOC_OK,
+	OCS_EVT_DOMAIN_ALLOC_FAIL,
+	OCS_EVT_DOMAIN_REQ_ATTACH,
+	OCS_EVT_DOMAIN_ATTACH_OK,
+	OCS_EVT_DOMAIN_ATTACH_FAIL,
+	OCS_EVT_DOMAIN_LOST,
+	OCS_EVT_DOMAIN_FREE_OK,
+	OCS_EVT_DOMAIN_FREE_FAIL,
+	OCS_EVT_HW_DOMAIN_REQ_ATTACH,
+	OCS_EVT_HW_DOMAIN_REQ_FREE,
+
+	/* Sport Events */
+	OCS_EVT_SPORT_ALLOC_OK = OCS_SM_EVENT_START(OCS_SM_PORT),
+	OCS_EVT_SPORT_ALLOC_FAIL,
+	OCS_EVT_SPORT_ATTACH_OK,
+	OCS_EVT_SPORT_ATTACH_FAIL,
+	OCS_EVT_SPORT_FREE_OK,
+	OCS_EVT_SPORT_FREE_FAIL,
+	OCS_EVT_SPORT_TOPOLOGY_NOTIFY,
+	OCS_EVT_HW_PORT_ALLOC_OK,
+	OCS_EVT_HW_PORT_ALLOC_FAIL,
+	OCS_EVT_HW_PORT_ATTACH_OK,
+	OCS_EVT_HW_PORT_REQ_ATTACH,
+	OCS_EVT_HW_PORT_REQ_FREE,
+	OCS_EVT_HW_PORT_FREE_OK,
+
+	/* Login Events */
+	OCS_EVT_SRRS_ELS_REQ_OK = OCS_SM_EVENT_START(OCS_SM_LOGIN),
+	OCS_EVT_SRRS_ELS_CMPL_OK,
+	OCS_EVT_SRRS_ELS_REQ_FAIL,
+	OCS_EVT_SRRS_ELS_CMPL_FAIL,
+	OCS_EVT_SRRS_ELS_REQ_RJT,
+	OCS_EVT_NODE_ATTACH_OK,
+	OCS_EVT_NODE_ATTACH_FAIL,
+	OCS_EVT_NODE_FREE_OK,
+	OCS_EVT_NODE_FREE_FAIL,
+	OCS_EVT_ELS_FRAME,
+	OCS_EVT_ELS_REQ_TIMEOUT,
+	OCS_EVT_ELS_REQ_ABORTED,
+	OCS_EVT_ABORT_ELS,		/**< request an ELS IO be aborted */
+	OCS_EVT_ELS_ABORT_CMPL,	        /**< ELS abort process complete */
+
+	OCS_EVT_ABTS_RCVD,
+
+	OCS_EVT_NODE_MISSING,		/**< node is not in the GID_PT payload */
+	OCS_EVT_NODE_REFOUND,		/**< node is allocated and in the GID_PT payload */
+	OCS_EVT_SHUTDOWN_IMPLICIT_LOGO,	/**< node shutting down due to PLOGI recvd (implicit logo) */
+	OCS_EVT_SHUTDOWN_EXPLICIT_LOGO,	/**< node shutting down due to LOGO recvd/sent (explicit logo) */
+
+	OCS_EVT_PLOGI_RCVD,
+	OCS_EVT_FLOGI_RCVD,
+	OCS_EVT_LOGO_RCVD,
+	OCS_EVT_RRQ_RCVD,
+	OCS_EVT_PRLI_RCVD,
+	OCS_EVT_PRLO_RCVD,
+	OCS_EVT_PDISC_RCVD,
+	OCS_EVT_FDISC_RCVD,
+	OCS_EVT_ADISC_RCVD,
+	OCS_EVT_RSCN_RCVD,
+	OCS_EVT_SCR_RCVD,
+	OCS_EVT_ELS_RCVD,
+
+	OCS_EVT_FCP_CMD_RCVD,
+
+	/* Used by fabric emulation */
+	OCS_EVT_RFT_ID_RCVD,
+	OCS_EVT_RFF_ID_RCVD,
+	OCS_EVT_GNN_ID_RCVD,
+	OCS_EVT_GPN_ID_RCVD,
+	OCS_EVT_GFPN_ID_RCVD,
+	OCS_EVT_GFF_ID_RCVD,
+	OCS_EVT_GID_FT_RCVD,
+	OCS_EVT_GID_PT_RCVD,
+	OCS_EVT_RPN_ID_RCVD,
+	OCS_EVT_RNN_ID_RCVD,
+	OCS_EVT_RCS_ID_RCVD,
+	OCS_EVT_RSNN_NN_RCVD,
+	OCS_EVT_RSPN_ID_RCVD,
+	OCS_EVT_RHBA_RCVD,
+	OCS_EVT_RPA_RCVD,
+
+	OCS_EVT_GIDPT_DELAY_EXPIRED,
+
+	/* SCSI Target Server events */
+	OCS_EVT_ABORT_IO,
+	OCS_EVT_ABORT_IO_NO_RESP,
+	OCS_EVT_IO_CMPL,
+	OCS_EVT_IO_CMPL_ERRORS,
+	OCS_EVT_RESP_CMPL,
+	OCS_EVT_ABORT_CMPL,
+	OCS_EVT_NODE_ACTIVE_IO_LIST_EMPTY,
+	OCS_EVT_NODE_DEL_INI_COMPLETE,
+	OCS_EVT_NODE_DEL_TGT_COMPLETE,
+	OCS_EVT_IO_ABORTED_BY_TMF,
+	OCS_EVT_IO_ABORT_IGNORED,
+	OCS_EVT_IO_FIRST_BURST,
+	OCS_EVT_IO_FIRST_BURST_ERR,
+	OCS_EVT_IO_FIRST_BURST_ABORTED,
+
+	/* Must be last */
+	OCS_EVT_LAST
+} ocs_sm_event_t;
+
+/* Declare ocs_sm_ctx_s */
+typedef struct ocs_sm_ctx_s ocs_sm_ctx_t;
+
+/* State machine state function */
+typedef void *(*ocs_sm_function_t)(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+
+/* State machine context header  */
+struct ocs_sm_ctx_s {
+	ocs_sm_function_t current_state;
+	const char *description;
+	void	*app;			/** Application-specific handle. */
+};
+
+extern int ocs_sm_post_event(ocs_sm_ctx_t *, ocs_sm_event_t, void *);
+extern void ocs_sm_transition(ocs_sm_ctx_t *, ocs_sm_function_t, void *);
+extern void ocs_sm_disable(ocs_sm_ctx_t *ctx);
+extern const char *ocs_sm_event_name(ocs_sm_event_t evt);
+
+#if 0
+#define smtrace(sm)	ocs_log_debug(NULL, "%s: %-20s -->   %s\n", sm, ocs_sm_event_name(evt), __func__)
+#else
+#define smtrace(...)
+#endif
+
+#endif /* ! _OCS_SM_H */
diff --git a/sys/dev/ocs_fc/ocs_sport.c b/sys/dev/ocs_fc/ocs_sport.c
new file mode 100644
index 000000000000..d39d45180723
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_sport.c
@@ -0,0 +1,1926 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Details SLI port (sport) functions.
+ */
+
+
+#include "ocs.h"
+#include "ocs_fabric.h"
+#include "ocs_els.h"
+#include "ocs_device.h"
+
+static void ocs_vport_update_spec(ocs_sport_t *sport);
+static void ocs_vport_link_down(ocs_sport_t *sport);
+
+void ocs_mgmt_sport_list(ocs_textbuf_t *textbuf, void *sport);
+void ocs_mgmt_sport_get_all(ocs_textbuf_t *textbuf, void *sport);
+int ocs_mgmt_sport_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *sport);
+int ocs_mgmt_sport_set(char *parent, char *name, char *value, void *sport);
+int ocs_mgmt_sport_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
+		void *arg_out, uint32_t arg_out_length, void *sport);
+static ocs_mgmt_functions_t sport_mgmt_functions = {
+	.get_list_handler = ocs_mgmt_sport_list,
+	.get_handler = ocs_mgmt_sport_get,
+	.get_all_handler = ocs_mgmt_sport_get_all,
+	.set_handler = ocs_mgmt_sport_set,
+	.exec_handler = ocs_mgmt_sport_exec,
+};
+
+/*!
+@defgroup sport_sm SLI Port (sport) State Machine: States
+*/
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port HW callback.
+ *
+ * @par Description
+ * This function is called in response to a HW sport event. This code resolves
+ * the reference to the sport object, and posts the corresponding event.
+ *
+ * @param arg Pointer to the OCS context.
+ * @param event HW sport event.
+ * @param data Application-specific event (pointer to the sport).
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int32_t
+ocs_port_cb(void *arg, ocs_hw_port_event_e event, void *data)
+{
+	ocs_t *ocs = arg;
+	ocs_sli_port_t *sport = data;
+
+	switch (event) {
+	case OCS_HW_PORT_ALLOC_OK:
+		ocs_log_debug(ocs, "OCS_HW_PORT_ALLOC_OK\n");
+		ocs_sm_post_event(&sport->sm, OCS_EVT_SPORT_ALLOC_OK, NULL);
+		break;
+	case OCS_HW_PORT_ALLOC_FAIL:
+		ocs_log_debug(ocs, "OCS_HW_PORT_ALLOC_FAIL\n");
+		ocs_sm_post_event(&sport->sm, OCS_EVT_SPORT_ALLOC_FAIL, NULL);
+		break;
+	case OCS_HW_PORT_ATTACH_OK:
+		ocs_log_debug(ocs, "OCS_HW_PORT_ATTACH_OK\n");
+		ocs_sm_post_event(&sport->sm, OCS_EVT_SPORT_ATTACH_OK, NULL);
+		break;
+	case OCS_HW_PORT_ATTACH_FAIL:
+		ocs_log_debug(ocs, "OCS_HW_PORT_ATTACH_FAIL\n");
+		ocs_sm_post_event(&sport->sm, OCS_EVT_SPORT_ATTACH_FAIL, NULL);
+		break;
+	case OCS_HW_PORT_FREE_OK:
+		ocs_log_debug(ocs, "OCS_HW_PORT_FREE_OK\n");
+		ocs_sm_post_event(&sport->sm, OCS_EVT_SPORT_FREE_OK, NULL);
+		break;
+	case OCS_HW_PORT_FREE_FAIL:
+		ocs_log_debug(ocs, "OCS_HW_PORT_FREE_FAIL\n");
+		ocs_sm_post_event(&sport->sm, OCS_EVT_SPORT_FREE_FAIL, NULL);
+		break;
+	default:
+		ocs_log_test(ocs, "unknown event %#x\n", event);
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Allocate a SLI port object.
+ *
+ * @par Description
+ * A sport object is allocated and associated with the domain. Various
+ * structure members are initialized.
+ *
+ * @param domain Pointer to the domain structure.
+ * @param wwpn World wide port name in host endian.
+ * @param wwnn World wide node name in host endian.
+ * @param fc_id Port ID of sport may be specified, use UINT32_MAX to fabric choose
+ * @param enable_ini Enables initiator capability on this port using a non-zero value.
+ * @param enable_tgt Enables target capability on this port using a non-zero value.
+ *
+ * @return Pointer to an ocs_sport_t object; or NULL.
+ */
+
+ocs_sport_t *
+ocs_sport_alloc(ocs_domain_t *domain, uint64_t wwpn, uint64_t wwnn, uint32_t fc_id, uint8_t enable_ini, uint8_t enable_tgt)
+{
+	ocs_sport_t *sport;
+
+	if (domain->ocs->ctrlmask & OCS_CTRLMASK_INHIBIT_INITIATOR) {
+		enable_ini = 0;
+	}
+
+	/* Return a failure if this sport has already been allocated */
+	if (wwpn != 0) {
+		sport = ocs_sport_find_wwn(domain, wwnn, wwpn);
+		if (sport != NULL) {
+			ocs_log_test(domain->ocs, "Failed: SPORT %016llx  %016llx already allocated\n",
+				     (unsigned long long)wwnn, (unsigned long long)wwpn);
+			return NULL;
+		}
+	}
+
+	sport = ocs_malloc(domain->ocs, sizeof(*sport), OCS_M_NOWAIT | OCS_M_ZERO);
+	if (sport) {
+		sport->ocs = domain->ocs;
+		ocs_snprintf(sport->display_name, sizeof(sport->display_name), "------");
+		sport->domain = domain;
+		sport->lookup = spv_new(domain->ocs);
+		sport->instance_index = domain->sport_instance_count++;
+		ocs_sport_lock_init(sport);
+		ocs_list_init(&sport->node_list, ocs_node_t, link);
+		sport->sm.app = sport;
+		sport->enable_ini = enable_ini;
+		sport->enable_tgt = enable_tgt;
+		sport->enable_rscn = (sport->enable_ini || (sport->enable_tgt && enable_target_rscn(sport->ocs)));
+
+		/* Copy service parameters from domain */
+		ocs_memcpy(sport->service_params, domain->service_params, sizeof(fc_plogi_payload_t));
+
+		/* Update requested fc_id */
+		sport->fc_id = fc_id;
+
+		/* Update the sport's service parameters for the new wwn's */
+		sport->wwpn = wwpn;
+		sport->wwnn = wwnn;
+		ocs_snprintf(sport->wwnn_str, sizeof(sport->wwnn_str), "%016llx" , (unsigned long long)wwnn);
+
+		/* Initialize node group list */
+		ocs_lock_init(sport->ocs, &sport->node_group_lock, "node_group_lock[%d]", sport->instance_index);
+		ocs_list_init(&sport->node_group_dir_list, ocs_node_group_dir_t, link);
+
+		/* if this is the "first" sport of the domain, then make it the "phys" sport */
+		ocs_domain_lock(domain);
+			if (ocs_list_empty(&domain->sport_list)) {
+				domain->sport = sport;
+			}
+
+			ocs_list_add_tail(&domain->sport_list, sport);
+		ocs_domain_unlock(domain);
+
+		sport->mgmt_functions = &sport_mgmt_functions;
+
+		ocs_log_debug(domain->ocs, "[%s] allocate sport\n", sport->display_name);
+	}
+	return sport;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Free a SLI port object.
+ *
+ * @par Description
+ * The sport object is freed.
+ *
+ * @param sport Pointer to the SLI port object.
+ *
+ * @return None.
+ */
+
+void
+ocs_sport_free(ocs_sport_t *sport)
+{
+	ocs_domain_t *domain;
+	ocs_node_group_dir_t *node_group_dir;
+	ocs_node_group_dir_t *node_group_dir_next;
+	int post_all_free = FALSE;
+
+	if (sport) {
+		domain = sport->domain;
+		ocs_log_debug(domain->ocs, "[%s] free sport\n", sport->display_name);
+		ocs_domain_lock(domain);
+			ocs_list_remove(&domain->sport_list, sport);
+			ocs_sport_lock(sport);
+				spv_del(sport->lookup);
+				sport->lookup = NULL;
+
+				ocs_lock(&domain->lookup_lock);
+					/* Remove the sport from the domain's sparse vector lookup table */
+					spv_set(domain->lookup, sport->fc_id, NULL);
+				ocs_unlock(&domain->lookup_lock);
+
+				/* if this is the physical sport, then clear it out of the domain */
+				if (sport == domain->sport) {
+					domain->sport = NULL;
+				}
+
+				/*
+				 * If the domain's sport_list is empty, then post the ALL_NODES_FREE event to the domain,
+				 * after the lock is released. The domain may be free'd as a result of the event.
+				 */
+				if (ocs_list_empty(&domain->sport_list)) {
+					post_all_free = TRUE;
+				}
+
+				/* Free any node group directories */
+				ocs_lock(&sport->node_group_lock);
+					ocs_list_foreach_safe(&sport->node_group_dir_list, node_group_dir, node_group_dir_next) {
+						ocs_unlock(&sport->node_group_lock);
+							ocs_node_group_dir_free(node_group_dir);
+						ocs_lock(&sport->node_group_lock);
+					}
+				ocs_unlock(&sport->node_group_lock);
+			ocs_sport_unlock(sport);
+		ocs_domain_unlock(domain);
+
+		if (post_all_free) {
+			ocs_domain_post_event(domain, OCS_EVT_ALL_CHILD_NODES_FREE, NULL);
+		}
+
+		ocs_sport_lock_free(sport);
+		ocs_lock_free(&sport->node_group_lock);
+		ocs_scsi_sport_deleted(sport);
+
+		ocs_free(domain->ocs, sport, sizeof(*sport));
+		
+	}
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Free memory resources of a SLI port object.
+ *
+ * @par Description
+ * After the sport object is freed, its child objects are freed.
+ *
+ * @param sport Pointer to the SLI port object.
+ *
+ * @return None.
+ */
+
+void ocs_sport_force_free(ocs_sport_t *sport)
+{
+	ocs_node_t *node;
+	ocs_node_t *next;
+
+	/* shutdown sm processing */
+	ocs_sm_disable(&sport->sm);
+
+	ocs_scsi_notify_sport_force_free(sport);
+
+	ocs_sport_lock(sport);
+		ocs_list_foreach_safe(&sport->node_list, node, next) {
+			ocs_node_force_free(node);
+		}
+	ocs_sport_unlock(sport);
+	ocs_sport_free(sport);
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Return a SLI port object, given an instance index.
+ *
+ * @par Description
+ * A pointer to a sport object is returned, given its instance @c index.
+ *
+ * @param domain Pointer to the domain.
+ * @param index Instance index value to find.
+ *
+ * @return Returns a pointer to the ocs_sport_t object; or NULL.
+ */
+
+ocs_sport_t *
+ocs_sport_get_instance(ocs_domain_t *domain, uint32_t index)
+{
+	ocs_sport_t *sport;
+
+	ocs_domain_lock(domain);
+		ocs_list_foreach(&domain->sport_list, sport) {
+			if (sport->instance_index == index) {
+				ocs_domain_unlock(domain);
+				return sport;
+			}
+		}
+	ocs_domain_unlock(domain);
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Find a SLI port object, given an FC_ID.
+ *
+ * @par Description
+ * Returns a pointer to the sport object, given an FC_ID.
+ *
+ * @param domain Pointer to the domain.
+ * @param d_id FC_ID to find.
+ *
+ * @return Returns a pointer to the ocs_sport_t; or NULL.
+ */
+
+ocs_sport_t *
+ocs_sport_find(ocs_domain_t *domain, uint32_t d_id)
+{
+	ocs_sport_t *sport;
+
+	ocs_assert(domain, NULL);
+	ocs_lock(&domain->lookup_lock);
+		if (domain->lookup == NULL) {
+			ocs_log_test(domain->ocs, "assertion failed: domain->lookup is not valid\n");
+			ocs_unlock(&domain->lookup_lock);
+			return NULL;
+		}
+
+		sport = spv_get(domain->lookup, d_id);
+	ocs_unlock(&domain->lookup_lock);
+	return sport;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Find a SLI port, given the WWNN and WWPN.
+ *
+ * @par Description
+ * Return a pointer to a sport, given the WWNN and WWPN.
+ *
+ * @param domain Pointer to the domain.
+ * @param wwnn World wide node name.
+ * @param wwpn World wide port name.
+ *
+ * @return Returns a pointer to a SLI port, if found; or NULL.
+ */
+
+ocs_sport_t *
+ocs_sport_find_wwn(ocs_domain_t *domain, uint64_t wwnn, uint64_t wwpn)
+{
+	ocs_sport_t *sport = NULL;
+
+	ocs_domain_lock(domain);
+		ocs_list_foreach(&domain->sport_list, sport) {
+			if ((sport->wwnn == wwnn) && (sport->wwpn == wwpn)) {
+				ocs_domain_unlock(domain);
+				return sport;
+			}
+		}
+	ocs_domain_unlock(domain);
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Request a SLI port attach.
+ *
+ * @par Description
+ * External call to request an attach for a sport, given an FC_ID.
+ *
+ * @param sport Pointer to the sport context.
+ * @param fc_id FC_ID of which to attach.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int32_t
+ocs_sport_attach(ocs_sport_t *sport, uint32_t fc_id)
+{
+	ocs_hw_rtn_e rc;
+	ocs_node_t *node;
+
+	/* Set our lookup */
+	ocs_lock(&sport->domain->lookup_lock);
+		spv_set(sport->domain->lookup, fc_id, sport);
+	ocs_unlock(&sport->domain->lookup_lock);
+
+	/* Update our display_name */
+	ocs_node_fcid_display(fc_id, sport->display_name, sizeof(sport->display_name));
+	ocs_sport_lock(sport);
+		ocs_list_foreach(&sport->node_list, node) {
+			ocs_node_update_display_name(node);
+		}
+	ocs_sport_unlock(sport);
+	ocs_log_debug(sport->ocs, "[%s] attach sport: fc_id x%06x\n", sport->display_name, fc_id);
+
+	rc = ocs_hw_port_attach(&sport->ocs->hw, sport, fc_id);
+	if (rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(sport->ocs, "ocs_hw_port_attach failed: %d\n", rc);
+		return -1;
+	}
+	return 0;
+}
+
+/**
+ * @brief Common SLI port state machine declarations and initialization.
+ */
+#define std_sport_state_decl() \
+	ocs_sport_t *sport = NULL; \
+	ocs_domain_t *domain = NULL; \
+	ocs_t *ocs = NULL; \
+	\
+	ocs_assert(ctx, NULL); \
+	sport = ctx->app; \
+	ocs_assert(sport, NULL); \
+	\
+	domain = sport->domain; \
+	ocs_assert(domain, NULL); \
+	ocs = sport->ocs; \
+	ocs_assert(ocs, NULL);
+
+/**
+ * @brief Common SLI port state machine trace logging.
+ */
+#define sport_sm_trace(sport)  \
+	do { \
+		if (OCS_LOG_ENABLE_DOMAIN_SM_TRACE(ocs)) \
+			ocs_log_debug(ocs, "[%s] %-20s\n", sport->display_name, ocs_sm_event_name(evt)); \
+	} while (0)
+
+
+/**
+ * @brief SLI port state machine: Common event handler.
+ *
+ * @par Description
+ * Handle common sport events.
+ *
+ * @param funcname Function name to display.
+ * @param ctx Sport state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+static void *
+__ocs_sport_common(const char *funcname, ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	switch(evt) {
+	case OCS_EVT_ENTER:
+	case OCS_EVT_REENTER:
+	case OCS_EVT_EXIT:
+	case OCS_EVT_ALL_CHILD_NODES_FREE:
+		break;
+	case OCS_EVT_SPORT_ATTACH_OK:
+			ocs_sm_transition(ctx, __ocs_sport_attached, NULL);
+		break;
+	case OCS_EVT_SHUTDOWN: {
+		ocs_node_t *node;
+		ocs_node_t *node_next;
+		int node_list_empty;
+
+		/* Flag this sport as shutting down */
+		sport->shutting_down = 1;
+
+		if (sport->is_vport) {
+			ocs_vport_link_down(sport);
+		}
+
+		ocs_sport_lock(sport);
+			node_list_empty = ocs_list_empty(&sport->node_list);
+		ocs_sport_unlock(sport);
+
+		if (node_list_empty) {
+			/* sm: node list is empty / ocs_hw_port_free
+			 * Remove the sport from the domain's sparse vector lookup table */
+			ocs_lock(&domain->lookup_lock);
+				spv_set(domain->lookup, sport->fc_id, NULL);
+			ocs_unlock(&domain->lookup_lock);
+			ocs_sm_transition(ctx, __ocs_sport_wait_port_free, NULL);
+			if (ocs_hw_port_free(&ocs->hw, sport)) {
+				ocs_log_test(sport->ocs, "ocs_hw_port_free failed\n");
+				/* Not much we can do, free the sport anyways */
+				ocs_sport_free(sport);
+			}
+		} else {
+			/* sm: node list is not empty / shutdown nodes */
+			ocs_sm_transition(ctx, __ocs_sport_wait_shutdown, NULL);
+			ocs_sport_lock(sport);
+				ocs_list_foreach_safe(&sport->node_list, node, node_next) {
+					/*
+					 * If this is a vport, logout of the fabric controller so that it
+					 * deletes the vport on the switch.
+					 */
+					if((node->rnode.fc_id == FC_ADDR_FABRIC) && (sport->is_vport)) {
+						/* if link is down, don't send logo */
+						if (sport->ocs->hw.link.status == SLI_LINK_STATUS_DOWN) {
+							ocs_node_post_event(node, OCS_EVT_SHUTDOWN, NULL);
+						} else {
+							ocs_log_debug(ocs,"[%s] sport shutdown vport,sending logo to node\n",
+								      node->display_name);
+						
+							if (ocs_send_logo(node, OCS_FC_ELS_SEND_DEFAULT_TIMEOUT,
+								  0, NULL, NULL) == NULL) {
+								/* failed to send LOGO, go ahead and cleanup node anyways */
+								node_printf(node, "Failed to send LOGO\n");
+								ocs_node_post_event(node, OCS_EVT_SHUTDOWN_EXPLICIT_LOGO, NULL);
+							} else {
+								/* sent LOGO, wait for response */
+								ocs_node_transition(node, __ocs_d_wait_logo_rsp, NULL);
+							}
+						}
+					} else {
+						ocs_node_post_event(node, OCS_EVT_SHUTDOWN, NULL);
+					}
+				}
+			ocs_sport_unlock(sport);
+		}
+		break;
+	}
+	default:
+		ocs_log_test(sport->ocs, "[%s] %-20s %-20s not handled\n", sport->display_name, funcname, ocs_sm_event_name(evt));
+		break;
+	}
+
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port state machine: Physical sport allocated.
+ *
+ * @par Description
+ * This is the initial state for sport objects.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_sport_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	sport_sm_trace(sport);
+
+	switch(evt) {
+	/* the physical sport is attached */
+	case OCS_EVT_SPORT_ATTACH_OK:
+		ocs_assert(sport == domain->sport, NULL);
+		ocs_sm_transition(ctx, __ocs_sport_attached, NULL);
+		break;
+
+	case OCS_EVT_SPORT_ALLOC_OK:
+		/* ignore */
+		break;
+	default:
+		__ocs_sport_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port state machine: Handle initial virtual port events.
+ *
+ * @par Description
+ * This state is entered when a virtual port is instantiated,
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_sport_vport_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	sport_sm_trace(sport);
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		uint64_t be_wwpn = ocs_htobe64(sport->wwpn);
+
+		if (sport->wwpn == 0) {
+			ocs_log_debug(ocs, "vport: letting f/w select WWN\n");
+		}
+
+		if (sport->fc_id != UINT32_MAX) {
+			ocs_log_debug(ocs, "vport: hard coding port id: %x\n", sport->fc_id);
+		}
+
+		ocs_sm_transition(ctx, __ocs_sport_vport_wait_alloc, NULL);
+		/* If wwpn is zero, then we'll let the f/w */
+		if (ocs_hw_port_alloc(&ocs->hw, sport, sport->domain,
+			(sport->wwpn == 0) ? NULL : (uint8_t *)&be_wwpn)) {
+			ocs_log_err(ocs, "Can't allocate port\n");
+			break;
+		}
+
+
+		break;
+	}
+	default:
+		__ocs_sport_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port state machine: Wait for the HW SLI port allocation to complete.
+ *
+ * @par Description
+ * Waits for the HW sport allocation request to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_sport_vport_wait_alloc(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	sport_sm_trace(sport);
+
+	switch(evt) {
+	case OCS_EVT_SPORT_ALLOC_OK: {
+		fc_plogi_payload_t *sp = (fc_plogi_payload_t*) sport->service_params;
+		ocs_node_t *fabric;
+
+		/* If we let f/w assign wwn's, then sport wwn's with those returned by hw */
+		if (sport->wwnn == 0) {
+			sport->wwnn = ocs_be64toh(sport->sli_wwnn);
+			sport->wwpn = ocs_be64toh(sport->sli_wwpn);
+			ocs_snprintf(sport->wwnn_str, sizeof(sport->wwnn_str), "%016llx", (unsigned long long) sport->wwpn);
+		}
+
+		/* Update the sport's service parameters */
+		sp->port_name_hi = ocs_htobe32((uint32_t) (sport->wwpn >> 32ll));
+		sp->port_name_lo = ocs_htobe32((uint32_t) sport->wwpn);
+		sp->node_name_hi = ocs_htobe32((uint32_t) (sport->wwnn >> 32ll));
+		sp->node_name_lo = ocs_htobe32((uint32_t) sport->wwnn);
+
+		/* if sport->fc_id is uninitialized, then request that the fabric node use FDISC
+		 * to find an fc_id.   Otherwise we're restoring vports, or we're in
+		 * fabric emulation mode, so attach the fc_id
+		 */
+		if (sport->fc_id == UINT32_MAX) {
+			fabric = ocs_node_alloc(sport, FC_ADDR_FABRIC, FALSE, FALSE);
+			if (fabric == NULL) {
+				ocs_log_err(ocs, "ocs_node_alloc() failed\n");
+				return NULL;
+			}
+			ocs_node_transition(fabric, __ocs_vport_fabric_init, NULL);
+		} else {
+			ocs_snprintf(sport->wwnn_str, sizeof(sport->wwnn_str), "%016llx", (unsigned long long)sport->wwpn);
+			ocs_sport_attach(sport, sport->fc_id);
+		}
+		ocs_sm_transition(ctx, __ocs_sport_vport_allocated, NULL);
+		break;
+	}
+	default:
+		__ocs_sport_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port state machine: virtual sport allocated.
+ *
+ * @par Description
+ * This state is entered after the sport is allocated; it then waits for a fabric node
+ * FDISC to complete, which requests a sport attach.
+ * The sport attach complete is handled in this state.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_sport_vport_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	sport_sm_trace(sport);
+
+	switch(evt) {
+	case OCS_EVT_SPORT_ATTACH_OK: {
+		ocs_node_t *node;
+
+		if (!(domain->femul_enable)) {
+			/* Find our fabric node, and forward this event */
+			node = ocs_node_find(sport, FC_ADDR_FABRIC);
+			if (node == NULL) {
+				ocs_log_test(ocs, "can't find node %06x\n", FC_ADDR_FABRIC);
+				break;
+			}
+			/* sm: / forward sport attach to fabric node */
+			ocs_node_post_event(node, evt, NULL);
+		}
+		ocs_sm_transition(ctx, __ocs_sport_attached, NULL);
+		break;
+	}
+	default:
+		__ocs_sport_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port state machine: Attached.
+ *
+ * @par Description
+ * State entered after the sport attach has completed.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_sport_attached(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	sport_sm_trace(sport);
+
+	switch(evt) {
+	case OCS_EVT_ENTER: {
+		ocs_node_t *node;
+
+		ocs_log_debug(ocs, "[%s] SPORT attached WWPN %016llx WWNN %016llx \n", (unsigned long long)sport->display_name,
+			sport->wwpn, sport->wwnn);
+		ocs_sport_lock(sport);
+			ocs_list_foreach(&sport->node_list, node) {
+				ocs_node_update_display_name(node);
+			}
+		ocs_sport_unlock(sport);
+		sport->tgt_id = sport->fc_id;
+		if (sport->enable_ini) {
+			ocs_scsi_ini_new_sport(sport);
+		}
+		if (sport->enable_tgt) {
+			ocs_scsi_tgt_new_sport(sport);
+		}
+
+		/* Update the vport (if its not the physical sport) parameters */
+		if (sport->is_vport) {
+			ocs_vport_update_spec(sport);
+		}
+
+		break;
+	}
+
+	case OCS_EVT_EXIT:
+		ocs_log_debug(ocs, "[%s] SPORT deattached WWPN %016llx WWNN %016llx \n", (unsigned long long)sport->display_name,
+			sport->wwpn, sport->wwnn);
+		if (sport->enable_ini) {
+			ocs_scsi_ini_del_sport(sport);
+		}
+		if (sport->enable_tgt) {
+			ocs_scsi_tgt_del_sport(sport);
+		}
+		break;
+	default:
+		__ocs_sport_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port state machine: Wait for the node shutdowns to complete.
+ *
+ * @par Description
+ * Waits for the ALL_CHILD_NODES_FREE event to be posted from the node
+ * shutdown process.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_sport_wait_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	sport_sm_trace(sport);
+
+	switch(evt) {
+	case OCS_EVT_SPORT_ALLOC_OK:
+	case OCS_EVT_SPORT_ALLOC_FAIL:
+	case OCS_EVT_SPORT_ATTACH_OK:
+	case OCS_EVT_SPORT_ATTACH_FAIL:
+		/* ignore these events - just wait for the all free event */
+		break;
+
+	case OCS_EVT_ALL_CHILD_NODES_FREE: {
+		/* Remove the sport from the domain's sparse vector lookup table */
+		ocs_lock(&domain->lookup_lock);
+			spv_set(domain->lookup, sport->fc_id, NULL);
+		ocs_unlock(&domain->lookup_lock);
+		ocs_sm_transition(ctx, __ocs_sport_wait_port_free, NULL);
+		if (ocs_hw_port_free(&ocs->hw, sport)) {
+			ocs_log_err(sport->ocs, "ocs_hw_port_free failed\n");
+			/* Not much we can do, free the sport anyways */
+			ocs_sport_free(sport);
+		}
+		break;
+	}
+	default:
+		__ocs_sport_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief SLI port state machine: Wait for the HW's port free to complete.
+ *
+ * @par Description
+ * Waits for the HW's port free to complete.
+ *
+ * @param ctx Remote node state machine context.
+ * @param evt Event to process.
+ * @param arg Per event optional argument.
+ *
+ * @return Returns NULL.
+ */
+
+void *
+__ocs_sport_wait_port_free(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg)
+{
+	std_sport_state_decl();
+
+	sport_sm_trace(sport);
+
+	switch(evt) {
+	case OCS_EVT_SPORT_ATTACH_OK:
+		/* Ignore as we are waiting for the free CB */
+		break;
+	case OCS_EVT_SPORT_FREE_OK: {
+		/* All done, free myself */
+		ocs_sport_free(sport);
+		break;
+	}
+	default:
+		__ocs_sport_common(__func__, ctx, evt, arg);
+		return NULL;
+	}
+	return NULL;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Start the vports on a domain
+ *
+ * @par Description
+ * Use the vport specification to find the associated vports and start them.
+ *
+ * @param domain Pointer to the domain context.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+int32_t
+ocs_vport_start(ocs_domain_t *domain)
+{
+	ocs_t *ocs = domain->ocs;
+	ocs_xport_t *xport = ocs->xport;
+	ocs_vport_spec_t *vport;
+	ocs_vport_spec_t *next;
+	ocs_sport_t *sport;
+	int32_t rc = 0;
+
+	ocs_device_lock(ocs);
+	ocs_list_foreach_safe(&xport->vport_list, vport, next) {
+		if (vport->domain_instance == domain->instance_index &&
+		    vport->sport == NULL) {
+			/* If role not set, skip this vport */
+			if (!(vport->enable_ini || vport->enable_tgt)) {
+				continue;
+			}
+
+			/* Allocate a sport */
+			vport->sport = sport = ocs_sport_alloc(domain, vport->wwpn, vport->wwnn, vport->fc_id,
+							       vport->enable_ini, vport->enable_tgt);
+			if (sport == NULL) {
+				rc = -1;
+			} else {
+				sport->is_vport = 1;
+				sport->tgt_data = vport->tgt_data;
+				sport->ini_data = vport->ini_data;
+
+				/* Transition to vport_init */
+				ocs_sm_transition(&sport->sm, __ocs_sport_vport_init, NULL);
+			}
+		}
+	}
+	ocs_device_unlock(ocs);
+	return rc;
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Clear the sport reference in the vport specification.
+ *
+ * @par Description
+ * Clear the sport pointer on the vport specification when the vport is torn down. This allows it to be
+ * re-created when the link is re-established.
+ *
+ * @param sport Pointer to the sport context.
+ */
+static void
+ocs_vport_link_down(ocs_sport_t *sport)
+{
+	ocs_t *ocs = sport->ocs;
+	ocs_xport_t *xport = ocs->xport;
+	ocs_vport_spec_t *vport;
+
+	ocs_device_lock(ocs);
+	ocs_list_foreach(&xport->vport_list, vport) {
+		if (vport->sport == sport) {
+			vport->sport = NULL;
+			break;
+		}
+	}
+	ocs_device_unlock(ocs);
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Allocate a new virtual SLI port.
+ *
+ * @par Description
+ * A new sport is created, in response to an external management request.
+ *
+ * @n @b Note: If the WWPN is zero, the firmware will assign the WWNs.
+ *
+ * @param domain Pointer to the domain context.
+ * @param wwpn World wide port name.
+ * @param wwnn World wide node name
+ * @param fc_id Requested port ID (used in fabric emulation mode).
+ * @param ini TRUE, if port is created as an initiator node.
+ * @param tgt TRUE, if port is created as a target node.
+ * @param tgt_data Pointer to target specific data
+ * @param ini_data Pointer to initiator specific data
+ * @param restore_vport If TRUE, then the vport will be re-created automatically
+ *                      on link disruption.
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+int32_t
+ocs_sport_vport_new(ocs_domain_t *domain, uint64_t wwpn, uint64_t wwnn,
+		    uint32_t fc_id, uint8_t ini, uint8_t tgt, void *tgt_data,
+		    void *ini_data, uint8_t restore_vport)
+{
+	ocs_sport_t *sport;
+
+	if (ini && (domain->ocs->enable_ini == 0)) {
+		ocs_log_test(domain->ocs, "driver initiator functionality not enabled\n");
+		return -1;
+	}
+
+	if (tgt && (domain->ocs->enable_tgt == 0)) {
+		ocs_log_test(domain->ocs, "driver target functionality not enabled\n");
+		return -1;
+	}
+
+	/* Create a vport spec if we need to recreate this vport after a link up event */
+	if (restore_vport) {
+		if (ocs_vport_create_spec(domain->ocs, wwnn, wwpn, fc_id, ini, tgt, tgt_data, ini_data)) {
+			ocs_log_test(domain->ocs, "failed to create vport object entry\n");
+			return -1;
+		}
+		return ocs_vport_start(domain);
+	}
+
+	/* Allocate a sport */
+	sport = ocs_sport_alloc(domain, wwpn, wwnn, fc_id, ini, tgt);
+
+	if (sport == NULL) {
+		return -1;
+	}
+
+	sport->is_vport = 1;
+	sport->tgt_data = tgt_data;
+	sport->ini_data = ini_data;
+	
+	/* Transition to vport_init */
+	ocs_sm_transition(&sport->sm, __ocs_sport_vport_init, NULL);
+
+	return 0;
+}
+
+int32_t
+ocs_sport_vport_alloc(ocs_domain_t *domain, ocs_vport_spec_t *vport)
+{
+	ocs_sport_t *sport = NULL;
+
+	if (domain == NULL) {
+		return (0);
+	}
+
+	ocs_assert((vport->sport == NULL), -1);	
+
+	/* Allocate a sport */
+	vport->sport = sport = ocs_sport_alloc(domain, vport->wwpn, vport->wwnn, UINT32_MAX, vport->enable_ini, vport->enable_tgt);
+
+	if (sport == NULL) {
+		return -1;
+	}
+
+	sport->is_vport = 1;
+	sport->tgt_data = vport->tgt_data;
+	sport->ini_data = vport->tgt_data;
+
+	/* Transition to vport_init */
+	ocs_sm_transition(&sport->sm, __ocs_sport_vport_init, NULL);
+
+	return (0);
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Remove a previously-allocated virtual port.
+ *
+ * @par Description
+ * A previously-allocated virtual port is removed by posting the shutdown event to the
+ * sport with a matching WWN.
+ *
+ * @param ocs Pointer to the device object.
+ * @param domain Pointer to the domain structure (may be NULL).
+ * @param wwpn World wide port name of the port to delete (host endian).
+ * @param wwnn World wide node name of the port to delete (host endian).
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int32_t ocs_sport_vport_del(ocs_t *ocs, ocs_domain_t *domain, uint64_t wwpn, uint64_t wwnn)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_sport_t *sport;
+	int found = 0;
+	ocs_vport_spec_t *vport;
+	ocs_vport_spec_t *next;
+	uint32_t instance;
+
+	/* If no domain is given, use instance 0, otherwise use domain instance */
+	if (domain == NULL) {
+		instance = 0;
+	} else {
+		instance = domain->instance_index;
+	}
+
+	/* walk the ocs_vport_list and remove from there */
+
+	ocs_device_lock(ocs);
+		ocs_list_foreach_safe(&xport->vport_list, vport, next) {
+			if ((vport->domain_instance == instance) &&
+				(vport->wwpn == wwpn) && (vport->wwnn == wwnn)) {
+				vport->sport = NULL;
+				break;
+			}
+		}
+	ocs_device_unlock(ocs);
+
+	if (domain == NULL) {
+		/* No domain means no sport to look for */
+		return 0;
+	}
+
+	ocs_domain_lock(domain);
+		ocs_list_foreach(&domain->sport_list, sport) {
+			if ((sport->wwpn == wwpn) && (sport->wwnn == wwnn)) {
+				found = 1;
+				break;
+			}
+		}
+		if (found) {
+			/* Shutdown this SPORT */
+			ocs_sm_post_event(&sport->sm, OCS_EVT_SHUTDOWN, NULL);
+		}
+	ocs_domain_unlock(domain);
+	return 0;
+}
+
+/**
+ * @brief Force free all saved vports.
+ *
+ * @par Description
+ * Delete all device vports.
+ *
+ * @param ocs Pointer to the device object.
+ *
+ * @return None.
+ */
+
+void
+ocs_vport_del_all(ocs_t *ocs)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_vport_spec_t *vport;
+	ocs_vport_spec_t *next;
+
+	ocs_device_lock(ocs);
+		ocs_list_foreach_safe(&xport->vport_list, vport, next) {
+			ocs_list_remove(&xport->vport_list, vport);
+			ocs_free(ocs, vport, sizeof(*vport));
+		}
+	ocs_device_unlock(ocs);
+}
+
+/**
+ * @ingroup sport_sm
+ * @brief Generate a SLI port ddump.
+ *
+ * @par Description
+ * Generates the SLI port ddump data.
+ *
+ * @param textbuf Pointer to the text buffer.
+ * @param sport Pointer to the SLI-4 port.
+ *
+ * @return Returns 0 on success, or a negative value on failure.
+ */
+
+int
+ocs_ddump_sport(ocs_textbuf_t *textbuf, ocs_sli_port_t *sport)
+{
+	ocs_node_t *node;
+	ocs_node_group_dir_t *node_group_dir;
+	int retval = 0;
+
+	ocs_ddump_section(textbuf, "sport", sport->instance_index);
+	ocs_ddump_value(textbuf, "display_name", "%s", sport->display_name);
+
+	ocs_ddump_value(textbuf, "is_vport", "%d", sport->is_vport);
+	ocs_ddump_value(textbuf, "enable_ini", "%d", sport->enable_ini);
+	ocs_ddump_value(textbuf, "enable_tgt", "%d", sport->enable_tgt);
+	ocs_ddump_value(textbuf, "shutting_down", "%d", sport->shutting_down);
+	ocs_ddump_value(textbuf, "topology", "%d", sport->topology);
+	ocs_ddump_value(textbuf, "p2p_winner", "%d", sport->p2p_winner);
+	ocs_ddump_value(textbuf, "p2p_port_id", "%06x", sport->p2p_port_id);
+	ocs_ddump_value(textbuf, "p2p_remote_port_id", "%06x", sport->p2p_remote_port_id);
+	ocs_ddump_value(textbuf, "wwpn", "%016llx", (unsigned long long)sport->wwpn);
+	ocs_ddump_value(textbuf, "wwnn", "%016llx", (unsigned long long)sport->wwnn);
+	/*TODO: service_params */
+
+	ocs_ddump_value(textbuf, "indicator", "x%x", sport->indicator);
+	ocs_ddump_value(textbuf, "fc_id", "x%06x", sport->fc_id);
+	ocs_ddump_value(textbuf, "index", "%d", sport->index);
+
+	ocs_display_sparams(NULL, "sport_sparams", 1, textbuf, sport->service_params+4);
+
+	/* HLM dump */
+	ocs_ddump_section(textbuf, "hlm", sport->instance_index);
+	ocs_lock(&sport->node_group_lock);
+		ocs_list_foreach(&sport->node_group_dir_list, node_group_dir) {
+			ocs_remote_node_group_t *remote_node_group;
+
+			ocs_ddump_section(textbuf, "node_group_dir", node_group_dir->instance_index);
+
+			ocs_ddump_value(textbuf, "node_group_list_count", "%d", node_group_dir->node_group_list_count);
+			ocs_ddump_value(textbuf, "next_idx", "%d", node_group_dir->next_idx);
+			ocs_list_foreach(&node_group_dir->node_group_list, remote_node_group) {
+				ocs_ddump_section(textbuf, "node_group", remote_node_group->instance_index);
+				ocs_ddump_value(textbuf, "indicator", "x%x", remote_node_group->indicator);
+				ocs_ddump_value(textbuf, "index", "x%x", remote_node_group->index);
+				ocs_ddump_value(textbuf, "instance_index", "x%x", remote_node_group->instance_index);
+				ocs_ddump_endsection(textbuf, "node_group", 0);
+			}
+			ocs_ddump_endsection(textbuf, "node_group_dir", 0);
+		}
+	ocs_unlock(&sport->node_group_lock);
+	ocs_ddump_endsection(textbuf, "hlm", sport->instance_index);
+
+	ocs_scsi_ini_ddump(textbuf, OCS_SCSI_DDUMP_SPORT, sport);
+	ocs_scsi_tgt_ddump(textbuf, OCS_SCSI_DDUMP_SPORT, sport);
+
+	/* Dump all the nodes */
+	if (ocs_sport_lock_try(sport) != TRUE) {
+		/* Didn't get lock */
+		return -1;
+	}
+		/* Here the sport lock is held */
+		ocs_list_foreach(&sport->node_list, node) {
+			retval = ocs_ddump_node(textbuf, node);
+			if (retval != 0) {
+				break;
+			}
+		}
+	ocs_sport_unlock(sport);
+
+	ocs_ddump_endsection(textbuf, "sport", sport->index);
+
+	return retval;
+}
+
+
+void
+ocs_mgmt_sport_list(ocs_textbuf_t *textbuf, void *object)
+{
+	ocs_node_t *node;
+	ocs_sport_t *sport = (ocs_sport_t *)object;
+
+	ocs_mgmt_start_section(textbuf, "sport", sport->instance_index);
+
+	/* Add my status values to textbuf */
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "indicator");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "fc_id");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "index");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "display_name");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "is_vport");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_ini");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "enable_tgt");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "p2p");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "p2p_winner");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "p2p_port_id");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "p2p_remote_port_id");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "wwpn");
+	ocs_mgmt_emit_property_name(textbuf, MGMT_MODE_RD, "wwnn");
+
+	if (ocs_sport_lock_try(sport) == TRUE) {
+
+		/* If we get here, then we are holding the sport lock */
+		ocs_list_foreach(&sport->node_list, node) {
+			if ((node->mgmt_functions) && (node->mgmt_functions->get_list_handler)) {
+				node->mgmt_functions->get_list_handler(textbuf, node);
+			}
+
+		}
+		ocs_sport_unlock(sport);
+	}
+
+	ocs_mgmt_end_section(textbuf, "sport", sport->instance_index);
+}
+
+int
+ocs_mgmt_sport_get(ocs_textbuf_t *textbuf, char *parent, char *name, void *object)
+{
+	ocs_node_t *node;
+	ocs_sport_t *sport = (ocs_sport_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	ocs_mgmt_start_section(textbuf, "sport", sport->instance_index);
+
+	snprintf(qualifier, sizeof(qualifier), "%s/sport[%d]", parent, sport->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+		char *unqualified_name = name + strlen(qualifier) +1;
+
+		/* See if it's a value I can supply */
+		if (ocs_strcmp(unqualified_name, "indicator") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "indicator", "0x%x", sport->indicator);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "fc_id") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "0x%06x", sport->fc_id);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "index") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "index", "%d", sport->index);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "display_name") == 0) {
+			ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", sport->display_name);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "is_vport") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_vport",  sport->is_vport);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "enable_ini") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_ini",  sport->enable_ini);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "enable_tgt") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_tgt",  sport->enable_tgt);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "p2p_winner") == 0) {
+			ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "p2p_winner",  sport->p2p_winner);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "p2p_port_id") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p2p_port_id", "0x%06x", sport->p2p_port_id);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "p2p_remote_port_id") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p2p_remote_port_id", "0x%06x", sport->p2p_remote_port_id);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "wwpn") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwpn", "0x%016llx", (unsigned long long)sport->wwpn);
+			retval = 0;
+		} else if (ocs_strcmp(unqualified_name, "wwnn") == 0) {
+			ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwnn", "0x%016llx", (unsigned long long)sport->wwnn);
+			retval = 0;
+		} else {
+			/* If I didn't know the value of this status pass the request to each of my children */
+			ocs_sport_lock(sport);
+				ocs_list_foreach(&sport->node_list, node) {
+					if ((node->mgmt_functions) && (node->mgmt_functions->get_handler)) {
+						retval = node->mgmt_functions->get_handler(textbuf, qualifier, name, node);
+					}
+
+					if (retval == 0) {
+						break;
+					}
+				}
+			ocs_sport_unlock(sport);
+		}
+	}
+
+	ocs_mgmt_end_section(textbuf, "sport", sport->instance_index);
+
+	return retval;
+}
+
+void
+ocs_mgmt_sport_get_all(ocs_textbuf_t *textbuf, void *object)
+{
+	ocs_node_t *node;
+	ocs_sport_t *sport = (ocs_sport_t *)object;
+
+	ocs_mgmt_start_section(textbuf, "sport", sport->instance_index);
+
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "indicator", "0x%x", sport->indicator);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "fc_id", "0x%06x", sport->fc_id);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "index", "%d", sport->index);
+	ocs_mgmt_emit_string(textbuf, MGMT_MODE_RD, "display_name", sport->display_name);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "is_vport",  sport->is_vport);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_ini",  sport->enable_ini);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "enable_tgt",  sport->enable_tgt);
+	ocs_mgmt_emit_boolean(textbuf, MGMT_MODE_RD, "p2p_winner",  sport->p2p_winner);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p2p_port_id", "0x%06x", sport->p2p_port_id);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "p2p_remote_port_id", "0x%06x", sport->p2p_remote_port_id);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwpn", "0x%016llx" , (unsigned long long)sport->wwpn);
+	ocs_mgmt_emit_int(textbuf, MGMT_MODE_RD, "wwnn", "0x%016llx", (unsigned long long)sport->wwnn);
+
+	ocs_sport_lock(sport);
+	ocs_list_foreach(&sport->node_list, node) {
+		if ((node->mgmt_functions) && (node->mgmt_functions->get_all_handler)) {
+			node->mgmt_functions->get_all_handler(textbuf, node);
+		}
+	}
+	ocs_sport_unlock(sport);
+
+	ocs_mgmt_end_section(textbuf, "sport", sport->instance_index);
+}
+
+int
+ocs_mgmt_sport_set(char *parent, char *name, char *value, void *object)
+{
+	ocs_node_t *node;
+	ocs_sport_t *sport = (ocs_sport_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	snprintf(qualifier, sizeof(qualifier), "%s/sport[%d]", parent, sport->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(name, qualifier, strlen(qualifier)) == 0) {
+		/* The sport has no settable values.  Pass the request to each node. */
+
+		ocs_sport_lock(sport);
+		ocs_list_foreach(&sport->node_list, node) {
+			if ((node->mgmt_functions) && (node->mgmt_functions->set_handler)) {
+				retval = node->mgmt_functions->set_handler(qualifier, name, value, node);
+			}
+			if (retval == 0) {
+				break;
+			}
+		}
+		ocs_sport_unlock(sport);
+	}
+
+	return retval;
+}
+
+
+int
+ocs_mgmt_sport_exec(char *parent, char *action, void *arg_in, uint32_t arg_in_length,
+		    void *arg_out, uint32_t arg_out_length, void *object)
+{
+	ocs_node_t *node;
+	ocs_sport_t *sport = (ocs_sport_t *)object;
+	char qualifier[80];
+	int retval = -1;
+
+	snprintf(qualifier, sizeof(qualifier), "%s.sport%d", parent, sport->instance_index);
+
+	/* If it doesn't start with my qualifier I don't know what to do with it */
+	if (ocs_strncmp(action, qualifier, strlen(qualifier)) == 0) {
+
+		/* See if it's an action I can perform */
+
+		/* if (ocs_strcmp ....
+		 * {
+		 * } else
+		 */
+
+		{
+			/* If I didn't know how to do this action pass the request to each of my children */
+			ocs_sport_lock(sport);
+				ocs_list_foreach(&sport->node_list, node) {
+					if ((node->mgmt_functions) && (node->mgmt_functions->exec_handler)) {
+						retval = node->mgmt_functions->exec_handler(qualifier, action, arg_in, arg_in_length,
+											    arg_out, arg_out_length, node);
+					}
+
+					if (retval == 0) {
+						break;
+					}
+
+				}
+			ocs_sport_unlock(sport);
+		}
+	}
+
+	return retval;
+}
+
+/**
+ * @brief Save the virtual port's parameters.
+ *
+ * @par Description
+ * The information required to restore a virtual port is saved.
+ *
+ * @param sport Pointer to the sport context.
+ *
+ * @return None.
+ */
+
+static void
+ocs_vport_update_spec(ocs_sport_t *sport)
+{
+	ocs_t *ocs = sport->ocs;
+	ocs_xport_t *xport = ocs->xport;
+	ocs_vport_spec_t *vport;
+
+	ocs_device_lock(ocs);
+	ocs_list_foreach(&xport->vport_list, vport) {
+		if (vport->sport == sport) {
+			vport->wwnn = sport->wwnn;
+			vport->wwpn = sport->wwpn;
+			vport->tgt_data = sport->tgt_data;
+			vport->ini_data = sport->ini_data;
+			break;
+		}
+	}
+	ocs_device_unlock(ocs);
+}
+
+/**
+ * @brief Create a saved vport entry.
+ *
+ * A saved vport entry is added to the vport list, which is restored following
+ * a link up. This function is used to allow vports to be created the first time
+ * the link comes up without having to go through the ioctl() API.
+ *
+ * @param ocs Pointer to device context.
+ * @param wwnn World wide node name (may be zero for auto-select).
+ * @param wwpn World wide port name (may be zero for auto-select).
+ * @param fc_id Requested port ID (used in fabric emulation mode).
+ * @param enable_ini TRUE if vport is to be an initiator port.
+ * @param enable_tgt TRUE if vport is to be a target port.
+ * @param tgt_data Pointer to target specific data.
+ * @param ini_data Pointer to initiator specific data.
+ *
+ * @return None.
+ */
+
+int8_t 
+ocs_vport_create_spec(ocs_t *ocs, uint64_t wwnn, uint64_t wwpn, uint32_t fc_id, uint32_t enable_ini, uint32_t enable_tgt, void *tgt_data, void *ini_data)
+{
+	ocs_xport_t *xport = ocs->xport;
+	ocs_vport_spec_t *vport;
+
+	/* walk the ocs_vport_list and return failure if a valid(vport with non zero WWPN and WWNN) vport entry 
+	   is already created */
+	ocs_list_foreach(&xport->vport_list, vport) {
+		if ((wwpn && (vport->wwpn == wwpn)) && (wwnn && (vport->wwnn == wwnn))) {
+			ocs_log_test(ocs, "Failed: VPORT %016llx  %016llx already allocated\n",
+				     (unsigned long long)wwnn, (unsigned long long)wwpn);
+			return -1;
+		}
+	}
+
+	vport = ocs_malloc(ocs, sizeof(*vport), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (vport == NULL) {
+		ocs_log_err(ocs, "ocs_malloc failed\n");
+		return -1;
+	}
+
+	vport->wwnn = wwnn;
+	vport->wwpn = wwpn;
+	vport->fc_id = fc_id;
+	vport->domain_instance = 0;	/*TODO: may need to change this */
+	vport->enable_tgt = enable_tgt;
+	vport->enable_ini = enable_ini;
+	vport->tgt_data = tgt_data;
+	vport->ini_data = ini_data;
+
+	ocs_device_lock(ocs);
+		ocs_list_add_tail(&xport->vport_list, vport);
+	ocs_device_unlock(ocs);
+	return 0;
+}
+
+/* node group api */
+
+/**
+ * @brief Perform the AND operation on source vectors.
+ *
+ * @par Description
+ * Performs an AND operation on the 8-bit values in source vectors @c b and @c c.
+ * The resulting value is stored in @c a.
+ *
+ * @param a Destination-byte vector.
+ * @param b Source-byte vector.
+ * @param c Source-byte vector.
+ * @param n Byte count.
+ *
+ * @return None.
+ */
+
+static void
+and8(uint8_t *a, uint8_t *b, uint8_t *c, uint32_t n)
+{
+	uint32_t i;
+
+	for (i = 0; i < n; i ++) {
+		*a = *b & *c;
+		a++;
+		b++;
+		c++;
+	}
+}
+
+/**
+ * @brief Service parameters mask data.
+ */
+static fc_sparms_t sparms_cmp_mask = {
+	0,			/*uint32_t	command_code: 8, */
+	0,			/*		resv1: 24; */
+	{~0, ~0, ~0, ~0},	/* uint32_t	common_service_parameters[4]; */
+	0,			/* uint32_t	port_name_hi; */
+	0,			/* uint32_t	port_name_lo; */
+	0,			/* uint32_t	node_name_hi; */
+	0,			/* uint32_t	node_name_lo; */
+	{~0, ~0, ~0, ~0},	/* uint32_t	class1_service_parameters[4]; */
+	{~0, ~0, ~0, ~0},	/* uint32_t	class2_service_parameters[4]; */
+	{~0, ~0, ~0, ~0},	/* uint32_t	class3_service_parameters[4]; */
+	{~0, ~0, ~0, ~0},	/* uint32_t	class4_service_parameters[4]; */
+	{~0, ~0, ~0, ~0}};	/* uint32_t	vendor_version_level[4]; */
+
+/**
+ * @brief Compare service parameters.
+ *
+ * @par Description
+ * Returns 0 if the two service parameters are the same, excluding the port/node name
+ * elements.
+ *
+ * @param sp1 Pointer to service parameters 1.
+ * @param sp2 Pointer to service parameters 2.
+ *
+ * @return Returns 0 if parameters match; otherwise, returns a positive or negative value,
+ * depending on the arithmetic magnitude of the first mismatching byte.
+ */
+
+int
+ocs_sparm_cmp(uint8_t *sp1, uint8_t *sp2)
+{
+	int i;
+	int v;
+	uint8_t *sp3 = (uint8_t*) &sparms_cmp_mask;
+
+	for (i = 0; i < OCS_SERVICE_PARMS_LENGTH; i ++) {
+		v = ((int)(sp1[i] & sp3[i])) - ((int)(sp2[i] & sp3[i]));
+		if (v) {
+			break;
+		}
+	}
+	return v;
+}
+
+/**
+ * @brief Allocate a node group directory entry.
+ *
+ * @par Description
+ * A node group directory entry is allocated, initialized, and added to the sport's
+ * node group directory list.
+ *
+ * @param sport Pointer to the sport object.
+ * @param sparms Pointer to the service parameters.
+ *
+ * @return Returns a pointer to the allocated ocs_node_group_dir_t; or NULL.
+ */
+
+ocs_node_group_dir_t *
+ocs_node_group_dir_alloc(ocs_sport_t *sport, uint8_t *sparms)
+{
+	ocs_node_group_dir_t *node_group_dir;
+
+	node_group_dir = ocs_malloc(sport->ocs, sizeof(*node_group_dir), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (node_group_dir != NULL) {
+		node_group_dir->sport = sport;
+
+		ocs_lock(&sport->node_group_lock);
+			node_group_dir->instance_index = sport->node_group_dir_next_instance++;
+			and8(node_group_dir->service_params, sparms, (uint8_t*)&sparms_cmp_mask, OCS_SERVICE_PARMS_LENGTH);
+			ocs_list_init(&node_group_dir->node_group_list, ocs_remote_node_group_t, link);
+
+			node_group_dir->node_group_list_count = 0;
+			node_group_dir->next_idx = 0;
+			ocs_list_add_tail(&sport->node_group_dir_list, node_group_dir);
+		ocs_unlock(&sport->node_group_lock);
+
+		ocs_log_debug(sport->ocs, "[%s] [%d] allocating node group directory\n", sport->display_name,
+			node_group_dir->instance_index);
+	}
+	return node_group_dir;
+}
+
+/**
+ * @brief Free a node group directory entry.
+ *
+ * @par Description
+ * The node group directory entry @c node_group_dir is removed
+ * from the sport's node group directory list and freed.
+ *
+ * @param node_group_dir Pointer to the node group directory entry.
+ *
+ * @return None.
+ */
+
+void
+ocs_node_group_dir_free(ocs_node_group_dir_t *node_group_dir)
+{
+	ocs_sport_t *sport;
+	if (node_group_dir != NULL) {
+		sport = node_group_dir->sport;
+		ocs_log_debug(sport->ocs, "[%s] [%d] freeing node group directory\n", sport->display_name,
+			node_group_dir->instance_index);
+		ocs_lock(&sport->node_group_lock);
+			if (!ocs_list_empty(&node_group_dir->node_group_list)) {
+				ocs_log_test(sport->ocs, "[%s] WARNING: node group list not empty\n", sport->display_name);
+			}
+			ocs_list_remove(&sport->node_group_dir_list, node_group_dir);
+		ocs_unlock(&sport->node_group_lock);
+		ocs_free(sport->ocs, node_group_dir, sizeof(*node_group_dir));
+	}
+}
+
+/**
+ * @brief Find a matching node group directory entry.
+ *
+ * @par Description
+ * The sport's node group directory list is searched for a matching set of
+ * service parameters. The first matching entry is returned; otherwise
+ * NULL is returned.
+ *
+ * @param sport Pointer to the sport object.
+ * @param sparms Pointer to the sparams to match.
+ *
+ * @return Returns a pointer to the first matching entry found; or NULL.
+ */
+
+ocs_node_group_dir_t *
+ocs_node_group_dir_find(ocs_sport_t *sport, uint8_t *sparms)
+{
+	ocs_node_group_dir_t *node_dir = NULL;
+
+	ocs_lock(&sport->node_group_lock);
+		ocs_list_foreach(&sport->node_group_dir_list, node_dir) {
+			if (ocs_sparm_cmp(sparms, node_dir->service_params) == 0) {
+				ocs_unlock(&sport->node_group_lock);
+				return node_dir;
+			}
+		}
+	ocs_unlock(&sport->node_group_lock);
+	return NULL;
+}
+
+/**
+ * @brief Allocate a remote node group object.
+ *
+ * @par Description
+ * A remote node group object is allocated, initialized, and placed on the node group
+ * list of @c node_group_dir. The HW remote node group @b alloc function is called.
+ *
+ * @param node_group_dir Pointer to the node group directory.
+ *
+ * @return Returns a pointer to the allocated remote node group object; or NULL.
+ */
+
+ocs_remote_node_group_t *
+ocs_remote_node_group_alloc(ocs_node_group_dir_t *node_group_dir)
+{
+	ocs_t *ocs;
+	ocs_sport_t *sport;
+	ocs_remote_node_group_t *node_group;
+	ocs_hw_rtn_e hrc;
+
+	ocs_assert(node_group_dir, NULL);
+	ocs_assert(node_group_dir->sport, NULL);
+	ocs_assert(node_group_dir->sport->ocs, NULL);
+
+	sport = node_group_dir->sport;
+	ocs = sport->ocs;
+
+
+	node_group = ocs_malloc(ocs, sizeof(*node_group), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (node_group != NULL) {
+
+		/* set pointer to node group directory */
+		node_group->node_group_dir = node_group_dir;
+
+		ocs_lock(&node_group_dir->sport->node_group_lock);
+			node_group->instance_index = sport->node_group_next_instance++;
+		ocs_unlock(&node_group_dir->sport->node_group_lock);
+
+		/* invoke HW node group inialization */
+		hrc = ocs_hw_node_group_alloc(&ocs->hw, node_group);
+		if (hrc != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(ocs, "ocs_hw_node_group_alloc() failed: %d\n", hrc);
+			ocs_free(ocs, node_group, sizeof(*node_group));
+			return NULL;
+		}
+
+		ocs_log_debug(ocs, "[%s] [%d] indicator x%03x allocating node group\n", sport->display_name,
+			node_group->indicator, node_group->instance_index);
+
+			/* add to the node group directory entry node group list */
+		ocs_lock(&node_group_dir->sport->node_group_lock);
+			ocs_list_add_tail(&node_group_dir->node_group_list, node_group);
+			node_group_dir->node_group_list_count ++;
+		ocs_unlock(&node_group_dir->sport->node_group_lock);
+	}
+	return node_group;
+}
+
+/**
+ * @brief Free a remote node group object.
+ *
+ * @par Description
+ * The remote node group object @c node_group is removed from its
+ * node group directory entry and freed.
+ *
+ * @param node_group Pointer to the remote node group object.
+ *
+ * @return None.
+ */
+
+void
+ocs_remote_node_group_free(ocs_remote_node_group_t *node_group)
+{
+	ocs_sport_t *sport;
+	ocs_node_group_dir_t *node_group_dir;
+
+	if (node_group != NULL) {
+
+		ocs_assert(node_group->node_group_dir);
+		ocs_assert(node_group->node_group_dir->sport);
+		ocs_assert(node_group->node_group_dir->sport->ocs);
+
+		node_group_dir = node_group->node_group_dir;
+		sport = node_group_dir->sport;
+
+		ocs_log_debug(sport->ocs, "[%s] [%d] freeing node group\n", sport->display_name, node_group->instance_index);
+
+		/* Remove from node group directory node group list */
+		ocs_lock(&sport->node_group_lock);
+			ocs_list_remove(&node_group_dir->node_group_list, node_group);
+			node_group_dir->node_group_list_count --;
+		/* TODO: note that we're going to have the node_group_dir entry persist forever ... we could delete it if
+		 * the group_list_count goes to zero (or the linked list is empty */
+		ocs_unlock(&sport->node_group_lock);
+		ocs_free(sport->ocs, node_group, sizeof(*node_group));
+	}
+}
+
+/**
+ * @brief Initialize a node for high login mode.
+ *
+ * @par Description
+ * The @c node is initialized for high login mode. The following steps are performed:
+ * 1. The sports node group directory is searched for a matching set of service parameters.
+ * 2. If a matching set is not found, a node group directory entry is allocated.
+ * 3. If less than the @c hlm_group_size number of remote node group objects is present in the
+ *   node group directory, a new remote node group object is allocated and added to the list.
+ * 4. A remote node group object is selected, and the node is attached to the node group.
+ *
+ * @param node Pointer to the node.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int
+ocs_node_group_init(ocs_node_t *node)
+{
+	ocs_t *ocs;
+	ocs_sport_t *sport;
+	ocs_node_group_dir_t *node_group_dir;
+	ocs_remote_node_group_t *node_group;
+	ocs_hw_rtn_e hrc;
+
+	ocs_assert(node, -1);
+	ocs_assert(node->sport, -1);
+	ocs_assert(node->ocs, -1);
+
+	ocs = node->ocs;
+	sport = node->sport;
+
+	ocs_assert(ocs->enable_hlm, -1);
+
+	/* see if there's a node group directory allocated for this service parameter set */
+	node_group_dir = ocs_node_group_dir_find(sport, node->service_params);
+	if (node_group_dir == NULL) {
+		/* not found, so allocate one */
+		node_group_dir = ocs_node_group_dir_alloc(sport, node->service_params);
+		if (node_group_dir == NULL) {
+			/* node group directory allocation failed ... can't continue, however,
+			 * the node will be allocated with a normal (not shared) RPI
+			 */
+			ocs_log_err(ocs, "ocs_node_group_dir_alloc() failed\n");
+			return -1;
+		}
+	}
+
+	/* check to see if we've allocated hlm_group_size's worth of node group structures for this
+	 * directory entry, if not, then allocate and use a new one, otherwise pick the next one.
+	 */
+	ocs_lock(&node->sport->node_group_lock);
+		if (node_group_dir->node_group_list_count < ocs->hlm_group_size) {
+			ocs_unlock(&node->sport->node_group_lock);
+				node_group = ocs_remote_node_group_alloc(node_group_dir);
+			if (node_group == NULL) {
+				ocs_log_err(ocs, "ocs_remote_node_group_alloc() failed\n");
+				return -1;
+			}
+			ocs_lock(&node->sport->node_group_lock);
+		} else {
+			uint32_t idx = 0;
+
+			ocs_list_foreach(&node_group_dir->node_group_list, node_group) {
+				if (idx >= ocs->hlm_group_size) {
+					ocs_log_err(node->ocs, "assertion failed: idx >= ocs->hlm_group_size\n");
+					ocs_unlock(&node->sport->node_group_lock);
+					return -1;
+				}
+
+				if (idx == node_group_dir->next_idx) {
+					break;
+				}
+				idx ++;
+			}
+			if (idx == ocs->hlm_group_size) {
+				node_group = ocs_list_get_head(&node_group_dir->node_group_list);
+			}
+			if (++node_group_dir->next_idx >= node_group_dir->node_group_list_count) {
+				node_group_dir->next_idx = 0;
+			}
+		}
+	ocs_unlock(&node->sport->node_group_lock);
+
+	/* Initialize a pointer in the node back to the node group */
+	node->node_group = node_group;
+
+	/* Join this node into the group */
+	hrc = ocs_hw_node_group_attach(&ocs->hw, node_group, &node->rnode);
+
+	return (hrc == OCS_HW_RTN_SUCCESS) ? 0 : -1;
+}
+
+
diff --git a/sys/dev/ocs_fc/ocs_sport.h b/sys/dev/ocs_fc/ocs_sport.h
new file mode 100644
index 000000000000..88bc5f5d949a
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_sport.h
@@ -0,0 +1,113 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS FC SLI port (SPORT) exported declarations
+ *
+ */
+
+#if !defined(__OCS_SPORT_H__)
+#define __OCS_SPORT_H__
+
+extern int32_t ocs_port_cb(void *arg, ocs_hw_port_event_e event, void *data);
+extern ocs_sport_t *ocs_sport_alloc(ocs_domain_t *domain, uint64_t wwpn, uint64_t wwnn, uint32_t fc_id,
+	uint8_t enable_ini, uint8_t enable_tgt);
+extern void ocs_sport_free(ocs_sport_t *sport);
+extern void ocs_sport_force_free(ocs_sport_t *sport);
+
+static inline void
+ocs_sport_lock_init(ocs_sport_t *sport)
+{
+}
+
+static inline void
+ocs_sport_lock_free(ocs_sport_t *sport)
+{
+}
+
+static inline int32_t
+ocs_sport_lock_try(ocs_sport_t *sport)
+{
+	/* Use the device wide lock */
+	return ocs_device_lock_try(sport->ocs);
+}
+
+static inline void
+ocs_sport_lock(ocs_sport_t *sport)
+{
+	/* Use the device wide lock */
+	ocs_device_lock(sport->ocs);
+}
+
+static inline void
+ocs_sport_unlock(ocs_sport_t *sport)
+{
+	/* Use the device wide lock */
+	ocs_device_unlock(sport->ocs);
+}
+
+extern ocs_sport_t *ocs_sport_find(ocs_domain_t *domain, uint32_t d_id);
+extern ocs_sport_t *ocs_sport_find_wwn(ocs_domain_t *domain, uint64_t wwnn, uint64_t wwpn);
+extern int32_t ocs_sport_attach(ocs_sport_t *sport, uint32_t fc_id);
+
+extern void *__ocs_sport_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_sport_wait_shutdown(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_sport_wait_port_free(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_sport_vport_init(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_sport_vport_wait_alloc(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_sport_vport_allocated(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+extern void *__ocs_sport_attached(ocs_sm_ctx_t *ctx, ocs_sm_event_t evt, void *arg);
+
+extern int32_t ocs_vport_start(ocs_domain_t *domain);
+extern int32_t ocs_sport_vport_new(ocs_domain_t *domain, uint64_t wwpn, uint64_t wwnn, uint32_t fc_id, uint8_t ini, uint8_t tgt, void *tgt_data, void *ini_data, uint8_t restore_vport);
+extern int32_t ocs_sport_vport_alloc(ocs_domain_t *domain, ocs_vport_spec_t *vport);
+extern int32_t ocs_sport_vport_del(ocs_t *ocs, ocs_domain_t *domain, uint64_t wwpn, uint64_t wwnn);
+extern void ocs_vport_del_all(ocs_t *ocs);
+extern int8_t ocs_vport_create_spec(ocs_t *ocs, uint64_t wwnn, uint64_t wwpn, uint32_t fc_id, uint32_t enable_ini, uint32_t enable_tgt, void *tgt_data, void *ini_data);
+
+extern int ocs_ddump_sport(ocs_textbuf_t *textbuf, ocs_sport_t *sport);
+
+/* Node group API */
+extern int ocs_sparm_cmp(uint8_t *sparms1, uint8_t *sparms2);
+extern ocs_node_group_dir_t *ocs_node_group_dir_alloc(ocs_sport_t *sport, uint8_t *sparms);
+extern void ocs_node_group_dir_free(ocs_node_group_dir_t *node_group_dir);
+extern ocs_node_group_dir_t *ocs_node_group_dir_find(ocs_sport_t *sport, uint8_t *sparms);
+extern ocs_remote_node_group_t *ocs_remote_node_group_alloc(ocs_node_group_dir_t *node_group_dir);
+extern void ocs_remote_node_group_free(ocs_remote_node_group_t *node_group);
+extern int ocs_node_group_init(ocs_node_t *node);
+extern void ocs_node_group_free(ocs_node_t *node);
+
+
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_stats.h b/sys/dev/ocs_fc/ocs_stats.h
new file mode 100644
index 000000000000..a7f324e099cc
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_stats.h
@@ -0,0 +1,49 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ */
+
+
+#if !defined(__OCS_STATS_H__)
+#define __OCS_STATS_H__
+
+#define OCS_STAT_ENABLE		0
+#if OCS_STAT_ENABLE
+	#define OCS_STAT(x)	x
+#else
+	#define OCS_STAT(x)
+#endif
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_unsol.c b/sys/dev/ocs_fc/ocs_unsol.c
new file mode 100644
index 000000000000..8c2ab2ad880d
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_unsol.c
@@ -0,0 +1,1399 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Code to handle unsolicited received FC frames.
+ */
+
+/*!
+ * @defgroup unsol Unsolicited Frame Handling
+ */
+
+#include "ocs.h"
+#include "ocs_els.h"
+#include "ocs_fabric.h"
+#include "ocs_device.h"
+
+
+#define frame_printf(ocs, hdr, fmt, ...) \
+	do { \
+		char s_id_text[16]; \
+		ocs_node_fcid_display(fc_be24toh((hdr)->s_id), s_id_text, sizeof(s_id_text)); \
+		ocs_log_debug(ocs, "[%06x.%s] %02x/%04x/%04x: " fmt, fc_be24toh((hdr)->d_id), s_id_text, \
+			(hdr)->r_ctl, ocs_be16toh((hdr)->ox_id), ocs_be16toh((hdr)->rx_id), ##__VA_ARGS__); \
+	} while(0)
+
+static int32_t ocs_unsol_process(ocs_t *ocs, ocs_hw_sequence_t *seq);
+static int32_t ocs_dispatch_fcp_cmd(ocs_node_t *node, ocs_hw_sequence_t *seq);
+static int32_t ocs_dispatch_fcp_cmd_auto_xfer_rdy(ocs_node_t *node, ocs_hw_sequence_t *seq);
+static int32_t ocs_dispatch_fcp_data(ocs_node_t *node, ocs_hw_sequence_t *seq);
+static int32_t ocs_domain_dispatch_frame(void *arg, ocs_hw_sequence_t *seq);
+static int32_t ocs_node_dispatch_frame(void *arg, ocs_hw_sequence_t *seq);
+static int32_t ocs_fc_tmf_rejected_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg);
+static ocs_hw_sequence_t *ocs_frame_next(ocs_list_t *pend_list, ocs_lock_t *list_lock);
+static uint8_t ocs_node_frames_held(void *arg);
+static uint8_t ocs_domain_frames_held(void *arg);
+static int32_t ocs_purge_pending(ocs_t *ocs, ocs_list_t *pend_list, ocs_lock_t *list_lock);
+static int32_t ocs_sframe_send_task_set_full_or_busy(ocs_node_t *node, ocs_hw_sequence_t *seq);
+
+#define OCS_MAX_FRAMES_BEFORE_YEILDING 10000
+
+/**
+ * @brief Process the RQ circular buffer and process the incoming frames.
+ *
+ * @param mythread Pointer to thread object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+ocs_unsol_rq_thread(ocs_thread_t *mythread)
+{
+	ocs_xport_rq_thread_info_t *thread_data = mythread->arg;
+	ocs_t *ocs = thread_data->ocs;
+	ocs_hw_sequence_t *seq;
+	uint32_t yield_count = OCS_MAX_FRAMES_BEFORE_YEILDING;
+
+	ocs_log_debug(ocs, "%s running\n", mythread->name);
+	while (!ocs_thread_terminate_requested(mythread)) {
+		seq = ocs_cbuf_get(thread_data->seq_cbuf, 100000);
+		if (seq == NULL) {
+			/* Prevent soft lockups by yielding the CPU */
+			ocs_thread_yield(&thread_data->thread);
+			yield_count = OCS_MAX_FRAMES_BEFORE_YEILDING;
+			continue;
+		}
+		/* Note: Always returns 0 */
+		ocs_unsol_process((ocs_t*)seq->hw->os, seq);
+
+		/* We have to prevent CPU soft lockups, so just yield the CPU after x frames. */
+		if (--yield_count == 0) {
+			ocs_thread_yield(&thread_data->thread);
+			yield_count = OCS_MAX_FRAMES_BEFORE_YEILDING;
+		}
+	}
+	ocs_log_debug(ocs, "%s exiting\n", mythread->name);
+	thread_data->thread_started = FALSE;
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Callback function when aborting a port owned XRI
+ * exchanges.
+ *
+ * @return Returns 0.
+ */
+static int32_t
+ocs_unsol_abort_cb (ocs_hw_io_t *hio, ocs_remote_node_t *rnode, uint32_t len, int32_t status, uint32_t ext, void *arg)
+{
+	ocs_t *ocs = arg;
+	ocs_assert(hio, -1);
+	ocs_assert(arg, -1);
+	ocs_log_debug(ocs, "xri=0x%x tag=0x%x\n", hio->indicator, hio->reqtag);
+	ocs_hw_io_free(&ocs->hw, hio);
+	return 0;
+}
+
+
+/**
+ * @ingroup unsol
+ * @brief Abort either a RQ Pair auto XFER RDY XRI.
+ * @return Returns None.
+ */
+static void
+ocs_port_owned_abort(ocs_t *ocs, ocs_hw_io_t *hio)
+{
+	ocs_hw_rtn_e hw_rc;
+	hw_rc = ocs_hw_io_abort(&ocs->hw, hio, FALSE,
+				  ocs_unsol_abort_cb, ocs);
+	if((hw_rc == OCS_HW_RTN_IO_ABORT_IN_PROGRESS) ||
+	   (hw_rc == OCS_HW_RTN_IO_PORT_OWNED_ALREADY_ABORTED)) {
+		ocs_log_debug(ocs, "already aborted XRI 0x%x\n", hio->indicator);
+	} else if(hw_rc != OCS_HW_RTN_SUCCESS) {
+		ocs_log_debug(ocs, "Error aborting XRI 0x%x status %d\n",
+			      hio->indicator, hw_rc);
+	}
+}
+
+/**
+ * @ingroup unsol
+ * @brief Handle unsolicited FC frames.
+ *
+ * <h3 class="desc">Description</h3>
+ * This function is called from the HW with unsolicited FC frames (FCP, ELS, BLS, etc.).
+ *
+ * @param arg Application-specified callback data.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+int32_t
+ocs_unsolicited_cb(void *arg, ocs_hw_sequence_t *seq)
+{
+	ocs_t *ocs = arg;
+	ocs_xport_t *xport = ocs->xport;
+	int32_t rc;
+
+	CPUTRACE("");
+
+	if (ocs->rq_threads == 0) {
+		rc = ocs_unsol_process(ocs, seq);
+	} else {
+		/* use the ox_id to dispatch this IO to a thread */
+		fc_header_t *hdr = seq->header->dma.virt;
+		uint32_t ox_id =  ocs_be16toh(hdr->ox_id);
+		uint32_t thr_index = ox_id % ocs->rq_threads;
+
+		rc = ocs_cbuf_put(xport->rq_thread_info[thr_index].seq_cbuf, seq);
+	}
+
+	if (rc) {
+		ocs_hw_sequence_free(&ocs->hw, seq);
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Handle unsolicited FC frames.
+ *
+ * <h3 class="desc">Description</h3>
+ * This function is called either from ocs_unsolicited_cb() or ocs_unsol_rq_thread().
+ *
+ * @param ocs Pointer to the ocs structure.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+static int32_t
+ocs_unsol_process(ocs_t *ocs, ocs_hw_sequence_t *seq)
+{
+	ocs_xport_fcfi_t *xport_fcfi = NULL;
+	ocs_domain_t *domain;
+	uint8_t seq_fcfi = seq->fcfi;
+
+	/* HW_WORKAROUND_OVERRIDE_FCFI_IN_SRB */
+	if (ocs->hw.workaround.override_fcfi) {
+		if (ocs->hw.first_domain_idx > -1) {
+			seq_fcfi = ocs->hw.first_domain_idx;
+		}
+	}
+
+	/* Range check seq->fcfi */
+	if (seq_fcfi < ARRAY_SIZE(ocs->xport->fcfi)) {
+		xport_fcfi = &ocs->xport->fcfi[seq_fcfi];
+	}
+
+	/* If the transport FCFI entry is NULL, then drop the frame */
+	if (xport_fcfi == NULL) {
+		ocs_log_test(ocs, "FCFI %d is not valid, dropping frame\n", seq->fcfi);
+		if (seq->hio != NULL) {
+			ocs_port_owned_abort(ocs, seq->hio);
+		}
+
+		ocs_hw_sequence_free(&ocs->hw, seq);
+		return 0;
+	}
+	domain = ocs_hw_domain_get(&ocs->hw, seq_fcfi);
+
+	/*
+	 * If we are holding frames or the domain is not yet registered or
+	 * there's already frames on the pending list,
+	 * then add the new frame to pending list
+	 */
+	if (domain == NULL ||
+	    xport_fcfi->hold_frames ||
+	    !ocs_list_empty(&xport_fcfi->pend_frames)) {
+		ocs_lock(&xport_fcfi->pend_frames_lock);
+			ocs_list_add_tail(&xport_fcfi->pend_frames, seq);
+		ocs_unlock(&xport_fcfi->pend_frames_lock);
+
+		if (domain != NULL) {
+			/* immediately process pending frames */
+			ocs_domain_process_pending(domain);
+		}
+	} else {
+		/*
+		 * We are not holding frames and pending list is empty, just process frame.
+		 * A non-zero return means the frame was not handled - so cleanup
+		 */
+		if (ocs_domain_dispatch_frame(domain, seq)) {
+			if (seq->hio != NULL) {
+				ocs_port_owned_abort(ocs, seq->hio);
+			}
+			ocs_hw_sequence_free(&ocs->hw, seq);
+		}
+	}
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Process pending frames queued to the given node.
+ *
+ * <h3 class="desc">Description</h3>
+ * Frames that are queued for the \c node are dispatched and returned
+ * to the RQ.
+ *
+ * @param node Node of the queued frames that are to be dispatched.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int32_t
+ocs_process_node_pending(ocs_node_t *node)
+{
+	ocs_t *ocs = node->ocs;
+	ocs_hw_sequence_t *seq = NULL;
+	uint32_t pend_frames_processed = 0;
+
+	for (;;) {
+		/* need to check for hold frames condition after each frame processed
+		 * because any given frame could cause a transition to a state that
+		 * holds frames
+		 */
+		if (ocs_node_frames_held(node)) {
+			break;
+		}
+
+		/* Get next frame/sequence */
+		ocs_lock(&node->pend_frames_lock);
+			seq = ocs_list_remove_head(&node->pend_frames);
+			if (seq == NULL) {
+				pend_frames_processed = node->pend_frames_processed;
+				node->pend_frames_processed = 0;
+				ocs_unlock(&node->pend_frames_lock);
+				break;
+			}
+			node->pend_frames_processed++;
+		ocs_unlock(&node->pend_frames_lock);
+
+		/* now dispatch frame(s) to dispatch function */
+		if (ocs_node_dispatch_frame(node, seq)) {
+			if (seq->hio != NULL) {
+				ocs_port_owned_abort(ocs, seq->hio);
+			}
+			ocs_hw_sequence_free(&ocs->hw, seq);
+		}
+	}
+
+	if (pend_frames_processed != 0) {
+		ocs_log_debug(ocs, "%u node frames held and processed\n", pend_frames_processed);
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Process pending frames queued to the given domain.
+ *
+ * <h3 class="desc">Description</h3>
+ * Frames that are queued for the \c domain are dispatched and
+ * returned to the RQ.
+ *
+ * @param domain Domain of the queued frames that are to be
+ *		 dispatched.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int32_t
+ocs_domain_process_pending(ocs_domain_t *domain)
+{
+	ocs_t *ocs = domain->ocs;
+	ocs_xport_fcfi_t *xport_fcfi;
+	ocs_hw_sequence_t *seq = NULL;
+	uint32_t pend_frames_processed = 0;
+
+	ocs_assert(domain->fcf_indicator < SLI4_MAX_FCFI, -1);
+	xport_fcfi = &ocs->xport->fcfi[domain->fcf_indicator];
+
+	for (;;) {
+		/* need to check for hold frames condition after each frame processed
+		 * because any given frame could cause a transition to a state that
+		 * holds frames
+		 */
+		if (ocs_domain_frames_held(domain)) {
+			break;
+		}
+
+		/* Get next frame/sequence */
+		ocs_lock(&xport_fcfi->pend_frames_lock);
+			seq = ocs_list_remove_head(&xport_fcfi->pend_frames);
+			if (seq == NULL) {
+				pend_frames_processed = xport_fcfi->pend_frames_processed;
+				xport_fcfi->pend_frames_processed = 0;
+				ocs_unlock(&xport_fcfi->pend_frames_lock);
+				break;
+			}
+			xport_fcfi->pend_frames_processed++;
+		ocs_unlock(&xport_fcfi->pend_frames_lock);
+
+		/* now dispatch frame(s) to dispatch function */
+		if (ocs_domain_dispatch_frame(domain, seq)) {
+			if (seq->hio != NULL) {
+				ocs_port_owned_abort(ocs, seq->hio);
+			}
+			ocs_hw_sequence_free(&ocs->hw, seq);
+		}
+	}
+	if (pend_frames_processed != 0) {
+		ocs_log_debug(ocs, "%u domain frames held and processed\n", pend_frames_processed);
+	}
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Purge given pending list
+ *
+ * <h3 class="desc">Description</h3>
+ * Frames that are queued on the given pending list are
+ * discarded and returned to the RQ.
+ *
+ * @param ocs Pointer to ocs object.
+ * @param pend_list Pending list to be purged.
+ * @param list_lock Lock that protects pending list.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+static int32_t
+ocs_purge_pending(ocs_t *ocs, ocs_list_t *pend_list, ocs_lock_t *list_lock)
+{
+	ocs_hw_sequence_t *frame;
+
+	for (;;) {
+		frame = ocs_frame_next(pend_list, list_lock);
+		if (frame == NULL) {
+			break;
+		}
+
+		frame_printf(ocs, (fc_header_t*) frame->header->dma.virt, "Discarding held frame\n");
+		if (frame->hio != NULL) {
+			ocs_port_owned_abort(ocs, frame->hio);
+		}
+		ocs_hw_sequence_free(&ocs->hw, frame);
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Purge node's pending (queued) frames.
+ *
+ * <h3 class="desc">Description</h3>
+ * Frames that are queued for the \c node are discarded and returned
+ * to the RQ.
+ *
+ * @param node Node of the queued frames that are to be discarded.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+int32_t
+ocs_node_purge_pending(ocs_node_t *node)
+{
+	return ocs_purge_pending(node->ocs, &node->pend_frames, &node->pend_frames_lock);
+}
+
+/**
+ * @ingroup unsol
+ * @brief Purge xport's pending (queued) frames.
+ *
+ * <h3 class="desc">Description</h3>
+ * Frames that are queued for the \c xport are discarded and
+ * returned to the RQ.
+ *
+ * @param domain Pointer to domain object.
+ *
+ * @return Returns 0 on success; or a negative error value on failure.
+ */
+
+int32_t
+ocs_domain_purge_pending(ocs_domain_t *domain)
+{
+	ocs_t *ocs = domain->ocs;
+	ocs_xport_fcfi_t *xport_fcfi;
+
+	ocs_assert(domain->fcf_indicator < SLI4_MAX_FCFI, -1);
+	xport_fcfi = &ocs->xport->fcfi[domain->fcf_indicator];
+	return ocs_purge_pending(domain->ocs,
+				 &xport_fcfi->pend_frames,
+				 &xport_fcfi->pend_frames_lock);
+}
+
+/**
+ * @ingroup unsol
+ * @brief Check if node's pending frames are held.
+ *
+ * @param arg Node for which the pending frame hold condition is
+ * checked.
+ *
+ * @return Returns 1 if node is holding pending frames, or 0
+ * if not.
+ */
+
+static uint8_t
+ocs_node_frames_held(void *arg)
+{
+	ocs_node_t *node = (ocs_node_t *)arg;
+	return node->hold_frames;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Check if domain's pending frames are held.
+ *
+ * @param arg Domain for which the pending frame hold condition is
+ * checked.
+ *
+ * @return Returns 1 if domain is holding pending frames, or 0
+ * if not.
+ */
+
+static uint8_t
+ocs_domain_frames_held(void *arg)
+{
+	ocs_domain_t *domain = (ocs_domain_t *)arg;
+	ocs_t *ocs = domain->ocs;
+	ocs_xport_fcfi_t *xport_fcfi;
+
+	ocs_assert(domain != NULL, 1);
+	ocs_assert(domain->fcf_indicator < SLI4_MAX_FCFI, 1);
+	xport_fcfi = &ocs->xport->fcfi[domain->fcf_indicator];
+	return xport_fcfi->hold_frames;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Globally (at xport level) hold unsolicited frames.
+ *
+ * <h3 class="desc">Description</h3>
+ * This function places a hold on processing unsolicited FC
+ * frames queued to the xport pending list.
+ *
+ * @param domain Pointer to domain object.
+ *
+ * @return Returns None.
+ */
+
+void
+ocs_domain_hold_frames(ocs_domain_t *domain)
+{
+	ocs_t *ocs = domain->ocs;
+	ocs_xport_fcfi_t *xport_fcfi;
+
+	ocs_assert(domain->fcf_indicator < SLI4_MAX_FCFI);
+	xport_fcfi = &ocs->xport->fcfi[domain->fcf_indicator];
+	if (!xport_fcfi->hold_frames) {
+		ocs_log_debug(domain->ocs, "hold frames set for FCFI %d\n",
+			      domain->fcf_indicator);
+		xport_fcfi->hold_frames = 1;
+	}
+}
+
+/**
+ * @ingroup unsol
+ * @brief Clear hold on unsolicited frames.
+ *
+ * <h3 class="desc">Description</h3>
+ * This function clears the hold on processing unsolicited FC
+ * frames queued to the domain pending list.
+ *
+ * @param domain Pointer to domain object.
+ *
+ * @return Returns None.
+ */
+
+void
+ocs_domain_accept_frames(ocs_domain_t *domain)
+{
+	ocs_t *ocs = domain->ocs;
+	ocs_xport_fcfi_t *xport_fcfi;
+
+	ocs_assert(domain->fcf_indicator < SLI4_MAX_FCFI);
+	xport_fcfi = &ocs->xport->fcfi[domain->fcf_indicator];
+	if (xport_fcfi->hold_frames == 1) {
+		ocs_log_debug(domain->ocs, "hold frames cleared for FCFI %d\n",
+			      domain->fcf_indicator);
+	}
+	xport_fcfi->hold_frames = 0;
+	ocs_domain_process_pending(domain);
+}
+
+
+/**
+ * @ingroup unsol
+ * @brief Dispatch unsolicited FC frame.
+ *
+ * <h3 class="desc">Description</h3>
+ * This function processes an unsolicited FC frame queued at the
+ * domain level.
+ *
+ * @param arg Pointer to ocs object.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled.
+ */
+
+static __inline int32_t
+ocs_domain_dispatch_frame(void *arg, ocs_hw_sequence_t *seq)
+{
+	ocs_domain_t *domain = (ocs_domain_t *)arg;
+	ocs_t *ocs = domain->ocs;
+	fc_header_t *hdr;
+	uint32_t s_id;
+	uint32_t d_id;
+	ocs_node_t *node = NULL;
+	ocs_sport_t *sport = NULL;
+
+	ocs_assert(seq->header, -1);
+	ocs_assert(seq->header->dma.virt, -1);
+	ocs_assert(seq->payload->dma.virt, -1);
+
+	hdr = seq->header->dma.virt;
+
+	/* extract the s_id and d_id */
+	s_id = fc_be24toh(hdr->s_id);
+	d_id = fc_be24toh(hdr->d_id);
+
+	sport = domain->sport;
+	if (sport == NULL) {
+		frame_printf(ocs, hdr, "phy sport for FC ID 0x%06x is NULL, dropping frame\n", d_id);
+		return -1;
+	}
+
+	if (sport->fc_id != d_id) {
+		/* Not a physical port IO lookup sport associated with the npiv port */
+		sport = ocs_sport_find(domain, d_id); /* Look up without lock */
+		if (sport == NULL) {
+			if (hdr->type == FC_TYPE_FCP) {
+				/* Drop frame */
+				ocs_log_warn(ocs, "unsolicited FCP frame with invalid d_id x%x, dropping\n",
+					     d_id);
+				return -1;
+			} else {
+				/* p2p will use this case */
+				sport = domain->sport;
+			}
+		}
+	}
+
+	/* Lookup the node given the remote s_id */
+	node = ocs_node_find(sport, s_id);
+
+	/* If not found, then create a new node */
+	if (node == NULL) {
+		/* If this is solicited data or control based on R_CTL and there is no node context,
+		 * then we can drop the frame
+		 */
+		if ((hdr->r_ctl == FC_RCTL_FC4_DATA) && (
+		    (hdr->info == FC_RCTL_INFO_SOL_DATA) || (hdr->info == FC_RCTL_INFO_SOL_CTRL))) {
+			ocs_log_debug(ocs, "solicited data/ctrl frame without node, dropping\n");
+			return -1;
+		}
+		node = ocs_node_alloc(sport, s_id, FALSE, FALSE);
+		if (node == NULL) {
+			ocs_log_err(ocs, "ocs_node_alloc() failed\n");
+			return -1;
+		}
+		/* don't send PLOGI on ocs_d_init entry */
+		ocs_node_init_device(node, FALSE);
+	}
+
+	if (node->hold_frames || !ocs_list_empty((&node->pend_frames))) {
+		/* TODO: info log level
+		frame_printf(ocs, hdr, "Holding frame\n");
+		*/
+		/* add frame to node's pending list */
+		ocs_lock(&node->pend_frames_lock);
+			ocs_list_add_tail(&node->pend_frames, seq);
+		ocs_unlock(&node->pend_frames_lock);
+
+		return 0;
+	}
+
+	/* now dispatch frame to the node frame handler */
+	return ocs_node_dispatch_frame(node, seq);
+}
+
+/**
+ * @ingroup unsol
+ * @brief Dispatch a frame.
+ *
+ * <h3 class="desc">Description</h3>
+ * A frame is dispatched from the \c node to the handler.
+ *
+ * @param arg Node that originated the frame.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled.
+ */
+static int32_t
+ocs_node_dispatch_frame(void *arg, ocs_hw_sequence_t *seq)
+{
+
+	fc_header_t *hdr = seq->header->dma.virt;
+	uint32_t port_id;
+	ocs_node_t *node = (ocs_node_t *)arg;
+	int32_t rc = -1;
+	int32_t sit_set = 0;
+
+	port_id = fc_be24toh(hdr->s_id);
+	ocs_assert(port_id == node->rnode.fc_id, -1);
+
+	if (fc_be24toh(hdr->f_ctl) & FC_FCTL_END_SEQUENCE) {
+		/*if SIT is set */
+		if (fc_be24toh(hdr->f_ctl) & FC_FCTL_SEQUENCE_INITIATIVE) {
+			sit_set = 1;
+		}
+		switch (hdr->r_ctl) {
+		case FC_RCTL_ELS:
+			if (sit_set) {
+				rc = ocs_node_recv_els_frame(node, seq);
+			}
+			break;
+
+		case FC_RCTL_BLS:
+			if (sit_set) {
+				rc = ocs_node_recv_abts_frame(node, seq);
+			}else {
+				rc = ocs_node_recv_bls_no_sit(node, seq);
+			}
+			break;
+
+		case FC_RCTL_FC4_DATA:
+			switch(hdr->type) {
+			case FC_TYPE_FCP:
+				if (hdr->info == FC_RCTL_INFO_UNSOL_CMD) {
+					if (node->fcp_enabled) {
+						if (sit_set) {
+							rc = ocs_dispatch_fcp_cmd(node, seq);
+						}else {
+							/* send the auto xfer ready command */
+							rc = ocs_dispatch_fcp_cmd_auto_xfer_rdy(node, seq);
+						}
+					} else {
+						rc = ocs_node_recv_fcp_cmd(node, seq);
+					}
+				} else if (hdr->info == FC_RCTL_INFO_SOL_DATA) {
+					if (sit_set) {
+						rc = ocs_dispatch_fcp_data(node, seq);
+					}
+				}
+				break;
+			case FC_TYPE_GS:
+				if (sit_set) {
+					rc = ocs_node_recv_ct_frame(node, seq);
+				}
+				break;
+			default:
+				break;
+			}
+			break;
+		}
+	} else {
+		node_printf(node, "Dropping frame hdr = %08x %08x %08x %08x %08x %08x\n",
+			    ocs_htobe32(((uint32_t *)hdr)[0]),
+			    ocs_htobe32(((uint32_t *)hdr)[1]),
+			    ocs_htobe32(((uint32_t *)hdr)[2]),
+			    ocs_htobe32(((uint32_t *)hdr)[3]),
+			    ocs_htobe32(((uint32_t *)hdr)[4]),
+			    ocs_htobe32(((uint32_t *)hdr)[5]));
+	}
+	return rc;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Dispatch unsolicited FCP frames (RQ Pair).
+ *
+ * <h3 class="desc">Description</h3>
+ * Dispatch unsolicited FCP frames (called from the device node state machine).
+ *
+ * @param io Pointer to the IO context.
+ * @param task_management_flags Task management flags from the FCP_CMND frame.
+ * @param node Node that originated the frame.
+ * @param lun 32-bit LUN from FCP_CMND frame.
+ *
+ * @return Returns None.
+ */
+
+static void
+ocs_dispatch_unsolicited_tmf(ocs_io_t *io, uint8_t task_management_flags, ocs_node_t *node, uint64_t lun)
+{
+	uint32_t i;
+	struct {
+		uint32_t mask;
+		ocs_scsi_tmf_cmd_e cmd;
+	} tmflist[] = {
+		{FCP_QUERY_TASK_SET,		OCS_SCSI_TMF_QUERY_TASK_SET},
+		{FCP_ABORT_TASK_SET,		OCS_SCSI_TMF_ABORT_TASK_SET},
+		{FCP_CLEAR_TASK_SET,		OCS_SCSI_TMF_CLEAR_TASK_SET},
+		{FCP_QUERY_ASYNCHRONOUS_EVENT,	OCS_SCSI_TMF_QUERY_ASYNCHRONOUS_EVENT},
+		{FCP_LOGICAL_UNIT_RESET,	OCS_SCSI_TMF_LOGICAL_UNIT_RESET},
+		{FCP_TARGET_RESET,		OCS_SCSI_TMF_TARGET_RESET},
+		{FCP_CLEAR_ACA,			OCS_SCSI_TMF_CLEAR_ACA}};
+
+	io->exp_xfer_len = 0; /* BUG 32235 */
+
+	for (i = 0; i < ARRAY_SIZE(tmflist); i ++) {
+		if (tmflist[i].mask & task_management_flags) {
+			io->tmf_cmd = tmflist[i].cmd;
+			ocs_scsi_recv_tmf(io, lun, tmflist[i].cmd, NULL, 0);
+			break;
+		}
+	}
+	if (i == ARRAY_SIZE(tmflist)) {
+		/* Not handled */
+		node_printf(node, "TMF x%x rejected\n", task_management_flags);
+		ocs_scsi_send_tmf_resp(io, OCS_SCSI_TMF_FUNCTION_REJECTED, NULL, ocs_fc_tmf_rejected_cb, NULL);
+	}
+}
+
+static int32_t
+ocs_validate_fcp_cmd(ocs_t *ocs, ocs_hw_sequence_t *seq)
+{
+	size_t		exp_payload_len = 0;
+	fcp_cmnd_iu_t *cmnd = seq->payload->dma.virt;
+	exp_payload_len = sizeof(fcp_cmnd_iu_t) - 16 + cmnd->additional_fcp_cdb_length;
+
+	/*
+	 * If we received less than FCP_CMND_IU bytes, assume that the frame is
+	 * corrupted in some way and drop it. This was seen when jamming the FCTL
+	 * fill bytes field.
+	 */
+	if (seq->payload->dma.len < exp_payload_len) {
+		fc_header_t	*fchdr = seq->header->dma.virt;
+		ocs_log_debug(ocs, "dropping ox_id %04x with payload length (%zd) less than expected (%zd)\n",
+			      ocs_be16toh(fchdr->ox_id), seq->payload->dma.len,
+			      exp_payload_len);
+		return -1;
+	}
+	return 0;
+
+}
+
+static void
+ocs_populate_io_fcp_cmd(ocs_io_t *io, fcp_cmnd_iu_t *cmnd, fc_header_t *fchdr, uint8_t sit)
+{
+	uint32_t	*fcp_dl;
+	io->init_task_tag = ocs_be16toh(fchdr->ox_id);
+	/* note, tgt_task_tag, hw_tag  set when HW io is allocated */
+	fcp_dl = (uint32_t*)(&(cmnd->fcp_cdb_and_dl));
+	fcp_dl += cmnd->additional_fcp_cdb_length;
+	io->exp_xfer_len = ocs_be32toh(*fcp_dl);
+	io->transferred = 0;
+
+	/* The upper 7 bits of CS_CTL is the frame priority thru the SAN.
+	 * Our assertion here is, the priority given to a frame containing
+	 * the FCP cmd should be the priority given to ALL frames contained
+	 * in that IO. Thus we need to save the incoming CS_CTL here.
+	 */
+	if (fc_be24toh(fchdr->f_ctl) & FC_FCTL_PRIORITY_ENABLE) {
+		io->cs_ctl = fchdr->cs_ctl;
+	} else {
+		io->cs_ctl = 0;
+	}
+	io->seq_init = sit;
+}
+
+static uint32_t
+ocs_get_flags_fcp_cmd(fcp_cmnd_iu_t *cmnd)
+{
+	uint32_t flags = 0;
+	switch (cmnd->task_attribute) {
+	case FCP_TASK_ATTR_SIMPLE:
+		flags |= OCS_SCSI_CMD_SIMPLE;
+		break;
+	case FCP_TASK_ATTR_HEAD_OF_QUEUE:
+		flags |= OCS_SCSI_CMD_HEAD_OF_QUEUE;
+		break;
+	case FCP_TASK_ATTR_ORDERED:
+		flags |= OCS_SCSI_CMD_ORDERED;
+		break;
+	case FCP_TASK_ATTR_ACA:
+		flags |= OCS_SCSI_CMD_ACA;
+		break;
+	case FCP_TASK_ATTR_UNTAGGED:
+		flags |= OCS_SCSI_CMD_UNTAGGED;
+		break;
+	}
+	if (cmnd->wrdata)
+		flags |= OCS_SCSI_CMD_DIR_IN;
+	if (cmnd->rddata)
+		flags |= OCS_SCSI_CMD_DIR_OUT;
+
+	return flags;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Dispatch unsolicited FCP_CMND frame.
+ *
+ * <h3 class="desc">Description</h3>
+ * Dispatch unsolicited FCP_CMND frame. RQ Pair mode - always
+ * used for RQ Pair mode since first burst is not supported.
+ *
+ * @param node Node that originated the frame.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled and RX buffers need
+ * to be returned.
+ */
+static int32_t
+ocs_dispatch_fcp_cmd(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	ocs_t *ocs = node->ocs;
+	fc_header_t	*fchdr = seq->header->dma.virt;
+	fcp_cmnd_iu_t	*cmnd = NULL;
+	ocs_io_t	*io = NULL;
+	fc_vm_header_t 	*vhdr;
+	uint8_t 	df_ctl;
+	uint64_t	lun = UINT64_MAX;
+	int32_t		rc = 0;
+
+	ocs_assert(seq->payload, -1);
+	cmnd = seq->payload->dma.virt;
+
+	/* perform FCP_CMND validation check(s) */
+	if (ocs_validate_fcp_cmd(ocs, seq)) {
+		return -1;
+	}
+
+	lun = CAM_EXTLUN_BYTE_SWIZZLE(be64dec(cmnd->fcp_lun));
+	if (lun == UINT64_MAX) {
+		return -1;
+	}
+
+	io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_RESPONDER);
+	if (io == NULL) {
+		uint32_t send_frame_capable;
+
+		/* If we have SEND_FRAME capability, then use it to send task set full or busy */
+		rc = ocs_hw_get(&ocs->hw, OCS_HW_SEND_FRAME_CAPABLE, &send_frame_capable);
+		if ((rc == 0) && send_frame_capable) {
+			rc = ocs_sframe_send_task_set_full_or_busy(node, seq);
+			if (rc) {
+				ocs_log_test(ocs, "ocs_sframe_send_task_set_full_or_busy failed: %d\n", rc);
+			}
+			return rc;
+		}
+
+		ocs_log_err(ocs, "IO allocation failed ox_id %04x\n", ocs_be16toh(fchdr->ox_id));
+		return -1;
+	}
+	io->hw_priv = seq->hw_priv;
+
+	/* Check if the CMD has vmheader. */
+	io->app_id = 0;
+	df_ctl = fchdr->df_ctl;
+	if (df_ctl & FC_DFCTL_DEVICE_HDR_16_MASK) {
+		uint32_t vmhdr_offset = 0;
+		/* Presence of VMID. Get the vm header offset. */
+		if (df_ctl & FC_DFCTL_ESP_HDR_MASK) {
+			vmhdr_offset += FC_DFCTL_ESP_HDR_SIZE;
+			ocs_log_err(ocs, "ESP Header present. Fix ESP Size.\n");
+		}
+
+		if (df_ctl & FC_DFCTL_NETWORK_HDR_MASK) {
+			vmhdr_offset += FC_DFCTL_NETWORK_HDR_SIZE;
+		}
+		vhdr = (fc_vm_header_t *) ((char *)fchdr + sizeof(fc_header_t) + vmhdr_offset);
+		io->app_id = ocs_be32toh(vhdr->src_vmid);
+	}
+
+	/* RQ pair, if we got here, SIT=1 */
+	ocs_populate_io_fcp_cmd(io, cmnd, fchdr, TRUE);
+
+	if (cmnd->task_management_flags) {
+		ocs_dispatch_unsolicited_tmf(io, cmnd->task_management_flags, node, lun);
+	} else {
+		uint32_t flags = ocs_get_flags_fcp_cmd(cmnd);
+
+		/* can return failure for things like task set full and UAs,
+		 * no need to treat as a dropped frame if rc != 0
+		 */
+		ocs_scsi_recv_cmd(io, lun, cmnd->fcp_cdb,
+				  sizeof(cmnd->fcp_cdb) +
+				  (cmnd->additional_fcp_cdb_length * sizeof(uint32_t)),
+				  flags);
+	}
+
+	/* successfully processed, now return RX buffer to the chip */
+	ocs_hw_sequence_free(&ocs->hw, seq);
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Dispatch unsolicited FCP_CMND frame (auto xfer rdy).
+ *
+ * <h3 class="desc">Description</h3>
+ * Dispatch unsolicited FCP_CMND frame that is assisted with auto xfer ready.
+ *
+ * @param node Node that originated the frame.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled and RX buffers need
+ * to be returned.
+ */
+static int32_t
+ocs_dispatch_fcp_cmd_auto_xfer_rdy(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	ocs_t *ocs = node->ocs;
+	fc_header_t	*fchdr = seq->header->dma.virt;
+	fcp_cmnd_iu_t	*cmnd = NULL;
+	ocs_io_t	*io = NULL;
+	uint64_t	lun = UINT64_MAX;
+	int32_t		rc = 0;
+
+	ocs_assert(seq->payload, -1);
+	cmnd = seq->payload->dma.virt;
+
+	/* perform FCP_CMND validation check(s) */
+	if (ocs_validate_fcp_cmd(ocs, seq)) {
+		return -1;
+	}
+
+	/* make sure first burst or auto xfer_rdy is enabled */
+	if (!seq->auto_xrdy) {
+		node_printf(node, "IO is not Auto Xfr Rdy assisted, dropping FCP_CMND\n");
+		return -1;
+	}
+
+	lun = CAM_EXTLUN_BYTE_SWIZZLE(be64dec(cmnd->fcp_lun));
+
+	/* TODO should there be a check here for an error? Why do any of the
+	 * below if the LUN decode failed? */
+	io = ocs_scsi_io_alloc(node, OCS_SCSI_IO_ROLE_RESPONDER);
+	if (io == NULL) {
+		uint32_t send_frame_capable;
+
+		/* If we have SEND_FRAME capability, then use it to send task set full or busy */
+		rc = ocs_hw_get(&ocs->hw, OCS_HW_SEND_FRAME_CAPABLE, &send_frame_capable);
+		if ((rc == 0) && send_frame_capable) {
+			rc = ocs_sframe_send_task_set_full_or_busy(node, seq);
+			if (rc) {
+				ocs_log_test(ocs, "ocs_sframe_send_task_set_full_or_busy failed: %d\n", rc);
+			}
+			return rc;
+		}
+
+		ocs_log_err(ocs, "IO allocation failed ox_id %04x\n", ocs_be16toh(fchdr->ox_id));
+		return -1;
+	}
+	io->hw_priv = seq->hw_priv;
+
+	/* RQ pair, if we got here, SIT=0 */
+	ocs_populate_io_fcp_cmd(io, cmnd, fchdr, FALSE);
+
+	if (cmnd->task_management_flags) {
+		/* first burst command better not be a TMF */
+		ocs_log_err(ocs, "TMF flags set 0x%x\n", cmnd->task_management_flags);
+		ocs_scsi_io_free(io);
+		return -1;
+	} else {
+		uint32_t flags = ocs_get_flags_fcp_cmd(cmnd);
+
+		/* activate HW IO */
+		ocs_hw_io_activate_port_owned(&ocs->hw, seq->hio);
+		io->hio = seq->hio;
+		seq->hio->ul_io = io;
+		io->tgt_task_tag = seq->hio->indicator;
+
+		/* Note: Data buffers are received in another call */
+		ocs_scsi_recv_cmd_first_burst(io, lun, cmnd->fcp_cdb,
+					      sizeof(cmnd->fcp_cdb) +
+					      (cmnd->additional_fcp_cdb_length * sizeof(uint32_t)),
+					      flags, NULL, 0);
+	}
+
+	/* FCP_CMND processed, return RX buffer to the chip */
+	ocs_hw_sequence_free(&ocs->hw, seq);
+	return 0;
+}
+
+/**
+ * @ingroup unsol
+ * @brief Dispatch FCP data frames for auto xfer ready.
+ *
+ * <h3 class="desc">Description</h3>
+ * Dispatch unsolicited FCP data frames (auto xfer ready)
+ * containing sequence initiative transferred (SIT=1).
+ *
+ * @param node Node that originated the frame.
+ * @param seq Header/payload sequence buffers.
+ *
+ * @return Returns 0 if frame processed and RX buffers cleaned
+ * up appropriately, -1 if frame not handled.
+ */
+
+static int32_t
+ocs_dispatch_fcp_data(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	ocs_t *ocs = node->ocs;
+	ocs_hw_t *hw = &ocs->hw;
+	ocs_hw_io_t *hio = seq->hio;
+	ocs_io_t	*io;
+	ocs_dma_t fburst[1];
+
+	ocs_assert(seq->payload, -1);
+	ocs_assert(hio, -1);
+
+	io = hio->ul_io;
+	if (io == NULL) {
+		ocs_log_err(ocs, "data received for NULL io, xri=0x%x\n",
+			    hio->indicator);
+		return -1;
+	}
+
+	/*
+	 * We only support data completions for auto xfer ready. Make sure
+	 * this is a port owned XRI.
+	 */
+	if (!ocs_hw_is_io_port_owned(hw, seq->hio)) {
+		ocs_log_err(ocs, "data received for host owned XRI, xri=0x%x\n",
+			    hio->indicator);
+		return -1;
+	}
+
+	/* For error statuses, pass the error to the target back end */
+	if (seq->status != OCS_HW_UNSOL_SUCCESS) {
+		ocs_log_err(ocs, "data with status 0x%x received, xri=0x%x\n",
+			    seq->status, hio->indicator);
+
+		/*
+		 * In this case, there is an existing, in-use HW IO that
+		 * first may need to be aborted. Then, the backend will be
+		 * notified of the error while waiting for the data.
+		 */
+		ocs_port_owned_abort(ocs, seq->hio);
+
+		/*
+		 * HW IO has already been allocated and is waiting for data.
+		 * Need to tell backend that an error has occurred.
+		 */
+		ocs_scsi_recv_cmd_first_burst(io, 0, NULL, 0, OCS_SCSI_FIRST_BURST_ERR, NULL, 0);
+		return -1;
+	}
+
+	/* sequence initiative has been transferred */
+	io->seq_init = 1;
+
+	/* convert the array of pointers to the correct type, to send to backend */
+	fburst[0] = seq->payload->dma;
+
+	/* the amount of first burst data was saved as "acculated sequence length" */
+	io->transferred = seq->payload->dma.len;
+
+	if (ocs_scsi_recv_cmd_first_burst(io, 0, NULL, 0, 0,
+					  fburst, io->transferred)) {
+		ocs_log_err(ocs, "error passing first burst, xri=0x%x, oxid=0x%x\n",
+			    hio->indicator, io->init_task_tag);
+	}
+
+	/* Free the header and all the accumulated payload buffers */
+	ocs_hw_sequence_free(&ocs->hw, seq);
+	return 0;
+}
+
+
+/**
+ * @ingroup unsol
+ * @brief Handle the callback for the TMF FUNCTION_REJECTED response.
+ *
+ * <h3 class="desc">Description</h3>
+ * Handle the callback of a send TMF FUNCTION_REJECTED response request.
+ *
+ * @param io Pointer to the IO context.
+ * @param scsi_status Status of the response.
+ * @param flags Callback flags.
+ * @param arg Callback argument.
+ *
+ * @return Returns 0 on success, or a negative error value on failure.
+ */
+
+static int32_t
+ocs_fc_tmf_rejected_cb(ocs_io_t *io, ocs_scsi_io_status_e scsi_status, uint32_t flags, void *arg)
+{
+	ocs_scsi_io_free(io);
+	return 0;
+}
+
+/**
+ * @brief Return next FC frame on node->pend_frames list
+ *
+ * The next FC frame on the node->pend_frames list is returned, or NULL
+ * if the list is empty.
+ *
+ * @param pend_list Pending list to be purged.
+ * @param list_lock Lock that protects pending list.
+ *
+ * @return Returns pointer to the next FC frame, or NULL if the pending frame list
+ * is empty.
+ */
+static ocs_hw_sequence_t *
+ocs_frame_next(ocs_list_t *pend_list, ocs_lock_t *list_lock)
+{
+	ocs_hw_sequence_t *frame = NULL;
+
+	ocs_lock(list_lock);
+		frame = ocs_list_remove_head(pend_list);
+	ocs_unlock(list_lock);
+	return frame;
+}
+
+/**
+ * @brief Process send fcp response frame callback
+ *
+ * The function is called when the send FCP response posting has completed. Regardless
+ * of the outcome, the sequence is freed.
+ *
+ * @param arg Pointer to originator frame sequence.
+ * @param cqe Pointer to completion queue entry.
+ * @param status Status of operation.
+ *
+ * @return None.
+ */
+static void
+ocs_sframe_common_send_cb(void *arg, uint8_t *cqe, int32_t status)
+{
+	ocs_hw_send_frame_context_t *ctx = arg;
+	ocs_hw_t *hw = ctx->hw;
+
+	/* Free WQ completion callback */
+	ocs_hw_reqtag_free(hw, ctx->wqcb);
+
+	/* Free sequence */
+	ocs_hw_sequence_free(hw, ctx->seq);
+}
+
+/**
+ * @brief Send a frame, common code
+ *
+ * A frame is sent using SEND_FRAME, the R_CTL/F_CTL/TYPE may be specified, the payload is
+ * sent as a single frame.
+ *
+ * Memory resources are allocated from RQ buffers contained in the passed in sequence data.
+ *
+ * @param node Pointer to node object.
+ * @param seq Pointer to sequence object.
+ * @param r_ctl R_CTL value to place in FC header.
+ * @param info INFO value to place in FC header.
+ * @param f_ctl F_CTL value to place in FC header.
+ * @param type TYPE value to place in FC header.
+ * @param payload Pointer to payload data
+ * @param payload_len Length of payload in bytes.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+static int32_t
+ocs_sframe_common_send(ocs_node_t *node, ocs_hw_sequence_t *seq, uint8_t r_ctl, uint8_t info, uint32_t f_ctl,
+		       uint8_t type, void *payload, uint32_t payload_len)
+{
+	ocs_t *ocs = node->ocs;
+	ocs_hw_t *hw = &ocs->hw;
+	ocs_hw_rtn_e rc = 0;
+	fc_header_t *behdr = seq->header->dma.virt;
+	fc_header_le_t hdr;
+	uint32_t s_id = fc_be24toh(behdr->s_id);
+	uint32_t d_id = fc_be24toh(behdr->d_id);
+	uint16_t ox_id = ocs_be16toh(behdr->ox_id);
+	uint16_t rx_id = ocs_be16toh(behdr->rx_id);
+	ocs_hw_send_frame_context_t *ctx;
+
+	uint32_t heap_size = seq->payload->dma.size;
+	uintptr_t heap_phys_base = seq->payload->dma.phys;
+	uint8_t *heap_virt_base = seq->payload->dma.virt;
+	uint32_t heap_offset = 0;
+
+	/* Build the FC header reusing the RQ header DMA buffer */
+	ocs_memset(&hdr, 0, sizeof(hdr));
+	hdr.d_id = s_id;			/* send it back to whomever sent it to us */
+	hdr.r_ctl = r_ctl;
+	hdr.info = info;
+	hdr.s_id = d_id;
+	hdr.cs_ctl = 0;
+	hdr.f_ctl = f_ctl;
+	hdr.type = type;
+	hdr.seq_cnt = 0;
+	hdr.df_ctl = 0;
+
+	/*
+	 * send_frame_seq_id is an atomic, we just let it increment, while storing only
+	 * the low 8 bits to hdr->seq_id
+	 */
+	hdr.seq_id = (uint8_t) ocs_atomic_add_return(&hw->send_frame_seq_id, 1);
+
+	hdr.rx_id = rx_id;
+	hdr.ox_id = ox_id;
+	hdr.parameter = 0;
+
+	/* Allocate and fill in the send frame request context */
+	ctx = (void*)(heap_virt_base + heap_offset);
+	heap_offset += sizeof(*ctx);
+	ocs_assert(heap_offset < heap_size, -1);
+	ocs_memset(ctx, 0, sizeof(*ctx));
+
+	/* Save sequence */
+	ctx->seq = seq;
+
+	/* Allocate a response payload DMA buffer from the heap */
+	ctx->payload.phys = heap_phys_base + heap_offset;
+	ctx->payload.virt = heap_virt_base + heap_offset;
+	ctx->payload.size = payload_len;
+	ctx->payload.len = payload_len;
+	heap_offset += payload_len;
+	ocs_assert(heap_offset <= heap_size, -1);
+
+	/* Copy the payload in */
+	ocs_memcpy(ctx->payload.virt, payload, payload_len);
+
+	/* Send */
+	rc = ocs_hw_send_frame(&ocs->hw, (void*)&hdr, FC_SOFI3, FC_EOFT, &ctx->payload, ctx,
+				ocs_sframe_common_send_cb, ctx);
+	if (rc) {
+		ocs_log_test(ocs, "ocs_hw_send_frame failed: %d\n", rc);
+	}
+
+	return rc ? -1 : 0;
+}
+
+/**
+ * @brief Send FCP response using SEND_FRAME
+ *
+ * The FCP response is send using the SEND_FRAME function.
+ *
+ * @param node Pointer to node object.
+ * @param seq Pointer to inbound sequence.
+ * @param rsp Pointer to response data.
+ * @param rsp_len Length of response data, in bytes.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+static int32_t
+ocs_sframe_send_fcp_rsp(ocs_node_t *node, ocs_hw_sequence_t *seq, void *rsp, uint32_t rsp_len)
+{
+	return ocs_sframe_common_send(node, seq,
+				      FC_RCTL_FC4_DATA,
+				      FC_RCTL_INFO_CMD_STATUS,
+				      FC_FCTL_EXCHANGE_RESPONDER |
+					      FC_FCTL_LAST_SEQUENCE |
+					      FC_FCTL_END_SEQUENCE |
+					      FC_FCTL_SEQUENCE_INITIATIVE,
+				      FC_TYPE_FCP,
+				      rsp, rsp_len);
+}
+
+/**
+ * @brief Send task set full response
+ *
+ * Return a task set full or busy response using send frame.
+ *
+ * @param node Pointer to node object.
+ * @param seq Pointer to originator frame sequence.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+static int32_t
+ocs_sframe_send_task_set_full_or_busy(ocs_node_t *node, ocs_hw_sequence_t *seq)
+{
+	fcp_rsp_iu_t fcprsp;
+	fcp_cmnd_iu_t *fcpcmd = seq->payload->dma.virt;
+	uint32_t *fcp_dl_ptr;
+	uint32_t fcp_dl;
+	int32_t rc = 0;
+
+	/* extract FCP_DL from FCP command*/
+	fcp_dl_ptr = (uint32_t*)(&(fcpcmd->fcp_cdb_and_dl));
+	fcp_dl_ptr += fcpcmd->additional_fcp_cdb_length;
+	fcp_dl = ocs_be32toh(*fcp_dl_ptr);
+
+	/* construct task set full or busy response */
+	ocs_memset(&fcprsp, 0, sizeof(fcprsp));
+	ocs_lock(&node->active_ios_lock);
+		fcprsp.scsi_status = ocs_list_empty(&node->active_ios) ? SCSI_STATUS_BUSY : SCSI_STATUS_TASK_SET_FULL;
+	ocs_unlock(&node->active_ios_lock);
+	*((uint32_t*)&fcprsp.fcp_resid) = fcp_dl;
+
+	/* send it using send_frame */
+	rc = ocs_sframe_send_fcp_rsp(node, seq, &fcprsp, sizeof(fcprsp) - sizeof(fcprsp.data));
+	if (rc) {
+		ocs_log_test(node->ocs, "ocs_sframe_send_fcp_rsp failed: %d\n", rc);
+	}
+	return rc;
+}
+
+/**
+ * @brief Send BA_ACC using sent frame
+ *
+ * A BA_ACC is sent using SEND_FRAME
+ *
+ * @param node Pointer to node object.
+ * @param seq Pointer to originator frame sequence.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+int32_t
+ocs_sframe_send_bls_acc(ocs_node_t *node,  ocs_hw_sequence_t *seq)
+{
+	fc_header_t *behdr = seq->header->dma.virt;
+	uint16_t ox_id = ocs_be16toh(behdr->ox_id);
+	uint16_t rx_id = ocs_be16toh(behdr->rx_id);
+	fc_ba_acc_payload_t acc = {0};
+
+	acc.ox_id = ocs_htobe16(ox_id);
+	acc.rx_id = ocs_htobe16(rx_id);
+	acc.low_seq_cnt = UINT16_MAX;
+	acc.high_seq_cnt = UINT16_MAX;
+
+	return ocs_sframe_common_send(node, seq,
+				      FC_RCTL_BLS,
+				      FC_RCTL_INFO_UNSOL_DATA,
+				      FC_FCTL_EXCHANGE_RESPONDER |
+					      FC_FCTL_LAST_SEQUENCE |
+					      FC_FCTL_END_SEQUENCE,
+				      FC_TYPE_BASIC_LINK,
+				      &acc, sizeof(acc));
+}
diff --git a/sys/dev/ocs_fc/ocs_unsol.h b/sys/dev/ocs_fc/ocs_unsol.h
new file mode 100644
index 000000000000..a36b2299f4eb
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_unsol.h
@@ -0,0 +1,53 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Declarations for the interface exported by ocs_unsol.c
+ */
+
+#if !defined(__OSC_UNSOL_H__)
+#define __OSC_UNSOL_H__
+
+extern int32_t ocs_unsol_rq_thread(ocs_thread_t *mythread);
+extern int32_t ocs_unsolicited_cb(void *arg, ocs_hw_sequence_t *seq);
+extern int32_t ocs_node_purge_pending(ocs_node_t *node);
+extern int32_t ocs_process_node_pending(ocs_node_t *node);
+extern int32_t ocs_domain_process_pending(ocs_domain_t *domain);
+extern int32_t ocs_domain_purge_pending(ocs_domain_t *domain);
+extern int32_t ocs_dispatch_unsolicited_bls(ocs_node_t *node, ocs_hw_sequence_t *seq);
+extern void ocs_domain_hold_frames(ocs_domain_t *domain);
+extern void ocs_domain_accept_frames(ocs_domain_t *domain);
+extern void ocs_seq_coalesce_cleanup(ocs_hw_io_t *hio, uint8_t abort_io);
+extern int32_t ocs_sframe_send_bls_acc(ocs_node_t *node,  ocs_hw_sequence_t *seq);
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_utils.c b/sys/dev/ocs_fc/ocs_utils.c
new file mode 100644
index 000000000000..f6f74302835e
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_utils.c
@@ -0,0 +1,2826 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ */
+
+#include "ocs.h"
+#include "ocs_os.h"
+
+#define DEFAULT_SLAB_LEN		(64*1024)
+
+struct ocs_array_s {
+	ocs_os_handle_t os;
+
+	uint32_t size;
+	uint32_t count;
+
+	uint32_t n_rows;
+	uint32_t elems_per_row;
+	uint32_t bytes_per_row;
+
+	void **array_rows;
+	uint32_t array_rows_len;
+};
+
+static uint32_t slab_len = DEFAULT_SLAB_LEN;
+
+/**
+ * @brief Set array slab allocation length
+ *
+ * The slab length is the maximum allocation length that the array uses.
+ * The default 64k slab length may be overridden using this function.
+ *
+ * @param len new slab length.
+ *
+ * @return none
+ */
+void
+ocs_array_set_slablen(uint32_t len)
+{
+	slab_len = len;
+}
+
+/**
+ * @brief Allocate an array object
+ *
+ * An array object of size and number of elements is allocated
+ *
+ * @param os OS handle
+ * @param size size of array elements in bytes
+ * @param count number of elements in array
+ *
+ * @return pointer to array object or NULL
+ */
+ocs_array_t *
+ocs_array_alloc(ocs_os_handle_t os, uint32_t size, uint32_t count)
+{
+	ocs_array_t *array = NULL;
+	uint32_t i;
+
+	/* Fail if the item size exceeds slab_len - caller should increase slab_size,
+	 * or not use this API.
+	 */
+	if (size > slab_len) {
+		ocs_log_err(NULL, "Error: size exceeds slab length\n");
+		return NULL;
+	}
+
+	array = ocs_malloc(os, sizeof(*array), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (array == NULL) {
+		return NULL;
+	}
+
+	array->os = os;
+	array->size = size;
+	array->count = count;
+	array->elems_per_row = slab_len / size;
+	array->n_rows = (count + array->elems_per_row - 1) / array->elems_per_row;
+	array->bytes_per_row = array->elems_per_row * array->size;
+
+	array->array_rows_len = array->n_rows * sizeof(*array->array_rows);
+	array->array_rows = ocs_malloc(os, array->array_rows_len, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (array->array_rows == NULL) {
+		ocs_array_free(array);
+		return NULL;
+	}
+	for (i = 0; i < array->n_rows; i++) {
+		array->array_rows[i] = ocs_malloc(os, array->bytes_per_row, OCS_M_ZERO | OCS_M_NOWAIT);
+		if (array->array_rows[i] == NULL) {
+			ocs_array_free(array);
+			return NULL;
+		}
+	}
+
+	return array;
+}
+
+/**
+ * @brief Free an array object
+ *
+ * Frees a prevously allocated array object
+ *
+ * @param array pointer to array object
+ *
+ * @return none
+ */
+void
+ocs_array_free(ocs_array_t *array)
+{
+	uint32_t i;
+
+	if (array != NULL) {
+		if (array->array_rows != NULL) {
+			for (i = 0; i < array->n_rows; i++) {
+				if (array->array_rows[i] != NULL) {
+					ocs_free(array->os, array->array_rows[i], array->bytes_per_row);
+				}
+			}
+			ocs_free(array->os, array->array_rows, array->array_rows_len);
+		}
+		ocs_free(array->os, array, sizeof(*array));
+	}
+}
+
+/**
+ * @brief Return reference to an element of an array object
+ *
+ * Return the address of an array element given an index
+ *
+ * @param array pointer to array object
+ * @param idx array element index
+ *
+ * @return rointer to array element, or NULL if index out of range
+ */
+void *ocs_array_get(ocs_array_t *array, uint32_t idx)
+{
+	void *entry = NULL;
+
+	if (idx < array->count) {
+		uint32_t row = idx / array->elems_per_row;
+		uint32_t offset = idx % array->elems_per_row;
+		entry = ((uint8_t*)array->array_rows[row]) + (offset * array->size);
+	}
+	return entry;
+}
+
+/**
+ * @brief Return number of elements in an array
+ *
+ * Return the number of elements in an array
+ *
+ * @param array pointer to array object
+ *
+ * @return returns count of elements in an array
+ */
+uint32_t
+ocs_array_get_count(ocs_array_t *array)
+{
+	return array->count;
+}
+
+/**
+ * @brief Return size of array elements in bytes
+ *
+ * Returns the size in bytes of each array element
+ *
+ * @param array pointer to array object
+ *
+ * @return size of array element
+ */
+uint32_t
+ocs_array_get_size(ocs_array_t *array)
+{
+	return array->size;
+}
+
+/**
+ * @brief Void pointer array structure
+ *
+ * This structure describes an object consisting of an array of void
+ * pointers.   The object is allocated with a maximum array size, entries
+ * are then added to the array with while maintaining an entry count.   A set of
+ * iterator APIs are included to allow facilitate cycling through the array
+ * entries in a circular fashion.
+ *
+ */
+struct ocs_varray_s {
+	ocs_os_handle_t os;
+	uint32_t array_count;			/*>> maximum entry count in array */
+	void **array;				/*>> pointer to allocated array memory */
+	uint32_t entry_count;			/*>> number of entries added to the array */
+	uint32_t next_index;			/*>> iterator next index */
+	ocs_lock_t lock;			/*>> iterator lock */
+};
+
+/**
+ * @brief Allocate a void pointer array
+ *
+ * A void pointer array of given length is allocated.
+ *
+ * @param os OS handle
+ * @param array_count Array size
+ *
+ * @return returns a pointer to the ocs_varray_t object, other NULL on error
+ */
+ocs_varray_t *
+ocs_varray_alloc(ocs_os_handle_t os, uint32_t array_count)
+{
+	ocs_varray_t *va;
+
+	va = ocs_malloc(os, sizeof(*va), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (va != NULL) {
+		va->os = os;
+		va->array_count = array_count;
+		va->array = ocs_malloc(os, sizeof(*va->array) * va->array_count, OCS_M_ZERO | OCS_M_NOWAIT);
+		if (va->array != NULL) {
+			va->next_index = 0;
+			ocs_lock_init(os, &va->lock, "varray:%p", va);
+		} else {
+			ocs_free(os, va, sizeof(*va));
+			va = NULL;
+		}
+	}
+	return va;
+}
+
+/**
+ * @brief Free a void pointer array
+ *
+ * The void pointer array object is free'd
+ *
+ * @param va Pointer to void pointer array
+ *
+ * @return none
+ */
+void
+ocs_varray_free(ocs_varray_t *va)
+{
+	if (va != NULL) {
+		ocs_lock_free(&va->lock);
+		if (va->array != NULL) {
+			ocs_free(va->os, va->array, sizeof(*va->array) * va->array_count);
+		}
+		ocs_free(va->os, va, sizeof(*va));
+	}
+}
+
+/**
+ * @brief Add an entry to a void pointer array
+ *
+ * An entry is added to the void pointer array
+ *
+ * @param va Pointer to void pointer array
+ * @param entry Pointer to entry to add
+ *
+ * @return returns 0 if entry was added, -1 if there is no more space in the array
+ */
+int32_t
+ocs_varray_add(ocs_varray_t *va, void *entry)
+{
+	uint32_t rc = -1;
+
+	ocs_lock(&va->lock);
+		if (va->entry_count < va->array_count) {
+			va->array[va->entry_count++] = entry;
+			rc = 0;
+		}
+	ocs_unlock(&va->lock);
+
+	return rc;
+}
+
+/**
+ * @brief Reset the void pointer array iterator
+ *
+ * The next index value of the void pointer array iterator is cleared.
+ *
+ * @param va Pointer to void pointer array
+ *
+ * @return none
+ */
+void
+ocs_varray_iter_reset(ocs_varray_t *va)
+{
+	ocs_lock(&va->lock);
+		va->next_index = 0;
+	ocs_unlock(&va->lock);
+}
+
+/**
+ * @brief Return next entry from a void pointer array
+ *
+ * The next entry in the void pointer array is returned.
+ *
+ * @param va Pointer to void point array
+ *
+ * Note: takes the void pointer array lock
+ *
+ * @return returns next void pointer entry
+ */
+void *
+ocs_varray_iter_next(ocs_varray_t *va)
+{
+	void *rval = NULL;
+
+	if (va != NULL) {
+		ocs_lock(&va->lock);
+			rval = _ocs_varray_iter_next(va);
+		ocs_unlock(&va->lock);
+	}
+	return rval;
+}
+
+/**
+ * @brief Return next entry from a void pointer array
+ *
+ * The next entry in the void pointer array is returned.
+ *
+ * @param va Pointer to void point array
+ *
+ * Note: doesn't take the void pointer array lock
+ *
+ * @return returns next void pointer entry
+ */
+void *
+_ocs_varray_iter_next(ocs_varray_t *va)
+{
+	void *rval;
+
+	rval = va->array[va->next_index];
+	if (++va->next_index >= va->entry_count) {
+		va->next_index = 0;
+	}
+	return rval;
+}
+
+/**
+ * @brief Take void pointer array lock
+ *
+ * Takes the lock for the given void pointer array
+ *
+ * @param va Pointer to void pointer array
+ *
+ * @return none
+ */
+void
+ocs_varray_lock(ocs_varray_t *va)
+{
+	ocs_lock(&va->lock);
+}
+
+/**
+ * @brief Release void pointer array lock
+ *
+ * Releases the lock for the given void pointer array
+ *
+ * @param va Pointer to void pointer array
+ *
+ * @return none
+ */
+void
+ocs_varray_unlock(ocs_varray_t *va)
+{
+	ocs_unlock(&va->lock);
+}
+
+/**
+ * @brief Return entry count for a void pointer array
+ *
+ * The entry count for a void pointer array is returned
+ *
+ * @param va Pointer to void pointer array
+ *
+ * @return returns entry count
+ */
+uint32_t
+ocs_varray_get_count(ocs_varray_t *va)
+{
+	uint32_t rc;
+
+	ocs_lock(&va->lock);
+		rc = va->entry_count;
+	ocs_unlock(&va->lock);
+	return rc;
+}
+
+
+struct ocs_cbuf_s {
+	ocs_os_handle_t os;		/*<< OS handle */
+	uint32_t entry_count;		/*<< entry count */
+	void **array;			/*<< pointer to array of cbuf pointers */
+	uint32_t pidx;			/*<< producer index */
+	uint32_t cidx;			/*<< consumer index */
+	ocs_lock_t cbuf_plock;		/*<< idx lock */
+	ocs_lock_t cbuf_clock;		/*<< idx lock */
+	ocs_sem_t cbuf_psem;		/*<< cbuf producer counting semaphore */
+	ocs_sem_t cbuf_csem;		/*<< cbuf consumer counting semaphore */
+};
+
+/**
+ * @brief Initialize a circular buffer queue
+ *
+ * A circular buffer with producer/consumer API is allocated
+ *
+ * @param os OS handle
+ * @param entry_count count of entries
+ *
+ * @return returns pointer to circular buffer, or NULL
+ */
+ocs_cbuf_t*
+ocs_cbuf_alloc(ocs_os_handle_t os, uint32_t entry_count)
+{
+	ocs_cbuf_t *cbuf;
+
+	cbuf = ocs_malloc(os, sizeof(*cbuf), OCS_M_NOWAIT | OCS_M_ZERO);
+	if (cbuf == NULL) {
+		return NULL;
+	}
+
+	cbuf->os = os;
+	cbuf->entry_count = entry_count;
+	cbuf->pidx = 0;
+	cbuf->cidx = 0;
+
+	ocs_lock_init(NULL, &cbuf->cbuf_clock, "cbuf_c:%p", cbuf);
+	ocs_lock_init(NULL, &cbuf->cbuf_plock, "cbuf_p:%p", cbuf);
+	ocs_sem_init(&cbuf->cbuf_csem, 0, "cbuf:%p", cbuf);
+	ocs_sem_init(&cbuf->cbuf_psem, cbuf->entry_count, "cbuf:%p", cbuf);
+
+	cbuf->array = ocs_malloc(os, entry_count * sizeof(*cbuf->array), OCS_M_NOWAIT | OCS_M_ZERO);
+	if (cbuf->array == NULL) {
+		ocs_cbuf_free(cbuf);
+		return NULL;
+	}
+
+	return cbuf;
+}
+
+/**
+ * @brief Free a circular buffer
+ *
+ * The memory resources of a circular buffer are free'd
+ *
+ * @param cbuf pointer to circular buffer
+ *
+ * @return none
+ */
+void
+ocs_cbuf_free(ocs_cbuf_t *cbuf)
+{
+	if (cbuf != NULL) {
+		if (cbuf->array != NULL) {
+			ocs_free(cbuf->os, cbuf->array, sizeof(*cbuf->array) * cbuf->entry_count);
+		}
+		ocs_lock_free(&cbuf->cbuf_clock);
+		ocs_lock_free(&cbuf->cbuf_plock);
+		ocs_free(cbuf->os, cbuf, sizeof(*cbuf));
+	}
+}
+
+/**
+ * @brief Get pointer to buffer
+ *
+ * Wait for a buffer to become available, and return a pointer to the buffer.
+ *
+ * @param cbuf pointer to circular buffer
+ * @param timeout_usec timeout in microseconds
+ *
+ * @return pointer to buffer, or NULL if timeout
+ */
+void*
+ocs_cbuf_get(ocs_cbuf_t *cbuf, int32_t timeout_usec)
+{
+	void *ret = NULL;
+
+	if (likely(ocs_sem_p(&cbuf->cbuf_csem, timeout_usec) == 0)) {
+		ocs_lock(&cbuf->cbuf_clock);
+			ret = cbuf->array[cbuf->cidx];
+			if (unlikely(++cbuf->cidx >= cbuf->entry_count)) {
+				cbuf->cidx = 0;
+			}
+		ocs_unlock(&cbuf->cbuf_clock);
+		ocs_sem_v(&cbuf->cbuf_psem);
+	}
+	return ret;
+}
+
+/**
+ * @brief write a buffer
+ *
+ * The buffer is written to the circular buffer.
+ *
+ * @param cbuf pointer to circular buffer
+ * @param elem pointer to entry
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_cbuf_put(ocs_cbuf_t *cbuf, void *elem)
+{
+	int32_t rc = 0;
+
+	if (likely(ocs_sem_p(&cbuf->cbuf_psem, -1) == 0)) {
+		ocs_lock(&cbuf->cbuf_plock);
+			cbuf->array[cbuf->pidx] = elem;
+			if (unlikely(++cbuf->pidx >= cbuf->entry_count)) {
+				cbuf->pidx = 0;
+			}
+		ocs_unlock(&cbuf->cbuf_plock);
+		ocs_sem_v(&cbuf->cbuf_csem);
+	} else {
+		rc = -1;
+	}
+	return rc;
+}
+
+/**
+ * @brief Prime a circular buffer data
+ *
+ * Post array buffers to a circular buffer
+ *
+ * @param cbuf pointer to circular buffer
+ * @param array pointer to buffer array
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+ocs_cbuf_prime(ocs_cbuf_t *cbuf, ocs_array_t *array)
+{
+	uint32_t i;
+	uint32_t count = MIN(ocs_array_get_count(array), cbuf->entry_count);
+
+	for (i = 0; i < count; i++) {
+		ocs_cbuf_put(cbuf, ocs_array_get(array, i));
+	}
+	return 0;
+}
+
+/**
+ * @brief Generate driver dump start of file information
+ *
+ * The start of file information is added to 'textbuf'
+ *
+ * @param textbuf pointer to driver dump text buffer
+ *
+ * @return none
+ */
+
+void
+ocs_ddump_startfile(ocs_textbuf_t *textbuf)
+{
+	ocs_textbuf_printf(textbuf, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n");
+}
+
+/**
+ * @brief Generate driver dump end of file information
+ *
+ * The end of file information is added to 'textbuf'
+ *
+ * @param textbuf pointer to driver dump text buffer
+ *
+ * @return none
+ */
+
+void
+ocs_ddump_endfile(ocs_textbuf_t *textbuf)
+{
+}
+
+/**
+ * @brief Generate driver dump section start data
+ *
+ * The driver section start information is added to textbuf
+ *
+ * @param textbuf pointer to text buffer
+ * @param name name of section
+ * @param instance instance number of this section
+ *
+ * @return none
+ */
+
+void
+ocs_ddump_section(ocs_textbuf_t *textbuf, const char *name, uint32_t instance)
+{
+	ocs_textbuf_printf(textbuf, "<%s type=\"section\" instance=\"%d\">\n", name, instance);
+}
+
+/**
+ * @brief Generate driver dump section end data
+ *
+ * The driver section end information is added to textbuf
+ *
+ * @param textbuf pointer to text buffer
+ * @param name name of section
+ * @param instance instance number of this section
+ *
+ * @return none
+ */
+
+void
+ocs_ddump_endsection(ocs_textbuf_t *textbuf, const char *name, uint32_t instance)
+{
+	ocs_textbuf_printf(textbuf, "</%s>\n", name);
+}
+
+/**
+ * @brief Generate driver dump data for a given value
+ *
+ * A value is added to textbuf
+ *
+ * @param textbuf pointer to text buffer
+ * @param name name of variable
+ * @param fmt snprintf format specifier
+ *
+ * @return none
+ */
+
+void
+ocs_ddump_value(ocs_textbuf_t *textbuf, const char *name, const char *fmt, ...)
+{
+	va_list ap;
+	char valuebuf[64];
+
+	va_start(ap, fmt);
+	vsnprintf(valuebuf, sizeof(valuebuf), fmt, ap);
+	va_end(ap);
+
+	ocs_textbuf_printf(textbuf, "<%s>%s</%s>\n", name, valuebuf, name);
+}
+
+
+/**
+ * @brief Generate driver dump data for an arbitrary buffer of DWORDS
+ *
+ * A status value is added to textbuf
+ *
+ * @param textbuf pointer to text buffer
+ * @param name name of status variable
+ * @param instance instance number of this section
+ * @param buffer buffer to print
+ * @param size size of buffer in bytes
+ *
+ * @return none
+ */
+
+void
+ocs_ddump_buffer(ocs_textbuf_t *textbuf, const char *name, uint32_t instance, void *buffer, uint32_t size)
+{
+	uint32_t *dword;
+	uint32_t i;
+	uint32_t count;
+
+	count = size / sizeof(uint32_t);
+
+	if (count == 0) {
+		return;
+	}
+
+	ocs_textbuf_printf(textbuf, "<%s type=\"buffer\" instance=\"%d\">\n", name, instance);
+
+	dword = buffer;
+	for (i = 0; i < count; i++) {
+#define OCS_NEWLINE_MOD	8
+		ocs_textbuf_printf(textbuf, "%08x ", *dword++);
+		if ((i % OCS_NEWLINE_MOD) == (OCS_NEWLINE_MOD - 1)) {
+			ocs_textbuf_printf(textbuf, "\n");
+		}
+	}
+
+	ocs_textbuf_printf(textbuf, "</%s>\n", name);
+}
+
+/**
+ * @brief Generate driver dump for queue
+ *
+ * Add queue elements to text buffer
+ *
+ * @param textbuf pointer to driver dump text buffer
+ * @param q_addr address of start of queue
+ * @param size size of each queue entry
+ * @param length number of queue entries in the queue
+ * @param index current index of queue
+ * @param qentries number of most recent queue entries to dump
+ *
+ * @return none
+ */
+
+void
+ocs_ddump_queue_entries(ocs_textbuf_t *textbuf, void *q_addr, uint32_t size,
+			uint32_t length, int32_t index, uint32_t qentries)
+{
+	uint32_t i;
+	uint32_t j;
+	uint8_t *entry;
+	uint32_t *dword;
+	uint32_t entry_count = 0;
+	uint32_t entry_words = size / sizeof(uint32_t);
+
+	if ((qentries == (uint32_t)-1) || (qentries > length)) {
+		/* if qentries is -1 or larger than queue size, dump entire queue */
+		entry_count = length;
+		index = 0;
+	} else {
+		entry_count = qentries;
+
+		index -= (qentries - 1);
+		if (index < 0) {
+			index += length;
+		}
+
+	}
+#define OCS_NEWLINE_MOD	8
+	ocs_textbuf_printf(textbuf, "<qentries>\n");
+	for (i = 0; i < entry_count; i++){
+		entry = q_addr;
+		entry += index * size;
+		dword = (uint32_t *)entry;
+
+		ocs_textbuf_printf(textbuf, "[%04x] ", index);
+		for (j = 0; j < entry_words; j++) {
+			ocs_textbuf_printf(textbuf, "%08x ", *dword++);
+			if (((j+1) == entry_words) ||
+			    ((j % OCS_NEWLINE_MOD) == (OCS_NEWLINE_MOD - 1))) {
+				ocs_textbuf_printf(textbuf, "\n");
+				if ((j+1) < entry_words) {
+					ocs_textbuf_printf(textbuf, "       ");
+				}
+			}
+		}
+
+		index++;
+		if ((uint32_t)index >= length) {
+			index = 0;
+		}
+	}
+	ocs_textbuf_printf(textbuf, "</qentries>\n");
+}
+
+
+#define OCS_DEBUG_ENABLE(x)	(x ? ~0 : 0)
+
+#define OCS_DEBUG_MASK \
+	(OCS_DEBUG_ENABLE(1)	& OCS_DEBUG_ALWAYS)  | \
+	(OCS_DEBUG_ENABLE(0)	& OCS_DEBUG_ENABLE_MQ_DUMP) | \
+	(OCS_DEBUG_ENABLE(0)	& OCS_DEBUG_ENABLE_CQ_DUMP) | \
+	(OCS_DEBUG_ENABLE(0)	& OCS_DEBUG_ENABLE_WQ_DUMP) | \
+	(OCS_DEBUG_ENABLE(0)	& OCS_DEBUG_ENABLE_EQ_DUMP) | \
+	(OCS_DEBUG_ENABLE(0)	& OCS_DEBUG_ENABLE_SPARAM_DUMP)
+
+static uint32_t ocs_debug_mask = OCS_DEBUG_MASK;
+
+static int
+_isprint(int c) {
+	return ((c > 32) && (c < 127));
+}
+
+/**
+ * @ingroup debug
+ * @brief enable debug options
+ *
+ * Enables debug options by or-ing in <b>mask</b> into the currently enabled
+ * debug mask.
+ *
+ * @param mask mask bits to enable
+ *
+ * @return none
+ */
+
+void ocs_debug_enable(uint32_t mask) {
+	ocs_debug_mask |= mask;
+}
+
+/**
+ * @ingroup debug
+ * @brief disable debug options
+ *
+ * Disables debug options by clearing bits in <b>mask</b> into the currently enabled
+ * debug mask.
+ *
+ * @param mask mask bits to enable
+ *
+ * @return none
+ */
+
+void ocs_debug_disable(uint32_t mask) {
+	ocs_debug_mask &= ~mask;
+}
+
+/**
+ * @ingroup debug
+ * @brief return true if debug bits are enabled
+ *
+ * Returns true if the request debug bits are set.
+ *
+ * @param mask debug bit mask
+ *
+ * @return true if corresponding bits are set
+ *
+ * @note Passing in a mask value of zero always returns true
+ */
+
+int ocs_debug_is_enabled(uint32_t mask) {
+	return (ocs_debug_mask & mask) == mask;
+}
+
+
+/**
+ * @ingroup debug
+ * @brief Dump 32 bit hex/ascii data
+ *
+ * Dumps using ocs_log a buffer of data as 32 bit hex and ascii
+ *
+ * @param mask debug enable bits
+ * @param os os handle
+ * @param label text label for the display (may be NULL)
+ * @param buf pointer to data buffer
+ * @param buf_length length of data buffer
+ *
+ * @return none
+ *
+ */
+
+void
+ocs_dump32(uint32_t mask, ocs_os_handle_t os, const char *label, void *buf, uint32_t buf_length)
+{
+	uint32_t word_count = buf_length / sizeof(uint32_t);
+	uint32_t i;
+	uint32_t columns = 8;
+	uint32_t n;
+	uint32_t *wbuf;
+	char *cbuf;
+	uint32_t addr = 0;
+	char linebuf[200];
+	char *pbuf = linebuf;
+
+	if (!ocs_debug_is_enabled(mask))
+		return;
+
+	if (label)
+		ocs_log_debug(os, "%s\n", label);
+
+	wbuf = buf;
+	while (word_count > 0) {
+		pbuf = linebuf;
+		pbuf += ocs_snprintf(pbuf, sizeof(linebuf) - (pbuf-linebuf), "%08X:  ", addr);
+
+		n = word_count;
+		if (n > columns)
+			n = columns;
+
+		for (i = 0; i < n; i ++)
+			pbuf += ocs_snprintf(pbuf, sizeof(linebuf) - (pbuf-linebuf), "%08X ", wbuf[i]);
+
+		for (; i < columns; i ++)
+			pbuf += ocs_snprintf(pbuf, sizeof(linebuf) - (pbuf-linebuf), "%8s ", "");
+
+		pbuf += ocs_snprintf(pbuf, sizeof(linebuf) - (pbuf-linebuf), "    ");
+		cbuf = (char*)wbuf;
+		for (i = 0; i < n*sizeof(uint32_t); i ++)
+			pbuf += ocs_snprintf(pbuf, sizeof(linebuf) - (pbuf-linebuf), "%c", _isprint(cbuf[i]) ? cbuf[i] : '.');
+		pbuf += ocs_snprintf(pbuf, sizeof(linebuf) - (pbuf-linebuf), "\n");
+
+		ocs_log_debug(os, "%s", linebuf);
+
+		wbuf += n;
+		word_count -= n;
+		addr += n*sizeof(uint32_t);
+	}
+}
+
+
+#if defined(OCS_DEBUG_QUEUE_HISTORY)
+
+/* each bit corresponds to word to capture */
+#define OCS_Q_HIST_WQE_WORD_MASK_DEFAULT	(BIT(4) | BIT(6) | BIT(7) | BIT(9) | BIT(12))
+#define OCS_Q_HIST_TRECV_CONT_WQE_WORD_MASK	(BIT(4) | BIT(5) | BIT(6) | BIT(7) | BIT(9) | BIT(12))
+#define OCS_Q_HIST_IWRITE_WQE_WORD_MASK		(BIT(4) | BIT(5) | BIT(6) | BIT(7) | BIT(9))
+#define OCS_Q_HIST_IREAD_WQE_WORD_MASK		(BIT(4) | BIT(6) | BIT(7) | BIT(9))
+#define OCS_Q_HIST_ABORT_WQE_WORD_MASK		(BIT(3) | BIT(7) | BIT(8) | BIT(9))
+#define OCS_Q_HIST_WCQE_WORD_MASK		(BIT(0) | BIT(3))
+#define OCS_Q_HIST_WCQE_WORD_MASK_ERR		(BIT(0) | BIT(1) | BIT(2) | BIT(3))
+#define OCS_Q_HIST_CQXABT_WORD_MASK		(BIT(0) | BIT(1) | BIT(2) | BIT(3))
+
+/* if set, will provide extra queue information in each entry */
+#define OCS_Q_HIST_ENABLE_Q_INFO	0
+uint8_t ocs_queue_history_q_info_enabled(void)
+{
+	return OCS_Q_HIST_ENABLE_Q_INFO;
+}
+
+/* if set, will provide timestamps in each entry */
+#define OCS_Q_HIST_ENABLE_TIMESTAMPS	0
+uint8_t ocs_queue_history_timestamp_enabled(void)
+{
+	return OCS_Q_HIST_ENABLE_TIMESTAMPS;
+}
+
+/* Add WQEs and masks to override default WQE mask */
+ocs_q_hist_wqe_mask_t ocs_q_hist_wqe_masks[] = {
+	/* WQE command   Word mask */
+	{SLI4_WQE_ABORT, OCS_Q_HIST_ABORT_WQE_WORD_MASK},
+	{SLI4_WQE_FCP_IREAD64, OCS_Q_HIST_IREAD_WQE_WORD_MASK},
+	{SLI4_WQE_FCP_IWRITE64, OCS_Q_HIST_IWRITE_WQE_WORD_MASK},
+	{SLI4_WQE_FCP_CONT_TRECEIVE64, OCS_Q_HIST_TRECV_CONT_WQE_WORD_MASK},
+};
+
+/* CQE masks */
+ocs_q_hist_cqe_mask_t ocs_q_hist_cqe_masks[] = {
+	/* CQE type     Q_hist_type		mask (success) 	mask (non-success) */
+	{SLI_QENTRY_WQ, OCS_Q_HIST_TYPE_CWQE, 	OCS_Q_HIST_WCQE_WORD_MASK, OCS_Q_HIST_WCQE_WORD_MASK_ERR},
+	{SLI_QENTRY_XABT, OCS_Q_HIST_TYPE_CXABT, OCS_Q_HIST_CQXABT_WORD_MASK, OCS_Q_HIST_WCQE_WORD_MASK},
+};
+
+static uint32_t ocs_q_hist_get_wqe_mask(sli4_generic_wqe_t *wqe)
+{
+	uint32_t i;
+	for (i = 0; i < ARRAY_SIZE(ocs_q_hist_wqe_masks); i++) {
+		if (ocs_q_hist_wqe_masks[i].command == wqe->command) {
+			return ocs_q_hist_wqe_masks[i].mask;
+		}
+	}
+	/* return default WQE mask */
+	return OCS_Q_HIST_WQE_WORD_MASK_DEFAULT;
+}
+
+/**
+ * @ingroup debug
+ * @brief Initialize resources for queue history
+ *
+ * @param os os handle
+ * @param q_hist Pointer to the queue history object.
+ *
+ * @return none
+ */
+void
+ocs_queue_history_init(ocs_t *ocs, ocs_hw_q_hist_t *q_hist)
+{
+	q_hist->ocs = ocs;
+	if (q_hist->q_hist != NULL) {
+		/* Setup is already done */
+		ocs_log_debug(ocs, "q_hist not NULL, skipping init\n");
+		return;
+	}
+
+	q_hist->q_hist = ocs_malloc(ocs, sizeof(*q_hist->q_hist)*OCS_Q_HIST_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
+
+	if (q_hist->q_hist == NULL) {
+		ocs_log_err(ocs, "Could not allocate queue history buffer\n");
+	} else {
+		ocs_lock_init(ocs, &q_hist->q_hist_lock, "queue history lock[%d]", ocs_instance(ocs));
+	}
+
+	q_hist->q_hist_index = 0;
+}
+
+/**
+ * @ingroup debug
+ * @brief Free resources for queue history
+ *
+ * @param q_hist Pointer to the queue history object.
+ *
+ * @return none
+ */
+void
+ocs_queue_history_free(ocs_hw_q_hist_t *q_hist)
+{
+	ocs_t *ocs = q_hist->ocs;
+
+	if (q_hist->q_hist != NULL) {
+		ocs_free(ocs, q_hist->q_hist, sizeof(*q_hist->q_hist)*OCS_Q_HIST_SIZE);
+		ocs_lock_free(&q_hist->q_hist_lock);
+		q_hist->q_hist = NULL;
+	}
+}
+
+static void
+ocs_queue_history_add_q_info(ocs_hw_q_hist_t *q_hist, uint32_t qid, uint32_t qindex)
+{
+	if (ocs_queue_history_q_info_enabled()) {
+		/* write qid, index */
+		q_hist->q_hist[q_hist->q_hist_index] = (qid << 16) | qindex;
+		q_hist->q_hist_index++;
+		q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+	}
+}
+
+static void
+ocs_queue_history_add_timestamp(ocs_hw_q_hist_t *q_hist)
+{
+	if (ocs_queue_history_timestamp_enabled()) {
+		/* write tsc */
+		uint64_t tsc_value;
+		tsc_value = get_cyclecount();
+		q_hist->q_hist[q_hist->q_hist_index] = ((tsc_value >> 32 ) & 0xFFFFFFFF);
+		q_hist->q_hist_index++;
+		q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+		q_hist->q_hist[q_hist->q_hist_index] = (tsc_value & 0xFFFFFFFF);
+		q_hist->q_hist_index++;
+		q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+	}
+}
+
+/**
+ * @ingroup debug
+ * @brief Log work queue entry (WQE) into history array
+ *
+ * @param q_hist Pointer to the queue history object.
+ * @param entryw Work queue entry in words
+ * @param qid Queue ID
+ * @param qindex Queue index
+ *
+ * @return none
+ */
+void
+ocs_queue_history_wq(ocs_hw_q_hist_t *q_hist, uint32_t *entryw, uint32_t qid, uint32_t qindex)
+{
+	int i;
+	ocs_q_hist_ftr_t ftr;
+	uint32_t wqe_word_mask = ocs_q_hist_get_wqe_mask((sli4_generic_wqe_t *)entryw);
+
+	if (q_hist->q_hist == NULL) {
+		/* Can't save anything */
+		return;
+	}
+
+	ftr.word = 0;
+	ftr.s.type = OCS_Q_HIST_TYPE_WQE;
+	ocs_lock(&q_hist->q_hist_lock);
+		/* Capture words in reverse order since we'll be interpretting them LIFO */
+		for (i = ((sizeof(wqe_word_mask)*8) - 1); i >= 0; i--){
+			if ((wqe_word_mask >> i) & 1) {
+				q_hist->q_hist[q_hist->q_hist_index] = entryw[i];
+				q_hist->q_hist_index++;
+				q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+			}
+		}
+
+		ocs_queue_history_add_q_info(q_hist, qid, qindex);
+		ocs_queue_history_add_timestamp(q_hist);
+
+		/* write footer */
+		if (wqe_word_mask) {
+			ftr.s.mask = wqe_word_mask;
+			q_hist->q_hist[q_hist->q_hist_index] = ftr.word;
+			q_hist->q_hist_index++;
+			q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+		}
+
+	ocs_unlock(&q_hist->q_hist_lock);
+}
+
+/**
+ * @ingroup debug
+ * @brief Log misc words
+ *
+ * @param q_hist Pointer to the queue history object.
+ * @param entryw array of words
+ * @param num_words number of words in entryw
+ *
+ * @return none
+ */
+void
+ocs_queue_history_misc(ocs_hw_q_hist_t *q_hist, uint32_t *entryw, uint32_t num_words)
+{
+	int i;
+	ocs_q_hist_ftr_t ftr;
+	uint32_t mask = 0;
+
+	if (q_hist->q_hist == NULL) {
+		/* Can't save anything */
+		return;
+	}
+
+	ftr.word = 0;
+	ftr.s.type = OCS_Q_HIST_TYPE_MISC;
+	ocs_lock(&q_hist->q_hist_lock);
+		/* Capture words in reverse order since we'll be interpretting them LIFO */
+		for (i = num_words-1; i >= 0; i--) {
+			q_hist->q_hist[q_hist->q_hist_index] = entryw[i];
+			q_hist->q_hist_index++;
+			q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+			mask |= BIT(i);
+		}
+
+		ocs_queue_history_add_timestamp(q_hist);
+
+		/* write footer */
+		if (num_words) {
+			ftr.s.mask = mask;
+			q_hist->q_hist[q_hist->q_hist_index] = ftr.word;
+			q_hist->q_hist_index++;
+			q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+		}
+
+	ocs_unlock(&q_hist->q_hist_lock);
+}
+
+/**
+ * @ingroup debug
+ * @brief Log work queue completion (CQE) entry into history
+ *        array
+ *
+ * @param q_hist Pointer to the queue history object.
+ * @param ctype Type of completion entry
+ * @param entryw Completion queue entry in words
+ * @param status Completion queue status
+ * @param qid Queue ID
+ * @param qindex Queue index
+ *
+ * @return none
+ */
+void
+ocs_queue_history_cqe(ocs_hw_q_hist_t *q_hist, uint8_t ctype, uint32_t *entryw, uint8_t status, uint32_t qid, uint32_t qindex)
+{
+	int i;
+	unsigned j;
+	uint32_t cqe_word_mask = 0;
+	ocs_q_hist_ftr_t ftr;
+
+	if (q_hist->q_hist == NULL) {
+		/* Can't save anything */
+		return;
+	}
+
+	ftr.word = 0;
+	for (j = 0; j < ARRAY_SIZE(ocs_q_hist_cqe_masks); j++) {
+		if (ocs_q_hist_cqe_masks[j].ctype == ctype) {
+			ftr.s.type = ocs_q_hist_cqe_masks[j].type;
+			if (status != 0) {
+				cqe_word_mask = ocs_q_hist_cqe_masks[j].mask_err;
+			} else {
+				cqe_word_mask = ocs_q_hist_cqe_masks[j].mask;
+			}
+		}
+	}
+	ocs_lock(&q_hist->q_hist_lock);
+		/* Capture words in reverse order since we'll be interpretting them LIFO */
+		for (i = ((sizeof(cqe_word_mask)*8) - 1); i >= 0; i--){
+			if ((cqe_word_mask >> i) & 1) {
+				q_hist->q_hist[q_hist->q_hist_index] = entryw[i];
+				q_hist->q_hist_index++;
+				q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+			}
+		}
+		ocs_queue_history_add_q_info(q_hist, qid, qindex);
+		ocs_queue_history_add_timestamp(q_hist);
+
+		/* write footer */
+		if (cqe_word_mask) {
+			ftr.s.mask = cqe_word_mask;
+			q_hist->q_hist[q_hist->q_hist_index] = ftr.word;
+			q_hist->q_hist_index++;
+			q_hist->q_hist_index = q_hist->q_hist_index % OCS_Q_HIST_SIZE;
+		}
+
+	ocs_unlock(&q_hist->q_hist_lock);
+}
+
+/**
+ * @brief Get previous index
+ *
+ * @param index Index from which previous index is derived.
+ */
+uint32_t
+ocs_queue_history_prev_index(uint32_t index)
+{
+	if (index == 0) {
+		return OCS_Q_HIST_SIZE - 1;
+	} else {
+		return index - 1;
+	}
+}
+
+#endif /* OCS_DEBUG_QUEUE_HISTORY */
+
+/**
+ * @brief Display service parameters
+ *
+ * <description>
+ *
+ * @param prelabel leading display label
+ * @param reqlabel display label
+ * @param dest destination 0=ocs_log, 1=textbuf
+ * @param textbuf text buffer destination (if dest==1)
+ * @param sparams pointer to service parameter
+ *
+ * @return none
+ */
+
+void
+ocs_display_sparams(const char *prelabel, const char *reqlabel, int dest, void *textbuf, void *sparams)
+{
+	char label[64];
+
+	if (sparams == NULL) {
+		return;
+	}
+
+	switch(dest) {
+	case 0:
+		if (prelabel != NULL) {
+			ocs_snprintf(label, sizeof(label), "[%s] sparam: %s", prelabel, reqlabel);
+		} else {
+			ocs_snprintf(label, sizeof(label), "sparam: %s", reqlabel);
+		}
+
+		ocs_dump32(OCS_DEBUG_ENABLE_SPARAM_DUMP, NULL, label, sparams, sizeof(fc_plogi_payload_t));
+		break;
+	case 1:
+		ocs_ddump_buffer((ocs_textbuf_t*) textbuf, reqlabel, 0, sparams, sizeof(fc_plogi_payload_t));
+		break;
+	}
+}
+
+/**
+ * @brief Calculate the T10 PI CRC guard value for a block.
+ *
+ * @param buffer Pointer to the data buffer.
+ * @param size Number of bytes.
+ * @param crc Previously-calculated CRC, or 0 for a new block.
+ *
+ * @return Returns the calculated CRC, which may be passed back in for partial blocks.
+ *
+ */
+
+uint16_t
+ocs_scsi_dif_calc_crc(const uint8_t *buffer, uint32_t size, uint16_t crc)
+{
+	return t10crc16(buffer, size, crc);
+}
+
+/**
+ * @brief Calculate the IP-checksum guard value for a block.
+ *
+ * @param addrlen array of address length pairs
+ * @param addrlen_count number of entries in the addrlen[] array
+ *
+ * Algorithm:
+ *    Sum all all the 16-byte words in the block
+ *    Add in the "carry", which is everything in excess of 16-bits
+ *    Flip all the bits
+ *
+ * @return Returns the calculated checksum
+ */
+
+uint16_t
+ocs_scsi_dif_calc_checksum(ocs_scsi_vaddr_len_t addrlen[], uint32_t addrlen_count)
+{
+	uint32_t i, j;
+	uint16_t checksum;
+	uint32_t intermediate; /* Use an intermediate to hold more than 16 bits during calculations */
+	uint32_t count;
+	uint16_t *buffer;
+
+	intermediate = 0;
+	for (j = 0; j < addrlen_count; j++) {
+		buffer = addrlen[j].vaddr;
+		count = addrlen[j].length / 2;
+		for (i=0; i < count; i++) {
+			intermediate += buffer[i];
+		}
+	}
+
+	/* Carry is everything over 16 bits */
+	intermediate += ((intermediate & 0xffff0000) >> 16);
+
+	/* Flip all the bits */
+	intermediate = ~intermediate;
+
+	checksum = intermediate;
+
+	return checksum;
+}
+
+/**
+ * @brief Return blocksize given SCSI API DIF block size
+ *
+ * Given the DIF block size enumerated value, return the block size value. (e.g.
+ * OCS_SCSI_DIF_BLK_SIZE_512 returns 512)
+ *
+ * @param dif_info Pointer to SCSI API DIF info block
+ *
+ * @return returns block size, or 0 if SCSI API DIF blocksize is invalid
+ */
+
+uint32_t
+ocs_scsi_dif_blocksize(ocs_scsi_dif_info_t *dif_info)
+{
+	uint32_t blocksize = 0;
+
+	switch(dif_info->blk_size) {
+	case OCS_SCSI_DIF_BK_SIZE_512:	blocksize = 512; break;
+	case OCS_SCSI_DIF_BK_SIZE_1024:	blocksize = 1024; break;
+	case OCS_SCSI_DIF_BK_SIZE_2048:	blocksize = 2048; break;
+	case OCS_SCSI_DIF_BK_SIZE_4096:	blocksize = 4096; break;
+	case OCS_SCSI_DIF_BK_SIZE_520:	blocksize = 520; break;
+	case OCS_SCSI_DIF_BK_SIZE_4104:	blocksize = 4104; break;
+	default:
+		break;
+	}
+
+	return blocksize;
+}
+
+/**
+ * @brief Set SCSI API DIF blocksize
+ *
+ * Given a blocksize value (512, 1024, etc.), set the SCSI API DIF blocksize
+ * in the DIF info block
+ *
+ * @param dif_info Pointer to the SCSI API DIF info block
+ * @param blocksize Block size
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+
+int32_t
+ocs_scsi_dif_set_blocksize(ocs_scsi_dif_info_t *dif_info, uint32_t blocksize)
+{
+	int32_t rc = 0;
+
+	switch(blocksize) {
+	case 512:	dif_info->blk_size = OCS_SCSI_DIF_BK_SIZE_512; break;
+	case 1024:	dif_info->blk_size = OCS_SCSI_DIF_BK_SIZE_1024; break;
+	case 2048:	dif_info->blk_size = OCS_SCSI_DIF_BK_SIZE_2048; break;
+	case 4096:	dif_info->blk_size = OCS_SCSI_DIF_BK_SIZE_4096; break;
+	case 520:	dif_info->blk_size = OCS_SCSI_DIF_BK_SIZE_520; break;
+	case 4104:	dif_info->blk_size = OCS_SCSI_DIF_BK_SIZE_4104; break;
+	default:
+		rc = -1;
+		break;
+	}
+	return rc;
+
+}
+
+/**
+ * @brief Return memory block size given SCSI DIF API
+ *
+ * The blocksize in memory for the DIF transfer is returned, given the SCSI DIF info
+ * block and the direction of transfer.
+ *
+ * @param dif_info Pointer to DIF info block
+ * @param wiretomem Transfer direction, 1 is wire to memory, 0 is memory to wire
+ *
+ * @return Memory blocksize, or negative error value
+ *
+ * WARNING: the order of initialization of the adj[] arrays MUST match the declarations
+ * of OCS_SCSI_DIF_OPER_*
+ */
+
+int32_t
+ocs_scsi_dif_mem_blocksize(ocs_scsi_dif_info_t *dif_info, int wiretomem)
+{
+	uint32_t blocksize;
+	uint8_t wiretomem_adj[] = {
+		0,		/* OCS_SCSI_DIF_OPER_DISABLED, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CRC, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_SCSI_DIF_OPER_IN_RAW_OUT_RAW, */
+	uint8_t memtowire_adj[] = {
+		0,		/* OCS_SCSI_DIF_OPER_DISABLED, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CRC, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_NODIF, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_SCSI_DIF_OPER_IN_RAW_OUT_RAW, */
+
+	blocksize = ocs_scsi_dif_blocksize(dif_info);
+	if (blocksize == 0) {
+		return -1;
+	}
+
+	if (wiretomem) {
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(wiretomem_adj), 0);
+		blocksize += wiretomem_adj[dif_info->dif_oper];
+	} else {	/* mem to wire */
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(memtowire_adj), 0);
+		blocksize += memtowire_adj[dif_info->dif_oper];
+	}
+	return blocksize;
+}
+
+/**
+ * @brief Return wire block size given SCSI DIF API
+ *
+ * The blocksize on the wire for the DIF transfer is returned, given the SCSI DIF info
+ * block and the direction of transfer.
+ *
+ * @param dif_info Pointer to DIF info block
+ * @param wiretomem Transfer direction, 1 is wire to memory, 0 is memory to wire
+ *
+ * @return Wire blocksize or negative error value
+ *
+ * WARNING: the order of initialization of the adj[] arrays MUST match the declarations
+ * of OCS_SCSI_DIF_OPER_*
+ */
+
+int32_t
+ocs_scsi_dif_wire_blocksize(ocs_scsi_dif_info_t *dif_info, int wiretomem)
+{
+	uint32_t blocksize;
+	uint8_t wiretomem_adj[] = {
+		0,		/* OCS_SCSI_DIF_OPER_DISABLED, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CRC, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_NODIF, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_SCSI_DIF_OPER_IN_RAW_OUT_RAW, */
+	uint8_t memtowire_adj[] = {
+		0,		/* OCS_SCSI_DIF_OPER_DISABLED, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CRC, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		0,		/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_SCSI_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_SCSI_DIF_OPER_IN_RAW_OUT_RAW, */
+
+
+	blocksize = ocs_scsi_dif_blocksize(dif_info);
+	if (blocksize == 0) {
+		return -1;
+	}
+
+	if (wiretomem) {
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(wiretomem_adj), 0);
+		blocksize += wiretomem_adj[dif_info->dif_oper];
+	} else {	/* mem to wire */
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(memtowire_adj), 0);
+		blocksize += memtowire_adj[dif_info->dif_oper];
+	}
+
+	return blocksize;
+}
+/**
+ * @brief Return blocksize given HW API DIF block size
+ *
+ * Given the DIF block size enumerated value, return the block size value. (e.g.
+ * OCS_SCSI_DIF_BLK_SIZE_512 returns 512)
+ *
+ * @param dif_info Pointer to HW API DIF info block
+ *
+ * @return returns block size, or 0 if HW API DIF blocksize is invalid
+ */
+
+uint32_t
+ocs_hw_dif_blocksize(ocs_hw_dif_info_t *dif_info)
+{
+	uint32_t blocksize = 0;
+
+	switch(dif_info->blk_size) {
+	case OCS_HW_DIF_BK_SIZE_512:	blocksize = 512; break;
+	case OCS_HW_DIF_BK_SIZE_1024:	blocksize = 1024; break;
+	case OCS_HW_DIF_BK_SIZE_2048:	blocksize = 2048; break;
+	case OCS_HW_DIF_BK_SIZE_4096:	blocksize = 4096; break;
+	case OCS_HW_DIF_BK_SIZE_520:	blocksize = 520; break;
+	case OCS_HW_DIF_BK_SIZE_4104:	blocksize = 4104; break;
+	default:
+		break;
+	}
+
+	return blocksize;
+}
+
+/**
+ * @brief Return memory block size given HW DIF API
+ *
+ * The blocksize in memory for the DIF transfer is returned, given the HW DIF info
+ * block and the direction of transfer.
+ *
+ * @param dif_info Pointer to DIF info block
+ * @param wiretomem Transfer direction, 1 is wire to memory, 0 is memory to wire
+ *
+ * @return Memory blocksize, or negative error value
+ *
+ * WARNING: the order of initialization of the adj[] arrays MUST match the declarations
+ * of OCS_HW_DIF_OPER_*
+ */
+
+int32_t
+ocs_hw_dif_mem_blocksize(ocs_hw_dif_info_t *dif_info, int wiretomem)
+{
+	uint32_t blocksize;
+	uint8_t wiretomem_adj[] = {
+		0,		/* OCS_HW_DIF_OPER_DISABLED, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CRC, */
+		0,		/* OCS_HW_DIF_OPER_IN_CRC_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		0,		/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_HW_DIF_OPER_IN_RAW_OUT_RAW, */
+	uint8_t memtowire_adj[] = {
+		0,		/* OCS_HW_DIF_OPER_DISABLED, */
+		0,		/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CRC, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_NODIF, */
+		0,		/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_HW_DIF_OPER_IN_RAW_OUT_RAW, */
+
+	blocksize = ocs_hw_dif_blocksize(dif_info);
+	if (blocksize == 0) {
+		return -1;
+	}
+
+	if (wiretomem) {
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(wiretomem_adj), 0);
+		blocksize += wiretomem_adj[dif_info->dif_oper];
+	} else {	/* mem to wire */
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(memtowire_adj), 0);
+		blocksize += memtowire_adj[dif_info->dif_oper];
+	}
+	return blocksize;
+}
+
+/**
+ * @brief Return wire block size given HW DIF API
+ *
+ * The blocksize on the wire for the DIF transfer is returned, given the HW DIF info
+ * block and the direction of transfer.
+ *
+ * @param dif_info Pointer to DIF info block
+ * @param wiretomem Transfer direction, 1 is wire to memory, 0 is memory to wire
+ *
+ * @return Wire blocksize or negative error value
+ *
+ * WARNING: the order of initialization of the adj[] arrays MUST match the declarations
+ * of OCS_HW_DIF_OPER_*
+ */
+
+int32_t
+ocs_hw_dif_wire_blocksize(ocs_hw_dif_info_t *dif_info, int wiretomem)
+{
+	uint32_t blocksize;
+	uint8_t wiretomem_adj[] = {
+		0,		/* OCS_HW_DIF_OPER_DISABLED, */
+		0,		/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CRC, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_NODIF, */
+		0,		/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_HW_DIF_OPER_IN_RAW_OUT_RAW, */
+	uint8_t memtowire_adj[] = {
+		0,		/* OCS_HW_DIF_OPER_DISABLED, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CRC, */
+		0,		/* OCS_HW_DIF_OPER_IN_CRC_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_NODIF_OUT_CHKSUM, */
+		0,		/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_NODIF, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CRC, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CRC_OUT_CHKSUM, */
+		DIF_SIZE,	/* OCS_HW_DIF_OPER_IN_CHKSUM_OUT_CRC, */
+		DIF_SIZE};	/* OCS_HW_DIF_OPER_IN_RAW_OUT_RAW, */
+
+
+	blocksize = ocs_hw_dif_blocksize(dif_info);
+	if (blocksize == 0) {
+		return -1;
+	}
+
+	if (wiretomem) {
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(wiretomem_adj), 0);
+		blocksize += wiretomem_adj[dif_info->dif_oper];
+	} else {	/* mem to wire */
+		ocs_assert(dif_info->dif_oper < ARRAY_SIZE(memtowire_adj), 0);
+		blocksize += memtowire_adj[dif_info->dif_oper];
+	}
+
+	return blocksize;
+}
+
+static int32_t ocs_segment_remaining(ocs_textbuf_segment_t *segment);
+static ocs_textbuf_segment_t *ocs_textbuf_segment_alloc(ocs_textbuf_t *textbuf);
+static void ocs_textbuf_segment_free(ocs_t *ocs, ocs_textbuf_segment_t *segment);
+static ocs_textbuf_segment_t *ocs_textbuf_get_segment(ocs_textbuf_t *textbuf, uint32_t idx);
+
+uint8_t *
+ocs_textbuf_get_buffer(ocs_textbuf_t *textbuf)
+{
+	return ocs_textbuf_ext_get_buffer(textbuf, 0);
+}
+
+int32_t
+ocs_textbuf_get_length(ocs_textbuf_t *textbuf)
+{
+	return ocs_textbuf_ext_get_length(textbuf, 0);
+}
+
+int32_t
+ocs_textbuf_get_written(ocs_textbuf_t *textbuf)
+{
+	uint32_t idx;
+	int32_t n;
+	int32_t total = 0;
+
+	for (idx = 0; (n = ocs_textbuf_ext_get_written(textbuf, idx)) >= 0; idx++) {
+		total += n;
+	}
+	return total;
+}
+
+uint8_t *ocs_textbuf_ext_get_buffer(ocs_textbuf_t *textbuf, uint32_t idx)
+{
+	ocs_textbuf_segment_t *segment = ocs_textbuf_get_segment(textbuf, idx);
+	if (segment == NULL) {
+		return NULL;
+	}
+	return segment->buffer;
+}
+
+int32_t ocs_textbuf_ext_get_length(ocs_textbuf_t *textbuf, uint32_t idx)
+{
+	ocs_textbuf_segment_t *segment = ocs_textbuf_get_segment(textbuf, idx);
+	if (segment == NULL) {
+		return -1;
+	}
+	return segment->buffer_length;
+}
+
+int32_t ocs_textbuf_ext_get_written(ocs_textbuf_t *textbuf, uint32_t idx)
+{
+	ocs_textbuf_segment_t *segment = ocs_textbuf_get_segment(textbuf, idx);
+	if (segment == NULL) {
+		return -1;
+	}
+	return segment->buffer_written;
+}
+
+uint32_t
+ocs_textbuf_initialized(ocs_textbuf_t *textbuf)
+{
+	return (textbuf->ocs != NULL);
+}
+
+int32_t
+ocs_textbuf_alloc(ocs_t *ocs, ocs_textbuf_t *textbuf, uint32_t length)
+{
+	ocs_memset(textbuf, 0, sizeof(*textbuf));
+
+	textbuf->ocs = ocs;
+	ocs_list_init(&textbuf->segment_list, ocs_textbuf_segment_t, link);
+
+	if (length > OCS_TEXTBUF_MAX_ALLOC_LEN) {
+		textbuf->allocation_length = OCS_TEXTBUF_MAX_ALLOC_LEN;
+	} else {
+		textbuf->allocation_length = length;
+	}
+
+	/* mark as extendable */
+	textbuf->extendable = TRUE;
+
+	/* save maximum allocation length */
+	textbuf->max_allocation_length = length;
+
+	/* Add first segment */
+	return (ocs_textbuf_segment_alloc(textbuf) == NULL) ? -1 : 0;
+}
+
+static ocs_textbuf_segment_t *
+ocs_textbuf_segment_alloc(ocs_textbuf_t *textbuf)
+{
+	ocs_textbuf_segment_t *segment = NULL;
+
+	if (textbuf->extendable) {
+		segment = ocs_malloc(textbuf->ocs, sizeof(*segment), OCS_M_ZERO | OCS_M_NOWAIT);
+		if (segment != NULL) {
+			segment->buffer = ocs_malloc(textbuf->ocs, textbuf->allocation_length, OCS_M_ZERO | OCS_M_NOWAIT);
+			if (segment->buffer != NULL) {
+				segment->buffer_length = textbuf->allocation_length;
+				segment->buffer_written = 0;
+				ocs_list_add_tail(&textbuf->segment_list, segment);
+				textbuf->total_allocation_length += textbuf->allocation_length;
+
+				/* If we've allocated our limit, then mark as not extendable */
+				if (textbuf->total_allocation_length >= textbuf->max_allocation_length) {
+					textbuf->extendable = 0;
+				}
+
+			} else {
+				ocs_textbuf_segment_free(textbuf->ocs, segment);
+				segment = NULL;
+			}
+		}
+	}
+	return segment;
+}
+
+static void
+ocs_textbuf_segment_free(ocs_t *ocs, ocs_textbuf_segment_t *segment)
+{
+	if (segment) {
+		if (segment->buffer && !segment->user_allocated) {
+			ocs_free(ocs, segment->buffer, segment->buffer_length);
+		}
+		ocs_free(ocs, segment, sizeof(*segment));
+	}
+}
+
+static ocs_textbuf_segment_t *
+ocs_textbuf_get_segment(ocs_textbuf_t *textbuf, uint32_t idx)
+{
+	uint32_t i;
+	ocs_textbuf_segment_t *segment;
+
+	if (ocs_textbuf_initialized(textbuf)) {
+		i = 0;
+		ocs_list_foreach(&textbuf->segment_list, segment) {
+			if (i == idx) {
+				return segment;
+			}
+			i++;
+		}
+	}
+	return NULL;
+}
+
+int32_t
+ocs_textbuf_init(ocs_t *ocs, ocs_textbuf_t *textbuf, void *buffer, uint32_t length)
+{
+	int32_t rc = -1;
+	ocs_textbuf_segment_t *segment;
+
+	ocs_memset(textbuf, 0, sizeof(*textbuf));
+
+	textbuf->ocs = ocs;
+	ocs_list_init(&textbuf->segment_list, ocs_textbuf_segment_t, link);
+	segment = ocs_malloc(ocs, sizeof(*segment), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (segment) {
+		segment->buffer = buffer;
+		segment->buffer_length = length;
+		segment->buffer_written = 0;
+		segment->user_allocated = 1;
+		ocs_list_add_tail(&textbuf->segment_list, segment);
+		rc = 0;
+	}
+
+	return rc;
+}
+
+void
+ocs_textbuf_free(ocs_t *ocs, ocs_textbuf_t *textbuf)
+{
+	ocs_textbuf_segment_t *segment;
+	ocs_textbuf_segment_t *n;
+
+	if (ocs_textbuf_initialized(textbuf)) {
+		ocs_list_foreach_safe(&textbuf->segment_list, segment, n) {
+			ocs_list_remove(&textbuf->segment_list, segment);
+			ocs_textbuf_segment_free(ocs, segment);
+		}
+
+		ocs_memset(textbuf, 0, sizeof(*textbuf));
+	}
+}
+
+void
+ocs_textbuf_printf(ocs_textbuf_t *textbuf, const char *fmt, ...)
+{
+	va_list ap;
+
+	if (ocs_textbuf_initialized(textbuf)) {
+		va_start(ap, fmt);
+		ocs_textbuf_vprintf(textbuf, fmt, ap);
+		va_end(ap);
+	}
+}
+
+void
+ocs_textbuf_vprintf(ocs_textbuf_t *textbuf, const char *fmt, va_list ap)
+{
+	int avail;
+	int written;
+	ocs_textbuf_segment_t *segment;
+	va_list save_ap;
+
+	if (!ocs_textbuf_initialized(textbuf)) {
+		return;
+	}
+
+	va_copy(save_ap, ap);
+
+	/* fetch last segment */
+	segment = ocs_list_get_tail(&textbuf->segment_list);
+
+	avail = ocs_segment_remaining(segment);
+	if (avail == 0) {
+		if ((segment = ocs_textbuf_segment_alloc(textbuf)) == NULL) {
+			goto out;
+		}
+		avail = ocs_segment_remaining(segment);
+	}
+
+	written = ocs_vsnprintf(segment->buffer + segment->buffer_written, avail, fmt, ap);
+
+	/* See if data was truncated */
+	if (written >= avail) {
+
+		written = avail;
+
+		if (textbuf->extendable) {
+
+			/* revert the partially written data */
+			*(segment->buffer + segment->buffer_written) = 0;
+
+			/* Allocate a new segment */
+			if ((segment = ocs_textbuf_segment_alloc(textbuf)) == NULL) {
+				ocs_log_err(textbuf->ocs, "alloc segment failed\n");
+				goto out;
+			}
+			avail = ocs_segment_remaining(segment);
+
+			/* Retry the write */
+			written = ocs_vsnprintf(segment->buffer + segment->buffer_written, avail, fmt, save_ap);
+		}
+	}
+	segment->buffer_written += written;
+
+out:
+	va_end(save_ap);
+}
+
+void
+ocs_textbuf_putc(ocs_textbuf_t *textbuf, uint8_t c)
+{
+	ocs_textbuf_segment_t *segment;
+
+	if (ocs_textbuf_initialized(textbuf)) {
+		segment = ocs_list_get_tail(&textbuf->segment_list);
+
+		if (ocs_segment_remaining(segment)) {
+			*(segment->buffer + segment->buffer_written++) = c;
+		}
+		if (ocs_segment_remaining(segment) == 0) {
+			ocs_textbuf_segment_alloc(textbuf);
+		}
+	}
+}
+
+void
+ocs_textbuf_puts(ocs_textbuf_t *textbuf, char *s)
+{
+	if (ocs_textbuf_initialized(textbuf)) {
+		while(*s) {
+			ocs_textbuf_putc(textbuf, *s++);
+		}
+	}
+}
+
+void
+ocs_textbuf_buffer(ocs_textbuf_t *textbuf, uint8_t *buffer, uint32_t buffer_length)
+{
+	char *s;
+
+	if (!ocs_textbuf_initialized(textbuf)) {
+		return;
+	}
+
+	s = (char*) buffer;
+	while(*s) {
+
+		/*
+		 * XML escapes
+		 *
+		 * "   &quot;
+		 * '   &apos;
+		 * <   &lt;
+		 * >   &gt;
+		 * &   &amp;
+		 */
+
+		switch(*s) {
+		case '"':	ocs_textbuf_puts(textbuf, "&quot;"); break;
+		case '\'':	ocs_textbuf_puts(textbuf, "&apos;"); break;
+		case '<':	ocs_textbuf_puts(textbuf, "&lt;"); break;
+		case '>':	ocs_textbuf_puts(textbuf, "&gt;"); break;
+		case '&':	ocs_textbuf_puts(textbuf, "&amp;"); break;
+		default:	ocs_textbuf_putc(textbuf, *s); break;
+		}
+		s++;
+	}
+
+}
+
+void
+ocs_textbuf_copy(ocs_textbuf_t *textbuf, uint8_t *buffer, uint32_t buffer_length)
+{
+	char *s;
+
+	if (!ocs_textbuf_initialized(textbuf)) {
+		return;
+	}
+
+	s = (char*) buffer;
+	while(*s) {
+		ocs_textbuf_putc(textbuf, *s++);
+	}
+
+}
+
+int32_t
+ocs_textbuf_remaining(ocs_textbuf_t *textbuf)
+{
+	if (ocs_textbuf_initialized(textbuf)) {
+		return ocs_segment_remaining(ocs_list_get_head(&textbuf->segment_list));
+	} else {
+		return 0;
+	}
+}
+
+static int32_t
+ocs_segment_remaining(ocs_textbuf_segment_t *segment)
+{
+	return segment->buffer_length - segment->buffer_written;
+}
+
+void
+ocs_textbuf_reset(ocs_textbuf_t *textbuf)
+{
+	uint32_t i = 0;
+	ocs_textbuf_segment_t *segment;
+	ocs_textbuf_segment_t *n;
+
+	if (ocs_textbuf_initialized(textbuf)) {
+		/* zero written on the first segment, free the rest */
+		ocs_list_foreach_safe(&textbuf->segment_list, segment, n) {
+			if (i++ == 0) {
+				segment->buffer_written = 0;
+			} else {
+				ocs_list_remove(&textbuf->segment_list, segment);
+				ocs_textbuf_segment_free(textbuf->ocs, segment);
+			}
+		}
+	}
+}
+
+/**
+ * @brief Sparse Vector API.
+ *
+ * This is a trimmed down sparse vector implementation tuned to the problem of
+ * 24-bit FC_IDs. In this case, the 24-bit index value is broken down in three
+ * 8-bit values. These values are used to index up to three 256 element arrays.
+ * Arrays are allocated, only when needed. @n @n
+ * The lookup can complete in constant time (3 indexed array references). @n @n
+ * A typical use case would be that the fabric/directory FC_IDs would cause two rows to be
+ * allocated, and the fabric assigned remote nodes would cause two rows to be allocated, with
+ * the root row always allocated. This gives five rows of 256 x sizeof(void*),
+ * resulting in 10k.
+ */
+
+
+
+/**
+ * @ingroup spv
+ * @brief Allocate a new sparse vector row.
+ *
+ * @param os OS handle
+ * @param rowcount Count of rows.
+ *
+ * @par Description
+ * A new sparse vector row is allocated.
+ *
+ * @param rowcount Number of elements in a row.
+ *
+ * @return Returns the pointer to a row.
+ */
+static void
+**spv_new_row(ocs_os_handle_t os, uint32_t rowcount)
+{
+	return ocs_malloc(os, sizeof(void*) * rowcount, OCS_M_ZERO | OCS_M_NOWAIT);
+}
+
+
+
+/**
+ * @ingroup spv
+ * @brief Delete row recursively.
+ *
+ * @par Description
+ * This function recursively deletes the rows in this sparse vector
+ *
+ * @param os OS handle
+ * @param a Pointer to the row.
+ * @param n Number of elements in the row.
+ * @param depth Depth of deleting.
+ *
+ * @return None.
+ */
+static void
+_spv_del(ocs_os_handle_t os, void **a, uint32_t n, uint32_t depth)
+{
+	if (a) {
+		if (depth) {
+			uint32_t i;
+
+			for (i = 0; i < n; i ++) {
+				_spv_del(os, a[i], n, depth-1);
+			}
+
+			ocs_free(os, a, SPV_ROWLEN*sizeof(*a));
+		}
+	}
+}
+
+/**
+ * @ingroup spv
+ * @brief Delete a sparse vector.
+ *
+ * @par Description
+ * The sparse vector is freed.
+ *
+ * @param spv Pointer to the sparse vector object.
+ */
+void
+spv_del(sparse_vector_t spv)
+{
+	if (spv) {
+		_spv_del(spv->os, spv->array, SPV_ROWLEN, SPV_DIM);
+		ocs_free(spv->os, spv, sizeof(*spv));
+	}
+}
+
+/**
+ * @ingroup spv
+ * @brief Instantiate a new sparse vector object.
+ *
+ * @par Description
+ * A new sparse vector is allocated.
+ *
+ * @param os OS handle
+ *
+ * @return Returns the pointer to the sparse vector, or NULL.
+ */
+sparse_vector_t
+spv_new(ocs_os_handle_t os)
+{
+	sparse_vector_t spv;
+	uint32_t i;
+
+	spv = ocs_malloc(os, sizeof(*spv), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (!spv) {
+		return NULL;
+	}
+
+	spv->os = os;
+	spv->max_idx = 1;
+	for (i = 0; i < SPV_DIM; i ++) {
+		spv->max_idx *= SPV_ROWLEN;
+	}
+
+	return spv;
+}
+
+/**
+ * @ingroup spv
+ * @brief Return the address of a cell.
+ *
+ * @par Description
+ * Returns the address of a cell, allocates sparse rows as needed if the
+ *         alloc_new_rows parameter is set.
+ *
+ * @param sv Pointer to the sparse vector.
+ * @param idx Index of which to return the address.
+ * @param alloc_new_rows If TRUE, then new rows may be allocated to set values,
+ *                       Set to FALSE for retrieving values.
+ *
+ * @return Returns the pointer to the cell, or NULL.
+ */
+static void
+*spv_new_cell(sparse_vector_t sv, uint32_t idx, uint8_t alloc_new_rows)
+{
+	uint32_t a = (idx >> 16) & 0xff;
+	uint32_t b = (idx >>  8) & 0xff;
+	uint32_t c = (idx >>  0) & 0xff;
+	void **p;
+
+	if (idx >= sv->max_idx) {
+		return NULL;
+	}
+
+	if (sv->array == NULL) {
+		sv->array = (alloc_new_rows ? spv_new_row(sv->os, SPV_ROWLEN) : NULL);
+		if (sv->array == NULL) {
+			return NULL;
+		}
+	}
+	p = sv->array;
+	if (p[a] == NULL) {
+		p[a] = (alloc_new_rows ? spv_new_row(sv->os, SPV_ROWLEN) : NULL);
+		if (p[a] == NULL) {
+			return NULL;
+		}
+	}
+	p = p[a];
+	if (p[b] == NULL) {
+		p[b] = (alloc_new_rows ? spv_new_row(sv->os, SPV_ROWLEN) : NULL);
+		if (p[b] == NULL) {
+			return NULL;
+		}
+	}
+	p = p[b];
+
+	return &p[c];
+}
+
+/**
+ * @ingroup spv
+ * @brief Set the sparse vector cell value.
+ *
+ * @par Description
+ * Sets the sparse vector at @c idx to @c value.
+ *
+ * @param sv Pointer to the sparse vector.
+ * @param idx Index of which to store.
+ * @param value Value to store.
+ *
+ * @return None.
+ */
+void
+spv_set(sparse_vector_t sv, uint32_t idx, void *value)
+{
+	void **ref = spv_new_cell(sv, idx, TRUE);
+	if (ref) {
+		*ref = value;
+	}
+}
+
+/**
+ * @ingroup spv
+ * @brief Return the sparse vector cell value.
+ *
+ * @par Description
+ * Returns the value at @c idx.
+ *
+ * @param sv Pointer to the sparse vector.
+ * @param idx Index of which to return the value.
+ *
+ * @return Returns the cell value, or NULL.
+ */
+void
+*spv_get(sparse_vector_t sv, uint32_t idx)
+{
+	void **ref = spv_new_cell(sv, idx, FALSE);
+	if (ref) {
+		return *ref;
+	}
+	return NULL;
+}
+
+/*****************************************************************/
+/*                                                               */
+/* CRC LOOKUP TABLE                                              */
+/* ================                                              */
+/* The following CRC lookup table was generated automagically    */
+/* by the Rocksoft^tm Model CRC Algorithm Table Generation       */
+/* Program V1.0 using the following model parameters:            */
+/*                                                               */
+/*    Width   : 2 bytes.                                         */
+/*    Poly    : 0x8BB7                                           */
+/*    Reverse : FALSE.                                           */
+/*                                                               */
+/* For more information on the Rocksoft^tm Model CRC Algorithm,  */
+/* see the document titled "A Painless Guide to CRC Error        */
+/* Detection Algorithms" by Ross Williams                        */
+/* (ross@guest.adelaide.edu.au.). This document is likely to be  */
+/* in the FTP archive "ftp.adelaide.edu.au/pub/rocksoft".        */
+/*                                                               */
+/*****************************************************************/
+/*
+ * Emulex Inc, changes:
+ * - minor syntax changes for successful compilation with contemporary
+ *   C compilers, and OCS SDK API
+ * - crctable[] generated using Rocksoft public domain code
+ *
+ * Used in the Emulex SDK, the generated file crctable.out is cut and pasted into
+ * applicable SDK sources.
+ */
+
+
+static unsigned short crctable[256] =
+{
+ 0x0000, 0x8BB7, 0x9CD9, 0x176E, 0xB205, 0x39B2, 0x2EDC, 0xA56B,
+ 0xEFBD, 0x640A, 0x7364, 0xF8D3, 0x5DB8, 0xD60F, 0xC161, 0x4AD6,
+ 0x54CD, 0xDF7A, 0xC814, 0x43A3, 0xE6C8, 0x6D7F, 0x7A11, 0xF1A6,
+ 0xBB70, 0x30C7, 0x27A9, 0xAC1E, 0x0975, 0x82C2, 0x95AC, 0x1E1B,
+ 0xA99A, 0x222D, 0x3543, 0xBEF4, 0x1B9F, 0x9028, 0x8746, 0x0CF1,
+ 0x4627, 0xCD90, 0xDAFE, 0x5149, 0xF422, 0x7F95, 0x68FB, 0xE34C,
+ 0xFD57, 0x76E0, 0x618E, 0xEA39, 0x4F52, 0xC4E5, 0xD38B, 0x583C,
+ 0x12EA, 0x995D, 0x8E33, 0x0584, 0xA0EF, 0x2B58, 0x3C36, 0xB781,
+ 0xD883, 0x5334, 0x445A, 0xCFED, 0x6A86, 0xE131, 0xF65F, 0x7DE8,
+ 0x373E, 0xBC89, 0xABE7, 0x2050, 0x853B, 0x0E8C, 0x19E2, 0x9255,
+ 0x8C4E, 0x07F9, 0x1097, 0x9B20, 0x3E4B, 0xB5FC, 0xA292, 0x2925,
+ 0x63F3, 0xE844, 0xFF2A, 0x749D, 0xD1F6, 0x5A41, 0x4D2F, 0xC698,
+ 0x7119, 0xFAAE, 0xEDC0, 0x6677, 0xC31C, 0x48AB, 0x5FC5, 0xD472,
+ 0x9EA4, 0x1513, 0x027D, 0x89CA, 0x2CA1, 0xA716, 0xB078, 0x3BCF,
+ 0x25D4, 0xAE63, 0xB90D, 0x32BA, 0x97D1, 0x1C66, 0x0B08, 0x80BF,
+ 0xCA69, 0x41DE, 0x56B0, 0xDD07, 0x786C, 0xF3DB, 0xE4B5, 0x6F02,
+ 0x3AB1, 0xB106, 0xA668, 0x2DDF, 0x88B4, 0x0303, 0x146D, 0x9FDA,
+ 0xD50C, 0x5EBB, 0x49D5, 0xC262, 0x6709, 0xECBE, 0xFBD0, 0x7067,
+ 0x6E7C, 0xE5CB, 0xF2A5, 0x7912, 0xDC79, 0x57CE, 0x40A0, 0xCB17,
+ 0x81C1, 0x0A76, 0x1D18, 0x96AF, 0x33C4, 0xB873, 0xAF1D, 0x24AA,
+ 0x932B, 0x189C, 0x0FF2, 0x8445, 0x212E, 0xAA99, 0xBDF7, 0x3640,
+ 0x7C96, 0xF721, 0xE04F, 0x6BF8, 0xCE93, 0x4524, 0x524A, 0xD9FD,
+ 0xC7E6, 0x4C51, 0x5B3F, 0xD088, 0x75E3, 0xFE54, 0xE93A, 0x628D,
+ 0x285B, 0xA3EC, 0xB482, 0x3F35, 0x9A5E, 0x11E9, 0x0687, 0x8D30,
+ 0xE232, 0x6985, 0x7EEB, 0xF55C, 0x5037, 0xDB80, 0xCCEE, 0x4759,
+ 0x0D8F, 0x8638, 0x9156, 0x1AE1, 0xBF8A, 0x343D, 0x2353, 0xA8E4,
+ 0xB6FF, 0x3D48, 0x2A26, 0xA191, 0x04FA, 0x8F4D, 0x9823, 0x1394,
+ 0x5942, 0xD2F5, 0xC59B, 0x4E2C, 0xEB47, 0x60F0, 0x779E, 0xFC29,
+ 0x4BA8, 0xC01F, 0xD771, 0x5CC6, 0xF9AD, 0x721A, 0x6574, 0xEEC3,
+ 0xA415, 0x2FA2, 0x38CC, 0xB37B, 0x1610, 0x9DA7, 0x8AC9, 0x017E,
+ 0x1F65, 0x94D2, 0x83BC, 0x080B, 0xAD60, 0x26D7, 0x31B9, 0xBA0E,
+ 0xF0D8, 0x7B6F, 0x6C01, 0xE7B6, 0x42DD, 0xC96A, 0xDE04, 0x55B3
+};
+
+/*****************************************************************/
+/*                   End of CRC Lookup Table                     */
+/*****************************************************************/
+
+/**
+ * @brief Calculate the T10 PI CRC guard value for a block.
+ *
+ * Code based on Rocksoft's public domain CRC code, refer to
+ * http://www.ross.net/crc/download/crc_v3.txt.  Minimally altered
+ * to work with the ocs_dif API.
+ *
+ * @param blk_adr Pointer to the data buffer.
+ * @param blk_len Number of bytes.
+ * @param crc Previously-calculated CRC, or crcseed for a new block.
+ *
+ * @return Returns the calculated CRC, which may be passed back in for partial blocks.
+ *
+ */
+
+unsigned short
+t10crc16(const unsigned char *blk_adr, unsigned long blk_len, unsigned short crc)
+{
+	if (blk_len > 0) {
+		while (blk_len--) {
+			crc = crctable[((crc>>8) ^ *blk_adr++) & 0xFFL] ^ (crc << 8);
+		}
+	}
+	return crc;
+}
+
+struct ocs_ramlog_s {
+	uint32_t initialized;
+	uint32_t textbuf_count;
+	uint32_t textbuf_base;
+	ocs_textbuf_t *textbufs;
+	uint32_t cur_textbuf_idx;
+	ocs_textbuf_t *cur_textbuf;
+	ocs_lock_t lock;
+};
+
+static uint32_t ocs_ramlog_next_idx(ocs_ramlog_t *ramlog, uint32_t idx);
+
+/**
+ * @brief Allocate a ramlog buffer.
+ *
+ * Initialize a RAM logging buffer with text buffers totalling buffer_len.
+ *
+ * @param ocs Pointer to driver structure.
+ * @param buffer_len Total length of RAM log buffers.
+ * @param buffer_count Number of text buffers to allocate (totalling buffer-len).
+ *
+ * @return Returns pointer to ocs_ramlog_t instance, or NULL.
+ */
+ocs_ramlog_t *
+ocs_ramlog_init(ocs_t *ocs, uint32_t buffer_len, uint32_t buffer_count)
+{
+	uint32_t i;
+	uint32_t rc;
+	ocs_ramlog_t *ramlog;
+
+	ramlog = ocs_malloc(ocs, sizeof(*ramlog), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (ramlog == NULL) {
+		ocs_log_err(ocs, "ocs_malloc ramlog failed\n");
+		return NULL;
+	}
+
+	ramlog->textbuf_count = buffer_count;
+
+	ramlog->textbufs = ocs_malloc(ocs, sizeof(*ramlog->textbufs)*buffer_count, OCS_M_ZERO | OCS_M_NOWAIT);
+	if (ramlog->textbufs == NULL) {
+		ocs_log_err(ocs, "ocs_malloc textbufs failed\n");
+		ocs_ramlog_free(ocs, ramlog);
+		return NULL;
+	}
+
+	for (i = 0; i < buffer_count; i ++) {
+		rc = ocs_textbuf_alloc(ocs, &ramlog->textbufs[i], buffer_len);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_textbuf_alloc failed\n");
+			ocs_ramlog_free(ocs, ramlog);
+			return NULL;
+		}
+	}
+
+	ramlog->cur_textbuf_idx = 0;
+	ramlog->textbuf_base = 1;
+	ramlog->cur_textbuf = &ramlog->textbufs[0];
+	ramlog->initialized = TRUE;
+	ocs_lock_init(ocs, &ramlog->lock, "ramlog_lock[%d]", ocs_instance(ocs));
+	return ramlog;
+}
+
+/**
+ * @brief Free a ramlog buffer.
+ *
+ * A previously allocated RAM logging buffer is freed.
+ *
+ * @param ocs Pointer to driver structure.
+ * @param ramlog Pointer to RAM logging buffer structure.
+ *
+ * @return None.
+ */
+
+void
+ocs_ramlog_free(ocs_t *ocs, ocs_ramlog_t *ramlog)
+{
+	uint32_t i;
+
+	if (ramlog != NULL) {
+		ocs_lock_free(&ramlog->lock);
+		if (ramlog->textbufs) {
+			for (i = 0; i < ramlog->textbuf_count; i ++) {
+				ocs_textbuf_free(ocs, &ramlog->textbufs[i]);
+			}
+
+			ocs_free(ocs, ramlog->textbufs, ramlog->textbuf_count*sizeof(*ramlog->textbufs));
+			ramlog->textbufs = NULL;
+		}
+		ocs_free(ocs, ramlog, sizeof(*ramlog));
+	}
+}
+
+/**
+ * @brief Clear a ramlog buffer.
+ *
+ * The text in the start of day and/or recent ramlog text buffers is cleared.
+ *
+ * @param ocs Pointer to driver structure.
+ * @param ramlog Pointer to RAM logging buffer structure.
+ * @param clear_start_of_day Clear the start of day (driver init) portion of the ramlog.
+ * @param clear_recent Clear the recent messages portion of the ramlog.
+ *
+ * @return None.
+ */
+
+void
+ocs_ramlog_clear(ocs_t *ocs, ocs_ramlog_t *ramlog, int clear_start_of_day, int clear_recent)
+{
+	uint32_t i;
+
+	if (clear_recent) {
+		for (i = ramlog->textbuf_base; i < ramlog->textbuf_count; i ++) {
+			ocs_textbuf_reset(&ramlog->textbufs[i]);
+		}
+		ramlog->cur_textbuf_idx = 1;
+	}
+	if (clear_start_of_day && ramlog->textbuf_base) {
+		ocs_textbuf_reset(&ramlog->textbufs[0]);
+		/* Set textbuf_base to 0, so that all buffers are available for
+		 * recent logs
+		 */
+		ramlog->textbuf_base = 0;
+	}
+}
+
+/**
+ * @brief Append formatted printf data to a ramlog buffer.
+ *
+ * Formatted data is appended to a RAM logging buffer.
+ *
+ * @param os Pointer to driver structure.
+ * @param fmt Pointer to printf style format specifier.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+int32_t
+ocs_ramlog_printf(void *os, const char *fmt, ...)
+{
+	ocs_t *ocs = os;
+	va_list ap;
+	int32_t res;
+
+	if (ocs == NULL || ocs->ramlog == NULL) {
+		return -1;
+	}
+
+	va_start(ap, fmt);
+	res = ocs_ramlog_vprintf(ocs->ramlog, fmt, ap);
+	va_end(ap);
+
+	return res;
+}
+
+/**
+ * @brief Append formatted text to a ramlog using variable arguments.
+ *
+ * Formatted data is appended to the RAM logging buffer, using variable arguments.
+ *
+ * @param ramlog Pointer to RAM logging buffer.
+ * @param fmt Pointer to printf style formatting string.
+ * @param ap Variable argument pointer.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+int32_t
+ocs_ramlog_vprintf(ocs_ramlog_t *ramlog, const char *fmt, va_list ap)
+{
+	if (ramlog == NULL || !ramlog->initialized) {
+		return -1;
+	}
+
+	/* check the current text buffer, if it is almost full (less than 120 characaters), then
+	 * roll to the next one.
+	 */
+	ocs_lock(&ramlog->lock);
+	if (ocs_textbuf_remaining(ramlog->cur_textbuf) < 120) {
+		ramlog->cur_textbuf_idx = ocs_ramlog_next_idx(ramlog, ramlog->cur_textbuf_idx);
+		ramlog->cur_textbuf = &ramlog->textbufs[ramlog->cur_textbuf_idx];
+		ocs_textbuf_reset(ramlog->cur_textbuf);
+	}
+
+	ocs_textbuf_vprintf(ramlog->cur_textbuf, fmt, ap);
+	ocs_unlock(&ramlog->lock);
+
+	return 0;
+}
+
+/**
+ * @brief Return next ramlog buffer index.
+ *
+ * Given a RAM logging buffer index, return the next index.
+ *
+ * @param ramlog Pointer to RAM logging buffer.
+ * @param idx Index value.
+ *
+ * @return Returns next index value.
+ */
+
+static uint32_t
+ocs_ramlog_next_idx(ocs_ramlog_t *ramlog, uint32_t idx)
+{
+	idx = idx + 1;
+
+	if (idx >= ramlog->textbuf_count) {
+		idx = ramlog->textbuf_base;
+	}
+
+	return idx;
+}
+
+/**
+ * @brief Perform ramlog buffer driver dump.
+ *
+ * The RAM logging buffer is appended to the driver dump data.
+ *
+ * @param textbuf Pointer to the driver dump text buffer.
+ * @param ramlog Pointer to the RAM logging buffer.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+int32_t
+ocs_ddump_ramlog(ocs_textbuf_t *textbuf, ocs_ramlog_t *ramlog)
+{
+	uint32_t i;
+	ocs_textbuf_t *rltextbuf;
+	int idx;
+
+	if ((ramlog == NULL) || (ramlog->textbufs == NULL)) {
+		return -1;
+	}
+
+	ocs_ddump_section(textbuf, "driver-log", 0);
+
+	/* Dump the start of day buffer */
+	ocs_ddump_section(textbuf, "startofday", 0);
+	/* If textbuf_base is 0, then all buffers are used for recent */
+	if (ramlog->textbuf_base) {
+		rltextbuf = &ramlog->textbufs[0];
+		ocs_textbuf_buffer(textbuf, ocs_textbuf_get_buffer(rltextbuf), ocs_textbuf_get_written(rltextbuf));
+	}
+	ocs_ddump_endsection(textbuf, "startofday", 0);
+
+	/* Dump the most recent buffers */
+	ocs_ddump_section(textbuf, "recent", 0);
+
+	/* start with the next textbuf */
+	idx = ocs_ramlog_next_idx(ramlog, ramlog->textbuf_count);
+
+	for (i = ramlog->textbuf_base; i < ramlog->textbuf_count; i ++) {
+		rltextbuf = &ramlog->textbufs[idx];
+		ocs_textbuf_buffer(textbuf, ocs_textbuf_get_buffer(rltextbuf), ocs_textbuf_get_written(rltextbuf));
+		idx = ocs_ramlog_next_idx(ramlog, idx);
+	}
+	ocs_ddump_endsection(textbuf, "recent", 0);
+	ocs_ddump_endsection(textbuf, "driver-log", 0);
+
+	return 0;
+}
+
+struct ocs_pool_s {
+	ocs_os_handle_t os;
+	ocs_array_t *a;
+	ocs_list_t freelist;
+	uint32_t use_lock:1;
+	ocs_lock_t lock;
+};
+
+typedef struct {
+	ocs_list_link_t link;
+} pool_hdr_t;
+
+
+/**
+ * @brief Allocate a memory pool.
+ *
+ * A memory pool of given size and item count is allocated.
+ *
+ * @param os OS handle.
+ * @param size Size in bytes of item.
+ * @param count Number of items in a memory pool.
+ * @param use_lock TRUE to enable locking of pool.
+ *
+ * @return Returns pointer to allocated memory pool, or NULL.
+ */
+ocs_pool_t *
+ocs_pool_alloc(ocs_os_handle_t os, uint32_t size, uint32_t count, uint32_t use_lock)
+{
+	ocs_pool_t *pool;
+	uint32_t i;
+
+	pool = ocs_malloc(os, sizeof(*pool), OCS_M_ZERO | OCS_M_NOWAIT);
+	if (pool == NULL) {
+		return NULL;
+	}
+
+	pool->os = os;
+	pool->use_lock = use_lock;
+
+	/* Allocate an array where each array item is the size of a pool_hdr_t plus
+	 * the requested memory item size (size)
+	 */
+	pool->a = ocs_array_alloc(os, size + sizeof(pool_hdr_t), count);
+	if (pool->a == NULL) {
+		ocs_pool_free(pool);
+		return NULL;
+	}
+
+	ocs_list_init(&pool->freelist, pool_hdr_t, link);
+	for (i = 0; i < count; i++) {
+		ocs_list_add_tail(&pool->freelist, ocs_array_get(pool->a, i));
+	}
+
+	if (pool->use_lock) {
+		ocs_lock_init(os, &pool->lock, "ocs_pool:%p", pool);
+	}
+
+	return pool;
+}
+
+/**
+ * @brief Reset a memory pool.
+ *
+ * Place all pool elements on the free list, and zero them.
+ *
+ * @param pool Pointer to the pool object.
+ *
+ * @return None.
+ */
+void
+ocs_pool_reset(ocs_pool_t *pool)
+{
+	uint32_t i;
+	uint32_t count = ocs_array_get_count(pool->a);
+	uint32_t size = ocs_array_get_size(pool->a);
+
+	if (pool->use_lock) {
+		ocs_lock(&pool->lock);
+	}
+
+	/*
+	 * Remove all the entries from the free list, otherwise we will
+	 * encountered linked list asserts when they are re-added.
+	 */
+	while (!ocs_list_empty(&pool->freelist)) {
+		ocs_list_remove_head(&pool->freelist);
+	}
+
+	/* Reset the free list */
+	ocs_list_init(&pool->freelist, pool_hdr_t, link);
+
+	/* Return all elements to the free list and zero the elements */
+	for (i = 0; i < count; i++) {
+		ocs_memset(ocs_pool_get_instance(pool, i), 0, size - sizeof(pool_hdr_t));
+		ocs_list_add_tail(&pool->freelist, ocs_array_get(pool->a, i));
+	}
+	if (pool->use_lock) {
+		ocs_unlock(&pool->lock);
+	}
+
+}
+
+/**
+ * @brief Free a previously allocated memory pool.
+ *
+ * The memory pool is freed.
+ *
+ * @param pool Pointer to memory pool.
+ *
+ * @return None.
+ */
+void
+ocs_pool_free(ocs_pool_t *pool)
+{
+	if (pool != NULL) {
+		if (pool->a != NULL) {
+			ocs_array_free(pool->a);
+		}
+		if (pool->use_lock) {
+			ocs_lock_free(&pool->lock);
+		}
+		ocs_free(pool->os, pool, sizeof(*pool));
+	}
+}
+
+/**
+ * @brief Allocate a memory pool item
+ *
+ * A memory pool item is taken from the free list and returned.
+ *
+ * @param pool Pointer to memory pool.
+ *
+ * @return Pointer to allocated item, otherwise NULL if there are no unallocated
+ *	   items.
+ */
+void *
+ocs_pool_get(ocs_pool_t *pool)
+{
+	pool_hdr_t *h;
+	void *item = NULL;
+
+	if (pool->use_lock) {
+		ocs_lock(&pool->lock);
+	}
+
+	h = ocs_list_remove_head(&pool->freelist);
+
+	if (h != NULL) {
+		/* Return the array item address offset by the size of pool_hdr_t */
+		item = &h[1];
+	}
+
+	if (pool->use_lock) {
+		ocs_unlock(&pool->lock);
+	}
+	return item;
+}
+
+/**
+ * @brief free memory pool item
+ *
+ * A memory pool item is freed.
+ *
+ * @param pool Pointer to memory pool.
+ * @param item Pointer to item to free.
+ *
+ * @return None.
+ */
+void
+ocs_pool_put(ocs_pool_t *pool, void *item)
+{
+	pool_hdr_t *h;
+
+	if (pool->use_lock) {
+		ocs_lock(&pool->lock);
+	}
+
+	/* Fetch the address of the array item, which is the item address negatively offset
+	 * by size of pool_hdr_t (note the index of [-1]
+	 */
+	h = &((pool_hdr_t*)item)[-1];
+
+	ocs_list_add_tail(&pool->freelist, h);
+
+	if (pool->use_lock) {
+		ocs_unlock(&pool->lock);
+	}
+
+}
+
+/**
+ * @brief Return memory pool item count.
+ *
+ * Returns the allocated number of items.
+ *
+ * @param pool Pointer to memory pool.
+ *
+ * @return Returns count of allocated items.
+ */
+uint32_t
+ocs_pool_get_count(ocs_pool_t *pool)
+{
+	uint32_t count;
+	if (pool->use_lock) {
+		ocs_lock(&pool->lock);
+	}
+	count = ocs_array_get_count(pool->a);
+	if (pool->use_lock) {
+		ocs_unlock(&pool->lock);
+	}
+	return count;
+}
+
+/**
+ * @brief Return item given an index.
+ *
+ * A pointer to a memory pool item is returned given an index.
+ *
+ * @param pool Pointer to memory pool.
+ * @param idx Index.
+ *
+ * @return Returns pointer to item, or NULL if index is invalid.
+ */
+void *
+ocs_pool_get_instance(ocs_pool_t *pool, uint32_t idx)
+{
+	pool_hdr_t *h = ocs_array_get(pool->a, idx);
+
+	if (h == NULL) {
+		return NULL;
+	}
+	return &h[1];
+}
+
+/**
+ * @brief Return count of free objects in a pool.
+ *
+ * The number of objects on a pool's free list.
+ *
+ * @param pool Pointer to memory pool.
+ *
+ * @return Returns count of objects on free list.
+ */
+uint32_t
+ocs_pool_get_freelist_count(ocs_pool_t *pool)
+{
+	uint32_t count = 0;
+	void *item;
+
+	if (pool->use_lock) {
+		ocs_lock(&pool->lock);
+	}
+
+	ocs_list_foreach(&pool->freelist, item) {
+		count++;
+	}
+
+	if (pool->use_lock) {
+		ocs_unlock(&pool->lock);
+	}
+	return count;
+}
diff --git a/sys/dev/ocs_fc/ocs_utils.h b/sys/dev/ocs_fc/ocs_utils.h
new file mode 100644
index 000000000000..b4f6ec0635fa
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_utils.h
@@ -0,0 +1,345 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ */
+
+#ifndef __OCS_UTILS_H
+#define __OCS_UTILS_H
+
+#include "ocs_list.h"
+typedef struct ocs_array_s ocs_array_t;
+
+extern void ocs_array_set_slablen(uint32_t len);
+extern ocs_array_t *ocs_array_alloc(ocs_os_handle_t os, uint32_t size, uint32_t count);
+extern void ocs_array_free(ocs_array_t *array);
+extern void *ocs_array_get(ocs_array_t *array, uint32_t idx);
+extern uint32_t ocs_array_get_count(ocs_array_t *array);
+extern uint32_t ocs_array_get_size(ocs_array_t *array);
+
+/* Void pointer array and iterator */
+typedef struct ocs_varray_s ocs_varray_t;
+
+extern ocs_varray_t *ocs_varray_alloc(ocs_os_handle_t os, uint32_t entry_count);
+extern void ocs_varray_free(ocs_varray_t *ai);
+extern int32_t ocs_varray_add(ocs_varray_t *ai, void *entry);
+extern void ocs_varray_iter_reset(ocs_varray_t *ai);
+extern void *ocs_varray_iter_next(ocs_varray_t *ai);
+extern void *_ocs_varray_iter_next(ocs_varray_t *ai);
+extern void ocs_varray_lock(ocs_varray_t *ai);
+extern void ocs_varray_unlock(ocs_varray_t *ai);
+extern uint32_t ocs_varray_get_count(ocs_varray_t *ai);
+
+
+/***************************************************************************
+ * Circular buffer
+ *
+ */
+
+typedef struct ocs_cbuf_s ocs_cbuf_t;
+
+extern ocs_cbuf_t *ocs_cbuf_alloc(ocs_os_handle_t os, uint32_t entry_count);
+extern void ocs_cbuf_free(ocs_cbuf_t *cbuf);
+extern void *ocs_cbuf_get(ocs_cbuf_t *cbuf, int32_t timeout_usec);
+extern int32_t ocs_cbuf_put(ocs_cbuf_t *cbuf, void *elem);
+extern int32_t ocs_cbuf_prime(ocs_cbuf_t *cbuf, ocs_array_t *array);
+
+typedef struct {
+        void *vaddr;
+        uint32_t length;
+} ocs_scsi_vaddr_len_t;
+
+
+#define OCS_TEXTBUF_MAX_ALLOC_LEN	(256*1024)
+
+typedef struct {
+	ocs_list_link_t link;
+	uint8_t user_allocated:1;
+	uint8_t *buffer;
+	uint32_t buffer_length;
+	uint32_t buffer_written;
+} ocs_textbuf_segment_t;
+
+typedef struct {
+	ocs_t *ocs;
+	ocs_list_t segment_list;
+	uint8_t extendable:1;
+	uint32_t allocation_length;
+	uint32_t total_allocation_length;
+	uint32_t max_allocation_length;
+} ocs_textbuf_t;
+
+extern int32_t ocs_textbuf_alloc(ocs_t *ocs, ocs_textbuf_t *textbuf, uint32_t length);
+extern uint32_t ocs_textbuf_initialized(ocs_textbuf_t *textbuf);
+extern int32_t ocs_textbuf_init(ocs_t *ocs, ocs_textbuf_t *textbuf, void *buffer, uint32_t length);
+extern void ocs_textbuf_free(ocs_t *ocs, ocs_textbuf_t *textbuf);
+extern void ocs_textbuf_putc(ocs_textbuf_t *textbuf, uint8_t c);
+extern void ocs_textbuf_puts(ocs_textbuf_t *textbuf, char *s);
+__attribute__((format(printf,2,3)))
+extern void ocs_textbuf_printf(ocs_textbuf_t *textbuf, const char *fmt, ...);
+__attribute__((format(printf,2,0)))
+extern void ocs_textbuf_vprintf(ocs_textbuf_t *textbuf, const char *fmt, va_list ap);
+extern void ocs_textbuf_buffer(ocs_textbuf_t *textbuf, uint8_t *buffer, uint32_t buffer_length);
+extern void ocs_textbuf_copy(ocs_textbuf_t *textbuf, uint8_t *buffer, uint32_t buffer_length);
+extern int32_t ocs_textbuf_remaining(ocs_textbuf_t *textbuf);
+extern void ocs_textbuf_reset(ocs_textbuf_t *textbuf);
+extern uint8_t *ocs_textbuf_get_buffer(ocs_textbuf_t *textbuf);
+extern int32_t ocs_textbuf_get_length(ocs_textbuf_t *textbuf);
+extern int32_t ocs_textbuf_get_written(ocs_textbuf_t *textbuf);
+extern uint8_t *ocs_textbuf_ext_get_buffer(ocs_textbuf_t *textbuf, uint32_t idx);
+extern int32_t ocs_textbuf_ext_get_length(ocs_textbuf_t *textbuf, uint32_t idx);
+extern int32_t ocs_textbuf_ext_get_written(ocs_textbuf_t *textbuf, uint32_t idx);
+
+
+typedef struct ocs_pool_s ocs_pool_t;
+
+extern ocs_pool_t *ocs_pool_alloc(ocs_os_handle_t os, uint32_t size, uint32_t count, uint32_t use_lock);
+extern void ocs_pool_reset(ocs_pool_t *pool);
+extern void ocs_pool_free(ocs_pool_t *pool);
+extern void *ocs_pool_get(ocs_pool_t *pool);
+extern void ocs_pool_put(ocs_pool_t *pool, void *item);
+extern uint32_t ocs_pool_get_count(ocs_pool_t *pool);
+extern void *ocs_pool_get_instance(ocs_pool_t *pool, uint32_t idx);
+extern uint32_t ocs_pool_get_freelist_count(ocs_pool_t *pool);
+
+
+/* Uncomment this line to enable logging extended queue history
+ */
+//#define OCS_DEBUG_QUEUE_HISTORY
+
+
+/* Allocate maximum allowed (4M) */
+#if defined(OCS_DEBUG_QUEUE_HISTORY)
+#define OCS_Q_HIST_SIZE (1000000UL)		/* Size in words */
+#endif
+
+#define OCS_LOG_ENABLE_SM_TRACE(ocs)		(((ocs) != NULL) ? (((ocs)->logmask & (1U << 0)) != 0) : 0)
+#define OCS_LOG_ENABLE_ELS_TRACE(ocs)		(((ocs) != NULL) ? (((ocs)->logmask & (1U << 1)) != 0) : 0)
+#define OCS_LOG_ENABLE_SCSI_TRACE(ocs)		(((ocs) != NULL) ? (((ocs)->logmask & (1U << 2)) != 0) : 0)
+#define OCS_LOG_ENABLE_SCSI_TGT_TRACE(ocs)	(((ocs) != NULL) ? (((ocs)->logmask & (1U << 3)) != 0) : 0)
+#define OCS_LOG_ENABLE_DOMAIN_SM_TRACE(ocs)	(((ocs) != NULL) ? (((ocs)->logmask & (1U << 4)) != 0) : 0)
+#define OCS_LOG_ENABLE_Q_FULL_BUSY_MSG(ocs)	(((ocs) != NULL) ? (((ocs)->logmask & (1U << 5)) != 0) : 0)
+#define OCS_LOG_ENABLE_IO_ERRORS(ocs)		(((ocs) != NULL) ? (((ocs)->logmask & (1U << 6)) != 0) : 0)
+
+
+extern void ocs_dump32(uint32_t, ocs_os_handle_t, const char *, void *, uint32_t);
+extern void ocs_debug_enable(uint32_t mask);
+extern void ocs_debug_disable(uint32_t mask);
+extern int ocs_debug_is_enabled(uint32_t mask);
+extern void ocs_debug_attach(void *);
+extern void ocs_debug_detach(void *);
+
+#if defined(OCS_DEBUG_QUEUE_HISTORY)
+
+/**
+ * @brief Queue history footer
+ */
+typedef union ocs_q_hist_ftr_u {
+	uint32_t word;
+	struct {
+#define Q_HIST_TYPE_LEN 		3
+#define Q_HIST_MASK_LEN 		29
+		uint32_t mask:Q_HIST_MASK_LEN,
+			 type:Q_HIST_TYPE_LEN;
+	} s;
+} ocs_q_hist_ftr_t;
+
+
+/**
+ * @brief WQE command mask lookup
+ */
+typedef struct ocs_q_hist_wqe_mask_s {
+	uint8_t command;
+	uint32_t mask;
+} ocs_q_hist_wqe_mask_t;
+
+/**
+ * @brief CQE mask lookup
+ */
+typedef struct ocs_q_hist_cqe_mask_s {
+	uint8_t ctype;
+	uint32_t :Q_HIST_MASK_LEN,
+		 type:Q_HIST_TYPE_LEN;
+	uint32_t mask;
+	uint32_t mask_err;
+} ocs_q_hist_cqe_mask_t;
+
+/**
+ * @brief Queue history type
+ */
+typedef enum {
+	/* changes need to be made to ocs_queue_history_type_name() as well */
+	OCS_Q_HIST_TYPE_WQE = 0,
+	OCS_Q_HIST_TYPE_CWQE,
+	OCS_Q_HIST_TYPE_CXABT,
+	OCS_Q_HIST_TYPE_MISC,
+} ocs_q_hist_type_t;
+
+static __inline const char *
+ocs_queue_history_type_name(ocs_q_hist_type_t type)
+{
+	switch (type) {
+	case OCS_Q_HIST_TYPE_WQE: return "wqe"; break;
+	case OCS_Q_HIST_TYPE_CWQE: return "wcqe"; break;
+	case OCS_Q_HIST_TYPE_CXABT: return "xacqe"; break;
+	case OCS_Q_HIST_TYPE_MISC: return "misc"; break;
+	default: return "unknown"; break;
+	}
+}
+
+typedef struct {
+	ocs_t		*ocs;
+	uint32_t	*q_hist;
+	uint32_t	q_hist_index;
+	ocs_lock_t	q_hist_lock;
+} ocs_hw_q_hist_t;
+
+extern void ocs_queue_history_cqe(ocs_hw_q_hist_t*, uint8_t, uint32_t *, uint8_t, uint32_t, uint32_t);
+extern void ocs_queue_history_wq(ocs_hw_q_hist_t*, uint32_t *, uint32_t, uint32_t);
+extern void ocs_queue_history_misc(ocs_hw_q_hist_t*, uint32_t *, uint32_t);
+extern void ocs_queue_history_init(ocs_t *, ocs_hw_q_hist_t*);
+extern void ocs_queue_history_free(ocs_hw_q_hist_t*);
+extern uint32_t ocs_queue_history_prev_index(uint32_t);
+extern uint8_t ocs_queue_history_q_info_enabled(void);
+extern uint8_t ocs_queue_history_timestamp_enabled(void);
+#else
+#define ocs_queue_history_wq(...)
+#define ocs_queue_history_cqe(...)
+#define ocs_queue_history_misc(...)
+#define ocs_queue_history_init(...)
+#define ocs_queue_history_free(...)
+#endif
+
+#define OCS_DEBUG_ALWAYS		(1U << 0)
+#define OCS_DEBUG_ENABLE_MQ_DUMP	(1U << 1)
+#define OCS_DEBUG_ENABLE_CQ_DUMP	(1U << 2)
+#define OCS_DEBUG_ENABLE_WQ_DUMP	(1U << 3)
+#define OCS_DEBUG_ENABLE_EQ_DUMP	(1U << 4)
+#define OCS_DEBUG_ENABLE_SPARAM_DUMP	(1U << 5)
+
+extern void _ocs_assert(const char *cond, const char *filename, int linenum);
+
+#define ocs_assert(cond, ...) \
+	do { \
+		if (!(cond)) { \
+			_ocs_assert(#cond, __FILE__, __LINE__); \
+			return __VA_ARGS__; \
+		} \
+	} while (0)
+
+extern void ocs_dump_service_params(const char *label, void *sparms);
+extern void ocs_display_sparams(const char *prelabel, const char *reqlabel, int dest, void *textbuf, void *sparams);
+
+
+typedef struct {
+	uint16_t crc;
+	uint16_t app_tag;
+	uint32_t ref_tag;
+} ocs_dif_t;
+
+/* DIF guard calculations */
+extern uint16_t ocs_scsi_dif_calc_crc(const uint8_t *, uint32_t size, uint16_t crc);
+extern uint16_t ocs_scsi_dif_calc_checksum(ocs_scsi_vaddr_len_t addrlen[], uint32_t addrlen_count);
+
+/**
+ * @brief Power State change message types
+ *
+ */
+typedef enum {
+	OCS_PM_PREPARE = 1,
+	OCS_PM_SLEEP,
+	OCS_PM_HIBERNATE,
+	OCS_PM_RESUME,
+} ocs_pm_msg_e;
+
+/**
+ * @brief Power State values
+ *
+ */
+typedef enum {
+	OCS_PM_STATE_S0 = 0,
+	OCS_PM_STATE_S1,
+	OCS_PM_STATE_S2,
+	OCS_PM_STATE_S3,
+	OCS_PM_STATE_S4,
+} ocs_pm_state_e;
+
+typedef struct {
+	ocs_pm_state_e pm_state;		/*<< Current PM state */
+} ocs_pm_context_t;
+
+extern int32_t ocs_pm_request(ocs_t *ocs, ocs_pm_msg_e msg, int32_t (*callback)(ocs_t *ocs, int32_t status, void *arg),
+	void *arg);
+extern ocs_pm_state_e ocs_pm_get_state(ocs_t *ocs);
+extern const char *ocs_pm_get_state_string(ocs_t *ocs);
+
+#define SPV_ROWLEN	256
+#define SPV_DIM		3
+
+
+/*!
+* @defgroup spv Sparse Vector
+*/
+
+/**
+ * @brief Sparse vector structure.
+ */
+typedef struct sparse_vector_s {
+	ocs_os_handle_t os;
+	uint32_t max_idx;		/**< maximum index value */
+	void **array;			/**< pointer to 3D array */
+} *sparse_vector_t;
+
+extern void spv_del(sparse_vector_t spv);
+extern sparse_vector_t spv_new(ocs_os_handle_t os);
+extern void spv_set(sparse_vector_t sv, uint32_t idx, void *value);
+extern void *spv_get(sparse_vector_t sv, uint32_t idx);
+
+extern unsigned short t10crc16(const unsigned char *blk_adr, unsigned long blk_len, unsigned short crc);
+
+typedef struct ocs_ramlog_s ocs_ramlog_t;
+
+#define OCS_RAMLOG_DEFAULT_BUFFERS              5
+
+extern ocs_ramlog_t *ocs_ramlog_init(ocs_t *ocs, uint32_t buffer_len, uint32_t buffer_count);
+extern void ocs_ramlog_free(ocs_t *ocs, ocs_ramlog_t *ramlog);
+extern void ocs_ramlog_clear(ocs_t *ocs, ocs_ramlog_t *ramlog, int clear_start_of_day, int clear_recent);
+__attribute__((format(printf,2,3)))
+extern int32_t ocs_ramlog_printf(void *os, const char *fmt, ...);
+__attribute__((format(printf,2,0)))
+extern int32_t ocs_ramlog_vprintf(ocs_ramlog_t *ramlog, const char *fmt, va_list ap);
+extern int32_t ocs_ddump_ramlog(ocs_textbuf_t *textbuf, ocs_ramlog_t *ramlog);
+
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_vpd.h b/sys/dev/ocs_fc/ocs_vpd.h
new file mode 100644
index 000000000000..c5c0341320e4
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_vpd.h
@@ -0,0 +1,203 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * OCS VPD parser
+ */
+
+#if !defined(__OCS_VPD_H__)
+#define __OCS_VPD_H__
+
+/**
+ * @brief VPD buffer structure
+ */
+
+typedef struct {
+	uint8_t *buffer;
+	uint32_t length;
+	uint32_t offset;
+	uint8_t checksum;
+	} vpdbuf_t;
+
+/**
+ * @brief return next VPD byte
+ *
+ * Returns next VPD byte and updates accumulated checksum
+ *
+ * @param vpd pointer to vpd buffer
+ *
+ * @return returns next byte for success, or a negative error code value for failure.
+ *
+ */
+
+static inline int
+vpdnext(vpdbuf_t *vpd)
+{
+	int rc = -1;
+	if (vpd->offset < vpd->length) {
+		rc = vpd->buffer[vpd->offset++];
+		vpd->checksum += rc;
+	}
+	return rc;
+}
+
+/**
+ * @brief return true if no more vpd buffer data
+ *
+ * return true if the vpd buffer data has been completely consumed
+ *
+ * @param vpd pointer to vpd buffer
+ *
+ * @return returns true if no more data
+ *
+ */
+static inline int
+vpddone(vpdbuf_t *vpd)
+{
+	return vpd->offset >= vpd->length;
+}
+/**
+ * @brief return pointer to current VPD data location
+ *
+ * Returns a pointer to the current location in the VPD data
+ *
+ * @param vpd pointer to vpd buffer
+ *
+ * @return pointer to current VPD data location
+ */
+
+static inline uint8_t *
+vpdref(vpdbuf_t *vpd)
+{
+	return &vpd->buffer[vpd->offset];
+}
+
+#define VPD_LARGE_RESOURCE_TYPE_ID_STRING_TAG	0x82
+#define VPD_LARGE_RESOURCE_TYPE_R_TAG		0x90
+#define VPD_LARGE_RESOURCE_TYPE_W_TAG		0x91
+#define VPD_SMALL_RESOURCE_TYPE_END_TAG		0x78
+
+/**
+ * @brief find a VPD entry
+ *
+ * Finds a VPD entry given the two character code
+ *
+ * @param vpddata pointer to raw vpd data buffer
+ * @param vpddata_length length of vpddata buffer in bytes
+ * @param key key to look up
+
+ * @return returns a pointer to the key location or NULL if not found or checksum error
+ */
+
+static inline uint8_t *
+ocs_find_vpd(uint8_t *vpddata, uint32_t vpddata_length, const char *key)
+{
+	vpdbuf_t vpdbuf;
+	uint8_t *pret = NULL;
+	uint8_t c0 = key[0];
+	uint8_t c1 = key[1];
+
+	vpdbuf.buffer = (uint8_t*) vpddata;
+	vpdbuf.length = vpddata_length;
+	vpdbuf.offset = 0;
+	vpdbuf.checksum = 0;
+
+	while (!vpddone(&vpdbuf)) {
+		int type = vpdnext(&vpdbuf);
+		int len_lo;
+		int len_hi;
+		int len;
+		int i;
+
+		if (type == VPD_SMALL_RESOURCE_TYPE_END_TAG) {
+			break;
+		}
+
+		len_lo = vpdnext(&vpdbuf);
+		len_hi = vpdnext(&vpdbuf);
+		len = len_lo + (len_hi << 8);
+
+		if ((type == VPD_LARGE_RESOURCE_TYPE_R_TAG) || (type == VPD_LARGE_RESOURCE_TYPE_W_TAG)) {
+			while (len > 0) {
+				int rc0;
+				int rc1;
+				int sublen;
+				uint8_t *pstart;
+
+				rc0 = vpdnext(&vpdbuf);
+				rc1 = vpdnext(&vpdbuf);
+
+				/* Mark this location */
+				pstart = vpdref(&vpdbuf);
+
+				sublen = vpdnext(&vpdbuf);
+
+				/* Adjust remaining len */
+				len -= (sublen + 3);
+
+				/* check for match with request */
+				if ((c0 == rc0) && (c1 == rc1)) {
+					pret = pstart;
+					for (i = 0; i < sublen; i++) {
+						vpdnext(&vpdbuf);
+					}
+				/* check for "RV" end */
+				} else if ('R' == rc0 && 'V' == rc1) {
+
+					/* Read the checksum */
+					for (i = 0; i < sublen; i++) {
+						vpdnext(&vpdbuf);
+					}
+
+					/* The accumulated checksum should be zero here */
+					if (vpdbuf.checksum != 0) {
+						ocs_log_test(NULL, "checksum error\n");
+						return NULL;
+					}
+				}
+				else
+					for (i = 0; i < sublen; i++) {
+						vpdnext(&vpdbuf);
+					}
+			}
+		}
+
+		for (i = 0; i < len; i++) {
+			vpdnext(&vpdbuf);
+		}
+	}
+
+	return pret;
+}
+#endif 
diff --git a/sys/dev/ocs_fc/ocs_xport.c b/sys/dev/ocs_fc/ocs_xport.c
new file mode 100644
index 000000000000..b7211c9851d2
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_xport.c
@@ -0,0 +1,1105 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * FC transport API
+ *
+ */
+
+#include "ocs.h"
+#include "ocs_device.h"
+
+static void ocs_xport_link_stats_cb(int32_t status, uint32_t num_counters, ocs_hw_link_stat_counts_t *counters, void *arg);
+static void ocs_xport_host_stats_cb(int32_t status, uint32_t num_counters, ocs_hw_host_stat_counts_t *counters, void *arg);
+/**
+ * @brief Post node event callback argument.
+ */
+typedef struct {
+	ocs_sem_t sem;
+	ocs_node_t *node;
+	ocs_sm_event_t evt;
+	void *context;
+} ocs_xport_post_node_event_t;
+
+/**
+ * @brief Allocate a transport object.
+ *
+ * @par Description
+ * A transport object is allocated, and associated with a device instance.
+ *
+ * @param ocs Pointer to device instance.
+ *
+ * @return Returns the pointer to the allocated transport object, or NULL if failed.
+ */
+ocs_xport_t *
+ocs_xport_alloc(ocs_t *ocs)
+{
+	ocs_xport_t *xport;
+
+	ocs_assert(ocs, NULL);
+	xport = ocs_malloc(ocs, sizeof(*xport), OCS_M_ZERO);
+	if (xport != NULL) {
+		xport->ocs = ocs;
+	}
+	return xport;
+}
+
+/**
+ * @brief Create the RQ threads and the circular buffers used to pass sequences.
+ *
+ * @par Description
+ * Creates the circular buffers and the servicing threads for RQ processing.
+ *
+ * @param xport Pointer to transport object
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static void
+ocs_xport_rq_threads_teardown(ocs_xport_t *xport)
+{
+	ocs_t *ocs = xport->ocs;
+	uint32_t i;
+
+	if (xport->num_rq_threads == 0 ||
+	    xport->rq_thread_info == NULL) {
+		return;
+	}
+
+	/* Abort any threads */
+	for (i = 0; i < xport->num_rq_threads; i++) {
+		if (xport->rq_thread_info[i].thread_started) {
+			ocs_thread_terminate(&xport->rq_thread_info[i].thread);
+			/* wait for the thread to exit */
+			ocs_log_debug(ocs, "wait for thread %d to exit\n", i);
+			while (xport->rq_thread_info[i].thread_started) {
+				ocs_udelay(10000);
+			}
+			ocs_log_debug(ocs, "thread %d to exited\n", i);
+		}
+		if (xport->rq_thread_info[i].seq_cbuf != NULL) {
+			ocs_cbuf_free(xport->rq_thread_info[i].seq_cbuf);
+			xport->rq_thread_info[i].seq_cbuf = NULL;
+		}
+	}
+}
+
+/**
+ * @brief Create the RQ threads and the circular buffers used to pass sequences.
+ *
+ * @par Description
+ * Creates the circular buffers and the servicing threads for RQ processing.
+ *
+ * @param xport Pointer to transport object.
+ * @param num_rq_threads Number of RQ processing threads that the
+ * driver creates.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+ocs_xport_rq_threads_create(ocs_xport_t *xport, uint32_t num_rq_threads)
+{
+	ocs_t *ocs = xport->ocs;
+	int32_t rc = 0;
+	uint32_t i;
+
+	xport->num_rq_threads = num_rq_threads;
+	ocs_log_debug(ocs, "number of RQ threads %d\n", num_rq_threads);
+	if (num_rq_threads == 0) {
+		return 0;
+	}
+
+	/* Allocate the space for the thread objects */
+	xport->rq_thread_info = ocs_malloc(ocs, sizeof(ocs_xport_rq_thread_info_t) * num_rq_threads, OCS_M_ZERO);
+	if (xport->rq_thread_info == NULL) {
+		ocs_log_err(ocs, "memory allocation failure\n");
+		return -1;
+	}
+
+	/* Create the circular buffers and threads. */
+	for (i = 0; i < num_rq_threads; i++) {
+		xport->rq_thread_info[i].ocs = ocs;
+		xport->rq_thread_info[i].seq_cbuf = ocs_cbuf_alloc(ocs, OCS_HW_RQ_NUM_HDR);
+		if (xport->rq_thread_info[i].seq_cbuf == NULL) {
+			goto ocs_xport_rq_threads_create_error;
+		}
+
+		ocs_snprintf(xport->rq_thread_info[i].thread_name,
+			     sizeof(xport->rq_thread_info[i].thread_name),
+			     "ocs_unsol_rq:%d:%d", ocs->instance_index, i);
+		rc = ocs_thread_create(ocs, &xport->rq_thread_info[i].thread, ocs_unsol_rq_thread,
+				       xport->rq_thread_info[i].thread_name,
+				       &xport->rq_thread_info[i], OCS_THREAD_RUN);
+		if (rc) {
+			ocs_log_err(ocs, "ocs_thread_create failed: %d\n", rc);
+			goto ocs_xport_rq_threads_create_error;
+		}
+		xport->rq_thread_info[i].thread_started = TRUE;
+	}
+	return 0;
+
+ocs_xport_rq_threads_create_error:
+	ocs_xport_rq_threads_teardown(xport);
+	return -1;
+}
+
+/**
+ * @brief Do as much allocation as possible, but do not initialization the device.
+ *
+ * @par Description
+ * Performs the functions required to get a device ready to run.
+ *
+ * @param xport Pointer to transport object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+ocs_xport_attach(ocs_xport_t *xport)
+{
+	ocs_t *ocs = xport->ocs;
+	int32_t rc;
+	uint32_t max_sgl;
+	uint32_t n_sgl;
+	uint32_t i;
+	uint32_t value;
+	uint32_t max_remote_nodes;
+
+	/* booleans used for cleanup if initialization fails */
+	uint8_t io_pool_created = FALSE;
+	uint8_t node_pool_created = FALSE;
+	uint8_t rq_threads_created = FALSE;
+
+	ocs_list_init(&ocs->domain_list, ocs_domain_t, link);
+
+	for (i = 0; i < SLI4_MAX_FCFI; i++) {
+		xport->fcfi[i].hold_frames = 1;
+		ocs_lock_init(ocs, &xport->fcfi[i].pend_frames_lock, "xport pend_frames[%d]", i);
+		ocs_list_init(&xport->fcfi[i].pend_frames, ocs_hw_sequence_t, link);
+	}
+
+	rc = ocs_hw_set_ptr(&ocs->hw, OCS_HW_WAR_VERSION, ocs->hw_war_version);
+	if (rc) {
+		ocs_log_test(ocs, "can't set OCS_HW_WAR_VERSION\n");
+		return -1;
+	}
+
+	rc = ocs_hw_setup(&ocs->hw, ocs, SLI4_PORT_TYPE_FC);
+	if (rc) {
+		ocs_log_err(ocs, "%s: Can't setup hardware\n", ocs->desc);
+		return -1;
+	} else if (ocs->ctrlmask & OCS_CTRLMASK_CRASH_RESET) {
+		ocs_log_debug(ocs, "stopping after ocs_hw_setup\n");
+		return -1;
+	}
+
+	ocs_hw_set(&ocs->hw, OCS_HW_BOUNCE, ocs->hw_bounce);
+	ocs_log_debug(ocs, "HW bounce: %d\n", ocs->hw_bounce);
+
+	ocs_hw_set(&ocs->hw, OCS_HW_RQ_SELECTION_POLICY, ocs->rq_selection_policy);
+	ocs_hw_set(&ocs->hw, OCS_HW_RR_QUANTA, ocs->rr_quanta);
+	ocs_hw_get(&ocs->hw, OCS_HW_RQ_SELECTION_POLICY, &value);
+	ocs_log_debug(ocs, "RQ Selection Policy: %d\n", value);
+
+	ocs_hw_set_ptr(&ocs->hw, OCS_HW_FILTER_DEF, (void*) ocs->filter_def);
+
+	ocs_hw_get(&ocs->hw, OCS_HW_MAX_SGL, &max_sgl);
+	max_sgl -= SLI4_SGE_MAX_RESERVED;
+	n_sgl = MIN(OCS_FC_MAX_SGL, max_sgl);
+
+	/* EVT: For chained SGL testing */
+	if (ocs->ctrlmask & OCS_CTRLMASK_TEST_CHAINED_SGLS) {
+		n_sgl = 4;
+	}
+
+	/* Note: number of SGLs must be set for ocs_node_create_pool */
+	if (ocs_hw_set(&ocs->hw, OCS_HW_N_SGL, n_sgl) != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(ocs, "%s: Can't set number of SGLs\n", ocs->desc);
+		return -1;
+	} else {
+		ocs_log_debug(ocs, "%s: Configured for %d SGLs\n", ocs->desc, n_sgl);
+	}
+
+	ocs_hw_get(&ocs->hw, OCS_HW_MAX_NODES, &max_remote_nodes);
+
+	rc = ocs_node_create_pool(ocs, (ocs->max_remote_nodes) ?
+				 ocs->max_remote_nodes : max_remote_nodes);
+	if (rc) {
+		ocs_log_err(ocs, "Can't allocate node pool\n");
+		goto ocs_xport_attach_cleanup;
+	} else {
+		node_pool_created = TRUE;
+	}
+
+	/* EVT: if testing chained SGLs allocate OCS_FC_MAX_SGL SGE's in the IO */
+	xport->io_pool = ocs_io_pool_create(ocs, ocs->num_scsi_ios,
+		(ocs->ctrlmask & OCS_CTRLMASK_TEST_CHAINED_SGLS) ? OCS_FC_MAX_SGL : n_sgl);
+	if (xport->io_pool == NULL) {
+		ocs_log_err(ocs, "Can't allocate IO pool\n");
+		goto ocs_xport_attach_cleanup;
+	} else {
+		io_pool_created = TRUE;
+	}
+
+	/*
+	 * setup the RQ processing threads
+	 */
+	if (ocs_xport_rq_threads_create(xport, ocs->rq_threads) != 0) {
+		ocs_log_err(ocs, "failure creating RQ threads\n");
+		goto ocs_xport_attach_cleanup;
+	}
+	rq_threads_created = TRUE;
+
+	return 0;
+
+ocs_xport_attach_cleanup:
+	if (io_pool_created) {
+		ocs_io_pool_free(xport->io_pool);
+	}
+
+	if (node_pool_created) {
+		ocs_node_free_pool(ocs);
+	}
+
+	if (rq_threads_created) {
+		ocs_xport_rq_threads_teardown(xport);
+	}
+
+	return -1;
+}
+
+/**
+ * @brief Determines how to setup auto Xfer ready.
+ *
+ * @par Description
+ * @param xport Pointer to transport object.
+ *
+ * @return Returns 0 on success or a non-zero value on failure.
+ */
+static int32_t
+ocs_xport_initialize_auto_xfer_ready(ocs_xport_t *xport)
+{
+	ocs_t *ocs = xport->ocs;
+	uint32_t auto_xfer_rdy;
+	char prop_buf[32];
+	uint32_t ramdisc_blocksize = 512;
+	uint8_t p_type = 0;
+
+	ocs_hw_get(&ocs->hw, OCS_HW_AUTO_XFER_RDY_CAPABLE, &auto_xfer_rdy);
+	if (!auto_xfer_rdy) {
+		ocs->auto_xfer_rdy_size = 0;
+		ocs_log_test(ocs, "Cannot enable auto xfer rdy for this port\n");
+		return 0;
+	}
+
+	if (ocs_hw_set(&ocs->hw, OCS_HW_AUTO_XFER_RDY_SIZE, ocs->auto_xfer_rdy_size)) {
+		ocs_log_test(ocs, "%s: Can't set auto xfer rdy mode\n", ocs->desc);
+		return -1;
+	}
+
+	/*
+	 * Determine if we are doing protection in the backend. We are looking
+	 * at the modules parameters here. The backend cannot allow a format
+	 * command to change the protection mode when using this feature,
+	 * otherwise the firmware will not do the proper thing.
+	 */
+	if (ocs_get_property("p_type", prop_buf, sizeof(prop_buf)) == 0) {
+		p_type = ocs_strtoul(prop_buf, 0, 0);
+	}
+	if (ocs_get_property("ramdisc_blocksize", prop_buf, sizeof(prop_buf)) == 0) {
+		ramdisc_blocksize = ocs_strtoul(prop_buf, 0, 0);
+	}
+	if (ocs_get_property("external_dif", prop_buf, sizeof(prop_buf)) == 0) {
+		if(ocs_strlen(prop_buf)) {
+			if (p_type == 0) {
+				p_type = 1;
+			}
+		}
+	}
+
+	if (p_type != 0) {
+		if (ocs_hw_set(&ocs->hw, OCS_HW_AUTO_XFER_RDY_T10_ENABLE, TRUE)) {
+			ocs_log_test(ocs, "%s: Can't set auto xfer rdy mode\n", ocs->desc);
+			return -1;
+		}
+		if (ocs_hw_set(&ocs->hw, OCS_HW_AUTO_XFER_RDY_BLK_SIZE, ramdisc_blocksize)) {
+			ocs_log_test(ocs, "%s: Can't set auto xfer rdy blk size\n", ocs->desc);
+			return -1;
+		}
+		if (ocs_hw_set(&ocs->hw, OCS_HW_AUTO_XFER_RDY_P_TYPE, p_type)) {
+			ocs_log_test(ocs, "%s: Can't set auto xfer rdy mode\n", ocs->desc);
+			return -1;
+		}
+		if (ocs_hw_set(&ocs->hw, OCS_HW_AUTO_XFER_RDY_REF_TAG_IS_LBA, TRUE)) {
+			ocs_log_test(ocs, "%s: Can't set auto xfer rdy ref tag\n", ocs->desc);
+			return -1;
+		}
+		if (ocs_hw_set(&ocs->hw, OCS_HW_AUTO_XFER_RDY_APP_TAG_VALID, FALSE)) {
+			ocs_log_test(ocs, "%s: Can't set auto xfer rdy app tag valid\n", ocs->desc);
+			return -1;
+		}
+	}
+	ocs_log_debug(ocs, "Auto xfer rdy is enabled, p_type=%d, blksize=%d\n",
+		p_type, ramdisc_blocksize);
+	return 0;
+}
+
+/**
+ * @brief Initializes the device.
+ *
+ * @par Description
+ * Performs the functions required to make a device functional.
+ *
+ * @param xport Pointer to transport object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+ocs_xport_initialize(ocs_xport_t *xport)
+{
+	ocs_t *ocs = xport->ocs;
+	int32_t rc;
+	uint32_t i;
+	uint32_t max_hw_io;
+	uint32_t max_sgl;
+	uint32_t hlm;
+	uint32_t rq_limit;
+	uint32_t dif_capable;
+	uint8_t dif_separate = 0;
+	char prop_buf[32];
+
+	/* booleans used for cleanup if initialization fails */
+	uint8_t ini_device_set = FALSE;
+	uint8_t tgt_device_set = FALSE;
+	uint8_t hw_initialized = FALSE;
+
+	ocs_hw_get(&ocs->hw, OCS_HW_MAX_IO, &max_hw_io);
+	if (ocs_hw_set(&ocs->hw, OCS_HW_N_IO, max_hw_io) != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(ocs, "%s: Can't set number of IOs\n", ocs->desc);
+		return -1;
+	}
+
+	ocs_hw_get(&ocs->hw, OCS_HW_MAX_SGL, &max_sgl);
+	max_sgl -= SLI4_SGE_MAX_RESERVED;
+
+	if (ocs->enable_hlm) {
+		ocs_hw_get(&ocs->hw, OCS_HW_HIGH_LOGIN_MODE, &hlm);
+		if (!hlm) {
+			ocs->enable_hlm = FALSE;
+			ocs_log_err(ocs, "Cannot enable high login mode for this port\n");
+		} else {
+                        ocs_log_debug(ocs, "High login mode is enabled\n");
+			if (ocs_hw_set(&ocs->hw, OCS_HW_HIGH_LOGIN_MODE, TRUE)) {
+				ocs_log_err(ocs, "%s: Can't set high login mode\n", ocs->desc);
+				return -1;
+			}
+		}
+	}
+
+	/* validate the auto xfer_rdy size */
+	if (ocs->auto_xfer_rdy_size > 0 &&
+	    (ocs->auto_xfer_rdy_size < 2048 ||
+	     ocs->auto_xfer_rdy_size > 65536)) {
+		ocs_log_err(ocs, "Auto XFER_RDY size is out of range (2K-64K)\n");
+		return -1;
+	}
+
+	ocs_hw_get(&ocs->hw, OCS_HW_MAX_IO, &max_hw_io);
+
+	if (ocs->auto_xfer_rdy_size > 0) {
+		if (ocs_xport_initialize_auto_xfer_ready(xport)) {
+			ocs_log_err(ocs, "%s: Failed auto xfer ready setup\n", ocs->desc);
+			return -1;
+		}
+		if (ocs->esoc){
+			ocs_hw_set(&ocs->hw, OCS_ESOC, TRUE);
+		}
+	}
+
+	if (ocs->explicit_buffer_list) {
+		/* Are pre-registered SGL's required? */
+		ocs_hw_get(&ocs->hw, OCS_HW_PREREGISTER_SGL, &i);
+		if (i == TRUE) {
+			ocs_log_err(ocs, "Explicit Buffer List not supported on this device, not enabled\n");
+		} else {
+			ocs_hw_set(&ocs->hw, OCS_HW_PREREGISTER_SGL, FALSE);
+		}
+	}
+
+	if (ocs_hw_set(&ocs->hw, OCS_HW_TOPOLOGY, ocs->topology) != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(ocs, "%s: Can't set the toplogy\n", ocs->desc);
+		return -1;
+	}
+	ocs_hw_set(&ocs->hw, OCS_HW_RQ_DEFAULT_BUFFER_SIZE, OCS_FC_RQ_SIZE_DEFAULT);
+
+	if (ocs_hw_set(&ocs->hw, OCS_HW_LINK_SPEED, ocs->speed) != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(ocs, "%s: Can't set the link speed\n", ocs->desc);
+		return -1;
+	}
+
+	if (ocs_hw_set(&ocs->hw, OCS_HW_ETH_LICENSE, ocs->ethernet_license) != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(ocs, "%s: Can't set the ethernet license\n", ocs->desc);
+		return -1;
+	}
+
+	/* currently only lancer support setting the CRC seed value */
+	if (ocs->hw.sli.asic_type == SLI4_ASIC_TYPE_LANCER) {
+		if (ocs_hw_set(&ocs->hw, OCS_HW_DIF_SEED, OCS_FC_DIF_SEED) != OCS_HW_RTN_SUCCESS) {
+			ocs_log_err(ocs, "%s: Can't set the DIF seed\n", ocs->desc);
+			return -1;
+		}
+	}
+
+	/* Set the Dif mode */
+	if (0 == ocs_hw_get(&ocs->hw, OCS_HW_DIF_CAPABLE, &dif_capable)) {
+		if (dif_capable) {
+			if (ocs_get_property("dif_separate", prop_buf, sizeof(prop_buf)) == 0) {
+				dif_separate = ocs_strtoul(prop_buf, 0, 0);
+			}
+
+			if ((rc = ocs_hw_set(&ocs->hw, OCS_HW_DIF_MODE,
+			      (dif_separate == 0 ? OCS_HW_DIF_MODE_INLINE : OCS_HW_DIF_MODE_SEPARATE)))) {
+				ocs_log_err(ocs, "Requested DIF MODE not supported\n");
+			}
+		}
+	}
+
+	if (ocs->target_io_timer_sec) {
+		ocs_log_debug(ocs, "setting target io timer=%d\n", ocs->target_io_timer_sec);
+		ocs_hw_set(&ocs->hw, OCS_HW_EMULATE_TARGET_WQE_TIMEOUT, TRUE);
+	}
+
+	ocs_hw_callback(&ocs->hw, OCS_HW_CB_DOMAIN, ocs_domain_cb, ocs);
+	ocs_hw_callback(&ocs->hw, OCS_HW_CB_REMOTE_NODE, ocs_remote_node_cb, ocs);
+	ocs_hw_callback(&ocs->hw, OCS_HW_CB_UNSOLICITED, ocs_unsolicited_cb, ocs);
+	ocs_hw_callback(&ocs->hw, OCS_HW_CB_PORT, ocs_port_cb, ocs);
+
+	ocs->fw_version = (const char*) ocs_hw_get_ptr(&ocs->hw, OCS_HW_FW_REV);
+
+	/* Initialize vport list */
+	ocs_list_init(&xport->vport_list, ocs_vport_spec_t, link);
+	ocs_lock_init(ocs, &xport->io_pending_lock, "io_pending_lock[%d]", ocs->instance_index);
+	ocs_list_init(&xport->io_pending_list, ocs_io_t, io_pending_link);
+	ocs_atomic_init(&xport->io_active_count, 0);
+	ocs_atomic_init(&xport->io_pending_count, 0);
+	ocs_atomic_init(&xport->io_total_free, 0);
+	ocs_atomic_init(&xport->io_total_pending, 0);
+	ocs_atomic_init(&xport->io_alloc_failed_count, 0);
+	ocs_atomic_init(&xport->io_pending_recursing, 0);
+	ocs_lock_init(ocs, &ocs->hw.watchdog_lock, " Watchdog Lock[%d]", ocs_instance(ocs));
+	rc = ocs_hw_init(&ocs->hw);
+	if (rc) {
+		ocs_log_err(ocs, "ocs_hw_init failure\n");
+		goto ocs_xport_init_cleanup;
+	} else {
+		hw_initialized = TRUE;
+	}
+
+	rq_limit = max_hw_io/2;
+	if (ocs_hw_set(&ocs->hw, OCS_HW_RQ_PROCESS_LIMIT, rq_limit) != OCS_HW_RTN_SUCCESS) {
+		ocs_log_err(ocs, "%s: Can't set the RQ process limit\n", ocs->desc);
+	}
+
+	if (ocs->config_tgt) {
+		rc = ocs_scsi_tgt_new_device(ocs);
+		if (rc) {
+			ocs_log_err(ocs, "failed to initialize target\n");
+			goto ocs_xport_init_cleanup;
+		} else {
+			tgt_device_set = TRUE;
+		}
+	}
+
+	if (ocs->enable_ini) {
+		rc = ocs_scsi_ini_new_device(ocs);
+		if (rc) {
+			ocs_log_err(ocs, "failed to initialize initiator\n");
+			goto ocs_xport_init_cleanup;
+		} else {
+			ini_device_set = TRUE;
+		}
+
+	}
+
+	/* Add vports */
+	if (ocs->num_vports != 0) {
+
+		uint32_t max_vports;
+		ocs_hw_get(&ocs->hw, OCS_HW_MAX_VPORTS, &max_vports);
+
+		if (ocs->num_vports < max_vports) {
+			ocs_log_debug(ocs, "Provisioning %d vports\n", ocs->num_vports);
+			for (i = 0; i < ocs->num_vports; i++) {
+				ocs_vport_create_spec(ocs, 0, 0, UINT32_MAX, ocs->enable_ini, ocs->enable_tgt, NULL, NULL);
+			}
+		} else {
+			ocs_log_err(ocs, "failed to create vports. num_vports range should be (1-%d) \n", max_vports-1);
+			goto ocs_xport_init_cleanup;
+		}
+	}
+
+	return 0;
+
+ocs_xport_init_cleanup:
+	if (ini_device_set) {
+		ocs_scsi_ini_del_device(ocs);
+	}
+
+	if (tgt_device_set) {
+		ocs_scsi_tgt_del_device(ocs);
+	}
+
+	if (hw_initialized) {
+		/* ocs_hw_teardown can only execute after ocs_hw_init */
+		ocs_hw_teardown(&ocs->hw);
+	}
+
+	return -1;
+}
+
+/**
+ * @brief Detaches the transport from the device.
+ *
+ * @par Description
+ * Performs the functions required to shut down a device.
+ *
+ * @param xport Pointer to transport object.
+ *
+ * @return Returns 0 on success or a non-zero value on failure.
+ */
+int32_t
+ocs_xport_detach(ocs_xport_t *xport)
+{
+	ocs_t *ocs = xport->ocs;
+
+	/* free resources associated with target-server and initiator-client */
+	if (ocs->config_tgt)
+		ocs_scsi_tgt_del_device(ocs);
+
+	if (ocs->enable_ini) {
+		ocs_scsi_ini_del_device(ocs);
+
+		/*Shutdown FC Statistics timer*/
+		if (ocs_timer_pending(&ocs->xport->stats_timer))
+			ocs_del_timer(&ocs->xport->stats_timer);
+	}
+
+	ocs_hw_teardown(&ocs->hw);
+
+	return 0;
+}
+
+/**
+ * @brief domain list empty callback
+ *
+ * @par Description
+ * Function is invoked when the device domain list goes empty. By convention
+ * @c arg points to an ocs_sem_t instance, that is incremented.
+ *
+ * @param ocs Pointer to device object.
+ * @param arg Pointer to semaphore instance.
+ *
+ * @return None.
+ */
+
+static void
+ocs_xport_domain_list_empty_cb(ocs_t *ocs, void *arg)
+{
+	ocs_sem_t *sem = arg;
+
+	ocs_assert(ocs);
+	ocs_assert(sem);
+
+	ocs_sem_v(sem);
+}
+
+/**
+ * @brief post node event callback
+ *
+ * @par Description
+ * This function is called from the mailbox completion interrupt context to post an
+ * event to a node object. By doing this in the interrupt context, it has
+ * the benefit of only posting events in the interrupt context, deferring the need to
+ * create a per event node lock.
+ *
+ * @param hw Pointer to HW structure.
+ * @param status Completion status for mailbox command.
+ * @param mqe Mailbox queue completion entry.
+ * @param arg Callback argument.
+ *
+ * @return Returns 0 on success, a negative error code value on failure.
+ */
+
+static int32_t
+ocs_xport_post_node_event_cb(ocs_hw_t *hw, int32_t status, uint8_t *mqe, void *arg)
+{
+	ocs_xport_post_node_event_t *payload = arg;
+
+	if (payload != NULL) {
+		ocs_node_post_event(payload->node, payload->evt, payload->context);
+		ocs_sem_v(&payload->sem);
+	}
+
+        return 0;
+}
+
+/**
+ * @brief Initiate force free.
+ *
+ * @par Description
+ * Perform force free of OCS.
+ *
+ * @param xport Pointer to transport object.
+ *
+ * @return None.
+ */
+
+static void
+ocs_xport_force_free(ocs_xport_t *xport)
+{
+	ocs_t *ocs = xport->ocs;
+	ocs_domain_t *domain;
+	ocs_domain_t *next;
+
+	ocs_log_debug(ocs, "reset required, do force shutdown\n");
+	ocs_device_lock(ocs);
+		ocs_list_foreach_safe(&ocs->domain_list, domain, next) {
+			ocs_domain_force_free(domain);
+		}
+	ocs_device_unlock(ocs);
+}
+
+/**
+ * @brief Perform transport attach function.
+ *
+ * @par Description
+ * Perform the attach function, which for the FC transport makes a HW call
+ * to bring up the link.
+ *
+ * @param xport pointer to transport object.
+ * @param cmd command to execute.
+ *
+ * ocs_xport_control(ocs_xport_t *xport, OCS_XPORT_PORT_ONLINE)
+ * ocs_xport_control(ocs_xport_t *xport, OCS_XPORT_PORT_OFFLINE)
+ * ocs_xport_control(ocs_xport_t *xport, OCS_XPORT_PORT_SHUTDOWN)
+ * ocs_xport_control(ocs_xport_t *xport, OCS_XPORT_POST_NODE_EVENT, ocs_node_t *node, ocs_sm_event_t, void *context)
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+int32_t
+ocs_xport_control(ocs_xport_t *xport, ocs_xport_ctrl_e cmd, ...)
+{
+	uint32_t rc = 0;
+	ocs_t *ocs = NULL;
+	va_list argp;
+
+	ocs_assert(xport, -1);
+	ocs_assert(xport->ocs, -1);
+	ocs = xport->ocs;
+
+	switch (cmd) {
+	case OCS_XPORT_PORT_ONLINE: {
+		/* Bring the port on-line */
+		rc = ocs_hw_port_control(&ocs->hw, OCS_HW_PORT_INIT, 0, NULL, NULL);
+		if (rc) {
+			ocs_log_err(ocs, "%s: Can't init port\n", ocs->desc);
+		} else {
+			xport->configured_link_state = cmd;
+		}
+		break;
+	}
+	case OCS_XPORT_PORT_OFFLINE: {
+		if (ocs_hw_port_control(&ocs->hw, OCS_HW_PORT_SHUTDOWN, 0, NULL, NULL)) {
+			ocs_log_err(ocs, "port shutdown failed\n");
+		} else {
+			xport->configured_link_state = cmd;
+		}
+		break;
+	}
+
+	case OCS_XPORT_SHUTDOWN: {
+		ocs_sem_t sem;
+		uint32_t reset_required;
+
+		/* if a PHYSDEV reset was performed (e.g. hw dump), will affect
+		 * all PCI functions; orderly shutdown won't work, just force free
+		 */
+		/* TODO: need to poll this regularly... */
+		if (ocs_hw_get(&ocs->hw, OCS_HW_RESET_REQUIRED, &reset_required) != OCS_HW_RTN_SUCCESS) {
+			reset_required = 0;
+		}
+
+		if (reset_required) {
+			ocs_log_debug(ocs, "reset required, do force shutdown\n");
+			ocs_xport_force_free(xport);
+			break;
+		}
+		ocs_sem_init(&sem, 0, "domain_list_sem");
+		ocs_register_domain_list_empty_cb(ocs, ocs_xport_domain_list_empty_cb, &sem);
+
+		if (ocs_hw_port_control(&ocs->hw, OCS_HW_PORT_SHUTDOWN, 0, NULL, NULL)) {
+			ocs_log_debug(ocs, "port shutdown failed, do force shutdown\n");
+			ocs_xport_force_free(xport);
+		} else {
+			ocs_log_debug(ocs, "Waiting %d seconds for domain shutdown.\n", (OCS_FC_DOMAIN_SHUTDOWN_TIMEOUT_USEC/1000000));
+
+			rc = ocs_sem_p(&sem, OCS_FC_DOMAIN_SHUTDOWN_TIMEOUT_USEC);
+			if (rc) {
+				ocs_log_debug(ocs, "Note: Domain shutdown timed out\n");
+				ocs_xport_force_free(xport);
+			}
+		}
+
+		ocs_register_domain_list_empty_cb(ocs, NULL, NULL);
+
+		/* Free up any saved virtual ports */
+		ocs_vport_del_all(ocs);
+		break;
+	}
+
+	/*
+	 * POST_NODE_EVENT:  post an event to a node object
+	 *
+	 * This transport function is used to post an event to a node object. It does
+	 * this by submitting a NOP mailbox command to defer execution to the
+	 * interrupt context (thereby enforcing the serialized execution of event posting
+	 * to the node state machine instances)
+	 *
+	 * A counting semaphore is used to make the call synchronous (we wait until
+	 * the callback increments the semaphore before returning (or times out)
+	 */
+	case OCS_XPORT_POST_NODE_EVENT: {
+		ocs_node_t *node;
+		ocs_sm_event_t evt;
+		void *context;
+		ocs_xport_post_node_event_t payload;
+		ocs_t *ocs;
+		ocs_hw_t *hw;
+
+		/* Retrieve arguments */
+		va_start(argp, cmd);
+		node = va_arg(argp, ocs_node_t*);
+		evt = va_arg(argp, ocs_sm_event_t);
+		context = va_arg(argp, void *);
+		va_end(argp);
+
+		ocs_assert(node, -1);
+		ocs_assert(node->ocs, -1);
+
+		ocs = node->ocs;
+		hw = &ocs->hw;
+
+		/* if node's state machine is disabled, don't bother continuing */
+		if (!node->sm.current_state) {
+			ocs_log_test(ocs, "node %p state machine disabled\n", node);
+			return -1;
+		}
+
+		/* Setup payload */
+		ocs_memset(&payload, 0, sizeof(payload));
+		ocs_sem_init(&payload.sem, 0, "xport_post_node_Event");
+		payload.node = node;
+		payload.evt = evt;
+		payload.context = context;
+
+		if (ocs_hw_async_call(hw, ocs_xport_post_node_event_cb, &payload)) {
+			ocs_log_test(ocs, "ocs_hw_async_call failed\n");
+			rc = -1;
+			break;
+		}
+
+		/* Wait for completion */
+		if (ocs_sem_p(&payload.sem, OCS_SEM_FOREVER)) {
+			ocs_log_test(ocs, "POST_NODE_EVENT: sem wait failed\n");
+			rc = -1;
+		}
+
+		break;
+	}
+	/*
+	 * Set wwnn for the port.  This will be used instead of the default provided by FW.
+	 */
+	case OCS_XPORT_WWNN_SET: {
+		uint64_t wwnn;
+
+		/* Retrieve arguments */
+		va_start(argp, cmd);
+		wwnn = va_arg(argp, uint64_t);
+		va_end(argp);
+
+		ocs_log_debug(ocs, " WWNN %016" PRIx64 "\n", wwnn);
+		xport->req_wwnn = wwnn;
+
+		break;
+	}
+	/*
+	 * Set wwpn for the port.  This will be used instead of the default provided by FW.
+	 */
+	case OCS_XPORT_WWPN_SET: {
+		uint64_t wwpn;
+
+		/* Retrieve arguments */
+		va_start(argp, cmd);
+		wwpn = va_arg(argp, uint64_t);
+		va_end(argp);
+
+		ocs_log_debug(ocs, " WWPN %016" PRIx64 "\n", wwpn);
+		xport->req_wwpn = wwpn;
+
+		break;
+	}
+
+
+	default:
+		break;
+	}
+	return rc;
+}
+
+/**
+ * @brief Return status on a link.
+ *
+ * @par Description
+ * Returns status information about a link.
+ *
+ * @param xport Pointer to transport object.
+ * @param cmd Command to execute.
+ * @param result Pointer to result value.
+ *
+ * ocs_xport_status(ocs_xport_t *xport, OCS_XPORT_PORT_STATUS)
+ * ocs_xport_status(ocs_xport_t *xport, OCS_XPORT_LINK_SPEED, ocs_xport_stats_t *result)
+ *	return link speed in MB/sec
+ * ocs_xport_status(ocs_xport_t *xport, OCS_XPORT_IS_SUPPORTED_LINK_SPEED, ocs_xport_stats_t *result)
+ *	[in] *result is speed to check in MB/s
+ *	returns 1 if supported, 0 if not
+ * ocs_xport_status(ocs_xport_t *xport, OCS_XPORT_LINK_STATISTICS, ocs_xport_stats_t *result)
+ *	return link/host port stats
+ * ocs_xport_status(ocs_xport_t *xport, OCS_XPORT_LINK_STAT_RESET, ocs_xport_stats_t *result)
+ *	resets link/host stats
+ *
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+int32_t
+ocs_xport_status(ocs_xport_t *xport, ocs_xport_status_e cmd, ocs_xport_stats_t *result)
+{
+	uint32_t rc = 0;
+	ocs_t *ocs = NULL;
+	ocs_xport_stats_t value;
+	ocs_hw_rtn_e hw_rc;
+
+	ocs_assert(xport, -1);
+	ocs_assert(xport->ocs, -1);
+
+	ocs = xport->ocs;
+
+	switch (cmd) {
+	case OCS_XPORT_CONFIG_PORT_STATUS:
+		ocs_assert(result, -1);
+		if (xport->configured_link_state == 0) {
+			/* Initial state is offline. configured_link_state is    */
+			/* set to online explicitly when port is brought online. */
+			xport->configured_link_state = OCS_XPORT_PORT_OFFLINE;
+		}
+		result->value = xport->configured_link_state;
+		break;
+
+	case OCS_XPORT_PORT_STATUS:
+		ocs_assert(result, -1);
+		/* Determine port status based on link speed. */
+		hw_rc = ocs_hw_get(&(ocs->hw), OCS_HW_LINK_SPEED, &value.value);
+		if (hw_rc == OCS_HW_RTN_SUCCESS) {
+			if (value.value == 0) {
+				result->value = 0;
+			} else {
+				result->value = 1;
+			}
+			rc = 0;
+		} else {
+			rc = -1;
+		}
+		break;
+
+	case OCS_XPORT_LINK_SPEED: {
+		uint32_t speed;
+
+		ocs_assert(result, -1);
+		result->value = 0;
+
+		rc = ocs_hw_get(&ocs->hw, OCS_HW_LINK_SPEED, &speed);
+		if (rc == 0) {
+			result->value = speed;
+		}
+		break;
+	}
+
+	case OCS_XPORT_IS_SUPPORTED_LINK_SPEED: {
+		uint32_t speed;
+		uint32_t link_module_type;
+
+		ocs_assert(result, -1);
+		speed = result->value;
+
+		rc = ocs_hw_get(&ocs->hw, OCS_HW_LINK_MODULE_TYPE, &link_module_type);
+		if (rc == 0) {
+			switch(speed) {
+			case 1000:	rc = (link_module_type & OCS_HW_LINK_MODULE_TYPE_1GB) != 0; break;
+			case 2000:	rc = (link_module_type & OCS_HW_LINK_MODULE_TYPE_2GB) != 0; break;
+			case 4000:	rc = (link_module_type & OCS_HW_LINK_MODULE_TYPE_4GB) != 0; break;
+			case 8000:	rc = (link_module_type & OCS_HW_LINK_MODULE_TYPE_8GB) != 0; break;
+			case 10000:	rc = (link_module_type & OCS_HW_LINK_MODULE_TYPE_10GB) != 0; break;
+			case 16000:	rc = (link_module_type & OCS_HW_LINK_MODULE_TYPE_16GB) != 0; break;
+			case 32000:	rc = (link_module_type & OCS_HW_LINK_MODULE_TYPE_32GB) != 0; break;
+			default:	rc = 0; break;
+			}
+		} else {
+			rc = 0;
+		}
+		break;
+	}
+	case OCS_XPORT_LINK_STATISTICS: 
+		ocs_device_lock(ocs);
+			ocs_memcpy((void *)result, &ocs->xport->fc_xport_stats, sizeof(ocs_xport_stats_t));
+		ocs_device_unlock(ocs);
+		break;
+	case OCS_XPORT_LINK_STAT_RESET: {
+		/* Create a semaphore to synchronize the stat reset process. */
+		ocs_sem_init(&(result->stats.semaphore), 0, "fc_stats_reset");
+
+		/* First reset the link stats */
+		if ((rc = ocs_hw_get_link_stats(&ocs->hw, 0, 1, 1, ocs_xport_link_stats_cb, result)) != 0) {
+			ocs_log_err(ocs, "%s: Failed to reset link statistics\n", __func__);
+			break;
+		}
+
+		/* Wait for semaphore to be signaled when the command completes */
+		/* TODO:  Should there be a timeout on this?  If so, how long? */
+		if (ocs_sem_p(&(result->stats.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_test(ocs, "ocs_sem_p failed\n");
+			rc = -ENXIO;
+			break;
+		}
+
+		/* Next reset the host stats */
+		if ((rc = ocs_hw_get_host_stats(&ocs->hw, 1,  ocs_xport_host_stats_cb, result)) != 0) {
+			ocs_log_err(ocs, "%s: Failed to reset host statistics\n", __func__);
+			break;
+		}
+
+		/* Wait for semaphore to be signaled when the command completes */
+		if (ocs_sem_p(&(result->stats.semaphore), OCS_SEM_FOREVER) != 0) {
+			/* Undefined failure */
+			ocs_log_test(ocs, "ocs_sem_p failed\n");
+			rc = -ENXIO;
+			break;
+		}
+		break;
+	}
+	case OCS_XPORT_IS_QUIESCED:
+		ocs_device_lock(ocs);
+			result->value = ocs_list_empty(&ocs->domain_list);
+		ocs_device_unlock(ocs);
+		break;
+	default:
+		rc = -1;
+		break;
+	}
+
+	return rc;
+
+}
+
+static void
+ocs_xport_link_stats_cb(int32_t status, uint32_t num_counters, ocs_hw_link_stat_counts_t *counters, void *arg)
+{
+        ocs_xport_stats_t *result = arg;
+
+        result->stats.link_stats.link_failure_error_count = counters[OCS_HW_LINK_STAT_LINK_FAILURE_COUNT].counter;
+        result->stats.link_stats.loss_of_sync_error_count = counters[OCS_HW_LINK_STAT_LOSS_OF_SYNC_COUNT].counter;
+        result->stats.link_stats.primitive_sequence_error_count = counters[OCS_HW_LINK_STAT_PRIMITIVE_SEQ_COUNT].counter;
+        result->stats.link_stats.invalid_transmission_word_error_count = counters[OCS_HW_LINK_STAT_INVALID_XMIT_WORD_COUNT].counter;
+        result->stats.link_stats.crc_error_count = counters[OCS_HW_LINK_STAT_CRC_COUNT].counter;
+
+        ocs_sem_v(&(result->stats.semaphore));
+}
+
+
+static void
+ocs_xport_host_stats_cb(int32_t status, uint32_t num_counters, ocs_hw_host_stat_counts_t *counters, void *arg)
+{
+        ocs_xport_stats_t *result = arg;
+
+        result->stats.host_stats.transmit_kbyte_count = counters[OCS_HW_HOST_STAT_TX_KBYTE_COUNT].counter;
+        result->stats.host_stats.receive_kbyte_count = counters[OCS_HW_HOST_STAT_RX_KBYTE_COUNT].counter;
+        result->stats.host_stats.transmit_frame_count = counters[OCS_HW_HOST_STAT_TX_FRAME_COUNT].counter;
+        result->stats.host_stats.receive_frame_count = counters[OCS_HW_HOST_STAT_RX_FRAME_COUNT].counter;
+
+        ocs_sem_v(&(result->stats.semaphore));
+}
+
+
+/**
+ * @brief Free a transport object.
+ *
+ * @par Description
+ * The transport object is freed.
+ *
+ * @param xport Pointer to transport object.
+ *
+ * @return None.
+ */
+
+void
+ocs_xport_free(ocs_xport_t *xport)
+{
+	ocs_t *ocs;
+	uint32_t i;
+
+	if (xport) {
+		ocs = xport->ocs;
+		ocs_io_pool_free(xport->io_pool);
+		ocs_node_free_pool(ocs);
+		if(mtx_initialized(&xport->io_pending_lock.lock))
+			ocs_lock_free(&xport->io_pending_lock);
+
+		for (i = 0; i < SLI4_MAX_FCFI; i++) {
+			ocs_lock_free(&xport->fcfi[i].pend_frames_lock);
+		}
+
+		ocs_xport_rq_threads_teardown(xport);
+
+		ocs_free(ocs, xport, sizeof(*xport));
+	}
+}
diff --git a/sys/dev/ocs_fc/ocs_xport.h b/sys/dev/ocs_fc/ocs_xport.h
new file mode 100644
index 000000000000..c7841cd5122e
--- /dev/null
+++ b/sys/dev/ocs_fc/ocs_xport.h
@@ -0,0 +1,213 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ *
+ */
+
+#if !defined(__OCS_XPORT_H__)
+#define __OCS_XPORT_H__
+
+/**
+ * @brief FCFI lookup/pending frames
+ */
+typedef struct ocs_xport_fcfi_s {
+	ocs_lock_t	pend_frames_lock;
+	ocs_list_t	pend_frames;
+	uint32_t	hold_frames:1;		/*<< hold pending frames */
+	uint32_t	pend_frames_processed;	/*<< count of pending frames that were processed */
+} ocs_xport_fcfi_t;
+
+/**
+ * @brief Structure to hold the information related to an RQ processing thread used
+ *        to increase 40G performance.
+ */
+typedef struct ocs_xport_rq_thread_info_s {
+	ocs_t *ocs;
+	uint8_t thread_started;
+	ocs_thread_t thread;
+	ocs_cbuf_t * seq_cbuf;
+	char thread_name[64];
+} ocs_xport_rq_thread_info_t;
+
+typedef enum {
+	OCS_XPORT_PORT_ONLINE=1,
+	OCS_XPORT_PORT_OFFLINE,
+	OCS_XPORT_SHUTDOWN,
+	OCS_XPORT_POST_NODE_EVENT,
+	OCS_XPORT_WWNN_SET,
+	OCS_XPORT_WWPN_SET,
+} ocs_xport_ctrl_e;
+
+typedef enum {
+	OCS_XPORT_PORT_STATUS,
+	OCS_XPORT_CONFIG_PORT_STATUS,
+	OCS_XPORT_LINK_SPEED,
+	OCS_XPORT_IS_SUPPORTED_LINK_SPEED,
+	OCS_XPORT_LINK_STATISTICS,
+	OCS_XPORT_LINK_STAT_RESET,
+	OCS_XPORT_IS_QUIESCED
+} ocs_xport_status_e;
+
+typedef struct ocs_xport_link_stats_s {
+	uint32_t	rec:1,
+				gec:1,
+				w02of:1,
+				w03of:1,
+				w04of:1,
+				w05of:1,
+				w06of:1,
+				w07of:1,
+				w08of:1,
+				w09of:1,
+				w10of:1,
+				w11of:1,
+				w12of:1,
+				w13of:1,
+				w14of:1,
+				w15of:1,
+				w16of:1,
+				w17of:1,
+				w18of:1,
+				w19of:1,
+				w20of:1,
+				w21of:1,
+				resv0:8,
+				clrc:1,
+				clof:1;
+	uint32_t	link_failure_error_count;
+	uint32_t	loss_of_sync_error_count;
+	uint32_t	loss_of_signal_error_count;
+	uint32_t	primitive_sequence_error_count;
+	uint32_t	invalid_transmission_word_error_count;
+	uint32_t	crc_error_count;
+	uint32_t	primitive_sequence_event_timeout_count;
+	uint32_t	elastic_buffer_overrun_error_count;
+	uint32_t	arbitration_fc_al_timout_count;
+	uint32_t	advertised_receive_bufftor_to_buffer_credit;
+	uint32_t	current_receive_buffer_to_buffer_credit;
+	uint32_t	advertised_transmit_buffer_to_buffer_credit;
+	uint32_t	current_transmit_buffer_to_buffer_credit;
+	uint32_t	received_eofa_count;
+	uint32_t	received_eofdti_count;
+	uint32_t	received_eofni_count;
+	uint32_t	received_soff_count;
+	uint32_t	received_dropped_no_aer_count;
+	uint32_t	received_dropped_no_available_rpi_resources_count;
+	uint32_t	received_dropped_no_available_xri_resources_count;
+} ocs_xport_link_stats_t;
+
+typedef struct ocs_xport_host_stats_s {
+	uint32_t	cc:1,
+				  :31;
+	uint32_t	transmit_kbyte_count;
+	uint32_t	receive_kbyte_count;
+	uint32_t	transmit_frame_count;
+	uint32_t	receive_frame_count;
+	uint32_t	transmit_sequence_count;
+	uint32_t	receive_sequence_count;
+	uint32_t	total_exchanges_originator;
+	uint32_t	total_exchanges_responder;
+	uint32_t	receive_p_bsy_count;
+	uint32_t	receive_f_bsy_count;
+	uint32_t	dropped_frames_due_to_no_rq_buffer_count;
+	uint32_t	empty_rq_timeout_count;
+	uint32_t	dropped_frames_due_to_no_xri_count;
+	uint32_t	empty_xri_pool_count;
+} ocs_xport_host_stats_t;
+
+typedef struct ocs_xport_host_statistics_s {
+	ocs_sem_t semaphore;
+	ocs_xport_link_stats_t link_stats;
+	ocs_xport_host_stats_t host_stats;
+} ocs_xport_host_statistics_t;
+
+typedef union ocs_xport {
+	uint32_t value;
+	ocs_xport_host_statistics_t stats;
+} ocs_xport_stats_t;
+/**
+ * @brief Transport private values
+ */
+struct ocs_xport_s {
+	ocs_t *ocs;
+	uint64_t req_wwpn;			/*<< wwpn requested by user for primary sport */
+	uint64_t req_wwnn;			/*<< wwnn requested by user for primary sport */
+
+	ocs_xport_fcfi_t fcfi[SLI4_MAX_FCFI];
+
+	/* Nodes */
+	uint32_t nodes_count;			/**< number of allocated nodes */
+	ocs_node_t **nodes;			/**< array of pointers to nodes */
+	ocs_list_t nodes_free_list;		/**< linked list of free nodes */
+
+	/* Io pool and counts */
+	ocs_io_pool_t *io_pool;			/**< pointer to IO pool */
+	ocs_atomic_t io_alloc_failed_count;	/**< used to track how often IO pool is empty */
+	ocs_lock_t io_pending_lock;		/**< lock for io_pending_list */
+	ocs_list_t io_pending_list;		/**< list of IOs waiting for HW resources
+						 **  lock: xport->io_pending_lock
+						 **  link: ocs_io_t->io_pending_link
+						 */
+	ocs_atomic_t io_total_alloc;		/**< count of totals IOS allocated */
+	ocs_atomic_t io_total_free;		/**< count of totals IOS free'd */
+	ocs_atomic_t io_total_pending;		/**< count of totals IOS that were pended */
+	ocs_atomic_t io_active_count;		/**< count of active IOS */
+	ocs_atomic_t io_pending_count;		/**< count of pending IOS */
+	ocs_atomic_t io_pending_recursing;	/**< non-zero if ocs_scsi_check_pending is executing */
+
+	/* vport */
+	ocs_list_t vport_list;			/**< list of VPORTS (NPIV) */
+
+	/* Port */
+	uint32_t configured_link_state;		/**< requested link state */
+
+	/* RQ processing threads */
+	uint32_t num_rq_threads;
+	ocs_xport_rq_thread_info_t *rq_thread_info;
+
+	ocs_timer_t     stats_timer;            /**< Timer for Statistics */
+	ocs_xport_stats_t fc_xport_stats;
+};
+
+
+extern ocs_xport_t *ocs_xport_alloc(ocs_t *ocs);
+extern int32_t ocs_xport_attach(ocs_xport_t *xport);
+extern int32_t ocs_xport_initialize(ocs_xport_t *xport);
+extern int32_t ocs_xport_detach(ocs_xport_t *xport);
+extern int32_t ocs_xport_control(ocs_xport_t *xport, ocs_xport_ctrl_e cmd, ...);
+extern int32_t ocs_xport_status(ocs_xport_t *xport, ocs_xport_status_e cmd, ocs_xport_stats_t *result);
+extern void ocs_xport_free(ocs_xport_t *xport);
+
+#endif 
diff --git a/sys/dev/ocs_fc/sli4.c b/sys/dev/ocs_fc/sli4.c
new file mode 100644
index 000000000000..c346fb2e0d8c
--- /dev/null
+++ b/sys/dev/ocs_fc/sli4.c
@@ -0,0 +1,8648 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @defgroup sli SLI-4 Base APIs
+ */
+
+/**
+ * @file
+ * All common (i.e. transport-independent) SLI-4 functions are implemented
+ * in this file.
+ */
+
+#include "sli4.h"
+
+#if defined(OCS_INCLUDE_DEBUG)
+#include "ocs_utils.h"
+#endif
+
+#define SLI4_BMBX_DELAY_US 1000 /* 1 ms */
+#define SLI4_INIT_PORT_DELAY_US 10000 /* 10 ms */
+
+static int32_t sli_fw_init(sli4_t *);
+static int32_t sli_fw_term(sli4_t *);
+static int32_t sli_sliport_control(sli4_t *sli4, uint32_t endian);
+static int32_t sli_cmd_fw_deinitialize(sli4_t *, void *, size_t);
+static int32_t sli_cmd_fw_initialize(sli4_t *, void *, size_t);
+static int32_t sli_queue_doorbell(sli4_t *, sli4_queue_t *);
+static uint8_t sli_queue_entry_is_valid(sli4_queue_t *, uint8_t *, uint8_t);
+
+const uint8_t sli4_fw_initialize[] = {
+	0xff, 0x12, 0x34, 0xff,
+	0xff, 0x56, 0x78, 0xff,
+};
+
+const uint8_t sli4_fw_deinitialize[] = {
+	0xff, 0xaa, 0xbb, 0xff,
+	0xff, 0xcc, 0xdd, 0xff,
+};
+
+typedef struct {
+	uint32_t rev_id;
+	uint32_t family;	/* generation */
+	sli4_asic_type_e type;
+	sli4_asic_rev_e rev;
+} sli4_asic_entry_t;
+
+sli4_asic_entry_t sli4_asic_table[] = {
+	{	0x00,	1,	SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_A0},
+	{	0x01,	1,	SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_A1},
+	{	0x02,	1,	SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_A2},
+	{	0x00,	4,	SLI4_ASIC_TYPE_SKYHAWK,	SLI4_ASIC_REV_A0},
+	{	0x00,	2,	SLI4_ASIC_TYPE_SKYHAWK,	SLI4_ASIC_REV_A0},
+	{	0x10,	1,	SLI4_ASIC_TYPE_BE3,	SLI4_ASIC_REV_B0},
+	{	0x10,	0x04,	SLI4_ASIC_TYPE_SKYHAWK,	SLI4_ASIC_REV_B0},
+	{	0x11,	0x04,	SLI4_ASIC_TYPE_SKYHAWK,	SLI4_ASIC_REV_B1},
+	{	0x0,	0x0a,	SLI4_ASIC_TYPE_LANCER,	SLI4_ASIC_REV_A0},
+	{	0x10,	0x0b,	SLI4_ASIC_TYPE_LANCER,	SLI4_ASIC_REV_B0},
+	{	0x30,	0x0b,	SLI4_ASIC_TYPE_LANCER,	SLI4_ASIC_REV_D0},
+	{	0x3,	0x0b,	SLI4_ASIC_TYPE_LANCERG6,SLI4_ASIC_REV_A3},
+	{	0x0,	0x0c,	SLI4_ASIC_TYPE_LANCERG6,SLI4_ASIC_REV_A0},
+	{	0x1,	0x0c,	SLI4_ASIC_TYPE_LANCERG6,SLI4_ASIC_REV_A1},
+	{	0x3,	0x0c,	SLI4_ASIC_TYPE_LANCERG6,SLI4_ASIC_REV_A3},
+
+	{	0x00,	0x05,	SLI4_ASIC_TYPE_CORSAIR,	SLI4_ASIC_REV_A0},
+};
+
+/*
+ * @brief Convert queue type enum (SLI_QTYPE_*) into a string.
+ */
+const char *SLI_QNAME[] = {
+	"Event Queue",
+	"Completion Queue",
+	"Mailbox Queue",
+	"Work Queue",
+	"Receive Queue",
+	"Undefined"
+};
+
+/**
+ * @brief Define the mapping of registers to their BAR and offset.
+ *
+ * @par Description
+ * Although SLI-4 specification defines a common set of registers, their locations
+ * (both BAR and offset) depend on the interface type. This array maps a register
+ * enum to an array of BAR/offset pairs indexed by the interface type. For
+ * example, to access the bootstrap mailbox register on an interface type 0
+ * device, code can refer to the offset using regmap[SLI4_REG_BMBX][0].offset.
+ *
+ * @b Note: A value of UINT32_MAX for either the register set (rset) or offset (off)
+ * indicates an invalid mapping.
+ */
+const sli4_reg_t regmap[SLI4_REG_MAX][SLI4_MAX_IF_TYPES] = {
+	/* SLI4_REG_BMBX */
+	{
+		{ 2, SLI4_BMBX_REG }, { 0, SLI4_BMBX_REG }, { 0, SLI4_BMBX_REG }, { 0, SLI4_BMBX_REG },
+	},
+	/* SLI4_REG_EQCQ_DOORBELL */
+	{
+		{ 2, SLI4_EQCQ_DOORBELL_REG }, { 0, SLI4_EQCQ_DOORBELL_REG },
+		{ 0, SLI4_EQCQ_DOORBELL_REG }, { 0, SLI4_EQCQ_DOORBELL_REG },
+	},
+	/* SLI4_REG_FCOE_RQ_DOORBELL */
+	{
+		{ 2, SLI4_RQ_DOORBELL_REG }, { 0, SLI4_RQ_DOORBELL_REG },
+		{ 0, SLI4_RQ_DOORBELL_REG }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_IO_WQ_DOORBELL */
+	{
+		{ 2, SLI4_IO_WQ_DOORBELL_REG }, { 0, SLI4_IO_WQ_DOORBELL_REG }, { 0, SLI4_IO_WQ_DOORBELL_REG }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_MQ_DOORBELL */
+	{
+		{ 2, SLI4_MQ_DOORBELL_REG }, { 0, SLI4_MQ_DOORBELL_REG },
+		{ 0, SLI4_MQ_DOORBELL_REG }, { 0, SLI4_MQ_DOORBELL_REG },
+	},
+	/* SLI4_REG_PHYSDEV_CONTROL */
+	{
+		{ UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { 0, SLI4_PHSDEV_CONTROL_REG_23 }, { 0, SLI4_PHSDEV_CONTROL_REG_23 },
+	},
+	/* SLI4_REG_SLIPORT_CONTROL */
+	{
+		{ UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { 0, SLI4_SLIPORT_CONTROL_REG }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_SLIPORT_ERROR1 */
+	{
+		{ UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { 0, SLI4_SLIPORT_ERROR1 }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_SLIPORT_ERROR2 */
+	{
+		{ UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { 0, SLI4_SLIPORT_ERROR2 }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_SLIPORT_SEMAPHORE */
+	{
+		{ 1, SLI4_PORT_SEMAPHORE_REG_0 },  { 0, SLI4_PORT_SEMAPHORE_REG_1 },
+		{ 0, SLI4_PORT_SEMAPHORE_REG_23 }, { 0, SLI4_PORT_SEMAPHORE_REG_23 },
+	},
+	/* SLI4_REG_SLIPORT_STATUS */
+	{
+		{ UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { 0, SLI4_PORT_STATUS_REG_23 }, { 0, SLI4_PORT_STATUS_REG_23 },
+	},
+	/* SLI4_REG_UERR_MASK_HI */
+	{
+		{ 0, SLI4_UERR_MASK_HIGH_REG }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_UERR_MASK_LO */
+	{
+		{ 0, SLI4_UERR_MASK_LOW_REG }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_UERR_STATUS_HI */
+	{
+		{ 0, SLI4_UERR_STATUS_HIGH_REG }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_UERR_STATUS_LO */
+	{
+		{ 0, SLI4_UERR_STATUS_LOW_REG }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_SW_UE_CSR1 */
+	{
+		{ 1, SLI4_SW_UE_CSR1}, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX },
+	},
+	/* SLI4_REG_SW_UE_CSR2 */
+	{
+		{ 1, SLI4_SW_UE_CSR2}, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX }, { UINT32_MAX, UINT32_MAX },
+	},
+};
+
+/**
+ * @brief Read the given SLI register.
+ *
+ * @param sli Pointer to the SLI context.
+ * @param reg Register name enum.
+ *
+ * @return Returns the register value.
+ */
+uint32_t
+sli_reg_read(sli4_t *sli, sli4_regname_e reg)
+{
+	const sli4_reg_t	*r = &(regmap[reg][sli->if_type]);
+
+	if ((UINT32_MAX == r->rset) || (UINT32_MAX == r->off)) {
+		ocs_log_err(sli->os, "regname %d not defined for if_type %d\n", reg, sli->if_type);
+		return UINT32_MAX;
+	}
+
+	return ocs_reg_read32(sli->os, r->rset, r->off);
+}
+
+/**
+ * @brief Write the value to the given SLI register.
+ *
+ * @param sli Pointer to the SLI context.
+ * @param reg Register name enum.
+ * @param val Value to write.
+ *
+ * @return None.
+ */
+void
+sli_reg_write(sli4_t *sli, sli4_regname_e reg, uint32_t val)
+{
+	const sli4_reg_t	*r = &(regmap[reg][sli->if_type]);
+
+	if ((UINT32_MAX == r->rset) || (UINT32_MAX == r->off)) {
+		ocs_log_err(sli->os, "regname %d not defined for if_type %d\n", reg, sli->if_type);
+		return;
+	}
+
+	ocs_reg_write32(sli->os, r->rset, r->off, val);
+}
+
+/**
+ * @brief Check if the SLI_INTF register is valid.
+ *
+ * @param val 32-bit SLI_INTF register value.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static uint8_t
+sli_intf_valid_check(uint32_t val)
+{
+	return ((val >> SLI4_INTF_VALID_SHIFT) & SLI4_INTF_VALID_MASK) != SLI4_INTF_VALID;
+}
+
+/**
+ * @brief Retrieve the SLI revision level.
+ *
+ * @param val 32-bit SLI_INTF register value.
+ *
+ * @return Returns the SLI revision level.
+ */
+static uint8_t
+sli_intf_sli_revision(uint32_t val)
+{
+	return ((val >> SLI4_INTF_SLI_REVISION_SHIFT) & SLI4_INTF_SLI_REVISION_MASK);
+}
+
+static uint8_t
+sli_intf_sli_family(uint32_t val)
+{
+	return ((val >> SLI4_INTF_SLI_FAMILY_SHIFT) & SLI4_INTF_SLI_FAMILY_MASK);
+}
+
+/**
+ * @brief Retrieve the SLI interface type.
+ *
+ * @param val 32-bit SLI_INTF register value.
+ *
+ * @return Returns the SLI interface type.
+ */
+static uint8_t
+sli_intf_if_type(uint32_t val)
+{
+	return ((val >> SLI4_INTF_IF_TYPE_SHIFT) & SLI4_INTF_IF_TYPE_MASK);
+}
+
+/**
+ * @brief Retrieve PCI revision ID.
+ *
+ * @param val 32-bit PCI CLASS_REVISION register value.
+ *
+ * @return Returns the PCI revision ID.
+ */
+static uint8_t
+sli_pci_rev_id(uint32_t val)
+{
+	return ((val >> SLI4_PCI_REV_ID_SHIFT) & SLI4_PCI_REV_ID_MASK);
+}
+
+/**
+ * @brief retrieve SLI ASIC generation
+ *
+ * @param val 32-bit SLI_ASIC_ID register value
+ *
+ * @return SLI ASIC generation
+ */
+static uint8_t
+sli_asic_gen(uint32_t val)
+{
+	return ((val >> SLI4_ASIC_GEN_SHIFT) & SLI4_ASIC_GEN_MASK);
+}
+
+/**
+ * @brief Wait for the bootstrap mailbox to report "ready".
+ *
+ * @param sli4 SLI context pointer.
+ * @param msec Number of milliseconds to wait.
+ *
+ * @return Returns 0 if BMBX is ready, or non-zero otherwise (i.e. time out occurred).
+ */
+static int32_t
+sli_bmbx_wait(sli4_t *sli4, uint32_t msec)
+{
+	uint32_t	val = 0;
+
+	do {
+		ocs_udelay(SLI4_BMBX_DELAY_US);
+		val = sli_reg_read(sli4, SLI4_REG_BMBX);
+		msec--;
+	} while(msec && !(val & SLI4_BMBX_RDY));
+
+	return(!(val & SLI4_BMBX_RDY));
+}
+
+/**
+ * @brief Write bootstrap mailbox.
+ *
+ * @param sli4 SLI context pointer.
+ *
+ * @return Returns 0 if command succeeded, or non-zero otherwise.
+ */
+static int32_t
+sli_bmbx_write(sli4_t *sli4)
+{
+	uint32_t	val = 0;
+
+	/* write buffer location to bootstrap mailbox register */
+	ocs_dma_sync(&sli4->bmbx, OCS_DMASYNC_PREWRITE);
+	val = SLI4_BMBX_WRITE_HI(sli4->bmbx.phys);
+	sli_reg_write(sli4, SLI4_REG_BMBX, val);
+
+	if (sli_bmbx_wait(sli4, SLI4_BMBX_DELAY_US)) {
+		ocs_log_crit(sli4->os, "BMBX WRITE_HI failed\n");
+		return -1;
+	}
+	val = SLI4_BMBX_WRITE_LO(sli4->bmbx.phys);
+	sli_reg_write(sli4, SLI4_REG_BMBX, val);
+
+	/* wait for SLI Port to set ready bit */
+	return sli_bmbx_wait(sli4, SLI4_BMBX_TIMEOUT_MSEC/*XXX*/);
+}
+
+#if defined(OCS_INCLUDE_DEBUG)
+/**
+ * @ingroup sli
+ * @brief Dump BMBX mailbox command.
+ *
+ * @par Description
+ * Convenience function for dumping BMBX mailbox commands. Takes
+ * into account which mailbox command is given since SLI_CONFIG
+ * commands are special.
+ *
+ * @b Note: This function takes advantage of
+ * the one-command-at-a-time nature of the BMBX to be able to
+ * display non-embedded SLI_CONFIG commands. This will not work
+ * for mailbox commands on the MQ. Luckily, all current non-emb
+ * mailbox commands go through the BMBX.
+ *
+ * @param sli4 SLI context pointer.
+ * @param mbx Pointer to mailbox command to dump.
+ * @param prefix Prefix for dump label.
+ *
+ * @return None.
+ */
+static void
+sli_dump_bmbx_command(sli4_t *sli4, void *mbx, const char *prefix)
+{
+	uint32_t size = 0;
+	char label[64];
+	uint32_t i;
+	/* Mailbox diagnostic logging */
+	sli4_mbox_command_header_t *hdr = (sli4_mbox_command_header_t *)mbx;
+
+	if (!ocs_debug_is_enabled(OCS_DEBUG_ENABLE_MQ_DUMP)) {
+		return;
+	}
+
+	if (hdr->command == SLI4_MBOX_COMMAND_SLI_CONFIG) {
+		sli4_cmd_sli_config_t *sli_config = (sli4_cmd_sli_config_t *)hdr;
+		sli4_req_hdr_t	*sli_config_hdr;
+		if (sli_config->emb) {
+			ocs_snprintf(label, sizeof(label), "%s (emb)", prefix);
+
+			/*  if embedded, dump entire command */
+			sli_config_hdr = (sli4_req_hdr_t *)sli_config->payload.embed;
+			size = sizeof(*sli_config) - sizeof(sli_config->payload) +
+				sli_config_hdr->request_length + (4*sizeof(uint32_t));
+			ocs_dump32(OCS_DEBUG_ENABLE_MQ_DUMP, sli4->os, label,
+				   (uint8_t *)sli4->bmbx.virt, size);
+		} else {
+			sli4_sli_config_pmd_t *pmd;
+			ocs_snprintf(label, sizeof(label), "%s (non-emb hdr)", prefix);
+
+			/* if non-embedded, break up into two parts: SLI_CONFIG hdr
+			   and the payload(s) */
+			size = sizeof(*sli_config) - sizeof(sli_config->payload) + (12 * sli_config->pmd_count);
+			ocs_dump32(OCS_DEBUG_ENABLE_MQ_DUMP, sli4->os, label,
+				   (uint8_t *)sli4->bmbx.virt, size);
+
+			/* as sanity check, make sure first PMD matches what was saved */
+			pmd = &sli_config->payload.mem;
+			if ((pmd->address_high == ocs_addr32_hi(sli4->bmbx_non_emb_pmd->phys)) &&
+			    (pmd->address_low == ocs_addr32_lo(sli4->bmbx_non_emb_pmd->phys))) {
+				for (i = 0; i < sli_config->pmd_count; i++, pmd++) {
+					sli_config_hdr = sli4->bmbx_non_emb_pmd->virt;
+					ocs_snprintf(label, sizeof(label), "%s (non-emb pay[%d])",
+						     prefix, i);
+					ocs_dump32(OCS_DEBUG_ENABLE_MQ_DUMP, sli4->os, label,
+						   (uint8_t *)sli4->bmbx_non_emb_pmd->virt,
+						   sli_config_hdr->request_length + (4*sizeof(uint32_t)));
+				}
+			} else {
+				ocs_log_debug(sli4->os, "pmd addr does not match pmd:%x %x (%x %x)\n",
+					pmd->address_high, pmd->address_low,
+					ocs_addr32_hi(sli4->bmbx_non_emb_pmd->phys),
+					ocs_addr32_lo(sli4->bmbx_non_emb_pmd->phys));
+			}
+
+		}
+	} else {
+		/* not an SLI_CONFIG command, just display first 64 bytes, like we do
+		   for MQEs */
+		size = 64;
+		ocs_dump32(OCS_DEBUG_ENABLE_MQ_DUMP, sli4->os, prefix,
+			   (uint8_t *)mbx, size);
+	}
+}
+#endif
+
+/**
+ * @ingroup sli
+ * @brief Submit a command to the bootstrap mailbox and check the status.
+ *
+ * @param sli4 SLI context pointer.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_bmbx_command(sli4_t *sli4)
+{
+	void *cqe = (uint8_t *)sli4->bmbx.virt + SLI4_BMBX_SIZE;
+
+#if defined(OCS_INCLUDE_DEBUG)
+	sli_dump_bmbx_command(sli4, sli4->bmbx.virt, "bmbx cmd");
+#endif
+
+	if (sli_fw_error_status(sli4) > 0) {
+		ocs_log_crit(sli4->os, "Chip is in an error state - Mailbox "
+			"command rejected status=%#x error1=%#x error2=%#x\n",
+			sli_reg_read(sli4, SLI4_REG_SLIPORT_STATUS),
+			sli_reg_read(sli4, SLI4_REG_SLIPORT_ERROR1),
+			sli_reg_read(sli4, SLI4_REG_SLIPORT_ERROR2));
+		return -1;
+	}
+
+	if (sli_bmbx_write(sli4)) {
+		ocs_log_crit(sli4->os, "bootstrap mailbox write fail phys=%p reg=%#x\n",
+			(void*)sli4->bmbx.phys,
+			sli_reg_read(sli4, SLI4_REG_BMBX));
+		return -1;
+	}
+
+	/* check completion queue entry status */
+	ocs_dma_sync(&sli4->bmbx, OCS_DMASYNC_POSTREAD);
+	if (((sli4_mcqe_t *)cqe)->val) {
+#if defined(OCS_INCLUDE_DEBUG)
+		sli_dump_bmbx_command(sli4, sli4->bmbx.virt, "bmbx cmpl");
+        ocs_dump32(OCS_DEBUG_ENABLE_CQ_DUMP, sli4->os, "bmbx cqe", cqe, sizeof(sli4_mcqe_t));
+#endif
+		return sli_cqe_mq(cqe);
+	} else {
+		ocs_log_err(sli4->os, "invalid or wrong type\n");
+		return -1;
+	}
+}
+
+/****************************************************************************
+ * Messages
+ */
+
+/**
+ * @ingroup sli
+ * @brief Write a CONFIG_LINK command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_config_link(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_cmd_config_link_t	*config_link = buf;
+
+	ocs_memset(buf, 0, size);
+
+	config_link->hdr.command = SLI4_MBOX_COMMAND_CONFIG_LINK;
+
+	/* Port interprets zero in a field as "use default value" */
+
+	return sizeof(sli4_cmd_config_link_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a DOWN_LINK command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_down_link(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_mbox_command_header_t	*hdr = buf;
+
+	ocs_memset(buf, 0, size);
+
+	hdr->command = SLI4_MBOX_COMMAND_DOWN_LINK;
+
+	/* Port interprets zero in a field as "use default value" */
+
+	return sizeof(sli4_mbox_command_header_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a DUMP Type 4 command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param wki The well known item ID.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_dump_type4(sli4_t *sli4, void *buf, size_t size, uint16_t wki)
+{
+	sli4_cmd_dump4_t	*cmd = buf;
+
+	ocs_memset(buf, 0, size);
+
+	cmd->hdr.command = SLI4_MBOX_COMMAND_DUMP;
+	cmd->type = 4;
+	cmd->wki_selection = wki;
+	return sizeof(sli4_cmd_dump4_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_READ_TRANSCEIVER_DATA command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param page_num The page of SFP data to retrieve (0xa0 or 0xa2).
+ * @param dma DMA structure from which the data will be copied.
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_read_transceiver_data(sli4_t *sli4, void *buf, size_t size, uint32_t page_num,
+				     ocs_dma_t *dma)
+{
+	sli4_req_common_read_transceiver_data_t *req = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	payload_size;
+
+	if (dma == NULL) {
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_common_read_transceiver_data_t),
+				   sizeof(sli4_res_common_read_transceiver_data_t));
+	} else {
+		payload_size = dma->size;
+	}
+
+	if (sli4->port_type == SLI4_PORT_TYPE_FC) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size, dma);
+	}
+
+	if (dma == NULL) {
+		req = (sli4_req_common_read_transceiver_data_t *)((uint8_t *)buf + sli_config_off);
+	} else {
+		req = (sli4_req_common_read_transceiver_data_t *)dma->virt;
+		ocs_memset(req, 0, dma->size);
+	}
+
+	req->hdr.opcode = SLI4_OPC_COMMON_READ_TRANSCEIVER_DATA;
+	req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+
+	req->page_number = page_num;
+	req->port = sli4->physical_port;
+
+	return(sli_config_off + sizeof(sli4_req_common_read_transceiver_data_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a READ_LINK_STAT command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param req_ext_counters If TRUE, then the extended counters will be requested.
+ * @param clear_overflow_flags If TRUE, then overflow flags will be cleared.
+ * @param clear_all_counters If TRUE, the counters will be cleared.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_read_link_stats(sli4_t *sli4, void *buf, size_t size,
+			uint8_t req_ext_counters,
+			uint8_t clear_overflow_flags,
+			uint8_t clear_all_counters)
+{
+	sli4_cmd_read_link_stats_t	*cmd = buf;
+
+	ocs_memset(buf, 0, size);
+
+	cmd->hdr.command = SLI4_MBOX_COMMAND_READ_LNK_STAT;
+	cmd->rec = req_ext_counters;
+	cmd->clrc = clear_all_counters;
+	cmd->clof = clear_overflow_flags;
+	return sizeof(sli4_cmd_read_link_stats_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a READ_STATUS command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param clear_counters If TRUE, the counters will be cleared.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_read_status(sli4_t *sli4, void *buf, size_t size,
+			uint8_t clear_counters)
+{
+	sli4_cmd_read_status_t	*cmd = buf;
+
+	ocs_memset(buf, 0, size);
+
+	cmd->hdr.command = SLI4_MBOX_COMMAND_READ_STATUS;
+	cmd->cc = clear_counters;
+	return sizeof(sli4_cmd_read_status_t);
+}
+
+/**
+ * @brief Write a FW_DEINITIALIZE command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_fw_deinitialize(sli4_t *sli4, void *buf, size_t size)
+{
+
+	ocs_memset(buf, 0, size);
+	ocs_memcpy(buf, sli4_fw_deinitialize, sizeof(sli4_fw_deinitialize));
+
+	return sizeof(sli4_fw_deinitialize);
+}
+
+/**
+ * @brief Write a FW_INITIALIZE command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_fw_initialize(sli4_t *sli4, void *buf, size_t size)
+{
+
+	ocs_memset(buf, 0, size);
+	ocs_memcpy(buf, sli4_fw_initialize, sizeof(sli4_fw_initialize));
+
+	return sizeof(sli4_fw_initialize);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an INIT_LINK command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param speed Link speed.
+ * @param reset_alpa For native FC, this is the selective reset AL_PA
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_init_link(sli4_t *sli4, void *buf, size_t size, uint32_t speed, uint8_t reset_alpa)
+{
+	sli4_cmd_init_link_t	*init_link = buf;
+
+	ocs_memset(buf, 0, size);
+
+	init_link->hdr.command = SLI4_MBOX_COMMAND_INIT_LINK;
+
+	/* Most fields only have meaning for FC links */
+	if (sli4->config.topology != SLI4_READ_CFG_TOPO_FCOE) {
+		init_link->selective_reset_al_pa = reset_alpa;
+		init_link->link_flags.loopback = FALSE;
+
+		init_link->link_speed_selection_code = speed;
+		switch (speed) {
+		case FC_LINK_SPEED_1G:
+		case FC_LINK_SPEED_2G:
+		case FC_LINK_SPEED_4G:
+		case FC_LINK_SPEED_8G:
+		case FC_LINK_SPEED_16G:
+		case FC_LINK_SPEED_32G:
+			init_link->link_flags.fixed_speed = TRUE;
+			break;
+		case FC_LINK_SPEED_10G:
+			ocs_log_test(sli4->os, "unsupported FC speed %d\n", speed);
+			return 0;
+		}
+
+		switch (sli4->config.topology) {
+		case SLI4_READ_CFG_TOPO_FC:
+			/* Attempt P2P but failover to FC-AL */
+			init_link->link_flags.enable_topology_failover = TRUE;
+
+			if (sli_get_asic_type(sli4) == SLI4_ASIC_TYPE_LANCER)
+				init_link->link_flags.topology = SLI4_INIT_LINK_F_FCAL_FAIL_OVER;
+			else
+				init_link->link_flags.topology = SLI4_INIT_LINK_F_P2P_FAIL_OVER;
+
+			break;
+		case SLI4_READ_CFG_TOPO_FC_AL:
+			init_link->link_flags.topology = SLI4_INIT_LINK_F_FCAL_ONLY;
+			if ((init_link->link_speed_selection_code == FC_LINK_SPEED_16G) ||
+			    (init_link->link_speed_selection_code == FC_LINK_SPEED_32G)) {
+				ocs_log_test(sli4->os, "unsupported FC-AL speed %d\n", speed);
+				return 0;
+			}
+			break;
+		case SLI4_READ_CFG_TOPO_FC_DA:
+			init_link->link_flags.topology = FC_TOPOLOGY_P2P;
+			break;
+		default:
+			ocs_log_test(sli4->os, "unsupported topology %#x\n", sli4->config.topology);
+			return 0;
+		}
+
+		init_link->link_flags.unfair = FALSE;
+		init_link->link_flags.skip_lirp_lilp = FALSE;
+		init_link->link_flags.gen_loop_validity_check = FALSE;
+		init_link->link_flags.skip_lisa = FALSE;
+		init_link->link_flags.select_hightest_al_pa = FALSE;
+	}
+
+	return sizeof(sli4_cmd_init_link_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an INIT_VFI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param vfi VFI
+ * @param fcfi FCFI
+ * @param vpi VPI (Set to -1 if unused.)
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_init_vfi(sli4_t *sli4, void *buf, size_t size, uint16_t vfi,
+		uint16_t fcfi, uint16_t vpi)
+{
+	sli4_cmd_init_vfi_t	*init_vfi = buf;
+
+	ocs_memset(buf, 0, size);
+
+	init_vfi->hdr.command = SLI4_MBOX_COMMAND_INIT_VFI;
+
+	init_vfi->vfi = vfi;
+	init_vfi->fcfi = fcfi;
+
+	/*
+	 * If the VPI is valid, initialize it at the same time as
+	 * the VFI
+	 */
+	if (0xffff != vpi) {
+		init_vfi->vp  = TRUE;
+		init_vfi->vpi = vpi;
+	}
+
+	return sizeof(sli4_cmd_init_vfi_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an INIT_VPI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param vpi VPI allocated.
+ * @param vfi VFI associated with this VPI.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_init_vpi(sli4_t *sli4, void *buf, size_t size, uint16_t vpi, uint16_t vfi)
+{
+	sli4_cmd_init_vpi_t	*init_vpi = buf;
+
+	ocs_memset(buf, 0, size);
+
+	init_vpi->hdr.command = SLI4_MBOX_COMMAND_INIT_VPI;
+	init_vpi->vpi = vpi;
+	init_vpi->vfi = vfi;
+
+	return sizeof(sli4_cmd_init_vpi_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a POST_XRI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param xri_base Starting XRI value for range of XRI given to SLI Port.
+ * @param xri_count Number of XRIs provided to the SLI Port.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_post_xri(sli4_t *sli4, void *buf, size_t size,  uint16_t xri_base, uint16_t xri_count)
+{
+	sli4_cmd_post_xri_t	*post_xri = buf;
+
+	ocs_memset(buf, 0, size);
+
+	post_xri->hdr.command = SLI4_MBOX_COMMAND_POST_XRI;
+	post_xri->xri_base = xri_base;
+	post_xri->xri_count = xri_count;
+
+	if (sli4->config.auto_xfer_rdy == 0) {
+		post_xri->enx = TRUE;
+		post_xri->val = TRUE;
+	}
+
+	return sizeof(sli4_cmd_post_xri_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a RELEASE_XRI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param num_xri The number of XRIs to be released.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_release_xri(sli4_t *sli4, void *buf, size_t size,  uint8_t num_xri)
+{
+	sli4_cmd_release_xri_t	*release_xri = buf;
+
+	ocs_memset(buf, 0, size);
+
+	release_xri->hdr.command = SLI4_MBOX_COMMAND_RELEASE_XRI;
+	release_xri->xri_count = num_xri;
+
+	return sizeof(sli4_cmd_release_xri_t);
+}
+
+/**
+ * @brief Write a READ_CONFIG command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_read_config(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_cmd_read_config_t	*read_config = buf;
+
+	ocs_memset(buf, 0, size);
+
+	read_config->hdr.command = SLI4_MBOX_COMMAND_READ_CONFIG;
+
+	return sizeof(sli4_cmd_read_config_t);
+}
+
+/**
+ * @brief Write a READ_NVPARMS command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_read_nvparms(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_cmd_read_nvparms_t	*read_nvparms = buf;
+
+	ocs_memset(buf, 0, size);
+
+	read_nvparms->hdr.command = SLI4_MBOX_COMMAND_READ_NVPARMS;
+
+	return sizeof(sli4_cmd_read_nvparms_t);
+}
+
+/**
+ * @brief Write a WRITE_NVPARMS command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param wwpn WWPN to write - pointer to array of 8 uint8_t.
+ * @param wwnn WWNN to write - pointer to array of 8 uint8_t.
+ * @param hard_alpa Hard ALPA to write.
+ * @param preferred_d_id  Preferred D_ID to write.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_write_nvparms(sli4_t *sli4, void *buf, size_t size, uint8_t *wwpn, uint8_t *wwnn, uint8_t hard_alpa,
+		uint32_t preferred_d_id)
+{
+	sli4_cmd_write_nvparms_t	*write_nvparms = buf;
+
+	ocs_memset(buf, 0, size);
+
+	write_nvparms->hdr.command = SLI4_MBOX_COMMAND_WRITE_NVPARMS;
+	ocs_memcpy(write_nvparms->wwpn, wwpn, 8);
+	ocs_memcpy(write_nvparms->wwnn, wwnn, 8);
+	write_nvparms->hard_alpa = hard_alpa;
+	write_nvparms->preferred_d_id = preferred_d_id;
+
+	return sizeof(sli4_cmd_write_nvparms_t);
+}
+
+/**
+ * @brief Write a READ_REV command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param vpd Pointer to the buffer.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_read_rev(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *vpd)
+{
+	sli4_cmd_read_rev_t	*read_rev = buf;
+
+	ocs_memset(buf, 0, size);
+
+	read_rev->hdr.command = SLI4_MBOX_COMMAND_READ_REV;
+
+	if (vpd && vpd->size) {
+		read_rev->vpd = TRUE;
+
+		read_rev->available_length = vpd->size;
+
+		read_rev->physical_address_low  = ocs_addr32_lo(vpd->phys);
+		read_rev->physical_address_high = ocs_addr32_hi(vpd->phys);
+	}
+
+	return sizeof(sli4_cmd_read_rev_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a READ_SPARM64 command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param dma DMA buffer for the service parameters.
+ * @param vpi VPI used to determine the WWN.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_read_sparm64(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma,
+		uint16_t vpi)
+{
+	sli4_cmd_read_sparm64_t	*read_sparm64 = buf;
+
+	ocs_memset(buf, 0, size);
+
+	if (SLI4_READ_SPARM64_VPI_SPECIAL == vpi) {
+		ocs_log_test(sli4->os, "special VPI not supported!!!\n");
+		return -1;
+	}
+
+	if (!dma || !dma->phys) {
+		ocs_log_test(sli4->os, "bad DMA buffer\n");
+		return -1;
+	}
+
+	read_sparm64->hdr.command = SLI4_MBOX_COMMAND_READ_SPARM64;
+
+	read_sparm64->bde_64.bde_type = SLI4_BDE_TYPE_BDE_64;
+	read_sparm64->bde_64.buffer_length = dma->size;
+	read_sparm64->bde_64.u.data.buffer_address_low  = ocs_addr32_lo(dma->phys);
+	read_sparm64->bde_64.u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+
+	read_sparm64->vpi = vpi;
+
+	return sizeof(sli4_cmd_read_sparm64_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a READ_TOPOLOGY command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param dma DMA buffer for loop map (optional).
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_read_topology(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma)
+{
+	sli4_cmd_read_topology_t *read_topo = buf;
+
+	ocs_memset(buf, 0, size);
+
+	read_topo->hdr.command = SLI4_MBOX_COMMAND_READ_TOPOLOGY;
+
+	if (dma && dma->size) {
+		if (dma->size < SLI4_MIN_LOOP_MAP_BYTES) {
+			ocs_log_test(sli4->os, "loop map buffer too small %jd\n",
+					dma->size);
+			return 0;
+		}
+
+		ocs_memset(dma->virt, 0, dma->size);
+
+		read_topo->bde_loop_map.bde_type = SLI4_BDE_TYPE_BDE_64;
+		read_topo->bde_loop_map.buffer_length = dma->size;
+		read_topo->bde_loop_map.u.data.buffer_address_low  = ocs_addr32_lo(dma->phys);
+		read_topo->bde_loop_map.u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+	}
+
+	return sizeof(sli4_cmd_read_topology_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a REG_FCFI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param index FCF index returned by READ_FCF_TABLE.
+ * @param rq_cfg RQ_ID/R_CTL/TYPE routing information
+ * @param vlan_id VLAN ID tag.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_reg_fcfi(sli4_t *sli4, void *buf, size_t size, uint16_t index, sli4_cmd_rq_cfg_t rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG], uint16_t vlan_id)
+{
+	sli4_cmd_reg_fcfi_t	*reg_fcfi = buf;
+	uint32_t		i;
+
+	ocs_memset(buf, 0, size);
+
+	reg_fcfi->hdr.command = SLI4_MBOX_COMMAND_REG_FCFI;
+
+	reg_fcfi->fcf_index = index;
+
+	for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) {
+		switch(i) {
+		case 0:	reg_fcfi->rq_id_0 = rq_cfg[0].rq_id; break;
+		case 1:	reg_fcfi->rq_id_1 = rq_cfg[1].rq_id; break;
+		case 2:	reg_fcfi->rq_id_2 = rq_cfg[2].rq_id; break;
+		case 3:	reg_fcfi->rq_id_3 = rq_cfg[3].rq_id; break;
+		}
+		reg_fcfi->rq_cfg[i].r_ctl_mask = rq_cfg[i].r_ctl_mask;
+		reg_fcfi->rq_cfg[i].r_ctl_match = rq_cfg[i].r_ctl_match;
+		reg_fcfi->rq_cfg[i].type_mask = rq_cfg[i].type_mask;
+		reg_fcfi->rq_cfg[i].type_match = rq_cfg[i].type_match;
+	}
+
+	if (vlan_id) {
+		reg_fcfi->vv = TRUE;
+		reg_fcfi->vlan_tag = vlan_id;
+	}
+
+	return sizeof(sli4_cmd_reg_fcfi_t);
+}
+
+/**
+ * @brief Write REG_FCFI_MRQ to provided command buffer
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param fcf_index FCF index returned by READ_FCF_TABLE.
+ * @param vlan_id VLAN ID tag.
+ * @param rr_quant Round robin quanta if RQ selection policy is 2
+ * @param rq_selection_policy RQ selection policy
+ * @param num_rqs Array of count of RQs per filter
+ * @param rq_ids Array of RQ ids per filter
+ * @param rq_cfg RQ_ID/R_CTL/TYPE routing information
+ *
+ * @return returns 0 for success, a negative error code value for failure.
+ */
+int32_t
+sli_cmd_reg_fcfi_mrq(sli4_t *sli4, void *buf, size_t size, uint8_t mode,
+		     uint16_t fcf_index, uint16_t vlan_id, uint8_t rq_selection_policy,
+		     uint8_t mrq_bit_mask, uint16_t num_mrqs,
+		     sli4_cmd_rq_cfg_t rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG])
+{
+	sli4_cmd_reg_fcfi_mrq_t	*reg_fcfi_mrq = buf;
+	uint32_t i;
+
+	ocs_memset(buf, 0, size);
+
+	reg_fcfi_mrq->hdr.command = SLI4_MBOX_COMMAND_REG_FCFI_MRQ;
+	if (mode == SLI4_CMD_REG_FCFI_SET_FCFI_MODE) {
+		reg_fcfi_mrq->fcf_index = fcf_index;
+		if (vlan_id) {
+			reg_fcfi_mrq->vv = TRUE;
+			reg_fcfi_mrq->vlan_tag = vlan_id;
+		}
+		goto done;
+	}
+
+	reg_fcfi_mrq->mode = mode;
+	for (i = 0; i < SLI4_CMD_REG_FCFI_NUM_RQ_CFG; i++) {
+		reg_fcfi_mrq->rq_cfg[i].r_ctl_mask = rq_cfg[i].r_ctl_mask;
+		reg_fcfi_mrq->rq_cfg[i].r_ctl_match = rq_cfg[i].r_ctl_match;
+		reg_fcfi_mrq->rq_cfg[i].type_mask = rq_cfg[i].type_mask;
+		reg_fcfi_mrq->rq_cfg[i].type_match = rq_cfg[i].type_match;
+
+		switch(i) {
+		case 3:	reg_fcfi_mrq->rq_id_3 = rq_cfg[i].rq_id; break;
+		case 2:	reg_fcfi_mrq->rq_id_2 = rq_cfg[i].rq_id; break;
+		case 1:	reg_fcfi_mrq->rq_id_1 = rq_cfg[i].rq_id; break;
+		case 0:	reg_fcfi_mrq->rq_id_0 = rq_cfg[i].rq_id; break;
+		}
+	}
+
+	reg_fcfi_mrq->rq_selection_policy = rq_selection_policy;
+	reg_fcfi_mrq->mrq_filter_bitmask = mrq_bit_mask;
+	reg_fcfi_mrq->num_mrq_pairs = num_mrqs;
+done:
+	return sizeof(sli4_cmd_reg_fcfi_mrq_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a REG_RPI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param nport_id Remote F/N_Port_ID.
+ * @param rpi Previously-allocated Remote Port Indicator.
+ * @param vpi Previously-allocated Virtual Port Indicator.
+ * @param dma DMA buffer that contains the remote port's service parameters.
+ * @param update Boolean indicating an update to an existing RPI (TRUE)
+ * or a new registration (FALSE).
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_reg_rpi(sli4_t *sli4, void *buf, size_t size, uint32_t nport_id, uint16_t rpi, 
+			uint16_t vpi, ocs_dma_t *dma, uint8_t update,  uint8_t enable_t10_pi)
+{
+	sli4_cmd_reg_rpi_t *reg_rpi = buf;
+
+	ocs_memset(buf, 0, size);
+
+	reg_rpi->hdr.command = SLI4_MBOX_COMMAND_REG_RPI;
+
+	reg_rpi->rpi = rpi;
+	reg_rpi->remote_n_port_id = nport_id;
+	reg_rpi->upd = update;
+	reg_rpi->etow = enable_t10_pi;
+
+	reg_rpi->bde_64.bde_type = SLI4_BDE_TYPE_BDE_64;
+	reg_rpi->bde_64.buffer_length = SLI4_REG_RPI_BUF_LEN;
+	reg_rpi->bde_64.u.data.buffer_address_low  = ocs_addr32_lo(dma->phys);
+	reg_rpi->bde_64.u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+
+	reg_rpi->vpi = vpi;
+
+	return sizeof(sli4_cmd_reg_rpi_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a REG_VFI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param domain Pointer to the domain object.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_reg_vfi(sli4_t *sli4, void *buf, size_t size, ocs_domain_t *domain)
+{
+	sli4_cmd_reg_vfi_t	*reg_vfi = buf;
+
+	if (!sli4 || !buf || !domain) {
+		return 0;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	reg_vfi->hdr.command = SLI4_MBOX_COMMAND_REG_VFI;
+
+	reg_vfi->vfi = domain->indicator;
+
+	reg_vfi->fcfi = domain->fcf_indicator;
+
+	/* TODO contents of domain->dma only valid if topo == FABRIC */
+	reg_vfi->sparm.bde_type = SLI4_BDE_TYPE_BDE_64;
+	reg_vfi->sparm.buffer_length = 0x70;
+	reg_vfi->sparm.u.data.buffer_address_low  = ocs_addr32_lo(domain->dma.phys);
+	reg_vfi->sparm.u.data.buffer_address_high = ocs_addr32_hi(domain->dma.phys);
+
+	reg_vfi->e_d_tov = sli4->config.e_d_tov;
+	reg_vfi->r_a_tov = sli4->config.r_a_tov;
+
+	reg_vfi->vp = TRUE;
+	reg_vfi->vpi = domain->sport->indicator;
+	ocs_memcpy(reg_vfi->wwpn, &domain->sport->sli_wwpn, sizeof(reg_vfi->wwpn));
+	reg_vfi->local_n_port_id = domain->sport->fc_id;
+
+	return sizeof(sli4_cmd_reg_vfi_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a REG_VPI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param sport Point to SLI Port object.
+ * @param update Boolean indicating whether to update the existing VPI (true)
+ * or create a new VPI (false).
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_reg_vpi(sli4_t *sli4, void *buf, size_t size, ocs_sli_port_t *sport, uint8_t update)
+{
+	sli4_cmd_reg_vpi_t	*reg_vpi = buf;
+
+	if (!sli4 || !buf || !sport) {
+		return 0;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	reg_vpi->hdr.command = SLI4_MBOX_COMMAND_REG_VPI;
+
+	reg_vpi->local_n_port_id = sport->fc_id;
+	reg_vpi->upd = update != 0;
+	ocs_memcpy(reg_vpi->wwpn, &sport->sli_wwpn, sizeof(reg_vpi->wwpn));
+	reg_vpi->vpi = sport->indicator;
+	reg_vpi->vfi = sport->domain->indicator;
+
+	return sizeof(sli4_cmd_reg_vpi_t);
+}
+
+/**
+ * @brief Write a REQUEST_FEATURES command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param mask Features to request.
+ * @param query Use feature query mode (does not change FW).
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_request_features(sli4_t *sli4, void *buf, size_t size, sli4_features_t mask, uint8_t query)
+{
+	sli4_cmd_request_features_t *features = buf;
+
+	ocs_memset(buf, 0, size);
+
+	features->hdr.command = SLI4_MBOX_COMMAND_REQUEST_FEATURES;
+
+	if (query) {
+		features->qry = TRUE;
+	}
+	features->command.dword = mask.dword;
+
+	return sizeof(sli4_cmd_request_features_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a SLI_CONFIG command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param length Length in bytes of attached command.
+ * @param dma DMA buffer for non-embedded commands.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_sli_config(sli4_t *sli4, void *buf, size_t size, uint32_t length, ocs_dma_t *dma)
+{
+	sli4_cmd_sli_config_t	*sli_config = NULL;
+
+	if ((length > sizeof(sli_config->payload.embed)) && (dma == NULL)) {
+		ocs_log_test(sli4->os, "length(%d) > payload(%ld)\n",
+				length, sizeof(sli_config->payload.embed));
+		return -1;
+	}
+
+	sli_config = buf;
+
+	ocs_memset(buf, 0, size);
+
+	sli_config->hdr.command = SLI4_MBOX_COMMAND_SLI_CONFIG;
+	if (NULL == dma) {
+		sli_config->emb = TRUE;
+		sli_config->payload_length = length;
+	} else {
+		sli_config->emb = FALSE;
+
+		sli_config->pmd_count = 1;
+
+		sli_config->payload.mem.address_low = ocs_addr32_lo(dma->phys);
+		sli_config->payload.mem.address_high = ocs_addr32_hi(dma->phys);
+		sli_config->payload.mem.length = dma->size;
+		sli_config->payload_length = dma->size;
+#if defined(OCS_INCLUDE_DEBUG)
+		/* save pointer to DMA for BMBX dumping purposes */
+		sli4->bmbx_non_emb_pmd = dma;
+#endif
+
+	}
+
+	return offsetof(sli4_cmd_sli_config_t, payload.embed);
+}
+
+/**
+ * @brief Initialize SLI Port control register.
+ *
+ * @param sli4 SLI context pointer.
+ * @param endian Endian value to write.
+ *
+ * @return Returns 0 on success, or a negative error code value on failure.
+ */
+
+static int32_t
+sli_sliport_control(sli4_t *sli4, uint32_t endian)
+{
+	uint32_t iter;
+	int32_t rc;
+
+	rc = -1;
+
+	/* Initialize port, endian */
+	sli_reg_write(sli4, SLI4_REG_SLIPORT_CONTROL, endian | SLI4_SLIPORT_CONTROL_IP);
+
+	for (iter = 0; iter < 3000; iter ++) {
+		ocs_udelay(SLI4_INIT_PORT_DELAY_US);
+		if (sli_fw_ready(sli4) == 1) {
+			rc = 0;
+			break;
+		}
+	}
+
+	if (rc != 0) {
+		ocs_log_crit(sli4->os, "port failed to become ready after initialization\n");
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a UNREG_FCFI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param indicator Indicator value.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_unreg_fcfi(sli4_t *sli4, void *buf, size_t size, uint16_t indicator)
+{
+	sli4_cmd_unreg_fcfi_t	*unreg_fcfi = buf;
+
+	if (!sli4 || !buf) {
+		return 0;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	unreg_fcfi->hdr.command = SLI4_MBOX_COMMAND_UNREG_FCFI;
+
+	unreg_fcfi->fcfi = indicator;
+
+	return sizeof(sli4_cmd_unreg_fcfi_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an UNREG_RPI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param indicator Indicator value.
+ * @param which Type of unregister, such as node, port, domain, or FCF.
+ * @param fc_id FC address.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_unreg_rpi(sli4_t *sli4, void *buf, size_t size, uint16_t indicator, sli4_resource_e which,
+		uint32_t fc_id)
+{
+	sli4_cmd_unreg_rpi_t	*unreg_rpi = buf;
+	uint8_t		index_indicator = 0;
+
+	if (!sli4 || !buf) {
+		return 0;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	unreg_rpi->hdr.command = SLI4_MBOX_COMMAND_UNREG_RPI;
+
+	switch (which) {
+	case SLI_RSRC_FCOE_RPI:
+		index_indicator = SLI4_UNREG_RPI_II_RPI;
+		if (fc_id != UINT32_MAX) {
+			unreg_rpi->dp = TRUE;
+			unreg_rpi->destination_n_port_id = fc_id & 0x00ffffff;
+		}
+		break;
+	case SLI_RSRC_FCOE_VPI:
+		index_indicator = SLI4_UNREG_RPI_II_VPI;
+		break;
+	case SLI_RSRC_FCOE_VFI:
+		index_indicator = SLI4_UNREG_RPI_II_VFI;
+		break;
+	case SLI_RSRC_FCOE_FCFI:
+		index_indicator = SLI4_UNREG_RPI_II_FCFI;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unknown type %#x\n", which);
+		return 0;
+	}
+
+	unreg_rpi->ii = index_indicator;
+	unreg_rpi->index = indicator;
+
+	return sizeof(sli4_cmd_unreg_rpi_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an UNREG_VFI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param domain Pointer to the domain object
+ * @param which Type of unregister, such as domain, FCFI, or everything.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_unreg_vfi(sli4_t *sli4, void *buf, size_t size, ocs_domain_t *domain, uint32_t which)
+{
+	sli4_cmd_unreg_vfi_t	*unreg_vfi = buf;
+
+	if (!sli4 || !buf || !domain) {
+		return 0;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	unreg_vfi->hdr.command = SLI4_MBOX_COMMAND_UNREG_VFI;
+	switch (which) {
+	case SLI4_UNREG_TYPE_DOMAIN:
+		unreg_vfi->index = domain->indicator;
+		break;
+	case SLI4_UNREG_TYPE_FCF:
+		unreg_vfi->index = domain->fcf_indicator;
+		break;
+	case SLI4_UNREG_TYPE_ALL:
+		unreg_vfi->index = UINT16_MAX;
+		break;
+	default:
+		return 0;
+	}
+
+	if (SLI4_UNREG_TYPE_DOMAIN != which) {
+		unreg_vfi->ii = SLI4_UNREG_VFI_II_FCFI;
+	}
+
+	return sizeof(sli4_cmd_unreg_vfi_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an UNREG_VPI command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param indicator Indicator value.
+ * @param which Type of unregister: port, domain, FCFI, everything
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_unreg_vpi(sli4_t *sli4, void *buf, size_t size, uint16_t indicator, uint32_t which)
+{
+	sli4_cmd_unreg_vpi_t	*unreg_vpi = buf;
+
+	if (!sli4 || !buf) {
+		return 0;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	unreg_vpi->hdr.command = SLI4_MBOX_COMMAND_UNREG_VPI;
+	unreg_vpi->index = indicator;
+	switch (which) {
+	case SLI4_UNREG_TYPE_PORT:
+		unreg_vpi->ii = SLI4_UNREG_VPI_II_VPI;
+		break;
+	case SLI4_UNREG_TYPE_DOMAIN:
+		unreg_vpi->ii = SLI4_UNREG_VPI_II_VFI;
+		break;
+	case SLI4_UNREG_TYPE_FCF:
+		unreg_vpi->ii = SLI4_UNREG_VPI_II_FCFI;
+		break;
+	case SLI4_UNREG_TYPE_ALL:
+		unreg_vpi->index = UINT16_MAX;	/* override indicator */
+		unreg_vpi->ii = SLI4_UNREG_VPI_II_FCFI;
+		break;
+	default:
+		return 0;
+	}
+
+	return sizeof(sli4_cmd_unreg_vpi_t);
+}
+
+
+/**
+ * @ingroup sli
+ * @brief Write an CONFIG_AUTO_XFER_RDY command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param max_burst_len if the write FCP_DL is less than this size,
+ * then the SLI port will generate the auto XFER_RDY.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_config_auto_xfer_rdy(sli4_t *sli4, void *buf, size_t size, uint32_t max_burst_len)
+{
+	sli4_cmd_config_auto_xfer_rdy_t	*req = buf;
+
+	if (!sli4 || !buf) {
+		return 0;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	req->hdr.command = SLI4_MBOX_COMMAND_CONFIG_AUTO_XFER_RDY;
+	req->max_burst_len = max_burst_len;
+
+	return sizeof(sli4_cmd_config_auto_xfer_rdy_t);
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an CONFIG_AUTO_XFER_RDY_HP command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to the destination buffer.
+ * @param size Buffer size, in bytes.
+ * @param max_burst_len if the write FCP_DL is less than this size,
+ * @param esoc enable start offset computation,
+ * @param block_size block size,
+ * then the SLI port will generate the auto XFER_RDY.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_config_auto_xfer_rdy_hp(sli4_t *sli4, void *buf, size_t size, uint32_t max_burst_len,
+                                                uint32_t esoc, uint32_t block_size )
+{
+        sli4_cmd_config_auto_xfer_rdy_hp_t      *req = buf;
+
+        if (!sli4 || !buf) {
+                return 0;
+        }
+
+        ocs_memset(buf, 0, size);
+
+        req->hdr.command = SLI4_MBOX_COMMAND_CONFIG_AUTO_XFER_RDY_HP;
+        req->max_burst_len = max_burst_len;
+        req->esoc = esoc;
+        req->block_size = block_size;
+        return sizeof(sli4_cmd_config_auto_xfer_rdy_hp_t);
+}
+
+/**
+ * @brief Write a COMMON_FUNCTION_RESET command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_function_reset(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_req_common_function_reset_t *reset = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_common_function_reset_t),
+				sizeof(sli4_res_common_function_reset_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	reset = (sli4_req_common_function_reset_t *)((uint8_t *)buf + sli_config_off);
+
+	reset->hdr.opcode = SLI4_OPC_COMMON_FUNCTION_RESET;
+	reset->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+
+	return(sli_config_off + sizeof(sli4_req_common_function_reset_t));
+}
+
+/**
+ * @brief Write a COMMON_CREATE_CQ command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param qmem DMA memory for the queue.
+ * @param eq_id Associated EQ_ID
+ * @param ignored This parameter carries the ULP which is only used for WQ and RQs
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_create_cq(sli4_t *sli4, void *buf, size_t size,
+		ocs_dma_t *qmem, uint16_t eq_id, uint16_t ignored)
+{
+	sli4_req_common_create_cq_v0_t	*cqv0 = NULL;
+	sli4_req_common_create_cq_v2_t	*cqv2 = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	p;
+	uintptr_t	addr;
+	uint32_t	if_type = sli4->if_type;
+	uint32_t	page_bytes = 0;
+	uint32_t	num_pages = 0;
+	uint32_t 	cmd_size = 0;
+	uint32_t	page_size = 0;
+	uint32_t	n_cqe = 0;
+
+	/* First calculate number of pages and the mailbox cmd length */
+	switch (if_type)
+	{
+	case SLI4_IF_TYPE_BE3_SKH_PF:
+		page_bytes = SLI_PAGE_SIZE;
+		num_pages = sli_page_count(qmem->size, page_bytes);
+		cmd_size = sizeof(sli4_req_common_create_cq_v0_t) + (8 * num_pages);
+		break;
+	case SLI4_IF_TYPE_LANCER_FC_ETH:
+		n_cqe = qmem->size / SLI4_CQE_BYTES;
+		switch (n_cqe) {
+		case 256:
+		case 512:
+		case 1024:
+		case 2048:
+			page_size = 1;
+			break;
+		case 4096:
+			page_size = 2;
+			break;
+		default:
+			return 0;
+		}
+		page_bytes = page_size * SLI_PAGE_SIZE;
+		num_pages = sli_page_count(qmem->size, page_bytes);
+		cmd_size = sizeof(sli4_req_common_create_cq_v2_t) + (8 * num_pages);
+		break;
+	default:
+		ocs_log_test(sli4->os, "unsupported IF_TYPE %d\n", if_type);
+		return -1;
+	}
+
+
+	/* now that we have the mailbox command size, we can set SLI_CONFIG fields */
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max((size_t)cmd_size, sizeof(sli4_res_common_create_queue_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+
+	switch (if_type)
+	{
+	case SLI4_IF_TYPE_BE3_SKH_PF:
+		cqv0 = (sli4_req_common_create_cq_v0_t *)((uint8_t *)buf + sli_config_off);
+		cqv0->hdr.opcode = SLI4_OPC_COMMON_CREATE_CQ;
+		cqv0->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+		cqv0->hdr.version = 0;
+		cqv0->hdr.request_length = cmd_size - sizeof(sli4_req_hdr_t);
+
+		/* valid values for number of pages: 1, 2, 4 (sec 4.4.3) */
+		cqv0->num_pages = num_pages;
+		switch (cqv0->num_pages) {
+		case 1:
+			cqv0->cqecnt = SLI4_CQ_CNT_256;
+			break;
+		case 2:
+			cqv0->cqecnt = SLI4_CQ_CNT_512;
+			break;
+		case 4:
+			cqv0->cqecnt = SLI4_CQ_CNT_1024;
+			break;
+		default:
+			ocs_log_test(sli4->os, "num_pages %d not valid\n", cqv0->num_pages);
+			return -1;
+		}
+		cqv0->evt = TRUE;
+		cqv0->valid = TRUE;
+		/* TODO cq->nodelay = ???; */
+		/* TODO cq->clswm = ???; */
+		cqv0->arm = FALSE;
+		cqv0->eq_id = eq_id;
+
+		for (p = 0, addr = qmem->phys;
+				p < cqv0->num_pages;
+				p++, addr += page_bytes) {
+			cqv0->page_physical_address[p].low = ocs_addr32_lo(addr);
+			cqv0->page_physical_address[p].high = ocs_addr32_hi(addr);
+		}
+
+		break;
+	case SLI4_IF_TYPE_LANCER_FC_ETH:
+	{
+		cqv2 = (sli4_req_common_create_cq_v2_t *)((uint8_t *)buf + sli_config_off);
+		cqv2->hdr.opcode = SLI4_OPC_COMMON_CREATE_CQ;
+		cqv2->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+		cqv2->hdr.version = 2;
+		cqv2->hdr.request_length = cmd_size - sizeof(sli4_req_hdr_t);
+
+		cqv2->page_size = page_size;
+
+		/* valid values for number of pages: 1, 2, 4, 8 (sec 4.4.3) */
+		cqv2->num_pages = num_pages;
+		if (!cqv2->num_pages || (cqv2->num_pages > SLI4_COMMON_CREATE_CQ_V2_MAX_PAGES)) {
+			return 0;
+		}
+
+		switch (cqv2->num_pages) {
+		case 1:
+			cqv2->cqecnt = SLI4_CQ_CNT_256;
+			break;
+		case 2:
+			cqv2->cqecnt = SLI4_CQ_CNT_512;
+			break;
+		case 4:
+			cqv2->cqecnt = SLI4_CQ_CNT_1024;
+			break;
+		case 8:
+			cqv2->cqecnt = SLI4_CQ_CNT_LARGE;
+			cqv2->cqe_count = n_cqe;
+			break;
+		default:
+			ocs_log_test(sli4->os, "num_pages %d not valid\n", cqv2->num_pages);
+			return -1;
+		}
+
+		cqv2->evt = TRUE;
+		cqv2->valid = TRUE;
+		/* TODO cq->nodelay = ???; */
+		/* TODO cq->clswm = ???; */
+		cqv2->arm = FALSE;
+		cqv2->eq_id = eq_id;
+
+		for (p = 0, addr = qmem->phys;
+				p < cqv2->num_pages;
+				p++, addr += page_bytes) {
+			cqv2->page_physical_address[p].low = ocs_addr32_lo(addr);
+			cqv2->page_physical_address[p].high = ocs_addr32_hi(addr);
+		}
+	}
+		break;
+	default:
+		ocs_log_test(sli4->os, "unsupported IF_TYPE %d\n", if_type);
+		return -1;
+	}
+
+	return (sli_config_off + cmd_size);
+}
+
+/**
+ * @brief Write a COMMON_DESTROY_CQ command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param cq_id CQ ID
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_destroy_cq(sli4_t *sli4, void *buf, size_t size, uint16_t cq_id)
+{
+	sli4_req_common_destroy_cq_t	*cq = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				/* Payload length must accommodate both request and response */
+				max(sizeof(sli4_req_common_destroy_cq_t),
+					sizeof(sli4_res_hdr_t)),
+				NULL);
+	}
+	cq = (sli4_req_common_destroy_cq_t *)((uint8_t *)buf + sli_config_off);
+
+	cq->hdr.opcode = SLI4_OPC_COMMON_DESTROY_CQ;
+	cq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	cq->hdr.request_length = sizeof(sli4_req_common_destroy_cq_t) -
+					sizeof(sli4_req_hdr_t);
+	cq->cq_id = cq_id;
+
+	return(sli_config_off + sizeof(sli4_req_common_destroy_cq_t));
+}
+
+/**
+ * @brief Write a COMMON_MODIFY_EQ_DELAY command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param q Queue object array.
+ * @param num_q Queue object array count.
+ * @param shift Phase shift for staggering interrupts.
+ * @param delay_mult Delay multiplier for limiting interrupt frequency.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_modify_eq_delay(sli4_t *sli4, void *buf, size_t size, sli4_queue_t *q, int num_q, uint32_t shift,
+				uint32_t delay_mult)
+{
+	sli4_req_common_modify_eq_delay_t *modify_delay = NULL;
+	uint32_t	sli_config_off = 0;
+	int i;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				/* Payload length must accommodate both request and response */
+				max(sizeof(sli4_req_common_modify_eq_delay_t), sizeof(sli4_res_hdr_t)),
+				NULL);
+	}
+
+	modify_delay = (sli4_req_common_modify_eq_delay_t *)((uint8_t *)buf + sli_config_off);
+
+	modify_delay->hdr.opcode = SLI4_OPC_COMMON_MODIFY_EQ_DELAY;
+	modify_delay->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	modify_delay->hdr.request_length = sizeof(sli4_req_common_modify_eq_delay_t) -
+					sizeof(sli4_req_hdr_t);
+
+	modify_delay->num_eq = num_q;
+
+	for (i = 0; i<num_q; i++) {
+		modify_delay->eq_delay_record[i].eq_id = q[i].id;
+		modify_delay->eq_delay_record[i].phase = shift;
+		modify_delay->eq_delay_record[i].delay_multiplier = delay_mult;
+	}
+
+	return(sli_config_off + sizeof(sli4_req_common_modify_eq_delay_t));
+}
+
+/**
+ * @brief Write a COMMON_CREATE_EQ command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param qmem DMA memory for the queue.
+ * @param ignored1 Ignored (used for consistency among queue creation functions).
+ * @param ignored2 Ignored (used for consistency among queue creation functions).
+ *
+ * @note Other queue creation routines use the last parameter to pass in
+ * the associated Q_ID and ULP. EQ doesn't have an associated queue or ULP,
+ * so these parameters are ignored
+ *
+ * @note This creates a Version 0 message
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_create_eq(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *qmem,
+		uint16_t ignored1, uint16_t ignored2)
+{
+	sli4_req_common_create_eq_t	*eq = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	p;
+	uintptr_t	addr;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_common_create_eq_t),
+				sizeof(sli4_res_common_create_queue_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	eq = (sli4_req_common_create_eq_t *)((uint8_t *)buf + sli_config_off);
+
+	eq->hdr.opcode = SLI4_OPC_COMMON_CREATE_EQ;
+	eq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	eq->hdr.request_length = sizeof(sli4_req_common_create_eq_t) -
+					sizeof(sli4_req_hdr_t);
+	/* valid values for number of pages: 1, 2, 4 (sec 4.4.3) */
+	eq->num_pages = qmem->size / SLI_PAGE_SIZE;
+	switch (eq->num_pages) {
+	case 1:
+		eq->eqesz = SLI4_EQE_SIZE_4;
+		eq->count = SLI4_EQ_CNT_1024;
+		break;
+	case 2:
+		eq->eqesz = SLI4_EQE_SIZE_4;
+		eq->count = SLI4_EQ_CNT_2048;
+		break;
+	case 4:
+		eq->eqesz = SLI4_EQE_SIZE_4;
+		eq->count = SLI4_EQ_CNT_4096;
+		break;
+	default:
+		ocs_log_test(sli4->os, "num_pages %d not valid\n", eq->num_pages);
+		return -1;
+	}
+	eq->valid = TRUE;
+	eq->arm = FALSE;
+	eq->delay_multiplier = 32;
+
+	for (p = 0, addr = qmem->phys;
+			p < eq->num_pages;
+			p++, addr += SLI_PAGE_SIZE) {
+		eq->page_address[p].low = ocs_addr32_lo(addr);
+		eq->page_address[p].high = ocs_addr32_hi(addr);
+	}
+
+	return(sli_config_off + sizeof(sli4_req_common_create_eq_t));
+}
+
+
+/**
+ * @brief Write a COMMON_DESTROY_EQ command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param eq_id Queue ID to destroy.
+ *
+ * @note Other queue creation routines use the last parameter to pass in
+ * the associated Q_ID. EQ doesn't have an associated queue so this
+ * parameter is ignored.
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_destroy_eq(sli4_t *sli4, void *buf, size_t size, uint16_t eq_id)
+{
+	sli4_req_common_destroy_eq_t	*eq = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				/* Payload length must accommodate both request and response */
+				max(sizeof(sli4_req_common_destroy_eq_t),
+					sizeof(sli4_res_hdr_t)),
+				NULL);
+	}
+	eq = (sli4_req_common_destroy_eq_t *)((uint8_t *)buf + sli_config_off);
+
+	eq->hdr.opcode = SLI4_OPC_COMMON_DESTROY_EQ;
+	eq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	eq->hdr.request_length = sizeof(sli4_req_common_destroy_eq_t) -
+					sizeof(sli4_req_hdr_t);
+
+	eq->eq_id = eq_id;
+
+	return(sli_config_off + sizeof(sli4_req_common_destroy_eq_t));
+}
+
+/**
+ * @brief Write a LOWLEVEL_SET_WATCHDOG command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param timeout watchdog timer timeout in seconds
+ *
+ * @return void
+ */
+void
+sli4_cmd_lowlevel_set_watchdog(sli4_t *sli4, void *buf, size_t size, uint16_t timeout)
+{
+
+	sli4_req_lowlevel_set_watchdog_t *req = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				/* Payload length must accommodate both request and response */
+				max(sizeof(sli4_req_lowlevel_set_watchdog_t),
+					sizeof(sli4_res_lowlevel_set_watchdog_t)),
+				NULL);
+	}
+	req = (sli4_req_lowlevel_set_watchdog_t *)((uint8_t *)buf + sli_config_off);
+
+	req->hdr.opcode = SLI4_OPC_LOWLEVEL_SET_WATCHDOG;
+	req->hdr.subsystem = SLI4_SUBSYSTEM_LOWLEVEL;
+	req->hdr.request_length = sizeof(sli4_req_lowlevel_set_watchdog_t) - sizeof(sli4_req_hdr_t);
+	req->watchdog_timeout = timeout;
+	
+	return;
+}
+
+static int32_t
+sli_cmd_common_get_cntl_attributes(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma)
+{
+	sli4_req_hdr_t *hdr = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof(sli4_req_hdr_t),
+				dma);
+	}
+
+	if (dma == NULL) {
+		return 0;
+	}
+
+	ocs_memset(dma->virt, 0, dma->size);
+
+	hdr = dma->virt;
+
+	hdr->opcode = SLI4_OPC_COMMON_GET_CNTL_ATTRIBUTES;
+	hdr->subsystem = SLI4_SUBSYSTEM_COMMON;
+	hdr->request_length = dma->size;
+
+	return(sli_config_off + sizeof(sli4_req_hdr_t));
+}
+
+/**
+ * @brief Write a COMMON_GET_CNTL_ADDL_ATTRIBUTES command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param dma DMA structure from which the data will be copied.
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_get_cntl_addl_attributes(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma)
+{
+	sli4_req_hdr_t *hdr = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, sizeof(sli4_req_hdr_t), dma);
+	}
+
+	if (dma == NULL) {
+		return 0;
+	}
+
+	ocs_memset(dma->virt, 0, dma->size);
+
+	hdr = dma->virt;
+
+	hdr->opcode = SLI4_OPC_COMMON_GET_CNTL_ADDL_ATTRIBUTES;
+	hdr->subsystem = SLI4_SUBSYSTEM_COMMON;
+	hdr->request_length = dma->size;
+
+	return(sli_config_off + sizeof(sli4_req_hdr_t));
+}
+
+/**
+ * @brief Write a COMMON_CREATE_MQ_EXT command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param qmem DMA memory for the queue.
+ * @param cq_id Associated CQ_ID.
+ * @param ignored This parameter carries the ULP which is only used for WQ and RQs
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_create_mq_ext(sli4_t *sli4, void *buf, size_t size,
+			     ocs_dma_t *qmem, uint16_t cq_id, uint16_t ignored)
+{
+	sli4_req_common_create_mq_ext_t	*mq = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	p;
+	uintptr_t	addr;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_common_create_mq_ext_t),
+				sizeof(sli4_res_common_create_queue_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	mq = (sli4_req_common_create_mq_ext_t *)((uint8_t *)buf + sli_config_off);
+
+	mq->hdr.opcode = SLI4_OPC_COMMON_CREATE_MQ_EXT;
+	mq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	mq->hdr.request_length = sizeof(sli4_req_common_create_mq_ext_t) -
+					sizeof(sli4_req_hdr_t);
+	/* valid values for number of pages: 1, 2, 4, 8 (sec 4.4.12) */
+	mq->num_pages = qmem->size / SLI_PAGE_SIZE;
+	switch (mq->num_pages) {
+	case 1:
+		mq->ring_size = SLI4_MQE_SIZE_16;
+		break;
+	case 2:
+		mq->ring_size = SLI4_MQE_SIZE_32;
+		break;
+	case 4:
+		mq->ring_size = SLI4_MQE_SIZE_64;
+		break;
+	case 8:
+		mq->ring_size = SLI4_MQE_SIZE_128;
+		break;
+	default:
+		ocs_log_test(sli4->os, "num_pages %d not valid\n", mq->num_pages);
+		return -1;
+	}
+
+	/* TODO break this down by sli4->config.topology */
+	mq->async_event_bitmap = SLI4_ASYNC_EVT_FC_FCOE;
+
+	if (sli4->config.mq_create_version) {
+		mq->cq_id_v1 = cq_id;
+		mq->hdr.version = 1;
+	}
+	else {
+		mq->cq_id_v0 = cq_id;
+	}
+	mq->val = TRUE;
+
+	for (p = 0, addr = qmem->phys;
+			p < mq->num_pages;
+			p++, addr += SLI_PAGE_SIZE) {
+		mq->page_physical_address[p].low = ocs_addr32_lo(addr);
+		mq->page_physical_address[p].high = ocs_addr32_hi(addr);
+	}
+
+	return(sli_config_off + sizeof(sli4_req_common_create_mq_ext_t));
+}
+
+/**
+ * @brief Write a COMMON_DESTROY_MQ command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param mq_id MQ ID
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_destroy_mq(sli4_t *sli4, void *buf, size_t size, uint16_t mq_id)
+{
+	sli4_req_common_destroy_mq_t	*mq = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				/* Payload length must accommodate both request and response */
+				max(sizeof(sli4_req_common_destroy_mq_t),
+					sizeof(sli4_res_hdr_t)),
+				NULL);
+	}
+	mq = (sli4_req_common_destroy_mq_t *)((uint8_t *)buf + sli_config_off);
+
+	mq->hdr.opcode = SLI4_OPC_COMMON_DESTROY_MQ;
+	mq->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	mq->hdr.request_length = sizeof(sli4_req_common_destroy_mq_t) -
+					sizeof(sli4_req_hdr_t);
+
+	mq->mq_id = mq_id;
+
+	return(sli_config_off + sizeof(sli4_req_common_destroy_mq_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_NOP command
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param context NOP context value (passed to response, except on FC/FCoE).
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_nop(sli4_t *sli4, void *buf, size_t size, uint64_t context)
+{
+	sli4_req_common_nop_t *nop = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				/* Payload length must accommodate both request and response */
+				max(sizeof(sli4_req_common_nop_t), sizeof(sli4_res_common_nop_t)),
+				NULL);
+	}
+
+	nop = (sli4_req_common_nop_t *)((uint8_t *)buf + sli_config_off);
+
+	nop->hdr.opcode = SLI4_OPC_COMMON_NOP;
+	nop->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	nop->hdr.request_length = 8;
+
+	ocs_memcpy(&nop->context, &context, sizeof(context));
+
+	return(sli_config_off + sizeof(sli4_req_common_nop_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_GET_RESOURCE_EXTENT_INFO command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param rtype Resource type (for example, XRI, VFI, VPI, and RPI).
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_get_resource_extent_info(sli4_t *sli4, void *buf, size_t size, uint16_t rtype)
+{
+	sli4_req_common_get_resource_extent_info_t *extent = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof(sli4_req_common_get_resource_extent_info_t),
+				NULL);
+	}
+
+	extent = (sli4_req_common_get_resource_extent_info_t *)((uint8_t *)buf + sli_config_off);
+
+	extent->hdr.opcode = SLI4_OPC_COMMON_GET_RESOURCE_EXTENT_INFO;
+	extent->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	extent->hdr.request_length = 4;
+
+	extent->resource_type = rtype;
+
+	return(sli_config_off + sizeof(sli4_req_common_get_resource_extent_info_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_GET_SLI4_PARAMETERS command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_get_sli4_parameters(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_req_hdr_t	*hdr = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof(sli4_res_common_get_sli4_parameters_t),
+				NULL);
+	}
+
+	hdr = (sli4_req_hdr_t *)((uint8_t *)buf + sli_config_off);
+
+	hdr->opcode = SLI4_OPC_COMMON_GET_SLI4_PARAMETERS;
+	hdr->subsystem = SLI4_SUBSYSTEM_COMMON;
+	hdr->request_length = 0x50;
+
+	return(sli_config_off + sizeof(sli4_req_hdr_t));
+}
+
+/**
+ * @brief Write a COMMON_QUERY_FW_CONFIG command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to destination buffer.
+ * @param size Buffer size in bytes.
+ *
+ * @return Returns the number of bytes written
+ */
+static int32_t
+sli_cmd_common_query_fw_config(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_req_common_query_fw_config_t   *fw_config;
+	uint32_t	sli_config_off = 0;
+	uint32_t payload_size;
+
+	/* Payload length must accommodate both request and response */
+	payload_size = max(sizeof(sli4_req_common_query_fw_config_t),
+			   sizeof(sli4_res_common_query_fw_config_t));
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				payload_size,
+				NULL);
+	}
+
+	fw_config = (sli4_req_common_query_fw_config_t*)((uint8_t*)buf + sli_config_off);
+	fw_config->hdr.opcode	      = SLI4_OPC_COMMON_QUERY_FW_CONFIG;
+	fw_config->hdr.subsystem      = SLI4_SUBSYSTEM_COMMON;
+	fw_config->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+	return sli_config_off + sizeof(sli4_req_common_query_fw_config_t);
+}
+
+/**
+ * @brief Write a COMMON_GET_PORT_NAME command to the provided buffer.
+ *
+ * @param sli4 SLI context pointer.
+ * @param buf Virtual pointer to destination buffer.
+ * @param size Buffer size in bytes.
+ *
+ * @note Function supports both version 0 and 1 forms of this command via
+ * the IF_TYPE.
+ *
+ * @return Returns the number of bytes written.
+ */
+static int32_t
+sli_cmd_common_get_port_name(sli4_t *sli4, void *buf, size_t size)
+{
+	sli4_req_common_get_port_name_t	*port_name;
+	uint32_t	sli_config_off = 0;
+	uint32_t	payload_size;
+	uint8_t		version = 0;
+	uint8_t		pt = 0;
+
+	/* Select command version according to IF_TYPE */
+	switch (sli4->if_type) {
+	case SLI4_IF_TYPE_BE3_SKH_PF:
+	case SLI4_IF_TYPE_BE3_SKH_VF:
+		version = 0;
+		break;
+	case SLI4_IF_TYPE_LANCER_FC_ETH:
+	case SLI4_IF_TYPE_LANCER_RDMA:
+		version = 1;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unsupported IF_TYPE %d\n", sli4->if_type);
+		return 0;
+	}
+
+	/* Payload length must accommodate both request and response */
+	payload_size = max(sizeof(sli4_req_common_get_port_name_t),
+			   sizeof(sli4_res_common_get_port_name_t));
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				payload_size,
+				NULL);
+
+		pt = 1;
+	}
+
+	port_name = (sli4_req_common_get_port_name_t *)((uint8_t *)buf + sli_config_off);
+
+	port_name->hdr.opcode		= SLI4_OPC_COMMON_GET_PORT_NAME;
+	port_name->hdr.subsystem	= SLI4_SUBSYSTEM_COMMON;
+	port_name->hdr.request_length	= sizeof(sli4_req_hdr_t) + (version * sizeof(uint32_t));
+	port_name->hdr.version		= version;
+
+	/* Set the port type value (ethernet=0, FC=1) for V1 commands */
+	if (version == 1) {
+		port_name->pt = pt;
+	}
+
+	return sli_config_off + port_name->hdr.request_length;
+}
+
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_WRITE_OBJECT command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param noc True if the object should be written but not committed to flash.
+ * @param eof True if this is the last write for this object.
+ * @param desired_write_length Number of bytes of data to write to the object.
+ * @param offset Offset, in bytes, from the start of the object.
+ * @param object_name Name of the object to write.
+ * @param dma DMA structure from which the data will be copied.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_write_object(sli4_t *sli4, void *buf, size_t size,
+		uint16_t noc, uint16_t eof, uint32_t desired_write_length,
+		uint32_t offset,
+		char *object_name,
+		ocs_dma_t *dma)
+{
+	sli4_req_common_write_object_t *wr_obj = NULL;
+	uint32_t	sli_config_off = 0;
+	sli4_bde_t *host_buffer;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof (sli4_req_common_write_object_t) + sizeof (sli4_bde_t),
+				NULL);
+	}
+
+	wr_obj = (sli4_req_common_write_object_t *)((uint8_t *)buf + sli_config_off);
+
+	wr_obj->hdr.opcode = SLI4_OPC_COMMON_WRITE_OBJECT;
+	wr_obj->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	wr_obj->hdr.request_length = sizeof(*wr_obj) - 4*sizeof(uint32_t) + sizeof(sli4_bde_t);
+	wr_obj->hdr.timeout = 0;
+	wr_obj->hdr.version = 0;
+
+	wr_obj->noc = noc;
+	wr_obj->eof = eof;
+	wr_obj->desired_write_length = desired_write_length;
+	wr_obj->write_offset = offset;
+	ocs_strncpy(wr_obj->object_name, object_name, sizeof(wr_obj->object_name));
+	wr_obj->host_buffer_descriptor_count = 1;
+
+	host_buffer = (sli4_bde_t *)wr_obj->host_buffer_descriptor;
+
+	/* Setup to transfer xfer_size bytes to device */
+	host_buffer->bde_type = SLI4_BDE_TYPE_BDE_64;
+	host_buffer->buffer_length = desired_write_length;
+	host_buffer->u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
+	host_buffer->u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+
+
+	return(sli_config_off + sizeof(sli4_req_common_write_object_t) + sizeof (sli4_bde_t));
+}
+
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_DELETE_OBJECT command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param object_name Name of the object to write.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_delete_object(sli4_t *sli4, void *buf, size_t size,
+		char *object_name)
+{
+	sli4_req_common_delete_object_t *del_obj = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof (sli4_req_common_delete_object_t),
+				NULL);
+	}
+
+	del_obj = (sli4_req_common_delete_object_t *)((uint8_t *)buf + sli_config_off);
+
+	del_obj->hdr.opcode = SLI4_OPC_COMMON_DELETE_OBJECT;
+	del_obj->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	del_obj->hdr.request_length = sizeof(*del_obj);
+	del_obj->hdr.timeout = 0;
+	del_obj->hdr.version = 0;
+
+	ocs_strncpy(del_obj->object_name, object_name, sizeof(del_obj->object_name));
+	return(sli_config_off + sizeof(sli4_req_common_delete_object_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_READ_OBJECT command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param desired_read_length Number of bytes of data to read from the object.
+ * @param offset Offset, in bytes, from the start of the object.
+ * @param object_name Name of the object to read.
+ * @param dma DMA structure from which the data will be copied.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_read_object(sli4_t *sli4, void *buf, size_t size,
+		uint32_t desired_read_length,
+		uint32_t offset,
+		char *object_name,
+		ocs_dma_t *dma)
+{
+	sli4_req_common_read_object_t *rd_obj = NULL;
+	uint32_t	sli_config_off = 0;
+	sli4_bde_t *host_buffer;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof (sli4_req_common_read_object_t) + sizeof (sli4_bde_t),
+				NULL);
+	}
+
+	rd_obj = (sli4_req_common_read_object_t *)((uint8_t *)buf + sli_config_off);
+
+	rd_obj->hdr.opcode = SLI4_OPC_COMMON_READ_OBJECT;
+	rd_obj->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	rd_obj->hdr.request_length = sizeof(*rd_obj) - 4*sizeof(uint32_t) + sizeof(sli4_bde_t);
+	rd_obj->hdr.timeout = 0;
+	rd_obj->hdr.version = 0;
+
+	rd_obj->desired_read_length = desired_read_length;
+	rd_obj->read_offset = offset;
+	ocs_strncpy(rd_obj->object_name, object_name, sizeof(rd_obj->object_name));
+	rd_obj->host_buffer_descriptor_count = 1;
+
+	host_buffer = (sli4_bde_t *)rd_obj->host_buffer_descriptor;
+
+	/* Setup to transfer xfer_size bytes to device */
+	host_buffer->bde_type = SLI4_BDE_TYPE_BDE_64;
+	host_buffer->buffer_length = desired_read_length;
+	if (dma != NULL) {
+		host_buffer->u.data.buffer_address_low = ocs_addr32_lo(dma->phys);
+		host_buffer->u.data.buffer_address_high = ocs_addr32_hi(dma->phys);
+	} else {
+		host_buffer->u.data.buffer_address_low = 0;
+		host_buffer->u.data.buffer_address_high = 0;
+	}
+
+
+	return(sli_config_off + sizeof(sli4_req_common_read_object_t) + sizeof (sli4_bde_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a DMTF_EXEC_CLP_CMD command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param cmd DMA structure that describes the buffer for the command.
+ * @param resp DMA structure that describes the buffer for the response.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_dmtf_exec_clp_cmd(sli4_t *sli4, void *buf, size_t size,
+		ocs_dma_t *cmd,
+		ocs_dma_t *resp)
+{
+	sli4_req_dmtf_exec_clp_cmd_t *clp_cmd = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof (sli4_req_dmtf_exec_clp_cmd_t),
+				NULL);
+	}
+
+	clp_cmd = (sli4_req_dmtf_exec_clp_cmd_t*)((uint8_t *)buf + sli_config_off);
+
+	clp_cmd->hdr.opcode = SLI4_OPC_DMTF_EXEC_CLP_CMD;
+	clp_cmd->hdr.subsystem = SLI4_SUBSYSTEM_DMTF;
+	clp_cmd->hdr.request_length = sizeof(sli4_req_dmtf_exec_clp_cmd_t) -
+					sizeof(sli4_req_hdr_t);
+	clp_cmd->hdr.timeout = 0;
+	clp_cmd->hdr.version = 0;
+	clp_cmd->cmd_buf_length = cmd->size;
+	clp_cmd->cmd_buf_addr_low = ocs_addr32_lo(cmd->phys);
+	clp_cmd->cmd_buf_addr_high = ocs_addr32_hi(cmd->phys);
+	clp_cmd->resp_buf_length = resp->size;
+	clp_cmd->resp_buf_addr_low = ocs_addr32_lo(resp->phys);
+	clp_cmd->resp_buf_addr_high = ocs_addr32_hi(resp->phys);
+
+	return(sli_config_off + sizeof(sli4_req_dmtf_exec_clp_cmd_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_SET_DUMP_LOCATION command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param query Zero to set dump location, non-zero to query dump size
+ * @param is_buffer_list Set to one if the buffer is a set of buffer descriptors or
+ *                       set to 0 if the buffer is a contiguous dump area.
+ * @param buffer DMA structure to which the dump will be copied.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_set_dump_location(sli4_t *sli4, void *buf, size_t size,
+				 uint8_t query, uint8_t is_buffer_list,
+				 ocs_dma_t *buffer, uint8_t fdb)
+{
+	sli4_req_common_set_dump_location_t *set_dump_loc = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof (sli4_req_common_set_dump_location_t),
+				NULL);
+	}
+
+	set_dump_loc = (sli4_req_common_set_dump_location_t *)((uint8_t *)buf + sli_config_off);
+
+	set_dump_loc->hdr.opcode = SLI4_OPC_COMMON_SET_DUMP_LOCATION;
+	set_dump_loc->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	set_dump_loc->hdr.request_length = sizeof(sli4_req_common_set_dump_location_t) - sizeof(sli4_req_hdr_t);
+	set_dump_loc->hdr.timeout = 0;
+	set_dump_loc->hdr.version = 0;
+
+	set_dump_loc->blp = is_buffer_list;
+	set_dump_loc->qry = query;
+	set_dump_loc->fdb = fdb;
+
+	if (buffer) {
+		set_dump_loc->buf_addr_low = ocs_addr32_lo(buffer->phys);
+		set_dump_loc->buf_addr_high = ocs_addr32_hi(buffer->phys);
+		set_dump_loc->buffer_length = buffer->len;
+	} else {
+		set_dump_loc->buf_addr_low = 0;
+		set_dump_loc->buf_addr_high = 0;
+		set_dump_loc->buffer_length = 0;
+	}
+
+	return(sli_config_off + sizeof(sli4_req_common_set_dump_location_t));
+}
+
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_SET_FEATURES command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param feature Feature to set.
+ * @param param_len Length of the parameter (must be a multiple of 4 bytes).
+ * @param parameter Pointer to the parameter value.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_set_features(sli4_t *sli4, void *buf, size_t size,
+			    uint32_t feature,
+			    uint32_t param_len,
+			    void* parameter)
+{
+	sli4_req_common_set_features_t *cmd = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof (sli4_req_common_set_features_t),
+				NULL);
+	}
+
+	cmd = (sli4_req_common_set_features_t *)((uint8_t *)buf + sli_config_off);
+
+	cmd->hdr.opcode = SLI4_OPC_COMMON_SET_FEATURES;
+	cmd->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+	cmd->hdr.request_length = sizeof(sli4_req_common_set_features_t) - sizeof(sli4_req_hdr_t);
+	cmd->hdr.timeout = 0;
+	cmd->hdr.version = 0;
+
+	cmd->feature = feature;
+	cmd->param_len = param_len;
+	ocs_memcpy(cmd->params, parameter, param_len);
+
+	return(sli_config_off + sizeof(sli4_req_common_set_features_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_COMMON_GET_PROFILE_CONFIG command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size in bytes.
+ * @param dma DMA capable memory used to retrieve profile.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_get_profile_config(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma)
+{
+        sli4_req_common_get_profile_config_t *req = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	payload_size;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+				sizeof (sli4_req_common_get_profile_config_t),
+				dma);
+	}
+
+	if (dma != NULL) {
+		req = dma->virt;
+		ocs_memset(req, 0, dma->size);
+		payload_size = dma->size;
+	} else {
+		req = (sli4_req_common_get_profile_config_t *)((uint8_t *)buf + sli_config_off);
+		payload_size = sizeof(sli4_req_common_get_profile_config_t);
+	}
+
+        req->hdr.opcode = SLI4_OPC_COMMON_GET_PROFILE_CONFIG;
+        req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+        req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+        req->hdr.version = 1;
+
+        return(sli_config_off + sizeof(sli4_req_common_get_profile_config_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_COMMON_SET_PROFILE_CONFIG command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param dma DMA capable memory containing profile.
+ * @param profile_id Profile ID to configure.
+ * @param descriptor_count Number of descriptors in DMA buffer.
+ * @param isap Implicit Set Active Profile value to use.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_set_profile_config(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma,
+		uint8_t profile_id, uint32_t descriptor_count, uint8_t isap)
+{
+        sli4_req_common_set_profile_config_t *req = NULL;
+        uint32_t cmd_off = 0;
+        uint32_t payload_size;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		cmd_off = sli_cmd_sli_config(sli4, buf, size,
+						    sizeof (sli4_req_common_set_profile_config_t),
+						    dma);
+	}
+
+	if (dma != NULL) {
+		req = dma->virt;
+		ocs_memset(req, 0, dma->size);
+		payload_size = dma->size;
+	} else {
+		req = (sli4_req_common_set_profile_config_t *)((uint8_t *)buf + cmd_off);
+		payload_size = sizeof(sli4_req_common_set_profile_config_t);
+	}
+
+        req->hdr.opcode = SLI4_OPC_COMMON_SET_PROFILE_CONFIG;
+        req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+        req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+        req->hdr.version = 1;
+        req->profile_id = profile_id;
+        req->desc_count = descriptor_count;
+        req->isap = isap;
+
+        return(cmd_off + sizeof(sli4_req_common_set_profile_config_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_COMMON_GET_PROFILE_LIST command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size in bytes.
+ * @param start_profile_index First profile index to return.
+ * @param dma Buffer into which the list will be written.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_get_profile_list(sli4_t *sli4, void *buf, size_t size,
+                                   uint32_t start_profile_index, ocs_dma_t *dma)
+{
+        sli4_req_common_get_profile_list_t *req = NULL;
+        uint32_t cmd_off = 0;
+        uint32_t payload_size;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		cmd_off = sli_cmd_sli_config(sli4, buf, size,
+					     sizeof (sli4_req_common_get_profile_list_t),
+					     dma);
+	}
+
+	if (dma != NULL) {
+		req = dma->virt;
+		ocs_memset(req, 0, dma->size);
+		payload_size = dma->size;
+	} else {
+		req = (sli4_req_common_get_profile_list_t *)((uint8_t *)buf + cmd_off);
+		payload_size = sizeof(sli4_req_common_get_profile_list_t);
+	}
+
+        req->hdr.opcode = SLI4_OPC_COMMON_GET_PROFILE_LIST;
+        req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+        req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+        req->hdr.version = 0;
+
+        req->start_profile_index = start_profile_index;
+
+        return(cmd_off + sizeof(sli4_req_common_get_profile_list_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_COMMON_GET_ACTIVE_PROFILE command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size in bytes.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_get_active_profile(sli4_t *sli4, void *buf, size_t size)
+{
+        sli4_req_common_get_active_profile_t *req = NULL;
+        uint32_t cmd_off = 0;
+        uint32_t payload_size;
+
+        /* Payload length must accommodate both request and response */
+        payload_size = max(sizeof(sli4_req_common_get_active_profile_t),
+                           sizeof(sli4_res_common_get_active_profile_t));
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		cmd_off = sli_cmd_sli_config(sli4, buf, size,
+				payload_size,
+				NULL);
+	}
+
+        req = (sli4_req_common_get_active_profile_t *)
+                ((uint8_t*)buf + cmd_off);
+
+        req->hdr.opcode = SLI4_OPC_COMMON_GET_ACTIVE_PROFILE;
+        req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+        req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+        req->hdr.version = 0;
+
+        return(cmd_off + sizeof(sli4_req_common_get_active_profile_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_COMMON_SET_ACTIVE_PROFILE command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size in bytes.
+ * @param fd If non-zero, set profile to factory default.
+ * @param active_profile_id ID of new active profile.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_set_active_profile(sli4_t *sli4, void *buf, size_t size,
+                                  uint32_t fd, uint32_t active_profile_id)
+{
+        sli4_req_common_set_active_profile_t *req = NULL;
+        uint32_t cmd_off = 0;
+        uint32_t payload_size;
+
+        /* Payload length must accommodate both request and response */
+        payload_size = max(sizeof(sli4_req_common_set_active_profile_t),
+                           sizeof(sli4_res_common_set_active_profile_t));
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		cmd_off = sli_cmd_sli_config(sli4, buf, size,
+				payload_size,
+				NULL);
+	}
+
+        req = (sli4_req_common_set_active_profile_t *)
+                ((uint8_t*)buf + cmd_off);
+
+        req->hdr.opcode = SLI4_OPC_COMMON_SET_ACTIVE_PROFILE;
+        req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+        req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+        req->hdr.version = 0;
+        req->fd = fd;
+        req->active_profile_id = active_profile_id;
+
+        return(cmd_off + sizeof(sli4_req_common_set_active_profile_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_GET_RECONFIG_LINK_INFO command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size in bytes.
+ * @param dma Buffer to store the supported link configuration modes from the physical device.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_get_reconfig_link_info(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma)
+{
+        sli4_req_common_get_reconfig_link_info_t *req = NULL;
+        uint32_t cmd_off = 0;
+        uint32_t payload_size;
+
+        /* Payload length must accommodate both request and response */
+        payload_size = max(sizeof(sli4_req_common_get_reconfig_link_info_t),
+                           sizeof(sli4_res_common_get_reconfig_link_info_t));
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		cmd_off = sli_cmd_sli_config(sli4, buf, size,
+				payload_size,
+				dma);
+	}
+
+	if (dma != NULL) {
+		req = dma->virt;
+		ocs_memset(req, 0, dma->size);
+		payload_size = dma->size;
+	} else {
+		req = (sli4_req_common_get_reconfig_link_info_t *)((uint8_t *)buf + cmd_off);
+		payload_size = sizeof(sli4_req_common_get_reconfig_link_info_t);
+	}
+
+        req->hdr.opcode = SLI4_OPC_COMMON_GET_RECONFIG_LINK_INFO;
+        req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+        req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+        req->hdr.version = 0;
+
+        return(cmd_off + sizeof(sli4_req_common_get_reconfig_link_info_t));
+}
+
+/**
+ * @ingroup sli
+ * @brief Write a COMMON_SET_RECONFIG_LINK_ID command.
+ *
+ * @param sli4 SLI context.
+ * @param buf destination buffer for the command.
+ * @param size buffer size in bytes.
+ * @param fd If non-zero, set link config to factory default.
+ * @param active_link_config_id ID of new active profile.
+ * @param dma Buffer to assign the link configuration mode that is to become active from the physical device.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_common_set_reconfig_link_id(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma,
+                                  uint32_t fd, uint32_t active_link_config_id)
+{
+        sli4_req_common_set_reconfig_link_id_t *req = NULL;
+        uint32_t cmd_off = 0;
+        uint32_t payload_size;
+
+        /* Payload length must accommodate both request and response */
+        payload_size = max(sizeof(sli4_req_common_set_reconfig_link_id_t),
+                           sizeof(sli4_res_common_set_reconfig_link_id_t));
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		cmd_off = sli_cmd_sli_config(sli4, buf, size,
+				payload_size,
+				NULL);
+	}
+
+		if (dma != NULL) {
+		req = dma->virt;
+		ocs_memset(req, 0, dma->size);
+		payload_size = dma->size;
+	} else {
+		req = (sli4_req_common_set_reconfig_link_id_t *)((uint8_t *)buf + cmd_off);
+		payload_size = sizeof(sli4_req_common_set_reconfig_link_id_t);
+	}
+
+        req->hdr.opcode = SLI4_OPC_COMMON_SET_RECONFIG_LINK_ID;
+        req->hdr.subsystem = SLI4_SUBSYSTEM_COMMON;
+        req->hdr.request_length = payload_size - sizeof(sli4_req_hdr_t);
+        req->hdr.version = 0;
+        req->fd = fd;
+        req->next_link_config_id = active_link_config_id;
+
+        return(cmd_off + sizeof(sli4_req_common_set_reconfig_link_id_t));
+}
+
+
+/**
+ * @ingroup sli
+ * @brief Check the mailbox/queue completion entry.
+ *
+ * @param buf Pointer to the MCQE.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_cqe_mq(void *buf)
+{
+	sli4_mcqe_t	*mcqe = buf;
+
+	/*
+	 * Firmware can split mbx completions into two MCQEs: first with only
+	 * the "consumed" bit set and a second with the "complete" bit set.
+	 * Thus, ignore MCQE unless "complete" is set.
+	 */
+	if (!mcqe->cmp) {
+		return -2;
+	}
+
+	if (mcqe->completion_status) {
+		ocs_log_debug(NULL, "bad status (cmpl=%#x ext=%#x con=%d cmp=%d ae=%d val=%d)\n",
+				mcqe->completion_status,
+				mcqe->extended_status,
+				mcqe->con,
+				mcqe->cmp,
+				mcqe->ae,
+				mcqe->val);
+	}
+
+	return mcqe->completion_status;
+}
+
+/**
+ * @ingroup sli
+ * @brief Check the asynchronous event completion entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Pointer to the ACQE.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_cqe_async(sli4_t *sli4, void *buf)
+{
+	sli4_acqe_t	*acqe = buf;
+	int32_t		rc = -1;
+
+	if (!sli4 || !buf) {
+		ocs_log_err(NULL, "bad parameter sli4=%p buf=%p\n", sli4, buf);
+		return -1;
+	}
+
+	switch (acqe->event_code) {
+	case SLI4_ACQE_EVENT_CODE_LINK_STATE:
+		rc = sli_fc_process_link_state(sli4, buf);
+		break;
+	case SLI4_ACQE_EVENT_CODE_FCOE_FIP:
+		rc = sli_fc_process_fcoe(sli4, buf);
+		break;
+	case SLI4_ACQE_EVENT_CODE_GRP_5:
+		/*TODO*/ocs_log_debug(sli4->os, "ACQE GRP5\n");
+		break;
+	case SLI4_ACQE_EVENT_CODE_SLI_PORT_EVENT:
+        ocs_log_debug(sli4->os,"ACQE SLI Port, type=0x%x, data1,2=0x%08x,0x%08x\n",
+		acqe->event_type, acqe->event_data[0], acqe->event_data[1]);
+#if defined(OCS_INCLUDE_DEBUG)
+		ocs_dump32(OCS_DEBUG_ALWAYS, sli4->os, "acq", acqe, sizeof(*acqe));
+#endif
+		break;
+	case SLI4_ACQE_EVENT_CODE_FC_LINK_EVENT:
+		rc = sli_fc_process_link_attention(sli4, buf);
+		break;
+	default:
+		/*TODO*/ocs_log_test(sli4->os, "ACQE unknown=%#x\n", acqe->event_code);
+	}
+
+	return rc;
+}
+
+/**
+ * @brief Check the SLI_CONFIG response.
+ *
+ * @par Description
+ * Function checks the SLI_CONFIG response and the payload status.
+ *
+ * @param buf Pointer to SLI_CONFIG response.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+sli_res_sli_config(void *buf)
+{
+	sli4_cmd_sli_config_t	*sli_config = buf;
+
+	if (!buf || (SLI4_MBOX_COMMAND_SLI_CONFIG != sli_config->hdr.command)) {
+		ocs_log_err(NULL, "bad parameter buf=%p cmd=%#x\n", buf,
+				buf ? sli_config->hdr.command : -1);
+		return -1;
+	}
+
+	if (sli_config->hdr.status) {
+		return sli_config->hdr.status;
+	}
+
+	if (sli_config->emb) {
+		return sli_config->payload.embed[4];
+	} else {
+		ocs_log_test(NULL, "external buffers not supported\n");
+		return -1;
+	}
+}
+
+/**
+ * @brief Issue a COMMON_FUNCTION_RESET command.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+sli_common_function_reset(sli4_t *sli4)
+{
+
+	if (sli_cmd_common_function_reset(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (COM_FUNC_RESET)\n");
+			return -1;
+		}
+		if (sli_res_sli_config(sli4->bmbx.virt)) {
+			ocs_log_err(sli4->os, "bad status COM_FUNC_RESET\n");
+			return -1;
+		}
+	} else {
+		ocs_log_err(sli4->os, "bad COM_FUNC_RESET write\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+/**
+ * @brief check to see if the FW is ready.
+ *
+ * @par Description
+ * Based on <i>SLI-4 Architecture Specification, Revision 4.x0-13 (2012).</i>.
+ *
+ * @param sli4 SLI context.
+ * @param timeout_ms Time, in milliseconds, to wait for the port to be ready
+ *  before failing.
+ *
+ * @return Returns TRUE for ready, or FALSE otherwise.
+ */
+static int32_t
+sli_wait_for_fw_ready(sli4_t *sli4, uint32_t timeout_ms)
+{
+	uint32_t	iter = timeout_ms / (SLI4_INIT_PORT_DELAY_US / 1000);
+	uint32_t	ready = FALSE;
+
+	do {
+		iter--;
+		ocs_udelay(SLI4_INIT_PORT_DELAY_US);
+		if (sli_fw_ready(sli4) == 1) {
+			ready = TRUE;
+		}
+	} while (!ready && (iter > 0));
+
+	return ready;
+}
+
+/**
+ * @brief Initialize the firmware.
+ *
+ * @par Description
+ * Based on <i>SLI-4 Architecture Specification, Revision 4.x0-13 (2012).</i>.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+sli_fw_init(sli4_t *sli4)
+{
+	uint32_t ready;
+	uint32_t endian;
+
+	/*
+	 * Is firmware ready for operation?
+	 */
+	ready = sli_wait_for_fw_ready(sli4, SLI4_FW_READY_TIMEOUT_MSEC);
+	if (!ready) {
+		ocs_log_crit(sli4->os, "FW status is NOT ready\n");
+		return -1;
+	}
+
+	/*
+	 * Reset port to a known state
+	 */
+	switch (sli4->if_type) {
+	case SLI4_IF_TYPE_BE3_SKH_PF:
+	case SLI4_IF_TYPE_BE3_SKH_VF:
+		/* No SLIPORT_CONTROL register so use command sequence instead */
+		if (sli_bmbx_wait(sli4, SLI4_BMBX_DELAY_US)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox not ready\n");
+			return -1;
+		}
+
+		if (sli_cmd_fw_initialize(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+			if (sli_bmbx_command(sli4)) {
+				ocs_log_crit(sli4->os, "bootstrap mailbox write fail (FW_INIT)\n");
+				return -1;
+			}
+		} else {
+			ocs_log_crit(sli4->os, "bad FW_INIT write\n");
+			return -1;
+		}
+
+		if (sli_common_function_reset(sli4)) {
+			ocs_log_err(sli4->os, "bad COM_FUNC_RESET write\n");
+			return -1;
+		}
+		break;
+	case SLI4_IF_TYPE_LANCER_FC_ETH:
+#if BYTE_ORDER == LITTLE_ENDIAN
+		endian = SLI4_SLIPORT_CONTROL_LITTLE_ENDIAN;
+#else
+		endian = SLI4_SLIPORT_CONTROL_BIG_ENDIAN;
+#endif
+
+		if (sli_sliport_control(sli4, endian))
+			return -1;
+		break;
+	default:
+		ocs_log_test(sli4->os, "if_type %d not supported\n", sli4->if_type);
+		return -1;
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Terminate the firmware.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+sli_fw_term(sli4_t *sli4)
+{
+	uint32_t endian;
+
+	if (sli4->if_type == SLI4_IF_TYPE_BE3_SKH_PF ||
+	    sli4->if_type == SLI4_IF_TYPE_BE3_SKH_VF) {
+		/* No SLIPORT_CONTROL register so use command sequence instead */
+		if (sli_bmbx_wait(sli4, SLI4_BMBX_DELAY_US)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox not ready\n");
+			return -1;
+		}
+
+		if (sli_common_function_reset(sli4)) {
+			ocs_log_err(sli4->os, "bad COM_FUNC_RESET write\n");
+			return -1;
+		}
+
+		if (sli_cmd_fw_deinitialize(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+			if (sli_bmbx_command(sli4)) {
+				ocs_log_crit(sli4->os, "bootstrap mailbox write fail (FW_DEINIT)\n");
+				return -1;
+			}
+		} else {
+			ocs_log_test(sli4->os, "bad FW_DEINIT write\n");
+			return -1;
+		}
+	} else {
+#if BYTE_ORDER == LITTLE_ENDIAN
+		endian = SLI4_SLIPORT_CONTROL_LITTLE_ENDIAN;
+#else
+		endian = SLI4_SLIPORT_CONTROL_BIG_ENDIAN;
+#endif
+		/* type 2 etc. use SLIPORT_CONTROL to initialize port */
+		sli_sliport_control(sli4, endian);
+	}
+	return 0;
+}
+
+/**
+ * @brief Write the doorbell register associated with the queue object.
+ *
+ * @param sli4 SLI context.
+ * @param q Queue object.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+sli_queue_doorbell(sli4_t *sli4, sli4_queue_t *q)
+{
+	uint32_t	val = 0;
+
+	switch (q->type) {
+	case SLI_QTYPE_EQ:
+		val = sli_eq_doorbell(q->n_posted, q->id, FALSE);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		break;
+	case SLI_QTYPE_CQ:
+		val = sli_cq_doorbell(q->n_posted, q->id, FALSE);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		break;
+	case SLI_QTYPE_MQ:
+		val = SLI4_MQ_DOORBELL(q->n_posted, q->id);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		break;
+	case SLI_QTYPE_RQ:
+	{
+		uint32_t	n_posted = q->n_posted;
+		/*
+		 * FC/FCoE has different rules for Receive Queues. The host
+		 * should only update the doorbell of the RQ-pair containing
+		 * the headers since the header / payload RQs are treated
+		 * as a matched unit.
+		 */
+		if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+			/*
+			 * In RQ-pair, an RQ either contains the FC header
+			 * (i.e. is_hdr == TRUE) or the payload.
+			 *
+			 * Don't ring doorbell for payload RQ
+			 */
+			if (!q->u.flag.is_hdr) {
+				break;
+			}
+			/*
+			 * Some RQ cannot be incremented one entry at a time. Instead,
+			 * the driver collects a number of entries and updates the
+			 * RQ in batches.
+			 */
+			if (q->u.flag.rq_batch) {
+				if (((q->index + q->n_posted) % SLI4_QUEUE_RQ_BATCH)) {
+					break;
+				}
+				n_posted = SLI4_QUEUE_RQ_BATCH;
+			}
+		}
+
+		val = SLI4_RQ_DOORBELL(n_posted, q->id);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		break;
+	}
+	case SLI_QTYPE_WQ:
+		val = SLI4_WQ_DOORBELL(q->n_posted, q->index, q->id);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		break;
+	default:
+		ocs_log_test(sli4->os, "bad queue type %d\n", q->type);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int32_t
+sli_request_features(sli4_t *sli4, sli4_features_t *features, uint8_t query)
+{
+
+	if (sli_cmd_request_features(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE,
+				*features, query)) {
+		sli4_cmd_request_features_t *req_features = sli4->bmbx.virt;
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (REQUEST_FEATURES)\n");
+			return -1;
+		}
+		if (req_features->hdr.status) {
+			ocs_log_err(sli4->os, "REQUEST_FEATURES bad status %#x\n",
+					req_features->hdr.status);
+			return -1;
+		}
+		features->dword = req_features->response.dword;
+	} else {
+		ocs_log_err(sli4->os, "bad REQUEST_FEATURES write\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/**
+ * @brief Calculate max queue entries.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+void
+sli_calc_max_qentries(sli4_t *sli4)
+{
+	sli4_qtype_e q;
+	uint32_t alloc_size, qentries, qentry_size;
+
+	for (q = SLI_QTYPE_EQ; q < SLI_QTYPE_MAX; q++) {
+		sli4->config.max_qentries[q] = sli_convert_mask_to_count(sli4->config.count_method[q],
+									 sli4->config.count_mask[q]);
+	}
+
+	/* single, continguous DMA allocations will be called for each queue
+	 * of size (max_qentries * queue entry size); since these can be large,
+	 * check against the OS max DMA allocation size
+	 */
+	for (q = SLI_QTYPE_EQ; q < SLI_QTYPE_MAX; q++) {
+		qentries = sli4->config.max_qentries[q];
+		qentry_size = sli_get_queue_entry_size(sli4, q);
+		alloc_size = qentries * qentry_size;
+		if (alloc_size > ocs_max_dma_alloc(sli4->os, SLI_PAGE_SIZE)) {
+			while (alloc_size > ocs_max_dma_alloc(sli4->os, SLI_PAGE_SIZE)) {
+				/* cut the qentries in hwf until alloc_size <= max DMA alloc size */
+				qentries >>= 1;
+				alloc_size = qentries * qentry_size;
+			}
+			ocs_log_debug(sli4->os, "[%s]: max_qentries from %d to %d (max dma %d)\n",
+				SLI_QNAME[q], sli4->config.max_qentries[q],
+				qentries, ocs_max_dma_alloc(sli4->os, SLI_PAGE_SIZE));
+			sli4->config.max_qentries[q] = qentries;
+		}
+	}
+}
+
+/**
+ * @brief Issue a FW_CONFIG mailbox command and store the results.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static int32_t
+sli_query_fw_config(sli4_t *sli4)
+{
+	/*
+	 * Read the device configuration
+	 *
+	 * Note: Only ulp0 fields contain values
+	 */
+	if (sli_cmd_common_query_fw_config(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+		sli4_res_common_query_fw_config_t   *fw_config =
+			(sli4_res_common_query_fw_config_t *)
+			(((uint8_t *)sli4->bmbx.virt) + offsetof(sli4_cmd_sli_config_t, payload.embed));
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (QUERY_FW_CONFIG)\n");
+			return -1;
+		}
+		if (fw_config->hdr.status) {
+			ocs_log_err(sli4->os, "COMMON_QUERY_FW_CONFIG bad status %#x\n",
+				fw_config->hdr.status);
+			return -1;
+		}
+
+		sli4->physical_port = fw_config->physical_port;
+		sli4->config.dual_ulp_capable = ((fw_config->function_mode & SLI4_FUNCTION_MODE_DUA_MODE) == 0 ? 0 : 1);
+		sli4->config.is_ulp_fc[0] = ((fw_config->ulp0_mode &
+					      (SLI4_ULP_MODE_FCOE_INI |
+					       SLI4_ULP_MODE_FCOE_TGT)) == 0 ? 0 : 1);
+		sli4->config.is_ulp_fc[1] = ((fw_config->ulp1_mode &
+					      (SLI4_ULP_MODE_FCOE_INI |
+					       SLI4_ULP_MODE_FCOE_TGT)) == 0 ? 0 : 1);
+
+		if (sli4->config.dual_ulp_capable) {
+			/*
+			 * Lancer will not support this, so we use the values
+			 * from the READ_CONFIG.
+			 */
+			if (sli4->config.is_ulp_fc[0] &&
+			    sli4->config.is_ulp_fc[1]) {
+				sli4->config.max_qcount[SLI_QTYPE_WQ] = fw_config->ulp0_toe_wq_total + fw_config->ulp1_toe_wq_total;
+				sli4->config.max_qcount[SLI_QTYPE_RQ] = fw_config->ulp0_toe_defrq_total + fw_config->ulp1_toe_defrq_total;
+			} else if (sli4->config.is_ulp_fc[0]) {
+				sli4->config.max_qcount[SLI_QTYPE_WQ] = fw_config->ulp0_toe_wq_total;
+				sli4->config.max_qcount[SLI_QTYPE_RQ] = fw_config->ulp0_toe_defrq_total;
+			} else {
+				sli4->config.max_qcount[SLI_QTYPE_WQ] = fw_config->ulp1_toe_wq_total;
+				sli4->config.max_qcount[SLI_QTYPE_RQ] = fw_config->ulp1_toe_defrq_total;
+			}
+		}
+	} else {
+		ocs_log_err(sli4->os, "bad QUERY_FW_CONFIG write\n");
+		return -1;
+	}
+	return 0;
+}
+
+
+static int32_t
+sli_get_config(sli4_t *sli4)
+{
+	ocs_dma_t	get_cntl_addl_data;
+
+	/*
+	 * Read the device configuration
+	 */
+	if (sli_cmd_read_config(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+		sli4_res_read_config_t	*read_config = sli4->bmbx.virt;
+		uint32_t	i;
+		uint32_t	total;
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (READ_CONFIG)\n");
+			return -1;
+		}
+		if (read_config->hdr.status) {
+			ocs_log_err(sli4->os, "READ_CONFIG bad status %#x\n",
+					read_config->hdr.status);
+			return -1;
+		}
+
+		sli4->config.has_extents = read_config->ext;
+		if (FALSE == sli4->config.has_extents) {
+			uint32_t	i = 0;
+			uint32_t	*base = sli4->config.extent[0].base;
+
+			if (!base) {
+				if (NULL == (base = ocs_malloc(sli4->os, SLI_RSRC_MAX * sizeof(uint32_t),
+								OCS_M_ZERO | OCS_M_NOWAIT))) {
+					ocs_log_err(sli4->os, "memory allocation failed for sli4_resource_t\n");
+					return -1;
+				}
+			}
+
+			for (i = 0; i < SLI_RSRC_MAX; i++) {
+				sli4->config.extent[i].number = 1;
+				sli4->config.extent[i].n_alloc = 0;
+				sli4->config.extent[i].base = &base[i];
+			}
+
+			sli4->config.extent[SLI_RSRC_FCOE_VFI].base[0] = read_config->vfi_base;
+			sli4->config.extent[SLI_RSRC_FCOE_VFI].size = read_config->vfi_count;
+
+			sli4->config.extent[SLI_RSRC_FCOE_VPI].base[0] = read_config->vpi_base;
+			sli4->config.extent[SLI_RSRC_FCOE_VPI].size = read_config->vpi_count;
+
+			sli4->config.extent[SLI_RSRC_FCOE_RPI].base[0] = read_config->rpi_base;
+			sli4->config.extent[SLI_RSRC_FCOE_RPI].size = read_config->rpi_count;
+
+			sli4->config.extent[SLI_RSRC_FCOE_XRI].base[0] = read_config->xri_base;
+			sli4->config.extent[SLI_RSRC_FCOE_XRI].size = read_config->xri_count;
+
+			sli4->config.extent[SLI_RSRC_FCOE_FCFI].base[0] = 0;
+			sli4->config.extent[SLI_RSRC_FCOE_FCFI].size = read_config->fcfi_count;
+		} else {
+			/* TODO extents*/
+			;
+		}
+
+		for (i = 0; i < SLI_RSRC_MAX; i++) {
+			total = sli4->config.extent[i].number * sli4->config.extent[i].size;
+			sli4->config.extent[i].use_map = ocs_bitmap_alloc(total);
+			if (NULL == sli4->config.extent[i].use_map) {
+				ocs_log_err(sli4->os, "bitmap memory allocation failed "
+						"resource %d\n", i);
+				return -1;
+			}
+			sli4->config.extent[i].map_size = total;
+		}
+
+		sli4->config.topology = read_config->topology;
+		switch (sli4->config.topology) {
+		case SLI4_READ_CFG_TOPO_FCOE:
+			ocs_log_debug(sli4->os, "FCoE\n");
+			break;
+		case SLI4_READ_CFG_TOPO_FC:
+			ocs_log_debug(sli4->os, "FC (unknown)\n");
+			break;
+		case SLI4_READ_CFG_TOPO_FC_DA:
+			ocs_log_debug(sli4->os, "FC (direct attach)\n");
+			break;
+		case SLI4_READ_CFG_TOPO_FC_AL:
+			ocs_log_debug(sli4->os, "FC (arbitrated loop)\n");
+			break;
+		default:
+			ocs_log_test(sli4->os, "bad topology %#x\n", sli4->config.topology);
+		}
+
+		sli4->config.e_d_tov = read_config->e_d_tov;
+		sli4->config.r_a_tov = read_config->r_a_tov;
+
+		sli4->config.link_module_type = read_config->lmt;
+
+		sli4->config.max_qcount[SLI_QTYPE_EQ] = read_config->eq_count;
+		sli4->config.max_qcount[SLI_QTYPE_CQ] = read_config->cq_count;
+		sli4->config.max_qcount[SLI_QTYPE_WQ] = read_config->wq_count;
+		sli4->config.max_qcount[SLI_QTYPE_RQ] = read_config->rq_count;
+
+		/*
+		 * READ_CONFIG doesn't give the max number of MQ. Applications
+		 * will typically want 1, but we may need another at some future
+		 * date. Dummy up a "max" MQ count here.
+		 */
+		sli4->config.max_qcount[SLI_QTYPE_MQ] = SLI_USER_MQ_COUNT;
+	} else {
+		ocs_log_err(sli4->os, "bad READ_CONFIG write\n");
+		return -1;
+	}
+
+	if (sli_cmd_common_get_sli4_parameters(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+		sli4_res_common_get_sli4_parameters_t	*parms = (sli4_res_common_get_sli4_parameters_t *)
+			(((uint8_t *)sli4->bmbx.virt) + offsetof(sli4_cmd_sli_config_t, payload.embed));
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (COMMON_GET_SLI4_PARAMETERS)\n");
+			return -1;
+		} else if (parms->hdr.status) {
+			ocs_log_err(sli4->os, "COMMON_GET_SLI4_PARAMETERS bad status %#x att'l %#x\n",
+					parms->hdr.status, parms->hdr.additional_status);
+			return -1;
+		}
+
+		sli4->config.auto_reg = parms->areg;
+		sli4->config.auto_xfer_rdy = parms->agxf;
+		sli4->config.hdr_template_req = parms->hdrr;
+		sli4->config.t10_dif_inline_capable = parms->timm;
+		sli4->config.t10_dif_separate_capable = parms->tsmm;
+
+		sli4->config.mq_create_version = parms->mqv;
+		sli4->config.cq_create_version = parms->cqv;
+		sli4->config.rq_min_buf_size = parms->min_rq_buffer_size;
+		sli4->config.rq_max_buf_size = parms->max_rq_buffer_size;
+
+		sli4->config.qpage_count[SLI_QTYPE_EQ] = parms->eq_page_cnt;
+		sli4->config.qpage_count[SLI_QTYPE_CQ] = parms->cq_page_cnt;
+		sli4->config.qpage_count[SLI_QTYPE_MQ] = parms->mq_page_cnt;
+		sli4->config.qpage_count[SLI_QTYPE_WQ] = parms->wq_page_cnt;
+		sli4->config.qpage_count[SLI_QTYPE_RQ] = parms->rq_page_cnt;
+
+		/* save count methods and masks for each queue type */
+		sli4->config.count_mask[SLI_QTYPE_EQ] = parms->eqe_count_mask;
+		sli4->config.count_method[SLI_QTYPE_EQ] = parms->eqe_count_method;
+		sli4->config.count_mask[SLI_QTYPE_CQ] = parms->cqe_count_mask;
+		sli4->config.count_method[SLI_QTYPE_CQ] = parms->cqe_count_method;
+		sli4->config.count_mask[SLI_QTYPE_MQ] = parms->mqe_count_mask;
+		sli4->config.count_method[SLI_QTYPE_MQ] = parms->mqe_count_method;
+		sli4->config.count_mask[SLI_QTYPE_WQ] = parms->wqe_count_mask;
+		sli4->config.count_method[SLI_QTYPE_WQ] = parms->wqe_count_method;
+		sli4->config.count_mask[SLI_QTYPE_RQ] = parms->rqe_count_mask;
+		sli4->config.count_method[SLI_QTYPE_RQ] = parms->rqe_count_method;
+
+		/* now calculate max queue entries */
+		sli_calc_max_qentries(sli4);
+
+		sli4->config.max_sgl_pages = parms->sgl_page_cnt;	/* max # of pages */
+		sli4->config.sgl_page_sizes = parms->sgl_page_sizes;	/* bit map of available sizes */
+		/* ignore HLM here. Use value from REQUEST_FEATURES */
+		
+		sli4->config.sge_supported_length = parms->sge_supported_length;
+		if (sli4->config.sge_supported_length > OCS_MAX_SGE_SIZE)
+			sli4->config.sge_supported_length = OCS_MAX_SGE_SIZE;
+
+		sli4->config.sgl_pre_registration_required = parms->sglr;
+		/* default to using pre-registered SGL's */
+		sli4->config.sgl_pre_registered = TRUE;
+
+		sli4->config.perf_hint = parms->phon;
+		sli4->config.perf_wq_id_association = parms->phwq;
+
+		sli4->config.rq_batch = parms->rq_db_window;
+
+		/* save the fields for skyhawk SGL chaining */
+		sli4->config.sgl_chaining_params.chaining_capable =
+			(parms->sglc == 1);
+		sli4->config.sgl_chaining_params.frag_num_field_offset =
+			parms->frag_num_field_offset;
+		sli4->config.sgl_chaining_params.frag_num_field_mask =
+			(1ull << parms->frag_num_field_size) - 1;
+		sli4->config.sgl_chaining_params.sgl_index_field_offset =
+			parms->sgl_index_field_offset;
+		sli4->config.sgl_chaining_params.sgl_index_field_mask =
+			(1ull << parms->sgl_index_field_size) - 1;
+		sli4->config.sgl_chaining_params.chain_sge_initial_value_lo =
+			parms->chain_sge_initial_value_lo;
+		sli4->config.sgl_chaining_params.chain_sge_initial_value_hi =
+			parms->chain_sge_initial_value_hi;
+
+		/* Use the highest available WQE size. */
+		if (parms->wqe_sizes & SLI4_128BYTE_WQE_SUPPORT) {
+			sli4->config.wqe_size = SLI4_WQE_EXT_BYTES;
+		} else {
+			sli4->config.wqe_size = SLI4_WQE_BYTES;
+		}
+	}
+
+	if (sli_query_fw_config(sli4)) {
+		ocs_log_err(sli4->os, "Error sending QUERY_FW_CONFIG\n");
+		return -1;
+	}
+
+	sli4->config.port_number = 0;
+
+	/*
+	 * Issue COMMON_GET_CNTL_ATTRIBUTES to get port_number. Temporarily
+	 * uses VPD DMA buffer as the response won't fit in the embedded
+	 * buffer.
+	 */
+	if (sli_cmd_common_get_cntl_attributes(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, &sli4->vpd.data)) {
+		sli4_res_common_get_cntl_attributes_t *attr = sli4->vpd.data.virt;
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (COMMON_GET_CNTL_ATTRIBUTES)\n");
+			return -1;
+		} else if (attr->hdr.status) {
+			ocs_log_err(sli4->os, "COMMON_GET_CNTL_ATTRIBUTES bad status %#x att'l %#x\n",
+					attr->hdr.status, attr->hdr.additional_status);
+			return -1;
+		}
+
+		sli4->config.port_number = attr->port_number;
+
+		ocs_memcpy(sli4->config.bios_version_string, attr->bios_version_string,
+				sizeof(sli4->config.bios_version_string));
+	} else {
+		ocs_log_err(sli4->os, "bad COMMON_GET_CNTL_ATTRIBUTES write\n");
+		return -1;
+	}
+
+	if (ocs_dma_alloc(sli4->os, &get_cntl_addl_data, sizeof(sli4_res_common_get_cntl_addl_attributes_t),
+			  OCS_MIN_DMA_ALIGNMENT)) {
+		ocs_log_err(sli4->os, "Failed to allocate memory for GET_CNTL_ADDL_ATTR data\n");
+	} else {
+		if (sli_cmd_common_get_cntl_addl_attributes(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE,
+							    &get_cntl_addl_data)) {
+			sli4_res_common_get_cntl_addl_attributes_t *attr = get_cntl_addl_data.virt;
+
+			if (sli_bmbx_command(sli4)) {
+				ocs_log_crit(sli4->os,
+					     "bootstrap mailbox write fail (COMMON_GET_CNTL_ADDL_ATTRIBUTES)\n");
+				ocs_dma_free(sli4->os, &get_cntl_addl_data);
+				return -1;
+			}
+			if (attr->hdr.status) {
+				ocs_log_err(sli4->os, "COMMON_GET_CNTL_ADDL_ATTRIBUTES bad status %#x\n",
+					    attr->hdr.status);
+				ocs_dma_free(sli4->os, &get_cntl_addl_data);
+				return -1;
+			}
+
+			ocs_memcpy(sli4->config.ipl_name, attr->ipl_file_name, sizeof(sli4->config.ipl_name));
+
+			ocs_log_debug(sli4->os, "IPL:%s \n", (char*)sli4->config.ipl_name);
+		} else {
+			ocs_log_err(sli4->os, "bad COMMON_GET_CNTL_ADDL_ATTRIBUTES write\n");
+			ocs_dma_free(sli4->os, &get_cntl_addl_data);
+			return -1;
+		}
+
+		ocs_dma_free(sli4->os, &get_cntl_addl_data);
+	}
+
+	if (sli_cmd_common_get_port_name(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+		sli4_res_common_get_port_name_t	*port_name = (sli4_res_common_get_port_name_t *)(((uint8_t *)sli4->bmbx.virt) +
+			offsetof(sli4_cmd_sli_config_t, payload.embed));
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (COMMON_GET_PORT_NAME)\n");
+			return -1;
+		}
+
+		sli4->config.port_name[0] = port_name->port_name[sli4->config.port_number];
+	}
+	sli4->config.port_name[1] = '\0';
+
+	if (sli_cmd_read_rev(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, &sli4->vpd.data)) {
+		sli4_cmd_read_rev_t	*read_rev = sli4->bmbx.virt;
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (READ_REV)\n");
+			return -1;
+		}
+		if (read_rev->hdr.status) {
+			ocs_log_err(sli4->os, "READ_REV bad status %#x\n",
+					read_rev->hdr.status);
+			return -1;
+		}
+
+		sli4->config.fw_rev[0] = read_rev->first_fw_id;
+		ocs_memcpy(sli4->config.fw_name[0],read_rev->first_fw_name, sizeof(sli4->config.fw_name[0]));
+
+		sli4->config.fw_rev[1] = read_rev->second_fw_id;
+		ocs_memcpy(sli4->config.fw_name[1],read_rev->second_fw_name, sizeof(sli4->config.fw_name[1]));
+
+		sli4->config.hw_rev[0] = read_rev->first_hw_revision;
+		sli4->config.hw_rev[1] = read_rev->second_hw_revision;
+		sli4->config.hw_rev[2] = read_rev->third_hw_revision;
+
+		ocs_log_debug(sli4->os, "FW1:%s (%08x) / FW2:%s (%08x)\n",
+				read_rev->first_fw_name, read_rev->first_fw_id,
+				read_rev->second_fw_name, read_rev->second_fw_id);
+
+		ocs_log_debug(sli4->os, "HW1: %08x / HW2: %08x\n", read_rev->first_hw_revision,
+				read_rev->second_hw_revision);
+
+		/* Check that all VPD data was returned */
+		if (read_rev->returned_vpd_length != read_rev->actual_vpd_length) {
+			ocs_log_test(sli4->os, "VPD length: available=%d returned=%d actual=%d\n",
+					read_rev->available_length,
+					read_rev->returned_vpd_length,
+					read_rev->actual_vpd_length);
+		}
+		sli4->vpd.length = read_rev->returned_vpd_length;
+	} else {
+		ocs_log_err(sli4->os, "bad READ_REV write\n");
+		return -1;
+	}
+
+	if (sli_cmd_read_nvparms(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE)) {
+		sli4_cmd_read_nvparms_t	*read_nvparms = sli4->bmbx.virt;
+
+		if (sli_bmbx_command(sli4)) {
+			ocs_log_crit(sli4->os, "bootstrap mailbox write fail (READ_NVPARMS)\n");
+			return -1;
+		}
+		if (read_nvparms->hdr.status) {
+			ocs_log_err(sli4->os, "READ_NVPARMS bad status %#x\n",
+					read_nvparms->hdr.status);
+			return -1;
+		}
+
+		ocs_memcpy(sli4->config.wwpn, read_nvparms->wwpn, sizeof(sli4->config.wwpn));
+		ocs_memcpy(sli4->config.wwnn, read_nvparms->wwnn, sizeof(sli4->config.wwnn));
+
+		ocs_log_debug(sli4->os, "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
+				sli4->config.wwpn[0],
+				sli4->config.wwpn[1],
+				sli4->config.wwpn[2],
+				sli4->config.wwpn[3],
+				sli4->config.wwpn[4],
+				sli4->config.wwpn[5],
+				sli4->config.wwpn[6],
+				sli4->config.wwpn[7]);
+		ocs_log_debug(sli4->os, "WWNN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
+				sli4->config.wwnn[0],
+				sli4->config.wwnn[1],
+				sli4->config.wwnn[2],
+				sli4->config.wwnn[3],
+				sli4->config.wwnn[4],
+				sli4->config.wwnn[5],
+				sli4->config.wwnn[6],
+				sli4->config.wwnn[7]);
+	} else {
+		ocs_log_err(sli4->os, "bad READ_NVPARMS write\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ * Public functions
+ */
+
+/**
+ * @ingroup sli
+ * @brief Set up the SLI context.
+ *
+ * @param sli4 SLI context.
+ * @param os Device abstraction.
+ * @param port_type Protocol type of port (for example, FC and NIC).
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_setup(sli4_t *sli4, ocs_os_handle_t os, sli4_port_type_e port_type)
+{
+	uint32_t sli_intf = UINT32_MAX;
+	uint32_t pci_class_rev = 0;
+	uint32_t rev_id = 0;
+	uint32_t family = 0;
+	uint32_t i;
+	sli4_asic_entry_t *asic;
+
+	ocs_memset(sli4, 0, sizeof(sli4_t));
+
+	sli4->os = os;
+	sli4->port_type = port_type;
+
+	/*
+	 * Read the SLI_INTF register to discover the register layout
+	 * and other capability information
+	 */
+	sli_intf = ocs_config_read32(os, SLI4_INTF_REG);
+
+	if (sli_intf_valid_check(sli_intf)) {
+		ocs_log_err(os, "SLI_INTF is not valid\n");
+		return -1;
+	}
+
+	/* driver only support SLI-4 */
+	sli4->sli_rev = sli_intf_sli_revision(sli_intf);
+	if (4 != sli4->sli_rev) {
+		ocs_log_err(os, "Unsupported SLI revision (intf=%#x)\n",
+				sli_intf);
+		return -1;
+	}
+
+	sli4->sli_family = sli_intf_sli_family(sli_intf);
+
+	sli4->if_type = sli_intf_if_type(sli_intf);
+
+	if (SLI4_IF_TYPE_LANCER_FC_ETH == sli4->if_type) {
+		ocs_log_debug(os, "status=%#x error1=%#x error2=%#x\n",
+				sli_reg_read(sli4, SLI4_REG_SLIPORT_STATUS),
+				sli_reg_read(sli4, SLI4_REG_SLIPORT_ERROR1),
+				sli_reg_read(sli4, SLI4_REG_SLIPORT_ERROR2));
+	}
+
+	/*
+	 * set the ASIC type and revision
+	 */
+	pci_class_rev = ocs_config_read32(os, SLI4_PCI_CLASS_REVISION);
+	rev_id = sli_pci_rev_id(pci_class_rev);
+	family = sli4->sli_family;
+	if (family == SLI4_FAMILY_CHECK_ASIC_TYPE) {
+		uint32_t asic_id = ocs_config_read32(os, SLI4_ASIC_ID_REG);
+		family = sli_asic_gen(asic_id);
+	}
+
+	for (i = 0, asic = sli4_asic_table; i < ARRAY_SIZE(sli4_asic_table); i++, asic++) {
+		if ((rev_id == asic->rev_id) && (family == asic->family)) {
+			sli4->asic_type = asic->type;
+			sli4->asic_rev = asic->rev;
+			break;
+		}
+	}
+	/* Fail if no matching asic type/rev was found */
+	if( (sli4->asic_type == 0) || (sli4->asic_rev == 0)) {
+		ocs_log_err(os, "no matching asic family/rev found: %02x/%02x\n", family, rev_id);
+		return -1;
+	}
+
+	/*
+	 * The bootstrap mailbox is equivalent to a MQ with a single 256 byte
+	 * entry, a CQ with a single 16 byte entry, and no event queue.
+	 * Alignment must be 16 bytes as the low order address bits in the
+	 * address register are also control / status.
+	 */
+	if (ocs_dma_alloc(sli4->os, &sli4->bmbx, SLI4_BMBX_SIZE +
+				sizeof(sli4_mcqe_t), 16)) {
+		ocs_log_err(os, "bootstrap mailbox allocation failed\n");
+		return -1;
+	}
+
+	if (sli4->bmbx.phys & SLI4_BMBX_MASK_LO) {
+		ocs_log_err(os, "bad alignment for bootstrap mailbox\n");
+		return -1;
+	}
+
+	ocs_log_debug(os, "bmbx v=%p p=0x%x %08x s=%zd\n", sli4->bmbx.virt,
+		ocs_addr32_hi(sli4->bmbx.phys),
+		ocs_addr32_lo(sli4->bmbx.phys),
+		sli4->bmbx.size);
+
+	/* TODO 4096 is arbitrary. What should this value actually be? */
+	if (ocs_dma_alloc(sli4->os, &sli4->vpd.data, 4096/*TODO*/, 4096)) {
+		/* Note that failure isn't fatal in this specific case */
+		sli4->vpd.data.size = 0;
+		ocs_log_test(os, "VPD buffer allocation failed\n");
+	}
+
+	if (sli_fw_init(sli4)) {
+		ocs_log_err(sli4->os, "FW initialization failed\n");
+		return -1;
+	}
+
+	/*
+	 * Set one of fcpi(initiator), fcpt(target), fcpc(combined) to true
+	 * in addition to any other desired features
+	 */
+	sli4->config.features.flag.iaab = TRUE;
+	sli4->config.features.flag.npiv = TRUE;
+	sli4->config.features.flag.dif = TRUE;
+	sli4->config.features.flag.vf = TRUE;
+	sli4->config.features.flag.fcpc = TRUE;
+	sli4->config.features.flag.iaar = TRUE;
+	sli4->config.features.flag.hlm = TRUE;
+	sli4->config.features.flag.perfh = TRUE;
+	sli4->config.features.flag.rxseq = TRUE;
+	sli4->config.features.flag.rxri = TRUE;
+	sli4->config.features.flag.mrqp = TRUE;
+
+	/* use performance hints if available */
+	if (sli4->config.perf_hint) {
+		sli4->config.features.flag.perfh = TRUE;
+	}
+
+	if (sli_request_features(sli4, &sli4->config.features, TRUE)) {
+		return -1;
+	}
+
+	if (sli_get_config(sli4)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+int32_t
+sli_init(sli4_t *sli4)
+{
+
+	if (sli4->config.has_extents) {
+		/* TODO COMMON_ALLOC_RESOURCE_EXTENTS */;
+		ocs_log_test(sli4->os, "XXX need to implement extent allocation\n");
+		return -1;
+	}
+
+	sli4->config.features.flag.hlm = sli4->config.high_login_mode;
+	sli4->config.features.flag.rxseq = FALSE;
+	sli4->config.features.flag.rxri  = FALSE;
+
+	if (sli_request_features(sli4, &sli4->config.features, FALSE)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+int32_t
+sli_reset(sli4_t *sli4)
+{
+	uint32_t	i;
+
+	if (sli_fw_init(sli4)) {
+		ocs_log_crit(sli4->os, "FW initialization failed\n");
+		return -1;
+	}
+
+	if (sli4->config.extent[0].base) {
+		ocs_free(sli4->os, sli4->config.extent[0].base, SLI_RSRC_MAX * sizeof(uint32_t));
+		sli4->config.extent[0].base = NULL;
+	}
+
+	for (i = 0; i < SLI_RSRC_MAX; i++) {
+		if (sli4->config.extent[i].use_map) {
+			ocs_bitmap_free(sli4->config.extent[i].use_map);
+			sli4->config.extent[i].use_map = NULL;
+		}
+		sli4->config.extent[i].base = NULL;
+	}
+
+	if (sli_get_config(sli4)) {
+		return -1;
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Issue a Firmware Reset.
+ *
+ * @par Description
+ * Issues a Firmware Reset to the chip.  This reset affects the entire chip,
+ * so all PCI function on the same PCI bus and device are affected.
+ * @n @n This type of reset can be used to activate newly downloaded firmware.
+ * @n @n The driver should be considered to be in an unknown state after this
+ * reset and should be reloaded.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return Returns 0 on success, or -1 otherwise.
+ */
+
+int32_t
+sli_fw_reset(sli4_t *sli4)
+{
+	uint32_t val;
+	uint32_t ready;
+
+	/*
+	 * Firmware must be ready before issuing the reset.
+	 */
+	ready = sli_wait_for_fw_ready(sli4, SLI4_FW_READY_TIMEOUT_MSEC);
+	if (!ready) {
+		ocs_log_crit(sli4->os, "FW status is NOT ready\n");
+		return -1;
+	}
+	switch(sli4->if_type) {
+	case SLI4_IF_TYPE_BE3_SKH_PF:
+		/* BE3 / Skyhawk use PCICFG_SOFT_RESET_CSR */
+		val = ocs_config_read32(sli4->os, SLI4_PCI_SOFT_RESET_CSR);
+		val |= SLI4_PCI_SOFT_RESET_MASK;
+		ocs_config_write32(sli4->os, SLI4_PCI_SOFT_RESET_CSR, val);
+		break;
+	case SLI4_IF_TYPE_LANCER_FC_ETH:
+		/* Lancer uses PHYDEV_CONTROL */
+
+		val = SLI4_PHYDEV_CONTROL_FRST;
+		sli_reg_write(sli4, SLI4_REG_PHYSDEV_CONTROL, val);
+		break;
+	default:
+		ocs_log_test(sli4->os, "Unexpected iftype %d\n", sli4->if_type);
+		return -1;
+		break;
+	}
+
+	/* wait for the FW to become ready after the reset */
+	ready = sli_wait_for_fw_ready(sli4, SLI4_FW_READY_TIMEOUT_MSEC);
+	if (!ready) {
+		ocs_log_crit(sli4->os, "Failed to become ready after firmware reset\n");
+		return -1;
+	}
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Tear down a SLI context.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return Returns 0 on success, or non-zero otherwise.
+ */
+int32_t
+sli_teardown(sli4_t *sli4)
+{
+	uint32_t i;
+
+	if (sli4->config.extent[0].base) {
+		ocs_free(sli4->os, sli4->config.extent[0].base, SLI_RSRC_MAX * sizeof(uint32_t));
+		sli4->config.extent[0].base = NULL;
+	}
+
+	for (i = 0; i < SLI_RSRC_MAX; i++) {
+		if (sli4->config.has_extents) {
+			/* TODO COMMON_DEALLOC_RESOURCE_EXTENTS */;
+		}
+
+		sli4->config.extent[i].base = NULL;
+
+		ocs_bitmap_free(sli4->config.extent[i].use_map);
+		sli4->config.extent[i].use_map = NULL;
+	}
+
+	if (sli_fw_term(sli4)) {
+		ocs_log_err(sli4->os, "FW deinitialization failed\n");
+	}
+
+	ocs_dma_free(sli4->os, &sli4->vpd.data);
+	ocs_dma_free(sli4->os, &sli4->bmbx);
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Register a callback for the given event.
+ *
+ * @param sli4 SLI context.
+ * @param which Event of interest.
+ * @param func Function to call when the event occurs.
+ * @param arg Argument passed to the callback function.
+ *
+ * @return Returns 0 on success, or non-zero otherwise.
+ */
+int32_t
+sli_callback(sli4_t *sli4, sli4_callback_e which, void *func, void *arg)
+{
+
+	if (!sli4 || !func || (which >= SLI4_CB_MAX)) {
+		ocs_log_err(NULL, "bad parameter sli4=%p which=%#x func=%p\n",
+			    sli4, which, func);
+		return -1;
+	}
+
+	switch (which) {
+	case SLI4_CB_LINK:
+		sli4->link = func;
+		sli4->link_arg = arg;
+		break;
+	case SLI4_CB_FIP:
+		sli4->fip = func;
+		sli4->fip_arg = arg;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unknown callback %#x\n", which);
+		return -1;
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Initialize a queue object.
+ *
+ * @par Description
+ * This initializes the sli4_queue_t object members, including the underlying
+ * DMA memory.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to queue object.
+ * @param qtype Type of queue to create.
+ * @param size Size of each entry.
+ * @param n_entries Number of entries to allocate.
+ * @param align Starting memory address alignment.
+ *
+ * @note Checks if using the existing DMA memory (if any) is possible. If not,
+ * it frees the existing memory and re-allocates.
+ *
+ * @return Returns 0 on success, or non-zero otherwise.
+ */
+int32_t
+__sli_queue_init(sli4_t *sli4, sli4_queue_t *q, uint32_t qtype,
+		size_t size, uint32_t n_entries, uint32_t align)
+{
+
+	if ((q->dma.virt == NULL) || (size != q->size) || (n_entries != q->length)) {
+		if (q->dma.size) {
+			ocs_dma_free(sli4->os, &q->dma);
+		}
+
+		ocs_memset(q, 0, sizeof(sli4_queue_t));
+
+		if (ocs_dma_alloc(sli4->os, &q->dma, size * n_entries, align)) {
+			ocs_log_err(sli4->os, "%s allocation failed\n", SLI_QNAME[qtype]);
+			return -1;
+		}
+
+		ocs_memset(q->dma.virt, 0, size * n_entries);
+
+		ocs_lock_init(sli4->os, &q->lock, "%s lock[%d:%p]", 
+			SLI_QNAME[qtype], ocs_instance(sli4->os), &q->lock);
+
+		q->type = qtype;
+		q->size = size;
+		q->length = n_entries;
+
+		/* Limit to hwf the queue size per interrupt */
+		q->proc_limit = n_entries / 2;
+
+		switch(q->type) {
+		case SLI_QTYPE_EQ:
+			q->posted_limit = q->length / 2;
+			break;
+		default:
+			if ((sli4->if_type == SLI4_IF_TYPE_BE3_SKH_PF) ||
+			    (sli4->if_type == SLI4_IF_TYPE_BE3_SKH_VF)) {
+				/* For Skyhawk, ring the doorbell more often */
+				q->posted_limit = 8;
+			} else {
+				q->posted_limit = 64;
+			}
+			break;
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Issue the command to create a queue.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to queue object.
+ *
+ * @return Returns 0 on success, or non-zero otherwise.
+ */
+int32_t
+__sli_create_queue(sli4_t *sli4, sli4_queue_t *q)
+{
+	sli4_res_common_create_queue_t *res_q = NULL;
+
+	if (sli_bmbx_command(sli4)){
+		ocs_log_crit(sli4->os, "bootstrap mailbox write fail %s\n",
+				SLI_QNAME[q->type]);
+		ocs_dma_free(sli4->os, &q->dma);
+		return -1;
+	}
+	if (sli_res_sli_config(sli4->bmbx.virt)) {
+		ocs_log_err(sli4->os, "bad status create %s\n", SLI_QNAME[q->type]);
+		ocs_dma_free(sli4->os, &q->dma);
+		return -1;
+	}
+	res_q = (void *)((uint8_t *)sli4->bmbx.virt +
+			offsetof(sli4_cmd_sli_config_t, payload));
+
+	if (res_q->hdr.status) {
+		ocs_log_err(sli4->os, "bad create %s status=%#x addl=%#x\n",
+				SLI_QNAME[q->type],
+				res_q->hdr.status, res_q->hdr.additional_status);
+		ocs_dma_free(sli4->os, &q->dma);
+		return -1;
+	} else {
+		q->id = res_q->q_id;
+		q->doorbell_offset = res_q->db_offset;
+		q->doorbell_rset = res_q->db_rs;
+
+		switch (q->type) {
+		case SLI_QTYPE_EQ:
+			/* No doorbell information in response for EQs */
+			q->doorbell_offset = regmap[SLI4_REG_EQCQ_DOORBELL][sli4->if_type].off;
+			q->doorbell_rset = regmap[SLI4_REG_EQCQ_DOORBELL][sli4->if_type].rset;
+			break;
+		case SLI_QTYPE_CQ:
+			/* No doorbell information in response for CQs */
+			q->doorbell_offset = regmap[SLI4_REG_EQCQ_DOORBELL][sli4->if_type].off;
+			q->doorbell_rset = regmap[SLI4_REG_EQCQ_DOORBELL][sli4->if_type].rset;
+			break;
+		case SLI_QTYPE_MQ:
+			/* No doorbell information in response for MQs */
+			q->doorbell_offset = regmap[SLI4_REG_MQ_DOORBELL][sli4->if_type].off;
+			q->doorbell_rset = regmap[SLI4_REG_MQ_DOORBELL][sli4->if_type].rset;
+			break;
+		case SLI_QTYPE_RQ:
+			/* set the doorbell for non-skyhawks */
+			if (!sli4->config.dual_ulp_capable) {
+				q->doorbell_offset = regmap[SLI4_REG_FCOE_RQ_DOORBELL][sli4->if_type].off;
+				q->doorbell_rset = regmap[SLI4_REG_FCOE_RQ_DOORBELL][sli4->if_type].rset;
+			}
+			break;
+		case SLI_QTYPE_WQ:
+			/* set the doorbell for non-skyhawks */
+			if (!sli4->config.dual_ulp_capable) {
+				q->doorbell_offset = regmap[SLI4_REG_IO_WQ_DOORBELL][sli4->if_type].off;
+				q->doorbell_rset = regmap[SLI4_REG_IO_WQ_DOORBELL][sli4->if_type].rset;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Get queue entry size.
+ *
+ * Get queue entry size given queue type.
+ *
+ * @param sli4 SLI context
+ * @param qtype Type for which the entry size is returned.
+ *
+ * @return Returns > 0 on success (queue entry size), or a negative value on failure.
+ */
+int32_t
+sli_get_queue_entry_size(sli4_t *sli4, uint32_t qtype)
+{
+	uint32_t	size = 0;
+
+	if (!sli4) {
+		ocs_log_err(NULL, "bad parameter sli4=%p\n", sli4);
+		return -1;
+	}
+
+	switch (qtype) {
+	case SLI_QTYPE_EQ:
+		size = sizeof(uint32_t);
+		break;
+	case SLI_QTYPE_CQ:
+		size = 16;
+		break;
+	case SLI_QTYPE_MQ:
+		size = 256;
+		break;
+	case SLI_QTYPE_WQ:
+		if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+			size = sli4->config.wqe_size;
+		} else {
+			/* TODO */
+			ocs_log_test(sli4->os, "unsupported queue entry size\n");
+			return -1;
+		}
+		break;
+	case SLI_QTYPE_RQ:
+		size = SLI4_FCOE_RQE_SIZE;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unknown queue type %d\n", qtype);
+		return -1;
+	}
+	return size;
+}
+
+/**
+ * @ingroup sli
+ * @brief Modify the delay timer for all the EQs
+ *
+ * @param sli4 SLI context.
+ * @param eq Array of EQs.
+ * @param num_eq Count of EQs.
+ * @param shift Phase shift for staggering interrupts.
+ * @param delay_mult Delay multiplier for limiting interrupt frequency.
+ *
+ * @return Returns 0 on success, or -1 otherwise.
+ */
+int32_t
+sli_eq_modify_delay(sli4_t *sli4, sli4_queue_t *eq, uint32_t num_eq, uint32_t shift, uint32_t delay_mult)
+{
+
+	sli_cmd_common_modify_eq_delay(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, eq, num_eq, shift, delay_mult);
+
+	if (sli_bmbx_command(sli4)) {
+		ocs_log_crit(sli4->os, "bootstrap mailbox write fail (MODIFY EQ DELAY)\n");
+		return -1;
+	}
+	if (sli_res_sli_config(sli4->bmbx.virt)) {
+		ocs_log_err(sli4->os, "bad status MODIFY EQ DELAY\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Allocate a queue.
+ *
+ * @par Description
+ * Allocates DMA memory and configures the requested queue type.
+ *
+ * @param sli4 SLI context.
+ * @param qtype Type of queue to create.
+ * @param q Pointer to the queue object.
+ * @param n_entries Number of entries to allocate.
+ * @param assoc Associated queue (that is, the EQ for a CQ, the CQ for a MQ, and so on).
+ * @param ulp The ULP to bind, which is only used for WQ and RQs
+ *
+ * @return Returns 0 on success, or -1 otherwise.
+ */
+int32_t
+sli_queue_alloc(sli4_t *sli4, uint32_t qtype, sli4_queue_t *q, uint32_t n_entries,
+		sli4_queue_t *assoc, uint16_t ulp)
+{
+	int32_t		size;
+	uint32_t	align = 0;
+	sli4_create_q_fn_t create = NULL;
+
+	if (!sli4 || !q) {
+		ocs_log_err(NULL, "bad parameter sli4=%p q=%p\n", sli4, q);
+		return -1;
+	}
+
+	/* get queue size */
+	size = sli_get_queue_entry_size(sli4, qtype);
+	if (size < 0)
+		return -1;
+	align = SLI_PAGE_SIZE;
+
+	switch (qtype) {
+	case SLI_QTYPE_EQ:
+		create = sli_cmd_common_create_eq;
+		break;
+	case SLI_QTYPE_CQ:
+		create = sli_cmd_common_create_cq;
+		break;
+	case SLI_QTYPE_MQ:
+		/* Validate the number of entries */
+		switch (n_entries) {
+		case 16:
+		case 32:
+		case 64:
+		case 128:
+			break;
+		default:
+			ocs_log_test(sli4->os, "illegal n_entries value %d for MQ\n", n_entries);
+			return -1;
+		}
+		assoc->u.flag.is_mq = TRUE;
+		create = sli_cmd_common_create_mq_ext;
+		break;
+	case SLI_QTYPE_WQ:
+		if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+			if (sli4->if_type == SLI4_IF_TYPE_BE3_SKH_PF) {
+				create = sli_cmd_fcoe_wq_create;
+			} else {
+				create = sli_cmd_fcoe_wq_create_v1;
+			}
+		} else {
+			/* TODO */
+			ocs_log_test(sli4->os, "unsupported WQ create\n");
+			return -1;
+		}
+		break;
+	default:
+		ocs_log_test(sli4->os, "unknown queue type %d\n", qtype);
+		return -1;
+	}
+
+
+	if (__sli_queue_init(sli4, q, qtype, size, n_entries, align)) {
+		ocs_log_err(sli4->os, "%s allocation failed\n", SLI_QNAME[qtype]);
+		return -1;
+	}
+
+	if (create(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, &q->dma, assoc ? assoc->id : 0, ulp)) {
+
+		if (__sli_create_queue(sli4, q)) {
+			ocs_log_err(sli4->os, "create %s failed\n", SLI_QNAME[qtype]);
+			return -1;
+		}
+		q->ulp = ulp;
+	} else {
+		ocs_log_err(sli4->os, "cannot create %s\n", SLI_QNAME[qtype]);
+		return -1;
+	}
+
+	return 0;
+}
+
+
+/**
+ * @ingroup sli
+ * @brief Allocate a c queue set.
+ *
+ * @param sli4 SLI context.
+ * @param num_cqs to create
+ * @param qs Pointers to the queue objects.
+ * @param n_entries Number of entries to allocate per CQ.
+ * @param eqs Associated event queues
+ *
+ * @return Returns 0 on success, or -1 otherwise.
+ */
+int32_t
+sli_cq_alloc_set(sli4_t *sli4, sli4_queue_t *qs[], uint32_t num_cqs,
+		 uint32_t n_entries, sli4_queue_t *eqs[])
+{
+	uint32_t i, offset = 0,  page_bytes = 0, payload_size, cmd_size = 0;
+	uint32_t p = 0, page_size = 0, n_cqe = 0, num_pages_cq;
+	uintptr_t addr;
+	ocs_dma_t dma;
+	sli4_req_common_create_cq_set_v0_t  *req = NULL;
+	sli4_res_common_create_queue_set_t *res = NULL;
+
+	if (!sli4) {
+		ocs_log_err(NULL, "bad parameter sli4=%p\n", sli4);
+		return -1;
+	}
+
+	/* Align the queue DMA memory */
+	for (i = 0; i < num_cqs; i++) {
+		if (__sli_queue_init(sli4, qs[i], SLI_QTYPE_CQ, SLI4_CQE_BYTES,
+			n_entries, SLI_PAGE_SIZE)) {
+			ocs_log_err(sli4->os, "Queue init failed.\n");
+			goto error;
+		}
+	}
+
+	n_cqe = qs[0]->dma.size / SLI4_CQE_BYTES;
+	switch (n_cqe) {
+	case 256:
+	case 512:
+	case 1024:
+	case 2048:
+		page_size = 1;
+		break;
+	case 4096:
+		page_size = 2;
+		break;
+	default:
+		return -1;
+	}
+
+	page_bytes = page_size * SLI_PAGE_SIZE;
+	num_pages_cq = sli_page_count(qs[0]->dma.size, page_bytes);
+	cmd_size = sizeof(sli4_req_common_create_cq_set_v0_t) + (8 * num_pages_cq * num_cqs);
+	payload_size = max((size_t)cmd_size, sizeof(sli4_res_common_create_queue_set_t));
+
+	if (ocs_dma_alloc(sli4->os, &dma, payload_size, SLI_PAGE_SIZE)) {
+		ocs_log_err(sli4->os, "DMA allocation failed\n");
+		goto error;
+	}
+	ocs_memset(dma.virt, 0, payload_size);
+
+	if (sli_cmd_sli_config(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, 
+			payload_size, &dma) == -1) {
+		goto error;
+	}
+
+	/* Fill the request structure */
+
+	req = (sli4_req_common_create_cq_set_v0_t *)((uint8_t *)dma.virt);
+	req->hdr.opcode = SLI4_OPC_COMMON_CREATE_CQ_SET;
+	req->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	req->hdr.version = 0;
+	req->hdr.request_length = cmd_size - sizeof(sli4_req_hdr_t);
+	req->page_size = page_size;
+
+	req->num_pages = num_pages_cq;
+	switch (req->num_pages) {
+	case 1:
+		req->cqecnt = SLI4_CQ_CNT_256;
+		break;
+	case 2:
+		req->cqecnt = SLI4_CQ_CNT_512;
+		break;
+	case 4:
+		req->cqecnt = SLI4_CQ_CNT_1024;
+		break;
+	case 8:
+		req->cqecnt = SLI4_CQ_CNT_LARGE;
+		req->cqe_count = n_cqe;
+		break;
+	default:
+		ocs_log_test(sli4->os, "num_pages %d not valid\n", req->num_pages);
+		goto error;
+	}
+
+	req->evt = TRUE;
+	req->valid = TRUE;
+	req->arm = FALSE;
+	req->num_cq_req = num_cqs;
+
+	/* Fill page addresses of all the CQs. */
+	for (i = 0; i < num_cqs; i++) {
+		req->eq_id[i] = eqs[i]->id;
+		for (p = 0, addr = qs[i]->dma.phys; p < req->num_pages; p++, addr += page_bytes) {
+			req->page_physical_address[offset].low = ocs_addr32_lo(addr);
+			req->page_physical_address[offset].high = ocs_addr32_hi(addr);
+			offset++;
+		}
+	}
+
+	if (sli_bmbx_command(sli4)) {
+		ocs_log_crit(sli4->os, "bootstrap mailbox write fail CQSet\n");
+		goto error;
+	}
+
+	res = (void *)((uint8_t *)dma.virt);
+	if (res->hdr.status) {
+		ocs_log_err(sli4->os, "bad create CQSet status=%#x addl=%#x\n",
+			res->hdr.status, res->hdr.additional_status);
+		goto error;
+	} else {
+		/* Check if we got all requested CQs. */
+		if (res->num_q_allocated != num_cqs) {
+			ocs_log_crit(sli4->os, "Requested count CQs doesnt match.\n");
+			goto error;
+		}
+
+		/* Fill the resp cq ids. */
+		for (i = 0; i < num_cqs; i++) {
+			qs[i]->id = res->q_id + i;
+			qs[i]->doorbell_offset = regmap[SLI4_REG_EQCQ_DOORBELL][sli4->if_type].off;
+			qs[i]->doorbell_rset   = regmap[SLI4_REG_EQCQ_DOORBELL][sli4->if_type].rset;
+		}
+	}
+
+	ocs_dma_free(sli4->os, &dma);
+
+	return 0;
+
+error:
+	for (i = 0; i < num_cqs; i++) {
+		if (qs[i]->dma.size) {
+			ocs_dma_free(sli4->os, &qs[i]->dma);
+		}
+	}
+
+	if (dma.size) {
+		ocs_dma_free(sli4->os, &dma);
+	}
+
+	return -1;
+}
+
+
+
+/**
+ * @ingroup sli
+ * @brief Free a queue.
+ *
+ * @par Description
+ * Frees DMA memory and de-registers the requested queue.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to the queue object.
+ * @param destroy_queues Non-zero if the mailbox commands should be sent to destroy the queues.
+ * @param free_memory Non-zero if the DMA memory associated with the queue should be freed.
+ *
+ * @return Returns 0 on success, or -1 otherwise.
+ */
+int32_t
+sli_queue_free(sli4_t *sli4, sli4_queue_t *q, uint32_t destroy_queues, uint32_t free_memory)
+{
+	sli4_destroy_q_fn_t destroy = NULL;
+	int32_t		rc = -1;
+
+	if (!sli4 || !q) {
+		ocs_log_err(NULL, "bad parameter sli4=%p q=%p\n", sli4, q);
+		return -1;
+	}
+
+	if (destroy_queues) {
+		switch (q->type) {
+		case SLI_QTYPE_EQ:
+			destroy = sli_cmd_common_destroy_eq;
+			break;
+		case SLI_QTYPE_CQ:
+			destroy = sli_cmd_common_destroy_cq;
+			break;
+		case SLI_QTYPE_MQ:
+			destroy = sli_cmd_common_destroy_mq;
+			break;
+		case SLI_QTYPE_WQ:
+			if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+				destroy = sli_cmd_fcoe_wq_destroy;
+			} else {
+				/* TODO */
+				ocs_log_test(sli4->os, "unsupported WQ destroy\n");
+				return -1;
+			}
+			break;
+		case SLI_QTYPE_RQ:
+			if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+				destroy = sli_cmd_fcoe_rq_destroy;
+			} else {
+				/* TODO */
+				ocs_log_test(sli4->os, "unsupported RQ destroy\n");
+				return -1;
+			}
+			break;
+		default:
+			ocs_log_test(sli4->os, "bad queue type %d\n",
+					q->type);
+			return -1;
+		}
+
+		/*
+		 * Destroying queues makes BE3 sad (version 0 interface type). Rely
+		 * on COMMON_FUNCTION_RESET to free host allocated queue resources
+		 * inside the SLI Port.
+		 */
+		if (SLI4_IF_TYPE_BE3_SKH_PF == sli4->if_type) {
+			destroy = NULL;
+		}
+
+		/* Destroy the queue if the operation is defined */
+		if (destroy && destroy(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, q->id)) {
+			sli4_res_hdr_t	*res = NULL;
+
+			if (sli_bmbx_command(sli4)){
+				ocs_log_crit(sli4->os, "bootstrap mailbox write fail destroy %s\n",
+						SLI_QNAME[q->type]);
+			} else if (sli_res_sli_config(sli4->bmbx.virt)) {
+				ocs_log_err(sli4->os, "bad status destroy %s\n", SLI_QNAME[q->type]);
+			} else {
+				res = (void *)((uint8_t *)sli4->bmbx.virt +
+						offsetof(sli4_cmd_sli_config_t, payload));
+
+				if (res->status) {
+					ocs_log_err(sli4->os, "bad destroy %s status=%#x addl=%#x\n",
+							SLI_QNAME[q->type],
+							res->status, res->additional_status);
+				} else {
+					rc = 0;
+				}
+			}
+		}
+	}
+
+	if (free_memory) {
+		ocs_lock_free(&q->lock);
+
+		if (ocs_dma_free(sli4->os, &q->dma)) {
+			ocs_log_err(sli4->os, "%s queue ID %d free failed\n",
+				    SLI_QNAME[q->type], q->id);
+			rc = -1;
+		}
+	}
+
+	return rc;
+}
+
+int32_t
+sli_queue_reset(sli4_t *sli4, sli4_queue_t *q)
+{
+
+	ocs_lock(&q->lock);
+
+	q->index = 0;
+	q->n_posted = 0;
+
+	if (SLI_QTYPE_MQ == q->type) {
+		q->u.r_idx = 0;
+	}
+
+	if (q->dma.virt != NULL) {
+		ocs_memset(q->dma.virt, 0, (q->size * q->length));
+	}
+
+	ocs_unlock(&q->lock);
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Check if the given queue is empty.
+ *
+ * @par Description
+ * If the valid bit of the current entry is unset, the queue is empty.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to the queue object.
+ *
+ * @return Returns TRUE if empty, or FALSE otherwise.
+ */
+int32_t
+sli_queue_is_empty(sli4_t *sli4, sli4_queue_t *q)
+{
+	int32_t		rc = TRUE;
+	uint8_t		*qe = q->dma.virt;
+
+	ocs_lock(&q->lock);
+
+	ocs_dma_sync(&q->dma, OCS_DMASYNC_POSTREAD);
+
+	qe += q->index * q->size;
+
+	rc = !sli_queue_entry_is_valid(q, qe, FALSE);
+
+	ocs_unlock(&q->lock);
+
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Arm an EQ.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to queue object.
+ * @param arm If TRUE, arm the EQ.
+ *
+ * @return Returns 0 on success, or non-zero otherwise.
+ */
+int32_t
+sli_queue_eq_arm(sli4_t *sli4, sli4_queue_t *q, uint8_t arm)
+{
+	uint32_t	val = 0;
+
+	ocs_lock(&q->lock);
+		val = sli_eq_doorbell(q->n_posted, q->id, arm);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		q->n_posted = 0;
+	ocs_unlock(&q->lock);
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Arm a queue.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to queue object.
+ * @param arm If TRUE, arm the queue.
+ *
+ * @return Returns 0 on success, or non-zero otherwise.
+ */
+int32_t
+sli_queue_arm(sli4_t *sli4, sli4_queue_t *q, uint8_t arm)
+{
+	uint32_t	val = 0;
+
+	ocs_lock(&q->lock);
+
+	switch (q->type) {
+	case SLI_QTYPE_EQ:
+		val = sli_eq_doorbell(q->n_posted, q->id, arm);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		q->n_posted = 0;
+		break;
+	case SLI_QTYPE_CQ:
+		val = sli_cq_doorbell(q->n_posted, q->id, arm);
+		ocs_reg_write32(sli4->os, q->doorbell_rset, q->doorbell_offset, val);
+		q->n_posted = 0;
+		break;
+	default:
+		ocs_log_test(sli4->os, "should only be used for EQ/CQ, not %s\n",
+			     SLI_QNAME[q->type]);
+	}
+
+	ocs_unlock(&q->lock);
+
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an entry to the queue object.
+ *
+ * Note: Assumes the q->lock will be locked and released by the caller.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to the queue object.
+ * @param entry Pointer to the entry contents.
+ *
+ * @return Returns queue index on success, or negative error value otherwise.
+ */
+int32_t
+_sli_queue_write(sli4_t *sli4, sli4_queue_t *q, uint8_t *entry)
+{
+	int32_t		rc = 0;
+	uint8_t		*qe = q->dma.virt;
+	uint32_t	qindex;
+
+	qindex = q->index;
+	qe += q->index * q->size;
+
+	if (entry) {
+		if ((SLI_QTYPE_WQ == q->type) && sli4->config.perf_wq_id_association) {
+			sli_set_wq_id_association(entry, q->id);
+		}
+#if defined(OCS_INCLUDE_DEBUG)
+		switch (q->type) {
+		case SLI_QTYPE_WQ: {
+			ocs_dump32(OCS_DEBUG_ENABLE_WQ_DUMP, sli4->os, "wqe", entry, q->size);
+			break;
+
+		}
+		case SLI_QTYPE_MQ:
+			/* Note: we don't really need to dump the whole 
+			 * 256 bytes, just do 64 */
+			ocs_dump32(OCS_DEBUG_ENABLE_MQ_DUMP, sli4->os, "mqe outbound", entry, 64);
+			break;
+
+		default:
+			break;
+		}
+#endif
+		ocs_memcpy(qe, entry, q->size);
+		q->n_posted = 1;
+	}
+
+	ocs_dma_sync(&q->dma, OCS_DMASYNC_PREWRITE);
+
+	rc = sli_queue_doorbell(sli4, q);
+
+	q->index = (q->index + q->n_posted) & (q->length - 1);
+	q->n_posted = 0;
+
+	if (rc < 0) {
+		/* failure */
+		return rc;
+	} else if (rc > 0) {
+		/* failure, but we need to return a negative value on failure */
+		return -rc;
+	} else {
+		return qindex;
+	}
+}
+
+/**
+ * @ingroup sli
+ * @brief Write an entry to the queue object.
+ *
+ * Note: Assumes the q->lock will be locked and released by the caller.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to the queue object.
+ * @param entry Pointer to the entry contents.
+ *
+ * @return Returns queue index on success, or negative error value otherwise.
+ */
+int32_t
+sli_queue_write(sli4_t *sli4, sli4_queue_t *q, uint8_t *entry)
+{
+	int32_t rc;
+
+	ocs_lock(&q->lock);
+		rc = _sli_queue_write(sli4, q, entry);
+	ocs_unlock(&q->lock);
+
+	return rc;
+}
+
+/**
+ * @brief Check if the current queue entry is valid.
+ *
+ * @param q Pointer to the queue object.
+ * @param qe Pointer to the queue entry.
+ * @param clear Boolean to clear valid bit.
+ *
+ * @return Returns TRUE if the entry is valid, or FALSE otherwise.
+ */
+static uint8_t
+sli_queue_entry_is_valid(sli4_queue_t *q, uint8_t *qe, uint8_t clear)
+{
+	uint8_t		valid = FALSE;
+
+	switch (q->type) {
+	case SLI_QTYPE_EQ:
+		valid = ((sli4_eqe_t *)qe)->vld;
+		if (valid && clear) {
+			((sli4_eqe_t *)qe)->vld = 0;
+		}
+		break;
+	case SLI_QTYPE_CQ:
+		/*
+		 * For both MCQE and WCQE/RCQE, the valid bit
+		 * is bit 31 of dword 3 (0 based)
+		 */
+		valid = (qe[15] & 0x80) != 0;
+		if (valid & clear) {
+			qe[15] &= ~0x80;
+		}
+		break;
+	case SLI_QTYPE_MQ:
+		valid = q->index != q->u.r_idx;
+		break;
+	case SLI_QTYPE_RQ:
+		valid = TRUE;
+		clear = FALSE;
+		break;
+	default:
+		ocs_log_test(NULL, "doesn't handle type=%#x\n", q->type);
+	}
+
+	if (clear) {
+		ocs_dma_sync(&q->dma, OCS_DMASYNC_PREWRITE);
+	}
+
+	return valid;
+}
+
+/**
+ * @ingroup sli
+ * @brief Read an entry from the queue object.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to the queue object.
+ * @param entry Destination pointer for the queue entry contents.
+ *
+ * @return Returns 0 on success, or non-zero otherwise.
+ */
+int32_t
+sli_queue_read(sli4_t *sli4, sli4_queue_t *q, uint8_t *entry)
+{
+	int32_t		rc = 0;
+	uint8_t		*qe = q->dma.virt;
+	uint32_t	*qindex = NULL;
+
+	if (SLI_QTYPE_MQ == q->type) {
+		qindex = &q->u.r_idx;
+	} else {
+		qindex = &q->index;
+	}
+
+	ocs_lock(&q->lock);
+
+	ocs_dma_sync(&q->dma, OCS_DMASYNC_POSTREAD);
+
+	qe += *qindex * q->size;
+
+	if (!sli_queue_entry_is_valid(q, qe, TRUE)) {
+		ocs_unlock(&q->lock);
+		return -1;
+	}
+
+	if (entry) {
+		ocs_memcpy(entry, qe, q->size);
+#if defined(OCS_INCLUDE_DEBUG)
+		switch(q->type) {
+		case SLI_QTYPE_CQ:
+			ocs_dump32(OCS_DEBUG_ENABLE_CQ_DUMP, sli4->os, "cq", entry, q->size);
+			break;
+		case SLI_QTYPE_MQ:
+			ocs_dump32(OCS_DEBUG_ENABLE_MQ_DUMP, sli4->os, "mq Compl", entry, 64);
+			break;
+		case SLI_QTYPE_EQ:
+			ocs_dump32(OCS_DEBUG_ENABLE_EQ_DUMP, sli4->os, "eq Compl", entry, q->size);
+			break;
+		default:
+			break;
+		}
+#endif
+	}
+
+	switch (q->type) {
+		case SLI_QTYPE_EQ:
+		case SLI_QTYPE_CQ:
+		case SLI_QTYPE_MQ:
+			*qindex = (*qindex + 1) & (q->length - 1);
+			if (SLI_QTYPE_MQ != q->type) {
+				q->n_posted++;
+			}
+			break;
+		default:
+			/* reads don't update the index */
+			break;
+	}
+
+	ocs_unlock(&q->lock);
+
+	return rc;
+}
+
+int32_t
+sli_queue_index(sli4_t *sli4, sli4_queue_t *q)
+{
+
+	if (q) {
+		return q->index;
+	} else {
+		return -1;
+	}
+}
+
+int32_t
+sli_queue_poke(sli4_t *sli4, sli4_queue_t *q, uint32_t index, uint8_t *entry)
+{
+	int32_t rc;
+
+	ocs_lock(&q->lock);
+		rc = _sli_queue_poke(sli4, q, index, entry);
+	ocs_unlock(&q->lock);
+
+	return rc;
+}
+
+int32_t
+_sli_queue_poke(sli4_t *sli4, sli4_queue_t *q, uint32_t index, uint8_t *entry)
+{
+	int32_t		rc = 0;
+	uint8_t		*qe = q->dma.virt;
+
+	if (index >= q->length) {
+		return -1;
+	}
+
+	qe += index * q->size;
+
+	if (entry) {
+		ocs_memcpy(qe, entry, q->size);
+	}
+
+	ocs_dma_sync(&q->dma, OCS_DMASYNC_PREWRITE);
+
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Allocate SLI Port resources.
+ *
+ * @par Description
+ * Allocate port-related resources, such as VFI, RPI, XRI, and so on.
+ * Resources are modeled using extents, regardless of whether the underlying
+ * device implements resource extents. If the device does not implement
+ * extents, the SLI layer models this as a single (albeit large) extent.
+ *
+ * @param sli4 SLI context.
+ * @param rtype Resource type (for example, RPI or XRI)
+ * @param rid Allocated resource ID.
+ * @param index Index into the bitmap.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_resource_alloc(sli4_t *sli4, sli4_resource_e rtype, uint32_t *rid, uint32_t *index)
+{
+	int32_t		rc = 0;
+	uint32_t	size;
+	uint32_t	extent_idx;
+	uint32_t	item_idx;
+	int		status;
+
+	*rid = UINT32_MAX;
+	*index = UINT32_MAX;
+
+	switch (rtype) {
+	case SLI_RSRC_FCOE_VFI:
+	case SLI_RSRC_FCOE_VPI:
+	case SLI_RSRC_FCOE_RPI:
+	case SLI_RSRC_FCOE_XRI:
+		status = ocs_bitmap_find(sli4->config.extent[rtype].use_map,
+				sli4->config.extent[rtype].map_size);
+		if (status < 0) {
+			ocs_log_err(sli4->os, "out of resource %d (alloc=%d)\n",
+					rtype, sli4->config.extent[rtype].n_alloc);
+			rc = -1;
+			break;
+		} else {
+			*index = status;
+		}
+
+		size = sli4->config.extent[rtype].size;
+
+		extent_idx = *index / size;
+		item_idx   = *index % size;
+
+		*rid = sli4->config.extent[rtype].base[extent_idx] + item_idx;
+
+		sli4->config.extent[rtype].n_alloc++;
+		break;
+	default:
+		rc = -1;
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Free the SLI Port resources.
+ *
+ * @par Description
+ * Free port-related resources, such as VFI, RPI, XRI, and so. See discussion of
+ * "extent" usage in sli_resource_alloc.
+ *
+ * @param sli4 SLI context.
+ * @param rtype Resource type (for example, RPI or XRI).
+ * @param rid Allocated resource ID.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_resource_free(sli4_t *sli4, sli4_resource_e rtype, uint32_t rid)
+{
+	int32_t		rc = -1;
+	uint32_t	x;
+	uint32_t	size, *base;
+
+	switch (rtype) {
+	case SLI_RSRC_FCOE_VFI:
+	case SLI_RSRC_FCOE_VPI:
+	case SLI_RSRC_FCOE_RPI:
+	case SLI_RSRC_FCOE_XRI:
+		/*
+		 * Figure out which extent contains the resource ID. I.e. find
+		 * the extent such that
+		 *   extent->base <= resource ID < extent->base + extent->size
+		 */
+		base = sli4->config.extent[rtype].base;
+		size = sli4->config.extent[rtype].size;
+
+		/*
+		 * In the case of FW reset, this may be cleared but the force_free path will
+		 * still attempt to free the resource. Prevent a NULL pointer access.
+		 */
+		if (base != NULL) {
+			for (x = 0; x < sli4->config.extent[rtype].number; x++) {
+				if ((rid >= base[x]) && (rid < (base[x] + size))) {
+					rid -= base[x];
+					ocs_bitmap_clear(sli4->config.extent[rtype].use_map,
+							 (x * size) + rid);
+					rc = 0;
+					break;
+				}
+			}
+		}
+		break;
+	default:
+		;
+	}
+
+	return rc;
+}
+
+int32_t
+sli_resource_reset(sli4_t *sli4, sli4_resource_e rtype)
+{
+	int32_t		rc = -1;
+	uint32_t	i;
+
+	switch (rtype) {
+	case SLI_RSRC_FCOE_VFI:
+	case SLI_RSRC_FCOE_VPI:
+	case SLI_RSRC_FCOE_RPI:
+	case SLI_RSRC_FCOE_XRI:
+		for (i = 0; i < sli4->config.extent[rtype].map_size; i++) {
+			ocs_bitmap_clear(sli4->config.extent[rtype].use_map, i);
+		}
+		rc = 0;
+		break;
+	default:
+		;
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Parse an EQ entry to retrieve the CQ_ID for this event.
+ *
+ * @param sli4 SLI context.
+ * @param buf Pointer to the EQ entry.
+ * @param cq_id CQ_ID for this entry (only valid on success).
+ *
+ * @return
+ * - 0 if success.
+ * - < 0 if error.
+ * - > 0 if firmware detects EQ overflow.
+ */
+int32_t
+sli_eq_parse(sli4_t *sli4, uint8_t *buf, uint16_t *cq_id)
+{
+	sli4_eqe_t	*eqe = (void *)buf;
+	int32_t		rc = 0;
+
+	if (!sli4 || !buf || !cq_id) {
+		ocs_log_err(NULL, "bad parameters sli4=%p buf=%p cq_id=%p\n",
+				sli4, buf, cq_id);
+		return -1;
+	}
+
+	switch (eqe->major_code) {
+	case SLI4_MAJOR_CODE_STANDARD:
+		*cq_id = eqe->resource_id;
+		break;
+	case SLI4_MAJOR_CODE_SENTINEL:
+		ocs_log_debug(sli4->os, "sentinel EQE\n");
+		rc = 1;
+		break;
+	default:
+		ocs_log_test(sli4->os, "Unsupported EQE: major %x minor %x\n",
+				eqe->major_code, eqe->minor_code);
+		rc = -1;
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Parse a CQ entry to retrieve the event type and the associated queue.
+ *
+ * @param sli4 SLI context.
+ * @param cq CQ to process.
+ * @param cqe Pointer to the CQ entry.
+ * @param etype CQ event type.
+ * @param q_id Queue ID associated with this completion message
+ * (that is, MQ_ID, RQ_ID, and so on).
+ *
+ * @return
+ * - 0 if call completed correctly and CQE status is SUCCESS.
+ * - -1 if call failed (no CQE status).
+ * - Other value if call completed correctly and return value is a CQE status value.
+ */
+int32_t
+sli_cq_parse(sli4_t *sli4, sli4_queue_t *cq, uint8_t *cqe, sli4_qentry_e *etype,
+		uint16_t *q_id)
+{
+	int32_t	rc = 0;
+
+	if (!sli4 || !cq || !cqe || !etype) {
+		ocs_log_err(NULL, "bad parameters sli4=%p cq=%p cqe=%p etype=%p q_id=%p\n",
+			    sli4, cq, cqe, etype, q_id);
+		return -1;
+	}
+
+	if (cq->u.flag.is_mq) {
+		sli4_mcqe_t	*mcqe = (void *)cqe;
+
+		if (mcqe->ae) {
+			*etype = SLI_QENTRY_ASYNC;
+		} else {
+			*etype = SLI_QENTRY_MQ;
+			rc = sli_cqe_mq(mcqe);
+		}
+		*q_id = -1;
+	} else if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		rc = sli_fc_cqe_parse(sli4, cq, cqe, etype, q_id);
+	} else {
+		ocs_log_test(sli4->os, "implement CQE parsing type = %#x\n",
+			     sli4->port_type);
+		rc = -1;
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Cause chip to enter an unrecoverable error state.
+ *
+ * @par Description
+ * Cause chip to enter an unrecoverable error state. This is
+ * used when detecting unexpected FW behavior so FW can be
+ * hwted from the driver as soon as error is detected.
+ *
+ * @param sli4 SLI context.
+ * @param dump Generate dump as part of reset.
+ *
+ * @return Returns 0 if call completed correctly, or -1 if call failed (unsupported chip).
+ */
+int32_t sli_raise_ue(sli4_t *sli4, uint8_t dump)
+{
+#define FDD 2
+	if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(sli4)) {
+		switch(sli_get_asic_type(sli4)) {
+		case SLI4_ASIC_TYPE_BE3: {
+			sli_reg_write(sli4, SLI4_REG_SW_UE_CSR1, 0xffffffff);
+			sli_reg_write(sli4, SLI4_REG_SW_UE_CSR2, 0);
+			break;
+		}
+		case SLI4_ASIC_TYPE_SKYHAWK: {
+			uint32_t value;
+			value = ocs_config_read32(sli4->os, SLI4_SW_UE_REG);
+			ocs_config_write32(sli4->os, SLI4_SW_UE_REG, (value | (1U << 24)));
+			break;
+		}
+		default:
+			ocs_log_test(sli4->os, "invalid asic type %d\n", sli_get_asic_type(sli4));
+			return -1;
+		}
+	} else if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(sli4)) {	
+		if (dump == FDD) {
+			sli_reg_write(sli4, SLI4_REG_SLIPORT_CONTROL, SLI4_SLIPORT_CONTROL_FDD | SLI4_SLIPORT_CONTROL_IP);
+		} else {
+			uint32_t value = SLI4_PHYDEV_CONTROL_FRST;
+			if (dump == 1) {
+				value |= SLI4_PHYDEV_CONTROL_DD;
+			}
+			sli_reg_write(sli4, SLI4_REG_PHYSDEV_CONTROL, value);
+		}
+	} else {
+		ocs_log_test(sli4->os, "invalid iftype=%d\n", sli_get_if_type(sli4));
+		return -1;
+	}
+	return 0;
+}
+
+/**
+ * @ingroup sli
+ * @brief Read the SLIPORT_STATUS register to to check if a dump is present.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return  Returns 1 if the chip is ready, or 0 if the chip is not ready, 2 if fdp is present.
+ */
+int32_t sli_dump_is_ready(sli4_t *sli4)
+{
+	int32_t	rc = 0;
+	uint32_t port_val;
+	uint32_t bmbx_val;
+	uint32_t uerr_lo;
+	uint32_t uerr_hi;
+	uint32_t uerr_mask_lo;
+	uint32_t uerr_mask_hi;
+
+	if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(sli4)) {
+		/* for iftype=0, dump ready when UE is encountered */
+		uerr_lo = sli_reg_read(sli4, SLI4_REG_UERR_STATUS_LO);
+		uerr_hi = sli_reg_read(sli4, SLI4_REG_UERR_STATUS_HI);
+		uerr_mask_lo = sli_reg_read(sli4, SLI4_REG_UERR_MASK_LO);
+		uerr_mask_hi = sli_reg_read(sli4, SLI4_REG_UERR_MASK_HI);
+		if ((uerr_lo & ~uerr_mask_lo) || (uerr_hi & ~uerr_mask_hi)) {
+			rc = 1;
+		}
+
+	} else if (SLI4_IF_TYPE_LANCER_FC_ETH == sli_get_if_type(sli4)) {
+		/*
+		 * Ensure that the port is ready AND the mailbox is
+		 * ready before signaling that the dump is ready to go.
+		 */
+		port_val = sli_reg_read(sli4, SLI4_REG_SLIPORT_STATUS);
+		bmbx_val = sli_reg_read(sli4, SLI4_REG_BMBX);
+
+		if ((bmbx_val & SLI4_BMBX_RDY) &&
+		    SLI4_PORT_STATUS_READY(port_val)) { 
+		    	if(SLI4_PORT_STATUS_DUMP_PRESENT(port_val)) {
+				rc = 1;
+			}else if( SLI4_PORT_STATUS_FDP_PRESENT(port_val)) {
+				rc = 2;
+			}
+		}
+	} else {
+		ocs_log_test(sli4->os, "invalid iftype=%d\n", sli_get_if_type(sli4));
+		return -1;
+	}
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Read the SLIPORT_STATUS register to check if a dump is present.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return
+ * - 0 if call completed correctly and no dump is present.
+ * - 1 if call completed and dump is present.
+ * - -1 if call failed (unsupported chip).
+ */
+int32_t sli_dump_is_present(sli4_t *sli4)
+{
+	uint32_t val;
+	uint32_t ready;
+
+	if (SLI4_IF_TYPE_LANCER_FC_ETH != sli_get_if_type(sli4)) {
+		ocs_log_test(sli4->os, "Function only supported for I/F type 2");
+		return -1;
+	}
+
+	/* If the chip is not ready, then there cannot be a dump */
+	ready = sli_wait_for_fw_ready(sli4, SLI4_INIT_PORT_DELAY_US);
+	if (!ready) {
+		return 0;
+	}
+
+	val = sli_reg_read(sli4, SLI4_REG_SLIPORT_STATUS);
+	if (UINT32_MAX == val) {
+		ocs_log_err(sli4->os, "error reading SLIPORT_STATUS\n");
+		return -1;
+	} else {
+		return ((val & SLI4_PORT_STATUS_DIP) ? 1 : 0);
+	}
+}
+
+/**
+ * @ingroup sli
+ * @brief Read the SLIPORT_STATUS register to check if the reset required is set.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return
+ * - 0 if call completed correctly and reset is not required.
+ * - 1 if call completed and reset is required.
+ * - -1 if call failed.
+ */
+int32_t sli_reset_required(sli4_t *sli4)
+{
+	uint32_t val;
+
+	if (SLI4_IF_TYPE_BE3_SKH_PF == sli_get_if_type(sli4)) {
+		ocs_log_test(sli4->os, "reset required N/A for iftype 0\n");
+		return 0;
+	}
+
+	val = sli_reg_read(sli4, SLI4_REG_SLIPORT_STATUS);
+	if (UINT32_MAX == val) {
+		ocs_log_err(sli4->os, "error reading SLIPORT_STATUS\n");
+		return -1;
+	} else {
+		return ((val & SLI4_PORT_STATUS_RN) ? 1 : 0);
+	}
+}
+
+/**
+ * @ingroup sli
+ * @brief Read the SLIPORT_SEMAPHORE and SLIPORT_STATUS registers to check if
+ * the port status indicates that a FW error has occurred.
+ *
+ * @param sli4 SLI context.
+ *
+ * @return
+ * - 0 if call completed correctly and no FW error occurred.
+ * - > 0 which indicates that a FW error has occurred.
+ * - -1 if call failed.
+ */
+int32_t sli_fw_error_status(sli4_t *sli4)
+{
+	uint32_t sliport_semaphore;
+	int32_t rc = 0;
+
+	sliport_semaphore = sli_reg_read(sli4, SLI4_REG_SLIPORT_SEMAPHORE);
+	if (UINT32_MAX == sliport_semaphore) {
+		ocs_log_err(sli4->os, "error reading SLIPORT_SEMAPHORE register\n");
+		return 1;
+	}
+	rc = (SLI4_PORT_SEMAPHORE_IN_ERR(sliport_semaphore) ? 1 : 0);
+
+	if (rc == 0) {
+		if (SLI4_IF_TYPE_BE3_SKH_PF == sli4->if_type ||
+		    (SLI4_IF_TYPE_BE3_SKH_VF == sli4->if_type)) {
+			uint32_t uerr_mask_lo, uerr_mask_hi;
+			uint32_t uerr_status_lo, uerr_status_hi;
+
+			uerr_mask_lo = sli_reg_read(sli4, SLI4_REG_UERR_MASK_LO);
+			uerr_mask_hi = sli_reg_read(sli4, SLI4_REG_UERR_MASK_HI);
+			uerr_status_lo = sli_reg_read(sli4, SLI4_REG_UERR_STATUS_LO);
+			uerr_status_hi = sli_reg_read(sli4, SLI4_REG_UERR_STATUS_HI);
+			if ((uerr_mask_lo & uerr_status_lo) != 0 ||
+			    (uerr_mask_hi & uerr_status_hi) != 0) {
+				rc = 1;
+			}
+		} else if ((SLI4_IF_TYPE_LANCER_FC_ETH == sli4->if_type)) {
+			uint32_t sliport_status;
+
+			sliport_status = sli_reg_read(sli4, SLI4_REG_SLIPORT_STATUS);
+			rc = (SLI4_PORT_STATUS_ERROR(sliport_status) ? 1 : 0);
+		}
+	}
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Determine if the chip FW is in a ready state
+ *
+ * @param sli4 SLI context.
+ *
+ * @return
+ * - 0 if call completed correctly and FW is not ready.
+ * - 1 if call completed correctly and FW is ready.
+ * - -1 if call failed.
+ */
+int32_t
+sli_fw_ready(sli4_t *sli4)
+{
+	uint32_t val;
+	int32_t rc = -1;
+
+	/*
+	 * Is firmware ready for operation? Check needed depends on IF_TYPE
+	 */
+	if (SLI4_IF_TYPE_BE3_SKH_PF == sli4->if_type ||
+	    SLI4_IF_TYPE_BE3_SKH_VF == sli4->if_type) {
+		val = sli_reg_read(sli4, SLI4_REG_SLIPORT_SEMAPHORE);
+		rc = ((SLI4_PORT_SEMAPHORE_STATUS_POST_READY ==
+		       SLI4_PORT_SEMAPHORE_PORT(val)) &&
+		      (!SLI4_PORT_SEMAPHORE_IN_ERR(val)) ? 1 : 0);
+	} else if (SLI4_IF_TYPE_LANCER_FC_ETH == sli4->if_type) {
+		val = sli_reg_read(sli4, SLI4_REG_SLIPORT_STATUS);
+		rc = (SLI4_PORT_STATUS_READY(val) ? 1 : 0);
+	}
+	return rc;
+}
+
+/**
+ * @ingroup sli
+ * @brief Determine if the link can be configured
+ *
+ * @param sli4 SLI context.
+ *
+ * @return
+ * - 0 if link is not configurable.
+ * - 1 if link is configurable.
+ */
+int32_t sli_link_is_configurable(sli4_t *sli)
+{
+	int32_t rc = 0;
+	/*
+	 * Link config works on: Skyhawk and Lancer
+	 * Link config does not work on: LancerG6
+	 */
+
+	switch (sli_get_asic_type(sli)) {
+	case SLI4_ASIC_TYPE_SKYHAWK:
+	case SLI4_ASIC_TYPE_LANCER:
+	case SLI4_ASIC_TYPE_CORSAIR:
+		rc = 1;
+		break;
+	case SLI4_ASIC_TYPE_LANCERG6:
+	case SLI4_ASIC_TYPE_BE3:
+	default:
+		rc = 0;
+		break;
+	}
+
+	return rc;
+
+}
+
+/* vim: set noexpandtab textwidth=120: */
+
+extern const char *SLI_QNAME[];
+extern const sli4_reg_t regmap[SLI4_REG_MAX][SLI4_MAX_IF_TYPES];
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_WQ_CREATE command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param qmem DMA memory for the queue.
+ * @param cq_id Associated CQ_ID.
+ * @param ulp The ULP to bind
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_wq_create(sli4_t *sli4, void *buf, size_t size,
+		       ocs_dma_t *qmem, uint16_t cq_id, uint16_t ulp)
+{
+	sli4_req_fcoe_wq_create_t	*wq = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	p;
+	uintptr_t	addr;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_fcoe_wq_create_t),
+				sizeof(sli4_res_common_create_queue_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	wq = (sli4_req_fcoe_wq_create_t *)((uint8_t *)buf + sli_config_off);
+
+	wq->hdr.opcode = SLI4_OPC_FCOE_WQ_CREATE;
+	wq->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	wq->hdr.request_length = sizeof(sli4_req_fcoe_wq_create_t) -
+					sizeof(sli4_req_hdr_t);
+	/* valid values for number of pages: 1-4 (sec 4.5.1) */
+	wq->num_pages = sli_page_count(qmem->size, SLI_PAGE_SIZE);
+	if (!wq->num_pages || (wq->num_pages > SLI4_FCOE_WQ_CREATE_V0_MAX_PAGES)) {
+		return 0;
+	}
+
+	wq->cq_id = cq_id;
+
+	if (sli4->config.dual_ulp_capable) {
+		wq->dua = 1;
+		wq->bqu = 1;
+		wq->ulp = ulp;
+	}
+
+	for (p = 0, addr = qmem->phys;
+			p < wq->num_pages;
+			p++, addr += SLI_PAGE_SIZE) {
+		wq->page_physical_address[p].low  = ocs_addr32_lo(addr);
+		wq->page_physical_address[p].high = ocs_addr32_hi(addr);
+	}
+
+	return(sli_config_off + sizeof(sli4_req_fcoe_wq_create_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_WQ_CREATE_V1 command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param qmem DMA memory for the queue.
+ * @param cq_id Associated CQ_ID.
+ * @param ignored This parameter carries the ULP for WQ (ignored for V1)
+
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_wq_create_v1(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *qmem,
+			  uint16_t cq_id, uint16_t ignored)
+{
+	sli4_req_fcoe_wq_create_v1_t	*wq = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	p;
+	uintptr_t	addr;
+	uint32_t	page_size = 0;
+	uint32_t	page_bytes = 0;
+	uint32_t	n_wqe = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_fcoe_wq_create_v1_t),
+				sizeof(sli4_res_common_create_queue_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	wq = (sli4_req_fcoe_wq_create_v1_t *)((uint8_t *)buf + sli_config_off);
+
+	wq->hdr.opcode = SLI4_OPC_FCOE_WQ_CREATE;
+	wq->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	wq->hdr.request_length = sizeof(sli4_req_fcoe_wq_create_v1_t) -
+					sizeof(sli4_req_hdr_t);
+	wq->hdr.version = 1;
+
+	n_wqe = qmem->size / sli4->config.wqe_size;
+
+	/* This heuristic to determine the page size is simplistic 
+	 * but could be made more sophisticated
+	 */
+	switch (qmem->size) {
+	case 4096:
+	case 8192:
+	case 16384:
+	case 32768:
+		page_size = 1;
+		break;
+	case 65536:
+		page_size = 2;
+		break;
+	case 131072:
+		page_size = 4;
+		break;
+	case 262144:
+		page_size = 8;
+		break;
+	case 524288:
+		page_size = 10;
+		break;
+	default:
+		return 0;
+	}
+	page_bytes = page_size * SLI_PAGE_SIZE;
+
+	/* valid values for number of pages: 1-8 */
+	wq->num_pages = sli_page_count(qmem->size, page_bytes);
+	if (!wq->num_pages || (wq->num_pages > SLI4_FCOE_WQ_CREATE_V1_MAX_PAGES)) {
+		return 0;
+	}
+
+	wq->cq_id = cq_id;
+
+	wq->page_size = page_size;
+
+	if (sli4->config.wqe_size == SLI4_WQE_EXT_BYTES) {
+		wq->wqe_size = SLI4_WQE_EXT_SIZE;
+	} else {
+		wq->wqe_size = SLI4_WQE_SIZE;
+	}
+
+	wq->wqe_count = n_wqe;
+
+	for (p = 0, addr = qmem->phys;
+			p < wq->num_pages;
+			p++, addr += page_bytes) {
+		wq->page_physical_address[p].low  = ocs_addr32_lo(addr);
+		wq->page_physical_address[p].high = ocs_addr32_hi(addr);
+	}
+
+	return(sli_config_off + sizeof(sli4_req_fcoe_wq_create_v1_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_WQ_DESTROY command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param wq_id WQ_ID.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_wq_destroy(sli4_t *sli4, void *buf, size_t size, uint16_t wq_id)
+{
+	sli4_req_fcoe_wq_destroy_t	*wq = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_fcoe_wq_destroy_t),
+				sizeof(sli4_res_hdr_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	wq = (sli4_req_fcoe_wq_destroy_t *)((uint8_t *)buf + sli_config_off);
+
+	wq->hdr.opcode = SLI4_OPC_FCOE_WQ_DESTROY;
+	wq->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	wq->hdr.request_length = sizeof(sli4_req_fcoe_wq_destroy_t) -
+					sizeof(sli4_req_hdr_t);
+
+	wq->wq_id = wq_id;
+
+	return(sli_config_off + sizeof(sli4_req_fcoe_wq_destroy_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_POST_SGL_PAGES command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param xri starting XRI
+ * @param xri_count XRI
+ * @param page0 First SGL memory page.
+ * @param page1 Second SGL memory page (optional).
+ * @param dma DMA buffer for non-embedded mailbox command (options)
+ *
+ * if non-embedded mbx command is used, dma buffer must be at least (32 + xri_count*16) in length
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_post_sgl_pages(sli4_t *sli4, void *buf, size_t size,
+		uint16_t xri, uint32_t xri_count, ocs_dma_t *page0[], ocs_dma_t *page1[], ocs_dma_t *dma)
+{
+	sli4_req_fcoe_post_sgl_pages_t	*post = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	i;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_fcoe_post_sgl_pages_t),
+				sizeof(sli4_res_hdr_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				dma);
+	}
+	if (dma) {
+		post = dma->virt;
+		ocs_memset(post, 0, dma->size);
+	} else {
+		post = (sli4_req_fcoe_post_sgl_pages_t *)((uint8_t *)buf + sli_config_off);
+	}
+
+	post->hdr.opcode = SLI4_OPC_FCOE_POST_SGL_PAGES;
+	post->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	/* payload size calculation
+	 *   4 = xri_start + xri_count
+	 *   xri_count = # of XRI's registered
+	 *   sizeof(uint64_t) = physical address size
+	 *   2 = # of physical addresses per page set
+	 */
+	post->hdr.request_length = 4 + (xri_count * (sizeof(uint64_t) * 2));
+
+	post->xri_start = xri;
+	post->xri_count = xri_count;
+
+	for (i = 0; i < xri_count; i++) {
+		post->page_set[i].page0_low  = ocs_addr32_lo(page0[i]->phys);
+		post->page_set[i].page0_high = ocs_addr32_hi(page0[i]->phys);
+	}
+
+	if (page1) {
+		for (i = 0; i < xri_count; i++) {
+			post->page_set[i].page1_low  = ocs_addr32_lo(page1[i]->phys);
+			post->page_set[i].page1_high = ocs_addr32_hi(page1[i]->phys);
+		}
+	}
+
+	return dma ? sli_config_off : (sli_config_off + sizeof(sli4_req_fcoe_post_sgl_pages_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_RQ_CREATE command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param qmem DMA memory for the queue.
+ * @param cq_id Associated CQ_ID.
+ * @param ulp This parameter carries the ULP for the RQ
+ * @param buffer_size Buffer size pointed to by each RQE.
+ *
+ * @note This creates a Version 0 message.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_rq_create(sli4_t *sli4, void *buf, size_t size,
+		ocs_dma_t *qmem, uint16_t cq_id, uint16_t ulp, uint16_t buffer_size)
+{
+	sli4_req_fcoe_rq_create_t	*rq = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	p;
+	uintptr_t	addr;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_fcoe_rq_create_t),
+				sizeof(sli4_res_common_create_queue_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	rq = (sli4_req_fcoe_rq_create_t *)((uint8_t *)buf + sli_config_off);
+
+	rq->hdr.opcode = SLI4_OPC_FCOE_RQ_CREATE;
+	rq->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	rq->hdr.request_length = sizeof(sli4_req_fcoe_rq_create_t) -
+					sizeof(sli4_req_hdr_t);
+	/* valid values for number of pages: 1-8 (sec 4.5.6) */
+	rq->num_pages = sli_page_count(qmem->size, SLI_PAGE_SIZE);
+	if (!rq->num_pages || (rq->num_pages > SLI4_FCOE_RQ_CREATE_V0_MAX_PAGES)) {
+		ocs_log_test(sli4->os, "num_pages %d not valid\n", rq->num_pages);
+		return 0;
+	}
+
+	/*
+	 * RQE count is the log base 2 of the total number of entries
+	 */
+	rq->rqe_count = ocs_lg2(qmem->size / SLI4_FCOE_RQE_SIZE);
+
+	if ((buffer_size < SLI4_FCOE_RQ_CREATE_V0_MIN_BUF_SIZE) ||
+			(buffer_size > SLI4_FCOE_RQ_CREATE_V0_MAX_BUF_SIZE)) {
+		ocs_log_err(sli4->os, "buffer_size %d out of range (%d-%d)\n",
+				buffer_size,
+				SLI4_FCOE_RQ_CREATE_V0_MIN_BUF_SIZE,
+				SLI4_FCOE_RQ_CREATE_V0_MAX_BUF_SIZE);
+		return -1;
+	}
+	rq->buffer_size = buffer_size;
+
+	rq->cq_id = cq_id;
+
+	if (sli4->config.dual_ulp_capable) {
+		rq->dua = 1;
+		rq->bqu = 1;
+		rq->ulp = ulp;
+	}
+
+	for (p = 0, addr = qmem->phys;
+			p < rq->num_pages;
+			p++, addr += SLI_PAGE_SIZE) {
+		rq->page_physical_address[p].low  = ocs_addr32_lo(addr);
+		rq->page_physical_address[p].high = ocs_addr32_hi(addr);
+	}
+
+	return(sli_config_off + sizeof(sli4_req_fcoe_rq_create_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_RQ_CREATE_V1 command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param qmem DMA memory for the queue.
+ * @param cq_id Associated CQ_ID.
+ * @param ulp This parameter carries the ULP for RQ (ignored for V1)
+ * @param buffer_size Buffer size pointed to by each RQE.
+ *
+ * @note This creates a Version 0 message
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_rq_create_v1(sli4_t *sli4, void *buf, size_t size,
+			  ocs_dma_t *qmem, uint16_t cq_id, uint16_t ulp,
+			  uint16_t buffer_size)
+{
+	sli4_req_fcoe_rq_create_v1_t	*rq = NULL;
+	uint32_t	sli_config_off = 0;
+	uint32_t	p;
+	uintptr_t	addr;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_fcoe_rq_create_v1_t),
+				sizeof(sli4_res_common_create_queue_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	rq = (sli4_req_fcoe_rq_create_v1_t *)((uint8_t *)buf + sli_config_off);
+
+	rq->hdr.opcode = SLI4_OPC_FCOE_RQ_CREATE;
+	rq->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	rq->hdr.request_length = sizeof(sli4_req_fcoe_rq_create_v1_t) -
+					sizeof(sli4_req_hdr_t);
+	rq->hdr.version = 1;
+
+	/* Disable "no buffer warnings" to avoid Lancer bug */
+	rq->dnb = TRUE;
+
+	/* valid values for number of pages: 1-8 (sec 4.5.6) */
+	rq->num_pages = sli_page_count(qmem->size, SLI_PAGE_SIZE);
+	if (!rq->num_pages || (rq->num_pages > SLI4_FCOE_RQ_CREATE_V1_MAX_PAGES)) {
+		ocs_log_test(sli4->os, "num_pages %d not valid, max %d\n",
+                rq->num_pages, SLI4_FCOE_RQ_CREATE_V1_MAX_PAGES);
+		return 0;
+	}
+
+	/*
+	 * RQE count is the total number of entries (note not lg2(# entries))
+	 */
+	rq->rqe_count = qmem->size / SLI4_FCOE_RQE_SIZE;
+
+	rq->rqe_size = SLI4_FCOE_RQE_SIZE_8;
+
+	rq->page_size = SLI4_FCOE_RQ_PAGE_SIZE_4096;
+
+	if ((buffer_size < sli4->config.rq_min_buf_size) ||
+	    (buffer_size > sli4->config.rq_max_buf_size)) {
+		ocs_log_err(sli4->os, "buffer_size %d out of range (%d-%d)\n",
+				buffer_size,
+				sli4->config.rq_min_buf_size,
+				sli4->config.rq_max_buf_size);
+		return -1;
+	}
+	rq->buffer_size = buffer_size;
+
+	rq->cq_id = cq_id;
+
+	for (p = 0, addr = qmem->phys;
+			p < rq->num_pages;
+			p++, addr += SLI_PAGE_SIZE) {
+		rq->page_physical_address[p].low  = ocs_addr32_lo(addr);
+		rq->page_physical_address[p].high = ocs_addr32_hi(addr);
+	}
+
+	return(sli_config_off + sizeof(sli4_req_fcoe_rq_create_v1_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_RQ_DESTROY command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param rq_id RQ_ID.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_rq_destroy(sli4_t *sli4, void *buf, size_t size, uint16_t rq_id)
+{
+	sli4_req_fcoe_rq_destroy_t	*rq = NULL;
+	uint32_t	sli_config_off = 0;
+
+	if (SLI4_PORT_TYPE_FC == sli4->port_type) {
+		uint32_t payload_size;
+
+		/* Payload length must accommodate both request and response */
+		payload_size = max(sizeof(sli4_req_fcoe_rq_destroy_t),
+				sizeof(sli4_res_hdr_t));
+
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size,
+				NULL);
+	}
+	rq = (sli4_req_fcoe_rq_destroy_t *)((uint8_t *)buf + sli_config_off);
+
+	rq->hdr.opcode = SLI4_OPC_FCOE_RQ_DESTROY;
+	rq->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	rq->hdr.request_length = sizeof(sli4_req_fcoe_rq_destroy_t) -
+					sizeof(sli4_req_hdr_t);
+
+	rq->rq_id = rq_id;
+
+	return(sli_config_off + sizeof(sli4_req_fcoe_rq_destroy_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_READ_FCF_TABLE command.
+ *
+ * @note
+ * The response of this command exceeds the size of an embedded
+ * command and requires an external buffer with DMA capability to hold the results.
+ * The caller should allocate the ocs_dma_t structure / memory.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param dma Pointer to DMA memory structure. This is allocated by the caller.
+ * @param index FCF table index to retrieve.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_read_fcf_table(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *dma, uint16_t index)
+{
+	sli4_req_fcoe_read_fcf_table_t *read_fcf = NULL;
+
+	if (SLI4_PORT_TYPE_FC != sli4->port_type) {
+		ocs_log_test(sli4->os, "FCOE_READ_FCF_TABLE only supported on FC\n");
+		return -1;
+	}
+
+	read_fcf = dma->virt;
+
+	ocs_memset(read_fcf, 0, sizeof(sli4_req_fcoe_read_fcf_table_t));
+
+	read_fcf->hdr.opcode = SLI4_OPC_FCOE_READ_FCF_TABLE;
+	read_fcf->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	read_fcf->hdr.request_length = dma->size -
+		sizeof(sli4_req_fcoe_read_fcf_table_t);
+	read_fcf->fcf_index = index;
+
+	return sli_cmd_sli_config(sli4, buf, size, 0, dma);
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCOE_POST_HDR_TEMPLATES command.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the command.
+ * @param size Buffer size, in bytes.
+ * @param dma Pointer to DMA memory structure. This is allocated by the caller.
+ * @param rpi Starting RPI index for the header templates.
+ * @param payload_dma Pointer to DMA memory used to hold larger descriptor counts.
+ *
+ * @return Returns the number of bytes written.
+ */
+int32_t
+sli_cmd_fcoe_post_hdr_templates(sli4_t *sli4, void *buf, size_t size,
+		ocs_dma_t *dma, uint16_t rpi, ocs_dma_t *payload_dma)
+{
+	sli4_req_fcoe_post_hdr_templates_t *template = NULL;
+	uint32_t	sli_config_off = 0;
+	uintptr_t	phys = 0;
+	uint32_t	i = 0;
+	uint32_t	page_count;
+	uint32_t	payload_size;
+
+	page_count = sli_page_count(dma->size, SLI_PAGE_SIZE);
+
+	payload_size = sizeof(sli4_req_fcoe_post_hdr_templates_t) +
+				page_count * sizeof(sli4_physical_page_descriptor_t);
+
+	if (page_count > 16) {
+		/* We can't fit more than 16 descriptors into an embedded mailbox
+		   command, it has to be non-embedded */
+		if (ocs_dma_alloc(sli4->os, payload_dma, payload_size, 4)) {
+			ocs_log_err(sli4->os, "mailbox payload memory allocation fail\n");
+			return 0;
+		}
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size, payload_dma);
+		template = (sli4_req_fcoe_post_hdr_templates_t *)payload_dma->virt;
+	} else {
+		sli_config_off = sli_cmd_sli_config(sli4, buf, size, payload_size, NULL);
+		template = (sli4_req_fcoe_post_hdr_templates_t *)((uint8_t *)buf + sli_config_off);
+	}
+
+	if (UINT16_MAX == rpi) {
+		rpi = sli4->config.extent[SLI_RSRC_FCOE_RPI].base[0];
+	}
+
+	template->hdr.opcode = SLI4_OPC_FCOE_POST_HDR_TEMPLATES;
+	template->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	template->hdr.request_length = sizeof(sli4_req_fcoe_post_hdr_templates_t) -
+					sizeof(sli4_req_hdr_t);
+
+	template->rpi_offset = rpi;
+	template->page_count = page_count;
+	phys = dma->phys;
+	for (i = 0; i < template->page_count; i++) {
+		template->page_descriptor[i].low  = ocs_addr32_lo(phys);
+		template->page_descriptor[i].high = ocs_addr32_hi(phys);
+
+		phys += SLI_PAGE_SIZE;
+	}
+
+	return(sli_config_off + payload_size);
+}
+
+int32_t
+sli_cmd_fcoe_rediscover_fcf(sli4_t *sli4, void *buf, size_t size, uint16_t index)
+{
+	sli4_req_fcoe_rediscover_fcf_t *redisc = NULL;
+	uint32_t	sli_config_off = 0;
+
+	sli_config_off = sli_cmd_sli_config(sli4, buf, size,
+			sizeof(sli4_req_fcoe_rediscover_fcf_t),
+			NULL);
+
+	redisc = (sli4_req_fcoe_rediscover_fcf_t *)((uint8_t *)buf + sli_config_off);
+
+	redisc->hdr.opcode = SLI4_OPC_FCOE_REDISCOVER_FCF;
+	redisc->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	redisc->hdr.request_length = sizeof(sli4_req_fcoe_rediscover_fcf_t) -
+					sizeof(sli4_req_hdr_t);
+
+	if (index == UINT16_MAX) {
+		redisc->fcf_count = 0;
+	} else {
+		redisc->fcf_count = 1;
+		redisc->fcf_index[0] = index;
+	}
+
+	return(sli_config_off + sizeof(sli4_req_fcoe_rediscover_fcf_t));
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an ABORT_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param type Abort type, such as XRI, abort tag, and request tag.
+ * @param send_abts Boolean to cause the hardware to automatically generate an ABTS.
+ * @param ids ID of IOs to abort.
+ * @param mask Mask applied to the ID values to abort.
+ * @param tag Tag value associated with this abort.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param dnrx When set to 1, this field indicates that the SLI Port must not return the associated XRI to the SLI
+ *             Port's optimized write XRI pool.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_abort_wqe(sli4_t *sli4, void *buf, size_t size, sli4_abort_type_e type, uint32_t send_abts,
+	      uint32_t ids, uint32_t mask, uint16_t tag, uint16_t cq_id)
+{
+	sli4_abort_wqe_t	*abort = buf;
+
+	ocs_memset(buf, 0, size);
+
+	switch (type) {
+	case SLI_ABORT_XRI:
+		abort->criteria = SLI4_ABORT_CRITERIA_XRI_TAG;
+		if (mask) {
+			ocs_log_warn(sli4->os, "warning non-zero mask %#x when aborting XRI %#x\n", mask, ids);
+			mask = 0;
+		}
+		break;
+	case SLI_ABORT_ABORT_ID:
+		abort->criteria = SLI4_ABORT_CRITERIA_ABORT_TAG;
+		break;
+	case SLI_ABORT_REQUEST_ID:
+		abort->criteria = SLI4_ABORT_CRITERIA_REQUEST_TAG;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unsupported type %#x\n", type);
+		return -1;
+	}
+
+	abort->ia = send_abts ? 0 : 1;
+
+	/* Suppress ABTS retries */
+	abort->ir = 1;
+
+	abort->t_mask = mask;
+	abort->t_tag  = ids;
+	abort->command = SLI4_WQE_ABORT;
+	abort->request_tag = tag;
+	abort->qosd = TRUE;
+	abort->cq_id = cq_id;
+	abort->cmd_type = SLI4_CMD_ABORT_WQE;
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an ELS_REQUEST64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the ELS request.
+ * @param req_type ELS request type.
+ * @param req_len Length of ELS request in bytes.
+ * @param max_rsp_len Max length of ELS response in bytes.
+ * @param timeout Time, in seconds, before an IO times out. Zero means 2 * R_A_TOV.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rnode Destination of ELS request (that is, the remote node).
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_els_request64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl, uint8_t req_type,
+		      uint32_t req_len, uint32_t max_rsp_len, uint8_t timeout,
+		      uint16_t xri, uint16_t tag, uint16_t cq_id, ocs_remote_node_t *rnode)
+{
+	sli4_els_request64_wqe_t	*els = buf;
+	sli4_sge_t	*sge = sgl->virt;
+	uint8_t		is_fabric = FALSE;
+
+	ocs_memset(buf, 0, size);
+
+	if (sli4->config.sgl_pre_registered) {
+		els->xbl = FALSE;
+
+		els->dbde = TRUE;
+		els->els_request_payload.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+		els->els_request_payload.buffer_length = req_len;
+		els->els_request_payload.u.data.buffer_address_low  = sge[0].buffer_address_low;
+		els->els_request_payload.u.data.buffer_address_high = sge[0].buffer_address_high;
+	} else {
+		els->xbl = TRUE;
+
+		els->els_request_payload.bde_type = SLI4_BDE_TYPE_BLP;
+
+		els->els_request_payload.buffer_length = 2 * sizeof(sli4_sge_t);
+		els->els_request_payload.u.blp.sgl_segment_address_low  = ocs_addr32_lo(sgl->phys);
+		els->els_request_payload.u.blp.sgl_segment_address_high = ocs_addr32_hi(sgl->phys);
+	}
+
+	els->els_request_payload_length = req_len;
+	els->max_response_payload_length = max_rsp_len;
+
+	els->xri_tag = xri;
+	els->timer = timeout;
+	els->class = SLI4_ELS_REQUEST64_CLASS_3;
+
+	els->command = SLI4_WQE_ELS_REQUEST64;
+
+	els->request_tag = tag;
+
+	if (rnode->node_group) {
+		els->hlm = TRUE;
+		els->remote_id = rnode->fc_id & 0x00ffffff;
+	}
+
+	els->iod = SLI4_ELS_REQUEST64_DIR_READ;
+
+	els->qosd = TRUE;
+
+	/* figure out the ELS_ID value from the request buffer */
+
+	switch (req_type) {
+	case FC_ELS_CMD_LOGO:
+		els->els_id = SLI4_ELS_REQUEST64_LOGO;
+		if (rnode->attached) {
+			els->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+			els->context_tag = rnode->indicator;
+		} else {
+			els->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+			els->context_tag = rnode->sport->indicator;
+		}
+		if (FC_ADDR_FABRIC == rnode->fc_id) {
+			is_fabric = TRUE;
+		}
+		break;
+	case FC_ELS_CMD_FDISC:
+		if (FC_ADDR_FABRIC == rnode->fc_id) {
+			is_fabric = TRUE;
+		}
+		if (0 == rnode->sport->fc_id) {
+			els->els_id = SLI4_ELS_REQUEST64_FDISC;
+			is_fabric = TRUE;
+		} else {
+			els->els_id = SLI4_ELS_REQUEST64_OTHER;
+		}
+		els->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+		els->context_tag = rnode->sport->indicator;
+		els->sp = TRUE;
+		break;
+	case FC_ELS_CMD_FLOGI:
+		els->els_id = SLI4_ELS_REQUEST64_FLOGIN;
+		is_fabric = TRUE;
+		if (SLI4_IF_TYPE_BE3_SKH_PF == sli4->if_type) {
+			if (!rnode->sport->domain) {
+				ocs_log_test(sli4->os, "invalid domain handle\n");
+				return -1;
+			}
+			/*
+			 * IF_TYPE 0 skips INIT_VFI/INIT_VPI and therefore must use the
+			 * FCFI here
+			 */
+			els->ct = SLI4_ELS_REQUEST64_CONTEXT_FCFI;
+			els->context_tag = rnode->sport->domain->fcf_indicator;
+			els->sp = TRUE;
+		} else {
+			els->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+			els->context_tag = rnode->sport->indicator;
+
+			/*
+			 * Set SP here ... we haven't done a REG_VPI yet
+			 * TODO: need to maybe not set this when we have
+			 *       completed VFI/VPI registrations ...
+			 *
+			 * Use the FC_ID of the SPORT if it has been allocated, otherwise
+			 * use an S_ID of zero.
+			 */
+			els->sp = TRUE;
+			if (rnode->sport->fc_id != UINT32_MAX) {
+				els->sid = rnode->sport->fc_id;
+			}
+		}
+		break;
+	case FC_ELS_CMD_PLOGI:
+		els->els_id = SLI4_ELS_REQUEST64_PLOGI;
+		els->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+		els->context_tag = rnode->sport->indicator;
+		break;
+	case FC_ELS_CMD_SCR:
+		els->els_id = SLI4_ELS_REQUEST64_OTHER;
+		els->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+		els->context_tag = rnode->sport->indicator;
+		break;
+	default:
+		els->els_id = SLI4_ELS_REQUEST64_OTHER;
+		if (rnode->attached) {
+			els->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+			els->context_tag = rnode->indicator;
+		} else {
+			els->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+			els->context_tag = rnode->sport->indicator;
+		}
+		break;
+	}
+
+	if (is_fabric) {
+		els->cmd_type = SLI4_ELS_REQUEST64_CMD_FABRIC;
+	} else {
+		els->cmd_type = SLI4_ELS_REQUEST64_CMD_NON_FABRIC;
+	}
+
+	els->cq_id = cq_id;
+
+	if (SLI4_ELS_REQUEST64_CONTEXT_RPI != els->ct) {
+		els->remote_id = rnode->fc_id;
+	}
+	if (SLI4_ELS_REQUEST64_CONTEXT_VPI == els->ct) {
+		els->temporary_rpi = rnode->indicator;
+	}
+
+	return 0;
+}
+
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCP_ICMND64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the scatter gather list.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rpi remote node indicator (RPI)
+ * @param rnode Destination request (that is, the remote node).
+ * @param timeout Time, in seconds, before an IO times out. Zero means no timeout.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fcp_icmnd64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl,
+		    uint16_t xri, uint16_t tag, uint16_t cq_id,
+		    uint32_t rpi, ocs_remote_node_t *rnode, uint8_t timeout)
+{
+	sli4_fcp_icmnd64_wqe_t *icmnd = buf;
+	sli4_sge_t	*sge = NULL;
+
+	ocs_memset(buf, 0, size);
+
+	if (!sgl || !sgl->virt) {
+		ocs_log_err(sli4->os, "bad parameter sgl=%p virt=%p\n",
+			    sgl, sgl ? sgl->virt : NULL);
+		return -1;
+	}
+	sge = sgl->virt;
+
+	if (sli4->config.sgl_pre_registered) {
+		icmnd->xbl = FALSE;
+
+		icmnd->dbde = TRUE;
+		icmnd->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+		icmnd->bde.buffer_length = sge[0].buffer_length;
+		icmnd->bde.u.data.buffer_address_low  = sge[0].buffer_address_low;
+		icmnd->bde.u.data.buffer_address_high = sge[0].buffer_address_high;
+	} else {
+		icmnd->xbl = TRUE;
+
+		icmnd->bde.bde_type = SLI4_BDE_TYPE_BLP;
+
+		icmnd->bde.buffer_length = sgl->size;
+		icmnd->bde.u.blp.sgl_segment_address_low  = ocs_addr32_lo(sgl->phys);
+		icmnd->bde.u.blp.sgl_segment_address_high = ocs_addr32_hi(sgl->phys);
+	}
+
+	icmnd->payload_offset_length = sge[0].buffer_length + sge[1].buffer_length;
+	icmnd->xri_tag = xri;
+	icmnd->context_tag = rpi;
+	icmnd->timer = timeout;
+
+	icmnd->pu = 2;	/* WQE word 4 contains read transfer length */
+	icmnd->class = SLI4_ELS_REQUEST64_CLASS_3;
+	icmnd->command = SLI4_WQE_FCP_ICMND64;
+	icmnd->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+
+	icmnd->abort_tag = xri;
+
+	icmnd->request_tag = tag;
+	icmnd->len_loc = 3;
+	if (rnode->node_group) {
+		icmnd->hlm = TRUE;
+		icmnd->remote_n_port_id = rnode->fc_id & 0x00ffffff;
+	}
+	if (((ocs_node_t *)rnode->node)->fcp2device) {
+		icmnd->erp = TRUE;
+	}
+	icmnd->cmd_type = SLI4_CMD_FCP_ICMND64_WQE;
+	icmnd->cq_id = cq_id;
+
+	return  0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCP_IREAD64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the scatter gather list.
+ * @param first_data_sge Index of first data sge (used if perf hints are enabled)
+ * @param xfer_len Data transfer length.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rpi remote node indicator (RPI)
+ * @param rnode Destination request (i.e. remote node).
+ * @param dif T10 DIF operation, or 0 to disable.
+ * @param bs T10 DIF block size, or 0 if DIF is disabled.
+ * @param timeout Time, in seconds, before an IO times out. Zero means no timeout.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fcp_iread64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl, uint32_t first_data_sge,
+		    uint32_t xfer_len, uint16_t xri, uint16_t tag, uint16_t cq_id,
+		    uint32_t rpi, ocs_remote_node_t *rnode,
+		    uint8_t dif, uint8_t bs, uint8_t timeout)
+{
+	sli4_fcp_iread64_wqe_t *iread = buf;
+	sli4_sge_t	*sge = NULL;
+
+	ocs_memset(buf, 0, size);
+
+	if (!sgl || !sgl->virt) {
+		ocs_log_err(sli4->os, "bad parameter sgl=%p virt=%p\n",
+			    sgl, sgl ? sgl->virt : NULL);
+		return -1;
+	}
+	sge = sgl->virt;
+
+	if (sli4->config.sgl_pre_registered) {
+		iread->xbl = FALSE;
+
+		iread->dbde = TRUE;
+		iread->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+		iread->bde.buffer_length = sge[0].buffer_length;
+		iread->bde.u.data.buffer_address_low  = sge[0].buffer_address_low;
+		iread->bde.u.data.buffer_address_high = sge[0].buffer_address_high;
+	} else {
+		iread->xbl = TRUE;
+
+		iread->bde.bde_type = SLI4_BDE_TYPE_BLP;
+
+		iread->bde.buffer_length = sgl->size;
+		iread->bde.u.blp.sgl_segment_address_low  = ocs_addr32_lo(sgl->phys);
+		iread->bde.u.blp.sgl_segment_address_high = ocs_addr32_hi(sgl->phys);
+
+		/* fill out fcp_cmnd buffer len and change resp buffer to be of type
+		 * "skip" (note: response will still be written to sge[1] if necessary) */
+		iread->fcp_cmd_buffer_length = sge[0].buffer_length;
+		sge[1].sge_type = SLI4_SGE_TYPE_SKIP;
+	}
+
+	iread->payload_offset_length = sge[0].buffer_length + sge[1].buffer_length;
+	iread->total_transfer_length = xfer_len;
+
+	iread->xri_tag = xri;
+	iread->context_tag = rpi;
+
+	iread->timer = timeout;
+
+	iread->pu = 2;	/* WQE word 4 contains read transfer length */
+	iread->class = SLI4_ELS_REQUEST64_CLASS_3;
+	iread->command = SLI4_WQE_FCP_IREAD64;
+	iread->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+	iread->dif = dif;
+	iread->bs  = bs;
+
+	iread->abort_tag = xri;
+
+	iread->request_tag = tag;
+	iread->len_loc = 3;
+	if (rnode->node_group) {
+		iread->hlm = TRUE;
+		iread->remote_n_port_id = rnode->fc_id & 0x00ffffff;
+	}
+	if (((ocs_node_t *)rnode->node)->fcp2device) {
+		iread->erp = TRUE;
+	}
+	iread->iod = 1;
+	iread->cmd_type = SLI4_CMD_FCP_IREAD64_WQE;
+	iread->cq_id = cq_id;
+
+	if (sli4->config.perf_hint) {
+		iread->first_data_bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+		iread->first_data_bde.buffer_length = sge[first_data_sge].buffer_length;
+		iread->first_data_bde.u.data.buffer_address_low  = sge[first_data_sge].buffer_address_low;
+		iread->first_data_bde.u.data.buffer_address_high = sge[first_data_sge].buffer_address_high;
+	}
+
+	return  0;
+}
+
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCP_IWRITE64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the scatter gather list.
+ * @param first_data_sge Index of first data sge (used if perf hints are enabled)
+ * @param xfer_len Data transfer length.
+ * @param first_burst The number of first burst bytes
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rpi remote node indicator (RPI)
+ * @param rnode Destination request (i.e. remote node)
+ * @param dif T10 DIF operation, or 0 to disable
+ * @param bs T10 DIF block size, or 0 if DIF is disabled
+ * @param timeout Time, in seconds, before an IO times out. Zero means no timeout.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fcp_iwrite64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl, uint32_t first_data_sge,
+		     uint32_t xfer_len, uint32_t first_burst, uint16_t xri, uint16_t tag, uint16_t cq_id,
+		     uint32_t rpi, ocs_remote_node_t *rnode,
+		     uint8_t dif, uint8_t bs, uint8_t timeout)
+{
+	sli4_fcp_iwrite64_wqe_t *iwrite = buf;
+	sli4_sge_t	*sge = NULL;
+
+	ocs_memset(buf, 0, size);
+
+	if (!sgl || !sgl->virt) {
+		ocs_log_err(sli4->os, "bad parameter sgl=%p virt=%p\n",
+			    sgl, sgl ? sgl->virt : NULL);
+		return -1;
+	}
+	sge = sgl->virt;
+
+	if (sli4->config.sgl_pre_registered) {
+		iwrite->xbl = FALSE;
+
+		iwrite->dbde = TRUE;
+		iwrite->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+		iwrite->bde.buffer_length = sge[0].buffer_length;
+		iwrite->bde.u.data.buffer_address_low  = sge[0].buffer_address_low;
+		iwrite->bde.u.data.buffer_address_high = sge[0].buffer_address_high;
+	} else {
+		iwrite->xbl = TRUE;
+
+		iwrite->bde.bde_type = SLI4_BDE_TYPE_BLP;
+
+		iwrite->bde.buffer_length = sgl->size;
+		iwrite->bde.u.blp.sgl_segment_address_low  = ocs_addr32_lo(sgl->phys);
+		iwrite->bde.u.blp.sgl_segment_address_high = ocs_addr32_hi(sgl->phys);
+
+		/* fill out fcp_cmnd buffer len and change resp buffer to be of type
+		 * "skip" (note: response will still be written to sge[1] if necessary) */
+		iwrite->fcp_cmd_buffer_length = sge[0].buffer_length;
+		sge[1].sge_type = SLI4_SGE_TYPE_SKIP;
+	}
+
+	iwrite->payload_offset_length = sge[0].buffer_length + sge[1].buffer_length;
+	iwrite->total_transfer_length = xfer_len;
+	iwrite->initial_transfer_length = MIN(xfer_len, first_burst);
+
+	iwrite->xri_tag = xri;
+	iwrite->context_tag = rpi;
+
+	iwrite->timer = timeout;
+
+	iwrite->pu = 2;	/* WQE word 4 contains read transfer length */
+	iwrite->class = SLI4_ELS_REQUEST64_CLASS_3;
+	iwrite->command = SLI4_WQE_FCP_IWRITE64;
+	iwrite->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+	iwrite->dif = dif;
+	iwrite->bs  = bs;
+
+	iwrite->abort_tag = xri;
+
+	iwrite->request_tag = tag;
+	iwrite->len_loc = 3;
+	if (rnode->node_group) {
+		iwrite->hlm = TRUE;
+		iwrite->remote_n_port_id = rnode->fc_id & 0x00ffffff;
+	}
+	if (((ocs_node_t *)rnode->node)->fcp2device) {
+		iwrite->erp = TRUE;
+	}
+	iwrite->cmd_type = SLI4_CMD_FCP_IWRITE64_WQE;
+	iwrite->cq_id = cq_id;
+
+	if (sli4->config.perf_hint) {
+		iwrite->first_data_bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+		iwrite->first_data_bde.buffer_length = sge[first_data_sge].buffer_length;
+		iwrite->first_data_bde.u.data.buffer_address_low  = sge[first_data_sge].buffer_address_low;
+		iwrite->first_data_bde.u.data.buffer_address_high = sge[first_data_sge].buffer_address_high;
+	}
+
+	return  0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCP_TRECEIVE64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the Scatter-Gather List.
+ * @param first_data_sge Index of first data sge (used if perf hints are enabled)
+ * @param relative_off Relative offset of the IO (if any).
+ * @param xfer_len Data transfer length.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param xid OX_ID for the exchange.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rpi remote node indicator (RPI)
+ * @param rnode Destination request (i.e. remote node).
+ * @param flags Optional attributes, including:
+ *  - ACTIVE - IO is already active.
+ *  - AUTO RSP - Automatically generate a good FCP_RSP.
+ * @param dif T10 DIF operation, or 0 to disable.
+ * @param bs T10 DIF block size, or 0 if DIF is disabled.
+ * @param csctl value of csctl field.
+ * @param app_id value for VM application header.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fcp_treceive64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl, uint32_t first_data_sge,
+		       uint32_t relative_off, uint32_t xfer_len, uint16_t xri, uint16_t tag, uint16_t cq_id,
+		       uint16_t xid, uint32_t rpi, ocs_remote_node_t *rnode, uint32_t flags, uint8_t dif, uint8_t bs,
+		       uint8_t csctl, uint32_t app_id)
+{
+	sli4_fcp_treceive64_wqe_t *trecv = buf;
+	sli4_fcp_128byte_wqe_t *trecv_128 = buf;
+	sli4_sge_t	*sge = NULL;
+
+	ocs_memset(buf, 0, size);
+
+	if (!sgl || !sgl->virt) {
+		ocs_log_err(sli4->os, "bad parameter sgl=%p virt=%p\n",
+			    sgl, sgl ? sgl->virt : NULL);
+		return -1;
+	}
+	sge = sgl->virt;
+
+	if (sli4->config.sgl_pre_registered) {
+		trecv->xbl = FALSE;
+
+		trecv->dbde = TRUE;
+		trecv->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+		trecv->bde.buffer_length = sge[0].buffer_length;
+		trecv->bde.u.data.buffer_address_low  = sge[0].buffer_address_low;
+		trecv->bde.u.data.buffer_address_high = sge[0].buffer_address_high;
+
+		trecv->payload_offset_length = sge[0].buffer_length;
+	} else {
+		trecv->xbl = TRUE;
+
+		/* if data is a single physical address, use a BDE */
+		if (!dif && (xfer_len <= sge[2].buffer_length)) {
+			trecv->dbde = TRUE;
+			trecv->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+			trecv->bde.buffer_length = sge[2].buffer_length;
+			trecv->bde.u.data.buffer_address_low  = sge[2].buffer_address_low;
+			trecv->bde.u.data.buffer_address_high = sge[2].buffer_address_high;
+		} else {
+			trecv->bde.bde_type = SLI4_BDE_TYPE_BLP;
+			trecv->bde.buffer_length = sgl->size;
+			trecv->bde.u.blp.sgl_segment_address_low  = ocs_addr32_lo(sgl->phys);
+			trecv->bde.u.blp.sgl_segment_address_high = ocs_addr32_hi(sgl->phys);
+		}
+	}
+
+	trecv->relative_offset = relative_off;
+
+	if (flags & SLI4_IO_CONTINUATION) {
+		trecv->xc = TRUE;
+	}
+	trecv->xri_tag = xri;
+
+	trecv->context_tag = rpi;
+
+	trecv->pu = TRUE;	/* WQE uses relative offset */
+
+	if (flags & SLI4_IO_AUTO_GOOD_RESPONSE) {
+		trecv->ar = TRUE;
+	}
+
+	trecv->command = SLI4_WQE_FCP_TRECEIVE64;
+	trecv->class = SLI4_ELS_REQUEST64_CLASS_3;
+	trecv->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+	trecv->dif = dif;
+	trecv->bs  = bs;
+
+	trecv->remote_xid = xid;
+
+	trecv->request_tag = tag;
+
+	trecv->iod = 1;
+
+	trecv->len_loc = 0x2;
+
+	if (rnode->node_group) {
+		trecv->hlm = TRUE;
+		trecv->dword5.dword = rnode->fc_id & 0x00ffffff;
+	}
+
+	trecv->cmd_type = SLI4_CMD_FCP_TRECEIVE64_WQE;
+
+	trecv->cq_id = cq_id;
+
+	trecv->fcp_data_receive_length = xfer_len;
+
+	if (sli4->config.perf_hint) {
+		trecv->first_data_bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+		trecv->first_data_bde.buffer_length = sge[first_data_sge].buffer_length;
+		trecv->first_data_bde.u.data.buffer_address_low  = sge[first_data_sge].buffer_address_low;
+		trecv->first_data_bde.u.data.buffer_address_high = sge[first_data_sge].buffer_address_high;
+	}
+
+	/* The upper 7 bits of csctl is the priority */
+	if (csctl & SLI4_MASK_CCP) {
+		trecv->ccpe = 1;
+		trecv->ccp = (csctl & SLI4_MASK_CCP);
+	}
+
+	if (app_id && (sli4->config.wqe_size == SLI4_WQE_EXT_BYTES) && !trecv->eat) {
+		trecv->app_id_valid = 1;
+		trecv->wqes = 1;
+		trecv_128->dw[31] = app_id;
+	}
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCP_CONT_TRECEIVE64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the Scatter-Gather List.
+ * @param first_data_sge Index of first data sge (used if perf hints are enabled)
+ * @param relative_off Relative offset of the IO (if any).
+ * @param xfer_len Data transfer length.
+ * @param xri XRI for this exchange.
+ * @param sec_xri Secondary XRI for this exchange. (BZ 161832 workaround)
+ * @param tag IO tag value.
+ * @param xid OX_ID for the exchange.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rpi remote node indicator (RPI)
+ * @param rnode Destination request (i.e. remote node).
+ * @param flags Optional attributes, including:
+ *  - ACTIVE - IO is already active.
+ *  - AUTO RSP - Automatically generate a good FCP_RSP.
+ * @param dif T10 DIF operation, or 0 to disable.
+ * @param bs T10 DIF block size, or 0 if DIF is disabled.
+ * @param csctl value of csctl field.
+ * @param app_id value for VM application header.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fcp_cont_treceive64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl, uint32_t first_data_sge,
+			uint32_t relative_off, uint32_t xfer_len, uint16_t xri, uint16_t sec_xri, uint16_t tag,
+			uint16_t cq_id, uint16_t xid, uint32_t rpi, ocs_remote_node_t *rnode, uint32_t flags,
+			uint8_t dif, uint8_t bs, uint8_t csctl, uint32_t app_id)
+{
+	int32_t rc;
+
+	rc = sli_fcp_treceive64_wqe(sli4, buf, size, sgl, first_data_sge, relative_off, xfer_len, xri, tag,
+			cq_id, xid, rpi, rnode, flags, dif, bs, csctl, app_id);
+	if (rc == 0) {
+		sli4_fcp_treceive64_wqe_t *trecv = buf;
+
+		trecv->command = SLI4_WQE_FCP_CONT_TRECEIVE64;
+		trecv->dword5.sec_xri_tag = sec_xri;
+	}
+	return rc;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCP_TRSP64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the Scatter-Gather List.
+ * @param rsp_len Response data length.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param xid OX_ID for the exchange.
+ * @param rpi remote node indicator (RPI)
+ * @param rnode Destination request (i.e. remote node).
+ * @param flags Optional attributes, including:
+ *  - ACTIVE - IO is already active
+ *  - AUTO RSP - Automatically generate a good FCP_RSP.
+ * @param csctl value of csctl field.
+ * @param port_owned 0/1 to indicate if the XRI is port owned (used to set XBL=0)
+ * @param app_id value for VM application header.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fcp_trsp64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl, uint32_t rsp_len,
+		   uint16_t xri, uint16_t tag, uint16_t cq_id, uint16_t xid, uint32_t rpi, ocs_remote_node_t *rnode,
+		   uint32_t flags, uint8_t csctl, uint8_t port_owned, uint32_t app_id)
+{
+	sli4_fcp_trsp64_wqe_t *trsp = buf;
+	sli4_fcp_128byte_wqe_t *trsp_128 = buf;
+
+	ocs_memset(buf, 0, size);
+
+	if (flags & SLI4_IO_AUTO_GOOD_RESPONSE) {
+		trsp->ag = TRUE;
+		/*
+		 * The SLI-4 documentation states that the BDE is ignored when
+		 * using auto-good response, but, at least for IF_TYPE 0 devices,
+		 * this does not appear to be true.
+		 */
+		if (SLI4_IF_TYPE_BE3_SKH_PF == sli4->if_type) {
+			trsp->bde.buffer_length = 12;	/* byte size of RSP */
+		}
+	} else {
+		sli4_sge_t	*sge = sgl->virt;
+
+		if (sli4->config.sgl_pre_registered || port_owned) {
+			trsp->dbde = TRUE;
+		} else {
+			trsp->xbl = TRUE;
+		}
+
+		trsp->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+		trsp->bde.buffer_length = sge[0].buffer_length;
+		trsp->bde.u.data.buffer_address_low  = sge[0].buffer_address_low;
+		trsp->bde.u.data.buffer_address_high = sge[0].buffer_address_high;
+
+		trsp->fcp_response_length = rsp_len;
+	}
+
+	if (flags & SLI4_IO_CONTINUATION) {
+		trsp->xc = TRUE;
+	}
+
+	if (rnode->node_group) {
+		trsp->hlm = TRUE;
+		trsp->dword5 = rnode->fc_id & 0x00ffffff;
+	}
+
+	trsp->xri_tag = xri;
+	trsp->rpi = rpi;
+
+	trsp->command = SLI4_WQE_FCP_TRSP64;
+	trsp->class = SLI4_ELS_REQUEST64_CLASS_3;
+
+	trsp->remote_xid = xid;
+	trsp->request_tag = tag;
+	trsp->dnrx = ((flags & SLI4_IO_DNRX) == 0 ? 0 : 1);
+	trsp->len_loc = 0x1;
+	trsp->cq_id = cq_id;
+	trsp->cmd_type = SLI4_CMD_FCP_TRSP64_WQE;
+
+	/* The upper 7 bits of csctl is the priority */
+	if (csctl & SLI4_MASK_CCP) {
+		trsp->ccpe = 1;
+		trsp->ccp = (csctl & SLI4_MASK_CCP);
+	}
+
+	if (app_id && (sli4->config.wqe_size == SLI4_WQE_EXT_BYTES) && !trsp->eat) {
+		trsp->app_id_valid = 1;
+		trsp->wqes = 1;
+		trsp_128->dw[31] = app_id;
+	}
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an FCP_TSEND64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the scatter gather list.
+ * @param first_data_sge Index of first data sge (used if perf hints are enabled)
+ * @param relative_off Relative offset of the IO (if any).
+ * @param xfer_len Data transfer length.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param xid OX_ID for the exchange.
+ * @param rpi remote node indicator (RPI)
+ * @param rnode Destination request (i.e. remote node).
+ * @param flags Optional attributes, including:
+ *  - ACTIVE - IO is already active.
+ *  - AUTO RSP - Automatically generate a good FCP_RSP.
+ * @param dif T10 DIF operation, or 0 to disable.
+ * @param bs T10 DIF block size, or 0 if DIF is disabled.
+ * @param csctl value of csctl field.
+ * @param app_id value for VM application header.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fcp_tsend64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl, uint32_t first_data_sge,
+		    uint32_t relative_off, uint32_t xfer_len,
+		    uint16_t xri, uint16_t tag, uint16_t cq_id, uint16_t xid, uint32_t rpi, ocs_remote_node_t *rnode,
+		    uint32_t flags, uint8_t dif, uint8_t bs, uint8_t csctl, uint32_t app_id)
+{
+	sli4_fcp_tsend64_wqe_t *tsend = buf;
+	sli4_fcp_128byte_wqe_t *tsend_128 = buf;
+	sli4_sge_t	*sge = NULL;
+
+	ocs_memset(buf, 0, size);
+
+	if (!sgl || !sgl->virt) {
+		ocs_log_err(sli4->os, "bad parameter sgl=%p virt=%p\n",
+			    sgl, sgl ? sgl->virt : NULL);
+		return -1;
+	}
+	sge = sgl->virt;
+
+	if (sli4->config.sgl_pre_registered) {
+		tsend->xbl = FALSE;
+
+		tsend->dbde = TRUE;
+		tsend->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+		/* TSEND64_WQE specifies first two SGE are skipped
+		 * (i.e. 3rd is valid) */
+		tsend->bde.buffer_length = sge[2].buffer_length;
+		tsend->bde.u.data.buffer_address_low  = sge[2].buffer_address_low;
+		tsend->bde.u.data.buffer_address_high = sge[2].buffer_address_high;
+	} else {
+		tsend->xbl = TRUE;
+
+		/* if data is a single physical address, use a BDE */
+		if (!dif && (xfer_len <= sge[2].buffer_length)) {
+			tsend->dbde = TRUE;
+			tsend->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+			/* TSEND64_WQE specifies first two SGE are skipped
+			 * (i.e. 3rd is valid) */
+			tsend->bde.buffer_length = sge[2].buffer_length;
+			tsend->bde.u.data.buffer_address_low  = sge[2].buffer_address_low;
+			tsend->bde.u.data.buffer_address_high = sge[2].buffer_address_high;
+		} else {
+			tsend->bde.bde_type = SLI4_BDE_TYPE_BLP;
+			tsend->bde.buffer_length = sgl->size;
+			tsend->bde.u.blp.sgl_segment_address_low  = ocs_addr32_lo(sgl->phys);
+			tsend->bde.u.blp.sgl_segment_address_high = ocs_addr32_hi(sgl->phys);
+		}
+	}
+
+	tsend->relative_offset = relative_off;
+
+	if (flags & SLI4_IO_CONTINUATION) {
+		tsend->xc = TRUE;
+	}
+	tsend->xri_tag = xri;
+
+	tsend->rpi = rpi;
+
+	tsend->pu = TRUE;	/* WQE uses relative offset */
+
+	if (flags & SLI4_IO_AUTO_GOOD_RESPONSE) {
+		tsend->ar = TRUE;
+	}
+
+	tsend->command = SLI4_WQE_FCP_TSEND64;
+	tsend->class = SLI4_ELS_REQUEST64_CLASS_3;
+	tsend->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+	tsend->dif = dif;
+	tsend->bs  = bs;
+
+	tsend->remote_xid = xid;
+
+	tsend->request_tag = tag;
+
+	tsend->len_loc = 0x2;
+
+	if (rnode->node_group) {
+		tsend->hlm = TRUE;
+		tsend->dword5 = rnode->fc_id & 0x00ffffff;
+	}
+
+	tsend->cq_id = cq_id;
+
+	tsend->cmd_type = SLI4_CMD_FCP_TSEND64_WQE;
+
+	tsend->fcp_data_transmit_length = xfer_len;
+
+	if (sli4->config.perf_hint) {
+		tsend->first_data_bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+		tsend->first_data_bde.buffer_length = sge[first_data_sge].buffer_length;
+		tsend->first_data_bde.u.data.buffer_address_low  = sge[first_data_sge].buffer_address_low;
+		tsend->first_data_bde.u.data.buffer_address_high = sge[first_data_sge].buffer_address_high;
+	}
+
+	/* The upper 7 bits of csctl is the priority */
+	if (csctl & SLI4_MASK_CCP) {
+		tsend->ccpe = 1;
+		tsend->ccp = (csctl & SLI4_MASK_CCP);
+	}
+
+	if (app_id && (sli4->config.wqe_size == SLI4_WQE_EXT_BYTES) && !tsend->eat) {
+		tsend->app_id_valid = 1;
+		tsend->wqes = 1;
+		tsend_128->dw[31] = app_id;
+	}
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write a GEN_REQUEST64 work queue entry.
+ *
+ * @note This WQE is only used to send FC-CT commands.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sgl DMA memory for the request.
+ * @param req_len Length of request.
+ * @param max_rsp_len Max length of response.
+ * @param timeout Time, in seconds, before an IO times out. Zero means infinite.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rnode Destination of request (that is, the remote node).
+ * @param r_ctl R_CTL value for sequence.
+ * @param type TYPE value for sequence.
+ * @param df_ctl DF_CTL value for sequence.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_gen_request64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *sgl,
+		      uint32_t req_len, uint32_t max_rsp_len, uint8_t timeout,
+		      uint16_t xri, uint16_t tag, uint16_t cq_id, ocs_remote_node_t *rnode,
+		      uint8_t r_ctl, uint8_t type, uint8_t df_ctl)
+{
+	sli4_gen_request64_wqe_t	*gen = buf;
+	sli4_sge_t	*sge = NULL;
+
+	ocs_memset(buf, 0, size);
+
+	if (!sgl || !sgl->virt) {
+		ocs_log_err(sli4->os, "bad parameter sgl=%p virt=%p\n",
+			    sgl, sgl ? sgl->virt : NULL);
+		return -1;
+	}
+	sge = sgl->virt;
+
+	if (sli4->config.sgl_pre_registered) {
+		gen->xbl = FALSE;
+
+		gen->dbde = TRUE;
+		gen->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+
+		gen->bde.buffer_length = req_len;
+		gen->bde.u.data.buffer_address_low  = sge[0].buffer_address_low;
+		gen->bde.u.data.buffer_address_high = sge[0].buffer_address_high;
+	} else {
+		gen->xbl = TRUE;
+
+		gen->bde.bde_type = SLI4_BDE_TYPE_BLP;
+
+		gen->bde.buffer_length = 2 * sizeof(sli4_sge_t);
+		gen->bde.u.blp.sgl_segment_address_low  = ocs_addr32_lo(sgl->phys);
+		gen->bde.u.blp.sgl_segment_address_high = ocs_addr32_hi(sgl->phys);
+	}
+
+	gen->request_payload_length = req_len;
+	gen->max_response_payload_length = max_rsp_len;
+
+	gen->df_ctl = df_ctl;
+	gen->type = type;
+	gen->r_ctl = r_ctl;
+
+	gen->xri_tag = xri;
+
+	gen->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+	gen->context_tag = rnode->indicator;
+
+	gen->class = SLI4_ELS_REQUEST64_CLASS_3;
+
+	gen->command = SLI4_WQE_GEN_REQUEST64;
+
+	gen->timer = timeout;
+
+	gen->request_tag = tag;
+
+	gen->iod = SLI4_ELS_REQUEST64_DIR_READ;
+
+	gen->qosd = TRUE;
+
+	if (rnode->node_group) {
+		gen->hlm = TRUE;
+		gen->remote_n_port_id = rnode->fc_id & 0x00ffffff;
+	}
+
+	gen->cmd_type = SLI4_CMD_GEN_REQUEST64_WQE;
+
+	gen->cq_id = cq_id;
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write a SEND_FRAME work queue entry
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param sof Start of frame value
+ * @param eof End of frame value
+ * @param hdr Pointer to FC header data
+ * @param payload DMA memory for the payload.
+ * @param req_len Length of payload.
+ * @param timeout Time, in seconds, before an IO times out. Zero means infinite.
+ * @param xri XRI for this exchange.
+ * @param req_tag IO tag value.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_send_frame_wqe(sli4_t *sli4, void *buf, size_t size, uint8_t sof, uint8_t eof, uint32_t *hdr,
+		   ocs_dma_t *payload, uint32_t req_len, uint8_t timeout,
+		   uint16_t xri, uint16_t req_tag)
+{
+	sli4_send_frame_wqe_t *sf = buf;
+
+	ocs_memset(buf, 0, size);
+
+	sf->dbde = TRUE;
+	sf->bde.buffer_length = req_len;
+	sf->bde.u.data.buffer_address_low = ocs_addr32_lo(payload->phys);
+	sf->bde.u.data.buffer_address_high = ocs_addr32_hi(payload->phys);
+
+	/* Copy FC header */
+	sf->fc_header_0_1[0] = hdr[0];
+	sf->fc_header_0_1[1] = hdr[1];
+	sf->fc_header_2_5[0] = hdr[2];
+	sf->fc_header_2_5[1] = hdr[3];
+	sf->fc_header_2_5[2] = hdr[4];
+	sf->fc_header_2_5[3] = hdr[5];
+
+	sf->frame_length = req_len;
+
+	sf->xri_tag = xri;
+	sf->pu = 0;
+	sf->context_tag = 0;
+
+
+	sf->ct = 0;
+	sf->command = SLI4_WQE_SEND_FRAME;
+	sf->class = SLI4_ELS_REQUEST64_CLASS_3;
+	sf->timer = timeout;
+
+	sf->request_tag = req_tag;
+	sf->eof = eof;
+	sf->sof = sof;
+
+	sf->qosd = 0;
+	sf->lenloc = 1;
+	sf->xc = 0;
+
+	sf->xbl = 1;
+
+	sf->cmd_type = SLI4_CMD_SEND_FRAME_WQE;
+	sf->cq_id = 0xffff;
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write a XMIT_SEQUENCE64 work queue entry.
+ *
+ * This WQE is used to send FC-CT response frames.
+ *
+ * @note This API implements a restricted use for this WQE, a TODO: would
+ * include passing in sequence initiative, and full SGL's
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param payload DMA memory for the request.
+ * @param payload_len Length of request.
+ * @param timeout Time, in seconds, before an IO times out. Zero means infinite.
+ * @param ox_id originator exchange ID
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param rnode Destination of request (that is, the remote node).
+ * @param r_ctl R_CTL value for sequence.
+ * @param type TYPE value for sequence.
+ * @param df_ctl DF_CTL value for sequence.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_xmit_sequence64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *payload,
+		      uint32_t payload_len, uint8_t timeout, uint16_t ox_id,
+		      uint16_t xri, uint16_t tag, ocs_remote_node_t *rnode,
+		      uint8_t r_ctl, uint8_t type, uint8_t df_ctl)
+{
+	sli4_xmit_sequence64_wqe_t	*xmit = buf;
+
+	ocs_memset(buf, 0, size);
+
+	if ((payload == NULL) || (payload->virt == NULL)) {
+		ocs_log_err(sli4->os, "bad parameter sgl=%p virt=%p\n",
+			    payload, payload ? payload->virt : NULL);
+		return -1;
+	}
+
+	if (sli4->config.sgl_pre_registered) {
+		xmit->dbde = TRUE;
+	} else {
+		xmit->xbl = TRUE;
+	}
+
+	xmit->bde.bde_type = SLI4_BDE_TYPE_BDE_64;
+	xmit->bde.buffer_length = payload_len;
+	xmit->bde.u.data.buffer_address_low  = ocs_addr32_lo(payload->phys);
+	xmit->bde.u.data.buffer_address_high = ocs_addr32_hi(payload->phys);
+	xmit->sequence_payload_len = payload_len;
+
+	xmit->remote_n_port_id = rnode->fc_id & 0x00ffffff;
+
+	xmit->relative_offset = 0;
+
+	xmit->si = 0;			/* sequence initiative - this matches what is seen from
+					 * FC switches in response to FCGS commands */
+	xmit->ft = 0;			/* force transmit */
+	xmit->xo = 0;			/* exchange responder */
+	xmit->ls = 1;			/* last in seqence */
+	xmit->df_ctl = df_ctl;
+	xmit->type = type;
+	xmit->r_ctl = r_ctl;
+
+	xmit->xri_tag = xri;
+	xmit->context_tag = rnode->indicator;
+
+	xmit->dif = 0;
+	xmit->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+	xmit->bs = 0;
+
+	xmit->command = SLI4_WQE_XMIT_SEQUENCE64;
+	xmit->class = SLI4_ELS_REQUEST64_CLASS_3;
+	xmit->pu = 0;
+	xmit->timer = timeout;
+
+	xmit->abort_tag = 0;
+	xmit->request_tag = tag;
+	xmit->remote_xid = ox_id;
+
+	xmit->iod = SLI4_ELS_REQUEST64_DIR_READ;
+
+	if (rnode->node_group) {
+		xmit->hlm = TRUE;
+		xmit->remote_n_port_id = rnode->fc_id & 0x00ffffff;
+	}
+
+	xmit->cmd_type = SLI4_CMD_XMIT_SEQUENCE64_WQE;
+
+	xmit->len_loc = 2;
+
+	xmit->cq_id = 0xFFFF;
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write a REQUEUE_XRI_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_requeue_xri_wqe(sli4_t *sli4, void *buf, size_t size, uint16_t xri, uint16_t tag, uint16_t cq_id)
+{
+	sli4_requeue_xri_wqe_t	*requeue = buf;
+
+	ocs_memset(buf, 0, size);
+
+	requeue->command = SLI4_WQE_REQUEUE_XRI;
+	requeue->xri_tag = xri;
+	requeue->request_tag = tag;
+	requeue->xc = 1;
+	requeue->qosd = 1;
+	requeue->cq_id = cq_id;
+	requeue->cmd_type = SLI4_CMD_REQUEUE_XRI_WQE;
+	return 0;
+}
+
+int32_t
+sli_xmit_bcast64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *payload,
+		uint32_t payload_len, uint8_t timeout, uint16_t xri, uint16_t tag,
+		uint16_t cq_id, ocs_remote_node_t *rnode,
+		uint8_t r_ctl, uint8_t type, uint8_t df_ctl)
+{
+	sli4_xmit_bcast64_wqe_t *bcast = buf;
+
+	/* Command requires a temporary RPI (i.e. unused remote node) */
+	if (rnode->attached) {
+		ocs_log_test(sli4->os, "remote node %d in use\n", rnode->indicator);
+		return -1;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	bcast->dbde = TRUE;
+	bcast->sequence_payload.bde_type = SLI4_BDE_TYPE_BDE_64;
+	bcast->sequence_payload.buffer_length = payload_len;
+	bcast->sequence_payload.u.data.buffer_address_low  = ocs_addr32_lo(payload->phys);
+	bcast->sequence_payload.u.data.buffer_address_high = ocs_addr32_hi(payload->phys);
+
+	bcast->sequence_payload_length = payload_len;
+
+	bcast->df_ctl = df_ctl;
+	bcast->type = type;
+	bcast->r_ctl = r_ctl;
+
+	bcast->xri_tag = xri;
+
+	bcast->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+	bcast->context_tag = rnode->sport->indicator;
+
+	bcast->class = SLI4_ELS_REQUEST64_CLASS_3;
+
+	bcast->command = SLI4_WQE_XMIT_BCAST64;
+
+	bcast->timer = timeout;
+
+	bcast->request_tag = tag;
+
+	bcast->temporary_rpi = rnode->indicator;
+
+	bcast->len_loc = 0x1;
+
+	bcast->iod = SLI4_ELS_REQUEST64_DIR_WRITE;
+
+	bcast->cmd_type = SLI4_CMD_XMIT_BCAST64_WQE;
+
+	bcast->cq_id = cq_id;
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write an XMIT_BLS_RSP64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param payload Contents of the BLS payload to be sent.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param rnode Destination of request (that is, the remote node).
+ * @param s_id Source ID to use in the response. If UINT32_MAX, use SLI Port's ID.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_xmit_bls_rsp64_wqe(sli4_t *sli4, void *buf, size_t size, sli_bls_payload_t *payload,
+		       uint16_t xri, uint16_t tag, uint16_t cq_id, ocs_remote_node_t *rnode, uint32_t s_id)
+{
+	sli4_xmit_bls_rsp_wqe_t *bls = buf;
+
+	/*
+	 * Callers can either specify RPI or S_ID, but not both
+	 */
+	if (rnode->attached && (s_id != UINT32_MAX)) {
+		ocs_log_test(sli4->os, "S_ID specified for attached remote node %d\n",
+			     rnode->indicator);
+		return -1;
+	}
+
+	ocs_memset(buf, 0, size);
+
+	if (SLI_BLS_ACC == payload->type) {
+		bls->payload_word0 = (payload->u.acc.seq_id_last << 16) |
+			(payload->u.acc.seq_id_validity << 24);
+		bls->high_seq_cnt = payload->u.acc.high_seq_cnt;
+		bls->low_seq_cnt = payload->u.acc.low_seq_cnt;
+	} else if (SLI_BLS_RJT == payload->type) {
+		bls->payload_word0 = *((uint32_t *)&payload->u.rjt);
+		bls->ar = TRUE;
+	} else {
+		ocs_log_test(sli4->os, "bad BLS type %#x\n",
+				payload->type);
+		return -1;
+	}
+
+	bls->ox_id = payload->ox_id;
+	bls->rx_id = payload->rx_id;
+
+	if (rnode->attached) {
+		bls->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+		bls->context_tag = rnode->indicator;
+	} else {
+		bls->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+		bls->context_tag = rnode->sport->indicator;
+
+		if (UINT32_MAX != s_id) {
+			bls->local_n_port_id = s_id & 0x00ffffff;
+		} else {
+			bls->local_n_port_id = rnode->sport->fc_id & 0x00ffffff;
+		}
+		bls->remote_id = rnode->fc_id & 0x00ffffff;
+
+		bls->temporary_rpi = rnode->indicator;
+	}
+
+	bls->xri_tag = xri;
+
+	bls->class = SLI4_ELS_REQUEST64_CLASS_3;
+
+	bls->command = SLI4_WQE_XMIT_BLS_RSP;
+
+	bls->request_tag = tag;
+
+	bls->qosd = TRUE;
+
+	if (rnode->node_group) {
+		bls->hlm = TRUE;
+		bls->remote_id = rnode->fc_id & 0x00ffffff;
+	}
+
+	bls->cq_id = cq_id;
+
+	bls->cmd_type = SLI4_CMD_XMIT_BLS_RSP64_WQE;
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Write a XMIT_ELS_RSP64_WQE work queue entry.
+ *
+ * @param sli4 SLI context.
+ * @param buf Destination buffer for the WQE.
+ * @param size Buffer size, in bytes.
+ * @param rsp DMA memory for the ELS response.
+ * @param rsp_len Length of ELS response, in bytes.
+ * @param xri XRI for this exchange.
+ * @param tag IO tag value.
+ * @param cq_id The id of the completion queue where the WQE response is sent.
+ * @param ox_id OX_ID of the exchange containing the request.
+ * @param rnode Destination of the ELS response (that is, the remote node).
+ * @param flags Optional attributes, including:
+ *  - SLI4_IO_CONTINUATION - IO is already active.
+ * @param s_id S_ID used for special responses.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_xmit_els_rsp64_wqe(sli4_t *sli4, void *buf, size_t size, ocs_dma_t *rsp,
+		       uint32_t rsp_len, uint16_t xri, uint16_t tag, uint16_t cq_id,
+		       uint16_t ox_id, ocs_remote_node_t *rnode, uint32_t flags, uint32_t s_id)
+{
+	sli4_xmit_els_rsp64_wqe_t	*els = buf;
+
+	ocs_memset(buf, 0, size);
+
+	if (sli4->config.sgl_pre_registered) {
+		els->dbde = TRUE;
+	} else {
+		els->xbl = TRUE;
+	}
+
+	els->els_response_payload.bde_type = SLI4_BDE_TYPE_BDE_64;
+	els->els_response_payload.buffer_length = rsp_len;
+	els->els_response_payload.u.data.buffer_address_low  = ocs_addr32_lo(rsp->phys);
+	els->els_response_payload.u.data.buffer_address_high = ocs_addr32_hi(rsp->phys);
+
+	els->els_response_payload_length = rsp_len;
+
+	els->xri_tag = xri;
+
+	els->class = SLI4_ELS_REQUEST64_CLASS_3;
+
+	els->command = SLI4_WQE_ELS_RSP64;
+
+	els->request_tag = tag;
+
+	els->ox_id = ox_id;
+
+	els->iod = SLI4_ELS_REQUEST64_DIR_WRITE;
+
+	els->qosd = TRUE;
+
+	if (flags & SLI4_IO_CONTINUATION) {
+		els->xc = TRUE;
+	}
+
+	if (rnode->attached) {
+		els->ct = SLI4_ELS_REQUEST64_CONTEXT_RPI;
+		els->context_tag = rnode->indicator;
+	} else {
+		els->ct = SLI4_ELS_REQUEST64_CONTEXT_VPI;
+		els->context_tag = rnode->sport->indicator;
+		els->remote_id = rnode->fc_id & 0x00ffffff;
+		els->temporary_rpi = rnode->indicator;
+		if (UINT32_MAX != s_id) {
+			els->sp = TRUE;
+			els->s_id = s_id & 0x00ffffff;
+		}
+	}
+
+	if (rnode->node_group) {
+		els->hlm = TRUE;
+		els->remote_id = rnode->fc_id & 0x00ffffff;
+	}
+
+	els->cmd_type = SLI4_ELS_REQUEST64_CMD_GEN;
+
+	els->cq_id = cq_id;
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Process an asynchronous Link State event entry.
+ *
+ * @par Description
+ * Parses Asynchronous Completion Queue Entry (ACQE),
+ * creates an abstracted event, and calls registered callback functions.
+ *
+ * @param sli4 SLI context.
+ * @param acqe Pointer to the ACQE.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fc_process_link_state(sli4_t *sli4, void *acqe)
+{
+	sli4_link_state_t	*link_state = acqe;
+	sli4_link_event_t	event = { 0 };
+	int32_t			rc = 0;
+
+	if (!sli4->link) {
+		/* bail if there is no callback */
+		return 0;
+	}
+
+	if (SLI4_LINK_TYPE_ETHERNET == link_state->link_type) {
+		event.topology = SLI_LINK_TOPO_NPORT;
+		event.medium   = SLI_LINK_MEDIUM_ETHERNET;
+	} else {
+		/* TODO is this supported for anything other than FCoE? */
+		ocs_log_test(sli4->os, "unsupported link type %#x\n",
+				link_state->link_type);
+		event.topology = SLI_LINK_TOPO_MAX;
+		event.medium   = SLI_LINK_MEDIUM_MAX;
+		rc = -1;
+	}
+
+	switch (link_state->port_link_status) {
+	case SLI4_PORT_LINK_STATUS_PHYSICAL_DOWN:
+	case SLI4_PORT_LINK_STATUS_LOGICAL_DOWN:
+		event.status = SLI_LINK_STATUS_DOWN;
+		break;
+	case SLI4_PORT_LINK_STATUS_PHYSICAL_UP:
+	case SLI4_PORT_LINK_STATUS_LOGICAL_UP:
+		event.status = SLI_LINK_STATUS_UP;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unsupported link status %#x\n",
+				link_state->port_link_status);
+		event.status = SLI_LINK_STATUS_MAX;
+		rc = -1;
+	}
+
+	switch (link_state->port_speed) {
+	case 0:
+		event.speed = 0;
+		break;
+	case 1:
+		event.speed = 10;
+		break;
+	case 2:
+		event.speed = 100;
+		break;
+	case 3:
+		event.speed = 1000;
+		break;
+	case 4:
+		event.speed = 10000;
+		break;
+	case 5:
+		event.speed = 20000;
+		break;
+	case 6:
+		event.speed = 25000;
+		break;
+	case 7:
+		event.speed = 40000;
+		break;
+	case 8:
+		event.speed = 100000;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unsupported port_speed %#x\n",
+				link_state->port_speed);
+		rc = -1;
+	}
+
+	sli4->link(sli4->link_arg, (void *)&event);
+
+	return rc;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Process an asynchronous Link Attention event entry.
+ *
+ * @par Description
+ * Parses Asynchronous Completion Queue Entry (ACQE),
+ * creates an abstracted event, and calls the registered callback functions.
+ *
+ * @param sli4 SLI context.
+ * @param acqe Pointer to the ACQE.
+ *
+ * @todo XXX all events return LINK_UP.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fc_process_link_attention(sli4_t *sli4, void *acqe)
+{
+	sli4_link_attention_t	*link_attn = acqe;
+	sli4_link_event_t	event = { 0 };
+
+	ocs_log_debug(sli4->os, "link_number=%d attn_type=%#x topology=%#x port_speed=%#x "
+			"port_fault=%#x shared_link_status=%#x logical_link_speed=%#x "
+			"event_tag=%#x\n", link_attn->link_number, link_attn->attn_type,
+			link_attn->topology, link_attn->port_speed, link_attn->port_fault,
+			link_attn->shared_link_status, link_attn->logical_link_speed,
+			link_attn->event_tag);
+
+	if (!sli4->link) {
+		return 0;
+	}
+
+	event.medium   = SLI_LINK_MEDIUM_FC;
+
+	switch (link_attn->attn_type) {
+	case SLI4_LINK_ATTN_TYPE_LINK_UP:
+		event.status = SLI_LINK_STATUS_UP;
+		break;
+	case SLI4_LINK_ATTN_TYPE_LINK_DOWN:
+		event.status = SLI_LINK_STATUS_DOWN;
+		break;
+	case SLI4_LINK_ATTN_TYPE_NO_HARD_ALPA:
+		ocs_log_debug(sli4->os, "attn_type: no hard alpa\n");
+		event.status = SLI_LINK_STATUS_NO_ALPA;
+		break;
+	default:
+		ocs_log_test(sli4->os, "attn_type: unknown\n");
+		break;
+	}
+
+	switch (link_attn->event_type) {
+	case SLI4_FC_EVENT_LINK_ATTENTION:
+		break;
+	case SLI4_FC_EVENT_SHARED_LINK_ATTENTION:
+		ocs_log_debug(sli4->os, "event_type: FC shared link event \n");
+		break;
+	default:
+		ocs_log_test(sli4->os, "event_type: unknown\n");
+		break;
+	}
+
+	switch (link_attn->topology) {
+	case SLI4_LINK_ATTN_P2P:
+		event.topology = SLI_LINK_TOPO_NPORT;
+		break;
+	case SLI4_LINK_ATTN_FC_AL:
+		event.topology = SLI_LINK_TOPO_LOOP;
+		break;
+	case SLI4_LINK_ATTN_INTERNAL_LOOPBACK:
+		ocs_log_debug(sli4->os, "topology Internal loopback\n");
+		event.topology = SLI_LINK_TOPO_LOOPBACK_INTERNAL;
+		break;
+	case SLI4_LINK_ATTN_SERDES_LOOPBACK:
+		ocs_log_debug(sli4->os, "topology serdes loopback\n");
+		event.topology = SLI_LINK_TOPO_LOOPBACK_EXTERNAL;
+		break;
+	default:
+		ocs_log_test(sli4->os, "topology: unknown\n");
+		break;
+	}
+
+	event.speed    = link_attn->port_speed * 1000;
+
+	sli4->link(sli4->link_arg, (void *)&event);
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Parse an FC/FCoE work queue CQ entry.
+ *
+ * @param sli4 SLI context.
+ * @param cq CQ to process.
+ * @param cqe Pointer to the CQ entry.
+ * @param etype CQ event type.
+ * @param r_id Resource ID associated with this completion message (such as the IO tag).
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fc_cqe_parse(sli4_t *sli4, sli4_queue_t *cq, uint8_t *cqe, sli4_qentry_e *etype,
+		uint16_t *r_id)
+{
+	uint8_t		code = cqe[SLI4_CQE_CODE_OFFSET];
+	int32_t		rc = -1;
+
+	switch (code) {
+	case SLI4_CQE_CODE_WORK_REQUEST_COMPLETION:
+	{
+		sli4_fc_wcqe_t *wcqe = (void *)cqe;
+
+		*etype = SLI_QENTRY_WQ;
+		*r_id = wcqe->request_tag;
+		rc = wcqe->status;
+
+		/* Flag errors except for FCP_RSP_FAILURE */
+		if (rc && (rc != SLI4_FC_WCQE_STATUS_FCP_RSP_FAILURE)) {
+
+			ocs_log_test(sli4->os, "WCQE: status=%#x hw_status=%#x tag=%#x w1=%#x w2=%#x xb=%d\n",
+				wcqe->status, wcqe->hw_status,
+				wcqe->request_tag, wcqe->wqe_specific_1,
+				wcqe->wqe_specific_2, wcqe->xb);
+			ocs_log_test(sli4->os, "      %08X %08X %08X %08X\n", ((uint32_t*) cqe)[0], ((uint32_t*) cqe)[1],
+				((uint32_t*) cqe)[2], ((uint32_t*) cqe)[3]);
+		}
+
+		/* TODO: need to pass additional status back out of here as well
+		 * as status (could overload rc as status/addlstatus are only 8 bits each)
+		 */
+
+		break;
+	}
+	case SLI4_CQE_CODE_RQ_ASYNC:
+	{
+		sli4_fc_async_rcqe_t *rcqe = (void *)cqe;
+
+		*etype = SLI_QENTRY_RQ;
+		*r_id = rcqe->rq_id;
+		rc = rcqe->status;
+		break;
+	}
+	case SLI4_CQE_CODE_RQ_ASYNC_V1:
+	{
+		sli4_fc_async_rcqe_v1_t *rcqe = (void *)cqe;
+
+		*etype = SLI_QENTRY_RQ;
+		*r_id = rcqe->rq_id;
+		rc = rcqe->status;
+		break;
+	}
+	case SLI4_CQE_CODE_OPTIMIZED_WRITE_CMD:
+	{
+		sli4_fc_optimized_write_cmd_cqe_t *optcqe = (void *)cqe;
+
+		*etype = SLI_QENTRY_OPT_WRITE_CMD;
+		*r_id = optcqe->rq_id;
+		rc = optcqe->status;
+		break;
+	}
+	case SLI4_CQE_CODE_OPTIMIZED_WRITE_DATA:
+	{
+		sli4_fc_optimized_write_data_cqe_t *dcqe = (void *)cqe;
+
+		*etype = SLI_QENTRY_OPT_WRITE_DATA;
+		*r_id = dcqe->xri;
+		rc = dcqe->status;
+
+		/* Flag errors */
+		if (rc != SLI4_FC_WCQE_STATUS_SUCCESS) {
+			ocs_log_test(sli4->os, "Optimized DATA CQE: status=%#x hw_status=%#x xri=%#x dpl=%#x w3=%#x xb=%d\n",
+				dcqe->status, dcqe->hw_status,
+				dcqe->xri, dcqe->total_data_placed,
+				((uint32_t*) cqe)[3], dcqe->xb);
+		}
+		break;
+	}
+	case SLI4_CQE_CODE_RQ_COALESCING:
+	{
+		sli4_fc_coalescing_rcqe_t *rcqe = (void *)cqe;
+
+		*etype = SLI_QENTRY_RQ;
+		*r_id = rcqe->rq_id;
+		rc = rcqe->status;
+		break;
+	}
+	case SLI4_CQE_CODE_XRI_ABORTED:
+	{
+		sli4_fc_xri_aborted_cqe_t *xa = (void *)cqe;
+
+		*etype = SLI_QENTRY_XABT;
+		*r_id = xa->xri;
+		rc = 0;
+		break;
+	}
+	case SLI4_CQE_CODE_RELEASE_WQE: {
+		sli4_fc_wqec_t *wqec = (void*) cqe;
+
+		*etype = SLI_QENTRY_WQ_RELEASE;
+		*r_id = wqec->wq_id;
+		rc = 0;
+		break;
+	}
+	default:
+		ocs_log_test(sli4->os, "CQE completion code %d not handled\n", code);
+		*etype = SLI_QENTRY_MAX;
+		*r_id = UINT16_MAX;
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Return the ELS/CT response length.
+ *
+ * @param sli4 SLI context.
+ * @param cqe Pointer to the CQ entry.
+ *
+ * @return Returns the length, in bytes.
+ */
+uint32_t
+sli_fc_response_length(sli4_t *sli4, uint8_t *cqe)
+{
+	sli4_fc_wcqe_t *wcqe = (void *)cqe;
+
+	return wcqe->wqe_specific_1;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Return the FCP IO length.
+ *
+ * @param sli4 SLI context.
+ * @param cqe Pointer to the CQ entry.
+ *
+ * @return Returns the length, in bytes.
+ */
+uint32_t
+sli_fc_io_length(sli4_t *sli4, uint8_t *cqe)
+{
+	sli4_fc_wcqe_t *wcqe = (void *)cqe;
+
+	return wcqe->wqe_specific_1;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Retrieve the D_ID from the completion.
+ *
+ * @param sli4 SLI context.
+ * @param cqe Pointer to the CQ entry.
+ * @param d_id Pointer where the D_ID is written.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fc_els_did(sli4_t *sli4, uint8_t *cqe, uint32_t *d_id)
+{
+	sli4_fc_wcqe_t *wcqe = (void *)cqe;
+
+	*d_id = 0;
+
+	if (wcqe->status) {
+		return -1;
+	} else {
+		*d_id = wcqe->wqe_specific_2 & 0x00ffffff;
+		return 0;
+	}
+}
+
+uint32_t
+sli_fc_ext_status(sli4_t *sli4, uint8_t *cqe)
+{
+	sli4_fc_wcqe_t *wcqe = (void *)cqe;
+	uint32_t	mask;
+
+	switch (wcqe->status) {
+	case SLI4_FC_WCQE_STATUS_FCP_RSP_FAILURE:
+		mask = UINT32_MAX;
+		break;
+	case SLI4_FC_WCQE_STATUS_LOCAL_REJECT:
+	case SLI4_FC_WCQE_STATUS_CMD_REJECT:
+		mask = 0xff;
+		break;
+	case SLI4_FC_WCQE_STATUS_NPORT_RJT:
+	case SLI4_FC_WCQE_STATUS_FABRIC_RJT:
+	case SLI4_FC_WCQE_STATUS_NPORT_BSY:
+	case SLI4_FC_WCQE_STATUS_FABRIC_BSY:
+	case SLI4_FC_WCQE_STATUS_LS_RJT:
+		mask = UINT32_MAX;
+		break;
+	case SLI4_FC_WCQE_STATUS_DI_ERROR:
+		mask = UINT32_MAX;
+		break;
+	default:
+		mask = 0;
+	}
+
+	return wcqe->wqe_specific_2 & mask;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Retrieve the RQ index from the completion.
+ *
+ * @param sli4 SLI context.
+ * @param cqe Pointer to the CQ entry.
+ * @param rq_id Pointer where the rq_id is written.
+ * @param index Pointer where the index is written.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fc_rqe_rqid_and_index(sli4_t *sli4, uint8_t *cqe, uint16_t *rq_id, uint32_t *index)
+{
+	sli4_fc_async_rcqe_t	*rcqe = (void *)cqe;
+	sli4_fc_async_rcqe_v1_t	*rcqe_v1 = (void *)cqe;
+	int32_t	rc = -1;
+	uint8_t	code = 0;
+
+	*rq_id = 0;
+	*index = UINT32_MAX;
+
+	code = cqe[SLI4_CQE_CODE_OFFSET];
+
+	if (code == SLI4_CQE_CODE_RQ_ASYNC) {
+		*rq_id = rcqe->rq_id;
+		if (SLI4_FC_ASYNC_RQ_SUCCESS == rcqe->status) {
+			*index = rcqe->rq_element_index;
+			rc = 0;
+		} else {
+			*index = rcqe->rq_element_index;
+			rc = rcqe->status;
+			ocs_log_test(sli4->os, "status=%02x (%s) rq_id=%d, index=%x pdpl=%x sof=%02x eof=%02x hdpl=%x\n",
+				rcqe->status, sli_fc_get_status_string(rcqe->status), rcqe->rq_id,
+				rcqe->rq_element_index, rcqe->payload_data_placement_length, rcqe->sof_byte,
+				rcqe->eof_byte, rcqe->header_data_placement_length);
+		}
+	} else if (code == SLI4_CQE_CODE_RQ_ASYNC_V1) {
+		*rq_id = rcqe_v1->rq_id;
+		if (SLI4_FC_ASYNC_RQ_SUCCESS == rcqe_v1->status) {
+			*index = rcqe_v1->rq_element_index;
+			rc = 0;
+		} else {
+			*index = rcqe_v1->rq_element_index;
+			rc = rcqe_v1->status;
+			ocs_log_test(sli4->os, "status=%02x (%s) rq_id=%d, index=%x pdpl=%x sof=%02x eof=%02x hdpl=%x\n",
+				rcqe_v1->status, sli_fc_get_status_string(rcqe_v1->status),
+				rcqe_v1->rq_id, rcqe_v1->rq_element_index,
+				rcqe_v1->payload_data_placement_length, rcqe_v1->sof_byte,
+				rcqe_v1->eof_byte, rcqe_v1->header_data_placement_length);
+		}
+	} else if (code == SLI4_CQE_CODE_OPTIMIZED_WRITE_CMD) {
+		sli4_fc_optimized_write_cmd_cqe_t *optcqe = (void *)cqe;
+
+		*rq_id = optcqe->rq_id;
+		if (SLI4_FC_ASYNC_RQ_SUCCESS == optcqe->status) {
+			*index = optcqe->rq_element_index;
+			rc = 0;
+		} else {
+			*index = optcqe->rq_element_index;
+			rc = optcqe->status;
+			ocs_log_test(sli4->os, "status=%02x (%s) rq_id=%d, index=%x pdpl=%x hdpl=%x oox=%d agxr=%d xri=0x%x rpi=0x%x\n",
+				optcqe->status, sli_fc_get_status_string(optcqe->status), optcqe->rq_id,
+				optcqe->rq_element_index, optcqe->payload_data_placement_length,
+				optcqe->header_data_placement_length, optcqe->oox, optcqe->agxr, optcqe->xri,
+				optcqe->rpi);
+		}
+	} else if (code == SLI4_CQE_CODE_RQ_COALESCING) {
+		sli4_fc_coalescing_rcqe_t	*rcqe = (void *)cqe;
+
+		*rq_id = rcqe->rq_id;
+		if (SLI4_FC_COALESCE_RQ_SUCCESS == rcqe->status) {
+			*index = rcqe->rq_element_index;
+			rc = 0;
+		} else {
+			*index = UINT32_MAX;
+			rc = rcqe->status;
+
+			ocs_log_test(sli4->os, "status=%02x (%s) rq_id=%d, index=%x rq_id=%#x sdpl=%x\n",
+				rcqe->status, sli_fc_get_status_string(rcqe->status), rcqe->rq_id,
+				rcqe->rq_element_index, rcqe->rq_id, rcqe->sequence_reporting_placement_length);
+		}
+	} else {
+		*index = UINT32_MAX;
+
+		rc = rcqe->status;
+
+		ocs_log_debug(sli4->os, "status=%02x rq_id=%d, index=%x pdpl=%x sof=%02x eof=%02x hdpl=%x\n",
+			rcqe->status, rcqe->rq_id, rcqe->rq_element_index, rcqe->payload_data_placement_length,
+			rcqe->sof_byte, rcqe->eof_byte, rcqe->header_data_placement_length);
+	}
+
+	return rc;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Process an asynchronous FCoE event entry.
+ *
+ * @par Description
+ * Parses Asynchronous Completion Queue Entry (ACQE),
+ * creates an abstracted event, and calls the registered callback functions.
+ *
+ * @param sli4 SLI context.
+ * @param acqe Pointer to the ACQE.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+int32_t
+sli_fc_process_fcoe(sli4_t *sli4, void *acqe)
+{
+	sli4_fcoe_fip_t	*fcoe = acqe;
+	sli4_fip_event_t event = { 0 };
+	uint32_t	mask = UINT32_MAX;
+
+	ocs_log_debug(sli4->os, "ACQE FCoE FIP type=%02x count=%d tag=%#x\n",
+			fcoe->event_type,
+			fcoe->fcf_count,
+			fcoe->event_tag);
+
+	if (!sli4->fip) {
+		return 0;
+	}
+
+	event.type = fcoe->event_type;
+	event.index = UINT32_MAX;
+
+	switch (fcoe->event_type) {
+	case SLI4_FCOE_FIP_FCF_DISCOVERED:
+		ocs_log_debug(sli4->os, "FCF Discovered index=%d\n", fcoe->event_information);
+		break;
+	case SLI4_FCOE_FIP_FCF_TABLE_FULL:
+		ocs_log_debug(sli4->os, "FCF Table Full\n");
+		mask = 0;
+		break;
+	case SLI4_FCOE_FIP_FCF_DEAD:
+		ocs_log_debug(sli4->os, "FCF Dead/Gone index=%d\n", fcoe->event_information);
+		break;
+	case SLI4_FCOE_FIP_FCF_CLEAR_VLINK:
+		mask = UINT16_MAX;
+		ocs_log_debug(sli4->os, "Clear VLINK Received VPI=%#x\n", fcoe->event_information & mask);
+		break;
+	case SLI4_FCOE_FIP_FCF_MODIFIED:
+		ocs_log_debug(sli4->os, "FCF Modified\n");
+		break;
+	default:
+		ocs_log_test(sli4->os, "bad FCoE type %#x", fcoe->event_type);
+		mask = 0;
+	}
+
+	if (mask != 0) {
+		event.index = fcoe->event_information & mask;
+	}
+
+	sli4->fip(sli4->fip_arg, &event);
+
+	return 0;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Allocate a receive queue.
+ *
+ * @par Description
+ * Allocates DMA memory and configures the requested queue type.
+ *
+ * @param sli4 SLI context.
+ * @param q Pointer to the queue object for the header.
+ * @param n_entries Number of entries to allocate.
+ * @param buffer_size buffer size for the queue.
+ * @param cq Associated CQ.
+ * @param ulp The ULP to bind
+ * @param is_hdr Used to validate the rq_id and set the type of queue
+ *
+ * @return Returns 0 on success, or -1 on failure.
+ */
+int32_t
+sli_fc_rq_alloc(sli4_t *sli4, sli4_queue_t *q,
+		uint32_t n_entries, uint32_t buffer_size,
+		sli4_queue_t *cq, uint16_t ulp, uint8_t is_hdr)
+{
+	int32_t (*rq_create)(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, uint16_t, uint16_t);
+
+	if ((sli4 == NULL) || (q == NULL)) {
+		void *os = sli4 != NULL ? sli4->os : NULL;
+
+		ocs_log_err(os, "bad parameter sli4=%p q=%p\n", sli4, q);
+		return -1;
+	}
+
+	if (__sli_queue_init(sli4, q, SLI_QTYPE_RQ, SLI4_FCOE_RQE_SIZE,
+				n_entries, SLI_PAGE_SIZE)) {
+		return -1;
+	}
+
+	if (sli4->if_type == SLI4_IF_TYPE_BE3_SKH_PF) {
+		rq_create = sli_cmd_fcoe_rq_create;
+	} else {
+		rq_create = sli_cmd_fcoe_rq_create_v1;
+	}
+
+	if (rq_create(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE, &q->dma,
+		      cq->id, ulp, buffer_size)) {
+		if (__sli_create_queue(sli4, q)) {
+			ocs_dma_free(sli4->os, &q->dma);
+			return -1;
+		}
+		if (is_hdr && q->id & 1) {
+			ocs_log_test(sli4->os, "bad header RQ_ID %d\n", q->id);
+			ocs_dma_free(sli4->os, &q->dma);
+			return -1;
+		} else if (!is_hdr  && (q->id & 1) == 0) {
+			ocs_log_test(sli4->os, "bad data RQ_ID %d\n", q->id);
+			ocs_dma_free(sli4->os, &q->dma);
+			return -1;
+		}
+	} else {
+		return -1;
+	}
+	q->u.flag.is_hdr = is_hdr;
+	if (SLI4_IF_TYPE_BE3_SKH_PF == sli4->if_type) {
+		q->u.flag.rq_batch = TRUE;
+	}
+	return 0;
+}
+
+
+/**
+ * @ingroup sli_fc
+ * @brief Allocate a receive queue set.
+ *
+ * @param sli4 SLI context.
+ * @param num_rq_pairs to create
+ * @param qs Pointers to the queue objects for both header and data.
+ *	Length of this arrays should be 2 * num_rq_pairs
+ * @param base_cq_id. Assumes base_cq_id : (base_cq_id + num_rq_pairs) cqs as allotted.
+ * @param n_entries number of entries in each RQ queue.
+ * @param header_buffer_size
+ * @param payload_buffer_size
+ * @param ulp The ULP to bind
+ *
+ * @return Returns 0 on success, or -1 on failure.
+ */
+int32_t
+sli_fc_rq_set_alloc(sli4_t *sli4, uint32_t num_rq_pairs,
+		    sli4_queue_t *qs[], uint32_t base_cq_id,
+		    uint32_t n_entries, uint32_t header_buffer_size,
+		    uint32_t payload_buffer_size,  uint16_t ulp)
+{
+	uint32_t i, p, offset = 0;
+	uint32_t payload_size, total_page_count = 0;
+	uintptr_t addr;
+	ocs_dma_t dma;
+	sli4_res_common_create_queue_set_t *rsp = NULL;
+	sli4_req_fcoe_rq_create_v2_t    *req = NULL;
+
+	for (i = 0; i < (num_rq_pairs * 2); i++) {
+		if (__sli_queue_init(sli4, qs[i], SLI_QTYPE_RQ, SLI4_FCOE_RQE_SIZE,
+					n_entries, SLI_PAGE_SIZE)) {
+			goto error;
+		}
+	}
+
+	total_page_count = sli_page_count(qs[0]->dma.size, SLI_PAGE_SIZE) * num_rq_pairs * 2;
+
+	/* Payload length must accommodate both request and response */
+	payload_size = max((sizeof(sli4_req_fcoe_rq_create_v1_t) + (8 * total_page_count)),
+			 sizeof(sli4_res_common_create_queue_set_t));
+
+	if (ocs_dma_alloc(sli4->os, &dma, payload_size, SLI_PAGE_SIZE)) {
+		ocs_log_err(sli4->os, "DMA allocation failed\n");
+		goto error;
+	}
+	ocs_memset(dma.virt, 0, payload_size);
+
+	if (sli_cmd_sli_config(sli4, sli4->bmbx.virt, SLI4_BMBX_SIZE,
+			payload_size, &dma) == -1) {
+		goto error;
+	}
+	req = (sli4_req_fcoe_rq_create_v2_t *)((uint8_t *)dma.virt);
+
+	/* Fill Header fields */
+	req->hdr.opcode    = SLI4_OPC_FCOE_RQ_CREATE;
+	req->hdr.subsystem = SLI4_SUBSYSTEM_FCFCOE;
+	req->hdr.version   = 2;
+	req->hdr.request_length = sizeof(sli4_req_fcoe_rq_create_v2_t) - sizeof(sli4_req_hdr_t)
+					+ (8 * total_page_count);
+
+	/* Fill Payload fields */
+	req->dnb           = TRUE;
+	req->num_pages     = sli_page_count(qs[0]->dma.size, SLI_PAGE_SIZE);
+	req->rqe_count     = qs[0]->dma.size / SLI4_FCOE_RQE_SIZE;
+	req->rqe_size      = SLI4_FCOE_RQE_SIZE_8;
+	req->page_size     = SLI4_FCOE_RQ_PAGE_SIZE_4096;
+	req->rq_count      = num_rq_pairs * 2;
+	req->base_cq_id    = base_cq_id;
+	req->hdr_buffer_size     = header_buffer_size;
+	req->payload_buffer_size = payload_buffer_size;
+
+	for (i = 0; i < (num_rq_pairs * 2); i++) {
+		for (p = 0, addr = qs[i]->dma.phys; p < req->num_pages; p++, addr += SLI_PAGE_SIZE) {
+			req->page_physical_address[offset].low  = ocs_addr32_lo(addr);
+			req->page_physical_address[offset].high = ocs_addr32_hi(addr);
+			offset++;
+		}
+	}
+
+	if (sli_bmbx_command(sli4)){
+		ocs_log_crit(sli4->os, "bootstrap mailbox write faild RQSet\n");
+		goto error;
+	}
+
+
+	rsp = (void *)((uint8_t *)dma.virt);
+	if (rsp->hdr.status) {
+		ocs_log_err(sli4->os, "bad create RQSet status=%#x addl=%#x\n",
+			rsp->hdr.status, rsp->hdr.additional_status);
+		goto error;
+	} else {
+		for (i = 0; i < (num_rq_pairs * 2); i++) {
+			qs[i]->id = i + rsp->q_id;
+			if ((qs[i]->id & 1) == 0) {
+				qs[i]->u.flag.is_hdr = TRUE;
+			} else {
+				qs[i]->u.flag.is_hdr = FALSE;
+			}
+			qs[i]->doorbell_offset = regmap[SLI4_REG_FCOE_RQ_DOORBELL][sli4->if_type].off;
+			qs[i]->doorbell_rset = regmap[SLI4_REG_FCOE_RQ_DOORBELL][sli4->if_type].rset;
+		}
+	}
+
+	ocs_dma_free(sli4->os, &dma);
+
+	return 0;
+
+error:
+	for (i = 0; i < (num_rq_pairs * 2); i++) {
+		if (qs[i]->dma.size) {
+			ocs_dma_free(sli4->os, &qs[i]->dma);
+		}
+	}
+
+	if (dma.size) {
+		ocs_dma_free(sli4->os, &dma);
+	}
+
+	return -1;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Get the RPI resource requirements.
+ *
+ * @param sli4 SLI context.
+ * @param n_rpi Number of RPIs desired.
+ *
+ * @return Returns the number of bytes needed. This value may be zero.
+ */
+uint32_t
+sli_fc_get_rpi_requirements(sli4_t *sli4, uint32_t n_rpi)
+{
+	uint32_t	bytes = 0;
+
+	/* Check if header templates needed */
+	if (sli4->config.hdr_template_req) {
+		/* round up to a page */
+		bytes = SLI_ROUND_PAGE(n_rpi * SLI4_FCOE_HDR_TEMPLATE_SIZE);
+	}
+
+	return bytes;
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Return a text string corresponding to a CQE status value
+ *
+ * @param status Status value
+ *
+ * @return Returns corresponding string, otherwise "unknown"
+ */
+const char *
+sli_fc_get_status_string(uint32_t status)
+{
+	static struct {
+		uint32_t code;
+		const char *label;
+	} lookup[] = {
+		{SLI4_FC_WCQE_STATUS_SUCCESS,			"SUCCESS"},
+		{SLI4_FC_WCQE_STATUS_FCP_RSP_FAILURE,		"FCP_RSP_FAILURE"},
+		{SLI4_FC_WCQE_STATUS_REMOTE_STOP,		"REMOTE_STOP"},
+		{SLI4_FC_WCQE_STATUS_LOCAL_REJECT,		"LOCAL_REJECT"},
+		{SLI4_FC_WCQE_STATUS_NPORT_RJT,			"NPORT_RJT"},
+		{SLI4_FC_WCQE_STATUS_FABRIC_RJT,		"FABRIC_RJT"},
+		{SLI4_FC_WCQE_STATUS_NPORT_BSY,			"NPORT_BSY"},
+		{SLI4_FC_WCQE_STATUS_FABRIC_BSY,		"FABRIC_BSY"},
+		{SLI4_FC_WCQE_STATUS_LS_RJT,			"LS_RJT"},
+		{SLI4_FC_WCQE_STATUS_CMD_REJECT,		"CMD_REJECT"},
+		{SLI4_FC_WCQE_STATUS_FCP_TGT_LENCHECK,		"FCP_TGT_LENCHECK"},
+		{SLI4_FC_WCQE_STATUS_RQ_BUF_LEN_EXCEEDED,	"BUF_LEN_EXCEEDED"},
+		{SLI4_FC_WCQE_STATUS_RQ_INSUFF_BUF_NEEDED,	"RQ_INSUFF_BUF_NEEDED"},
+		{SLI4_FC_WCQE_STATUS_RQ_INSUFF_FRM_DISC,	"RQ_INSUFF_FRM_DESC"},
+		{SLI4_FC_WCQE_STATUS_RQ_DMA_FAILURE,		"RQ_DMA_FAILURE"},
+		{SLI4_FC_WCQE_STATUS_FCP_RSP_TRUNCATE,		"FCP_RSP_TRUNCATE"},
+		{SLI4_FC_WCQE_STATUS_DI_ERROR,			"DI_ERROR"},
+		{SLI4_FC_WCQE_STATUS_BA_RJT,			"BA_RJT"},
+		{SLI4_FC_WCQE_STATUS_RQ_INSUFF_XRI_NEEDED,	"RQ_INSUFF_XRI_NEEDED"},
+		{SLI4_FC_WCQE_STATUS_RQ_INSUFF_XRI_DISC,	"INSUFF_XRI_DISC"},
+		{SLI4_FC_WCQE_STATUS_RX_ERROR_DETECT,		"RX_ERROR_DETECT"},
+		{SLI4_FC_WCQE_STATUS_RX_ABORT_REQUEST,		"RX_ABORT_REQUEST"},
+		};
+	uint32_t i;
+
+	for (i = 0; i < ARRAY_SIZE(lookup); i++) {
+		if (status == lookup[i].code) {
+			return lookup[i].label;
+		}
+	}
+	return "unknown";
+}
diff --git a/sys/dev/ocs_fc/sli4.h b/sys/dev/ocs_fc/sli4.h
new file mode 100644
index 000000000000..04d50353dd51
--- /dev/null
+++ b/sys/dev/ocs_fc/sli4.h
@@ -0,0 +1,5609 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/**
+ * @file
+ * Define common SLI-4 structures and function prototypes.
+ */
+
+#ifndef _SLI4_H
+#define _SLI4_H
+
+#include "ocs_os.h"
+
+#define SLI_PAGE_SIZE		(4096)
+#define SLI_SUB_PAGE_MASK	(SLI_PAGE_SIZE - 1)
+#define SLI_PAGE_SHIFT		12
+#define SLI_ROUND_PAGE(b)	(((b) + SLI_SUB_PAGE_MASK) & ~SLI_SUB_PAGE_MASK)
+
+#define SLI4_BMBX_TIMEOUT_MSEC		30000
+#define SLI4_FW_READY_TIMEOUT_MSEC	30000
+
+static inline uint32_t
+sli_page_count(size_t bytes, uint32_t page_size)
+{
+	uint32_t	mask = page_size - 1;
+	uint32_t	shift = 0;
+
+	switch (page_size) {
+	case 4096:
+		shift = 12;
+		break;
+	case 8192:
+		shift = 13;
+		break;
+	case 16384:
+		shift = 14;
+		break;
+	case 32768:
+		shift = 15;
+		break;
+	case 65536:
+		shift = 16;
+		break;
+	default:
+		return 0;
+	}
+
+	return (bytes + mask) >> shift;
+}
+
+/*************************************************************************
+ * Common PCI configuration space register definitions
+ */
+
+#define SLI4_PCI_CLASS_REVISION		0x0008	/** register offset */
+#define SLI4_PCI_REV_ID_SHIFT			0
+#define SLI4_PCI_REV_ID_MASK			0xff
+#define SLI4_PCI_CLASS_SHIFT			8
+#define SLI4_PCI_CLASS_MASK			0xfff
+
+#define SLI4_PCI_SOFT_RESET_CSR		0x005c	/** register offset */
+#define SLI4_PCI_SOFT_RESET_MASK		0x0080
+
+/*************************************************************************
+ * Common SLI-4 register offsets and field definitions
+ */
+
+/**
+ * @brief SLI_INTF - SLI Interface Definition Register
+ */
+#define SLI4_INTF_REG			0x0058	/** register offset */
+#define SLI4_INTF_VALID_SHIFT			29
+#define SLI4_INTF_VALID_MASK			0x7
+#define SLI4_INTF_VALID				0x6
+#define SLI4_INTF_IF_TYPE_SHIFT			12
+#define SLI4_INTF_IF_TYPE_MASK			0xf
+#define SLI4_INTF_SLI_FAMILY_SHIFT		8
+#define SLI4_INTF_SLI_FAMILY_MASK		0xf
+#define SLI4_INTF_SLI_REVISION_SHIFT		4
+#define SLI4_INTF_SLI_REVISION_MASK		0xf
+#define SLI4_FAMILY_CHECK_ASIC_TYPE		0xf
+
+#define SLI4_IF_TYPE_BE3_SKH_PF		0
+#define SLI4_IF_TYPE_BE3_SKH_VF		1
+#define SLI4_IF_TYPE_LANCER_FC_ETH	2
+#define SLI4_IF_TYPE_LANCER_RDMA	3
+#define SLI4_MAX_IF_TYPES		4
+
+/**
+ * @brief ASIC_ID - SLI ASIC Type and Revision Register
+ */
+#define SLI4_ASIC_ID_REG			0x009c /* register offset */
+#define SLI4_ASIC_REV_SHIFT			0
+#define SLI4_ASIC_REV_MASK			0xf
+#define SLI4_ASIC_VER_SHIFT			4
+#define SLI4_ASIC_VER_MASK			0xf
+#define SLI4_ASIC_GEN_SHIFT			8
+#define SLI4_ASIC_GEN_MASK			0xff
+#define SLI4_ASIC_GEN_BE2			0x00
+#define SLI4_ASIC_GEN_BE3			0x03
+#define SLI4_ASIC_GEN_SKYHAWK			0x04
+#define SLI4_ASIC_GEN_CORSAIR			0x05
+#define SLI4_ASIC_GEN_LANCER			0x0b
+
+
+/**
+ * @brief BMBX - Bootstrap Mailbox Register
+ */
+#define SLI4_BMBX_REG			0x0160	/* register offset */
+#define SLI4_BMBX_MASK_HI			0x3
+#define SLI4_BMBX_MASK_LO			0xf
+#define SLI4_BMBX_RDY				BIT(0)
+#define SLI4_BMBX_HI				BIT(1)
+#define SLI4_BMBX_WRITE_HI(r)			((ocs_addr32_hi(r) & ~SLI4_BMBX_MASK_HI) | \
+								SLI4_BMBX_HI)
+#define SLI4_BMBX_WRITE_LO(r)			(((ocs_addr32_hi(r) & SLI4_BMBX_MASK_HI) << 30) | \
+								(((r) & ~SLI4_BMBX_MASK_LO) >> 2))
+
+#define SLI4_BMBX_SIZE			256
+
+
+/**
+ * @brief EQCQ_DOORBELL - EQ and CQ Doorbell Register
+ */
+#define SLI4_EQCQ_DOORBELL_REG		0x120
+#define SLI4_EQCQ_DOORBELL_CI			BIT(9)
+#define SLI4_EQCQ_DOORBELL_QT			BIT(10)
+#define SLI4_EQCQ_DOORBELL_ARM			BIT(29)
+#define SLI4_EQCQ_DOORBELL_SE			BIT(31)
+#define SLI4_EQCQ_NUM_SHIFT			16
+#define SLI4_EQCQ_NUM_MASK			0x01ff
+#define SLI4_EQCQ_EQ_ID_MASK			0x3fff
+#define SLI4_EQCQ_CQ_ID_MASK			0x7fff
+#define SLI4_EQCQ_EQ_ID_MASK_LO			0x01ff
+#define SLI4_EQCQ_CQ_ID_MASK_LO			0x03ff
+#define SLI4_EQCQ_EQCQ_ID_MASK_HI		0xf800
+
+/**
+ * @brief SLIPORT_CONTROL - SLI Port Control Register
+ */
+#define SLI4_SLIPORT_CONTROL_REG	0x0408
+#define SLI4_SLIPORT_CONTROL_END		BIT(30)
+#define SLI4_SLIPORT_CONTROL_LITTLE_ENDIAN	(0)
+#define SLI4_SLIPORT_CONTROL_BIG_ENDIAN		BIT(30)
+#define SLI4_SLIPORT_CONTROL_IP			BIT(27)
+#define SLI4_SLIPORT_CONTROL_IDIS		BIT(22)
+#define SLI4_SLIPORT_CONTROL_FDD		BIT(31)
+
+/**
+ * @brief SLI4_SLIPORT_ERROR1 - SLI Port Error Register
+ */
+#define SLI4_SLIPORT_ERROR1		0x040c
+
+/**
+ * @brief SLI4_SLIPORT_ERROR2 - SLI Port Error Register
+ */
+#define SLI4_SLIPORT_ERROR2		0x0410
+
+/**
+ * @brief User error registers
+ */
+#define SLI4_UERR_STATUS_LOW_REG		0xA0
+#define SLI4_UERR_STATUS_HIGH_REG		0xA4
+#define SLI4_UERR_MASK_LOW_REG			0xA8
+#define SLI4_UERR_MASK_HIGH_REG			0xAC
+
+/**
+ * @brief Registers for generating software UE (BE3)
+ */
+#define SLI4_SW_UE_CSR1			0x138
+#define SLI4_SW_UE_CSR2			0x1FFFC
+
+/**
+ * @brief Registers for generating software UE (Skyhawk)
+ */
+#define SLI4_SW_UE_REG			0x5C 	/* register offset */
+
+static inline uint32_t sli_eq_doorbell(uint16_t n_popped, uint16_t id, uint8_t arm)
+{
+	uint32_t	reg = 0;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	struct {
+		uint32_t	eq_id_lo:9,
+				ci:1,			/* clear interrupt */
+				qt:1,			/* queue type */
+				eq_id_hi:5,
+				number_popped:13,
+				arm:1,
+				:1,
+				se:1;
+	} * eq_doorbell = (void *)&reg;
+#else
+#error big endian version not defined
+#endif
+
+	eq_doorbell->eq_id_lo = id & SLI4_EQCQ_EQ_ID_MASK_LO;
+	eq_doorbell->qt = 1;	/* EQ is type 1 (section 2.2.3.3 SLI Arch) */
+	eq_doorbell->eq_id_hi = (id >> 9) & 0x1f;
+	eq_doorbell->number_popped = n_popped;
+	eq_doorbell->arm = arm;
+	eq_doorbell->ci = TRUE;
+
+	return reg;
+}
+
+static inline uint32_t sli_cq_doorbell(uint16_t n_popped, uint16_t id, uint8_t arm)
+{
+	uint32_t	reg = 0;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	struct {
+		uint32_t	cq_id_lo:10,
+				qt:1,			/* queue type */
+				cq_id_hi:5,
+				number_popped:13,
+				arm:1,
+				:1,
+				se:1;
+	} * cq_doorbell = (void *)&reg;
+#else
+#error big endian version not defined
+#endif
+
+	cq_doorbell->cq_id_lo = id & SLI4_EQCQ_CQ_ID_MASK_LO;
+	cq_doorbell->qt = 0;	/* CQ is type 0 (section 2.2.3.3 SLI Arch) */
+	cq_doorbell->cq_id_hi = (id >> 10) & 0x1f;
+	cq_doorbell->number_popped = n_popped;
+	cq_doorbell->arm = arm;
+
+	return reg;
+}
+
+/**
+ * @brief MQ_DOORBELL - MQ Doorbell Register
+ */
+#define SLI4_MQ_DOORBELL_REG		0x0140	/* register offset */
+#define SLI4_MQ_DOORBELL_NUM_SHIFT		16
+#define SLI4_MQ_DOORBELL_NUM_MASK		0x3fff
+#define SLI4_MQ_DOORBELL_ID_MASK		0xffff
+#define SLI4_MQ_DOORBELL(n, i)			((((n) & SLI4_MQ_DOORBELL_NUM_MASK) << SLI4_MQ_DOORBELL_NUM_SHIFT) | \
+						  ((i) & SLI4_MQ_DOORBELL_ID_MASK))
+
+/**
+ * @brief RQ_DOORBELL - RQ Doorbell Register
+ */
+#define SLI4_RQ_DOORBELL_REG		0x0a0	/* register offset */
+#define SLI4_RQ_DOORBELL_NUM_SHIFT		16
+#define SLI4_RQ_DOORBELL_NUM_MASK		0x3fff
+#define SLI4_RQ_DOORBELL_ID_MASK		0xffff
+#define SLI4_RQ_DOORBELL(n, i)			((((n) & SLI4_RQ_DOORBELL_NUM_MASK) << SLI4_RQ_DOORBELL_NUM_SHIFT) | \
+						  ((i) & SLI4_RQ_DOORBELL_ID_MASK))
+
+/**
+ * @brief WQ_DOORBELL - WQ Doorbell Register
+ */
+#define SLI4_IO_WQ_DOORBELL_REG		0x040	/* register offset */
+#define SLI4_WQ_DOORBELL_IDX_SHIFT		16
+#define SLI4_WQ_DOORBELL_IDX_MASK		0x00ff
+#define SLI4_WQ_DOORBELL_NUM_SHIFT		24
+#define SLI4_WQ_DOORBELL_NUM_MASK		0x00ff
+#define SLI4_WQ_DOORBELL_ID_MASK		0xffff
+#define SLI4_WQ_DOORBELL(n, x, i)		((((n) & SLI4_WQ_DOORBELL_NUM_MASK) << SLI4_WQ_DOORBELL_NUM_SHIFT) | \
+						 (((x) & SLI4_WQ_DOORBELL_IDX_MASK) << SLI4_WQ_DOORBELL_IDX_SHIFT) | \
+						  ((i) & SLI4_WQ_DOORBELL_ID_MASK))
+
+/**
+ * @brief SLIPORT_SEMAPHORE - SLI Port Host and Port Status Register
+ */
+#define SLI4_PORT_SEMAPHORE_REG_0	0x00ac	/** register offset Interface Type 0 + 1 */
+#define SLI4_PORT_SEMAPHORE_REG_1	0x0180	/** register offset Interface Type 0 + 1 */
+#define SLI4_PORT_SEMAPHORE_REG_23	0x0400	/** register offset Interface Type 2 + 3 */
+#define SLI4_PORT_SEMAPHORE_PORT_MASK		0x0000ffff
+#define SLI4_PORT_SEMAPHORE_PORT(r)		((r) & SLI4_PORT_SEMAPHORE_PORT_MASK)
+#define SLI4_PORT_SEMAPHORE_HOST_MASK		0x00ff0000
+#define SLI4_PORT_SEMAPHORE_HOST_SHIFT		16
+#define SLI4_PORT_SEMAPHORE_HOST(r)		(((r) & SLI4_PORT_SEMAPHORE_HOST_MASK) >> \
+								SLI4_PORT_SEMAPHORE_HOST_SHIFT)
+#define SLI4_PORT_SEMAPHORE_SCR2		BIT(26)	/** scratch area 2 */
+#define SLI4_PORT_SEMAPHORE_SCR1		BIT(27)	/** scratch area 1 */
+#define SLI4_PORT_SEMAPHORE_IPC			BIT(28)	/** IP conflict */
+#define SLI4_PORT_SEMAPHORE_NIP			BIT(29)	/** no IP address */
+#define SLI4_PORT_SEMAPHORE_SFI			BIT(30)	/** secondary firmware image used */
+#define SLI4_PORT_SEMAPHORE_PERR		BIT(31)	/** POST fatal error */
+
+#define SLI4_PORT_SEMAPHORE_STATUS_POST_READY	0xc000
+#define SLI4_PORT_SEMAPHORE_STATUS_UNRECOV_ERR	0xf000
+#define SLI4_PORT_SEMAPHORE_STATUS_ERR_MASK	0xf000
+#define SLI4_PORT_SEMAPHORE_IN_ERR(r)		(SLI4_PORT_SEMAPHORE_STATUS_UNRECOV_ERR == ((r) & \
+								SLI4_PORT_SEMAPHORE_STATUS_ERR_MASK))
+
+/**
+ * @brief SLIPORT_STATUS - SLI Port Status Register
+ */
+
+#define SLI4_PORT_STATUS_REG_23		0x0404	/** register offset Interface Type 2 + 3 */
+#define SLI4_PORT_STATUS_FDP			BIT(21)	/** function specific dump present */
+#define SLI4_PORT_STATUS_RDY			BIT(23)	/** ready */
+#define SLI4_PORT_STATUS_RN			BIT(24)	/** reset needed */
+#define SLI4_PORT_STATUS_DIP			BIT(25)	/** dump present */
+#define SLI4_PORT_STATUS_OTI			BIT(29) /** over temp indicator */
+#define SLI4_PORT_STATUS_END			BIT(30)	/** endianness */
+#define SLI4_PORT_STATUS_ERR			BIT(31)	/** SLI port error */
+#define SLI4_PORT_STATUS_READY(r)		((r) & SLI4_PORT_STATUS_RDY)
+#define SLI4_PORT_STATUS_ERROR(r)		((r) & SLI4_PORT_STATUS_ERR)
+#define SLI4_PORT_STATUS_DUMP_PRESENT(r)	((r) & SLI4_PORT_STATUS_DIP)
+#define SLI4_PORT_STATUS_FDP_PRESENT(r)		((r) & SLI4_PORT_STATUS_FDP)
+
+
+#define SLI4_PHSDEV_CONTROL_REG_23		0x0414	/** register offset Interface Type 2 + 3 */
+#define SLI4_PHYDEV_CONTROL_DRST		BIT(0)	/** physical device reset */
+#define SLI4_PHYDEV_CONTROL_FRST		BIT(1)	/** firmware reset */
+#define SLI4_PHYDEV_CONTROL_DD			BIT(2)	/** diagnostic dump */
+#define SLI4_PHYDEV_CONTROL_FRL_MASK		0x000000f0
+#define SLI4_PHYDEV_CONTROL_FRL_SHIFT		4
+#define SLI4_PHYDEV_CONTROL_FRL(r)		(((r) & SLI4_PHYDEV_CONTROL_FRL_MASK) >> \
+								SLI4_PHYDEV_CONTROL_FRL_SHIFT_SHIFT)
+
+/*************************************************************************
+ * SLI-4 mailbox command formats and definitions
+ */
+
+typedef struct sli4_mbox_command_header_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:8,
+			command:8,
+			status:16;	/** Port writes to indicate success / fail */
+#else
+#error big endian version not defined
+#endif
+} sli4_mbox_command_header_t;
+
+#define SLI4_MBOX_COMMAND_CONFIG_LINK	0x07
+#define SLI4_MBOX_COMMAND_DUMP		0x17
+#define SLI4_MBOX_COMMAND_DOWN_LINK	0x06
+#define SLI4_MBOX_COMMAND_INIT_LINK	0x05
+#define SLI4_MBOX_COMMAND_INIT_VFI	0xa3
+#define SLI4_MBOX_COMMAND_INIT_VPI	0xa4
+#define SLI4_MBOX_COMMAND_POST_XRI	0xa7
+#define SLI4_MBOX_COMMAND_RELEASE_XRI	0xac
+#define SLI4_MBOX_COMMAND_READ_CONFIG	0x0b
+#define SLI4_MBOX_COMMAND_READ_STATUS	0x0e
+#define SLI4_MBOX_COMMAND_READ_NVPARMS	0x02
+#define SLI4_MBOX_COMMAND_READ_REV	0x11
+#define SLI4_MBOX_COMMAND_READ_LNK_STAT	0x12
+#define SLI4_MBOX_COMMAND_READ_SPARM64	0x8d
+#define SLI4_MBOX_COMMAND_READ_TOPOLOGY	0x95
+#define SLI4_MBOX_COMMAND_REG_FCFI	0xa0
+#define SLI4_MBOX_COMMAND_REG_FCFI_MRQ	0xaf
+#define SLI4_MBOX_COMMAND_REG_RPI	0x93
+#define SLI4_MBOX_COMMAND_REG_RX_RQ	0xa6
+#define SLI4_MBOX_COMMAND_REG_VFI	0x9f
+#define SLI4_MBOX_COMMAND_REG_VPI	0x96
+#define SLI4_MBOX_COMMAND_REQUEST_FEATURES 0x9d
+#define SLI4_MBOX_COMMAND_SLI_CONFIG	0x9b
+#define SLI4_MBOX_COMMAND_UNREG_FCFI	0xa2
+#define SLI4_MBOX_COMMAND_UNREG_RPI	0x14
+#define SLI4_MBOX_COMMAND_UNREG_VFI	0xa1
+#define SLI4_MBOX_COMMAND_UNREG_VPI	0x97
+#define SLI4_MBOX_COMMAND_WRITE_NVPARMS	0x03
+#define SLI4_MBOX_COMMAND_CONFIG_AUTO_XFER_RDY	0xAD
+#define SLI4_MBOX_COMMAND_CONFIG_AUTO_XFER_RDY_HP       0xAE
+
+#define SLI4_MBOX_STATUS_SUCCESS	0x0000
+#define SLI4_MBOX_STATUS_FAILURE	0x0001
+#define SLI4_MBOX_STATUS_RPI_NOT_REG	0x1400
+
+/**
+ * @brief Buffer Descriptor Entry (BDE)
+ */
+typedef struct sli4_bde_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	buffer_length:24,
+			bde_type:8;
+	union {
+		struct {
+			uint32_t	buffer_address_low;
+			uint32_t	buffer_address_high;
+		} data;
+		struct {
+			uint32_t	offset;
+			uint32_t	rsvd2;
+		} imm;
+		struct {
+			uint32_t	sgl_segment_address_low;
+			uint32_t	sgl_segment_address_high;
+		} blp;
+	} u;
+#else
+#error big endian version not defined
+#endif
+} sli4_bde_t;
+
+#define SLI4_BDE_TYPE_BDE_64		0x00	/** Generic 64-bit data */
+#define SLI4_BDE_TYPE_BDE_IMM		0x01	/** Immediate data */
+#define SLI4_BDE_TYPE_BLP		0x40	/** Buffer List Pointer */
+
+/**
+ * @brief Scatter-Gather Entry (SGE)
+ */
+typedef struct sli4_sge_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	buffer_address_high;
+	uint32_t	buffer_address_low;
+	uint32_t	data_offset:27,
+			sge_type:4,
+			last:1;
+	uint32_t	buffer_length;
+#else
+#error big endian version not defined
+#endif
+} sli4_sge_t;
+
+/**
+ * @brief T10 DIF Scatter-Gather Entry (SGE)
+ */
+typedef struct sli4_dif_sge_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	buffer_address_high;
+	uint32_t	buffer_address_low;
+	uint32_t	:27,
+			sge_type:4,
+			last:1;
+	uint32_t	:32;
+#else
+#error big endian version not defined
+#endif
+} sli4_dif_sge_t;
+
+/**
+ * @brief T10 DIF Seed Scatter-Gather Entry (SGE)
+ */
+typedef struct sli4_diseed_sge_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	ref_tag_cmp;
+	uint32_t	ref_tag_repl;
+	uint32_t	app_tag_repl:16,
+			:2,
+			hs:1,
+			ws:1,
+			ic:1,
+			ics:1,
+			atrt:1,
+			at:1,
+			fwd_app_tag:1,
+			repl_app_tag:1,
+			head_insert:1,
+			sge_type:4,
+			last:1;
+	uint32_t	app_tag_cmp:16,
+			dif_blk_size:3,
+			auto_incr_ref_tag:1,
+			check_app_tag:1,
+			check_ref_tag:1,
+			check_crc:1,
+			new_ref_tag:1,
+			dif_op_rx:4,
+			dif_op_tx:4;
+#else
+#error big endian version not defined
+#endif
+} sli4_diseed_sge_t;
+
+/**
+ * @brief List Segment Pointer Scatter-Gather Entry (SGE)
+ */
+typedef struct sli4_lsp_sge_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	buffer_address_high;
+	uint32_t	buffer_address_low;
+	uint32_t	:27,
+			sge_type:4,
+			last:1;
+	uint32_t	segment_length:24,
+			:8;
+#else
+#error big endian version not defined
+#endif
+} sli4_lsp_sge_t;
+
+#define SLI4_SGE_MAX_RESERVED			3
+
+#define SLI4_SGE_DIF_OP_IN_NODIF_OUT_CRC     0x00
+#define SLI4_SGE_DIF_OP_IN_CRC_OUT_NODIF     0x01
+#define SLI4_SGE_DIF_OP_IN_NODIF_OUT_CHKSUM  0x02
+#define SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_NODIF  0x03
+#define SLI4_SGE_DIF_OP_IN_CRC_OUT_CRC       0x04
+#define SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CHKSUM 0x05
+#define SLI4_SGE_DIF_OP_IN_CRC_OUT_CHKSUM    0x06
+#define SLI4_SGE_DIF_OP_IN_CHKSUM_OUT_CRC    0x07
+#define SLI4_SGE_DIF_OP_IN_RAW_OUT_RAW       0x08
+
+#define SLI4_SGE_TYPE_DATA		0x00
+#define SLI4_SGE_TYPE_CHAIN		0x03	/** Skyhawk only */
+#define SLI4_SGE_TYPE_DIF		0x04	/** Data Integrity Field */
+#define SLI4_SGE_TYPE_LSP		0x05	/** List Segment Pointer */
+#define SLI4_SGE_TYPE_PEDIF		0x06	/** Post Encryption Engine DIF */
+#define SLI4_SGE_TYPE_PESEED		0x07	/** Post Encryption Engine DIF Seed */
+#define SLI4_SGE_TYPE_DISEED		0x08	/** DIF Seed */
+#define SLI4_SGE_TYPE_ENC		0x09	/** Encryption */
+#define SLI4_SGE_TYPE_ATM		0x0a	/** DIF Application Tag Mask */
+#define SLI4_SGE_TYPE_SKIP		0x0c	/** SKIP */
+
+#define OCS_MAX_SGE_SIZE		0x80000000 /* Maximum data allowed in a SGE */
+
+/**
+ * @brief CONFIG_LINK
+ */
+typedef struct sli4_cmd_config_link_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	maxbbc:8,	/** Max buffer-to-buffer credit */
+			:24;
+	uint32_t	alpa:8,
+			n_port_id:16,
+			:8;
+	uint32_t	rsvd3;
+	uint32_t	e_d_tov;
+	uint32_t	lp_tov;
+	uint32_t	r_a_tov;
+	uint32_t	r_t_tov;
+	uint32_t	al_tov;
+	uint32_t	rsvd9;
+	uint32_t	:8,
+			bbscn:4,	/** buffer-to-buffer state change number */
+			cscn:1,		/** configure BBSCN */
+			:19;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_config_link_t;
+
+/**
+ * @brief DUMP Type 4
+ */
+#define SLI4_WKI_TAG_SAT_TEM 0x1040
+typedef struct sli4_cmd_dump4_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	type:4,
+			:28;
+	uint32_t	wki_selection:16,
+			:16;
+	uint32_t	resv;
+	uint32_t	returned_byte_cnt;
+	uint32_t	resp_data[59];
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_dump4_t;
+
+/**
+ * @brief FW_INITIALIZE - initialize a SLI port
+ *
+ * @note This command uses a different format than all others.
+ */
+
+extern const uint8_t sli4_fw_initialize[8];
+
+/**
+ * @brief FW_DEINITIALIZE - deinitialize a SLI port
+ *
+ * @note This command uses a different format than all others.
+ */
+
+extern const uint8_t sli4_fw_deinitialize[8];
+
+/**
+ * @brief INIT_LINK - initialize the link for a FC/FCoE port
+ */
+typedef struct sli4_cmd_init_link_flags_s {
+	uint32_t	loopback:1,
+			topology:2,
+			#define FC_TOPOLOGY_FCAL	0
+			#define FC_TOPOLOGY_P2P		1
+			:3,
+			unfair:1,
+			skip_lirp_lilp:1,
+			gen_loop_validity_check:1,
+			skip_lisa:1,
+			enable_topology_failover:1,
+			fixed_speed:1,
+			:3,
+			select_hightest_al_pa:1,
+			:16; 	/* pad to 32 bits */
+} sli4_cmd_init_link_flags_t;
+
+#define SLI4_INIT_LINK_F_LOOP_BACK	BIT(0)
+#define SLI4_INIT_LINK_F_UNFAIR		BIT(6)
+#define SLI4_INIT_LINK_F_NO_LIRP	BIT(7)
+#define SLI4_INIT_LINK_F_LOOP_VALID_CHK	BIT(8)
+#define SLI4_INIT_LINK_F_NO_LISA	BIT(9)
+#define SLI4_INIT_LINK_F_FAIL_OVER	BIT(10)
+#define SLI4_INIT_LINK_F_NO_AUTOSPEED	BIT(11)
+#define SLI4_INIT_LINK_F_PICK_HI_ALPA	BIT(15)
+
+#define SLI4_INIT_LINK_F_P2P_ONLY	1
+#define SLI4_INIT_LINK_F_FCAL_ONLY	2
+
+#define SLI4_INIT_LINK_F_FCAL_FAIL_OVER	0
+#define SLI4_INIT_LINK_F_P2P_FAIL_OVER	1
+
+typedef struct sli4_cmd_init_link_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	selective_reset_al_pa:8,
+			:24;
+	sli4_cmd_init_link_flags_t link_flags;
+	uint32_t	link_speed_selection_code;
+			#define FC_LINK_SPEED_1G		1
+			#define FC_LINK_SPEED_2G		2
+			#define FC_LINK_SPEED_AUTO_1_2		3
+			#define FC_LINK_SPEED_4G		4
+			#define FC_LINK_SPEED_AUTO_4_1		5
+			#define FC_LINK_SPEED_AUTO_4_2		6
+			#define FC_LINK_SPEED_AUTO_4_2_1	7
+			#define FC_LINK_SPEED_8G		8
+			#define FC_LINK_SPEED_AUTO_8_1		9
+			#define FC_LINK_SPEED_AUTO_8_2		10
+			#define FC_LINK_SPEED_AUTO_8_2_1	11
+			#define FC_LINK_SPEED_AUTO_8_4		12
+			#define FC_LINK_SPEED_AUTO_8_4_1	13
+			#define FC_LINK_SPEED_AUTO_8_4_2	14
+			#define FC_LINK_SPEED_10G		16
+			#define FC_LINK_SPEED_16G		17
+			#define FC_LINK_SPEED_AUTO_16_8_4	18
+			#define FC_LINK_SPEED_AUTO_16_8		19
+			#define FC_LINK_SPEED_32G		20
+			#define FC_LINK_SPEED_AUTO_32_16_8	21
+			#define FC_LINK_SPEED_AUTO_32_16	22
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_init_link_t;
+
+/**
+ * @brief INIT_VFI - initialize the VFI resource
+ */
+typedef struct sli4_cmd_init_vfi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	vfi:16,
+			:12,
+			vp:1,
+			vf:1,
+			vt:1,
+			vr:1;
+	uint32_t	fcfi:16,
+			vpi:16;
+	uint32_t	vf_id:13,
+			pri:3,
+			:16;
+	uint32_t	:24,
+			hop_count:8;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_init_vfi_t;
+
+/**
+ * @brief INIT_VPI - initialize the VPI resource
+ */
+typedef struct sli4_cmd_init_vpi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	vpi:16,
+			vfi:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_init_vpi_t;
+
+/**
+ * @brief POST_XRI - post XRI resources to the SLI Port
+ */
+typedef struct sli4_cmd_post_xri_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	xri_base:16,
+			xri_count:12,
+			enx:1,
+			dl:1,
+			di:1,
+			val:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_post_xri_t;
+
+/**
+ * @brief RELEASE_XRI - Release XRI resources from the SLI Port
+ */
+typedef struct sli4_cmd_release_xri_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	released_xri_count:5,
+			:11,
+			xri_count:5,
+			:11;
+	struct {
+		uint32_t	xri_tag0:16,
+				xri_tag1:16;
+	} xri_tbl[62];
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_release_xri_t;
+
+/**
+ * @brief READ_CONFIG - read SLI port configuration parameters
+ */
+typedef struct sli4_cmd_read_config_s {
+	sli4_mbox_command_header_t	hdr;
+} sli4_cmd_read_config_t;
+
+typedef struct sli4_res_read_config_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:31,
+			ext:1;		/** Resource Extents */
+	uint32_t	:24,
+			topology:8;
+	uint32_t	rsvd3;
+	uint32_t	e_d_tov:16,
+			:16;
+	uint32_t	rsvd5;
+	uint32_t	r_a_tov:16,
+			:16;
+	uint32_t	rsvd7;
+	uint32_t	rsvd8;
+	uint32_t	lmt:16,		/** Link Module Type */
+			:16;
+	uint32_t	rsvd10;
+	uint32_t	rsvd11;
+	uint32_t	xri_base:16,
+			xri_count:16;
+	uint32_t	rpi_base:16,
+			rpi_count:16;
+	uint32_t	vpi_base:16,
+			vpi_count:16;
+	uint32_t	vfi_base:16,
+			vfi_count:16;
+	uint32_t	:16,
+			fcfi_count:16;
+	uint32_t	rq_count:16,
+			eq_count:16;
+	uint32_t	wq_count:16,
+			cq_count:16;
+	uint32_t	pad[45];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_read_config_t;
+
+#define SLI4_READ_CFG_TOPO_FCOE			0x0	/** FCoE topology */
+#define SLI4_READ_CFG_TOPO_FC			0x1	/** FC topology unknown */
+#define SLI4_READ_CFG_TOPO_FC_DA		0x2	/** FC Direct Attach (non FC-AL) topology */
+#define SLI4_READ_CFG_TOPO_FC_AL		0x3	/** FC-AL topology */
+
+/**
+ * @brief READ_NVPARMS - read SLI port configuration parameters
+ */
+typedef struct sli4_cmd_read_nvparms_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd1;
+	uint32_t	rsvd2;
+	uint32_t	rsvd3;
+	uint32_t	rsvd4;
+	uint8_t		wwpn[8];
+	uint8_t		wwnn[8];
+	uint32_t	hard_alpa:8,
+			preferred_d_id:24;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_read_nvparms_t;
+
+/**
+ * @brief WRITE_NVPARMS - write SLI port configuration parameters
+ */
+typedef struct sli4_cmd_write_nvparms_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd1;
+	uint32_t	rsvd2;
+	uint32_t	rsvd3;
+	uint32_t	rsvd4;
+	uint8_t		wwpn[8];
+	uint8_t		wwnn[8];
+	uint32_t	hard_alpa:8,
+			preferred_d_id:24;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_write_nvparms_t;
+
+/**
+ * @brief READ_REV - read the Port revision levels
+ */
+typedef struct sli4_cmd_read_rev_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:16,
+			sli_level:4,
+			fcoem:1,
+			ceev:2,
+			:6,
+			vpd:1,
+			:2;
+	uint32_t	first_hw_revision;
+	uint32_t	second_hw_revision;
+	uint32_t	rsvd4;
+	uint32_t	third_hw_revision;
+	uint32_t	fc_ph_low:8,
+			fc_ph_high:8,
+			feature_level_low:8,
+			feature_level_high:8;
+	uint32_t	rsvd7;
+	uint32_t	first_fw_id;
+	char		first_fw_name[16];
+	uint32_t	second_fw_id;
+	char		second_fw_name[16];
+	uint32_t	rsvd18[30];
+	uint32_t	available_length:24,
+			:8;
+	uint32_t	physical_address_low;
+	uint32_t	physical_address_high;
+	uint32_t	returned_vpd_length;
+	uint32_t	actual_vpd_length;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_read_rev_t;
+
+/**
+ * @brief READ_SPARM64 - read the Port service parameters
+ */
+typedef struct sli4_cmd_read_sparm64_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd1;
+	uint32_t	rsvd2;
+	sli4_bde_t	bde_64;
+	uint32_t	vpi:16,
+			:16;
+	uint32_t	port_name_start:16,
+			port_name_length:16;
+	uint32_t	node_name_start:16,
+			node_name_length:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_read_sparm64_t;
+
+#define SLI4_READ_SPARM64_VPI_DEFAULT	0
+#define SLI4_READ_SPARM64_VPI_SPECIAL	UINT16_MAX
+
+#define SLI4_READ_SPARM64_WWPN_OFFSET	(4 * sizeof(uint32_t))
+#define SLI4_READ_SPARM64_WWNN_OFFSET	(SLI4_READ_SPARM64_WWPN_OFFSET + sizeof(uint64_t))
+
+typedef struct sli4_port_state_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	nx_port_recv_state:2,
+			nx_port_trans_state:2,
+			nx_port_state_machine:4,
+			link_speed:8,
+			:14,
+			tf:1,
+			lu:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_port_state_t;
+
+/**
+ * @brief READ_TOPOLOGY - read the link event information
+ */
+typedef struct sli4_cmd_read_topology_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	event_tag;
+	uint32_t	attention_type:8,
+			il:1,
+			pb_recvd:1,
+			:22;
+	uint32_t	topology:8,
+			lip_type:8,
+			lip_al_ps:8,
+			al_pa_granted:8;
+	sli4_bde_t	bde_loop_map;
+	sli4_port_state_t link_down;
+	sli4_port_state_t link_current;
+	uint32_t	max_bbc:8,
+			init_bbc:8,
+			bbscn:4,
+			cbbscn:4,
+			:8;
+	uint32_t	r_t_tov:9,
+			:3,
+			al_tov:4,
+			lp_tov:16;
+	uint32_t	acquired_al_pa:8,
+			:7,
+			pb:1,
+			specified_al_pa:16;
+	uint32_t	initial_n_port_id:24,
+			:8;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_read_topology_t;
+
+#define SLI4_MIN_LOOP_MAP_BYTES	128
+
+#define SLI4_READ_TOPOLOGY_LINK_UP	0x1
+#define SLI4_READ_TOPOLOGY_LINK_DOWN	0x2
+#define SLI4_READ_TOPOLOGY_LINK_NO_ALPA	0x3
+
+#define SLI4_READ_TOPOLOGY_UNKNOWN	0x0
+#define SLI4_READ_TOPOLOGY_NPORT	0x1
+#define SLI4_READ_TOPOLOGY_FC_AL	0x2
+
+#define SLI4_READ_TOPOLOGY_SPEED_NONE	0x00
+#define SLI4_READ_TOPOLOGY_SPEED_1G	0x04
+#define SLI4_READ_TOPOLOGY_SPEED_2G	0x08
+#define SLI4_READ_TOPOLOGY_SPEED_4G	0x10
+#define SLI4_READ_TOPOLOGY_SPEED_8G	0x20
+#define SLI4_READ_TOPOLOGY_SPEED_10G	0x40
+#define SLI4_READ_TOPOLOGY_SPEED_16G	0x80
+#define SLI4_READ_TOPOLOGY_SPEED_32G	0x90
+
+/**
+ * @brief REG_FCFI - activate a FC Forwarder
+ */
+#define SLI4_CMD_REG_FCFI_NUM_RQ_CFG	4
+typedef struct sli4_cmd_reg_fcfi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fcf_index:16,
+			fcfi:16;
+	uint32_t	rq_id_1:16,
+			rq_id_0:16;
+	uint32_t	rq_id_3:16,
+			rq_id_2:16;
+	struct {
+		uint32_t	r_ctl_mask:8,
+				r_ctl_match:8,
+				type_mask:8,
+				type_match:8;
+	} rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG];
+	uint32_t	vlan_tag:12,
+			vv:1,
+			:19;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_reg_fcfi_t;
+
+#define SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG	4
+#define SLI4_CMD_REG_FCFI_MRQ_MAX_NUM_RQ	32
+#define SLI4_CMD_REG_FCFI_SET_FCFI_MODE		0
+#define SLI4_CMD_REG_FCFI_SET_MRQ_MODE		1
+
+typedef struct sli4_cmd_reg_fcfi_mrq_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fcf_index:16,
+			fcfi:16;
+
+	uint32_t	rq_id_1:16,
+			rq_id_0:16;
+
+	uint32_t	rq_id_3:16,
+			rq_id_2:16;
+
+	struct {
+		uint32_t	r_ctl_mask:8,
+				r_ctl_match:8,
+				type_mask:8,
+				type_match:8;
+	} rq_cfg[SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG];
+
+	uint32_t	vlan_tag:12,
+			vv:1,
+			mode:1,
+			:18;
+
+	uint32_t	num_mrq_pairs:8,
+			mrq_filter_bitmask:4,
+			rq_selection_policy:4,
+			:16;
+#endif
+} sli4_cmd_reg_fcfi_mrq_t;
+
+/**
+ * @brief REG_RPI - register a Remote Port Indicator
+ */
+typedef struct sli4_cmd_reg_rpi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rpi:16,
+			:16;
+	uint32_t	remote_n_port_id:24,
+			upd:1,
+			:2,
+			etow:1,
+			:1,
+			terp:1,
+			:1,
+			ci:1;
+	sli4_bde_t	bde_64;
+	uint32_t	vpi:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_reg_rpi_t;
+#define SLI4_REG_RPI_BUF_LEN			0x70
+
+
+/**
+ * @brief REG_VFI - register a Virtual Fabric Indicator
+ */
+typedef struct sli4_cmd_reg_vfi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	vfi:16,
+			:12,
+			vp:1,
+			upd:1,
+			:2;
+	uint32_t	fcfi:16,
+			vpi:16;			/* vp=TRUE */
+	uint8_t		wwpn[8];		/* vp=TRUE */
+	sli4_bde_t	sparm;			/* either FLOGI or PLOGI */
+	uint32_t	e_d_tov;
+	uint32_t	r_a_tov;
+	uint32_t	local_n_port_id:24,	/* vp=TRUE */
+			:8;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_reg_vfi_t;
+
+/**
+ * @brief REG_VPI - register a Virtual Port Indicator
+ */
+typedef struct sli4_cmd_reg_vpi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd1;
+	uint32_t	local_n_port_id:24,
+			upd:1,
+			:7;
+	uint8_t		wwpn[8];
+	uint32_t	rsvd5;
+	uint32_t	vpi:16,
+			vfi:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_reg_vpi_t;
+
+/**
+ * @brief REQUEST_FEATURES - request / query SLI features
+ */
+typedef union {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	struct {
+		uint32_t	iaab:1,		/** inhibit auto-ABTS originator */
+				npiv:1,		/** NPIV support */
+				dif:1,		/** DIF/DIX support */
+				vf:1,		/** virtual fabric support */
+				fcpi:1,		/** FCP initiator support */
+				fcpt:1,		/** FCP target support */
+				fcpc:1,		/** combined FCP initiator/target */
+				:1,
+				rqd:1,		/** recovery qualified delay */
+				iaar:1,		/** inhibit auto-ABTS responder */
+				hlm:1,		/** High Login Mode */
+				perfh:1,	/** performance hints */
+				rxseq:1,	/** RX Sequence Coalescing */
+				rxri:1,		/** Release XRI variant of Coalescing */
+				dcl2:1,		/** Disable Class 2 */
+				rsco:1,		/** Receive Sequence Coalescing Optimizations */
+				mrqp:1,		/** Multi RQ Pair Mode Support */
+				:15;
+	} flag;
+	uint32_t	dword;
+#else
+#error big endian version not defined
+#endif
+} sli4_features_t;
+
+typedef struct sli4_cmd_request_features_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	qry:1,
+			:31;
+#else
+#error big endian version not defined
+#endif
+	sli4_features_t	command;
+	sli4_features_t	response;
+} sli4_cmd_request_features_t;
+
+/**
+ * @brief SLI_CONFIG - submit a configuration command to Port
+ *
+ * Command is either embedded as part of the payload (embed) or located
+ * in a separate memory buffer (mem)
+ */
+
+
+typedef struct sli4_sli_config_pmd_s {
+	uint32_t	address_low;
+	uint32_t	address_high;
+	uint32_t	length:24,
+			:8;
+} sli4_sli_config_pmd_t;
+
+typedef struct sli4_cmd_sli_config_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	emb:1,
+			:2,
+			pmd_count:5,
+			:24;
+	uint32_t	payload_length;
+	uint32_t	rsvd3;
+	uint32_t	rsvd4;
+	uint32_t	rsvd5;
+	union {
+		uint8_t			embed[58 * sizeof(uint32_t)];
+		sli4_sli_config_pmd_t   mem;
+	} payload;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_sli_config_t;
+
+/**
+ * @brief READ_STATUS - read tx/rx status of a particular port
+ *
+ */
+
+typedef struct sli4_cmd_read_status_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	cc:1,
+			:31;
+	uint32_t	rsvd2;
+	uint32_t	transmit_kbyte_count;
+	uint32_t	receive_kbyte_count;
+	uint32_t	transmit_frame_count;
+	uint32_t	receive_frame_count;
+	uint32_t	transmit_sequence_count;
+	uint32_t	receive_sequence_count;
+	uint32_t	total_exchanges_originator;
+	uint32_t	total_exchanges_responder;
+	uint32_t	receive_p_bsy_count;
+	uint32_t	receive_f_bsy_count;
+	uint32_t	dropped_frames_due_to_no_rq_buffer_count;
+	uint32_t	empty_rq_timeout_count;
+	uint32_t	dropped_frames_due_to_no_xri_count;
+	uint32_t	empty_xri_pool_count;
+
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_read_status_t;
+
+/**
+ * @brief READ_LNK_STAT - read link status of a particular port
+ *
+ */
+
+typedef struct sli4_cmd_read_link_stats_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rec:1,
+			gec:1,
+			w02of:1,
+			w03of:1,
+			w04of:1,
+			w05of:1,
+			w06of:1,
+			w07of:1,
+			w08of:1,
+			w09of:1,
+			w10of:1,
+			w11of:1,
+			w12of:1,
+			w13of:1,
+			w14of:1,
+			w15of:1,
+			w16of:1,
+			w17of:1,
+			w18of:1,
+			w19of:1,
+			w20of:1,
+			w21of:1,
+			resv0:8,
+			clrc:1,
+			clof:1;
+	uint32_t	link_failure_error_count;
+	uint32_t	loss_of_sync_error_count;
+	uint32_t	loss_of_signal_error_count;
+	uint32_t	primitive_sequence_error_count;
+	uint32_t	invalid_transmission_word_error_count;
+	uint32_t	crc_error_count;
+	uint32_t	primitive_sequence_event_timeout_count;
+	uint32_t	elastic_buffer_overrun_error_count;
+	uint32_t	arbitration_fc_al_timout_count;
+	uint32_t	advertised_receive_bufftor_to_buffer_credit;
+	uint32_t	current_receive_buffer_to_buffer_credit;
+	uint32_t	advertised_transmit_buffer_to_buffer_credit;
+	uint32_t	current_transmit_buffer_to_buffer_credit;
+	uint32_t	received_eofa_count;
+	uint32_t	received_eofdti_count;
+	uint32_t	received_eofni_count;
+	uint32_t	received_soff_count;
+	uint32_t	received_dropped_no_aer_count;
+	uint32_t	received_dropped_no_available_rpi_resources_count;
+	uint32_t	received_dropped_no_available_xri_resources_count;
+
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_read_link_stats_t;
+
+/**
+ * @brief Format a WQE with WQ_ID Association performance hint
+ *
+ * @par Description
+ * PHWQ works by over-writing part of Word 10 in the WQE with the WQ ID.
+ *
+ * @param entry Pointer to the WQE.
+ * @param q_id Queue ID.
+ *
+ * @return None.
+ */
+static inline void
+sli_set_wq_id_association(void *entry, uint16_t q_id)
+{
+	uint32_t *wqe = entry;
+
+	/*
+	 * Set Word 10, bit 0 to zero
+	 * Set Word 10, bits 15:1 to the WQ ID
+	 */
+#if BYTE_ORDER == LITTLE_ENDIAN
+	wqe[10] &= ~0xffff;
+	wqe[10] |= q_id << 1;
+#else
+#error big endian version not defined
+#endif
+}
+
+/**
+ * @brief UNREG_FCFI - unregister a FCFI
+ */
+typedef struct sli4_cmd_unreg_fcfi_s {
+	sli4_mbox_command_header_t	hdr;
+	uint32_t	rsvd1;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fcfi:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_unreg_fcfi_t;
+
+/**
+ * @brief UNREG_RPI - unregister one or more RPI
+ */
+typedef struct sli4_cmd_unreg_rpi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	index:16,
+			:13,
+			dp:1,
+			ii:2;
+	uint32_t	destination_n_port_id:24,
+			:8;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_unreg_rpi_t;
+
+#define SLI4_UNREG_RPI_II_RPI			0x0
+#define SLI4_UNREG_RPI_II_VPI			0x1
+#define SLI4_UNREG_RPI_II_VFI			0x2
+#define SLI4_UNREG_RPI_II_FCFI			0x3
+
+/**
+ * @brief UNREG_VFI - unregister one or more VFI
+ */
+typedef struct sli4_cmd_unreg_vfi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd1;
+	uint32_t	index:16,
+			:14,
+			ii:2;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_unreg_vfi_t;
+
+#define SLI4_UNREG_VFI_II_VFI			0x0
+#define SLI4_UNREG_VFI_II_FCFI			0x3
+
+enum {
+	SLI4_UNREG_TYPE_PORT,
+	SLI4_UNREG_TYPE_DOMAIN,
+	SLI4_UNREG_TYPE_FCF,
+	SLI4_UNREG_TYPE_ALL
+};
+
+/**
+ * @brief UNREG_VPI - unregister one or more VPI
+ */
+typedef struct sli4_cmd_unreg_vpi_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd1;
+	uint32_t	index:16,
+			:14,
+			ii:2;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_unreg_vpi_t;
+
+#define SLI4_UNREG_VPI_II_VPI			0x0
+#define SLI4_UNREG_VPI_II_VFI			0x2
+#define SLI4_UNREG_VPI_II_FCFI			0x3
+
+
+/**
+ * @brief AUTO_XFER_RDY - Configure the auto-generate XFER-RDY feature.
+ */
+typedef struct sli4_cmd_config_auto_xfer_rdy_s {
+	sli4_mbox_command_header_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	resv;
+	uint32_t	max_burst_len;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_config_auto_xfer_rdy_t;
+
+typedef struct sli4_cmd_config_auto_xfer_rdy_hp_s {
+        sli4_mbox_command_header_t      hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+        uint32_t        resv;
+        uint32_t        max_burst_len;
+        uint32_t        esoc:1,
+                        :31;
+        uint32_t        block_size:16,
+                        :16;
+#else
+#error big endian version not defined
+#endif
+} sli4_cmd_config_auto_xfer_rdy_hp_t;
+
+
+/*************************************************************************
+ * SLI-4 common configuration command formats and definitions
+ */
+
+#define SLI4_CFG_STATUS_SUCCESS			0x00
+#define SLI4_CFG_STATUS_FAILED			0x01
+#define SLI4_CFG_STATUS_ILLEGAL_REQUEST		0x02
+#define SLI4_CFG_STATUS_ILLEGAL_FIELD		0x03
+
+#define SLI4_MGMT_STATUS_FLASHROM_READ_FAILED	0xcb
+
+#define SLI4_CFG_ADD_STATUS_NO_STATUS		0x00
+#define SLI4_CFG_ADD_STATUS_INVALID_OPCODE	0x1e
+
+/**
+ * Subsystem values.
+ */
+#define SLI4_SUBSYSTEM_COMMON			0x01
+#define SLI4_SUBSYSTEM_LOWLEVEL			0x0B
+#define SLI4_SUBSYSTEM_FCFCOE			0x0c
+#define SLI4_SUBSYSTEM_DMTF			0x11
+
+#define	SLI4_OPC_LOWLEVEL_SET_WATCHDOG		0X36
+
+/**
+ * Common opcode (OPC) values.
+ */
+#define SLI4_OPC_COMMON_FUNCTION_RESET			0x3d
+#define SLI4_OPC_COMMON_CREATE_CQ			0x0c
+#define SLI4_OPC_COMMON_CREATE_CQ_SET			0x1d
+#define SLI4_OPC_COMMON_DESTROY_CQ			0x36
+#define SLI4_OPC_COMMON_MODIFY_EQ_DELAY			0x29
+#define SLI4_OPC_COMMON_CREATE_EQ			0x0d
+#define SLI4_OPC_COMMON_DESTROY_EQ			0x37
+#define SLI4_OPC_COMMON_CREATE_MQ_EXT			0x5a
+#define SLI4_OPC_COMMON_DESTROY_MQ			0x35
+#define SLI4_OPC_COMMON_GET_CNTL_ATTRIBUTES		0x20
+#define SLI4_OPC_COMMON_NOP				0x21
+#define SLI4_OPC_COMMON_GET_RESOURCE_EXTENT_INFO	0x9a
+#define SLI4_OPC_COMMON_GET_SLI4_PARAMETERS		0xb5
+#define SLI4_OPC_COMMON_QUERY_FW_CONFIG			0x3a
+#define SLI4_OPC_COMMON_GET_PORT_NAME			0x4d
+
+#define SLI4_OPC_COMMON_WRITE_FLASHROM			0x07
+#define SLI4_OPC_COMMON_MANAGE_FAT			0x44
+#define SLI4_OPC_COMMON_READ_TRANSCEIVER_DATA		0x49
+#define SLI4_OPC_COMMON_GET_CNTL_ADDL_ATTRIBUTES	0x79
+#define SLI4_OPC_COMMON_GET_EXT_FAT_CAPABILITIES	0x7d
+#define SLI4_OPC_COMMON_SET_EXT_FAT_CAPABILITIES	0x7e
+#define SLI4_OPC_COMMON_EXT_FAT_CONFIGURE_SNAPSHOT	0x7f
+#define SLI4_OPC_COMMON_EXT_FAT_RETRIEVE_SNAPSHOT	0x80
+#define SLI4_OPC_COMMON_EXT_FAT_READ_STRING_TABLE	0x82
+#define SLI4_OPC_COMMON_GET_FUNCTION_CONFIG		0xa0
+#define SLI4_OPC_COMMON_GET_PROFILE_CONFIG		0xa4
+#define SLI4_OPC_COMMON_SET_PROFILE_CONFIG		0xa5
+#define SLI4_OPC_COMMON_GET_PROFILE_LIST		0xa6
+#define SLI4_OPC_COMMON_GET_ACTIVE_PROFILE		0xa7
+#define SLI4_OPC_COMMON_SET_ACTIVE_PROFILE		0xa8
+#define SLI4_OPC_COMMON_READ_OBJECT			0xab
+#define SLI4_OPC_COMMON_WRITE_OBJECT			0xac
+#define SLI4_OPC_COMMON_DELETE_OBJECT			0xae
+#define SLI4_OPC_COMMON_READ_OBJECT_LIST		0xad
+#define SLI4_OPC_COMMON_SET_DUMP_LOCATION		0xb8
+#define SLI4_OPC_COMMON_SET_FEATURES			0xbf
+#define SLI4_OPC_COMMON_GET_RECONFIG_LINK_INFO		0xc9
+#define SLI4_OPC_COMMON_SET_RECONFIG_LINK_ID		0xca
+
+/**
+ * DMTF opcode (OPC) values.
+ */
+#define SLI4_OPC_DMTF_EXEC_CLP_CMD			0x01
+
+/**
+ * @brief Generic Command Request header
+ */
+typedef struct sli4_req_hdr_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	opcode:8,
+			subsystem:8,
+			:16;
+	uint32_t	timeout;
+	uint32_t	request_length;
+	uint32_t	version:8,
+			:24;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_hdr_t;
+
+/**
+ * @brief Generic Command Response header
+ */
+typedef struct sli4_res_hdr_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	opcode:8,
+			subsystem:8,
+			:16;
+	uint32_t	status:8,
+			additional_status:8,
+			:16;
+	uint32_t	response_length;
+	uint32_t	actual_response_length;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_hdr_t;
+
+/**
+ * @brief COMMON_FUNCTION_RESET
+ *
+ * Resets the Port, returning it to a power-on state. This configuration
+ * command does not have a payload and should set/expect the lengths to
+ * be zero.
+ */
+typedef struct sli4_req_common_function_reset_s {
+	sli4_req_hdr_t	hdr;
+} sli4_req_common_function_reset_t;
+
+
+typedef struct sli4_res_common_function_reset_s {
+	sli4_res_hdr_t	hdr;
+} sli4_res_common_function_reset_t;
+
+/**
+ * @brief COMMON_CREATE_CQ_V0
+ *
+ * Create a Completion Queue.
+ */
+typedef struct sli4_req_common_create_cq_v0_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			:16;
+	uint32_t	:12,
+			clswm:2,
+			nodelay:1,
+			:12,
+			cqecnt:2,
+			valid:1,
+			:1,
+			evt:1;
+	uint32_t	:22,
+			eq_id:8,
+			:1,
+			arm:1;
+	uint32_t	rsvd[2];
+	struct {
+		uint32_t	low;
+		uint32_t	high;
+	} page_physical_address[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_create_cq_v0_t;
+
+/**
+ * @brief COMMON_CREATE_CQ_V2
+ *
+ * Create a Completion Queue.
+ */
+typedef struct sli4_req_common_create_cq_v2_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			page_size:8,
+			:8,
+	uint32_t	:12,
+			clswm:2,
+			nodelay:1,
+			autovalid:1,
+			:11,
+			cqecnt:2,
+			valid:1,
+			:1,
+			evt:1;
+	uint32_t	eq_id:16,
+			:15,
+			arm:1;
+	uint32_t	cqe_count:16,
+			:16;
+	uint32_t	rsvd[1];
+	struct {
+		uint32_t	low;
+		uint32_t	high;
+	} page_physical_address[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_create_cq_v2_t;
+
+
+
+/**
+ * @brief COMMON_CREATE_CQ_SET_V0
+ *
+ * Create a set of Completion Queues.
+ */
+typedef struct sli4_req_common_create_cq_set_v0_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			page_size:8,
+			:8;
+	uint32_t	:12,
+			clswm:2,
+			nodelay:1,
+			autovalid:1,
+			rsvd:11,
+			cqecnt:2,
+			valid:1,
+			:1,
+			evt:1;
+	uint32_t	num_cq_req:16,
+			cqe_count:15,
+			arm:1;
+	uint16_t	eq_id[16];
+	struct {
+		uint32_t	low;
+		uint32_t	high;
+	} page_physical_address[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_create_cq_set_v0_t;
+
+/**
+ * CQE count.
+ */
+#define SLI4_CQ_CNT_256			0
+#define SLI4_CQ_CNT_512			1
+#define SLI4_CQ_CNT_1024		2
+#define SLI4_CQ_CNT_LARGE		3
+
+#define SLI4_CQE_BYTES			(4 * sizeof(uint32_t))
+
+#define SLI4_COMMON_CREATE_CQ_V2_MAX_PAGES 8
+
+/**
+ * @brief Generic Common Create EQ/CQ/MQ/WQ/RQ Queue completion
+ */
+typedef struct sli4_res_common_create_queue_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t q_id:16,
+		:8,
+		ulp:8;
+	uint32_t db_offset;
+	uint32_t db_rs:16,
+		 db_fmt:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_create_queue_t;
+
+
+typedef struct sli4_res_common_create_queue_set_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t q_id:16,
+		num_q_allocated:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_create_queue_set_t;
+
+
+/**
+ * @brief Common Destroy CQ
+ */
+typedef struct sli4_req_common_destroy_cq_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	cq_id:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_destroy_cq_t;
+
+/**
+ * @brief COMMON_MODIFY_EQ_DELAY
+ *
+ * Modify the delay multiplier for EQs
+ */
+typedef struct sli4_req_common_modify_eq_delay_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_eq;
+	struct {
+		uint32_t	eq_id;
+		uint32_t	phase;
+		uint32_t	delay_multiplier;
+	} eq_delay_record[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_modify_eq_delay_t;
+
+/**
+ * @brief COMMON_CREATE_EQ
+ *
+ * Create an Event Queue.
+ */
+typedef struct sli4_req_common_create_eq_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			:16;
+	uint32_t	:29,
+			valid:1,
+			:1,
+			eqesz:1;
+	uint32_t	:26,
+			count:3,
+			:2,
+			arm:1;
+	uint32_t	:13,
+			delay_multiplier:10,
+			:9;
+	uint32_t	rsvd;
+	struct {
+		uint32_t	low;
+		uint32_t	high;
+	} page_address[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_create_eq_t;
+
+#define SLI4_EQ_CNT_256			0
+#define SLI4_EQ_CNT_512			1
+#define SLI4_EQ_CNT_1024		2
+#define SLI4_EQ_CNT_2048		3
+#define SLI4_EQ_CNT_4096		4
+
+#define SLI4_EQE_SIZE_4			0
+#define SLI4_EQE_SIZE_16		1
+
+/**
+ * @brief Common Destroy EQ
+ */
+typedef struct sli4_req_common_destroy_eq_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	eq_id:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_destroy_eq_t;
+
+/**
+ * @brief COMMON_CREATE_MQ_EXT
+ *
+ * Create a Mailbox Queue; accommodate v0 and v1 forms.
+ */
+typedef struct sli4_req_common_create_mq_ext_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			cq_id_v1:16;
+	uint32_t	async_event_bitmap;
+	uint32_t	async_cq_id_v1:16,
+			ring_size:4,
+			:2,
+			cq_id_v0:10;
+	uint32_t	:31,
+			val:1;
+	uint32_t	acqv:1,
+			async_cq_id_v0:10,
+			:21;
+	uint32_t	rsvd9;
+	struct {
+		uint32_t	low;
+		uint32_t	high;
+	} page_physical_address[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_create_mq_ext_t;
+
+#define SLI4_MQE_SIZE_16		0x05
+#define SLI4_MQE_SIZE_32		0x06
+#define SLI4_MQE_SIZE_64		0x07
+#define SLI4_MQE_SIZE_128		0x08
+
+#define SLI4_ASYNC_EVT_LINK_STATE	BIT(1)
+#define SLI4_ASYNC_EVT_FCOE_FIP		BIT(2)
+#define SLI4_ASYNC_EVT_DCBX		BIT(3)
+#define SLI4_ASYNC_EVT_ISCSI		BIT(4)
+#define SLI4_ASYNC_EVT_GRP5		BIT(5)
+#define SLI4_ASYNC_EVT_FC		BIT(16)
+#define SLI4_ASYNC_EVT_SLI_PORT		BIT(17)
+#define SLI4_ASYNC_EVT_VF		BIT(18)
+#define SLI4_ASYNC_EVT_MR		BIT(19)
+
+#define SLI4_ASYNC_EVT_ALL	\
+		SLI4_ASYNC_EVT_LINK_STATE 	| \
+		SLI4_ASYNC_EVT_FCOE_FIP		| \
+		SLI4_ASYNC_EVT_DCBX		| \
+		SLI4_ASYNC_EVT_ISCSI		| \
+		SLI4_ASYNC_EVT_GRP5		| \
+		SLI4_ASYNC_EVT_FC		| \
+		SLI4_ASYNC_EVT_SLI_PORT		| \
+		SLI4_ASYNC_EVT_VF		|\
+		SLI4_ASYNC_EVT_MR
+
+#define SLI4_ASYNC_EVT_FC_FCOE \
+		SLI4_ASYNC_EVT_LINK_STATE	| \
+		SLI4_ASYNC_EVT_FCOE_FIP		| \
+		SLI4_ASYNC_EVT_GRP5		| \
+		SLI4_ASYNC_EVT_FC		| \
+		SLI4_ASYNC_EVT_SLI_PORT
+
+/**
+ * @brief Common Destroy MQ
+ */
+typedef struct sli4_req_common_destroy_mq_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	mq_id:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_destroy_mq_t;
+
+/**
+ * @brief COMMON_GET_CNTL_ATTRIBUTES
+ *
+ * Query for information about the SLI Port
+ */
+typedef struct sli4_res_common_get_cntl_attributes_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint8_t		version_string[32];
+	uint8_t		manufacturer_name[32];
+	uint32_t	supported_modes;
+	uint32_t	eprom_version_lo:8,
+			eprom_version_hi:8,
+			:16;
+	uint32_t	mbx_data_structure_version;
+	uint32_t	ep_firmware_data_structure_version;
+	uint8_t		ncsi_version_string[12];
+	uint32_t	default_extended_timeout;
+	uint8_t		model_number[32];
+	uint8_t		description[64];
+	uint8_t		serial_number[32];
+	uint8_t		ip_version_string[32];
+	uint8_t		fw_version_string[32];
+	uint8_t		bios_version_string[32];
+	uint8_t		redboot_version_string[32];
+	uint8_t		driver_version_string[32];
+	uint8_t		fw_on_flash_version_string[32];
+	uint32_t	functionalities_supported;
+	uint32_t	max_cdb_length:16,
+			asic_revision:8,
+			generational_guid0:8;
+	uint32_t	generational_guid1_12[3];
+	uint32_t	generational_guid13:24,
+			hba_port_count:8;
+	uint32_t	default_link_down_timeout:16,
+			iscsi_version_min_max:8,
+			multifunctional_device:8;
+	uint32_t	cache_valid:8,
+			hba_status:8,
+			max_domains_supported:8,
+			port_number:6,
+			port_type:2;
+	uint32_t	firmware_post_status;
+	uint32_t	hba_mtu;
+	uint32_t	iscsi_features:8,
+			rsvd121:24;
+	uint32_t	pci_vendor_id:16,
+			pci_device_id:16;
+	uint32_t	pci_sub_vendor_id:16,
+			pci_sub_system_id:16;
+	uint32_t	pci_bus_number:8,
+			pci_device_number:8,
+			pci_function_number:8,
+			interface_type:8;
+	uint64_t	unique_identifier;
+	uint32_t	number_of_netfilters:8,
+			rsvd130:24;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_cntl_attributes_t;
+
+/**
+ * @brief COMMON_GET_CNTL_ATTRIBUTES
+ *
+ * This command queries the controller information from the Flash ROM.
+ */
+typedef struct sli4_req_common_get_cntl_addl_attributes_s {
+	sli4_req_hdr_t	hdr;
+} sli4_req_common_get_cntl_addl_attributes_t;
+
+
+typedef struct sli4_res_common_get_cntl_addl_attributes_s {
+	sli4_res_hdr_t	hdr;
+	uint16_t	ipl_file_number;
+	uint8_t		ipl_file_version;
+	uint8_t		rsvd0;
+	uint8_t		on_die_temperature;
+	uint8_t		rsvd1[3];
+	uint32_t	driver_advanced_features_supported;
+	uint32_t	rsvd2[4];
+	char		fcoe_universal_bios_version[32];
+	char		fcoe_x86_bios_version[32];
+	char		fcoe_efi_bios_version[32];
+	char		fcoe_fcode_version[32];
+	char		uefi_bios_version[32];
+	char		uefi_nic_version[32];
+	char		uefi_fcode_version[32];
+	char		uefi_iscsi_version[32];
+	char		iscsi_x86_bios_version[32];
+	char		pxe_x86_bios_version[32];
+	uint8_t		fcoe_default_wwpn[8];
+	uint8_t		ext_phy_version[32];
+	uint8_t		fc_universal_bios_version[32];
+	uint8_t		fc_x86_bios_version[32];
+	uint8_t		fc_efi_bios_version[32];
+	uint8_t		fc_fcode_version[32];
+	uint8_t		ext_phy_crc_label[8];
+	uint8_t		ipl_file_name[16];
+	uint8_t		rsvd3[72];
+} sli4_res_common_get_cntl_addl_attributes_t;
+
+/**
+ * @brief COMMON_NOP
+ *
+ * This command does not do anything; it only returns the payload in the completion.
+ */
+typedef struct sli4_req_common_nop_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	context[2];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_nop_t;
+
+typedef struct sli4_res_common_nop_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	context[2];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_nop_t;
+
+/**
+ * @brief COMMON_GET_RESOURCE_EXTENT_INFO
+ */
+typedef struct sli4_req_common_get_resource_extent_info_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	resource_type:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_get_resource_extent_info_t;
+
+#define SLI4_RSC_TYPE_ISCSI_INI_XRI	0x0c
+#define SLI4_RSC_TYPE_FCOE_VFI		0x20
+#define SLI4_RSC_TYPE_FCOE_VPI		0x21
+#define SLI4_RSC_TYPE_FCOE_RPI		0x22
+#define SLI4_RSC_TYPE_FCOE_XRI		0x23
+
+typedef struct sli4_res_common_get_resource_extent_info_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	resource_extent_count:16,
+			resource_extent_size:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_resource_extent_info_t;
+
+
+#define SLI4_128BYTE_WQE_SUPPORT	0x02
+/**
+ * @brief COMMON_GET_SLI4_PARAMETERS
+ */
+typedef struct sli4_res_common_get_sli4_parameters_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	protocol_type:8,
+			:24;
+	uint32_t	ft:1,
+			:3,
+			sli_revision:4,
+			sli_family:4,
+			if_type:4,
+			sli_hint_1:8,
+			sli_hint_2:5,
+			:3;
+	uint32_t	eq_page_cnt:4,
+			:4,
+			eqe_sizes:4,
+			:4,
+			eq_page_sizes:8,
+			eqe_count_method:4,
+			:4;
+	uint32_t	eqe_count_mask:16,
+			:16;
+	uint32_t	cq_page_cnt:4,
+			:4,
+			cqe_sizes:4,
+			:2,
+			cqv:2,
+			cq_page_sizes:8,
+			cqe_count_method:4,
+			:4;
+	uint32_t	cqe_count_mask:16,
+			:16;
+	uint32_t	mq_page_cnt:4,
+			:10,
+			mqv:2,
+			mq_page_sizes:8,
+			mqe_count_method:4,
+			:4;
+	uint32_t	mqe_count_mask:16,
+			:16;
+	uint32_t	wq_page_cnt:4,
+			:4,
+			wqe_sizes:4,
+			:2,
+			wqv:2,
+			wq_page_sizes:8,
+			wqe_count_method:4,
+			:4;
+	uint32_t	wqe_count_mask:16,
+			:16;
+	uint32_t	rq_page_cnt:4,
+			:4,
+			rqe_sizes:4,
+			:2,
+			rqv:2,
+			rq_page_sizes:8,
+			rqe_count_method:4,
+			:4;
+	uint32_t	rqe_count_mask:16,
+			:12,
+			rq_db_window:4;
+	uint32_t	fcoe:1,
+			ext:1,
+			hdrr:1,
+			sglr:1,
+			fbrr:1,
+			areg:1,
+			tgt:1,
+			terp:1,
+			assi:1,
+			wchn:1,
+			tcca:1,
+			trty:1,
+			trir:1,
+			phoff:1,
+			phon:1,
+			phwq:1,			/** Performance Hint WQ_ID Association */
+			boundary_4ga:1,
+			rxc:1,
+			hlm:1,
+			ipr:1,
+			rxri:1,
+			sglc:1,
+			timm:1,
+			tsmm:1,
+			:1,
+			oas:1,
+			lc:1,
+			agxf:1,
+			loopback_scope:4;
+	uint32_t	sge_supported_length;
+	uint32_t	sgl_page_cnt:4,
+			:4,
+			sgl_page_sizes:8,
+			sgl_pp_align:8,
+			:8;
+	uint32_t	min_rq_buffer_size:16,
+			:16;
+	uint32_t	max_rq_buffer_size;
+	uint32_t	physical_xri_max:16,
+			physical_rpi_max:16;
+	uint32_t	physical_vpi_max:16,
+			physical_vfi_max:16;
+	uint32_t	rsvd19;
+	uint32_t	frag_num_field_offset:16,	/* dword 20 */
+			frag_num_field_size:16;
+	uint32_t	sgl_index_field_offset:16,	/* dword 21 */
+			sgl_index_field_size:16;
+	uint32_t	chain_sge_initial_value_lo;	/* dword 22 */
+	uint32_t	chain_sge_initial_value_hi;	/* dword 23 */
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_sli4_parameters_t;
+
+
+/**
+ * @brief COMMON_QUERY_FW_CONFIG
+ *
+ * This command retrieves firmware configuration parameters and adapter
+ * resources available to the driver.
+ */
+typedef struct sli4_req_common_query_fw_config_s {
+	sli4_req_hdr_t	hdr;
+} sli4_req_common_query_fw_config_t;
+
+
+#define SLI4_FUNCTION_MODE_FCOE_INI_MODE 0x40
+#define SLI4_FUNCTION_MODE_FCOE_TGT_MODE 0x80
+#define SLI4_FUNCTION_MODE_DUA_MODE      0x800
+
+#define SLI4_ULP_MODE_FCOE_INI           0x40
+#define SLI4_ULP_MODE_FCOE_TGT           0x80
+
+typedef struct sli4_res_common_query_fw_config_s {
+	sli4_res_hdr_t	hdr;
+	uint32_t	config_number;
+	uint32_t	asic_rev;
+	uint32_t	physical_port;
+	uint32_t	function_mode;
+	uint32_t	ulp0_mode;
+	uint32_t	ulp0_nic_wqid_base;
+	uint32_t	ulp0_nic_wq_total; /* Dword 10 */
+	uint32_t	ulp0_toe_wqid_base;
+	uint32_t	ulp0_toe_wq_total;
+	uint32_t	ulp0_toe_rqid_base;
+	uint32_t	ulp0_toe_rq_total;
+	uint32_t	ulp0_toe_defrqid_base;
+	uint32_t	ulp0_toe_defrq_total;
+	uint32_t	ulp0_lro_rqid_base;
+	uint32_t	ulp0_lro_rq_total;
+	uint32_t	ulp0_iscsi_icd_base;
+	uint32_t	ulp0_iscsi_icd_total; /* Dword 20 */
+	uint32_t	ulp1_mode;
+	uint32_t	ulp1_nic_wqid_base;
+	uint32_t	ulp1_nic_wq_total;
+	uint32_t	ulp1_toe_wqid_base;
+	uint32_t	ulp1_toe_wq_total;
+	uint32_t	ulp1_toe_rqid_base;
+	uint32_t	ulp1_toe_rq_total;
+	uint32_t	ulp1_toe_defrqid_base;
+	uint32_t	ulp1_toe_defrq_total;
+	uint32_t	ulp1_lro_rqid_base;  /* Dword 30 */
+	uint32_t	ulp1_lro_rq_total;
+	uint32_t	ulp1_iscsi_icd_base;
+	uint32_t	ulp1_iscsi_icd_total;
+	uint32_t	function_capabilities;
+	uint32_t	ulp0_cq_base;
+	uint32_t	ulp0_cq_total;
+	uint32_t	ulp0_eq_base;
+	uint32_t	ulp0_eq_total;
+	uint32_t	ulp0_iscsi_chain_icd_base;
+	uint32_t	ulp0_iscsi_chain_icd_total;  /* Dword 40 */
+	uint32_t	ulp1_iscsi_chain_icd_base;
+	uint32_t	ulp1_iscsi_chain_icd_total;
+} sli4_res_common_query_fw_config_t;
+
+/**
+ * @brief COMMON_GET_PORT_NAME
+ */
+typedef struct sli4_req_common_get_port_name_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	pt:2,		/* only COMMON_GET_PORT_NAME_V1 */
+			:30;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_get_port_name_t;
+
+typedef struct sli4_res_common_get_port_name_s {
+	sli4_res_hdr_t	hdr;
+	char		port_name[4];
+} sli4_res_common_get_port_name_t;
+
+/**
+ * @brief COMMON_WRITE_FLASHROM
+ */
+typedef struct sli4_req_common_write_flashrom_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	flash_rom_access_opcode;
+	uint32_t	flash_rom_access_operation_type;
+	uint32_t	data_buffer_size;
+	uint32_t	offset;
+	uint8_t		data_buffer[4];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_write_flashrom_t;
+
+#define SLI4_MGMT_FLASHROM_OPCODE_FLASH			0x01
+#define SLI4_MGMT_FLASHROM_OPCODE_SAVE			0x02
+#define SLI4_MGMT_FLASHROM_OPCODE_CLEAR			0x03
+#define SLI4_MGMT_FLASHROM_OPCODE_REPORT		0x04
+#define SLI4_MGMT_FLASHROM_OPCODE_IMAGE_INFO		0x05
+#define SLI4_MGMT_FLASHROM_OPCODE_IMAGE_CRC		0x06
+#define SLI4_MGMT_FLASHROM_OPCODE_OFFSET_BASED_FLASH	0x07
+#define SLI4_MGMT_FLASHROM_OPCODE_OFFSET_BASED_SAVE	0x08
+#define SLI4_MGMT_PHY_FLASHROM_OPCODE_FLASH		0x09
+#define SLI4_MGMT_PHY_FLASHROM_OPCODE_SAVE		0x0a
+
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_ISCSI		0x00
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_REDBOOT		0x01
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_BIOS		0x02
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_PXE_BIOS		0x03
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_CODE_CONTROL	0x04
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_IPSEC_CFG		0x05
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_INIT_DATA		0x06
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_ROM_OFFSET	0x07
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_FCOE_BIOS		0x08
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_ISCSI_BAK		0x09
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_FCOE_ACT		0x0a
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_FCOE_BAK		0x0b
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_CODE_CTRL_P	0x0c
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_NCSI		0x0d
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_NIC		0x0e
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_DCBX		0x0f
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_PXE_BIOS_CFG	0x10
+#define SLI4_FLASH_ROM_ACCESS_OP_TYPE_ALL_CFG_DATA	0x11
+
+/**
+ * @brief COMMON_MANAGE_FAT
+ */
+typedef struct sli4_req_common_manage_fat_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fat_operation;
+	uint32_t	read_log_offset;
+	uint32_t	read_log_length;
+	uint32_t	data_buffer_size;
+	uint32_t	data_buffer;		/* response only */
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_manage_fat_t;
+
+/**
+ * @brief COMMON_GET_EXT_FAT_CAPABILITIES
+ */
+typedef struct sli4_req_common_get_ext_fat_capabilities_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	parameter_type;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_get_ext_fat_capabilities_t;
+
+/**
+ * @brief COMMON_SET_EXT_FAT_CAPABILITIES
+ */
+typedef struct sli4_req_common_set_ext_fat_capabilities_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	maximum_log_entries;
+	uint32_t	log_entry_size;
+	uint32_t	logging_type:8,
+			maximum_logging_functions:8,
+			maximum_logging_ports:8,
+			:8;
+	uint32_t	supported_modes;
+	uint32_t	number_modules;
+	uint32_t	debug_module[14];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_ext_fat_capabilities_t;
+
+/**
+ * @brief COMMON_EXT_FAT_CONFIGURE_SNAPSHOT
+ */
+typedef struct sli4_req_common_ext_fat_configure_snapshot_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	total_log_entries;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_ext_fat_configure_snapshot_t;
+
+/**
+ * @brief COMMON_EXT_FAT_RETRIEVE_SNAPSHOT
+ */
+typedef struct sli4_req_common_ext_fat_retrieve_snapshot_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	snapshot_mode;
+	uint32_t	start_index;
+	uint32_t	number_log_entries;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_ext_fat_retrieve_snapshot_t;
+
+typedef struct sli4_res_common_ext_fat_retrieve_snapshot_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	number_log_entries;
+	uint32_t	version:8,
+			physical_port:8,
+			function_id:16;
+	uint32_t	trace_level;
+	uint32_t	module_mask[2];
+	uint32_t	trace_table_index;
+	uint32_t	timestamp;
+	uint8_t		string_data[16];
+	uint32_t	data[6];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_ext_fat_retrieve_snapshot_t;
+
+/**
+ * @brief COMMON_EXT_FAT_READ_STRING_TABLE
+ */
+typedef struct sli4_req_common_ext_fat_read_string_table_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	byte_offset;
+	uint32_t	number_bytes;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_ext_fat_read_string_table_t;
+
+typedef struct sli4_res_common_ext_fat_read_string_table_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	number_returned_bytes;
+	uint32_t	number_remaining_bytes;
+	uint32_t	table_data0:8,
+			:24;
+	uint8_t		table_data[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_ext_fat_read_string_table_t;
+
+/**
+ * @brief COMMON_READ_TRANSCEIVER_DATA
+ *
+ * This command reads SFF transceiver data(Format is defined
+ * by the SFF-8472 specification).
+ */
+typedef struct sli4_req_common_read_transceiver_data_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	page_number;
+	uint32_t	port;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_read_transceiver_data_t;
+
+typedef struct sli4_res_common_read_transceiver_data_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	page_number;
+	uint32_t	port;
+	uint32_t	page_data[32];
+	uint32_t	page_data_2[32];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_read_transceiver_data_t;
+
+/**
+ * @brief COMMON_READ_OBJECT
+ */
+typedef struct sli4_req_common_read_object_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	desired_read_length:24,
+			:8;
+	uint32_t	read_offset;
+	uint8_t		object_name[104];
+	uint32_t	host_buffer_descriptor_count;
+	sli4_bde_t	host_buffer_descriptor[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_read_object_t;
+
+typedef struct sli4_res_common_read_object_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	actual_read_length;
+	uint32_t	resv:31,
+			eof:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_read_object_t;
+
+/**
+ * @brief COMMON_WRITE_OBJECT
+ */
+typedef struct sli4_req_common_write_object_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	desired_write_length:24,
+			:6,
+			noc:1,
+			eof:1;
+	uint32_t	write_offset;
+	uint8_t		object_name[104];
+	uint32_t	host_buffer_descriptor_count;
+	sli4_bde_t	host_buffer_descriptor[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_write_object_t;
+
+typedef struct sli4_res_common_write_object_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	actual_write_length;
+	uint32_t	change_status:8,
+			:24;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_write_object_t;
+
+/**
+ * @brief COMMON_DELETE_OBJECT
+ */
+typedef struct sli4_req_common_delete_object_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd4;
+	uint32_t	rsvd5;
+	uint8_t		object_name[104];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_delete_object_t;
+
+/**
+ * @brief COMMON_READ_OBJECT_LIST
+ */
+typedef struct sli4_req_common_read_object_list_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	desired_read_length:24,
+			:8;
+	uint32_t	read_offset;
+	uint8_t		object_name[104];
+	uint32_t	host_buffer_descriptor_count;
+	sli4_bde_t	host_buffer_descriptor[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_read_object_list_t;
+
+/**
+ * @brief COMMON_SET_DUMP_LOCATION
+ */
+typedef struct sli4_req_common_set_dump_location_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	buffer_length:24,
+			:5,
+			fdb:1,
+			blp:1,
+			qry:1;
+	uint32_t	buf_addr_low;
+	uint32_t	buf_addr_high;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_dump_location_t;
+
+typedef struct sli4_res_common_set_dump_location_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	buffer_length:24,
+			:8;
+#else
+#error big endian version not defined
+#endif
+}sli4_res_common_set_dump_location_t;
+
+/**
+ * @brief COMMON_SET_SET_FEATURES
+ */
+#define SLI4_SET_FEATURES_DIF_SEED			0x01
+#define SLI4_SET_FEATURES_XRI_TIMER			0x03
+#define SLI4_SET_FEATURES_MAX_PCIE_SPEED		0x04
+#define SLI4_SET_FEATURES_FCTL_CHECK			0x05
+#define SLI4_SET_FEATURES_FEC				0x06
+#define SLI4_SET_FEATURES_PCIE_RECV_DETECT		0x07
+#define SLI4_SET_FEATURES_DIF_MEMORY_MODE		0x08
+#define SLI4_SET_FEATURES_DISABLE_SLI_PORT_PAUSE_STATE	0x09
+#define SLI4_SET_FEATURES_ENABLE_PCIE_OPTIONS		0x0A
+#define SLI4_SET_FEATURES_SET_CONFIG_AUTO_XFER_RDY_T10PI	0x0C
+#define SLI4_SET_FEATURES_ENABLE_MULTI_RECEIVE_QUEUE	0x0D
+#define SLI4_SET_FEATURES_SET_FTD_XFER_HINT		0x0F
+#define SLI4_SET_FEATURES_SLI_PORT_HEALTH_CHECK		0x11
+
+typedef struct sli4_req_common_set_features_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	feature;
+	uint32_t	param_len;
+	uint32_t	params[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_features_t;
+
+typedef struct sli4_req_common_set_features_dif_seed_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	seed:16,
+		:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_features_dif_seed_t;
+
+typedef struct sli4_req_common_set_features_t10_pi_mem_model_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	tmm:1,
+		:31;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_features_t10_pi_mem_model_t;
+
+typedef struct sli4_req_common_set_features_multirq_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	isr:1,			/*<< Include Sequence Reporting */
+			agxfe:1,		/*<< Auto Generate XFER-RDY Feature Enabled */
+			:30;
+	uint32_t	num_rqs:8,
+			rq_select_policy:4,
+			:20;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_features_multirq_t;
+
+typedef struct sli4_req_common_set_features_xfer_rdy_t10pi_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rtc:1,
+			atv:1,
+			tmm:1,
+			:1,
+			p_type:3,
+			blk_size:3,
+			:22;
+	uint32_t	app_tag:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_features_xfer_rdy_t10pi_t;
+
+typedef struct sli4_req_common_set_features_health_check_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	hck:1,
+			qry:1,
+			:30;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_features_health_check_t;
+
+typedef struct sli4_req_common_set_features_set_fdt_xfer_hint_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fdt_xfer_hint;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_features_set_fdt_xfer_hint_t;
+
+/**
+ * @brief DMTF_EXEC_CLP_CMD
+ */
+typedef struct sli4_req_dmtf_exec_clp_cmd_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	cmd_buf_length;
+	uint32_t	resp_buf_length;
+	uint32_t	cmd_buf_addr_low;
+	uint32_t	cmd_buf_addr_high;
+	uint32_t	resp_buf_addr_low;
+	uint32_t	resp_buf_addr_high;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_dmtf_exec_clp_cmd_t;
+
+typedef struct sli4_res_dmtf_exec_clp_cmd_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:32;
+	uint32_t	resp_length;
+	uint32_t	:32;
+	uint32_t	:32;
+	uint32_t	:32;
+	uint32_t	:32;
+	uint32_t	clp_status;
+	uint32_t	clp_detailed_status;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_dmtf_exec_clp_cmd_t;
+
+/**
+ * @brief Resource descriptor
+ */
+
+#define SLI4_RESOURCE_DESCRIPTOR_TYPE_PCIE	0x50
+#define SLI4_RESOURCE_DESCRIPTOR_TYPE_NIC	0x51
+#define SLI4_RESOURCE_DESCRIPTOR_TYPE_ISCSI	0x52
+#define SLI4_RESOURCE_DESCRIPTOR_TYPE_FCFCOE	0x53
+#define SLI4_RESOURCE_DESCRIPTOR_TYPE_RDMA	0x54
+#define SLI4_RESOURCE_DESCRIPTOR_TYPE_PORT	0x55
+#define SLI4_RESOURCE_DESCRIPTOR_TYPE_ISAP	0x56
+
+#define SLI4_PROTOCOL_NIC_TOE			0x01
+#define SLI4_PROTOCOL_ISCSI			0x02
+#define SLI4_PROTOCOL_FCOE			0x04
+#define SLI4_PROTOCOL_NIC_TOE_RDMA		0x08
+#define SLI4_PROTOCOL_FC			0x10
+#define SLI4_PROTOCOL_DEFAULT			0xff
+
+typedef struct sli4_resource_descriptor_v1_s {
+	uint32_t	descriptor_type:8,
+			descriptor_length:8,
+			:16;
+	uint32_t	type_specific[0];
+} sli4_resource_descriptor_v1_t;
+
+typedef struct sli4_pcie_resource_descriptor_v1_s {
+	uint32_t	descriptor_type:8,
+			descriptor_length:8,
+			:14,
+			imm:1,
+			nosv:1;
+	uint32_t	:16,
+			pf_number:10,
+			:6;
+	uint32_t        rsvd1;
+	uint32_t        sriov_state:8,
+			pf_state:8,
+			pf_type:8,
+			:8;
+	uint32_t        number_of_vfs:16,
+			:16;
+	uint32_t        mission_roles:8,
+			:19,
+			pchg:1,
+			schg:1,
+			xchg:1,
+			xrom:2;
+	uint32_t        rsvd2[16];
+} sli4_pcie_resource_descriptor_v1_t;
+
+typedef struct sli4_isap_resource_descriptor_v1_s {
+	uint32_t        descriptor_type:8,
+			descriptor_length:8,
+			:16;
+	uint32_t        iscsi_tgt:1,
+			iscsi_ini:1,
+			iscsi_dif:1,
+			:29;
+	uint32_t        rsvd1[3];
+	uint32_t        fcoe_tgt:1,
+			fcoe_ini:1,
+			fcoe_dif:1,
+			:29;
+	uint32_t        rsvd2[7];
+	uint32_t        mc_type0:8,
+			mc_type1:8,
+			mc_type2:8,
+			mc_type3:8;
+	uint32_t        rsvd3[3];
+} sli4_isap_resouce_descriptor_v1_t;
+
+/**
+ * @brief COMMON_GET_FUNCTION_CONFIG
+ */
+typedef struct sli4_req_common_get_function_config_s {
+	sli4_req_hdr_t  hdr;
+} sli4_req_common_get_function_config_t;
+
+typedef struct sli4_res_common_get_function_config_s {
+	sli4_res_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        desc_count;
+	uint32_t        desc[54];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_function_config_t;
+
+/**
+ * @brief COMMON_GET_PROFILE_CONFIG
+ */
+typedef struct sli4_req_common_get_profile_config_s {
+	sli4_req_hdr_t  hdr;
+	uint32_t        profile_id:8,
+			typ:2,
+			:22;
+} sli4_req_common_get_profile_config_t;
+
+typedef struct sli4_res_common_get_profile_config_s {
+	sli4_res_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        desc_count;
+	uint32_t        desc[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_profile_config_t;
+
+/**
+ * @brief COMMON_SET_PROFILE_CONFIG
+ */
+typedef struct sli4_req_common_set_profile_config_s {
+	sli4_req_hdr_t  hdr;
+	uint32_t        profile_id:8,
+			:23,
+			isap:1;
+	uint32_t        desc_count;
+	uint32_t        desc[0];
+} sli4_req_common_set_profile_config_t;
+
+typedef struct sli4_res_common_set_profile_config_s {
+	sli4_res_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_set_profile_config_t;
+
+/**
+ * @brief Profile Descriptor for profile functions
+ */
+typedef struct sli4_profile_descriptor_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        profile_id:8,
+			:8,
+			profile_index:8,
+			:8;
+	uint32_t        profile_description[128];
+#else
+#error big endian version not defined
+#endif
+} sli4_profile_descriptor_t;
+
+/* We don't know in advance how many descriptors there are.  We have
+   to pick a number that we think will be big enough and ask for that
+   many. */
+
+#define MAX_PRODUCT_DESCRIPTORS 40
+
+/**
+ * @brief COMMON_GET_PROFILE_LIST
+ */
+typedef struct sli4_req_common_get_profile_list_s {
+	sli4_req_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        start_profile_index:8,
+			:24;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_get_profile_list_t;
+
+typedef struct sli4_res_common_get_profile_list_s {
+	sli4_res_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        profile_descriptor_count;
+	sli4_profile_descriptor_t profile_descriptor[MAX_PRODUCT_DESCRIPTORS];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_profile_list_t;
+
+/**
+ * @brief COMMON_GET_ACTIVE_PROFILE
+ */
+typedef struct sli4_req_common_get_active_profile_s {
+	sli4_req_hdr_t  hdr;
+} sli4_req_common_get_active_profile_t;
+
+typedef struct sli4_res_common_get_active_profile_s {
+	sli4_res_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        active_profile_id:8,
+			:8,
+			next_profile_id:8,
+			:8;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_active_profile_t;
+
+/**
+ * @brief COMMON_SET_ACTIVE_PROFILE
+ */
+typedef struct sli4_req_common_set_active_profile_s {
+	sli4_req_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        active_profile_id:8,
+			:23,
+			fd:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_active_profile_t;
+
+typedef struct sli4_res_common_set_active_profile_s {
+	sli4_res_hdr_t  hdr;
+} sli4_res_common_set_active_profile_t;
+
+/**
+ * @brief Link Config Descriptor for link config functions
+ */
+typedef struct sli4_link_config_descriptor_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t        link_config_id:8,
+			:24;
+	uint32_t        config_description[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_link_config_descriptor_t;
+
+#define MAX_LINK_CONFIG_DESCRIPTORS 10
+
+/**
+ * @brief COMMON_GET_RECONFIG_LINK_INFO
+ */
+typedef struct sli4_req_common_get_reconfig_link_info_s {
+	sli4_req_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_get_reconfig_link_info_t;
+
+typedef struct sli4_res_common_get_reconfig_link_info_s {
+	sli4_res_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	active_link_config_id:8,
+			:8,
+			next_link_config_id:8,
+			:8;
+	uint32_t	link_configuration_descriptor_count;
+	sli4_link_config_descriptor_t	desc[MAX_LINK_CONFIG_DESCRIPTORS];
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_get_reconfig_link_info_t;
+
+/**
+ * @brief COMMON_SET_RECONFIG_LINK_ID
+ */
+typedef struct sli4_req_common_set_reconfig_link_id_s {
+	sli4_req_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	next_link_config_id:8,
+			:23,
+			fd:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_common_set_reconfig_link_id_t;
+
+typedef struct sli4_res_common_set_reconfig_link_id_s {
+	sli4_res_hdr_t  hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+#else
+#error big endian version not defined
+#endif
+} sli4_res_common_set_reconfig_link_id_t;
+
+
+typedef struct sli4_req_lowlevel_set_watchdog_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	watchdog_timeout:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+
+} sli4_req_lowlevel_set_watchdog_t;
+
+
+typedef struct sli4_res_lowlevel_set_watchdog_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_lowlevel_set_watchdog_t;
+
+/**
+ * @brief Event Queue Entry
+ */
+typedef struct sli4_eqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	vld:1,		/** valid */
+			major_code:3,
+			minor_code:12,
+			resource_id:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_eqe_t;
+
+#define SLI4_MAJOR_CODE_STANDARD	0
+#define SLI4_MAJOR_CODE_SENTINEL	1
+
+/**
+ * @brief Mailbox Completion Queue Entry
+ *
+ * A CQE generated on the completion of a MQE from a MQ.
+ */
+typedef struct sli4_mcqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	completion_status:16, /** values are protocol specific */
+			extended_status:16;
+	uint32_t	mqe_tag_low;
+	uint32_t	mqe_tag_high;
+	uint32_t	:27,
+			con:1,		/** consumed - command now being executed */
+			cmp:1,		/** completed - command still executing if clear */
+			:1,
+			ae:1,		/** async event - this is an ACQE */
+			val:1;		/** valid - contents of CQE are valid */
+#else
+#error big endian version not defined
+#endif
+} sli4_mcqe_t;
+
+
+/**
+ * @brief Asynchronous Completion Queue Entry
+ *
+ * A CQE generated asynchronously in response to the link or other internal events.
+ */
+typedef struct sli4_acqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	event_data[3];
+	uint32_t	:8,
+			event_code:8,
+			event_type:8,	/** values are protocol specific */
+			:6,
+			ae:1,		/** async event - this is an ACQE */
+			val:1;		/** valid - contents of CQE are valid */
+#else
+#error big endian version not defined
+#endif
+} sli4_acqe_t;
+
+#define SLI4_ACQE_EVENT_CODE_LINK_STATE		0x01
+#define SLI4_ACQE_EVENT_CODE_FCOE_FIP		0x02
+#define SLI4_ACQE_EVENT_CODE_DCBX		0x03
+#define SLI4_ACQE_EVENT_CODE_ISCSI		0x04
+#define SLI4_ACQE_EVENT_CODE_GRP_5		0x05
+#define SLI4_ACQE_EVENT_CODE_FC_LINK_EVENT	0x10
+#define SLI4_ACQE_EVENT_CODE_SLI_PORT_EVENT	0x11
+#define SLI4_ACQE_EVENT_CODE_VF_EVENT		0x12
+#define SLI4_ACQE_EVENT_CODE_MR_EVENT		0x13
+
+/**
+ * @brief Register name enums
+ */
+typedef enum {
+	SLI4_REG_BMBX,
+	SLI4_REG_EQCQ_DOORBELL,
+	SLI4_REG_FCOE_RQ_DOORBELL,
+	SLI4_REG_IO_WQ_DOORBELL,
+	SLI4_REG_MQ_DOORBELL,
+	SLI4_REG_PHYSDEV_CONTROL,
+	SLI4_REG_SLIPORT_CONTROL,
+	SLI4_REG_SLIPORT_ERROR1,
+	SLI4_REG_SLIPORT_ERROR2,
+	SLI4_REG_SLIPORT_SEMAPHORE,
+	SLI4_REG_SLIPORT_STATUS,
+	SLI4_REG_UERR_MASK_HI,
+	SLI4_REG_UERR_MASK_LO,
+	SLI4_REG_UERR_STATUS_HI,
+	SLI4_REG_UERR_STATUS_LO,
+	SLI4_REG_SW_UE_CSR1,
+	SLI4_REG_SW_UE_CSR2,
+	SLI4_REG_MAX			/* must be last */
+} sli4_regname_e;
+
+typedef struct sli4_reg_s {
+	uint32_t	rset;
+	uint32_t	off;
+} sli4_reg_t;
+
+typedef enum {
+	SLI_QTYPE_EQ,
+	SLI_QTYPE_CQ,
+	SLI_QTYPE_MQ,
+	SLI_QTYPE_WQ,
+	SLI_QTYPE_RQ,
+	SLI_QTYPE_MAX,			/* must be last */
+} sli4_qtype_e;
+
+#define SLI_USER_MQ_COUNT	1	/** User specified max mail queues */
+#define SLI_MAX_CQ_SET_COUNT	16
+#define SLI_MAX_RQ_SET_COUNT	16
+
+typedef enum {
+	SLI_QENTRY_ASYNC,
+	SLI_QENTRY_MQ,
+	SLI_QENTRY_RQ,
+	SLI_QENTRY_WQ,
+	SLI_QENTRY_WQ_RELEASE,
+	SLI_QENTRY_OPT_WRITE_CMD,
+	SLI_QENTRY_OPT_WRITE_DATA,
+	SLI_QENTRY_XABT,
+	SLI_QENTRY_MAX			/* must be last */
+} sli4_qentry_e;
+
+typedef struct sli4_queue_s {
+	/* Common to all queue types */
+	ocs_dma_t	dma;
+	ocs_lock_t	lock;
+	uint32_t	index;		/** current host entry index */
+	uint16_t	size;		/** entry size */
+	uint16_t	length;		/** number of entries */
+	uint16_t	n_posted;	/** number entries posted */
+	uint16_t	id;		/** Port assigned xQ_ID */
+	uint16_t	ulp;		/** ULP assigned to this queue */
+	uint32_t	doorbell_offset;/** The offset for the doorbell */
+	uint16_t	doorbell_rset;	/** register set for the doorbell */
+	uint8_t		type;		/** queue type ie EQ, CQ, ... */
+	uint32_t	proc_limit;	/** limit number of CQE processed per iteration */
+	uint32_t	posted_limit;	/** number of CQE/EQE to process before ringing doorbell */
+	uint32_t	max_num_processed;
+	time_t		max_process_time;
+
+	/* Type specific gunk */
+	union {
+		uint32_t	r_idx;	/** "read" index (MQ only) */
+		struct {
+			uint32_t	is_mq:1,/** CQ contains MQ/Async completions */
+					is_hdr:1,/** is a RQ for packet headers */
+					rq_batch:1;/** RQ index incremented by 8 */
+		} flag;
+	} u;
+} sli4_queue_t;
+
+static inline void
+sli_queue_lock(sli4_queue_t *q)
+{
+	ocs_lock(&q->lock);
+}
+
+static inline void
+sli_queue_unlock(sli4_queue_t *q)
+{
+	ocs_unlock(&q->lock);
+}
+
+
+#define SLI4_QUEUE_DEFAULT_CQ	UINT16_MAX /** Use the default CQ */
+
+#define SLI4_QUEUE_RQ_BATCH	8
+
+typedef enum {
+	SLI4_CB_LINK,
+	SLI4_CB_FIP,
+	SLI4_CB_MAX			/* must be last */
+} sli4_callback_e;
+
+typedef enum {
+	SLI_LINK_STATUS_UP,
+	SLI_LINK_STATUS_DOWN,
+	SLI_LINK_STATUS_NO_ALPA,
+	SLI_LINK_STATUS_MAX,
+} sli4_link_status_e;
+
+typedef enum {
+	SLI_LINK_TOPO_NPORT = 1,	/** fabric or point-to-point */
+	SLI_LINK_TOPO_LOOP,
+	SLI_LINK_TOPO_LOOPBACK_INTERNAL,
+	SLI_LINK_TOPO_LOOPBACK_EXTERNAL,
+	SLI_LINK_TOPO_NONE,
+	SLI_LINK_TOPO_MAX,
+} sli4_link_topology_e;
+
+/* TODO do we need both sli4_port_type_e & sli4_link_medium_e */
+typedef enum {
+	SLI_LINK_MEDIUM_ETHERNET,
+	SLI_LINK_MEDIUM_FC,
+	SLI_LINK_MEDIUM_MAX,
+} sli4_link_medium_e;
+
+typedef struct sli4_link_event_s {
+	sli4_link_status_e	status;		/* link up/down */
+	sli4_link_topology_e	topology;
+	sli4_link_medium_e	medium;		/* Ethernet / FC */
+	uint32_t		speed;		/* Mbps */
+	uint8_t			*loop_map;
+	uint32_t		fc_id;
+} sli4_link_event_t;
+
+/**
+ * @brief Fields retrieved from skyhawk that used used to build chained SGL
+ */
+typedef struct sli4_sgl_chaining_params_s {
+	uint8_t		chaining_capable;
+	uint16_t	frag_num_field_offset;
+	uint16_t	sgl_index_field_offset;
+	uint64_t	frag_num_field_mask;
+	uint64_t	sgl_index_field_mask;
+	uint32_t	chain_sge_initial_value_lo;
+	uint32_t	chain_sge_initial_value_hi;
+} sli4_sgl_chaining_params_t;
+
+typedef struct sli4_fip_event_s {
+	uint32_t	type;
+	uint32_t	index;		/* FCF index or UINT32_MAX if invalid */
+} sli4_fip_event_t;
+
+typedef enum {
+	SLI_RSRC_FCOE_VFI,
+	SLI_RSRC_FCOE_VPI,
+	SLI_RSRC_FCOE_RPI,
+	SLI_RSRC_FCOE_XRI,
+	SLI_RSRC_FCOE_FCFI,
+	SLI_RSRC_MAX			/* must be last */
+} sli4_resource_e;
+
+typedef enum {
+	SLI4_PORT_TYPE_FC,
+	SLI4_PORT_TYPE_NIC,
+	SLI4_PORT_TYPE_MAX		/* must be last */
+} sli4_port_type_e;
+
+typedef enum {
+	SLI4_ASIC_TYPE_BE3 = 1,
+	SLI4_ASIC_TYPE_SKYHAWK,
+	SLI4_ASIC_TYPE_LANCER,
+	SLI4_ASIC_TYPE_CORSAIR,
+	SLI4_ASIC_TYPE_LANCERG6,
+} sli4_asic_type_e;
+
+typedef enum {
+	SLI4_ASIC_REV_FPGA = 1,
+	SLI4_ASIC_REV_A0,
+	SLI4_ASIC_REV_A1,
+	SLI4_ASIC_REV_A2,
+	SLI4_ASIC_REV_A3,
+	SLI4_ASIC_REV_B0,
+	SLI4_ASIC_REV_B1,
+	SLI4_ASIC_REV_C0,
+	SLI4_ASIC_REV_D0,
+} sli4_asic_rev_e;
+
+typedef struct sli4_s {
+	ocs_os_handle_t	os;
+	sli4_port_type_e port_type;
+
+	uint32_t	sli_rev;	/* SLI revision number */
+	uint32_t	sli_family;
+	uint32_t	if_type;	/* SLI Interface type */
+
+	sli4_asic_type_e asic_type;	/*<< ASIC type */
+	sli4_asic_rev_e asic_rev;	/*<< ASIC revision */
+	uint32_t	physical_port;
+
+	struct {
+		uint16_t		e_d_tov;
+		uint16_t		r_a_tov;
+		uint16_t		max_qcount[SLI_QTYPE_MAX];
+		uint32_t		max_qentries[SLI_QTYPE_MAX];
+		uint16_t		count_mask[SLI_QTYPE_MAX];
+		uint16_t		count_method[SLI_QTYPE_MAX];
+		uint32_t		qpage_count[SLI_QTYPE_MAX];
+		uint16_t		link_module_type;
+		uint8_t			rq_batch;
+		uint16_t		rq_min_buf_size;
+		uint32_t		rq_max_buf_size;
+		uint8_t			topology;
+		uint8_t			wwpn[8];
+		uint8_t			wwnn[8];
+		uint32_t		fw_rev[2];
+		uint8_t			fw_name[2][16];
+		char			ipl_name[16];
+		uint32_t		hw_rev[3];
+		uint8_t			port_number;
+		char			port_name[2];
+		char			bios_version_string[32];
+		uint8_t			dual_ulp_capable;
+		uint8_t			is_ulp_fc[2];
+		/*
+		 * Tracks the port resources using extents metaphor. For
+		 * devices that don't implement extents (i.e.
+		 * has_extents == FALSE), the code models each resource as
+		 * a single large extent.
+		 */
+		struct {
+			uint32_t	number;	/* number of extents */
+			uint32_t	size;	/* number of elements in each extent */
+			uint32_t	n_alloc;/* number of elements allocated */
+			uint32_t	*base;
+			ocs_bitmap_t	*use_map;/* bitmap showing resources in use */
+			uint32_t	map_size;/* number of bits in bitmap */
+		} extent[SLI_RSRC_MAX];
+		sli4_features_t		features;
+		uint32_t		has_extents:1,
+					auto_reg:1,
+					auto_xfer_rdy:1,
+					hdr_template_req:1,
+					perf_hint:1,
+					perf_wq_id_association:1,
+					cq_create_version:2,
+					mq_create_version:2,
+					high_login_mode:1,
+					sgl_pre_registered:1,
+					sgl_pre_registration_required:1,
+					t10_dif_inline_capable:1,
+					t10_dif_separate_capable:1;
+		uint32_t		sge_supported_length;
+		uint32_t		sgl_page_sizes;
+		uint32_t		max_sgl_pages;
+		sli4_sgl_chaining_params_t sgl_chaining_params;
+		size_t			wqe_size;
+	} config;
+
+	/*
+	 * Callback functions
+	 */
+	int32_t		(*link)(void *, void *);
+	void		*link_arg;
+	int32_t		(*fip)(void *, void *);
+	void		*fip_arg;
+
+	ocs_dma_t	bmbx;
+#if defined(OCS_INCLUDE_DEBUG)
+	/* Save pointer to physical memory descriptor for non-embedded SLI_CONFIG
+	 * commands for BMBX dumping purposes */
+	ocs_dma_t	*bmbx_non_emb_pmd;
+#endif
+
+	struct {
+		ocs_dma_t	data;
+		uint32_t	length;
+	} vpd;
+} sli4_t;
+
+/**
+ * Get / set parameter functions
+ */
+static inline uint32_t
+sli_get_max_rsrc(sli4_t *sli4, sli4_resource_e rsrc)
+{
+	if (rsrc >= SLI_RSRC_MAX) {
+		return 0;
+	}
+
+	return sli4->config.extent[rsrc].size;
+}
+
+static inline uint32_t
+sli_get_max_queue(sli4_t *sli4, sli4_qtype_e qtype)
+{
+	if (qtype >= SLI_QTYPE_MAX) {
+		return 0;
+	}
+	return sli4->config.max_qcount[qtype];
+}
+
+static inline uint32_t
+sli_get_max_qentries(sli4_t *sli4, sli4_qtype_e qtype)
+{
+
+	return sli4->config.max_qentries[qtype];
+}
+
+static inline uint32_t
+sli_get_max_sge(sli4_t *sli4)
+{
+	return sli4->config.sge_supported_length;
+}
+
+static inline uint32_t
+sli_get_max_sgl(sli4_t *sli4)
+{
+
+	if (sli4->config.sgl_page_sizes != 1) {
+		ocs_log_test(sli4->os, "unsupported SGL page sizes %#x\n",
+				sli4->config.sgl_page_sizes);
+		return 0;
+	}
+
+	return ((sli4->config.max_sgl_pages * SLI_PAGE_SIZE) / sizeof(sli4_sge_t));
+}
+
+static inline sli4_link_medium_e
+sli_get_medium(sli4_t *sli4)
+{
+	switch (sli4->config.topology) {
+	case SLI4_READ_CFG_TOPO_FCOE:
+		return SLI_LINK_MEDIUM_ETHERNET;
+	case SLI4_READ_CFG_TOPO_FC:
+	case SLI4_READ_CFG_TOPO_FC_DA:
+	case SLI4_READ_CFG_TOPO_FC_AL:
+		return SLI_LINK_MEDIUM_FC;
+	default:
+		return SLI_LINK_MEDIUM_MAX;
+	}
+}
+
+static inline void
+sli_skh_chain_sge_build(sli4_t *sli4, sli4_sge_t *sge, uint32_t xri_index, uint32_t frag_num, uint32_t offset)
+{
+	sli4_sgl_chaining_params_t *cparms = &sli4->config.sgl_chaining_params;
+
+
+	ocs_memset(sge, 0, sizeof(*sge));
+	sge->sge_type = SLI4_SGE_TYPE_CHAIN;
+	sge->buffer_address_high = (uint32_t)cparms->chain_sge_initial_value_hi;
+	sge->buffer_address_low =
+		(uint32_t)((cparms->chain_sge_initial_value_lo |
+			    (((uintptr_t)(xri_index & cparms->sgl_index_field_mask)) <<
+			     cparms->sgl_index_field_offset) |
+			    (((uintptr_t)(frag_num & cparms->frag_num_field_mask)) <<
+			     cparms->frag_num_field_offset)  |
+			    offset) >> 3);
+}
+
+static inline uint32_t
+sli_get_sli_rev(sli4_t *sli4)
+{
+	return sli4->sli_rev;
+}
+
+static inline uint32_t
+sli_get_sli_family(sli4_t *sli4)
+{
+	return sli4->sli_family;
+}
+
+static inline uint32_t
+sli_get_if_type(sli4_t *sli4)
+{
+	return sli4->if_type;
+}
+
+static inline void *
+sli_get_wwn_port(sli4_t *sli4)
+{
+	return sli4->config.wwpn;
+}
+
+static inline void *
+sli_get_wwn_node(sli4_t *sli4)
+{
+	return sli4->config.wwnn;
+}
+
+static inline void *
+sli_get_vpd(sli4_t *sli4)
+{
+	return sli4->vpd.data.virt;
+}
+
+static inline uint32_t
+sli_get_vpd_len(sli4_t *sli4)
+{
+	return sli4->vpd.length;
+}
+
+static inline uint32_t
+sli_get_fw_revision(sli4_t *sli4, uint32_t which)
+{
+	return sli4->config.fw_rev[which];
+}
+
+static inline void *
+sli_get_fw_name(sli4_t *sli4, uint32_t which)
+{
+	return sli4->config.fw_name[which];
+}
+
+static inline char *
+sli_get_ipl_name(sli4_t *sli4)
+{
+	return sli4->config.ipl_name;
+}
+
+static inline uint32_t
+sli_get_hw_revision(sli4_t *sli4, uint32_t which)
+{
+	return sli4->config.hw_rev[which];
+}
+
+static inline uint32_t
+sli_get_auto_xfer_rdy_capable(sli4_t *sli4)
+{
+	return sli4->config.auto_xfer_rdy;
+}
+
+static inline uint32_t
+sli_get_dif_capable(sli4_t *sli4)
+{
+	return sli4->config.features.flag.dif;
+}
+
+static inline uint32_t
+sli_is_dif_inline_capable(sli4_t *sli4)
+{
+	return sli_get_dif_capable(sli4) && sli4->config.t10_dif_inline_capable;
+}
+
+static inline uint32_t
+sli_is_dif_separate_capable(sli4_t *sli4)
+{
+	return sli_get_dif_capable(sli4) && sli4->config.t10_dif_separate_capable;
+}
+
+static inline uint32_t
+sli_get_is_dual_ulp_capable(sli4_t *sli4)
+{
+	return sli4->config.dual_ulp_capable;
+}
+
+static inline uint32_t
+sli_get_is_sgl_chaining_capable(sli4_t *sli4)
+{
+	return sli4->config.sgl_chaining_params.chaining_capable;
+}
+
+static inline uint32_t
+sli_get_is_ulp_enabled(sli4_t *sli4, uint16_t ulp)
+{
+	return sli4->config.is_ulp_fc[ulp];
+}
+
+static inline uint32_t
+sli_get_hlm_capable(sli4_t *sli4)
+{
+	return sli4->config.features.flag.hlm;
+}
+
+static inline int32_t
+sli_set_hlm(sli4_t *sli4, uint32_t value)
+{
+	if (value && !sli4->config.features.flag.hlm) {
+		ocs_log_test(sli4->os, "HLM not supported\n");
+		return -1;
+	}
+
+	sli4->config.high_login_mode = value != 0 ? TRUE : FALSE;
+
+	return 0;
+}
+
+static inline uint32_t
+sli_get_hlm(sli4_t *sli4)
+{
+	return sli4->config.high_login_mode;
+}
+
+static inline uint32_t
+sli_get_sgl_preregister_required(sli4_t *sli4)
+{
+	return sli4->config.sgl_pre_registration_required;
+}
+
+static inline uint32_t
+sli_get_sgl_preregister(sli4_t *sli4)
+{
+	return sli4->config.sgl_pre_registered;
+}
+
+static inline int32_t
+sli_set_sgl_preregister(sli4_t *sli4, uint32_t value)
+{
+	if ((value == 0) && sli4->config.sgl_pre_registration_required) {
+		ocs_log_test(sli4->os, "SGL pre-registration required\n");
+		return -1;
+	}
+
+	sli4->config.sgl_pre_registered = value != 0 ? TRUE : FALSE;
+
+	return 0;
+}
+
+static inline sli4_asic_type_e
+sli_get_asic_type(sli4_t *sli4)
+{
+	return sli4->asic_type;
+}
+
+static inline sli4_asic_rev_e
+sli_get_asic_rev(sli4_t *sli4)
+{
+	return sli4->asic_rev;
+}
+
+static inline int32_t
+sli_set_topology(sli4_t *sli4, uint32_t value)
+{
+	int32_t	rc = 0;
+
+	switch (value) {
+	case SLI4_READ_CFG_TOPO_FCOE:
+	case SLI4_READ_CFG_TOPO_FC:
+	case SLI4_READ_CFG_TOPO_FC_DA:
+	case SLI4_READ_CFG_TOPO_FC_AL:
+		sli4->config.topology = value;
+		break;
+	default:
+		ocs_log_test(sli4->os, "unsupported topology %#x\n", value);
+		rc = -1;
+	}
+
+	return rc;
+}
+
+static inline uint16_t
+sli_get_link_module_type(sli4_t *sli4)
+{
+	return sli4->config.link_module_type;
+}
+
+static inline char *
+sli_get_portnum(sli4_t *sli4)
+{
+	return sli4->config.port_name;
+}
+
+static inline char *
+sli_get_bios_version_string(sli4_t *sli4)
+{
+	return sli4->config.bios_version_string;
+}
+
+static inline uint32_t
+sli_convert_mask_to_count(uint32_t method, uint32_t mask)
+{
+	uint32_t count = 0;
+
+	if (method) {
+		count = 1 << ocs_lg2(mask);
+		count *= 16;
+	} else {
+		count = mask;
+	}
+
+	return count;
+}
+
+/**
+ * @brief Common Create Queue function prototype
+ */
+typedef int32_t (*sli4_create_q_fn_t)(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, uint16_t);
+
+/**
+ * @brief Common Destroy Queue function prototype
+ */
+typedef int32_t (*sli4_destroy_q_fn_t)(sli4_t *, void *, size_t, uint16_t);
+
+
+/****************************************************************************
+ * Function prototypes
+ */
+extern int32_t sli_cmd_config_auto_xfer_rdy(sli4_t *, void *, size_t, uint32_t);
+extern int32_t sli_cmd_config_auto_xfer_rdy_hp(sli4_t *, void *, size_t, uint32_t, uint32_t, uint32_t);
+extern int32_t sli_cmd_config_link(sli4_t *, void *, size_t);
+extern int32_t sli_cmd_down_link(sli4_t *, void *, size_t);
+extern int32_t sli_cmd_dump_type4(sli4_t *, void *, size_t, uint16_t);
+extern int32_t sli_cmd_common_read_transceiver_data(sli4_t *, void *, size_t, uint32_t, ocs_dma_t *);
+extern int32_t sli_cmd_read_link_stats(sli4_t *, void *, size_t,uint8_t, uint8_t, uint8_t);
+extern int32_t sli_cmd_read_status(sli4_t *sli4, void *buf, size_t size, uint8_t clear_counters);
+extern int32_t sli_cmd_init_link(sli4_t *, void *, size_t, uint32_t, uint8_t);
+extern int32_t sli_cmd_init_vfi(sli4_t *, void *, size_t, uint16_t, uint16_t, uint16_t);
+extern int32_t sli_cmd_init_vpi(sli4_t *, void *, size_t, uint16_t, uint16_t);
+extern int32_t sli_cmd_post_xri(sli4_t *, void *, size_t,  uint16_t, uint16_t);
+extern int32_t sli_cmd_release_xri(sli4_t *, void *, size_t,  uint8_t);
+extern int32_t sli_cmd_read_sparm64(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t);
+extern int32_t sli_cmd_read_topology(sli4_t *, void *, size_t, ocs_dma_t *);
+extern int32_t sli_cmd_read_nvparms(sli4_t *, void *, size_t);
+extern int32_t sli_cmd_write_nvparms(sli4_t *, void *, size_t, uint8_t *, uint8_t *, uint8_t, uint32_t);
+typedef struct {
+	uint16_t rq_id;
+	uint8_t r_ctl_mask;
+	uint8_t r_ctl_match;
+	uint8_t type_mask;
+	uint8_t type_match;
+} sli4_cmd_rq_cfg_t;
+extern int32_t sli_cmd_reg_fcfi(sli4_t *, void *, size_t, uint16_t,
+				sli4_cmd_rq_cfg_t rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG], uint16_t);
+extern int32_t sli_cmd_reg_fcfi_mrq(sli4_t *, void *, size_t, uint8_t, uint16_t, uint16_t, uint8_t, uint8_t , uint16_t, sli4_cmd_rq_cfg_t *);
+
+extern int32_t sli_cmd_reg_rpi(sli4_t *, void *, size_t, uint32_t, uint16_t, uint16_t, ocs_dma_t *, uint8_t, uint8_t);
+extern int32_t sli_cmd_reg_vfi(sli4_t *, void *, size_t, ocs_domain_t *);
+extern int32_t sli_cmd_reg_vpi(sli4_t *, void *, size_t, ocs_sli_port_t *, uint8_t);
+extern int32_t sli_cmd_sli_config(sli4_t *, void *, size_t, uint32_t, ocs_dma_t *);
+extern int32_t sli_cmd_unreg_fcfi(sli4_t *, void *, size_t, uint16_t);
+extern int32_t sli_cmd_unreg_rpi(sli4_t *, void *, size_t, uint16_t, sli4_resource_e, uint32_t);
+extern int32_t sli_cmd_unreg_vfi(sli4_t *, void *, size_t, ocs_domain_t *, uint32_t);
+extern int32_t sli_cmd_unreg_vpi(sli4_t *, void *, size_t, uint16_t, uint32_t);
+extern int32_t sli_cmd_common_nop(sli4_t *, void *, size_t, uint64_t);
+extern int32_t sli_cmd_common_get_resource_extent_info(sli4_t *, void *, size_t, uint16_t);
+extern int32_t sli_cmd_common_get_sli4_parameters(sli4_t *, void *, size_t);
+extern int32_t sli_cmd_common_write_object(sli4_t *, void *, size_t,
+		uint16_t, uint16_t, uint32_t, uint32_t, char *, ocs_dma_t *);
+extern int32_t sli_cmd_common_delete_object(sli4_t *, void *, size_t, char *);
+extern int32_t sli_cmd_common_read_object(sli4_t *, void *, size_t, uint32_t,
+		uint32_t, char *, ocs_dma_t *);
+extern int32_t sli_cmd_dmtf_exec_clp_cmd(sli4_t *sli4, void *buf, size_t size,
+		ocs_dma_t *cmd,
+		ocs_dma_t *resp);
+extern int32_t sli_cmd_common_set_dump_location(sli4_t *sli4, void *buf, size_t size,
+						uint8_t query, uint8_t is_buffer_list,
+						ocs_dma_t *buffer, uint8_t fdb);
+extern int32_t sli_cmd_common_set_features(sli4_t *, void *, size_t, uint32_t, uint32_t, void*);
+extern int32_t sli_cmd_common_get_profile_list(sli4_t *sli4, void *buf,
+		size_t size, uint32_t start_profile_index, ocs_dma_t *dma);
+extern int32_t sli_cmd_common_get_active_profile(sli4_t *sli4, void *buf,
+		size_t size);
+extern int32_t sli_cmd_common_set_active_profile(sli4_t *sli4, void *buf,
+		size_t size,
+		uint32_t fd,
+		uint32_t active_profile_id);
+extern int32_t sli_cmd_common_get_reconfig_link_info(sli4_t *sli4, void *buf,
+		size_t size, ocs_dma_t *dma);
+extern int32_t sli_cmd_common_set_reconfig_link_id(sli4_t *sli4, void *buf,
+		size_t size, ocs_dma_t *dma,
+		uint32_t fd, uint32_t active_link_config_id);
+extern int32_t sli_cmd_common_get_function_config(sli4_t *sli4, void *buf,
+		size_t size);
+extern int32_t sli_cmd_common_get_profile_config(sli4_t *sli4, void *buf,
+		size_t size, ocs_dma_t *dma);
+extern int32_t sli_cmd_common_set_profile_config(sli4_t *sli4, void *buf,
+		size_t size, ocs_dma_t *dma,
+		uint8_t profile_id, uint32_t descriptor_count,
+		uint8_t isap);
+
+extern int32_t sli_cqe_mq(void *);
+extern int32_t sli_cqe_async(sli4_t *, void *);
+
+extern int32_t sli_setup(sli4_t *, ocs_os_handle_t, sli4_port_type_e);
+extern void sli_calc_max_qentries(sli4_t *sli4);
+extern int32_t sli_init(sli4_t *);
+extern int32_t sli_reset(sli4_t *);
+extern int32_t sli_fw_reset(sli4_t *);
+extern int32_t sli_teardown(sli4_t *);
+extern int32_t sli_callback(sli4_t *, sli4_callback_e, void *, void *);
+extern int32_t sli_bmbx_command(sli4_t *);
+extern int32_t __sli_queue_init(sli4_t *, sli4_queue_t *, uint32_t, size_t, uint32_t, uint32_t);
+extern int32_t __sli_create_queue(sli4_t *, sli4_queue_t *);
+extern int32_t sli_eq_modify_delay(sli4_t *sli4, sli4_queue_t *eq, uint32_t num_eq, uint32_t shift, uint32_t delay_mult);
+extern int32_t sli_queue_alloc(sli4_t *, uint32_t, sli4_queue_t *, uint32_t, sli4_queue_t *, uint16_t);
+extern int32_t sli_cq_alloc_set(sli4_t *, sli4_queue_t *qs[], uint32_t, uint32_t, sli4_queue_t *eqs[]);
+extern int32_t sli_get_queue_entry_size(sli4_t *, uint32_t);
+extern int32_t sli_queue_free(sli4_t *, sli4_queue_t *, uint32_t, uint32_t);
+extern int32_t sli_queue_reset(sli4_t *, sli4_queue_t *);
+extern int32_t sli_queue_is_empty(sli4_t *, sli4_queue_t *);
+extern int32_t sli_queue_eq_arm(sli4_t *, sli4_queue_t *, uint8_t);
+extern int32_t sli_queue_arm(sli4_t *, sli4_queue_t *, uint8_t);
+extern int32_t _sli_queue_write(sli4_t *, sli4_queue_t *, uint8_t *);
+extern int32_t sli_queue_write(sli4_t *, sli4_queue_t *, uint8_t *);
+extern int32_t sli_queue_read(sli4_t *, sli4_queue_t *, uint8_t *);
+extern int32_t sli_queue_index(sli4_t *, sli4_queue_t *);
+extern int32_t _sli_queue_poke(sli4_t *, sli4_queue_t *, uint32_t, uint8_t *);
+extern int32_t sli_queue_poke(sli4_t *, sli4_queue_t *, uint32_t, uint8_t *);
+extern int32_t sli_resource_alloc(sli4_t *, sli4_resource_e, uint32_t *, uint32_t *);
+extern int32_t sli_resource_free(sli4_t *, sli4_resource_e, uint32_t);
+extern int32_t sli_resource_reset(sli4_t *, sli4_resource_e);
+extern int32_t sli_eq_parse(sli4_t *, uint8_t *, uint16_t *);
+extern int32_t sli_cq_parse(sli4_t *, sli4_queue_t *, uint8_t *, sli4_qentry_e *, uint16_t *);
+
+extern int32_t sli_raise_ue(sli4_t *, uint8_t);
+extern int32_t sli_dump_is_ready(sli4_t *);
+extern int32_t sli_dump_is_present(sli4_t *);
+extern int32_t sli_reset_required(sli4_t *);
+extern int32_t sli_fw_error_status(sli4_t *);
+extern int32_t sli_fw_ready(sli4_t *);
+extern uint32_t sli_reg_read(sli4_t *, sli4_regname_e);
+extern void sli_reg_write(sli4_t *, sli4_regname_e, uint32_t);
+extern int32_t sli_link_is_configurable(sli4_t *);
+
+#include "ocs_fcp.h"
+
+/**
+ * @brief Maximum value for a FCFI
+ *
+ * Note that although most commands provide a 16 bit field for the FCFI,
+ * the FC/FCoE Asynchronous Recived CQE format only provides 6 bits for
+ * the returned FCFI. Then effectively, the FCFI cannot be larger than
+ * 1 << 6 or 64.
+ */
+#define SLI4_MAX_FCFI	64
+
+/**
+ * @brief Maximum value for FCF index
+ *
+ * The SLI-4 specification uses a 16 bit field in most places for the FCF
+ * index, but practically, this value will be much smaller. Arbitrarily
+ * limit the max FCF index to match the max FCFI value.
+ */
+#define SLI4_MAX_FCF_INDEX	SLI4_MAX_FCFI
+
+/*************************************************************************
+ * SLI-4 FC/FCoE mailbox command formats and definitions.
+ */
+
+/**
+ * FC/FCoE opcode (OPC) values.
+ */
+#define SLI4_OPC_FCOE_WQ_CREATE			0x1
+#define SLI4_OPC_FCOE_WQ_DESTROY		0x2
+#define SLI4_OPC_FCOE_POST_SGL_PAGES		0x3
+#define SLI4_OPC_FCOE_RQ_CREATE			0x5
+#define SLI4_OPC_FCOE_RQ_DESTROY		0x6
+#define SLI4_OPC_FCOE_READ_FCF_TABLE		0x8
+#define SLI4_OPC_FCOE_POST_HDR_TEMPLATES	0xb
+#define SLI4_OPC_FCOE_REDISCOVER_FCF		0x10
+
+/* Use the default CQ associated with the WQ */
+#define SLI4_CQ_DEFAULT 0xffff
+
+typedef struct sli4_physical_page_descriptor_s {
+	uint32_t	low;
+	uint32_t	high;
+} sli4_physical_page_descriptor_t;
+
+/**
+ * @brief FCOE_WQ_CREATE
+ *
+ * Create a Work Queue for FC/FCoE use.
+ */
+#define SLI4_FCOE_WQ_CREATE_V0_MAX_PAGES	4
+
+typedef struct sli4_req_fcoe_wq_create_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:8,
+			dua:1,
+			:7,
+			cq_id:16;
+	sli4_physical_page_descriptor_t page_physical_address[SLI4_FCOE_WQ_CREATE_V0_MAX_PAGES];
+	uint32_t	bqu:1,
+			:7,
+			ulp:8,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_wq_create_t;
+
+/**
+ * @brief FCOE_WQ_CREATE_V1
+ *
+ * Create a version 1 Work Queue for FC/FCoE use.
+ */
+typedef struct sli4_req_fcoe_wq_create_v1_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			cq_id:16;
+	uint32_t	page_size:8,
+			wqe_size:4,
+			:4,
+			wqe_count:16;
+	uint32_t	rsvd6;
+	sli4_physical_page_descriptor_t page_physical_address[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_wq_create_v1_t;
+
+#define SLI4_FCOE_WQ_CREATE_V1_MAX_PAGES	8
+
+/**
+ * @brief FCOE_WQ_DESTROY
+ *
+ * Destroy an FC/FCoE Work Queue.
+ */
+typedef struct sli4_req_fcoe_wq_destroy_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	wq_id:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_wq_destroy_t;
+
+/**
+ * @brief FCOE_POST_SGL_PAGES
+ *
+ * Register the scatter gather list (SGL) memory and associate it with an XRI.
+ */
+typedef struct sli4_req_fcoe_post_sgl_pages_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	xri_start:16,
+			xri_count:16;
+	struct {
+		uint32_t	page0_low;
+		uint32_t	page0_high;
+		uint32_t	page1_low;
+		uint32_t	page1_high;
+	} page_set[10];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_post_sgl_pages_t;
+
+/**
+ * @brief FCOE_RQ_CREATE
+ *
+ * Create a Receive Queue for FC/FCoE use.
+ */
+typedef struct sli4_req_fcoe_rq_create_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			dua:1,
+			bqu:1,
+			:6,
+			ulp:8;
+	uint32_t	:16,
+			rqe_count:4,
+			:12;
+	uint32_t	rsvd6;
+	uint32_t	buffer_size:16,
+			cq_id:16;
+	uint32_t	rsvd8;
+	sli4_physical_page_descriptor_t page_physical_address[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_rq_create_t;
+
+#define SLI4_FCOE_RQ_CREATE_V0_MAX_PAGES	8
+#define SLI4_FCOE_RQ_CREATE_V0_MIN_BUF_SIZE	128
+#define SLI4_FCOE_RQ_CREATE_V0_MAX_BUF_SIZE	2048
+
+/**
+ * @brief FCOE_RQ_CREATE_V1
+ *
+ * Create a version 1 Receive Queue for FC/FCoE use.
+ */
+typedef struct sli4_req_fcoe_rq_create_v1_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			:13,
+			dim:1,
+			dfd:1,
+			dnb:1;
+	uint32_t	page_size:8,
+			rqe_size:4,
+			:4,
+			rqe_count:16;
+	uint32_t	rsvd6;
+	uint32_t	:16,
+			cq_id:16;
+	uint32_t	buffer_size;
+	sli4_physical_page_descriptor_t page_physical_address[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_rq_create_v1_t;
+
+
+/**
+ * @brief FCOE_RQ_CREATE_V2
+ *
+ * Create a version 2 Receive Queue for FC/FCoE use.
+ */
+typedef struct sli4_req_fcoe_rq_create_v2_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	num_pages:16,
+			rq_count:8,
+			:5,
+			dim:1,
+			dfd:1,
+			dnb:1;
+	uint32_t	page_size:8,
+			rqe_size:4,
+			:4,
+			rqe_count:16;
+	uint32_t	hdr_buffer_size:16,
+			payload_buffer_size:16;
+	uint32_t	base_cq_id:16,
+			:16;
+	uint32_t	rsvd;
+	sli4_physical_page_descriptor_t page_physical_address[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_rq_create_v2_t;
+
+
+#define SLI4_FCOE_RQ_CREATE_V1_MAX_PAGES	8
+#define SLI4_FCOE_RQ_CREATE_V1_MIN_BUF_SIZE	64
+#define SLI4_FCOE_RQ_CREATE_V1_MAX_BUF_SIZE	2048
+
+#define SLI4_FCOE_RQE_SIZE_8			0x2
+#define SLI4_FCOE_RQE_SIZE_16			0x3
+#define SLI4_FCOE_RQE_SIZE_32			0x4
+#define SLI4_FCOE_RQE_SIZE_64			0x5
+#define SLI4_FCOE_RQE_SIZE_128			0x6
+
+#define SLI4_FCOE_RQ_PAGE_SIZE_4096		0x1
+#define SLI4_FCOE_RQ_PAGE_SIZE_8192		0x2
+#define SLI4_FCOE_RQ_PAGE_SIZE_16384		0x4
+#define SLI4_FCOE_RQ_PAGE_SIZE_32768		0x8
+#define SLI4_FCOE_RQ_PAGE_SIZE_64536		0x10
+
+#define SLI4_FCOE_RQE_SIZE			8
+
+/**
+ * @brief FCOE_RQ_DESTROY
+ *
+ * Destroy an FC/FCoE Receive Queue.
+ */
+typedef struct sli4_req_fcoe_rq_destroy_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rq_id:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_rq_destroy_t;
+
+/**
+ * @brief FCOE_READ_FCF_TABLE
+ *
+ * Retrieve a FCF database (also known as a table) entry created by the SLI Port
+ * during FIP discovery.
+ */
+typedef struct sli4_req_fcoe_read_fcf_table_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fcf_index:16,
+			:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_read_fcf_table_t;
+
+/* A FCF index of -1 on the request means return the first valid entry */
+#define SLI4_FCOE_FCF_TABLE_FIRST		(UINT16_MAX)
+
+/**
+ * @brief FCF table entry
+ *
+ * This is the information returned by the FCOE_READ_FCF_TABLE command.
+ */
+typedef struct sli4_fcf_entry_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	max_receive_size;
+	uint32_t	fip_keep_alive;
+	uint32_t	fip_priority;
+	uint8_t		fcf_mac_address[6];
+	uint8_t		fcf_available;
+	uint8_t		mac_address_provider;
+	uint8_t		fabric_name_id[8];
+	uint8_t		fc_map[3];
+	uint8_t		val:1,
+			fc:1,
+			:5,
+			sol:1;
+	uint32_t	fcf_index:16,
+			fcf_state:16;
+	uint8_t		vlan_bitmap[512];
+	uint8_t		switch_name[8];
+#else
+#error big endian version not defined
+#endif
+} sli4_fcf_entry_t;
+
+/**
+ * @brief FCOE_READ_FCF_TABLE response.
+ */
+typedef struct sli4_res_fcoe_read_fcf_table_s {
+	sli4_res_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	event_tag;
+	uint32_t	next_index:16,
+			:16;
+	sli4_fcf_entry_t fcf_entry;
+#else
+#error big endian version not defined
+#endif
+} sli4_res_fcoe_read_fcf_table_t;
+
+/* A next FCF index of -1 in the response means this is the last valid entry */
+#define SLI4_FCOE_FCF_TABLE_LAST		(UINT16_MAX)
+
+
+/**
+ * @brief FCOE_POST_HDR_TEMPLATES
+ */
+typedef struct sli4_req_fcoe_post_hdr_templates_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rpi_offset:16,
+			page_count:16;
+	sli4_physical_page_descriptor_t page_descriptor[0];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_post_hdr_templates_t;
+
+#define SLI4_FCOE_HDR_TEMPLATE_SIZE	64
+
+/**
+ * @brief FCOE_REDISCOVER_FCF
+ */
+typedef struct sli4_req_fcoe_rediscover_fcf_s {
+	sli4_req_hdr_t	hdr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fcf_count:16,
+			:16;
+	uint32_t	rsvd5;
+	uint16_t	fcf_index[16];
+#else
+#error big endian version not defined
+#endif
+} sli4_req_fcoe_rediscover_fcf_t;
+
+
+/**
+ * Work Queue Entry (WQE) types.
+ */
+#define SLI4_WQE_ABORT			0x0f
+#define SLI4_WQE_ELS_REQUEST64		0x8a
+#define SLI4_WQE_FCP_IBIDIR64		0xac
+#define SLI4_WQE_FCP_IREAD64		0x9a
+#define SLI4_WQE_FCP_IWRITE64		0x98
+#define SLI4_WQE_FCP_ICMND64		0x9c
+#define SLI4_WQE_FCP_TRECEIVE64		0xa1
+#define SLI4_WQE_FCP_CONT_TRECEIVE64	0xe5
+#define SLI4_WQE_FCP_TRSP64		0xa3
+#define SLI4_WQE_FCP_TSEND64		0x9f
+#define SLI4_WQE_GEN_REQUEST64		0xc2
+#define SLI4_WQE_SEND_FRAME		0xe1
+#define SLI4_WQE_XMIT_BCAST64		0X84
+#define SLI4_WQE_XMIT_BLS_RSP		0x97
+#define SLI4_WQE_ELS_RSP64		0x95
+#define SLI4_WQE_XMIT_SEQUENCE64	0x82
+#define SLI4_WQE_REQUEUE_XRI		0x93
+
+/**
+ * WQE command types.
+ */
+#define SLI4_CMD_FCP_IREAD64_WQE	0x00
+#define SLI4_CMD_FCP_ICMND64_WQE	0x00
+#define SLI4_CMD_FCP_IWRITE64_WQE	0x01
+#define SLI4_CMD_FCP_TRECEIVE64_WQE	0x02
+#define SLI4_CMD_FCP_TRSP64_WQE		0x03
+#define SLI4_CMD_FCP_TSEND64_WQE	0x07
+#define SLI4_CMD_GEN_REQUEST64_WQE	0x08
+#define SLI4_CMD_XMIT_BCAST64_WQE	0x08
+#define SLI4_CMD_XMIT_BLS_RSP64_WQE	0x08
+#define SLI4_CMD_ABORT_WQE		0x08
+#define SLI4_CMD_XMIT_SEQUENCE64_WQE	0x08
+#define SLI4_CMD_REQUEUE_XRI_WQE	0x0A
+#define SLI4_CMD_SEND_FRAME_WQE		0x0a
+
+#define SLI4_WQE_SIZE			0x05
+#define SLI4_WQE_EXT_SIZE		0x06
+
+#define SLI4_WQE_BYTES			(16 * sizeof(uint32_t))
+#define SLI4_WQE_EXT_BYTES		(32 * sizeof(uint32_t))
+
+/* Mask for ccp (CS_CTL) */
+#define SLI4_MASK_CCP	0xfe /* Upper 7 bits of CS_CTL is priority */
+
+/**
+ * @brief Generic WQE
+ */
+typedef struct sli4_generic_wqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	cmd_spec0_5[6];
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_generic_wqe_t;
+
+/**
+ * @brief WQE used to abort exchanges.
+ */
+typedef struct sli4_abort_wqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	rsvd0;
+	uint32_t	rsvd1;
+	uint32_t	ext_t_tag;
+	uint32_t	ia:1,
+			ir:1,
+			:6,
+			criteria:8,
+			:16;
+	uint32_t	ext_t_mask;
+	uint32_t	t_mask;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	t_tag;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+#else
+#error big endian version not defined
+#endif
+} sli4_abort_wqe_t;
+
+#define SLI4_ABORT_CRITERIA_XRI_TAG		0x01
+#define SLI4_ABORT_CRITERIA_ABORT_TAG		0x02
+#define SLI4_ABORT_CRITERIA_REQUEST_TAG		0x03
+#define SLI4_ABORT_CRITERIA_EXT_ABORT_TAG	0x04
+
+typedef enum {
+	SLI_ABORT_XRI,
+	SLI_ABORT_ABORT_ID,
+	SLI_ABORT_REQUEST_ID,
+	SLI_ABORT_MAX,		/* must be last */
+} sli4_abort_type_e;
+
+/**
+ * @brief WQE used to create an ELS request.
+ */
+typedef struct sli4_els_request64_wqe_s {
+	sli4_bde_t	els_request_payload;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	els_request_payload_length;
+	uint32_t	sid:24,
+			sp:1,
+			:7;
+	uint32_t	remote_id:24,
+			:8;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			ar:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			temporary_rpi:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			els_id:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	sli4_bde_t	els_response_payload_bde;
+	uint32_t	max_response_payload_length;
+#else
+#error big endian version not defined
+#endif
+} sli4_els_request64_wqe_t;
+
+#define SLI4_ELS_REQUEST64_CONTEXT_RPI	0x0
+#define SLI4_ELS_REQUEST64_CONTEXT_VPI	0x1
+#define SLI4_ELS_REQUEST64_CONTEXT_VFI	0x2
+#define SLI4_ELS_REQUEST64_CONTEXT_FCFI	0x3
+
+#define SLI4_ELS_REQUEST64_CLASS_2	0x1
+#define SLI4_ELS_REQUEST64_CLASS_3	0x2
+
+#define SLI4_ELS_REQUEST64_DIR_WRITE	0x0
+#define SLI4_ELS_REQUEST64_DIR_READ	0x1
+
+#define SLI4_ELS_REQUEST64_OTHER	0x0
+#define SLI4_ELS_REQUEST64_LOGO		0x1
+#define SLI4_ELS_REQUEST64_FDISC	0x2
+#define SLI4_ELS_REQUEST64_FLOGIN	0x3
+#define SLI4_ELS_REQUEST64_PLOGI	0x4
+
+#define SLI4_ELS_REQUEST64_CMD_GEN		0x08
+#define SLI4_ELS_REQUEST64_CMD_NON_FABRIC	0x0c
+#define SLI4_ELS_REQUEST64_CMD_FABRIC		0x0d
+
+/**
+ * @brief WQE used to create an FCP initiator no data command.
+ */
+typedef struct sli4_fcp_icmnd64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	payload_offset_length:16,
+			fcp_cmd_buffer_length:16;
+	uint32_t	rsvd4;
+	uint32_t	remote_n_port_id:24,
+			:8;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	dif:2,
+			ct:2,
+			bs:3,
+			:1,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			erp:1,
+			lnk:1,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	rsvd12;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	rsvd15;
+#else
+#error big endian version not defined
+#endif
+} sli4_fcp_icmnd64_wqe_t;
+
+/**
+ * @brief WQE used to create an FCP initiator read.
+ */
+typedef struct sli4_fcp_iread64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	payload_offset_length:16,
+			fcp_cmd_buffer_length:16;
+	uint32_t	total_transfer_length;
+	uint32_t	remote_n_port_id:24,
+			:8;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	dif:2,
+			ct:2,
+			bs:3,
+			:1,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			erp:1,
+			lnk:1,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	rsvd12;
+#else
+#error big endian version not defined
+#endif
+	sli4_bde_t	first_data_bde;	/* reserved if performance hints disabled */
+} sli4_fcp_iread64_wqe_t;
+
+/**
+ * @brief WQE used to create an FCP initiator write.
+ */
+typedef struct sli4_fcp_iwrite64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	payload_offset_length:16,
+			fcp_cmd_buffer_length:16;
+	uint32_t	total_transfer_length;
+	uint32_t	initial_transfer_length;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	dif:2,
+			ct:2,
+			bs:3,
+			:1,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			erp:1,
+			lnk:1,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	remote_n_port_id:24,
+			:8;
+#else
+#error big endian version not defined
+#endif
+	sli4_bde_t	first_data_bde;
+} sli4_fcp_iwrite64_wqe_t;
+
+
+typedef struct sli4_fcp_128byte_wqe_s {
+	uint32_t dw[32];	
+} sli4_fcp_128byte_wqe_t;
+
+/**
+ * @brief WQE used to create an FCP target receive, and FCP target
+ * receive continue.
+ */
+typedef struct sli4_fcp_treceive64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	payload_offset_length;
+	uint32_t	relative_offset;
+	/**
+	 * DWord 5 can either be the task retry identifier (HLM=0) or
+	 * the remote N_Port ID (HLM=1), or if implementing the Skyhawk
+	 * T10-PI workaround, the secondary xri tag
+	 */
+	union {
+		uint32_t	sec_xri_tag:16,
+				:16;
+		uint32_t	dword;
+	} dword5;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	dif:2,
+			ct:2,
+			bs:3,
+			:1,
+			command:8,
+			class:3,
+			ar:1,
+			pu:2,
+			conf:1,
+			lnk:1,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			remote_xid:16;
+	uint32_t	ebde_cnt:4,
+			:1,
+			app_id_valid:1,
+			:1,
+			len_loc:2,
+			qosd:1,
+			wchn:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			sr:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	fcp_data_receive_length;
+
+#else
+#error big endian version not defined
+#endif
+	sli4_bde_t	first_data_bde; /* For performance hints */
+
+} sli4_fcp_treceive64_wqe_t;
+
+/**
+ * @brief WQE used to create an FCP target response.
+ */
+typedef struct sli4_fcp_trsp64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	fcp_response_length;
+	uint32_t	rsvd4;
+	/**
+	 * DWord 5 can either be the task retry identifier (HLM=0) or
+	 * the remote N_Port ID (HLM=1)
+	 */
+	uint32_t	dword5;
+	uint32_t	xri_tag:16,
+			rpi:16;
+	uint32_t	:2,
+			ct:2,
+			dnrx:1,
+			:3,
+			command:8,
+			class:3,
+			ag:1,
+			pu:2,
+			conf:1,
+			lnk:1,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			remote_xid:16;
+	uint32_t	ebde_cnt:4,
+			:1,
+			app_id_valid:1,
+			:1,
+			len_loc:2,
+			qosd:1,
+			wchn:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			sr:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	rsvd12;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	rsvd15;
+#else
+#error big endian version not defined
+#endif
+} sli4_fcp_trsp64_wqe_t;
+
+/**
+ * @brief WQE used to create an FCP target send (DATA IN).
+ */
+typedef struct sli4_fcp_tsend64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	payload_offset_length;
+	uint32_t	relative_offset;
+	/**
+	 * DWord 5 can either be the task retry identifier (HLM=0) or
+	 * the remote N_Port ID (HLM=1)
+	 */
+	uint32_t	dword5;
+	uint32_t	xri_tag:16,
+			rpi:16;
+	uint32_t	dif:2,
+			ct:2,
+			bs:3,
+			:1,
+			command:8,
+			class:3,
+			ar:1,
+			pu:2,
+			conf:1,
+			lnk:1,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			remote_xid:16;
+	uint32_t	ebde_cnt:4,
+			:1,
+			app_id_valid:1,
+			:1,
+			len_loc:2,
+			qosd:1,
+			wchn:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			sr:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	fcp_data_transmit_length;
+
+#else
+#error big endian version not defined
+#endif
+	sli4_bde_t	first_data_bde; /* For performance hints */
+} sli4_fcp_tsend64_wqe_t;
+
+#define SLI4_IO_CONTINUATION		BIT(0)	/** The XRI associated with this IO is already active */
+#define SLI4_IO_AUTO_GOOD_RESPONSE	BIT(1)	/** Automatically generate a good RSP frame */
+#define SLI4_IO_NO_ABORT		BIT(2)
+#define SLI4_IO_DNRX			BIT(3)	/** Set the DNRX bit because no auto xref rdy buffer is posted */
+
+/* WQE DIF field contents */
+#define SLI4_DIF_DISABLED		0
+#define SLI4_DIF_PASS_THROUGH		1
+#define SLI4_DIF_STRIP			2
+#define SLI4_DIF_INSERT			3
+
+/**
+ * @brief WQE used to create a general request.
+ */
+typedef struct sli4_gen_request64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	request_payload_length;
+	uint32_t	relative_offset;
+	uint32_t	:8,
+			df_ctl:8,
+			type:8,
+			r_ctl:8;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	remote_n_port_id:24,
+			:8;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	max_response_payload_length;
+#else
+#error big endian version not defined
+#endif
+} sli4_gen_request64_wqe_t;
+
+/**
+ * @brief WQE used to create a send frame request.
+ */
+typedef struct sli4_send_frame_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	frame_length;
+	uint32_t	fc_header_0_1[2];
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			eof:8,
+			sof:8;
+	uint32_t	ebde_cnt:4,
+			:3,
+			lenloc:2,
+			qosd:1,
+			wchn:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	fc_header_2_5[4];
+#else
+#error big endian version not defined
+#endif
+} sli4_send_frame_wqe_t;
+
+/**
+ * @brief WQE used to create a transmit sequence.
+ */
+typedef struct sli4_xmit_sequence64_wqe_s {
+	sli4_bde_t	bde;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	remote_n_port_id:24,
+			:8;
+	uint32_t	relative_offset;
+	uint32_t	:2,
+			si:1,
+			ft:1,
+			:2,
+			xo:1,
+			ls:1,
+			df_ctl:8,
+			type:8,
+			r_ctl:8;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	dif:2,
+			ct:2,
+			bs:3,
+			:1,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			remote_xid:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			sr:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	sequence_payload_len;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	rsvd15;
+#else
+#error big endian version not defined
+#endif
+} sli4_xmit_sequence64_wqe_t;
+
+/**
+ * @brief WQE used unblock the specified XRI and to release it to the SLI Port's free pool.
+ */
+typedef struct sli4_requeue_xri_wqe_s {
+	uint32_t	rsvd0;
+	uint32_t	rsvd1;
+	uint32_t	rsvd2;
+	uint32_t	rsvd3;
+	uint32_t	rsvd4;
+	uint32_t	rsvd5;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	rsvd8;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			wchn:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	rsvd12;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	rsvd15;
+#else
+#error big endian version not defined
+#endif
+} sli4_requeue_xri_wqe_t;
+
+/**
+ * @brief WQE used to send a single frame sequence to broadcast address
+ */
+typedef struct sli4_xmit_bcast64_wqe_s {
+	sli4_bde_t	sequence_payload;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	sequence_payload_length;
+	uint32_t	rsvd4;
+	uint32_t	:8,
+			df_ctl:8,
+			type:8,
+			r_ctl:8;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			temporary_rpi:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	rsvd12;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	rsvd15;
+#else
+#error big endian version not defined
+#endif
+} sli4_xmit_bcast64_wqe_t;
+
+/**
+ * @brief WQE used to create a BLS response.
+ */
+typedef struct sli4_xmit_bls_rsp_wqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	payload_word0;
+	uint32_t	rx_id:16,
+			ox_id:16;
+	uint32_t	high_seq_cnt:16,
+			low_seq_cnt:16;
+	uint32_t	rsvd3;
+	uint32_t	local_n_port_id:24,
+			:8;
+	uint32_t	remote_id:24,
+			:6,
+			ar:1,
+			xo:1;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	temporary_rpi:16,
+			:16;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	rsvd15;
+#else
+#error big endian version not defined
+#endif
+} sli4_xmit_bls_rsp_wqe_t;
+
+typedef enum {
+	SLI_BLS_ACC,
+	SLI_BLS_RJT,
+	SLI_BLS_MAX
+} sli_bls_type_e;
+
+typedef struct sli_bls_payload_s {
+	sli_bls_type_e	type;
+	uint16_t	ox_id;
+	uint16_t	rx_id;
+	union {
+		struct {
+			uint32_t	seq_id_validity:8,
+					seq_id_last:8,
+					:16;
+			uint16_t	ox_id;
+			uint16_t	rx_id;
+			uint16_t	low_seq_cnt;
+			uint16_t	high_seq_cnt;
+		} acc;
+		struct {
+			uint32_t	vendor_unique:8,
+					reason_explanation:8,
+					reason_code:8,
+					:8;
+		} rjt;
+	} u;
+} sli_bls_payload_t;
+
+/**
+ * @brief WQE used to create an ELS response.
+ */
+typedef struct sli4_xmit_els_rsp64_wqe_s {
+	sli4_bde_t	els_response_payload;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	els_response_payload_length;
+	uint32_t	s_id:24,
+			sp:1,
+			:7;
+	uint32_t	remote_id:24,
+			:8;
+	uint32_t	xri_tag:16,
+			context_tag:16;
+	uint32_t	:2,
+			ct:2,
+			:4,
+			command:8,
+			class:3,
+			:1,
+			pu:2,
+			:2,
+			timer:8;
+	uint32_t	abort_tag;
+	uint32_t	request_tag:16,
+			ox_id:16;
+	uint32_t	ebde_cnt:4,
+			:3,
+			len_loc:2,
+			qosd:1,
+			:1,
+			xbl:1,
+			hlm:1,
+			iod:1,
+			dbde:1,
+			wqes:1,
+			pri:3,
+			pv:1,
+			eat:1,
+			xc:1,
+			:1,
+			ccpe:1,
+			ccp:8;
+	uint32_t	cmd_type:4,
+			:3,
+			wqec:1,
+			:8,
+			cq_id:16;
+	uint32_t	temporary_rpi:16,
+			:16;
+	uint32_t	rsvd13;
+	uint32_t	rsvd14;
+	uint32_t	rsvd15;
+#else
+#error big endian version not defined
+#endif
+} sli4_xmit_els_rsp64_wqe_t;
+
+/**
+ * @brief Asynchronouse Event: Link State ACQE.
+ */
+typedef struct sli4_link_state_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	link_number:6,
+			link_type:2,
+			port_link_status:8,
+			port_duplex:8,
+			port_speed:8;
+	uint32_t	port_fault:8,
+			:8,
+			logical_link_speed:16;
+	uint32_t	event_tag;
+	uint32_t	:8,
+			event_code:8,
+			event_type:8,	/** values are protocol specific */
+			:6,
+			ae:1,		/** async event - this is an ACQE */
+			val:1;		/** valid - contents of CQE are valid */
+#else
+#error big endian version not defined
+#endif
+} sli4_link_state_t;
+
+
+#define SLI4_LINK_ATTN_TYPE_LINK_UP		0x01
+#define SLI4_LINK_ATTN_TYPE_LINK_DOWN		0x02
+#define SLI4_LINK_ATTN_TYPE_NO_HARD_ALPA	0x03
+
+#define SLI4_LINK_ATTN_P2P			0x01
+#define SLI4_LINK_ATTN_FC_AL			0x02
+#define SLI4_LINK_ATTN_INTERNAL_LOOPBACK	0x03
+#define SLI4_LINK_ATTN_SERDES_LOOPBACK		0x04
+
+#define SLI4_LINK_ATTN_1G			0x01
+#define SLI4_LINK_ATTN_2G			0x02
+#define SLI4_LINK_ATTN_4G			0x04
+#define SLI4_LINK_ATTN_8G			0x08
+#define SLI4_LINK_ATTN_10G			0x0a
+#define SLI4_LINK_ATTN_16G			0x10
+
+#define SLI4_LINK_TYPE_ETHERNET			0x0
+#define SLI4_LINK_TYPE_FC			0x1
+
+/**
+ * @brief Asynchronouse Event: FC Link Attention Event.
+ */
+typedef struct sli4_link_attention_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	link_number:8,
+			attn_type:8,
+			topology:8,
+			port_speed:8;
+	uint32_t	port_fault:8,
+			shared_link_status:8,
+			logical_link_speed:16;
+	uint32_t	event_tag;
+	uint32_t	:8,
+			event_code:8,
+			event_type:8,	/** values are protocol specific */
+			:6,
+			ae:1,		/** async event - this is an ACQE */
+			val:1;		/** valid - contents of CQE are valid */
+#else
+#error big endian version not defined
+#endif
+} sli4_link_attention_t;
+
+/**
+ * @brief FC/FCoE event types.
+ */
+#define SLI4_LINK_STATE_PHYSICAL		0x00
+#define SLI4_LINK_STATE_LOGICAL			0x01
+
+#define SLI4_FCOE_FIP_FCF_DISCOVERED		0x01
+#define SLI4_FCOE_FIP_FCF_TABLE_FULL		0x02
+#define SLI4_FCOE_FIP_FCF_DEAD			0x03
+#define SLI4_FCOE_FIP_FCF_CLEAR_VLINK		0x04
+#define SLI4_FCOE_FIP_FCF_MODIFIED		0x05
+
+#define SLI4_GRP5_QOS_SPEED			0x01
+
+#define SLI4_FC_EVENT_LINK_ATTENTION		0x01
+#define SLI4_FC_EVENT_SHARED_LINK_ATTENTION	0x02
+
+#define SLI4_PORT_SPEED_NO_LINK			0x0
+#define SLI4_PORT_SPEED_10_MBPS			0x1
+#define SLI4_PORT_SPEED_100_MBPS		0x2
+#define SLI4_PORT_SPEED_1_GBPS			0x3
+#define SLI4_PORT_SPEED_10_GBPS			0x4
+
+#define SLI4_PORT_DUPLEX_NONE			0x0
+#define SLI4_PORT_DUPLEX_HWF			0x1
+#define SLI4_PORT_DUPLEX_FULL			0x2
+
+#define SLI4_PORT_LINK_STATUS_PHYSICAL_DOWN	0x0
+#define SLI4_PORT_LINK_STATUS_PHYSICAL_UP	0x1
+#define SLI4_PORT_LINK_STATUS_LOGICAL_DOWN	0x2
+#define SLI4_PORT_LINK_STATUS_LOGICAL_UP	0x3
+
+/**
+ * @brief Asynchronouse Event: FCoE/FIP ACQE.
+ */
+typedef struct sli4_fcoe_fip_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	event_information;
+	uint32_t	fcf_count:16,
+			fcoe_event_type:16;
+	uint32_t	event_tag;
+	uint32_t	:8,
+			event_code:8,
+			event_type:8,	/** values are protocol specific */
+			:6,
+			ae:1,		/** async event - this is an ACQE */
+			val:1;		/** valid - contents of CQE are valid */
+#else
+#error big endian version not defined
+#endif
+} sli4_fcoe_fip_t;
+
+/**
+ * @brief FC/FCoE WQ completion queue entry.
+ */
+typedef struct sli4_fc_wcqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	hw_status:8,
+			status:8,
+			request_tag:16;
+	uint32_t	wqe_specific_1;
+	uint32_t	wqe_specific_2;
+	uint32_t	:15,
+			qx:1,
+			code:8,
+			pri:3,
+			pv:1,
+			xb:1,
+			:2,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_wcqe_t;
+
+/**
+ * @brief FC/FCoE WQ consumed CQ queue entry.
+ */
+typedef struct sli4_fc_wqec_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:32;
+	uint32_t	:32;
+	uint32_t	wqe_index:16,
+			wq_id:16;
+	uint32_t	:16,
+			code:8,
+			:7,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_wqec_t;
+
+/**
+ * @brief FC/FCoE Completion Status Codes.
+ */
+#define SLI4_FC_WCQE_STATUS_SUCCESS		0x00
+#define SLI4_FC_WCQE_STATUS_FCP_RSP_FAILURE	0x01
+#define SLI4_FC_WCQE_STATUS_REMOTE_STOP		0x02
+#define SLI4_FC_WCQE_STATUS_LOCAL_REJECT	0x03
+#define SLI4_FC_WCQE_STATUS_NPORT_RJT		0x04
+#define SLI4_FC_WCQE_STATUS_FABRIC_RJT		0x05
+#define SLI4_FC_WCQE_STATUS_NPORT_BSY		0x06
+#define SLI4_FC_WCQE_STATUS_FABRIC_BSY		0x07
+#define SLI4_FC_WCQE_STATUS_LS_RJT		0x09
+#define SLI4_FC_WCQE_STATUS_CMD_REJECT		0x0b
+#define SLI4_FC_WCQE_STATUS_FCP_TGT_LENCHECK	0x0c
+#define SLI4_FC_WCQE_STATUS_RQ_BUF_LEN_EXCEEDED	0x11
+#define SLI4_FC_WCQE_STATUS_RQ_INSUFF_BUF_NEEDED 0x12
+#define SLI4_FC_WCQE_STATUS_RQ_INSUFF_FRM_DISC	0x13
+#define SLI4_FC_WCQE_STATUS_RQ_DMA_FAILURE	0x14
+#define SLI4_FC_WCQE_STATUS_FCP_RSP_TRUNCATE	0x15
+#define SLI4_FC_WCQE_STATUS_DI_ERROR		0x16
+#define SLI4_FC_WCQE_STATUS_BA_RJT		0x17
+#define SLI4_FC_WCQE_STATUS_RQ_INSUFF_XRI_NEEDED 0x18
+#define SLI4_FC_WCQE_STATUS_RQ_INSUFF_XRI_DISC	0x19
+#define SLI4_FC_WCQE_STATUS_RX_ERROR_DETECT	0x1a
+#define SLI4_FC_WCQE_STATUS_RX_ABORT_REQUEST	0x1b
+
+/* driver generated status codes; better not overlap with chip's status codes! */
+#define SLI4_FC_WCQE_STATUS_TARGET_WQE_TIMEOUT  0xff
+#define SLI4_FC_WCQE_STATUS_SHUTDOWN		0xfe
+#define SLI4_FC_WCQE_STATUS_DISPATCH_ERROR	0xfd
+
+/**
+ * @brief DI_ERROR Extended Status
+ */
+#define SLI4_FC_DI_ERROR_GE	(1 << 0) /* Guard Error */
+#define SLI4_FC_DI_ERROR_AE	(1 << 1) /* Application Tag Error */
+#define SLI4_FC_DI_ERROR_RE	(1 << 2) /* Reference Tag Error */
+#define SLI4_FC_DI_ERROR_TDPV	(1 << 3) /* Total Data Placed Valid */
+#define SLI4_FC_DI_ERROR_UDB	(1 << 4) /* Uninitialized DIF Block */
+#define SLI4_FC_DI_ERROR_EDIR   (1 << 5) /* Error direction */
+
+/**
+ * @brief Local Reject Reason Codes.
+ */
+#define SLI4_FC_LOCAL_REJECT_MISSING_CONTINUE	0x01
+#define SLI4_FC_LOCAL_REJECT_SEQUENCE_TIMEOUT	0x02
+#define SLI4_FC_LOCAL_REJECT_INTERNAL_ERROR	0x03
+#define SLI4_FC_LOCAL_REJECT_INVALID_RPI	0x04
+#define SLI4_FC_LOCAL_REJECT_NO_XRI		0x05
+#define SLI4_FC_LOCAL_REJECT_ILLEGAL_COMMAND	0x06
+#define SLI4_FC_LOCAL_REJECT_XCHG_DROPPED	0x07
+#define SLI4_FC_LOCAL_REJECT_ILLEGAL_FIELD	0x08
+#define SLI4_FC_LOCAL_REJECT_NO_ABORT_MATCH	0x0c
+#define SLI4_FC_LOCAL_REJECT_TX_DMA_FAILED	0x0d
+#define SLI4_FC_LOCAL_REJECT_RX_DMA_FAILED	0x0e
+#define SLI4_FC_LOCAL_REJECT_ILLEGAL_FRAME	0x0f
+#define SLI4_FC_LOCAL_REJECT_NO_RESOURCES	0x11
+#define SLI4_FC_LOCAL_REJECT_FCP_CONF_FAILURE	0x12
+#define SLI4_FC_LOCAL_REJECT_ILLEGAL_LENGTH	0x13
+#define SLI4_FC_LOCAL_REJECT_UNSUPPORTED_FEATURE 0x14
+#define SLI4_FC_LOCAL_REJECT_ABORT_IN_PROGRESS	0x15
+#define SLI4_FC_LOCAL_REJECT_ABORT_REQUESTED	0x16
+#define SLI4_FC_LOCAL_REJECT_RCV_BUFFER_TIMEOUT	0x17
+#define SLI4_FC_LOCAL_REJECT_LOOP_OPEN_FAILURE	0x18
+#define SLI4_FC_LOCAL_REJECT_LINK_DOWN		0x1a
+#define SLI4_FC_LOCAL_REJECT_CORRUPTED_DATA	0x1b
+#define SLI4_FC_LOCAL_REJECT_CORRUPTED_RPI	0x1c
+#define SLI4_FC_LOCAL_REJECT_OUT_OF_ORDER_DATA	0x1d
+#define SLI4_FC_LOCAL_REJECT_OUT_OF_ORDER_ACK	0x1e
+#define SLI4_FC_LOCAL_REJECT_DUP_FRAME		0x1f
+#define SLI4_FC_LOCAL_REJECT_LINK_CONTROL_FRAME	0x20
+#define SLI4_FC_LOCAL_REJECT_BAD_HOST_ADDRESS	0x21
+#define SLI4_FC_LOCAL_REJECT_MISSING_HDR_BUFFER	0x23
+#define SLI4_FC_LOCAL_REJECT_MSEQ_CHAIN_CORRUPTED 0x24
+#define SLI4_FC_LOCAL_REJECT_ABORTMULT_REQUESTED 0x25
+#define SLI4_FC_LOCAL_REJECT_BUFFER_SHORTAGE	0x28
+#define SLI4_FC_LOCAL_REJECT_RCV_XRIBUF_WAITING	0x29
+#define SLI4_FC_LOCAL_REJECT_INVALID_VPI	0x2e
+#define SLI4_FC_LOCAL_REJECT_MISSING_XRIBUF	0x30
+#define SLI4_FC_LOCAL_REJECT_INVALID_RELOFFSET	0x40
+#define SLI4_FC_LOCAL_REJECT_MISSING_RELOFFSET	0x41
+#define SLI4_FC_LOCAL_REJECT_INSUFF_BUFFERSPACE	0x42
+#define SLI4_FC_LOCAL_REJECT_MISSING_SI		0x43
+#define SLI4_FC_LOCAL_REJECT_MISSING_ES		0x44
+#define SLI4_FC_LOCAL_REJECT_INCOMPLETE_XFER	0x45
+#define SLI4_FC_LOCAL_REJECT_SLER_FAILURE	0x46
+#define SLI4_FC_LOCAL_REJECT_SLER_CMD_RCV_FAILURE 0x47
+#define SLI4_FC_LOCAL_REJECT_SLER_REC_RJT_ERR	0x48
+#define SLI4_FC_LOCAL_REJECT_SLER_REC_SRR_RETRY_ERR 0x49
+#define SLI4_FC_LOCAL_REJECT_SLER_SRR_RJT_ERR	0x4a
+#define SLI4_FC_LOCAL_REJECT_SLER_RRQ_RJT_ERR	0x4c
+#define SLI4_FC_LOCAL_REJECT_SLER_RRQ_RETRY_ERR	0x4d
+#define SLI4_FC_LOCAL_REJECT_SLER_ABTS_ERR	0x4e
+
+typedef struct sli4_fc_async_rcqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:8,
+			status:8,
+			rq_element_index:12,
+			:4;
+	uint32_t	rsvd1;
+	uint32_t	fcfi:6,
+			rq_id:10,
+			payload_data_placement_length:16;
+	uint32_t	sof_byte:8,
+			eof_byte:8,
+			code:8,
+			header_data_placement_length:6,
+			:1,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_async_rcqe_t;
+
+typedef struct sli4_fc_async_rcqe_v1_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:8,
+			status:8,
+			rq_element_index:12,
+			:4;
+	uint32_t	fcfi:6,
+			:26;
+	uint32_t	rq_id:16,
+			payload_data_placement_length:16;
+	uint32_t	sof_byte:8,
+			eof_byte:8,
+			code:8,
+			header_data_placement_length:6,
+			:1,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_async_rcqe_v1_t;
+
+#define SLI4_FC_ASYNC_RQ_SUCCESS		0x10
+#define SLI4_FC_ASYNC_RQ_BUF_LEN_EXCEEDED	0x11
+#define SLI4_FC_ASYNC_RQ_INSUFF_BUF_NEEDED	0x12
+#define SLI4_FC_ASYNC_RQ_INSUFF_BUF_FRM_DISC	0x13
+#define SLI4_FC_ASYNC_RQ_DMA_FAILURE		0x14
+
+typedef struct sli4_fc_coalescing_rcqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:8,
+			status:8,
+			rq_element_index:12,
+			:4;
+	uint32_t	rsvd1;
+	uint32_t	rq_id:16,
+			sequence_reporting_placement_length:16;
+	uint32_t	:16,
+			code:8,
+			:7,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_coalescing_rcqe_t;
+
+#define SLI4_FC_COALESCE_RQ_SUCCESS		0x10
+#define SLI4_FC_COALESCE_RQ_INSUFF_XRI_NEEDED	0x18
+
+typedef struct sli4_fc_optimized_write_cmd_cqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:8,
+			status:8,
+			rq_element_index:15,
+			iv:1;
+	uint32_t	fcfi:6,
+			:8,
+			oox:1,
+			agxr:1,
+			xri:16;
+	uint32_t	rq_id:16,
+			payload_data_placement_length:16;
+	uint32_t	rpi:16,
+			code:8,
+			header_data_placement_length:6,
+			:1,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_optimized_write_cmd_cqe_t;
+
+typedef struct sli4_fc_optimized_write_data_cqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	hw_status:8,
+			status:8,
+			xri:16;
+	uint32_t	total_data_placed;
+	uint32_t	extended_status;
+	uint32_t	:16,
+			code:8,
+			pri:3,
+			pv:1,
+			xb:1,
+			rha:1,
+			:1,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_optimized_write_data_cqe_t;
+
+typedef struct sli4_fc_xri_aborted_cqe_s {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	uint32_t	:8,
+			status:8,
+			:16;
+	uint32_t	extended_status;
+	uint32_t	xri:16,
+			remote_xid:16;
+	uint32_t	:16,
+			code:8,
+			xr:1,
+			:3,
+			eo:1,
+			br:1,
+			ia:1,
+			vld:1;
+#else
+#error big endian version not defined
+#endif
+} sli4_fc_xri_aborted_cqe_t;
+
+/**
+ * Code definitions applicable to all FC/FCoE CQE types.
+ */
+#define SLI4_CQE_CODE_OFFSET		14
+
+#define SLI4_CQE_CODE_WORK_REQUEST_COMPLETION	0x01
+#define SLI4_CQE_CODE_RELEASE_WQE		0x02
+#define SLI4_CQE_CODE_RQ_ASYNC			0x04
+#define SLI4_CQE_CODE_XRI_ABORTED		0x05
+#define SLI4_CQE_CODE_RQ_COALESCING		0x06
+#define SLI4_CQE_CODE_RQ_CONSUMPTION		0x07
+#define SLI4_CQE_CODE_MEASUREMENT_REPORTING	0x08
+#define SLI4_CQE_CODE_RQ_ASYNC_V1		0x09
+#define SLI4_CQE_CODE_OPTIMIZED_WRITE_CMD	0x0B
+#define SLI4_CQE_CODE_OPTIMIZED_WRITE_DATA	0x0C
+
+extern int32_t sli_fc_process_link_state(sli4_t *, void *);
+extern int32_t sli_fc_process_link_attention(sli4_t *, void *);
+extern int32_t sli_fc_cqe_parse(sli4_t *, sli4_queue_t *, uint8_t *, sli4_qentry_e *, uint16_t *);
+extern uint32_t sli_fc_response_length(sli4_t *, uint8_t *);
+extern uint32_t sli_fc_io_length(sli4_t *, uint8_t *);
+extern int32_t sli_fc_els_did(sli4_t *, uint8_t *, uint32_t *);
+extern uint32_t sli_fc_ext_status(sli4_t *, uint8_t *);
+extern int32_t sli_fc_rqe_rqid_and_index(sli4_t *, uint8_t *, uint16_t *, uint32_t *);
+extern int32_t sli_fc_process_fcoe(sli4_t *, void *);
+extern int32_t sli_cmd_fcoe_wq_create(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, uint16_t);
+extern int32_t sli_cmd_fcoe_wq_create_v1(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, uint16_t);
+extern int32_t sli_cmd_fcoe_wq_destroy(sli4_t *, void *, size_t, uint16_t);
+extern int32_t sli_cmd_fcoe_post_sgl_pages(sli4_t *, void *, size_t, uint16_t, uint32_t, ocs_dma_t **, ocs_dma_t **,
+ocs_dma_t *);
+extern int32_t sli_cmd_fcoe_rq_create(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, uint16_t, uint16_t);
+extern int32_t sli_cmd_fcoe_rq_create_v1(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, uint16_t, uint16_t);
+extern int32_t sli_cmd_fcoe_rq_destroy(sli4_t *, void *, size_t, uint16_t);
+extern int32_t sli_cmd_fcoe_read_fcf_table(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t);
+extern int32_t sli_cmd_fcoe_post_hdr_templates(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, ocs_dma_t *);
+extern int32_t sli_cmd_fcoe_rediscover_fcf(sli4_t *, void *, size_t, uint16_t);
+extern int32_t sli_fc_rq_alloc(sli4_t *, sli4_queue_t *, uint32_t, uint32_t, sli4_queue_t *, uint16_t, uint8_t);
+extern int32_t sli_fc_rq_set_alloc(sli4_t *, uint32_t, sli4_queue_t *[], uint32_t, uint32_t, uint32_t, uint32_t, uint16_t);
+extern uint32_t sli_fc_get_rpi_requirements(sli4_t *, uint32_t);
+extern int32_t sli_abort_wqe(sli4_t *, void *, size_t, sli4_abort_type_e, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t);
+
+extern int32_t sli_els_request64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint8_t, uint32_t, uint32_t, uint8_t, uint16_t, uint16_t, uint16_t, ocs_remote_node_t *);
+extern int32_t sli_fcp_iread64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint32_t, ocs_remote_node_t *, uint8_t, uint8_t, uint8_t);
+extern int32_t sli_fcp_iwrite64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint32_t, ocs_remote_node_t *, uint8_t, uint8_t, uint8_t);
+extern int32_t sli_fcp_icmnd64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint16_t, uint16_t, uint16_t, uint32_t, ocs_remote_node_t *, uint8_t);
+
+extern int32_t sli_fcp_treceive64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, uint32_t, ocs_remote_node_t *, uint32_t, uint8_t, uint8_t, uint8_t, uint32_t);
+extern int32_t sli_fcp_trsp64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, uint32_t, ocs_remote_node_t *, uint32_t, uint8_t, uint8_t, uint32_t);
+extern int32_t sli_fcp_tsend64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, uint32_t, ocs_remote_node_t *, uint32_t, uint8_t, uint8_t, uint8_t, uint32_t);
+extern int32_t sli_fcp_cont_treceive64_wqe(sli4_t *, void*, size_t, ocs_dma_t *, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint32_t, ocs_remote_node_t *, uint32_t, uint8_t, uint8_t, uint8_t, uint32_t);
+extern int32_t sli_gen_request64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint32_t,uint8_t, uint16_t, uint16_t, uint16_t, ocs_remote_node_t *, uint8_t, uint8_t, uint8_t);
+extern int32_t sli_send_frame_wqe(sli4_t *sli4, void *buf, size_t size, uint8_t sof, uint8_t eof, uint32_t *hdr,
+				  ocs_dma_t *payload, uint32_t req_len, uint8_t timeout,
+				  uint16_t xri, uint16_t req_tag);
+extern int32_t sli_xmit_sequence64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint8_t, uint16_t, uint16_t, uint16_t, ocs_remote_node_t *, uint8_t, uint8_t, uint8_t);
+extern int32_t sli_xmit_bcast64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint8_t, uint16_t, uint16_t, uint16_t, ocs_remote_node_t *, uint8_t, uint8_t, uint8_t);
+extern int32_t sli_xmit_bls_rsp64_wqe(sli4_t *, void *, size_t, sli_bls_payload_t *, uint16_t, uint16_t, uint16_t, ocs_remote_node_t *, uint32_t);
+extern int32_t sli_xmit_els_rsp64_wqe(sli4_t *, void *, size_t, ocs_dma_t *, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, ocs_remote_node_t *, uint32_t, uint32_t);
+extern int32_t sli_requeue_xri_wqe(sli4_t *, void *, size_t, uint16_t, uint16_t, uint16_t);
+extern void sli4_cmd_lowlevel_set_watchdog(sli4_t *sli4, void *buf, size_t size, uint16_t timeout);
+
+/**
+ * @ingroup sli_fc
+ * @brief Retrieve the received header and payload length.
+ *
+ * @param sli4 SLI context.
+ * @param cqe Pointer to the CQ entry.
+ * @param len_hdr Pointer where the header length is written.
+ * @param len_data Pointer where the payload length is written.
+ *
+ * @return Returns 0 on success, or a non-zero value on failure.
+ */
+static inline int32_t
+sli_fc_rqe_length(sli4_t *sli4, void *cqe, uint32_t *len_hdr, uint32_t *len_data)
+{
+	sli4_fc_async_rcqe_t	*rcqe = cqe;
+
+	*len_hdr = *len_data = 0;
+
+	if (SLI4_FC_ASYNC_RQ_SUCCESS == rcqe->status) {
+		*len_hdr  = rcqe->header_data_placement_length;
+		*len_data = rcqe->payload_data_placement_length;
+		return 0;
+	} else {
+		return -1;
+	}
+}
+
+/**
+ * @ingroup sli_fc
+ * @brief Retrieve the received FCFI.
+ *
+ * @param sli4 SLI context.
+ * @param cqe Pointer to the CQ entry.
+ *
+ * @return Returns the FCFI in the CQE. or UINT8_MAX if invalid CQE code.
+ */
+static inline uint8_t
+sli_fc_rqe_fcfi(sli4_t *sli4, void *cqe)
+{
+	uint8_t code = ((uint8_t*)cqe)[SLI4_CQE_CODE_OFFSET];
+	uint8_t fcfi = UINT8_MAX;
+
+	switch(code) {
+	case SLI4_CQE_CODE_RQ_ASYNC: {
+		sli4_fc_async_rcqe_t *rcqe = cqe;
+		fcfi = rcqe->fcfi;
+		break;
+	}
+	case SLI4_CQE_CODE_RQ_ASYNC_V1: {
+		sli4_fc_async_rcqe_v1_t *rcqev1 = cqe;
+		fcfi = rcqev1->fcfi;
+		break;
+	}
+	case SLI4_CQE_CODE_OPTIMIZED_WRITE_CMD: {
+		sli4_fc_optimized_write_cmd_cqe_t *opt_wr = cqe;
+		fcfi = opt_wr->fcfi;
+		break;
+	}
+	}
+
+	return fcfi;
+}
+
+extern const char *sli_fc_get_status_string(uint32_t status);
+ 
+#endif /* !_SLI4_H */
+
diff --git a/sys/dev/ocs_fc/version.h b/sys/dev/ocs_fc/version.h
new file mode 100644
index 000000000000..0f5d90d67b26
--- /dev/null
+++ b/sys/dev/ocs_fc/version.h
@@ -0,0 +1,84 @@
+/*-
+ * Copyright (c) 2017 Broadcom. All rights reserved.
+ * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#define STR_BE_BRANCH "0"
+#define STR_BE_BUILD "9999"
+#define STR_BE_DOT   "0"
+#define STR_BE_MINOR "0"
+#define STR_BE_MAJOR "0"
+
+#define BE_BRANCH 0
+#define BE_BUILD 9999
+#define BE_DOT   0
+#define BE_MINOR 0
+#define BE_MAJOR 0
+
+#define MGMT_BRANCH 0
+#define MGMT_BUILDNUM 476
+#define MGMT_MINOR 100
+#define MGMT_MAJOR 2
+
+#define BE_REDBOOT_VERSION "2.0.5.0"
+
+//start-auto
+#define BUILD_MONTH "6"
+#define BUILD_MONTH_NAME "June"
+#define BUILD_DAY "12"
+#define BUILD_YEAR "2009"
+#define BUILD_24HOUR "5"
+#define BUILD_12HOUR "5"
+#define BUILD_AM_PM "AM"
+#define BUILD_MIN "37"
+#define BUILD_SEC "17"
+#define BUILD_MONTH_NUMBER 6
+#define BUILD_DAY_NUMBER 12
+#define BUILD_YEAR_NUMBER 2009
+#define BUILD_24HOUR_NUMBER 5
+#define BUILD_12HOUR_NUMBER 5
+#define BUILD_MIN_NUMBER 37
+#define BUILD_SEC_NUMBER 17
+#undef MAJOR_BUILD
+#undef MINOR_BUILD
+#undef DOT_BUILD
+#undef NUMBERED_BUILD
+#undef BRANCH_BUILD
+//end-auto
+
+#define ELX_FCOE_XROM_BIOS_VER "7.03a1"
+#define ELX_FCoE_X86_VER       "4.02a1"
+#define ELX_FCoE_EFI_VER       "5.01a1"
+#define ELX_FCoE_FCODE_VER     "4.01a0"
+#define ELX_PXE_BIOS_VER       "3.00a5"
+#define ELX_UEFI_NIC_VER       "2.10A10"
+#define ELX_UEFI_FCODE_VER     "1.10A1"
+#define ELX_ISCSI_BIOS_VER     "1.00A8"
diff --git a/sys/modules/Makefile b/sys/modules/Makefile
index 2648443bf82b..28d3c7ebee82 100644
--- a/sys/modules/Makefile
+++ b/sys/modules/Makefile
@@ -296,6 +296,7 @@ SUBDIR=	\
 	${_nvram} \
 	${_nxge} \
 	oce \
+	${_ocs_fc} \
 	otus \
 	${_otusfw} \
 	ow \
@@ -609,6 +610,7 @@ _lio=		lio
 .endif
 _nctgpio=	nctgpio
 _ndis=		ndis
+_ocs_fc=	ocs_fc
 _pccard=	pccard
 .if ${MK_OFED} != "no" || defined(ALL_MODULES)
 _rdma=		rdma
diff --git a/sys/modules/ocs_fc/Makefile b/sys/modules/ocs_fc/Makefile
new file mode 100644
index 000000000000..ffd730eb08c4
--- /dev/null
+++ b/sys/modules/ocs_fc/Makefile
@@ -0,0 +1,45 @@
+# $FreeBSD$
+
+.PATH:	${SRCTOP}/sys/dev/ocs_fc
+KMOD = ocs_fc
+
+SRCS = \
+	device_if.h \
+	bus_if.h \
+	pci_if.h \
+	opt_scsi.h \
+	opt_cam.h
+
+# OS
+SRCS += ocs_pci.c ocs_ioctl.c ocs_os.c ocs_utils.c
+
+# hw
+SRCS += ocs_hw.c ocs_hw_queues.c
+
+# SLI
+SRCS += sli4.c ocs_sm.c
+
+# Transport
+SRCS += \
+	ocs_device.c \
+	ocs_xport.c \
+	ocs_domain.c \
+	ocs_sport.c \
+	ocs_els.c \
+	ocs_fabric.c \
+	ocs_io.c \
+	ocs_node.c \
+	ocs_scsi.c \
+	ocs_unsol.c \
+	ocs_ddump.c \
+	ocs_mgmt.c 
+
+
+# CAM initiator/target
+SRCS += ocs_cam.c
+
+CINCS = -I. 
+
+CLEANFILES += ${PROG}.debug ${PROG}.symbols cscope.* .depend.*
+
+.include <bsd.kmod.mk>