Merge tag 'scsi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Pull first round of SCSI updates from James Bottomley:
 "This is a large set of updates, mostly for drivers (qla2xxx [including
  support for new 83xx based card], qla4xxx, mpt2sas, bfa, zfcp, hpsa,
  be2iscsi, isci, lpfc, ipr, ibmvfc, ibmvscsi, megaraid_sas).

  There's also a rework for tape adding virtually unlimited numbers of
  tape drives plus a set of dif fixes for sd and a fix for a live lock
  on hot remove of SCSI devices.

  This round includes a signed tag pull of isci-for-3.6

  Signed-off-by: James Bottomley <JBottomley@Parallels.com>"

Fix up trivial conflict in drivers/scsi/qla2xxx/qla_nx.c due to new PCI
helper function use in a function that was removed by this pull.

* tag 'scsi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (198 commits)
  [SCSI] st: remove st_mutex
  [SCSI] sd: Ensure we correctly disable devices with unknown protection type
  [SCSI] hpsa: gen8plus Smart Array IDs
  [SCSI] qla4xxx: Update driver version to 5.03.00-k1
  [SCSI] qla4xxx: Disable generating pause frames for ISP83XX
  [SCSI] qla4xxx: Fix double clearing of risc_intr for ISP83XX
  [SCSI] qla4xxx: IDC implementation for Loopback
  [SCSI] qla4xxx: update copyrights in LICENSE.qla4xxx
  [SCSI] qla4xxx: Fix panic while rmmod
  [SCSI] qla4xxx: Fail probe_adapter if IRQ allocation fails
  [SCSI] qla4xxx: Prevent MSI/MSI-X falling back to INTx for ISP82XX
  [SCSI] qla4xxx: Update idc reg in case of PCI AER
  [SCSI] qla4xxx: Fix double IDC locking in qla4_8xxx_error_recovery
  [SCSI] qla4xxx: Clear interrupt while unloading driver for ISP83XX
  [SCSI] qla4xxx: Print correct IDC version
  [SCSI] qla4xxx: Added new mbox cmd to pass driver version to FW
  [SCSI] scsi_dh_alua: Enable STPG for unavailable ports
  [SCSI] scsi_remove_target: fix softlockup regression on hot remove
  [SCSI] ibmvscsi: Fix host config length field overflow
  [SCSI] ibmvscsi: Remove backend abstraction
  ...

23 files changed, 1736 insertions, 309 deletions

diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 456e5762977..b7c326f7a6d 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -775,7 +775,8 @@ bfa_intx(struct bfa_s *bfa)
         if (!intr)
                 return BFA_TRUE;
 
-        bfa_msix_lpu_err(bfa, intr);
+        if (bfa->intr_enabled)
+                bfa_msix_lpu_err(bfa, intr);
 
         return BFA_TRUE;
 }
@@ -803,11 +804,17 @@ bfa_isr_enable(struct bfa_s *bfa)
         writel(~umsk, bfa->iocfc.bfa_regs.intr_mask);
         bfa->iocfc.intr_mask = ~umsk;
         bfa_isr_mode_set(bfa, bfa->msix.nvecs != 0);
+
+        /*
+         * Set the flag indicating successful enabling of interrupts
+         */
+        bfa->intr_enabled = BFA_TRUE;
 }
 
 void
 bfa_isr_disable(struct bfa_s *bfa)
 {
+        bfa->intr_enabled = BFA_FALSE;
         bfa_isr_mode_set(bfa, BFA_FALSE);
         writel(-1L, bfa->iocfc.bfa_regs.intr_mask);
         bfa_msix_uninstall(bfa);
@@ -1022,7 +1029,7 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg)
 {
         u8      *dm_kva = NULL;
         u64     dm_pa = 0;
-        int     i, per_reqq_sz, per_rspq_sz, dbgsz;
+        int     i, per_reqq_sz, per_rspq_sz;
         struct bfa_iocfc_s  *iocfc = &bfa->iocfc;
         struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa);
         struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa);
@@ -1083,11 +1090,8 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg)
                         BFA_CACHELINE_SZ);
 
         /* Claim IOCFC kva memory */
-        dbgsz = (bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
-        if (dbgsz > 0) {
-                bfa_ioc_debug_memclaim(&bfa->ioc, bfa_mem_kva_curp(iocfc));
-                bfa_mem_kva_curp(iocfc) += dbgsz;
-        }
+        bfa_ioc_debug_memclaim(&bfa->ioc, bfa_mem_kva_curp(iocfc));
+        bfa_mem_kva_curp(iocfc) += BFA_DBG_FWTRC_LEN;
 }
 
 /*
@@ -1429,8 +1433,7 @@ bfa_iocfc_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
         bfa_mem_dma_setup(meminfo, iocfc_dma, dm_len);
 
         /* kva memory setup for IOCFC */
-        bfa_mem_kva_setup(meminfo, iocfc_kva,
-                        ((bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0));
+        bfa_mem_kva_setup(meminfo, iocfc_kva, BFA_DBG_FWTRC_LEN);
 }
 
 /*
diff --git a/drivers/scsi/bfa/bfa_cs.h b/drivers/scsi/bfa/bfa_cs.h
index 12bfeed268e..91a8aa394db 100644
--- a/drivers/scsi/bfa/bfa_cs.h
+++ b/drivers/scsi/bfa/bfa_cs.h
@@ -168,7 +168,7 @@ __bfa_trc32(struct bfa_trc_mod_s *trcm, int fileno, int line, u32 data)
 /*
  * bfa_q_deq - dequeue an element from head of the queue
  */
-#define bfa_q_deq(_q, _qe) {                                            \
+#define bfa_q_deq(_q, _qe) do {                                         \
         if (!list_empty(_q)) {                                          \
                 (*((struct list_head **) (_qe))) = bfa_q_next(_q);      \
                 bfa_q_prev(bfa_q_next(*((struct list_head **) _qe))) =  \
@@ -177,7 +177,7 @@ __bfa_trc32(struct bfa_trc_mod_s *trcm, int fileno, int line, u32 data)
         } else {                                                        \
                 *((struct list_head **) (_qe)) = (struct list_head *) NULL;\
         }                                                               \
-}
+} while (0)
 
 /*
  * bfa_q_deq_tail - dequeue an element from tail of the queue
diff --git a/drivers/scsi/bfa/bfa_defs_fcs.h b/drivers/scsi/bfa/bfa_defs_fcs.h
index 3bbc583f65c..06f0a163ca3 100644
--- a/drivers/scsi/bfa/bfa_defs_fcs.h
+++ b/drivers/scsi/bfa/bfa_defs_fcs.h
@@ -93,6 +93,7 @@ struct bfa_lport_cfg_s {
         wwn_t          pwwn;       /*  port wwn */
         wwn_t          nwwn;       /*  node wwn */
         struct bfa_lport_symname_s  sym_name;   /*  vm port symbolic name */
+        struct bfa_lport_symname_s node_sym_name; /* Node symbolic name */
         enum bfa_lport_role roles;      /* FCS port roles */
         u32     rsvd;
         bfa_boolean_t   preboot_vp;  /*  vport created from PBC */
@@ -192,6 +193,18 @@ struct bfa_lport_stats_s {
         u32     ns_gidft_unknown_rsp;
         u32     ns_gidft_alloc_wait;
 
+        u32     ns_rnnid_sent;
+        u32     ns_rnnid_accepts;
+        u32     ns_rnnid_rsp_err;
+        u32     ns_rnnid_rejects;
+        u32     ns_rnnid_alloc_wait;
+
+        u32     ns_rsnn_nn_sent;
+        u32     ns_rsnn_nn_accepts;
+        u32     ns_rsnn_nn_rsp_err;
+        u32     ns_rsnn_nn_rejects;
+        u32     ns_rsnn_nn_alloc_wait;
+
         /*
          * Mgmt Server stats
          */
@@ -410,6 +423,11 @@ struct bfa_rport_remote_link_stats_s {
         u32 icc; /*  Invalid CRC Count */
 };
 
+struct bfa_rport_qualifier_s {
+        wwn_t   pwwn;   /* Port WWN */
+        u32     pid;    /* port ID */
+        u32     rsvd;
+};
 
 #define BFA_MAX_IO_INDEX 7
 #define BFA_NO_IO_INDEX 9
diff --git a/drivers/scsi/bfa/bfa_fc.h b/drivers/scsi/bfa/bfa_fc.h
index 8d0b88f67a3..e0beb4d7e26 100644
--- a/drivers/scsi/bfa/bfa_fc.h
+++ b/drivers/scsi/bfa/bfa_fc.h
@@ -1279,6 +1279,7 @@ enum {
         GS_GSPN_ID      = 0x0118,       /* Get symbolic PN on ID */
         GS_RFT_ID       = 0x0217,       /* Register fc4type on ID */
         GS_RSPN_ID      = 0x0218,       /* Register symbolic PN on ID */
+        GS_RSNN_NN      = 0x0239,       /* Register symbolic NN on NN */
         GS_RPN_ID       = 0x0212,       /* Register port name */
         GS_RNN_ID       = 0x0213,       /* Register node name */
         GS_RCS_ID       = 0x0214,       /* Register class of service */
@@ -1357,6 +1358,15 @@ struct fcgs_rspnid_req_s {
 };
 
 /*
+ * RSNN_NN
+ */
+struct fcgs_rsnn_nn_req_s {
+        wwn_t   node_name;      /* Node name */
+        u8      snn_len;        /* symbolic node name length */
+        u8      snn[256];       /* symbolic node name */
+};
+
+/*
  * RPN_ID
  */
 struct fcgs_rpnid_req_s {
diff --git a/drivers/scsi/bfa/bfa_fcbuild.c b/drivers/scsi/bfa/bfa_fcbuild.c
index 17b59b8b564..273cee90b3b 100644
--- a/drivers/scsi/bfa/bfa_fcbuild.c
+++ b/drivers/scsi/bfa/bfa_fcbuild.c
@@ -1252,6 +1252,27 @@ fc_rspnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 }
 
 u16
+fc_rsnn_nn_build(struct fchs_s *fchs, void *pyld, u32 s_id,
+                        wwn_t node_name, u8 *name)
+{
+        struct ct_hdr_s *cthdr = (struct ct_hdr_s *) pyld;
+        struct fcgs_rsnn_nn_req_s *rsnn_nn =
+                (struct fcgs_rsnn_nn_req_s *) (cthdr + 1);
+        u32     d_id = bfa_hton3b(FC_NAME_SERVER);
+
+        fc_gs_fchdr_build(fchs, d_id, s_id, 0);
+        fc_gs_cthdr_build(cthdr, s_id, GS_RSNN_NN);
+
+        memset(rsnn_nn, 0, sizeof(struct fcgs_rsnn_nn_req_s));
+
+        rsnn_nn->node_name = node_name;
+        rsnn_nn->snn_len = (u8) strlen((char *)name);
+        strncpy((char *)rsnn_nn->snn, (char *)name, rsnn_nn->snn_len);
+
+        return sizeof(struct fcgs_rsnn_nn_req_s) + sizeof(struct ct_hdr_s);
+}
+
+u16
 fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id, u8 fc4_type)
 {
 
diff --git a/drivers/scsi/bfa/bfa_fcbuild.h b/drivers/scsi/bfa/bfa_fcbuild.h
index 42cd9d4da69..03c753d1e54 100644
--- a/drivers/scsi/bfa/bfa_fcbuild.h
+++ b/drivers/scsi/bfa/bfa_fcbuild.h
@@ -166,6 +166,8 @@ enum fc_parse_status fc_rrq_rsp_parse(struct fchs_s *buf, int len);
 
 u16        fc_rspnid_build(struct fchs_s *fchs, void *pld, u32 s_id,
                                 u16 ox_id, u8 *name);
+u16     fc_rsnn_nn_build(struct fchs_s *fchs, void *pld, u32 s_id,
+                                wwn_t node_name, u8 *name);
 
 u16        fc_rftid_build(struct fchs_s *fchs, void *pld, u32 s_id,
                                u16 ox_id, enum bfa_lport_role role);
diff --git a/drivers/scsi/bfa/bfa_fcpim.c b/drivers/scsi/bfa/bfa_fcpim.c
index f0f80e282e3..1633963c66c 100644
--- a/drivers/scsi/bfa/bfa_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcpim.c
@@ -1466,7 +1466,13 @@ bfa_status_t
 bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
                         struct bfa_itnim_ioprofile_s *ioprofile)
 {
-        struct bfa_fcpim_s *fcpim = BFA_FCPIM(itnim->bfa);
+        struct bfa_fcpim_s *fcpim;
+
+        if (!itnim)
+                return BFA_STATUS_NO_FCPIM_NEXUS;
+
+        fcpim = BFA_FCPIM(itnim->bfa);
+
         if (!fcpim->io_profile)
                 return BFA_STATUS_IOPROFILE_OFF;
 
@@ -1484,6 +1490,10 @@ void
 bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
 {
         int j;
+
+        if (!itnim)
+                return;
+
         memset(&itnim->stats, 0, sizeof(itnim->stats));
         memset(&itnim->ioprofile, 0, sizeof(itnim->ioprofile));
         for (j = 0; j < BFA_IOBUCKET_MAX; j++)
diff --git a/drivers/scsi/bfa/bfa_fcs.c b/drivers/scsi/bfa/bfa_fcs.c
index eaac57e1dde..fd3e84d32bd 100644
--- a/drivers/scsi/bfa/bfa_fcs.c
+++ b/drivers/scsi/bfa/bfa_fcs.c
@@ -76,6 +76,7 @@ bfa_fcs_attach(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
         fcs->bfa = bfa;
         fcs->bfad = bfad;
         fcs->min_cfg = min_cfg;
+        fcs->num_rport_logins = 0;
 
         bfa->fcs = BFA_TRUE;
         fcbuild_init();
@@ -119,6 +120,18 @@ bfa_fcs_update_cfg(struct bfa_fcs_s *fcs)
 }
 
 /*
+ * Stop FCS operations.
+ */
+void
+bfa_fcs_stop(struct bfa_fcs_s *fcs)
+{
+        bfa_wc_init(&fcs->wc, bfa_fcs_exit_comp, fcs);
+        bfa_wc_up(&fcs->wc);
+        bfa_fcs_fabric_modstop(fcs);
+        bfa_wc_wait(&fcs->wc);
+}
+
+/*
  * fcs pbc vport initialization
  */
 void
@@ -153,6 +166,7 @@ bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
         fcs->driver_info = *driver_info;
 
         bfa_fcs_fabric_psymb_init(&fcs->fabric);
+        bfa_fcs_fabric_nsymb_init(&fcs->fabric);
 }
 
 /*
@@ -213,6 +227,8 @@ static void bfa_fcs_fabric_notify_offline(struct bfa_fcs_fabric_s *fabric);
 static void bfa_fcs_fabric_delay(void *cbarg);
 static void bfa_fcs_fabric_delete(struct bfa_fcs_fabric_s *fabric);
 static void bfa_fcs_fabric_delete_comp(void *cbarg);
+static void bfa_fcs_fabric_stop(struct bfa_fcs_fabric_s *fabric);
+static void bfa_fcs_fabric_stop_comp(void *cbarg);
 static void bfa_fcs_fabric_process_uf(struct bfa_fcs_fabric_s *fabric,
                                       struct fchs_s *fchs, u16 len);
 static void bfa_fcs_fabric_process_flogi(struct bfa_fcs_fabric_s *fabric,
@@ -250,6 +266,10 @@ static void	bfa_fcs_fabric_sm_isolated(struct bfa_fcs_fabric_s *fabric,
                                            enum bfa_fcs_fabric_event event);
 static void     bfa_fcs_fabric_sm_deleting(struct bfa_fcs_fabric_s *fabric,
                                            enum bfa_fcs_fabric_event event);
+static void     bfa_fcs_fabric_sm_stopping(struct bfa_fcs_fabric_s *fabric,
+                                           enum bfa_fcs_fabric_event event);
+static void     bfa_fcs_fabric_sm_cleanup(struct bfa_fcs_fabric_s *fabric,
+                                          enum bfa_fcs_fabric_event event);
 /*
  *   Beginning state before fabric creation.
  */
@@ -334,6 +354,11 @@ bfa_fcs_fabric_sm_linkdown(struct bfa_fcs_fabric_s *fabric,
                 bfa_fcs_fabric_delete(fabric);
                 break;
 
+        case BFA_FCS_FABRIC_SM_STOP:
+                bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_cleanup);
+                bfa_fcs_fabric_stop(fabric);
+                break;
+
         default:
                 bfa_sm_fault(fabric->fcs, event);
         }
@@ -585,6 +610,11 @@ bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
                 bfa_fcs_fabric_delete(fabric);
                 break;
 
+        case BFA_FCS_FABRIC_SM_STOP:
+                bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_stopping);
+                bfa_fcs_fabric_stop(fabric);
+                break;
+
         case BFA_FCS_FABRIC_SM_AUTH_FAILED:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_auth_failed);
                 bfa_sm_send_event(fabric->lps, BFA_LPS_SM_OFFLINE);
@@ -682,7 +712,62 @@ bfa_fcs_fabric_sm_deleting(struct bfa_fcs_fabric_s *fabric,
         }
 }
 
+/*
+ * Fabric is being stopped, awaiting vport stop completions.
+ */
+static void
+bfa_fcs_fabric_sm_stopping(struct bfa_fcs_fabric_s *fabric,
+                           enum bfa_fcs_fabric_event event)
+{
+        bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn);
+        bfa_trc(fabric->fcs, event);
+
+        switch (event) {
+        case BFA_FCS_FABRIC_SM_STOPCOMP:
+                bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_cleanup);
+                bfa_sm_send_event(fabric->lps, BFA_LPS_SM_LOGOUT);
+                break;
+
+        case BFA_FCS_FABRIC_SM_LINK_UP:
+                break;
+
+        case BFA_FCS_FABRIC_SM_LINK_DOWN:
+                bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_cleanup);
+                break;
+
+        default:
+                bfa_sm_fault(fabric->fcs, event);
+        }
+}
+
+/*
+ * Fabric is being stopped, cleanup without FLOGO
+ */
+static void
+bfa_fcs_fabric_sm_cleanup(struct bfa_fcs_fabric_s *fabric,
+                          enum bfa_fcs_fabric_event event)
+{
+        bfa_trc(fabric->fcs, fabric->bport.port_cfg.pwwn);
+        bfa_trc(fabric->fcs, event);
 
+        switch (event) {
+        case BFA_FCS_FABRIC_SM_STOPCOMP:
+        case BFA_FCS_FABRIC_SM_LOGOCOMP:
+                bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_created);
+                bfa_wc_down(&(fabric->fcs)->wc);
+                break;
+
+        case BFA_FCS_FABRIC_SM_LINK_DOWN:
+                /*
+                 * Ignore - can get this event if we get notified about IOC down
+                 * before the fabric completion callbk is done.
+                 */
+                break;
+
+        default:
+                bfa_sm_fault(fabric->fcs, event);
+        }
+}
 
 /*
  *  fcs_fabric_private fabric private functions
@@ -760,6 +845,44 @@ bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric)
 }
 
 /*
+ * Node Symbolic Name Creation for base port and all vports
+ */
+void
+bfa_fcs_fabric_nsymb_init(struct bfa_fcs_fabric_s *fabric)
+{
+        struct bfa_lport_cfg_s *port_cfg = &fabric->bport.port_cfg;
+        char model[BFA_ADAPTER_MODEL_NAME_LEN] = {0};
+        struct bfa_fcs_driver_info_s *driver_info = &fabric->fcs->driver_info;
+
+        bfa_ioc_get_adapter_model(&fabric->fcs->bfa->ioc, model);
+
+        /* Model name/number */
+        strncpy((char *)&port_cfg->node_sym_name, model,
+                BFA_FCS_PORT_SYMBNAME_MODEL_SZ);
+        strncat((char *)&port_cfg->node_sym_name,
+                        BFA_FCS_PORT_SYMBNAME_SEPARATOR,
+                        sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
+
+        /* Driver Version */
+        strncat((char *)&port_cfg->node_sym_name, (char *)driver_info->version,
+                BFA_FCS_PORT_SYMBNAME_VERSION_SZ);
+        strncat((char *)&port_cfg->node_sym_name,
+                        BFA_FCS_PORT_SYMBNAME_SEPARATOR,
+                        sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
+
+        /* Host machine name */
+        strncat((char *)&port_cfg->node_sym_name,
+                (char *)driver_info->host_machine_name,
+                BFA_FCS_PORT_SYMBNAME_MACHINENAME_SZ);
+        strncat((char *)&port_cfg->node_sym_name,
+                        BFA_FCS_PORT_SYMBNAME_SEPARATOR,
+                        sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
+
+        /* null terminate */
+        port_cfg->node_sym_name.symname[BFA_SYMNAME_MAXLEN - 1] = 0;
+}
+
+/*
  * bfa lps login completion callback
  */
 void
@@ -919,6 +1042,28 @@ bfa_fcs_fabric_delay(void *cbarg)
 }
 
 /*
+ * Stop all vports and wait for vport stop completions.
+ */
+static void
+bfa_fcs_fabric_stop(struct bfa_fcs_fabric_s *fabric)
+{
+        struct bfa_fcs_vport_s *vport;
+        struct list_head        *qe, *qen;
+
+        bfa_wc_init(&fabric->stop_wc, bfa_fcs_fabric_stop_comp, fabric);
+
+        list_for_each_safe(qe, qen, &fabric->vport_q) {
+                vport = (struct bfa_fcs_vport_s *) qe;
+                bfa_wc_up(&fabric->stop_wc);
+                bfa_fcs_vport_fcs_stop(vport);
+        }
+
+        bfa_wc_up(&fabric->stop_wc);
+        bfa_fcs_lport_stop(&fabric->bport);
+        bfa_wc_wait(&fabric->stop_wc);
+}
+
+/*
  * Computes operating BB_SCN value
  */
 static u8
@@ -978,6 +1123,14 @@ bfa_fcs_fabric_delete_comp(void *cbarg)
         bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_DELCOMP);
 }
 
+static void
+bfa_fcs_fabric_stop_comp(void *cbarg)
+{
+        struct bfa_fcs_fabric_s *fabric = cbarg;
+
+        bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_STOPCOMP);
+}
+
 /*
  *  fcs_fabric_public fabric public functions
  */
@@ -1039,6 +1192,19 @@ bfa_fcs_fabric_modexit(struct bfa_fcs_s *fcs)
 }
 
 /*
+ * Fabric module stop -- stop FCS actions
+ */
+void
+bfa_fcs_fabric_modstop(struct bfa_fcs_s *fcs)
+{
+        struct bfa_fcs_fabric_s *fabric;
+
+        bfa_trc(fcs, 0);
+        fabric = &fcs->fabric;
+        bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_STOP);
+}
+
+/*
  * Fabric module start -- kick starts FCS actions
  */
 void
@@ -1219,8 +1385,11 @@ bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric, struct fchs_s *fchs,
                         return;
                 }
         }
-        bfa_trc(fabric->fcs, els_cmd->els_code);
-        bfa_fcs_lport_uf_recv(&fabric->bport, fchs, len);
+
+        if (!bfa_fcs_fabric_is_switched(fabric))
+                bfa_fcs_lport_uf_recv(&fabric->bport, fchs, len);
+
+        bfa_trc(fabric->fcs, fchs->type);
 }
 
 /*
@@ -1294,7 +1463,7 @@ bfa_fcs_fabric_send_flogi_acc(struct bfa_fcs_fabric_s *fabric)
         u16     reqlen;
         struct fchs_s   fchs;
 
-        fcxp = bfa_fcs_fcxp_alloc(fabric->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(fabric->fcs, BFA_FALSE);
         /*
          * Do not expect this failure -- expect remote node to retry
          */
@@ -1387,6 +1556,13 @@ bfa_fcs_fabric_set_fabric_name(struct bfa_fcs_fabric_s *fabric,
         }
 }
 
+void
+bfa_cb_lps_flogo_comp(void *bfad, void *uarg)
+{
+        struct bfa_fcs_fabric_s *fabric = uarg;
+        bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_LOGOCOMP);
+}
+
 /*
  *      Returns FCS vf structure for a given vf_id.
  *
diff --git a/drivers/scsi/bfa/bfa_fcs.h b/drivers/scsi/bfa/bfa_fcs.h
index 51c9e134571..6c4377cb287 100644
--- a/drivers/scsi/bfa/bfa_fcs.h
+++ b/drivers/scsi/bfa/bfa_fcs.h
@@ -62,9 +62,9 @@ struct bfa_fcs_s;
 #define N2N_LOCAL_PID       0x010000
 #define N2N_REMOTE_PID          0x020000
 #define BFA_FCS_RETRY_TIMEOUT 2000
+#define BFA_FCS_MAX_NS_RETRIES 5
 #define BFA_FCS_PID_IS_WKA(pid)  ((bfa_ntoh3b(pid) > 0xFFF000) ?  1 : 0)
-
-
+#define BFA_FCS_MAX_RPORT_LOGINS 1024
 
 struct bfa_fcs_lport_ns_s {
         bfa_sm_t        sm;             /*  state machine */
@@ -72,6 +72,8 @@ struct bfa_fcs_lport_ns_s {
         struct bfa_fcs_lport_s *port;   /*  parent port */
         struct bfa_fcxp_s *fcxp;
         struct bfa_fcxp_wqe_s fcxp_wqe;
+        u8      num_rnnid_retries;
+        u8      num_rsnn_nn_retries;
 };
 
 
@@ -205,6 +207,7 @@ struct bfa_fcs_fabric_s {
         struct bfa_lps_s        *lps;   /*  lport login services        */
         u8      fabric_ip_addr[BFA_FCS_FABRIC_IPADDR_SZ];
                                         /*  attached fabric's ip addr  */
+        struct bfa_wc_s stop_wc;        /*  wait counter for stop */
 };
 
 #define bfa_fcs_fabric_npiv_capable(__f)    ((__f)->is_npiv)
@@ -264,6 +267,7 @@ struct bfa_fcs_fabric_s;
 #define bfa_fcs_lport_get_pwwn(_lport)  ((_lport)->port_cfg.pwwn)
 #define bfa_fcs_lport_get_nwwn(_lport)  ((_lport)->port_cfg.nwwn)
 #define bfa_fcs_lport_get_psym_name(_lport)     ((_lport)->port_cfg.sym_name)
+#define bfa_fcs_lport_get_nsym_name(_lport) ((_lport)->port_cfg.node_sym_name)
 #define bfa_fcs_lport_is_initiator(_lport)                      \
         ((_lport)->port_cfg.roles & BFA_LPORT_ROLE_FCP_IM)
 #define bfa_fcs_lport_get_nrports(_lport)       \
@@ -286,9 +290,8 @@ bfa_fcs_lport_get_drvport(struct bfa_fcs_lport_s *port)
 
 bfa_boolean_t   bfa_fcs_lport_is_online(struct bfa_fcs_lport_s *port);
 struct bfa_fcs_lport_s *bfa_fcs_get_base_port(struct bfa_fcs_s *fcs);
-void bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s *port,
-                              wwn_t rport_wwns[], int *nrports);
-
+void bfa_fcs_lport_get_rport_quals(struct bfa_fcs_lport_s *port,
+                        struct bfa_rport_qualifier_s rport[], int *nrports);
 wwn_t bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn,
                               int index, int nrports, bfa_boolean_t bwwn);
 
@@ -324,12 +327,17 @@ void bfa_fcs_lport_init(struct bfa_fcs_lport_s *lport,
 void            bfa_fcs_lport_online(struct bfa_fcs_lport_s *port);
 void            bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port);
 void            bfa_fcs_lport_delete(struct bfa_fcs_lport_s *port);
+void            bfa_fcs_lport_stop(struct bfa_fcs_lport_s *port);
 struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_pid(
                 struct bfa_fcs_lport_s *port, u32 pid);
+struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_old_pid(
+                struct bfa_fcs_lport_s *port, u32 pid);
 struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_pwwn(
                 struct bfa_fcs_lport_s *port, wwn_t pwwn);
 struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_nwwn(
                 struct bfa_fcs_lport_s *port, wwn_t nwwn);
+struct bfa_fcs_rport_s *bfa_fcs_lport_get_rport_by_qualifier(
+                struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 pid);
 void            bfa_fcs_lport_add_rport(struct bfa_fcs_lport_s *port,
                                        struct bfa_fcs_rport_s *rport);
 void            bfa_fcs_lport_del_rport(struct bfa_fcs_lport_s *port,
@@ -338,6 +346,8 @@ void            bfa_fcs_lport_ns_init(struct bfa_fcs_lport_s *vport);
 void            bfa_fcs_lport_ns_offline(struct bfa_fcs_lport_s *vport);
 void            bfa_fcs_lport_ns_online(struct bfa_fcs_lport_s *vport);
 void            bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port);
+void            bfa_fcs_lport_ns_util_send_rspn_id(void *cbarg,
+                                struct bfa_fcxp_s *fcxp_alloced);
 void            bfa_fcs_lport_scn_init(struct bfa_fcs_lport_s *vport);
 void            bfa_fcs_lport_scn_offline(struct bfa_fcs_lport_s *vport);
 void            bfa_fcs_lport_scn_online(struct bfa_fcs_lport_s *vport);
@@ -382,6 +392,7 @@ void bfa_fcs_vport_online(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_offline(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_fcs_delete(struct bfa_fcs_vport_s *vport);
+void bfa_fcs_vport_fcs_stop(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_stop_comp(struct bfa_fcs_vport_s *vport);
 
 #define BFA_FCS_RPORT_DEF_DEL_TIMEOUT   90      /* in secs */
@@ -419,6 +430,7 @@ struct bfa_fcs_rport_s {
         struct bfa_fcs_s        *fcs;   /*  fcs instance */
         struct bfad_rport_s     *rp_drv;        /*  driver peer instance */
         u32     pid;    /*  port ID of rport */
+        u32     old_pid;        /* PID before rport goes offline */
         u16     maxfrsize;      /*  maximum frame size */
         __be16  reply_oxid;     /*  OX_ID of inbound requests */
         enum fc_cos     fc_cos; /*  FC classes of service supp */
@@ -459,7 +471,7 @@ struct bfa_fcs_rport_s *bfa_fcs_rport_lookup(struct bfa_fcs_lport_s *port,
 struct bfa_fcs_rport_s *bfa_fcs_rport_lookup_by_nwwn(
         struct bfa_fcs_lport_s *port, wwn_t rnwwn);
 void bfa_fcs_rport_set_del_timeout(u8 rport_tmo);
-
+void bfa_fcs_rport_set_max_logins(u32 max_logins);
 void bfa_fcs_rport_uf_recv(struct bfa_fcs_rport_s *rport,
          struct fchs_s *fchs, u16 len);
 void bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport);
@@ -505,12 +517,13 @@ struct bfa_fcs_itnim_s {
         struct bfa_fcxp_s       *fcxp;          /*  FCXP in use */
         struct bfa_itnim_stats_s        stats;  /*  itn statistics      */
 };
-#define bfa_fcs_fcxp_alloc(__fcs)       \
-        bfa_fcxp_alloc(NULL, (__fcs)->bfa, 0, 0, NULL, NULL, NULL, NULL)
-
-#define bfa_fcs_fcxp_alloc_wait(__bfa, __wqe, __alloc_cbfn, __alloc_cbarg) \
-        bfa_fcxp_alloc_wait(__bfa, __wqe, __alloc_cbfn, __alloc_cbarg, \
-                                        NULL, 0, 0, NULL, NULL, NULL, NULL)
+#define bfa_fcs_fcxp_alloc(__fcs, __req)                                \
+        bfa_fcxp_req_rsp_alloc(NULL, (__fcs)->bfa, 0, 0,                \
+                               NULL, NULL, NULL, NULL, __req)
+#define bfa_fcs_fcxp_alloc_wait(__bfa, __wqe, __alloc_cbfn,             \
+                                __alloc_cbarg, __req)                   \
+        bfa_fcxp_req_rsp_alloc_wait(__bfa, __wqe, __alloc_cbfn,         \
+                __alloc_cbarg, NULL, 0, 0, NULL, NULL, NULL, NULL, __req)
 
 static inline struct bfad_port_s *
 bfa_fcs_itnim_get_drvport(struct bfa_fcs_itnim_s *itnim)
@@ -592,7 +605,7 @@ bfa_status_t bfa_fcs_itnim_stats_clear(struct bfa_fcs_lport_s *port,
 struct bfa_fcs_itnim_s *bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport);
 void bfa_fcs_itnim_delete(struct bfa_fcs_itnim_s *itnim);
 void bfa_fcs_itnim_rport_offline(struct bfa_fcs_itnim_s *itnim);
-void bfa_fcs_itnim_rport_online(struct bfa_fcs_itnim_s *itnim);
+void bfa_fcs_itnim_brp_online(struct bfa_fcs_itnim_s *itnim);
 bfa_status_t bfa_fcs_itnim_get_online_state(struct bfa_fcs_itnim_s *itnim);
 void bfa_fcs_itnim_is_initiator(struct bfa_fcs_itnim_s *itnim);
 void bfa_fcs_fcpim_uf_recv(struct bfa_fcs_itnim_s *itnim,
@@ -676,6 +689,7 @@ struct bfa_fcs_s {
         struct bfa_fcs_stats_s  stats;  /*  FCS statistics */
         struct bfa_wc_s         wc;     /*  waiting counter */
         int                     fcs_aen_seq;
+        u32             num_rport_logins;
 };
 
 /*
@@ -702,6 +716,9 @@ enum bfa_fcs_fabric_event {
         BFA_FCS_FABRIC_SM_DELCOMP       = 14,   /*  all vports deleted event */
         BFA_FCS_FABRIC_SM_LOOPBACK      = 15,   /*  Received our own FLOGI   */
         BFA_FCS_FABRIC_SM_START         = 16,   /*  from driver       */
+        BFA_FCS_FABRIC_SM_STOP          = 17,   /*  Stop from driver    */
+        BFA_FCS_FABRIC_SM_STOPCOMP      = 18,   /*  Stop completion     */
+        BFA_FCS_FABRIC_SM_LOGOCOMP      = 19,   /*  FLOGO completion    */
 };
 
 /*
@@ -727,6 +744,26 @@ enum rport_event {
         RPSM_EVENT_ADDRESS_DISC = 16,   /*  Need to Discover rport's PID */
         RPSM_EVENT_PRLO_RCVD   = 17,    /*  PRLO from remote device     */
         RPSM_EVENT_PLOGI_RETRY = 18,    /*  Retry PLOGI continuously */
+        RPSM_EVENT_FC4_FCS_ONLINE = 19, /*!< FC-4 FCS online complete */
+};
+
+/*
+ * fcs_itnim_sm FCS itnim state machine events
+ */
+enum bfa_fcs_itnim_event {
+        BFA_FCS_ITNIM_SM_FCS_ONLINE = 1,        /*  rport online event */
+        BFA_FCS_ITNIM_SM_OFFLINE = 2,   /*  rport offline */
+        BFA_FCS_ITNIM_SM_FRMSENT = 3,   /*  prli frame is sent */
+        BFA_FCS_ITNIM_SM_RSP_OK = 4,    /*  good response */
+        BFA_FCS_ITNIM_SM_RSP_ERROR = 5, /*  error response */
+        BFA_FCS_ITNIM_SM_TIMEOUT = 6,   /*  delay timeout */
+        BFA_FCS_ITNIM_SM_HCB_OFFLINE = 7, /*  BFA online callback */
+        BFA_FCS_ITNIM_SM_HCB_ONLINE = 8, /*  BFA offline callback */
+        BFA_FCS_ITNIM_SM_INITIATOR = 9, /*  rport is initiator */
+        BFA_FCS_ITNIM_SM_DELETE = 10,   /*  delete event from rport */
+        BFA_FCS_ITNIM_SM_PRLO = 11,     /*  delete event from rport */
+        BFA_FCS_ITNIM_SM_RSP_NOT_SUPP = 12, /* cmd not supported rsp */
+        BFA_FCS_ITNIM_SM_HAL_ONLINE = 13, /*!< bfa rport online event */
 };
 
 /*
@@ -741,6 +778,7 @@ void bfa_fcs_update_cfg(struct bfa_fcs_s *fcs);
 void bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
                               struct bfa_fcs_driver_info_s *driver_info);
 void bfa_fcs_exit(struct bfa_fcs_s *fcs);
+void bfa_fcs_stop(struct bfa_fcs_s *fcs);
 
 /*
  * bfa fcs vf public functions
@@ -766,11 +804,13 @@ void bfa_fcs_fabric_modstart(struct bfa_fcs_s *fcs);
 void bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric,
                 struct fchs_s *fchs, u16 len);
 void    bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric);
+void    bfa_fcs_fabric_nsymb_init(struct bfa_fcs_fabric_s *fabric);
 void bfa_fcs_fabric_set_fabric_name(struct bfa_fcs_fabric_s *fabric,
                wwn_t fabric_name);
 u16 bfa_fcs_fabric_get_switch_oui(struct bfa_fcs_fabric_s *fabric);
 void bfa_fcs_uf_attach(struct bfa_fcs_s *fcs);
 void bfa_fcs_port_attach(struct bfa_fcs_s *fcs);
+void bfa_fcs_fabric_modstop(struct bfa_fcs_s *fcs);
 void bfa_fcs_fabric_sm_online(struct bfa_fcs_fabric_s *fabric,
                         enum bfa_fcs_fabric_event event);
 void bfa_fcs_fabric_sm_loopback(struct bfa_fcs_fabric_s *fabric,
diff --git a/drivers/scsi/bfa/bfa_fcs_fcpim.c b/drivers/scsi/bfa/bfa_fcs_fcpim.c
index 9272840a240..6dc7926a3ed 100644
--- a/drivers/scsi/bfa/bfa_fcs_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcs_fcpim.c
@@ -40,25 +40,6 @@ static void	bfa_fcs_itnim_prli_response(void *fcsarg,
 static void     bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
                         enum bfa_itnim_aen_event event);
 
-/*
- *  fcs_itnim_sm FCS itnim state machine events
- */
-
-enum bfa_fcs_itnim_event {
-        BFA_FCS_ITNIM_SM_ONLINE = 1,    /*  rport online event */
-        BFA_FCS_ITNIM_SM_OFFLINE = 2,   /*  rport offline */
-        BFA_FCS_ITNIM_SM_FRMSENT = 3,   /*  prli frame is sent */
-        BFA_FCS_ITNIM_SM_RSP_OK = 4,    /*  good response */
-        BFA_FCS_ITNIM_SM_RSP_ERROR = 5, /*  error response */
-        BFA_FCS_ITNIM_SM_TIMEOUT = 6,   /*  delay timeout */
-        BFA_FCS_ITNIM_SM_HCB_OFFLINE = 7, /*  BFA online callback */
-        BFA_FCS_ITNIM_SM_HCB_ONLINE = 8, /*  BFA offline callback */
-        BFA_FCS_ITNIM_SM_INITIATOR = 9, /*  rport is initiator */
-        BFA_FCS_ITNIM_SM_DELETE = 10,   /*  delete event from rport */
-        BFA_FCS_ITNIM_SM_PRLO = 11,     /*  delete event from rport */
-        BFA_FCS_ITNIM_SM_RSP_NOT_SUPP = 12, /* cmd not supported rsp */
-};
-
 static void     bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
                                          enum bfa_fcs_itnim_event event);
 static void     bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
@@ -69,6 +50,8 @@ static void	bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
                                             enum bfa_fcs_itnim_event event);
 static void     bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
                                             enum bfa_fcs_itnim_event event);
+static void     bfa_fcs_itnim_sm_hal_rport_online(struct bfa_fcs_itnim_s *itnim,
+                                        enum bfa_fcs_itnim_event event);
 static void     bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
                                         enum bfa_fcs_itnim_event event);
 static void     bfa_fcs_itnim_sm_hcb_offline(struct bfa_fcs_itnim_s *itnim,
@@ -99,7 +82,7 @@ bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
         bfa_trc(itnim->fcs, event);
 
         switch (event) {
-        case BFA_FCS_ITNIM_SM_ONLINE:
+        case BFA_FCS_ITNIM_SM_FCS_ONLINE:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_prli_send);
                 itnim->prli_retries = 0;
                 bfa_fcs_itnim_send_prli(itnim, NULL);
@@ -138,6 +121,7 @@ bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
         case BFA_FCS_ITNIM_SM_INITIATOR:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
                 bfa_fcxp_walloc_cancel(itnim->fcs->bfa, &itnim->fcxp_wqe);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_OFFLINE:
@@ -166,12 +150,13 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
 
         switch (event) {
         case BFA_FCS_ITNIM_SM_RSP_OK:
-                if (itnim->rport->scsi_function == BFA_RPORT_INITIATOR) {
+                if (itnim->rport->scsi_function == BFA_RPORT_INITIATOR)
                         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
-                } else {
-                        bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_online);
-                        bfa_itnim_online(itnim->bfa_itnim, itnim->seq_rec);
-                }
+                else
+                        bfa_sm_set_state(itnim,
+                                bfa_fcs_itnim_sm_hal_rport_online);
+
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_RSP_ERROR:
@@ -194,6 +179,7 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
         case BFA_FCS_ITNIM_SM_INITIATOR:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
                 bfa_fcxp_discard(itnim->fcxp);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -208,6 +194,44 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
 }
 
 static void
+bfa_fcs_itnim_sm_hal_rport_online(struct bfa_fcs_itnim_s *itnim,
+                                enum bfa_fcs_itnim_event event)
+{
+        bfa_trc(itnim->fcs, itnim->rport->pwwn);
+        bfa_trc(itnim->fcs, event);
+
+        switch (event) {
+        case BFA_FCS_ITNIM_SM_HAL_ONLINE:
+                if (!itnim->bfa_itnim)
+                        itnim->bfa_itnim = bfa_itnim_create(itnim->fcs->bfa,
+                                        itnim->rport->bfa_rport, itnim);
+
+                if (itnim->bfa_itnim) {
+                        bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_online);
+                        bfa_itnim_online(itnim->bfa_itnim, itnim->seq_rec);
+                } else {
+                        bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
+                        bfa_sm_send_event(itnim->rport, RPSM_EVENT_DELETE);
+                }
+
+                break;
+
+        case BFA_FCS_ITNIM_SM_OFFLINE:
+                bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
+                break;
+
+        case BFA_FCS_ITNIM_SM_DELETE:
+                bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
+                bfa_fcs_itnim_free(itnim);
+                break;
+
+        default:
+                bfa_sm_fault(itnim->fcs, event);
+        }
+}
+
+static void
 bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
                             enum bfa_fcs_itnim_event event)
 {
@@ -238,6 +262,7 @@ bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
         case BFA_FCS_ITNIM_SM_INITIATOR:
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
                 bfa_timer_stop(&itnim->timer);
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -275,9 +300,8 @@ bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         case BFA_FCS_ITNIM_SM_OFFLINE:
-                bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
+                bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_offline);
                 bfa_itnim_offline(itnim->bfa_itnim);
-                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -372,8 +396,14 @@ bfa_fcs_itnim_sm_initiator(struct bfa_fcs_itnim_s *itnim,
                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
                 break;
 
+        /*
+         * fcs_online is expected here for well known initiator ports
+         */
+        case BFA_FCS_ITNIM_SM_FCS_ONLINE:
+                bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
+                break;
+
         case BFA_FCS_ITNIM_SM_RSP_ERROR:
-        case BFA_FCS_ITNIM_SM_ONLINE:
         case BFA_FCS_ITNIM_SM_INITIATOR:
                 break;
 
@@ -426,11 +456,12 @@ bfa_fcs_itnim_send_prli(void *itnim_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 itnim->stats.fcxp_alloc_wait++;
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &itnim->fcxp_wqe,
-                                    bfa_fcs_itnim_send_prli, itnim);
+                                bfa_fcs_itnim_send_prli, itnim, BFA_TRUE);
                 return;
         }
         itnim->fcxp = fcxp;
@@ -483,7 +514,7 @@ bfa_fcs_itnim_prli_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
                         if (prli_resp->parampage.servparams.initiator) {
                                 bfa_trc(itnim->fcs, prli_resp->parampage.type);
                                 itnim->rport->scsi_function =
-                                         BFA_RPORT_INITIATOR;
+                                                BFA_RPORT_INITIATOR;
                                 itnim->stats.prli_rsp_acc++;
                                 itnim->stats.initiator++;
                                 bfa_sm_send_event(itnim,
@@ -531,7 +562,11 @@ bfa_fcs_itnim_timeout(void *arg)
 static void
 bfa_fcs_itnim_free(struct bfa_fcs_itnim_s *itnim)
 {
-        bfa_itnim_delete(itnim->bfa_itnim);
+        if (itnim->bfa_itnim) {
+                bfa_itnim_delete(itnim->bfa_itnim);
+                itnim->bfa_itnim = NULL;
+        }
+
         bfa_fcb_itnim_free(itnim->fcs->bfad, itnim->itnim_drv);
 }
 
@@ -552,7 +587,6 @@ bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport)
         struct bfa_fcs_lport_s *port = rport->port;
         struct bfa_fcs_itnim_s *itnim;
         struct bfad_itnim_s   *itnim_drv;
-        struct bfa_itnim_s *bfa_itnim;
 
         /*
          * call bfad to allocate the itnim
@@ -570,20 +604,7 @@ bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport)
         itnim->fcs = rport->fcs;
         itnim->itnim_drv = itnim_drv;
 
-        /*
-         * call BFA to create the itnim
-         */
-        bfa_itnim =
-                bfa_itnim_create(port->fcs->bfa, rport->bfa_rport, itnim);
-
-        if (bfa_itnim == NULL) {
-                bfa_trc(port->fcs, rport->pwwn);
-                bfa_fcb_itnim_free(port->fcs->bfad, itnim_drv);
-                WARN_ON(1);
-                return NULL;
-        }
-
-        itnim->bfa_itnim     = bfa_itnim;
+        itnim->bfa_itnim     = NULL;
         itnim->seq_rec       = BFA_FALSE;
         itnim->rec_support   = BFA_FALSE;
         itnim->conf_comp     = BFA_FALSE;
@@ -613,20 +634,12 @@ bfa_fcs_itnim_delete(struct bfa_fcs_itnim_s *itnim)
  * Notification from rport that PLOGI is complete to initiate FC-4 session.
  */
 void
-bfa_fcs_itnim_rport_online(struct bfa_fcs_itnim_s *itnim)
+bfa_fcs_itnim_brp_online(struct bfa_fcs_itnim_s *itnim)
 {
         itnim->stats.onlines++;
 
-        if (!BFA_FCS_PID_IS_WKA(itnim->rport->pid)) {
-                bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_ONLINE);
-        } else {
-                /*
-                 *  For well known addresses, we set the itnim to initiator
-                 *  state
-                 */
-                itnim->stats.initiator++;
-                bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_INITIATOR);
-        }
+        if (!BFA_FCS_PID_IS_WKA(itnim->rport->pid))
+                bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_HAL_ONLINE);
 }
 
 /*
diff --git a/drivers/scsi/bfa/bfa_fcs_lport.c b/drivers/scsi/bfa/bfa_fcs_lport.c
index bcc4966e8ba..3b75f6fb2de 100644
--- a/drivers/scsi/bfa/bfa_fcs_lport.c
+++ b/drivers/scsi/bfa/bfa_fcs_lport.c
@@ -131,6 +131,8 @@ bfa_fcs_lport_sm_init(struct bfa_fcs_lport_s *port,
                 /* If vport - send completion call back */
                 if (port->vport)
                         bfa_fcs_vport_stop_comp(port->vport);
+                else
+                        bfa_wc_down(&(port->fabric->stop_wc));
                 break;
 
         case BFA_FCS_PORT_SM_OFFLINE:
@@ -166,6 +168,8 @@ bfa_fcs_lport_sm_online(
                         /* If vport - send completion call back */
                         if (port->vport)
                                 bfa_fcs_vport_stop_comp(port->vport);
+                        else
+                                bfa_wc_down(&(port->fabric->stop_wc));
                 } else {
                         bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping);
                         list_for_each_safe(qe, qen, &port->rport_q) {
@@ -222,6 +226,8 @@ bfa_fcs_lport_sm_offline(
                         /* If vport - send completion call back */
                         if (port->vport)
                                 bfa_fcs_vport_stop_comp(port->vport);
+                        else
+                                bfa_wc_down(&(port->fabric->stop_wc));
                 } else {
                         bfa_sm_set_state(port, bfa_fcs_lport_sm_stopping);
                         list_for_each_safe(qe, qen, &port->rport_q) {
@@ -267,6 +273,8 @@ bfa_fcs_lport_sm_stopping(struct bfa_fcs_lport_s *port,
                         /* If vport - send completion call back */
                         if (port->vport)
                                 bfa_fcs_vport_stop_comp(port->vport);
+                        else
+                                bfa_wc_down(&(port->fabric->stop_wc));
                 }
                 break;
 
@@ -340,7 +348,7 @@ bfa_fcs_lport_send_ls_rjt(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
         bfa_trc(port->fcs, rx_fchs->d_id);
         bfa_trc(port->fcs, rx_fchs->s_id);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -370,7 +378,7 @@ bfa_fcs_lport_send_fcgs_rjt(struct bfa_fcs_lport_s *port,
         bfa_trc(port->fcs, rx_fchs->d_id);
         bfa_trc(port->fcs, rx_fchs->s_id);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -507,7 +515,7 @@ bfa_fcs_lport_echo(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
         bfa_trc(port->fcs, rx_fchs->s_id);
         bfa_trc(port->fcs, rx_fchs->d_id);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -552,7 +560,7 @@ bfa_fcs_lport_rnid(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs,
         bfa_trc(port->fcs, rx_fchs->d_id);
         bfa_trc(port->fcs, rx_len);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -684,7 +692,7 @@ bfa_fcs_lport_abts_acc(struct bfa_fcs_lport_s *port, struct fchs_s *rx_fchs)
         bfa_trc(port->fcs, rx_fchs->d_id);
         bfa_trc(port->fcs, rx_fchs->s_id);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -854,6 +862,25 @@ bfa_fcs_lport_get_rport_by_pid(struct bfa_fcs_lport_s *port, u32 pid)
 }
 
 /*
+ * OLD_PID based Lookup for a R-Port in the Port R-Port Queue
+ */
+struct bfa_fcs_rport_s *
+bfa_fcs_lport_get_rport_by_old_pid(struct bfa_fcs_lport_s *port, u32 pid)
+{
+        struct bfa_fcs_rport_s *rport;
+        struct list_head        *qe;
+
+        list_for_each(qe, &port->rport_q) {
+                rport = (struct bfa_fcs_rport_s *) qe;
+                if (rport->old_pid == pid)
+                        return rport;
+        }
+
+        bfa_trc(port->fcs, pid);
+        return NULL;
+}
+
+/*
  *   PWWN based Lookup for a R-Port in the Port R-Port Queue
  */
 struct bfa_fcs_rport_s *
@@ -892,6 +919,26 @@ bfa_fcs_lport_get_rport_by_nwwn(struct bfa_fcs_lport_s *port, wwn_t nwwn)
 }
 
 /*
+ * PWWN & PID based Lookup for a R-Port in the Port R-Port Queue
+ */
+struct bfa_fcs_rport_s *
+bfa_fcs_lport_get_rport_by_qualifier(struct bfa_fcs_lport_s *port,
+                                     wwn_t pwwn, u32 pid)
+{
+        struct bfa_fcs_rport_s *rport;
+        struct list_head        *qe;
+
+        list_for_each(qe, &port->rport_q) {
+                rport = (struct bfa_fcs_rport_s *) qe;
+                if (wwn_is_equal(rport->pwwn, pwwn) && rport->pid == pid)
+                        return rport;
+        }
+
+        bfa_trc(port->fcs, pwwn);
+        return NULL;
+}
+
+/*
  * Called by rport module when new rports are discovered.
  */
 void
@@ -939,6 +986,16 @@ bfa_fcs_lport_offline(struct bfa_fcs_lport_s *port)
 }
 
 /*
+ * Called by fabric for base port and by vport for virtual ports
+ * when target mode driver is unloaded.
+ */
+void
+bfa_fcs_lport_stop(struct bfa_fcs_lport_s *port)
+{
+        bfa_sm_send_event(port, BFA_FCS_PORT_SM_STOP);
+}
+
+/*
  * Called by fabric to delete base lport and associated resources.
  *
  * Called by vport to delete lport and associated resources. Should call
@@ -1657,10 +1714,11 @@ bfa_fcs_lport_fdmi_send_rhba(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->port_cfg.pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
-                                        bfa_fcs_lport_fdmi_send_rhba, fdmi);
+                                bfa_fcs_lport_fdmi_send_rhba, fdmi, BFA_TRUE);
                 return;
         }
         fdmi->fcxp = fcxp;
@@ -1931,10 +1989,11 @@ bfa_fcs_lport_fdmi_send_rprt(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->port_cfg.pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
-                                        bfa_fcs_lport_fdmi_send_rprt, fdmi);
+                                bfa_fcs_lport_fdmi_send_rprt, fdmi, BFA_TRUE);
                 return;
         }
         fdmi->fcxp = fcxp;
@@ -2146,10 +2205,11 @@ bfa_fcs_lport_fdmi_send_rpa(void *fdmi_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->port_cfg.pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &fdmi->fcxp_wqe,
-                                        bfa_fcs_lport_fdmi_send_rpa, fdmi);
+                                bfa_fcs_lport_fdmi_send_rpa, fdmi, BFA_TRUE);
                 return;
         }
         fdmi->fcxp = fcxp;
@@ -2736,10 +2796,11 @@ bfa_fcs_lport_ms_send_gmal(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->pid);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
-                                        bfa_fcs_lport_ms_send_gmal, ms);
+                                bfa_fcs_lport_ms_send_gmal, ms, BFA_TRUE);
                 return;
         }
         ms->fcxp = fcxp;
@@ -2936,10 +2997,11 @@ bfa_fcs_lport_ms_send_gfn(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->pid);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
-                                        bfa_fcs_lport_ms_send_gfn, ms);
+                                bfa_fcs_lport_ms_send_gfn, ms, BFA_TRUE);
                 return;
         }
         ms->fcxp = fcxp;
@@ -3012,11 +3074,12 @@ bfa_fcs_lport_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->pid);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 port->stats.ms_plogi_alloc_wait++;
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ms->fcxp_wqe,
-                                        bfa_fcs_lport_ms_send_plogi, ms);
+                                bfa_fcs_lport_ms_send_plogi, ms, BFA_TRUE);
                 return;
         }
         ms->fcxp = fcxp;
@@ -3166,6 +3229,10 @@ static void     bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg,
                                             struct bfa_fcxp_s *fcxp_alloced);
 static void     bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg,
                                             struct bfa_fcxp_s *fcxp_alloced);
+static void     bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg,
+                                        struct bfa_fcxp_s *fcxp_alloced);
+static void     bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg,
+                                        struct bfa_fcxp_s *fcxp_alloced);
 static void     bfa_fcs_lport_ns_timeout(void *arg);
 static void     bfa_fcs_lport_ns_plogi_response(void *fcsarg,
                                                struct bfa_fcxp_s *fcxp,
@@ -3202,6 +3269,20 @@ static void     bfa_fcs_lport_ns_gid_ft_response(void *fcsarg,
                                                 u32 rsp_len,
                                                 u32 resid_len,
                                                 struct fchs_s *rsp_fchs);
+static void     bfa_fcs_lport_ns_rnn_id_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_lport_ns_rsnn_nn_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_lport_ns_process_gidft_pids(
                                 struct bfa_fcs_lport_s *port,
                                 u32 *pid_buf, u32 n_pids);
@@ -3226,6 +3307,8 @@ enum vport_ns_event {
         NSSM_EVENT_RFTID_SENT = 9,
         NSSM_EVENT_RFFID_SENT = 10,
         NSSM_EVENT_GIDFT_SENT = 11,
+        NSSM_EVENT_RNNID_SENT = 12,
+        NSSM_EVENT_RSNN_NN_SENT = 13,
 };
 
 static void     bfa_fcs_lport_ns_sm_offline(struct bfa_fcs_lport_ns_s *ns,
@@ -3266,6 +3349,21 @@ static void     bfa_fcs_lport_ns_sm_gid_ft_retry(struct bfa_fcs_lport_ns_s *ns,
                                                 enum vport_ns_event event);
 static void     bfa_fcs_lport_ns_sm_online(struct bfa_fcs_lport_ns_s *ns,
                                           enum vport_ns_event event);
+static void     bfa_fcs_lport_ns_sm_sending_rnn_id(
+                                        struct bfa_fcs_lport_ns_s *ns,
+                                        enum vport_ns_event event);
+static void     bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns,
+                                        enum vport_ns_event event);
+static void     bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns,
+                                                enum vport_ns_event event);
+static void     bfa_fcs_lport_ns_sm_sending_rsnn_nn(
+                                        struct bfa_fcs_lport_ns_s *ns,
+                                        enum vport_ns_event event);
+static void     bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
+                                                enum vport_ns_event event);
+static void     bfa_fcs_lport_ns_sm_rsnn_nn_retry(
+                                        struct bfa_fcs_lport_ns_s *ns,
+                                        enum vport_ns_event event);
 /*
  *      Start in offline state - awaiting linkup
  */
@@ -3333,8 +3431,9 @@ bfa_fcs_lport_ns_sm_plogi(struct bfa_fcs_lport_ns_s *ns,
                 break;
 
         case NSSM_EVENT_RSP_OK:
-                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
-                bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id);
+                ns->num_rnnid_retries = 0;
+                bfa_fcs_lport_ns_send_rnn_id(ns, NULL);
                 break;
 
         case NSSM_EVENT_PORT_OFFLINE:
@@ -3374,6 +3473,176 @@ bfa_fcs_lport_ns_sm_plogi_retry(struct bfa_fcs_lport_ns_s *ns,
 }
 
 static void
+bfa_fcs_lport_ns_sm_sending_rnn_id(struct bfa_fcs_lport_ns_s *ns,
+                                        enum vport_ns_event event)
+{
+        bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
+        bfa_trc(ns->port->fcs, event);
+
+        switch (event) {
+        case NSSM_EVENT_RNNID_SENT:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id);
+                break;
+
+        case NSSM_EVENT_PORT_OFFLINE:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
+                bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
+                                                &ns->fcxp_wqe);
+                break;
+        default:
+                bfa_sm_fault(ns->port->fcs, event);
+        }
+}
+
+static void
+bfa_fcs_lport_ns_sm_rnn_id(struct bfa_fcs_lport_ns_s *ns,
+                                enum vport_ns_event event)
+{
+        bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
+        bfa_trc(ns->port->fcs, event);
+
+        switch (event) {
+        case NSSM_EVENT_RSP_OK:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn);
+                ns->num_rnnid_retries = 0;
+                ns->num_rsnn_nn_retries = 0;
+                bfa_fcs_lport_ns_send_rsnn_nn(ns, NULL);
+                break;
+
+        case NSSM_EVENT_RSP_ERROR:
+                if (ns->num_rnnid_retries < BFA_FCS_MAX_NS_RETRIES) {
+                        bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rnn_id_retry);
+                        ns->port->stats.ns_retries++;
+                        ns->num_rnnid_retries++;
+                        bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
+                                &ns->timer, bfa_fcs_lport_ns_timeout, ns,
+                                BFA_FCS_RETRY_TIMEOUT);
+                } else {
+                        bfa_sm_set_state(ns,
+                                bfa_fcs_lport_ns_sm_sending_rspn_id);
+                        bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
+                }
+                break;
+
+        case NSSM_EVENT_PORT_OFFLINE:
+                bfa_fcxp_discard(ns->fcxp);
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
+                break;
+
+        default:
+                bfa_sm_fault(ns->port->fcs, event);
+        }
+}
+
+static void
+bfa_fcs_lport_ns_sm_rnn_id_retry(struct bfa_fcs_lport_ns_s *ns,
+                                enum vport_ns_event event)
+{
+        bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
+        bfa_trc(ns->port->fcs, event);
+
+        switch (event) {
+        case NSSM_EVENT_TIMEOUT:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rnn_id);
+                bfa_fcs_lport_ns_send_rnn_id(ns, NULL);
+                break;
+
+        case NSSM_EVENT_PORT_OFFLINE:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
+                bfa_timer_stop(&ns->timer);
+                break;
+
+        default:
+                bfa_sm_fault(ns->port->fcs, event);
+        }
+}
+
+static void
+bfa_fcs_lport_ns_sm_sending_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
+                                        enum vport_ns_event event)
+{
+        bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
+        bfa_trc(ns->port->fcs, event);
+
+        switch (event) {
+        case NSSM_EVENT_RSNN_NN_SENT:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn);
+                break;
+
+        case NSSM_EVENT_PORT_OFFLINE:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
+                bfa_fcxp_walloc_cancel(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
+                        &ns->fcxp_wqe);
+                break;
+
+        default:
+                bfa_sm_fault(ns->port->fcs, event);
+        }
+}
+
+static void
+bfa_fcs_lport_ns_sm_rsnn_nn(struct bfa_fcs_lport_ns_s *ns,
+                                enum vport_ns_event event)
+{
+        bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
+        bfa_trc(ns->port->fcs, event);
+
+        switch (event) {
+        case NSSM_EVENT_RSP_OK:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rspn_id);
+                ns->num_rsnn_nn_retries = 0;
+                bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
+                break;
+
+        case NSSM_EVENT_RSP_ERROR:
+                if (ns->num_rsnn_nn_retries < BFA_FCS_MAX_NS_RETRIES) {
+                        bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_rsnn_nn_retry);
+                        ns->port->stats.ns_retries++;
+                        ns->num_rsnn_nn_retries++;
+                        bfa_timer_start(BFA_FCS_GET_HAL_FROM_PORT(ns->port),
+                                        &ns->timer, bfa_fcs_lport_ns_timeout,
+                                        ns, BFA_FCS_RETRY_TIMEOUT);
+                } else {
+                        bfa_sm_set_state(ns,
+                                bfa_fcs_lport_ns_sm_sending_rspn_id);
+                        bfa_fcs_lport_ns_send_rspn_id(ns, NULL);
+                }
+                break;
+
+        case NSSM_EVENT_PORT_OFFLINE:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
+                bfa_fcxp_discard(ns->fcxp);
+                break;
+
+        default:
+                bfa_sm_fault(ns->port->fcs, event);
+        }
+}
+
+static void
+bfa_fcs_lport_ns_sm_rsnn_nn_retry(struct bfa_fcs_lport_ns_s *ns,
+                                        enum vport_ns_event event)
+{
+        bfa_trc(ns->port->fcs, ns->port->port_cfg.pwwn);
+        bfa_trc(ns->port->fcs, event);
+
+        switch (event) {
+        case NSSM_EVENT_TIMEOUT:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_sending_rsnn_nn);
+                bfa_fcs_lport_ns_send_rsnn_nn(ns, NULL);
+                break;
+
+        case NSSM_EVENT_PORT_OFFLINE:
+                bfa_sm_set_state(ns, bfa_fcs_lport_ns_sm_offline);
+                bfa_timer_stop(&ns->timer);
+                break;
+
+        default:
+                bfa_sm_fault(ns->port->fcs, event);
+        }
+}
+
+static void
 bfa_fcs_lport_ns_sm_sending_rspn_id(struct bfa_fcs_lport_ns_s *ns,
                                    enum vport_ns_event event)
 {
@@ -3770,11 +4039,12 @@ bfa_fcs_lport_ns_send_plogi(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->pid);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 port->stats.ns_plogi_alloc_wait++;
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
-                                        bfa_fcs_lport_ns_send_plogi, ns);
+                                bfa_fcs_lport_ns_send_plogi, ns, BFA_TRUE);
                 return;
         }
         ns->fcxp = fcxp;
@@ -3853,6 +4123,162 @@ bfa_fcs_lport_ns_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
 }
 
 /*
+ * Register node name for port_id
+ */
+static void
+bfa_fcs_lport_ns_send_rnn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
+{
+        struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
+        struct bfa_fcs_lport_s *port = ns->port;
+        struct fchs_s  fchs;
+        int     len;
+        struct bfa_fcxp_s *fcxp;
+
+        bfa_trc(port->fcs, port->port_cfg.pwwn);
+
+        fcxp = fcxp_alloced ? fcxp_alloced :
+                        bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
+        if (!fcxp) {
+                port->stats.ns_rnnid_alloc_wait++;
+                bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
+                                bfa_fcs_lport_ns_send_rnn_id, ns, BFA_TRUE);
+                return;
+        }
+
+        ns->fcxp = fcxp;
+
+        len = fc_rnnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
+                                bfa_fcs_lport_get_fcid(port),
+                                bfa_fcs_lport_get_fcid(port),
+                                bfa_fcs_lport_get_nwwn(port));
+
+        bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
+                          FC_CLASS_3, len, &fchs,
+                          bfa_fcs_lport_ns_rnn_id_response, (void *)ns,
+                          FC_MAX_PDUSZ, FC_FCCT_TOV);
+
+        port->stats.ns_rnnid_sent++;
+        bfa_sm_send_event(ns, NSSM_EVENT_RNNID_SENT);
+}
+
+static void
+bfa_fcs_lport_ns_rnn_id_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_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
+        struct bfa_fcs_lport_s *port = ns->port;
+        struct ct_hdr_s *cthdr = NULL;
+
+        bfa_trc(port->fcs, port->port_cfg.pwwn);
+
+        /*
+         * Sanity Checks
+         */
+        if (req_status != BFA_STATUS_OK) {
+                bfa_trc(port->fcs, req_status);
+                port->stats.ns_rnnid_rsp_err++;
+                bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
+                return;
+        }
+
+        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) {
+                port->stats.ns_rnnid_accepts++;
+                bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
+                return;
+        }
+
+        port->stats.ns_rnnid_rejects++;
+        bfa_trc(port->fcs, cthdr->reason_code);
+        bfa_trc(port->fcs, cthdr->exp_code);
+        bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
+}
+
+/*
+ * Register the symbolic node name for a given node name.
+ */
+static void
+bfa_fcs_lport_ns_send_rsnn_nn(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
+{
+        struct bfa_fcs_lport_ns_s *ns = ns_cbarg;
+        struct bfa_fcs_lport_s *port = ns->port;
+        struct fchs_s  fchs;
+        int     len;
+        struct bfa_fcxp_s *fcxp;
+        u8 *nsymbl;
+
+        bfa_trc(port->fcs, port->port_cfg.pwwn);
+
+        fcxp = fcxp_alloced ? fcxp_alloced :
+                        bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
+        if (!fcxp) {
+                port->stats.ns_rsnn_nn_alloc_wait++;
+                bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
+                                bfa_fcs_lport_ns_send_rsnn_nn, ns, BFA_TRUE);
+                return;
+        }
+        ns->fcxp = fcxp;
+
+        nsymbl = (u8 *) &(bfa_fcs_lport_get_nsym_name(
+                                        bfa_fcs_get_base_port(port->fcs)));
+
+        len = fc_rsnn_nn_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
+                                bfa_fcs_lport_get_fcid(port),
+                                bfa_fcs_lport_get_nwwn(port), nsymbl);
+
+        bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
+                          FC_CLASS_3, len, &fchs,
+                          bfa_fcs_lport_ns_rsnn_nn_response, (void *)ns,
+                          FC_MAX_PDUSZ, FC_FCCT_TOV);
+
+        port->stats.ns_rsnn_nn_sent++;
+
+        bfa_sm_send_event(ns, NSSM_EVENT_RSNN_NN_SENT);
+}
+
+static void
+bfa_fcs_lport_ns_rsnn_nn_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_lport_ns_s *ns = (struct bfa_fcs_lport_ns_s *) cbarg;
+        struct bfa_fcs_lport_s *port = ns->port;
+        struct ct_hdr_s *cthdr = NULL;
+
+        bfa_trc(port->fcs, port->port_cfg.pwwn);
+
+        /*
+         * Sanity Checks
+         */
+        if (req_status != BFA_STATUS_OK) {
+                bfa_trc(port->fcs, req_status);
+                port->stats.ns_rsnn_nn_rsp_err++;
+                bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
+                return;
+        }
+
+        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) {
+                port->stats.ns_rsnn_nn_accepts++;
+                bfa_sm_send_event(ns, NSSM_EVENT_RSP_OK);
+                return;
+        }
+
+        port->stats.ns_rsnn_nn_rejects++;
+        bfa_trc(port->fcs, cthdr->reason_code);
+        bfa_trc(port->fcs, cthdr->exp_code);
+        bfa_sm_send_event(ns, NSSM_EVENT_RSP_ERROR);
+}
+
+/*
  * Register the symbolic port name.
  */
 static void
@@ -3870,11 +4296,12 @@ bfa_fcs_lport_ns_send_rspn_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->port_cfg.pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 port->stats.ns_rspnid_alloc_wait++;
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
-                                        bfa_fcs_lport_ns_send_rspn_id, ns);
+                                bfa_fcs_lport_ns_send_rspn_id, ns, BFA_TRUE);
                 return;
         }
         ns->fcxp = fcxp;
@@ -3971,11 +4398,12 @@ bfa_fcs_lport_ns_send_rft_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->port_cfg.pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 port->stats.ns_rftid_alloc_wait++;
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
-                                        bfa_fcs_lport_ns_send_rft_id, ns);
+                                bfa_fcs_lport_ns_send_rft_id, ns, BFA_TRUE);
                 return;
         }
         ns->fcxp = fcxp;
@@ -4044,11 +4472,12 @@ bfa_fcs_lport_ns_send_rff_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->port_cfg.pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 port->stats.ns_rffid_alloc_wait++;
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
-                                        bfa_fcs_lport_ns_send_rff_id, ns);
+                                bfa_fcs_lport_ns_send_rff_id, ns, BFA_TRUE);
                 return;
         }
         ns->fcxp = fcxp;
@@ -4127,11 +4556,12 @@ bfa_fcs_lport_ns_send_gid_ft(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(port->fcs, port->pid);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 port->stats.ns_gidft_alloc_wait++;
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
-                                        bfa_fcs_lport_ns_send_gid_ft, ns);
+                                bfa_fcs_lport_ns_send_gid_ft, ns, BFA_TRUE);
                 return;
         }
         ns->fcxp = fcxp;
@@ -4261,6 +4691,10 @@ bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s *port, u32 *pid_buf,
         struct fcgs_gidft_resp_s *gidft_entry;
         struct bfa_fcs_rport_s *rport;
         u32        ii;
+        struct bfa_fcs_fabric_s *fabric = port->fabric;
+        struct bfa_fcs_vport_s *vport;
+        struct list_head *qe;
+        u8 found = 0;
 
         for (ii = 0; ii < n_pids; ii++) {
                 gidft_entry = (struct fcgs_gidft_resp_s *) &pid_buf[ii];
@@ -4269,6 +4703,29 @@ bfa_fcs_lport_ns_process_gidft_pids(struct bfa_fcs_lport_s *port, u32 *pid_buf,
                         continue;
 
                 /*
+                 * Ignore PID if it is of base port
+                 * (Avoid vports discovering base port as remote port)
+                 */
+                if (gidft_entry->pid == fabric->bport.pid)
+                        continue;
+
+                /*
+                 * Ignore PID if it is of vport created on the same base port
+                 * (Avoid vport discovering every other vport created on the
+                 * same port as remote port)
+                 */
+                list_for_each(qe, &fabric->vport_q) {
+                        vport = (struct bfa_fcs_vport_s *) qe;
+                        if (vport->lport.pid == gidft_entry->pid)
+                                found = 1;
+                }
+
+                if (found) {
+                        found = 0;
+                        continue;
+                }
+
+                /*
                  * Check if this rport already exists
                  */
                 rport = bfa_fcs_lport_get_rport_by_pid(port, gidft_entry->pid);
@@ -4335,7 +4792,8 @@ bfa_fcs_lport_ns_query(struct bfa_fcs_lport_s *port)
         struct bfa_fcs_lport_ns_s *ns = BFA_FCS_GET_NS_FROM_PORT(port);
 
         bfa_trc(port->fcs, port->pid);
-        bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY);
+        if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_online))
+                bfa_sm_send_event(ns, NSSM_EVENT_NS_QUERY);
 }
 
 static void
@@ -4355,6 +4813,70 @@ bfa_fcs_lport_ns_boot_target_disc(bfa_fcs_lport_t *port)
         }
 }
 
+void
+bfa_fcs_lport_ns_util_send_rspn_id(void *cbarg, struct bfa_fcxp_s *fcxp_alloced)
+{
+        struct bfa_fcs_lport_ns_s *ns = cbarg;
+        struct bfa_fcs_lport_s *port = ns->port;
+        struct fchs_s fchs;
+        struct bfa_fcxp_s *fcxp;
+        u8 symbl[256];
+        u8 *psymbl = &symbl[0];
+        int len;
+
+        if (!bfa_sm_cmp_state(port, bfa_fcs_lport_sm_online))
+                return;
+
+        /* Avoid sending RSPN in the following states. */
+        if (bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_offline) ||
+            bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_sending) ||
+            bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi) ||
+            bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_plogi_retry) ||
+            bfa_sm_cmp_state(ns, bfa_fcs_lport_ns_sm_rspn_id_retry))
+                return;
+
+        memset(symbl, 0, sizeof(symbl));
+        bfa_trc(port->fcs, port->port_cfg.pwwn);
+
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
+        if (!fcxp) {
+                port->stats.ns_rspnid_alloc_wait++;
+                bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &ns->fcxp_wqe,
+                        bfa_fcs_lport_ns_util_send_rspn_id, ns, BFA_FALSE);
+                return;
+        }
+
+        ns->fcxp = fcxp;
+
+        if (port->vport) {
+                /*
+                 * For Vports, we append the vport's port symbolic name
+                 * to that of the base port.
+                 */
+                strncpy((char *)psymbl, (char *)&(bfa_fcs_lport_get_psym_name
+                        (bfa_fcs_get_base_port(port->fcs))),
+                        strlen((char *)&bfa_fcs_lport_get_psym_name(
+                        bfa_fcs_get_base_port(port->fcs))));
+
+                /* Ensure we have a null terminating string. */
+                ((char *)psymbl)[strlen((char *)&bfa_fcs_lport_get_psym_name(
+                 bfa_fcs_get_base_port(port->fcs)))] = 0;
+
+                strncat((char *)psymbl,
+                        (char *)&(bfa_fcs_lport_get_psym_name(port)),
+                        strlen((char *)&bfa_fcs_lport_get_psym_name(port)));
+        }
+
+        len = fc_rspnid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
+                              bfa_fcs_lport_get_fcid(port), 0, psymbl);
+
+        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);
+
+        port->stats.ns_rspnid_sent++;
+}
+
 /*
  * FCS SCN
  */
@@ -4529,10 +5051,11 @@ bfa_fcs_lport_scn_send_scr(void *scn_cbarg, struct bfa_fcxp_s *fcxp_alloced)
         bfa_trc(port->fcs, port->pid);
         bfa_trc(port->fcs, port->port_cfg.pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &scn->fcxp_wqe,
-                                        bfa_fcs_lport_scn_send_scr, scn);
+                                bfa_fcs_lport_scn_send_scr, scn, BFA_TRUE);
                 return;
         }
         scn->fcxp = fcxp;
@@ -4614,7 +5137,7 @@ bfa_fcs_lport_scn_send_ls_acc(struct bfa_fcs_lport_s *port,
 
         bfa_trc(port->fcs, rx_fchs->s_id);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -4688,14 +5211,33 @@ static void
 bfa_fcs_lport_scn_portid_rscn(struct bfa_fcs_lport_s *port, u32 rpid)
 {
         struct bfa_fcs_rport_s *rport;
+        struct bfa_fcs_fabric_s *fabric = port->fabric;
+        struct bfa_fcs_vport_s *vport;
+        struct list_head *qe;
 
         bfa_trc(port->fcs, rpid);
 
         /*
+         * Ignore PID if it is of base port or of vports created on the
+         * same base port. It is to avoid vports discovering base port or
+         * other vports created on same base port as remote port
+         */
+        if (rpid == fabric->bport.pid)
+                return;
+
+        list_for_each(qe, &fabric->vport_q) {
+                vport = (struct bfa_fcs_vport_s *) qe;
+                if (vport->lport.pid == rpid)
+                        return;
+        }
+        /*
          * If this is an unknown device, then it just came online.
          * Otherwise let rport handle the RSCN event.
          */
         rport = bfa_fcs_lport_get_rport_by_pid(port, rpid);
+        if (!rport)
+                rport = bfa_fcs_lport_get_rport_by_old_pid(port, rpid);
+
         if (rport == NULL) {
                 /*
                  * If min cfg mode is enabled, we donot need to
@@ -4888,15 +5430,15 @@ bfa_fcs_lport_get_rport(struct bfa_fcs_lport_s *port, wwn_t wwn, int index,
 }
 
 void
-bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s *port,
-         wwn_t rport_wwns[], int *nrports)
+bfa_fcs_lport_get_rport_quals(struct bfa_fcs_lport_s *port,
+                struct bfa_rport_qualifier_s rports[], int *nrports)
 {
         struct list_head        *qh, *qe;
         struct bfa_fcs_rport_s *rport = NULL;
         int     i;
         struct bfa_fcs_s        *fcs;
 
-        if (port == NULL || rport_wwns == NULL || *nrports == 0)
+        if (port == NULL || rports == NULL || *nrports == 0)
                 return;
 
         fcs = port->fcs;
@@ -4916,7 +5458,13 @@ bfa_fcs_lport_get_rports(struct bfa_fcs_lport_s *port,
                         continue;
                 }
 
-                rport_wwns[i] = rport->pwwn;
+                if (!rport->pwwn && !rport->pid) {
+                        qe = bfa_q_next(qe);
+                        continue;
+                }
+
+                rports[i].pwwn = rport->pwwn;
+                rports[i].pid = rport->pid;
 
                 i++;
                 qe = bfa_q_next(qe);
@@ -5760,6 +6308,16 @@ bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s *vport)
 {
         vport->vport_stats.fab_cleanup++;
 }
+
+/*
+ * Stop notification from fabric SM. To be invoked from within FCS.
+ */
+void
+bfa_fcs_vport_fcs_stop(struct bfa_fcs_vport_s *vport)
+{
+        bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_STOP);
+}
+
 /*
  * delete notification from fabric SM. To be invoked from within FCS.
  */
diff --git a/drivers/scsi/bfa/bfa_fcs_rport.c b/drivers/scsi/bfa/bfa_fcs_rport.c
index fe0463a1db0..cc43b2a58ce 100644
--- a/drivers/scsi/bfa/bfa_fcs_rport.c
+++ b/drivers/scsi/bfa/bfa_fcs_rport.c
@@ -30,14 +30,22 @@ static u32
 bfa_fcs_rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT * 1000;
          /* In millisecs */
 /*
+ * bfa_fcs_rport_max_logins is max count of bfa_fcs_rports
+ * whereas DEF_CFG_NUM_RPORTS is max count of bfa_rports
+ */
+static u32 bfa_fcs_rport_max_logins = BFA_FCS_MAX_RPORT_LOGINS;
+
+/*
  * 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_fcs_online_action(struct bfa_fcs_rport_s *rport);
+static void     bfa_fcs_rport_hal_online_action(struct bfa_fcs_rport_s *rport);
+static void     bfa_fcs_rport_fcs_offline_action(struct bfa_fcs_rport_s *rport);
+static void     bfa_fcs_rport_hal_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);
@@ -76,6 +84,7 @@ static void	bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport,
 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_hal_offline(struct bfa_fcs_rport_s *rport);
 
 static void     bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport,
                                         enum rport_event event);
@@ -87,6 +96,8 @@ 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_fc4_fcs_online(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,
@@ -123,6 +134,10 @@ 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 void     bfa_fcs_rport_sm_fc4_off_delete(struct bfa_fcs_rport_s *rport,
+                                                enum rport_event event);
+static void     bfa_fcs_rport_sm_delete_pending(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},
@@ -130,6 +145,7 @@ static struct bfa_sm_table_s rport_sm_table[] = {
         {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_fc4_fcs_online), BFA_RPORT_ONLINE},
         {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},
@@ -167,8 +183,8 @@ bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         case RPSM_EVENT_PLOGI_RCVD:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_plogiacc_sending);
-                bfa_fcs_rport_send_plogiacc(rport, NULL);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
@@ -252,8 +268,8 @@ bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,
 
         switch (event) {
         case RPSM_EVENT_FCXP_SENT:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
-                bfa_fcs_rport_hal_online(rport);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         case RPSM_EVENT_DELETE:
@@ -348,9 +364,9 @@ bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
                 bfa_timer_stop(&rport->timer);
-                bfa_fcs_rport_hal_online(rport);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         default:
@@ -370,9 +386,9 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
 
         switch (event) {
         case RPSM_EVENT_ACCEPTED:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
                 rport->plogi_retries = 0;
-                bfa_fcs_rport_hal_online(rport);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         case RPSM_EVENT_LOGO_RCVD:
@@ -397,6 +413,7 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
                                         BFA_FCS_RETRY_TIMEOUT);
                 } else {
                         bfa_stats(rport->port, rport_del_max_plogi_retry);
+                        rport->old_pid = rport->pid;
                         rport->pid = 0;
                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
                         bfa_timer_start(rport->fcs->bfa, &rport->timer,
@@ -443,13 +460,77 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
                 bfa_fcxp_discard(rport->fcxp);
-                bfa_fcs_rport_hal_online(rport);
+                bfa_fcs_rport_fcs_online_action(rport);
+                break;
+
+        default:
+                bfa_sm_fault(rport->fcs, event);
+        }
+}
+
+/*
+ * PLOGI is done. Await bfa_fcs_itnim to ascertain the scsi function
+ */
+static void
+bfa_fcs_rport_sm_fc4_fcs_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_FC4_FCS_ONLINE:
+                if (rport->scsi_function == BFA_RPORT_INITIATOR) {
+                        if (!BFA_FCS_PID_IS_WKA(rport->pid))
+                                bfa_fcs_rpf_rport_online(rport);
+                        bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
+                        break;
+                }
+
+                if (!rport->bfa_rport)
+                        rport->bfa_rport =
+                                bfa_rport_create(rport->fcs->bfa, rport);
+
+                if (rport->bfa_rport) {
+                        bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                        bfa_fcs_rport_hal_online(rport);
+                } else {
+                        bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
+                        bfa_fcs_rport_fcs_offline_action(rport);
+                }
+                break;
+
+        case RPSM_EVENT_PLOGI_RCVD:
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
+                rport->plogi_pending = BFA_TRUE;
+                bfa_fcs_rport_fcs_offline_action(rport);
+                break;
+
+        case RPSM_EVENT_PLOGI_COMP:
+        case RPSM_EVENT_LOGO_IMP:
+        case RPSM_EVENT_ADDRESS_CHANGE:
+        case RPSM_EVENT_SCN:
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
+                bfa_fcs_rport_fcs_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_fcs_offline_action(rport);
+                break;
+
+        case RPSM_EVENT_DELETE:
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
+                bfa_fcs_rport_fcs_offline_action(rport);
                 break;
 
         default:
                 bfa_sm_fault(rport->fcs, event);
+                break;
         }
 }
 
@@ -468,41 +549,34 @@ bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
         switch (event) {
         case RPSM_EVENT_HCB_ONLINE:
                 bfa_sm_set_state(rport, bfa_fcs_rport_sm_online);
-                bfa_fcs_rport_online_action(rport);
+                bfa_fcs_rport_hal_online_action(rport);
                 break;
 
-        case RPSM_EVENT_PRLO_RCVD:
         case RPSM_EVENT_PLOGI_COMP:
                 break;
 
+        case RPSM_EVENT_PRLO_RCVD:
         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);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logorcv);
+                bfa_fcs_rport_fcs_offline_action(rport);
                 break;
 
+        case RPSM_EVENT_SCN:
         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);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
+                bfa_fcs_rport_fcs_offline_action(rport);
                 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);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_offline);
+                bfa_fcs_rport_fcs_offline_action(rport);
                 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.
-                 */
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
+                bfa_fcs_rport_fcs_offline_action(rport);
                 break;
 
         default:
@@ -537,18 +611,18 @@ bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport, enum rport_event event)
         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);
+                bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
@@ -579,7 +653,7 @@ bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
         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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         case RPSM_EVENT_SCN:
@@ -592,24 +666,16 @@ bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
         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);
+                bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         default:
@@ -642,14 +708,14 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
                         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);
+                        bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         case RPSM_EVENT_SCN:
@@ -659,7 +725,7 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
         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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
@@ -668,7 +734,7 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
         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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         default:
@@ -696,21 +762,21 @@ bfa_fcs_rport_sm_adisc_sending(struct bfa_fcs_rport_s *rport,
         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);
+                bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         case RPSM_EVENT_SCN:
@@ -719,7 +785,7 @@ bfa_fcs_rport_sm_adisc_sending(struct bfa_fcs_rport_s *rport,
         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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         default:
@@ -756,13 +822,13 @@ bfa_fcs_rport_sm_adisc(struct bfa_fcs_rport_s *rport, enum rport_event event)
         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);
+                bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         case RPSM_EVENT_SCN:
@@ -774,14 +840,14 @@ bfa_fcs_rport_sm_adisc(struct bfa_fcs_rport_s *rport, enum rport_event event)
         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);
+                bfa_fcs_rport_hal_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);
+                bfa_fcs_rport_hal_offline_action(rport);
                 break;
 
         default:
@@ -803,13 +869,19 @@ bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
         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);
+                bfa_fcs_rport_hal_offline(rport);
                 break;
 
         case RPSM_EVENT_DELETE:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_logosend);
+                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);
+
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_off_delete);
                 break;
 
+        case RPSM_EVENT_HCB_ONLINE:
         case RPSM_EVENT_LOGO_RCVD:
         case RPSM_EVENT_PRLO_RCVD:
         case RPSM_EVENT_ADDRESS_CHANGE:
@@ -835,7 +907,20 @@ bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,
         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);
+                bfa_fcs_rport_hal_offline(rport);
+                break;
+
+        case RPSM_EVENT_LOGO_RCVD:
+                bfa_fcs_rport_send_logo_acc(rport);
+        case RPSM_EVENT_PRLO_RCVD:
+                if (rport->prlo == BFA_TRUE)
+                        bfa_fcs_rport_send_prlo_acc(rport);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_off_delete);
+                break;
+
+        case RPSM_EVENT_HCB_ONLINE:
+        case RPSM_EVENT_DELETE:
+                /* Rport is being deleted */
                 break;
 
         default:
@@ -857,13 +942,23 @@ bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
         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);
+                bfa_fcs_rport_hal_offline(rport);
                 break;
 
-        case RPSM_EVENT_SCN:
-        case RPSM_EVENT_LOGO_IMP:
         case RPSM_EVENT_LOGO_RCVD:
+                /*
+                 * Rport is going offline. Just ack the logo
+                 */
+                bfa_fcs_rport_send_logo_acc(rport);
+                break;
+
         case RPSM_EVENT_PRLO_RCVD:
+                bfa_fcs_rport_send_prlo_acc(rport);
+                break;
+
+        case RPSM_EVENT_HCB_ONLINE:
+        case RPSM_EVENT_SCN:
+        case RPSM_EVENT_LOGO_IMP:
         case RPSM_EVENT_ADDRESS_CHANGE:
                 /*
                  * rport is already going offline.
@@ -907,24 +1002,23 @@ bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
                  */
 
         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 {
+                if (!bfa_fcs_lport_is_online(rport->port)) {
                         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;
+                }
+                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);
                 }
                 break;
 
@@ -1001,7 +1095,11 @@ bfa_fcs_rport_sm_hcb_logorcv(struct bfa_fcs_rport_s *rport,
                 break;
 
         case RPSM_EVENT_DELETE:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hcb_logosend);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending);
+                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);
                 break;
 
         case RPSM_EVENT_LOGO_IMP:
@@ -1040,7 +1138,14 @@ bfa_fcs_rport_sm_hcb_logosend(struct bfa_fcs_rport_s *rport,
                 break;
 
         case RPSM_EVENT_LOGO_RCVD:
+                bfa_fcs_rport_send_logo_acc(rport);
         case RPSM_EVENT_PRLO_RCVD:
+                if (rport->prlo == BFA_TRUE)
+                        bfa_fcs_rport_send_prlo_acc(rport);
+
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_delete_pending);
+                break;
+
         case RPSM_EVENT_ADDRESS_CHANGE:
                 break;
 
@@ -1072,7 +1177,11 @@ bfa_fcs_rport_sm_logo_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         case RPSM_EVENT_LOGO_RCVD:
+                bfa_fcs_rport_send_logo_acc(rport);
         case RPSM_EVENT_PRLO_RCVD:
+                if (rport->prlo == BFA_TRUE)
+                        bfa_fcs_rport_send_prlo_acc(rport);
+
                 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);
@@ -1126,9 +1235,9 @@ bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
                 bfa_timer_stop(&rport->timer);
-                bfa_fcs_rport_hal_online(rport);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         case RPSM_EVENT_PLOGI_SEND:
@@ -1190,9 +1299,9 @@ bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rport->fcxp_wqe);
-                bfa_fcs_rport_hal_online(rport);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         default:
@@ -1254,9 +1363,9 @@ bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
                 bfa_timer_stop(&rport->timer);
-                bfa_fcs_rport_hal_online(rport);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         default:
@@ -1296,6 +1405,7 @@ bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
                                  bfa_fcs_rport_sm_nsdisc_sending);
                         bfa_fcs_rport_send_nsdisc(rport, NULL);
                 } else {
+                        rport->old_pid = rport->pid;
                         rport->pid = 0;
                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
                         bfa_timer_start(rport->fcs->bfa, &rport->timer,
@@ -1343,9 +1453,9 @@ bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
                 break;
 
         case RPSM_EVENT_PLOGI_COMP:
-                bfa_sm_set_state(rport, bfa_fcs_rport_sm_hal_online);
+                bfa_sm_set_state(rport, bfa_fcs_rport_sm_fc4_fcs_online);
                 bfa_fcxp_discard(rport->fcxp);
-                bfa_fcs_rport_hal_online(rport);
+                bfa_fcs_rport_fcs_online_action(rport);
                 break;
 
         default:
@@ -1353,7 +1463,63 @@ bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
         }
 }
 
+/*
+ * Rport needs to be deleted
+ * waiting for ITNIM clean up to finish
+ */
+static void
+bfa_fcs_rport_sm_fc4_off_delete(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_delete_pending);
+                bfa_fcs_rport_hal_offline(rport);
+                break;
+
+        case RPSM_EVENT_DELETE:
+        case RPSM_EVENT_PLOGI_RCVD:
+                /* Ignore these events */
+                break;
+
+        default:
+                bfa_sm_fault(rport->fcs, event);
+                break;
+        }
+}
+
+/*
+ * RPort needs to be deleted
+ * waiting for BFA/FW to finish current processing
+ */
+static void
+bfa_fcs_rport_sm_delete_pending(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_uninit);
+                bfa_fcs_rport_free(rport);
+                break;
+
+        case RPSM_EVENT_DELETE:
+        case RPSM_EVENT_LOGO_IMP:
+        case RPSM_EVENT_PLOGI_RCVD:
+                /* Ignore these events */
+                break;
+
+        default:
+                bfa_sm_fault(rport->fcs, event);
+        }
+}
 
 /*
  *  fcs_rport_private FCS RPORT provate functions
@@ -1370,10 +1536,11 @@ bfa_fcs_rport_send_plogi(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(rport->fcs, rport->pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
-                                        bfa_fcs_rport_send_plogi, rport);
+                                bfa_fcs_rport_send_plogi, rport, BFA_TRUE);
                 return;
         }
         rport->fcxp = fcxp;
@@ -1490,10 +1657,11 @@ bfa_fcs_rport_send_plogiacc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
         bfa_trc(rport->fcs, rport->pwwn);
         bfa_trc(rport->fcs, rport->reply_oxid);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
-                                        bfa_fcs_rport_send_plogiacc, rport);
+                                bfa_fcs_rport_send_plogiacc, rport, BFA_FALSE);
                 return;
         }
         rport->fcxp = fcxp;
@@ -1522,10 +1690,11 @@ bfa_fcs_rport_send_adisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(rport->fcs, rport->pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
-                                        bfa_fcs_rport_send_adisc, rport);
+                                bfa_fcs_rport_send_adisc, rport, BFA_TRUE);
                 return;
         }
         rport->fcxp = fcxp;
@@ -1585,10 +1754,11 @@ bfa_fcs_rport_send_nsdisc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(rport->fcs, rport->pid);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
-                                        bfa_fcs_rport_send_nsdisc, rport);
+                                bfa_fcs_rport_send_nsdisc, rport, BFA_TRUE);
                 return;
         }
         rport->fcxp = fcxp;
@@ -1741,10 +1911,11 @@ bfa_fcs_rport_send_logo(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         port = rport->port;
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rport->fcxp_wqe,
-                                        bfa_fcs_rport_send_logo, rport);
+                                bfa_fcs_rport_send_logo, rport, BFA_FALSE);
                 return;
         }
         rport->fcxp = fcxp;
@@ -1778,7 +1949,7 @@ bfa_fcs_rport_send_logo_acc(void *rport_cbarg)
 
         port = rport->port;
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -1849,7 +2020,7 @@ bfa_fcs_rport_process_prli(struct bfa_fcs_rport_s *rport,
                 bfa_fcs_itnim_is_initiator(rport->itnim);
         }
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -1886,7 +2057,7 @@ bfa_fcs_rport_process_rpsc(struct bfa_fcs_rport_s *rport,
 
         speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -1920,7 +2091,7 @@ bfa_fcs_rport_process_adisc(struct bfa_fcs_rport_s *rport,
          */
         if (bfa_fcs_itnim_get_online_state(rport->itnim) == BFA_STATUS_OK) {
 
-                fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+                fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
                 if (!fcxp)
                         return;
 
@@ -1957,6 +2128,15 @@ bfa_fcs_rport_hal_online(struct bfa_fcs_rport_s *rport)
         bfa_rport_online(rport->bfa_rport, &rport_info);
 }
 
+static void
+bfa_fcs_rport_hal_offline(struct bfa_fcs_rport_s *rport)
+{
+        if (rport->bfa_rport)
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_OFFLINE);
+        else
+                bfa_cb_rport_offline(rport);
+}
+
 static struct bfa_fcs_rport_s *
 bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
 {
@@ -1967,6 +2147,11 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
         /*
          * allocate rport
          */
+        if (fcs->num_rport_logins >= bfa_fcs_rport_max_logins) {
+                bfa_trc(fcs, rpid);
+                return NULL;
+        }
+
         if (bfa_fcb_rport_alloc(fcs->bfad, &rport, &rport_drv)
                 != BFA_STATUS_OK) {
                 bfa_trc(fcs, rpid);
@@ -1981,16 +2166,9 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
         rport->rp_drv = rport_drv;
         rport->pid = rpid;
         rport->pwwn = pwwn;
+        rport->old_pid = 0;
 
-        /*
-         * 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;
-        }
+        rport->bfa_rport = NULL;
 
         /*
          * allocate FC-4s
@@ -2001,14 +2179,13 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid)
                 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);
+        fcs->num_rport_logins++;
 
         bfa_sm_set_state(rport, bfa_fcs_rport_sm_uninit);
 
@@ -2024,20 +2201,28 @@ static void
 bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport)
 {
         struct bfa_fcs_lport_s *port = rport->port;
+        struct bfa_fcs_s *fcs = port->fcs;
 
         /*
          * - delete FC-4s
          * - delete BFA rport
          * - remove from queue of rports
          */
+        rport->plogi_pending = BFA_FALSE;
+
         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);
+        if (rport->bfa_rport) {
+                bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_DELETE);
+                rport->bfa_rport = NULL;
+        }
+
         bfa_fcs_lport_del_rport(port, rport);
+        fcs->num_rport_logins--;
         kfree(rport->rp_drv);
 }
 
@@ -2071,7 +2256,18 @@ bfa_fcs_rport_aen_post(struct bfa_fcs_rport_s *rport,
 }
 
 static void
-bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport)
+bfa_fcs_rport_fcs_online_action(struct bfa_fcs_rport_s *rport)
+{
+        if ((!rport->pid) || (!rport->pwwn)) {
+                bfa_trc(rport->fcs, rport->pid);
+                bfa_sm_fault(rport->fcs, rport->pid);
+        }
+
+        bfa_sm_send_event(rport->itnim, BFA_FCS_ITNIM_SM_FCS_ONLINE);
+}
+
+static void
+bfa_fcs_rport_hal_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;
@@ -2086,7 +2282,7 @@ bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport)
         }
 
         if (bfa_fcs_lport_is_initiator(port)) {
-                bfa_fcs_itnim_rport_online(rport->itnim);
+                bfa_fcs_itnim_brp_online(rport->itnim);
                 if (!BFA_FCS_PID_IS_WKA(rport->pid))
                         bfa_fcs_rpf_rport_online(rport);
         };
@@ -2102,15 +2298,28 @@ bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport)
 }
 
 static void
-bfa_fcs_rport_offline_action(struct bfa_fcs_rport_s *rport)
+bfa_fcs_rport_fcs_offline_action(struct bfa_fcs_rport_s *rport)
+{
+        if (!BFA_FCS_PID_IS_WKA(rport->pid))
+                bfa_fcs_rpf_rport_offline(rport);
+
+        bfa_fcs_itnim_rport_offline(rport->itnim);
+}
+
+static void
+bfa_fcs_rport_hal_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];
 
+        if (!rport->bfa_rport) {
+                bfa_fcs_rport_fcs_offline_action(rport);
+                return;
+        }
+
         rport->stats.offlines++;
-        rport->plogi_pending = BFA_FALSE;
 
         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
         wwn2str(rpwwn_buf, rport->pwwn);
@@ -2340,7 +2549,6 @@ bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport)
         bfa_sm_send_event(rport, RPSM_EVENT_SCN);
 }
 
-
 /*
  *      brief
  *      This routine BFA callback for bfa_rport_online() call.
@@ -2508,7 +2716,7 @@ bfa_fcs_rport_send_prlo_acc(struct bfa_fcs_rport_s *rport)
 
         bfa_trc(rport->fcs, rport->pid);
 
-        fcxp = bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(port->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
         len = fc_prlo_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
@@ -2534,7 +2742,7 @@ bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport, struct fchs_s *rx_fchs,
 
         bfa_trc(rport->fcs, rx_fchs->s_id);
 
-        fcxp = bfa_fcs_fcxp_alloc(rport->fcs);
+        fcxp = bfa_fcs_fcxp_alloc(rport->fcs, BFA_FALSE);
         if (!fcxp)
                 return;
 
@@ -2582,6 +2790,17 @@ bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, __be16 ox_id)
         bfa_sm_send_event(rport, RPSM_EVENT_PRLO_RCVD);
 }
 
+/*
+ * Called by BFAD to set the max limit on number of bfa_fcs_rport allocation
+ * which limits number of concurrent logins to remote ports
+ */
+void
+bfa_fcs_rport_set_max_logins(u32 max_logins)
+{
+        if (max_logins > 0)
+                bfa_fcs_rport_max_logins = max_logins;
+}
+
 void
 bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
                 struct bfa_rport_attr_s *rport_attr)
@@ -2605,9 +2824,11 @@ bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
         rport_attr->curr_speed  = rport->rpf.rpsc_speed;
         rport_attr->assigned_speed  = rport->rpf.assigned_speed;
 
-        qos_attr.qos_priority = rport->bfa_rport->qos_attr.qos_priority;
-        qos_attr.qos_flow_id =
-                cpu_to_be32(rport->bfa_rport->qos_attr.qos_flow_id);
+        if (rport->bfa_rport) {
+                qos_attr.qos_priority = rport->bfa_rport->qos_attr.qos_priority;
+                qos_attr.qos_flow_id =
+                        cpu_to_be32(rport->bfa_rport->qos_attr.qos_flow_id);
+        }
         rport_attr->qos_attr = qos_attr;
 
         rport_attr->trl_enforced = BFA_FALSE;
@@ -2940,10 +3161,11 @@ bfa_fcs_rpf_send_rpsc2(void *rpf_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 
         bfa_trc(rport->fcs, rport->pwwn);
 
-        fcxp = fcxp_alloced ? fcxp_alloced : bfa_fcs_fcxp_alloc(port->fcs);
+        fcxp = fcxp_alloced ? fcxp_alloced :
+               bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
         if (!fcxp) {
                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &rpf->fcxp_wqe,
-                                        bfa_fcs_rpf_send_rpsc2, rpf);
+                                bfa_fcs_rpf_send_rpsc2, rpf, BFA_TRUE);
                 return;
         }
         rpf->fcxp = fcxp;
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index 21ad2902e5c..75ca8752b9f 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -92,7 +92,6 @@ static void bfa_ioc_event_notify(struct bfa_ioc_s *ioc ,
                                 enum bfa_ioc_event_e event);
 static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
 static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
-static void bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc);
 static void bfa_ioc_fail_notify(struct bfa_ioc_s *ioc);
 static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc);
 
@@ -599,8 +598,9 @@ bfa_ioc_sm_fail(struct bfa_ioc_s *ioc, enum ioc_event event)
                 break;
 
         case IOC_E_HWERROR:
+        case IOC_E_HWFAILED:
                 /*
-                 * HB failure notification, ignore.
+                 * HB failure / HW error notification, ignore.
                  */
                 break;
         default:
@@ -632,6 +632,10 @@ bfa_ioc_sm_hwfail(struct bfa_ioc_s *ioc, enum ioc_event event)
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
                 break;
 
+        case IOC_E_HWERROR:
+                /* Ignore - already in hwfail state */
+                break;
+
         default:
                 bfa_sm_fault(ioc, event);
         }
@@ -1455,7 +1459,7 @@ bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
                 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
 
         for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) {
-                if (fwhdr->md5sum[i] != drv_fwhdr->md5sum[i]) {
+                if (fwhdr->md5sum[i] != cpu_to_le32(drv_fwhdr->md5sum[i])) {
                         bfa_trc(ioc, i);
                         bfa_trc(ioc, fwhdr->md5sum[i]);
                         bfa_trc(ioc, drv_fwhdr->md5sum[i]);
@@ -1480,7 +1484,7 @@ bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc, u32 boot_env)
         drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
                 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
 
-        if (fwhdr.signature != drv_fwhdr->signature) {
+        if (fwhdr.signature != cpu_to_le32(drv_fwhdr->signature)) {
                 bfa_trc(ioc, fwhdr.signature);
                 bfa_trc(ioc, drv_fwhdr->signature);
                 return BFA_FALSE;
@@ -1704,7 +1708,7 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
                  * write smem
                  */
                 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff,
-                              fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]);
+                        cpu_to_le32(fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]));
 
                 loff += sizeof(u32);
 
@@ -2260,6 +2264,12 @@ bfa_ioc_disable(struct bfa_ioc_s *ioc)
         bfa_fsm_send_event(ioc, IOC_E_DISABLE);
 }
 
+void
+bfa_ioc_suspend(struct bfa_ioc_s *ioc)
+{
+        ioc->dbg_fwsave_once = BFA_TRUE;
+        bfa_fsm_send_event(ioc, IOC_E_HWERROR);
+}
 
 /*
  * Initialize memory for saving firmware trace. Driver must initialize
@@ -2269,7 +2279,7 @@ void
 bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
 {
         ioc->dbg_fwsave     = dbg_fwsave;
-        ioc->dbg_fwsave_len = (ioc->iocpf.auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
+        ioc->dbg_fwsave_len = BFA_DBG_FWTRC_LEN;
 }
 
 /*
@@ -2856,7 +2866,7 @@ bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc)
 /*
  * Save firmware trace if configured.
  */
-static void
+void
 bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc)
 {
         int             tlen;
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index 7b916e04ca5..b2856f96567 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -820,6 +820,7 @@ void bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa,
                 struct bfa_ioc_cbfn_s *cbfn, struct bfa_timer_mod_s *timer_mod);
 void bfa_ioc_auto_recover(bfa_boolean_t auto_recover);
 void bfa_ioc_detach(struct bfa_ioc_s *ioc);
+void bfa_ioc_suspend(struct bfa_ioc_s *ioc);
 void bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
                 enum bfi_pcifn_class clscode);
 void bfa_ioc_mem_claim(struct bfa_ioc_s *ioc,  u8 *dm_kva, u64 dm_pa);
@@ -866,6 +867,7 @@ bfa_boolean_t bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc,
 void bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event);
 bfa_status_t bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats);
 bfa_status_t bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc);
+void bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc);
 
 /*
  * asic block configuration related APIs
diff --git a/drivers/scsi/bfa/bfa_modules.h b/drivers/scsi/bfa/bfa_modules.h
index 2d36e482383..189fff71e3c 100644
--- a/drivers/scsi/bfa/bfa_modules.h
+++ b/drivers/scsi/bfa/bfa_modules.h
@@ -121,6 +121,7 @@ struct bfa_s {
         bfa_boolean_t           fcs;            /*  FCS is attached to BFA */
         struct bfa_msix_s       msix;
         int                     bfa_aen_seq;
+        bfa_boolean_t           intr_enabled;   /*  Status of interrupts */
 };
 
 extern bfa_boolean_t bfa_auto_recover;
diff --git a/drivers/scsi/bfa/bfa_svc.c b/drivers/scsi/bfa/bfa_svc.c
index 2e856e6710f..b2538d60db3 100644
--- a/drivers/scsi/bfa/bfa_svc.c
+++ b/drivers/scsi/bfa/bfa_svc.c
@@ -440,9 +440,11 @@ claim_fcxps_mem(struct bfa_fcxp_mod_s *mod)
         fcxp = (struct bfa_fcxp_s *) bfa_mem_kva_curp(mod);
         memset(fcxp, 0, sizeof(struct bfa_fcxp_s) * mod->num_fcxps);
 
-        INIT_LIST_HEAD(&mod->fcxp_free_q);
+        INIT_LIST_HEAD(&mod->fcxp_req_free_q);
+        INIT_LIST_HEAD(&mod->fcxp_rsp_free_q);
         INIT_LIST_HEAD(&mod->fcxp_active_q);
-        INIT_LIST_HEAD(&mod->fcxp_unused_q);
+        INIT_LIST_HEAD(&mod->fcxp_req_unused_q);
+        INIT_LIST_HEAD(&mod->fcxp_rsp_unused_q);
 
         mod->fcxp_list = fcxp;
 
@@ -450,7 +452,14 @@ claim_fcxps_mem(struct bfa_fcxp_mod_s *mod)
                 fcxp->fcxp_mod = mod;
                 fcxp->fcxp_tag = i;
 
-                list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
+                if (i < (mod->num_fcxps / 2)) {
+                        list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
+                        fcxp->req_rsp = BFA_TRUE;
+                } else {
+                        list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
+                        fcxp->req_rsp = BFA_FALSE;
+                }
+
                 bfa_reqq_winit(&fcxp->reqq_wqe, bfa_fcxp_qresume, fcxp);
                 fcxp->reqq_waiting = BFA_FALSE;
 
@@ -514,7 +523,8 @@ bfa_fcxp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         if (!cfg->drvcfg.min_cfg)
                 mod->rsp_pld_sz = BFA_FCXP_MAX_LBUF_SZ;
 
-        INIT_LIST_HEAD(&mod->wait_q);
+        INIT_LIST_HEAD(&mod->req_wait_q);
+        INIT_LIST_HEAD(&mod->rsp_wait_q);
 
         claim_fcxps_mem(mod);
 }
@@ -542,7 +552,8 @@ bfa_fcxp_iocdisable(struct bfa_s *bfa)
         struct list_head              *qe, *qen;
 
         /* Enqueue unused fcxp resources to free_q */
-        list_splice_tail_init(&mod->fcxp_unused_q, &mod->fcxp_free_q);
+        list_splice_tail_init(&mod->fcxp_req_unused_q, &mod->fcxp_req_free_q);
+        list_splice_tail_init(&mod->fcxp_rsp_unused_q, &mod->fcxp_rsp_free_q);
 
         list_for_each_safe(qe, qen, &mod->fcxp_active_q) {
                 fcxp = (struct bfa_fcxp_s *) qe;
@@ -559,11 +570,14 @@ bfa_fcxp_iocdisable(struct bfa_s *bfa)
 }
 
 static struct bfa_fcxp_s *
-bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
+bfa_fcxp_get(struct bfa_fcxp_mod_s *fm, bfa_boolean_t req)
 {
         struct bfa_fcxp_s *fcxp;
 
-        bfa_q_deq(&fm->fcxp_free_q, &fcxp);
+        if (req)
+                bfa_q_deq(&fm->fcxp_req_free_q, &fcxp);
+        else
+                bfa_q_deq(&fm->fcxp_rsp_free_q, &fcxp);
 
         if (fcxp)
                 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
@@ -642,7 +656,11 @@ bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
         struct bfa_fcxp_mod_s *mod = fcxp->fcxp_mod;
         struct bfa_fcxp_wqe_s *wqe;
 
-        bfa_q_deq(&mod->wait_q, &wqe);
+        if (fcxp->req_rsp)
+                bfa_q_deq(&mod->req_wait_q, &wqe);
+        else
+                bfa_q_deq(&mod->rsp_wait_q, &wqe);
+
         if (wqe) {
                 bfa_trc(mod->bfa, fcxp->fcxp_tag);
 
@@ -657,7 +675,11 @@ bfa_fcxp_put(struct bfa_fcxp_s *fcxp)
 
         WARN_ON(!bfa_q_is_on_q(&mod->fcxp_active_q, fcxp));
         list_del(&fcxp->qe);
-        list_add_tail(&fcxp->qe, &mod->fcxp_free_q);
+
+        if (fcxp->req_rsp)
+                list_add_tail(&fcxp->qe, &mod->fcxp_req_free_q);
+        else
+                list_add_tail(&fcxp->qe, &mod->fcxp_rsp_free_q);
 }
 
 static void
@@ -900,21 +922,23 @@ bfa_fcxp_queue(struct bfa_fcxp_s *fcxp, struct bfi_fcxp_send_req_s *send_req)
  *                              Address (given the sge index).
  * @param[in]   get_rsp_sglen   function ptr to be called to get a response SG
  *                              len (given the sge index).
+ * @param[in]   req             Allocated FCXP is used to send req or rsp?
+ *                              request - BFA_TRUE, response - BFA_FALSE
  *
  * @return FCXP instance. NULL on failure.
  */
 struct bfa_fcxp_s *
-bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
-               int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
-               bfa_fcxp_get_sglen_t req_sglen_cbfn,
-               bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
-               bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
+bfa_fcxp_req_rsp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
+                int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
+                bfa_fcxp_get_sglen_t req_sglen_cbfn,
+                bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
+                bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req)
 {
         struct bfa_fcxp_s *fcxp = NULL;
 
         WARN_ON(bfa == NULL);
 
-        fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
+        fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa), req);
         if (fcxp == NULL)
                 return NULL;
 
@@ -1071,17 +1095,20 @@ bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
 }
 
 void
-bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
+bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
                bfa_fcxp_alloc_cbfn_t alloc_cbfn, void *alloc_cbarg,
                void *caller, int nreq_sgles,
                int nrsp_sgles, bfa_fcxp_get_sgaddr_t req_sga_cbfn,
                bfa_fcxp_get_sglen_t req_sglen_cbfn,
                bfa_fcxp_get_sgaddr_t rsp_sga_cbfn,
-               bfa_fcxp_get_sglen_t rsp_sglen_cbfn)
+               bfa_fcxp_get_sglen_t rsp_sglen_cbfn, bfa_boolean_t req)
 {
         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 
-        WARN_ON(!list_empty(&mod->fcxp_free_q));
+        if (req)
+                WARN_ON(!list_empty(&mod->fcxp_req_free_q));
+        else
+                WARN_ON(!list_empty(&mod->fcxp_rsp_free_q));
 
         wqe->alloc_cbfn = alloc_cbfn;
         wqe->alloc_cbarg = alloc_cbarg;
@@ -1094,7 +1121,10 @@ bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
         wqe->rsp_sga_cbfn = rsp_sga_cbfn;
         wqe->rsp_sglen_cbfn = rsp_sglen_cbfn;
 
-        list_add_tail(&wqe->qe, &mod->wait_q);
+        if (req)
+                list_add_tail(&wqe->qe, &mod->req_wait_q);
+        else
+                list_add_tail(&wqe->qe, &mod->rsp_wait_q);
 }
 
 void
@@ -1102,7 +1132,8 @@ bfa_fcxp_walloc_cancel(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe)
 {
         struct bfa_fcxp_mod_s *mod = BFA_FCXP_MOD(bfa);
 
-        WARN_ON(!bfa_q_is_on_q(&mod->wait_q, wqe));
+        WARN_ON(!bfa_q_is_on_q(&mod->req_wait_q, wqe) ||
+                !bfa_q_is_on_q(&mod->rsp_wait_q, wqe));
         list_del(&wqe->qe);
 }
 
@@ -1153,8 +1184,13 @@ bfa_fcxp_res_recfg(struct bfa_s *bfa, u16 num_fcxp_fw)
         int     i;
 
         for (i = 0; i < (mod->num_fcxps - num_fcxp_fw); i++) {
-                bfa_q_deq_tail(&mod->fcxp_free_q, &qe);
-                list_add_tail(qe, &mod->fcxp_unused_q);
+                if (i < ((mod->num_fcxps - num_fcxp_fw) / 2)) {
+                        bfa_q_deq_tail(&mod->fcxp_req_free_q, &qe);
+                        list_add_tail(qe, &mod->fcxp_req_unused_q);
+                } else {
+                        bfa_q_deq_tail(&mod->fcxp_rsp_free_q, &qe);
+                        list_add_tail(qe, &mod->fcxp_rsp_unused_q);
+                }
         }
 }
 
@@ -1404,11 +1440,11 @@ bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
 
         switch (event) {
         case BFA_LPS_SM_FWRSP:
+        case BFA_LPS_SM_OFFLINE:
                 bfa_sm_set_state(lps, bfa_lps_sm_init);
                 bfa_lps_logout_comp(lps);
                 break;
 
-        case BFA_LPS_SM_OFFLINE:
         case BFA_LPS_SM_DELETE:
                 bfa_sm_set_state(lps, bfa_lps_sm_init);
                 break;
@@ -1786,6 +1822,8 @@ bfa_lps_logout_comp_cb(void *arg, bfa_boolean_t complete)
 
         if (lps->fdisc)
                 bfa_cb_lps_fdisclogo_comp(lps->bfa->bfad, lps->uarg);
+        else
+                bfa_cb_lps_flogo_comp(lps->bfa->bfad, lps->uarg);
 }
 
 /*
@@ -4237,6 +4275,10 @@ bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
                 break;
 
+        case BFA_RPORT_SM_OFFLINE:
+                bfa_rport_offline_cb(rp);
+                break;
+
         default:
                 bfa_stats(rp, sm_off_unexp);
                 bfa_sm_fault(rp->bfa, event);
@@ -4353,6 +4395,7 @@ bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
         case BFA_RPORT_SM_HWFAIL:
                 bfa_stats(rp, sm_offp_hwf);
                 bfa_sm_set_state(rp, bfa_rport_sm_iocdisable);
+                bfa_rport_offline_cb(rp);
                 break;
 
         default:
@@ -4731,8 +4774,10 @@ bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
         WARN_ON(speed == 0);
         WARN_ON(speed == BFA_PORT_SPEED_AUTO);
 
-        rport->rport_info.speed = speed;
-        bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
+        if (rport) {
+                rport->rport_info.speed = speed;
+                bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
+        }
 }
 
 /* Set Rport LUN Mask */
diff --git a/drivers/scsi/bfa/bfa_svc.h b/drivers/scsi/bfa/bfa_svc.h
index f3006756463..1abcf7c5166 100644
--- a/drivers/scsi/bfa/bfa_svc.h
+++ b/drivers/scsi/bfa/bfa_svc.h
@@ -97,10 +97,13 @@ struct bfa_fcxp_mod_s {
         struct bfa_s      *bfa;         /* backpointer to BFA */
         struct bfa_fcxp_s *fcxp_list;   /* array of FCXPs */
         u16     num_fcxps;      /* max num FCXP requests */
-        struct list_head  fcxp_free_q;  /* free FCXPs */
-        struct list_head  fcxp_active_q;        /* active FCXPs */
-        struct list_head  wait_q;               /* wait queue for free fcxp */
-        struct list_head fcxp_unused_q; /* unused fcxps */
+        struct list_head fcxp_req_free_q; /* free FCXPs used for sending req */
+        struct list_head fcxp_rsp_free_q; /* free FCXPs used for sending req */
+        struct list_head fcxp_active_q; /* active FCXPs */
+        struct list_head req_wait_q;    /* wait queue for free req_fcxp */
+        struct list_head rsp_wait_q;    /* wait queue for free rsp_fcxp */
+        struct list_head fcxp_req_unused_q;     /* unused req_fcxps */
+        struct list_head fcxp_rsp_unused_q;     /* unused rsp_fcxps */
         u32     req_pld_sz;
         u32     rsp_pld_sz;
         struct bfa_mem_dma_s dma_seg[BFA_FCXP_DMA_SEGS];
@@ -197,6 +200,7 @@ struct bfa_fcxp_s {
         struct bfa_cb_qe_s    hcb_qe;   /*  comp: callback qelem */
         struct bfa_reqq_wait_s  reqq_wqe;
         bfa_boolean_t   reqq_waiting;
+        bfa_boolean_t   req_rsp;        /* Used to track req/rsp fcxp */
 };
 
 struct bfa_fcxp_wqe_s {
@@ -586,20 +590,22 @@ void	bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp);
 /*
  * bfa fcxp API functions
  */
-struct bfa_fcxp_s *bfa_fcxp_alloc(void *bfad_fcxp, struct bfa_s *bfa,
+struct bfa_fcxp_s *bfa_fcxp_req_rsp_alloc(void *bfad_fcxp, struct bfa_s *bfa,
                                   int nreq_sgles, int nrsp_sgles,
                                   bfa_fcxp_get_sgaddr_t get_req_sga,
                                   bfa_fcxp_get_sglen_t get_req_sglen,
                                   bfa_fcxp_get_sgaddr_t get_rsp_sga,
-                                  bfa_fcxp_get_sglen_t get_rsp_sglen);
-void bfa_fcxp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
+                                  bfa_fcxp_get_sglen_t get_rsp_sglen,
+                                  bfa_boolean_t req);
+void bfa_fcxp_req_rsp_alloc_wait(struct bfa_s *bfa, struct bfa_fcxp_wqe_s *wqe,
                                 bfa_fcxp_alloc_cbfn_t alloc_cbfn,
                                 void *cbarg, void *bfad_fcxp,
                                 int nreq_sgles, int nrsp_sgles,
                                 bfa_fcxp_get_sgaddr_t get_req_sga,
                                 bfa_fcxp_get_sglen_t get_req_sglen,
                                 bfa_fcxp_get_sgaddr_t get_rsp_sga,
-                                bfa_fcxp_get_sglen_t get_rsp_sglen);
+                                bfa_fcxp_get_sglen_t get_rsp_sglen,
+                                bfa_boolean_t req);
 void bfa_fcxp_walloc_cancel(struct bfa_s *bfa,
                             struct bfa_fcxp_wqe_s *wqe);
 void bfa_fcxp_discard(struct bfa_fcxp_s *fcxp);
@@ -658,6 +664,7 @@ u8 bfa_lps_get_fwtag(struct bfa_s *bfa, u8 lp_tag);
 u32 bfa_lps_get_base_pid(struct bfa_s *bfa);
 u8 bfa_lps_get_tag_from_pid(struct bfa_s *bfa, u32 pid);
 void bfa_cb_lps_flogi_comp(void *bfad, void *uarg, bfa_status_t status);
+void bfa_cb_lps_flogo_comp(void *bfad, void *uarg);
 void bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status);
 void bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg);
 void bfa_cb_lps_cvl_event(void *bfad, void *uarg);
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index 2c8f0c71307..c37494916a1 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -57,6 +57,7 @@ int		pcie_max_read_reqsz;
 int             bfa_debugfs_enable = 1;
 int             msix_disable_cb = 0, msix_disable_ct = 0;
 int             max_xfer_size = BFAD_MAX_SECTORS >> 1;
+int             max_rport_logins = BFA_FCS_MAX_RPORT_LOGINS;
 
 /* Firmware releated */
 u32     bfi_image_cb_size, bfi_image_ct_size, bfi_image_ct2_size;
@@ -148,6 +149,8 @@ MODULE_PARM_DESC(bfa_debugfs_enable, "Enables debugfs feature, default=1,"
 module_param(max_xfer_size, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(max_xfer_size, "default=32MB,"
                 " Range[64k|128k|256k|512k|1024k|2048k]");
+module_param(max_rport_logins, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(max_rport_logins, "Max number of logins to initiator and target rports on a port (physical/logical), default=1024");
 
 static void
 bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event);
@@ -736,6 +739,9 @@ bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad)
                 }
         }
 
+        /* Enable PCIE Advanced Error Recovery (AER) if kernel supports */
+        pci_enable_pcie_error_reporting(pdev);
+
         bfad->pci_bar0_kva = pci_iomap(pdev, 0, pci_resource_len(pdev, 0));
         bfad->pci_bar2_kva = pci_iomap(pdev, 2, pci_resource_len(pdev, 2));
 
@@ -806,6 +812,8 @@ bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad)
                 }
         }
 
+        pci_save_state(pdev);
+
         return 0;
 
 out_release_region:
@@ -822,6 +830,8 @@ bfad_pci_uninit(struct pci_dev *pdev, struct bfad_s *bfad)
         pci_iounmap(pdev, bfad->pci_bar0_kva);
         pci_iounmap(pdev, bfad->pci_bar2_kva);
         pci_release_regions(pdev);
+        /* Disable PCIE Advanced Error Recovery (AER) */
+        pci_disable_pcie_error_reporting(pdev);
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
 }
@@ -1258,6 +1268,16 @@ bfad_setup_intr(struct bfad_s *bfad)
 
                 error = pci_enable_msix(bfad->pcidev, msix_entries, bfad->nvec);
                 if (error) {
+                        /* In CT1 & CT2, try to allocate just one vector */
+                        if (bfa_asic_id_ctc(pdev->device)) {
+                                printk(KERN_WARNING "bfa %s: trying one msix "
+                                       "vector failed to allocate %d[%d]\n",
+                                       bfad->pci_name, bfad->nvec, error);
+                                bfad->nvec = 1;
+                                error = pci_enable_msix(bfad->pcidev,
+                                                msix_entries, bfad->nvec);
+                        }
+
                         /*
                          * Only error number of vector is available.
                          * We don't have a mechanism to map multiple
@@ -1267,12 +1287,13 @@ bfad_setup_intr(struct bfad_s *bfad)
                          *  vectors. Linux doesn't duplicate vectors
                          * in the MSIX table for this case.
                          */
-
-                        printk(KERN_WARNING "bfad%d: "
-                                "pci_enable_msix failed (%d),"
-                                " use line based.\n", bfad->inst_no, error);
-
-                        goto line_based;
+                        if (error) {
+                                printk(KERN_WARNING "bfad%d: "
+                                       "pci_enable_msix failed (%d), "
+                                       "use line based.\n",
+                                        bfad->inst_no, error);
+                                goto line_based;
+                        }
                 }
 
                 /* Disable INTX in MSI-X mode */
@@ -1470,6 +1491,197 @@ bfad_pci_remove(struct pci_dev *pdev)
         kfree(bfad);
 }
 
+/*
+ * PCI Error Recovery entry, error detected.
+ */
+static pci_ers_result_t
+bfad_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
+{
+        struct bfad_s *bfad = pci_get_drvdata(pdev);
+        unsigned long   flags;
+        pci_ers_result_t ret = PCI_ERS_RESULT_NONE;
+
+        dev_printk(KERN_ERR, &pdev->dev,
+                   "error detected state: %d - flags: 0x%x\n",
+                   state, bfad->bfad_flags);
+
+        switch (state) {
+        case pci_channel_io_normal: /* non-fatal error */
+                spin_lock_irqsave(&bfad->bfad_lock, flags);
+                bfad->bfad_flags &= ~BFAD_EEH_BUSY;
+                /* Suspend/fail all bfa operations */
+                bfa_ioc_suspend(&bfad->bfa.ioc);
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                del_timer_sync(&bfad->hal_tmo);
+                ret = PCI_ERS_RESULT_CAN_RECOVER;
+                break;
+        case pci_channel_io_frozen: /* fatal error */
+                init_completion(&bfad->comp);
+                spin_lock_irqsave(&bfad->bfad_lock, flags);
+                bfad->bfad_flags |= BFAD_EEH_BUSY;
+                /* Suspend/fail all bfa operations */
+                bfa_ioc_suspend(&bfad->bfa.ioc);
+                bfa_fcs_stop(&bfad->bfa_fcs);
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                wait_for_completion(&bfad->comp);
+
+                bfad_remove_intr(bfad);
+                del_timer_sync(&bfad->hal_tmo);
+                pci_disable_device(pdev);
+                ret = PCI_ERS_RESULT_NEED_RESET;
+                break;
+        case pci_channel_io_perm_failure: /* PCI Card is DEAD */
+                spin_lock_irqsave(&bfad->bfad_lock, flags);
+                bfad->bfad_flags |= BFAD_EEH_BUSY |
+                                    BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE;
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+                /* If the error_detected handler is called with the reason
+                 * pci_channel_io_perm_failure - it will subsequently call
+                 * pci_remove() entry point to remove the pci device from the
+                 * system - So defer the cleanup to pci_remove(); cleaning up
+                 * here causes inconsistent state during pci_remove().
+                 */
+                ret = PCI_ERS_RESULT_DISCONNECT;
+                break;
+        default:
+                WARN_ON(1);
+        }
+
+        return ret;
+}
+
+int
+restart_bfa(struct bfad_s *bfad)
+{
+        unsigned long flags;
+        struct pci_dev *pdev = bfad->pcidev;
+
+        bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg,
+                   &bfad->meminfo, &bfad->hal_pcidev);
+
+        /* Enable Interrupt and wait bfa_init completion */
+        if (bfad_setup_intr(bfad)) {
+                dev_printk(KERN_WARNING, &pdev->dev,
+                           "%s: bfad_setup_intr failed\n", bfad->pci_name);
+                bfa_sm_send_event(bfad, BFAD_E_INTR_INIT_FAILED);
+                return -1;
+        }
+
+        init_completion(&bfad->comp);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        bfa_iocfc_init(&bfad->bfa);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        /* Set up interrupt handler for each vectors */
+        if ((bfad->bfad_flags & BFAD_MSIX_ON) &&
+            bfad_install_msix_handler(bfad))
+                dev_printk(KERN_WARNING, &pdev->dev,
+                           "%s: install_msix failed.\n", bfad->pci_name);
+
+        bfad_init_timer(bfad);
+        wait_for_completion(&bfad->comp);
+        bfad_drv_start(bfad);
+
+        return 0;
+}
+
+/*
+ * PCI Error Recovery entry, re-initialize the chip.
+ */
+static pci_ers_result_t
+bfad_pci_slot_reset(struct pci_dev *pdev)
+{
+        struct bfad_s *bfad = pci_get_drvdata(pdev);
+        u8 byte;
+
+        dev_printk(KERN_ERR, &pdev->dev,
+                   "bfad_pci_slot_reset flags: 0x%x\n", bfad->bfad_flags);
+
+        if (pci_enable_device(pdev)) {
+                dev_printk(KERN_ERR, &pdev->dev, "Cannot re-enable "
+                           "PCI device after reset.\n");
+                return PCI_ERS_RESULT_DISCONNECT;
+        }
+
+        pci_restore_state(pdev);
+
+        /*
+         * Read some byte (e.g. DMA max. payload size which can't
+         * be 0xff any time) to make sure - we did not hit another PCI error
+         * in the middle of recovery. If we did, then declare permanent failure.
+         */
+        pci_read_config_byte(pdev, 0x68, &byte);
+        if (byte == 0xff) {
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "slot_reset failed ... got another PCI error !\n");
+                goto out_disable_device;
+        }
+
+        pci_save_state(pdev);
+        pci_set_master(pdev);
+
+        if (pci_set_dma_mask(bfad->pcidev, DMA_BIT_MASK(64)) != 0)
+                if (pci_set_dma_mask(bfad->pcidev, DMA_BIT_MASK(32)) != 0)
+                        goto out_disable_device;
+
+        pci_cleanup_aer_uncorrect_error_status(pdev);
+
+        if (restart_bfa(bfad) == -1)
+                goto out_disable_device;
+
+        pci_enable_pcie_error_reporting(pdev);
+        dev_printk(KERN_WARNING, &pdev->dev,
+                   "slot_reset completed  flags: 0x%x!\n", bfad->bfad_flags);
+
+        return PCI_ERS_RESULT_RECOVERED;
+
+out_disable_device:
+        pci_disable_device(pdev);
+        return PCI_ERS_RESULT_DISCONNECT;
+}
+
+static pci_ers_result_t
+bfad_pci_mmio_enabled(struct pci_dev *pdev)
+{
+        unsigned long   flags;
+        struct bfad_s *bfad = pci_get_drvdata(pdev);
+
+        dev_printk(KERN_INFO, &pdev->dev, "mmio_enabled\n");
+
+        /* Fetch FW diagnostic information */
+        bfa_ioc_debug_save_ftrc(&bfad->bfa.ioc);
+
+        /* Cancel all pending IOs */
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        init_completion(&bfad->comp);
+        bfa_fcs_stop(&bfad->bfa_fcs);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        wait_for_completion(&bfad->comp);
+
+        bfad_remove_intr(bfad);
+        del_timer_sync(&bfad->hal_tmo);
+        pci_disable_device(pdev);
+
+        return PCI_ERS_RESULT_NEED_RESET;
+}
+
+static void
+bfad_pci_resume(struct pci_dev *pdev)
+{
+        unsigned long   flags;
+        struct bfad_s *bfad = pci_get_drvdata(pdev);
+
+        dev_printk(KERN_WARNING, &pdev->dev, "resume\n");
+
+        /* wait until the link is online */
+        bfad_rport_online_wait(bfad);
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        bfad->bfad_flags &= ~BFAD_EEH_BUSY;
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+}
+
 struct pci_device_id bfad_id_table[] = {
         {
                 .vendor = BFA_PCI_VENDOR_ID_BROCADE,
@@ -1513,11 +1725,22 @@ struct pci_device_id bfad_id_table[] = {
 
 MODULE_DEVICE_TABLE(pci, bfad_id_table);
 
+/*
+ * PCI error recovery handlers.
+ */
+static struct pci_error_handlers bfad_err_handler = {
+        .error_detected = bfad_pci_error_detected,
+        .slot_reset = bfad_pci_slot_reset,
+        .mmio_enabled = bfad_pci_mmio_enabled,
+        .resume = bfad_pci_resume,
+};
+
 static struct pci_driver bfad_pci_driver = {
         .name = BFAD_DRIVER_NAME,
         .id_table = bfad_id_table,
         .probe = bfad_pci_probe,
         .remove = __devexit_p(bfad_pci_remove),
+        .err_handler = &bfad_err_handler,
 };
 
 /*
@@ -1546,6 +1769,7 @@ bfad_init(void)
 
         bfa_auto_recover = ioc_auto_recover;
         bfa_fcs_rport_set_del_timeout(rport_del_timeout);
+        bfa_fcs_rport_set_max_logins(max_rport_logins);
 
         error = pci_register_driver(&bfad_pci_driver);
         if (error) {
diff --git a/drivers/scsi/bfa/bfad_attr.c b/drivers/scsi/bfa/bfad_attr.c
index b8392744017..72f5dc32cc1 100644
--- a/drivers/scsi/bfa/bfad_attr.c
+++ b/drivers/scsi/bfa/bfad_attr.c
@@ -587,6 +587,37 @@ bfad_im_vport_disable(struct fc_vport *fc_vport, bool disable)
         return 0;
 }
 
+void
+bfad_im_vport_set_symbolic_name(struct fc_vport *fc_vport)
+{
+        struct bfad_vport_s *vport = (struct bfad_vport_s *)fc_vport->dd_data;
+        struct bfad_im_port_s *im_port =
+                        (struct bfad_im_port_s *)vport->drv_port.im_port;
+        struct bfad_s *bfad = im_port->bfad;
+        struct Scsi_Host *vshost = vport->drv_port.im_port->shost;
+        char *sym_name = fc_vport->symbolic_name;
+        struct bfa_fcs_vport_s *fcs_vport;
+        wwn_t   pwwn;
+        unsigned long flags;
+
+        u64_to_wwn(fc_host_port_name(vshost), (u8 *)&pwwn);
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs, 0, pwwn);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        if (fcs_vport == NULL)
+                return;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (strlen(sym_name) > 0) {
+                strcpy(fcs_vport->lport.port_cfg.sym_name.symname, sym_name);
+                bfa_fcs_lport_ns_util_send_rspn_id(
+                        BFA_FCS_GET_NS_FROM_PORT((&fcs_vport->lport)), NULL);
+        }
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+}
+
 struct fc_function_template bfad_im_fc_function_template = {
 
         /* Target dynamic attributes */
@@ -640,6 +671,7 @@ struct fc_function_template bfad_im_fc_function_template = {
         .vport_create = bfad_im_vport_create,
         .vport_delete = bfad_im_vport_delete,
         .vport_disable = bfad_im_vport_disable,
+        .set_vport_symbolic_name = bfad_im_vport_set_symbolic_name,
         .bsg_request = bfad_im_bsg_request,
         .bsg_timeout = bfad_im_bsg_timeout,
 };
@@ -792,6 +824,13 @@ bfad_im_model_desc_show(struct device *dev, struct device_attribute *attr,
                 else if (nports == 2 && !bfa_ioc_is_cna(&bfad->bfa.ioc))
                         snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
                                 "Brocade 16Gbps PCIe dual port FC HBA");
+        } else if (!strcmp(model, "Brocade-1867")) {
+                if (nports == 1 && !bfa_ioc_is_cna(&bfad->bfa.ioc))
+                        snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                                "Brocade 16Gbps PCIe single port FC HBA for IBM");
+                else if (nports == 2 && !bfa_ioc_is_cna(&bfad->bfa.ioc))
+                        snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                                "Brocade 16Gbps PCIe dual port FC HBA for IBM");
         } else
                 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
                         "Invalid Model");
@@ -909,15 +948,16 @@ bfad_im_num_of_discovered_ports_show(struct device *dev,
         struct bfad_port_s    *port = im_port->port;
         struct bfad_s         *bfad = im_port->bfad;
         int        nrports = 2048;
-        wwn_t          *rports = NULL;
+        struct bfa_rport_qualifier_s *rports = NULL;
         unsigned long   flags;
 
-        rports = kzalloc(sizeof(wwn_t) * nrports , GFP_ATOMIC);
+        rports = kzalloc(sizeof(struct bfa_rport_qualifier_s) * nrports,
+                         GFP_ATOMIC);
         if (rports == NULL)
                 return snprintf(buf, PAGE_SIZE, "Failed\n");
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        bfa_fcs_lport_get_rports(port->fcs_port, rports, &nrports);
+        bfa_fcs_lport_get_rport_quals(port->fcs_port, rports, &nrports);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         kfree(rports);
 
diff --git a/drivers/scsi/bfa/bfad_bsg.c b/drivers/scsi/bfa/bfad_bsg.c
index 9c1495b321d..0afa39076ce 100644
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -535,7 +535,8 @@ bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
 
         if (bfad_chk_iocmd_sz(payload_len,
                         sizeof(struct bfa_bsg_lport_get_rports_s),
-                        sizeof(wwn_t) * iocmd->nrports) != BFA_STATUS_OK) {
+                        sizeof(struct bfa_rport_qualifier_s) * iocmd->nrports)
+                        != BFA_STATUS_OK) {
                 iocmd->status = BFA_STATUS_VERSION_FAIL;
                 return 0;
         }
@@ -552,8 +553,9 @@ bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
                 goto out;
         }
 
-        bfa_fcs_lport_get_rports(fcs_port, (wwn_t *)iocmd_bufptr,
-                                &iocmd->nrports);
+        bfa_fcs_lport_get_rport_quals(fcs_port,
+                        (struct bfa_rport_qualifier_s *)iocmd_bufptr,
+                        &iocmd->nrports);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         iocmd->status = BFA_STATUS_OK;
 out:
@@ -578,7 +580,11 @@ bfad_iocmd_rport_get_attr(struct bfad_s *bfad, void *cmd)
                 goto out;
         }
 
-        fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
+        if (iocmd->pid)
+                fcs_rport = bfa_fcs_lport_get_rport_by_qualifier(fcs_port,
+                                                iocmd->rpwwn, iocmd->pid);
+        else
+                fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
         if (fcs_rport == NULL) {
                 bfa_trc(bfad, 0);
                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -671,9 +677,11 @@ bfad_iocmd_rport_get_stats(struct bfad_s *bfad, void *cmd)
 
         memcpy((void *)&iocmd->stats, (void *)&fcs_rport->stats,
                 sizeof(struct bfa_rport_stats_s));
-        memcpy((void *)&iocmd->stats.hal_stats,
-               (void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats),
-               sizeof(struct bfa_rport_hal_stats_s));
+        if (bfa_fcs_rport_get_halrport(fcs_rport)) {
+                memcpy((void *)&iocmd->stats.hal_stats,
+                       (void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats),
+                        sizeof(struct bfa_rport_hal_stats_s));
+        }
 
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         iocmd->status = BFA_STATUS_OK;
@@ -709,7 +717,8 @@ bfad_iocmd_rport_clr_stats(struct bfad_s *bfad, void *cmd)
 
         memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s));
         rport = bfa_fcs_rport_get_halrport(fcs_rport);
-        memset(&rport->stats, 0, sizeof(rport->stats));
+        if (rport)
+                memset(&rport->stats, 0, sizeof(rport->stats));
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         iocmd->status = BFA_STATUS_OK;
 out:
@@ -744,7 +753,8 @@ bfad_iocmd_rport_set_speed(struct bfad_s *bfad, void *cmd)
         fcs_rport->rpf.assigned_speed  = iocmd->speed;
         /* Set this speed in f/w only if the RPSC speed is not available */
         if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)
-                bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);
+                if (fcs_rport->bfa_rport)
+                        bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         iocmd->status = BFA_STATUS_OK;
 out:
@@ -1030,9 +1040,10 @@ bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd)
                         iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
                 else {
                         iocmd->status = BFA_STATUS_OK;
-                        memcpy((void *)&iocmd->iostats, (void *)
-                               &(bfa_fcs_itnim_get_halitn(itnim)->stats),
-                               sizeof(struct bfa_itnim_iostats_s));
+                        if (bfa_fcs_itnim_get_halitn(itnim))
+                                memcpy((void *)&iocmd->iostats, (void *)
+                                &(bfa_fcs_itnim_get_halitn(itnim)->stats),
+                                       sizeof(struct bfa_itnim_iostats_s));
                 }
         }
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -2949,13 +2960,13 @@ bfad_fcxp_bsg_send(struct fc_bsg_job *job, struct bfad_fcxp *drv_fcxp,
         spin_lock_irqsave(&bfad->bfad_lock, flags);
 
         /* Allocate bfa_fcxp structure */
-        hal_fcxp = bfa_fcxp_alloc(drv_fcxp, &bfad->bfa,
+        hal_fcxp = bfa_fcxp_req_rsp_alloc(drv_fcxp, &bfad->bfa,
                                   drv_fcxp->num_req_sgles,
                                   drv_fcxp->num_rsp_sgles,
                                   bfad_fcxp_get_req_sgaddr_cb,
                                   bfad_fcxp_get_req_sglen_cb,
                                   bfad_fcxp_get_rsp_sgaddr_cb,
-                                  bfad_fcxp_get_rsp_sglen_cb);
+                                  bfad_fcxp_get_rsp_sglen_cb, BFA_TRUE);
         if (!hal_fcxp) {
                 bfa_trc(bfad, 0);
                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
diff --git a/drivers/scsi/bfa/bfad_bsg.h b/drivers/scsi/bfa/bfad_bsg.h
index 17ad6728313..8c569ddb750 100644
--- a/drivers/scsi/bfa/bfad_bsg.h
+++ b/drivers/scsi/bfa/bfad_bsg.h
@@ -319,6 +319,8 @@ struct bfa_bsg_rport_attr_s {
         u16             vf_id;
         wwn_t           pwwn;
         wwn_t           rpwwn;
+        u32             pid;
+        u32             rsvd;
         struct bfa_rport_attr_s attr;
 };
 
diff --git a/drivers/scsi/bfa/bfad_drv.h b/drivers/scsi/bfa/bfad_drv.h
index 7f74f1d1912..1840651ce1d 100644
--- a/drivers/scsi/bfa/bfad_drv.h
+++ b/drivers/scsi/bfa/bfad_drv.h
@@ -37,6 +37,7 @@
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
 #include <linux/bitops.h>
+#include <linux/aer.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
@@ -56,7 +57,7 @@
 #ifdef BFA_DRIVER_VERSION
 #define BFAD_DRIVER_VERSION    BFA_DRIVER_VERSION
 #else
-#define BFAD_DRIVER_VERSION    "3.0.23.0"
+#define BFAD_DRIVER_VERSION    "3.1.2.0"
 #endif
 
 #define BFAD_PROTO_NAME FCPI_NAME
@@ -81,6 +82,8 @@
 #define BFAD_FC4_PROBE_DONE                     0x00000200
 #define BFAD_PORT_DELETE                        0x00000001
 #define BFAD_INTX_ON                            0x00000400
+#define BFAD_EEH_BUSY                           0x00000800
+#define BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE    0x00001000
 /*
  * BFAD related definition
  */
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index 2eebf8d4d58..8f92732655c 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -1216,6 +1216,15 @@ bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd
                 return 0;
         }
 
+        if (bfad->bfad_flags & BFAD_EEH_BUSY) {
+                if (bfad->bfad_flags & BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE)
+                        cmnd->result = DID_NO_CONNECT << 16;
+                else
+                        cmnd->result = DID_REQUEUE << 16;
+                done(cmnd);
+                return 0;
+        }
+
         sg_cnt = scsi_dma_map(cmnd);
         if (sg_cnt < 0)
                 return SCSI_MLQUEUE_HOST_BUSY;