[SCSI] bfa: Revised Fabric Assigned Address(FAA) feature implementation.

Made changes to the Fabric Assigned Address(FAA) feature implementation.
Introduced the IOCFC state machine, which now handles the FAA logic,
IOC and BFA sub-modules enablement.
Removed un-wanted FAA enable/disable routines; FAA is enabled by default.

Signed-off-by: Krishna Gudipati <kgudipat@brocade.com>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

10 files changed, 525 insertions, 380 deletions

diff --git a/drivers/scsi/bfa/bfa.h b/drivers/scsi/bfa/bfa.h
index a796de935054..4ad7e368bbc2 100644
--- a/drivers/scsi/bfa/bfa.h
+++ b/drivers/scsi/bfa/bfa.h
@@ -225,9 +225,9 @@ struct bfa_faa_args_s {
 };
 
 struct bfa_iocfc_s {
+        bfa_fsm_t               fsm;
         struct bfa_s            *bfa;
         struct bfa_iocfc_cfg_s  cfg;
-        int                     action;
         u32             req_cq_pi[BFI_IOC_MAX_CQS];
         u32             rsp_cq_ci[BFI_IOC_MAX_CQS];
         u8              hw_qid[BFI_IOC_MAX_CQS];
@@ -236,7 +236,9 @@ struct bfa_iocfc_s {
         struct bfa_cb_qe_s      dis_hcb_qe;
         struct bfa_cb_qe_s      en_hcb_qe;
         struct bfa_cb_qe_s      stats_hcb_qe;
-        bfa_boolean_t           cfgdone;
+        bfa_boolean_t           submod_enabled;
+        bfa_boolean_t           cb_reqd;        /* Driver call back reqd */
+        bfa_status_t            op_status;      /* Status of bfa iocfc op */
 
         struct bfa_dma_s        cfg_info;
         struct bfi_iocfc_cfg_s *cfginfo;
@@ -341,8 +343,6 @@ void bfa_hwct_msix_getvecs(struct bfa_s *bfa, u32 *vecmap, u32 *nvecs,
 void bfa_hwct_msix_get_rme_range(struct bfa_s *bfa, u32 *start,
                                  u32 *end);
 void bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns);
-wwn_t bfa_iocfc_get_pwwn(struct bfa_s *bfa);
-wwn_t bfa_iocfc_get_nwwn(struct bfa_s *bfa);
 int bfa_iocfc_get_pbc_vports(struct bfa_s *bfa,
                                 struct bfi_pbc_vport_s *pbc_vport);
 
@@ -428,7 +428,6 @@ bfa_status_t bfa_iocfc_israttr_set(struct bfa_s *bfa,
 
 void bfa_iocfc_enable(struct bfa_s *bfa);
 void bfa_iocfc_disable(struct bfa_s *bfa);
-void bfa_iocfc_cb_dconf_modinit(struct bfa_s *bfa, bfa_status_t status);
 #define bfa_timer_start(_bfa, _timer, _timercb, _arg, _timeout)         \
         bfa_timer_begin(&(_bfa)->timer_mod, _timer, _timercb, _arg, _timeout)
 
diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 035c9d5caf01..456e5762977d 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -200,13 +200,431 @@ enum {
 #define DEF_CFG_NUM_SBOOT_LUNS          16
 
 /*
+ * IOCFC state machine definitions/declarations
+ */
+bfa_fsm_state_decl(bfa_iocfc, stopped, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, initing, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, dconf_read, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, init_cfg_wait,
+                   struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, init_cfg_done,
+                   struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, operational,
+                   struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, dconf_write,
+                   struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, stopping, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, enabling, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, cfg_wait, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, disabling, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, disabled, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, failed, struct bfa_iocfc_s, enum iocfc_event);
+bfa_fsm_state_decl(bfa_iocfc, init_failed,
+                   struct bfa_iocfc_s, enum iocfc_event);
+
+/*
  * forward declaration for IOC FC functions
  */
+static void bfa_iocfc_start_submod(struct bfa_s *bfa);
+static void bfa_iocfc_disable_submod(struct bfa_s *bfa);
+static void bfa_iocfc_send_cfg(void *bfa_arg);
 static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status);
 static void bfa_iocfc_disable_cbfn(void *bfa_arg);
 static void bfa_iocfc_hbfail_cbfn(void *bfa_arg);
 static void bfa_iocfc_reset_cbfn(void *bfa_arg);
 static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn;
+static void bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete);
+static void bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl);
+static void bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl);
+static void bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl);
+
+static void
+bfa_iocfc_sm_stopped_entry(struct bfa_iocfc_s *iocfc)
+{
+}
+
+static void
+bfa_iocfc_sm_stopped(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_INIT:
+        case IOCFC_E_ENABLE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_initing);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_initing_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_ioc_enable(&iocfc->bfa->ioc);
+}
+
+static void
+bfa_iocfc_sm_initing(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_IOC_ENABLED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_dconf_read_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_dconf_modinit(iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_dconf_read(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_DCONF_DONE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_wait);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_init_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_iocfc_send_cfg(iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_init_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_CFG_DONE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_done);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_init_cfg_done_entry(struct bfa_iocfc_s *iocfc)
+{
+        iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
+        bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
+                     bfa_iocfc_init_cb, iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_init_cfg_done(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_START:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
+                break;
+        case IOCFC_E_STOP:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
+                break;
+        case IOCFC_E_DISABLE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_operational_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_fcport_init(iocfc->bfa);
+        bfa_iocfc_start_submod(iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_operational(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_STOP:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
+                break;
+        case IOCFC_E_DISABLE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_dconf_write_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_dconf_modexit(iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_dconf_write(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_DCONF_DONE:
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_stopping_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_ioc_disable(&iocfc->bfa->ioc);
+}
+
+static void
+bfa_iocfc_sm_stopping(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_IOC_DISABLED:
+                bfa_isr_disable(iocfc->bfa);
+                bfa_iocfc_disable_submod(iocfc->bfa);
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
+                iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
+                bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.stop_hcb_qe,
+                             bfa_iocfc_stop_cb, iocfc->bfa);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_enabling_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_ioc_enable(&iocfc->bfa->ioc);
+}
+
+static void
+bfa_iocfc_sm_enabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_IOC_ENABLED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
+
+                if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
+                        break;
+
+                iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
+                bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
+                             bfa_iocfc_enable_cb, iocfc->bfa);
+                iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_iocfc_send_cfg(iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_CFG_DONE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
+                if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
+                        break;
+
+                iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
+                bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
+                             bfa_iocfc_enable_cb, iocfc->bfa);
+                iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
+                break;
+        case IOCFC_E_IOC_FAILED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
+                if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
+                        break;
+
+                iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
+                bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
+                             bfa_iocfc_enable_cb, iocfc->bfa);
+                iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_disabling_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_ioc_disable(&iocfc->bfa->ioc);
+}
+
+static void
+bfa_iocfc_sm_disabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_IOC_DISABLED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabled);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_disabled_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_isr_disable(iocfc->bfa);
+        bfa_iocfc_disable_submod(iocfc->bfa);
+        iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
+        bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
+                     bfa_iocfc_disable_cb, iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_disabled(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_STOP:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
+                break;
+        case IOCFC_E_ENABLE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_enabling);
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_failed_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_isr_disable(iocfc->bfa);
+        bfa_iocfc_disable_submod(iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_STOP:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
+                break;
+        case IOCFC_E_DISABLE:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
+                break;
+        case IOCFC_E_IOC_ENABLED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
+
+static void
+bfa_iocfc_sm_init_failed_entry(struct bfa_iocfc_s *iocfc)
+{
+        bfa_isr_disable(iocfc->bfa);
+        iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
+        bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
+                     bfa_iocfc_init_cb, iocfc->bfa);
+}
+
+static void
+bfa_iocfc_sm_init_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
+{
+        bfa_trc(iocfc->bfa, event);
+
+        switch (event) {
+        case IOCFC_E_STOP:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
+                break;
+        case IOCFC_E_DISABLE:
+                bfa_ioc_disable(&iocfc->bfa->ioc);
+                break;
+        case IOCFC_E_IOC_ENABLED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
+                break;
+        case IOCFC_E_IOC_DISABLED:
+                bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
+                iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
+                bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
+                             bfa_iocfc_disable_cb, iocfc->bfa);
+                break;
+        case IOCFC_E_IOC_FAILED:
+                break;
+        default:
+                bfa_sm_fault(iocfc->bfa, event);
+                break;
+        }
+}
 
 /*
  * BFA Interrupt handling functions
@@ -532,11 +950,9 @@ bfa_iocfc_send_cfg(void *bfa_arg)
          * Enable interrupt coalescing if it is driver init path
          * and not ioc disable/enable path.
          */
-        if (!iocfc->cfgdone)
+        if (bfa_fsm_cmp_state(iocfc, bfa_iocfc_sm_init_cfg_wait))
                 cfg_info->intr_attr.coalesce = BFA_TRUE;
 
-        iocfc->cfgdone = BFA_FALSE;
-
         /*
          * dma map IOC configuration itself
          */
@@ -556,8 +972,6 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 
         bfa->bfad = bfad;
         iocfc->bfa = bfa;
-        iocfc->action = BFA_IOCFC_ACT_NONE;
-
         iocfc->cfg = *cfg;
 
         /*
@@ -690,6 +1104,8 @@ bfa_iocfc_start_submod(struct bfa_s *bfa)
 
         for (i = 0; hal_mods[i]; i++)
                 hal_mods[i]->start(bfa);
+
+        bfa->iocfc.submod_enabled = BFA_TRUE;
 }
 
 /*
@@ -700,8 +1116,13 @@ bfa_iocfc_disable_submod(struct bfa_s *bfa)
 {
         int             i;
 
+        if (bfa->iocfc.submod_enabled == BFA_FALSE)
+                return;
+
         for (i = 0; hal_mods[i]; i++)
                 hal_mods[i]->iocdisable(bfa);
+
+        bfa->iocfc.submod_enabled = BFA_FALSE;
 }
 
 static void
@@ -709,15 +1130,8 @@ bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete)
 {
         struct bfa_s    *bfa = bfa_arg;
 
-        if (complete) {
-                if (bfa->iocfc.cfgdone && BFA_DCONF_MOD(bfa)->flashdone)
-                        bfa_cb_init(bfa->bfad, BFA_STATUS_OK);
-                else
-                        bfa_cb_init(bfa->bfad, BFA_STATUS_FAILED);
-        } else {
-                if (bfa->iocfc.cfgdone)
-                        bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
-        }
+        if (complete)
+                bfa_cb_init(bfa->bfad, bfa->iocfc.op_status);
 }
 
 static void
@@ -728,8 +1142,6 @@ bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl)
 
         if (compl)
                 complete(&bfad->comp);
-        else
-                bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
 }
 
 static void
@@ -801,8 +1213,6 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
         fwcfg->num_uf_bufs    = be16_to_cpu(fwcfg->num_uf_bufs);
         fwcfg->num_rports     = be16_to_cpu(fwcfg->num_rports);
 
-        iocfc->cfgdone = BFA_TRUE;
-
         /*
          * configure queue register offsets as learnt from firmware
          */
@@ -818,22 +1228,13 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
          */
         bfa_msix_queue_install(bfa);
 
-        /*
-         * Configuration is complete - initialize/start submodules
-         */
-        bfa_fcport_init(bfa);
-
-        if (iocfc->action == BFA_IOCFC_ACT_INIT) {
-                if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
-                        bfa_cb_queue(bfa, &iocfc->init_hcb_qe,
-                                bfa_iocfc_init_cb, bfa);
-        } else {
-                if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
-                        bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
-                                        bfa_iocfc_enable_cb, bfa);
-                bfa_iocfc_start_submod(bfa);
+        if (bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn != 0) {
+                bfa->ioc.attr->pwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn;
+                bfa->ioc.attr->nwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_nwwn;
+                bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE);
         }
 }
+
 void
 bfa_iocfc_reset_queues(struct bfa_s *bfa)
 {
@@ -847,6 +1248,23 @@ bfa_iocfc_reset_queues(struct bfa_s *bfa)
         }
 }
 
+/*
+ *      Process FAA pwwn msg from fw.
+ */
+static void
+bfa_iocfc_process_faa_addr(struct bfa_s *bfa, struct bfi_faa_addr_msg_s *msg)
+{
+        struct bfa_iocfc_s              *iocfc   = &bfa->iocfc;
+        struct bfi_iocfc_cfgrsp_s       *cfgrsp  = iocfc->cfgrsp;
+
+        cfgrsp->pbc_cfg.pbc_pwwn = msg->pwwn;
+        cfgrsp->pbc_cfg.pbc_nwwn = msg->nwwn;
+
+        bfa->ioc.attr->pwwn = msg->pwwn;
+        bfa->ioc.attr->nwwn = msg->nwwn;
+        bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE);
+}
+
 /* Fabric Assigned Address specific functions */
 
 /*
@@ -862,84 +1280,13 @@ bfa_faa_validate_request(struct bfa_s *bfa)
                 if ((ioc_type != BFA_IOC_TYPE_FC) || bfa_mfg_is_mezz(card_type))
                         return BFA_STATUS_FEATURE_NOT_SUPPORTED;
         } else {
-                if (!bfa_ioc_is_acq_addr(&bfa->ioc))
-                        return BFA_STATUS_IOC_NON_OP;
+                return BFA_STATUS_IOC_NON_OP;
         }
 
         return BFA_STATUS_OK;
 }
 
 bfa_status_t
-bfa_faa_enable(struct bfa_s *bfa, bfa_cb_iocfc_t cbfn, void *cbarg)
-{
-        struct bfi_faa_en_dis_s faa_enable_req;
-        struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
-        bfa_status_t            status;
-
-        iocfc->faa_args.faa_cb.faa_cbfn = cbfn;
-        iocfc->faa_args.faa_cb.faa_cbarg = cbarg;
-
-        status = bfa_faa_validate_request(bfa);
-        if (status != BFA_STATUS_OK)
-                return status;
-
-        if (iocfc->faa_args.busy == BFA_TRUE)
-                return BFA_STATUS_DEVBUSY;
-
-        if (iocfc->faa_args.faa_state == BFA_FAA_ENABLED)
-                return BFA_STATUS_FAA_ENABLED;
-
-        if (bfa_fcport_is_trunk_enabled(bfa))
-                return BFA_STATUS_ERROR_TRUNK_ENABLED;
-
-        bfa_fcport_cfg_faa(bfa, BFA_FAA_ENABLED);
-        iocfc->faa_args.busy = BFA_TRUE;
-
-        memset(&faa_enable_req, 0, sizeof(struct bfi_faa_en_dis_s));
-        bfi_h2i_set(faa_enable_req.mh, BFI_MC_IOCFC,
-                BFI_IOCFC_H2I_FAA_ENABLE_REQ, bfa_fn_lpu(bfa));
-
-        bfa_ioc_mbox_send(&bfa->ioc, &faa_enable_req,
-                        sizeof(struct bfi_faa_en_dis_s));
-
-        return BFA_STATUS_OK;
-}
-
-bfa_status_t
-bfa_faa_disable(struct bfa_s *bfa, bfa_cb_iocfc_t cbfn,
-                void *cbarg)
-{
-        struct bfi_faa_en_dis_s faa_disable_req;
-        struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
-        bfa_status_t            status;
-
-        iocfc->faa_args.faa_cb.faa_cbfn = cbfn;
-        iocfc->faa_args.faa_cb.faa_cbarg = cbarg;
-
-        status = bfa_faa_validate_request(bfa);
-        if (status != BFA_STATUS_OK)
-                return status;
-
-        if (iocfc->faa_args.busy == BFA_TRUE)
-                return BFA_STATUS_DEVBUSY;
-
-        if (iocfc->faa_args.faa_state == BFA_FAA_DISABLED)
-                return BFA_STATUS_FAA_DISABLED;
-
-        bfa_fcport_cfg_faa(bfa, BFA_FAA_DISABLED);
-        iocfc->faa_args.busy = BFA_TRUE;
-
-        memset(&faa_disable_req, 0, sizeof(struct bfi_faa_en_dis_s));
-        bfi_h2i_set(faa_disable_req.mh, BFI_MC_IOCFC,
-                BFI_IOCFC_H2I_FAA_DISABLE_REQ, bfa_fn_lpu(bfa));
-
-        bfa_ioc_mbox_send(&bfa->ioc, &faa_disable_req,
-                sizeof(struct bfi_faa_en_dis_s));
-
-        return BFA_STATUS_OK;
-}
-
-bfa_status_t
 bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
                 bfa_cb_iocfc_t cbfn, void *cbarg)
 {
@@ -970,38 +1317,6 @@ bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
 }
 
 /*
- *      FAA enable response
- */
-static void
-bfa_faa_enable_reply(struct bfa_iocfc_s *iocfc,
-                struct bfi_faa_en_dis_rsp_s *rsp)
-{
-        void    *cbarg = iocfc->faa_args.faa_cb.faa_cbarg;
-        bfa_status_t    status = rsp->status;
-
-        WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn);
-
-        iocfc->faa_args.faa_cb.faa_cbfn(cbarg, status);
-        iocfc->faa_args.busy = BFA_FALSE;
-}
-
-/*
- *      FAA disable response
- */
-static void
-bfa_faa_disable_reply(struct bfa_iocfc_s *iocfc,
-                struct bfi_faa_en_dis_rsp_s *rsp)
-{
-        void    *cbarg = iocfc->faa_args.faa_cb.faa_cbarg;
-        bfa_status_t    status = rsp->status;
-
-        WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn);
-
-        iocfc->faa_args.faa_cb.faa_cbfn(cbarg, status);
-        iocfc->faa_args.busy = BFA_FALSE;
-}
-
-/*
  *      FAA query response
  */
 static void
@@ -1030,25 +1345,10 @@ bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status)
 {
         struct bfa_s    *bfa = bfa_arg;
 
-        if (status == BFA_STATUS_FAA_ACQ_ADDR) {
-                bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
-                                bfa_iocfc_init_cb, bfa);
-                return;
-        }
-
-        if (status != BFA_STATUS_OK) {
-                bfa_isr_disable(bfa);
-                if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
-                        bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
-                                     bfa_iocfc_init_cb, bfa);
-                else if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
-                        bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
-                                        bfa_iocfc_enable_cb, bfa);
-                return;
-        }
-
-        bfa_iocfc_send_cfg(bfa);
-        bfa_dconf_modinit(bfa);
+        if (status == BFA_STATUS_OK)
+                bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_ENABLED);
+        else
+                bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED);
 }
 
 /*
@@ -1059,17 +1359,7 @@ bfa_iocfc_disable_cbfn(void *bfa_arg)
 {
         struct bfa_s    *bfa = bfa_arg;
 
-        bfa_isr_disable(bfa);
-        bfa_iocfc_disable_submod(bfa);
-
-        if (bfa->iocfc.action == BFA_IOCFC_ACT_STOP)
-                bfa_cb_queue(bfa, &bfa->iocfc.stop_hcb_qe, bfa_iocfc_stop_cb,
-                             bfa);
-        else {
-                WARN_ON(bfa->iocfc.action != BFA_IOCFC_ACT_DISABLE);
-                bfa_cb_queue(bfa, &bfa->iocfc.dis_hcb_qe, bfa_iocfc_disable_cb,
-                             bfa);
-        }
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_DISABLED);
 }
 
 /*
@@ -1081,13 +1371,7 @@ bfa_iocfc_hbfail_cbfn(void *bfa_arg)
         struct bfa_s    *bfa = bfa_arg;
 
         bfa->queue_process = BFA_FALSE;
-
-        bfa_isr_disable(bfa);
-        bfa_iocfc_disable_submod(bfa);
-
-        if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
-                bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe, bfa_iocfc_init_cb,
-                             bfa);
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED);
 }
 
 /*
@@ -1102,7 +1386,6 @@ bfa_iocfc_reset_cbfn(void *bfa_arg)
         bfa_isr_enable(bfa);
 }
 
-
 /*
  * Query IOC memory requirement information.
  */
@@ -1178,6 +1461,12 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         INIT_LIST_HEAD(&bfa->comp_q);
         for (i = 0; i < BFI_IOC_MAX_CQS; i++)
                 INIT_LIST_HEAD(&bfa->reqq_waitq[i]);
+
+        bfa->iocfc.cb_reqd = BFA_FALSE;
+        bfa->iocfc.op_status = BFA_STATUS_OK;
+        bfa->iocfc.submod_enabled = BFA_FALSE;
+
+        bfa_fsm_set_state(&bfa->iocfc, bfa_iocfc_sm_stopped);
 }
 
 /*
@@ -1186,8 +1475,7 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 void
 bfa_iocfc_init(struct bfa_s *bfa)
 {
-        bfa->iocfc.action = BFA_IOCFC_ACT_INIT;
-        bfa_ioc_enable(&bfa->ioc);
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_INIT);
 }
 
 /*
@@ -1197,8 +1485,7 @@ bfa_iocfc_init(struct bfa_s *bfa)
 void
 bfa_iocfc_start(struct bfa_s *bfa)
 {
-        if (bfa->iocfc.cfgdone)
-                bfa_iocfc_start_submod(bfa);
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_START);
 }
 
 /*
@@ -1208,12 +1495,8 @@ bfa_iocfc_start(struct bfa_s *bfa)
 void
 bfa_iocfc_stop(struct bfa_s *bfa)
 {
-        bfa->iocfc.action = BFA_IOCFC_ACT_STOP;
-
         bfa->queue_process = BFA_FALSE;
-        bfa_dconf_modexit(bfa);
-        if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
-                bfa_ioc_disable(&bfa->ioc);
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_STOP);
 }
 
 void
@@ -1233,13 +1516,9 @@ bfa_iocfc_isr(void *bfaarg, struct bfi_mbmsg_s *m)
         case BFI_IOCFC_I2H_UPDATEQ_RSP:
                 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK);
                 break;
-        case BFI_IOCFC_I2H_FAA_ENABLE_RSP:
-                bfa_faa_enable_reply(iocfc,
-                        (struct bfi_faa_en_dis_rsp_s *)msg);
-                break;
-        case BFI_IOCFC_I2H_FAA_DISABLE_RSP:
-                bfa_faa_disable_reply(iocfc,
-                        (struct bfi_faa_en_dis_rsp_s *)msg);
+        case BFI_IOCFC_I2H_ADDR_MSG:
+                bfa_iocfc_process_faa_addr(bfa,
+                                (struct bfi_faa_addr_msg_s *)msg);
                 break;
         case BFI_IOCFC_I2H_FAA_QUERY_RSP:
                 bfa_faa_query_reply(iocfc, (bfi_faa_query_rsp_t *)msg);
@@ -1313,8 +1592,8 @@ bfa_iocfc_enable(struct bfa_s *bfa)
 {
         bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
                      "IOC Enable");
-        bfa->iocfc.action = BFA_IOCFC_ACT_ENABLE;
-        bfa_ioc_enable(&bfa->ioc);
+        bfa->iocfc.cb_reqd = BFA_TRUE;
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_ENABLE);
 }
 
 void
@@ -1322,17 +1601,16 @@ bfa_iocfc_disable(struct bfa_s *bfa)
 {
         bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
                      "IOC Disable");
-        bfa->iocfc.action = BFA_IOCFC_ACT_DISABLE;
 
         bfa->queue_process = BFA_FALSE;
-        bfa_ioc_disable(&bfa->ioc);
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DISABLE);
 }
 
-
 bfa_boolean_t
 bfa_iocfc_is_operational(struct bfa_s *bfa)
 {
-        return bfa_ioc_is_operational(&bfa->ioc) && bfa->iocfc.cfgdone;
+        return bfa_ioc_is_operational(&bfa->ioc) &&
+                bfa_fsm_cmp_state(&bfa->iocfc, bfa_iocfc_sm_operational);
 }
 
 /*
@@ -1574,16 +1852,6 @@ bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q)
         }
 }
 
-void
-bfa_iocfc_cb_dconf_modinit(struct bfa_s *bfa, bfa_status_t status)
-{
-        if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT) {
-                if (bfa->iocfc.cfgdone == BFA_TRUE)
-                        bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
-                                bfa_iocfc_init_cb, bfa);
-        }
-}
-
 /*
  * Return the list of PCI vendor/device id lists supported by this
  * BFA instance.
diff --git a/drivers/scsi/bfa/bfa_defs_svc.h b/drivers/scsi/bfa/bfa_defs_svc.h
index cb07c628b2f1..36756ce0e58f 100644
--- a/drivers/scsi/bfa/bfa_defs_svc.h
+++ b/drivers/scsi/bfa/bfa_defs_svc.h
@@ -52,7 +52,7 @@ struct bfa_iocfc_fwcfg_s {
         u16             num_uf_bufs;    /*  unsolicited recv buffers    */
         u8              num_cqs;
         u8              fw_tick_res;    /*  FW clock resolution in ms */
-        u8              rsvd[2];
+        u8              rsvd[6];
 };
 #pragma pack()
 
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index 3164f7bec475..56cf3f6c6884 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -88,7 +88,6 @@ static void bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc);
 static void bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
 static void bfa_ioc_mbox_flush(struct bfa_ioc_s *ioc);
 static void bfa_ioc_recover(struct bfa_ioc_s *ioc);
-static void bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc);
 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);
@@ -113,7 +112,6 @@ enum ioc_event {
         IOC_E_HWERROR           = 10,   /*  hardware error interrupt    */
         IOC_E_TIMEOUT           = 11,   /*  timeout                     */
         IOC_E_HWFAILED          = 12,   /*  PCI mapping failure notice  */
-        IOC_E_FWRSP_ACQ_ADDR    = 13,   /*  Acquiring address           */
 };
 
 bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc_s, enum ioc_event);
@@ -126,7 +124,6 @@ bfa_fsm_state_decl(bfa_ioc, fail, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event);
 bfa_fsm_state_decl(bfa_ioc, hwfail, struct bfa_ioc_s, enum ioc_event);
-bfa_fsm_state_decl(bfa_ioc, acq_addr, struct bfa_ioc_s, enum ioc_event);
 
 static struct bfa_sm_table_s ioc_sm_table[] = {
         {BFA_SM(bfa_ioc_sm_uninit), BFA_IOC_UNINIT},
@@ -139,7 +136,6 @@ static struct bfa_sm_table_s ioc_sm_table[] = {
         {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
         {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
         {BFA_SM(bfa_ioc_sm_hwfail), BFA_IOC_HWFAIL},
-        {BFA_SM(bfa_ioc_sm_acq_addr), BFA_IOC_ACQ_ADDR},
 };
 
 /*
@@ -370,17 +366,9 @@ bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
         switch (event) {
         case IOC_E_FWRSP_GETATTR:
                 bfa_ioc_timer_stop(ioc);
-                bfa_ioc_check_attr_wwns(ioc);
-                bfa_ioc_hb_monitor(ioc);
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
                 break;
 
-        case IOC_E_FWRSP_ACQ_ADDR:
-                bfa_ioc_timer_stop(ioc);
-                bfa_ioc_hb_monitor(ioc);
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_acq_addr);
-                break;
-
         case IOC_E_PFFAILED:
         case IOC_E_HWERROR:
                 bfa_ioc_timer_stop(ioc);
@@ -405,51 +393,6 @@ bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
         }
 }
 
-/*
- * Acquiring address from fabric (entry function)
- */
-static void
-bfa_ioc_sm_acq_addr_entry(struct bfa_ioc_s *ioc)
-{
-}
-
-/*
- *      Acquiring address from the fabric
- */
-static void
-bfa_ioc_sm_acq_addr(struct bfa_ioc_s *ioc, enum ioc_event event)
-{
-        bfa_trc(ioc, event);
-
-        switch (event) {
-        case IOC_E_FWRSP_GETATTR:
-                bfa_ioc_check_attr_wwns(ioc);
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
-                break;
-
-        case IOC_E_PFFAILED:
-        case IOC_E_HWERROR:
-                bfa_hb_timer_stop(ioc);
-        case IOC_E_HBFAIL:
-                ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
-                if (event != IOC_E_PFFAILED)
-                        bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
-                break;
-
-        case IOC_E_DISABLE:
-                bfa_hb_timer_stop(ioc);
-                bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
-                break;
-
-        case IOC_E_ENABLE:
-                break;
-
-        default:
-                bfa_sm_fault(ioc, event);
-        }
-}
-
 static void
 bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
 {
@@ -457,6 +400,7 @@ bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
 
         ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
         bfa_ioc_event_notify(ioc, BFA_IOC_E_ENABLED);
+        bfa_ioc_hb_monitor(ioc);
         BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC enabled\n");
         bfa_ioc_aen_post(ioc, BFA_IOC_AEN_ENABLE);
 }
@@ -2156,10 +2100,6 @@ bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)
                 bfa_ioc_getattr_reply(ioc);
                 break;
 
-        case BFI_IOC_I2H_ACQ_ADDR_REPLY:
-                bfa_fsm_send_event(ioc, IOC_E_FWRSP_ACQ_ADDR);
-                break;
-
         default:
                 bfa_trc(ioc, msg->mh.msg_id);
                 WARN_ON(1);
@@ -2450,15 +2390,6 @@ bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
 }
 
 /*
- * Return TRUE if IOC is in acquiring address state
- */
-bfa_boolean_t
-bfa_ioc_is_acq_addr(struct bfa_ioc_s *ioc)
-{
-        return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_acq_addr);
-}
-
-/*
  * return true if IOC firmware is different.
  */
 bfa_boolean_t
@@ -2950,17 +2881,6 @@ bfa_ioc_recover(struct bfa_ioc_s *ioc)
         bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
 }
 
-static void
-bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc)
-{
-        if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_LL)
-                return;
-        if (ioc->attr->nwwn == 0)
-                bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_NWWN);
-        if (ioc->attr->pwwn == 0)
-                bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_PWWN);
-}
-
 /*
  *  BFA IOC PF private functions
  */
@@ -5675,24 +5595,27 @@ bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
         case BFA_DCONF_SM_INIT:
                 if (dconf->min_cfg) {
                         bfa_trc(dconf->bfa, dconf->min_cfg);
+                        bfa_fsm_send_event(&dconf->bfa->iocfc,
+                                        IOCFC_E_DCONF_DONE);
                         return;
                 }
                 bfa_sm_set_state(dconf, bfa_dconf_sm_flash_read);
-                dconf->flashdone = BFA_FALSE;
-                bfa_trc(dconf->bfa, dconf->flashdone);
+                bfa_timer_start(dconf->bfa, &dconf->timer,
+                        bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
                 bfa_status = bfa_flash_read_part(BFA_FLASH(dconf->bfa),
                                         BFA_FLASH_PART_DRV, dconf->instance,
                                         dconf->dconf,
                                         sizeof(struct bfa_dconf_s), 0,
                                         bfa_dconf_init_cb, dconf->bfa);
                 if (bfa_status != BFA_STATUS_OK) {
+                        bfa_timer_stop(&dconf->timer);
                         bfa_dconf_init_cb(dconf->bfa, BFA_STATUS_FAILED);
                         bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
                         return;
                 }
                 break;
         case BFA_DCONF_SM_EXIT:
-                dconf->flashdone = BFA_TRUE;
+                bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
         case BFA_DCONF_SM_IOCDISABLE:
         case BFA_DCONF_SM_WR:
         case BFA_DCONF_SM_FLASH_COMP:
@@ -5713,15 +5636,20 @@ bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
 
         switch (event) {
         case BFA_DCONF_SM_FLASH_COMP:
+                bfa_timer_stop(&dconf->timer);
                 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
                 break;
         case BFA_DCONF_SM_TIMEOUT:
                 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
+                bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_IOC_FAILED);
                 break;
         case BFA_DCONF_SM_EXIT:
-                dconf->flashdone = BFA_TRUE;
-                bfa_trc(dconf->bfa, dconf->flashdone);
+                bfa_timer_stop(&dconf->timer);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
+                break;
         case BFA_DCONF_SM_IOCDISABLE:
+                bfa_timer_stop(&dconf->timer);
                 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
                 break;
         default:
@@ -5744,9 +5672,8 @@ bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
                 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
                 break;
         case BFA_DCONF_SM_EXIT:
-                dconf->flashdone = BFA_TRUE;
-                bfa_trc(dconf->bfa, dconf->flashdone);
                 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
                 break;
         case BFA_DCONF_SM_INIT:
         case BFA_DCONF_SM_IOCDISABLE:
@@ -5808,9 +5735,7 @@ bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
                 bfa_timer_stop(&dconf->timer);
         case BFA_DCONF_SM_TIMEOUT:
                 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
-                dconf->flashdone = BFA_TRUE;
-                bfa_trc(dconf->bfa, dconf->flashdone);
-                bfa_ioc_disable(&dconf->bfa->ioc);
+                bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
                 break;
         default:
                 bfa_sm_fault(dconf->bfa, event);
@@ -5857,8 +5782,8 @@ bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
                 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
                 break;
         case BFA_DCONF_SM_EXIT:
-                dconf->flashdone = BFA_TRUE;
                 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
                 break;
         case BFA_DCONF_SM_IOCDISABLE:
                 break;
@@ -5899,11 +5824,6 @@ bfa_dconf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         if (cfg->drvcfg.min_cfg) {
                 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_hdr_s);
                 dconf->min_cfg = BFA_TRUE;
-                /*
-                 * Set the flashdone flag to TRUE explicitly as no flash
-                 * write will happen in min_cfg mode.
-                 */
-                dconf->flashdone = BFA_TRUE;
         } else {
                 dconf->min_cfg = BFA_FALSE;
                 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_s);
@@ -5919,9 +5839,7 @@ bfa_dconf_init_cb(void *arg, bfa_status_t status)
         struct bfa_s *bfa = arg;
         struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
 
-        dconf->flashdone = BFA_TRUE;
-        bfa_trc(bfa, dconf->flashdone);
-        bfa_iocfc_cb_dconf_modinit(bfa, status);
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
         if (status == BFA_STATUS_OK) {
                 bfa_dconf_read_data_valid(bfa) = BFA_TRUE;
                 if (dconf->dconf->hdr.signature != BFI_DCONF_SIGNATURE)
@@ -5929,7 +5847,7 @@ bfa_dconf_init_cb(void *arg, bfa_status_t status)
                 if (dconf->dconf->hdr.version != BFI_DCONF_VERSION)
                         dconf->dconf->hdr.version = BFI_DCONF_VERSION;
         }
-        bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
+        bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DCONF_DONE);
 }
 
 void
@@ -6011,7 +5929,5 @@ void
 bfa_dconf_modexit(struct bfa_s *bfa)
 {
         struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
-        BFA_DCONF_MOD(bfa)->flashdone = BFA_FALSE;
-        bfa_trc(bfa, BFA_DCONF_MOD(bfa)->flashdone);
         bfa_sm_send_event(dconf, BFA_DCONF_SM_EXIT);
 }
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index 546d46b37101..1a99d4b5b50f 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -373,6 +373,22 @@ struct bfa_cb_qe_s {
 };
 
 /*
+ * IOCFC state machine definitions/declarations
+ */
+enum iocfc_event {
+        IOCFC_E_INIT            = 1,    /* IOCFC init request           */
+        IOCFC_E_START           = 2,    /* IOCFC mod start request      */
+        IOCFC_E_STOP            = 3,    /* IOCFC stop request           */
+        IOCFC_E_ENABLE          = 4,    /* IOCFC enable request         */
+        IOCFC_E_DISABLE         = 5,    /* IOCFC disable request        */
+        IOCFC_E_IOC_ENABLED     = 6,    /* IOC enabled message          */
+        IOCFC_E_IOC_DISABLED    = 7,    /* IOC disabled message         */
+        IOCFC_E_IOC_FAILED      = 8,    /* failure notice by IOC sm     */
+        IOCFC_E_DCONF_DONE      = 9,    /* dconf read/write done        */
+        IOCFC_E_CFG_DONE        = 10,   /* IOCFC config complete        */
+};
+
+/*
  * ASIC block configurtion related
  */
 
@@ -706,7 +722,6 @@ struct bfa_dconf_s {
 struct bfa_dconf_mod_s {
         bfa_sm_t                sm;
         u8                      instance;
-        bfa_boolean_t           flashdone;
         bfa_boolean_t           read_data_valid;
         bfa_boolean_t           min_cfg;
         struct bfa_timer_s      timer;
diff --git a/drivers/scsi/bfa/bfa_svc.c b/drivers/scsi/bfa/bfa_svc.c
index aa8a0eaf91f9..f92a85f037a3 100644
--- a/drivers/scsi/bfa/bfa_svc.c
+++ b/drivers/scsi/bfa/bfa_svc.c
@@ -3825,8 +3825,6 @@ bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
                         attr->port_state = BFA_PORT_ST_IOCDIS;
                 else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
                         attr->port_state = BFA_PORT_ST_FWMISMATCH;
-                else if (bfa_ioc_is_acq_addr(&fcport->bfa->ioc))
-                        attr->port_state = BFA_PORT_ST_ACQ_ADDR;
         }
 
         /* FCoE vlan */
diff --git a/drivers/scsi/bfa/bfa_svc.h b/drivers/scsi/bfa/bfa_svc.h
index b52cbb6bcd5a..f30067564639 100644
--- a/drivers/scsi/bfa/bfa_svc.h
+++ b/drivers/scsi/bfa/bfa_svc.h
@@ -663,10 +663,6 @@ void bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg);
 void bfa_cb_lps_cvl_event(void *bfad, void *uarg);
 
 /* FAA specific APIs */
-bfa_status_t bfa_faa_enable(struct bfa_s *bfa,
-                        bfa_cb_iocfc_t cbfn, void *cbarg);
-bfa_status_t bfa_faa_disable(struct bfa_s *bfa,
-                        bfa_cb_iocfc_t cbfn, void *cbarg);
 bfa_status_t bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
                         bfa_cb_iocfc_t cbfn, void *cbarg);
 
diff --git a/drivers/scsi/bfa/bfad_bsg.c b/drivers/scsi/bfa/bfad_bsg.c
index f62cf4981473..31a1d8a027b8 100644
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -1288,50 +1288,6 @@ out:
 }
 
 int
-bfad_iocmd_faa_enable(struct bfad_s *bfad, void *cmd)
-{
-        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
-        unsigned long   flags;
-        struct bfad_hal_comp    fcomp;
-
-        init_completion(&fcomp.comp);
-        iocmd->status = BFA_STATUS_OK;
-        spin_lock_irqsave(&bfad->bfad_lock, flags);
-        iocmd->status = bfa_faa_enable(&bfad->bfa, bfad_hcb_comp, &fcomp);
-        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
-
-        if (iocmd->status != BFA_STATUS_OK)
-                goto out;
-
-        wait_for_completion(&fcomp.comp);
-        iocmd->status = fcomp.status;
-out:
-        return 0;
-}
-
-int
-bfad_iocmd_faa_disable(struct bfad_s *bfad, void *cmd)
-{
-        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
-        unsigned long   flags;
-        struct bfad_hal_comp    fcomp;
-
-        init_completion(&fcomp.comp);
-        iocmd->status = BFA_STATUS_OK;
-        spin_lock_irqsave(&bfad->bfad_lock, flags);
-        iocmd->status = bfa_faa_disable(&bfad->bfa, bfad_hcb_comp, &fcomp);
-        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
-
-        if (iocmd->status != BFA_STATUS_OK)
-                goto out;
-
-        wait_for_completion(&fcomp.comp);
-        iocmd->status = fcomp.status;
-out:
-        return 0;
-}
-
-int
 bfad_iocmd_faa_query(struct bfad_s *bfad, void *cmd)
 {
         struct bfa_bsg_faa_attr_s *iocmd = (struct bfa_bsg_faa_attr_s *)cmd;
@@ -2636,12 +2592,6 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
         case IOCMD_FLASH_DISABLE_OPTROM:
                 rc = bfad_iocmd_ablk_optrom(bfad, cmd, iocmd);
                 break;
-        case IOCMD_FAA_ENABLE:
-                rc = bfad_iocmd_faa_enable(bfad, iocmd);
-                break;
-        case IOCMD_FAA_DISABLE:
-                rc = bfad_iocmd_faa_disable(bfad, iocmd);
-                break;
         case IOCMD_FAA_QUERY:
                 rc = bfad_iocmd_faa_query(bfad, iocmd);
                 break;
diff --git a/drivers/scsi/bfa/bfad_bsg.h b/drivers/scsi/bfa/bfad_bsg.h
index e859adb9aa9e..17ad67283130 100644
--- a/drivers/scsi/bfa/bfad_bsg.h
+++ b/drivers/scsi/bfa/bfad_bsg.h
@@ -83,8 +83,6 @@ enum {
         IOCMD_PORT_CFG_MODE,
         IOCMD_FLASH_ENABLE_OPTROM,
         IOCMD_FLASH_DISABLE_OPTROM,
-        IOCMD_FAA_ENABLE,
-        IOCMD_FAA_DISABLE,
         IOCMD_FAA_QUERY,
         IOCMD_CEE_GET_ATTR,
         IOCMD_CEE_GET_STATS,
diff --git a/drivers/scsi/bfa/bfi_ms.h b/drivers/scsi/bfa/bfi_ms.h
index 0d9f1fb50db0..d4220e13cafa 100644
--- a/drivers/scsi/bfa/bfi_ms.h
+++ b/drivers/scsi/bfa/bfi_ms.h
@@ -28,17 +28,15 @@ enum bfi_iocfc_h2i_msgs {
         BFI_IOCFC_H2I_CFG_REQ           = 1,
         BFI_IOCFC_H2I_SET_INTR_REQ      = 2,
         BFI_IOCFC_H2I_UPDATEQ_REQ       = 3,
-        BFI_IOCFC_H2I_FAA_ENABLE_REQ    = 4,
-        BFI_IOCFC_H2I_FAA_DISABLE_REQ   = 5,
-        BFI_IOCFC_H2I_FAA_QUERY_REQ     = 6,
+        BFI_IOCFC_H2I_FAA_QUERY_REQ     = 4,
+        BFI_IOCFC_H2I_ADDR_REQ          = 5,
 };
 
 enum bfi_iocfc_i2h_msgs {
         BFI_IOCFC_I2H_CFG_REPLY         = BFA_I2HM(1),
         BFI_IOCFC_I2H_UPDATEQ_RSP       = BFA_I2HM(3),
-        BFI_IOCFC_I2H_FAA_ENABLE_RSP    = BFA_I2HM(4),
-        BFI_IOCFC_I2H_FAA_DISABLE_RSP   = BFA_I2HM(5),
-        BFI_IOCFC_I2H_FAA_QUERY_RSP     = BFA_I2HM(6),
+        BFI_IOCFC_I2H_FAA_QUERY_RSP     = BFA_I2HM(4),
+        BFI_IOCFC_I2H_ADDR_MSG          = BFA_I2HM(5),
 };
 
 struct bfi_iocfc_cfg_s {
@@ -184,6 +182,13 @@ struct bfi_faa_en_dis_s {
         struct bfi_mhdr_s mh;   /* common msg header    */
 };
 
+struct bfi_faa_addr_msg_s {
+        struct  bfi_mhdr_s mh;  /* common msg header    */
+        u8      rsvd[4];
+        wwn_t   pwwn;           /* Fabric acquired PWWN */
+        wwn_t   nwwn;           /* Fabric acquired PWWN */
+};
+
 /*
  * BFI_IOCFC_H2I_FAA_QUERY_REQ message
  */