[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>

diff --git a/drivers/scsi/bfa/bfa.h b/drivers/scsi/bfa/bfa.h
index a796de9..4ad7e36 100644 (file)
--- 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 035c9d5..456e576 100644 (file)
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -199,14 +199,432 @@ enum {
 #define DEF_CFG_NUM_SBOOT_TGTS         16
 #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,83 +1280,12 @@ 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)
@@ -969,38 +1316,6 @@ bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
        return BFA_STATUS_OK;
 }
 
-/*
- *     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
  */
@@ -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 cb07c62..36756ce 100644 (file)
--- 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 3164f7b..56cf3f6 100644 (file)
--- 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);
@@ -2449,15 +2389,6 @@ bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
                bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
 }
 
-/*
- * 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.
  */
@@ -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 546d46b..1a99d4b 100644 (file)
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -372,6 +372,22 @@ struct bfa_cb_qe_s {
        void            *cbarg;
 };
 
+/*
+ * 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 aa8a0ea..f92a85f 100644 (file)
--- 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 b52cbb6..f300675 100644 (file)
--- 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 f62cf49..31a1d8a 100644 (file)
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -1287,50 +1287,6 @@ out:
        return 0;
 }
 
-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)
 {
@@ -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 e859adb..17ad672 100644 (file)
--- 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 0d9f1fb..d4220e1 100644 (file)
--- 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
  */