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

Pull SCSI updates from James Bottomley:
 "This is primarily another round of driver updates (lpfc, bfa, fcoe,
  ipr) plus a new ufshcd driver.  There shouldn't be anything
  controversial in here (The final deletion of scsi proc_ops which
  caused some build breakage has been held over until the next merge
  window to give us more time to stabilise it).

  I'm afraid, with me moving continents at exactly the wrong time,
  anything submitted after the merge window opened has been held over to
  the next merge window."

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (63 commits)
  [SCSI] ipr: Driver version 2.5.3
  [SCSI] ipr: Increase alignment boundary of command blocks
  [SCSI] ipr: Increase max concurrent oustanding commands
  [SCSI] ipr: Remove unnecessary memory barriers
  [SCSI] ipr: Remove unnecessary interrupt clearing on new adapters
  [SCSI] ipr: Fix target id allocation re-use problem
  [SCSI] atp870u, mpt2sas, qla4xxx use pci_dev->revision
  [SCSI] fcoe: Drop the rtnl_mutex before calling fcoe_ctlr_link_up
  [SCSI] bfa: Update the driver version to 3.0.23.0
  [SCSI] bfa: BSG and User interface fixes.
  [SCSI] bfa: Fix to avoid vport delete hang on request queue full scenario.
  [SCSI] bfa: Move service parameter programming logic into firmware.
  [SCSI] bfa: Revised Fabric Assigned Address(FAA) feature implementation.
  [SCSI] bfa: Flash controller IOC pll init fixes.
  [SCSI] bfa: Serialize the IOC hw semaphore unlock logic.
  [SCSI] bfa: Modify ISR to process pending completions
  [SCSI] bfa: Add fc host issue lip support
  [SCSI] mpt2sas: remove extraneous sas_log_info messages
  [SCSI] libfc: fcoe_transport_create fails in single-CPU environment
  [SCSI] fcoe: reduce contention for fcoe_rx_list lock [v2]
  ...

1 files changed, 484 insertions, 209 deletions

diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 4bd546bcc240..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
@@ -231,16 +649,19 @@ bfa_reqq_resume(struct bfa_s *bfa, int qid)
         }
 }
 
-static inline void
+bfa_boolean_t
 bfa_isr_rspq(struct bfa_s *bfa, int qid)
 {
         struct bfi_msg_s *m;
         u32     pi, ci;
         struct list_head *waitq;
+        bfa_boolean_t ret;
 
         ci = bfa_rspq_ci(bfa, qid);
         pi = bfa_rspq_pi(bfa, qid);
 
+        ret = (ci != pi);
+
         while (ci != pi) {
                 m = bfa_rspq_elem(bfa, qid, ci);
                 WARN_ON(m->mhdr.msg_class >= BFI_MC_MAX);
@@ -260,6 +681,8 @@ bfa_isr_rspq(struct bfa_s *bfa, int qid)
         waitq = bfa_reqq(bfa, qid);
         if (!list_empty(waitq))
                 bfa_reqq_resume(bfa, qid);
+
+        return ret;
 }
 
 static inline void
@@ -320,6 +743,7 @@ bfa_intx(struct bfa_s *bfa)
 {
         u32 intr, qintr;
         int queue;
+        bfa_boolean_t rspq_comp = BFA_FALSE;
 
         intr = readl(bfa->iocfc.bfa_regs.intr_status);
 
@@ -332,11 +756,12 @@ bfa_intx(struct bfa_s *bfa)
          */
         if (bfa->queue_process) {
                 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
-                        bfa_isr_rspq(bfa, queue);
+                        if (bfa_isr_rspq(bfa, queue))
+                                rspq_comp = BFA_TRUE;
         }
 
         if (!intr)
-                return BFA_TRUE;
+                return (qintr | rspq_comp) ? BFA_TRUE : BFA_FALSE;
 
         /*
          * CPE completion queue interrupt
@@ -525,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
          */
@@ -549,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;
 
         /*
@@ -683,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;
 }
 
 /*
@@ -693,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
@@ -702,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
@@ -721,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
@@ -794,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
          */
@@ -811,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)
 {
@@ -840,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 */
 
 /*
@@ -855,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)
 {
@@ -963,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
@@ -1023,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);
 }
 
 /*
@@ -1052,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);
 }
 
 /*
@@ -1074,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);
 }
 
 /*
@@ -1095,7 +1386,6 @@ bfa_iocfc_reset_cbfn(void *bfa_arg)
         bfa_isr_enable(bfa);
 }
 
-
 /*
  * Query IOC memory requirement information.
  */
@@ -1171,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);
 }
 
 /*
@@ -1179,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);
 }
 
 /*
@@ -1190,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);
 }
 
 /*
@@ -1201,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
@@ -1226,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);
@@ -1306,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
@@ -1315,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);
 }
 
 /*
@@ -1567,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.