// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. * Copyright (c) 2014- QLogic Corporation. * All rights reserved * www.qlogic.com * * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter. #include "bfad_drv.h" #include "bfad_im.h" #include "bfa_ioc.h" #include "bfi_reg.h" #include "bfa_defs.h" #include "bfa_defs_svc.h" #include "bfi.h" /* * IOC local definitions #define BFA_IOC_TOV 3000 /* msecs */ #define BFA_IOC_HWSEM_TOV 500 /* msecs */ #define BFA_IOC_HB_TOV 500 /* msecs */ #define BFA_IOC_TOV_RECOVER BFA_IOC_HB_TOV#define BFA_IOC_POLL_TOV BFA_TIMER_FREQ#define bfa_ioc_timer_start(__ioc) \#define bfa_ioc_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->ioc_timer)#define bfa_hb_timer_start(__ioc) \#define bfa_hb_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->hb_timer)#define BFA_DBG_FWTRC_OFF(_fn) (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))#define bfa_ioc_state_disabled(__sm) \/* * Asic specific macros : see bfa_hw_cb.c and bfa_hw_ct.c for details. #define bfa_ioc_firmware_lock(__ioc) \#define bfa_ioc_firmware_unlock(__ioc) \#define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))#define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))#define bfa_ioc_notify_fail(__ioc) \#define bfa_ioc_sync_start(__ioc) \#define bfa_ioc_sync_join(__ioc) \#define bfa_ioc_sync_leave(__ioc) \#define bfa_ioc_sync_ack(__ioc) \#define bfa_ioc_sync_complete(__ioc) \#define bfa_ioc_set_cur_ioc_fwstate(__ioc, __fwstate) \#define bfa_ioc_get_cur_ioc_fwstate(__ioc) \#define bfa_ioc_set_alt_ioc_fwstate(__ioc, __fwstate) \#define bfa_ioc_get_alt_ioc_fwstate(__ioc) \#define bfa_ioc_mbox_cmd_pending(__ioc) \/* * forward declarations static void bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc);static void bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force);static void bfa_ioc_timeout(void *ioc);static void bfa_ioc_poll_fwinit(struct bfa_ioc_s *ioc);static void bfa_ioc_send_enable(struct bfa_ioc_s *ioc);static void bfa_ioc_send_disable(struct bfa_ioc_s *ioc);static void bfa_ioc_send_getattr(struct bfa_ioc_s *ioc);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_event_notify(struct bfa_ioc_s *ioc ,enum bfa_ioc_event_e event);static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);static void bfa_ioc_fail_notify(struct bfa_ioc_s *ioc);static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc);static enum bfi_ioc_img_ver_cmp_e bfa_ioc_fw_ver_patch_cmp(struct bfi_ioc_image_hdr_s *base_fwhdr,struct bfi_ioc_image_hdr_s *fwhdr_to_cmp);static enum bfi_ioc_img_ver_cmp_e bfa_ioc_flash_fwver_cmp(struct bfa_ioc_s *ioc,struct bfi_ioc_image_hdr_s *base_fwhdr);/* * IOC state machine definitions/declarations struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_s, enum ioc_event);struct bfa_ioc_sm_table {/* state machine function */ enum bfa_ioc_state state; /* state machine encoding */ char *name; /* state name for display */ static struct bfa_ioc_sm_table ioc_sm_table[] = {static inline enum bfa_ioc_statestruct bfa_ioc_sm_table *smt, bfa_ioc_sm_t sm)int i = 0;while (smt[i].sm && smt[i].sm != sm)return smt[i].state;/* * IOCPF state machine definitions/declarations #define bfa_iocpf_timer_start(__ioc) \#define bfa_iocpf_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->ioc_timer)#define bfa_iocpf_poll_timer_start(__ioc) \#define bfa_sem_timer_start(__ioc) \#define bfa_sem_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->sem_timer)/* * Forward declareations for iocpf state machine static void bfa_iocpf_timeout(void *ioc_arg);static void bfa_iocpf_sem_timeout(void *ioc_arg);static void bfa_iocpf_poll_timeout(void *ioc_arg);/* * IOCPF states enum bfa_iocpf_state {/* IOC is in reset state */ /* Waiting for IOC h/w semaphore */ /* IOC h/w is being initialized */ /* IOCPF is initialized */ /* IOCPF failed */ /* IOCPF failed */ /* IOCPF is being disabled */ /* IOCPF is disabled */ /* IOC f/w different from drivers */ struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s,enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_s,enum iocpf_event);struct bfa_iocpf_s, enum iocpf_event);struct bfa_iocpf_sm_table {/* state machine function */ enum bfa_iocpf_state state; /* state machine encoding */ char *name; /* state name for display */ static inline enum bfa_iocpf_statestruct bfa_iocpf_sm_table *smt, bfa_iocpf_sm_t sm)int i = 0;while (smt[i].sm && smt[i].sm != sm)return smt[i].state;static struct bfa_iocpf_sm_table iocpf_sm_table[] = {/* * IOC State Machine /* * Beginning state. IOC uninit state. static void struct bfa_ioc_s *ioc)/* * IOC is in uninit state. static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_RESET:break ;default :/* * Reset entry actions -- initialize state machine static void struct bfa_ioc_s *ioc)/* * IOC is in reset state. static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_ENABLE:break ;case IOC_E_DISABLE:break ;case IOC_E_DETACH:break ;default :static void struct bfa_ioc_s *ioc)/* * Host IOC function is being enabled, awaiting response from firmware. * Semaphore is acquired. static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_ENABLED:break ;case IOC_E_PFFAILED:/* !!! fall through !!! */ case IOC_E_HWERROR:if (event != IOC_E_PFFAILED)break ;case IOC_E_HWFAILED:break ;case IOC_E_DISABLE:break ;case IOC_E_DETACH:break ;case IOC_E_ENABLE:break ;default :static void struct bfa_ioc_s *ioc)/* * IOC configuration in progress. Timer is active. static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_FWRSP_GETATTR:break ;case IOC_E_PFFAILED:case IOC_E_HWERROR:case IOC_E_TIMEOUT:if (event != IOC_E_PFFAILED)break ;case IOC_E_DISABLE:break ;case IOC_E_ENABLE:break ;default :static void struct bfa_ioc_s *ioc)struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;"IOC enabled\n" );static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_ENABLE:break ;case IOC_E_DISABLE:break ;case IOC_E_PFFAILED:case IOC_E_HWERROR:case IOC_E_HBFAIL:if (ioc->iocpf.auto_recover)else if (event != IOC_E_PFFAILED)break ;default :static void struct bfa_ioc_s *ioc)struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;"IOC disabled\n" );/* * IOC is being disabled static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_DISABLED:break ;case IOC_E_HWERROR:/* * No state change. Will move to disabled state * after iocpf sm completes failure processing and * moves to disabled state. break ;case IOC_E_HWFAILED:break ;default :/* * IOC disable completion entry. static void struct bfa_ioc_s *ioc)static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_ENABLE:break ;case IOC_E_DISABLE:break ;case IOC_E_DETACH:break ;default :static void struct bfa_ioc_s *ioc)/* * Hardware initialization retry. static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_ENABLED:break ;case IOC_E_PFFAILED:case IOC_E_HWERROR:/* * Initialization retry failed. if (event != IOC_E_PFFAILED)break ;case IOC_E_HWFAILED:break ;case IOC_E_ENABLE:break ;case IOC_E_DISABLE:break ;case IOC_E_DETACH:break ;default :static void struct bfa_ioc_s *ioc)/* * IOC failure. static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_ENABLE:break ;case IOC_E_DISABLE:break ;case IOC_E_DETACH:break ;case IOC_E_HWERROR:case IOC_E_HWFAILED:/* * HB failure / HW error notification, ignore. break ;default :static void struct bfa_ioc_s *ioc)static void struct bfa_ioc_s *ioc, enum ioc_event event)switch (event) {case IOC_E_ENABLE:break ;case IOC_E_DISABLE:break ;case IOC_E_DETACH:break ;case IOC_E_HWERROR:/* Ignore - already in hwfail state */ break ;default :/* * IOCPF State Machine /* * Reset entry actions -- initialize state machine static void struct bfa_iocpf_s *iocpf)/* * Beginning state. IOC is in reset state. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_ENABLE:break ;case IOCPF_E_STOP:break ;default :/* * Semaphore should be acquired for version check. static void struct bfa_iocpf_s *iocpf)struct bfi_ioc_image_hdr_s fwhdr;int i;/* * Spin on init semaphore to serialize. while (r32 & 0x1) {/* h/w sem init */ if (fwstate == BFI_IOC_UNINIT) {goto sem_get;if (swab32(fwhdr.exec) == BFI_FWBOOT_TYPE_NORMAL) {goto sem_get;/* * Clear fwver hdr for (i = 0; i < sizeof (struct bfi_ioc_image_hdr_s) / sizeof (u32); i++) {sizeof (u32);/* * Unlock the hw semaphore. Should be here only once per boot. /* * unlock init semaphore. /* * Awaiting h/w semaphore to continue with version check. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_SEMLOCKED:if (bfa_ioc_firmware_lock(ioc)) {if (bfa_ioc_sync_start(ioc)) {else {else {break ;case IOCPF_E_SEM_ERROR:break ;case IOCPF_E_DISABLE:break ;case IOCPF_E_STOP:break ;default :/* * Notify enable completion callback. static void struct bfa_iocpf_s *iocpf)/* * Call only the first time sm enters fwmismatch state. if (iocpf->fw_mismatch_notified == BFA_FALSE)/* * Awaiting firmware version match. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_TIMEOUT:break ;case IOCPF_E_DISABLE:break ;case IOCPF_E_STOP:break ;default :/* * Request for semaphore. static void struct bfa_iocpf_s *iocpf)/* * Awaiting semaphore for h/w initialzation. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_SEMLOCKED:if (bfa_ioc_sync_complete(ioc)) {else {break ;case IOCPF_E_SEM_ERROR:break ;case IOCPF_E_DISABLE:break ;default :static void struct bfa_iocpf_s *iocpf)/* * Hardware is being initialized. Interrupts are enabled. * Holding hardware semaphore lock. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_FWREADY:break ;case IOCPF_E_TIMEOUT:break ;case IOCPF_E_DISABLE:break ;default :static void struct bfa_iocpf_s *iocpf)/* * Enable Interrupts before sending fw IOC ENABLE cmd. /* * Host IOC function is being enabled, awaiting response from firmware. * Semaphore is acquired. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_FWRSP_ENABLE:break ;case IOCPF_E_INITFAIL:case IOCPF_E_TIMEOUT:if (event == IOCPF_E_TIMEOUT)break ;case IOCPF_E_DISABLE:break ;default :static void struct bfa_iocpf_s *iocpf)static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_DISABLE:break ;case IOCPF_E_GETATTRFAIL:break ;case IOCPF_E_FAIL:break ;default :static void struct bfa_iocpf_s *iocpf)/* * IOC is being disabled static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_FWRSP_DISABLE:break ;case IOCPF_E_FAIL:case IOCPF_E_TIMEOUT:break ;case IOCPF_E_FWRSP_ENABLE:break ;default :static void struct bfa_iocpf_s *iocpf)/* * IOC hb ack request is being removed. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_SEMLOCKED:break ;case IOCPF_E_SEM_ERROR:break ;case IOCPF_E_FAIL:break ;default :/* * IOC disable completion entry. static void struct bfa_iocpf_s *iocpf)static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_ENABLE:break ;case IOCPF_E_STOP:break ;default :static void struct bfa_iocpf_s *iocpf)/* * Hardware initialization failed. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_SEMLOCKED:break ;case IOCPF_E_SEM_ERROR:break ;case IOCPF_E_DISABLE:break ;case IOCPF_E_STOP:break ;case IOCPF_E_FAIL:break ;default :static void struct bfa_iocpf_s *iocpf)/* * Hardware initialization failed. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_DISABLE:break ;case IOCPF_E_STOP:break ;default :static void struct bfa_iocpf_s *iocpf)/* * Mark IOC as failed in hardware and stop firmware. /* * Flush any queued up mailbox requests. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_SEMLOCKED:if (!iocpf->auto_recover) {else {if (bfa_ioc_sync_complete(ioc))else {break ;case IOCPF_E_SEM_ERROR:break ;case IOCPF_E_DISABLE:break ;case IOCPF_E_FAIL:break ;default :static void struct bfa_iocpf_s *iocpf)/* * IOC is in failed state. static void struct bfa_iocpf_s *iocpf, enum iocpf_event event)struct bfa_ioc_s *ioc = iocpf->ioc;switch (event) {case IOCPF_E_DISABLE:break ;default :/* * BFA IOC private functions /* * Notify common modules registered for notification. static void struct bfa_ioc_s *ioc, enum bfa_ioc_event_e event)struct bfa_ioc_notify_s *notify;struct list_head *qe;struct bfa_ioc_notify_s *)qe;static void struct bfa_ioc_s *ioc)void __iomem *sem_reg)int cnt = 0;#define BFA_SEM_SPINCNT 3000while ((r32 & 1) && (cnt < BFA_SEM_SPINCNT)) {if (!(r32 & 1))return BFA_TRUE;return BFA_FALSE;static void struct bfa_ioc_s *ioc)/* * First read to the semaphore register will return 0, subsequent reads * will return 1. Semaphore is released by writing 1 to the register if (r32 == ~0) {return ;if (!(r32 & 1)) {return ;/* * Initialize LPU local memory (aka secondary memory / SRAM) static void struct bfa_ioc_s *ioc)int i;#define PSS_LMEM_INIT_TIME 10000/* * i2c workaround 12.5khz clock /* * wait for memory initialization to be complete do {while (!(pss_ctl & __PSS_LMEM_INIT_DONE) && (i < PSS_LMEM_INIT_TIME));/* * If memory initialization is not successful, IOC timeout will catch * such failures. static void struct bfa_ioc_s *ioc)/* * Take processor out of reset. static void struct bfa_ioc_s *ioc)/* * Put processors in reset. /* * Get driver and firmware versions. void struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)int i;for (i = 0; i < (sizeof (struct bfi_ioc_image_hdr_s) / sizeof (u32));sizeof (u32);/* * Returns TRUE if driver is willing to work with current smem f/w version. struct bfa_ioc_s *ioc,struct bfi_ioc_image_hdr_s *smem_fwhdr)struct bfi_ioc_image_hdr_s *drv_fwhdr;enum bfi_ioc_img_ver_cmp_e smem_flash_cmp, drv_smem_cmp;struct bfi_ioc_image_hdr_s *)/* * If smem is incompatible or old, driver should not work with it. if (drv_smem_cmp == BFI_IOC_IMG_VER_INCOMP ||return BFA_FALSE;/* * IF Flash has a better F/W than smem do not work with smem. * If smem f/w == flash f/w, as smem f/w not old | incmp, work with it. * If Flash is old or incomp work with smem iff smem f/w == drv f/w. if (smem_flash_cmp == BFI_IOC_IMG_VER_BETTER) {return BFA_FALSE;else if (smem_flash_cmp == BFI_IOC_IMG_VER_SAME) {return BFA_TRUE;else {return (drv_smem_cmp == BFI_IOC_IMG_VER_SAME) ?/* * Return true if current running version is valid. Firmware signature and * execution context (driver/bios) must match. static bfa_boolean_tstruct bfa_ioc_s *ioc, u32 boot_env)struct bfi_ioc_image_hdr_s fwhdr;if (swab32(fwhdr.bootenv) != boot_env) {return BFA_FALSE;return bfa_ioc_fwver_cmp(ioc, &fwhdr);static bfa_boolean_tstruct bfi_ioc_image_hdr_s *fwhdr_1,struct bfi_ioc_image_hdr_s *fwhdr_2)int i;for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++)if (fwhdr_1->md5sum[i] != fwhdr_2->md5sum[i])return BFA_FALSE;return BFA_TRUE;/* * Returns TRUE if major minor and maintainence are same. * If patch versions are same, check for MD5 Checksum to be same. static bfa_boolean_tstruct bfi_ioc_image_hdr_s *drv_fwhdr,struct bfi_ioc_image_hdr_s *fwhdr_to_cmp)if (drv_fwhdr->signature != fwhdr_to_cmp->signature)return BFA_FALSE;if (drv_fwhdr->fwver.major != fwhdr_to_cmp->fwver.major)return BFA_FALSE;if (drv_fwhdr->fwver.minor != fwhdr_to_cmp->fwver.minor)return BFA_FALSE;if (drv_fwhdr->fwver.maint != fwhdr_to_cmp->fwver.maint)return BFA_FALSE;if (drv_fwhdr->fwver.patch == fwhdr_to_cmp->fwver.patch &&return bfa_ioc_fwver_md5_check(drv_fwhdr, fwhdr_to_cmp);return BFA_TRUE;static bfa_boolean_tstruct bfi_ioc_image_hdr_s *flash_fwhdr)if (flash_fwhdr->fwver.major == 0 || flash_fwhdr->fwver.major == 0xFF)return BFA_FALSE;return BFA_TRUE;static bfa_boolean_t fwhdr_is_ga(struct bfi_ioc_image_hdr_s *fwhdr)if (fwhdr->fwver.phase == 0 &&return BFA_TRUE;return BFA_FALSE;/* * Returns TRUE if both are compatible and patch of fwhdr_to_cmp is better. static enum bfi_ioc_img_ver_cmp_estruct bfi_ioc_image_hdr_s *base_fwhdr,struct bfi_ioc_image_hdr_s *fwhdr_to_cmp)if (bfa_ioc_fw_ver_compatible(base_fwhdr, fwhdr_to_cmp) == BFA_FALSE)return BFI_IOC_IMG_VER_INCOMP;if (fwhdr_to_cmp->fwver.patch > base_fwhdr->fwver.patch)return BFI_IOC_IMG_VER_BETTER;else if (fwhdr_to_cmp->fwver.patch < base_fwhdr->fwver.patch)return BFI_IOC_IMG_VER_OLD;/* * GA takes priority over internal builds of the same patch stream. * At this point major minor maint and patch numbers are same. if (fwhdr_is_ga(base_fwhdr) == BFA_TRUE) {if (fwhdr_is_ga(fwhdr_to_cmp))return BFI_IOC_IMG_VER_SAME;else return BFI_IOC_IMG_VER_OLD;else {if (fwhdr_is_ga(fwhdr_to_cmp))return BFI_IOC_IMG_VER_BETTER;if (fwhdr_to_cmp->fwver.phase > base_fwhdr->fwver.phase)return BFI_IOC_IMG_VER_BETTER;else if (fwhdr_to_cmp->fwver.phase < base_fwhdr->fwver.phase)return BFI_IOC_IMG_VER_OLD;if (fwhdr_to_cmp->fwver.build > base_fwhdr->fwver.build)return BFI_IOC_IMG_VER_BETTER;else if (fwhdr_to_cmp->fwver.build < base_fwhdr->fwver.build)return BFI_IOC_IMG_VER_OLD;/* * All Version Numbers are equal. * Md5 check to be done as a part of compatibility check. return BFI_IOC_IMG_VER_SAME;#define BFA_FLASH_PART_FWIMG_ADDR 0x100000 /* fw image address */ struct bfa_ioc_s *ioc, u32 off,return bfa_flash_raw_read(ioc->pcidev.pci_bar_kva,sizeof (u32)),char *)fwimg, BFI_FLASH_CHUNK_SZ);static enum bfi_ioc_img_ver_cmp_estruct bfa_ioc_s *ioc,struct bfi_ioc_image_hdr_s *base_fwhdr)struct bfi_ioc_image_hdr_s *flash_fwhdr;if (status != BFA_STATUS_OK)return BFI_IOC_IMG_VER_INCOMP;struct bfi_ioc_image_hdr_s *) fwimg;if (bfa_ioc_flash_fwver_valid(flash_fwhdr) == BFA_TRUE)return bfa_ioc_fw_ver_patch_cmp(base_fwhdr, flash_fwhdr);else return BFI_IOC_IMG_VER_INCOMP;/* * Invalidate fwver signature struct bfa_ioc_s *ioc)enum bfi_ioc_state ioc_fwstate;if (!bfa_ioc_state_disabled(ioc_fwstate))return BFA_STATUS_ADAPTER_ENABLED;return BFA_STATUS_OK;/* * Conditionally flush any pending message from firmware at start. static void struct bfa_ioc_s *ioc)if (r32)static void struct bfa_ioc_s *ioc, bfa_boolean_t force)enum bfi_ioc_state ioc_fwstate;if (force)/* * check if firmware is valid if (!fwvalid) {if (bfa_ioc_boot(ioc, boot_type, boot_env) == BFA_STATUS_OK)return ;/* * If hardware initialization is in progress (initialized by other IOC), * just wait for an initialization completion interrupt. if (ioc_fwstate == BFI_IOC_INITING) {return ;/* * If IOC function is disabled and firmware version is same, * just re-enable IOC. * * If option rom, IOC must not be in operational state. With * convergence, IOC will be in operational state when 2nd driver * is loaded. if (ioc_fwstate == BFI_IOC_DISABLED || ioc_fwstate == BFI_IOC_OP) {/* * When using MSI-X any pending firmware ready event should * be flushed. Otherwise MSI-X interrupts are not delivered. return ;/* * Initialize the h/w for any other states. if (bfa_ioc_boot(ioc, boot_type, boot_env) == BFA_STATUS_OK)static void void *ioc_arg)struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;void struct bfa_ioc_s *ioc, void *ioc_msg, int len)/* * first write msg to mailbox registers for (i = 0; i < len / sizeof (u32); i++)sizeof (u32));for (; i < BFI_IOC_MSGLEN_MAX / sizeof (u32); i++)sizeof (u32));/* * write 1 to mailbox CMD to trigger LPU event void ) readl(ioc->ioc_regs.hfn_mbox_cmd);static void struct bfa_ioc_s *ioc)struct bfi_ioc_ctrl_req_s enable_req;/* unsigned 32-bit time_t overflow in y2106 */ sizeof (struct bfi_ioc_ctrl_req_s));static void struct bfa_ioc_s *ioc)struct bfi_ioc_ctrl_req_s disable_req;/* unsigned 32-bit time_t overflow in y2106 */ sizeof (struct bfi_ioc_ctrl_req_s));static void struct bfa_ioc_s *ioc)struct bfi_ioc_getattr_req_s attr_req;sizeof (attr_req));static void void *cbarg)struct bfa_ioc_s *ioc = cbarg;if (ioc->hb_count == hb_count) {return ;else {static void struct bfa_ioc_s *ioc)/* * Initiate a full firmware download. static bfa_status_tstruct bfa_ioc_s *ioc, u32 boot_type,if (boot_env == BFI_FWBOOT_ENV_OS &&sizeof (u32);if (status != BFA_STATUS_OK)return status;else {for (i = 0; i < fwimg_size; i++) {if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {if (boot_env == BFI_FWBOOT_ENV_OS &&if (status != BFA_STATUS_OK)return status;else {/* * write smem sizeof (u32);/* * handle page offset wrap around if (loff == 0) {/* * Set boot type, env and device mode at the end. if (boot_env == BFI_FWBOOT_ENV_OS &&return BFA_STATUS_OK;/* * Update BFA configuration from firmware configuration. static void struct bfa_ioc_s *ioc)struct bfi_ioc_attr_s *attr = ioc->attr;/* * Attach time initialization of mbox logic. static void struct bfa_ioc_s *ioc)struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;int mc;for (mc = 0; mc < BFI_MC_MAX; mc++) {/* * Mbox poll timer -- restarts any pending mailbox requests. static void struct bfa_ioc_s *ioc)struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;struct bfa_mbox_cmd_s *cmd;/* * If no command pending, do nothing if (list_empty(&mod->cmd_q))return ;/* * If previous command is not yet fetched by firmware, do nothing if (stat)return ;/* * Enqueue command to firmware. sizeof (cmd->msg));/* * Cleanup any pending requests. static void struct bfa_ioc_s *ioc)struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;struct bfa_mbox_cmd_s *cmd;while (!list_empty(&mod->cmd_q))/* * Read data from SMEM to host through PCI memmap * * @param[in] ioc memory for IOC * @param[in] tbuf app memory to store data from smem * @param[in] soff smem offset * @param[in] sz size of smem in bytes static bfa_status_tstruct bfa_ioc_s *ioc, void *tbuf, u32 soff, u32 sz)int i, len;/* * Hold semaphore to serialize pll init and fwtrc. if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {return BFA_STATUS_FAILED;sizeof (u32);for (i = 0; i < len; i++) {sizeof (u32);/* * handle page offset wrap around if (loff == 0) {/* * release semaphore. return BFA_STATUS_OK;/* * Clear SMEM data from host through PCI memmap * * @param[in] ioc memory for IOC * @param[in] soff smem offset * @param[in] sz size of smem in bytes static bfa_status_tstruct bfa_ioc_s *ioc, u32 soff, u32 sz)int i, len;/* * Hold semaphore to serialize pll init and fwtrc. if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {return BFA_STATUS_FAILED;sizeof (u32); /* len in words */ for (i = 0; i < len; i++) {sizeof (u32);/* * handle page offset wrap around if (loff == 0) {/* * release semaphore. return BFA_STATUS_OK;static void struct bfa_ioc_s *ioc)struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;/* * Notify driver and common modules registered for notification. "Heart Beat of IOC has failed\n" );static void struct bfa_ioc_s *ioc)struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;/* * Provide enable completion callback. "Running firmware version is incompatible " "with the driver version\n" );struct bfa_ioc_s *ioc)/* * Hold semaphore so that nobody can access the chip during init. /* * Initialize LMEM /* * release semaphore. return BFA_STATUS_OK;/* * Interface used by diag module to do firmware boot with memory test * as the entry vector. struct bfa_ioc_s *ioc, u32 boot_type, u32 boot_env)struct bfi_ioc_image_hdr_s *drv_fwhdr;if (bfa_ioc_pll_init(ioc) != BFA_STATUS_OK)return BFA_STATUS_FAILED;if (boot_env == BFI_FWBOOT_ENV_OS &&struct bfi_ioc_image_hdr_s *)/* * Work with Flash iff flash f/w is better than driver f/w. * Otherwise push drivers firmware. if (bfa_ioc_flash_fwver_cmp(ioc, drv_fwhdr) ==/* * Initialize IOC state of all functions on a chip reset. if (boot_type == BFI_FWBOOT_TYPE_MEMTEST) {else {if (status == BFA_STATUS_OK)else {return status;struct bfa_ioc_s *ioc)return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_op);struct bfa_ioc_s *ioc, void *mbmsg)int i;if ((r32 & 1) == 0)return BFA_FALSE;/* * read the MBOX msg for (i = 0; i < (sizeof (union bfi_ioc_i2h_msg_u) / sizeof (u32));sizeof (u32));/* * turn off mailbox interrupt by clearing mailbox status return BFA_TRUE;void struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)union bfi_ioc_i2h_msg_u *msg;struct bfa_iocpf_s *iocpf = &ioc->iocpf;union bfi_ioc_i2h_msg_u *) m;switch (msg->mh.msg_id) {case BFI_IOC_I2H_HBEAT:break ;case BFI_IOC_I2H_ENABLE_REPLY:enum bfa_mode_s)msg->fw_event.port_mode;break ;case BFI_IOC_I2H_DISABLE_REPLY:break ;case BFI_IOC_I2H_GETATTR_REPLY:break ;default :/* * IOC attach time initialization and setup. * * @param[in] ioc memory for IOC * @param[in] bfa driver instance structure void struct bfa_ioc_s *ioc, void *bfa, struct bfa_ioc_cbfn_s *cbfn,struct bfa_timer_mod_s *timer_mod)/* * Driver detach time IOC cleanup. void struct bfa_ioc_s *ioc)/* * Setup IOC PCI properties. * * @param[in] pcidev PCI device information for this IOC void struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,enum bfi_pcifn_class clscode)/* * Initialize IOC and device personality switch (pcidev->device_id) {case BFA_PCI_DEVICE_ID_FC_8G1P:case BFA_PCI_DEVICE_ID_FC_8G2P:break ;case BFA_PCI_DEVICE_ID_CT:break ;case BFA_PCI_DEVICE_ID_CT_FC:break ;case BFA_PCI_DEVICE_ID_CT2:case BFA_PCI_DEVICE_ID_CT2_QUAD:if (clscode == BFI_PCIFN_CLASS_FC &&else {if (pcidev->ssid == BFA_PCI_CT2_SSID_FCoE) {else {break ;default :/* * Set asic specific interfaces. See bfa_ioc_cb.c and bfa_ioc_ct.c if (ioc->asic_gen == BFI_ASIC_GEN_CB)else if (ioc->asic_gen == BFI_ASIC_GEN_CT)else {/* * Initialize IOC dma memory * * @param[in] dm_kva kernel virtual address of IOC dma memory * @param[in] dm_pa physical address of IOC dma memory void struct bfa_ioc_s *ioc, u8 *dm_kva, u64 dm_pa)/* * dma memory for firmware attribute struct bfi_ioc_attr_s *) dm_kva;void struct bfa_ioc_s *ioc)void struct bfa_ioc_s *ioc)void struct bfa_ioc_s *ioc)/* * Initialize memory for saving firmware trace. Driver must initialize * trace memory before call bfa_ioc_enable(). void struct bfa_ioc_s *ioc, void *dbg_fwsave)/* * Register mailbox message handler functions * * @param[in] ioc IOC instance * @param[in] mcfuncs message class handler functions void struct bfa_ioc_s *ioc, bfa_ioc_mbox_mcfunc_t *mcfuncs)struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;int mc;for (mc = 0; mc < BFI_MC_MAX; mc++)/* * Register mailbox message handler function, to be called by common modules void struct bfa_ioc_s *ioc, enum bfi_mclass mc,void *cbarg)struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;/* * Queue a mailbox command request to firmware. Waits if mailbox is busy. * Responsibility of caller to serialize * * @param[in] ioc IOC instance * @param[i] cmd Mailbox command void struct bfa_ioc_s *ioc, struct bfa_mbox_cmd_s *cmd)struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;/* * If a previous command is pending, queue new command if (!list_empty(&mod->cmd_q)) {return ;/* * If mailbox is busy, queue command for poll timer if (stat) {return ;/* * mailbox is free -- queue command to firmware sizeof (cmd->msg));/* * Handle mailbox interrupts void struct bfa_ioc_s *ioc)struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;struct bfi_mbmsg_s m;int mc;if (bfa_ioc_msgget(ioc, &m)) {/* * Treat IOC message class as special. if (mc == BFI_MC_IOC) {return ;if ((mc >= BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL))return ;/* * Try to send pending mailbox commands void struct bfa_ioc_s *ioc)/* * return true if IOC is disabled struct bfa_ioc_s *ioc)return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling) ||/* * return true if IOC firmware is different. struct bfa_ioc_s *ioc)return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset) ||/* * Check if adapter is disabled -- both IOCs should be in a disabled * state. struct bfa_ioc_s *ioc)if (!bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled))return BFA_FALSE;if (!bfa_ioc_state_disabled(ioc_state))return BFA_FALSE;if (ioc->pcidev.device_id != BFA_PCI_DEVICE_ID_FC_8G1P) {if (!bfa_ioc_state_disabled(ioc_state))return BFA_FALSE;return BFA_TRUE;/* * Reset IOC fwstate registers. void struct bfa_ioc_s *ioc)#define BFA_MFG_NAME "QLogic" void struct bfa_ioc_s *ioc,struct bfa_adapter_attr_s *ad_attr)struct bfi_ioc_attr_s *ioc_attr;sizeof (struct bfa_mfg_vpd_s));/* For now, model descr uses same model string */ if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))else enum bfa_ioc_type_estruct bfa_ioc_s *ioc)if (ioc->clscode == BFI_PCIFN_CLASS_ETH)return BFA_IOC_TYPE_LL;return (ioc->attr->port_mode == BFI_PORT_MODE_FC)void struct bfa_ioc_s *ioc, char *serial_num)void *)serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);void *)serial_num,void *)ioc->attr->brcd_serialnum,void struct bfa_ioc_s *ioc, char *fw_ver)void *)fw_ver, 0, BFA_VERSION_LEN);void struct bfa_ioc_s *ioc, char *chip_rev)void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);'R' ;'e' ;'v' ;'-' ;'\0' ;void struct bfa_ioc_s *ioc, char *optrom_ver)void *)optrom_ver, 0, BFA_VERSION_LEN);void struct bfa_ioc_s *ioc, char *manufacturer)void *)manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);void struct bfa_ioc_s *ioc, char *model)struct bfi_ioc_attr_s *ioc_attr;void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);if (bfa_asic_id_ct2(ioc->pcidev.device_id) &&"%s-%u-%u%s" ,"p" );else "%s-%u" ,enum bfa_ioc_statestruct bfa_ioc_s *ioc)enum bfa_iocpf_state iocpf_st;enum bfa_ioc_state ioc_st = bfa_ioc_sm_to_state(ioc_sm_table, ioc->fsm);if (ioc_st == BFA_IOC_ENABLING ||switch (iocpf_st) {case BFA_IOCPF_SEMWAIT:break ;case BFA_IOCPF_HWINIT:break ;case BFA_IOCPF_FWMISMATCH:break ;case BFA_IOCPF_FAIL:break ;case BFA_IOCPF_INITFAIL:
Messung V0.5 C=95 H=93 G=93
¤ Dauer der Verarbeitung: 0.27 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
