Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0-only */
0002 /*
0003  * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
0004  * Copyright (c) 2014- QLogic Corporation.
0005  * All rights reserved
0006  * www.qlogic.com
0007  *
0008  * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
0009  */
0010 
0011 #ifndef __BFA_IOC_H__
0012 #define __BFA_IOC_H__
0013 
0014 #include "bfad_drv.h"
0015 #include "bfa_cs.h"
0016 #include "bfi.h"
0017 
0018 #define BFA_DBG_FWTRC_ENTS  (BFI_IOC_TRC_ENTS)
0019 #define BFA_DBG_FWTRC_LEN                   \
0020     (BFA_DBG_FWTRC_ENTS * sizeof(struct bfa_trc_s) +    \
0021     (sizeof(struct bfa_trc_mod_s) -             \
0022     BFA_TRC_MAX * sizeof(struct bfa_trc_s)))
0023 /*
0024  * BFA timer declarations
0025  */
0026 typedef void (*bfa_timer_cbfn_t)(void *);
0027 
0028 /*
0029  * BFA timer data structure
0030  */
0031 struct bfa_timer_s {
0032     struct list_head    qe;
0033     bfa_timer_cbfn_t timercb;
0034     void        *arg;
0035     int     timeout;    /* in millisecs */
0036 };
0037 
0038 /*
0039  * Timer module structure
0040  */
0041 struct bfa_timer_mod_s {
0042     struct list_head timer_q;
0043 };
0044 
0045 #define BFA_TIMER_FREQ 200 /* specified in millisecs */
0046 
0047 void bfa_timer_beat(struct bfa_timer_mod_s *mod);
0048 void bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer,
0049             bfa_timer_cbfn_t timercb, void *arg,
0050             unsigned int timeout);
0051 void bfa_timer_stop(struct bfa_timer_s *timer);
0052 
0053 /*
0054  * Generic Scatter Gather Element used by driver
0055  */
0056 struct bfa_sge_s {
0057     u32 sg_len;
0058     void        *sg_addr;
0059 };
0060 
0061 #define bfa_sge_word_swap(__sge) do {                        \
0062     ((u32 *)(__sge))[0] = swab32(((u32 *)(__sge))[0]);      \
0063     ((u32 *)(__sge))[1] = swab32(((u32 *)(__sge))[1]);      \
0064     ((u32 *)(__sge))[2] = swab32(((u32 *)(__sge))[2]);      \
0065 } while (0)
0066 
0067 #define bfa_swap_words(_x)  (   \
0068     ((u64)(_x) << 32) | ((u64)(_x) >> 32))
0069 
0070 #ifdef __BIG_ENDIAN
0071 #define bfa_sge_to_be(_x)
0072 #define bfa_sge_to_le(_x)   bfa_sge_word_swap(_x)
0073 #define bfa_sgaddr_le(_x)   bfa_swap_words(_x)
0074 #else
0075 #define bfa_sge_to_be(_x)   bfa_sge_word_swap(_x)
0076 #define bfa_sge_to_le(_x)
0077 #define bfa_sgaddr_le(_x)   (_x)
0078 #endif
0079 
0080 /*
0081  * BFA memory resources
0082  */
0083 struct bfa_mem_dma_s {
0084     struct list_head qe;        /* Queue of DMA elements */
0085     u32     mem_len;    /* Total Length in Bytes */
0086     u8      *kva;       /* kernel virtual address */
0087     u64     dma;        /* dma address if DMA memory */
0088     u8      *kva_curp;  /* kva allocation cursor */
0089     u64     dma_curp;   /* dma allocation cursor */
0090 };
0091 #define bfa_mem_dma_t struct bfa_mem_dma_s
0092 
0093 struct bfa_mem_kva_s {
0094     struct list_head qe;        /* Queue of KVA elements */
0095     u32     mem_len;    /* Total Length in Bytes */
0096     u8      *kva;       /* kernel virtual address */
0097     u8      *kva_curp;  /* kva allocation cursor */
0098 };
0099 #define bfa_mem_kva_t struct bfa_mem_kva_s
0100 
0101 struct bfa_meminfo_s {
0102     struct bfa_mem_dma_s dma_info;
0103     struct bfa_mem_kva_s kva_info;
0104 };
0105 
0106 /* BFA memory segment setup helpers */
0107 static inline void bfa_mem_dma_setup(struct bfa_meminfo_s *meminfo,
0108                      struct bfa_mem_dma_s *dm_ptr,
0109                      size_t seg_sz)
0110 {
0111     dm_ptr->mem_len = seg_sz;
0112     if (seg_sz)
0113         list_add_tail(&dm_ptr->qe, &meminfo->dma_info.qe);
0114 }
0115 
0116 static inline void bfa_mem_kva_setup(struct bfa_meminfo_s *meminfo,
0117                      struct bfa_mem_kva_s *kva_ptr,
0118                      size_t seg_sz)
0119 {
0120     kva_ptr->mem_len = seg_sz;
0121     if (seg_sz)
0122         list_add_tail(&kva_ptr->qe, &meminfo->kva_info.qe);
0123 }
0124 
0125 /* BFA dma memory segments iterator */
0126 #define bfa_mem_dma_sptr(_mod, _i)  (&(_mod)->dma_seg[(_i)])
0127 #define bfa_mem_dma_seg_iter(_mod, _sptr, _nr, _i)          \
0128     for (_i = 0, _sptr = bfa_mem_dma_sptr(_mod, _i); _i < (_nr);    \
0129          _i++, _sptr = bfa_mem_dma_sptr(_mod, _i))
0130 
0131 #define bfa_mem_kva_curp(_mod)  ((_mod)->kva_seg.kva_curp)
0132 #define bfa_mem_dma_virt(_sptr) ((_sptr)->kva_curp)
0133 #define bfa_mem_dma_phys(_sptr) ((_sptr)->dma_curp)
0134 #define bfa_mem_dma_len(_sptr)  ((_sptr)->mem_len)
0135 
0136 /* Get the corresponding dma buf kva for a req - from the tag */
0137 #define bfa_mem_get_dmabuf_kva(_mod, _tag, _rqsz)                 \
0138     (((u8 *)(_mod)->dma_seg[BFI_MEM_SEG_FROM_TAG(_tag, _rqsz)].kva_curp) +\
0139      BFI_MEM_SEG_REQ_OFFSET(_tag, _rqsz) * (_rqsz))
0140 
0141 /* Get the corresponding dma buf pa for a req - from the tag */
0142 #define bfa_mem_get_dmabuf_pa(_mod, _tag, _rqsz)            \
0143     ((_mod)->dma_seg[BFI_MEM_SEG_FROM_TAG(_tag, _rqsz)].dma_curp +  \
0144      BFI_MEM_SEG_REQ_OFFSET(_tag, _rqsz) * (_rqsz))
0145 
0146 /*
0147  * PCI device information required by IOC
0148  */
0149 struct bfa_pcidev_s {
0150     int     pci_slot;
0151     u8      pci_func;
0152     u16     device_id;
0153     u16     ssid;
0154     void __iomem    *pci_bar_kva;
0155 };
0156 
0157 /*
0158  * Structure used to remember the DMA-able memory block's KVA and Physical
0159  * Address
0160  */
0161 struct bfa_dma_s {
0162     void        *kva;   /* ! Kernel virtual address */
0163     u64 pa; /* ! Physical address       */
0164 };
0165 
0166 #define BFA_DMA_ALIGN_SZ    256
0167 #define BFA_ROUNDUP(_l, _s) (((_l) + ((_s) - 1)) & ~((_s) - 1))
0168 
0169 /*
0170  * smem size for Crossbow and Catapult
0171  */
0172 #define BFI_SMEM_CB_SIZE    0x200000U   /* ! 2MB for crossbow   */
0173 #define BFI_SMEM_CT_SIZE    0x280000U   /* ! 2.5MB for catapult */
0174 
0175 #define bfa_dma_be_addr_set(dma_addr, pa)   \
0176         __bfa_dma_be_addr_set(&dma_addr, (u64)pa)
0177 static inline void
0178 __bfa_dma_be_addr_set(union bfi_addr_u *dma_addr, u64 pa)
0179 {
0180     dma_addr->a32.addr_lo = cpu_to_be32(pa);
0181     dma_addr->a32.addr_hi = cpu_to_be32(pa >> 32);
0182 }
0183 
0184 #define bfa_alen_set(__alen, __len, __pa)   \
0185     __bfa_alen_set(__alen, __len, (u64)__pa)
0186 
0187 static inline void
0188 __bfa_alen_set(struct bfi_alen_s *alen, u32 len, u64 pa)
0189 {
0190     alen->al_len = cpu_to_be32(len);
0191     bfa_dma_be_addr_set(alen->al_addr, pa);
0192 }
0193 
0194 struct bfa_ioc_regs_s {
0195     void __iomem *hfn_mbox_cmd;
0196     void __iomem *hfn_mbox;
0197     void __iomem *lpu_mbox_cmd;
0198     void __iomem *lpu_mbox;
0199     void __iomem *lpu_read_stat;
0200     void __iomem *pss_ctl_reg;
0201     void __iomem *pss_err_status_reg;
0202     void __iomem *app_pll_fast_ctl_reg;
0203     void __iomem *app_pll_slow_ctl_reg;
0204     void __iomem *ioc_sem_reg;
0205     void __iomem *ioc_usage_sem_reg;
0206     void __iomem *ioc_init_sem_reg;
0207     void __iomem *ioc_usage_reg;
0208     void __iomem *host_page_num_fn;
0209     void __iomem *heartbeat;
0210     void __iomem *ioc_fwstate;
0211     void __iomem *alt_ioc_fwstate;
0212     void __iomem *ll_halt;
0213     void __iomem *alt_ll_halt;
0214     void __iomem *err_set;
0215     void __iomem *ioc_fail_sync;
0216     void __iomem *shirq_isr_next;
0217     void __iomem *shirq_msk_next;
0218     void __iomem *smem_page_start;
0219     u32 smem_pg0;
0220 };
0221 
0222 #define bfa_mem_read(_raddr, _off)  swab32(readl(((_raddr) + (_off))))
0223 #define bfa_mem_write(_raddr, _off, _val)   \
0224             writel(swab32((_val)), ((_raddr) + (_off)))
0225 /*
0226  * IOC Mailbox structures
0227  */
0228 struct bfa_mbox_cmd_s {
0229     struct list_head    qe;
0230     u32 msg[BFI_IOC_MSGSZ];
0231 };
0232 
0233 /*
0234  * IOC mailbox module
0235  */
0236 typedef void (*bfa_ioc_mbox_mcfunc_t)(void *cbarg, struct bfi_mbmsg_s *m);
0237 struct bfa_ioc_mbox_mod_s {
0238     struct list_head        cmd_q;  /*  pending mbox queue  */
0239     int         nmclass;    /*  number of handlers */
0240     struct {
0241         bfa_ioc_mbox_mcfunc_t   cbfn;   /*  message handlers    */
0242         void            *cbarg;
0243     } mbhdlr[BFI_MC_MAX];
0244 };
0245 
0246 /*
0247  * IOC callback function interfaces
0248  */
0249 typedef void (*bfa_ioc_enable_cbfn_t)(void *bfa, enum bfa_status status);
0250 typedef void (*bfa_ioc_disable_cbfn_t)(void *bfa);
0251 typedef void (*bfa_ioc_hbfail_cbfn_t)(void *bfa);
0252 typedef void (*bfa_ioc_reset_cbfn_t)(void *bfa);
0253 struct bfa_ioc_cbfn_s {
0254     bfa_ioc_enable_cbfn_t   enable_cbfn;
0255     bfa_ioc_disable_cbfn_t  disable_cbfn;
0256     bfa_ioc_hbfail_cbfn_t   hbfail_cbfn;
0257     bfa_ioc_reset_cbfn_t    reset_cbfn;
0258 };
0259 
0260 /*
0261  * IOC event notification mechanism.
0262  */
0263 enum bfa_ioc_event_e {
0264     BFA_IOC_E_ENABLED   = 1,
0265     BFA_IOC_E_DISABLED  = 2,
0266     BFA_IOC_E_FAILED    = 3,
0267 };
0268 
0269 typedef void (*bfa_ioc_notify_cbfn_t)(void *, enum bfa_ioc_event_e);
0270 
0271 struct bfa_ioc_notify_s {
0272     struct list_head        qe;
0273     bfa_ioc_notify_cbfn_t   cbfn;
0274     void            *cbarg;
0275 };
0276 
0277 /*
0278  * Initialize a IOC event notification structure
0279  */
0280 #define bfa_ioc_notify_init(__notify, __cbfn, __cbarg) do { \
0281     (__notify)->cbfn = (__cbfn);      \
0282     (__notify)->cbarg = (__cbarg);      \
0283 } while (0)
0284 
0285 struct bfa_iocpf_s {
0286     bfa_fsm_t       fsm;
0287     struct bfa_ioc_s    *ioc;
0288     bfa_boolean_t       fw_mismatch_notified;
0289     bfa_boolean_t       auto_recover;
0290     u32         poll_time;
0291 };
0292 
0293 struct bfa_ioc_s {
0294     bfa_fsm_t       fsm;
0295     struct bfa_s        *bfa;
0296     struct bfa_pcidev_s pcidev;
0297     struct bfa_timer_mod_s  *timer_mod;
0298     struct bfa_timer_s  ioc_timer;
0299     struct bfa_timer_s  sem_timer;
0300     struct bfa_timer_s  hb_timer;
0301     u32     hb_count;
0302     struct list_head    notify_q;
0303     void            *dbg_fwsave;
0304     int         dbg_fwsave_len;
0305     bfa_boolean_t       dbg_fwsave_once;
0306     enum bfi_pcifn_class    clscode;
0307     struct bfa_ioc_regs_s   ioc_regs;
0308     struct bfa_trc_mod_s    *trcmod;
0309     struct bfa_ioc_drv_stats_s  stats;
0310     bfa_boolean_t       fcmode;
0311     bfa_boolean_t       pllinit;
0312     bfa_boolean_t       stats_busy; /*  outstanding stats */
0313     u8          port_id;
0314     struct bfa_dma_s    attr_dma;
0315     struct bfi_ioc_attr_s   *attr;
0316     struct bfa_ioc_cbfn_s   *cbfn;
0317     struct bfa_ioc_mbox_mod_s mbox_mod;
0318     struct bfa_ioc_hwif_s   *ioc_hwif;
0319     struct bfa_iocpf_s  iocpf;
0320     enum bfi_asic_gen   asic_gen;
0321     enum bfi_asic_mode  asic_mode;
0322     enum bfi_port_mode  port0_mode;
0323     enum bfi_port_mode  port1_mode;
0324     enum bfa_mode_s     port_mode;
0325     u8          ad_cap_bm;  /* adapter cap bit mask */
0326     u8          port_mode_cfg;  /* config port mode */
0327     int         ioc_aen_seq;
0328 };
0329 
0330 struct bfa_ioc_hwif_s {
0331     bfa_status_t (*ioc_pll_init) (void __iomem *rb, enum bfi_asic_mode m);
0332     bfa_boolean_t   (*ioc_firmware_lock)    (struct bfa_ioc_s *ioc);
0333     void        (*ioc_firmware_unlock)  (struct bfa_ioc_s *ioc);
0334     void        (*ioc_reg_init) (struct bfa_ioc_s *ioc);
0335     void        (*ioc_map_port) (struct bfa_ioc_s *ioc);
0336     void        (*ioc_isr_mode_set) (struct bfa_ioc_s *ioc,
0337                     bfa_boolean_t msix);
0338     void        (*ioc_notify_fail)  (struct bfa_ioc_s *ioc);
0339     void        (*ioc_ownership_reset)  (struct bfa_ioc_s *ioc);
0340     bfa_boolean_t   (*ioc_sync_start)       (struct bfa_ioc_s *ioc);
0341     void        (*ioc_sync_join)    (struct bfa_ioc_s *ioc);
0342     void        (*ioc_sync_leave)   (struct bfa_ioc_s *ioc);
0343     void        (*ioc_sync_ack)     (struct bfa_ioc_s *ioc);
0344     bfa_boolean_t   (*ioc_sync_complete)    (struct bfa_ioc_s *ioc);
0345     bfa_boolean_t   (*ioc_lpu_read_stat)    (struct bfa_ioc_s *ioc);
0346     void        (*ioc_set_fwstate)  (struct bfa_ioc_s *ioc,
0347                     enum bfi_ioc_state fwstate);
0348     enum bfi_ioc_state  (*ioc_get_fwstate)  (struct bfa_ioc_s *ioc);
0349     void        (*ioc_set_alt_fwstate)  (struct bfa_ioc_s *ioc,
0350                     enum bfi_ioc_state fwstate);
0351     enum bfi_ioc_state  (*ioc_get_alt_fwstate)  (struct bfa_ioc_s *ioc);
0352 };
0353 
0354 /*
0355  * Queue element to wait for room in request queue. FIFO order is
0356  * maintained when fullfilling requests.
0357  */
0358 struct bfa_reqq_wait_s {
0359     struct list_head    qe;
0360     void    (*qresume) (void *cbarg);
0361     void    *cbarg;
0362 };
0363 
0364 typedef void    (*bfa_cb_cbfn_t) (void *cbarg, bfa_boolean_t complete);
0365 
0366 /*
0367  * Generic BFA callback element.
0368  */
0369 struct bfa_cb_qe_s {
0370     struct list_head    qe;
0371     bfa_cb_cbfn_t   cbfn;
0372     bfa_boolean_t   once;
0373     bfa_boolean_t   pre_rmv;    /* set for stack based qe(s) */
0374     bfa_status_t    fw_status;  /* to access fw status in comp proc */
0375     void        *cbarg;
0376 };
0377 
0378 /*
0379  * IOCFC state machine definitions/declarations
0380  */
0381 enum iocfc_event {
0382     IOCFC_E_INIT        = 1,    /* IOCFC init request       */
0383     IOCFC_E_START       = 2,    /* IOCFC mod start request  */
0384     IOCFC_E_STOP        = 3,    /* IOCFC stop request       */
0385     IOCFC_E_ENABLE      = 4,    /* IOCFC enable request     */
0386     IOCFC_E_DISABLE     = 5,    /* IOCFC disable request    */
0387     IOCFC_E_IOC_ENABLED = 6,    /* IOC enabled message      */
0388     IOCFC_E_IOC_DISABLED    = 7,    /* IOC disabled message     */
0389     IOCFC_E_IOC_FAILED  = 8,    /* failure notice by IOC sm */
0390     IOCFC_E_DCONF_DONE  = 9,    /* dconf read/write done    */
0391     IOCFC_E_CFG_DONE    = 10,   /* IOCFC config complete    */
0392 };
0393 
0394 /*
0395  * ASIC block configurtion related
0396  */
0397 
0398 typedef void (*bfa_ablk_cbfn_t)(void *, enum bfa_status);
0399 
0400 struct bfa_ablk_s {
0401     struct bfa_ioc_s    *ioc;
0402     struct bfa_ablk_cfg_s   *cfg;
0403     u16         *pcifn;
0404     struct bfa_dma_s    dma_addr;
0405     bfa_boolean_t       busy;
0406     struct bfa_mbox_cmd_s   mb;
0407     bfa_ablk_cbfn_t     cbfn;
0408     void            *cbarg;
0409     struct bfa_ioc_notify_s ioc_notify;
0410     struct bfa_mem_dma_s    ablk_dma;
0411 };
0412 #define BFA_MEM_ABLK_DMA(__bfa)     (&((__bfa)->modules.ablk.ablk_dma))
0413 
0414 /*
0415  *  SFP module specific
0416  */
0417 typedef void    (*bfa_cb_sfp_t) (void *cbarg, bfa_status_t status);
0418 
0419 struct bfa_sfp_s {
0420     void    *dev;
0421     struct bfa_ioc_s    *ioc;
0422     struct bfa_trc_mod_s    *trcmod;
0423     struct sfp_mem_s    *sfpmem;
0424     bfa_cb_sfp_t        cbfn;
0425     void            *cbarg;
0426     enum bfi_sfp_mem_e  memtype; /* mem access type   */
0427     u32         status;
0428     struct bfa_mbox_cmd_s   mbcmd;
0429     u8          *dbuf_kva; /* dma buf virtual address */
0430     u64         dbuf_pa;   /* dma buf physical address */
0431     struct bfa_ioc_notify_s ioc_notify;
0432     enum bfa_defs_sfp_media_e *media;
0433     enum bfa_port_speed portspeed;
0434     bfa_cb_sfp_t        state_query_cbfn;
0435     void            *state_query_cbarg;
0436     u8          lock;
0437     u8          data_valid; /* data in dbuf is valid */
0438     u8          state;      /* sfp state  */
0439     u8          state_query_lock;
0440     struct bfa_mem_dma_s    sfp_dma;
0441     u8          is_elb;     /* eloopback  */
0442 };
0443 
0444 #define BFA_SFP_MOD(__bfa)  (&(__bfa)->modules.sfp)
0445 #define BFA_MEM_SFP_DMA(__bfa)  (&(BFA_SFP_MOD(__bfa)->sfp_dma))
0446 
0447 u32 bfa_sfp_meminfo(void);
0448 
0449 void    bfa_sfp_attach(struct bfa_sfp_s *sfp, struct bfa_ioc_s *ioc,
0450             void *dev, struct bfa_trc_mod_s *trcmod);
0451 
0452 void    bfa_sfp_memclaim(struct bfa_sfp_s *diag, u8 *dm_kva, u64 dm_pa);
0453 void    bfa_sfp_intr(void *bfaarg, struct bfi_mbmsg_s *msg);
0454 
0455 bfa_status_t    bfa_sfp_show(struct bfa_sfp_s *sfp, struct sfp_mem_s *sfpmem,
0456                  bfa_cb_sfp_t cbfn, void *cbarg);
0457 
0458 bfa_status_t    bfa_sfp_media(struct bfa_sfp_s *sfp,
0459             enum bfa_defs_sfp_media_e *media,
0460             bfa_cb_sfp_t cbfn, void *cbarg);
0461 
0462 bfa_status_t    bfa_sfp_speed(struct bfa_sfp_s *sfp,
0463             enum bfa_port_speed portspeed,
0464             bfa_cb_sfp_t cbfn, void *cbarg);
0465 
0466 /*
0467  *  Flash module specific
0468  */
0469 typedef void    (*bfa_cb_flash_t) (void *cbarg, bfa_status_t status);
0470 
0471 struct bfa_flash_s {
0472     struct bfa_ioc_s *ioc;      /* back pointer to ioc */
0473     struct bfa_trc_mod_s *trcmod;
0474     u32     type;           /* partition type */
0475     u8      instance;       /* partition instance */
0476     u8      rsv[3];
0477     u32     op_busy;        /*  operation busy flag */
0478     u32     residue;        /*  residual length */
0479     u32     offset;         /*  offset */
0480     bfa_status_t    status;         /*  status */
0481     u8      *dbuf_kva;      /*  dma buf virtual address */
0482     u64     dbuf_pa;        /*  dma buf physical address */
0483     struct bfa_reqq_wait_s  reqq_wait; /*  to wait for room in reqq */
0484     bfa_cb_flash_t  cbfn;           /*  user callback function */
0485     void        *cbarg;         /*  user callback arg */
0486     u8      *ubuf;          /*  user supplied buffer */
0487     struct bfa_cb_qe_s  hcb_qe; /*  comp: BFA callback qelem */
0488     u32     addr_off;       /*  partition address offset */
0489     struct bfa_mbox_cmd_s   mb;       /*  mailbox */
0490     struct bfa_ioc_notify_s ioc_notify; /*  ioc event notify */
0491     struct bfa_mem_dma_s    flash_dma;
0492 };
0493 
0494 #define BFA_FLASH(__bfa)        (&(__bfa)->modules.flash)
0495 #define BFA_MEM_FLASH_DMA(__bfa)    (&(BFA_FLASH(__bfa)->flash_dma))
0496 
0497 bfa_status_t bfa_flash_get_attr(struct bfa_flash_s *flash,
0498             struct bfa_flash_attr_s *attr,
0499             bfa_cb_flash_t cbfn, void *cbarg);
0500 bfa_status_t bfa_flash_erase_part(struct bfa_flash_s *flash,
0501             enum bfa_flash_part_type type, u8 instance,
0502             bfa_cb_flash_t cbfn, void *cbarg);
0503 bfa_status_t bfa_flash_update_part(struct bfa_flash_s *flash,
0504             enum bfa_flash_part_type type, u8 instance,
0505             void *buf, u32 len, u32 offset,
0506             bfa_cb_flash_t cbfn, void *cbarg);
0507 bfa_status_t bfa_flash_read_part(struct bfa_flash_s *flash,
0508             enum bfa_flash_part_type type, u8 instance, void *buf,
0509             u32 len, u32 offset, bfa_cb_flash_t cbfn, void *cbarg);
0510 u32 bfa_flash_meminfo(bfa_boolean_t mincfg);
0511 void bfa_flash_attach(struct bfa_flash_s *flash, struct bfa_ioc_s *ioc,
0512         void *dev, struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg);
0513 void bfa_flash_memclaim(struct bfa_flash_s *flash,
0514         u8 *dm_kva, u64 dm_pa, bfa_boolean_t mincfg);
0515 bfa_status_t    bfa_flash_raw_read(void __iomem *pci_bar_kva,
0516                 u32 offset, char *buf, u32 len);
0517 
0518 /*
0519  *  DIAG module specific
0520  */
0521 
0522 typedef void (*bfa_cb_diag_t) (void *cbarg, bfa_status_t status);
0523 typedef void (*bfa_cb_diag_beacon_t) (void *dev, bfa_boolean_t beacon,
0524             bfa_boolean_t link_e2e_beacon);
0525 
0526 /*
0527  *      Firmware ping test results
0528  */
0529 struct bfa_diag_results_fwping {
0530     u32     data;   /* store the corrupted data */
0531     u32     status;
0532     u32     dmastatus;
0533     u8      rsvd[4];
0534 };
0535 
0536 struct bfa_diag_qtest_result_s {
0537     u32 status;
0538     u16 count;  /* successful queue test count */
0539     u8  queue;
0540     u8  rsvd;   /* 64-bit align */
0541 };
0542 
0543 /*
0544  * Firmware ping test results
0545  */
0546 struct bfa_diag_fwping_s {
0547     struct bfa_diag_results_fwping *result;
0548     bfa_cb_diag_t  cbfn;
0549     void            *cbarg;
0550     u32             data;
0551     u8              lock;
0552     u8              rsv[3];
0553     u32             status;
0554     u32             count;
0555     struct bfa_mbox_cmd_s   mbcmd;
0556     u8              *dbuf_kva;      /* dma buf virtual address */
0557     u64             dbuf_pa;        /* dma buf physical address */
0558 };
0559 
0560 /*
0561  *      Temperature sensor query results
0562  */
0563 struct bfa_diag_results_tempsensor_s {
0564     u32     status;
0565     u16     temp;           /* 10-bit A/D value */
0566     u16     brd_temp;       /* 9-bit board temp */
0567     u8      ts_junc;        /* show junction tempsensor   */
0568     u8      ts_brd;         /* show board tempsensor      */
0569     u8      rsvd[6];        /* keep 8 bytes alignment     */
0570 };
0571 
0572 struct bfa_diag_tsensor_s {
0573     bfa_cb_diag_t   cbfn;
0574     void            *cbarg;
0575     struct bfa_diag_results_tempsensor_s *temp;
0576     u8              lock;
0577     u8              rsv[3];
0578     u32             status;
0579     struct bfa_mbox_cmd_s   mbcmd;
0580 };
0581 
0582 struct bfa_diag_sfpshow_s {
0583     struct sfp_mem_s        *sfpmem;
0584     bfa_cb_diag_t           cbfn;
0585     void                    *cbarg;
0586     u8      lock;
0587     u8      static_data;
0588     u8      rsv[2];
0589     u32     status;
0590     struct bfa_mbox_cmd_s    mbcmd;
0591     u8      *dbuf_kva;      /* dma buf virtual address */
0592     u64     dbuf_pa;        /* dma buf physical address */
0593 };
0594 
0595 struct bfa_diag_led_s {
0596     struct bfa_mbox_cmd_s   mbcmd;
0597     bfa_boolean_t   lock;   /* 1: ledtest is operating */
0598 };
0599 
0600 struct bfa_diag_beacon_s {
0601     struct bfa_mbox_cmd_s   mbcmd;
0602     bfa_boolean_t   state;          /* port beacon state */
0603     bfa_boolean_t   link_e2e;       /* link beacon state */
0604 };
0605 
0606 struct bfa_diag_s {
0607     void    *dev;
0608     struct bfa_ioc_s        *ioc;
0609     struct bfa_trc_mod_s        *trcmod;
0610     struct bfa_diag_fwping_s    fwping;
0611     struct bfa_diag_tsensor_s   tsensor;
0612     struct bfa_diag_sfpshow_s   sfpshow;
0613     struct bfa_diag_led_s       ledtest;
0614     struct bfa_diag_beacon_s    beacon;
0615     void    *result;
0616     struct bfa_timer_s timer;
0617     bfa_cb_diag_beacon_t  cbfn_beacon;
0618     bfa_cb_diag_t  cbfn;
0619     void        *cbarg;
0620     u8      block;
0621     u8      timer_active;
0622     u8      rsvd[2];
0623     u32     status;
0624     struct bfa_ioc_notify_s ioc_notify;
0625     struct bfa_mem_dma_s    diag_dma;
0626 };
0627 
0628 #define BFA_DIAG_MOD(__bfa)     (&(__bfa)->modules.diag_mod)
0629 #define BFA_MEM_DIAG_DMA(__bfa) (&(BFA_DIAG_MOD(__bfa)->diag_dma))
0630 
0631 u32 bfa_diag_meminfo(void);
0632 void bfa_diag_memclaim(struct bfa_diag_s *diag, u8 *dm_kva, u64 dm_pa);
0633 void bfa_diag_attach(struct bfa_diag_s *diag, struct bfa_ioc_s *ioc, void *dev,
0634              bfa_cb_diag_beacon_t cbfn_beacon,
0635              struct bfa_trc_mod_s *trcmod);
0636 bfa_status_t    bfa_diag_reg_read(struct bfa_diag_s *diag, u32 offset,
0637             u32 len, u32 *buf, u32 force);
0638 bfa_status_t    bfa_diag_reg_write(struct bfa_diag_s *diag, u32 offset,
0639             u32 len, u32 value, u32 force);
0640 bfa_status_t    bfa_diag_tsensor_query(struct bfa_diag_s *diag,
0641             struct bfa_diag_results_tempsensor_s *result,
0642             bfa_cb_diag_t cbfn, void *cbarg);
0643 bfa_status_t    bfa_diag_fwping(struct bfa_diag_s *diag, u32 cnt,
0644             u32 pattern, struct bfa_diag_results_fwping *result,
0645             bfa_cb_diag_t cbfn, void *cbarg);
0646 bfa_status_t    bfa_diag_sfpshow(struct bfa_diag_s *diag,
0647             struct sfp_mem_s *sfpmem, u8 static_data,
0648             bfa_cb_diag_t cbfn, void *cbarg);
0649 bfa_status_t    bfa_diag_memtest(struct bfa_diag_s *diag,
0650             struct bfa_diag_memtest_s *memtest, u32 pattern,
0651             struct bfa_diag_memtest_result *result,
0652             bfa_cb_diag_t cbfn, void *cbarg);
0653 bfa_status_t    bfa_diag_ledtest(struct bfa_diag_s *diag,
0654             struct bfa_diag_ledtest_s *ledtest);
0655 bfa_status_t    bfa_diag_beacon_port(struct bfa_diag_s *diag,
0656             bfa_boolean_t beacon, bfa_boolean_t link_e2e_beacon,
0657             u32 sec);
0658 
0659 /*
0660  *  PHY module specific
0661  */
0662 typedef void (*bfa_cb_phy_t) (void *cbarg, bfa_status_t status);
0663 
0664 struct bfa_phy_s {
0665     struct bfa_ioc_s *ioc;          /* back pointer to ioc */
0666     struct bfa_trc_mod_s *trcmod;   /* trace module */
0667     u8  instance;       /* port instance */
0668     u8  op_busy;        /* operation busy flag */
0669     u8  rsv[2];
0670     u32 residue;        /* residual length */
0671     u32 offset;         /* offset */
0672     bfa_status_t    status;         /* status */
0673     u8  *dbuf_kva;      /* dma buf virtual address */
0674     u64 dbuf_pa;        /* dma buf physical address */
0675     struct bfa_reqq_wait_s reqq_wait; /* to wait for room in reqq */
0676     bfa_cb_phy_t    cbfn;           /* user callback function */
0677     void        *cbarg;         /* user callback arg */
0678     u8      *ubuf;          /* user supplied buffer */
0679     struct bfa_cb_qe_s  hcb_qe; /* comp: BFA callback qelem */
0680     u32 addr_off;       /* phy address offset */
0681     struct bfa_mbox_cmd_s   mb;       /* mailbox */
0682     struct bfa_ioc_notify_s ioc_notify; /* ioc event notify */
0683     struct bfa_mem_dma_s    phy_dma;
0684 };
0685 #define BFA_PHY(__bfa)  (&(__bfa)->modules.phy)
0686 #define BFA_MEM_PHY_DMA(__bfa)  (&(BFA_PHY(__bfa)->phy_dma))
0687 
0688 bfa_boolean_t bfa_phy_busy(struct bfa_ioc_s *ioc);
0689 bfa_status_t bfa_phy_get_attr(struct bfa_phy_s *phy, u8 instance,
0690             struct bfa_phy_attr_s *attr,
0691             bfa_cb_phy_t cbfn, void *cbarg);
0692 bfa_status_t bfa_phy_get_stats(struct bfa_phy_s *phy, u8 instance,
0693             struct bfa_phy_stats_s *stats,
0694             bfa_cb_phy_t cbfn, void *cbarg);
0695 bfa_status_t bfa_phy_update(struct bfa_phy_s *phy, u8 instance,
0696             void *buf, u32 len, u32 offset,
0697             bfa_cb_phy_t cbfn, void *cbarg);
0698 bfa_status_t bfa_phy_read(struct bfa_phy_s *phy, u8 instance,
0699             void *buf, u32 len, u32 offset,
0700             bfa_cb_phy_t cbfn, void *cbarg);
0701 
0702 u32 bfa_phy_meminfo(bfa_boolean_t mincfg);
0703 void bfa_phy_attach(struct bfa_phy_s *phy, struct bfa_ioc_s *ioc,
0704         void *dev, struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg);
0705 void bfa_phy_memclaim(struct bfa_phy_s *phy,
0706         u8 *dm_kva, u64 dm_pa, bfa_boolean_t mincfg);
0707 void bfa_phy_intr(void *phyarg, struct bfi_mbmsg_s *msg);
0708 
0709 /*
0710  * FRU module specific
0711  */
0712 typedef void (*bfa_cb_fru_t) (void *cbarg, bfa_status_t status);
0713 
0714 struct bfa_fru_s {
0715     struct bfa_ioc_s *ioc;      /* back pointer to ioc */
0716     struct bfa_trc_mod_s *trcmod;   /* trace module */
0717     u8      op_busy;    /* operation busy flag */
0718     u8      rsv[3];
0719     u32     residue;    /* residual length */
0720     u32     offset;     /* offset */
0721     bfa_status_t    status;     /* status */
0722     u8      *dbuf_kva;  /* dma buf virtual address */
0723     u64     dbuf_pa;    /* dma buf physical address */
0724     struct bfa_reqq_wait_s reqq_wait; /* to wait for room in reqq */
0725     bfa_cb_fru_t    cbfn;       /* user callback function */
0726     void        *cbarg;     /* user callback arg */
0727     u8      *ubuf;      /* user supplied buffer */
0728     struct bfa_cb_qe_s  hcb_qe; /* comp: BFA callback qelem */
0729     u32     addr_off;   /* fru address offset */
0730     struct bfa_mbox_cmd_s mb;   /* mailbox */
0731     struct bfa_ioc_notify_s ioc_notify; /* ioc event notify */
0732     struct bfa_mem_dma_s    fru_dma;
0733     u8      trfr_cmpl;
0734 };
0735 
0736 #define BFA_FRU(__bfa)  (&(__bfa)->modules.fru)
0737 #define BFA_MEM_FRU_DMA(__bfa)  (&(BFA_FRU(__bfa)->fru_dma))
0738 
0739 bfa_status_t bfa_fruvpd_update(struct bfa_fru_s *fru,
0740             void *buf, u32 len, u32 offset,
0741             bfa_cb_fru_t cbfn, void *cbarg, u8 trfr_cmpl);
0742 bfa_status_t bfa_fruvpd_read(struct bfa_fru_s *fru,
0743             void *buf, u32 len, u32 offset,
0744             bfa_cb_fru_t cbfn, void *cbarg);
0745 bfa_status_t bfa_fruvpd_get_max_size(struct bfa_fru_s *fru, u32 *max_size);
0746 bfa_status_t bfa_tfru_write(struct bfa_fru_s *fru,
0747             void *buf, u32 len, u32 offset,
0748             bfa_cb_fru_t cbfn, void *cbarg);
0749 bfa_status_t bfa_tfru_read(struct bfa_fru_s *fru,
0750             void *buf, u32 len, u32 offset,
0751             bfa_cb_fru_t cbfn, void *cbarg);
0752 u32 bfa_fru_meminfo(bfa_boolean_t mincfg);
0753 void bfa_fru_attach(struct bfa_fru_s *fru, struct bfa_ioc_s *ioc,
0754         void *dev, struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg);
0755 void bfa_fru_memclaim(struct bfa_fru_s *fru,
0756         u8 *dm_kva, u64 dm_pa, bfa_boolean_t mincfg);
0757 void bfa_fru_intr(void *fruarg, struct bfi_mbmsg_s *msg);
0758 
0759 /*
0760  * Driver Config( dconf) specific
0761  */
0762 #define BFI_DCONF_SIGNATURE 0xabcdabcd
0763 #define BFI_DCONF_VERSION   1
0764 
0765 #pragma pack(1)
0766 struct bfa_dconf_hdr_s {
0767     u32 signature;
0768     u32 version;
0769 };
0770 
0771 struct bfa_dconf_s {
0772     struct bfa_dconf_hdr_s      hdr;
0773     struct bfa_lunmask_cfg_s    lun_mask;
0774     struct bfa_throttle_cfg_s   throttle_cfg;
0775 };
0776 #pragma pack()
0777 
0778 struct bfa_dconf_mod_s {
0779     bfa_sm_t        sm;
0780     u8          instance;
0781     bfa_boolean_t       read_data_valid;
0782     bfa_boolean_t       min_cfg;
0783     struct bfa_timer_s  timer;
0784     struct bfa_s        *bfa;
0785     void            *bfad;
0786     void            *trcmod;
0787     struct bfa_dconf_s  *dconf;
0788     struct bfa_mem_kva_s    kva_seg;
0789 };
0790 
0791 #define BFA_DCONF_MOD(__bfa)    \
0792     (&(__bfa)->modules.dconf_mod)
0793 #define BFA_MEM_DCONF_KVA(__bfa)    (&(BFA_DCONF_MOD(__bfa)->kva_seg))
0794 #define bfa_dconf_read_data_valid(__bfa)    \
0795     (BFA_DCONF_MOD(__bfa)->read_data_valid)
0796 #define BFA_DCONF_UPDATE_TOV    5000    /* memtest timeout in msec */
0797 #define bfa_dconf_get_min_cfg(__bfa)    \
0798     (BFA_DCONF_MOD(__bfa)->min_cfg)
0799 
0800 void    bfa_dconf_modinit(struct bfa_s *bfa);
0801 void    bfa_dconf_modexit(struct bfa_s *bfa);
0802 bfa_status_t    bfa_dconf_update(struct bfa_s *bfa);
0803 
0804 /*
0805  *  IOC specfic macros
0806  */
0807 #define bfa_ioc_pcifn(__ioc)        ((__ioc)->pcidev.pci_func)
0808 #define bfa_ioc_devid(__ioc)        ((__ioc)->pcidev.device_id)
0809 #define bfa_ioc_bar0(__ioc)     ((__ioc)->pcidev.pci_bar_kva)
0810 #define bfa_ioc_portid(__ioc)       ((__ioc)->port_id)
0811 #define bfa_ioc_asic_gen(__ioc)     ((__ioc)->asic_gen)
0812 #define bfa_ioc_is_cna(__ioc)   \
0813     ((bfa_ioc_get_type(__ioc) == BFA_IOC_TYPE_FCoE) ||  \
0814      (bfa_ioc_get_type(__ioc) == BFA_IOC_TYPE_LL))
0815 #define bfa_ioc_fetch_stats(__ioc, __stats) \
0816         (((__stats)->drv_stats) = (__ioc)->stats)
0817 #define bfa_ioc_clr_stats(__ioc)    \
0818         memset(&(__ioc)->stats, 0, sizeof((__ioc)->stats))
0819 #define bfa_ioc_maxfrsize(__ioc)    ((__ioc)->attr->maxfrsize)
0820 #define bfa_ioc_rx_bbcredit(__ioc)  ((__ioc)->attr->rx_bbcredit)
0821 #define bfa_ioc_speed_sup(__ioc)    \
0822     ((bfa_ioc_is_cna(__ioc)) ? BFA_PORT_SPEED_10GBPS :  \
0823      BFI_ADAPTER_GETP(SPEED, (__ioc)->attr->adapter_prop))
0824 #define bfa_ioc_get_nports(__ioc)   \
0825     BFI_ADAPTER_GETP(NPORTS, (__ioc)->attr->adapter_prop)
0826 
0827 #define bfa_ioc_stats(_ioc, _stats) ((_ioc)->stats._stats++)
0828 #define BFA_IOC_FWIMG_MINSZ (16 * 1024)
0829 #define BFA_IOC_FW_SMEM_SIZE(__ioc)         \
0830     ((bfa_ioc_asic_gen(__ioc) == BFI_ASIC_GEN_CB)   \
0831      ? BFI_SMEM_CB_SIZE : BFI_SMEM_CT_SIZE)
0832 #define BFA_IOC_FLASH_CHUNK_NO(off)     (off / BFI_FLASH_CHUNK_SZ_WORDS)
0833 #define BFA_IOC_FLASH_OFFSET_IN_CHUNK(off)  (off % BFI_FLASH_CHUNK_SZ_WORDS)
0834 #define BFA_IOC_FLASH_CHUNK_ADDR(chunkno)  (chunkno * BFI_FLASH_CHUNK_SZ_WORDS)
0835 
0836 /*
0837  * IOC mailbox interface
0838  */
0839 void bfa_ioc_mbox_queue(struct bfa_ioc_s *ioc, struct bfa_mbox_cmd_s *cmd);
0840 void bfa_ioc_mbox_register(struct bfa_ioc_s *ioc,
0841         bfa_ioc_mbox_mcfunc_t *mcfuncs);
0842 void bfa_ioc_mbox_isr(struct bfa_ioc_s *ioc);
0843 void bfa_ioc_mbox_send(struct bfa_ioc_s *ioc, void *ioc_msg, int len);
0844 bfa_boolean_t bfa_ioc_msgget(struct bfa_ioc_s *ioc, void *mbmsg);
0845 void bfa_ioc_mbox_regisr(struct bfa_ioc_s *ioc, enum bfi_mclass mc,
0846         bfa_ioc_mbox_mcfunc_t cbfn, void *cbarg);
0847 
0848 /*
0849  * IOC interfaces
0850  */
0851 
0852 #define bfa_ioc_pll_init_asic(__ioc) \
0853     ((__ioc)->ioc_hwif->ioc_pll_init((__ioc)->pcidev.pci_bar_kva, \
0854                (__ioc)->asic_mode))
0855 
0856 bfa_status_t bfa_ioc_pll_init(struct bfa_ioc_s *ioc);
0857 bfa_status_t bfa_ioc_cb_pll_init(void __iomem *rb, enum bfi_asic_mode mode);
0858 bfa_status_t bfa_ioc_ct_pll_init(void __iomem *rb, enum bfi_asic_mode mode);
0859 bfa_status_t bfa_ioc_ct2_pll_init(void __iomem *rb, enum bfi_asic_mode mode);
0860 
0861 #define bfa_ioc_isr_mode_set(__ioc, __msix) do {            \
0862     if ((__ioc)->ioc_hwif->ioc_isr_mode_set)            \
0863         ((__ioc)->ioc_hwif->ioc_isr_mode_set(__ioc, __msix));   \
0864 } while (0)
0865 #define bfa_ioc_ownership_reset(__ioc)              \
0866             ((__ioc)->ioc_hwif->ioc_ownership_reset(__ioc))
0867 #define bfa_ioc_get_fcmode(__ioc)   ((__ioc)->fcmode)
0868 #define bfa_ioc_lpu_read_stat(__ioc) do {           \
0869     if ((__ioc)->ioc_hwif->ioc_lpu_read_stat)       \
0870         ((__ioc)->ioc_hwif->ioc_lpu_read_stat(__ioc));  \
0871 } while (0)
0872 
0873 void bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc);
0874 void bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc);
0875 void bfa_ioc_set_ct2_hwif(struct bfa_ioc_s *ioc);
0876 void bfa_ioc_ct2_poweron(struct bfa_ioc_s *ioc);
0877 
0878 void bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa,
0879         struct bfa_ioc_cbfn_s *cbfn, struct bfa_timer_mod_s *timer_mod);
0880 void bfa_ioc_auto_recover(bfa_boolean_t auto_recover);
0881 void bfa_ioc_detach(struct bfa_ioc_s *ioc);
0882 void bfa_ioc_suspend(struct bfa_ioc_s *ioc);
0883 void bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
0884         enum bfi_pcifn_class clscode);
0885 void bfa_ioc_mem_claim(struct bfa_ioc_s *ioc,  u8 *dm_kva, u64 dm_pa);
0886 void bfa_ioc_enable(struct bfa_ioc_s *ioc);
0887 void bfa_ioc_disable(struct bfa_ioc_s *ioc);
0888 bfa_boolean_t bfa_ioc_intx_claim(struct bfa_ioc_s *ioc);
0889 
0890 bfa_status_t bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type,
0891         u32 boot_env);
0892 void bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *msg);
0893 void bfa_ioc_error_isr(struct bfa_ioc_s *ioc);
0894 bfa_boolean_t bfa_ioc_is_operational(struct bfa_ioc_s *ioc);
0895 bfa_boolean_t bfa_ioc_is_initialized(struct bfa_ioc_s *ioc);
0896 bfa_boolean_t bfa_ioc_is_disabled(struct bfa_ioc_s *ioc);
0897 bfa_boolean_t bfa_ioc_is_acq_addr(struct bfa_ioc_s *ioc);
0898 bfa_boolean_t bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc);
0899 bfa_boolean_t bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc);
0900 void bfa_ioc_reset_fwstate(struct bfa_ioc_s *ioc);
0901 enum bfa_ioc_type_e bfa_ioc_get_type(struct bfa_ioc_s *ioc);
0902 void bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num);
0903 void bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver);
0904 void bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver);
0905 void bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model);
0906 void bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc,
0907         char *manufacturer);
0908 void bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev);
0909 enum bfa_ioc_state bfa_ioc_get_state(struct bfa_ioc_s *ioc);
0910 
0911 void bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr);
0912 void bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
0913         struct bfa_adapter_attr_s *ad_attr);
0914 void bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave);
0915 bfa_status_t bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata,
0916         int *trclen);
0917 bfa_status_t bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata,
0918                  int *trclen);
0919 bfa_status_t bfa_ioc_debug_fwcore(struct bfa_ioc_s *ioc, void *buf,
0920     u32 *offset, int *buflen);
0921 bfa_status_t bfa_ioc_fwsig_invalidate(struct bfa_ioc_s *ioc);
0922 bfa_boolean_t bfa_ioc_sem_get(void __iomem *sem_reg);
0923 void bfa_ioc_fwver_get(struct bfa_ioc_s *ioc,
0924             struct bfi_ioc_image_hdr_s *fwhdr);
0925 bfa_boolean_t bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc,
0926             struct bfi_ioc_image_hdr_s *fwhdr);
0927 void bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event);
0928 bfa_status_t bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats);
0929 bfa_status_t bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc);
0930 void bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc);
0931 
0932 /*
0933  * asic block configuration related APIs
0934  */
0935 u32 bfa_ablk_meminfo(void);
0936 void bfa_ablk_memclaim(struct bfa_ablk_s *ablk, u8 *dma_kva, u64 dma_pa);
0937 void bfa_ablk_attach(struct bfa_ablk_s *ablk, struct bfa_ioc_s *ioc);
0938 bfa_status_t bfa_ablk_query(struct bfa_ablk_s *ablk,
0939         struct bfa_ablk_cfg_s *ablk_cfg,
0940         bfa_ablk_cbfn_t cbfn, void *cbarg);
0941 bfa_status_t bfa_ablk_adapter_config(struct bfa_ablk_s *ablk,
0942         enum bfa_mode_s mode, int max_pf, int max_vf,
0943         bfa_ablk_cbfn_t cbfn, void *cbarg);
0944 bfa_status_t bfa_ablk_port_config(struct bfa_ablk_s *ablk, int port,
0945         enum bfa_mode_s mode, int max_pf, int max_vf,
0946         bfa_ablk_cbfn_t cbfn, void *cbarg);
0947 bfa_status_t bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn,
0948         u8 port, enum bfi_pcifn_class personality,
0949         u16 bw_min, u16 bw_max, bfa_ablk_cbfn_t cbfn, void *cbarg);
0950 bfa_status_t bfa_ablk_pf_delete(struct bfa_ablk_s *ablk, int pcifn,
0951         bfa_ablk_cbfn_t cbfn, void *cbarg);
0952 bfa_status_t bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn,
0953         u16 bw_min, u16 bw_max, bfa_ablk_cbfn_t cbfn, void *cbarg);
0954 bfa_status_t bfa_ablk_optrom_en(struct bfa_ablk_s *ablk,
0955         bfa_ablk_cbfn_t cbfn, void *cbarg);
0956 bfa_status_t bfa_ablk_optrom_dis(struct bfa_ablk_s *ablk,
0957         bfa_ablk_cbfn_t cbfn, void *cbarg);
0958 
0959 bfa_status_t bfa_ioc_flash_img_get_chnk(struct bfa_ioc_s *ioc, u32 off,
0960                 u32 *fwimg);
0961 /*
0962  * bfa mfg wwn API functions
0963  */
0964 mac_t bfa_ioc_get_mac(struct bfa_ioc_s *ioc);
0965 mac_t bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc);
0966 
0967 /*
0968  * F/W Image Size & Chunk
0969  */
0970 extern u32 bfi_image_cb_size;
0971 extern u32 bfi_image_ct_size;
0972 extern u32 bfi_image_ct2_size;
0973 extern u32 *bfi_image_cb;
0974 extern u32 *bfi_image_ct;
0975 extern u32 *bfi_image_ct2;
0976 
0977 static inline u32 *
0978 bfi_image_cb_get_chunk(u32 off)
0979 {
0980     return (u32 *)(bfi_image_cb + off);
0981 }
0982 
0983 static inline u32 *
0984 bfi_image_ct_get_chunk(u32 off)
0985 {
0986     return (u32 *)(bfi_image_ct + off);
0987 }
0988 
0989 static inline u32 *
0990 bfi_image_ct2_get_chunk(u32 off)
0991 {
0992     return (u32 *)(bfi_image_ct2 + off);
0993 }
0994 
0995 static inline u32*
0996 bfa_cb_image_get_chunk(enum bfi_asic_gen asic_gen, u32 off)
0997 {
0998     switch (asic_gen) {
0999     case BFI_ASIC_GEN_CB:
1000         return bfi_image_cb_get_chunk(off);
1001         break;
1002     case BFI_ASIC_GEN_CT:
1003         return bfi_image_ct_get_chunk(off);
1004         break;
1005     case BFI_ASIC_GEN_CT2:
1006         return bfi_image_ct2_get_chunk(off);
1007         break;
1008     default:
1009         return NULL;
1010     }
1011 }
1012 
1013 static inline u32
1014 bfa_cb_image_get_size(enum bfi_asic_gen asic_gen)
1015 {
1016     switch (asic_gen) {
1017     case BFI_ASIC_GEN_CB:
1018         return bfi_image_cb_size;
1019         break;
1020     case BFI_ASIC_GEN_CT:
1021         return bfi_image_ct_size;
1022         break;
1023     case BFI_ASIC_GEN_CT2:
1024         return bfi_image_ct2_size;
1025         break;
1026     default:
1027         return 0;
1028     }
1029 }
1030 
1031 /*
1032  * CNA TRCMOD declaration
1033  */
1034 /*
1035  * !!! Only append to the enums defined here to avoid any versioning
1036  * !!! needed between trace utility and driver version
1037  */
1038 enum {
1039     BFA_TRC_CNA_PORT    = 1,
1040     BFA_TRC_CNA_IOC     = 2,
1041     BFA_TRC_CNA_IOC_CB  = 3,
1042     BFA_TRC_CNA_IOC_CT  = 4,
1043 };
1044 
1045 #endif /* __BFA_IOC_H__ */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!