--- a/usr/src/cmd/fcinfo/fcinfo.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/cmd/fcinfo/fcinfo.c	Wed Aug 05 17:14:23 2009 -0700
@@ -78,6 +78,7 @@
 	{"scsi-target", no_argument,	's', NULL},
 	{"fcoe-force-promisc", no_argument, 'f', NULL},
 	{"target", no_argument,		't', NULL},
+	{"initiator", no_argument,	'i', NULL},
 	{NULL, 0, 0}
 };
 
@@ -113,13 +114,13 @@
 	    npivCreatePortListFunc, NULL, NULL, NULL,
 	    OPERAND_NONE, NULL},
 	{"create-fcoe-port",
-	    fcoeAdmCreatePortFunc, "tpnf", "t", NULL,
+	    fcoeAdmCreatePortFunc, "itpnf", NULL, NULL,
 		OPERAND_MANDATORY_SINGLE, "Network Interface Name"},
 	{"delete-fcoe-port",
 	    fcoeAdmDeletePortFunc, NULL, NULL, NULL,
 		OPERAND_MANDATORY_SINGLE, "Network Interface Name"},
 	{"list-fcoe-ports",
-	    fcoeListPortsFunc, "t", NULL, NULL,
+	    fcoeListPortsFunc, "it", NULL, NULL,
 		OPERAND_NONE, NULL},
 	{NULL, 0, NULL, NULL, NULL, 0, NULL, NULL}
 };

--- a/usr/src/cmd/fcinfo/fcoeadm.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/cmd/fcinfo/fcoeadm.c	Wed Aug 05 17:14:23 2009 -0700
@@ -86,11 +86,11 @@
 
 	fprintf(stdout, gettext("\tMTU Size: %d\n"), attr->mtu_size);
 
-	fprintf(stdout, gettext("\tMAC Factory Address: "));
+	fprintf(stdout, gettext("\tPrimary MAC Address: "));
 	for (i = 0; i < 6; i++) {
 		fprintf(stdout, gettext("%02x"), attr->mac_factory_addr[i]);
 	}
-	fprintf(stdout, gettext("\n\tMAC Current Address: "));
+	fprintf(stdout, gettext("\n\tCurrent MAC Address: "));
 	for (i = 0; i < 6; i++) {
 		fprintf(stdout, gettext("%02x"), attr->mac_current_addr[i]);
 	}
@@ -268,6 +268,9 @@
 {
 	FCOE_STATUS status;
 	FCOE_UINT8	*macLinkName;
+	FCOE_UINT32		port_num;
+	FCOE_PORT_ATTRIBUTE	*portlist = NULL;
+	int			i;
 
 	/* check the mac name operand */
 	assert(objects == 1);
@@ -312,9 +315,39 @@
 			break;
 
 		case  FCOE_STATUS_ERROR_OFFLINE_DEV:
-			fprintf(stderr,
-			    gettext("Error: Please use stmfadm to offline "
-			    "the FCoE target first\n"));
+			status = FCOE_GetPortList(&port_num, &portlist);
+			if (status != FCOE_STATUS_OK || port_num == 0) {
+				fprintf(stderr,
+				    gettext("Error: FCoE port not found on the "
+				    "specified MAC link\n"));
+				break;
+			}
+			for (i = 0; i < port_num; i++) {
+				if (strcmp(
+				    (char *)portlist[i].mac_link_name,
+				    (char *)macLinkName) == 0) {
+					if (portlist[i].port_type ==
+					    FCOE_PORTTYPE_TARGET) {
+						fprintf(stderr,
+						    gettext("Error: Please use "
+						    "stmfadm to offline the "
+						    "FCoE target first\n"));
+					} else {
+						fprintf(stderr,
+						    gettext("Error: Failed to "
+						    "delete FCoE port because "
+						    "unable to offline the "
+						    "device\n"));
+					}
+					break;
+				}
+			}
+			free(portlist);
+			if (i == port_num) {
+				fprintf(stderr,
+				    gettext("Error: FCoE port not found on the "
+				    "specified MAC link\n"));
+			}
 			break;
 
 		case FCOE_STATUS_ERROR_GET_LINKINFO:

--- a/usr/src/cmd/fcoesvc/Makefile	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/cmd/fcoesvc/Makefile	Wed Aug 05 17:14:23 2009 -0700
@@ -24,31 +24,43 @@
 # Use is subject to license terms.
 #
 
-PROG =	svc-fcoet
+PROGFCOET	= svc-fcoet
+PROGFCOEI	= svc-fcoei
+PROG		= ${PROGFCOET} ${PROGFCOEI}
 
 include ../Makefile.cmd
 
-COMMONBASE = ../../common
+COMMONBASE	= ../../common
 
-LOCAL_OBJS = fcoetsvc.o
-LOCAL_SRCS =	$(LOCAL_OBJS:%.o=%.c)
-OBJS =	$(LOCAL_OBJS)
-SRCS = $(LOCAL_SRCS)
+OBJSFCOET	= fcoetsvc.o
+OBJSFCOEI	= fcoeisvc.o
+SRCSFCOET	= $(OBJSFCOET:%.o=%.c)
+SRCSFCOEI	= $(OBJSFCOEI:%.o=%.c)
+SRCS		= $(SRCSFCOET) ${SRCSFCOEI}
 
-LDLIBS += -lfcoe
+LDLIBS		+= -lfcoe
 
-MANIFEST    = fcoe_target.xml
-SVCMETHOD   = svc-fcoet
+MANIFEST	= fcoe_target.xml
+MANIFEST	+= fcoe_initiator.xml
+SVCMETHOD	= svc-fcoet
+SVCMETHOD	+= svc-fcoei
 
 ROOTMANIFESTDIR	= $(ROOTSVCSYSTEM)
 $(ROOTSVCSYSTEM)/fcoe_target.xml	:= FILEMODE = 0444
+$(ROOTSVCSYSTEM)/fcoe_initiator.xml	:= OWNER = root
+$(ROOTSVCSYSTEM)/fcoe_initiator.xml	:= GROUP = bin
+$(ROOTSVCSYSTEM)/fcoe_initiator.xml	:= FILEMODE = 0444
 
 .KEEP_STATE:
 
 all: $(PROG)
 
-$(PROG): $(OBJS)
-	$(LINK.c) -o $@ $(OBJS) $(LDLIBS)
+$(PROGFCOET): $(OBJSFCOET)
+	$(LINK.c) -o $@ $(OBJSFCOET) $(LDLIBS)
+	$(POST_PROCESS)
+
+$(PROGFCOEI): $(OBJSFCOEI)
+	$(LINK.c) -o $@ $(OBJSFCOEI) $(LDLIBS)
 	$(POST_PROCESS)
 
 install: all $(ROOTMANIFEST) $(ROOTSVCMETHOD)
@@ -56,13 +68,11 @@
 check:	$(CHKMANIFEST)
 	$(CSTYLE) -pPc $(SRCS:%=%)
 
-cmdparse.o:
-	    $(COMPILE.c) -o $@
-	    $(POST_PROCESS_O)
+clean:
+	$(RM) $(OBJSFCOET) ${OBJSFCOEI}
 
-clean:
-	$(RM) $(OBJS)
-
-lint:	lint_SRCS
+lint:
+	$(LINT.c) $(SRCSFCOET) $(LDLIBS)
+	$(LINT.c) $(SRCSFCOEI) ${LDLIBS}
 
 include ../Makefile.targ

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/fcoesvc/fcoe_initiator.xml	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,102 @@
+<?xml version="1.0"?>
+<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
+
+<!--
+
+CDDL HEADER START
+
+The contents of this file are subject to the terms of the
+Common Development and Distribution License (the "License").
+You may not use this file except in compliance with the License.
+
+You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+or http://www.opensolaris.org/os/licensing.
+See the License for the specific language governing permissions
+and limitations under the License.
+
+When distributing Covered Code, include this CDDL HEADER in each
+file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+If applicable, add the following below this CDDL HEADER, with the
+fields enclosed by brackets "[]" replaced with your own identifying
+information: Portions Copyright [yyyy] [name of copyright owner]
+
+CDDL HEADER END
+
+Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+Use is subject to license terms.
+
+Service manifests for the FCoE initiator configuration
+-->
+
+<!--
+	system/fcoe_initiator - Export FCoE initiator port services
+-->
+
+<service_bundle type='manifest' name='SUNWfcprtr:fcoe_initiator'>
+
+<service
+	name='system/fcoe_initiator'
+	type='service'
+	version='1'>
+
+	<create_default_instance enabled='true' />
+
+	<single_instance/>
+
+	<dependency name = 'network'
+		grouping='require_any'
+		restart_on='error'
+		type='service'>
+		<service_fmri value='svc:/milestone/network'/>
+	</dependency>
+
+	<exec_method
+		type='method'
+		name='start'
+		exec='/lib/svc/method/svc-fcoei'
+		timeout_seconds='600'>
+		<method_context>
+			<method_credential
+			user='root'
+			group='root'
+			privileges='basic,sys_devices'
+			/>
+		</method_context>
+	</exec_method>
+
+	<exec_method
+		type='method'
+		name='stop'
+		exec=':true'
+		timeout_seconds='60'>
+		<method_context>
+			<method_credential
+			user='root'
+			group='root'
+			privileges='basic,sys_devices'
+			/>
+		</method_context>
+	</exec_method>
+
+	<property_group name='startd' type='framework'>
+		<propval name='duration' type='astring'
+			value='transient' />
+	</property_group>
+
+	<stability value='Evolving' />
+
+	<template>
+		<common_name>
+			<loctext xml:lang='C'>
+				fcoe initiator service
+			</loctext>
+		</common_name>
+		<documentation>
+			<manpage title='fcadm' section='1M'
+				manpath='/usr/share/man' />
+		</documentation>
+	</template>
+
+</service>
+
+</service_bundle>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/fcoesvc/fcoeisvc.c	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,64 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <libfcoe.h>
+#include <locale.h>
+
+int
+main()
+{
+	FCOE_STATUS	status;
+	PFCOE_SMF_PORT_LIST portlist = NULL;
+	PFCOE_SMF_PORT_INSTANCE port = NULL;
+	int i;
+	int ret;
+
+	(void) setlocale(LC_ALL, "");
+
+	status = FCOE_LoadConfig(FCOE_PORTTYPE_INITIATOR, &portlist);
+
+	if (status != FCOE_STATUS_OK) {
+		ret = 1;
+	} else if (portlist == NULL) {
+		return (0);
+	} else {
+		for (i = 0; i < portlist->port_num; i++) {
+			port = &portlist->ports[i];
+			if (port->port_type == FCOE_PORTTYPE_INITIATOR) {
+				(void) FCOE_CreatePort(port->mac_link_name,
+				    port->port_type,
+				    port->port_pwwn,
+				    port->port_nwwn,
+				    port->mac_promisc);
+			}
+		}
+		ret = 0;
+	}
+
+	if (portlist != NULL) {
+		free(portlist);
+	}
+	return (ret);
+} /* end main */

--- a/usr/src/lib/storage/libg_fc/common/genf.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/lib/storage/libg_fc/common/genf.c	Wed Aug 05 17:14:23 2009 -0700
@@ -19,7 +19,7 @@
  * CDDL HEADER END
  */
 /*
- * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
@@ -78,6 +78,7 @@
 /* Bus strings - for internal use by g_get_path_type() only */
 #define	PCI_BUS			1
 #define	SBUS			2
+#define	FCOE			3
 
 struct str_type {
 	char *string;
@@ -87,6 +88,7 @@
 static struct str_type ValidBusStrings[] = {
 	{"pci@", PCI_BUS},
 	{"sbus@", SBUS},
+	{"fcoe", FCOE},
 	{NULL, 0}
 };
 

--- a/usr/src/pkgdefs/Makefile	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/pkgdefs/Makefile	Wed Aug 05 17:14:23 2009 -0700
@@ -255,6 +255,7 @@
 	SUNWfcoe \
 	SUNWfcoeu \
 	SUNWfcoet \
+	SUNWfcoei \
 	SUNWfilebench \
 	SUNWfmd  \
 	SUNWfmdr  \

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/Makefile	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,33 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+
+include ../Makefile.com
+
+.KEEP_STATE:
+
+all: $(FILES) depend preremove postinstall
+install: all pkg
+
+include ../Makefile.targ

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/depend	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,52 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#
+# This package information file defines software dependencies associated
+# with the pkg.  You can define three types of pkg dependencies with this file:
+#	 P indicates a prerequisite for installation
+#	 I indicates an incompatible package
+#	 R indicates a reverse dependency
+# <pkg.abbr> see pkginfo(4), PKG parameter
+# <name> see pkginfo(4), NAME parameter
+# <version> see pkginfo(4), VERSION parameter
+# <arch> see pkginfo(4), ARCH parameter
+# <type> <pkg.abbr> <name>
+# 	(<arch>)<version>
+# 	(<arch>)<version>
+# 	...
+# <type> <pkg.abbr> <name>
+# ...
+
+P SUNWcar	Core Architecture, (Root)
+P SUNWcakr      Core Solaris Kernel Architecture (Root)
+P SUNWkvm	Core Architecture, (Kvm)
+P SUNWcsr	Core Solaris, (Root)
+P SUNWckr       Core Solaris Kernel (Root)
+P SUNWcnetr     Core Solaris Network Infrastructure (Root)
+P SUNWcsu	Core Solaris, (Usr)
+P SUNWcsd	Core Solaris Devices
+P SUNWcsl	Core Solaris Libraries
+P SUNWfcoe	Sun FCoE Transport Driver
+P SUNWfctl	Sun Fibre Channel Transport layer

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/pkginfo.tmpl	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,50 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#
+#
+# This required package information file describes characteristics of the
+# package, such as package abbreviation, full package name, package version,
+# and package architecture.
+#
+ 
+PKG="SUNWfcoei"
+NAME="Sun FCoE Initiator Driver"
+ARCH="ISA"
+CATEGORY="system"
+BASEDIR=/
+SUNW_PKGVERS="1.0"
+SUNW_PKGTYPE="root"
+CLASSES="none"
+DESC="Sun FCoE (Fibre Channel over Ethernet) Initiator Driver"
+SUNW_PRODNAME="SunOS"
+SUNW_PRODVERS="RELEASE/VERSION"
+VERSION="ONVERS,REV=0.0.0"
+VENDOR="Sun Microsystems, Inc."
+HOTLINE="Please contact your local service provider"
+EMAIL=""
+MAXINST="1000"
+SUNW_PKG_ALLZONES="true"
+SUNW_PKG_HOLLOW="true"
+SUNW_PKG_THISZONE="false"

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/postinstall	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,54 @@
+#!/bin/sh
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#
+
+PATH=/usr/bin:/usr/sbin:$PATH; export PATH
+
+# Driver definitions
+DRVR_NAME=fcoei
+DRVR_PERM="-m '* 0600 root sys'"
+DRVR_CLASS=""
+DRVR_ALIASES=""
+
+
+if [ -z "${BASEDIR}" ]; then
+	echo "\n$0 Failed: BASEDIR is not set.\n" >&2
+	exit 1
+fi
+
+# Remove existing definition, if it exists. 
+/usr/sbin/rem_drv -b "${BASEDIR}" ${DRVR_NAME} > /dev/null 2>&1
+
+ADD_DRV="add_drv -n -b ${BASEDIR}"
+
+eval ${ADD_DRV} "${DRVR_PERM}" ${DRVR_CLASS} "${DRVR_ALIASES}" ${DRVR_NAME}
+if [ $? -ne 0 ]; then
+	echo "\nCommand Failed:\n${ADD_DRV} "${DRVR_PERM}" ${DRVR_CLASS} \
+		"${DRVR_ALIASES}" ${DRVR_NAME}\n" >&2
+	exit 1
+fi
+
+exit 0

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/preremove	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,33 @@
+#!/bin/sh
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#
+
+DRVR_NAME=fcoei
+
+# Remove the driver entries but leave it attached.
+/usr/sbin/rem_drv -b ${BASEDIR} ${DRVR_NAME}
+
+exit 0

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/prototype_com	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,41 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#
+# This required package information file contains a list of package contents.
+# The 'pkgmk' command uses this file to identify the contents of a package
+# and their location on the development machine when building the package.
+# Can be created via a text editor or through use of the 'pkgproto' command.
+
+#!search <pathname pathname ...>	# where to find pkg objects
+#!include <filename>			# include another 'prototype' file
+#!default <mode> <owner> <group>	# default used if not specified on entry
+#!<param>=<value>			# puts parameter in pkg environment
+
+#
+#
+i copyright
+i pkginfo 
+i depend
+i postinstall
+i preremove

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/prototype_i386	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,53 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#
+# This required package information file contains a list of package contents.
+# The 'pkgmk' command uses this file to identify the contents of a package
+# and their location on the development machine when building the package.
+# Can be created via a text editor or through use of the 'pkgproto' command.
+
+#!search <pathname pathname ...>	# where to find pkg objects
+#!include <filename>			# include another 'prototype' file
+#!default <mode> <owner> <group>	# default used if not specified on entry
+#!<param>=<value>			# puts parameter in pkg environment
+#
+# Include ISA independent files (prototype_com)
+#
+!include prototype_com
+#
+#
+# List files which are Intel specific here
+#
+# source locations relative to the prototype file
+#
+#
+# SUNWfcoei
+#
+d none kernel 0755 root sys
+d none kernel/drv 0755 root sys
+d none kernel/drv/amd64 0755 root sys
+f none kernel/drv/fcoei.conf 0644 root sys
+f none kernel/drv/fcoei 0755 root sys
+f none kernel/drv/amd64/fcoei 0755 root sys

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/pkgdefs/SUNWfcoei/prototype_sparc	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,52 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+#
+# This required package information file contains a list of package contents.
+# The 'pkgmk' command uses this file to identify the contents of a package
+# and their location on the development machine when building the package.
+# Can be created via a text editor or through use of the 'pkgproto' command.
+
+#!search <pathname pathname ...>	# where to find pkg objects
+#!include <filename>			# include another 'prototype' file
+#!default <mode> <owner> <group>	# default used if not specified on entry
+#!<param>=<value>			# puts parameter in pkg environment
+#
+# Include ISA independent files (prototype_com)
+#
+!include prototype_com
+#
+#
+# List files which are SPARC specific here
+#
+# source locations relative to the prototype file
+#
+#
+# SUNWfcoei
+#
+d none kernel 0755 root sys
+d none kernel/drv 0755 root sys
+f none kernel/drv/fcoei.conf 0644 root sys
+d none kernel/drv/sparcv9 0755 root sys
+f none kernel/drv/sparcv9/fcoei 0755 root sys

--- a/usr/src/pkgdefs/SUNWfcprtr/preremove	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/pkgdefs/SUNWfcprtr/preremove	Wed Aug 05 17:14:23 2009 -0700
@@ -71,4 +71,7 @@
 SERVICE="svc:/system/fcoe_target:default"
 disable_service
 
+SERVICE="svc:/system/fcoe_initiator:default"
+disable_service
+
 exit $exitcode

--- a/usr/src/pkgdefs/SUNWfcprtr/prototype_com	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/pkgdefs/SUNWfcprtr/prototype_com	Wed Aug 05 17:14:23 2009 -0700
@@ -47,9 +47,11 @@
 d none var/svc/manifest/network 0755 root sys
 d none var/svc/manifest/system 0755 root sys
 f manifest var/svc/manifest/network/npiv_config.xml 0444 root sys
+f manifest var/svc/manifest/system/fcoe_initiator.xml 0444 root sys
 f manifest var/svc/manifest/system/fcoe_target.xml 0444 root sys
 d none lib 755 root bin
 d none lib/svc 755 root bin
 d none lib/svc/method 755 root bin
 f none lib/svc/method/npivconfig 0555 root bin
+f none lib/svc/method/svc-fcoei 0555 root bin
 f none lib/svc/method/svc-fcoet 0555 root bin

--- a/usr/src/tools/scripts/bfu.sh	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/tools/scripts/bfu.sh	Wed Aug 05 17:14:23 2009 -0700
@@ -313,6 +313,7 @@
 	lib/svc/method/svc-drd
 	lib/svc/method/svc-dscp
 	lib/svc/method/svc-dumpadm
+	lib/svc/method/svc-fcoei
 	lib/svc/method/svc-fcoet
 	lib/svc/method/svc-intrd
 	lib/svc/method/svc-hal
@@ -383,6 +384,7 @@
 	var/svc/manifest/system/device/devices-audio.xml
 	var/svc/manifest/system/device/devices-fc-fabric.xml
 	var/svc/manifest/system/dumpadm.xml
+	var/svc/manifest/system/fcoe_initiator.xml
 	var/svc/manifest/system/fcoe_target.xml
 	var/svc/manifest/system/filesystem/rmvolmgr.xml
 	var/svc/manifest/system/fmd.xml

--- a/usr/src/uts/common/Makefile.files	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/Makefile.files	Wed Aug 05 17:14:23 2009 -0700
@@ -894,6 +894,8 @@
 
 FCOET_OBJS += fcoet.o fcoet_eth.o fcoet_fc.o
 
+FCOEI_OBJS += fcoei.o fcoei_eth.o fcoei_lv.o
+
 ISCSIT_SHARED_OBJS += \
 		iscsit_common.o
 

--- a/usr/src/uts/common/Makefile.rules	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/Makefile.rules	Wed Aug 05 17:14:23 2009 -0700
@@ -983,6 +983,10 @@
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
 
+$(OBJS_DIR)/%.o:		$(UTSBASE)/common/io/fibre-channel/fca/fcoei/%.c
+	$(COMPILE.c) -o $@ $<
+	$(CTFCONVERT_O)
+
 $(OBJS_DIR)/%.o:		$(UTSBASE)/common/io/sdcard/adapters/sdhost/%.c
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
@@ -2117,6 +2121,9 @@
 $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/io/fibre-channel/fca/emlxs/%.c
 	@($(LHEAD) $(LINT.c) $< $(LTAIL))
 
+$(LINTS_DIR)/%.ln:		$(UTSBASE)/common/io/fibre-channel/fca/fcoei/%.c
+	@($(LHEAD) $(LINT.c) $< $(LTAIL))
+
 $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/io/scsi/conf/%.c
 	@($(LHEAD) $(LINT.c) $< $(LTAIL))
 

--- a/usr/src/uts/common/io/comstar/port/fcoet/fcoet.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/comstar/port/fcoet/fcoet.c	Wed Aug 05 17:14:23 2009 -0700
@@ -453,6 +453,8 @@
 	client_fcoet.ect_port_event = fcoet_port_event;
 	client_fcoet.ect_release_sol_frame = fcoet_release_sol_frame;
 	client_fcoet.ect_client_port_struct = ss;
+	client_fcoet.ect_fcoe_ver = FCOE_VER_NOW;
+	FCOET_LOG(__FUNCTION__, "version: %x %x", FCOE_VER_NOW, fcoe_ver_now);
 	ret = ddi_prop_get_int(DDI_DEV_T_ANY, ss->ss_dip,
 	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "mac_id", -1);
 	if (ret == -1) {

--- a/usr/src/uts/common/io/comstar/port/fcoet/fcoet.h	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/comstar/port/fcoet/fcoet.h	Wed Aug 05 17:14:23 2009 -0700
@@ -33,7 +33,7 @@
 
 #ifdef	_KERNEL
 
-#define	FCOET_VERSION	"v20090311-1.00"
+#define	FCOET_VERSION	"v20090729-1.01"
 #define	FCOET_NAME	"COMSTAR FCoET "
 #define	FCOET_MOD_NAME	FCOET_NAME FCOET_VERSION
 

--- a/usr/src/uts/common/io/comstar/port/fcoet/fcoet_eth.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/comstar/port/fcoet/fcoet_eth.c	Wed Aug 05 17:14:23 2009 -0700
@@ -540,9 +540,11 @@
 
 	bcopy(frm->frm_payload, dbuf->db_sglist[sge_idx].seg_addr,
 	    frm->frm_payload_size);
+	atomic_add_16(&dbuf->db_sglist_length, 1);
 
 	xch->xch_left_data_size -= frm->frm_payload_size;
-	if (xch->xch_left_data_size <= 0) {
+	if ((xch->xch_left_data_size <= 0) ||
+	    dbuf->db_sglist_length >= FCOET_GET_SEG_NUM(dbuf)) {
 		fc_st = FCT_SUCCESS;
 		iof = 0;
 		dbuf->db_xfer_status = fc_st;

--- a/usr/src/uts/common/io/comstar/port/fcoet/fcoet_fc.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/comstar/port/fcoet/fcoet_fc.c	Wed Aug 05 17:14:23 2009 -0700
@@ -234,6 +234,7 @@
 		 * If it's write type command, we need send xfer_rdy now
 		 * We may need to consider bidirectional command later
 		 */
+		dbuf->db_sglist_length = 0;
 		frm = CMD2SS(cmd)->ss_eport->eport_alloc_frame(
 		    CMD2SS(cmd)->ss_eport, sizeof (fcoe_fcp_xfer_rdy_t) +
 		    FCFH_SIZE, NULL);

--- a/usr/src/uts/common/io/fcoe/fcoe.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/fcoe/fcoe.c	Wed Aug 05 17:14:23 2009 -0700
@@ -195,7 +195,7 @@
 	ddi_quiesce_not_needed
 };
 
-#define	FCOE_VERSION	"20090311-1.00"
+#define	FCOE_VERSION	"20090729-1.01"
 #define	FCOE_NAME	"FCoE Transport v" FCOE_VERSION
 #define	TASKQ_NAME_LEN	32
 
@@ -223,6 +223,7 @@
 /*
  * Driver's global variables
  */
+const fcoe_ver_e	 fcoe_ver_now	  = FCOE_VER_NOW;
 static void		*fcoe_state	  = NULL;
 fcoe_soft_state_t	*fcoe_global_ss	  = NULL;
 int			 fcoe_use_ext_log = 1;
@@ -409,23 +410,19 @@
 static int
 fcoe_initchild(dev_info_t *fcoe_dip, dev_info_t *client_dip)
 {
-	char		 name[32];
-	static int	 inicounter = 0;
-	static int	 tgtcounter = 0;
-	int		*counter;
+	char	client_addr[FCOE_STR_LEN];
+	int	rval;
 
-	if (strcmp(ddi_driver_name(client_dip), FCOET_DRIVER_NAME) == 0) {
-		counter = &tgtcounter;
-		tgtcounter++;
-	} else {
-		counter = &inicounter;
-		inicounter++;
+	rval = ddi_prop_get_int(DDI_DEV_T_ANY, client_dip,
+	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "mac_id", -1);
+	if (rval == -1) {
+		FCOE_LOG(__FUNCTION__, "no mac_id property: %p", client_dip);
+		return (DDI_FAILURE);
 	}
 
-	bzero(name, 32);
-	(void) sprintf((char *)name, "%x,0", *counter);
-	ddi_set_name_addr(client_dip, name);
-
+	bzero(client_addr, FCOE_STR_LEN);
+	(void) sprintf((char *)client_addr, "%x,0", rval);
+	ddi_set_name_addr(client_dip, client_addr);
 	return (DDI_SUCCESS);
 }
 
@@ -778,11 +775,9 @@
 		mutex_enter(&ss->ss_ioctl_mutex);
 		ret = fcoe_delete_port(ss->ss_dip, fcoeio,
 		    del_port_param->fdp_mac_linkid, is_target);
-		if (ret != 0) {
-			FCOE_LOG("fcoe",
-			    "fcoe_delete_port failed: %d", ret);
-		}
 		mutex_exit(&ss->ss_ioctl_mutex);
+		FCOE_LOG("fcoe", "fcoe_delete_port %x return: %d",
+		    del_port_param->fdp_mac_linkid, ret);
 		break;
 	}
 
@@ -818,8 +813,8 @@
 		return (ENOTTY);
 	}
 
-	FCOE_LOG("fcoe", "fcoe_ioctl returned %d, fcoeio_status = %d",
-	    ret, fcoeio->fcoeio_status);
+	FCOE_LOG("fcoe", "fcoe_ioctl %x returned %d, fcoeio_status = %d",
+	    fcoeio->fcoeio_cmd, ret, fcoeio->fcoeio_status);
 
 fcoeiocmd_release_buf:
 	if (ret == 0) {

--- a/usr/src/uts/common/io/fcoe/fcoe.h	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/fcoe/fcoe.h	Wed Aug 05 17:14:23 2009 -0700
@@ -156,6 +156,7 @@
 
 #define	FCOE_MAC_FLAG_ENABLED		0x01
 #define	FCOE_MAC_FLAG_BOUND		0x02
+#define	FCOE_MAC_FLAG_USER_DEL		0x04
 
 typedef struct fcoe_frame_header {
 	uint8_t		 ffh_ver[1];	/* version field - upper 4 bits */

--- a/usr/src/uts/common/io/fcoe/fcoe_eth.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/fcoe/fcoe_eth.c	Wed Aug 05 17:14:23 2009 -0700
@@ -199,6 +199,9 @@
 	    mac_stat_get(mac->fm_handle, MAC_STAT_LINK_UP)?
 	    FCOE_MAC_LINK_STATE_UP:FCOE_MAC_LINK_STATE_DOWN;
 
+	mac->fm_eport.eport_link_speed =
+	    mac_client_stat_get(mac->fm_cli_handle, MAC_STAT_IFSPEED);
+
 	/*
 	 * Add a notify function so that we get updates from MAC
 	 */
@@ -259,6 +262,7 @@
 		frame_size = raw_frame_size - PADDING_SIZE;
 		frm = fcoe_allocate_frame(&mac->fm_eport, frame_size, mp);
 		if (frm != NULL) {
+			frm->frm_clock = CURRENT_CLOCK;
 			fcoe_post_frame(frm);
 		}
 
@@ -290,7 +294,6 @@
 			mac->fm_eport.eport_link_speed =
 			    mac_client_stat_get(mac->fm_cli_handle,
 			    MAC_STAT_IFSPEED);
-
 			(void) fcoe_mac_set_address(&mac->fm_eport,
 			    mac->fm_primary_addr, B_FALSE);
 

--- a/usr/src/uts/common/io/fcoe/fcoe_fc.c	Wed Aug 05 16:12:50 2009 -0700
+++ b/usr/src/uts/common/io/fcoe/fcoe_fc.c	Wed Aug 05 17:14:23 2009 -0700
@@ -72,7 +72,11 @@
 	fcoe_mac_t	*mac;
 	fcoe_port_t	*eport;
 
-	ASSERT(MUTEX_HELD(&fcoe_global_ss->ss_ioctl_mutex));
+	if (client->ect_fcoe_ver != fcoe_ver_now) {
+		cmn_err(CE_WARN, "FCoE modules version mismatch, "
+		    "fail registering client.");
+		return (NULL);
+	}
 
 	/*
 	 * We will not come here, when someone is changing ss_mac_list,
@@ -131,8 +135,6 @@
 {
 	fcoe_mac_t	*mac = EPORT2MAC(eport);
 
-	ASSERT(MUTEX_HELD(&fcoe_global_ss->ss_ioctl_mutex));
-
 	/*
 	 * Wait for all the related frame to be freed, this should be fast
 	 * because before deregister fcoei/fcoet will make sure its port
@@ -144,6 +146,11 @@
 	}
 
 	atomic_and_32(&EPORT2MAC(eport)->fm_flags, ~FCOE_MAC_FLAG_BOUND);
+	atomic_and_32(&mac->fm_eport.eport_flags, ~EPORT_FLAG_MAC_IN_USE);
+	if (!(EPORT2MAC(eport)->fm_flags & FCOE_MAC_FLAG_USER_DEL)) {
+		(void) fcoe_close_mac(mac);
+		fcoe_destroy_mac(mac);
+	}
 }
 
 /* ARGSUSED */
@@ -466,14 +473,21 @@
 	}
 
 	*is_target = EPORT_CLT_TYPE(&mac->fm_eport);
-
 	if ((mac->fm_flags & FCOE_MAC_FLAG_ENABLED) != FCOE_MAC_FLAG_ENABLED) {
 		fcoeio->fcoeio_status = FCOEIOE_ALREADY;
 		return (EALREADY);
 	}
 
+	if (!(mac->fm_flags & FCOE_MAC_FLAG_BOUND)) {
+		/*
+		 * It means that deferred detach has finished
+		 * of last delete operation
+		 */
+		goto skip_devi_offline;
+	}
+
 	atomic_and_32(&mac->fm_eport.eport_flags, ~EPORT_FLAG_MAC_IN_USE);
-
+	mac->fm_flags |= FCOE_MAC_FLAG_USER_DEL;
 	rval = ndi_devi_offline(mac->fm_client_dev, NDI_DEVI_REMOVE);
 	if (rval != NDI_SUCCESS) {
 		FCOE_LOG("fcoe", "fcoe%d: offline_driver %s failed",
@@ -485,6 +499,8 @@
 		fcoeio->fcoeio_status = FCOEIOE_OFFLINE_FAILURE;
 		return (EBUSY);
 	}
+
+skip_devi_offline:
 	(void) fcoe_close_mac(mac);
 	fcoe_destroy_mac(mac);
 	return (0);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/uts/common/io/fibre-channel/fca/fcoei/fcoei.c	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,1130 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <sys/conf.h>
+#include <sys/ddi.h>
+#include <sys/stat.h>
+#include <sys/pci.h>
+#include <sys/sunddi.h>
+#include <sys/modctl.h>
+#include <sys/file.h>
+#include <sys/cred.h>
+#include <sys/byteorder.h>
+#include <sys/atomic.h>
+#include <sys/scsi/scsi.h>
+#include <sys/mac_client.h>
+#include <sys/modhash.h>
+
+/*
+ * leadville header files
+ */
+#include <sys/fibre-channel/fc.h>
+#include <sys/fibre-channel/impl/fc_fcaif.h>
+
+/*
+ * fcoe header files
+ */
+#include <sys/fcoe/fcoe_common.h>
+
+/*
+ * fcoei header files
+ */
+#include <fcoei.h>
+
+/*
+ * forward declaration of stack functions
+ */
+static uint32_t fcoei_xch_check(
+	mod_hash_key_t key, mod_hash_val_t *val, void *arg);
+static int fcoei_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
+static int fcoei_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
+static int fcoei_open(dev_t *devp, int flag, int otype, cred_t *credp);
+static int fcoei_close(dev_t dev, int flag, int otype, cred_t *credp);
+static int fcoei_ioctl(
+	dev_t dev, int cmd, intptr_t data, int mode, cred_t *credp, int *rval);
+static int fcoei_attach_init(fcoei_soft_state_t *ss);
+static int fcoei_detach_uninit(fcoei_soft_state_t *ss);
+static void fcoei_watchdog(void *arg);
+static void fcoei_process_events(fcoei_soft_state_t *ss);
+static void fcoei_trigger_fp_attach(void *arg);
+static void fcoei_abts_exchange(fcoei_exchange_t *xch);
+static void fcoei_clear_watchdog_jobs(fcoei_soft_state_t *ss);
+
+/*
+ * Driver identificaton stuff
+ */
+static struct cb_ops fcoei_cb_ops = {
+	fcoei_open,
+	fcoei_close,
+	nodev,
+	nodev,
+	nodev,
+	nodev,
+	nodev,
+	fcoei_ioctl,
+	nodev,
+	nodev,
+	nodev,
+	nochpoll,
+	ddi_prop_op,
+	0,
+	D_MP | D_NEW | D_HOTPLUG,
+	CB_REV,
+	nodev,
+	nodev
+};
+
+static struct dev_ops fcoei_ops = {
+	DEVO_REV,
+	0,
+	nodev,
+	nulldev,
+	nulldev,
+	fcoei_attach,
+	fcoei_detach,
+	nodev,
+	&fcoei_cb_ops,
+	NULL,
+	ddi_power,
+	ddi_quiesce_not_needed
+};
+
+static struct modldrv modldrv = {
+	&mod_driverops,
+	FCOEI_NAME_VERSION,
+	&fcoei_ops,
+};
+
+static struct modlinkage modlinkage = {
+	MODREV_1,
+	&modldrv,
+	NULL
+};
+
+/*
+ * Driver's global variables
+ */
+void	*fcoei_state	   = NULL;
+int	 fcoei_use_ext_log = 0;
+
+/*
+ * Common loadable module entry points _init, _fini, _info
+ */
+int
+_init(void)
+{
+	int ret;
+
+	ret = ddi_soft_state_init(&fcoei_state, sizeof (fcoei_soft_state_t), 0);
+	if (ret != DDI_SUCCESS) {
+		FCOEI_LOG(__FUNCTION__, "soft state init failed: %x", ret);
+		return (ret);
+	}
+
+	ret = mod_install(&modlinkage);
+	if (ret != 0) {
+		ddi_soft_state_fini(&fcoei_state);
+		FCOEI_LOG(__FUNCTION__, "fcoei mod_install failed: %x", ret);
+		return (ret);
+	}
+
+	/*
+	 * Let FCTL initialize devo_bus_ops
+	 */
+	fc_fca_init(&fcoei_ops);
+
+	FCOEI_LOG(__FUNCTION__, "fcoei _init succeeded");
+	return (ret);
+}
+
+int
+_fini(void)
+{
+	int ret;
+
+	ret = mod_remove(&modlinkage);
+	if (ret != 0) {
+		FCOEI_EXT_LOG(__FUNCTION__, "fcoei mod_remove failed: %x", ret);
+		return (ret);
+	}
+
+	ddi_soft_state_fini(&fcoei_state);
+	FCOEI_LOG(__FUNCTION__, "fcoei _fini succeeded");
+	return (ret);
+}
+
+int
+_info(struct modinfo *modinfop)
+{
+	return (mod_info(&modlinkage, modinfop));
+}
+
+/*
+ * Autoconfiguration entry points: attach, detach, getinfo
+ */
+
+static int
+fcoei_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
+{
+	int			 ret;
+	int			 fcoe_ret;
+	int			 instance;
+	fcoei_soft_state_t	*ss;
+
+	instance = ddi_get_instance(dip);
+	FCOEI_LOG(__FUNCTION__, "instance is %d", instance);
+	switch (cmd) {
+	case DDI_ATTACH:
+		ret = ddi_soft_state_zalloc(fcoei_state, instance);
+		if (ret != DDI_SUCCESS) {
+			FCOEI_LOG(__FUNCTION__, "ss zalloc failed: %x", ret);
+			return (ret);
+		}
+
+		/*
+		 * Get the soft state, and do basic initialization with dip
+		 */
+		ss = ddi_get_soft_state(fcoei_state, instance);
+		ss->ss_dip = dip;
+
+		fcoe_ret = fcoei_attach_init(ss);
+		if (fcoe_ret != FCOE_SUCCESS) {
+			ddi_soft_state_free(fcoei_state, instance);
+			FCOEI_LOG(__FUNCTION__, "fcoei_attach_init failed: "
+			    "%x", fcoe_ret);
+			return (DDI_FAILURE);
+		}
+
+		ss->ss_flags |= SS_FLAG_TRIGGER_FP_ATTACH;
+		(void) timeout(fcoei_trigger_fp_attach, ss, FCOE_SEC2TICK(1));
+		FCOEI_LOG(__FUNCTION__, "fcoei_attach succeeded: dip-%p, "
+		    "cmd-%x", dip, cmd);
+		return (DDI_SUCCESS);
+
+	case DDI_RESUME:
+		return (DDI_SUCCESS);
+
+	default:
+		FCOEI_LOG(__FUNCTION__, "unsupported attach cmd-%X", cmd);
+		return (DDI_FAILURE);
+	}
+}
+
+static int
+fcoei_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
+{
+	int			 fcoe_ret;
+	int			 instance;
+	fcoei_soft_state_t	*ss;
+
+	instance = ddi_get_instance(dip);
+	ss = ddi_get_soft_state(fcoei_state, instance);
+	if (ss == NULL) {
+		FCOEI_LOG(__FUNCTION__, "get ss failed: dip-%p", dip);
+		return (DDI_FAILURE);
+	}
+
+	switch (cmd) {
+	case DDI_DETACH:
+		if (ss->ss_flags & SS_FLAG_TRIGGER_FP_ATTACH) {
+			FCOEI_LOG(__FUNCTION__, "still await fp attach");
+			return (DDI_FAILURE);
+		}
+
+		if (ss->ss_flags & SS_FLAG_LV_BOUND) {
+			FCOEI_LOG(__FUNCTION__, "fp is not detached yet");
+			return (DDI_FAILURE);
+		}
+
+		fcoe_ret = fcoei_detach_uninit(ss);
+		if (fcoe_ret != FCOE_SUCCESS) {
+			FCOEI_LOG(__FUNCTION__, "fcoei_detach_uninit failed:"
+			    " dip-%p, fcoe_ret-%d", dip, fcoe_ret);
+			return (DDI_FAILURE);
+		}
+
+		FCOEI_LOG(__FUNCTION__, "succeeded: dip-%p, cmd-%x", dip, cmd);
+		return (DDI_SUCCESS);
+
+	case DDI_SUSPEND:
+		return (DDI_SUCCESS);
+
+	default:
+		FCOEI_LOG(__FUNCTION__, "unspported detach cmd-%X", cmd);
+		return (DDI_FAILURE);
+	}
+}
+
+/*
+ * Device access entry points: open, close, ioctl
+ */
+
+static int
+fcoei_open(dev_t *devp, int flag, int otype, cred_t *credp)
+{
+	fcoei_soft_state_t	*ss;
+
+	if (otype != OTYP_CHR) {
+		FCOEI_LOG(__FUNCTION__, "flag: %x", flag);
+		return (EINVAL);
+	}
+
+	if (drv_priv(credp)) {
+		return (EPERM);
+	}
+
+	/*
+	 * First of all, get related soft state
+	 */
+	ss = ddi_get_soft_state(fcoei_state, (int)getminor(*devp));
+	if (ss == NULL) {
+		return (ENXIO);
+	}
+
+	mutex_enter(&ss->ss_ioctl_mutex);
+	if (ss->ss_ioctl_flags & FCOEI_IOCTL_FLAG_OPEN) {
+		/*
+		 * We don't support concurrent open
+		 */
+		mutex_exit(&ss->ss_ioctl_mutex);
+		return (EBUSY);
+	}
+
+	ss->ss_ioctl_flags |= FCOEI_IOCTL_FLAG_OPEN;
+	mutex_exit(&ss->ss_ioctl_mutex);
+
+	return (0);
+}
+
+static int
+fcoei_close(dev_t dev, int flag, int otype, cred_t *credp)
+{
+	fcoei_soft_state_t	*ss;
+
+	if (otype != OTYP_CHR) {
+		FCOEI_LOG(__FUNCTION__, "flag: %x, %p", flag, credp);
+		return (EINVAL);
+	}
+
+	/*
+	 * First of all, get related soft state
+	 */
+	ss = ddi_get_soft_state(fcoei_state, (int)getminor(dev));
+	if (ss == NULL) {
+		return (ENXIO);
+	}
+
+	mutex_enter(&ss->ss_ioctl_mutex);
+	if (!(ss->ss_ioctl_flags & FCOEI_IOCTL_FLAG_OPEN)) {
+		/*
+		 * If it's not open, we can exit
+		 */
+
+		mutex_exit(&ss->ss_ioctl_mutex);
+		return (ENODEV);
+	}
+
+	ss->ss_ioctl_flags &= ~FCOEI_IOCTL_FLAG_OPEN;
+	mutex_exit(&ss->ss_ioctl_mutex);
+
+	return (0);
+}
+
+static int
+fcoei_ioctl(dev_t dev, int cmd, intptr_t data, int mode,
+    cred_t *credp, int *rval)
+{
+	fcoei_soft_state_t	*ss;
+	int			 ret = 0;
+
+	if (drv_priv(credp) != 0) {
+		FCOEI_LOG(__FUNCTION__, "data: %p, %x", data, mode);
+		return (EPERM);
+	}
+
+	/*
+	 * Get related soft state
+	 */
+	ss = ddi_get_soft_state(fcoei_state, (int32_t)getminor(dev));
+	if (!ss) {
+		return (ENXIO);
+	}
+
+	/*
+	 * Process ioctl
+	 */
+	switch (cmd) {
+
+	default:
+		FCOEI_LOG(__FUNCTION__, "ioctl-0x%02X", cmd);
+		ret = ENOTTY;
+	}
+
+	/*
+	 * Set return value
+	 */
+	*rval = ret;
+	return (ret);
+}
+
+/*
+ * fcoei_attach_init
+ *	init related stuff of the soft state
+ *
+ * Input:
+ *	ss = the soft state that will be processed
+ *
+ * Return:
+ *	if it succeeded or not
+ *
+ * Comment:
+ *	N/A
+ */
+static int
+fcoei_attach_init(fcoei_soft_state_t *ss)
+{
+	fcoe_port_t		*eport;
+	fcoe_client_t		 client_fcoei;
+	char			 taskq_name[32];
+	int			 ret;
+	la_els_logi_t		*els = &ss->ss_els_logi;
+	svc_param_t		*class3_param;
+
+	/*
+	 * Register fcoei to FCOE as its client
+	 */
+	client_fcoei.ect_eport_flags = EPORT_FLAG_INI_MODE |
+	    EPORT_FLAG_IS_DIRECT_P2P;
+	client_fcoei.ect_max_fc_frame_size = FCOE_MAX_FC_FRAME_SIZE;
+	client_fcoei.ect_private_frame_struct_size = sizeof (fcoei_frame_t);
+	fcoei_init_ect_vectors(&client_fcoei);
+	client_fcoei.ect_client_port_struct = ss;
+	client_fcoei.ect_fcoe_ver = FCOE_VER_NOW;
+	FCOEI_LOG(__FUNCTION__, "version: %x %x", FCOE_VER_NOW, fcoe_ver_now);
+	ret = ddi_prop_get_int(DDI_DEV_T_ANY, ss->ss_dip,
+	    DDI_PROP_DONTPASS | DDI_PROP_NOTPROM, "mac_id", -1);
+	if (ret == -1) {
+		FCOEI_LOG(__FUNCTION__, "get mac_id failed");
+		return (DDI_FAILURE);
+	} else {
+		client_fcoei.ect_channelid = ret;
+	}
+
+	/*
+	 * It's fcoe's responsiblity to initialize eport's all elements,
+	 * so we needn't do eport initialization
+	 */
+	eport = fcoe_register_client(&client_fcoei);
+	if (eport == NULL) {
+		goto fail_register_client;
+	} else {
+		ss->ss_eport = eport;
+		FCOE_SET_DEFAULT_FPORT_ADDR(eport->eport_efh_dst);
+	}
+
+	/*
+	 * Now it's time to register fca_tran to FCTL
+	 * Remember fc_local_port is transparent to FCA (fcoei)
+	 */
+	ss->ss_fca_tran.fca_version  = FCTL_FCA_MODREV_5;
+	ss->ss_fca_tran.fca_numports = 1;
+	ss->ss_fca_tran.fca_pkt_size = sizeof (fcoei_exchange_t);
+	ss->ss_fca_tran.fca_cmd_max  = 2048;
+
+	/*
+	 * scsi_tran_hba_setup could need these stuff
+	 */
+	ss->ss_fca_tran.fca_dma_lim  = NULL;
+	ss->ss_fca_tran.fca_iblock   = NULL;
+	ss->ss_fca_tran.fca_dma_attr = NULL;
+	ss->ss_fca_tran.fca_acc_attr = NULL;
+
+	/*
+	 * Initialize vectors
+	 */
+	fcoei_init_fcatran_vectors(&ss->ss_fca_tran);
+
+	/*
+	 * fc_fca_attach only sets driver's private, it has nothing to with
+	 * common port object between fcoei and leadville.
+	 * After this attach, fp_attach will be triggered, and it will call
+	 * fca_bind_port to let fcoei to know about common port object.
+	 */
+	if (fc_fca_attach(ss->ss_dip, &ss->ss_fca_tran) != DDI_SUCCESS) {
+		goto fail_fca_attach;
+	}
+
+	/*
+	 * It's time to do ss initialization
+	 */
+	ret = ddi_create_minor_node(ss->ss_dip, "admin",
+	    S_IFCHR, ddi_get_instance(ss->ss_dip), DDI_NT_NEXUS, 0);
+	if (ret != DDI_SUCCESS) {
+		goto fail_minor_node;
+	}
+
+	ss->ss_flags	   = 0;
+	ss->ss_port	   = NULL;
+	/*
+	 * ss->ss_eport has been initialized
+	 */
+
+	ss->ss_sol_oxid_hash = mod_hash_create_idhash(
+	    "fcoei_sol_oxid_hash", FCOEI_SOL_HASH_SIZE,
+	    mod_hash_null_valdtor);
+	ss->ss_unsol_rxid_hash = mod_hash_create_idhash(
+	    "fcoei_unsol_rxid_hash", FCOEI_UNSOL_HASH_SIZE,
+	    mod_hash_null_valdtor);
+	list_create(&ss->ss_comp_xch_list, sizeof (fcoei_exchange_t),
+	    offsetof(fcoei_exchange_t, xch_comp_node));
+	ss->ss_next_sol_oxid   = 0xFFFF;
+	ss->ss_next_unsol_rxid = 0xFFFF;
+
+	mutex_init(&ss->ss_watchdog_mutex, 0, MUTEX_DRIVER, 0);
+	cv_init(&ss->ss_watchdog_cv, NULL, CV_DRIVER, NULL);
+	(void) snprintf(taskq_name, 32, "leadville_fcoei_%d_taskq",
+	    ddi_get_instance(ss->ss_dip));
+	taskq_name[31] = 0;
+	ss->ss_taskq = ddi_taskq_create(ss->ss_dip,
+	    taskq_name, 64, TASKQ_DEFAULTPRI, DDI_SLEEP);
+
+	ss->ss_link_state	  = FC_STATE_OFFLINE;
+	ss->ss_link_speed	  = 0;
+	ss->ss_port_event_counter = 0;
+
+	list_create(&ss->ss_event_list, sizeof (fcoei_event_t),
+	    offsetof(fcoei_event_t, ae_node));
+
+	ss->ss_sol_cnt1   = 0;
+	ss->ss_sol_cnt2   = 0;
+	ss->ss_sol_cnt	   = &ss->ss_sol_cnt1;
+	ss->ss_unsol_cnt1 = 0;
+	ss->ss_unsol_cnt2 = 0;
+	ss->ss_unsol_cnt  = &ss->ss_unsol_cnt1;
+	ss->ss_ioctl_flags = 0;
+
+	mutex_init(&ss->ss_ioctl_mutex, 0, MUTEX_DRIVER, 0);
+
+	bcopy(eport->eport_portwwn, els->nport_ww_name.raw_wwn, 8);
+	bcopy(eport->eport_nodewwn, els->node_ww_name.raw_wwn, 8);
+	els->common_service.fcph_version = 0x2008;
+	els->common_service.btob_credit = 3;
+	els->common_service.cmn_features = 0x8800;
+	els->common_service.conc_sequences = 0xff;
+	els->common_service.relative_offset = 3;
+	els->common_service.e_d_tov = 0x07d0;
+	class3_param = (svc_param_t *)&els->class_3;
+	class3_param->class_opt = 0x8800;
+	class3_param->rcv_size = els->common_service.rx_bufsize = 2048;
+	class3_param->conc_sequences = 0xff;
+	class3_param->open_seq_per_xchng = 1;
+
+	/*
+	 * Fill out RNID Management Information
+	 */
+	bcopy(ss->ss_eport->eport_portwwn, ss->ss_rnid.global_id, 8);
+	ss->ss_rnid.unit_type  = FCOEI_RNID_HBA;
+	ss->ss_rnid.ip_version = FCOEI_RNID_IPV4;
+
+	/*
+	 * Start our watchdog
+	 */
+	(void) ddi_taskq_dispatch(ss->ss_taskq,
+	    fcoei_watchdog, ss, DDI_SLEEP);
+	while (!(ss->ss_flags & SS_FLAG_WATCHDOG_RUNNING)) {
+		delay(50);
+	}
+
+	/*
+	 * Report the device to the system
+	 */
+	ddi_report_dev(ss->ss_dip);
+	return (DDI_SUCCESS);
+
+
+fail_minor_node:
+	FCOEI_LOG(__FUNCTION__, "fail_minor_node");
+	fc_fca_detach(ss->ss_dip);
+
+fail_fca_attach:
+	eport->eport_deregister_client(eport);
+	FCOEI_LOG(__FUNCTION__, "fail_fca_attach");
+
+fail_register_client:
+	FCOEI_LOG(__FUNCTION__, "fail_register_client");
+	return (DDI_FAILURE);
+}
+
+/*
+ * fcoei_detach_uninit
+ *	uninit related stuff of the soft state
+ *
+ * Input:
+ *	ss = the soft state that will be processed
+ *
+ * Return:
+ *	if it succeeded or not
+ *
+ * Comment:
+ *	N/A
+ */
+int
+fcoei_detach_uninit(fcoei_soft_state_t *ss)
+{
+	/*
+	 * Stop watchdog first
+	 */
+	if (ss->ss_flags & SS_FLAG_WATCHDOG_RUNNING) {
+		ss->ss_flags |= SS_FLAG_TERMINATE_WATCHDOG;
+		cv_broadcast(&ss->ss_watchdog_cv);
+	}
+
+	/*
+	 * Destroy the taskq
+	 */
+	ddi_taskq_wait(ss->ss_taskq);
+	ddi_taskq_destroy(ss->ss_taskq);
+
+	/*
+	 * Release all allocated resources
+	 */
+	mutex_destroy(&ss->ss_ioctl_mutex);
+	mutex_destroy(&ss->ss_watchdog_mutex);
+	cv_destroy(&ss->ss_watchdog_cv);
+	mod_hash_destroy_idhash(ss->ss_sol_oxid_hash);
+	mod_hash_destroy_idhash(ss->ss_unsol_rxid_hash);
+	list_destroy(&ss->ss_event_list);
+	ss->ss_eport->eport_deregister_client(ss->ss_eport);
+	ddi_remove_minor_node(ss->ss_dip, NULL);
+
+	/*
+	 * Release itself
+	 */
+	ddi_soft_state_free(fcoei_state, ddi_get_instance(ss->ss_dip));
+	return (FCOE_SUCCESS);
+}
+
+/*
+ * fcoei_watchdog
+ *	Perform periodic checking and routine tasks
+ *
+ * Input:
+ *	arg = the soft state that will be processed
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	N/A
+ */
+static void
+fcoei_watchdog(void *arg)
+{
+	fcoei_soft_state_t	*ss;
+	clock_t			 tmp_delay;
+	clock_t			 start_clock;
+	clock_t			 last_clock;
+
+	/*
+	 * For debugging
+	 */
+	ss = (fcoei_soft_state_t *)arg;
+	FCOEI_LOG(__FUNCTION__, "ss %p", ss);
+	FCOEI_LOG(__FUNCTION__, "sol_hash %p", ss->ss_sol_oxid_hash);
+	FCOEI_LOG(__FUNCTION__, "unsol_hash %p", ss->ss_unsol_rxid_hash);
+	ss->ss_flags |= SS_FLAG_WATCHDOG_RUNNING;
+	tmp_delay = FCOE_SEC2TICK(1) / 2;
+	last_clock = CURRENT_CLOCK;
+
+	/*
+	 * If nobody reqeusts to terminate the watchdog, we will work forever
+	 */
+	while (!(ss->ss_flags & SS_FLAG_TERMINATE_WATCHDOG)) {
+		/*
+		 * We handle all asynchronous events serially
+		 */
+		fcoei_process_events(ss);
+
+		/*
+		 * To avoid to check timing too freqently, we check
+		 * if we need skip timing stuff.
+		 */
+		start_clock = CURRENT_CLOCK;
+		if ((start_clock - last_clock) < tmp_delay) {
+			goto end_timing;
+		} else {
+			last_clock = start_clock;
+		}
+
+		/*
+		 * It's time to do timeout checking of solicited exchanges
+		 */
+		if (ss->ss_sol_cnt == (&ss->ss_sol_cnt1)) {
+			if (ss->ss_sol_cnt2 == 0) {
+				ss->ss_sol_cnt = &ss->ss_sol_cnt2;
+			} else {
+				mod_hash_walk(ss->ss_sol_oxid_hash,
+				    fcoei_xch_check, ss);
+			}
+		} else {
+			if (ss->ss_sol_cnt1 == 0) {
+				ss->ss_sol_cnt = &ss->ss_sol_cnt1;
+			} else {
+				mod_hash_walk(ss->ss_sol_oxid_hash,
+				    fcoei_xch_check, ss);
+			}
+		}
+
+		/*
+		 * It's time to do timeout checking of unsolicited exchange
+		 */
+		if (ss->ss_unsol_cnt == (&ss->ss_unsol_cnt1)) {
+			if (ss->ss_unsol_cnt2 == 0) {
+				ss->ss_unsol_cnt = &ss->ss_unsol_cnt2;
+			} else {
+				mod_hash_walk(ss->ss_unsol_rxid_hash,
+				    fcoei_xch_check, ss);
+			}
+		} else {
+			if (ss->ss_unsol_cnt1 == 0) {
+				ss->ss_unsol_cnt = &ss->ss_unsol_cnt1;
+			} else {
+				mod_hash_walk(ss->ss_unsol_rxid_hash,
+				    fcoei_xch_check, ss);
+			}
+		}
+
+		/*
+		 * Check if there are exchanges which are ready to complete
+		 */
+		fcoei_handle_comp_xch_list(ss);
+
+	end_timing:
+		/*
+		 * Wait for next cycle
+		 */
+		mutex_enter(&ss->ss_watchdog_mutex);
+		ss->ss_flags |= SS_FLAG_WATCHDOG_IDLE;
+		if (!list_is_empty(&ss->ss_event_list)) {
+			goto skip_wait;
+		}
+
+		(void) cv_timedwait(&ss->ss_watchdog_cv,
+		    &ss->ss_watchdog_mutex, CURRENT_CLOCK +
+		    (clock_t)tmp_delay);
+	skip_wait:
+		ss->ss_flags &= ~SS_FLAG_WATCHDOG_IDLE;
+		mutex_exit(&ss->ss_watchdog_mutex);
+	}
+
+	/*
+	 * Do clear work before exit
+	 */
+	fcoei_clear_watchdog_jobs(ss);
+
+	/*
+	 * Watchdog has stopped
+	 */
+	ss->ss_flags &= ~SS_FLAG_WATCHDOG_RUNNING;
+}
+
+static void
+fcoei_clear_watchdog_jobs(fcoei_soft_state_t *ss)
+{
+	fcoei_event_t 		*ae;
+	fcoe_frame_t		*frm;
+
+	mutex_enter(&ss->ss_watchdog_mutex);
+	while (!list_is_empty(&ss->ss_event_list)) {
+		ae = (fcoei_event_t *)list_head(&ss->ss_event_list);
+		list_remove(&ss->ss_event_list, ae);
+		switch (ae->ae_type) {
+		case AE_EVENT_SOL_FRAME:
+			frm = (fcoe_frame_t *)ae->ae_obj;
+			frm->frm_eport->eport_release_frame(frm);
+			break;
+
+		case AE_EVENT_UNSOL_FRAME:
+			frm = (fcoe_frame_t *)ae->ae_obj;
+			frm->frm_eport->eport_free_netb(frm->frm_netb);
+			frm->frm_eport->eport_release_frame(frm);
+			break;
+
+		case AE_EVENT_PORT:
+			atomic_add_32(&ss->ss_port_event_counter, -1);
+			/* FALLTHROUGH */
+
+		case AE_EVENT_RESET:
+			kmem_free(ae, sizeof (fcoei_event_t));
+			break;
+
+		case AE_EVENT_EXCHANGE:
+			/* FALLTHROUGH */
+
+		default:
+			break;
+		}
+	}
+
+	mod_hash_clear(ss->ss_unsol_rxid_hash);
+	mod_hash_clear(ss->ss_sol_oxid_hash);
+
+	while (!list_is_empty(&ss->ss_comp_xch_list)) {
+		list_remove_head(&ss->ss_comp_xch_list);
+	}
+	mutex_exit(&ss->ss_watchdog_mutex);
+}
+
+/*
+ * fcoei_process_events
+ *	Process the events one by one
+ *
+ * Input:
+ *	ss = the soft state that will be processed
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	N/A
+ */
+static void
+fcoei_process_events(fcoei_soft_state_t *ss)
+{
+	fcoei_event_t	*ae = NULL;
+
+	/*
+	 * It's the only place to delete node from ss_event_list, so we needn't
+	 * hold mutex to check if the list is empty.
+	 */
+	ASSERT(!MUTEX_HELD(&ss->ss_watchdog_mutex));
+	while (list_is_empty(&ss->ss_event_list) == B_FALSE) {
+		mutex_enter(&ss->ss_watchdog_mutex);
+		ae = (fcoei_event_t *)list_remove_head(&ss->ss_event_list);
+		mutex_exit(&ss->ss_watchdog_mutex);
+
+		switch (ae->ae_type) {
+		case AE_EVENT_SOL_FRAME:
+			fcoei_handle_sol_frame_done((fcoe_frame_t *)ae->ae_obj);
+			break;
+
+		case AE_EVENT_UNSOL_FRAME:
+			fcoei_process_unsol_frame((fcoe_frame_t *)ae->ae_obj);
+			break;
+
+		case AE_EVENT_EXCHANGE:
+			fcoei_process_event_exchange(ae);
+			break;
+
+		case AE_EVENT_PORT:
+			fcoei_process_event_port(ae);
+			break;
+
+		case AE_EVENT_RESET:
+			fcoei_process_event_reset(ae);
+			break;
+
+		default:
+			FCOEI_LOG(__FUNCTION__, "unsupported events");
+		}
+
+	}
+}
+
+/*
+ * fcoei_handle_tmout_xch_list
+ *	Complete every exchange in the timed-out xch list of the soft state
+ *
+ * Input:
+ *	ss = the soft state that need be handled
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	When mod_hash_walk is in progress, we can't change the hashtable.
+ *	This is post-walk handling of exchange timing
+ */
+void
+fcoei_handle_comp_xch_list(fcoei_soft_state_t *ss)
+{
+	fcoei_exchange_t	*xch	  = NULL;
+
+	while ((xch = list_remove_head(&ss->ss_comp_xch_list)) != NULL) {
+		fcoei_complete_xch(xch, NULL, xch->xch_fpkt->pkt_state,
+		    xch->xch_fpkt->pkt_reason);
+	}
+}
+
+/*
+ * fcoei_xch_check
+ *	Check if the exchange timed out or link is down
+ *
+ * Input:
+ *	key = rxid of the unsolicited exchange
+ *	val = the unsolicited exchange
+ *	arg = the soft state
+ *
+ * Return:
+ *	MH_WALK_CONTINUE = continue to walk
+ *
+ * Comment:
+ *	We need send ABTS for timed-out for solicited exchange
+ *	If it's solicited FLOGI, we need set SS_FLAG_FLOGI_FAILED
+ *	If the link is down, we think it has timed out too.
+ */
+static uint32_t
+fcoei_xch_check(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
+{
+	fcoei_exchange_t	*xch = (fcoei_exchange_t *)val;
+
+	ASSERT(xch->xch_ss == arg);
+	if ((xch->xch_end_tick < CURRENT_CLOCK) &&
+	    (xch->xch_ss->ss_link_state != FC_STATE_OFFLINE)) {
+		if (xch->xch_flags & XCH_FLAG_IN_SOL_HASH) {
+			ASSERT(xch->xch_oxid == CMHK(key));
+			/*
+			 * It's solicited exchange
+			 */
+			fcoei_abts_exchange(xch);
+			if (LA_ELS_FLOGI == ((ls_code_t *)(void *)
+			    xch->xch_fpkt->pkt_cmd)->ls_code) {
+				/*
+				 * It's solicited FLOGI
+				 */
+				xch->xch_ss->ss_flags |= SS_FLAG_FLOGI_FAILED;
+			}
+		}
+
+		FCOEI_LOG(__FUNCTION__, "oxid-%x/rxid-%x  timed out",
+		    xch->xch_oxid, xch->xch_rxid);
+		xch->xch_flags |= XCH_FLAG_TMOUT;
+		xch->xch_fpkt->pkt_state = FC_PKT_TIMEOUT;
+		xch->xch_fpkt->pkt_reason = FC_REASON_ABORTED;
+		list_insert_tail(&xch->xch_ss->ss_comp_xch_list, xch);
+	} else if (xch->xch_ss->ss_link_state == FC_STATE_OFFLINE) {
+		FCOEI_LOG(__FUNCTION__, "oxid-%x/rxid-%x  offline complete",
+		    xch->xch_oxid, xch->xch_rxid);
+		xch->xch_flags |= XCH_FLAG_TMOUT;
+		xch->xch_fpkt->pkt_state = FC_PKT_PORT_OFFLINE;
+		xch->xch_fpkt->pkt_reason = FC_REASON_OFFLINE;
+		list_insert_tail(&xch->xch_ss->ss_comp_xch_list, xch);
+	}
+
+	return (MH_WALK_CONTINUE);
+}
+
+/*
+ * fcoei_init_ifm
+ *	initialize fcoei_frame
+ *
+ * Input:
+ *	frm = the frame that ifm need link to
+ *	xch = the exchange that ifm need link to
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	For solicited frames, it's called after FC frame header initialization
+ *	For unsolicited frames, it's called just after the frame enters fcoei
+ */
+void
+fcoei_init_ifm(fcoe_frame_t *frm, fcoei_exchange_t *xch)
+{
+	FRM2IFM(frm)->ifm_frm = frm;
+	FRM2IFM(frm)->ifm_xch = xch;
+	FRM2IFM(frm)->ifm_rctl = FRM_R_CTL(frm);
+}
+
+/*
+ * fcoei_trigger_fp_attach
+ *	Trigger fp_attach for this fcoei port
+ *
+ * Input:
+ *	arg = the soft state that fp will attach
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	N/A
+ */
+static void
+fcoei_trigger_fp_attach(void * arg)
+{
+	fcoei_soft_state_t	*ss    = (fcoei_soft_state_t *)arg;
+	dev_info_t		*child = NULL;
+	int			 rval  = NDI_FAILURE;
+
+	ndi_devi_alloc_sleep(ss->ss_dip, "fp", DEVI_PSEUDO_NODEID, &child);
+	if (child == NULL) {
+		FCOEI_LOG(__FUNCTION__, "can't alloc dev_info");
+		return;
+	}
+
+	/*
+	 * fp/fctl need this property
+	 */
+	if (ddi_prop_update_string(DDI_DEV_T_NONE, child,
+	    "bus-addr", "0,0") != DDI_PROP_SUCCESS) {
+		FCOEI_LOG(__FUNCTION__, "update bus-addr failed");
+		(void) ndi_devi_free(child);
+		return;
+	}
+
+	/*
+	 * If it's physical HBA, fp.conf will register the property.
+	 * fcoei is one software HBA, so we need register it manually
+	 */
+	if (ddi_prop_update_int(DDI_DEV_T_NONE, child,
+	    "port", 0) != DDI_PROP_SUCCESS) {
+		FCOEI_LOG(__FUNCTION__, "update port failed");
+		(void) ndi_devi_free(child);
+		return;
+	}
+
+	/*
+	 * It will call fp_attach eventually
+	 */
+	rval = ndi_devi_online(child, NDI_ONLINE_ATTACH);
+	ss->ss_flags &= ~SS_FLAG_TRIGGER_FP_ATTACH;
+	if (rval != NDI_SUCCESS) {
+		FCOEI_LOG(__FUNCTION__, "devi_online: %d", rval);
+	} else {
+		FCOEI_LOG(__FUNCTION__, "triggered successfully");
+	}
+}
+
+/*
+ * fcoei_abts_exchange
+ *	Send ABTS to abort solicited exchange
+ *
+ * Input:
+ *	xch = the exchange that will be aborted
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	ABTS frame uses the same oxid as the exchange
+ */
+static void
+fcoei_abts_exchange(fcoei_exchange_t *xch)
+{
+	fc_packet_t	*fpkt = xch->xch_fpkt;
+	fcoe_frame_t	*frm  = NULL;
+
+	/*
+	 * BLS_ABTS doesn't contain any other payload except FCFH
+	 */
+	frm = xch->xch_ss->ss_eport->eport_alloc_frame(xch->xch_ss->ss_eport,
+	    FCFH_SIZE, NULL);
+	if (frm == NULL) {
+		FCOEI_LOG(__FUNCTION__, "can't alloc frame: %p", xch);
+		return;
+	}
+
+	FFM_R_CTL(0x81, frm);
+	FFM_D_ID(fpkt->pkt_cmd_fhdr.d_id, frm);
+	FFM_S_ID(fpkt->pkt_cmd_fhdr.s_id, frm);
+	FFM_F_CTL(0x090000, frm);
+	FFM_SEQ_ID(0x01, frm);
+	FFM_OXID(xch->xch_oxid, frm);
+	FFM_RXID(xch->xch_rxid, frm);
+	fcoei_init_ifm(frm, xch);
+	xch->xch_ss->ss_eport->eport_tx_frame(frm);
+}
+
+/*
+ * fcoei_complete_xch
+ *	Complete the exchange
+ *
+ * Input:
+ *	xch = the exchange that will be completed
+ *	frm = newly-allocated frame that has not been submitted
+ *	pkt_state = LV fpkt state
+ *	pkt_reason = LV fpkt reason
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	N/A
+ */
+void
+fcoei_complete_xch(fcoei_exchange_t *xch, fcoe_frame_t *frm,
+    uint8_t pkt_state, uint8_t pkt_reason)
+{
+	mod_hash_val_t val;
+
+	if (pkt_state != FC_PKT_SUCCESS) {
+		FCOEI_LOG(__FUNCTION__, "FHDR: %x/%x/%x, %x/%x/%x",
+		    xch->xch_fpkt->pkt_cmd_fhdr.r_ctl,
+		    xch->xch_fpkt->pkt_cmd_fhdr.f_ctl,
+		    xch->xch_fpkt->pkt_cmd_fhdr.type,
+		    xch->xch_fpkt->pkt_resp_fhdr.r_ctl,
+		    xch->xch_fpkt->pkt_resp_fhdr.f_ctl,
+		    xch->xch_fpkt->pkt_resp_fhdr.type);
+		FCOEI_LOG(__FUNCTION__, "%p/%p/%x/%x",
+		    xch, frm, pkt_state, pkt_reason);
+	}
+
+	if (frm != NULL) {
+		/*
+		 * It's newly-allocated frame , which we haven't sent out
+		 */
+		xch->xch_ss->ss_eport->eport_free_netb(frm->frm_netb);
+		xch->xch_ss->ss_eport->eport_release_frame(frm);
+		FCOEI_LOG(__FUNCTION__, "xch: %p, not submitted", xch);
+	}
+
+	/*
+	 * If xch is in hash table, we need remove it
+	 */
+	if (xch->xch_flags & XCH_FLAG_IN_SOL_HASH) {
+		mod_hash_remove(xch->xch_ss->ss_sol_oxid_hash,
+		    FMHK(xch->xch_oxid), &val);
+		ASSERT((fcoei_exchange_t *)val == xch);
+		xch->xch_flags &= ~XCH_FLAG_IN_SOL_HASH;
+	} else if (xch->xch_flags & XCH_FLAG_IN_UNSOL_HASH) {
+		mod_hash_remove(xch->xch_ss->ss_unsol_rxid_hash,
+		    FMHK(xch->xch_rxid), &val);
+		ASSERT((fcoei_exchange_t *)val == xch);
+		xch->xch_flags &= ~XCH_FLAG_IN_UNSOL_HASH;
+	} else {
+		FCOEI_LOG(__FUNCTION__, "xch not in any hash: %p", xch);
+	}
+
+	xch->xch_fpkt->pkt_state = pkt_state;
+	xch->xch_fpkt->pkt_reason = pkt_reason;
+	if (xch->xch_fpkt->pkt_tran_flags & FC_TRAN_NO_INTR) {
+		FCOEI_LOG(__FUNCTION__, "polled xch is done: %p", xch);
+		sema_v(&xch->xch_sema);
+	} else {
+		xch->xch_fpkt->pkt_comp(xch->xch_fpkt);
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/uts/common/io/fibre-channel/fca/fcoei/fcoei.conf	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,24 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/uts/common/io/fibre-channel/fca/fcoei/fcoei.h	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,371 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+#ifndef	_FCOEI_H
+#define	_FCOEI_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#ifdef	_KERNEL
+
+/*
+ * FCOEI logging
+ */
+extern int fcoei_use_ext_log;
+extern void *fcoei_state;
+
+#define	FCOEI_EXT_LOG(log_ident, ...)				\
+	{							\
+		if (fcoei_use_ext_log) {			\
+			fcoe_trace(log_ident, __VA_ARGS__);	\
+		}						\
+	}
+
+#define	FCOEI_LOG(log_ident, ...)		\
+	fcoe_trace(log_ident, __VA_ARGS__)
+
+/*
+ * IOCTL supporting stuff
+ */
+#define	FCOEI_IOCTL_FLAG_MASK		0xFF
+#define	FCOEI_IOCTL_FLAG_IDLE		0x00
+#define	FCOEI_IOCTL_FLAG_OPEN		0x01
+#define	FCOEI_IOCTL_FLAG_EXCL		0x02
+
+/*
+ * define common constants
+ */
+#define	FCOEI_MAX_OPEN_XCHS	2048
+#define	FCOEI_SOL_HASH_SIZE	2048
+#define	FCOEI_UNSOL_HASH_SIZE	128
+#define	FCOEI_VERSION		"20090729-1.00"
+#define	FCOEI_NAME_VERSION	"SunFC FCoEI v" FCOEI_VERSION
+
+/*
+ * define RNID Management Info
+ */
+#define	FCOEI_RNID_HBA	0x7
+#define	FCOEI_RNID_IPV4	0x1
+#define	FCOEI_RNID_IPV6	0x2
+
+typedef enum event_type {
+	AE_EVENT_NONE = 0,
+	AE_EVENT_EXCHANGE,
+	AE_EVENT_SOL_FRAME,
+	AE_EVENT_UNSOL_FRAME,
+	AE_EVENT_PORT,
+	AE_EVENT_ABORT,
+	AE_EVENT_RESET,
+} event_type_e;
+
+typedef struct fcoei_event {
+	list_node_t	 ae_node;
+	event_type_e	 ae_type;
+
+	/*
+	 * event specific
+	 */
+	uint64_t	 ae_specific;
+
+	/*
+	 * event related object
+	 */
+	void		*ae_obj;
+} fcoei_event_t;
+
+typedef struct fcoei_soft_state {
+	dev_info_t		*ss_dip;
+	uint32_t		 ss_flags;
+	uint32_t		 ss_fcp_data_payload_size;
+	list_t			 ss_comp_xch_list;
+
+	/*
+	 * common data structure (fc_local_port_t) between leadville and fcoei
+	 */
+	void			*ss_port;
+
+	/*
+	 * common data structure between fcoei and fcoe module
+	 */
+	fcoe_port_t		*ss_eport;
+
+	mod_hash_t		*ss_sol_oxid_hash;
+	mod_hash_t		*ss_unsol_rxid_hash;
+	uint16_t		 ss_next_sol_oxid;
+	uint16_t		 ss_next_unsol_rxid;
+
+	/*
+	 * We will use ss_taskq to dispatch watchdog and other tasks
+	 */
+	ddi_taskq_t		*ss_taskq;
+
+	kcondvar_t		 ss_watchdog_cv;
+	kmutex_t		 ss_watchdog_mutex;
+
+	/*
+	 * current port state, speed. see fctl.h
+	 */
+	uint16_t		 ss_link_state;
+	uint16_t		 ss_link_speed;
+
+	/*
+	 * # of unprocessed port/link change
+	 */
+	uint32_t		 ss_port_event_counter;
+	list_t			 ss_event_list;
+
+	/*
+	 * solicited and unsolicited exchanges timing checking
+	 */
+	uint32_t		 ss_sol_cnt1;
+	uint32_t		 ss_sol_cnt2;
+	uint32_t		*ss_sol_cnt;
+	uint32_t		 ss_unsol_cnt1;
+	uint32_t		 ss_unsol_cnt2;
+	uint32_t		*ss_unsol_cnt;
+
+	/*
+	 * ioctl related stuff
+	 */
+	uint32_t		 ss_ioctl_flags;
+	kmutex_t		 ss_ioctl_mutex;
+
+	/*
+	 * fp-defined routines that fcoei will call
+	 */
+	fc_fca_bind_info_t	 ss_bind_info;
+
+	/*
+	 * fcoei-defined plogi response that fp will use
+	 */
+	la_els_logi_t		 ss_els_logi;
+
+	/*
+	 * fcoei-defined routines that fp will call
+	 */
+	fc_fca_tran_t		 ss_fca_tran;
+
+	/*
+	 * Direct p2p information, and ss's fcid will be stored here
+	 */
+	fc_fca_p2p_info_t	ss_p2p_info;
+
+	/*
+	 * RNID Management Information
+	 */
+	fc_rnid_t			ss_rnid;
+} fcoei_soft_state_t;
+
+#define	SS_FLAG_LV_NONE			0x0000
+#define	SS_FLAG_LV_BOUND		0x0001
+#define	SS_FLAG_PORT_DISABLED		0x0002
+#define	SS_FLAG_TERMINATE_WATCHDOG	0x0004
+#define	SS_FLAG_WATCHDOG_RUNNING	0x0008
+#define	SS_FLAG_WATCHDOG_IDLE		0x0010
+#define	SS_FLAG_TRIGGER_FP_ATTACH	0x0020
+#define	SS_FLAG_FLOGI_FAILED		0x0040
+
+/*
+ * fcoei_frame - corresponding data structure to fcoe_frame/fc_frame
+ */
+typedef struct fcoei_frame {
+	fcoei_event_t		 ifm_ae;
+	fcoe_frame_t		*ifm_frm;
+	uint32_t		 ifm_flags;
+	struct fcoei_exchange	*ifm_xch;
+
+	/*
+	 * will be used after the relevant frame mblk was released by ETH layer
+	 */
+	uint8_t			 ifm_rctl;
+} fcoei_frame_t;
+
+#define	IFM_FLAG_NONE		0x0000
+#define	IFM_FLAG_FREE_NETB	0x0001
+
+/*
+ * fcoei_exchange - corresponding data structure to leadville fc_packet
+ */
+typedef struct fcoei_exchange {
+	list_node_t		 xch_comp_node;
+	fcoei_event_t		 xch_ae;
+	uint32_t		 xch_flags;
+	fcoei_soft_state_t	*xch_ss;
+	clock_t			 xch_start_tick;
+	clock_t			 xch_end_tick;
+	int			 xch_resid;
+	ksema_t			 xch_sema;
+
+	/*
+	 * current cnt for timing check, when the exchange is created
+	 */
+	uint32_t		*xch_cnt;
+
+	/*
+	 * leadville fc_packet will not maintain oxid/rxid,
+	 * so fcoei exchange  need do it
+	 */
+	uint16_t		 xch_oxid;
+	uint16_t		 xch_rxid;
+
+	/*
+	 * to link leadville's stuff
+	 */
+	fc_packet_t		*xch_fpkt;
+	fc_unsol_buf_t		*xch_ub;
+} fcoei_exchange_t;
+
+#define	XCH_FLAG_NONE		0x00000000
+#define	XCH_FLAG_TMOUT		0x00000001
+#define	XCH_FLAG_ABORT		0x00000002
+#define	XCH_FLAG_IN_SOL_HASH	0x00000004
+#define	XCH_FLAG_IN_UNSOL_HASH	0x00000008
+
+typedef struct fcoei_walk_arg
+{
+	fcoei_exchange_t	*wa_xch;
+	uint16_t		 wa_oxid;
+} fcoei_walk_arg_t;
+
+/*
+ * Define conversion and calculation macros
+ */
+#define	FRM2IFM(x_frm)	((fcoei_frame_t *)(x_frm)->frm_client_private)
+#define	FRM2SS(x_frm)							\
+	((fcoei_soft_state_t *)(x_frm)->frm_eport->eport_client_private)
+
+#define	PORT2SS(x_port)	((fcoei_soft_state_t *)(x_port)->port_fca_private)
+#define	EPORT2SS(x_eport)					\
+	((fcoei_soft_state_t *)(x_eport)->eport_client_private)
+
+#define	FPKT2XCH(x_fpkt)	((fcoei_exchange_t *)x_fpkt->pkt_fca_private)
+#define	FRM2FPKT(x_fpkt)	(FRM2IFM(frm)->ifm_xch->xch_fpkt)
+
+#define	HANDLE2SS(x_handle)	((fcoei_soft_state_t *)fca_handle)
+
+#define	FPLD			frm->frm_payload
+
+#define	FCOEI_FRM2FHDR(x_frm, x_fhdr)				\
+	{							\
+		(x_fhdr)->r_ctl = FRM_R_CTL(x_frm);		\
+		(x_fhdr)->d_id = FRM_D_ID(x_frm);		\
+		(x_fhdr)->s_id = FRM_S_ID(x_frm);		\
+		(x_fhdr)->type = FRM_TYPE(x_frm);		\
+		(x_fhdr)->f_ctl = FRM_F_CTL(x_frm);		\
+		(x_fhdr)->seq_id = FRM_SEQ_ID(x_frm);		\
+		(x_fhdr)->df_ctl = FRM_DF_CTL(x_frm);		\
+		(x_fhdr)->seq_cnt = FRM_SEQ_CNT(x_frm);		\
+		(x_fhdr)->ox_id = FRM_OXID(x_frm);		\
+		(x_fhdr)->rx_id = FRM_RXID(x_frm);		\
+		(x_fhdr)->ro = FRM_PARAM(x_frm);		\
+	}
+
+#define	FCOEI_PARTIAL_FHDR2FRM(x_fhdr, x_frm)		\
+	{						\
+		FFM_R_CTL((x_fhdr)->r_ctl, x_frm);	\
+		FFM_D_ID((x_fhdr)->d_id, x_frm);	\
+		FFM_S_ID((x_fhdr)->s_id, x_frm);	\
+		FFM_TYPE((x_fhdr)->type, x_frm);	\
+		FFM_F_CTL((x_fhdr)->f_ctl, x_frm);	\
+	}
+
+#define	PRT_FRM_HDR(x_p, x_f)						\
+	{								\
+		FCOEI_LOG(x_p, "rctl/%x, fctl/%x, type/%x, oxid/%x",	\
+			FCOE_B2V_1((x_f)->frm_hdr->hdr_r_ctl),		\
+			FCOE_B2V_3((x_f)->frm_hdr->hdr_f_ctl),		\
+			FCOE_B2V_1((x_f)->frm_hdr->hdr_type),		\
+			FCOE_B2V_2((x_f)->frm_hdr->hdr_oxid));		\
+	}
+
+#define	FCOEI_INIT_SOL_ID_HASH(xch, xch_tmp)				\
+	{								\
+		do {							\
+			if (++xch->xch_ss->ss_next_sol_oxid == 0xFFFF) { \
+				++xch->xch_ss->ss_next_sol_oxid;	\
+			}						\
+		} while (mod_hash_find(xch->xch_ss->ss_sol_oxid_hash,	\
+		    (mod_hash_key_t)(intptr_t)xch->xch_ss->ss_next_sol_oxid, \
+		    (mod_hash_val_t)&xch_tmp) == 0);	\
+		xch->xch_oxid = xch->xch_ss->ss_next_sol_oxid;		\
+		xch->xch_rxid = 0xFFFF;					\
+		(void) mod_hash_insert(xch->xch_ss->ss_sol_oxid_hash,	\
+		    FMHK(xch->xch_oxid), (mod_hash_val_t)xch); \
+		xch->xch_flags |= XCH_FLAG_IN_SOL_HASH;			\
+	}
+
+#define	FCOEI_SET_UNSOL_FRM_RXID(frm, xch_tmp)				\
+	{								\
+		do {							\
+			if (++FRM2SS(frm)->ss_next_unsol_rxid == 0xFFFF) { \
+				++FRM2SS(frm)->ss_next_unsol_rxid;	\
+			}						\
+		} while (mod_hash_find(FRM2SS(frm)->ss_unsol_rxid_hash,	\
+		    (mod_hash_key_t)(intptr_t)FRM2SS(frm)->ss_next_unsol_rxid, \
+		    (mod_hash_val_t)&xch_tmp) == 0);	\
+		FFM_RXID(FRM2SS(frm)->ss_next_unsol_rxid, frm);	\
+	}
+
+#define	FCOEI_INIT_UNSOL_ID_HASH(xch)					\
+	{								\
+		xch->xch_oxid = fpkt->pkt_cmd_fhdr.ox_id;		\
+		xch->xch_rxid = fpkt->pkt_cmd_fhdr.rx_id;		\
+		(void) mod_hash_insert(xch->xch_ss->ss_unsol_rxid_hash,	\
+		    FMHK(xch->xch_rxid), (mod_hash_val_t)xch); 		\
+		xch->xch_flags |= XCH_FLAG_IN_UNSOL_HASH;		\
+	}
+
+/*
+ * Common functions defined in fcoei.c
+ */
+void fcoei_complete_xch(fcoei_exchange_t *xch, fcoe_frame_t *frm,
+    uint8_t pkt_state, uint8_t pkt_reason);
+void fcoei_init_ifm(fcoe_frame_t *frm, fcoei_exchange_t *xch);
+void fcoei_handle_comp_xch_list(fcoei_soft_state_t *ss);
+
+/*
+ * Common functions defined in fcoei_lv.c
+ */
+void fcoei_init_fcatran_vectors(fc_fca_tran_t *fcatran);
+void fcoei_process_event_exchange(fcoei_event_t *ae);
+void fcoei_process_event_reset(fcoei_event_t *ae);
+
+/*
+ * Common functions defined in fcoei_eth.c
+ */
+void fcoei_init_ect_vectors(fcoe_client_t *ect);
+void fcoei_process_unsol_frame(fcoe_frame_t *frm);
+void fcoei_handle_sol_frame_done(fcoe_frame_t *frm);
+void fcoei_process_event_port(fcoei_event_t *ae);
+void fcoei_port_event(fcoe_port_t *eport, uint32_t event);
+
+#endif /* _KERNEL */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _FCOEI_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/uts/common/io/fibre-channel/fca/fcoei/fcoei_eth.c	Wed Aug 05 17:14:23 2009 -0700
@@ -0,0 +1,1390 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * The following notice accompanied the original version of this file:
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2007 Intel Corporation. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * 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.
+ *   * Neither the name of Intel Corporation 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
+ * OWNER 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.
+ */
+
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * This file defines interface functions between fcoe and fcoei driver.
+ */
+
+#include <sys/conf.h>
+#include <sys/ddi.h>
+#include <sys/stat.h>
+#include <sys/pci.h>
+#include <sys/sunddi.h>
+#include <sys/modctl.h>
+#include <sys/file.h>
+#include <sys/cred.h>
+#include <sys/byteorder.h>
+#include <sys/atomic.h>
+#include <sys/scsi/scsi.h>
+#include <sys/mac_client.h>
+#include <sys/modhash.h>
+
+/*
+ * LEADVILLE header files
+ */
+#include <sys/fibre-channel/fc.h>
+#include <sys/fibre-channel/impl/fc_fcaif.h>
+
+/*
+ * COMSTAR header files
+ */
+#include <sys/stmf_defines.h>
+
+/*
+ * FCOE header files
+ */
+#include <sys/fcoe/fcoe_common.h>
+
+/*
+ * Driver's own header files
+ */
+#include <fcoei.h>
+
+/*
+ * Forward declaration of internal functions
+ */
+static void fcoei_process_unsol_els_req(fcoe_frame_t *frm);
+static void fcoei_process_sol_els_rsp(fcoe_frame_t *frm);
+static void fcoei_process_unsol_abts_req(fcoe_frame_t *frame);
+static void fcoei_process_sol_abts_acc(fcoe_frame_t *frame);
+static void fcoei_process_sol_abts_rjt(fcoe_frame_t *frame);
+static void fcoei_process_sol_ct_rsp(fcoe_frame_t *frame);
+static void fcoei_process_unsol_xfer_rdy(fcoe_frame_t *frame);
+static void fcoei_process_sol_fcp_resp(fcoe_frame_t *frm);
+
+static void fcoei_fill_fcp_resp(uint8_t *src, uint8_t *dest, int size);
+static void fcoei_fill_els_fpkt_resp(fcoe_frame_t *frm, fcoei_exchange_t *xch,
+    int size);
+
+/*
+ * fcoei_rx_frame
+ *	Unsolicited frame is received
+ *
+ * Input:
+ *	frame = unsolicited frame that is received
+ *
+ * Return:
+ *	N/A
+ *
+ * Comment:
+ *	N/A
+ */
+static void
+fcoei_rx_frame(fcoe_frame_t *frm)
+{
+	if (!(FRM2SS(frm)->ss_flags & SS_FLAG_LV_BOUND)) {
+		/*
+		 * Release the frame and netb
+		 */
+		FCOEI_LOG(__FUNCTION__, "not bound now");
+		frm->frm_eport->eport_free_netb(frm->frm_netb);
+		frm->frm_eport->eport_release_frame(frm);
+		return;
+	}
+
+	FRM2IFM(frm)->ifm_ae.ae_type = AE_EVENT_UNSOL_FRAME;
+	FRM2IFM(frm)->ifm_ae.ae_obj = frm;
+
+	mutex_enter(&FRM2SS(frm)->ss_watchdog_mutex);
+	list_insert_tail(&FRM2SS(frm)->ss_event_list, &FRM2IFM(frm)->ifm_ae);
+	if (FRM2SS(frm)->ss_flags & SS_FLAG_WATCHDOG_IDLE) {
+		cv_signal(&FRM2SS(frm)->ss_watchdog_cv);
+	}
+	mutex_exit(&FRM2SS(frm)->ss_watchdog_mutex);
+}
+
+/*
+ * fcoei_release_sol_frame
+ *	Release the solicited frame that has just been sent out
+ *
+ * Input:
+ *	frame = solicited frame that has been sent out
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	After FCOE sends solicited frames out, it will call this to notify
+ *	FCOEI of the completion.
+ */
+static void
+fcoei_release_sol_frame(fcoe_frame_t *frm)
+{
+	/*
+	 * For request-type frames, it's safe to be handled out of
+	 * watchdog, because it needn't update anything
+	 */
+	switch (FRM2IFM(frm)->ifm_rctl) {
+	case R_CTL_SOLICITED_DATA:
+	case R_CTL_COMMAND:
+	case R_CTL_ELS_REQ:
+	case R_CTL_UNSOL_CONTROL:
+	case R_CTL_LS_ABTS:
+		FRM2SS(frm)->ss_eport->eport_release_frame(frm);
+		break;
+
+	default:
+		FRM2IFM(frm)->ifm_ae.ae_type = AE_EVENT_SOL_FRAME;
+		FRM2IFM(frm)->ifm_ae.ae_obj = frm;
+
+		mutex_enter(&FRM2SS(frm)->ss_watchdog_mutex);
+		list_insert_tail(&FRM2SS(frm)->ss_event_list,
+		    &FRM2IFM(frm)->ifm_ae);
+		if (FRM2SS(frm)->ss_flags & SS_FLAG_WATCHDOG_IDLE) {
+			cv_signal(&FRM2SS(frm)->ss_watchdog_cv);
+		}
+		mutex_exit(&FRM2SS(frm)->ss_watchdog_mutex);
+		break;
+	}
+}
+
+/*
+ * fcoei_process_unsol_xfer_rdy
+ *	XFER_RDY is received
+ *
+ * Input:
+ *	frm = XFER_RDY frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	N/A
+ */
+static void
+fcoei_process_unsol_xfer_rdy(fcoe_frame_t *frm)
+{
+	uint16_t		 sol_oxid;
+	fcoei_exchange_t	*xch;
+	int			 rcv_buf_size;
+	int			 offset;
+	int			 left_size;
+	int			 data_size;
+	int			 frm_num;
+	int			 idx;
+	fcoe_frame_t		*nfrm;
+
+	sol_oxid = FRM_OXID(frm);
+	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
+	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
+		return;
+	}
+
+	/*
+	 * rcv_buf_size is the total size of data that should be transferred
+	 * in this sequence.
+	 * offset is based on the exchange not the sequence.
+	 */
+	xch->xch_rxid = FRM_RXID(frm);
+	rcv_buf_size = FCOE_B2V_4(frm->frm_payload + 4);
+	offset = FCOE_B2V_4(frm->frm_payload);
+	ASSERT(xch->xch_resid >= rcv_buf_size);
+
+	/*
+	 * Local variables initialization
+	 */
+	left_size = rcv_buf_size;
+	data_size = FRM2SS(frm)->ss_fcp_data_payload_size;
+	frm_num = (rcv_buf_size + data_size - 1) / data_size;
+
+	for (idx = 0; idx < frm_num - 1; idx++) {
+		/*
+		 * The first (frm_num -1) frames are always full
+		 */
+		nfrm = FRM2SS(frm)->ss_eport->eport_alloc_frame(
+		    FRM2SS(frm)->ss_eport, data_size + FCFH_SIZE, NULL);
+		if (nfrm == NULL) {
+			FCOEI_LOG(__FUNCTION__, "can't alloc frame");
+			return;
+		}
+
+		/*
+		 * Copy the data payload that will  be transferred
+		 */
+		bcopy(offset + (uint8_t *)xch->xch_fpkt->pkt_data,
+		    nfrm->frm_payload, nfrm->frm_payload_size);
+
+		FFM_R_CTL(R_CTL_SOLICITED_DATA, nfrm);
+		FFM_TYPE(FC_TYPE_SCSI_FCP, nfrm);
+		FFM_F_CTL(0x010008, nfrm);
+		FFM_OXID(xch->xch_oxid, nfrm);
+		FFM_RXID(xch->xch_rxid, nfrm);
+		FFM_S_ID(FRM_D_ID(frm), nfrm);
+		FFM_D_ID(FRM_S_ID(frm), nfrm);
+		FFM_SEQ_CNT(idx, nfrm);
+		FFM_PARAM(offset, nfrm);
+		fcoei_init_ifm(nfrm, xch);
+
+		/*
+		 * Submit the frame
+		 */
+		xch->xch_ss->ss_eport->eport_tx_frame(nfrm);
+
+		/*
+		 * Update offset and left_size
+		 */
+		offset += data_size;
+		left_size -= data_size;
+	}
+
+	/*
+	 * Send the last data frame of this sequence
+	 */
+	data_size = left_size;
+	nfrm = xch->xch_ss->ss_eport->eport_alloc_frame(
+	    xch->xch_ss->ss_eport, data_size + FCFH_SIZE, NULL);
+	if (nfrm != NULL) {
+		fcoei_init_ifm(nfrm, xch);
+	} else {
+		ASSERT(0);
+		return;
+	}
+
+	/*
+	 * Copy the data payload that will be transferred
+	 */
+	bcopy(offset + (uint8_t *)xch->xch_fpkt->pkt_data,
+	    nfrm->frm_payload, nfrm->frm_payload_size);
+
+	/*
+	 * Set ifm_rctl for fcoei_handle_sol_frame_done
+	 */
+	FRM2IFM(nfrm)->ifm_rctl = R_CTL_SOLICITED_DATA;
+
+	/*
+	 * FFM
+	 */
+	FFM_R_CTL(R_CTL_SOLICITED_DATA, nfrm);
+	FFM_TYPE(FC_TYPE_SCSI_FCP, nfrm);
+	FFM_F_CTL(0x090008, nfrm);
+	FFM_OXID(xch->xch_oxid, nfrm);
+	FFM_RXID(xch->xch_rxid, nfrm);
+	FFM_S_ID(FRM_D_ID(frm), nfrm);
+	FFM_D_ID(FRM_S_ID(frm), nfrm);
+	FFM_SEQ_CNT(idx, nfrm);
+	FFM_PARAM(offset, nfrm);
+
+	/*
+	 * Submit the frame
+	 */
+	xch->xch_ss->ss_eport->eport_tx_frame(nfrm);
+
+	/*
+	 * Sequence is a transaction, so we need only update
+	 * xch_remained_bytes in the end.
+	 */
+	xch->xch_resid -= rcv_buf_size;
+}
+
+/*
+ * fcoei_process_unsol_els_req
+ *	els req frame is received
+ *
+ * Input:
+ *	frm = ELS request frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	We will not create exchange data structure at this time,
+ *	and we should create unsolicited buffer, which will only
+ *	contain the exchange's request payload.
+ */
+static void
+fcoei_process_unsol_els_req(fcoe_frame_t *frm)
+{
+	fc_unsol_buf_t		*ub;
+	fc_rscn_t		*rscn;
+	uint32_t		 offset;
+	fcoei_exchange_t	*xch_tmp;
+
+	/*
+	 * Get the unsol rxid first
+	 */
+	FCOEI_SET_UNSOL_FRM_RXID(frm, xch_tmp);
+
+	/*
+	 * Do proper ub initialization
+	 */
+	ub = (fc_unsol_buf_t *)kmem_zalloc(sizeof (fc_unsol_buf_t), KM_SLEEP);
+	ub->ub_class = FC_TRAN_CLASS3;
+	ub->ub_bufsize = frm->frm_payload_size;
+	ub->ub_buffer = kmem_alloc(frm->frm_payload_size, KM_SLEEP);
+	ub->ub_port_handle = FRM2SS(frm);
+	ub->ub_token = (uint64_t)(long)ub;
+
+	/*
+	 * header conversion
+	 * Caution: ub_buffer is big endian, but ub_frame should be host-format
+	 * RSCN is one exception.
+	 */
+	FCOEI_FRM2FHDR(frm, &ub->ub_frame);
+
+	/*
+	 * If it's FLOGI, and our FLOGI failed last time,
+	 * then we post online event
+	 */
+	if ((FRM2SS(frm)->ss_flags & SS_FLAG_FLOGI_FAILED) &&
+	    (frm->frm_payload[0] == LA_ELS_FLOGI)) {
+		frm->frm_eport->eport_flags |=
+		    EPORT_FLAG_IS_DIRECT_P2P;
+		FRM2SS(frm)->ss_bind_info.port_statec_cb(FRM2SS(frm)->ss_port,
+		    FC_STATE_ONLINE);
+	}
+
+	switch (frm->frm_payload[0]) {
+	case LA_ELS_RSCN:
+		/*
+		 * Only RSCN need byte swapping
+		 */
+		rscn = (fc_rscn_t *)(void *)ub->ub_buffer;
+		rscn->rscn_code = frm->frm_payload[0];
+		rscn->rscn_len = frm->frm_payload[1];
+		rscn->rscn_payload_len =
+		    FCOE_B2V_2(frm->frm_payload + 2);
+
+		offset = 4;
+		for (int i = 0; i < rscn->rscn_payload_len - 4; i += 4) {
+			*(uint32_t *)((intptr_t)(uint8_t *)ub->ub_buffer +
+			    offset) = FCOE_B2V_4(frm->frm_payload + offset);
+			offset += 4;
+		}
+		break;
+
+	default:
+		bcopy(frm->frm_payload, ub->ub_buffer, frm->frm_payload_size);
+		break;
+	}
+
+	/*
+	 * Pass this unsol ELS up to Leadville
+	 */
+	FRM2SS(frm)->ss_bind_info.port_unsol_cb(FRM2SS(frm)->ss_port, ub, 0);
+}
+
+/*
+ * fcoei_search_abort_xch
+ *	Find the exchange that should be aborted
+ *
+ * Input:
+ *	key = oxid of the exchange
+ *	val = the exchange
+ *	arg = the soft state
+ *
+ * Returns:
+ *	MH_WALK_TERMINATE = found it, terminate the walk
+ *	MH_WALK_CONTINUE = not found, continue the walk
+ *
+ * Comments:
+ *	N/A
+ */
+static uint32_t
+fcoei_search_abort_xch(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
+{
+	fcoei_walk_arg_t	*wa = (fcoei_walk_arg_t *)arg;
+	fcoei_exchange_t	*xch = (fcoei_exchange_t *)val;
+
+	if (xch->xch_oxid == wa->wa_oxid) {
+		wa->wa_xch = xch;
+		ASSERT(xch->xch_oxid == CMHK(key));
+		return (MH_WALK_TERMINATE);
+	}
+
+	return (MH_WALK_CONTINUE);
+}
+
+/*
+ * fcoei_process_unsol_abts_req
+ *	ABTS request is received
+ *
+ * Input:
+ *	frm = ABTS request frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	The remote side wants to abort one unsolicited exchange.
+ */
+static void
+fcoei_process_unsol_abts_req(fcoe_frame_t *frm)
+{
+	fcoei_exchange_t	*xch = NULL;
+	fcoe_frame_t		*nfrm;
+	int			 payload_size;
+	fcoei_walk_arg_t	 walk_arg;
+
+	/*
+	 * According to spec, the responder could want to ABTS xch too
+	 */
+	if (FRM_SENDER_IS_XCH_RESPONDER(frm)) {
+		uint16_t sol_oxid = FRM_OXID(frm);
+		(void) mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
+		    FMHK(sol_oxid), (mod_hash_val_t *)&xch);
+	} else {
+		/*
+		 * it's a unsolicited exchange, and we need find it out from
+		 * unsolicited hash table. But at this time, RXID in frame could
+		 * still be 0xFFFF in most cases, so we need do exaustive search
+		 */
+		walk_arg.wa_xch = NULL;
+		walk_arg.wa_oxid = FRM_OXID(frm);
+		mod_hash_walk(FRM2SS(frm)->ss_unsol_rxid_hash,
+		    fcoei_search_abort_xch, &walk_arg);
+		xch = walk_arg.wa_xch;
+	}
+
+	if (xch == NULL) {
+		payload_size = 4;
+		nfrm = FRM2SS(frm)->ss_eport->eport_alloc_frame(
+		    FRM2SS(frm)->ss_eport,
+		    payload_size + FCFH_SIZE, NULL);
+		if (nfrm == NULL) {
+			FCOEI_LOG(__FUNCTION__, "can't alloc frame");
+			return;
+		}
+
+		bzero(nfrm->frm_payload, nfrm->frm_payload_size);
+		nfrm->frm_payload[1] = 0x05;
+		nfrm->frm_payload[3] = 0xAA;
+		FFM_R_CTL(R_CTL_LS_BA_RJT, nfrm);
+		fcoei_init_ifm(nfrm, xch);
+	} else {
+		/*
+		 * We should complete the exchange with frm as NULL,
+		 * and we don't care its success or failure
+		 */
+		fcoei_complete_xch(xch, NULL, FC_PKT_FAILURE, FC_REASON_ABTX);
+
+		/*
+		 * Construct ABTS ACC frame
+		 */
+		payload_size = 12;
+		nfrm = FRM2SS(frm)->ss_eport->eport_alloc_frame(
+		    FRM2SS(frm)->ss_eport, payload_size + FCFH_SIZE, NULL);
+		if (nfrm == NULL) {
+			FCOEI_LOG(__FUNCTION__, "can't alloc frame");
+			return;
+		}
+
+		bzero(nfrm->frm_payload, nfrm->frm_payload_size);
+		nfrm->frm_payload[4] = 0xFF & (xch->xch_oxid >> 8);
+		nfrm->frm_payload[5] = 0xFF & (xch->xch_oxid);
+		nfrm->frm_payload[6] = 0xFF & (xch->xch_rxid >> 8);
+		nfrm->frm_payload[7] = 0xFF & (xch->xch_rxid);
+		nfrm->frm_payload[10] = 0xFF;
+		nfrm->frm_payload[11] = 0xFF;
+
+		FFM_R_CTL(R_CTL_LS_BA_ACC, nfrm);
+		fcoei_init_ifm(nfrm, xch);
+	}
+
+	FFM_D_ID(FRM_S_ID(frm), nfrm);
+	FFM_S_ID(FRM_D_ID(frm), nfrm);
+	FFM_TYPE(FRM_TYPE(frm), nfrm);
+	FFM_F_CTL(FRM_F_CTL(frm), nfrm);
+	FFM_OXID(FRM_OXID(frm), nfrm);
+	FFM_RXID(FRM_RXID(frm), nfrm);
+	FRM2SS(frm)->ss_eport->eport_tx_frame(nfrm);
+}
+
+/*
+ * fcoei_process_sol_fcp_resp
+ *	FCP response is received
+ *
+ * Input:
+ *	frm = FCP response frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	N/A
+ */
+static void
+fcoei_process_sol_fcp_resp(fcoe_frame_t *frm)
+{
+	uint16_t		 sol_oxid;
+	uint32_t		 actual_size;
+	fcoei_exchange_t	*xch  = NULL;
+	fc_packet_t		*fpkt = NULL;
+	mod_hash_val_t		 val;
+	uint32_t		 i_fcp_status;
+
+	/*
+	 * Firstly, we search the related exchange
+	 */
+	sol_oxid = FRM_OXID(frm);
+	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
+	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
+		PRT_FRM_HDR(__FUNCTION__, frm);
+		FCOEI_LOG(__FUNCTION__, "can't find the corresponding xch: "
+		    "oxid/%x %lu - %lu", sol_oxid,
+		    CURRENT_CLOCK, frm->frm_clock);
+		return;
+	} else {
+		fpkt = xch->xch_fpkt;
+	}
+
+	/*
+	 * Decide the actual response length
+	 */
+	actual_size = fpkt->pkt_rsplen;
+	if (actual_size > frm->frm_payload_size) {
+		actual_size = frm->frm_payload_size;
+	}
+
+	/*
+	 * Update the exchange and hash table
+	 */
+	mod_hash_remove(FRM2SS(frm)->ss_sol_oxid_hash,
+	    FMHK(xch->xch_oxid), &val);
+	ASSERT((fcoei_exchange_t *)val == xch);
+	xch->xch_flags &= ~XCH_FLAG_IN_SOL_HASH;
+
+	/*
+	 * Upate fpkt related elements
+	 */
+	FCOEI_FRM2FHDR(frm, &fpkt->pkt_resp_fhdr);
+
+	/*
+	 * we should set pkt_reason and pkt_state carefully
+	 */
+	fpkt->pkt_state = FC_PKT_SUCCESS;
+	fpkt->pkt_reason = 0;
+
+	/*
+	 * First we zero the first 12 byte of dest
+	 */
+	bzero(xch->xch_fpkt->pkt_resp, 12);
+	i_fcp_status = BE_IN32(frm->frm_payload + 8);
+	if (i_fcp_status != 0) {
+		fcoei_fill_fcp_resp(frm->frm_payload,
+		    (uint8_t *)xch->xch_fpkt->pkt_resp, actual_size);
+	}
+
+	/*
+	 * Update pkt_resp_resid
+	 */
+	fpkt->pkt_data_resid = xch->xch_resid;
+	if ((xch->xch_resid != 0) && ((xch->xch_resid % 0x200) == 0) &&
+	    ((xch->xch_fpkt->pkt_datalen % 0x200) == 0) &&
+	    (i_fcp_status == 0)) {
+		FCOEI_LOG(__FUNCTION__, "frame lost no pause ? %x/%x",
+		    xch->xch_resid, xch->xch_fpkt->pkt_datalen);
+		fpkt->pkt_state = FC_PKT_LOCAL_RJT;
+		fpkt->pkt_reason = FC_REASON_UNDERRUN;
+	}
+
+	/*
+	 * Notify LV it's over
+	 */
+	if (fpkt->pkt_tran_flags & FC_TRAN_NO_INTR) {
+		FCOEI_LOG(__FUNCTION__, "BEFORE WAKEUP: %p-%p", fpkt, xch);
+		sema_v(&xch->xch_sema);
+		FCOEI_LOG(__FUNCTION__, "AFTERE WAKEUP: %p-%p", fpkt, xch);
+	} else {
+		xch->xch_fpkt->pkt_comp(xch->xch_fpkt);
+	}
+}
+
+/*
+ * fcoei_process_sol_els_rsp
+ *	ELS response is received
+ *
+ * Input:
+ *	frm = ELS response frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	N/A
+ */
+static void
+fcoei_process_sol_els_rsp(fcoe_frame_t *frm)
+{
+	uint16_t		 sol_oxid    = 0;
+	uint32_t		 actual_size = 0;
+	fcoei_exchange_t	*xch;
+	fc_packet_t		*fpkt;
+
+	/*
+	 * Look for the related exchange
+	 */
+	xch = NULL;
+	fpkt = NULL;
+	sol_oxid = FRM_OXID(frm);
+	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
+	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
+		PRT_FRM_HDR(__FUNCTION__, frm);
+		FCOEI_LOG(__FUNCTION__, "can't find the "
+		    "corresponding xch: oxid/%x", sol_oxid);
+		return;
+	}
+
+	xch->xch_rxid = FRM_RXID(frm);
+	fpkt = xch->xch_fpkt;
+
+	/*
+	 * Decide the actual response length
+	 */
+	actual_size = frm->frm_payload_size;
+	if (actual_size > fpkt->pkt_rsplen) {
+		FCOEI_LOG(__FUNCTION__, "pkt_rsplen is smaller"
+		    "0x(%x - %x)", actual_size, fpkt->pkt_rsplen);
+		actual_size = fpkt->pkt_rsplen;
+	}
+
+	/*
+	 * Upate fpkt related elements
+	 */
+	FCOEI_FRM2FHDR(frm, &fpkt->pkt_resp_fhdr);
+	fcoei_fill_els_fpkt_resp(frm, xch, actual_size);
+
+	/*
+	 * we should set pkt_reason and pkt_state carefully now
+	 * Need to analyze pkt_reason according to the response.
+	 * Leave it untouched now.
+	 */
+	if (((ls_code_t *)(void *)xch->xch_fpkt->pkt_resp)->ls_code ==
+	    LA_ELS_RJT) {
+		fcoei_complete_xch(xch, NULL, FC_PKT_FABRIC_RJT,
+		    FC_REASON_INVALID_PARAM);
+	} else {
+		fcoei_complete_xch(xch, NULL, FC_PKT_SUCCESS, 0);
+	}
+}
+
+/*
+ * fcoei_process_sol_ct_rsp
+ *	CT response is received
+ *
+ * Input:
+ *	frm = CT response frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	N/A
+ */
+static void
+fcoei_process_sol_ct_rsp(fcoe_frame_t *frm)
+{
+	uint16_t		 sol_oxid    = 0;
+	uint32_t		 actual_size = 0;
+	fcoei_exchange_t	*xch;
+	fc_packet_t		*fpkt;
+
+	/*
+	 * Look for the related exchange
+	 */
+	xch = NULL;
+	fpkt = NULL;
+	sol_oxid = FRM_OXID(frm);
+	if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
+	    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
+		FCOEI_LOG(__FUNCTION__, "can't find the "
+		    "corresponding xch: oxid/%x", sol_oxid);
+		return;
+	}
+
+	xch->xch_rxid = FRM_RXID(frm);
+	fpkt = xch->xch_fpkt;
+
+	/*
+	 * Decide the actual response length
+	 */
+	actual_size = fpkt->pkt_rsplen;
+	if (actual_size > frm->frm_payload_size) {
+		FCOEI_LOG(__FUNCTION__, "payload is smaller"
+		    "0x(%x - %x)", actual_size, frm->frm_payload_size);
+		actual_size = frm->frm_payload_size;
+	}
+
+	/*
+	 * Update fpkt related elements
+	 * Caution: we needn't do byte swapping for CT response
+	 */
+	FCOEI_FRM2FHDR(frm, &fpkt->pkt_resp_fhdr);
+	bcopy(FPLD, (uint8_t *)xch->xch_fpkt->pkt_resp, actual_size);
+
+	/*
+	 * Complete it with frm as NULL
+	 */
+	fcoei_complete_xch(xch, NULL, FC_PKT_SUCCESS, 0);
+}
+
+/*
+ * fcoei_process_sol_abts_acc
+ *	ABTS accpet is received
+ *
+ * Input:
+ *	frm = ABTS accept frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	We will always finish the abortion of solicited exchanges,
+ *	so we will not depend on the response from the remote side.
+ *	We just log one message.
+ */
+static void
+fcoei_process_sol_abts_acc(fcoe_frame_t *frm)
+{
+	FCOEI_LOG(__FUNCTION__, "the remote side has agreed to "
+	    "abort the exchange: oxid-%x, rxid-%x",
+	    FCOE_B2V_2(frm->frm_payload + 4),
+	    FCOE_B2V_2(frm->frm_payload + 6));
+}
+
+/*
+ * fcoei_process_sol_abts_rjt
+ *	ABTS reject is received
+ *
+ * Input:
+ *	frm = ABTS reject frame
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	We will alwayas finish the abortion of solicited exchanges,
+ *	so we will not depend on the response from the remote side.
+ *	We just log one message.
+ */
+static void
+fcoei_process_sol_abts_rjt(fcoe_frame_t *frm)
+{
+	FCOEI_LOG(__FUNCTION__, "the remote side rejected "
+	    "our request to abort one exchange.: %p", frm);
+}
+
+/*
+ * fcoei_fill_els_fpkt_resp
+ *	Fill fpkt ELS response in host format according frm payload
+ *
+ * Input:
+ *	src = frm payload in link format
+ *	dest = fpkt ELS response in host format
+ *	size = Maximum conversion size
+ *	els_op = ELS opcode
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	fpkt->pkt_resp must be mapped to one data structure, and it's
+ *	different from the content in the raw frame
+ */
+static void
+fcoei_fill_els_fpkt_resp(fcoe_frame_t *frm, fcoei_exchange_t *xch, int size)
+{
+	uint8_t			*src	   = frm->frm_payload;
+	uint8_t			*dest	   = (uint8_t *)xch->xch_fpkt->pkt_resp;
+	ls_code_t		*els_code  = (ls_code_t *)(void *)dest;
+	la_els_logi_t		*els_logi  = (la_els_logi_t *)(void *)dest;
+	la_els_adisc_t		*els_adisc = (la_els_adisc_t *)(void *)dest;
+	la_els_rls_acc_t	*els_rls;
+	la_els_rnid_acc_t	*els_rnid;
+	struct fcp_prli_acc	*prli_acc;
+	int			 offset;
+
+	els_code->ls_code = FCOE_B2V_1(src);
+	if (els_code->ls_code == LA_ELS_RJT) {
+		FCOEI_LOG(__FUNCTION__, "size :%d", size);
+		return;
+	}
+
+	switch (((ls_code_t *)(void *)xch->xch_fpkt->pkt_cmd)->ls_code) {
+	case LA_ELS_FLOGI:
+		bcopy((char *)frm->frm_hdr - 22,
+		    frm->frm_eport->eport_efh_dst, ETHERADDRL);
+		if (frm->frm_payload[8] & 0x10) {
+			/*
+			 * We are in fabric p2p mode
+			 */
+			uint8_t src_addr[ETHERADDRL];
+			frm->frm_eport->eport_flags &=
+			    ~EPORT_FLAG_IS_DIRECT_P2P;
+			FCOE_SET_DEFAULT_OUI(src_addr);
+			bcopy(frm->frm_hdr->hdr_d_id, src_addr + 3, 3);
+			frm->frm_eport->eport_set_mac_address(
+			    frm->frm_eport, src_addr, 1);
+		} else {
+			/*
+			 * We are in direct p2p mode
+			 */
+			frm->frm_eport->eport_flags |=
+			    EPORT_FLAG_IS_DIRECT_P2P;
+		}
+
+		if (!(FRM2SS(frm)->ss_eport->eport_flags &
+		    EPORT_FLAG_IS_DIRECT_P2P)) {
+			FRM2SS(frm)->ss_p2p_info.fca_d_id = FRM_D_ID(frm);
+		}
+
+		/* FALLTHROUGH */
+
+	case LA_ELS_PLOGI:
+		if (FRM2SS(frm)->ss_eport->eport_flags &
+		    EPORT_FLAG_IS_DIRECT_P2P) {
+			FRM2SS(frm)->ss_p2p_info.fca_d_id = FRM_D_ID(frm);
+			FRM2SS(frm)->ss_p2p_info.d_id = FRM_S_ID(frm);
+		}
+
+		offset = offsetof(la_els_logi_t, common_service);
+		els_logi->common_service.fcph_version = FCOE_B2V_2(src +
+		    offset);
+		offset += 2;
+		els_logi->common_service.btob_credit = FCOE_B2V_2(src +
+		    offset);
+		offset += 2;
+		els_logi->common_service.cmn_features = FCOE_B2V_2(src +
+		    offset);
+		offset += 2;
+		els_logi->common_service.rx_bufsize = FCOE_B2V_2(src +
+		    offset);
+		offset += 2;
+		els_logi->common_service.conc_sequences = FCOE_B2V_2(src +
+		    offset);
+		offset += 2;
+		els_logi->common_service.relative_offset = FCOE_B2V_2(src +
+		    offset);
+		offset += 2;
+		els_logi->common_service.e_d_tov = FCOE_B2V_4(src +
+		    offset);
+
+		/*
+		 * port/node WWN
+		 */
+		offset = offsetof(la_els_logi_t, nport_ww_name);
+		bcopy(src + offset, &els_logi->nport_ww_name, 8);
+		offset = offsetof(la_els_logi_t, node_ww_name);
+		bcopy(src + offset, &els_logi->node_ww_name, 8);
+
+		/*
+		 * class_3
+		 */
+		offset = offsetof(la_els_logi_t, class_3);
+		els_logi->class_3.class_opt = FCOE_B2V_2(src + offset);
+		offset += 2;
+		els_logi->class_3.initiator_ctl = FCOE_B2V_2(src + offset);
+		offset += 2;
+		els_logi->class_3.recipient_ctl = FCOE_B2V_2(src + offset);
+		offset += 2;
+		els_logi->class_3.rcv_size = FCOE_B2V_2(src + offset);
+		offset += 2;
+		els_logi->class_3.conc_sequences = FCOE_B2V_2(src + offset);
+		offset += 2;
+		els_logi->class_3.n_port_e_to_e_credit = FCOE_B2V_2(src +
+		    offset);
+		offset += 2;
+		els_logi->class_3.open_seq_per_xchng = FCOE_B2V_2(src + offset);
+
+		break;
+
+	case LA_ELS_PRLI:
+		/*
+		 * PRLI service parameter response page
+		 *
+		 * fcp_prli_acc doesn't include ls_code, don't use offsetof
+		 */
+		offset = 4;
+		prli_acc = (struct fcp_prli_acc *)(void *)(dest + offset);
+		prli_acc->type = FCOE_B2V_1(src + offset);
+		/*
+		 * Type code extension
+		 */
+		offset += 1;
+		/*
+		 * PRLI response flags
+		 */
+		offset += 1;
+		prli_acc->orig_process_assoc_valid =
+		    (FCOE_B2V_2(src + offset) & BIT_15) ? 1 : 0;
+		prli_acc->resp_process_assoc_valid =
+		    (FCOE_B2V_2(src + offset) & BIT_14) ? 1 : 0;
+		prli_acc->image_pair_established =
+		    (FCOE_B2V_2(src + offset) & BIT_13) ? 1 : 0;
+		prli_acc->accept_response_code =
+		    FCOE_B2V_2(src + offset) & 0x0F00;
+		/*
+		 * process associator
+		 */
+		offset += 2;
+		prli_acc->orig_process_associator = FCOE_B2V_4(src + offset);
+		offset += 4;
+		prli_acc->resp_process_associator = FCOE_B2V_4(src + offset);
+		/*
+		 * FC-4 type
+		 */
+		offset += 4;
+		prli_acc->initiator_fn =
+		    (FCOE_B2V_4(src + offset) & BIT_5) ? 1 : 0;
+		prli_acc->target_fn =
+		    (FCOE_B2V_4(src + offset) & BIT_4) ? 1 : 0;
+		prli_acc->cmd_data_mixed =
+		    (FCOE_B2V_4(src + offset) & BIT_3) ? 1 : 0;
+		prli_acc->data_resp_mixed =
+		    (FCOE_B2V_4(src + offset) & BIT_2) ? 1 : 0;
+		prli_acc->read_xfer_rdy_disabled =
+		    (FCOE_B2V_4(src + offset) & BIT_1) ? 1 : 0;
+		prli_acc->write_xfer_rdy_disabled =
+		    (FCOE_B2V_4(src + offset) & BIT_0) ? 1 : 0;
+
+		break;
+
+	case LA_ELS_LOGO:
+		/*
+		 * could only be LS_ACC, no additional information
+		 */
+		els_code->ls_code = FCOE_B2V_1(src);
+		break;
+
+	case LA_ELS_SCR:
+		/*
+		 * LS_ACC/LS_RJT, no additional information
+		 */
+		els_code->ls_code = FCOE_B2V_1(src);
+		break;
+
+	case LA_ELS_ADISC:
+		offset = 5;
+		els_adisc->hard_addr.hard_addr = FCOE_B2V_3(src + offset);
+		offset = offsetof(la_els_adisc_t, port_wwn);
+		bcopy(src + offset, &els_adisc->port_wwn, 8);
+		offset = offsetof(la_els_adisc_t, node_wwn);
+		bcopy(src + offset, &els_adisc->node_wwn, 8);
+		offset += 9;
+		els_adisc->nport_id.port_id = FCOE_B2V_3(src + offset);
+		break;
+	case LA_ELS_RLS:
+		els_rls = (la_els_rls_acc_t *)(void *)dest;
+		els_rls->ls_code.ls_code = FCOE_B2V_1(src);
+		offset = 4;
+		els_rls->rls_link_params.rls_link_fail =
+		    FCOE_B2V_4(src + offset);
+		offset = 8;
+		els_rls->rls_link_params.rls_sync_loss =
+		    FCOE_B2V_4(src + offset);
+		offset = 12;
+		els_rls->rls_link_params.rls_sig_loss =
+		    FCOE_B2V_4(src + offset);
+		offset = 16;
+		els_rls->rls_link_params.rls_prim_seq_err =
+		    FCOE_B2V_4(src + offset);
+		offset = 20;
+		els_rls->rls_link_params.rls_invalid_word =
+		    FCOE_B2V_4(src + offset);
+		offset = 24;
+		els_rls->rls_link_params.rls_invalid_crc =
+		    FCOE_B2V_4(src + offset);
+		break;
+	case LA_ELS_RNID:
+		els_rnid = (la_els_rnid_acc_t *)(void *)dest;
+		els_rnid->ls_code.ls_code = FCOE_B2V_1(src);
+		offset = 4;
+		bcopy(src + offset, &els_rnid->hdr.data_format, 1);
+		offset = 5;
+		bcopy(src + offset, &els_rnid->hdr.cmn_len, 1);
+		offset = 7;
+		bcopy(src + offset, &els_rnid->hdr.specific_len, 1);
+		offset = 8;
+		bcopy(src + offset, els_rnid->data, FCIO_RNID_MAX_DATA_LEN);
+		break;
+	default:
+		FCOEI_LOG(__FUNCTION__, "unsupported R_CTL");
+		break;
+	}
+}
+
+/*
+ * fcoei_fill_fcp_resp
+ *	Fill fpkt FCP response in host format according to frm payload
+ *
+ * Input:
+ *	src - frm payload in link format
+ *	dest - fpkt FCP response in host format
+ *	size - Maximum conversion size
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	This is called only for SCSI response with non good status
+ */
+static void
+fcoei_fill_fcp_resp(uint8_t *src, uint8_t *dest, int size)
+{
+	fcp_rsp_t	*fcp_rsp_iu = (fcp_rsp_t *)(void *)dest;
+	int		 offset;
+
+	/*
+	 * set fcp_status
+	 */
+	offset = offsetof(fcp_rsp_t, fcp_u);
+	offset += 2;
+	fcp_rsp_iu->fcp_u.fcp_status.resid_under =
+	    (FCOE_B2V_1(src + offset) & BIT_3) ? 1 : 0;
+	fcp_rsp_iu->fcp_u.fcp_status.resid_over =
+	    (FCOE_B2V_1(src + offset) & BIT_2) ? 1 : 0;
+	fcp_rsp_iu->fcp_u.fcp_status.sense_len_set =
+	    (FCOE_B2V_1(src + offset) & BIT_1) ? 1 : 0;
+	fcp_rsp_iu->fcp_u.fcp_status.rsp_len_set =
+	    (FCOE_B2V_1(src + offset) & BIT_0) ? 1 : 0;
+	offset += 1;
+	fcp_rsp_iu->fcp_u.fcp_status.scsi_status = FCOE_B2V_1(src + offset);
+	/*
+	 * fcp_resid/fcp_sense_len/fcp_response_len
+	 */
+	offset = offsetof(fcp_rsp_t, fcp_resid);
+	fcp_rsp_iu->fcp_resid = FCOE_B2V_4(src + offset);
+	offset = offsetof(fcp_rsp_t, fcp_sense_len);
+	fcp_rsp_iu->fcp_sense_len = FCOE_B2V_4(src + offset);
+	offset = offsetof(fcp_rsp_t, fcp_response_len);
+	fcp_rsp_iu->fcp_response_len = FCOE_B2V_4(src + offset);
+	/*
+	 * sense or response
+	 */
+	offset += 4;
+	if (fcp_rsp_iu->fcp_sense_len) {
+		if ((offset + fcp_rsp_iu->fcp_sense_len) > size) {
+			FCOEI_LOG(__FUNCTION__, "buffer too small - sens");
+			return;
+		}
+		bcopy(src + offset, dest + offset, fcp_rsp_iu->fcp_sense_len);
+		offset += fcp_rsp_iu->fcp_sense_len;
+	}
+
+	if (fcp_rsp_iu->fcp_response_len) {
+		if ((offset + fcp_rsp_iu->fcp_response_len) > size) {
+			FCOEI_LOG(__FUNCTION__, "buffer too small - resp");
+			return;
+		}
+		bcopy(src + offset, dest + offset,
+		    fcp_rsp_iu->fcp_response_len);
+	}
+}
+
+void
+fcoei_init_ect_vectors(fcoe_client_t *ect)
+{
+	ect->ect_rx_frame	   = fcoei_rx_frame;
+	ect->ect_port_event	   = fcoei_port_event;
+	ect->ect_release_sol_frame = fcoei_release_sol_frame;
+}
+
+/*
+ * fcoei_process_unsol_frame
+ *	Unsolicited frame is received
+ *
+ * Input:
+ *	frame = unsolicited frame that is received
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	watchdog will call this to process unsolicited frames that we
+ *	just received fcoei_process_xx is used to handle different
+ *	unsolicited frames
+ */
+void
+fcoei_process_unsol_frame(fcoe_frame_t *frm)
+{
+	fcoei_exchange_t	*xch;
+	uint16_t		 sol_oxid;
+
+	switch (FRM_R_CTL(frm)) {
+	case R_CTL_SOLICITED_DATA:
+		/*
+		 * READ data phase frame
+		 * Find the associated exchange
+		 */
+		sol_oxid = FRM_OXID(frm);
+		if (mod_hash_find(FRM2SS(frm)->ss_sol_oxid_hash,
+		    FMHK(sol_oxid), (mod_hash_val_t *)&xch) != 0) {
+			PRT_FRM_HDR(__FUNCTION__, frm);
+			FCOEI_LOG(__FUNCTION__, "associated xch not found: "
+			    "oxid/%x %lu - %lu", sol_oxid,
+			    CURRENT_CLOCK, frm->frm_clock);
+			break;
+		}
+
+		/*
+		 * Copy data into fpkt data buffer, and update the counter
+		 */
+		bcopy(frm->frm_payload, (uint8_t *)xch->xch_fpkt->pkt_data +
+		    FRM_PARAM(frm), frm->frm_payload_size);
+		xch->xch_resid -= frm->frm_payload_size;
+		xch->xch_rxid = FRM_RXID(frm);
+		break;
+
+	case R_CTL_XFER_RDY:
+		fcoei_process_unsol_xfer_rdy(frm);
+		break;
+
+	case R_CTL_STATUS:
+		fcoei_process_sol_fcp_resp(frm);
+		break;
+
+	case R_CTL_ELS_REQ:
+		fcoei_process_unsol_els_req(frm);
+		break;
+
+	case R_CTL_LS_ABTS:
+		fcoei_process_unsol_abts_req(frm);
+		break;
+
+	case R_CTL_ELS_RSP:
+		fcoei_process_sol_els_rsp(frm);
+		break;
+
+	case R_CTL_SOLICITED_CONTROL:
+		fcoei_process_sol_ct_rsp(frm);
+		break;
+
+	case R_CTL_LS_BA_ACC:
+		fcoei_process_sol_abts_acc(frm);
+		break;
+
+	case R_CTL_LS_BA_RJT:
+		fcoei_process_sol_abts_rjt(frm);
+		break;
+
+	default:
+		/*
+		 * Unsupported frame
+		 */
+		PRT_FRM_HDR("Unsupported unsol frame: ", frm);
+	}
+
+	/*
+	 * Release the frame and netb
+	 */
+	frm->frm_eport->eport_free_netb(frm->frm_netb);
+	frm->frm_eport->eport_release_frame(frm);
+}
+
+/*
+ * fcoei_handle_sol_frame_done
+ *	solicited frame is just sent out
+ *
+ * Input:
+ *	frame = solicited frame that has been sent out
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	watchdog will call this to handle solicited frames that FCOEI
+ *	has sent out Non-request frame post handling
+ */
+void
+fcoei_handle_sol_frame_done(fcoe_frame_t *frm)
+{
+	/*
+	 * the corresponding xch could be NULL at this time
+	 */
+	fcoei_exchange_t	*xch  = FRM2IFM(frm)->ifm_xch;
+
+	switch (FRM2IFM(frm)->ifm_rctl) {
+	case R_CTL_ELS_RSP:
+		/*
+		 * Complete it with frm as NULL
+		 */
+		fcoei_complete_xch(xch, NULL, FC_PKT_SUCCESS, 0);
+		break;
+
+	case R_CTL_LS_BA_ACC:
+		FCOEI_LOG(__FUNCTION__,  "BA_ACC out: xch-%p, frm-%p",
+		    xch, frm);
+		PRT_FRM_HDR("LS_BA_ACC", frm);
+		break;
+
+	case R_CTL_LS_BA_RJT:
+		FCOEI_LOG(__FUNCTION__,  "BA_RJT out: xch-%p, frm-%p",
+		    xch, frm);
+		PRT_FRM_HDR("LS_BA_RJT", frm);
+		break;
+
+	default:
+		/*
+		 * Unsupported frame
+		 */
+		PRT_FRM_HDR("Unsupported sol frame: ", frm);
+	}
+
+	/*
+	 * We should release only the frame, and we don't care its netb
+	 */
+	FRM2SS(frm)->ss_eport->eport_release_frame(frm);
+}
+
+/*
+ * fcoei_port_event
+ *	link/port state changed
+ *
+ * Input:
+ *	eport = to indicate which port has changed
+ *	event = what change
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	refer fctl.h for ss_link_state value
+ */
+void
+fcoei_port_event(fcoe_port_t *eport, uint32_t event)
+{
+	fcoei_event_t	*ae;
+
+	if (!(EPORT2SS(eport)->ss_flags & SS_FLAG_LV_BOUND)) {
+		FCOEI_LOG(__FUNCTION__, "not bound now");
+		return;
+	}
+
+	mutex_enter(&EPORT2SS(eport)->ss_watchdog_mutex);
+	switch (event) {
+	case FCOE_NOTIFY_EPORT_LINK_DOWN:
+		EPORT2SS(eport)->ss_link_state = FC_STATE_OFFLINE;
+		cmn_err(CE_NOTE, "%02x%02x%02x%02x%02x%02x%02x%02x Link down",
+		    eport->eport_portwwn[0], eport->eport_portwwn[1],
+		    eport->eport_portwwn[2], eport->eport_portwwn[3],
+		    eport->eport_portwwn[4], eport->eport_portwwn[5],
+		    eport->eport_portwwn[6], eport->eport_portwwn[7]);
+		break;
+
+	case FCOE_NOTIFY_EPORT_LINK_UP:
+		if (eport->eport_mtu >= 2200) {
+			EPORT2SS(eport)->ss_fcp_data_payload_size =
+			    FCOE_DEFAULT_FCP_DATA_PAYLOAD_SIZE;
+		} else {
+			FCOEI_LOG(__FUNCTION__, "fcoei: MTU is not big enough. "
+			    "we will use 1K frames in FCP data phase.");
+			EPORT2SS(eport)->ss_fcp_data_payload_size =
+			    FCOE_MIN_FCP_DATA_PAYLOAD_SIZE;
+		}
+
+		cmn_err(CE_NOTE, "%02x%02x%02x%02x%02x%02x%02x%02x Link up",
+		    eport->eport_portwwn[0], eport->eport_portwwn[1],
+		    eport->eport_portwwn[2], eport->eport_portwwn[3],
+		    eport->eport_portwwn[4], eport->eport_portwwn[5],
+		    eport->eport_portwwn[6], eport->eport_portwwn[7]);
+		EPORT2SS(eport)->ss_link_state = FC_STATE_ONLINE;
+		break;
+
+	default:
+		FCOEI_LOG(__FUNCTION__, "unsupported event");
+		mutex_exit(&EPORT2SS(eport)->ss_watchdog_mutex);
+
+		return;
+	}
+
+	EPORT2SS(eport)->ss_port_event_counter++;
+	ae = (fcoei_event_t *)kmem_zalloc(sizeof (fcoei_event_t), KM_SLEEP);
+	ae->ae_type = AE_EVENT_PORT;
+	ae->ae_obj = EPORT2SS(eport);
+	ae->ae_specific = EPORT2SS(eport)->ss_link_state;
+	list_insert_tail(&EPORT2SS(eport)->ss_event_list, ae);
+	mutex_exit(&EPORT2SS(eport)->ss_watchdog_mutex);
+}
+
+/*
+ * fcoei_process_event_port
+ *	link/port state changed
+ *
+ * Input:
+ *	ae = link fcoei_event
+ *
+ * Returns:
+ *	N/A
+ *
+ * Comments:
+ *	asynchronous events from FCOE
+ */
+void
+fcoei_process_event_port(fcoei_event_t *ae)
+{
+	fcoei_soft_state_t	*ss = (fcoei_soft_state_t *)ae->ae_obj;
+
+	if (ss->ss_eport->eport_link_speed == FCOE_PORT_SPEED_1G) {
+		ae->ae_specific |= FC_STATE_1GBIT_SPEED;
+	} else if (ss->ss_eport->eport_link_speed ==
+	    FCOE_PORT_SPEED_10G) {
+		ae->ae_specific |= FC_STATE_10GBIT_SPEED;
+	}
+
+	if (ss->ss_flags & SS_FLAG_LV_BOUND) {
+		ss->ss_bind_info.port_statec_cb(ss->ss_port,
+		    (uint32_t)ae->ae_specific);
+	} else {
+		FCOEI_LOG(__FUNCTION__, "ss %p not bound now", ss);
+	}
+
+	atomic_add_32(&ss->ss_port_event_counter, -1);
+	kmem_free(ae, sizeof (fcoei_event_t));
+}