// SPDX-License-Identifier: GPL-2.0
/* Huawei Hifc PCI Express Linux driver
 * Copyright(c) 2017 Huawei Technologies Co., Ltd
 *
 */
#include "unf_exchg.h"
#include "unf_log.h"
#include "unf_rport.h"
#include "unf_exchg.h"
#include "unf_service.h"
#include "unf_portman.h"
#include "unf_npiv.h"

static void unf_flogi_callback(void *v_lport,
			       void *v_rport,
			       void *v_xchg);
static void unf_fdisc_callback(void *v_lport,
			       void *v_rport,
			       void *v_xchg);
static void unf_plogi_callback(void *v_lport,
			       void *v_rport,
			       void *v_xchg);
static unsigned int unf_rec_handler(struct unf_lport_s *v_lport,
				    unsigned int v_sid,
				    struct unf_xchg_s *v_xchg);
static void unf_gid_ft_callback(void *v_lport,
				void *v_rport,
				void *v_xchg);
static void unf_gid_pt_callback(void *v_lport,
				void *v_rport,
				void *v_xchg);
static void unf_process_rport_after_logo(struct unf_lport_s *v_lport,
					 struct unf_rport_s *v_rport);
static unsigned int unf_flogi_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg);
static unsigned int unf_plogi_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg);
static unsigned int unf_prli_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg);
static unsigned int unf_prlo_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg);
static unsigned int unf_rscn_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg);
static unsigned int unf_logo_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg);
static unsigned int unf_echo_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg);
static unsigned int unf_pdisc_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg);
static unsigned int unf_adisc_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg);
static unsigned int unf_rrq_handler(struct unf_lport_s *v_lport,
				    unsigned int v_sid,
				    struct unf_xchg_s *v_xchg);
static unsigned int unf_rls_handler(struct unf_lport_s *v_lport,
				    unsigned int v_sid,
				    struct unf_xchg_s *v_xchg);
static unsigned int unf_send_els_rjt_by_rport(
					struct unf_lport_s *v_lport,
					struct unf_xchg_s *v_xchg,
					struct unf_rport_s *v_rport,
					struct unf_rjt_info_s *v_rjt_info);

unsigned int max_frame_size = UNF_DEFAULT_FRAME_SIZE;

#define FCP_XFER_RDY_IU   0x05
#define FCP_RSP_IU        0x07
#define FCP_DATA_IU       0x01

#define UNF_GID_LAST_PORT_ID  0x80
#define UNF_LOWLEVEL_BBCREDIT 0x6
#define UNF_DEFAULT_BB_SC_N   0
#define UNF_INIT_DISC         0x1 /* first time DISC */
#define UNF_RSCN_DISC         0x2 /* RSCN Port Addr DISC */
/* Reference from FCP-4 Table33 RR_TOV:  REC_TOV + 2*R_A_TOV + 1S,
 * REC_TOV = E_D_TOV + 1s
 */
#define UNF_CALC_LPORT_RRTOV(v_lport) \
	(((v_lport)->ed_tov + 1000) + (2 * (v_lport)->ra_tov + 1000))

#define UNF_GID_CONTROL(v_nport_id) ((v_nport_id) >> 24)

#define UNF_ECHO_PLD_DATA 0x1234567890ABCDEF
#define UNF_ECHO_REQ_SIZE 0

#define UNF_GET_PORT_OPTIONS(v_fc4feature) ((v_fc4feature) >> 20)

#define UNF_GET_DOMAIN_ID(x) (((x) & 0xFF0000) >> 16) /* domain id */
#define UNF_GET_AREA_ID(x)   (((x) & 0x00FF00) >> 8)  /* area id */

#define UNF_SERVICE_GET_NPORTID_FORM_GID_PAGE(v_port_id_page) \
	(((unsigned int)(v_port_id_page)->port_id_domain << 16) | \
	 ((unsigned int)(v_port_id_page)->port_id_area << 8) | \
	 ((unsigned int)(v_port_id_page)->port_id_port))

#define UNF_GNN_GFF_ID_RJT_REASON(rjt_reason) \
	((((rjt_reason) & UNF_CTIU_RJT_MASK) == \
	 UNF_CTIU_RJT_UNABLE_PERFORM) && \
	 ((((rjt_reason) & UNF_CTIU_RJT_EXP_MASK) == \
	  UNF_CTIU_RJT_EXP_PORTID_NO_REG) || \
	 (((rjt_reason) & UNF_CTIU_RJT_EXP_MASK) == \
	  UNF_CTIU_RJT_EXP_PORTNAME_NO_REG) || \
	 (((rjt_reason) & UNF_CTIU_RJT_EXP_MASK) == \
	  UNF_CTIU_RJT_EXP_NODENAME_NO_REG)))

#define UNF_NEED_BIG_RESPONSE_BUFF(cmnd_code) \
	(((cmnd_code) == ELS_ECHO) || ((cmnd_code) == NS_GID_PT) || \
	 ((cmnd_code) == NS_GID_FT))

#define NEED_REFRESH_NPORTID(pkg) ((((pkg)->cmnd == ELS_PLOGI) || \
				   ((pkg)->cmnd == ELS_PDISC) || \
				   ((pkg)->cmnd == ELS_ADISC)))

struct unf_els_handler_table {
	unsigned int cmnd;
	unsigned int (*pfn_els_cmnd_handler)(struct unf_lport_s *,
					     unsigned int, struct unf_xchg_s *);
};

#define UNF_SERVICE_COLLECT(service_collect, item) \
	do { \
		if ((item) < UNF_SERVICE_BUTT) { \
			service_collect.service_cnt[(item)]++;  \
		} \
	} while (0)

struct unf_els_handler_table els_handle[] = {
	{ ELS_PLOGI, unf_plogi_handler },
	{ ELS_FLOGI, unf_flogi_handler },
	{ ELS_LOGO,  unf_logo_handler },
	{ ELS_ECHO,  unf_echo_handler },
	{ ELS_RRQ,   unf_rrq_handler },
	{ ELS_REC,   unf_rec_handler },
	{ ELS_PRLI,  unf_prli_handler },
	{ ELS_PRLO,  unf_prlo_handler },
	{ ELS_PDISC, unf_pdisc_handler },
	{ ELS_ADISC, unf_adisc_handler },
	{ ELS_RSCN,  unf_rscn_handler },
	{ ELS_RLS,   unf_rls_handler }
};

static void unf_check_rport_need_delay_prli(struct unf_lport_s *v_lport,
					    struct unf_rport_s *v_rport,
					    unsigned int v_port_feature)
{
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3300, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3301, UNF_TRUE, v_rport, return);

	v_port_feature &= UNF_PORT_MODE_BOTH;

	/* Used for: L_Port has INI mode & R_Port is not SW */
	if (v_rport->nport_id < UNF_FC_FID_DOM_MGR) {
		/*
		 * 1. immediately: R_Port only with TGT, or
		 * L_Port only with INI & R_Port has TGT mode,
		 * send PRLI immediately
		 */
		if (((v_port_feature == UNF_PORT_MODE_TGT) ||
		     (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) ||
		    ((v_port_feature & UNF_PORT_MODE_TGT) ==
		      UNF_PORT_MODE_TGT)) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
				  UNF_LOG_LOGIN_ATT, UNF_MAJOR,
				  "[info]LOGIN: Port(0x%x_0x%x) Rport(0x%x) with feature(0x%x) send PRLI",
				  v_lport->port_id, v_lport->nport_id,
				  v_rport->nport_id, v_port_feature);

			/* Send PRLI to remote port */
			ret = unf_send_prli(v_lport, v_rport);
			if (ret != RETURN_OK) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
					  UNF_LOG_LOGIN_ATT,
					  UNF_WARN,
					  "[warn]LOGIN: Port(0x%x_0x%x) Rport(0x%x) with feature(0x%x) send PRLI failed",
					  v_lport->port_id,
					  v_lport->nport_id,
					  v_rport->nport_id,
					  v_port_feature);

				/* Do R_Port recovery */
				unf_rport_error_recovery(v_rport);
			}
		} else if (v_port_feature != UNF_PORT_MODE_INI) {
			/* 2. R_Port has BOTH mode or unknown,
			 * Delay to send PRLI
			 */
			/* Prevent: PRLI done before PLOGI */
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]LOGIN: Port(0x%x_0x%x) Rport(0x%x) with feature(0x%x) delay to send PRLI",
				  v_lport->port_id, v_lport->nport_id,
				  v_rport->nport_id, v_port_feature);

			/* Delay to send PRLI to R_Port */
			unf_rport_delay_login(v_rport);
		} else {
			/* 3. R_Port only with INI mode: wait for R_Port's
			 * PRLI: Do not care
			 */
			/* Cancel recovery(timer) work */
			if (delayed_work_pending(&v_rport->recovery_work)) {
				if (cancel_delayed_work(
					&v_rport->recovery_work)) {
					UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
						  UNF_LOG_LOGIN_ATT, UNF_INFO,
						  "[info]LOGIN: Port(0x%x_0x%x) Rport(0x%x) with feature(0x%x) is pure INI",
						  v_lport->port_id,
						  v_lport->nport_id,
						  v_rport->nport_id,
						  v_port_feature);

					unf_rport_ref_dec(v_rport);
				}
			}

			/* Server: R_Port only support INI,
			 * do not care this case
			 */
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
				  UNF_LOG_LOGIN_ATT, UNF_MAJOR,
				  "[info]LOGIN: Port(0x%x_0x%x) Rport(0x%x) with feature(0x%x) wait for PRLI",
				  v_lport->port_id, v_lport->nport_id,
				  v_rport->nport_id, v_port_feature);
		}
	}
}

static unsigned int unf_low_level_bb_credit(struct unf_lport_s *v_lport)
{
	struct unf_lport_s *lport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int bb_credit = UNF_LOWLEVEL_BBCREDIT;

	if (unlikely(!v_lport))
		return bb_credit;

	lport = v_lport;
	if (unlikely(!lport->low_level_func.port_mgr_op.pfn_ll_port_config_get))
		return bb_credit;

	ret = lport->low_level_func.port_mgr_op.pfn_ll_port_config_get(
			(void *)lport->fc_port,
			UNF_PORT_CFG_GET_WORKBALE_BBCREDIT,
			(void *)&bb_credit);
	if (unlikely(ret != RETURN_OK)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[warn]Port(0x%x) get BB_Credit failed, use default value(%d)",
			  lport->port_id, UNF_LOWLEVEL_BBCREDIT);

		bb_credit = UNF_LOWLEVEL_BBCREDIT;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]Port(0x%x) with BB_Credit(%u)",
		  lport->port_id, bb_credit);

	return bb_credit;
}

unsigned int unf_low_level_bbscn(struct unf_lport_s *v_lport)
{
	struct unf_lport_s *lport = v_lport;
	struct unf_low_level_port_mgr_op_s *port_mgr = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int bb_scn = UNF_DEFAULT_BB_SC_N;

	if (unlikely(!v_lport))
		return bb_scn;

	port_mgr = &lport->low_level_func.port_mgr_op;

	if (unlikely(!port_mgr->pfn_ll_port_config_get))
		return bb_scn;

	ret = port_mgr->pfn_ll_port_config_get((void *)lport->fc_port,
					    UNF_PORT_CFG_GET_WORKBALE_BBSCN,
					    (void *)&bb_scn);
	if (unlikely(ret != RETURN_OK)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[warn]Port(0x%x) get bbscn failed, use default value(%d)",
			  lport->port_id, UNF_DEFAULT_BB_SC_N);

		bb_scn = UNF_DEFAULT_BB_SC_N;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]Port(0x%x)'s bbscn(%d)",
		  lport->port_id, bb_scn);

	return bb_scn;
}

static unsigned int unf_els_cmnd_send(struct unf_lport_s *v_lport,
				      struct unf_frame_pkg_s *v_pkg,
				      struct unf_xchg_s *v_xchg)
{
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned long time_out = 0;

	UNF_CHECK_VALID(0x3302, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3303, UNF_TRUE, v_pkg, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3304, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	if (unlikely(!v_lport->low_level_func.service_op.pfn_unf_els_send)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) ELS send function is NULL",
			  v_lport->port_id);

		return ret;
	}

	/* Add ELS command/response (Exchange) timeout timer */
	time_out = UNF_GET_ELS_SFS_XCHG_TIMER(v_lport);
	if (v_xchg->cmnd_code == ELS_RRQ) {
		time_out = ((unsigned long)
			    UNF_GET_ELS_SFS_XCHG_TIMER(v_lport) >
			    UNF_RRQ_MIN_TIMEOUT_INTERVAL) ?
			    (unsigned long)
			    UNF_GET_ELS_SFS_XCHG_TIMER(v_lport) :
			    UNF_RRQ_MIN_TIMEOUT_INTERVAL;
	} else if (v_xchg->cmnd_code == ELS_LOGO) {
		time_out = UNF_LOGO_TIMEOUT_INTERVAL;
	}
	v_lport->xchg_mgr_temp.pfn_unf_xchg_add_timer((void *)v_xchg,
						   time_out,
						   UNF_TIMER_TYPE_SFS);

	v_pkg->private[PKG_PRIVATE_XCHG_TIMEER] =
		(unsigned int)UNF_GET_ELS_SFS_XCHG_TIMER(v_lport);
	v_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] =
		v_xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME];

	/* Send ELS command/response */
	ret = v_lport->low_level_func.service_op.pfn_unf_els_send(
		v_lport->fc_port, v_pkg);
	if (unlikely(ret != RETURN_OK)) {
		/* Cancel timer if send failed */
		v_lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer(
							(void *)v_xchg);
	}

	return ret;
}

static unsigned int unf_gs_cmnd_send(struct unf_lport_s *v_lport,
				     struct unf_frame_pkg_s *v_pkg,
				     struct unf_xchg_s *v_xchg)
{
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3305, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3306, UNF_TRUE, v_pkg, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3307, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	if (unlikely(!v_lport->low_level_func.service_op.pfn_unf_gs_send)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) GS send function is NULL",
			  v_lport->port_id);

		return ret;
	}

	/* Add GS command timeout timer */
	v_lport->xchg_mgr_temp.pfn_unf_xchg_add_timer(
			(void *)v_xchg,
			(unsigned long)UNF_GET_GS_SFS_XCHG_TIMER(v_lport),
			UNF_TIMER_TYPE_SFS);
	v_pkg->private[PKG_PRIVATE_XCHG_TIMEER] = (unsigned int)
			UNF_GET_GS_SFS_XCHG_TIMER(v_lport);
	v_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] =
			v_xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME];

	/* Send GS command */
	ret = v_lport->low_level_func.service_op.pfn_unf_gs_send(
			v_lport->fc_port, v_pkg);
	if (unlikely(ret != RETURN_OK))
		/* Cancel timer if send failed */
		v_lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer(
							(void *)v_xchg);

	return ret;
}

static unsigned int unf_bls_cmnd_send(struct unf_lport_s *v_lport,
				      struct unf_frame_pkg_s *v_pkg,
				      struct unf_xchg_s *v_xchg)
{
	UNF_CHECK_VALID(0x3308, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3309, UNF_TRUE, v_pkg, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3310, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	v_pkg->private[PKG_PRIVATE_XCHG_TIMEER] =
		(unsigned int)UNF_GET_BLS_SFS_XCHG_TIMER(v_lport);
	v_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] =
		v_xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME];

	return v_lport->low_level_func.service_op.pfn_unf_bls_send(
						v_lport->fc_port, v_pkg);
}

static void unf_fill_package(struct unf_frame_pkg_s *v_pkg,
			     struct unf_xchg_s *v_xchg,
			     struct unf_rport_s *v_rport)
{
	/* v_rport maybe NULL */
	UNF_CHECK_VALID(0x3311, UNF_TRUE, v_pkg, return);
	UNF_CHECK_VALID(0x3312, UNF_TRUE, v_xchg, return);

	v_pkg->cmnd = v_xchg->cmnd_code;
	v_pkg->fcp_cmnd = &v_xchg->fcp_cmnd;
	v_pkg->frame_head.csctl_sid = v_xchg->sid;
	v_pkg->frame_head.rctl_did = v_xchg->did;
	v_pkg->frame_head.oxid_rxid = ((unsigned int)v_xchg->ox_id << 16 |
					 v_xchg->rx_id);
	v_pkg->xchg_contex = v_xchg;

	UNF_CHECK_VALID(0x3313, UNF_TRUE, v_xchg->lport, return);
	v_pkg->private[PKG_PRIVATE_XCHG_VP_INDEX] =
		v_xchg->lport->vp_index;

	if (!v_rport) {
		v_pkg->private[PKG_PRIVATE_XCHG_RPORT_INDEX] =
		UNF_RPORT_INVALID_INDEX;
		v_pkg->private[PKG_PRIVATE_RPORT_RX_SIZE] = INVALID_VALUE32;
	} else {
		v_pkg->private[PKG_PRIVATE_XCHG_RPORT_INDEX] =
			v_rport->rport_index;
		v_pkg->private[PKG_PRIVATE_RPORT_RX_SIZE] =
			v_rport->max_frame_size;
	}

	v_pkg->private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX] = v_xchg->hot_pool_tag;
	v_pkg->private[PKG_PRIVATE_LOWLEVEL_XCHG_ADD] =
		v_xchg->private[PKG_PRIVATE_LOWLEVEL_XCHG_ADD];
	v_pkg->unf_cmnd_pload_bl.buffer_ptr =
		(unsigned char *)
		v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	v_pkg->unf_cmnd_pload_bl.buf_dma_addr =
		v_xchg->fcp_sfs_union.sfs_entry.sfs_buff_phy_addr;

	/* Low level need to know payload length if send ECHO response */
	v_pkg->unf_cmnd_pload_bl.length =
		v_xchg->fcp_sfs_union.sfs_entry.cur_offset;
}

static struct unf_xchg_s *unf_get_sfs_free_xchg_and_init(
					struct unf_lport_s *v_lport,
					unsigned int v_did,
					struct unf_rport_s *v_rport,
					union unf_sfs_u **v_fc_entry)
{
	struct unf_xchg_s *xchg = NULL;
	union unf_sfs_u *fc_entry = NULL;

	xchg = unf_cm_get_free_xchg(v_lport, UNF_XCHG_TYPE_SFS);
	if (!xchg)
		return NULL;

	xchg->did = v_did;
	xchg->sid = v_lport->nport_id;
	xchg->oid = xchg->sid;
	xchg->lport = v_lport;
	xchg->rport = v_rport;
	xchg->disc_rport = NULL;

	if (v_lport->low_level_func.xchg_mgr_type ==
	    UNF_LOW_LEVEL_MGR_TYPE_PASSTIVE)
		xchg->ox_id = xchg->hot_pool_tag;

	xchg->pfn_callback = NULL;
	xchg->pfn_ob_callback = NULL;

	fc_entry = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, xchg);
		return NULL;
	}

	*v_fc_entry = fc_entry;

	return xchg;
}

static void unf_scr_callback(void *v_lport,
			     void *v_rport,
			     void *v_xchg)
{
	/* Callback function for SCR response: Send GID_PT with INI mode */
	struct unf_lport_s *lport = (struct unf_lport_s *)v_lport;
	struct unf_disc_s *disc = &lport->disc;
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_xchg;
	struct unf_els_acc_s *els_acc = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned long lport_flag = 0;
	unsigned long disc_flag = 0;
	unsigned int cmnd = 0;

	UNF_CHECK_VALID(0x3694, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3695, UNF_TRUE, v_xchg, return);
	UNF_REFERNCE_VAR(v_rport);
	UNF_REFERNCE_VAR(ret);

	if (!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr)
		return;

	els_acc = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->els_acc;
	if (xchg->byte_orders & UNF_BIT_2)
		cmnd = be32_to_cpu(els_acc->cmnd);
	else
		cmnd = (els_acc->cmnd);

	if ((cmnd & UNF_ELS_CMND_HIGH_MASK) == UNF_ELS_CMND_ACC) {
		/* About ELS_CMND ACC */
		spin_lock_irqsave(&lport->lport_state_lock, lport_flag);

		/* Check L_Port state: SCR_WAIT */
		if (lport->en_states != UNF_LPORT_ST_SCR_WAIT) {
			spin_unlock_irqrestore(&lport->lport_state_lock,
					       lport_flag);

			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x_0x%x) receive SCR ACC with error state(0x%x)",
				  lport->port_id, lport->nport_id,
				  lport->en_states);
			return;
		}

		/* Update L_Port state machine: Ready */
		/* LPort: SCR_WAIT --> READY */
		unf_lport_stat_ma(lport, UNF_EVENT_LPORT_REMOTE_ACC);
		if (lport->en_states == UNF_LPORT_ST_READY) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]LOGIN: Port(0x%x_0x%x) enter READY state when received SCR response",
				  lport->port_id, lport->nport_id);
		}

		/* Start to Discovery with INI mode: GID_PT */
		if ((lport->options & UNF_PORT_MODE_INI) ==
		    UNF_PORT_MODE_INI) {
			spin_unlock_irqrestore(&lport->lport_state_lock,
					       lport_flag);

			if (lport->disc.unf_disc_temp.pfn_unf_disc_start) {
				spin_lock_irqsave(&disc->rport_busy_pool_lock,
						  disc_flag);
				lport->disc.disc_option = UNF_INIT_DISC;
				disc->last_disc_jiff = jiffies;
				spin_unlock_irqrestore(
					&disc->rport_busy_pool_lock, disc_flag);

				ret = lport->disc.unf_disc_temp.pfn_unf_disc_start(lport);

				UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
					  UNF_LOG_LOGIN_ATT, UNF_INFO,
					  "[info]LOGIN: Port(0x%x) DISC %s with INI mode",
					  lport->port_id,
					  (ret != RETURN_OK) ? "failed" :
					  "succeed");
			}

			UNF_REFERNCE_VAR(ret);
			return;
		}
		/* TGT mode: Do not care */
		spin_unlock_irqrestore(&lport->lport_state_lock, lport_flag);

		/* NOTE: set state with UNF_DISC_ST_END used for RSCN process */
		spin_lock_irqsave(&disc->rport_busy_pool_lock, disc_flag);
		lport->disc.en_states = UNF_DISC_ST_END;
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, disc_flag);

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x) is TGT mode, no need to discovery",
			  lport->port_id);
		return;
	}
	/* About ELS_CMND response: RJT */
	unf_lport_error_recovery(lport);

	UNF_REFERNCE_VAR(ret);
}

static void unf_scr_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Callback fucnion for exception: Do L_Port error recovery */
	struct unf_lport_s *lport = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3692, UNF_TRUE, v_xchg, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);

	UNF_CHECK_VALID(0x3693, UNF_TRUE, lport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]Port(0x%x) send SCR failed and do port recovery",
		  lport->port_id);

	unf_lport_error_recovery(lport);
}

unsigned int unf_send_scr(struct unf_lport_s *v_lport,
			  struct unf_rport_s *v_rport)
{
	/* after RCVD RFF_ID ACC */
	struct unf_scr_s *scr = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3314, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3315, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	/* Get free exchange for SCR */
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      NULL, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for SCR",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_SCR;  /* SCR */
	ox_id = xchg->ox_id;
	/* Set callback function */
	xchg->pfn_callback = unf_scr_callback;
	xchg->pfn_ob_callback = unf_scr_ob_callback;

	/* Fill command/response package */
	unf_fill_package(&pkg, xchg, v_rport);

	scr = &fc_entry->scr;
	memset(scr, 0, sizeof(struct unf_scr_s));
	scr->payload[0] = (UNF_GS_CMND_SCR);	 /* SCR is 0x62 */
	scr->payload[1] = (UNF_FABRIC_FULL_REG); /* Full registration */

	/* Send SCR command */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: SCR send %s. Port(0x%x_0x%x)--->rport(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_lport->nport_id,
		  v_rport->nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_rec_pld(struct unf_rec_pld_s *v_rec_pld,
			     unsigned int v_sid,
			     unsigned short v_oxid)
{
	UNF_CHECK_VALID(0x3339, UNF_TRUE, v_rec_pld, return);

	v_rec_pld->rec_cmnd = UNF_ELS_CMND_REC;
	v_rec_pld->xchg_org_sid = v_sid;
	v_rec_pld->ox_id = v_oxid;
	v_rec_pld->rx_id = INVALID_VALUE16;
}

unsigned int unf_send_rec(struct unf_lport_s *v_lport,
			  struct unf_rport_s *v_rport,
			  struct unf_xchg_s *v_io_xchg)
{
	struct unf_rec_pld_s *rec_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3324, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3325, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3325, UNF_TRUE, v_io_xchg, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	/* Get & Set new free exchange */
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for PLOGI",
			  v_lport->port_id);
		return ret;
	}

	xchg->cmnd_code = ELS_REC;
	ox_id = xchg->ox_id;
	unf_fill_package(&pkg, xchg, v_rport);

	rec_pld = &fc_entry->rec.rec_pld;
	memset(rec_pld, 0, sizeof(struct unf_rec_pld_s));

	unf_fill_rec_pld(rec_pld, v_lport->nport_id, v_io_xchg->ox_id);

	/* Start to Send REC command */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
		  "[info]LOGIN: Send REC %s. Port(0x%x_0x%x_0x%llx)--->RPort(0x%x_0x%llx) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_lport->nport_id, v_lport->port_name,
		  v_rport->nport_id, v_rport->port_name, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_flogi_pld(struct unf_flogi_payload_s *v_flogi_pld,
			       struct unf_lport_s *v_lport)
{
	struct unf_fabric_parms_s *fabric_parms = NULL;

	UNF_CHECK_VALID(0x3316, UNF_TRUE, v_flogi_pld, return);
	UNF_CHECK_VALID(0x3317, UNF_TRUE, v_lport, return);

	fabric_parms = &v_flogi_pld->fabric_parms;
	if ((v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT) ||
	    (v_lport->en_act_topo == UNF_TOP_P2P_MASK)) {
		/* Fabric or P2P  topology */
		fabric_parms->co_parms.bb_credit =
			unf_low_level_bb_credit(v_lport);
		fabric_parms->co_parms.lowest_version =
			UNF_PLOGI_VERSION_LOWER;
		fabric_parms->co_parms.highest_version =
			UNF_PLOGI_VERSION_UPPER;
		fabric_parms->co_parms.bb_receive_data_field_size =
			(v_lport->max_frame_size);
		fabric_parms->co_parms.bb_scn = unf_low_level_bbscn(v_lport);
	} else {
		/* Loop topology here */
		fabric_parms->co_parms.clean_address =
			UNF_CLEAN_ADDRESS_DEFAULT;
		fabric_parms->co_parms.bb_credit = UNF_BBCREDIT_LPORT;
		fabric_parms->co_parms.lowest_version =
			UNF_PLOGI_VERSION_LOWER;
		fabric_parms->co_parms.highest_version =
			UNF_PLOGI_VERSION_UPPER;
		fabric_parms->co_parms.alternate_bb_credit_mgmt =
			UNF_BBCREDIT_MANAGE_LPORT;  /* :1 */
		fabric_parms->co_parms.bb_receive_data_field_size =
			(v_lport->max_frame_size);
	}

	if (v_lport->low_level_func.support_max_npiv_num != 0)
		fabric_parms->co_parms.clean_address = 1; /* support NPIV */

	fabric_parms->cl_parms[2].valid = UNF_CLASS_VALID;
	fabric_parms->cl_parms[2].priority = UNF_PRIORITY_DISABLE;

	fabric_parms->cl_parms[2].sequential_delivery =
		UNF_SEQUEN_DELIVERY_REQ;
	fabric_parms->cl_parms[2].received_data_field_size =
		(v_lport->max_frame_size);

	fabric_parms->high_node_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->node_name);
	fabric_parms->low_node_name =
		UNF_GET_NAME_LOW_WORD(v_lport->node_name);
	fabric_parms->high_port_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->port_name);
	fabric_parms->low_port_name =
		UNF_GET_NAME_LOW_WORD(v_lport->port_name);
}

static void unf_flogi_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Send FLOGI failed & Do L_Port recovery */
	struct unf_lport_s *lport = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3644, UNF_TRUE, v_xchg, return);

	/* Get L_port from exchange context */
	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
	UNF_CHECK_VALID(0x3645, UNF_TRUE, lport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x) send FLOGI failed",
		  lport->port_id);

	/* Check L_Port state */
	spin_lock_irqsave(&lport->lport_state_lock, flag);
	if (lport->en_states != UNF_LPORT_ST_FLOGI_WAIT) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x) send FLOGI failed with state(0x%x)",
			  lport->port_id, lport->nport_id, lport->en_states);

		spin_unlock_irqrestore(&lport->lport_state_lock, flag);
		return;
	}
	spin_unlock_irqrestore(&lport->lport_state_lock, flag);

	/* Do L_Port error recovery */
	unf_lport_error_recovery(lport);
}

unsigned int unf_send_flogi(struct unf_lport_s *v_lport,
			    struct unf_rport_s *v_rport)
{
	struct unf_xchg_s *xchg = NULL;
	struct unf_flogi_payload_s *flogi_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3318, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3319, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	/* Get & Set New free Exchange Context */
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for FLOGI",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_FLOGI;  /* FLOGI */

	ox_id = xchg->ox_id;

	/* Set callback function */
	/* for rcvd flogi acc/rjt processer */
	xchg->pfn_callback = unf_flogi_callback;
	/* for send flogi failed processer */
	xchg->pfn_ob_callback = unf_flogi_ob_callback;

	/* Fill package: Exchange --to-->> Package */
	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill Flogi Payload */
	flogi_pld = &fc_entry->flogi.flogi_payload;
	memset(flogi_pld, 0, sizeof(struct unf_flogi_payload_s));
	unf_fill_flogi_pld(flogi_pld, v_lport);
	flogi_pld->cmnd = (UNF_ELS_CMND_FLOGI);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Begin to send FLOGI. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x)",
		  v_lport->port_id, v_rport->nport_id, ox_id);

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, flogi_pld,
			    sizeof(struct unf_flogi_payload_s));

	/* Start to send FLOGI command */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[warn]LOGIN: Send FLOGI failed. Port(0x%x)--->rport(0x%x)",
			  v_lport->port_id, v_rport->nport_id);

		unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	}

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fdisc_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Do recovery */
	struct unf_lport_s *lport = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3638, UNF_TRUE, v_xchg, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: FDISC send failed");

	UNF_CHECK_VALID(0x3639, UNF_TRUE, NULL != lport, return);

	/* Do L_Port error recovery */
	unf_lport_error_recovery(lport);
}

unsigned int unf_send_fdisc(struct unf_lport_s *v_lport,
			    struct unf_rport_s *v_rport)
{
	struct unf_xchg_s *exch = NULL;
	struct unf_flogi_payload_s *fdisc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3320, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3321, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	exch = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!exch) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for FDISC",
			  v_lport->port_id);

		return ret;
	}

	exch->cmnd_code = ELS_FDISC;  /* FDISC */

	ox_id = exch->ox_id;

	/* Set callback function */
	exch->pfn_callback = unf_fdisc_callback;
	exch->pfn_ob_callback = unf_fdisc_ob_callback;

	unf_fill_package(&pkg, exch, v_rport);

	/* Fill FDISC entry(payload) */
	fdisc_pld = &fc_entry->fdisc.fdisc_payload;
	memset(fdisc_pld, 0, sizeof(struct unf_flogi_payload_s));
	unf_fill_flogi_pld(fdisc_pld, v_lport);
	fdisc_pld->cmnd = UNF_ELS_CMND_FDISC;  /* update cmnd type */

	/* Start to send FDISC */
	ret = unf_els_cmnd_send(v_lport, &pkg, exch);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)exch);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: FDISC send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_plogi_pld(struct unf_plogi_payload_s *v_plogi_pld,
			       struct unf_lport_s *v_lport)
{
	struct unf_lgn_parms_s *login_parms = NULL;
	struct unf_lport_s *lport = NULL;

	UNF_CHECK_VALID(0x3322, UNF_TRUE, v_plogi_pld, return);
	UNF_CHECK_VALID(0x3323, UNF_TRUE, v_lport, return);

	lport = v_lport->root_lport;
	v_plogi_pld->cmnd = (UNF_ELS_CMND_PLOGI);
	login_parms = &v_plogi_pld->parms;

	if ((v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) {
		/* P2P or Fabric mode */
		login_parms->co_parms.bb_credit =
			(unf_low_level_bb_credit(v_lport));
		login_parms->co_parms.alternate_bb_credit_mgmt =
			UNF_BBCREDIT_MANAGE_NFPORT;  /* 0 */
		login_parms->co_parms.bb_scn =
			(v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ?
			0 : unf_low_level_bbscn(v_lport);
	} else {
		/* Public loop & Private loop mode */
		login_parms->co_parms.bb_credit = UNF_BBCREDIT_LPORT; /* 0 */
		login_parms->co_parms.alternate_bb_credit_mgmt =
			 UNF_BBCREDIT_MANAGE_LPORT;  /* 1 */
	}

	login_parms->co_parms.lowest_version = UNF_PLOGI_VERSION_LOWER;
	login_parms->co_parms.highest_version = UNF_PLOGI_VERSION_UPPER;
	login_parms->co_parms.continuously_increasing =
		UNF_CONTIN_INCREASE_SUPPORT;
	login_parms->co_parms.bb_receive_data_field_size =
		(v_lport->max_frame_size);
	login_parms->co_parms.nport_total_concurrent_sequences =
		(UNF_PLOGI_CONCURRENT_SEQ);
	login_parms->co_parms.relative_offset = (UNF_PLOGI_RO_CATEGORY);
	login_parms->co_parms.e_d_tov = UNF_DEFAULT_EDTOV;
	if (lport->b_priority == UNF_PRIORITY_ENABLE)
		login_parms->cl_parms[2].priority = UNF_PRIORITY_ENABLE;
	else
		login_parms->cl_parms[2].priority = UNF_PRIORITY_DISABLE;

	login_parms->cl_parms[2].valid = UNF_CLASS_VALID;  /* for class_3 */
	login_parms->cl_parms[2].received_data_field_size =
		(v_lport->max_frame_size);
	login_parms->cl_parms[2].concurrent_sequences =
		(UNF_PLOGI_CONCURRENT_SEQ);
	login_parms->cl_parms[2].open_sequences_per_exchange =
		(UNF_PLOGI_SEQ_PER_XCHG);

	login_parms->high_node_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->node_name);
	login_parms->low_node_name =
		UNF_GET_NAME_LOW_WORD(v_lport->node_name);
	login_parms->high_port_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->port_name);
	login_parms->low_port_name =
		UNF_GET_NAME_LOW_WORD(v_lport->port_name);

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, v_plogi_pld,
			    sizeof(struct unf_plogi_payload_s));
}

static void unf_plogi_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Do L_Port or R_Port recovery */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3656, UNF_TRUE, v_xchg, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	rport = v_xchg->rport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);

	UNF_CHECK_VALID(0x3657, UNF_TRUE, lport, return);
	UNF_CHECK_VALID(0x3734, UNF_TRUE, rport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x_0x%x) send PLOGI(0x%x_0x%x) to RPort(%p:0x%x_0x%x) failed",
		  lport->port_id, lport->nport_id, v_xchg->ox_id,
		  v_xchg->rx_id, rport, rport->rport_index, rport->nport_id);

	/* Start to recovery */
	if (rport->nport_id > UNF_FC_FID_DOM_MGR) {
		/* with Name server: R_Port is fabric --->>>
		 * L_Port error recovery
		 */
		unf_lport_error_recovery(lport);
	} else {
		/* R_Port is not fabric --->>> R_Port error recovery */
		unf_rport_error_recovery(rport);
	}
}

unsigned int unf_send_plogi(struct unf_lport_s *v_lport,
			    struct unf_rport_s *v_rport)
{
	struct unf_plogi_payload_s *plogi_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3324, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3325, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	/* Get & Set new free exchange */
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for PLOGI",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_PLOGI;  /* PLOGI */

	ox_id = xchg->ox_id;

	/* Set callback function */
	/* for rcvd plogi acc/rjt processer */
	xchg->pfn_callback = unf_plogi_callback;
	/* for send plogi failed processer */
	xchg->pfn_ob_callback = unf_plogi_ob_callback;

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill PLOGI payload */
	plogi_pld = &fc_entry->plogi.payload;
	memset(plogi_pld, 0, sizeof(struct unf_plogi_payload_s));
	unf_fill_plogi_pld(plogi_pld, v_lport);

	/* Start to Send PLOGI command */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Send PLOGI %s. Port(0x%x_0x%x_0x%llx)--->rport(0x%x_0x%llx) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_lport->nport_id, v_lport->port_name,
		  v_rport->nport_id, v_rport->port_name, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_logo_pld(struct unf_logo_payload_s *v_logo_pld,
			      struct unf_lport_s *v_lport)
{
	UNF_CHECK_VALID(0x3326, UNF_TRUE, v_logo_pld, return);
	UNF_CHECK_VALID(0x3327, UNF_TRUE, v_lport, return);

	v_logo_pld->cmnd = UNF_ELS_CMND_LOGO;
	v_logo_pld->nport_id = (v_lport->nport_id);
	v_logo_pld->high_port_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->port_name);
	v_logo_pld->low_port_name =
		UNF_GET_NAME_LOW_WORD(v_lport->port_name);

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id,
			    v_logo_pld,
			    sizeof(struct unf_logo_payload_s));
}

static void unf_logo_ob_callback(struct unf_xchg_s *v_xchg)
{
	struct unf_lport_s *lport;
	struct unf_rport_s *rport;
	struct unf_rport_s *old_rport;
	struct unf_xchg_s *xchg;
	unsigned int nport_id = 0;
	unsigned int logo_retry = 0;

	UNF_CHECK_VALID(0x3675, UNF_TRUE, NULL, return);
	xchg = v_xchg;
	old_rport = xchg->rport;
	logo_retry = old_rport->logo_retries;

	if (old_rport->nport_id != INVALID_VALUE32)
		unf_rport_enter_closing(old_rport);

	lport = xchg->lport;
	if (unf_is_lport_valid(lport) != RETURN_OK)
		return;

	/* Get R_Port by exchange info: Init state */
	nport_id = xchg->did;
	rport = unf_get_rport_by_nport_id(lport, nport_id);
	rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_INIT,
				   nport_id);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) cannot allocate RPort",
			  lport->port_id);
		return;
	}

	rport->logo_retries = logo_retry;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[info]LOGIN: Port(0x%x) received LOGO RSP timeout topo(0x%x) retries(%u)",
		  lport->port_id,  lport->en_act_topo, rport->logo_retries);

	/* RCVD LOGO/PRLO & SEND LOGO: the same process */
	if (rport->logo_retries < UNF_MAX_RETRY_COUNT) {
		/* <: retry (LOGIN or LOGO) if necessary */
		unf_process_rport_after_logo(lport, rport);
	} else {
		/* >=: Link down */
		unf_rport_immediate_linkdown(lport, rport);
	}
}

static void unf_logo_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	/* RCVD LOGO ACC/RJT: retry(LOGIN/LOGO) or link down immediately */
	struct unf_lport_s *lport = (struct unf_lport_s *)v_lport;
	struct unf_rport_s *rport = NULL;
	struct unf_rport_s *old_rport = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_els_rjt_s *els_acc_rjt = NULL;
	unsigned int cmnd = 0;
	unsigned int nport_id = 0;
	unsigned int logo_retry = 0;

	UNF_CHECK_VALID(0x3675, UNF_TRUE, v_xchg, return);
	UNF_REFERNCE_VAR(v_rport);

	xchg = (struct unf_xchg_s *)v_xchg;
	old_rport = xchg->rport;

	logo_retry = old_rport->logo_retries;
	if (old_rport->nport_id != INVALID_VALUE32)
		unf_rport_enter_closing(old_rport);

	if (unf_is_lport_valid(v_lport) != RETURN_OK)
		return;

	if (!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr)
		return;

	/* Get R_Port by exchange info: Init state */
	els_acc_rjt =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->els_rjt;
	nport_id = xchg->did;
	rport = unf_get_rport_by_nport_id(lport, nport_id);
	rport = unf_get_safe_rport(lport, rport,
				   UNF_RPORT_REUSE_INIT, nport_id);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) cannot allocate RPort",
			  lport->port_id);
		return;
	}

	rport->logo_retries = logo_retry;
	cmnd = be32_to_cpu(els_acc_rjt->cmnd);
	UNF_REFERNCE_VAR(cmnd);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Port(0x%x) received LOGO RSP(0x%x), topo(0x%x) Port options(0x%x) RPort options(0x%x) retries(%d)",
		  lport->port_id, (cmnd & UNF_ELS_CMND_HIGH_MASK),
		  lport->en_act_topo,
		  lport->options, rport->options, rport->logo_retries);

	/* RCVD LOGO/PRLO & SEND LOGO: the same process */
	if (rport->logo_retries < UNF_MAX_RETRY_COUNT)
		/* <: retry (LOGIN or LOGO) if necessary */
		unf_process_rport_after_logo(lport, rport);
	else
		/* >=: Link down */
		unf_rport_immediate_linkdown(lport, rport);
}

unsigned int unf_send_logo(struct unf_lport_s *v_lport,
			   struct unf_rport_s *v_rport)
{
	struct unf_logo_payload_s *logo_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3328, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for LOGO",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_LOGO;  /* LOGO */

	ox_id = xchg->ox_id;

	/* Set callback function */
	/* retry or link down immediately */
	xchg->pfn_callback = unf_logo_callback;
	xchg->pfn_ob_callback = unf_logo_ob_callback;  /* do nothing */

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill LOGO entry(payload) */
	logo_pld = &fc_entry->logo.payload;
	memset(logo_pld, 0, sizeof(struct unf_logo_payload_s));
	unf_fill_logo_pld(logo_pld, v_lport);

	/* Start to send LOGO command */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	v_rport->logo_retries++;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
		  "[info]LOGIN: LOGO send %s. Port(0x%x)--->rport(0x%x) OXID(0x%x) Retries(%d)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id,
		  ox_id, v_rport->logo_retries);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

unsigned int unf_send_logo_by_did(struct unf_lport_s *v_lport,
				  unsigned int v_did)
{
	/* Has non R_Port */
	struct unf_logo_payload_s *logo_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3329, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_did, NULL, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for LOGO",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_LOGO;  /* LOGO */

	ox_id = xchg->ox_id;

	unf_fill_package(&pkg, xchg, NULL);

	/* Fill LOGO entry(payload) */
	logo_pld = &fc_entry->logo.payload;
	memset(logo_pld, 0, sizeof(struct unf_logo_payload_s));
	unf_fill_logo_pld(logo_pld, v_lport);

	/* Start to send LOGO now */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: LOGO send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_did, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void *unf_get_one_big_sfs_buf(struct unf_xchg_s *v_xchg)
{
	struct unf_big_sfs_s *big_sfs = NULL;
	struct list_head *list_head = NULL;
	struct unf_xchg_mgr_s *xchg_mgr = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3330, UNF_TRUE, v_xchg, return NULL);
	xchg_mgr = v_xchg->xchg_mgr;
	UNF_CHECK_VALID(0x3331, UNF_TRUE, xchg_mgr, return NULL);

	spin_lock_irqsave(&xchg_mgr->st_big_sfs_pool.big_sfs_pool_lock, flag);
	if (!list_empty(&xchg_mgr->st_big_sfs_pool.list_free_pool)) {
		/* from free to busy */
		list_head = (&xchg_mgr->st_big_sfs_pool.list_free_pool)->next;
		list_del(list_head);
		xchg_mgr->st_big_sfs_pool.free_count--;
		list_add_tail(list_head,
			      &xchg_mgr->st_big_sfs_pool.list_busy_pool);
		big_sfs = list_entry(list_head, struct unf_big_sfs_s,
				     entry_big_sfs);
	} else {
		spin_unlock_irqrestore(
				&xchg_mgr->st_big_sfs_pool.big_sfs_pool_lock,
				flag);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Allocate big sfs buf failed, count(0x%x) exchange(0x%p) command(0x%x)",
			  xchg_mgr->st_big_sfs_pool.free_count,
			  v_xchg, v_xchg->cmnd_code);

		return NULL;
	}
	spin_unlock_irqrestore(&xchg_mgr->st_big_sfs_pool.big_sfs_pool_lock,
			       flag);

	v_xchg->big_sfs_buf = big_sfs;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]Allocate one address(0x%p) of big sfs buffer, remaining count(0x%x) exchange(0x%p) command(0x%x)",
		  big_sfs->vaddr,
		  xchg_mgr->st_big_sfs_pool.free_count,
		  v_xchg,
		  v_xchg->cmnd_code);

	return big_sfs->vaddr;
}

static void unf_echo_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	struct unf_lport_s *lport = (struct unf_lport_s *)v_lport;
	struct unf_rport_s *rport = (struct unf_rport_s *)v_rport;
	struct unf_xchg_s *xchg = NULL;
	struct unf_echo_payload_s *echo_rsp_pld = NULL;
	unsigned int cmnd = 0;
	unsigned int mag_ver_local = 0;
	unsigned int mag_ver_remote = 0;

	UNF_CHECK_VALID(0x3332, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3333, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3334, UNF_TRUE, v_xchg, return);
	UNF_REFERNCE_VAR(lport);
	UNF_REFERNCE_VAR(rport);

	xchg = (struct unf_xchg_s *)v_xchg;
	if (!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr)
		return;

	echo_rsp_pld = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo_acc.echo_pld;
	UNF_CHECK_VALID(0x3335, UNF_TRUE, NULL != echo_rsp_pld, return);

	if (xchg->byte_orders & UNF_BIT_2) {
		unf_big_end_to_cpu((unsigned char *)echo_rsp_pld,
				   sizeof(struct unf_echo_payload_s));
		cmnd = echo_rsp_pld->cmnd;
	} else {
		cmnd = echo_rsp_pld->cmnd;
	}

	mag_ver_local = echo_rsp_pld->data[0];
	mag_ver_remote = echo_rsp_pld->data[1];

	/* Print info */
	if ((cmnd & UNF_ELS_CMND_HIGH_MASK) == UNF_ELS_CMND_ACC) {
		if ((mag_ver_local == ECHO_MG_VERSION_LOCAL) &&
		    (mag_ver_remote == ECHO_MG_VERSION_REMOTE)) {
			/* both side are 1822 */
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
				  UNF_LOG_LOGIN_ATT, UNF_MAJOR,
				  "LPort(0x%x) send ECHO to RPort(0x%x), received ACC. local snd echo:(0x%x), remote rcv echo:(0x%x), remote snd echo acc:(0x%x), local rcv echo acc:(0x%x)",
				  lport->port_id, rport->nport_id,
				  xchg->private[PKG_PRIVATE_ECHO_CMD_SND_TIME],
				  xchg->private[PKG_PRIVATE_ECHO_CMD_RCV_TIME],
				  xchg->private[PKG_PRIVATE_ECHO_RSP_SND_TIME],
				  xchg->private[PKG_PRIVATE_ECHO_ACC_RCV_TIME]);
		} else if ((mag_ver_local == ECHO_MG_VERSION_LOCAL) &&
			   (mag_ver_remote != ECHO_MG_VERSION_REMOTE)) {
			/* the peer don't supprt smartping, only local snd
			 * and rcv rsp time stamp
			 */
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "LPort(0x%x) send ECHO to RPort(0x%x), received ACC. local snd echo:(0x%x), local rcv echo acc:(0x%x)",
				  lport->port_id, rport->nport_id,
				  xchg->private[PKG_PRIVATE_ECHO_CMD_SND_TIME],
				  xchg->private[PKG_PRIVATE_ECHO_ACC_RCV_TIME]);
		} else if ((mag_ver_local != ECHO_MG_VERSION_LOCAL) &&
			   (mag_ver_remote != ECHO_MG_VERSION_REMOTE)) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "LPort(0x%x) send ECHO to RPort(0x%x), received ACC. local and remote is not IN300",
				  lport->port_id, rport->nport_id);
		}
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) send ECHO to RPort(0x%x) and received RJT",
			  lport->port_id, rport->nport_id);
	}

	xchg->echo_info.echo_result = UNF_ELS_ECHO_RESULT_OK;
	xchg->echo_info.response_time = jiffies -
					 xchg->echo_info.response_time;

	/* wake up semaphore */
	up(&xchg->echo_info.echo_sync_sema);
}

static void unf_echo_ob_callback(struct unf_xchg_s *v_xchg)
{
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;

	UNF_CHECK_VALID(0x3336, UNF_TRUE, v_xchg, return);
	lport = v_xchg->lport;
	UNF_CHECK_VALID(0x3337, UNF_TRUE, lport, return);
	rport = v_xchg->rport;
	UNF_CHECK_VALID(0x3338, UNF_TRUE, rport, return);

	UNF_REFERNCE_VAR(lport);
	UNF_REFERNCE_VAR(rport);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]Port(0x%x) send ECHO to RPort(0x%x) but timeout",
		  lport->port_id, rport->nport_id);

	v_xchg->echo_info.echo_result = UNF_ELS_ECHO_RESULT_FAIL;

	/* wake up semaphore */
	up(&v_xchg->echo_info.echo_sync_sema);
}

unsigned int unf_send_echo(struct unf_lport_s *v_lport,
			   struct unf_rport_s *v_rport,
			   unsigned int *v_time)
{
	struct unf_echo_payload_s *echo_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned long delay = 0;
	unsigned short ox_id = 0;
	dma_addr_t phy_echo_addr;

	UNF_CHECK_VALID(0x3340, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3341, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3342, UNF_TRUE, v_time, return UNF_RETURN_ERROR);

	delay = 2 * (unsigned long)(v_lport->ra_tov);

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for ECHO",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_ECHO;  /* ECHO */

	xchg->fcp_sfs_union.sfs_entry.cur_offset = UNF_ECHO_REQ_SIZE;

	ox_id = xchg->ox_id;

	/* Set callback function */
	xchg->pfn_callback = unf_echo_callback;  /* wake up semaphore */
	xchg->pfn_ob_callback = unf_echo_ob_callback;  /* wake up semaphore */

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill ECHO entry(payload) */
	echo_pld = (struct unf_echo_payload_s *)unf_get_one_big_sfs_buf(xchg);
	if (!echo_pld) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can't allocate buffer for ECHO",
			  v_lport->port_id);

		unf_cm_free_xchg(v_lport, xchg);
		return UNF_RETURN_ERROR;
	}

	fc_entry->echo.echo_pld = echo_pld;
	phy_echo_addr = pci_map_single(v_lport->low_level_func.dev, echo_pld,
				       UNF_ECHO_PAYLOAD_LEN, DMA_BIDIRECTIONAL);
	if (pci_dma_mapping_error(
		v_lport->low_level_func.dev, phy_echo_addr)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) pci map err",
			  v_lport->port_id);
		unf_cm_free_xchg(v_lport, xchg);
		return UNF_RETURN_ERROR;
	}
	fc_entry->echo.phy_echo_addr = phy_echo_addr;
	memset(echo_pld, 0, sizeof(struct unf_echo_payload_s));
	echo_pld->cmnd = (UNF_ELS_CMND_ECHO);
	echo_pld->data[0] = ECHO_MG_VERSION_LOCAL;

	ret = unf_xchg_ref_inc(xchg, SEND_ELS);
	UNF_CHECK_VALID(0x3343, UNF_TRUE, (ret == RETURN_OK),
			return UNF_RETURN_ERROR);

	/* Start to send ECHO command */
	xchg->echo_info.response_time = jiffies;
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK) {
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	} else {
		if (down_timeout(&xchg->echo_info.echo_sync_sema,
				 (long)
				 msecs_to_jiffies((unsigned int)delay))) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]ECHO send %s. Port(0x%x)--->rport(0x%x) but response timeout with OX_ID(0x%x)",
				  (ret != RETURN_OK) ? "failed" : "succeed",
				  v_lport->port_id, v_rport->nport_id, ox_id);

			xchg->echo_info.echo_result =
				UNF_ELS_ECHO_RESULT_FAIL;
		}

		if (xchg->echo_info.echo_result ==
		    UNF_ELS_ECHO_RESULT_FAIL) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "Echo send fail or timeout");

			ret = UNF_RETURN_ERROR;
		} else {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "echo acc rsp,echo_cmd_snd(0x%xus)-->echo_cmd_rcv(0x%xus)-->echo_acc_snd(0x%xus)-->echo_acc_rcv(0x%xus).",
				  xchg->private[PKG_PRIVATE_ECHO_CMD_SND_TIME],
				  xchg->private[PKG_PRIVATE_ECHO_CMD_RCV_TIME],
				  xchg->private[PKG_PRIVATE_ECHO_RSP_SND_TIME],
				  xchg->private[PKG_PRIVATE_ECHO_ACC_RCV_TIME]);

			*v_time = (
				xchg->private[PKG_PRIVATE_ECHO_ACC_RCV_TIME] -
				xchg->private[PKG_PRIVATE_ECHO_CMD_SND_TIME]) -
				(xchg->private[PKG_PRIVATE_ECHO_RSP_SND_TIME] -
				xchg->private[PKG_PRIVATE_ECHO_CMD_RCV_TIME]);
		}
	}

	pci_unmap_single(v_lport->low_level_func.dev, phy_echo_addr,
			 UNF_ECHO_PAYLOAD_LEN, DMA_BIDIRECTIONAL);
	fc_entry->echo.phy_echo_addr = 0;
	unf_xchg_ref_dec(xchg, SEND_ELS);
	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_prli_pld(struct unf_pril_payload_s *v_prli_pld,
			      struct unf_lport_s *v_lport)
{
	unsigned int pld_len = 0;

	UNF_CHECK_VALID(0x3344, UNF_TRUE, v_prli_pld, return);
	UNF_CHECK_VALID(0x3345, UNF_TRUE, v_lport, return);

	pld_len = sizeof(struct unf_pril_payload_s) - UNF_PRLI_SIRT_EXTRA_SIZE;
	v_prli_pld->cmnd = (UNF_ELS_CMND_PRLI |
			      ((unsigned int)UNF_FC4_FRAME_PAGE_SIZE <<
			      UNF_FC4_FRAME_PAGE_SIZE_SHIFT) |
			      ((unsigned int)pld_len));

	v_prli_pld->parms[0] = (UNF_FC4_FRAME_PARM_0_FCP |
				UNF_FC4_FRAME_PARM_0_I_PAIR);
	v_prli_pld->parms[1] = UNF_NOT_MEANINGFUL;
	v_prli_pld->parms[2] = UNF_NOT_MEANINGFUL;

	/* About Read Xfer_rdy disable */
	v_prli_pld->parms[3] = (UNF_FC4_FRAME_PARM_3_R_XFER_DIS |
				v_lport->options);

	/* About FCP confirm */
	if (v_lport->low_level_func.lport_cfg_items.fcp_conf == UNF_TRUE)
		v_prli_pld->parms[3] |= UNF_FC4_FRAME_PARM_3_CONF_ALLOW;

	/* About Tape support */
	if (v_lport->low_level_func.lport_cfg_items.tape_support) {
		v_prli_pld->parms[3] |=
				(UNF_FC4_FRAME_PARM_3_REC_SUPPORT |
				UNF_FC4_FRAME_PARM_3_RETRY_SUPPORT |
				UNF_FC4_FRAME_PARM_3_TASK_RETRY_ID_SUPPORT |
				UNF_FC4_FRAME_PARM_3_CONF_ALLOW);
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]Port(0x%x)'s PRLI payload: options(0x%x) parameter-3(0x%x)",
		  v_lport->port_id, v_lport->options, v_prli_pld->parms[3]);

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, v_prli_pld,
			    sizeof(struct unf_pril_payload_s));
}

static void unf_prli_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	/* RCVD PRLI RSP: ACC or RJT --->>> SCSI Link Up */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_pril_payload_s *prli_acc_pld = NULL;
	unsigned long flag = 0;
	unsigned int cmnd = 0;
	unsigned int options = 0;
	unsigned int fcp_conf = 0;
	unsigned int rec_support = 0;
	unsigned int task_retry_support = 0;
	unsigned int retry_support = 0;
	unsigned int tape_support = 0;
	enum unf_rport_login_state_e rport_state = UNF_RPORT_ST_INIT;

	UNF_CHECK_VALID(0x3679, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3680, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3681, UNF_TRUE, v_xchg, return);
	lport = (struct unf_lport_s *)v_lport;
	rport = (struct unf_rport_s *)v_rport;
	xchg = (struct unf_xchg_s *)v_xchg;

	if (!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange(%p) entry is NULL",
			  lport->port_id, xchg);
		return;
	}

	/* Get PRLI ACC payload */
	prli_acc_pld =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->prli_acc.payload;
	if (xchg->byte_orders & UNF_BIT_2) {
		/* Change to little End, About INI/TGT mode & confirm info */
		options = be32_to_cpu(prli_acc_pld->parms[3]) &
			  (UNF_FC4_FRAME_PARM_3_TGT |
			  UNF_FC4_FRAME_PARM_3_INI);

		cmnd = be32_to_cpu(prli_acc_pld->cmnd);
		fcp_conf = be32_to_cpu(prli_acc_pld->parms[3]) &
			UNF_FC4_FRAME_PARM_3_CONF_ALLOW;
		rec_support = be32_to_cpu(prli_acc_pld->parms[3]) &
			UNF_FC4_FRAME_PARM_3_REC_SUPPORT;
		task_retry_support = be32_to_cpu(prli_acc_pld->parms[3]) &
			UNF_FC4_FRAME_PARM_3_TASK_RETRY_ID_SUPPORT;
		retry_support = be32_to_cpu(prli_acc_pld->parms[3]) &
			UNF_FC4_FRAME_PARM_3_RETRY_SUPPORT;

	} else {
		options = (prli_acc_pld->parms[3]) &
			  (UNF_FC4_FRAME_PARM_3_TGT |
			  UNF_FC4_FRAME_PARM_3_INI);

		cmnd = (prli_acc_pld->cmnd);
		fcp_conf = prli_acc_pld->parms[3] &
			UNF_FC4_FRAME_PARM_3_CONF_ALLOW;
		rec_support = prli_acc_pld->parms[3] &
			UNF_FC4_FRAME_PARM_3_REC_SUPPORT;
		task_retry_support = prli_acc_pld->parms[3] &
			UNF_FC4_FRAME_PARM_3_TASK_RETRY_ID_SUPPORT;
		retry_support = prli_acc_pld->parms[3] &
			UNF_FC4_FRAME_PARM_3_RETRY_SUPPORT;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: PRLI RSP: RPort(0x%x) parameter-3(0x%x) option(0x%x) cmd(0x%x) rec support:%u",
		  rport->nport_id, prli_acc_pld->parms[3], options,
		  cmnd, rec_support);

	/* PRLI ACC: R_Port READY & Report R_Port Link Up */
	if ((cmnd & UNF_ELS_CMND_HIGH_MASK) == UNF_ELS_CMND_ACC) {
		/* Update R_Port options(INI/TGT/BOTH) */
		rport->options = options;

		unf_update_port_feature(rport->port_name, rport->options);

		/* NOTE: R_Port only with INI mode, send LOGO */
		if (rport->options == UNF_PORT_MODE_INI) {
			/* Update R_Port state: LOGO */
			spin_lock_irqsave(&rport->rport_state_lock, flag);
			unf_rport_state_ma(rport, UNF_EVENT_RPORT_LOGO);
			spin_unlock_irqrestore(&rport->rport_state_lock, flag);

			/* NOTE: Start to Send LOGO */
			unf_rport_enter_logo(lport, rport);
			return;
		}

		/* About confirm */
		if (fcp_conf &&
		    (lport->low_level_func.lport_cfg_items.fcp_conf !=
		     UNF_FALSE)) {
			rport->fcp_conf_needed = UNF_TRUE;

			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]Port(0x%x_0x%x) FCP config is need for RPort(0x%x)",
				  lport->port_id, lport->nport_id,
				  rport->nport_id);
		}
	tape_support = (rec_support && task_retry_support && retry_support);
	if (tape_support &&
	    (lport->low_level_func.lport_cfg_items.tape_support != UNF_FALSE)) {
		rport->tape_support_needed = UNF_TRUE;

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
			  "[info]Port(0x%x_0x%x) Rec is enabled for RPort(0x%x)",
			  lport->port_id, lport->nport_id, rport->nport_id);
	}
		/* Update R_Port state: READY */
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		unf_rport_state_ma(rport, UNF_EVENT_RPORT_READY);
		rport_state = rport->rp_state;
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		/* Report R_Port online (Link Up) event to SCSI */
		if (rport_state == UNF_RPORT_ST_READY) {
			rport->logo_retries = 0;
			unf_update_lport_state_by_linkup_event(
				lport, rport, rport->options);
		}
	} else {
		/* PRLI RJT: Do R_Port error recovery */
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]LOGIN: Port(0x%x)<---LS_RJT(DID:0x%x SID:0x%x) for PRLI. RPort(0x%p) OX_ID(0x%x)",
			  lport->port_id, lport->nport_id,
			  rport->nport_id, rport, xchg->ox_id);

		unf_rport_error_recovery(rport);
	}
}

static void unf_prli_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Do R_Port recovery */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3676, UNF_TRUE, v_xchg, return);

	UNF_REFERNCE_VAR(lport);
	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	rport = v_xchg->rport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);

	UNF_CHECK_VALID(0x3677, UNF_TRUE, lport, return);
	UNF_CHECK_VALID(0x3678, UNF_TRUE, rport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x_0x%x) RPort(0x%x) send PRLI failed and do recovery",
		  lport->port_id, lport->nport_id, rport->nport_id);

	/* Start to do R_Port error recovery */
	unf_rport_error_recovery(rport);

	UNF_REFERNCE_VAR(lport);
}

unsigned int unf_send_prli(struct unf_lport_s *v_lport,
			   struct unf_rport_s *v_rport)
{
	struct unf_pril_payload_s *prli_pal = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3346, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3347, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	/* Get & Set new free exchange */
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for PRLI",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_PRLI;  // PRLI

	ox_id = xchg->ox_id;

	/* Set callback function */
	/* for rcvd prli acc/rjt processer */
	xchg->pfn_callback = unf_prli_callback;
	/* for send prli failed processer */
	xchg->pfn_ob_callback = unf_prli_ob_callback;

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill PRLI payload */
	prli_pal = &fc_entry->prli.payload;
	memset(prli_pal, 0, sizeof(struct unf_pril_payload_s));
	unf_fill_prli_pld(prli_pal, v_lport);

	/* Start to Send RPLI ELS CMND */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: PRLI send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_prlo_pld(struct unf_pril_payload_s *v_prlo_pld,
			      struct unf_lport_s *v_lport)
{
	UNF_CHECK_VALID(0x3348, UNF_TRUE, v_prlo_pld, return);
	UNF_CHECK_VALID(0x3349, UNF_TRUE, v_lport, return);

	v_prlo_pld->cmnd = (UNF_ELS_CMND_PRLO);
	v_prlo_pld->parms[0] = (UNF_FC4_FRAME_PARM_0_FCP);
	v_prlo_pld->parms[1] = UNF_NOT_MEANINGFUL;
	v_prlo_pld->parms[2] = UNF_NOT_MEANINGFUL;
	v_prlo_pld->parms[3] = UNF_NO_SERVICE_PARAMS;

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, v_prlo_pld,
			    sizeof(struct unf_pril_payload_s));
}

unsigned int unf_send_prlo(struct unf_lport_s *v_lport,
			   struct unf_rport_s *v_rport)
{
	struct unf_pril_payload_s *prlo_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3350, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3351, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	/* Get free exchange for PRLO */
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for PRLO",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_PRLO;  /* PRLO */

	ox_id = xchg->ox_id;

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill PRLO entry(payload) */
	prlo_pld = &fc_entry->prlo.payload;
	memset(prlo_pld, 0, sizeof(struct unf_pril_payload_s));
	unf_fill_prlo_pld(prlo_pld, v_lport);

	/* Start to send PRLO command */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: PRLO send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_rrq_pld(struct unf_rrq_s *v_rrq_pld,
			     struct unf_xchg_s *v_xchg)
{
	UNF_CHECK_VALID(0x3360, UNF_TRUE, v_rrq_pld, return);
	UNF_CHECK_VALID(0x3361, UNF_TRUE, v_xchg, return);

	v_rrq_pld->cmnd = UNF_ELS_CMND_RRQ;
	v_rrq_pld->sid = v_xchg->sid;
	v_rrq_pld->oxid_rxid = ((unsigned int)v_xchg->ox_id << 16 |
				  v_xchg->rx_id);
}

static void unf_rrq_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	/* Release I/O */
	struct unf_lport_s *lport = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_els_acc_s *els_acc = NULL;
	unsigned int cmnd = 0;
	struct unf_xchg_s *io_xchg = NULL;

	UNF_CHECK_VALID(0x3696, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3697, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3698, UNF_TRUE, v_xchg, return);
	UNF_REFERNCE_VAR(v_rport);

	lport = (struct unf_lport_s *)v_lport;
	UNF_REFERNCE_VAR(lport);
	xchg = (struct unf_xchg_s *)v_xchg;

	if (!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr) {
		UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
			  "[warn]Port(0x%x) exchange(0x%p) SfsEntryPtr is NULL",
			  lport->port_id, xchg);
		return;
	}

	io_xchg = (struct unf_xchg_s *)xchg->io_xchg;
	if (!io_xchg) {
		UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
			  "[warn]Port(0x%x) IO exchange is NULL. RRQ cb sfs xchg(0x%p) tag(0x%x)",
			  lport->port_id, xchg, xchg->hot_pool_tag);
		return;
	}

	UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
		  "[info]Port(0x%x) release IO exch(0x%p) tag(0x%x). RRQ cb sfs xchg(0x%p) tag(0x%x)",
		  lport->port_id, xchg->io_xchg, io_xchg->hot_pool_tag,
		  xchg, xchg->hot_pool_tag);

	/* NOTE: release I/O exchange resource */
	unf_xchg_ref_dec(io_xchg, XCHG_ALLOC);

	els_acc = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->els_acc;
	if (xchg->byte_orders & UNF_BIT_2)
		cmnd = be32_to_cpu(els_acc->cmnd);
	else
		cmnd = (els_acc->cmnd);
}

static void unf_rrq_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Release I/O */
	struct unf_xchg_s *xchg = NULL;
	struct unf_xchg_s *io_xchg = NULL;

	xchg = (struct unf_xchg_s *)v_xchg;
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Exchange can't be NULL");
		return;
	}

	io_xchg = (struct unf_xchg_s *)xchg->io_xchg;
	if (!io_xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]IO exchange can't be NULL with Sfs exch(0x%p) tag(0x%x)",
			  xchg, xchg->hot_pool_tag);
		return;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_KEVENT,
		  "[info]send RRQ failed: SFS exch(0x%p) tag(0x%x) exch(0x%p) tag(0x%x) OXID_RXID(0x%x_0x%x) SID_DID(0x%x_0x%x)",
		  xchg, xchg->hot_pool_tag, io_xchg, io_xchg->hot_pool_tag,
		  io_xchg->ox_id, io_xchg->rx_id, io_xchg->sid,
		  io_xchg->did);

	/* NOTE: Free I/O exchange resource */
	unf_xchg_ref_dec(io_xchg, XCHG_ALLOC);
}

unsigned int unf_send_rrq(struct unf_lport_s *v_lport,
			  struct unf_rport_s *v_rport,
			  struct unf_xchg_s *v_xchg)
{
	/* after ABTS Done */
	struct unf_rrq_s *rrq_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3362, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3363, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3364, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	if (v_xchg->rport_bind_jifs != v_rport->rport_alloc_jifs ||
	    (v_rport->nport_id == INVALID_VALUE32))
		return ret;
	/* Get & Set New free Exchange for RRQ */
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for RRQ",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = ELS_RRQ;  // RRQ

	/* Set callback function */
	xchg->pfn_callback = unf_rrq_callback; // release I/O exchange context
	/* release I/O exchange context */
	xchg->pfn_ob_callback = unf_rrq_ob_callback;
	xchg->io_xchg = v_xchg;  // pointer to IO XCHG

	ox_id = xchg->ox_id;

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill RRQ entry(payload) */
	rrq_pld = &fc_entry->rrq;
	memset(rrq_pld, 0, sizeof(struct unf_rrq_s));
	unf_fill_rrq_pld(rrq_pld, v_xchg);

	/* Start to send RRQ command to remote port */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]RRQ send %s. Port(0x%x)--->rport(0x%x) free old exchange(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id,
		  v_xchg->hot_pool_tag, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_gff_id_pld(struct unf_gffid_s *v_gff_id,
				unsigned int v_nport_id)
{
	UNF_CHECK_VALID(0x3365, UNF_TRUE, v_gff_id, return);

	v_gff_id->ctiu_pream.rev_inid = (UNF_REV_NPORTID_INIT);
	v_gff_id->ctiu_pream.gstype_gssub_options = (UNF_FSTYPE_OPT_INIT);
	v_gff_id->ctiu_pream.cmnd_rsp_size = (UNF_FSTYPE_GFF_ID);
	v_gff_id->ctiu_pream.frag_reason_exp_vend = UNF_FRAG_REASON_VENDOR;
	v_gff_id->nport_id = v_nport_id;
}

static void unf_gff_id_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Send PLOGI */
	struct unf_lport_s *lport = NULL;
	struct unf_lport_s *root_lport = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned long flag = 0;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int nport_id = 0;

	UNF_CHECK_VALID(0x3611, UNF_TRUE, v_xchg, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	nport_id = v_xchg->disc_port_id;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);

	UNF_CHECK_VALID(0x3612, UNF_TRUE, NULL != lport, return);

	root_lport = (struct unf_lport_s *)lport->root_lport;
	atomic_inc(&root_lport->disc.disc_thread_info.disc_contrl_size);
	wake_up_process(root_lport->disc.disc_thread_info.data_thread);

	/* Get (safe) R_Port */
	rport = unf_get_rport_by_nport_id(lport, nport_id);
	rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_ONLY,
				   nport_id);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can't allocate new RPort(0x%x)",
			  lport->port_id, nport_id);
		return;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]Port(0x%x_0x%x) send GFF_ID(0x%x_0x%x) to RPort(0x%x_0x%x) abnormal",
		  lport->port_id, lport->nport_id, v_xchg->ox_id,
		  v_xchg->rx_id, rport->rport_index, rport->nport_id);

	/* Update R_Port state: PLOGI_WAIT */
	spin_lock_irqsave(&rport->rport_state_lock, flag);
	rport->nport_id = nport_id;
	unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	/* NOTE: Start to send PLOGI */
	ret = unf_send_plogi(lport, rport);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) send PLOGI failed, enter recovry",
			  lport->port_id);

		/* Do R_Port recovery */
		unf_rport_error_recovery(rport);
	}
}

static void unf_check_rport_need_delay_plogi(struct unf_lport_s *v_lport,
					     struct unf_rport_s *v_rport,
					     unsigned int v_port_feature)
{
	/*
	 * Called by:
	 * 1. Private loop
	 * 2. RCVD GFF_ID ACC
	 */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = v_rport;
	unsigned long flag = 0;
	unsigned int nport_id = 0;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3613, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3614, UNF_TRUE, v_rport, return);
	nport_id = rport->nport_id;

	/*
	 * Send GFF_ID means L_Port has INI attribute
	 **
	 * When to send PLOGI:
	 * 1. R_Port has TGT mode (COM or TGT), send PLOGI immediately
	 * 2. R_Port only with INI, send LOGO immediately
	 * 3. R_Port with unknown attribute, delay to send PLOGI
	 */
	if ((v_port_feature & UNF_PORT_MODE_TGT) ||
	    (lport->enhanced_features &
	    UNF_LPORT_ENHANCED_FEATURE_ENHANCED_GFF)) {
		/* R_Port has TGT mode: send PLOGI immediately */
		rport = unf_get_safe_rport(v_lport, rport,
					   UNF_RPORT_REUSE_ONLY, nport_id);
		UNF_CHECK_VALID(0x3615, UNF_TRUE, rport, return);

		/* Update R_Port state: PLOGI_WAIT */
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->nport_id = nport_id;
		unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		/* Start to send PLOGI */
		ret = unf_send_plogi(lport, rport);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]LOGIN: Port(0x%x_0x%x) send PLOGI to RPort(0x%x) failed",
				  lport->port_id, lport->nport_id, nport_id);

			unf_rport_error_recovery(rport);
		}
	} else if (v_port_feature == UNF_PORT_MODE_INI) {
		/* R_Port only with INI mode: can't send PLOGI --->>>
		 * LOGO/nothing
		 */
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		if (rport->rp_state == UNF_RPORT_ST_INIT) {
			spin_unlock_irqrestore(&rport->rport_state_lock, flag);

			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]LOGIN: Port(0x%x_0x%x) send LOGO to RPort(0x%x) which only with INI mode",
				  lport->port_id, lport->nport_id, nport_id);

			/* Enter Closing state */
			unf_rport_enter_logo(lport, rport);
		} else {
			spin_unlock_irqrestore(&rport->rport_state_lock, flag);
		}
	} else {
		/* Unknown R_Port attribute: Delay to send PLOGI */
		rport = unf_get_safe_rport(v_lport, rport,
					   UNF_RPORT_REUSE_ONLY,
					   nport_id);
		UNF_CHECK_VALID(0x3616, UNF_TRUE, rport, return);

		/* Update R_Port state: PLOGI_WAIT */
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->nport_id = nport_id;
		unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		unf_rport_delay_login(rport);
	}
}

static void unf_rcv_gff_id_acc(struct unf_lport_s *v_lport,
			       struct unf_gffid_rsp_s *v_gff_id_rsp_pld,
			       unsigned int v_nport_id)
{
	/* Delay to LOGIN */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;
	struct unf_gffid_rsp_s *gff_id_rsp_pld = v_gff_id_rsp_pld;
	unsigned int fc4feature = 0;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3617, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3618, UNF_TRUE, v_gff_id_rsp_pld, return);

	fc4feature = gff_id_rsp_pld->fc_4_feature[1];
	if ((UNF_GFF_ACC_MASK & fc4feature) == 0)
		fc4feature = be32_to_cpu(gff_id_rsp_pld->fc_4_feature[1]);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Port(0x%x_0x%x) RPort(0x%x) received GFF_ID ACC. FC4 feature is 0x%x(1:TGT,2:INI,3:COM)",
		  lport->port_id, lport->nport_id, v_nport_id, fc4feature);

	/* Check (& Get new) R_Port */
	rport = unf_get_rport_by_nport_id(lport, v_nport_id);
	if (rport)
		rport = unf_find_rport(lport, v_nport_id, rport->port_name);

	if ((rport) ||
	    (UNF_GET_PORT_OPTIONS(fc4feature) != UNF_PORT_MODE_INI)) {
		rport = unf_get_safe_rport(lport, rport,
					   UNF_RPORT_REUSE_ONLY,
					   v_nport_id);
		UNF_CHECK_VALID(0x3619, UNF_TRUE, NULL != rport, return);
	} else {
		return;
	}

	if ((fc4feature & UNF_GFF_ACC_MASK) != 0) {
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->options = UNF_GET_PORT_OPTIONS(fc4feature);
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);
	} else if (rport->port_name != INVALID_WWPN) {
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->options = unf_get_port_feature(rport->port_name);
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);
	}

	/* NOTE: Send PLOGI if necessary */
	unf_check_rport_need_delay_plogi(lport, rport, rport->options);
}

static void unf_rcv_gff_id_rjt(struct unf_lport_s *v_lport,
			       struct unf_gffid_rsp_s *v_gff_id_rsp_pld,
			       unsigned int v_nport_id)
{
	/* Delay LOGIN or LOGO */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;
	struct unf_gffid_rsp_s *gff_id_rsp_pld = v_gff_id_rsp_pld;
	unsigned int rjt_reason = 0;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3620, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3621, UNF_TRUE, v_gff_id_rsp_pld, return);

	/* Check (& Get new) R_Port */
	rport = unf_get_rport_by_nport_id(lport, v_nport_id);
	if (rport)
		rport = unf_find_rport(lport, v_nport_id, rport->port_name);

	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x) get RPort by N_Port_ID(0x%x) failed and alloc new",
			  lport->port_id, v_nport_id);

		rport = unf_rport_get_free_and_init(lport, UNF_PORT_TYPE_FC,
						    v_nport_id);
		UNF_CHECK_VALID(0x3622, UNF_TRUE, NULL != rport, return);

		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->nport_id = v_nport_id;
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);
	}

	rjt_reason = gff_id_rsp_pld->ctiu_pream.frag_reason_exp_vend;

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x) send GFF_ID for RPort(0x%x) but was rejected. Reason code(0x%x)",
		  lport->port_id, v_nport_id, rjt_reason);

	if (!UNF_GNN_GFF_ID_RJT_REASON(rjt_reason)) {
		rport = unf_get_safe_rport(v_lport, rport,
					   UNF_RPORT_REUSE_ONLY,
					   v_nport_id);
		UNF_CHECK_VALID(0x3623, UNF_TRUE, NULL != rport, return);

		/* Update R_Port state: PLOGI_WAIT */
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->nport_id = v_nport_id;
		unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		/* Delay to send PLOGI */
		unf_rport_delay_login(rport);
	} else {
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		if (rport->rp_state == UNF_RPORT_ST_INIT) {
			spin_unlock_irqrestore(&rport->rport_state_lock, flag);

			/* Enter closing state */
			unf_rport_enter_logo(lport, rport);
		} else {
			spin_unlock_irqrestore(&rport->rport_state_lock, flag);
		}
	}
}

static void unf_gff_id_callback(void *v_lport, void *v_sns_port, void *v_xchg)
{
	struct unf_lport_s *lport = (struct unf_lport_s *)v_lport;
	struct unf_lport_s *root_lport = NULL;
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_xchg;
	struct unf_gffid_rsp_s *gff_id_rsp_pld = NULL;
	unsigned int cmnd_rsp_size = 0;
	unsigned int nport_id = 0;

	UNF_CHECK_VALID(0x3626, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3627, UNF_TRUE, v_sns_port, return);
	UNF_CHECK_VALID(0x3628, UNF_TRUE, v_xchg, return);

	UNF_REFERNCE_VAR(v_sns_port);
	nport_id = xchg->disc_port_id;

	gff_id_rsp_pld =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->gff_id_rsp;
	cmnd_rsp_size = (gff_id_rsp_pld->ctiu_pream.cmnd_rsp_size);

	root_lport = (struct unf_lport_s *)lport->root_lport;
	atomic_inc(&root_lport->disc.disc_thread_info.disc_contrl_size);
	wake_up_process(root_lport->disc.disc_thread_info.data_thread);

	if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_ACCEPT) {
		/* Case for GFF_ID ACC: (Delay)PLOGI */
		unf_rcv_gff_id_acc(lport, gff_id_rsp_pld, nport_id);
	} else if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_REJECT) {
		/* Case for GFF_ID RJT: Delay PLOGI or LOGO directly */
		unf_rcv_gff_id_rjt(lport, gff_id_rsp_pld, nport_id);
	} else {
		/* Send PLOGI */
		unf_rcv_gff_id_rsp_unknown(lport, nport_id);
	}
}

unsigned int unf_send_gff_id(struct unf_lport_s *v_lport,
			     struct unf_rport_s *v_sns_port,
			     unsigned int v_nport_id)
{
	struct unf_gffid_s *gff_id = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	struct unf_frame_pkg_s pkg;
	struct unf_lport_s *root_lport = NULL;

	UNF_CHECK_VALID(0x3367, UNF_TRUE, v_sns_port, return UNF_RETURN_ERROR);

	if (unf_is_lport_valid(v_lport) != RETURN_OK)
		/* Lport is invalid, no retry or handle required, return ok */
		return RETURN_OK;

	root_lport = (struct unf_lport_s *)v_lport->root_lport;
	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_sns_port->nport_id,
					      v_sns_port, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for GFF_ID",
			  v_lport->port_id);

		return unf_get_and_post_disc_event(v_lport, v_sns_port,
						   v_nport_id,
						   UNF_DISC_GET_FEATURE);
	}

	xchg->cmnd_code = NS_GFF_ID;  /* GFF_ID */

	xchg->disc_port_id = v_nport_id;

	/* Set callback function */
	xchg->pfn_ob_callback = unf_gff_id_ob_callback;  /* send PLOGI */
	xchg->pfn_callback = unf_gff_id_callback; /* send PLOGI or LOGO */

	ox_id = xchg->ox_id;

	unf_fill_package(&pkg, xchg, v_sns_port);

	/* Fill GFF_ID payload(entry) */
	gff_id = &fc_entry->gff_id; /* GFF_ID */
	memset(gff_id, 0, sizeof(struct unf_gffid_s));
	unf_fill_gff_id_pld(gff_id, v_nport_id);

	/* Send GFF_ID GS command now */
	ret = unf_gs_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	else
		atomic_dec(
			&root_lport->disc.disc_thread_info.disc_contrl_size);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: GFF_ID send %s. Port(0x%x)--->rport(0x%x). Inquire RPort(0x%x) OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_sns_port->nport_id,
		  v_nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_gnn_id_pld(struct unf_gnnid_s *v_gnn_id_pld,
				unsigned int v_nport_id)
{
	/* Inquiry R_Port node name from SW */
	UNF_CHECK_VALID(0x3368, UNF_TRUE, v_gnn_id_pld, return);

	v_gnn_id_pld->ctiu_pream.rev_inid = UNF_REV_NPORTID_INIT;
	v_gnn_id_pld->ctiu_pream.gstype_gssub_options = UNF_FSTYPE_OPT_INIT;
	v_gnn_id_pld->ctiu_pream.cmnd_rsp_size = UNF_FSTYPE_GNN_ID;
	v_gnn_id_pld->ctiu_pream.frag_reason_exp_vend = UNF_FRAG_REASON_VENDOR;

	v_gnn_id_pld->nport_id = v_nport_id;
}

/*
 * Function Name       : unf_gnn_id_ob_callback
 * Function Description: Callback for sending GNN_ID abnormal
 * Input Parameters    : struct unf_xchg_s *v_xchg
 * Output Parameters   : N/A
 * Return Type         : void
 */
static void unf_gnn_id_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Send GFF_ID */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *sns_port = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int nport_id = 0;
	struct unf_lport_s *root_lport = NULL;

	UNF_CHECK_VALID(0x3597, UNF_TRUE, v_xchg, return);
	lport = v_xchg->lport;
	UNF_CHECK_VALID(0x3598, UNF_TRUE, lport, return);
	sns_port = v_xchg->rport;
	UNF_CHECK_VALID(0x3599, UNF_TRUE, sns_port, return);
	nport_id = v_xchg->disc_port_id;

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x) send GNN_ID failed to inquire RPort(0x%x)",
		  lport->port_id, nport_id);

	root_lport = (struct unf_lport_s *)lport->root_lport;
	atomic_inc(&root_lport->disc.disc_thread_info.disc_contrl_size);
	wake_up_process(root_lport->disc.disc_thread_info.data_thread);

	/* NOTE: continue next stage */
	ret = unf_get_and_post_disc_event(lport, sns_port, nport_id,
					  UNF_DISC_GET_FEATURE);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) add discovery event(0x%x) failed Rport(0x%x)",
			  lport->port_id, UNF_DISC_GET_FEATURE, nport_id);

		unf_rcv_gff_id_rsp_unknown(lport, nport_id);  // send PLOGI
	}
}

static void unf_rcv_gnn_id_acc(struct unf_lport_s *v_lport,
			       struct unf_rport_s *v_sns_port,
			       struct unf_gnnid_rsp_s *v_gnn_id_rsp_pld,
			       unsigned int v_nport_id)
{
	/* Send GFF_ID or Link down immediately */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *sns_port = v_sns_port;
	struct unf_gnnid_rsp_s *gnn_id_rsp_pld = v_gnn_id_rsp_pld;
	struct unf_rport_s *rport = NULL;
	unsigned long long node_name = 0;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3600, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3601, UNF_TRUE, v_sns_port, return);
	UNF_CHECK_VALID(0x3602, UNF_TRUE, v_gnn_id_rsp_pld, return);

	node_name = ((unsigned long long)(gnn_id_rsp_pld->node_name[0]) <<
		     32) |
		     ((unsigned long long)(gnn_id_rsp_pld->node_name[1]));

	if (node_name == lport->node_name) {
		/* R_Port & L_Port with same Node Name */
		rport = unf_get_rport_by_nport_id(lport, v_nport_id);
		if (rport) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_KEVENT,
				  "[info]Port(0x%x) has the same node name(0x%llx) with RPort(0x%x), linkdown it",
				  lport->port_id, node_name, v_nport_id);

			/* Destroy immediately */
			unf_rport_immediate_linkdown(lport, rport);
		}
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]LOGIN: Port(0x%x) got RPort(0x%x) with node name(0x%llx) by GNN_ID",
			  lport->port_id, v_nport_id, node_name);

		/* Start to Send GFF_ID */
		ret = unf_get_and_post_disc_event(lport, sns_port, v_nport_id,
						  UNF_DISC_GET_FEATURE);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT,
				  UNF_ERR,
				  "[err]Port(0x%x) add discovery event(0x%x) failed Rport(0x%x)",
				  lport->port_id, UNF_DISC_GET_FEATURE,
				  v_nport_id);

			unf_rcv_gff_id_rsp_unknown(lport, v_nport_id);
		}
	}
}

static void unf_rcv_gnn_id_rjt(struct unf_lport_s *v_lport,
			       struct unf_rport_s *v_sns_port,
			       struct unf_gnnid_rsp_s *v_gnn_id_rsp_pld,
			       unsigned int v_nport_id)
{
	/* Send GFF_ID */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *sns_port = v_sns_port;
	struct unf_gnnid_rsp_s *gnn_id_rsp_pld = v_gnn_id_rsp_pld;
	unsigned int rjt_reason = 0;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3603, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3604, UNF_TRUE, v_sns_port, return);
	UNF_CHECK_VALID(0x3605, UNF_TRUE, v_gnn_id_rsp_pld, return);

	rjt_reason = (gnn_id_rsp_pld->ctiu_pream.frag_reason_exp_vend);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x_0x%x) GNN_ID was rejected with reason code(0x%x)",
		  lport->port_id, lport->nport_id, rjt_reason);

	if (!UNF_GNN_GFF_ID_RJT_REASON(rjt_reason)) {
		/* Node existence: Continue next stage */
		ret = unf_get_and_post_disc_event(lport, sns_port, v_nport_id,
						  UNF_DISC_GET_FEATURE);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT,
				  UNF_ERR,
				  "[err]Port(0x%x) add discovery event(0x%x) failed Rport(0x%x)",
				  lport->port_id, UNF_DISC_GET_FEATURE,
				  v_nport_id);

			unf_rcv_gff_id_rsp_unknown(lport, v_nport_id);
		}
	}
}

static void unf_gnn_id_callback(void *v_lport, void *v_sns_port, void *v_xchg)
{
	struct unf_lport_s *lport = (struct unf_lport_s *)v_lport;
	struct unf_rport_s *sns_port = (struct unf_rport_s *)v_sns_port;
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_xchg;
	struct unf_gnnid_rsp_s *gnn_id_rsp_pld = NULL;
	unsigned int cmnd_rsp_size = 0;
	unsigned int nport_id = 0;
	struct unf_lport_s *root_lport = NULL;

	UNF_CHECK_VALID(0x3608, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3609, UNF_TRUE, v_sns_port, return);
	UNF_CHECK_VALID(0x3610, UNF_TRUE, v_xchg, return);

	nport_id = xchg->disc_port_id;
	gnn_id_rsp_pld =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->gnn_id_rsp;
	cmnd_rsp_size = (gnn_id_rsp_pld->ctiu_pream.cmnd_rsp_size);

	root_lport = (struct unf_lport_s *)lport->root_lport;
	atomic_inc(&root_lport->disc.disc_thread_info.disc_contrl_size);
	wake_up_process(root_lport->disc.disc_thread_info.data_thread);

	if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_ACCEPT) {
		/* Case ACC: send GFF_ID or Link down immediately */
		unf_rcv_gnn_id_acc(lport, sns_port, gnn_id_rsp_pld, nport_id);
	} else if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_REJECT) {
		/* Case RJT: send GFF_ID */
		unf_rcv_gnn_id_rjt(lport, sns_port, gnn_id_rsp_pld, nport_id);
	} else { /* NOTE: continue next stage */
		/* Case unknown: send GFF_ID */
		unf_rcv_gnn_id_rsp_unknown(lport, sns_port, nport_id);
	}
}

unsigned int unf_send_gnn_id(struct unf_lport_s *v_lport,
			     struct unf_rport_s *v_sns_port,
			     unsigned int v_nport_id)
{
	/* from DISC stop/re-login */
	struct unf_gnnid_s *gnn_id_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	struct unf_frame_pkg_s pkg;
	struct unf_lport_s *root_lport = NULL;

	UNF_CHECK_VALID(0x3370, UNF_TRUE, v_sns_port, return UNF_RETURN_ERROR);

	if (unf_is_lport_valid(v_lport) != RETURN_OK)
		/* Lport is invalid, no retry or handle required, return ok */
		return RETURN_OK;

	root_lport = (struct unf_lport_s *)v_lport->root_lport;

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));
	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_sns_port->nport_id,
					      v_sns_port, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) exchange can't be NULL for GNN_ID",
			  v_lport->port_id);

		return unf_get_and_post_disc_event(v_lport, v_sns_port,
						   v_nport_id,
						   UNF_DISC_GET_NODE_NAME);
	}

	xchg->cmnd_code = NS_GNN_ID;  /* GNN_ID */
	xchg->disc_port_id = v_nport_id;

	ox_id = xchg->ox_id;

	/* Set callback function */
	xchg->pfn_ob_callback = unf_gnn_id_ob_callback;  /* send GFF_ID */
	xchg->pfn_callback = unf_gnn_id_callback; /* send GFF_ID */

	unf_fill_package(&pkg, xchg, v_sns_port);

	/* Fill GNN_ID entry(payload) */
	gnn_id_pld = &fc_entry->gnn_id; /* GNNID payload */
	memset(gnn_id_pld, 0, sizeof(struct unf_gnnid_s));
	unf_fill_gnn_id_pld(gnn_id_pld, v_nport_id);

	/* Start to send GNN_ID GS command */
	ret = unf_gs_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	else
		atomic_dec(
			&root_lport->disc.disc_thread_info.disc_contrl_size);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: GNN_ID send %s. Port(0x%x_0x%x)--->rport(0x%x) inquire Nportid(0x%x) OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed", v_lport->port_id,
		  v_lport->nport_id, v_sns_port->nport_id,
		  v_nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_gpn_id_pld(struct unf_gpnid_s *v_gpn_id_pld,
				unsigned int v_nport_id)
{
	UNF_CHECK_VALID(0x3371, UNF_TRUE, v_gpn_id_pld, return);

	v_gpn_id_pld->ctiu_pream.rev_inid = UNF_REV_NPORTID_INIT;
	v_gpn_id_pld->ctiu_pream.gstype_gssub_options = UNF_FSTYPE_OPT_INIT;
	v_gpn_id_pld->ctiu_pream.cmnd_rsp_size = UNF_FSTYPE_GPN_ID;
	v_gpn_id_pld->ctiu_pream.frag_reason_exp_vend = UNF_FRAG_REASON_VENDOR;

	/* Inquiry WWN from SW */
	v_gpn_id_pld->nport_id = v_nport_id;
}

unsigned int unf_rport_relogin(struct unf_lport_s *v_lport,
			       unsigned int v_nport_id)
{
	/* Send GNN_ID */
	struct unf_rport_s *sns_port = NULL;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3563, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);

	/* Get SNS R_Port */
	sns_port = unf_get_rport_by_nport_id(v_lport, UNF_FC_FID_DIR_SERV);
	if (!sns_port) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can't find fabric Port",
			  v_lport->nport_id);

		return UNF_RETURN_ERROR;
	}

	/* Send GNN_ID now to SW */
	ret = unf_get_and_post_disc_event(v_lport, sns_port, v_nport_id,
					  UNF_DISC_GET_NODE_NAME);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) add discovery event(0x%x) failed Rport(0x%x)",
			  v_lport->nport_id, UNF_DISC_GET_NODE_NAME,
			  v_nport_id);

		/* NOTE: Continue to next stage */
		unf_rcv_gnn_id_rsp_unknown(v_lport, sns_port, v_nport_id);
	}

	return ret;
}

static void unf_rcv_gpn_id_acc(struct unf_lport_s *v_lport,
			       unsigned int v_nport_id,
			       unsigned long long v_port_name)
{
	/* then PLOGI or re-login */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;
	unsigned long flag = 0;
	unsigned int ret = UNF_RETURN_ERROR;

	rport = unf_find_valid_rport(lport, v_port_name, v_nport_id);
	if (rport) {
		/* R_Port with TGT mode & L_Port with INI mode:
		 * send PLOGI with INIT state
		 */
		if ((rport->options & UNF_PORT_MODE_TGT) ==
		    UNF_PORT_MODE_TGT) {
			rport = unf_get_safe_rport(v_lport, rport,
						   UNF_RPORT_REUSE_INIT,
						   v_nport_id);
			UNF_CHECK_VALID(0x3630, UNF_TRUE, rport, return);

			/* Update R_Port state: PLOGI_WAIT */
			spin_lock_irqsave(&rport->rport_state_lock, flag);
			rport->nport_id = v_nport_id;
			unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
			spin_unlock_irqrestore(&rport->rport_state_lock, flag);

			/* Start to send PLOGI */
			ret = unf_send_plogi(lport, rport);
			if (ret != RETURN_OK) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
					  UNF_LOG_LOGIN_ATT, UNF_WARN,
					  "[warn]LOGIN: Port(0x%x_0x%x) send PLOGI failed for 0x%x, enter recovry",
					  lport->port_id, lport->nport_id,
					  v_nport_id);

				unf_rport_error_recovery(rport);
			}
		} else {
			spin_lock_irqsave(&rport->rport_state_lock, flag);
			if ((rport->rp_state != UNF_RPORT_ST_PLOGI_WAIT) &&
			    (rport->rp_state != UNF_RPORT_ST_PRLI_WAIT) &&
			    (rport->rp_state != UNF_RPORT_ST_READY)) {
				unf_rport_state_ma(rport,
						   UNF_EVENT_RPORT_LOGO);
				spin_unlock_irqrestore(
					&rport->rport_state_lock, flag);

				/* Do LOGO operation */
				unf_rport_enter_logo(lport, rport);
			} else {
				spin_unlock_irqrestore(
					&rport->rport_state_lock, flag);
			}
		}
	} else {
		/* Send GNN_ID */
		(void)unf_rport_relogin(lport, v_nport_id);
	}
}

static void unf_rcv_gpn_id_rjt(struct unf_lport_s *v_lport,
			       unsigned int v_nport_id)
{
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;

	UNF_CHECK_VALID(0x3631, UNF_TRUE, v_lport, return);

	rport = unf_get_rport_by_nport_id(lport, v_nport_id);
	if (rport)
		unf_rport_linkdown(lport, rport); /* Do R_Port Link down */
}

/*
 * Function Name       : unf_rcv_gpn_id_rsp_unknown
 * Function Description: Process unknown type of GPN_ID response
 * Input Parameters    : struct unf_lport_s *v_lport
 *                     : unsigned int v_nport_id
 * Output Parameters   : N/A
 * Return Type         : void
 */
void unf_rcv_gpn_id_rsp_unknown(struct unf_lport_s *v_lport,
				unsigned int v_nport_id)
{
	struct unf_lport_s *lport = v_lport;

	UNF_CHECK_VALID(0x3632, UNF_TRUE, v_lport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x) wrong response of GPN_ID with RPort(0x%x)",
		  lport->port_id, v_nport_id);

	/* NOTE: go to next stage */
	(void)unf_rport_relogin(lport, v_nport_id);
}

static void unf_gpn_id_callback(void *v_lport, void *v_sns_port, void *v_xchg)
{
	struct unf_lport_s *lport = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_gpnid_rsp_s *gpn_id_rsp_pld = NULL;
	unsigned long long port_name = 0;
	unsigned int cmnd_rsp_size = 0;
	unsigned int nport_id = 0;
	struct unf_lport_s *root_lport = NULL;

	UNF_CHECK_VALID(0x3635, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3636, UNF_TRUE, v_sns_port, return);
	UNF_CHECK_VALID(0x3637, UNF_TRUE, v_xchg, return);

	UNF_REFERNCE_VAR(v_sns_port);

	lport = (struct unf_lport_s *)v_lport;
	xchg = (struct unf_xchg_s *)v_xchg;
	nport_id = xchg->disc_port_id;

	root_lport = (struct unf_lport_s *)lport->root_lport;
	atomic_inc(&root_lport->disc.disc_thread_info.disc_contrl_size);
	wake_up_process(root_lport->disc.disc_thread_info.data_thread);

	gpn_id_rsp_pld =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->gpn_id_rsp;
	cmnd_rsp_size = gpn_id_rsp_pld->ctiu_pream.cmnd_rsp_size;
	if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_ACCEPT) {
		/* GPN_ID ACC */
		port_name = ((unsigned long long)
				(gpn_id_rsp_pld->port_name[0]) << 32) |
			    ((unsigned long long)
				(gpn_id_rsp_pld->port_name[1]));

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]LOGIN: Port(0x%x) GPN_ID ACC with WWN(0x%llx) RPort NPort ID(0x%x)",
			  lport->port_id, port_name, nport_id);

		/* Send PLOGI or LOGO or GNN_ID */
		unf_rcv_gpn_id_acc(lport, nport_id, port_name);
	} else if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) ==
		   UNF_CT_IU_REJECT) {
		/* GPN_ID RJT: Link Down */
		unf_rcv_gpn_id_rjt(lport, nport_id);
	} else {
		/* GPN_ID response type unknown: Send GNN_ID */
		unf_rcv_gpn_id_rsp_unknown(lport, nport_id);
	}
}

static void unf_gpn_id_ob_callback(struct unf_xchg_s *v_xchg)
{
	struct unf_lport_s *lport = NULL;
	unsigned int nport_id = 0;
	struct unf_lport_s *root_lport = NULL;

	UNF_CHECK_VALID(0x3633, UNF_TRUE, v_xchg, return);

	lport = v_xchg->lport;
	nport_id = v_xchg->disc_port_id;
	UNF_CHECK_VALID(0x3634, UNF_TRUE, lport, return);

	root_lport = (struct unf_lport_s *)lport->root_lport;
	atomic_inc(&root_lport->disc.disc_thread_info.disc_contrl_size);
	wake_up_process(root_lport->disc.disc_thread_info.data_thread);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x) send GPN_ID failed to inquire RPort(0x%x)",
		  lport->port_id, nport_id);

	/* NOTE: go to next stage */
	(void)unf_rport_relogin(lport, nport_id);
}

unsigned int unf_send_gpn_id(struct unf_lport_s *v_lport,
			     struct unf_rport_s *v_sns_port,
			     unsigned int v_nport_id)
{
	struct unf_gpnid_s *gpn_id_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	struct unf_frame_pkg_s pkg;
	struct unf_lport_s *root_lport = NULL;

	UNF_CHECK_VALID(0x3374, UNF_TRUE, v_sns_port, return UNF_RETURN_ERROR);

	if (unf_is_lport_valid(v_lport) != RETURN_OK) {
		/* Lport is invalid, no retry or handle required, return ok */
		return RETURN_OK;
	}
	root_lport = (struct unf_lport_s *)v_lport->root_lport;

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_sns_port->nport_id,
					      v_sns_port, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for GPN_ID",
			  v_lport->port_id);

		return unf_get_and_post_disc_event(v_lport, v_sns_port,
						   v_nport_id,
						   UNF_DISC_GET_PORT_NAME);
	}

	xchg->cmnd_code = NS_GPN_ID;  // GPN_ID
	xchg->disc_port_id = v_nport_id;

	ox_id = xchg->ox_id;

	/* Set callback function */
	xchg->pfn_callback = unf_gpn_id_callback;
	/* re-login --->>> GNN_ID */
	xchg->pfn_ob_callback = unf_gpn_id_ob_callback;

	unf_fill_package(&pkg, xchg, v_sns_port);

	/* Fill GPN_ID entry(payload) */
	gpn_id_pld = &fc_entry->gpn_id; /* GPN_ID payload */
	memset(gpn_id_pld, 0, sizeof(struct unf_gpnid_s));
	unf_fill_gpn_id_pld(gpn_id_pld, v_nport_id);

	/* Send GPN_ID GS command */
	ret = unf_gs_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	else
		atomic_dec(
			&root_lport->disc.disc_thread_info.disc_contrl_size);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: GPN_ID send %s. Port(0x%x)--->rport(0x%x). Inquire RPort(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed", v_lport->port_id,
		  v_sns_port->nport_id, v_nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_gid_ft_pld(struct unf_gid_s *v_gid_pld)
{
	UNF_CHECK_VALID(0x3376, UNF_TRUE, v_gid_pld, return);

	v_gid_pld->ctiu_pream.rev_inid = UNF_REV_NPORTID_INIT;
	v_gid_pld->ctiu_pream.gstype_gssub_options = UNF_FSTYPE_OPT_INIT;
	v_gid_pld->ctiu_pream.cmnd_rsp_size = UNF_FSTYPE_GID_FT;
	v_gid_pld->ctiu_pream.frag_reason_exp_vend = UNF_FRAG_REASON_VENDOR;

	v_gid_pld->scope_type = UNF_GID_FT_TYPE;
}

static void unf_gid_ft_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Do recovery */
	struct unf_lport_s *lport = NULL;
	union unf_sfs_u *sfs_ptr = NULL;
	struct unf_disc_s *disc = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3589, UNF_TRUE, v_xchg, return);

	sfs_ptr = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!sfs_ptr)
		return;

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
	if (!lport)
		return;

	disc = &lport->disc;
	spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
	unf_disc_state_ma(lport, UNF_EVENT_DISC_FAILED);
	spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

	/* Do DISC recovery operation */
	unf_disc_error_recovery(lport);
}

unsigned int unf_send_gid_ft(struct unf_lport_s *v_lport,
			     struct unf_rport_s *v_rport)
{
	struct unf_gid_s *gid_pld = NULL;
	struct unf_gid_rsp_s *gid_rsp = NULL;
	struct unf_gif_acc_pld_s *gid_acc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3377, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3378, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for GID_FT",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = NS_GID_FT;  // GID_FT

	ox_id = xchg->ox_id;

	/* Set callback function */
	xchg->pfn_ob_callback = unf_gid_ft_ob_callback;  // do DISC recovery
	xchg->pfn_callback = unf_gid_ft_callback;

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill GID_FT entry(payload) */
	gid_pld = &fc_entry->get_id.gid_req; /* GID req payload */
	unf_fill_gid_ft_pld(gid_pld);
	gid_rsp = &fc_entry->get_id.gid_rsp; /* GID rsp payload */

	/* Get GID_FT Response payload */
	gid_acc_pld = (struct unf_gif_acc_pld_s *)unf_get_one_big_sfs_buf(xchg);
	if (!gid_acc_pld) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) allocate GID_FT response buffer failed",
			  v_lport->port_id);

		unf_cm_free_xchg(v_lport, xchg);
		return UNF_RETURN_ERROR;
	}
	memset(gid_acc_pld, 0, sizeof(struct unf_gif_acc_pld_s));
	gid_rsp->gid_acc_pld = gid_acc_pld;

	/* Send GID_FT GS commmand now */
	ret = unf_gs_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: GID_FT send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_gid_pt_pld(struct unf_gid_s *v_gid_pld,
				struct unf_lport_s *v_lport)
{
	UNF_CHECK_VALID(0x3379, UNF_TRUE, v_gid_pld, return);
	UNF_CHECK_VALID(0x3380, UNF_TRUE, v_lport, return);

	v_gid_pld->ctiu_pream.rev_inid = (UNF_REV_NPORTID_INIT);
	v_gid_pld->ctiu_pream.gstype_gssub_options = (UNF_FSTYPE_OPT_INIT);
	v_gid_pld->ctiu_pream.cmnd_rsp_size = (UNF_FSTYPE_GID_PT);
	v_gid_pld->ctiu_pream.frag_reason_exp_vend = UNF_FRAG_REASON_VENDOR;

	/* 0x7F000000 means NX_Port */
	v_gid_pld->scope_type = UNF_GID_PT_TYPE;
	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, v_gid_pld,
			    sizeof(struct unf_gid_s));
}

static void unf_gid_pt_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Do recovery */
	struct unf_lport_s *lport = NULL;
	union unf_sfs_u *sfs_ptr = NULL;
	struct unf_disc_s *disc = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3593, UNF_TRUE, v_xchg, return);

	sfs_ptr = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!sfs_ptr)
		return;

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);
	if (!lport)
		return;

	disc = &lport->disc;
	spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
	unf_disc_state_ma(lport, UNF_EVENT_DISC_FAILED);
	spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

	/* Do DISC recovery operation */
	unf_disc_error_recovery(lport);
}

unsigned int unf_send_gid_pt(struct unf_lport_s *v_lport,
			     struct unf_rport_s *v_rport)
{
	/* from DISC start */
	struct unf_gid_s *gid_pld = NULL;
	struct unf_gid_rsp_s *gid_rsp = NULL;
	struct unf_gif_acc_pld_s *gid_acc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3381, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3382, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for GID_PT",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = NS_GID_PT;  /* GID_PT */
	ox_id = xchg->ox_id;

	/* Set callback function */
	xchg->pfn_ob_callback = unf_gid_pt_ob_callback; /* do DISC recovery */
	xchg->pfn_callback = unf_gid_pt_callback;

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill GID_PT entry(payload) */
	gid_pld = &fc_entry->get_id.gid_req; /* GID req payload */
	unf_fill_gid_pt_pld(gid_pld, v_lport);
	gid_rsp = &fc_entry->get_id.gid_rsp; /* GID rsp payload */

	/* Get GID_PT response payload */
	gid_acc_pld = (struct unf_gif_acc_pld_s *)unf_get_one_big_sfs_buf(xchg);
	if (!gid_acc_pld) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%0x) Allocate GID_PT response buffer failed",
			  v_lport->port_id);

		unf_cm_free_xchg(v_lport, xchg);
		return UNF_RETURN_ERROR;
	}
	memset(gid_acc_pld, 0, sizeof(struct unf_gif_acc_pld_s));
	gid_rsp->gid_acc_pld = gid_acc_pld;

	/* Send GID_PT GS command to SW */
	ret = unf_gs_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: GID_PT send %s. Port(0x%x_0x%x)--->rport(0x%x) with OXID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_lport->nport_id,
		  v_rport->nport_id, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_rft_id_pld(struct unf_rftid_s *v_rft_id_pld,
				struct unf_lport_s *v_lport)
{
	unsigned int i = 1;

	UNF_CHECK_VALID(0x3383, UNF_TRUE, v_rft_id_pld, return);
	UNF_CHECK_VALID(0x3384, UNF_TRUE, v_lport, return);

	v_rft_id_pld->ctiu_pream.rev_inid = UNF_REV_NPORTID_INIT;
	v_rft_id_pld->ctiu_pream.gstype_gssub_options = UNF_FSTYPE_OPT_INIT;
	v_rft_id_pld->ctiu_pream.cmnd_rsp_size = UNF_FSTYPE_RFT_ID;
	v_rft_id_pld->ctiu_pream.frag_reason_exp_vend = UNF_FRAG_REASON_VENDOR;
	v_rft_id_pld->nport_id = (v_lport->nport_id);
	v_rft_id_pld->fc_4_types[0] = (UNF_FC4_SCSI_BIT8);

	for (i = 1; i < 8; i++)
		v_rft_id_pld->fc_4_types[i] = 0;
}

static void unf_rft_id_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Do recovery */
	struct unf_lport_s *lport = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3687, UNF_TRUE, v_xchg, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);

	UNF_CHECK_VALID(0x3688, UNF_TRUE, lport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x_0x%x) send RFT_ID failed",
		  lport->port_id, lport->nport_id);

	/* Do L_Port recovery operation */
	unf_lport_error_recovery(lport);
}

static void unf_rft_id_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	/* RFT_ID --->>> RFF_ID */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_ctiu_prem_s *ctiu_prem = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int cmnd_rsp_size = 0;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3689, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3690, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3691, UNF_TRUE, v_xchg, return);

	lport = (struct unf_lport_s *)v_lport;
	rport = (struct unf_rport_s *)v_rport;
	xchg = (struct unf_xchg_s *)v_xchg;

	if (!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) SFS entry is NULL with state(0x%x)",
			  lport->port_id, lport->en_states);
		return;
	}

	ctiu_prem = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->rft_id_rsp.ctiu_pream;
	cmnd_rsp_size = ctiu_prem->cmnd_rsp_size;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Port(0x%x_0x%x) RFT_ID response is (0x%x)",
		  (cmnd_rsp_size & UNF_CT_IU_RSP_MASK),
		  lport->port_id, lport->nport_id);

	if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_ACCEPT) {
		/* Case for RFT_ID ACC: send RFF_ID */
		spin_lock_irqsave(&lport->lport_state_lock, flag);
		if (lport->en_states != UNF_LPORT_ST_RFT_ID_WAIT) {
			spin_unlock_irqrestore(&lport->lport_state_lock, flag);

			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]Port(0x%x_0x%x) receive RFT_ID ACC in state(0x%x)",
				  lport->port_id, lport->nport_id,
				  lport->en_states);

			return;
		}

		/* LPort: RFT_ID_WAIT --> RFF_ID_WAIT */
		unf_lport_stat_ma(lport, UNF_EVENT_LPORT_REMOTE_ACC);
		spin_unlock_irqrestore(&lport->lport_state_lock, flag);

		/* Start to send RFF_ID GS command */
		ret = unf_send_rff_id(lport, rport);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]LOGIN: Port(0x%x_0x%x) send RFF_ID failed",
				  lport->port_id, lport->nport_id);

			/* Do L_Port recovery */
			unf_lport_error_recovery(lport);
		}
	} else {
		/* Case for RFT_ID RJT: do recovery */
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x) receive RFT_ID RJT with reason_code(0x%x) explanation(0x%x)",
			  lport->port_id, lport->nport_id,
			  (ctiu_prem->frag_reason_exp_vend) &
			  UNF_CT_IU_REASON_MASK,
			  (ctiu_prem->frag_reason_exp_vend) &
			  UNF_CT_IU_EXPLAN_MASK);

		/* Do L_Port recovery */
		unf_lport_error_recovery(lport);
	}
}

unsigned int unf_send_rft_id(struct unf_lport_s *v_lport,
			     struct unf_rport_s *v_rport)
{
	/* After PLOGI process */
	struct unf_rftid_s *rft_id = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3385, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3386, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for RFT_ID",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = NS_RFT_ID;  /* RFT_ID */

	ox_id = xchg->ox_id;

	/* Set callback function */
	xchg->pfn_callback = unf_rft_id_callback;
	xchg->pfn_ob_callback = unf_rft_id_ob_callback; /* Do L_Port recovery */

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill RFT_ID entry(payload) */
	rft_id = &fc_entry->rft_id;
	memset(rft_id, 0, sizeof(struct unf_rftid_s));
	unf_fill_rft_id_pld(rft_id, v_lport);

	/* Send RFT_ID GS command */
	ret = unf_gs_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: RFT_ID send %s. Port(0x%x_0x%x)--->rport(0x%x). rport(0x%p) wwpn(0x%llx) OX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_lport->nport_id, v_rport->nport_id,
		  v_rport, v_rport->port_name, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_fill_rff_id_pld(struct unf_rffid_s *v_rff_id_pld,
				struct unf_lport_s *v_lport)
{
	UNF_CHECK_VALID(0x3387, UNF_TRUE, v_rff_id_pld, return);
	UNF_CHECK_VALID(0x3388, UNF_TRUE, v_lport, return);

	v_rff_id_pld->ctiu_pream.rev_inid = UNF_REV_NPORTID_INIT;
	v_rff_id_pld->ctiu_pream.gstype_gssub_options = UNF_FSTYPE_OPT_INIT;
	v_rff_id_pld->ctiu_pream.cmnd_rsp_size = UNF_FSTYPE_RFF_ID;
	v_rff_id_pld->ctiu_pream.frag_reason_exp_vend = UNF_FRAG_REASON_VENDOR;
	v_rff_id_pld->nport_id = v_lport->nport_id;
	v_rff_id_pld->fc_4_feature = UNF_FC4_FCP_TYPE |
				     (v_lport->options << 4);
}

static void unf_rff_id_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	/* RFF_ID --->>> SCR(for INI mode) */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_ctiu_prem_s *ctiu_prem = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int cmnd_rsp_size = 0;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3684, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3685, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3686, UNF_TRUE, v_xchg, return);

	lport = (struct unf_lport_s *)v_lport;
	xchg = (struct unf_xchg_s *)v_xchg;
	if (unlikely(!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr))
		return;

	/* SCR send to 0xfffffd(not 0xfffffc), need to get new R_Port */
	UNF_REFERNCE_VAR(v_rport);
	rport = unf_get_rport_by_nport_id(lport, UNF_FC_FID_FCTRL); // 0xfffffd
	rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_ONLY,
				   UNF_FC_FID_FCTRL);
	if (unlikely(!rport)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) can't allocate RPort(0x%x)",
			  lport->port_id, UNF_FC_FID_FCTRL);
		return;
	}

	rport->nport_id = UNF_FC_FID_FCTRL;
	ctiu_prem =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->rff_id_rsp.ctiu_pream;
	cmnd_rsp_size = ctiu_prem->cmnd_rsp_size;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]LOGIN: Port(0x%x_0x%x) RFF_ID rsp is (0x%x)",
		  lport->port_id, lport->nport_id,
		  (cmnd_rsp_size & UNF_CT_IU_RSP_MASK));

	/* RSP Type check: some SW not support RFF_ID, go to next stage also */
	if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_ACCEPT) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]LOGIN: Port(0x%x_0x%x) receive RFF ACC(0x%x) in state(0x%x)",
			  lport->port_id, lport->nport_id,
			  (cmnd_rsp_size & UNF_CT_IU_RSP_MASK),
			  lport->en_states);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x) receive RFF RJT(0x%x) in state(0x%x) with RJT reason code(0x%x) explanation(0x%x)",
			  lport->port_id, lport->nport_id,
			  (cmnd_rsp_size & UNF_CT_IU_RSP_MASK),
			  lport->en_states,
			  (ctiu_prem->frag_reason_exp_vend) &
			  UNF_CT_IU_REASON_MASK,
			  (ctiu_prem->frag_reason_exp_vend) &
			  UNF_CT_IU_EXPLAN_MASK);
	}

	/* L_Port state check */
	spin_lock_irqsave(&lport->lport_state_lock, flag);
	if (lport->en_states != UNF_LPORT_ST_RFF_ID_WAIT) {
		spin_unlock_irqrestore(&lport->lport_state_lock, flag);
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x) receive RFF reply in state(0x%x)",
			  lport->port_id, lport->nport_id, lport->en_states);

		return;
	}

	/* Update L_Port state & Send SCR to remote port */
	/* LPort: RFF_ID_WAIT --> SCR_WAIT */
	unf_lport_stat_ma(lport, UNF_EVENT_LPORT_REMOTE_ACC);
	spin_unlock_irqrestore(&lport->lport_state_lock, flag);

	/* Start to send SCR command */
	ret = unf_send_scr(lport, rport);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x) send SCR failed",
			  lport->port_id, lport->nport_id);

		/* Do L_Port recovery */
		unf_lport_error_recovery(lport);
	}
}

static void unf_rff_id_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Do recovery */
	struct unf_lport_s *lport = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3682, UNF_TRUE, v_xchg, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flag);
	lport = v_xchg->lport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flag);

	UNF_CHECK_VALID(0x3683, UNF_TRUE, NULL != lport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x_0x%x) send RFF_ID failed",
		  lport->port_id, lport->nport_id);

	/* Do L_Port recovery */
	unf_lport_error_recovery(lport);
}

unsigned int unf_send_rff_id(struct unf_lport_s *v_lport,
			     struct unf_rport_s *v_rport)
{
	/* from RFT_ID, then Send SCR */
	struct unf_rffid_s *rff_id = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_CHECK_VALID(0x3389, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3390, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "%s Enter", __func__);

	xchg = unf_get_sfs_free_xchg_and_init(v_lport, v_rport->nport_id,
					      v_rport, &fc_entry);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for RFF_ID",
			  v_lport->port_id);

		return ret;
	}

	xchg->cmnd_code = NS_RFF_ID;  // RFF_ID

	ox_id = xchg->ox_id;

	/* Set callback function */
	xchg->pfn_callback = unf_rff_id_callback;
	xchg->pfn_ob_callback = unf_rff_id_ob_callback; /* Do L_Port recovery */

	unf_fill_package(&pkg, xchg, v_rport);

	/* Fill RFF_ID entry(payload) */
	rff_id = &fc_entry->rff_id;
	memset(rff_id, 0, sizeof(struct unf_rffid_s));
	unf_fill_rff_id_pld(rff_id, v_lport);

	/* Send RFF_ID GS command */
	ret = unf_gs_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: RFF_ID feature 0x%x(10:TGT,20:INI,30:COM) send %s. Port(0x%x_0x%x)--->pstRPortid(0x%x) rport(0x%p) OX_ID(0x%x)",
		  v_lport->options, (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_lport->nport_id,
		  v_rport->nport_id, v_rport, ox_id);

	UNF_REFERNCE_VAR(ox_id);
	return ret;
}

static void unf_login_with_rport_in_n2n(struct unf_lport_s *v_lport,
					unsigned long long v_remote_port_name,
					unsigned long long v_remote_nort_name)
{
	/*
	 * Call by (P2P):
	 * 1. RCVD FLOGI ACC
	 * 2. Send FLOGI ACC succeed
	 **
	 * Compare WWN, larger is master, then send PLOGI
	 */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;
	unsigned long lport_flag = 0;
	unsigned long rport_flag = 0;
	unsigned long long port_name = 0;
	unsigned long long node_name = 0;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3539, UNF_TRUE, v_lport, return);

	spin_lock_irqsave(&lport->lport_state_lock, lport_flag);
	/* LPort: FLOGI_WAIT --> READY */
	unf_lport_stat_ma(lport, UNF_EVENT_LPORT_READY);
	spin_unlock_irqrestore(&lport->lport_state_lock, lport_flag);

	port_name = v_remote_port_name;
	node_name = v_remote_nort_name;

	if (lport->port_name > port_name) {
		/* Master case: send PLOGI */
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x)'s WWN(0x%llx) is larger than rport(0x%llx), should be master",
			  lport->port_id, lport->port_name, port_name);

		/* Update N_Port_ID now: 0xEF */
		lport->nport_id = UNF_P2P_LOCAL_NPORT_ID;

		rport = unf_find_valid_rport(v_lport, port_name,
					     UNF_P2P_REMOTE_NPORT_ID);  // 0xD6
		rport = unf_get_safe_rport(v_lport, rport,
					   UNF_RPORT_REUSE_ONLY,
					   UNF_P2P_REMOTE_NPORT_ID);
		if (rport) {
			rport->node_name = node_name;
			rport->port_name = port_name;
			rport->nport_id = UNF_P2P_REMOTE_NPORT_ID; // 0xD6
			rport->local_nport_id = UNF_P2P_LOCAL_NPORT_ID;  // 0xEF

			spin_lock_irqsave(&rport->rport_state_lock,
					  rport_flag);
			if ((rport->rp_state == UNF_RPORT_ST_PLOGI_WAIT) ||
			    (rport->rp_state == UNF_RPORT_ST_PRLI_WAIT) ||
			    (rport->rp_state == UNF_RPORT_ST_READY)) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_INFO,
					  UNF_LOG_LOGIN_ATT,
					  UNF_MAJOR,
					  "[info]LOGIN: Port(0x%x) Rport(0x%x) have sent PLOGI or PRLI with state(0x%x)",
					  lport->port_id, rport->nport_id,
					  rport->rp_state);

				spin_unlock_irqrestore(&rport->rport_state_lock,
						       rport_flag);
				return;
			}
			/* Update L_Port State: PLOGI_WAIT */
			unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
			spin_unlock_irqrestore(&rport->rport_state_lock,
					       rport_flag);

			/* P2P with master: Start to Send PLOGI */
			ret = unf_send_plogi(lport, rport);
			if (ret != RETURN_OK) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
					  UNF_LOG_LOGIN_ATT,
					  UNF_WARN,
					  "[warn]LOGIN: Port(0x%x) with WWN(0x%llx) send PLOGI to(0x%llx) failed",
					  lport->port_id, lport->port_name,
					  port_name);

				unf_rport_error_recovery(rport);
			}
		} else {
			/* Get/Alloc R_Port failed */
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) with WWN(0x%llx) allocate RPort(ID:0x%x,WWPN:0x%llx) failed",
				  lport->port_id, lport->port_name,
				  UNF_P2P_REMOTE_NPORT_ID, port_name);
		}
	} else {
		/* Slave case: L_Port's Port Name is smaller than R_Port */
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]Port(0x%x) with WWN(0x%llx) is smaller than rport(0x%llx), do nothing",
			  lport->port_id, lport->port_name, port_name);
	}
}

static void unf_flogi_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Callback for Sending FLOGI ACC succeed */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned long flags = 0;
	unsigned long long port_name = 0;
	unsigned long long node_name = 0;

	UNF_CHECK_VALID(0x3457, UNF_TRUE, v_xchg, return);
	UNF_CHECK_VALID(0x3458, UNF_TRUE, v_xchg->lport, return);
	UNF_CHECK_VALID(0x3459, UNF_TRUE, v_xchg->rport, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flags);
	lport = v_xchg->lport;
	rport = v_xchg->rport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flags);

	spin_lock_irqsave(&rport->rport_state_lock, flags);
	port_name = rport->port_name;
	node_name = rport->node_name;

	/* Swap case: Set WWPN & WWNN with zero */
	rport->port_name = 0;
	rport->node_name = 0;
	spin_unlock_irqrestore(&rport->rport_state_lock, flags);

	/* Enter PLOGI stage: after send FLOGI ACC succeed */
	unf_login_with_rport_in_n2n(lport, port_name, node_name);
}

unsigned int unf_send_flogi_acc(struct unf_lport_s *v_lport,
				struct unf_rport_s *v_rport,
				struct unf_xchg_s *v_xchg)
{
	struct unf_flogi_payload_s *flogi_acc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3393, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3394, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3395, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_FLOGI);

	v_xchg->did = 0; /* D_ID must be 0 */
	v_xchg->sid = UNF_FC_FID_FLOGI; /* S_ID must be 0xfffffe */
	v_xchg->oid = v_xchg->sid;
	v_xchg->pfn_callback = NULL;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;
	/* call back for sending FLOGI response */
	v_xchg->pfn_ob_callback = unf_flogi_acc_ob_callback;
	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_REG_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	unf_fill_package(&pkg, v_xchg, v_rport);

	/* Fill FLOGI ACC payload */
	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	flogi_acc_pld = &fc_entry->flogi_acc.flogi_payload;
	flogi_acc_pld->cmnd = (UNF_ELS_CMND_ACC);
	unf_fill_flogi_pld(flogi_acc_pld, v_lport);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	/* Send FLOGI ACC to remote port */
	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
		  "[info]LOGIN: FLOGI ACC send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static void unf_fill_plogi_acc_pld(struct unf_plogi_payload_s *v_plogi_acc_pld,
				   struct unf_lport_s *v_lport)
{
	struct unf_lgn_parms_s *login_parms = NULL;

	UNF_CHECK_VALID(0x3396, UNF_TRUE, v_plogi_acc_pld, return);
	UNF_CHECK_VALID(0x3397, UNF_TRUE, v_lport, return);

	v_plogi_acc_pld->cmnd = (UNF_ELS_CMND_ACC);
	login_parms = &v_plogi_acc_pld->parms;

	if ((v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) {
		login_parms->co_parms.bb_credit =
			unf_low_level_bb_credit(v_lport);
		login_parms->co_parms.alternate_bb_credit_mgmt =
			UNF_BBCREDIT_MANAGE_NFPORT;  /* 0 */
		login_parms->co_parms.bb_scn =
			(v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ?
				0 : unf_low_level_bbscn(v_lport);
	} else {
		login_parms->co_parms.bb_credit = UNF_BBCREDIT_LPORT;
		login_parms->co_parms.alternate_bb_credit_mgmt =
			UNF_BBCREDIT_MANAGE_LPORT;  /* 1 */
	}

	login_parms->co_parms.lowest_version = UNF_PLOGI_VERSION_LOWER;
	login_parms->co_parms.highest_version = UNF_PLOGI_VERSION_UPPER;
	login_parms->co_parms.continuously_increasing =
		UNF_CONTIN_INCREASE_SUPPORT;
	login_parms->co_parms.bb_receive_data_field_size =
		v_lport->max_frame_size;
	login_parms->co_parms.nport_total_concurrent_sequences =
		UNF_PLOGI_CONCURRENT_SEQ;
	login_parms->co_parms.relative_offset = (UNF_PLOGI_RO_CATEGORY);
	login_parms->co_parms.e_d_tov = (v_lport->ed_tov);
	login_parms->cl_parms[2].valid = UNF_CLASS_VALID;  /* class-3 */
	login_parms->cl_parms[2].received_data_field_size =
		v_lport->max_frame_size;
	login_parms->cl_parms[2].concurrent_sequences =
		UNF_PLOGI_CONCURRENT_SEQ;
	login_parms->cl_parms[2].open_sequences_per_exchange =
		UNF_PLOGI_SEQ_PER_XCHG;
	login_parms->high_node_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->node_name);
	login_parms->low_node_name =
		UNF_GET_NAME_LOW_WORD(v_lport->node_name);
	login_parms->high_port_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->port_name);
	login_parms->low_port_name =
		UNF_GET_NAME_LOW_WORD(v_lport->port_name);

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id,
			    v_plogi_acc_pld,
			    sizeof(struct unf_plogi_payload_s));
}

static void unf_schedule_open_work(struct unf_lport_s *v_lport,
				   struct unf_rport_s *v_rport)
{
	/* Used for L_Port port only with TGT, or R_Port only with INI */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = v_rport;
	unsigned long delay = 0;
	unsigned long flag = 0;
	unsigned int ret = 0;
	unsigned int port_feature = INVALID_VALUE32;

	UNF_CHECK_VALID(0x3452, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3453, UNF_TRUE, v_rport, return);

	delay = (unsigned long)lport->ed_tov;
	port_feature = rport->options & UNF_PORT_MODE_BOTH;

	if ((lport->options == UNF_PORT_MODE_TGT) ||
	    (port_feature == UNF_PORT_MODE_INI)) {
		spin_lock_irqsave(&rport->rport_state_lock, flag);

		ret = unf_rport_ref_inc(rport);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x_0x%x) RPort(0x%x) abnormal, no need open",
				  lport->port_id, lport->nport_id,
				  rport->nport_id);

			spin_unlock_irqrestore(&rport->rport_state_lock, flag);
			return;
		}

		/* Delay work pending check */
		if (delayed_work_pending(&rport->open_work)) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x_0x%x) RPort(0x%x) open work is running, no need re-open",
				  lport->port_id, lport->nport_id,
				  rport->nport_id);

			spin_unlock_irqrestore(&rport->rport_state_lock, flag);
			unf_rport_ref_dec(rport);
			return;
		}

		/* start open work */
		if (queue_delayed_work(
			unf_work_queue,
			&rport->open_work,
			(unsigned long)
			msecs_to_jiffies((unsigned int)delay))) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]Port(0x%x_0x%x) RPort(0x%x) start open work",
				  lport->port_id, lport->nport_id,
				  rport->nport_id);

			(void)unf_rport_ref_inc(rport);
		}
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		unf_rport_ref_dec(rport);
	}
}

static void unf_plogi_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned long flags = 0;

	UNF_CHECK_VALID(0x3454, UNF_TRUE, v_xchg, return);

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flags);
	lport = v_xchg->lport;
	rport = v_xchg->rport;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flags);

	UNF_CHECK_VALID(0x3455, UNF_TRUE, lport, return);
	UNF_CHECK_VALID(0x3456, UNF_TRUE, rport, return);

	/*
	 * 1. According to FC-LS 4.2.7.1:
	 * after RCVD PLOGI or sending PLOGI ACC, need to termitate open EXCH
	 */
	unf_cm_xchg_mgr_abort_io_by_id(lport, rport, rport->nport_id,
				       lport->nport_id, 0);

	/* 2. Send PLOGI ACC fail */
	if (v_xchg->ob_callback_sts != UNF_IO_SUCCESS) {
		/* Do R_Port recovery */
		unf_rport_error_recovery(rport);

		/* Do not care: Just used for L_Port only is
		 * TGT mode or R_Port only is INI mode
		 */
		unf_schedule_open_work(lport, rport);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
			  UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x_0x%x) send PLOGI ACC failed(0x%x) with RPort(0x%x) feature(0x%x)",
			  lport->port_id, lport->nport_id,
			  lport->options, v_xchg->ob_callback_sts,
			  rport->nport_id, rport->options);

		/* NOTE: return */
		return;
	}

	/* 3. Private Loop: check whether or not need to send PRLI */
	spin_lock_irqsave(&rport->rport_state_lock, flags);
	if ((lport->en_act_topo == UNF_ACT_TOP_PRIVATE_LOOP) &&
	    ((rport->rp_state == UNF_RPORT_ST_PRLI_WAIT) ||
	    (rport->rp_state == UNF_RPORT_ST_READY))) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]Port(0x%x_0x%x) RPort(0x%x) with State(0x%x) return directly",
			  lport->port_id, lport->nport_id,
			  rport->nport_id, rport->rp_state);

		/* Do nothing */
		spin_unlock_irqrestore(&rport->rport_state_lock, flags);
		return;
	}
	unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PRLI);  // PRLI_WAIT
	spin_unlock_irqrestore(&rport->rport_state_lock, flags);

	/* 4. Set Port Feature with BOTH: cancel */
	if ((rport->options == UNF_PORT_MODE_UNKNOWN) &&
	    (rport->port_name != INVALID_WWPN))
		rport->options = unf_get_port_feature(rport->port_name);

	/*
	 * 5. Check whether need to send PRLI delay
	 * Call by: RCVD PLOGI ACC or callback for sending PLOGI ACC succeed
	 */
	unf_check_rport_need_delay_prli(lport, rport, rport->options);

	/* 6. Do not care: Just used for L_Port only is
	 * TGT mode or R_Port only is INI mode
	 */
	unf_schedule_open_work(lport, rport);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Port(0x%x_0x%x_0x%x) send PLOGI ACC succeed with RPort(0x%x) feature(0x%x)",
		  lport->port_id, lport->nport_id, lport->options,
		  rport->nport_id, rport->options);
}

unsigned int unf_send_plogi_acc(struct unf_lport_s *v_lport,
				struct unf_rport_s *v_rport,
				struct unf_xchg_s *v_xchg)
{
	struct unf_plogi_payload_s *plogi_acc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3398, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3399, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3400, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_PLOGI);

	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->pfn_callback = NULL;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;
	/* call back for sending PLOGI ACC */
	v_xchg->pfn_ob_callback = unf_plogi_acc_ob_callback;

	unf_fill_package(&pkg, v_xchg, v_rport);

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	/* Fill PLOGI ACC payload */
	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	plogi_acc_pld = &fc_entry->plogi_acc.payload;
	unf_fill_plogi_acc_pld(plogi_acc_pld, v_lport);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	/* Start to Send PLOGI ACC now */
	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		/* NOTE: free exchange */
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	if ((v_rport->nport_id < UNF_FC_FID_DOM_MGR) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]LOGIN: PLOGI ACC send %s. Port(0x%x_0x%x_0x%llx)--->rport(0x%x_0x%llx) with OX_ID(0x%x) RX_ID(0x%x)",
			  (ret != RETURN_OK) ? "failed" : "succeed",
			  v_lport->port_id, v_lport->nport_id,
			  v_lport->port_name,
			  v_rport->nport_id, v_rport->port_name,
			  ox_id, rx_id);
	}

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static void unf_fill_rjt_pld(struct unf_els_rjt_s *v_els_rjt,
			     unsigned int v_reason_code,
			     unsigned int v_reason_explanation)
{
	UNF_CHECK_VALID(0x3401, UNF_TRUE, v_els_rjt, return);

	v_els_rjt->cmnd = UNF_ELS_CMND_RJT;
	v_els_rjt->reason_code = (v_reason_code | v_reason_explanation);
}

static void unf_fill_prli_acc_pld(struct unf_pril_payload_s *v_prli_acc_pld,
				  struct unf_lport_s *v_lport,
				  struct unf_rport_s *v_rport)
{
	unsigned int port_mode = UNF_FC4_FRAME_PARM_3_TGT;

	UNF_CHECK_VALID(0x3402, UNF_TRUE, v_prli_acc_pld, return);
	UNF_CHECK_VALID(0x3403, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3404, UNF_TRUE, v_rport, return);

	v_prli_acc_pld->cmnd = (
		UNF_ELS_CMND_ACC |
		((unsigned int)UNF_FC4_FRAME_PAGE_SIZE <<
		UNF_FC4_FRAME_PAGE_SIZE_SHIFT) |
		((unsigned int)(sizeof(struct unf_pril_payload_s) -
		UNF_PRLI_SIRT_EXTRA_SIZE)));

	v_prli_acc_pld->parms[0] = (UNF_FC4_FRAME_PARM_0_FCP |
				    UNF_FC4_FRAME_PARM_0_I_PAIR |
				    UNF_FC4_FRAME_PARM_0_GOOD_RSP_CODE);
	v_prli_acc_pld->parms[1] = UNF_NOT_MEANINGFUL;
	v_prli_acc_pld->parms[2] = UNF_NOT_MEANINGFUL;

	/* About INI/TGT mode */
	if (v_rport->nport_id < UNF_FC_FID_DOM_MGR)
		/* return INI (0x20): R_Port has TGT mode,
		 * L_Port has INI mode
		 */
		port_mode = UNF_FC4_FRAME_PARM_3_INI;
	else
		port_mode = v_lport->options;

	/* About Read xfer_rdy disable */
	v_prli_acc_pld->parms[3] = (UNF_FC4_FRAME_PARM_3_R_XFER_DIS |
				    port_mode);  /* 0x2 */

	/* About Tape support */
	if (v_rport->tape_support_needed) {
		v_prli_acc_pld->parms[3] |=
				(UNF_FC4_FRAME_PARM_3_REC_SUPPORT |
				UNF_FC4_FRAME_PARM_3_RETRY_SUPPORT |
				UNF_FC4_FRAME_PARM_3_TASK_RETRY_ID_SUPPORT |
				UNF_FC4_FRAME_PARM_3_CONF_ALLOW);

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "PRLI ACC tape support");
	}

	/* About confirm */
	if (v_lport->low_level_func.lport_cfg_items.fcp_conf == UNF_TRUE)
		/* 0x80 */
		v_prli_acc_pld->parms[3] |= UNF_FC4_FRAME_PARM_3_CONF_ALLOW;

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id,
			    v_prli_acc_pld, sizeof(struct unf_pril_payload_s));
}

static void unf_prli_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	/* Report R_Port scsi Link Up */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned long flags = 0;
	enum unf_rport_login_state_e rport_state = UNF_RPORT_ST_INIT;

	UNF_CHECK_VALID(0x3449, UNF_TRUE, v_xchg, return);
	lport = v_xchg->lport;
	rport = v_xchg->rport;
	UNF_CHECK_VALID(0x3450, UNF_TRUE, lport, return);
	UNF_CHECK_VALID(0x3451, UNF_TRUE, rport, return);

	/* Update & Report Link Up */
	spin_lock_irqsave(&rport->rport_state_lock, flags);
	unf_rport_state_ma(rport, UNF_EVENT_RPORT_READY);  // READY
	rport_state = rport->rp_state;
	if (rport->nport_id < UNF_FC_FID_DOM_MGR) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_KEVENT,
			  "[event]LOGIN: Port(0x%x) RPort(0x%x) state(0x%x) WWN(0x%llx) prliacc",
			  lport->port_id, rport->nport_id,
			  rport->rp_state, rport->port_name);
	}
	spin_unlock_irqrestore(&rport->rport_state_lock, flags);

	if (rport_state == UNF_RPORT_ST_READY) {
		rport->logo_retries = 0;
		unf_update_lport_state_by_linkup_event(lport, rport,
						       rport->options);
	}
}

unsigned int unf_send_prli_acc(struct unf_lport_s *v_lport,
			       struct unf_rport_s *v_rport,
			       struct unf_xchg_s *v_xchg)
{
	struct unf_pril_payload_s *prli_acc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3405, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3406, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3407, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_PRLI);
	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;

	v_xchg->pfn_callback = NULL;
	/* callback when send succeed */
	v_xchg->pfn_ob_callback = unf_prli_acc_ob_callback;

	/* Fill common package */
	unf_fill_package(&pkg, v_xchg, v_rport);

	/* Get FC entry (alloc when create exchange) */
	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	/* Fill FRLI Payload */
	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	prli_acc_pld = &fc_entry->prli_acc.payload;
	unf_fill_prli_acc_pld(prli_acc_pld, v_lport, v_rport);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	/* Send ELS (RPLI) RSP */
	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	if ((v_rport->nport_id < UNF_FC_FID_DOM_MGR) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]LOGIN: PRLI ACC send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
			  (ret != RETURN_OK) ? "failed" : "succeed",
			  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);
	}

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static unsigned int unf_send_rec_acc(struct unf_lport_s *v_lport,
				     struct unf_rport_s *v_rport,
				     struct unf_xchg_s *v_xchg)
{
	/* Reserved */
	UNF_REFERNCE_VAR(v_lport);
	UNF_REFERNCE_VAR(v_rport);
	UNF_REFERNCE_VAR(v_xchg);

	unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	return RETURN_OK;
}

static void unf_rrq_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	UNF_CHECK_VALID(0x3408, UNF_TRUE, v_xchg, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
		  "[info]RRQ ACC Xchg(0x%p) tag(0x%x)",
		  v_xchg, v_xchg->hot_pool_tag);

	UNF_REFERNCE_VAR(v_xchg);
}

static void unf_fill_els_acc_pld(struct unf_els_acc_s *v_els_acc_pld)
{
	UNF_CHECK_VALID(0x3420, UNF_TRUE, v_els_acc_pld, return);

	v_els_acc_pld->cmnd = UNF_ELS_CMND_ACC;
}

static void unf_rscn_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	UNF_REFERNCE_VAR(v_xchg);
}

static unsigned int unf_send_rscn_acc(struct unf_lport_s *v_lport,
				      struct unf_rport_s *v_rport,
				      struct unf_xchg_s *v_xchg)
{
	struct unf_els_acc_s *rscn_acc = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3421, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3422, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3423, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));
	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_RSCN);
	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;

	/* Set call back function */
	v_xchg->pfn_callback = NULL;
	v_xchg->pfn_ob_callback = unf_rscn_acc_ob_callback;  // do nothing

	unf_fill_package(&pkg, v_xchg, v_rport);

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	rscn_acc = &fc_entry->els_acc;
	unf_fill_els_acc_pld(rscn_acc);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: RSCN ACC send %s. Port(0x%x)--->rport(0x%x) with OXID(0x%x) RXID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static void unf_logo_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	UNF_REFERNCE_VAR(v_xchg);
}

unsigned int unf_send_logo_acc(struct unf_lport_s *v_lport,
			       struct unf_rport_s *v_rport,
			       struct unf_xchg_s *v_xchg)
{
	struct unf_els_acc_s *logo_acc = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3424, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3425, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3426, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_LOGO);
	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;
	v_xchg->pfn_callback = NULL;
	v_xchg->pfn_ob_callback = unf_logo_acc_ob_callback;  // do nothing

	unf_fill_package(&pkg, v_xchg, v_rport);

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	logo_acc = &fc_entry->els_acc;
	unf_fill_els_acc_pld(logo_acc);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	if (v_rport->nport_id < UNF_FC_FID_DOM_MGR) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]LOGIN: LOGO ACC send %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
			  (ret != RETURN_OK) ? "failed" : "succeed",
			  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);
	}

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static unsigned int unf_send_rrq_acc(struct unf_lport_s *v_lport,
				     struct unf_rport_s *v_rport,
				     struct unf_xchg_s *v_xchg)
{
	struct unf_els_acc_s *rrq_acc = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	struct unf_frame_pkg_s pkg = { 0 };

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3427, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3428, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3429, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;
	v_xchg->pfn_callback = NULL;  // do noting

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		return UNF_RETURN_ERROR;
	}

	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	rrq_acc = &fc_entry->els_acc;
	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_RRQ);
	v_xchg->pfn_ob_callback = unf_rrq_acc_ob_callback;  // do noting
	unf_fill_els_acc_pld(rrq_acc);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	unf_fill_package(&pkg, v_xchg, v_rport);

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]RRQ ACC send %s. Port(0x%x)--->rport(0x%x) with Xchg(0x%p) OX_ID(0x%x) RX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, v_xchg, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static void unf_fill_pdisc_acc_pld(struct unf_plogi_payload_s *v_pdisc_acc_pld,
				   struct unf_lport_s *v_lport)
{
	struct unf_lgn_parms_s *login_parms = NULL;

	UNF_CHECK_VALID(0x3430, UNF_TRUE, v_pdisc_acc_pld, return);
	UNF_CHECK_VALID(0x3431, UNF_TRUE, v_lport, return);

	v_pdisc_acc_pld->cmnd = UNF_ELS_CMND_ACC;
	login_parms = &v_pdisc_acc_pld->parms;

	if ((v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) {
		login_parms->co_parms.bb_credit =
			unf_low_level_bb_credit(v_lport);
		login_parms->co_parms.alternate_bb_credit_mgmt =
			UNF_BBCREDIT_MANAGE_NFPORT;
		login_parms->co_parms.bb_scn =
			(v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ?
			0 : unf_low_level_bbscn(v_lport);
	} else {
		login_parms->co_parms.bb_credit = UNF_BBCREDIT_LPORT;
		login_parms->co_parms.alternate_bb_credit_mgmt =
			UNF_BBCREDIT_MANAGE_LPORT;
	}

	login_parms->co_parms.lowest_version = UNF_PLOGI_VERSION_LOWER;
	login_parms->co_parms.highest_version = UNF_PLOGI_VERSION_UPPER;
	login_parms->co_parms.continuously_increasing =
		UNF_CONTIN_INCREASE_SUPPORT;
	login_parms->co_parms.bb_receive_data_field_size =
		v_lport->max_frame_size;
	login_parms->co_parms.nport_total_concurrent_sequences =
		UNF_PLOGI_CONCURRENT_SEQ;
	login_parms->co_parms.relative_offset = UNF_PLOGI_RO_CATEGORY;
	login_parms->co_parms.e_d_tov = v_lport->ed_tov;

	login_parms->cl_parms[2].valid = UNF_CLASS_VALID;  // class-3
	login_parms->cl_parms[2].received_data_field_size =
		v_lport->max_frame_size;
	login_parms->cl_parms[2].concurrent_sequences =
		UNF_PLOGI_CONCURRENT_SEQ;
	login_parms->cl_parms[2].open_sequences_per_exchange =
		UNF_PLOGI_SEQ_PER_XCHG;

	login_parms->high_node_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->node_name);
	login_parms->low_node_name =
		UNF_GET_NAME_LOW_WORD(v_lport->node_name);
	login_parms->high_port_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->port_name);
	login_parms->low_port_name =
		UNF_GET_NAME_LOW_WORD(v_lport->port_name);

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id,
			    v_pdisc_acc_pld,
			    sizeof(struct unf_plogi_payload_s));
}

static void unf_pdisc_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	UNF_REFERNCE_VAR(v_xchg);
}

unsigned int unf_send_pdisc_acc(struct unf_lport_s *v_lport,
				struct unf_rport_s *v_rport,
				struct unf_xchg_s *v_xchg)
{
	struct unf_plogi_payload_s *pdisc_acc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3432, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3433, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3434, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_PDISC);
	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;

	/* Set call back function */
	v_xchg->pfn_callback = NULL;
	v_xchg->pfn_ob_callback = unf_pdisc_acc_ob_callback;  // do nothing

	unf_fill_package(&pkg, v_xchg, v_rport);

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	pdisc_acc_pld = &fc_entry->pdisc_acc.payload;
	unf_fill_pdisc_acc_pld(pdisc_acc_pld, v_lport);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Send PDISC ACC %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static void unf_fill_adisc_acc_pld(struct unf_adisc_payload_s *v_adisc_acc_pld,
				   struct unf_lport_s *v_lport)
{
	UNF_CHECK_VALID(0x3435, UNF_TRUE, v_adisc_acc_pld, return);
	UNF_CHECK_VALID(0x3436, UNF_TRUE, v_lport, return);

	v_adisc_acc_pld->cmnd = (UNF_ELS_CMND_ACC);

	v_adisc_acc_pld->hard_address = (v_lport->nport_id & UNF_ALPA_MASK);
	v_adisc_acc_pld->high_node_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->node_name);
	v_adisc_acc_pld->low_node_name =
		UNF_GET_NAME_LOW_WORD(v_lport->node_name);
	v_adisc_acc_pld->high_port_name =
		UNF_GET_NAME_HIGH_WORD(v_lport->port_name);
	v_adisc_acc_pld->low_port_name =
		UNF_GET_NAME_LOW_WORD(v_lport->port_name);
	v_adisc_acc_pld->nport_id = v_lport->nport_id;

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id,
			    v_adisc_acc_pld,
			    sizeof(struct unf_adisc_payload_s));
}

static void unf_adisc_acc_ob_callback(struct unf_xchg_s *v_xchg)
{
	UNF_REFERNCE_VAR(v_xchg);
}

static unsigned int unf_send_adisc_acc(struct unf_lport_s *v_lport,
				       struct unf_rport_s *v_rport,
				       struct unf_xchg_s *v_xchg)
{
	struct unf_adisc_payload_s *adisc_acc_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3437, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3438, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3439, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_ADISC);
	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;

	v_xchg->pfn_callback = NULL;
	v_xchg->pfn_ob_callback = unf_adisc_acc_ob_callback;  // do nothing

	unf_fill_package(&pkg, v_xchg, v_rport);
	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	adisc_acc_pld = &fc_entry->adisc_acc.adisc_payl;
	unf_fill_adisc_acc_pld(adisc_acc_pld, v_lport);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Send ADISC ACC %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static void unf_fill_prlo_acc_pld(struct unf_prli_prlo_s *v_prlo_acc,
				  struct unf_lport_s *v_lport)
{
	struct unf_pril_payload_s *prlo_acc_pld = NULL;

	UNF_CHECK_VALID(0x3440, UNF_TRUE, v_prlo_acc, return);

	prlo_acc_pld = &v_prlo_acc->payload;
	prlo_acc_pld->cmnd = (UNF_ELS_CMND_ACC |
				((unsigned int)UNF_FC4_FRAME_PAGE_SIZE <<
				 UNF_FC4_FRAME_PAGE_SIZE_SHIFT) |
				((unsigned int)
				sizeof(struct unf_pril_payload_s)));
	prlo_acc_pld->parms[0] = UNF_FC4_FRAME_PARM_0_FCP |
				 UNF_FC4_FRAME_PARM_0_GOOD_RSP_CODE;
	prlo_acc_pld->parms[1] = 0;
	prlo_acc_pld->parms[2] = 0;
	prlo_acc_pld->parms[3] = 0;

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, prlo_acc_pld,
			    sizeof(struct unf_pril_payload_s));
}

static unsigned int unf_send_prlo_acc(struct unf_lport_s *v_lport,
				      struct unf_rport_s *v_rport,
				      struct unf_xchg_s *v_xchg)
{
	struct unf_prli_prlo_s *prlo_acc = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	struct unf_frame_pkg_s pkg;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	UNF_CHECK_VALID(0x3441, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3442, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3443, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_PRLO);
	v_xchg->did = v_rport->nport_id;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;
	v_xchg->rport = v_rport;

	v_xchg->pfn_callback = NULL;	// do nothing
	v_xchg->pfn_ob_callback = NULL;  // do nothing

	unf_fill_package(&pkg, v_xchg, v_rport);

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	memset(fc_entry, 0, sizeof(union unf_sfs_u));
	prlo_acc = &fc_entry->prlo_acc;
	unf_fill_prlo_acc_pld(prlo_acc, v_lport);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Send PRLO ACC %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

unsigned int unf_send_abts(struct unf_lport_s *v_lport,
			   struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_frame_pkg_s pkg;

	UNF_CHECK_VALID(0x3444, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3445, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
	rport = v_xchg->rport;
	UNF_CHECK_VALID(0x3446, UNF_TRUE, rport, return UNF_RETURN_ERROR);

	/* set pkg info */
	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));
	pkg.type = UNF_PKG_BLS_REQ;
	pkg.frame_head.csctl_sid = v_xchg->sid;
	pkg.frame_head.rctl_did = v_xchg->did;
	pkg.frame_head.oxid_rxid =
		(unsigned int)v_xchg->ox_id << 16 | v_xchg->rx_id;
	pkg.xchg_contex = v_xchg;
	pkg.unf_cmnd_pload_bl.buffer_ptr =
		(unsigned char *)
		v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;

	pkg.unf_cmnd_pload_bl.buf_dma_addr =
		v_xchg->fcp_sfs_union.sfs_entry.sfs_buff_phy_addr;
	pkg.private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX] = v_xchg->hot_pool_tag;

	UNF_SET_XCHG_ALLOC_TIME(&pkg, v_xchg);
	UNF_SET_ABORT_INFO_IOTYPE(&pkg, v_xchg);

	pkg.private[PKG_PRIVATE_XCHG_RPORT_INDEX] =
		v_xchg->private[PKG_PRIVATE_XCHG_RPORT_INDEX];

	/* Send ABTS frame to target */
	ret = unf_bls_cmnd_send(v_lport, &pkg, v_xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
		  "[info]Port(0x%x_0x%x) send ABTS %s. Abort exch(0x%p) Cmdsn:0x%lx, tag(0x%x) iotype(0x%x)",
		  v_lport->port_id, v_lport->nport_id,
		  (ret == UNF_RETURN_ERROR) ? "failed" : "succeed",
		  v_xchg, (unsigned long)v_xchg->cmnd_sn,
		  v_xchg->hot_pool_tag, v_xchg->data_direction);

	UNF_REFERNCE_VAR(rport);
	return ret;
}

unsigned int unf_release_rport_res(struct unf_lport_s *v_lport,
				   struct unf_rport_s *v_rport)
{
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_rport_info_s rport_info;

	UNF_CHECK_VALID(0x3447, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3448, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	memset(&rport_info, 0, sizeof(struct unf_rport_info_s));

	rport_info.rport_index = v_rport->rport_index;
	rport_info.nport_id = v_rport->nport_id;
	rport_info.port_name = v_rport->port_name;

	/* 2. release R_Port(parent context/Session) resource */
	if (!v_lport->low_level_func.service_op.pfn_unf_release_rport_res) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) release rport resource function can't be NULL",
			  v_lport->port_id);

		return ret;
	}

	ret = v_lport->low_level_func.service_op.pfn_unf_release_rport_res(
			v_lport->fc_port,
			&rport_info);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) rport_index(0x%x, %p) send release session CMND failed",
			  v_lport->port_id, rport_info.rport_index, v_rport);

	return ret;
}

static inline unsigned char unf_determin_bbscn(unsigned char local_bbscn,
					       unsigned char remote_bbscn)
{
	if ((remote_bbscn == 0) || (local_bbscn == 0))
		local_bbscn = 0;
	else
		local_bbscn = local_bbscn > remote_bbscn ?
			local_bbscn : remote_bbscn;

	return local_bbscn;
}

static void unf_cfg_lowlevel_fabric_params(
				struct unf_lport_s *v_lport,
				struct unf_rport_s *v_rport,
				struct unf_fabric_parms_s *v_login_parms)
{
	struct unf_port_login_parms_s login_co_parms = { 0 };
	unsigned int remote_edtov = 0;
	unsigned int ret = 0;
	unsigned char remote_edtov_resolution = 0; /* 0:ms; 1:ns */

	if (!v_lport->low_level_func.port_mgr_op.pfn_ll_port_config_set)
		return;

	login_co_parms.remote_rttov_tag =
		(unsigned char)UNF_GET_RT_TOV_FROM_PARAMS(v_login_parms);
	login_co_parms.remote_edtov_tag = 0;
	login_co_parms.remote_bbcredit =
		(unsigned short)
		UNF_GET_BB_CREDIT_FROM_PARAMS(v_login_parms);
	login_co_parms.compared_bbscn =
		(unsigned int)unf_determin_bbscn(
			(unsigned char)
			v_lport->low_level_func.lport_cfg_items.bb_scn,
			(unsigned char)
			UNF_GET_BB_SC_N_FROM_PARAMS(v_login_parms));

	remote_edtov_resolution =
		(unsigned char)
		UNF_GET_E_D_TOV_RESOLUTION_FROM_PARAMS(v_login_parms);
	remote_edtov = UNF_GET_E_D_TOV_FROM_PARAMS(v_login_parms);
	login_co_parms.compared_edtov_val =
		remote_edtov_resolution ?
		(remote_edtov / 1000000) : remote_edtov;

	login_co_parms.compared_ratov_val =
		UNF_GET_RA_TOV_FROM_PARAMS(v_login_parms);
	login_co_parms.els_cmnd_code = ELS_FLOGI;

	if (v_lport->en_act_topo & UNF_TOP_P2P_MASK) {
		login_co_parms.en_act_topo =
			(v_login_parms->co_parms.n_port == UNF_F_PORT) ?
			 UNF_ACT_TOP_P2P_FABRIC : UNF_ACT_TOP_P2P_DIRECT;
	} else {
		login_co_parms.en_act_topo = v_lport->en_act_topo;
	}

	ret = v_lport->low_level_func.port_mgr_op.pfn_ll_port_config_set(
			(void *)v_lport->fc_port,
			UNF_PORT_CFG_UPDATE_FABRIC_PARAM,
			(void *)&login_co_parms);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Lowlevel unsupport fabric config");
}

static unsigned int unf_check_flogi_params(
				struct unf_lport_s *v_lport,
				struct unf_rport_s *v_rport,
				struct unf_fabric_parms_s *v_fabric_parms)
{
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3460, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3461, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3462, UNF_TRUE, v_fabric_parms,
			return UNF_RETURN_ERROR);
	UNF_REFERNCE_VAR(v_lport);
	UNF_REFERNCE_VAR(v_rport);

	if (v_fabric_parms->cl_parms[2].valid == UNF_CLASS_INVALID) {
		/* Discard directly */
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) NPort_ID(0x%x) FLOGI not support class3",
			  v_lport->port_id, v_rport->nport_id);

		return UNF_RETURN_ERROR;
	}

	return ret;
}

static void unf_save_fabric_params(struct unf_lport_s *v_lport,
				   struct unf_rport_s *v_rport,
				   struct unf_fabric_parms_s *v_fabric_parms)
{
	unsigned long long fabric_node_name = 0;

	UNF_CHECK_VALID(0x3463, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3464, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3465, UNF_TRUE, v_fabric_parms, return);

	UNF_REFERNCE_VAR(v_lport);
	fabric_node_name = (unsigned long long)
			   (((unsigned long long)
			   (v_fabric_parms->high_node_name) << 32) |
			    ((unsigned long long)
			    (v_fabric_parms->low_node_name)));

	/* R_Port for 0xfffffe is used for FLOGI, not need to save WWN */
	if (v_fabric_parms->co_parms.bb_receive_data_field_size >
	    UNF_MAX_FRAME_SIZE)
		v_rport->max_frame_size = UNF_MAX_FRAME_SIZE;  // 2112
	else
		v_rport->max_frame_size =
			v_fabric_parms->co_parms.bb_receive_data_field_size;

	/* with Fabric attribute */
	if (v_fabric_parms->co_parms.n_port == UNF_F_PORT) {
		v_rport->ed_tov = v_fabric_parms->co_parms.e_d_tov;
		v_rport->ra_tov = v_fabric_parms->co_parms.r_a_tov;
		v_lport->ed_tov = v_fabric_parms->co_parms.e_d_tov;
		v_lport->ra_tov = v_fabric_parms->co_parms.r_a_tov;
		v_lport->rr_tov = UNF_CALC_LPORT_RRTOV(v_lport);
		v_lport->fabric_node_name = fabric_node_name;
	}

	/* Configure info from FLOGI to chip */
	unf_cfg_lowlevel_fabric_params(v_lport, v_rport, v_fabric_parms);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]Port(0x%x) Rport(0x%x) login parameter: E_D_TOV = %u. LPort E_D_TOV = %u. fabric nodename: 0x%x%x",
		  v_lport->port_id,
		  v_rport->nport_id,
		  (v_fabric_parms->co_parms.e_d_tov),
		  v_lport->ed_tov,
		  v_fabric_parms->high_node_name,
		  v_fabric_parms->low_node_name);
}

static unsigned int unf_flogi_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	struct unf_flogi_fdisc_acc_s *flogi_frame = NULL;
	struct unf_fabric_parms_s *fabric_login_parms = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned long flag = 0;
	unsigned long long wwpn = 0;
	unsigned long long wwnn = 0;

	UNF_CHECK_VALID(0x3466, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3467, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
	UNF_REFERNCE_VAR(v_sid);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_REG_ATT, UNF_MAJOR,
		  "[info]LOGIN: Port(0x%x)<---RPort(0x%x) Receive FLOGI with OX_ID(0x%x)",
		  v_lport->port_id, v_sid, v_xchg->ox_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info,
			    UNF_SERVICE_ITEM_FLOGI);

	/* Check L_Port state: Offline */
	if (v_lport->en_states >= UNF_LPORT_ST_OFFLINE) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) with state(0x%x) not need to handle FLOGI",
			  v_lport->port_id, v_lport->en_states);

		unf_cm_free_xchg(v_lport, v_xchg);
		return ret;
	}

	flogi_frame =
		&v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->flogi;
	fabric_login_parms = &flogi_frame->flogi_payload.fabric_parms;
	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id,
			    &flogi_frame->flogi_payload,
			    sizeof(struct unf_flogi_payload_s));
	wwpn = (unsigned long long)
		(((unsigned long long)
		(fabric_login_parms->high_port_name) << 32) |
		((unsigned long long)fabric_login_parms->low_port_name));
	wwnn = (unsigned long long)
		(((unsigned long long)
		(fabric_login_parms->high_node_name) << 32) |
		((unsigned long long)fabric_login_parms->low_node_name));

	/* Get (new) R_Port: reuse only */
	rport = unf_get_rport_by_nport_id(v_lport, UNF_FC_FID_FLOGI);
	rport = unf_get_safe_rport(v_lport, rport,
				   UNF_RPORT_REUSE_ONLY, UNF_FC_FID_FLOGI);
	if (unlikely(!rport)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) has no RPort. do nothing",
			  v_lport->port_id);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	/* Update R_Port info */
	spin_lock_irqsave(&rport->rport_state_lock, flag);
	rport->port_name = wwpn;
	rport->node_name = wwnn;
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	/* Check RCVD FLOGI parameters: only for class-3 */
	ret = unf_check_flogi_params(v_lport, rport, fabric_login_parms);
	if (ret != RETURN_OK) {
		/* Discard directly */
		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	/* P2P fabric */
	unf_lport_update_topo(v_lport, UNF_ACT_TOP_P2P_DIRECT);

	/* Save fabric parameters */
	unf_save_fabric_params(v_lport, rport, fabric_login_parms);

	/* Send ACC for FLOGI */
	ret = unf_send_flogi_acc(v_lport, rport, v_xchg);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x) send FLOGI ACC failed and do recover",
			  v_lport->port_id);

		/* Do L_Port recovery */
		unf_lport_error_recovery(v_lport);
	}

	return ret;
}

static void unf_cfg_lowlevel_port_params(struct unf_lport_s *v_lport,
					 struct unf_rport_s *v_rport,
					 struct unf_lgn_parms_s *v_login_parms,
					 unsigned int v_cmd_type)
{
	struct unf_port_login_parms_s login_co_parms = { 0 };
	unsigned int ret = 0;

	if (!v_lport->low_level_func.port_mgr_op.pfn_ll_port_config_set)
		return;

	login_co_parms.rport_index = v_rport->rport_index;
	login_co_parms.seq_cnt = 0;
	login_co_parms.ed_tov = 0;
	login_co_parms.ed_tov_timer_val = v_lport->ed_tov;
	login_co_parms.tx_mfs = v_rport->max_frame_size;

	login_co_parms.remote_rttov_tag =
		(unsigned char)UNF_GET_RT_TOV_FROM_PARAMS(v_login_parms);
	login_co_parms.remote_edtov_tag = 0;
	login_co_parms.remote_bbcredit =
		(unsigned short)UNF_GET_BB_CREDIT_FROM_PARAMS(v_login_parms);
	login_co_parms.els_cmnd_code = v_cmd_type;

	if (v_lport->en_act_topo == UNF_ACT_TOP_PRIVATE_LOOP) {
		login_co_parms.compared_bbscn = 0;
	} else {
		login_co_parms.compared_bbscn =
			(unsigned int)unf_determin_bbscn(
				(unsigned char)
				v_lport->low_level_func.lport_cfg_items.bb_scn,
				(unsigned char)
				UNF_GET_BB_SC_N_FROM_PARAMS(v_login_parms));
	}

	login_co_parms.compared_edtov_val = v_lport->ed_tov;
	login_co_parms.compared_ratov_val = v_lport->ra_tov;

	ret = v_lport->low_level_func.port_mgr_op.pfn_ll_port_config_set(
			(void *)v_lport->fc_port,
			UNF_PORT_CFG_UPDATE_PLOGI_PARAM,
			(void *)&login_co_parms);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) Lowlevel unsupport port config",
			  v_lport->port_id);
}

unsigned int unf_check_plogi_params(struct unf_lport_s *v_lport,
				    struct unf_rport_s *v_rport,
				    struct unf_lgn_parms_s *v_login_parms)
{
	unsigned int ret = RETURN_OK;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3468, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3469, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3470, UNF_TRUE, v_login_parms,
			return UNF_RETURN_ERROR);

	/* Parameters check: Class-type */
	if ((v_login_parms->cl_parms[2].valid == UNF_CLASS_INVALID) ||
	    (v_login_parms->co_parms.bb_receive_data_field_size == 0)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) RPort N_Port_ID(0x%x) with PLOGI parameters invalid: class3(%u), BBReceiveDataFieldSize(0x%x), send LOGO",
			  v_lport->port_id, v_rport->nport_id,
			  v_login_parms->cl_parms[2].valid,
			  v_login_parms->co_parms.bb_receive_data_field_size);

		spin_lock_irqsave(&v_rport->rport_state_lock, flag);
		/* --->>> LOGO */
		unf_rport_state_ma(v_rport, UNF_EVENT_RPORT_LOGO);
		spin_unlock_irqrestore(&v_rport->rport_state_lock, flag);

		/* Enter LOGO stage */
		unf_rport_enter_logo(v_lport, v_rport);
		return UNF_RETURN_ERROR;
	}

	/* 16G FC Brocade SW, Domain Controller's
	 * PLOGI both support CLASS-1 & CLASS-2
	 */
	if ((v_login_parms->cl_parms[0].valid == UNF_CLASS_VALID) ||
	    (v_login_parms->cl_parms[1].valid == UNF_CLASS_VALID)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x) get PLOGI class1(%u) class2(%u) from N_Port_ID(0x%x)",
			  v_lport->port_id,
			  v_login_parms->cl_parms[0].valid,
			  v_login_parms->cl_parms[1].valid,
			  v_rport->nport_id);
	}

	return ret;
}

static void unf_save_plogi_params(struct unf_lport_s *v_lport,
				  struct unf_rport_s *v_rport,
				  struct unf_lgn_parms_s *v_login_parms,
				  unsigned int v_cmd_code)
{
#define UNF_DELAY_TIME 100 /* WWPN smaller delay to send PRLI with COM mode */

	unsigned long long wwpn = INVALID_VALUE64;
	unsigned long long wwnn = INVALID_VALUE64;
	unsigned int ed_tov = 0;
	unsigned int remote_edtov = 0;

	if (v_login_parms->co_parms.bb_receive_data_field_size >
	    UNF_MAX_FRAME_SIZE)
		v_rport->max_frame_size = UNF_MAX_FRAME_SIZE;  // 2112
	else
		v_rport->max_frame_size =
			v_login_parms->co_parms.bb_receive_data_field_size;

	wwnn = (unsigned long long)
		(((unsigned long long)
		(v_login_parms->high_node_name) << 32) |
		((unsigned long long)v_login_parms->low_node_name));
	wwpn = (unsigned long long)
		(((unsigned long long)
		(v_login_parms->high_port_name) << 32) |
		((unsigned long long)v_login_parms->low_port_name));

	remote_edtov = v_login_parms->co_parms.e_d_tov;
	ed_tov = v_login_parms->co_parms.e_d_tov_resolution ?
			(remote_edtov / 1000000) : remote_edtov;

	v_rport->port_name = wwpn;
	v_rport->node_name = wwnn;
	v_rport->local_nport_id = v_lport->nport_id;

	if ((v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_PRIVATE_LOOP)) {
		/* P2P or Private Loop */
		v_lport->ed_tov = (v_lport->ed_tov > ed_tov) ?
			v_lport->ed_tov : ed_tov;
		v_lport->ra_tov = 2 * v_lport->ed_tov;  // 2 * E_D_TOV
		v_lport->rr_tov = UNF_CALC_LPORT_RRTOV(v_lport);

		if (ed_tov != 0)
			v_rport->ed_tov = ed_tov;
		else
			v_rport->ed_tov = UNF_DEFAULT_EDTOV;
	} else {
		/* SAN: E_D_TOV updated by FLOGI */
		v_rport->ed_tov = v_lport->ed_tov;
	}

	/* WWPN smaller: delay to send PRLI */
	if (v_rport->port_name > v_lport->port_name)
		v_rport->ed_tov += UNF_DELAY_TIME;  // 100ms

	/* Configure port parameters to low level (chip) */
	unf_cfg_lowlevel_port_params(v_lport, v_rport, v_login_parms,
				     v_cmd_code);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]Port(0x%x) RPort(0x%x) with WWPN(0x%llx) WWNN(0x%llx) login: ED_TOV(%u) Port: ED_TOV(%u)",
		  v_lport->port_id,
		  v_rport->nport_id,
		  v_rport->port_name, v_rport->node_name,
		  ed_tov,
		  v_lport->ed_tov);
}

static int unf_check_bbscn_is_enabled(unsigned char local_bbscn,
				      unsigned char remote_bbscn)
{
	return unf_determin_bbscn(local_bbscn, remote_bbscn) ?
				  UNF_TRUE : UNF_FALSE;
}

static unsigned int unf_irq_process_switch_2_thread(void *v_lport,
						    struct unf_xchg_s *v_xchg,
						    unf_evt_task v_evt_task)
{
	struct unf_cm_event_report *event = NULL;
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = 0;
	struct unf_lport_s *lport = NULL;

	UNF_CHECK_VALID(0x1996, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x1996, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
	lport = v_lport;
	xchg = v_xchg;

	if (unlikely((!lport->event_mgr.pfn_unf_get_free_event) ||
		     (!lport->event_mgr.pfn_unf_post_event) ||
		     (!lport->event_mgr.pfn_unf_release_event))) {
		UNF_TRACE(0x2065, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) event function is NULL",
			  lport->port_id);

		return UNF_RETURN_ERROR;
	}

	ret = unf_xchg_ref_inc(xchg, SFS_RESPONSE);
	UNF_CHECK_VALID(0x3343, UNF_TRUE, (ret == RETURN_OK),
			return UNF_RETURN_ERROR);

	event = lport->event_mgr.pfn_unf_get_free_event((void *)v_lport);
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, event,
			return UNF_RETURN_ERROR);

	event->lport = lport;
	event->event_asy_flag = UNF_EVENT_ASYN;
	event->pfn_unf_event_task = v_evt_task;
	event->para_in = v_xchg;
	lport->event_mgr.pfn_unf_post_event(lport, event);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]Port(0x%x) start to switch thread process now",
		  lport->port_id);

	return ret;
}

static unsigned int unf_plogi_handler_com_process(struct unf_xchg_s *v_xchg)
{
	struct unf_xchg_s *xchg = v_xchg;
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_plogi_pdisc_s *plogi_frame = NULL;
	struct unf_lgn_parms_s *login_parms = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned long flag = 0;

	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg->lport,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg->rport,
			return UNF_RETURN_ERROR);

	lport = xchg->lport;
	rport = xchg->rport;
	plogi_frame =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->plogi;
	login_parms = &plogi_frame->payload.parms;

	unf_save_plogi_params(lport, rport, login_parms,
			      ELS_PLOGI);

	/* Update state: PLOGI_WAIT */
	spin_lock_irqsave(&rport->rport_state_lock, flag);
	rport->nport_id = xchg->sid;
	unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	/* Send PLOGI ACC to remote port */
	ret = unf_send_plogi_acc(lport, rport, xchg);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x) send PLOGI ACC failed",
			  lport->port_id);

		/* NOTE: exchange has been freed inner(before) */
		unf_rport_error_recovery(rport);
		return ret;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]LOGIN: Port(0x%x) send PLOGI ACC to Port(0x%x) succeed",
		  lport->port_id, rport->nport_id);

	return ret;
}

static int unf_plogi_async_handle(void *v_argc_in, void *v_argc_out)
{
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_argc_in;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x2267, UNF_TRUE, xchg, return UNF_RETURN_ERROR);

	ret = unf_plogi_handler_com_process(xchg);
	unf_xchg_ref_dec(xchg, SFS_RESPONSE);

	return (int)ret;
}

static unsigned int unf_send_els_rjt_by_did(struct unf_lport_s *v_lport,
					    struct unf_xchg_s *v_xchg,
					    unsigned int v_did,
					    struct unf_rjt_info_s *v_rjt_info)
{
	struct unf_els_rjt_s *els_rjt = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = v_xchg;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);

	UNF_CHECK_VALID(0x3503, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3504, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	xchg->cmnd_code = UNF_SET_ELS_RJT_TYPE(v_rjt_info->els_cmnd_code);
	xchg->did = v_did;
	xchg->sid = v_lport->nport_id;
	xchg->oid = xchg->sid;
	xchg->lport = v_lport;
	xchg->rport = NULL;
	xchg->disc_rport = NULL;

	xchg->pfn_callback = NULL;
	xchg->pfn_ob_callback = NULL;

	unf_fill_package(&pkg, xchg, NULL);

	fc_entry = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, xchg);
		return UNF_RETURN_ERROR;
	}

	els_rjt = &fc_entry->els_rjt;
	memset(els_rjt, 0, sizeof(struct unf_els_rjt_s));
	unf_fill_rjt_pld(els_rjt, v_rjt_info->reason_code,
			 v_rjt_info->reason_explanation);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Send LS_RJT %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_did, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static unsigned int unf_plogi_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg)
{
	struct unf_xchg_s *xchg = v_xchg;
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;
	struct unf_plogi_pdisc_s *plogi_frame = NULL;
	struct unf_lgn_parms_s *login_parms = NULL;
	struct unf_rjt_info_s rjt_info = { 0 };
	unsigned long long wwpn = INVALID_VALUE64;
	unsigned int ret = UNF_RETURN_ERROR;
	int bbscn_enabled = UNF_FALSE;
	int switch_2_thread = UNF_FALSE;

	UNF_CHECK_VALID(0x3474, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3475, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	/* 1. Maybe: PLOGI is sent by Name server */
	if ((v_sid < UNF_FC_FID_DOM_MGR) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT))
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]LOGIN: Receive PLOGI. Port(0x%x_0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
			  v_lport->port_id, v_lport->nport_id, v_sid,
			  v_xchg->ox_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info,
			    UNF_SERVICE_ITEM_PLOGI);

	/* 2. State check: Offline */
	if (lport->en_states >= UNF_LPORT_ST_OFFLINE) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) received PLOGI with state(0x%x)",
			  lport->port_id, lport->nport_id, lport->en_states);

		unf_cm_free_xchg(lport, xchg);
		return UNF_RETURN_ERROR;
	}

	/*
	 * 3. According to FC-LS 4.2.7.1:
	 * After RCVD PLogi or send Plogi ACC, need to termitate open EXCH
	 */
	unf_cm_xchg_mgr_abort_io_by_id(lport, rport, v_sid, lport->nport_id, 0);

	/* Get R_Port by WWpn */
	plogi_frame =
		&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->plogi;
	login_parms = &plogi_frame->payload.parms;

	UNF_PRINT_SFS_LIMIT(UNF_INFO, lport->port_id,
			    &plogi_frame->payload,
			    sizeof(struct unf_plogi_payload_s));

	wwpn = (unsigned long long)
		(((unsigned long long)
		(login_parms->high_port_name) << 32) |
		((unsigned long long)login_parms->low_port_name));

	/* 4. Get (new) R_Port (by wwpn) */
	rport = unf_find_rport(lport, v_sid, wwpn);
	rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_ONLY, v_sid);
	if (!rport) {
		memset(&rjt_info, 0, sizeof(struct unf_rjt_info_s));
		rjt_info.els_cmnd_code = ELS_PLOGI;
		rjt_info.reason_code = UNF_LS_RJT_BUSY;
		rjt_info.reason_explanation =
			UNF_LS_RJT_INSUFFICIENT_RESOURCES;

		/* R_Port is NULL: Send ELS RJT for PLOGI */
		(void)unf_send_els_rjt_by_did(lport, xchg, v_sid, &rjt_info);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) has no RPort and send PLOGI reject",
			  lport->port_id);

		/* NOTE: exchange has been freed inner(before) */
		return UNF_RETURN_ERROR;
	}

	/* 5. Cancel recovery timer work after RCVD PLOGI */
	if (cancel_delayed_work(&rport->recovery_work))
		atomic_dec(&rport->rport_ref_cnt);

	/*
	 * 6. Plogi parameters check
	 * Call by: (RCVD) PLOGI handler & callback function for RCVD PLOGI_ACC
	 */
	ret = unf_check_plogi_params(lport, rport, login_parms);
	if (ret != RETURN_OK) {
		unf_cm_free_xchg(lport, xchg);
		return UNF_RETURN_ERROR;
	}

	xchg->lport = v_lport;
	xchg->rport = rport;
	xchg->sid = v_sid;

	/* 7. About bbscn for context change */
	bbscn_enabled = unf_check_bbscn_is_enabled(
		(unsigned char)lport->low_level_func.lport_cfg_items.bb_scn,
		(unsigned char)UNF_GET_BB_SC_N_FROM_PARAMS(login_parms));
	if ((lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT) &&
	    (bbscn_enabled == UNF_TRUE)) {
		switch_2_thread = UNF_TRUE;
		lport->b_bbscn_support = UNF_TRUE;
	}

	/* 8. Process PLOGI Frame: switch to thread if necessary */
	if ((switch_2_thread == UNF_TRUE) && (lport->root_lport == lport))
		/* Wait for LR complete sync */
		ret = unf_irq_process_switch_2_thread(lport, xchg,
						      unf_plogi_async_handle);
	else
		ret = unf_plogi_handler_com_process(xchg);

	return ret;
}

static void unf_obtain_tape_capacity(struct unf_lport_s *v_lport,
				     struct unf_rport_s *v_rport,
				     unsigned int tape_parm)
{
	unsigned int rec_support = 0;
	unsigned int task_retry_support = 0;
	unsigned int retry_support = 0;

	rec_support = tape_parm & UNF_FC4_FRAME_PARM_3_REC_SUPPORT;
	task_retry_support = tape_parm &
				UNF_FC4_FRAME_PARM_3_TASK_RETRY_ID_SUPPORT;
	retry_support = tape_parm & UNF_FC4_FRAME_PARM_3_RETRY_SUPPORT;

	if ((v_lport->low_level_func.lport_cfg_items.tape_support) &&
	    rec_support && task_retry_support && retry_support) {
		v_rport->tape_support_needed = UNF_TRUE;

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x_0x%x) FC_tape is needed for RPort(0x%x)",
			  v_lport->port_id, v_lport->nport_id,
			  v_rport->nport_id);
	}

	if ((tape_parm & UNF_FC4_FRAME_PARM_3_CONF_ALLOW) &&
	    (v_lport->low_level_func.lport_cfg_items.fcp_conf != UNF_FALSE)) {
		v_rport->fcp_conf_needed = UNF_TRUE;

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x_0x%x) FCP confirm is needed for RPort(0x%x)",
			  v_lport->port_id, v_lport->nport_id,
			  v_rport->nport_id);
	}
}

unsigned int unf_prli_handler_com_process(struct unf_xchg_s *v_xchg)
{
	struct unf_prli_prlo_s *prli = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned long flags = 0;
	unsigned int uisid = 0;
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_xchg_s *xchg = NULL;

	xchg = v_xchg;
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg->lport,
			return UNF_RETURN_ERROR);
	lport = xchg->lport;
	uisid = v_xchg->sid;

	UNF_SERVICE_COLLECT(lport->link_service_info, UNF_SERVICE_ITEM_PRLI);

	/* 1. Get R_Port: for each R_Port from rport_busy_list */
	rport = unf_get_rport_by_nport_id(lport, uisid);
	if (!rport) {
		/* non session (R_Port) existence */
		(void)unf_send_logo_by_did(lport, uisid);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) received PRLI but no RPort SID(0x%x) OX_ID(0x%x)",
			  lport->port_id, lport->nport_id, uisid,
			  v_xchg->ox_id);

		unf_cm_free_xchg(lport, v_xchg);
		return ret;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]LOGIN: Receive PRLI. Port(0x%x)<---RPort(0x%x) with S_ID(0x%x)",
		  lport->port_id, rport->nport_id, uisid);

	/* 2. Get PRLI info */
	prli = &v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->prli;
	if ((uisid < UNF_FC_FID_DOM_MGR) ||
	    (lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]LOGIN: Receive PRLI. Port(0x%x_0x%x)<---RPort(0x%x) parameter-3(0x%x) OX_ID(0x%x)",
			  lport->port_id, lport->nport_id, uisid,
			  prli->payload.parms[3], v_xchg->ox_id);
	}

	UNF_PRINT_SFS_LIMIT(UNF_INFO, lport->port_id,
			    &prli->payload, sizeof(struct unf_pril_payload_s));

	spin_lock_irqsave(&rport->rport_state_lock, flags);

	/* 3. Increase R_Port ref_cnt */
	ret = unf_rport_ref_inc(rport);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) RPort(0x%x_0x%p) is removing and do nothing",
			  lport->port_id, rport->nport_id, rport);

		spin_unlock_irqrestore(&rport->rport_state_lock, flags);

		unf_cm_free_xchg(lport, v_xchg);
		return RETURN_OK;
	}

	/* 4. Cancel R_Port Open work */
	if (cancel_delayed_work(&rport->open_work)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x_0x%x) RPort(0x%x) cancel open work succeed",
			  lport->port_id, lport->nport_id, rport->nport_id);

		/* This is not the last counter */
		atomic_dec(&rport->rport_ref_cnt);
	}

	/* 5. Check R_Port state */
	if ((rport->rp_state != UNF_RPORT_ST_PRLI_WAIT) &&
	    (rport->rp_state != UNF_RPORT_ST_READY)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) RPort(0x%x) with state(0x%x) when received PRLI, send LOGO",
			  lport->port_id, lport->nport_id,
			  rport->nport_id, rport->rp_state);

		unf_rport_state_ma(rport, UNF_EVENT_RPORT_LOGO);  // LOGO
		spin_unlock_irqrestore(&rport->rport_state_lock, flags);

		/* NOTE: Start to send LOGO */
		unf_rport_enter_logo(lport, rport);

		unf_cm_free_xchg(lport, v_xchg);
		unf_rport_ref_dec(rport);

		return ret;
	}

	spin_unlock_irqrestore(&rport->rport_state_lock, flags);

	/* 6. Update R_Port options(INI/TGT/BOTH) */
	rport->options = prli->payload.parms[3] &
				(UNF_FC4_FRAME_PARM_3_TGT |
				UNF_FC4_FRAME_PARM_3_INI);

	unf_update_port_feature(rport->port_name, rport->options);

	/* for Confirm */
	rport->fcp_conf_needed = UNF_FALSE;

	unf_obtain_tape_capacity(lport, rport, prli->payload.parms[3]);

	if ((prli->payload.parms[3] & UNF_FC4_FRAME_PARM_3_CONF_ALLOW) &&
	    (lport->low_level_func.lport_cfg_items.fcp_conf != UNF_FALSE)) {
		rport->fcp_conf_needed = UNF_TRUE;

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x_0x%x) FCP confirm is needed for RPort(0x%x)",
			  lport->port_id, lport->nport_id, rport->nport_id);
	}
	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]Port(0x%x_0x%x) RPort(0x%x) parameter-3(0x%x) options(0x%x)",
		  lport->port_id, lport->nport_id, rport->nport_id,
		  prli->payload.parms[3], rport->options);

	/* 7. Send PRLI ACC */
	ret = unf_send_prli_acc(lport, rport, v_xchg);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x) RPort(0x%x) send PRLI ACC failed",
			  lport->port_id, lport->nport_id, rport->nport_id);

		/* NOTE: exchange has been freed inner(before) */
		unf_rport_error_recovery(rport);
	}

	/* 8. Decrease R_Port ref_cnt */
	unf_rport_ref_dec(rport);

	return ret;
}

static int unf_prli_async_handle(void *v_argc_in, void *v_argc_out)
{
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_argc_in;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x2267, UNF_TRUE, xchg, return UNF_RETURN_ERROR);

	ret = unf_prli_handler_com_process(xchg);

	unf_xchg_ref_dec(xchg, SFS_RESPONSE);

	return (int)ret;
}

static unsigned int unf_prli_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg)
{
	unsigned int ret = UNF_RETURN_ERROR;
	int switch_2_thread = UNF_FALSE;
	struct unf_lport_s *lport = NULL;

	UNF_CHECK_VALID(0x3476, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3477, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	v_xchg->sid = v_sid;
	v_xchg->lport = v_lport;
	lport = v_lport;

	if ((v_lport->b_bbscn_support) &&
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT))
		switch_2_thread = UNF_TRUE;

	if ((switch_2_thread == UNF_TRUE) && (lport->root_lport == lport))
		/* Wait for LR done sync */
		ret = unf_irq_process_switch_2_thread(v_lport, v_xchg,
						      unf_prli_async_handle);
	else
		ret = unf_prli_handler_com_process(v_xchg);

	return ret;
}

static void unf_save_rscn_port_id(
			struct unf_rscn_mg_s *v_rscn_mg,
			struct unf_rscn_port_id_page_s *v_rscn_port_id)
{
	struct unf_port_id_page_s *exit_port_id_page = NULL;
	struct unf_port_id_page_s *new_port_id_page = NULL;
	struct list_head *node = NULL;
	struct list_head *next_node = NULL;
	unsigned long flag = 0;
	enum int_e repeat = UNF_FALSE;

	UNF_CHECK_VALID(0x3478, UNF_TRUE, v_rscn_mg, return);
	UNF_CHECK_VALID(0x3479, UNF_TRUE, v_rscn_port_id, return);

	/* 1. check new RSCN Port_ID (RSNC_Page)
	 * whether within RSCN_Mgr or not
	 */
	spin_lock_irqsave(&v_rscn_mg->rscn_id_list_lock, flag);
	if (list_empty(&v_rscn_mg->list_using_rscn_page)) {
		repeat = UNF_FALSE;
	} else {
		/* Check repeat: for each exist RSCN page
		 * form RSCN_Mgr Page list
		 */
		list_for_each_safe(node, next_node,
				   &v_rscn_mg->list_using_rscn_page) {
			exit_port_id_page =
				list_entry(node, struct unf_port_id_page_s,
					   list_node_rscn);
			if ((exit_port_id_page->port_id_port ==
			     v_rscn_port_id->port_id_port) &&
			    (exit_port_id_page->port_id_area ==
			     v_rscn_port_id->port_id_area) &&
			    (exit_port_id_page->port_id_domain ==
			     v_rscn_port_id->port_id_domain)) {
				repeat = UNF_TRUE;
				break;
			}
		}
	}
	spin_unlock_irqrestore(&v_rscn_mg->rscn_id_list_lock, flag);

	UNF_CHECK_VALID(0x3480, UNF_TRUE, v_rscn_mg->pfn_unf_get_free_rscn_node,
			return);

	/* 2. Get & add free RSNC Node --->>> RSCN_Mgr */
	if (repeat == UNF_FALSE) {
		new_port_id_page =
			v_rscn_mg->pfn_unf_get_free_rscn_node(v_rscn_mg);
		if (!new_port_id_page) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_ERR,
				  UNF_LOG_LOGIN_ATT, UNF_ERR,
				  "[err]Get free RSCN node failed");

			return;
		}

		new_port_id_page->uc_addr_format = v_rscn_port_id->addr_format;
		new_port_id_page->uc_event_qualifier =
			v_rscn_port_id->event_qualifier;
		new_port_id_page->uc_reserved = v_rscn_port_id->reserved;
		new_port_id_page->port_id_domain =
			v_rscn_port_id->port_id_domain;
		new_port_id_page->port_id_area = v_rscn_port_id->port_id_area;
		new_port_id_page->port_id_port = v_rscn_port_id->port_id_port;

		/* Add entry to list: using_rscn_page */
		spin_lock_irqsave(&v_rscn_mg->rscn_id_list_lock, flag);
		list_add_tail(&new_port_id_page->list_node_rscn,
			      &v_rscn_mg->list_using_rscn_page);
		spin_unlock_irqrestore(&v_rscn_mg->rscn_id_list_lock, flag);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x) has repeat RSCN node with domain(0x%x) area(0x%x)",
			  v_rscn_port_id->port_id_domain,
			  v_rscn_port_id->port_id_area,
			  v_rscn_port_id->port_id_port);
	}
}

static unsigned int unf_analysis_rscn_payload(struct unf_lport_s *v_lport,
					      struct unf_rscn_pld_s *v_rscn_pld)
{
#define UNF_OS_DISC_REDISC_TIME 10000

	struct unf_rscn_port_id_page_s *rscn_port_id = NULL;
	struct unf_disc_s *disc = NULL;
	struct unf_rscn_mg_s *rscn_mgr = NULL;
	unsigned int i = 0;
	unsigned int pld_len = 0;
	unsigned int port_id_page_cnt = 0;
	unsigned int ret = RETURN_OK;
	unsigned long flag = 0;
	enum int_e need_disc_flag = UNF_FALSE;

	UNF_CHECK_VALID(0x3481, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3482, UNF_TRUE, v_rscn_pld, return UNF_RETURN_ERROR);

	/* This field is the length in bytes of the entire Payload,
	 * inclusive of the word 0
	 */
	pld_len = UNF_GET_RSCN_PLD_LEN(v_rscn_pld->cmnd);
	pld_len -= sizeof(v_rscn_pld->cmnd);
	port_id_page_cnt = pld_len / UNF_RSCN_PAGE_LEN;

	/* Pages within payload is nor more than 255 */
	if (port_id_page_cnt > UNF_RSCN_PAGE_SUM) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x_0x%x) page num(0x%x) exceed 255 in RSCN",
			  v_lport->port_id, v_lport->nport_id,
			  port_id_page_cnt);

		return UNF_RETURN_ERROR;
	}

	/* L_Port-->Disc-->Rscn_Mgr */
	disc = &v_lport->disc;
	rscn_mgr = &disc->rscn_mgr;

	/* for each ID from RSCN_Page: check whether need to Disc or not */
	while (i < port_id_page_cnt) {
		rscn_port_id = &v_rscn_pld->port_id_page[i];
		if (unf_lookup_lport_by_nport_id(v_lport, *(unsigned int *)rscn_port_id)) {
		/* Prevent to create session with L_Port which have the same N_Port_ID */
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_INFO,
				  "[info]Port(0x%x) find local N_Port_ID(0x%x) within RSCN payload",
				  ((struct unf_lport_s *)
				  (v_lport->root_lport))->nport_id,
				  *(unsigned int *)rscn_port_id);
		} else {
			/* New RSCN_Page ID find, save it to RSCN_Mgr */
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_INFO,
				  "[info]Port(0x%x_0x%x) save RSCN N_Port_ID(0x%x)",
				  v_lport->port_id, v_lport->nport_id,
				  *(unsigned int *)rscn_port_id);

			/* 1. new RSCN_Page ID find, save it to RSCN_Mgr */
			unf_save_rscn_port_id(rscn_mgr, rscn_port_id);
			need_disc_flag = UNF_TRUE;
			unf_report_io_dm_event(v_lport, ELS_RSCN,
					       *(unsigned int *)rscn_port_id);
		}
		i++;
	}

	if (need_disc_flag != UNF_TRUE) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_NORMAL, UNF_MAJOR,
			  "[info]Port(0x%x) find all N_Port_ID and do not need to disc",
			 ((struct unf_lport_s *)(v_lport->root_lport))->nport_id);

		return RETURN_OK;
	}

	/* 2. Do/Start Disc: Check & do Disc (GID_PT) process */
	if (!disc->unf_disc_temp.pfn_unf_disc_start) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) DISC start function is NULL",
			  v_lport->nport_id, v_lport->nport_id);

		return UNF_RETURN_ERROR;
	}

	spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
	if ((disc->en_states == UNF_DISC_ST_END) ||
	    ((jiffies - disc->last_disc_jiff) >
	    msecs_to_jiffies(UNF_OS_DISC_REDISC_TIME))) {
		disc->disc_option = UNF_RSCN_DISC;
		disc->last_disc_jiff = jiffies;
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

		ret = disc->unf_disc_temp.pfn_unf_disc_start(v_lport);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_ABNORMAL, UNF_INFO,
			  "[info]Port(0x%x_0x%x) DISC state(0x%x) with last time(%llu) and don't do DISC",
			  v_lport->port_id, v_lport->nport_id,
			  disc->en_states, disc->last_disc_jiff);

		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);
	}

	return ret;
}

static unsigned int unf_rscn_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg)
{
	/*
	 * A RSCN ELS shall be sent to registered Nx_Ports
	 * when an event occurs that may have affected the state of
	 * one or more Nx_Ports, or the ULP state within the Nx_Port.
	 *
	 * The Payload of a RSCN Request includes a list
	 * containing the addresses of the affected Nx_Ports.
	 *
	 * Each affected Port_ID page contains the ID of the Nx_Port,
	 * Fabric Controller, E_Port, domain, or area for
	 * which the event was detected.
	 */
	struct unf_rscn_pld_s *rscn_pld = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int pld_len = 0;

	UNF_REFERNCE_VAR(pld_len);
	UNF_CHECK_VALID(0x3483, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3484, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]Receive RSCN Port(0x%x_0x%x)<---RPort(0x%x) OX_ID(0x%x)",
		  v_lport->port_id, v_lport->nport_id, v_sid,
		  v_xchg->ox_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info,
			    UNF_SERVICE_ITEM_RSCN);

	/* 1. Get R_Port by S_ID */
	rport = unf_get_rport_by_nport_id(v_lport, v_sid);  // rport busy_list
	if (!rport) {
		rport = unf_rport_get_free_and_init(v_lport,
						    UNF_PORT_TYPE_FC, v_sid);
		if (!rport) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x_0x%x) received RSCN but has no RPort(0x%x) with OX_ID(0x%x)",
				  v_lport->port_id, v_lport->nport_id,
				  v_sid, v_xchg->ox_id);

			unf_cm_free_xchg(v_lport, v_xchg);
			return UNF_RETURN_ERROR;
		}

		rport->nport_id = v_sid;
	}

	rscn_pld =
		v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->rscn.rscn_pld;
	UNF_CHECK_VALID(0x3485, UNF_TRUE, NULL != rscn_pld,
			return UNF_RETURN_ERROR);
	pld_len = UNF_GET_RSCN_PLD_LEN(rscn_pld->cmnd);
	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, rscn_pld, pld_len);

	/* 2. NOTE: Analysis RSCN payload(save & disc if necessary) */
	ret = unf_analysis_rscn_payload(v_lport, rscn_pld);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) analysis RSCN failed",
			  v_lport->port_id, v_lport->nport_id);

	/* 3. send rscn_acc after analysis payload */
	ret = unf_send_rscn_acc(v_lport, rport, v_xchg);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) send RSCN response failed",
			  v_lport->port_id, v_lport->nport_id);

		return UNF_RETURN_ERROR;
	}

	UNF_REFERNCE_VAR(pld_len);
	return ret;
}

static void unf_analysis_pdisc_pld(struct unf_lport_s *v_lport,
				   struct unf_rport_s *v_rport,
				   struct unf_plogi_pdisc_s *v_pdisc)
{
	struct unf_lgn_parms_s *pdisc_params = NULL;
	unsigned long long wwpn = INVALID_VALUE64;
	unsigned long long wwnn = INVALID_VALUE64;

	UNF_CHECK_VALID(0x3486, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3487, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3488, UNF_TRUE, v_pdisc, return);
	UNF_REFERNCE_VAR(v_lport);

	pdisc_params = &v_pdisc->payload.parms;
	if (pdisc_params->co_parms.bb_receive_data_field_size >
	    UNF_MAX_FRAME_SIZE)
		v_rport->max_frame_size = UNF_MAX_FRAME_SIZE;  // 2112
	else
		v_rport->max_frame_size =
			pdisc_params->co_parms.bb_receive_data_field_size;

	wwnn = (unsigned long long)
		(((unsigned long long)
		(pdisc_params->high_node_name) << 32) |
		((unsigned long long)pdisc_params->low_node_name));
	wwpn = (unsigned long long)
		(((unsigned long long)(pdisc_params->high_port_name) << 32) |
		((unsigned long long)pdisc_params->low_port_name));

	v_rport->port_name = wwpn;
	v_rport->node_name = wwnn;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]Port(0x%x) save PDISC parameters to Rport(0x%x) WWPN(0x%llx) WWNN(0x%llx)",
		  v_lport->port_id, v_rport->nport_id,
		  v_rport->port_name, v_rport->node_name);
}

static unsigned int unf_send_pdisc_rjt(struct unf_lport_s *v_lport,
				       struct unf_rport_s *v_rport,
				       struct unf_xchg_s *v_xchg)
{
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_rjt_info_s rjt_info;

	UNF_CHECK_VALID(0x3432, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3433, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3434, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	memset(&rjt_info, 0, sizeof(struct unf_rjt_info_s));
	rjt_info.els_cmnd_code = ELS_PDISC;
	rjt_info.reason_code = UNF_LS_RJT_LOGICAL_ERROR;
	rjt_info.reason_explanation = UNF_LS_RJT_NO_ADDITIONAL_INFO;

	ret = unf_send_els_rjt_by_rport(v_lport, v_xchg, v_rport, &rjt_info);

	return ret;
}

static unsigned int unf_pdisc_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg)
{
	struct unf_plogi_pdisc_s *pdisc = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned long flags = 0;
	unsigned int ret = RETURN_OK;
	unsigned long long wwpn = 0;

	UNF_CHECK_VALID(0x3489, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3490, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Receive PDISC. Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
		  v_lport->port_id, v_sid, v_xchg->ox_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info, UNF_SERVICE_ITEM_PDISC);
	pdisc = &v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->pdisc;
	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id,
			    &pdisc->payload,
			    sizeof(struct unf_plogi_payload_s));
	wwpn = (unsigned long long)
		(((unsigned long long)
		(pdisc->payload.parms.high_port_name) << 32) |
		((unsigned long long)pdisc->payload.parms.low_port_name));

	rport = unf_find_rport(v_lport, v_sid, wwpn);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can't find RPort by NPort ID(0x%x). Free exchange and send LOGO",
			  v_lport->port_id, v_sid);

		unf_cm_free_xchg(v_lport, v_xchg);
		(void)unf_send_logo_by_did(v_lport, v_sid);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MINOR,
			  "[info]Port(0x%x) get exist RPort(0x%x) when receive PDISC with S_Id(0x%x)",
			  v_lport->port_id, rport->nport_id, v_sid);

		if (v_sid >= UNF_FC_FID_DOM_MGR)
			return unf_send_pdisc_rjt(v_lport, rport, v_xchg);

		unf_analysis_pdisc_pld(v_lport, rport, pdisc);

		/* State: READY */
		spin_lock_irqsave(&rport->rport_state_lock, flags);
		if (rport->rp_state == UNF_RPORT_ST_READY) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]Port(0x%x) find RPort(0x%x) state is READY when receiving PDISC",
				  v_lport->port_id, v_sid);

			spin_unlock_irqrestore(&rport->rport_state_lock,
					       flags);

			ret = unf_send_pdisc_acc(v_lport, rport, v_xchg);
			if (ret != RETURN_OK) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
					  UNF_LOG_LOGIN_ATT, UNF_WARN,
					  "[warn]Port(0x%x) handle PDISC failed",
					 v_lport->port_id);

				return ret;
			}

			/* Report Down/Up event to scsi */
			unf_update_lport_state_by_linkup_event(v_lport, rport,
							       rport->options);
		}
		/* State: Closing */
		else if ((rport->rp_state == UNF_RPORT_ST_CLOSING) &&
			 (rport->session)) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) find RPort(0x%x) state is 0x%x when receiving PDISC",
				  v_lport->port_id, v_sid, rport->rp_state);

			spin_unlock_irqrestore(&rport->rport_state_lock,
					       flags);

			unf_cm_free_xchg(v_lport, v_xchg);
			(void)unf_send_logo_by_did(v_lport, v_sid);
		}
		/* State: PRLI_WAIT */
		else if (rport->rp_state == UNF_RPORT_ST_PRLI_WAIT) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]Port(0x%x) find RPort(0x%x) state is 0x%x when receiving PDISC",
				  v_lport->port_id, v_sid, rport->rp_state);

			spin_unlock_irqrestore(&rport->rport_state_lock, flags);

			ret = unf_send_pdisc_acc(v_lport, rport, v_xchg);
			if (ret != RETURN_OK) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
					  UNF_LOG_LOGIN_ATT,
					  UNF_WARN,
					  "[warn]Port(0x%x) handle PDISC failed",
					 v_lport->port_id);

				return ret;
			}
		} else {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) find RPort(0x%x) state is 0x%x when receiving PDISC, send LOGO",
				  v_lport->port_id, v_sid, rport->rp_state);

			unf_rport_state_ma(rport, UNF_EVENT_RPORT_LOGO);
			spin_unlock_irqrestore(&rport->rport_state_lock, flags);

			unf_rport_enter_logo(v_lport, rport);
			unf_cm_free_xchg(v_lport, v_xchg);
		}
	}

	return ret;
}

static void unf_analysis_adisc_pld(struct unf_lport_s *v_lport,
				   struct unf_rport_s *v_rport,
				   struct unf_adisc_payload_s *v_adisc_pld)
{
	unsigned long long wwpn = INVALID_VALUE64;
	unsigned long long wwnn = INVALID_VALUE64;

	UNF_CHECK_VALID(0x3491, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3492, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3493, UNF_TRUE, v_adisc_pld, return);
	UNF_REFERNCE_VAR(v_lport);

	wwnn = (unsigned long long)
		(((unsigned long long)(v_adisc_pld->high_node_name) << 32) |
			((unsigned long long)v_adisc_pld->low_node_name));
	wwpn = (unsigned long long)
		(((unsigned long long)(v_adisc_pld->high_port_name) << 32) |
			((unsigned long long)v_adisc_pld->low_port_name));

	v_rport->port_name = wwpn;
	v_rport->node_name = wwnn;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]Port(0x%x) save ADISC parameters to RPort(0x%x), WWPN(0x%llx) WWNN(0x%llx) NPort ID(0x%x)",
		  v_lport->port_id, v_rport->nport_id,
		  v_rport->port_name, v_rport->node_name,
		  v_adisc_pld->nport_id);
}

static unsigned int unf_adisc_handler(struct unf_lport_s *v_lport,
				      unsigned int v_sid,
				      struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	struct unf_adisc_payload_s *adisc_pld = NULL;
	unsigned long flags = 0;
	unsigned long long wwpn = 0;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3494, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3495, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Receive ADISC. Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
		  v_lport->port_id, v_sid, v_xchg->ox_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info,
			    UNF_SERVICE_ITEM_ADISC);
	adisc_pld = &v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->adisc.adisc_payl;
	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, adisc_pld,
			    sizeof(struct unf_adisc_payload_s));
	wwpn = (unsigned long long)
		(((unsigned long long)(adisc_pld->high_port_name) << 32) |
			((unsigned long long)adisc_pld->low_port_name));

	rport = unf_find_rport(v_lport, v_sid, wwpn);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) can't find RPort by NPort ID(0x%x). Free exchange and send LOGO",
			  v_lport->port_id, v_sid);

		unf_cm_free_xchg(v_lport, v_xchg);
		(void)unf_send_logo_by_did(v_lport, v_sid);

		return ret;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MINOR,
		  "[info]Port(0x%x) get exist RPort(0x%x) when receive ADISC with S_ID(0x%x)",
		  v_lport->port_id, rport->nport_id, v_sid);

	unf_analysis_adisc_pld(v_lport, rport, adisc_pld);

	/* State: READY */
	spin_lock_irqsave(&rport->rport_state_lock, flags);
	if (rport->rp_state == UNF_RPORT_ST_READY) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]Port(0x%x) find RPort(0x%x) state is READY when receiving ADISC",
			  v_lport->port_id, v_sid);

		spin_unlock_irqrestore(&rport->rport_state_lock, flags);

		/* Return ACC directly */
		ret = unf_send_adisc_acc(v_lport, rport, v_xchg);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) send ADISC ACC failed",
				  v_lport->port_id);

			return ret;
		}

		/* Report Down/Up event to SCSI */
		unf_update_lport_state_by_linkup_event(v_lport, rport,
						       rport->options);
	}
	/* State: Closing */
	else if ((rport->rp_state == UNF_RPORT_ST_CLOSING) &&
		 (rport->session)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) find RPort(0x%x) state is 0x%x when receiving ADISC",
			  v_lport->port_id, v_sid, rport->rp_state);

		spin_unlock_irqrestore(&rport->rport_state_lock, flags);

		rport = unf_get_safe_rport(v_lport, rport,
					   UNF_RPORT_REUSE_RECOVER,
					   rport->nport_id);
		if (rport) {
			spin_lock_irqsave(&rport->rport_state_lock, flags);
			rport->nport_id = v_sid;
			spin_unlock_irqrestore(&rport->rport_state_lock,
					       flags);

			ret = unf_send_adisc_acc(v_lport, rport, v_xchg);
			if (ret != RETURN_OK) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
					  UNF_LOG_LOGIN_ATT, UNF_WARN,
					  "[warn]Port(0x%x) send ADISC ACC failed",
					 v_lport->port_id);

				return ret;
			}

			unf_update_lport_state_by_linkup_event(v_lport, rport,
							       rport->options);
		} else {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) can't find RPort by NPort_ID(0x%x). Free exchange and send LOGO",
				  v_lport->port_id, v_sid);

			unf_cm_free_xchg(v_lport, v_xchg);
			(void)unf_send_logo_by_did(v_lport, v_sid);
		}
	}
	/* State: PRLI_WAIT */
	else if (rport->rp_state == UNF_RPORT_ST_PRLI_WAIT) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]Port(0x%x) find RPort(0x%x) state is 0x%x when receiving ADISC",
			  v_lport->port_id, v_sid, rport->rp_state);

		spin_unlock_irqrestore(&rport->rport_state_lock, flags);

		ret = unf_send_adisc_acc(v_lport, rport, v_xchg);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) send ADISC ACC failed",
				  v_lport->port_id);

			return ret;
		}
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) find RPort(0x%x) state is 0x%x when receiving ADISC, send LOGO",
			  v_lport->port_id, v_sid, rport->rp_state);

		unf_rport_state_ma(rport, UNF_EVENT_RPORT_LOGO);
		spin_unlock_irqrestore(&rport->rport_state_lock, flags);

		unf_rport_enter_logo(v_lport, rport);
		unf_cm_free_xchg(v_lport, v_xchg);
	}

	return ret;
}

static unsigned int unf_rec_handler(struct unf_lport_s *v_lport,
				    unsigned int v_sid,
				    struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3496, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3497, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
	UNF_REFERNCE_VAR(v_sid);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Port(0x%x) receive REC", v_lport->port_id);

	/* Send rec acc */
	ret = unf_send_rec_acc(v_lport, rport, v_xchg);  // discard directly

	return ret;
}

static unsigned int unf_rrq_handler(struct unf_lport_s *v_lport,
				    unsigned int v_sid,
				    struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	struct unf_rrq_s *rrq = NULL;
	struct unf_xchg_s *xchg_reused = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	unsigned int sid = 0;
	unsigned long flags = 0;
	struct unf_rjt_info_s rjt_info = { 0 };
	struct unf_xchg_hot_pool_s *hot_pool = NULL;

	UNF_CHECK_VALID(0x3498, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3499, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
	UNF_REFERNCE_VAR(rx_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info, UNF_SERVICE_ITEM_RRQ);
	rrq = &v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->rrq;
	ox_id = (unsigned short)(rrq->oxid_rxid >> 16);
	rx_id = (unsigned short)(rrq->oxid_rxid);
	sid = rrq->sid & UNF_NPORTID_MASK;

	UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_KEVENT,
		  "[warn]Receive RRQ. Port(0x%x)<---RPort(0x%x) sfsXchg(0x%p) OX_ID(0x%x,0x%x) RX_ID(0x%x)",
		  v_lport->port_id, v_sid, v_xchg,
		  ox_id, v_xchg->ox_id, rx_id);

	/* Get R_Port */
	rport = unf_get_rport_by_nport_id(v_lport, v_sid);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
			  "[warn]Port(0x%x) receive RRQ but has no RPort(0x%x)",
			  v_lport->port_id, v_sid);

		/* NOTE: send LOGO */
		ret = unf_send_logo_by_did(v_lport, sid);

		unf_cm_free_xchg(v_lport, v_xchg);
		return ret;
	}

	/* Get Target (Abort I/O) exchange context */
	/* UNF_FindXchgByOxId */
	xchg_reused = unf_cm_lookup_xchg_by_id(v_lport, ox_id, sid);
	if (!xchg_reused) {
		UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
			  "[warn]Port(0x%x) cannot find exchange with OX_ID(0x%x) RX_ID(0x%x) S_ID(0x%x)",
			  v_lport->port_id, ox_id, rx_id, sid);

		rjt_info.els_cmnd_code = ELS_RRQ;
		rjt_info.reason_code = FCXLS_BA_RJT_LOGICAL_ERROR |
			FCXLS_LS_RJT_INVALID_OXID_RXID;

		/* NOTE: send ELS RJT */
		if (unf_send_els_rjt_by_rport(v_lport, v_xchg,
					      rport, &rjt_info) !=
		    RETURN_OK) {
			unf_cm_free_xchg(v_lport, v_xchg);
			return UNF_RETURN_ERROR;
		}

		return RETURN_OK;
	}

	hot_pool = xchg_reused->hot_pool;
	if (unlikely(!hot_pool)) {
		UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
			  "Port(0x%x) OxId(0x%x) Rxid(0x%x) Sid(0x%x) Hot Pool is NULL.",
			  v_lport->port_id, ox_id, rx_id, sid);

		return ret;
	}

	spin_lock_irqsave(&hot_pool->xchg_hot_pool_lock, flags);
	xchg_reused->ox_id = INVALID_VALUE16;
	xchg_reused->rx_id = INVALID_VALUE16;
	spin_unlock_irqrestore(&hot_pool->xchg_hot_pool_lock, flags);

	/* NOTE: release I/O exchange context */
	unf_xchg_ref_dec(xchg_reused, SFS_RESPONSE);

	/* Send RRQ ACC */
	ret = unf_send_rrq_acc(v_lport, rport, v_xchg);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can not send RRQ rsp. Xchg(0x%p) Ioxchg(0x%p) OX_RX_ID(0x%x 0x%x) S_ID(0x%x)",
			  v_lport->port_id, v_xchg,
			  xchg_reused, ox_id, rx_id, sid);

		unf_cm_free_xchg(v_lport, v_xchg);
		return ret;
	}

	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static unsigned int unf_send_els_rjt_by_rport(struct unf_lport_s *v_lport,
					      struct unf_xchg_s *v_xchg,
					      struct unf_rport_s *v_rport,
					      struct unf_rjt_info_s *v_rjt_info)
{
	struct unf_els_rjt_s *els_rjt = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = v_xchg;
	struct unf_frame_pkg_s pkg = { 0 };
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);

	UNF_CHECK_VALID(0x3500, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3501, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3502, UNF_TRUE, v_rport, return UNF_RETURN_ERROR);

	xchg->cmnd_code = UNF_SET_ELS_RJT_TYPE(v_rjt_info->els_cmnd_code);
	xchg->did = v_rport->nport_id;
	xchg->sid = v_lport->nport_id;
	xchg->oid = xchg->sid;
	xchg->lport = v_lport;
	xchg->rport = v_rport;
	xchg->disc_rport = NULL;

	xchg->pfn_callback = NULL;
	xchg->pfn_ob_callback = NULL;

	unf_fill_package(&pkg, xchg, v_rport);

	fc_entry = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, xchg);
		return UNF_RETURN_ERROR;
	}

	els_rjt = &fc_entry->els_rjt;
	memset(els_rjt, 0, sizeof(struct unf_els_rjt_s));
	unf_fill_rjt_pld(els_rjt, v_rjt_info->reason_code,
			 v_rjt_info->reason_explanation);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Send LS_RJT for 0x%x %s. Port(0x%x)--->rport(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
		  v_rjt_info->els_cmnd_code,
		  (ret != RETURN_OK) ? "failed" : "succeed",
		  v_lport->port_id, v_rport->nport_id, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);

	return ret;
}

static unsigned int unf_els_cmnd_default_handler(struct unf_lport_s *v_lport,
						 struct unf_xchg_s *v_xchg,
						 unsigned int v_sid,
						 unsigned int v_els_cmnd_code)
{
#define ELS_LCB 0X81
#define ELS_RDP 0X18

	struct unf_rport_s *rport = NULL;
	struct unf_rjt_info_s rjt_info = { 0 };
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3505, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3506, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	if ((v_els_cmnd_code != ELS_LCB) && (v_els_cmnd_code != ELS_RDP)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_ABNORMAL, UNF_KEVENT,
			  "[info]Receive Unknown ELS command(0x%x). Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
			  v_els_cmnd_code, v_lport->port_id, v_sid,
			  v_xchg->ox_id);
	}

	memset(&rjt_info, 0, sizeof(struct unf_rjt_info_s));
	rjt_info.els_cmnd_code = v_els_cmnd_code;
	rjt_info.reason_code = UNF_LS_RJT_NOT_SUPPORTED;

	rport = unf_get_rport_by_nport_id(v_lport, v_sid);
	if (rport)
		ret = unf_send_els_rjt_by_rport(v_lport, v_xchg, rport,
						&rjt_info);
	else
		ret = unf_send_els_rjt_by_did(v_lport, v_xchg, v_sid,
					      &rjt_info);

	return ret;
}

static struct unf_xchg_s *unf_alloc_xchg_for_rcv_cmnd(
					struct unf_lport_s *v_lport,
					struct unf_frame_pkg_s *v_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned long flags = 0;
	unsigned int i = 0;
	unsigned int offset = 0;
	unsigned char *cmnd_pld = NULL;
	unsigned int first_dword = 0;
	unsigned int alloc_time = 0;

	UNF_CHECK_VALID(0x3508, UNF_TRUE, v_lport, return NULL);
	UNF_CHECK_VALID(0x3509, UNF_TRUE, v_pkg, return NULL);

	if (!v_pkg->xchg_contex) {
		xchg = unf_cm_get_free_xchg(v_lport, UNF_XCHG_TYPE_SFS);
		if (!xchg) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[warn]Port(0x%x) get new exchange failed",
				  v_lport->port_id);

			return NULL;
		}

		offset = (xchg->fcp_sfs_union.sfs_entry.cur_offset);
		cmnd_pld = (unsigned char *)xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->rscn.rscn_pld;
		first_dword = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->sfs_common.frame_head.rctl_did;

		if ((cmnd_pld) || (first_dword != 0) || (offset != 0)) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) exchange(0x%p) abnormal, maybe data overrun, start(%llu) command(0x%x)",
				  v_lport->port_id, xchg,
				  xchg->alloc_jif, v_pkg->cmnd);

			UNF_PRINT_SFS(UNF_INFO, v_lport->port_id,
				      xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr,
				      sizeof(union unf_sfs_u));
		}

		memset(xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr, 0,
		       sizeof(union unf_sfs_u));

		v_pkg->xchg_contex = (void *)xchg;

		spin_lock_irqsave(&xchg->xchg_state_lock, flags);
		xchg->fcp_sfs_union.sfs_entry.cur_offset = 0;
		alloc_time = xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME];
		for (i = 0; i < PKG_MAX_PRIVATE_DATA_SIZE; i++)
			xchg->private[i] = v_pkg->private[i];

		xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME] = alloc_time;
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
	} else {
		xchg = (struct unf_xchg_s *)v_pkg->xchg_contex;
	}

	if (!xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr) {
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

		return NULL;
	}

	return xchg;
}

static unsigned char *unf_calc_big_cmnd_pld_buffer(struct unf_xchg_s *v_xchg,
						   unsigned int v_cmnd_code)
{
	unsigned char *cmnd_pld = NULL;
	void *buf = NULL;
	unsigned char *dest = NULL;

	UNF_CHECK_VALID(0x3510, UNF_TRUE, v_xchg, return NULL);

	if (v_cmnd_code == ELS_RSCN)
		cmnd_pld = (unsigned char *)v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->rscn.rscn_pld;
	else
		cmnd_pld = (unsigned char *)v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo.echo_pld;

	if (!cmnd_pld) {
		buf = unf_get_one_big_sfs_buf(v_xchg);
		if (!buf)
			return NULL;

		if (v_cmnd_code == ELS_RSCN) {
			memset(buf, 0, sizeof(struct unf_rscn_pld_s));
			v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->rscn.rscn_pld = buf;
		} else {
			memset(buf, 0, sizeof(struct unf_echo_payload_s));
			v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo.echo_pld = buf;
		}

		dest = (unsigned char *)buf;
	} else {
		dest = (unsigned char *)
		       (cmnd_pld + v_xchg->fcp_sfs_union.sfs_entry.cur_offset);
	}

	return dest;
}

static unsigned char *unf_calc_other_pld_buffer(struct unf_xchg_s *v_xchg)
{
	unsigned char *dest = NULL;
	unsigned int offset = 0;

	UNF_CHECK_VALID(0x3511, UNF_TRUE, v_xchg, return NULL);

	offset = (sizeof(struct unf_fchead_s)) +
		(v_xchg->fcp_sfs_union.sfs_entry.cur_offset);
	dest = (unsigned char *)
		((unsigned char *)
			(v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr) +
				 offset);

	return dest;
}

static struct unf_xchg_s *unf_mv_data_2_xchg(struct unf_lport_s *v_lport,
					     struct unf_frame_pkg_s *v_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned char *dest = NULL;
	unsigned int length = 0;
	unsigned long flags = 0;

	UNF_CHECK_VALID(0x3512, UNF_TRUE, v_lport, return NULL);
	UNF_CHECK_VALID(0x3513, UNF_TRUE, v_pkg, return NULL);

	xchg = unf_alloc_xchg_for_rcv_cmnd(v_lport, v_pkg);
	if (!xchg)
		return NULL;

	spin_lock_irqsave(&xchg->xchg_state_lock, flags);

	memcpy(&xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->sfs_common.frame_head,
	       &v_pkg->frame_head,
	       sizeof(v_pkg->frame_head));

	if ((v_pkg->cmnd == ELS_RSCN) || (v_pkg->cmnd == ELS_ECHO))
		dest = unf_calc_big_cmnd_pld_buffer(xchg, v_pkg->cmnd);
	else
		dest = unf_calc_other_pld_buffer(xchg);

	if (!dest) {
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

		return NULL;
	}

	if (((xchg->fcp_sfs_union.sfs_entry.cur_offset +
	      v_pkg->unf_cmnd_pload_bl.length) >
	     (unsigned int)sizeof(union unf_sfs_u)) &&
	    (v_pkg->cmnd != ELS_RSCN) &&
	    (v_pkg->cmnd != ELS_ECHO)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) excange(0x%p) command(0x%x,0x%x) copy payload overrun(0x%x:0x%x:0x%x)",
			  v_lport->port_id, xchg, v_pkg->cmnd,
			  xchg->hot_pool_tag,
			  xchg->fcp_sfs_union.sfs_entry.cur_offset,
			  v_pkg->unf_cmnd_pload_bl.length,
			  (unsigned int)sizeof(union unf_sfs_u));

		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);

		return NULL;
	}

	length = v_pkg->unf_cmnd_pload_bl.length;
	if (length > 0)
		memcpy(dest, v_pkg->unf_cmnd_pload_bl.buffer_ptr, length);

	xchg->fcp_sfs_union.sfs_entry.cur_offset += length;
	spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

	return xchg;
}

static unsigned int unf_logo_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	struct unf_rport_s *logo_rport = NULL;
	struct unf_logo_s *logo = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int nport_id = 0;
	struct unf_rjt_info_s rjt_info = { 0 };

	UNF_REFERNCE_VAR(logo);
	UNF_CHECK_VALID(0x3514, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3515, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	UNF_SERVICE_COLLECT(v_lport->link_service_info, UNF_SERVICE_ITEM_LOGO);
	logo = &v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->logo;
	nport_id = logo->payload.nport_id & UNF_NPORTID_MASK;

	if (v_sid < UNF_FC_FID_DOM_MGR) {
		/* R_Port is not fabric port */
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_KEVENT,
			  "[info]LOGIN: Receive LOGO. Port(0x%x)<---RPort(0x%x) NPort_ID(0x%x) OXID(0x%x)",
			  v_lport->port_id, v_sid, nport_id, v_xchg->ox_id);
	}

	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, &logo->payload,
			    sizeof(struct unf_logo_payload_s));

	/*
	 * 1. S_ID unequal to NPort_ID:
	 * link down Rport find by NPort_ID immediately
	 */
	if (nport_id != v_sid) {
		logo_rport = unf_get_rport_by_nport_id(v_lport, nport_id);
		if (logo_rport)
			unf_rport_immediate_linkdown(v_lport, logo_rport);
	}

	/* 2. Get R_Port by S_ID (frame header) */
	rport = unf_get_rport_by_nport_id(v_lport, v_sid);
	rport = unf_get_safe_rport(v_lport, rport, UNF_RPORT_REUSE_INIT,
				   v_sid);  // INIT
	if (!rport) {
		memset(&rjt_info, 0, sizeof(struct unf_rjt_info_s));
		rjt_info.els_cmnd_code = ELS_LOGO;
		rjt_info.reason_code = UNF_LS_RJT_LOGICAL_ERROR;
		rjt_info.reason_explanation = UNF_LS_RJT_NO_ADDITIONAL_INFO;
		ret = unf_send_els_rjt_by_did(v_lport, v_xchg, v_sid,
					      &rjt_info);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) receive LOGO but has no RPort(0x%x)",
			  v_lport->port_id, v_sid);

		return ret;
	}

	/*
	 * 3. I/O resource release: set ABORT tag
	 *
	 * Call by: R_Port remove; RCVD LOGO; RCVD PLOGI; send PLOGI ACC
	 */
	unf_cm_xchg_mgr_abort_io_by_id(v_lport, rport, v_sid, v_lport->nport_id,
				       INI_IO_STATE_LOGO);

	/* 4. Send LOGO ACC */
	ret = unf_send_logo_acc(v_lport, rport, v_xchg);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) send LOGO failed",
			  v_lport->port_id);

	/*
	 * 5. Do same operations with RCVD LOGO/PRLO & Send LOGO:
	 * retry (LOGIN or LOGO) or link down immediately
	 */
	unf_process_rport_after_logo(v_lport, rport);

	return ret;
}

static unsigned int unf_prlo_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	struct unf_prli_prlo_s *prlo = NULL;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_REFERNCE_VAR(prlo);
	UNF_CHECK_VALID(0x3516, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3517, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Receive PRLO. Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
		  v_lport->port_id, v_sid, v_xchg->ox_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info, UNF_SERVICE_ITEM_LOGO);

	/* Get (new) R_Port */
	rport = unf_get_rport_by_nport_id(v_lport, v_sid);
	rport = unf_get_safe_rport(v_lport, rport,
				   UNF_RPORT_REUSE_INIT, v_sid);  /* INIT */
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) receive PRLO but has no RPort",
			  v_lport->port_id);

		/* Discard directly */
		unf_cm_free_xchg(v_lport, v_xchg);
		return ret;
	}

	prlo = &v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->prlo;
	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, &prlo->payload,
			    sizeof(struct unf_pril_payload_s));

	/* Send PRLO ACC to remote */
	ret = unf_send_prlo_acc(v_lport, rport, v_xchg);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) send PRLO ACC failed",
			  v_lport->port_id);

	/* Enter Enhanced action after LOGO (retry LOGIN or LOGO) */
	unf_process_rport_after_logo(v_lport, rport);

	UNF_REFERNCE_VAR(prlo);
	return ret;
}

static void unf_fill_echo_acc_pld(struct unf_echo_s *v_echo_acc)
{
	struct unf_echo_payload_s *echo_acc_pld = NULL;

	UNF_CHECK_VALID(0x3518, UNF_TRUE, v_echo_acc, return);

	echo_acc_pld = v_echo_acc->echo_pld;
	UNF_CHECK_VALID(0x3519, UNF_TRUE, echo_acc_pld, return);

	echo_acc_pld->cmnd = UNF_ELS_CMND_ACC;
}

static void unf_echo_acc_callback(struct unf_xchg_s *v_xchg)
{
	struct unf_lport_s *lport;

	UNF_CHECK_VALID(0x3517, UNF_TRUE, v_xchg, return);

	lport = v_xchg->lport;

	UNF_CHECK_VALID(0x3517, UNF_TRUE, lport, return);
	if (v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo_acc.phy_echo_addr) {
		pci_unmap_single(
			lport->low_level_func.dev,
			v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo_acc.phy_echo_addr,
			UNF_ECHO_PAYLOAD_LEN,
			DMA_BIDIRECTIONAL);
		v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo_acc.phy_echo_addr = 0;
	}
}

static unsigned int unf_send_echo_acc(struct unf_lport_s *v_lport,
				      unsigned int v_did,
				      struct unf_xchg_s *v_xchg)
{
	struct unf_echo_s *echo_acc = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	struct unf_frame_pkg_s pkg;
	dma_addr_t phy_echo_acc_addr;
	struct unf_rjt_info_s rjt_info = { 0 };

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);

	UNF_CHECK_VALID(0x3520, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3521, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));
	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_ECHO);
	v_xchg->did = v_did;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;

	v_xchg->pfn_callback = NULL;
	v_xchg->pfn_ob_callback = unf_echo_acc_callback;

	unf_fill_package(&pkg, v_xchg, v_xchg->rport);

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}

	echo_acc = &fc_entry->echo_acc;
	unf_fill_echo_acc_pld(echo_acc);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;
	phy_echo_acc_addr = pci_map_single(v_lport->low_level_func.dev,
					   echo_acc->echo_pld,
					   UNF_ECHO_PAYLOAD_LEN,
					   DMA_BIDIRECTIONAL);
	if (pci_dma_mapping_error(v_lport->low_level_func.dev,
				  phy_echo_acc_addr)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) pci map err",
			  v_lport->port_id);
		unf_cm_free_xchg(v_lport, v_xchg);
		return UNF_RETURN_ERROR;
	}
	echo_acc->phy_echo_addr = phy_echo_acc_addr;

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);
	if (ret != RETURN_OK) {
		pci_unmap_single(v_lport->low_level_func.dev,
				 phy_echo_acc_addr,
				 UNF_ECHO_PAYLOAD_LEN,
				 DMA_BIDIRECTIONAL);
		echo_acc->phy_echo_addr = 0;
		if (ret == UNF_RETURN_NOT_SUPPORT) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_KEVENT,
				  "[info]Port(0x%x) send ECHO reject to RPort(0x%x) with OX_ID(0x%x) RX_ID(0x%x)",
				  v_lport->port_id, v_did, ox_id, rx_id);

			rjt_info.els_cmnd_code = ELS_ECHO;
			rjt_info.reason_code = UNF_LS_RJT_NOT_SUPPORTED;
			unf_send_els_rjt_by_rport(v_lport, v_xchg,
						  v_xchg->rport,
						  &rjt_info);
		} else {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) send ECHO ACC to RPort(0x%x) with OX_ID(0x%x) RX_ID(0x%x) failed",
				  v_lport->port_id, v_did, ox_id, rx_id);

			unf_cm_free_xchg((void *)v_lport, (void *)v_xchg);
		}
	}

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static unsigned int unf_echo_handler(struct unf_lport_s *v_lport,
				     unsigned int v_sid,
				     struct unf_xchg_s *v_xchg)
{
	struct unf_echo_payload_s *echo_pld = NULL;
	struct unf_rport_s *rport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int data_len = 0;

	UNF_CHECK_VALID(0x3522, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3523, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	data_len = v_xchg->fcp_sfs_union.sfs_entry.cur_offset;

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]Receive ECHO. Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x))",
		  v_lport->port_id, v_sid, v_xchg->ox_id);

	UNF_SERVICE_COLLECT(v_lport->link_service_info, UNF_SERVICE_ITEM_ECHO);
	echo_pld = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo.echo_pld;
	UNF_PRINT_SFS_LIMIT(UNF_INFO, v_lport->port_id, echo_pld, data_len);
	rport = unf_get_rport_by_nport_id(v_lport, v_sid);
	v_xchg->rport = rport;

	ret = unf_send_echo_acc(v_lport, v_sid, v_xchg);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) send ECHO ACC failed",
			  v_lport->port_id);

	UNF_REFERNCE_VAR(echo_pld);
	UNF_REFERNCE_VAR(data_len);
	return ret;
}

static unsigned int unf_check_els_cmnd_valid(struct unf_lport_s *v_lport,
					     struct unf_frame_pkg_s *v_fra_pkg,
					     struct unf_xchg_s *v_xchg)
{
	struct unf_lport_s *lport = v_lport;
	struct unf_frame_pkg_s *ppkg = v_fra_pkg;
	struct unf_xchg_s *xchg = v_xchg;
	struct unf_rjt_info_s rjt_info = { 0 };
	struct unf_lport_s *vport = NULL;
	unsigned int sid = 0;
	unsigned int did = 0;

	sid = (ppkg->frame_head.csctl_sid) & UNF_NPORTID_MASK;
	did = (ppkg->frame_head.rctl_did) & UNF_NPORTID_MASK;

	memset(&rjt_info, 0, sizeof(struct unf_rjt_info_s));
	rjt_info.reason_code = UNF_LS_RJT_NOT_SUPPORTED;

	if ((ppkg->cmnd == ELS_FLOGI) &&
	    (lport->en_act_topo == UNF_ACT_TOP_PRIVATE_LOOP)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x) receive FLOGI in top (0x%x) and send LS_RJT",
			  lport->port_id, lport->en_act_topo);

		rjt_info.els_cmnd_code = ELS_FLOGI;
		(void)unf_send_els_rjt_by_did(lport, xchg, sid, &rjt_info);

		return UNF_RETURN_ERROR;
	}

	if ((ppkg->cmnd == ELS_PLOGI) && (did >= UNF_FC_FID_DOM_MGR)) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x)receive PLOGI with wellknown address(0x%x) and Send LS_RJT",
			  lport->port_id, did);

		rjt_info.els_cmnd_code = ELS_PLOGI;
		(void)unf_send_els_rjt_by_did(lport, xchg, sid, &rjt_info);

		return UNF_RETURN_ERROR;
	}

	if (((lport->nport_id == 0) ||
	     (lport->nport_id == INVALID_VALUE32)) &&
	    (NEED_REFRESH_NPORTID(ppkg))) {
		lport->nport_id = did;
	} else if ((did != lport->nport_id) && (ppkg->cmnd != ELS_FLOGI)) {
		vport = unf_cm_lookup_vport_by_did(lport, did);
		if (!vport) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) receive ELS cmd(0x%x) with abnormal D_ID(0x%x)",
				  lport->nport_id, ppkg->cmnd, did);

			unf_cm_free_xchg(lport, xchg);
			return UNF_RETURN_ERROR;
		}
	}

	return RETURN_OK;
}

static unsigned int unf_rcv_els_cmnd_req(struct unf_lport_s *v_lport,
					 struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int i = 0;
	unsigned int sid = 0;
	unsigned int did = 0;
	struct unf_lport_s *vport = NULL;
	unsigned int (*pfn_els_cmnd_handler)(struct unf_lport_s *, unsigned int,
					     struct unf_xchg_s *) = NULL;

	sid = (v_fra_pkg->frame_head.csctl_sid) & UNF_NPORTID_MASK;
	did = (v_fra_pkg->frame_head.rctl_did) & UNF_NPORTID_MASK;

	xchg = unf_mv_data_2_xchg(v_lport, v_fra_pkg);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) receive ElsCmnd(0x%x), exchange is NULL",
			  v_lport->port_id, v_fra_pkg->cmnd);

		return UNF_RETURN_ERROR;
	}

	if (v_fra_pkg->last_pkg_flag != UNF_TRUE) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Exchange(%u) waiting for last WQE",
			  xchg->hot_pool_tag);

		return RETURN_OK;
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
		  "[info]Exchange(%u) get last WQE", xchg->hot_pool_tag);

	if (v_lport->low_level_func.xchg_mgr_type ==
	    UNF_LOW_LEVEL_MGR_TYPE_PASSTIVE) {
		xchg->ox_id = UNF_GET_OXID(v_fra_pkg);
		xchg->abort_oxid = xchg->ox_id;
		xchg->rx_id = xchg->hot_pool_tag;
	}
	xchg->cmnd_code = v_fra_pkg->cmnd;

	ret = unf_check_els_cmnd_valid(v_lport, v_fra_pkg, xchg);
	if (ret != RETURN_OK) {
		/* NOTE: exchange has been released */
		return UNF_RETURN_ERROR;
	}

	if ((did != v_lport->nport_id)	&& (v_fra_pkg->cmnd != ELS_FLOGI)) {
		vport = unf_cm_lookup_vport_by_did(v_lport, did);
		if (!vport) {
			UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
				  "[warn]Port(0x%x) received unknown ELS command with S_ID(0x%x) D_ID(0x%x))",
				  v_lport->port_id, sid, did);

			return UNF_RETURN_ERROR;
		}
		v_lport = vport;
		UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_INFO,
			  "[info]VPort(0x%x) received ELS command with S_ID(0x%x) D_ID(0x%x)",
			  v_lport->port_id, sid, did);
	}

	do {
		if ((v_fra_pkg->cmnd) == els_handle[i].cmnd) {
			pfn_els_cmnd_handler =
				els_handle[i].pfn_els_cmnd_handler;
			break;
		}

		i++;
	} while (i < (sizeof(els_handle) /
		      sizeof(struct unf_els_handler_table)));

	if (pfn_els_cmnd_handler) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_INFO,
			  "[info]Port(0x%x) receive ELS(0x%x) from RPort(0x%x) and process it",
			  v_lport->port_id, v_fra_pkg->cmnd, sid);

		ret = pfn_els_cmnd_handler(v_lport, sid, xchg);
	} else {
		ret = unf_els_cmnd_default_handler(v_lport, xchg, sid,
						   v_fra_pkg->cmnd);
	}

	return ret;
}

static unsigned int unf_send_els_rsp_succ(struct unf_lport_s *v_lport,
					  struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = RETURN_OK;
	unsigned short hot_pool_tag = 0;
	unsigned long flags = 0;
	void (*pfn_ob_callback)(struct unf_xchg_s *) = NULL;

	UNF_CHECK_VALID(0x3529, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3530, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);

	if (!v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) lookup exchange by tag function is NULL",
			  v_lport->port_id);

		return UNF_RETURN_ERROR;
	}

	hot_pool_tag = (unsigned short)
		(v_fra_pkg->private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX]);
	xchg = (struct unf_xchg_s *)
		(v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag(
							(void *)v_lport,
							hot_pool_tag));
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) find exhange by tag(0x%x) failed",
			  v_lport->port_id, hot_pool_tag);

		return UNF_RETURN_ERROR;
	}

	v_lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)xchg);

	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	if ((xchg->pfn_ob_callback) &&
	    (!(xchg->io_state & TGT_IO_STATE_ABORT))) {
		pfn_ob_callback = xchg->pfn_ob_callback;
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x) with exchange(0x%p) tag(%u) do callback",
			  v_lport->port_id, xchg, hot_pool_tag);

		pfn_ob_callback(xchg);
	} else {
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
	}

	unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	return ret;
}

static unsigned char *unf_calc_big_resp_pld_buffer(struct unf_xchg_s *v_xchg,
						   unsigned int v_cmnd_code)
{
	unsigned char *resp_pld = NULL;
	unsigned char *dest = NULL;

	UNF_CHECK_VALID(0x3510, UNF_TRUE, v_xchg, return NULL);

	if (v_cmnd_code == ELS_ECHO)
		resp_pld = (unsigned char *)
			v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->echo.echo_pld;
	else
		resp_pld = (unsigned char *)
			v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->get_id.gid_rsp.gid_acc_pld;

	if (resp_pld)
		dest = (unsigned char *)
			(resp_pld + v_xchg->fcp_sfs_union.sfs_entry.cur_offset);

	return dest;
}

static unsigned char *unf_calc_other_resp_pld_buffer(struct unf_xchg_s *v_xchg)
{
	unsigned char *dest = NULL;
	unsigned int offset = 0;

	UNF_CHECK_VALID(0x3511, UNF_TRUE, v_xchg, return NULL);

	offset = v_xchg->fcp_sfs_union.sfs_entry.cur_offset;
	dest = (unsigned char *)((unsigned char *)
		(v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr) + offset);

	return dest;
}

static unsigned int unf_mv_resp_2_xchg(struct unf_xchg_s *v_xchg,
				       struct unf_frame_pkg_s *v_pkg)
{
	unsigned char *dest = NULL;
	unsigned int length = 0;
	unsigned int offset = 0;
	unsigned int max_frame_len = 0;
	unsigned long flags = 0;

	spin_lock_irqsave(&v_xchg->xchg_state_lock, flags);

	if (UNF_NEED_BIG_RESPONSE_BUFF(v_xchg->cmnd_code)) {
		dest = unf_calc_big_resp_pld_buffer(v_xchg,
						    v_xchg->cmnd_code);
		offset = 0;
		max_frame_len = sizeof(struct unf_gif_acc_pld_s);
	} else if (v_xchg->cmnd_code == NS_GA_NXT ||
		   v_xchg->cmnd_code == NS_GIEL) {
		dest = unf_calc_big_resp_pld_buffer(v_xchg,
						    v_xchg->cmnd_code);
		offset = 0;
		max_frame_len =
			v_xchg->fcp_sfs_union.sfs_entry.sfs_buff_len;
	} else {
		dest = unf_calc_other_resp_pld_buffer(v_xchg);
		offset = sizeof(struct unf_fchead_s);
		max_frame_len = sizeof(union unf_sfs_u);
	}

	if (!dest) {
		spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flags);

		return UNF_RETURN_ERROR;
	}

	if (v_xchg->fcp_sfs_union.sfs_entry.cur_offset == 0) {
		v_xchg->fcp_sfs_union.sfs_entry.cur_offset += offset;
		dest = dest + offset;
	}

	length = v_pkg->unf_cmnd_pload_bl.length;

	if ((v_xchg->fcp_sfs_union.sfs_entry.cur_offset + length) >
	    max_frame_len) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Exchange(0x%p) command(0x%x) hotpooltag(0x%x) OX_RX_ID(0x%x) S_ID(0x%x) D_ID(0x%x) copy payload overrun(0x%x:0x%x:0x%x)",
			  v_xchg, v_xchg->cmnd_code, v_xchg->hot_pool_tag,
			  v_pkg->frame_head.oxid_rxid,
			  v_pkg->frame_head.csctl_sid & UNF_NPORTID_MASK,
			  v_pkg->frame_head.rctl_did & UNF_NPORTID_MASK,
			  v_xchg->fcp_sfs_union.sfs_entry.cur_offset,
			  v_pkg->unf_cmnd_pload_bl.length,
			  max_frame_len);

		length = max_frame_len - v_xchg->fcp_sfs_union.sfs_entry.cur_offset;
	}

	if (length > 0)
		memcpy(dest, v_pkg->unf_cmnd_pload_bl.buffer_ptr, length);

	v_xchg->fcp_sfs_union.sfs_entry.cur_offset += length;
	spin_unlock_irqrestore(&v_xchg->xchg_state_lock, flags);

	return RETURN_OK;
}

static unsigned int unf_send_els_cmnd_succ(struct unf_lport_s *v_lport,
					   struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = RETURN_OK;
	unsigned short hot_pool_tag = 0;
	unsigned long flags = 0;
	void (*pfn_callback)(void *, void *, void *) = NULL;
	struct unf_lport_s *lport = NULL;

	UNF_CHECK_VALID(0x3531, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3532, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);
	lport = v_lport;

	if (!lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) lookup exchange by tag function can't be NULL",
			  lport->port_id);

		return UNF_RETURN_ERROR;
	}

	hot_pool_tag = (unsigned short)
		(v_fra_pkg->private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX]);
	xchg = (struct unf_xchg_s *)
		(lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag((void *)lport,
							     hot_pool_tag));
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) find exchange by tag(0x%x) failed",
			  lport->port_id, lport->nport_id, hot_pool_tag);

		return UNF_RETURN_ERROR;
	}

	UNF_CHECK_ALLOCTIME_VALID(
			lport, hot_pool_tag, xchg,
			v_fra_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME],
			xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME]);

	if (((v_fra_pkg->frame_head.csctl_sid) & UNF_NPORTID_MASK) !=
	    xchg->did) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) find exhange invalid, package S_ID(0x%x) exchange S_ID(0x%x) D_ID(0x%x)",
			  lport->port_id, v_fra_pkg->frame_head.csctl_sid,
			  xchg->sid, xchg->did);

		return UNF_RETURN_ERROR;
	}

	if (v_fra_pkg->last_pkg_flag == UNF_PKG_NOT_LAST_RESPONSE) {
		ret = unf_mv_resp_2_xchg(xchg, v_fra_pkg);

		return ret;
	}

	xchg->byte_orders = v_fra_pkg->byte_orders;
	lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)xchg);

	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	if ((xchg->pfn_callback) &&
	    ((xchg->cmnd_code == ELS_RRQ) ||
	     (xchg->cmnd_code == ELS_LOGO) ||
	     (!(xchg->io_state & TGT_IO_STATE_ABORT)))) {
		pfn_callback = xchg->pfn_callback;

		if ((xchg->cmnd_code == ELS_FLOGI) ||
		    (xchg->cmnd_code == ELS_FDISC))
			xchg->sid = v_fra_pkg->frame_head.rctl_did &
					UNF_NPORTID_MASK;

		if (xchg->cmnd_code == ELS_ECHO) {
			xchg->private[PKG_PRIVATE_ECHO_CMD_RCV_TIME] =
				v_fra_pkg->private[PKG_PRIVATE_ECHO_CMD_RCV_TIME];
			xchg->private[PKG_PRIVATE_ECHO_RSP_SND_TIME] =
				v_fra_pkg->private[PKG_PRIVATE_ECHO_RSP_SND_TIME];
			xchg->private[PKG_PRIVATE_ECHO_CMD_SND_TIME] =
				v_fra_pkg->private[PKG_PRIVATE_ECHO_CMD_SND_TIME];
			xchg->private[PKG_PRIVATE_ECHO_ACC_RCV_TIME] =
				v_fra_pkg->private[PKG_PRIVATE_ECHO_ACC_RCV_TIME];
		}
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		/* Do callback */
		pfn_callback(xchg->lport, xchg->rport, xchg);
	} else {
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
	}

	unf_cm_free_xchg((void *)lport, (void *)xchg);
	return ret;
}

static unsigned int unf_send_els_cmnd_failed(struct unf_lport_s *v_lport,
					     struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = RETURN_OK;
	unsigned short hot_pool_tag = 0;
	unsigned long flags = 0;
	void (*pfn_ob_callback)(struct unf_xchg_s *) = NULL;

	UNF_CHECK_VALID(0x3533, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3534, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);

	if (!v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) lookup exchange by tag function can't be NULL",
			  v_lport->port_id);

		return UNF_RETURN_ERROR;
	}

	hot_pool_tag = (unsigned short)
		(v_fra_pkg->private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX]);
	xchg = (struct unf_xchg_s *)
		(v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag(
								(void *)v_lport,
								hot_pool_tag));
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) find exhange by tag(0x%x) failed",
			  v_lport->port_id, v_lport->nport_id, hot_pool_tag);

		return UNF_RETURN_ERROR;
	}

	UNF_CHECK_ALLOCTIME_VALID(
			v_lport, hot_pool_tag, xchg,
			v_fra_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME],
			xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME]);

	v_lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)xchg);

	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	if ((xchg->pfn_ob_callback) &&
	    ((xchg->cmnd_code == ELS_RRQ) ||
	     (xchg->cmnd_code == ELS_LOGO) ||
	     (!(xchg->io_state & TGT_IO_STATE_ABORT)))) {
		pfn_ob_callback = xchg->pfn_ob_callback;
		xchg->ob_callback_sts = v_fra_pkg->status;
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		pfn_ob_callback(xchg);

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x) exchange(0x%p) tag(0x%x) do callback",
			  v_lport->port_id, xchg, hot_pool_tag);
	} else {
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
	}

	unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	return ret;
}

static unsigned int unf_rcv_els_cmnd_reply(struct unf_lport_s *v_lport,
					   struct unf_frame_pkg_s *v_fra_pkg)
{
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3535, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3536, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);

	if ((v_fra_pkg->status == UNF_IO_SUCCESS) ||
	    (v_fra_pkg->status == UNF_IO_UNDER_FLOW))
		ret = unf_send_els_cmnd_succ(v_lport, v_fra_pkg);
	else
		ret = unf_send_els_cmnd_failed(v_lport, v_fra_pkg);

	return ret;
}

void unf_lport_enter_msn_plogi(struct unf_lport_s *v_lport)
{
	/* Fabric or Public Loop Mode: Login with Name server */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;
	unsigned long flag = 0;
	unsigned int ret = UNF_RETURN_ERROR;
	struct unf_plogi_payload_s *plogi_pld = NULL;
	union unf_sfs_u *fc_entry = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_frame_pkg_s pkg;

	UNF_CHECK_VALID(0x1811, UNF_TRUE, v_lport, return);

	/* Get (safe) R_Port */
	rport = unf_rport_get_free_and_init(v_lport, UNF_PORT_TYPE_FC,
					    UNF_FC_FID_MGMT_SERV);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) allocate RPort failed",
			  v_lport->port_id);
		return;
	}

	spin_lock_irqsave(&rport->rport_state_lock, flag);
	rport->nport_id = UNF_FC_FID_MGMT_SERV;  // 0xfffffa
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));

	/* Get & Set new free exchange */
	xchg = unf_cm_get_free_xchg(v_lport, UNF_XCHG_TYPE_SFS);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) exchange can't be NULL for PLOGI",
			  v_lport->port_id);

		return;
	}

	xchg->cmnd_code = ELS_PLOGI;  // PLOGI
	xchg->did = rport->nport_id;
	xchg->sid = v_lport->nport_id;
	xchg->oid = xchg->sid;
	xchg->lport = lport;
	xchg->rport = rport;

	if (v_lport->low_level_func.xchg_mgr_type ==
	    UNF_LOW_LEVEL_MGR_TYPE_PASSTIVE)
		xchg->ox_id = xchg->hot_pool_tag;

	/* Set callback function */
	xchg->pfn_callback = NULL;  // for rcvd plogi acc/rjt processer
	xchg->pfn_ob_callback = NULL;  // for send plogi failed processer

	unf_fill_package(&pkg, xchg, rport);

	/* Fill PLOGI payload */
	fc_entry = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, xchg->hot_pool_tag);

		unf_cm_free_xchg(v_lport, xchg);
		return;
	}

	plogi_pld = &fc_entry->plogi.payload;
	memset(plogi_pld, 0, sizeof(struct unf_plogi_payload_s));
	unf_fill_plogi_pld(plogi_pld, v_lport);

	/* Start to Send PLOGI command */
	ret = unf_els_cmnd_send(v_lport, &pkg, xchg);
	if (ret != RETURN_OK)
		unf_cm_free_xchg((void *)v_lport, (void *)xchg);
}

static void unf_register_to_switch(struct unf_lport_s *v_lport)
{
	/* Register to Fabric, used for: FABRIC & PUBLI LOOP */
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3542, UNF_TRUE, v_lport, return);

	spin_lock_irqsave(&v_lport->lport_state_lock, flag);
	/* LPort: FLOGI_WAIT --> PLOGI_WAIT */
	unf_lport_stat_ma(v_lport, UNF_EVENT_LPORT_REMOTE_ACC);
	spin_unlock_irqrestore(&v_lport->lport_state_lock, flag);

	/* Login with Name server: PLOGI */
	unf_lport_enter_sns_plogi(v_lport);

	unf_lport_enter_msn_plogi(v_lport);

	if ((v_lport->root_lport == v_lport) &&/* Physical Port */
	    (v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC)) {
		unf_linkup_all_vports(v_lport);
	}
}

void unf_login_with_loop_node(struct unf_lport_s *v_lport, unsigned int v_alpa)
{
	/* Only used for Private Loop LOGIN */
	struct unf_rport_s *rport = NULL;
	unsigned long rport_flag = 0;
	unsigned int port_feature = 0;
	unsigned int ret;

	/* Check AL_PA validity */
	if (v_lport->nport_id == v_alpa) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x) is the same as RPort with AL_PA(0x%x), do nothing",
			  v_lport->port_id, v_alpa);
		return;
	}

	if (v_alpa == 0) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) RPort(0x%x) is fabric, do nothing",
			  v_lport->port_id, v_alpa);
		return;
	}

	/* Get & set R_Port: reuse only */
	rport = unf_get_rport_by_nport_id(v_lport, v_alpa);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: Port(0x%x_0x%x) RPort(0x%x_0x%p) login with private loop",
		  v_lport->port_id, v_lport->nport_id, v_alpa, rport);

	rport = unf_get_safe_rport(v_lport, rport, UNF_RPORT_REUSE_ONLY,
				   v_alpa);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) allocate new RPort(0x%x) failed",
			  v_lport->port_id, v_lport->nport_id, v_alpa);
		return;
	}

	/* Update R_Port state & N_Port_ID */
	spin_lock_irqsave(&rport->rport_state_lock, rport_flag);
	rport->nport_id = v_alpa;
	unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);  // PLOGI_WAIT
	spin_unlock_irqrestore(&rport->rport_state_lock, rport_flag);

	/* Private Loop: check whether need delay to send PLOGI or not */
	port_feature = rport->options;

	/* check Rport and Lport feature */
	if ((port_feature == UNF_PORT_MODE_UNKNOWN) &&
	    (v_lport->options == UNF_PORT_MODE_INI)) {
		/* Start to send PLOGI */
		ret = unf_send_plogi(v_lport, rport);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]LOGIN: Port(0x%x_0x%x) send PLOGI to RPort(0x%x) failed",
				  v_lport->port_id, v_lport->nport_id,
				  rport->nport_id);

			unf_rport_error_recovery(rport);
		}
	} else {
		unf_check_rport_need_delay_plogi(v_lport, rport, port_feature);
	}
}

unsigned int unf_receive_els_pkg(void *v_lport,
				 struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_lport_s *lport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3543, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3544, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);
	lport = (struct unf_lport_s *)v_lport;

	switch (v_fra_pkg->type) {
	case UNF_PKG_ELS_REQ_DONE:
		ret = unf_rcv_els_cmnd_reply(lport, v_fra_pkg);
		break;

	case UNF_PKG_ELS_REQ:
		ret = unf_rcv_els_cmnd_req(lport, v_fra_pkg);
		break;

	default:
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) with exchange type(0x%x) abnormal",
			  lport->port_id, lport->nport_id, v_fra_pkg->type);
		break;
	}

	return ret;
}

unsigned int unf_send_els_done(void *v_lport, struct unf_frame_pkg_s *v_pkg)
{
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3545, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3546, UNF_TRUE, v_pkg, return UNF_RETURN_ERROR);

	if (v_pkg->type == UNF_PKG_ELS_REPLY_DONE) {
		if ((v_pkg->status == UNF_IO_SUCCESS) ||
		    (v_pkg->status == UNF_IO_UNDER_FLOW))
			ret = unf_send_els_rsp_succ(v_lport, v_pkg);
		else
			ret = unf_send_els_cmnd_failed(v_lport, v_pkg);
	}

	return ret;
}

static unsigned int unf_rcv_gs_cmnd_reply(struct unf_lport_s *v_lport,
					  struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned long flags = 0;
	unsigned short hot_pool_tag = 0;
	unsigned int ret = RETURN_OK;
	struct unf_lport_s *lport = NULL;
	void (*pfn_callback)(void *, void *, void *) = NULL;

	UNF_CHECK_VALID(0x3553, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3554, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);
	lport = v_lport;
	hot_pool_tag = (unsigned short)
		(v_fra_pkg->private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX]);

	xchg = (struct unf_xchg_s *)unf_cm_lookup_xchg_by_tag(
						(void *)lport, hot_pool_tag);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) find exhange by tag(0x%x) failed",
			  lport->port_id, hot_pool_tag);

		return UNF_RETURN_ERROR;
	}

	UNF_CHECK_ALLOCTIME_VALID(
			lport, hot_pool_tag, xchg,
			v_fra_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME],
			xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME]);

	if (v_fra_pkg->last_pkg_flag == UNF_PKG_NOT_LAST_RESPONSE) {
		ret = unf_mv_resp_2_xchg(xchg, v_fra_pkg);
		return ret;
	}

	lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)xchg);

	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	if ((xchg->pfn_callback) && (!(xchg->io_state & TGT_IO_STATE_ABORT))) {
		pfn_callback = xchg->pfn_callback;
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		pfn_callback(xchg->lport, xchg->rport, xchg);
	} else {
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
	}

	unf_cm_free_xchg((void *)lport, (void *)xchg);
	return ret;
}

static unsigned int unf_send_gs_cmnd_failed(struct unf_lport_s *v_lport,
					    struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_xchg_s *xchg = NULL;
	unsigned int ret = RETURN_OK;
	unsigned short hot_pool_tag = 0;
	unsigned long flags = 0;

	void (*pfn_ob_callback)(struct unf_xchg_s *) = NULL;

	UNF_CHECK_VALID(0x3555, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3556, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);

	if (!v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) loopup exchange by tag function can't be NULL",
			  v_lport->port_id);

		return UNF_RETURN_ERROR;
	}

	hot_pool_tag = (unsigned short)
		(v_fra_pkg->private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX]);
	xchg = (struct unf_xchg_s *)
		(v_lport->xchg_mgr_temp.pfn_unf_look_up_xchg_by_tag(
							(void *)v_lport,
							hot_pool_tag));

	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can't find exhange by tag(0x%x)",
			  v_lport->port_id, hot_pool_tag);

		return UNF_RETURN_ERROR;
	}

	UNF_CHECK_ALLOCTIME_VALID(
			v_lport, hot_pool_tag, xchg,
			v_fra_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME],
			xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME]);

	v_lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)xchg);

	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	if ((xchg->pfn_ob_callback) &&
	    (!(xchg->io_state & TGT_IO_STATE_ABORT))) {
		pfn_ob_callback = xchg->pfn_ob_callback;
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		pfn_ob_callback(xchg);
	} else {
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
	}

	unf_cm_free_xchg((void *)v_lport, (void *)xchg);
	return ret;
}

unsigned int unf_receive_gs_pkg(void *v_lport,
				struct unf_frame_pkg_s *v_fra_pkg)
{
	struct unf_lport_s *lport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3557, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3558, UNF_TRUE, v_fra_pkg, return UNF_RETURN_ERROR);

	lport = (struct unf_lport_s *)v_lport;

	if ((v_fra_pkg->type) == UNF_PKG_GS_REQ_DONE) {
		if ((v_fra_pkg->status == UNF_IO_SUCCESS) ||
		    (v_fra_pkg->status == UNF_IO_UNDER_FLOW) ||
		    (v_fra_pkg->status == UNF_IO_OVER_FLOW))
			ret = unf_rcv_gs_cmnd_reply(lport, v_fra_pkg);
		else
			ret = unf_send_gs_cmnd_failed(lport, v_fra_pkg);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) exchange type(0x%x) mismatch",
			  lport->port_id, v_fra_pkg->type);

		return UNF_RETURN_ERROR;
	}

	return ret;
}

static void unf_handle_init_gid_acc(struct unf_gif_acc_pld_s *v_gid_acc_pld,
				    struct unf_lport_s *v_lport)
{
	/*
	 * from SCR ACC callback
	 * NOTE: inquiry disc R_Port used for NPIV
	 */
	struct unf_disc_rport_s *disc_rport = NULL;
	struct unf_disc_s *disc = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned int gid_port_id = 0;
	unsigned int nport_id = 0;
	unsigned int i = 0;
	unsigned char control = 0;

	UNF_CHECK_VALID(0x3559, UNF_TRUE, v_gid_acc_pld, return);
	UNF_CHECK_VALID(0x3560, UNF_TRUE, v_lport, return);

	/*
	 * 1. Find & Check & Get (new) R_Port from list_disc_rports_pool
	 * then, Add to R_Port Disc_busy_list
	 */
	while (i < UNF_GID_PORT_CNT) {
		gid_port_id = (v_gid_acc_pld->gid_port_id[i]);
		nport_id = UNF_NPORTID_MASK & gid_port_id;
		control = UNF_GID_CONTROL(gid_port_id);

		/* for each N_Port_ID from GID_ACC payload */
		if ((nport_id != v_lport->nport_id) && (nport_id != 0) &&
		    (!unf_lookup_lport_by_nport_id(v_lport, nport_id))) {
			/* for New Port, not L_Port */
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]Port(0x%x_0x%x) get nportid(0x%x) from GID_ACC",
				  v_lport->port_id, v_lport->nport_id,
				  nport_id);

			/* Get R_Port from list of RPort Disc Pool */
			disc_rport =
				unf_rport_get_free_and_init(v_lport,
							    UNF_PORT_TYPE_DISC,
							    nport_id);
			if (!disc_rport) {
				UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
					  UNF_LOG_LOGIN_ATT, UNF_WARN,
					  "[warn]Port(0x%x_0x%x) can't allocate new rport(0x%x) from disc pool",
					  v_lport->port_id,
					  v_lport->nport_id,
					  nport_id);

				i++;
				continue;
			}
		}

		if ((control & UNF_GID_LAST_PORT_ID) == UNF_GID_LAST_PORT_ID)
			break;

		i++;
	}

	/*
	 * 2. Do port disc stop operation:
	 * NOTE: Do DISC & release R_Port from
	 * busy_list back to list_disc_rports_pool
	 */
	disc = &v_lport->disc;
	if (!disc->unf_disc_temp.pfn_unf_disc_stop) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) disc stop function is NULL",
			  v_lport->port_id, v_lport->nport_id);

		return;
	}

	ret = disc->unf_disc_temp.pfn_unf_disc_stop(v_lport);
	if (ret != RETURN_OK)
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) do disc stop failed",
			  v_lport->port_id, v_lport->nport_id);
}

void unf_rport_immediate_linkdown(struct unf_lport_s *v_lport,
				  struct unf_rport_s *v_rport)
{
	/* Swap case: Report Link Down immediately & release R_Port */
	unsigned long flags = 0;
	struct unf_disc_s *disc = NULL;

	UNF_CHECK_VALID(0x3561, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3562, UNF_TRUE, v_rport, return);

	spin_lock_irqsave(&v_rport->rport_state_lock, flags);
	/* 1. Inc R_Port ref_cnt */
	if (unf_rport_ref_inc(v_rport) != RETURN_OK) {
		spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) Rport(0x%p,0x%x) is removing and no need process",
			  v_lport->port_id, v_rport, v_rport->nport_id);

		return;
	}

	/* 2. R_PORT state update: Link Down Event --->>> closing state */
	unf_rport_state_ma(v_rport, UNF_EVENT_RPORT_LINK_DOWN);
	spin_unlock_irqrestore(&v_rport->rport_state_lock, flags);

	/* 3. Put R_Port from busy to destroy list */
	disc = &v_lport->disc;
	spin_lock_irqsave(&disc->rport_busy_pool_lock, flags);
	list_del_init(&v_rport->entry_rport);
	list_add_tail(&v_rport->entry_rport, &disc->list_destroy_rports);
	spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flags);

	/* 4. Schedule Closing work (Enqueuing workqueue) */
	unf_schedule_closing_work(v_lport, v_rport);

	unf_rport_ref_dec(v_rport);
}

static unsigned int unf_rport_check_wwn(struct unf_lport_s *v_lport,
					struct unf_rport_s *v_rport)
{
	/* Send GPN_ID */
	struct unf_rport_s *sns_port = NULL;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3564, UNF_TRUE, v_lport,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3565, UNF_TRUE, v_rport,
			return UNF_RETURN_ERROR);

	/* Get SNS R_Port */
	sns_port = unf_get_rport_by_nport_id(v_lport,
					     UNF_FC_FID_DIR_SERV);
	if (!sns_port) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) can't find fabric Port",
			  v_lport->nport_id);

		return UNF_RETURN_ERROR;
	}

	/* Send GPN_ID to SW */
	ret = unf_get_and_post_disc_event(v_lport, sns_port, v_rport->nport_id,
					  UNF_DISC_GET_PORT_NAME);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) add discovery event(0x%x) failed Rport(0x%x)",
			  v_lport->nport_id, UNF_DISC_GET_PORT_NAME,
			  v_rport->nport_id);

		unf_rcv_gpn_id_rsp_unknown(v_lport, v_rport->nport_id);
	}

	return ret;
}

static unsigned int unf_handle_rscn_port_not_in_disc(
						struct unf_lport_s *v_lport,
						unsigned int v_rscn_nport_id)
{
	/* RSCN Port_ID not in GID_ACC payload table: Link Down */
	struct unf_rport_s *rport = NULL;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3566, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);

	/* from R_Port busy list by N_Port_ID */
	rport = unf_get_rport_by_nport_id(v_lport, v_rscn_nport_id);
	if (rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_KEVENT,
			  "[info]Port(0x%x) RPort(0x%x) wwpn(0x%llx) has been removed and link down it",
			  v_lport->port_id, v_rscn_nport_id,
			  rport->port_name);

		unf_rport_linkdown(v_lport, rport);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x) has no RPort(0x%x) and do nothing",
			  v_lport->nport_id, v_rscn_nport_id);
	}

	return ret;
}

static unsigned int unf_handle_rscn_port_in_disc(struct unf_lport_s *v_lport,
						 unsigned int v_rscn_nport_id)
{
	/* Send GPN_ID or re-login(GNN_ID) */
	struct unf_rport_s *rport = NULL;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3567, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);

	/* from R_Port busy list by N_Port_ID */
	rport = unf_get_rport_by_nport_id(v_lport, v_rscn_nport_id);
	if (rport) {
		/* R_Port exist: send GPN_ID */
		ret = unf_rport_check_wwn(v_lport, rport);
	} else {
		if ((v_lport->options & UNF_PORT_MODE_INI) ==
		    UNF_PORT_MODE_INI) {
			/* Re-LOGIN with INI mode: Send GNN_ID */
			ret = unf_rport_relogin(v_lport, v_rscn_nport_id);
		} else {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_MAJOR,
				  "[info]Port(0x%x) with no INI feature. Do nothing",
				  v_lport->nport_id);
		}
	}

	return ret;
}

static unsigned int unf_handle_rscn_port_addr(
				struct unf_port_id_page_s *v_port_id_page,
				struct unf_gif_acc_pld_s *v_gid_acc_pld,
				struct unf_lport_s *v_lport)
{
	/*
	 * Input parameters:
	 * 1. Port_ID_page: saved from RSCN payload
	 * 2. GID_ACC_payload: back from GID_ACC (GID_PT or GID_FT)
	 **
	 * Do work: check whether RSCN Port_ID within GID_ACC payload or not
	 * then, re-login or link down rport
	 */
	unsigned int rscn_nport_id = 0;
	unsigned int gid_port_id = 0;
	unsigned int nport_id = 0;
	unsigned int i = 0;
	unsigned char control = 0;
	unsigned int ret = RETURN_OK;
	enum int_e have_same_id = UNF_FALSE;

	UNF_CHECK_VALID(0x3568, UNF_TRUE, v_port_id_page,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3569, UNF_TRUE, v_gid_acc_pld,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3570, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);

	/* 1. get RSCN_NPort_ID from (L_Port->Disc->RSCN_Mgr)->RSCN_Port_ID_Page */
	rscn_nport_id = UNF_SERVICE_GET_NPORTID_FORM_GID_PAGE(v_port_id_page);

	/*
	 * 2. for RSCN_NPort_ID
	 * check whether RSCN_NPort_ID within GID_ACC_Payload or not
	 */
	while (i < UNF_GID_PORT_CNT) { /* 4k */
		gid_port_id = (v_gid_acc_pld->gid_port_id[i]);
		nport_id = UNF_NPORTID_MASK & gid_port_id;
		control = UNF_GID_CONTROL(gid_port_id);

		if ((v_lport->nport_id != nport_id) && (nport_id != 0)) {
			/* is not L_Port */
			if (rscn_nport_id == nport_id) {
				/* RSCN Port_ID within GID_ACC payload */
				have_same_id = UNF_TRUE;
				break;
			}
		}

		if ((control & UNF_GID_LAST_PORT_ID) == UNF_GID_LAST_PORT_ID)
			break;

		i++;
	}

	/* 3. RSCN_Port_ID not within GID_ACC payload table */
	if (have_same_id == UNF_FALSE) {
		/* rport has been removed */
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[warn]Port(0x%x_0x%x) find RSCN N_Port_ID(0x%x) in GID_ACC table failed",
			  v_lport->port_id, v_lport->nport_id,
			  rscn_nport_id);

		/* Link down rport */
		ret = unf_handle_rscn_port_not_in_disc(v_lport,
						       rscn_nport_id);
	} else { /* 4. RSCN_Port_ID within GID_ACC payload table */
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x_0x%x) find RSCN N_Port_ID(0x%x) in GID_ACC table succeed",
			  v_lport->port_id, v_lport->nport_id,
			  rscn_nport_id);

		/* Re-login with INI mode */
		ret = unf_handle_rscn_port_in_disc(v_lport, rscn_nport_id);
	}

	return ret;
}

static void unf_check_rport_rscn_process(
				struct unf_rport_s *v_rport,
				struct unf_port_id_page_s *v_port_id_page)
{
	struct unf_rport_s *rport = v_rport;
	struct unf_port_id_page_s *port_id_page = v_port_id_page;
	unsigned char format = port_id_page->uc_addr_format;

	switch (format) {
	/* domain+area */
	case UNF_RSCN_AREA_ADDR_GROUP:
		if (UNF_GET_DOMAIN_ID(rport->nport_id) ==
		    port_id_page->port_id_domain &&
		    UNF_GET_AREA_ID(rport->nport_id) ==
		    port_id_page->port_id_area) {
			rport->rscn_position = UNF_RPORT_NEED_PROCESS;
		}
		break;
	/* domain */
	case UNF_RSCN_DOMAIN_ADDR_GROUP:
		if (UNF_GET_DOMAIN_ID(rport->nport_id) ==
		    port_id_page->port_id_domain)
			rport->rscn_position = UNF_RPORT_NEED_PROCESS;
		break;
	/* all */
	case UNF_RSCN_FABRIC_ADDR_GROUP:
		rport->rscn_position = UNF_RPORT_NEED_PROCESS;
		break;
	default:
		break;
	}
}

static void unf_set_rport_rscn_position(
				struct unf_lport_s *v_lport,
				struct unf_port_id_page_s *v_port_id_page)
{
	struct unf_rport_s *rport = NULL;
	struct list_head *node = NULL;
	struct list_head *next_node = NULL;
	struct unf_disc_s *disc = NULL;
	unsigned long disc_flag = 0;
	unsigned long rport_flag = 0;

	UNF_CHECK_VALID(0x3571, UNF_TRUE, v_lport, return);
	disc = &v_lport->disc;

	spin_lock_irqsave(&disc->rport_busy_pool_lock, disc_flag);
	list_for_each_safe(node, next_node, &disc->list_busy_rports) {
		rport = list_entry(node, struct unf_rport_s, entry_rport);
		spin_lock_irqsave(&rport->rport_state_lock, rport_flag);

		if (rport->nport_id < UNF_FC_FID_DOM_MGR) {
			if (rport->rscn_position == UNF_RPORT_NOT_NEED_PROCESS)
				unf_check_rport_rscn_process(rport,
							     v_port_id_page);
		} else {
			rport->rscn_position = UNF_RPORT_NOT_NEED_PROCESS;
		}

		spin_unlock_irqrestore(&rport->rport_state_lock, rport_flag);
	}
	spin_unlock_irqrestore(&disc->rport_busy_pool_lock, disc_flag);
}

static void unf_set_rport_rscn_position_local(struct unf_lport_s *v_lport)
{
	struct unf_rport_s *rport = NULL;
	struct list_head *node = NULL;
	struct list_head *next_node = NULL;
	struct unf_disc_s *disc = NULL;
	unsigned long disc_flag = 0;
	unsigned long rport_flag = 0;

	UNF_CHECK_VALID(0x3572, UNF_TRUE, v_lport, return);
	disc = &v_lport->disc;

	spin_lock_irqsave(&disc->rport_busy_pool_lock, disc_flag);
	list_for_each_safe(node, next_node, &disc->list_busy_rports) {
		rport = list_entry(node, struct unf_rport_s, entry_rport);
		spin_lock_irqsave(&rport->rport_state_lock, rport_flag);

		if (rport->nport_id < UNF_FC_FID_DOM_MGR) {
			if (rport->rscn_position == UNF_RPORT_NEED_PROCESS)
				rport->rscn_position =
					UNF_RPORT_ONLY_IN_LOCAL_PROCESS;
		} else {
			rport->rscn_position = UNF_RPORT_NOT_NEED_PROCESS;
		}

		spin_unlock_irqrestore(&rport->rport_state_lock, rport_flag);
	}
	spin_unlock_irqrestore(&disc->rport_busy_pool_lock, disc_flag);
}

static void unf_reset_rport_rscn_setting(struct unf_lport_s *v_lport)
{
	struct unf_rport_s *rport = NULL;
	struct list_head *node = NULL;
	struct list_head *next_node = NULL;
	struct unf_disc_s *disc = NULL;
	unsigned long rport_flag = 0;

	UNF_CHECK_VALID(0x3573, UNF_TRUE, v_lport, return);
	disc = &v_lport->disc;

	list_for_each_safe(node, next_node, &disc->list_busy_rports) {
		rport = list_entry(node, struct unf_rport_s, entry_rport);
		spin_lock_irqsave(&rport->rport_state_lock, rport_flag);
		rport->rscn_position = UNF_RPORT_NOT_NEED_PROCESS;
		spin_unlock_irqrestore(&rport->rport_state_lock, rport_flag);
	}
}

static void unf_compare_nport_id_with_rport_list(
				struct unf_lport_s *v_lport,
				unsigned int v_nport_id,
				struct unf_port_id_page_s *v_port_id_page)
{
	struct unf_rport_s *rport = NULL;
	unsigned long rport_flag = 0;
	unsigned char format = v_port_id_page->uc_addr_format;

	UNF_CHECK_VALID(0x3574, UNF_TRUE, v_lport, return);

	switch (format) {
	/* domain+area */
	case UNF_RSCN_AREA_ADDR_GROUP:
		if ((UNF_GET_DOMAIN_ID(v_nport_id) !=
		    v_port_id_page->port_id_domain) ||
		    (UNF_GET_AREA_ID(v_nport_id) !=
		    v_port_id_page->port_id_area))
			return;
		break;
	/* domain */
	case UNF_RSCN_DOMAIN_ADDR_GROUP:
		if (UNF_GET_DOMAIN_ID(v_nport_id) !=
		   v_port_id_page->port_id_domain)
			return;
		break;
	/* all */
	case UNF_RSCN_FABRIC_ADDR_GROUP:
		break;
	/* can't enter this branch guarantee by outer */
	default:
		break;
	}

	rport = unf_get_rport_by_nport_id(v_lport, v_nport_id);

	if (!rport) {
		if ((v_lport->options & UNF_PORT_MODE_INI) ==
		    UNF_PORT_MODE_INI) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
				  UNF_KEVENT,
				  "[event]Port(0x%x) Find Rport(0x%x) by RSCN",
				  v_lport->nport_id, v_nport_id);
			unf_rport_relogin(v_lport, v_nport_id);
		}
	} else {
		spin_lock_irqsave(&rport->rport_state_lock, rport_flag);
		if (rport->rscn_position == UNF_RPORT_NEED_PROCESS)
			rport->rscn_position =
				UNF_RPORT_IN_DISC_AND_LOCAL_PROCESS;

		spin_unlock_irqrestore(&rport->rport_state_lock, rport_flag);
	}
}

static void unf_compare_disc_with_local_rport(
				struct unf_lport_s *v_lport,
				struct unf_gif_acc_pld_s *v_gid_acc_pld,
				struct unf_port_id_page_s *v_port_id_page)
{
	unsigned int gid_port_id = 0;
	unsigned int nport_id = 0;
	unsigned int i = 0;
	unsigned char control = 0;

	UNF_CHECK_VALID(0x3575, UNF_TRUE, v_gid_acc_pld, return);
	UNF_CHECK_VALID(0x3576, UNF_TRUE, v_lport, return);

	while (i < UNF_GID_PORT_CNT) {
		gid_port_id = (v_gid_acc_pld->gid_port_id[i]);
		nport_id = UNF_NPORTID_MASK & gid_port_id;
		control = UNF_GID_CONTROL(gid_port_id);

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]Port(0x%x) DISC N_Port_ID(0x%x)",
			  v_lport->nport_id, nport_id);

		if ((nport_id != 0) &&
		    (!unf_lookup_lport_by_nport_id(v_lport, nport_id)))
			unf_compare_nport_id_with_rport_list(v_lport, nport_id,
							     v_port_id_page);

		if ((UNF_GID_LAST_PORT_ID & control) == UNF_GID_LAST_PORT_ID)
			break;

		i++;
	}

	unf_set_rport_rscn_position_local(v_lport);
}

static unsigned int unf_process_each_rport_after_rscn(
						struct unf_lport_s *v_lport,
						struct unf_rport_s *v_sns_port,
						struct unf_rport_s *v_rport)
{
	unsigned long rport_flag = 0;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3577, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3578, UNF_TRUE, v_sns_port, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3579, UNF_TRUE, v_sns_port, return UNF_RETURN_ERROR);

	UNF_REFERNCE_VAR(v_sns_port);

	spin_lock_irqsave(&v_rport->rport_state_lock, rport_flag);

	if (v_rport->rscn_position == UNF_RPORT_IN_DISC_AND_LOCAL_PROCESS) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_KEVENT,
			  "[info]Port(0x%x_0x%x) RPort(0x%x) rescan position(0x%x), check wwpn",
			  v_lport->port_id, v_lport->nport_id,
			  v_rport->nport_id, v_rport->rscn_position);
		v_rport->rscn_position = UNF_RPORT_NOT_NEED_PROCESS;
		spin_unlock_irqrestore(&v_rport->rport_state_lock, rport_flag);
		ret = unf_rport_check_wwn(v_lport, v_rport);
	} else if (v_rport->rscn_position ==
		   UNF_RPORT_ONLY_IN_LOCAL_PROCESS) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_KEVENT,
			  "[event]Port(0x%x_0x%x) RPort(0x%x) rescan position(0x%x), linkdown it",
			  v_lport->port_id, v_lport->nport_id,
			  v_rport->nport_id, v_rport->rscn_position);
		v_rport->rscn_position = UNF_RPORT_NOT_NEED_PROCESS;
		spin_unlock_irqrestore(&v_rport->rport_state_lock, rport_flag);
		unf_rport_linkdown(v_lport, v_rport);
	} else {
		spin_unlock_irqrestore(&v_rport->rport_state_lock, rport_flag);
	}

	return ret;
}

static unsigned int unf_process_local_rport_after_rscn(
					struct unf_lport_s *v_lport,
					struct unf_rport_s *v_sns_port)
{
	struct unf_rport_s *rport = NULL;
	struct list_head *node = NULL;
	struct unf_disc_s *disc = NULL;
	unsigned long disc_flag = 0;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3580, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3581, UNF_TRUE, v_sns_port, return UNF_RETURN_ERROR);
	disc = &v_lport->disc;

	spin_lock_irqsave(&disc->rport_busy_pool_lock, disc_flag);
	if (list_empty(&disc->list_busy_rports)) {
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, disc_flag);

		return UNF_RETURN_ERROR;
	}

	node = (&disc->list_busy_rports)->next;

	do {
		rport = list_entry(node, struct unf_rport_s, entry_rport);

		if (rport->rscn_position == UNF_RPORT_NOT_NEED_PROCESS) {
			node = node->next;
			continue;
		} else {
			spin_unlock_irqrestore(&disc->rport_busy_pool_lock,
					       disc_flag);
			ret = unf_process_each_rport_after_rscn(v_lport,
								v_sns_port,
								rport);
			spin_lock_irqsave(&disc->rport_busy_pool_lock,
					  disc_flag);
			node = (&disc->list_busy_rports)->next;
		}
	} while (node != &disc->list_busy_rports);

	unf_reset_rport_rscn_setting(v_lport);
	spin_unlock_irqrestore(&disc->rport_busy_pool_lock, disc_flag);

	return ret;
}

static unsigned int unf_handle_rscn_group_addr(
				struct unf_port_id_page_s *v_port_id_page,
				struct unf_gif_acc_pld_s *v_gid_acc_pld,
				struct unf_lport_s *v_lport)
{
	struct unf_rport_s *sns_port = NULL;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3582, UNF_TRUE, v_port_id_page,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3583, UNF_TRUE, v_gid_acc_pld,
			return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3584, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);

	UNF_REFERNCE_VAR(v_port_id_page);

	sns_port = unf_get_rport_by_nport_id(v_lport, UNF_FC_FID_DIR_SERV);
	if (!sns_port) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) find fabric port failed",
			  v_lport->port_id);

		return UNF_RETURN_ERROR;
	}

	unf_set_rport_rscn_position(v_lport, v_port_id_page);
	unf_compare_disc_with_local_rport(v_lport, v_gid_acc_pld,
					  v_port_id_page);

	ret = unf_process_local_rport_after_rscn(v_lport, sns_port);
	return ret;
}

static void unf_handle_rscn_gid_acc(struct unf_gif_acc_pld_s *v_gid_acc_pld,
				    struct unf_lport_s *v_lport)
{
	/* for N_Port_ID table return from RSCN */
	struct unf_port_id_page_s *port_id_page = NULL;
	struct unf_rscn_mg_s *rscn_mgr = NULL;
	struct list_head *list_node = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3585, UNF_TRUE, v_gid_acc_pld, return);
	UNF_CHECK_VALID(0x3586, UNF_TRUE, v_lport, return);
	rscn_mgr = &v_lport->disc.rscn_mgr;

	spin_lock_irqsave(&rscn_mgr->rscn_id_list_lock, flag);
	while (!list_empty(&rscn_mgr->list_using_rscn_page)) {
		/*
		 * for each RSCN_Using_Page(NPortID)
		 * for each L_Port->Disc->RSCN_Mgr->
		 * RSCN_Using_Page(Port_ID_Page)
		 * NOTE:
		 * check using_page_port_id whether within
		 * GID_ACC payload or not
		 */
		list_node = (&rscn_mgr->list_using_rscn_page)->next;
		port_id_page = list_entry(list_node, struct unf_port_id_page_s,
					  list_node_rscn);
		/* NOTE: here delete node (from RSCN using Page) */
		list_del(list_node);
		spin_unlock_irqrestore(&rscn_mgr->rscn_id_list_lock, flag);

		switch (port_id_page->uc_addr_format) {
		/* each page of RSNC corresponding one of N_Port_ID */
		case UNF_RSCN_PORT_ADDR:
			(void)unf_handle_rscn_port_addr(port_id_page,
							v_gid_acc_pld,
							v_lport);
			break;

		/* each page of RSNC corresponding address group */
		case UNF_RSCN_AREA_ADDR_GROUP:
		case UNF_RSCN_DOMAIN_ADDR_GROUP:
		case UNF_RSCN_FABRIC_ADDR_GROUP:
			(void)unf_handle_rscn_group_addr(port_id_page,
							 v_gid_acc_pld,
							 v_lport);
			break;

		default:
			break;
		}

		/* NOTE: release this RSCN_Node */
		rscn_mgr->pfn_unf_release_rscn_node(rscn_mgr, port_id_page);

		/* go to next */
		spin_lock_irqsave(&rscn_mgr->rscn_id_list_lock, flag);
	}
	spin_unlock_irqrestore(&rscn_mgr->rscn_id_list_lock, flag);
}

static void unf_gid_acc_handle(struct unf_gif_acc_pld_s *v_gid_acc_pld,
			       struct unf_lport_s *v_lport)
{
#define UNF_NONE_DISC 0X0 /* before enter DISC */

	struct unf_disc_s *disc = NULL;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3587, UNF_TRUE, v_gid_acc_pld, return);
	UNF_CHECK_VALID(0x3588, UNF_TRUE, v_lport, return);
	disc = &v_lport->disc;

	spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
	switch (disc->disc_option) {
	case UNF_INIT_DISC:  // from SCR callback with INI mode
		disc->disc_option = UNF_NONE_DISC;
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);
		/* R_Port from Disc_list */
		unf_handle_init_gid_acc(v_gid_acc_pld, v_lport);
		break;

	case UNF_RSCN_DISC:  /* from RSCN payload parse(analysis) */
		disc->disc_option = UNF_NONE_DISC;
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

		/* R_Port from busy_list */
		unf_handle_rscn_gid_acc(v_gid_acc_pld, v_lport);
		break;

	default:
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x)'s disc option(0x%x) is abnormal",
			  v_lport->port_id,
			  v_lport->nport_id,
			  disc->disc_option);
		break;
	}
}

static void unf_gid_ft_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	struct unf_lport_s *lport = NULL;
	struct unf_disc_s *disc = NULL;
	struct unf_gif_acc_pld_s *gid_acc_pld = NULL;
	struct unf_xchg_s *xchg = NULL;
	union unf_sfs_u *sfs_ptr = NULL;
	unsigned int cmnd_rsp_size = 0;
	unsigned int rjt_reason = 0;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3590, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3591, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3592, UNF_TRUE, v_xchg, return);
	UNF_REFERNCE_VAR(v_rport);

	lport = (struct unf_lport_s *)v_lport;
	xchg = (struct unf_xchg_s *)v_xchg;
	disc = &lport->disc;

	sfs_ptr = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	gid_acc_pld = sfs_ptr->get_id.gid_rsp.gid_acc_pld;
	if (!gid_acc_pld) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x) GID_FT response payload is NULL",
			  lport->port_id);

		return;
	}

	cmnd_rsp_size = (gid_acc_pld->ctiu_pream.cmnd_rsp_size);
	if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_ACCEPT) {
		spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
		unf_disc_state_ma(lport, UNF_EVENT_DISC_SUCCESS);
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

		/* Process GID_FT ACC */
		unf_gid_acc_handle(gid_acc_pld, lport);
	} else if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_REJECT) {
		rjt_reason = (gid_acc_pld->ctiu_pream.frag_reason_exp_vend);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x) GID_FT was rejected with reason code(0x%x)",
			  lport->port_id, rjt_reason);

		if ((rjt_reason & UNF_CTIU_RJT_EXP_MASK) ==
		    UNF_CTIU_RJT_EXP_FC4TYPE_NO_REG) {
			spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
			unf_disc_state_ma(lport, UNF_EVENT_DISC_SUCCESS);
			spin_unlock_irqrestore(&disc->rport_busy_pool_lock,
					       flag);

			unf_gid_acc_handle(gid_acc_pld, lport);
		} else {
			spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
			unf_disc_state_ma(lport, UNF_EVENT_DISC_SUCCESS);
			spin_unlock_irqrestore(&disc->rport_busy_pool_lock,
					       flag);
		}
	} else {
		spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
		unf_disc_state_ma(lport, UNF_EVENT_DISC_FAILED);
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

		/* Do DISC recovery operation */
		unf_disc_error_recovery(lport);
	}
}

static void unf_gid_pt_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_disc_s *disc = NULL;
	struct unf_gif_acc_pld_s *gid_acc_pld = NULL;
	struct unf_xchg_s *xchg = NULL;
	union unf_sfs_u *sfs_ptr = NULL;
	unsigned int cmnd_rsp_size = 0;
	unsigned int rjt_reason = 0;
	unsigned long flag = 0;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3594, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3595, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3596, UNF_TRUE, v_xchg, return);

	lport = (struct unf_lport_s *)v_lport;
	rport = (struct unf_rport_s *)v_rport;
	disc = &lport->disc;
	xchg = (struct unf_xchg_s *)v_xchg;
	sfs_ptr = xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;

	gid_acc_pld = sfs_ptr->get_id.gid_rsp.gid_acc_pld;
	if (!gid_acc_pld) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x) GID_PT response payload is NULL",
			  lport->port_id);

		return;
	}

	cmnd_rsp_size = (gid_acc_pld->ctiu_pream.cmnd_rsp_size);
	if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_ACCEPT) {
		spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
		unf_disc_state_ma(lport, UNF_EVENT_DISC_SUCCESS);
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

		unf_gid_acc_handle(gid_acc_pld, lport);
	} else if ((cmnd_rsp_size & UNF_CT_IU_RSP_MASK) == UNF_CT_IU_REJECT) {
		rjt_reason = (gid_acc_pld->ctiu_pream.frag_reason_exp_vend);

		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x_0x%x) GID_PT was rejected with reason code(0x%x)",
			  lport->port_id, lport->nport_id, rjt_reason);

		if (UNF_CTIU_RJT_EXP_PORTTYPE_NO_REG ==
		    (rjt_reason & UNF_CTIU_RJT_EXP_MASK)) {
			spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
			unf_disc_state_ma(lport, UNF_EVENT_DISC_SUCCESS);
			spin_unlock_irqrestore(&disc->rport_busy_pool_lock,
					       flag);

			unf_gid_acc_handle(gid_acc_pld, lport);
		} else {
			ret = unf_send_gid_ft(lport, rport);
			if (ret != RETURN_OK) {
				spin_lock_irqsave(&disc->rport_busy_pool_lock,
						  flag);
				unf_disc_state_ma(lport, UNF_EVENT_DISC_FAILED);
				spin_unlock_irqrestore(
					&disc->rport_busy_pool_lock, flag);

				/* Do DISC recovery */
				unf_disc_error_recovery(lport);
			}
		}
	} else {
		spin_lock_irqsave(&disc->rport_busy_pool_lock, flag);
		unf_disc_state_ma(lport, UNF_EVENT_DISC_FAILED);
		spin_unlock_irqrestore(&disc->rport_busy_pool_lock, flag);

		/* Do DISC recovery */
		unf_disc_error_recovery(lport);
	}
}

void unf_rcv_gnn_id_rsp_unknown(struct unf_lport_s *v_lport,
				struct unf_rport_s *v_sns_port,
				unsigned int v_nport_id)
{
	/* Send GFF_ID */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *sns_port = v_sns_port;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3606, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3607, UNF_TRUE, v_sns_port, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
		  UNF_WARN,
		  "[warn]LOGIN: Port(0x%x_0x%x) Rportid(0x%x) GNN_ID response is unknown. Sending GFF_ID",
		  lport->port_id, lport->nport_id, v_nport_id);

	ret = unf_get_and_post_disc_event(lport, sns_port, v_nport_id,
					  UNF_DISC_GET_FEATURE);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) add discovery event(0x%x) failed Rport(0x%x)",
			  lport->port_id, UNF_DISC_GET_FEATURE, v_nport_id);

		/* NOTE: go to next stage */
		unf_rcv_gff_id_rsp_unknown(lport, v_nport_id);  // send PLOGI
	}
}

void unf_rcv_gff_id_rsp_unknown(struct unf_lport_s *v_lport,
				unsigned int v_nport_id)
{
	/* Send PLOGI */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;
	unsigned long flag = 0;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3624, UNF_TRUE, v_lport, return);

	UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
		  "[warn]LOGIN: Port(0x%x) send GFF_ID for RPort(0x%x) but response is unknown",
		  lport->port_id, v_nport_id);

	/* Get (Safe) R_Port & Set State */
	rport = unf_get_rport_by_nport_id(lport, v_nport_id);
	if (rport)
		rport = unf_find_rport(lport, v_nport_id, rport->port_name);

	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) can't get RPort by NPort ID(0x%x), allocate new RPort",
			  lport->port_id, lport->nport_id, v_nport_id);

		rport = unf_rport_get_free_and_init(lport, UNF_PORT_TYPE_FC,
						    v_nport_id);
		UNF_CHECK_VALID(0x3619, UNF_TRUE, NULL != rport, return);

		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->nport_id = v_nport_id;
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);
	}

	rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_ONLY,
				   v_nport_id);
	UNF_CHECK_VALID(0x3625, UNF_TRUE, rport, return);

	/* Update R_Port state: PLOGI_WAIT */
	spin_lock_irqsave(&rport->rport_state_lock, flag);
	rport->nport_id = v_nport_id;
	unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	/* Start to send PLOGI */
	ret = unf_send_plogi(lport, rport);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x) can not send PLOGI for RPort(0x%x), enter recovery",
			  lport->port_id, v_nport_id);

		unf_rport_error_recovery(rport);
	}
}

static void unf_lport_update_nport_id(struct unf_lport_s *v_lport,
				      unsigned int v_nport_id)
{
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3646, UNF_TRUE, v_lport, return);

	spin_lock_irqsave(&v_lport->lport_state_lock, flag);
	v_lport->nport_id = v_nport_id;
	spin_unlock_irqrestore(&v_lport->lport_state_lock, flag);
}

static void unf_lport_update_time_params(
				struct unf_lport_s *v_lport,
				struct unf_flogi_payload_s *v_flogi_payload)
{
	unsigned long flag = 0;
	unsigned int ed_tov = 0;
	unsigned int ra_tov = 0;

	UNF_CHECK_VALID(0x3647, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3648, UNF_TRUE, v_flogi_payload, return);

	ed_tov = v_flogi_payload->fabric_parms.co_parms.e_d_tov;
	ra_tov = v_flogi_payload->fabric_parms.co_parms.r_a_tov;

	spin_lock_irqsave(&v_lport->lport_state_lock, flag);

	/* FC-FS-3: 21.3.4, 21.3.5 */
	if ((v_lport->en_act_topo == UNF_ACT_TOP_P2P_FABRIC) ||
	    (v_lport->en_act_topo == UNF_ACT_TOP_PUBLIC_LOOP)) {
		v_lport->ed_tov = ed_tov;
		v_lport->ra_tov = ra_tov;
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_EQUIP_ATT,
			  UNF_MAJOR,
			  "[info]Port(0x%x_0x%x) with topo(0x%x) no need to save time parameters",
			  v_lport->port_id, v_lport->nport_id,
			  v_lport->en_act_topo);
	}

	spin_unlock_irqrestore(&v_lport->lport_state_lock, flag);
}

static void unf_fdisc_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	/* Register to Name Server or Do recovery */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_xchg_s *xchg = NULL;
	struct unf_flogi_payload_s *fdisc_pld = NULL;
	unsigned long flag = 0;
	unsigned int cmd = 0;

	lport = (struct unf_lport_s *)v_lport;
	rport = (struct unf_rport_s *)v_rport;
	xchg = (struct unf_xchg_s *)v_xchg;
	UNF_CHECK_VALID(0x3640, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3641, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3642, UNF_TRUE, v_xchg, return);
	UNF_CHECK_VALID(0x3643, UNF_TRUE,
			xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr,
			return);
	fdisc_pld = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->fdisc_acc.fdisc_payload;
	if (xchg->byte_orders & UNF_BIT_2)
		unf_big_end_to_cpu((unsigned char *)fdisc_pld,
				   sizeof(struct unf_flogi_payload_s));

	cmd = fdisc_pld->cmnd;
	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: FDISC response is (0x%x). Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
		  cmd, lport->port_id, rport->nport_id, xchg->ox_id);
	rport = unf_get_rport_by_nport_id(lport, UNF_FC_FID_FLOGI);
	rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_ONLY,
				   UNF_FC_FID_FLOGI);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) has no Rport", lport->port_id);
		return;
	}

	spin_lock_irqsave(&rport->rport_state_lock, flag);
	rport->nport_id = UNF_FC_FID_FLOGI;
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	if ((cmd & UNF_ELS_CMND_HIGH_MASK) == UNF_ELS_CMND_ACC) {
		/* Case for ACC */
		spin_lock_irqsave(&lport->lport_state_lock, flag);
		if (lport->en_states != UNF_LPORT_ST_FLOGI_WAIT) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x_0x%x) receive Flogi/Fdisc ACC in state(0x%x)",
				  lport->port_id, lport->nport_id,
				  lport->en_states);

			spin_unlock_irqrestore(&lport->lport_state_lock, flag);
			return;
		}
		spin_unlock_irqrestore(&lport->lport_state_lock, flag);

		unf_lport_update_nport_id(lport, xchg->sid);
		unf_lport_update_time_params(lport, fdisc_pld);

		unf_register_to_switch(lport);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: FDISC response is (0x%x). Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
			  cmd, lport->port_id, rport->nport_id,
			  xchg->ox_id);

		/* Case for RJT: Do L_Port recovery */
		unf_lport_error_recovery(lport);
	}
}

static void unf_rcv_flogi_acc(struct unf_lport_s *v_lport,
			      struct unf_rport_s *v_rport,
			      struct unf_flogi_payload_s *v_flogi_pld,
			      unsigned int v_nport_id,
			      struct unf_xchg_s *v_xchg)
{
	/* PLOGI to Name server or remote port */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = v_rport;
	struct unf_flogi_payload_s *flogi_pld = v_flogi_pld;
	struct unf_fabric_parms_s *fabric_params = NULL;
	unsigned long long port_name = 0;
	unsigned long long node_name = 0;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3649, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3650, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3651, UNF_TRUE, v_flogi_pld, return);

	/* Check L_Port state: FLOGI_WAIT */
	spin_lock_irqsave(&lport->lport_state_lock, flag);
	if (lport->en_states != UNF_LPORT_ST_FLOGI_WAIT) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[info]Port(0x%x_0x%x) receive FLOGI ACC with state(0x%x)",
			  lport->port_id, lport->nport_id, lport->en_states);

		spin_unlock_irqrestore(&lport->lport_state_lock, flag);
		return;
	}
	spin_unlock_irqrestore(&lport->lport_state_lock, flag);

	fabric_params = &flogi_pld->fabric_parms;
	node_name = (unsigned long long)
		(((unsigned long long)(fabric_params->high_node_name) << 32) |
		 ((unsigned long long)(fabric_params->low_node_name)));
	port_name = (unsigned long long)
		(((unsigned long long)(fabric_params->high_port_name) << 32) |
		 ((unsigned long long)(fabric_params->low_port_name)));

	/* flogi acc pyload class 3 service priority value */
	lport->b_priority = UNF_PRIORITY_DISABLE;

	/* Save Flogi parameters */
	unf_save_fabric_params(lport, rport, fabric_params);

	if (UNF_CHECK_NPORT_FPORT_BIT(flogi_pld) == UNF_N_PORT) {
		/* P2P Mode */
		unf_lport_update_topo(lport, UNF_ACT_TOP_P2P_DIRECT);
		unf_login_with_rport_in_n2n(lport, port_name, node_name);
	} else {
		/* for: UNF_ACT_TOP_PUBLIC_LOOP
		 * /UNF_ACT_TOP_P2P_FABRIC/UNF_TOP_P2P_MASK
		 */
		if (lport->en_act_topo != UNF_ACT_TOP_PUBLIC_LOOP)
			unf_lport_update_topo(lport, UNF_ACT_TOP_P2P_FABRIC);

		unf_lport_update_nport_id(lport, v_nport_id);
		unf_lport_update_time_params(lport, flogi_pld);

		/* Save process both for Public loop & Fabric */
		unf_register_to_switch(lport);
	}
}

static void unf_flogi_acc_com_process(struct unf_xchg_s *v_xchg)
{
	/* Maybe within interrupt or thread context */
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_flogi_payload_s *flogi_pld = NULL;
	unsigned int nport_id = 0;
	unsigned int cmnd = 0;
	unsigned long flags = 0;
	struct unf_xchg_s *xchg = v_xchg;

	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg, return);
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg->lport, return);

	lport = xchg->lport;
	rport = xchg->rport;
	flogi_pld = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->flogi_acc.flogi_payload;
	cmnd = flogi_pld->cmnd;

	/* Get N_Port_ID & R_Port */
	/* Others: 0xFFFFFE */
	rport = unf_get_rport_by_nport_id(lport, UNF_FC_FID_FLOGI);
	nport_id = UNF_FC_FID_FLOGI;

	/* Get Safe R_Port: reuse only */
	rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_ONLY,
				   nport_id);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can not allocate new Rport",
			  lport->port_id);

		return;
	}

	/* Update R_Port N_Port_ID */
	spin_lock_irqsave(&rport->rport_state_lock, flags);
	/* Others: 0xFFFFFE */
	rport->nport_id = UNF_FC_FID_FLOGI;
	spin_unlock_irqrestore(&rport->rport_state_lock, flags);

	/* Process FLOGI ACC or RJT */
	if ((cmnd & UNF_ELS_CMND_HIGH_MASK) == UNF_ELS_CMND_ACC) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
			  "[info]LOGIN: FLOGI response is(0x%x). Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
			  cmnd, lport->port_id, rport->nport_id,
			  xchg->ox_id);

		/* Case for ACC */
		unf_rcv_flogi_acc(lport, rport, flogi_pld, xchg->sid, xchg);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: FLOGI response is(0x%x). Port(0x%x)<---RPort(0x%x) with OX_ID(0x%x)",
			  cmnd, lport->port_id, rport->nport_id,
			  xchg->ox_id);

		/* Case for RJT: do L_Port error recovery */
		unf_lport_error_recovery(lport);
	}
}

static int unf_rcv_flogi_acc_async_callback(void *v_arg_in,
					    void *v_arg_out)
{
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_arg_in;

	UNF_CHECK_VALID(0x2267, UNF_TRUE, xchg, return UNF_RETURN_ERROR);

	unf_flogi_acc_com_process(xchg);

	unf_xchg_ref_dec(xchg, SFS_RESPONSE);
	return RETURN_OK;
}

static void unf_flogi_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	/* Callback function for FLOGI ACC or RJT */
	struct unf_lport_s *lport = (struct unf_lport_s *)v_lport;
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_xchg;
	struct unf_flogi_payload_s *flogi_pld = NULL;
	int bbscn_enabled = UNF_FALSE;
	enum unf_act_topo_e act_topo = UNF_ACT_TOP_UNKNOWN;
	int switch_2_thread = UNF_FALSE;

	UNF_CHECK_VALID(0x3652, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3653, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3654, UNF_TRUE, v_xchg, return);
	UNF_CHECK_VALID(0x3655, UNF_TRUE,
			xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr,
			return);

	xchg->lport = v_lport;
	flogi_pld = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->flogi_acc.flogi_payload;

	if (xchg->byte_orders & UNF_BIT_2)
		unf_big_end_to_cpu((unsigned char *)flogi_pld,
				   sizeof(struct unf_flogi_payload_s));

	if ((lport->en_act_topo != UNF_ACT_TOP_PUBLIC_LOOP) &&
	    (UNF_CHECK_NPORT_FPORT_BIT(flogi_pld) == UNF_F_PORT))
		/* Get Top Mode (P2P_F) --->>> used for BBSCN */
		act_topo = UNF_ACT_TOP_P2P_FABRIC;

	bbscn_enabled = unf_check_bbscn_is_enabled(
			(unsigned char)
			lport->low_level_func.lport_cfg_items.bb_scn,
			(unsigned char)
			UNF_GET_BB_SC_N_FROM_PARAMS(&flogi_pld->fabric_parms));
	if ((act_topo == UNF_ACT_TOP_P2P_FABRIC) &&
	    (bbscn_enabled == UNF_TRUE)) {
		/* BBSCN Enable or not --->>> used for Context change */
		lport->b_bbscn_support = UNF_TRUE;
		switch_2_thread = UNF_TRUE;
	}

	if ((switch_2_thread == UNF_TRUE) && (lport->root_lport == lport)) {
		/* Wait for LR done sync: for Root Port */
		(void)unf_irq_process_switch_2_thread(
					lport, xchg,
					unf_rcv_flogi_acc_async_callback);
	} else {
		/* Process FLOGI response directly */
		unf_flogi_acc_com_process(xchg);
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_ALL,
		  "[info]Port(0x%x) process FLOGI response: switch(%d) to thread done",
		  lport->port_id, switch_2_thread);
}

struct unf_rport_s *unf_find_rport(struct unf_lport_s *v_lport,
				   unsigned int v_rport_nport_id,
				   unsigned long long v_port_name)
{
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = NULL;

	UNF_CHECK_VALID(0x3658, UNF_TRUE, v_lport, return NULL);

	if (v_rport_nport_id >= UNF_FC_FID_DOM_MGR) // N_Port_ID <---> SID
		/* R_Port is Fabric: by N_Port_ID */
		rport = unf_get_rport_by_nport_id(lport, v_rport_nport_id);
	else
		/* Others: by WWPN & N_Port_ID */
		rport = unf_find_valid_rport(lport, v_port_name,
					     v_rport_nport_id);

	return rport;
}

static void unf_rcv_plogi_acc(struct unf_lport_s *v_lport,
			      struct unf_rport_s *v_rport,
			      struct unf_lgn_parms_s *v_login_parms)
{
	/* PLOGI ACC: PRLI(non fabric) or RFT_ID(fabric) */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = v_rport;
	struct unf_lgn_parms_s *login_parms = v_login_parms;
	unsigned long long node_name = 0;
	unsigned long long port_name = 0;
	unsigned long flag = 0;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3659, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3660, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3661, UNF_TRUE, v_login_parms, return);

	node_name = (unsigned long long)
		(((unsigned long long)(login_parms->high_node_name) << 32) |
		 ((unsigned long long)(login_parms->low_node_name)));
	port_name = (unsigned long long)
		(((unsigned long long)(login_parms->high_port_name) << 32) |
		 ((unsigned long long)(login_parms->low_port_name)));

	/* ACC & Case for: R_Port is fabric (RFT_ID) */
	if (rport->nport_id >= UNF_FC_FID_DOM_MGR) {
		/* Check L_Port state */
		spin_lock_irqsave(&lport->lport_state_lock, flag);
		if (lport->en_states != UNF_LPORT_ST_PLOGI_WAIT) {
			spin_unlock_irqrestore(&lport->lport_state_lock, flag);

			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x) receive PLOGI ACC with error state(0x%x)",
				  v_lport->port_id, lport->en_states);

			return;
		}
		/* PLOGI_WAIT --> RFT_ID_WAIT */
		unf_lport_stat_ma(lport, UNF_EVENT_LPORT_REMOTE_ACC);
		spin_unlock_irqrestore(&lport->lport_state_lock, flag);

		/* PLOGI parameters save */
		unf_save_plogi_params(lport, rport, login_parms, ELS_ACC);

		/* Update R_Port WWPN & WWNN */
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->node_name = node_name;
		rport->port_name = port_name;
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		/* Start to Send RFT_ID */
		ret = unf_send_rft_id(lport, rport);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]LOGIN: Port(0x%x) send RFT_ID failed",
				  v_lport->port_id);

			unf_lport_error_recovery(lport);
		}
	} else {
		/* ACC & Case for: R_Port is not fabric */
		if ((rport->options == UNF_PORT_MODE_UNKNOWN) &&
		    (rport->port_name != INVALID_WWPN))
			rport->options = unf_get_port_feature(port_name);
		/* Set Port Feature with BOTH: cancel */

		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->node_name = node_name;
		rport->port_name = port_name;

		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_INFO,
			  "[info]LOGIN: Port(0x%x)<---LS_ACC(DID:0x%x SID:0x%x) for PLOGI ACC with RPort state(0x%x) NodeName(0x%llx) E_D_TOV(%d)",
			  lport->port_id, lport->nport_id,
			  rport->nport_id, rport->rp_state,
			  rport->node_name, rport->ed_tov);

		if ((lport->en_act_topo == UNF_ACT_TOP_PRIVATE_LOOP) &&
		    ((rport->rp_state == UNF_RPORT_ST_PRLI_WAIT) ||
		    (rport->rp_state == UNF_RPORT_ST_READY))) {
			/* Do nothing, return directly */
			spin_unlock_irqrestore(&rport->rport_state_lock, flag);
			return;
		}

		/* PRLI_WAIT */
		unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PRLI);
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		/* PLOGI parameters save */
		unf_save_plogi_params(lport, rport, login_parms, ELS_ACC);

		/*
		 * Need Delay to Send PRLI or not
		 * Used for: L_Port with INI mode & R_Port is not Fabric
		 */
		unf_check_rport_need_delay_prli(lport, rport,
						rport->options);

		/* Do not care: Just used for L_Port only is
		 * TGT mode or R_Port only is INI mode
		 */
		unf_schedule_open_work(lport, rport);
	}
}

static void unf_plogi_acc_com_process(struct unf_xchg_s *v_xchg)
{
	struct unf_lport_s *lport = NULL;
	struct unf_rport_s *rport = NULL;
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_xchg;
	struct unf_plogi_payload_s *plogi_pld = NULL;
	struct unf_lgn_parms_s *login_parms = NULL;
	unsigned long flag = 0;
	unsigned long long port_name = 0;
	unsigned int rport_nport_id = 0;
	unsigned int cmnd = 0;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg, return);
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg->lport, return);
	UNF_CHECK_VALID(INVALID_VALUE32, UNF_TRUE, xchg->rport, return);

	lport = xchg->lport;
	rport = xchg->rport;
	rport_nport_id = rport->nport_id;
	plogi_pld = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->plogi_acc.payload;
	login_parms = &plogi_pld->parms;
	cmnd = (plogi_pld->cmnd);

	if ((cmnd & UNF_ELS_CMND_HIGH_MASK) == UNF_ELS_CMND_ACC) {
		/* Case for PLOGI ACC: Go to next stage */
		port_name = (unsigned long long)
			(((unsigned long long)(login_parms->high_port_name) << 32) |
			 ((unsigned long long)(login_parms->low_port_name)));

		/* Get (new) R_Port: 0xfffffc has same WWN with 0xfffcxx */
		rport = unf_find_rport(lport, rport_nport_id, port_name);
		rport = unf_get_safe_rport(lport, rport, UNF_RPORT_REUSE_ONLY,
					   rport_nport_id);
		if (unlikely(!rport)) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]Port(0x%x_0x%x) alloc new RPort with wwpn(0x%llx) failed",
				  lport->port_id, lport->nport_id,
				  port_name);
			return;
		}

		/* PLOGI parameters check */
		ret = unf_check_plogi_params(lport, rport, login_parms);
		if (ret != RETURN_OK)
			return;

		/* Update R_Port state */
		spin_lock_irqsave(&rport->rport_state_lock, flag);
		rport->nport_id = rport_nport_id;
		/* --->>> PLOGI_WAIT */
		unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);
		spin_unlock_irqrestore(&rport->rport_state_lock, flag);

		/* Start to process PLOGI ACC */
		unf_rcv_plogi_acc(lport, rport, login_parms);
	} else {
		/* Case for PLOGI RJT: L_Port or R_Port recovery */
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]LOGIN: Port(0x%x)<---RPort(0x%p) with LS_RJT(DID:0x%x SID:0x%x) for PLOGI",
			  lport->port_id, rport, lport->nport_id,
			  rport->nport_id);

		if (rport->nport_id >= UNF_FC_FID_DOM_MGR)
			/* for Name server */
			unf_lport_error_recovery(lport);
		else
			unf_rport_error_recovery(rport);
	}

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]LOGIN: PLOGI response(0x%x). Port(0x%x_0x%x)<---RPort(0x%x_0x%p) wwpn(0x%llx) OX_ID(0x%x)",
		  cmnd, lport->port_id, lport->nport_id, rport->nport_id,
		  rport, port_name, xchg->ox_id);
}

static int unf_rcv_plogi_acc_async_callback(void *v_argc_in, void *v_argc_out)
{
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_argc_in;

	UNF_CHECK_VALID(0x2267, UNF_TRUE, xchg, return UNF_RETURN_ERROR);

	unf_plogi_acc_com_process(xchg);

	unf_xchg_ref_dec(xchg, SFS_RESPONSE);

	return RETURN_OK;
}

static void unf_plogi_callback(void *v_lport, void *v_rport, void *v_xchg)
{
	struct unf_lport_s *lport = (struct unf_lport_s *)v_lport;
	struct unf_xchg_s *xchg = (struct unf_xchg_s *)v_xchg;
	struct unf_plogi_payload_s *plogi_pld = NULL;
	struct unf_lgn_parms_s *login_parms = NULL;
	int bbscn_enabled = UNF_FALSE;
	int switch_2_thread = UNF_FALSE;

	UNF_CHECK_VALID(0x3662, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3663, UNF_TRUE, v_rport, return);
	UNF_CHECK_VALID(0x3664, UNF_TRUE, v_xchg, return);
	UNF_CHECK_VALID(0x3665, UNF_TRUE,
			xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr,
			return);

	plogi_pld = &xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr->plogi_acc.payload;
	login_parms = &plogi_pld->parms;
	xchg->lport = v_lport;

	if (xchg->byte_orders & UNF_BIT_2)
		unf_big_end_to_cpu((unsigned char *)plogi_pld,
				   sizeof(struct unf_plogi_payload_s));

	bbscn_enabled = unf_check_bbscn_is_enabled(
		(unsigned char)lport->low_level_func.lport_cfg_items.bb_scn,
		(unsigned char)UNF_GET_BB_SC_N_FROM_PARAMS(login_parms));
	if ((bbscn_enabled == UNF_TRUE) &&
	    (lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT)) {
		switch_2_thread = UNF_TRUE;
		lport->b_bbscn_support = UNF_TRUE;
	}

	if ((switch_2_thread == UNF_TRUE) && (lport->root_lport == lport)) {
		/* Wait for LR done sync: just for ROOT Port */
		(void)unf_irq_process_switch_2_thread(
					lport, xchg,
					unf_rcv_plogi_acc_async_callback);
	} else {
		unf_plogi_acc_com_process(xchg);
	}
}

static void unf_process_logo_in_pri_loop(struct unf_lport_s *v_lport,
					 struct unf_rport_s *v_rport)
{
	/* Send PLOGI or LOGO */
	struct unf_rport_s *rport = v_rport;
	unsigned long flag = 0;

	UNF_CHECK_VALID(0x3666, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3667, UNF_TRUE, v_rport, return);

	spin_lock_irqsave(&rport->rport_state_lock, flag);
	unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI); /* PLOGI WAIT */
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	/* Private Loop with INI mode, Avoid COM Mode problem */
	unf_rport_delay_login(rport);
}

static void unf_process_logo_in_n2n(struct unf_lport_s *v_lport,
				    struct unf_rport_s *v_rport)
{
	/* Send PLOGI or LOGO */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = v_rport;
	unsigned long flag = 0;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3668, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3669, UNF_TRUE, v_rport, return);

	spin_lock_irqsave(&rport->rport_state_lock, flag);

	unf_rport_state_ma(rport, UNF_EVENT_RPORT_ENTER_PLOGI);  // PLOGI WAIT
	spin_unlock_irqrestore(&rport->rport_state_lock, flag);

	if (lport->port_name > rport->port_name) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT,
			  UNF_MAJOR,
			  "[info]Port(0x%x)'s WWN(0x%llx) is larger than(0x%llx), should be master",
			  lport->port_id, lport->port_name,
			  rport->port_name);

		ret = unf_send_plogi(lport, rport);
		if (ret != RETURN_OK) {
			UNF_TRACE(UNF_EVTLOG_DRIVER_WARN,
				  UNF_LOG_LOGIN_ATT,
				  UNF_WARN,
				  "[warn]LOGIN: Port(0x%x) send PLOGI failed, enter recovery",
				  v_lport->port_id);

			unf_rport_error_recovery(rport);
		}
	} else {
		unf_rport_enter_logo(lport, rport);
	}
}

void unf_process_logo_in_fabric(struct unf_lport_s *v_lport,
				struct unf_rport_s *v_rport)
{
	/* Send GFF_ID or LOGO */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = v_rport;
	struct unf_rport_s *sns_port = NULL;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3670, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3671, UNF_TRUE, v_rport, return);

	/* L_Port with INI Mode: Send GFF_ID */
	sns_port = unf_get_rport_by_nport_id(lport, UNF_FC_FID_DIR_SERV);
	if (!sns_port) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT,
			  UNF_WARN,
			  "[warn]Port(0x%x) can't find fabric port",
			  lport->port_id);
		return;
	}

	ret = unf_get_and_post_disc_event(v_lport, sns_port, rport->nport_id,
					  UNF_DISC_GET_FEATURE);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) add discovery event(0x%x) failed Rport(0x%x)",
			  lport->port_id, UNF_DISC_GET_FEATURE,
			  rport->nport_id);

		unf_rcv_gff_id_rsp_unknown(lport, rport->nport_id);
	}
}

static void unf_process_rport_after_logo(struct unf_lport_s *v_lport,
					 struct unf_rport_s *v_rport)
{
	/*
	 * 1. LOGO handler
	 * 2. RPLO handler
	 * 3. LOGO_CALL_BACK (send LOGO ACC) handler
	 */
	struct unf_lport_s *lport = v_lport;
	struct unf_rport_s *rport = v_rport;

	UNF_CHECK_VALID(0x3672, UNF_TRUE, v_lport, return);
	UNF_CHECK_VALID(0x3673, UNF_TRUE, v_rport, return);

	if (rport->nport_id < UNF_FC_FID_DOM_MGR) {
		/* R_Port is not fabric port (retry LOGIN or LOGO) */
		if (lport->en_act_topo == UNF_ACT_TOP_PRIVATE_LOOP) {
			/* Private Loop: PLOGI or LOGO */
			unf_process_logo_in_pri_loop(lport, rport);
		} else if (lport->en_act_topo == UNF_ACT_TOP_P2P_DIRECT) {
			/* Point to Point: LOGIN or LOGO */
			unf_process_logo_in_n2n(lport, rport);
		} else {
			/* Fabric or Public Loop: GFF_ID or LOGO */
			unf_process_logo_in_fabric(lport, rport);
		}
	} else {
		/* Rport is fabric port: link down now */
		unf_rport_linkdown(lport, rport);
	}
}

static unsigned int unf_rcv_bls_req_done(struct unf_lport_s *v_lport,
					 struct unf_frame_pkg_s *v_pkg)
{
	/*
	 * About I/O resource:
	 * 1. normal: Release I/O resource during RRQ processer
	 * 2. exception: Release I/O resource immediately
	 */
	struct unf_xchg_s *xchg = NULL;
	unsigned short hot_pool_tag = 0;
	unsigned long flags = 0;
	unsigned long time_ms = 0;
	unsigned int ret = RETURN_OK;
	struct unf_lport_s *lport = NULL;

	UNF_CHECK_VALID(0x3723, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3724, UNF_TRUE, v_pkg, return UNF_RETURN_ERROR);
	lport = v_lport;

	/* 1. BLS Request Response: Hot Pool Tag --->>> OX_ID */
	hot_pool_tag =
		(unsigned short)v_pkg->private[PKG_PRIVATE_XCHG_HOT_POOL_INDEX];
	xchg = (struct unf_xchg_s *)unf_cm_lookup_xchg_by_tag(
						(void *)lport, hot_pool_tag);
	if (!xchg) {
		UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
			  "[warn]Port(0x%x) can't find exchange by tag(0x%x) when receiving ABTS response",
			  lport->port_id, hot_pool_tag);

		/* return directly */
		return UNF_RETURN_ERROR;
	}

	/* Consistency check */
	UNF_CHECK_ALLOCTIME_VALID(v_lport, hot_pool_tag, xchg,
				  v_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME],
				  xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME]);

	/* 2. Increase ref_cnt for exchange protecting */

	ret = unf_xchg_ref_inc(xchg, TGT_ABTS_DONE);  /* hold */
	UNF_CHECK_VALID(0x3725, UNF_TRUE, (ret == RETURN_OK),
			return UNF_RETURN_ERROR);

	/* 3. Exchag I/O State Set & Check: reused */
	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	xchg->io_state |= INI_IO_STATE_DONE;  /* I/O Done */
	xchg->abts_state |= ABTS_RESPONSE_RECEIVED;
	if (!(xchg->io_state & INI_IO_STATE_UPABORT)) {
		/* NOTE: I/O exchange has been released and used again */
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
			  "[warn]Port(0x%x_0x%x) SID(0x%x) exch(0x%p) (0x%x:0x%x:0x%x:0x%x) state(0x%x) is abnormal with cnt(0x%x)",
			  lport->port_id, lport->nport_id,
			  xchg->sid, xchg, xchg->hot_pool_tag,
			  xchg->ox_id, xchg->rx_id, xchg->oid,
			  xchg->io_state,
			  atomic_read(&xchg->ref_cnt));

		/* return directly */
		/* cancel ref & do nothing */
		unf_xchg_ref_dec(xchg, TGT_ABTS_DONE);
		return UNF_RETURN_ERROR;
	}
	spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

	/* 4. Exchange Timer check, cancel if necessary */
	lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer((void *)xchg);

	/*
	 * 5. Exchage I/O Status check: Succ-> Add RRQ Timer
	 * ***** pkg->status --- to --->>> scsi_cmnd->result *****
	 *
	 * FAILED: ERR_Code or X_ID is err, or BA_RSP type is err
	 */
	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	if (v_pkg->status == UNF_IO_SUCCESS) {
		/* Succeed: PKG status -->> EXCH status -->> scsi status */
		UNF_SET_SCSI_CMND_RESULT(xchg, UNF_IO_SUCCESS);
		xchg->io_state |= INI_IO_STATE_WAIT_RRQ;
		xchg->rx_id = UNF_GET_RXID(v_pkg);
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		/* Add RRQ timer */
		time_ms = (unsigned long)(lport->ra_tov);
		lport->xchg_mgr_temp.pfn_unf_xchg_add_timer(
							(void *)xchg,
							time_ms,
							UNF_TIMER_TYPE_INI_RRQ);
	} else {
		/* Failed: PKG status -->> EXCH status -->> scsi status */
		UNF_SET_SCSI_CMND_RESULT(xchg, UNF_IO_FAILED);
		if (MARKER_STS_RECEIVED & xchg->abts_state) {
			spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

			/* NOTE: release I/O resource immediately */
			unf_cm_free_xchg(lport, xchg);
		} else {
			UNF_TRACE(UNF_EVTLOG_IO_WARN, UNF_LOG_IO_ATT, UNF_WARN,
				  "[warn]Port(0x%x) exch(0x%p) OX_RX(0x%x:0x%x) IOstate(0x%x) ABTSstate(0x%x) receive response abnormal ref(0x%x)",
				  lport->port_id, xchg, xchg->ox_id,
				  xchg->rx_id,
				  xchg->io_state, xchg->abts_state,
				  atomic_read(&xchg->ref_cnt));
			spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
		}
	}

	/*
	 * 6. If abts response arrived before
	 * marker sts received just wake up abts marker sema
	 */
	spin_lock_irqsave(&xchg->xchg_state_lock, flags);
	if (!(xchg->abts_state & MARKER_STS_RECEIVED)) {
		xchg->ucode_abts_state = v_pkg->status;
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);

		/* NOTE: wake up semaphore */
		up(&xchg->task_sema);
	} else {
		spin_unlock_irqrestore(&xchg->xchg_state_lock, flags);
	}

	/* 7. dec exch ref_cnt */
	unf_xchg_ref_dec(xchg, TGT_ABTS_DONE);
	return ret;
}

static unsigned int unf_rcv_abort_ini_io_done(struct unf_lport_s *v_lport,
					      struct unf_frame_pkg_s *v_pkg)
{
	/* INI mode: do not care */
	struct unf_xchg_s *io_xchg = NULL;
	unsigned short io_pool_tag = 0;
	unsigned int ret = RETURN_OK;

	UNF_CHECK_VALID(0x3735, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3736, UNF_TRUE, v_pkg, return UNF_RETURN_ERROR);

	io_pool_tag = UNF_GET_IO_XCHG_TAG(v_pkg);
	io_xchg = (struct unf_xchg_s *)unf_cm_lookup_xchg_by_tag(
							(void *)v_lport,
							io_pool_tag);
	if (io_xchg) {
		UNF_CHECK_ALLOCTIME_VALID(
			v_lport, io_pool_tag, io_xchg,
			v_pkg->private[PKG_PRIVATE_XCHG_ALLOC_TIME],
			io_xchg->private[PKG_PRIVATE_XCHG_ALLOC_TIME]);

		/* 1. Timer release */
		v_lport->xchg_mgr_temp.pfn_unf_xchg_cancel_timer(
							(void *)io_xchg);

		UNF_TRACE(UNF_EVTLOG_IO_INFO, UNF_LOG_IO_ATT, UNF_MAJOR,
			  "[info]Port(0x%x) abort INI IO with status(0x%x) exchange(0x%p) tag(0x%x)",
			  v_lport->port_id, v_pkg->status,
			  io_xchg, io_pool_tag);

		/* 2. Free I/O Exchange context */
		unf_cm_free_xchg((void *)v_lport, (void *)io_xchg);
	}

	return ret;
}

unsigned int unf_receive_bls_pkg(void *v_lport, struct unf_frame_pkg_s *v_pkg)
{
	struct unf_lport_s *lport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;

	lport = (struct unf_lport_s *)v_lport;
	UNF_CHECK_VALID(0x3730, UNF_TRUE, lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3731, UNF_TRUE, v_pkg, return UNF_RETURN_ERROR);

	if (v_pkg->type == UNF_PKG_BLS_REQ_DONE) {
		/* INI: RCVD BLS Req Done */
		ret = unf_rcv_bls_req_done(v_lport, v_pkg);
	} else if (v_pkg->type == UNF_PKG_INI_IO) {
		/* INI: Abort Done (do not care) */
		ret = unf_rcv_abort_ini_io_done(v_lport, v_pkg);
	} else {
		UNF_TRACE(UNF_EVTLOG_DRIVER_ERR, UNF_LOG_LOGIN_ATT, UNF_ERR,
			  "[err]Port(0x%x) received BLS packet type(%xh) is error",
			  lport->port_id, v_pkg->type);

		return UNF_RETURN_ERROR;
	}

	UNF_REFERNCE_VAR(lport);

	return ret;
}

static void unf_fill_rls_acc_pld(struct unf_rls_acc_s *v_rls_acc,
				 struct unf_lport_s *v_lport)
{
	struct unf_rls_acc_payload_s *rls_acc_pld = NULL;

	rls_acc_pld = &v_rls_acc->rls;
	rls_acc_pld->cmnd = UNF_ELS_CMND_ACC;

	rls_acc_pld->link_failure_count =
		v_lport->err_code_sum.link_fail_count;
	rls_acc_pld->loss_of_sync_count =
		v_lport->err_code_sum.loss_of_sync_count;
	rls_acc_pld->loss_of_signal_count =
		v_lport->err_code_sum.loss_of_signal_count;
	rls_acc_pld->primitive_seq_count = 0;
	rls_acc_pld->invalid_trans_word_count = 0;
	rls_acc_pld->invalid_crc_count =
		v_lport->err_code_sum.bad_crc_count;
}

static unsigned int unf_send_rls_acc(struct unf_lport_s *v_lport,
				     unsigned int v_did,
				     struct unf_xchg_s *v_xchg)
{
	struct unf_rls_acc_s *rls_acc = NULL;
	union unf_sfs_u *fc_entry = NULL;
	unsigned int ret = UNF_RETURN_ERROR;
	unsigned short ox_id = 0;
	unsigned short rx_id = 0;
	struct unf_frame_pkg_s pkg;

	memset(&pkg, 0, sizeof(struct unf_frame_pkg_s));
	v_xchg->cmnd_code = UNF_SET_ELS_ACC_TYPE(ELS_RLS);
	v_xchg->did = v_did;
	v_xchg->sid = v_lport->nport_id;
	v_xchg->oid = v_xchg->sid;
	v_xchg->lport = v_lport;

	v_xchg->pfn_callback = NULL;
	v_xchg->pfn_ob_callback = NULL;

	unf_fill_package(&pkg, v_xchg, v_xchg->rport);

	fc_entry = v_xchg->fcp_sfs_union.sfs_entry.fc_sfs_entry_ptr;
	if (!fc_entry) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) entry can't be NULL with tag(0x%x)",
			  v_lport->port_id, v_xchg->hot_pool_tag);
		return UNF_RETURN_ERROR;
	}

	rls_acc = &fc_entry->rls_acc;
	unf_fill_rls_acc_pld(rls_acc, v_lport);
	ox_id = v_xchg->ox_id;
	rx_id = v_xchg->rx_id;

	ret = unf_els_cmnd_send(v_lport, &pkg, v_xchg);

	UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_MAJOR,
		  "[info]Port(0x%x) send Rls acc  %s to RPort(0x%x) with OX_ID(0x%x) RX_ID(0x%x).",
		  v_lport->port_id, (ret != RETURN_OK) ? "failed" : "succeed",
		  v_did, ox_id, rx_id);

	UNF_REFERNCE_VAR(ox_id);
	UNF_REFERNCE_VAR(rx_id);
	return ret;
}

static unsigned int unf_rls_handler(struct unf_lport_s *v_lport,
				    unsigned int v_sid,
				    struct unf_xchg_s *v_xchg)
{
	struct unf_rport_s *rport = NULL;
	unsigned int ret = UNF_RETURN_ERROR;

	UNF_CHECK_VALID(0x3483, UNF_TRUE, v_lport, return UNF_RETURN_ERROR);
	UNF_CHECK_VALID(0x3484, UNF_TRUE, v_xchg, return UNF_RETURN_ERROR);

	UNF_SERVICE_COLLECT(v_lport->link_service_info, UNF_SERVICE_ITEM_RLS);

	rport = unf_get_rport_by_nport_id(v_lport, v_sid);
	if (!rport) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_INFO, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn] Port(0x%x_0x%x) can`t find RPort by sid(0x%x) OX_ID(0x%x)",
			  v_lport->port_id, v_lport->nport_id, v_sid,
			  v_xchg->ox_id);
		unf_cm_free_xchg(v_lport, v_xchg);
		return ret;
	}
	v_xchg->rport = rport;

	ret = unf_send_rls_acc(v_lport, v_sid, v_xchg);
	if (ret != RETURN_OK) {
		UNF_TRACE(UNF_EVTLOG_DRIVER_WARN, UNF_LOG_LOGIN_ATT, UNF_WARN,
			  "[warn]Port(0x%x) send RLS ACC failed",
			  v_lport->port_id);
		unf_cm_free_xchg(v_lport, v_xchg);
	}

	return ret;
}