/*

   * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.

   * All rights reserved
   * www.brocade.com
   *
   * Linux driver for Brocade Fibre Channel Host Bus Adapter.
   *
   * This program is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License (GPL) Version 2 as
   * published by the Free Software Foundation
   *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * General Public License for more details.
   */

  /*

   *  rport.c Remote port implementation.
   */

  #include "bfad_drv.h"

  #include "bfad_im.h"

  #include "bfa_fcs.h"
  #include "bfa_fcbuild.h"

  
  BFA_TRC_FILE(FCS, RPORT);

  static u32
  bfa_fcs_rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT * 1000;
  	 /* In millisecs */

  /*
   * forward declarations
   */

  static struct bfa_fcs_rport_s *bfa_fcs_rport_alloc(
  		struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid);
  static void	bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport);
  static void	bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport);
  static void	bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport);
  static void	bfa_fcs_rport_offline_action(struct bfa_fcs_rport_s *rport);
  static void	bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport,
  					struct fc_logi_s *plogi);
  static void	bfa_fcs_rport_timeout(void *arg);
  static void	bfa_fcs_rport_send_plogi(void *rport_cbarg,

  					 struct bfa_fcxp_s *fcxp_alloced);

  static void	bfa_fcs_rport_send_plogiacc(void *rport_cbarg,
  					struct bfa_fcxp_s *fcxp_alloced);
  static void	bfa_fcs_rport_plogi_response(void *fcsarg,
  				struct bfa_fcxp_s *fcxp, void *cbarg,
  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs);
  static void	bfa_fcs_rport_send_adisc(void *rport_cbarg,

  					 struct bfa_fcxp_s *fcxp_alloced);

  static void	bfa_fcs_rport_adisc_response(void *fcsarg,
  				struct bfa_fcxp_s *fcxp, void *cbarg,
  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs);
  static void	bfa_fcs_rport_send_nsdisc(void *rport_cbarg,

  					 struct bfa_fcxp_s *fcxp_alloced);

  static void	bfa_fcs_rport_gidpn_response(void *fcsarg,
  				struct bfa_fcxp_s *fcxp, void *cbarg,
  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs);
  static void	bfa_fcs_rport_gpnid_response(void *fcsarg,
  				struct bfa_fcxp_s *fcxp, void *cbarg,
  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs);
  static void	bfa_fcs_rport_send_logo(void *rport_cbarg,

  					struct bfa_fcxp_s *fcxp_alloced);

  static void	bfa_fcs_rport_send_logo_acc(void *rport_cbarg);
  static void	bfa_fcs_rport_process_prli(struct bfa_fcs_rport_s *rport,
  					struct fchs_s *rx_fchs, u16 len);
  static void	bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport,
  				struct fchs_s *rx_fchs, u8 reason_code,
  					  u8 reason_code_expl);
  static void	bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
  				struct fchs_s *rx_fchs, u16 len);
  static void bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport);

  static void	bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport,

  					enum rport_event event);

  static void	bfa_fcs_rport_sm_plogi_sending(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,

  						  enum rport_event event);

  static void	bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport,

  					enum rport_event event);

  static void	bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport,
  					enum rport_event event);
  static void	bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,

  						 enum rport_event event);

  static void	bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport,

  					 enum rport_event event);

  static void	bfa_fcs_rport_sm_adisc_sending(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_adisc(struct bfa_fcs_rport_s *rport,
  					enum rport_event event);
  static void	bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_hcb_logorcv(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_hcb_logosend(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_logo_sending(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport,

  					 enum rport_event event);

  static void	bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
  						enum rport_event event);
  static void	bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,

  						enum rport_event event);

  
  static struct bfa_sm_table_s rport_sm_table[] = {
  	{BFA_SM(bfa_fcs_rport_sm_uninit), BFA_RPORT_UNINIT},
  	{BFA_SM(bfa_fcs_rport_sm_plogi_sending), BFA_RPORT_PLOGI},
  	{BFA_SM(bfa_fcs_rport_sm_plogiacc_sending), BFA_RPORT_ONLINE},
  	{BFA_SM(bfa_fcs_rport_sm_plogi_retry), BFA_RPORT_PLOGI_RETRY},
  	{BFA_SM(bfa_fcs_rport_sm_plogi), BFA_RPORT_PLOGI},
  	{BFA_SM(bfa_fcs_rport_sm_hal_online), BFA_RPORT_ONLINE},
  	{BFA_SM(bfa_fcs_rport_sm_online), BFA_RPORT_ONLINE},
  	{BFA_SM(bfa_fcs_rport_sm_nsquery_sending), BFA_RPORT_NSQUERY},
  	{BFA_SM(bfa_fcs_rport_sm_nsquery), BFA_RPORT_NSQUERY},
  	{BFA_SM(bfa_fcs_rport_sm_adisc_sending), BFA_RPORT_ADISC},
  	{BFA_SM(bfa_fcs_rport_sm_adisc), BFA_RPORT_ADISC},
  	{BFA_SM(bfa_fcs_rport_sm_fc4_logorcv), BFA_RPORT_LOGORCV},
  	{BFA_SM(bfa_fcs_rport_sm_fc4_logosend), BFA_RPORT_LOGO},
  	{BFA_SM(bfa_fcs_rport_sm_fc4_offline), BFA_RPORT_OFFLINE},
  	{BFA_SM(bfa_fcs_rport_sm_hcb_offline), BFA_RPORT_OFFLINE},
  	{BFA_SM(bfa_fcs_rport_sm_hcb_logorcv), BFA_RPORT_LOGORCV},
  	{BFA_SM(bfa_fcs_rport_sm_hcb_logosend), BFA_RPORT_LOGO},
  	{BFA_SM(bfa_fcs_rport_sm_logo_sending), BFA_RPORT_LOGO},
  	{BFA_SM(bfa_fcs_rport_sm_offline), BFA_RPORT_OFFLINE},
  	{BFA_SM(bfa_fcs_rport_sm_nsdisc_sending), BFA_RPORT_NSDISC},
  	{BFA_SM(bfa_fcs_rport_sm_nsdisc_retry), BFA_RPORT_NSDISC},
  	{BFA_SM(bfa_fcs_rport_sm_nsdisc_sent), BFA_RPORT_NSDISC},
  };

  /*

   *		Beginning state.

   */
  static void
  bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport, enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_PLOGI_SEND:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
  		rport->plogi_retries = 0;
  		bfa_fcs_rport_send_plogi(rport, NULL);
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	case RPSM_EVENT_ADDRESS_CHANGE:
  	case RPSM_EVENT_ADDRESS_DISC:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
  		rport->ns_retries = 0;

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;

  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		PLOGI is being sent.

   */
  static void
  bfa_fcs_rport_sm_plogi_sending(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FCXP_SENT:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi);
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_ADDRESS_CHANGE:

  	case RPSM_EVENT_SCN:
  		/* query the NS */

  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
  		rport->ns_retries = 0;

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		rport->pid = 0;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;

  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		PLOGI is being sent.

   */
  static void
  bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FCXP_SENT:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_free(rport);
  		break;

  	case RPSM_EVENT_PLOGI_RCVD:

  	case RPSM_EVENT_PLOGI_COMP:

  	case RPSM_EVENT_SCN:

  		/*

  		 * Ignore, SCN is possibly online notification.
  		 */
  		break;
  
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
  		rport->ns_retries = 0;

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		rport->pid = 0;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;
  
  	case RPSM_EVENT_HCB_OFFLINE:

  		/*

  		 * Ignore BFA callback, on a PLOGI receive we call bfa offline.
  		 */
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		PLOGI is sent.

   */
  static void
  bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
  			enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {

  	case RPSM_EVENT_TIMEOUT:

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
  		bfa_fcs_rport_send_plogi(rport, NULL);

  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_free(rport);
  		break;

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_LOGO_RCVD:
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_ADDRESS_CHANGE:

  	case RPSM_EVENT_SCN:

  		bfa_timer_stop(&rport->timer);
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
  		rport->ns_retries = 0;

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		rport->pid = 0;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_timer_stop(&rport->timer);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		PLOGI is sent.

   */
  static void
  bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_ACCEPTED:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		rport->plogi_retries = 0;
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:
  		bfa_fcs_rport_send_logo_acc(rport);

  		/*
  		 * !! fall through !!
  		 */
  	case RPSM_EVENT_PRLO_RCVD:
  		if (rport->prlo == BFA_TRUE)
  			bfa_fcs_rport_send_prlo_acc(rport);

  		bfa_fcxp_discard(rport->fcxp);
  		/*
  		 * !! fall through !!
  		 */
  	case RPSM_EVENT_FAILED:

  		if (rport->plogi_retries < BFA_FCS_RPORT_MAX_RETRIES) {
  			rport->plogi_retries++;
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_retry);
  			bfa_timer_start(rport->fcs->bfa, &rport->timer,
  					bfa_fcs_rport_timeout, rport,
  					BFA_FCS_RETRY_TIMEOUT);
  		} else {
  			bfa_stats(rport->port, rport_del_max_plogi_retry);
  			rport->pid = 0;
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  			bfa_timer_start(rport->fcs->bfa, &rport->timer,
  					bfa_fcs_rport_timeout, rport,
  					bfa_fcs_rport_del_timeout);
  		}
  		break;
  
  	case	RPSM_EVENT_PLOGI_RETRY:
  		rport->plogi_retries = 0;

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_retry);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,

  				(FC_RA_TOV * 1000));

  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		rport->pid = 0;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;
  
  	case RPSM_EVENT_ADDRESS_CHANGE:

  	case RPSM_EVENT_SCN:

  		bfa_fcxp_discard(rport->fcxp);
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
  		rport->ns_retries = 0;

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;

  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		PLOGI is complete. Awaiting BFA rport online callback. FC-4s
   *		are offline.

   */
  static void
  bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
  			enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_HCB_ONLINE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
  		bfa_fcs_rport_online_action(rport);
  		break;

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_PLOGI_COMP:

  		break;

  	case RPSM_EVENT_LOGO_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv);

  		bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);

  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);

  		bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);

  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:

  		rport->plogi_pending = BFA_TRUE;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);

  		bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);

  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);

  		bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);

  		break;
  
  	case RPSM_EVENT_SCN:

  		/*

  		 * @todo
  		 * Ignore SCN - PLOGI just completed, FC-4 login should detect
  		 * device failures.
  		 */
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport is ONLINE. FC-4s active.

   */
  static void
  bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport, enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_SCN:

  		if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
  			bfa_sm_set_state(rport,
  					 bfa_fcs_rport_sm_nsquery_sending);
  			rport->ns_retries = 0;

  			bfa_fcs_rport_send_nsdisc(rport, NULL);

  		} else {
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_sending);
  			bfa_fcs_rport_send_adisc(rport, NULL);
  		}
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  	case RPSM_EVENT_LOGO_IMP:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		An SCN event is received in ONLINE state. NS query is being sent
   *		prior to ADISC authentication with rport. FC-4s are paused.

   */
  static void
  bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FCXP_SENT:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsquery);
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_SCN:

  		/*

  		 * ignore SCN, wait for response to query itself
  		 */
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		rport->pid = 0;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *	An SCN event is received in ONLINE state. NS query is sent to rport.
   *	FC-4s are paused.

   */
  static void
  bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_ACCEPTED:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc_sending);
  		bfa_fcs_rport_send_adisc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_FAILED:
  		rport->ns_retries++;
  		if (rport->ns_retries < BFA_FCS_RPORT_MAX_RETRIES) {
  			bfa_sm_set_state(rport,
  					 bfa_fcs_rport_sm_nsquery_sending);

  			bfa_fcs_rport_send_nsdisc(rport, NULL);

  		} else {
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  			bfa_fcs_rport_offline_action(rport);
  		}
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_SCN:
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  	case RPSM_EVENT_PLOGI_RCVD:
  	case RPSM_EVENT_LOGO_IMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *	An SCN event is received in ONLINE state. ADISC is being sent for
   *	authenticating with rport. FC-4s are paused.

   */
  static void
  bfa_fcs_rport_sm_adisc_sending(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FCXP_SENT:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_adisc);
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_SCN:
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		An SCN event is received in ONLINE state. ADISC is to rport.
   *		FC-4s are paused.

   */
  static void
  bfa_fcs_rport_sm_adisc(struct bfa_fcs_rport_s *rport, enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_ACCEPTED:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);

  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:

  		/*

  		 * Too complex to cleanup FC-4 & rport and then acc to PLOGI.
  		 * At least go offline when a PLOGI is received.
  		 */
  		bfa_fcxp_discard(rport->fcxp);
  		/*
  		 * !!! fall through !!!
  		 */
  
  	case RPSM_EVENT_FAILED:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_SCN:

  		/*

  		 * already processing RSCN
  		 */
  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_offline_action(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport has sent LOGO. Awaiting FC-4 offline completion callback.

   */
  static void
  bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
  			enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FC4_OFFLINE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logorcv);

  		bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);

  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_ADDRESS_CHANGE:
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		LOGO needs to be sent to rport. Awaiting FC-4 offline completion
   *		callback.

   */
  static void
  bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FC4_OFFLINE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);

  		bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);

  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *	Rport is going offline. Awaiting FC-4 offline completion callback.

   */
  static void
  bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
  			enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FC4_OFFLINE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);

  		bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);

  		break;
  
  	case RPSM_EVENT_SCN:
  	case RPSM_EVENT_LOGO_IMP:
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_ADDRESS_CHANGE:

  		/*

  		 * rport is already going offline.
  		 * SCN - ignore and wait till transitioning to offline state
  		 */
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport is offline. FC-4s are offline. Awaiting BFA rport offline
   *		callback.

   */
  static void
  bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,

  				enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_HCB_OFFLINE:

  		if (bfa_fcs_lport_is_online(rport->port) &&
  		    (rport->plogi_pending)) {
  			rport->plogi_pending = BFA_FALSE;
  			bfa_sm_set_state(rport,
  				bfa_fcs_rport_sm_plogiacc_sending);
  			bfa_fcs_rport_send_plogiacc(rport, NULL);
  			break;
  		}
  		/*
  		 * !! fall through !!
  		 */

  	case RPSM_EVENT_ADDRESS_CHANGE:

  		if (bfa_fcs_lport_is_online(rport->port)) {

  			if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
  				bfa_sm_set_state(rport,
  					bfa_fcs_rport_sm_nsdisc_sending);
  				rport->ns_retries = 0;

  				bfa_fcs_rport_send_nsdisc(rport, NULL);

  			} else {
  				bfa_sm_set_state(rport,
  					bfa_fcs_rport_sm_plogi_sending);
  				rport->plogi_retries = 0;
  				bfa_fcs_rport_send_plogi(rport, NULL);
  			}

  		} else {
  			rport->pid = 0;
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  			bfa_timer_start(rport->fcs->bfa, &rport->timer,
  					bfa_fcs_rport_timeout, rport,
  					bfa_fcs_rport_del_timeout);
  		}
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_SCN:
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_PLOGI_RCVD:
  	case RPSM_EVENT_LOGO_IMP:

  		/*

  		 * Ignore, already offline.
  		 */
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport is offline. FC-4s are offline. Awaiting BFA rport offline
   *		callback to send LOGO accept.

   */
  static void
  bfa_fcs_rport_sm_hcb_logorcv(struct bfa_fcs_rport_s *rport,
  			enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_HCB_OFFLINE:
  	case RPSM_EVENT_ADDRESS_CHANGE:

  		if (rport->pid && (rport->prlo == BFA_TRUE))
  			bfa_fcs_rport_send_prlo_acc(rport);
  		if (rport->pid && (rport->prlo == BFA_FALSE))

  			bfa_fcs_rport_send_logo_acc(rport);
  		/*

  		 * If the lport is online and if the rport is not a well
  		 * known address port,
  		 * we try to re-discover the r-port.

  		 */

  		if (bfa_fcs_lport_is_online(rport->port) &&
  			(!BFA_FCS_PID_IS_WKA(rport->pid))) {

  			if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
  				bfa_sm_set_state(rport,
  					bfa_fcs_rport_sm_nsdisc_sending);
  				rport->ns_retries = 0;
  				bfa_fcs_rport_send_nsdisc(rport, NULL);
  			} else {
  				/* For N2N  Direct Attach, try to re-login */
  				bfa_sm_set_state(rport,
  					bfa_fcs_rport_sm_plogi_sending);
  				rport->plogi_retries = 0;
  				bfa_fcs_rport_send_plogi(rport, NULL);
  			}

  		} else {
  			/*

  			 * if it is not a well known address, reset the
  			 * pid to 0.

  			 */
  			if (!BFA_FCS_PID_IS_WKA(rport->pid))
  				rport->pid = 0;
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  			bfa_timer_start(rport->fcs->bfa, &rport->timer,
  					bfa_fcs_rport_timeout, rport,
  					bfa_fcs_rport_del_timeout);
  		}
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_offline);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  		/*

  		 * Ignore - already processing a LOGO.
  		 */
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport is being deleted. FC-4s are offline.
   *  Awaiting BFA rport offline
   *		callback to send LOGO.

   */
  static void
  bfa_fcs_rport_sm_hcb_logosend(struct bfa_fcs_rport_s *rport,

  		 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_HCB_OFFLINE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_logo_sending);
  		bfa_fcs_rport_send_logo(rport, NULL);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_ADDRESS_CHANGE:
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport is being deleted. FC-4s are offline. LOGO is being sent.

   */
  static void
  bfa_fcs_rport_sm_logo_sending(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FCXP_SENT:

  		/* Once LOGO is sent, we donot wait for the response */

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_SCN:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport is offline. FC-4s are offline. BFA rport is offline.
   *		Timer active to delete stale rport.

   */
  static void
  bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport, enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_TIMEOUT:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_SCN:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
  		bfa_timer_stop(&rport->timer);
  		rport->ns_retries = 0;

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_LOGO_IMP:
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_SEND:
  		bfa_timer_stop(&rport->timer);
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
  		rport->plogi_retries = 0;
  		bfa_fcs_rport_send_plogi(rport, NULL);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *	Rport address has changed. Nameserver discovery request is being sent.

   */
  static void
  bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_FCXP_SENT:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sent);
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_SCN:
  	case RPSM_EVENT_LOGO_RCVD:

  	case RPSM_EVENT_PRLO_RCVD:

  	case RPSM_EVENT_PLOGI_SEND:
  		break;
  
  	case RPSM_EVENT_ADDRESS_CHANGE:

  		rport->ns_retries = 0; /* reset the retry count */

  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Nameserver discovery failed. Waiting for timeout to retry.

   */
  static void
  bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,

  	 enum rport_event event)

  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_TIMEOUT:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;
  
  	case RPSM_EVENT_SCN:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_nsdisc_sending);
  		bfa_timer_stop(&rport->timer);
  		rport->ns_retries = 0;

  		bfa_fcs_rport_send_nsdisc(rport, NULL);

  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		rport->pid = 0;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_timer_stop(&rport->timer);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:
  		bfa_fcs_rport_send_logo_acc(rport);
  		break;

  	case RPSM_EVENT_PRLO_RCVD:
  		bfa_fcs_rport_send_prlo_acc(rport);
  		break;

  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_timer_stop(&rport->timer);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *		Rport address has changed. Nameserver discovery request is sent.

   */
  static void
  bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
  			enum rport_event event)
  {
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->pid);
  	bfa_trc(rport->fcs, event);
  
  	switch (event) {
  	case RPSM_EVENT_ACCEPTED:
  	case RPSM_EVENT_ADDRESS_CHANGE:
  		if (rport->pid) {
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogi_sending);
  			bfa_fcs_rport_send_plogi(rport, NULL);
  		} else {
  			bfa_sm_set_state(rport,

  				 bfa_fcs_rport_sm_nsdisc_sending);

  			rport->ns_retries = 0;

  			bfa_fcs_rport_send_nsdisc(rport, NULL);

  		}
  		break;
  
  	case RPSM_EVENT_FAILED:
  		rport->ns_retries++;
  		if (rport->ns_retries < BFA_FCS_RPORT_MAX_RETRIES) {
  			bfa_sm_set_state(rport,

  				 bfa_fcs_rport_sm_nsdisc_sending);
  			bfa_fcs_rport_send_nsdisc(rport, NULL);

  		} else {
  			rport->pid = 0;
  			bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  			bfa_timer_start(rport->fcs->bfa, &rport->timer,
  					bfa_fcs_rport_timeout, rport,
  					bfa_fcs_rport_del_timeout);
  		};
  		break;
  
  	case RPSM_EVENT_DELETE:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_free(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_RCVD:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_send_plogiacc(rport, NULL);
  		break;
  
  	case RPSM_EVENT_LOGO_IMP:
  		rport->pid = 0;
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_timer_start(rport->fcs->bfa, &rport->timer,
  				bfa_fcs_rport_timeout, rport,
  				bfa_fcs_rport_del_timeout);
  		break;

  	case RPSM_EVENT_PRLO_RCVD:
  		bfa_fcs_rport_send_prlo_acc(rport);
  		break;

  	case RPSM_EVENT_SCN:

  		/*

  		 * ignore, wait for NS query response
  		 */
  		break;
  
  	case RPSM_EVENT_LOGO_RCVD:

  		/*

  		 * Not logged-in yet. Accept LOGO.
  		 */
  		bfa_fcs_rport_send_logo_acc(rport);
  		break;
  
  	case RPSM_EVENT_PLOGI_COMP:
  		bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
  		bfa_fcxp_discard(rport->fcxp);
  		bfa_fcs_rport_hal_online(rport);
  		break;
  
  	default:

  		bfa_sm_fault(rport->fcs, event);

  	}
  }

  /*

   *  fcs_rport_private FCS RPORT provate functions
   */
  
  static void
  bfa_fcs_rport_send_plogi(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  {
  	struct bfa_fcs_rport_s *rport = rport_cbarg;

  	struct bfa_fcs_lport_s *port = rport->port;
  	struct fchs_s	fchs;
  	int		len;

  	struct bfa_fcxp_s *fcxp;
  
  	bfa_trc(rport->fcs, rport->pwwn);
  
  	fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp) {

  		bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
  					bfa_fcs_rport_send_plogi, rport);

  		return;
  	}
  	rport->fcxp = fcxp;
  
  	len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,

  				bfa_fcs_lport_get_fcid(port), 0,
  				port->port_cfg.pwwn, port->port_cfg.nwwn,

  				bfa_fcport_get_maxfrsize(port->fcs->bfa),
  				bfa_fcport_get_rx_bbcredit(port->fcs->bfa));

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, bfa_fcs_rport_plogi_response,
  			(void *)rport, FC_MAX_PDUSZ, FC_ELS_TOV);

  
  	rport->stats.plogis++;
  	bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
  }
  
  static void
  bfa_fcs_rport_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,

  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs)

  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;

  	struct fc_logi_s	*plogi_rsp;
  	struct fc_ls_rjt_s	*ls_rjt;
  	struct bfa_fcs_rport_s *twin;

  	struct list_head	*qe;

  
  	bfa_trc(rport->fcs, rport->pwwn);
  
  	/*
  	 * Sanity Checks
  	 */
  	if (req_status != BFA_STATUS_OK) {
  		bfa_trc(rport->fcs, req_status);
  		rport->stats.plogi_failed++;
  		bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  		return;
  	}
  
  	plogi_rsp = (struct fc_logi_s *) BFA_FCXP_RSP_PLD(fcxp);

  	/*

  	 * Check for failure first.
  	 */
  	if (plogi_rsp->els_cmd.els_code != FC_ELS_ACC) {
  		ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
  
  		bfa_trc(rport->fcs, ls_rjt->reason_code);
  		bfa_trc(rport->fcs, ls_rjt->reason_code_expl);

  		if ((ls_rjt->reason_code == FC_LS_RJT_RSN_UNABLE_TO_PERF_CMD) &&
  		 (ls_rjt->reason_code_expl == FC_LS_RJT_EXP_INSUFF_RES)) {
  			rport->stats.rjt_insuff_res++;
  			bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_RETRY);
  			return;
  		}

  		rport->stats.plogi_rejects++;
  		bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  		return;
  	}

  	/*

  	 * PLOGI is complete. Make sure this device is not one of the known
  	 * device with a new FC port address.
  	 */
  	list_for_each(qe, &rport->port->rport_q) {

  		twin = (struct bfa_fcs_rport_s *) qe;

  		if (twin == rport)
  			continue;
  		if (!rport->pwwn && (plogi_rsp->port_name == twin->pwwn)) {
  			bfa_trc(rport->fcs, twin->pid);
  			bfa_trc(rport->fcs, rport->pid);

  			/* Update plogi stats in twin */
  			twin->stats.plogis  += rport->stats.plogis;
  			twin->stats.plogi_rejects  +=
  				 rport->stats.plogi_rejects;
  			twin->stats.plogi_timeouts  +=
  				 rport->stats.plogi_timeouts;
  			twin->stats.plogi_failed +=
  				 rport->stats.plogi_failed;
  			twin->stats.plogi_rcvd	  += rport->stats.plogi_rcvd;

  			twin->stats.plogi_accs++;

  			bfa_sm_send_event(rport, RPSM_EVENT_DELETE);

  
  			bfa_fcs_rport_update(twin, plogi_rsp);
  			twin->pid = rsp_fchs->s_id;
  			bfa_sm_send_event(twin, RPSM_EVENT_PLOGI_COMP);
  			return;
  		}
  	}

  	/*

  	 * Normal login path -- no evil twins.
  	 */
  	rport->stats.plogi_accs++;
  	bfa_fcs_rport_update(rport, plogi_rsp);
  	bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
  }
  
  static void
  bfa_fcs_rport_send_plogiacc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  {
  	struct bfa_fcs_rport_s *rport = rport_cbarg;

  	struct bfa_fcs_lport_s *port = rport->port;
  	struct fchs_s		fchs;
  	int		len;

  	struct bfa_fcxp_s *fcxp;
  
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_trc(rport->fcs, rport->reply_oxid);
  
  	fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp) {

  		bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
  					bfa_fcs_rport_send_plogiacc, rport);

  		return;
  	}
  	rport->fcxp = fcxp;

  	len = fc_plogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  				 rport->pid, bfa_fcs_lport_get_fcid(port),
  				 rport->reply_oxid, port->port_cfg.pwwn,
  				 port->port_cfg.nwwn,

  				 bfa_fcport_get_maxfrsize(port->fcs->bfa),
  				 bfa_fcport_get_rx_bbcredit(port->fcs->bfa));

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);

  
  	bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
  }
  
  static void
  bfa_fcs_rport_send_adisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  {
  	struct bfa_fcs_rport_s *rport = rport_cbarg;

  	struct bfa_fcs_lport_s *port = rport->port;
  	struct fchs_s		fchs;
  	int		len;

  	struct bfa_fcxp_s *fcxp;
  
  	bfa_trc(rport->fcs, rport->pwwn);
  
  	fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp) {

  		bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
  					bfa_fcs_rport_send_adisc, rport);

  		return;
  	}
  	rport->fcxp = fcxp;
  
  	len = fc_adisc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,

  				bfa_fcs_lport_get_fcid(port), 0,
  				port->port_cfg.pwwn, port->port_cfg.nwwn);

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, bfa_fcs_rport_adisc_response,
  			rport, FC_MAX_PDUSZ, FC_ELS_TOV);

  
  	rport->stats.adisc_sent++;
  	bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
  }
  
  static void
  bfa_fcs_rport_adisc_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,

  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs)

  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
  	void		*pld = bfa_fcxp_get_rspbuf(fcxp);
  	struct fc_ls_rjt_s	*ls_rjt;

  
  	if (req_status != BFA_STATUS_OK) {
  		bfa_trc(rport->fcs, req_status);
  		rport->stats.adisc_failed++;
  		bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  		return;
  	}
  
  	if (fc_adisc_rsp_parse((struct fc_adisc_s *)pld, rsp_len, rport->pwwn,

  				rport->nwwn)  == FC_PARSE_OK) {

  		rport->stats.adisc_accs++;
  		bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
  		return;
  	}
  
  	rport->stats.adisc_rejects++;
  	ls_rjt = pld;
  	bfa_trc(rport->fcs, ls_rjt->els_cmd.els_code);
  	bfa_trc(rport->fcs, ls_rjt->reason_code);
  	bfa_trc(rport->fcs, ls_rjt->reason_code_expl);
  	bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  }
  
  static void

  bfa_fcs_rport_send_nsdisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)

  {
  	struct bfa_fcs_rport_s *rport = rport_cbarg;

  	struct bfa_fcs_lport_s *port = rport->port;
  	struct fchs_s	fchs;

  	struct bfa_fcxp_s *fcxp;

  	int		len;
  	bfa_cb_fcxp_send_t cbfn;

  
  	bfa_trc(rport->fcs, rport->pid);
  
  	fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp) {

  		bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
  					bfa_fcs_rport_send_nsdisc, rport);

  		return;
  	}
  	rport->fcxp = fcxp;

  	if (rport->pwwn) {
  		len = fc_gidpn_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  				bfa_fcs_lport_get_fcid(port), 0, rport->pwwn);
  		cbfn = bfa_fcs_rport_gidpn_response;
  	} else {
  		len = fc_gpnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  				bfa_fcs_lport_get_fcid(port), 0, rport->pid);
  		cbfn = bfa_fcs_rport_gpnid_response;
  	}

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, cbfn,
  			(void *)rport, FC_MAX_PDUSZ, FC_FCCT_TOV);

  
  	bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
  }
  
  static void
  bfa_fcs_rport_gidpn_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,

  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs)

  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
  	struct ct_hdr_s	*cthdr;

  	struct fcgs_gidpn_resp_s	*gidpn_rsp;

  	struct bfa_fcs_rport_s	*twin;
  	struct list_head	*qe;

  
  	bfa_trc(rport->fcs, rport->pwwn);
  
  	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);

  	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);

  
  	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {

  		/* Check if the pid is the same as before. */

  		gidpn_rsp = (struct fcgs_gidpn_resp_s *) (cthdr + 1);
  
  		if (gidpn_rsp->dap == rport->pid) {

  			/* Device is online  */

  			bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
  		} else {
  			/*

  			 * Device's PID has changed. We need to cleanup
  			 * and re-login. If there is another device with
  			 * the the newly discovered pid, send an scn notice
  			 * so that its new pid can be discovered.

  			 */
  			list_for_each(qe, &rport->port->rport_q) {

  				twin = (struct bfa_fcs_rport_s *) qe;

  				if (twin == rport)
  					continue;
  				if (gidpn_rsp->dap == twin->pid) {
  					bfa_trc(rport->fcs, twin->pid);
  					bfa_trc(rport->fcs, rport->pid);
  
  					twin->pid = 0;
  					bfa_sm_send_event(twin,

  					 RPSM_EVENT_ADDRESS_CHANGE);

  				}
  			}
  			rport->pid = gidpn_rsp->dap;
  			bfa_sm_send_event(rport, RPSM_EVENT_ADDRESS_CHANGE);
  		}
  		return;
  	}
  
  	/*
  	 * Reject Response
  	 */
  	switch (cthdr->reason_code) {
  	case CT_RSN_LOGICAL_BUSY:
  		/*
  		 * Need to retry
  		 */
  		bfa_sm_send_event(rport, RPSM_EVENT_TIMEOUT);
  		break;
  
  	case CT_RSN_UNABLE_TO_PERF:
  		/*
  		 * device doesn't exist : Start timer to cleanup this later.
  		 */
  		bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  		break;
  
  	default:
  		bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  		break;
  	}
  }

  static void
  bfa_fcs_rport_gpnid_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
  				bfa_status_t req_status, u32 rsp_len,
  				u32 resid_len, struct fchs_s *rsp_fchs)
  {
  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
  	struct ct_hdr_s	*cthdr;
  
  	bfa_trc(rport->fcs, rport->pwwn);
  
  	cthdr = (struct ct_hdr_s *) BFA_FCXP_RSP_PLD(fcxp);

  	cthdr->cmd_rsp_code = be16_to_cpu(cthdr->cmd_rsp_code);

  
  	if (cthdr->cmd_rsp_code == CT_RSP_ACCEPT) {
  		bfa_sm_send_event(rport, RPSM_EVENT_ACCEPTED);
  		return;
  	}
  
  	/*
  	 * Reject Response
  	 */
  	switch (cthdr->reason_code) {
  	case CT_RSN_LOGICAL_BUSY:
  		/*
  		 * Need to retry
  		 */
  		bfa_sm_send_event(rport, RPSM_EVENT_TIMEOUT);
  		break;
  
  	case CT_RSN_UNABLE_TO_PERF:
  		/*
  		 * device doesn't exist : Start timer to cleanup this later.
  		 */
  		bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  		break;
  
  	default:
  		bfa_sm_send_event(rport, RPSM_EVENT_FAILED);
  		break;
  	}
  }

  /*

   *	Called to send a logout to the rport.

   */
  static void
  bfa_fcs_rport_send_logo(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
  {
  	struct bfa_fcs_rport_s *rport = rport_cbarg;

  	struct bfa_fcs_lport_s *port;
  	struct fchs_s	fchs;

  	struct bfa_fcxp_s *fcxp;

  	u16	len;

  
  	bfa_trc(rport->fcs, rport->pid);
  
  	port = rport->port;
  
  	fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp) {

  		bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
  					bfa_fcs_rport_send_logo, rport);

  		return;
  	}
  	rport->fcxp = fcxp;
  
  	len = fc_logo_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,

  				bfa_fcs_lport_get_fcid(port), 0,
  				bfa_fcs_lport_get_pwwn(port));

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, NULL,
  			rport, FC_MAX_PDUSZ, FC_ELS_TOV);

  
  	rport->stats.logos++;
  	bfa_fcxp_discard(rport->fcxp);
  	bfa_sm_send_event(rport, RPSM_EVENT_FCXP_SENT);
  }

  /*

   *	Send ACC for a LOGO received.

   */
  static void
  bfa_fcs_rport_send_logo_acc(void *rport_cbarg)
  {
  	struct bfa_fcs_rport_s *rport = rport_cbarg;

  	struct bfa_fcs_lport_s *port;
  	struct fchs_s	fchs;

  	struct bfa_fcxp_s *fcxp;

  	u16	len;

  
  	bfa_trc(rport->fcs, rport->pid);
  
  	port = rport->port;
  
  	fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp)
  		return;
  
  	rport->stats.logo_rcvd++;

  	len = fc_logo_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  				rport->pid, bfa_fcs_lport_get_fcid(port),
  				rport->reply_oxid);

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);

  }

  /*

   *	brief
   *	This routine will be called by bfa_timer on timer timeouts.

   *

   *	param[in]	rport			- pointer to bfa_fcs_lport_ns_t.
   *	param[out]	rport_status	- pointer to return vport status in

   *

   *	return
   *		void

   *

   *	Special Considerations:

   *

   *	note

   */
  static void
  bfa_fcs_rport_timeout(void *arg)
  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) arg;

  
  	rport->stats.plogi_timeouts++;

  	bfa_stats(rport->port, rport_plogi_timeouts);

  	bfa_sm_send_event(rport, RPSM_EVENT_TIMEOUT);
  }
  
  static void
  bfa_fcs_rport_process_prli(struct bfa_fcs_rport_s *rport,
  			struct fchs_s *rx_fchs, u16 len)
  {
  	struct bfa_fcxp_s *fcxp;

  	struct fchs_s	fchs;
  	struct bfa_fcs_lport_s *port = rport->port;
  	struct fc_prli_s	*prli;

  
  	bfa_trc(port->fcs, rx_fchs->s_id);
  	bfa_trc(port->fcs, rx_fchs->d_id);
  
  	rport->stats.prli_rcvd++;

  	/*

  	 * We are in Initiator Mode

  	 */
  	prli = (struct fc_prli_s *) (rx_fchs + 1);

  	if (prli->parampage.servparams.target) {

  		/*

  		 * PRLI from a target ?
  		 * Send the Acc.
  		 * PRLI sent by us will be used to transition the IT nexus,
  		 * once the response is received from the target.

  		 */
  		bfa_trc(port->fcs, rx_fchs->s_id);
  		rport->scsi_function = BFA_RPORT_TARGET;

  	} else {
  		bfa_trc(rport->fcs, prli->parampage.type);
  		rport->scsi_function = BFA_RPORT_INITIATOR;
  		bfa_fcs_itnim_is_initiator(rport->itnim);

  	}
  
  	fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp)
  		return;

  	len = fc_prli_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  				rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  				rx_fchs->ox_id, port->port_cfg.roles);

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);

  }
  
  static void
  bfa_fcs_rport_process_rpsc(struct bfa_fcs_rport_s *rport,
  			struct fchs_s *rx_fchs, u16 len)
  {
  	struct bfa_fcxp_s *fcxp;

  	struct fchs_s	fchs;
  	struct bfa_fcs_lport_s *port = rport->port;

  	struct fc_rpsc_speed_info_s speeds;

  	struct bfa_port_attr_s pport_attr;

  
  	bfa_trc(port->fcs, rx_fchs->s_id);
  	bfa_trc(port->fcs, rx_fchs->d_id);
  
  	rport->stats.rpsc_rcvd++;
  	speeds.port_speed_cap =
  		RPSC_SPEED_CAP_1G | RPSC_SPEED_CAP_2G | RPSC_SPEED_CAP_4G |
  		RPSC_SPEED_CAP_8G;
  
  	/*
  	 * get curent speed from pport attributes from BFA
  	 */

  	bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);

  
  	speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed);
  
  	fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  	if (!fcxp)
  		return;

  	len = fc_rpsc_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
  				rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  				rx_fchs->ox_id, &speeds);

  
  	bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,

  			FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);

  }
  
  static void
  bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
  			struct fchs_s *rx_fchs, u16 len)
  {
  	struct bfa_fcxp_s *fcxp;

  	struct fchs_s	fchs;
  	struct bfa_fcs_lport_s *port = rport->port;
  	struct fc_adisc_s	*adisc;

  
  	bfa_trc(port->fcs, rx_fchs->s_id);
  	bfa_trc(port->fcs, rx_fchs->d_id);
  
  	rport->stats.adisc_rcvd++;

  	adisc = (struct fc_adisc_s *) (rx_fchs + 1);
  
  	/*

  	 * Accept if the itnim for this rport is online.
  	 * Else reject the ADISC.

  	 */
  	if (bfa_fcs_itnim_get_online_state(rport->itnim) == BFA_STATUS_OK) {
  
  		fcxp = bfa_fcs_fcxp_alloc(port->fcs);
  		if (!fcxp)
  			return;
  
  		len = fc_adisc_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),

  			 rx_fchs->s_id, bfa_fcs_lport_get_fcid(port),
  			 rx_fchs->ox_id, port->port_cfg.pwwn,
  			 port->port_cfg.nwwn);

  
  		bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag,

  				BFA_FALSE, FC_CLASS_3, len, &fchs, NULL, NULL,
  				FC_MAX_PDUSZ, 0);

  	} else {
  		rport->stats.adisc_rejected++;
  		bfa_fcs_rport_send_ls_rjt(rport, rx_fchs,
  					  FC_LS_RJT_RSN_UNABLE_TO_PERF_CMD,
  					  FC_LS_RJT_EXP_LOGIN_REQUIRED);
  	}

  }
  
  static void
  bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport)
  {

  	struct bfa_fcs_lport_s *port = rport->port;

  	struct bfa_rport_info_s rport_info;
  
  	rport_info.pid = rport->pid;
  	rport_info.local_pid = port->pid;
  	rport_info.lp_tag = port->lp_tag;
  	rport_info.vf_id = port->fabric->vf_id;
  	rport_info.vf_en = port->fabric->is_vf;
  	rport_info.fc_class = rport->fc_cos;
  	rport_info.cisc = rport->cisc;
  	rport_info.max_frmsz = rport->maxfrsize;
  	bfa_rport_online(rport->bfa_rport, &rport_info);
  }

  static struct bfa_fcs_rport_s *

  bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)

  {

  	struct bfa_fcs_s	*fcs = port->fcs;

  	struct bfa_fcs_rport_s *rport;

  	struct bfad_rport_s	*rport_drv;

  	/*

  	 * allocate rport
  	 */
  	if (bfa_fcb_rport_alloc(fcs->bfad, &rport, &rport_drv)

  		!= BFA_STATUS_OK) {

  		bfa_trc(fcs, rpid);
  		return NULL;
  	}
  
  	/*
  	 * Initialize r-port
  	 */
  	rport->port = port;
  	rport->fcs = fcs;
  	rport->rp_drv = rport_drv;
  	rport->pid = rpid;
  	rport->pwwn = pwwn;

  	/*

  	 * allocate BFA rport
  	 */
  	rport->bfa_rport = bfa_rport_create(port->fcs->bfa, rport);
  	if (!rport->bfa_rport) {
  		bfa_trc(fcs, rpid);
  		kfree(rport_drv);
  		return NULL;
  	}

  	/*

  	 * allocate FC-4s
  	 */

  	WARN_ON(!bfa_fcs_lport_is_initiator(port));

  	if (bfa_fcs_lport_is_initiator(port)) {

  		rport->itnim = bfa_fcs_itnim_create(rport);
  		if (!rport->itnim) {
  			bfa_trc(fcs, rpid);

  			bfa_sm_send_event(rport->bfa_rport,
  						BFA_RPORT_SM_DELETE);

  			kfree(rport_drv);
  			return NULL;
  		}
  	}

  	bfa_fcs_lport_add_rport(port, rport);

  
  	bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);

  	/* Initialize the Rport Features(RPF) Sub Module  */

  	if (!BFA_FCS_PID_IS_WKA(rport->pid))
  		bfa_fcs_rpf_init(rport);
  
  	return rport;
  }
  
  
  static void
  bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport)
  {

  	struct bfa_fcs_lport_s *port = rport->port;

  	/*

  	 * - delete FC-4s
  	 * - delete BFA rport
  	 * - remove from queue of rports
  	 */

  	if (bfa_fcs_lport_is_initiator(port)) {

  		bfa_fcs_itnim_delete(rport->itnim);

  		if (rport->pid != 0 && !BFA_FCS_PID_IS_WKA(rport->pid))
  			bfa_fcs_rpf_rport_offline(rport);
  	}

  	bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_DELETE);

  	bfa_fcs_lport_del_rport(port, rport);

  	kfree(rport->rp_drv);
  }
  
  static void

  bfa_fcs_rport_aen_post(struct bfa_fcs_rport_s *rport,
  			enum bfa_rport_aen_event event,
  			struct bfa_rport_aen_data_s *data)
  {
  	struct bfa_fcs_lport_s *port = rport->port;
  	struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
  	struct bfa_aen_entry_s  *aen_entry;
  
  	bfad_get_aen_entry(bfad, aen_entry);
  	if (!aen_entry)
  		return;
  
  	if (event == BFA_RPORT_AEN_QOS_PRIO)
  		aen_entry->aen_data.rport.priv.qos = data->priv.qos;
  	else if (event == BFA_RPORT_AEN_QOS_FLOWID)
  		aen_entry->aen_data.rport.priv.qos = data->priv.qos;
  
  	aen_entry->aen_data.rport.vf_id = rport->port->fabric->vf_id;
  	aen_entry->aen_data.rport.ppwwn = bfa_fcs_lport_get_pwwn(
  					bfa_fcs_get_base_port(rport->fcs));
  	aen_entry->aen_data.rport.lpwwn = bfa_fcs_lport_get_pwwn(rport->port);
  	aen_entry->aen_data.rport.rpwwn = rport->pwwn;
  
  	/* Send the AEN notification */
  	bfad_im_post_vendor_event(aen_entry, bfad, ++rport->fcs->fcs_aen_seq,
  				  BFA_AEN_CAT_RPORT, event);
  }
  
  static void

  bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport)
  {

  	struct bfa_fcs_lport_s *port = rport->port;
  	struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
  	char	lpwwn_buf[BFA_STRING_32];
  	char	rpwwn_buf[BFA_STRING_32];

  
  	rport->stats.onlines++;

  	if ((!rport->pid) || (!rport->pwwn)) {
  		bfa_trc(rport->fcs, rport->pid);
  		bfa_sm_fault(rport->fcs, rport->pid);
  	}

  	if (bfa_fcs_lport_is_initiator(port)) {

  		bfa_fcs_itnim_rport_online(rport->itnim);
  		if (!BFA_FCS_PID_IS_WKA(rport->pid))
  			bfa_fcs_rpf_rport_online(rport);
  	};

  	wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
  	wwn2str(rpwwn_buf, rport->pwwn);

  	if (!BFA_FCS_PID_IS_WKA(rport->pid)) {

  		BFA_LOG(KERN_INFO, bfad, bfa_log_level,

  		"Remote port (WWN = %s) online for logical port (WWN = %s)
  ",
  		rpwwn_buf, lpwwn_buf);

  		bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_ONLINE, NULL);
  	}

  }
  
  static void
  bfa_fcs_rport_offline_action(struct bfa_fcs_rport_s *rport)
  {

  	struct bfa_fcs_lport_s *port = rport->port;
  	struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
  	char	lpwwn_buf[BFA_STRING_32];
  	char	rpwwn_buf[BFA_STRING_32];

  
  	rport->stats.offlines++;

  	rport->plogi_pending = BFA_FALSE;

  	wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
  	wwn2str(rpwwn_buf, rport->pwwn);

  	if (!BFA_FCS_PID_IS_WKA(rport->pid)) {

  		if (bfa_fcs_lport_is_online(rport->port) == BFA_TRUE) {

  			BFA_LOG(KERN_ERR, bfad, bfa_log_level,

  				"Remote port (WWN = %s) connectivity lost for "
  				"logical port (WWN = %s)
  ",
  				rpwwn_buf, lpwwn_buf);

  			bfa_fcs_rport_aen_post(rport,
  				BFA_RPORT_AEN_DISCONNECT, NULL);
  		} else {

  			BFA_LOG(KERN_INFO, bfad, bfa_log_level,

  				"Remote port (WWN = %s) offlined by "
  				"logical port (WWN = %s)
  ",
  				rpwwn_buf, lpwwn_buf);

  			bfa_fcs_rport_aen_post(rport,
  				BFA_RPORT_AEN_OFFLINE, NULL);
  		}

  	}

  	if (bfa_fcs_lport_is_initiator(port)) {

  		bfa_fcs_itnim_rport_offline(rport->itnim);
  		if (!BFA_FCS_PID_IS_WKA(rport->pid))
  			bfa_fcs_rpf_rport_offline(rport);
  	}

  }

  /*

   * Update rport parameters from PLOGI or PLOGI accept.
   */
  static void
  bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport, struct fc_logi_s *plogi)
  {

  	bfa_fcs_lport_t *port = rport->port;

  	/*

  	 * - port name
  	 * - node name
  	 */
  	rport->pwwn = plogi->port_name;
  	rport->nwwn = plogi->node_name;

  	/*

  	 * - class of service
  	 */
  	rport->fc_cos = 0;
  	if (plogi->class3.class_valid)
  		rport->fc_cos = FC_CLASS_3;
  
  	if (plogi->class2.class_valid)
  		rport->fc_cos |= FC_CLASS_2;

  	/*

  	 * - CISC
  	 * - MAX receive frame size
  	 */
  	rport->cisc = plogi->csp.cisc;

  	rport->maxfrsize = be16_to_cpu(plogi->class3.rxsz);

  	bfa_trc(port->fcs, be16_to_cpu(plogi->csp.bbcred));

  	bfa_trc(port->fcs, port->fabric->bb_credit);

  	/*

  	 * Direct Attach P2P mode :
  	 * This is to handle a bug (233476) in IBM targets in Direct Attach

  	 *  Mode. Basically, in FLOGI Accept the target would have
  	 * erroneously set the BB Credit to the value used in the FLOGI
  	 * sent by the HBA. It uses the correct value (its own BB credit)
  	 * in PLOGI.

  	 */

  	if ((!bfa_fcs_fabric_is_switched(port->fabric))	 &&

  		(be16_to_cpu(plogi->csp.bbcred) < port->fabric->bb_credit)) {

  		bfa_trc(port->fcs, be16_to_cpu(plogi->csp.bbcred));

  		bfa_trc(port->fcs, port->fabric->bb_credit);

  		port->fabric->bb_credit = be16_to_cpu(plogi->csp.bbcred);

  		bfa_fcport_set_tx_bbcredit(port->fcs->bfa,

  					  port->fabric->bb_credit, 0);

  	}
  
  }

  /*

   *	Called to handle LOGO received from an existing remote port.

   */
  static void
  bfa_fcs_rport_process_logo(struct bfa_fcs_rport_s *rport, struct fchs_s *fchs)
  {
  	rport->reply_oxid = fchs->ox_id;
  	bfa_trc(rport->fcs, rport->reply_oxid);

  	rport->prlo = BFA_FALSE;

  	rport->stats.logo_rcvd++;
  	bfa_sm_send_event(rport, RPSM_EVENT_LOGO_RCVD);
  }

  /*

   *  fcs_rport_public FCS rport public interfaces
   */

  /*

   *	Called by bport/vport to create a remote port instance for a discovered
   *	remote device.

   *
   * @param[in] port	- base port or vport
   * @param[in] rpid	- remote port ID
   *
   * @return None
   */
  struct bfa_fcs_rport_s *

  bfa_fcs_rport_create(struct bfa_fcs_lport_s *port, u32 rpid)

  {
  	struct bfa_fcs_rport_s *rport;
  
  	bfa_trc(port->fcs, rpid);
  	rport = bfa_fcs_rport_alloc(port, WWN_NULL, rpid);
  	if (!rport)
  		return NULL;
  
  	bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_SEND);
  	return rport;
  }

  /*

   * Called to create a rport for which only the wwn is known.
   *
   * @param[in] port	- base port
   * @param[in] rpwwn	- remote port wwn
   *
   * @return None
   */
  struct bfa_fcs_rport_s *

  bfa_fcs_rport_create_by_wwn(struct bfa_fcs_lport_s *port, wwn_t rpwwn)

  {
  	struct bfa_fcs_rport_s *rport;

  	bfa_trc(port->fcs, rpwwn);
  	rport = bfa_fcs_rport_alloc(port, rpwwn, 0);
  	if (!rport)
  		return NULL;
  
  	bfa_sm_send_event(rport, RPSM_EVENT_ADDRESS_DISC);
  	return rport;
  }

  /*

   * Called by bport in private loop topology to indicate that a
   * rport has been discovered and plogi has been completed.
   *
   * @param[in] port	- base port or vport
   * @param[in] rpid	- remote port ID
   */
  void

  bfa_fcs_rport_start(struct bfa_fcs_lport_s *port, struct fchs_s *fchs,
  	 struct fc_logi_s *plogi)

  {
  	struct bfa_fcs_rport_s *rport;
  
  	rport = bfa_fcs_rport_alloc(port, WWN_NULL, fchs->s_id);
  	if (!rport)
  		return;
  
  	bfa_fcs_rport_update(rport, plogi);
  
  	bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_COMP);
  }

  /*

   *	Called by bport/vport to handle PLOGI received from a new remote port.
   *	If an existing rport does a plogi, it will be handled separately.

   */
  void

  bfa_fcs_rport_plogi_create(struct bfa_fcs_lport_s *port, struct fchs_s *fchs,
  				struct fc_logi_s *plogi)

  {
  	struct bfa_fcs_rport_s *rport;
  
  	rport = bfa_fcs_rport_alloc(port, plogi->port_name, fchs->s_id);
  	if (!rport)
  		return;
  
  	bfa_fcs_rport_update(rport, plogi);
  
  	rport->reply_oxid = fchs->ox_id;
  	bfa_trc(rport->fcs, rport->reply_oxid);
  
  	rport->stats.plogi_rcvd++;
  	bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_RCVD);
  }

  /*

   *	Called by bport/vport to handle PLOGI received from an existing
   *	 remote port.

   */
  void
  bfa_fcs_rport_plogi(struct bfa_fcs_rport_s *rport, struct fchs_s *rx_fchs,

  			struct fc_logi_s *plogi)

  {

  	/*

  	 * @todo Handle P2P and initiator-initiator.
  	 */
  
  	bfa_fcs_rport_update(rport, plogi);
  
  	rport->reply_oxid = rx_fchs->ox_id;
  	bfa_trc(rport->fcs, rport->reply_oxid);

  	rport->pid = rx_fchs->s_id;
  	bfa_trc(rport->fcs, rport->pid);

  	rport->stats.plogi_rcvd++;
  	bfa_sm_send_event(rport, RPSM_EVENT_PLOGI_RCVD);
  }

  /*

   *	Called by bport/vport to notify SCN for the remote port

   */
  void
  bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport)
  {

  	rport->stats.rscns++;
  	bfa_sm_send_event(rport, RPSM_EVENT_SCN);
  }

  /*

   *	brief
   *	This routine BFA callback for bfa_rport_online() call.

   *

   *	param[in]	cb_arg	-  rport struct.

   *

   *	return
   *		void

   *

   *	Special Considerations:

   *

   *	note

   */
  void
  bfa_cb_rport_online(void *cbarg)
  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;

  
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_sm_send_event(rport, RPSM_EVENT_HCB_ONLINE);
  }

  /*

   *	brief
   *	This routine BFA callback for bfa_rport_offline() call.

   *

   *	param[in]	rport	-

   *

   *	return
   *		void

   *

   *	Special Considerations:

   *

   *	note

   */
  void
  bfa_cb_rport_offline(void *cbarg)
  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;

  
  	bfa_trc(rport->fcs, rport->pwwn);
  	bfa_sm_send_event(rport, RPSM_EVENT_HCB_OFFLINE);
  }

  /*

   *	brief
   *	This routine is a static BFA callback when there is a QoS flow_id
   *	change notification

   *

   *	param[in]	rport	-

   *

   *	return
   *		void

   *

   *	Special Considerations:

   *

   *	note

   */
  void
  bfa_cb_rport_qos_scn_flowid(void *cbarg,

  		struct bfa_rport_qos_attr_s old_qos_attr,
  		struct bfa_rport_qos_attr_s new_qos_attr)

  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;

  	struct bfa_rport_aen_data_s aen_data;

  
  	bfa_trc(rport->fcs, rport->pwwn);

  	aen_data.priv.qos = new_qos_attr;
  	bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_QOS_FLOWID, &aen_data);

  }

  /*

   *	brief
   *	This routine is a static BFA callback when there is a QoS priority
   *	change notification

   *

   *	param[in]	rport	-

   *

   *	return
   *		void

   *

   *	Special Considerations:

   *

   *	note

   */
  void

  bfa_cb_rport_qos_scn_prio(void *cbarg,
  		struct bfa_rport_qos_attr_s old_qos_attr,
  		struct bfa_rport_qos_attr_s new_qos_attr)

  {

  	struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;