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 #ifndef __BFA_H__
0011 #define __BFA_H__
0012 
0013 #include "bfad_drv.h"
0014 #include "bfa_cs.h"
0015 #include "bfa_plog.h"
0016 #include "bfa_defs_svc.h"
0017 #include "bfi.h"
0018 #include "bfa_ioc.h"
0019 
0020 struct bfa_s;
0021 
0022 typedef void (*bfa_isr_func_t) (struct bfa_s *bfa, struct bfi_msg_s *m);
0023 typedef void (*bfa_cb_cbfn_status_t) (void *cbarg, bfa_status_t status);
0024 
0025 /*
0026  * Interrupt message handlers
0027  */
0028 void bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m);
0029 
0030 /*
0031  * Request and response queue related defines
0032  */
0033 #define BFA_REQQ_NELEMS_MIN (4)
0034 #define BFA_RSPQ_NELEMS_MIN (4)
0035 
0036 #define bfa_reqq_pi(__bfa, __reqq)  ((__bfa)->iocfc.req_cq_pi[__reqq])
0037 #define bfa_reqq_ci(__bfa, __reqq)                  \
0038     (*(u32 *)((__bfa)->iocfc.req_cq_shadow_ci[__reqq].kva))
0039 
0040 #define bfa_reqq_full(__bfa, __reqq)                \
0041     (((bfa_reqq_pi(__bfa, __reqq) + 1) &            \
0042       ((__bfa)->iocfc.cfg.drvcfg.num_reqq_elems - 1)) ==    \
0043      bfa_reqq_ci(__bfa, __reqq))
0044 
0045 #define bfa_reqq_next(__bfa, __reqq)                    \
0046     (bfa_reqq_full(__bfa, __reqq) ? NULL :              \
0047      ((void *)((struct bfi_msg_s *)((__bfa)->iocfc.req_cq_ba[__reqq].kva) \
0048            + bfa_reqq_pi((__bfa), (__reqq)))))
0049 
0050 #define bfa_reqq_produce(__bfa, __reqq, __mh)  do {         \
0051         (__mh).mtag.h2i.qid     = (__bfa)->iocfc.hw_qid[__reqq];\
0052         (__bfa)->iocfc.req_cq_pi[__reqq]++;         \
0053         (__bfa)->iocfc.req_cq_pi[__reqq] &=         \
0054             ((__bfa)->iocfc.cfg.drvcfg.num_reqq_elems - 1); \
0055         writel((__bfa)->iocfc.req_cq_pi[__reqq],        \
0056             (__bfa)->iocfc.bfa_regs.cpe_q_pi[__reqq]);  \
0057         } while (0)
0058 
0059 #define bfa_rspq_pi(__bfa, __rspq)                  \
0060     (*(u32 *)((__bfa)->iocfc.rsp_cq_shadow_pi[__rspq].kva))
0061 
0062 #define bfa_rspq_ci(__bfa, __rspq)  ((__bfa)->iocfc.rsp_cq_ci[__rspq])
0063 #define bfa_rspq_elem(__bfa, __rspq, __ci)              \
0064     (&((struct bfi_msg_s *)((__bfa)->iocfc.rsp_cq_ba[__rspq].kva))[__ci])
0065 
0066 #define CQ_INCR(__index, __size) do {           \
0067     (__index)++;                    \
0068     (__index) &= ((__size) - 1);            \
0069 } while (0)
0070 
0071 /*
0072  * Circular queue usage assignments
0073  */
0074 enum {
0075     BFA_REQQ_IOC    = 0,    /*  all low-priority IOC msgs   */
0076     BFA_REQQ_FCXP   = 0,    /*  all FCXP messages       */
0077     BFA_REQQ_LPS    = 0,    /*  all lport service msgs  */
0078     BFA_REQQ_PORT   = 0,    /*  all port messages       */
0079     BFA_REQQ_FLASH  = 0,    /*  for flash module        */
0080     BFA_REQQ_DIAG   = 0,    /*  for diag module     */
0081     BFA_REQQ_RPORT  = 0,    /*  all port messages       */
0082     BFA_REQQ_SBOOT  = 0,    /*  all san boot messages   */
0083     BFA_REQQ_QOS_LO = 1,    /*  all low priority IO */
0084     BFA_REQQ_QOS_MD = 2,    /*  all medium priority IO  */
0085     BFA_REQQ_QOS_HI = 3,    /*  all high priority IO    */
0086 };
0087 
0088 static inline void
0089 bfa_reqq_winit(struct bfa_reqq_wait_s *wqe, void (*qresume) (void *cbarg),
0090            void *cbarg)
0091 {
0092     wqe->qresume = qresume;
0093     wqe->cbarg = cbarg;
0094 }
0095 
0096 #define bfa_reqq(__bfa, __reqq) (&(__bfa)->reqq_waitq[__reqq])
0097 
0098 /*
0099  * static inline void
0100  * bfa_reqq_wait(struct bfa_s *bfa, int reqq, struct bfa_reqq_wait_s *wqe)
0101  */
0102 #define bfa_reqq_wait(__bfa, __reqq, __wqe) do {            \
0103                                     \
0104         struct list_head *waitq = bfa_reqq(__bfa, __reqq);      \
0105                                     \
0106         WARN_ON(((__reqq) >= BFI_IOC_MAX_CQS));         \
0107         WARN_ON(!((__wqe)->qresume && (__wqe)->cbarg));     \
0108                                     \
0109         list_add_tail(&(__wqe)->qe, waitq);      \
0110     } while (0)
0111 
0112 #define bfa_reqq_wcancel(__wqe) list_del(&(__wqe)->qe)
0113 
0114 #define bfa_cb_queue(__bfa, __hcb_qe, __cbfn, __cbarg) do { \
0115         (__hcb_qe)->cbfn  = (__cbfn);      \
0116         (__hcb_qe)->cbarg = (__cbarg);      \
0117         (__hcb_qe)->pre_rmv = BFA_FALSE;        \
0118         list_add_tail(&(__hcb_qe)->qe, &(__bfa)->comp_q);      \
0119     } while (0)
0120 
0121 #define bfa_cb_dequeue(__hcb_qe)    list_del(&(__hcb_qe)->qe)
0122 
0123 #define bfa_cb_queue_once(__bfa, __hcb_qe, __cbfn, __cbarg) do {    \
0124         (__hcb_qe)->cbfn  = (__cbfn);      \
0125         (__hcb_qe)->cbarg = (__cbarg);      \
0126         if (!(__hcb_qe)->once) {      \
0127             list_add_tail(&(__hcb_qe)->qe, &(__bfa)->comp_q);      \
0128             (__hcb_qe)->once = BFA_TRUE;            \
0129         }                           \
0130     } while (0)
0131 
0132 #define bfa_cb_queue_status(__bfa, __hcb_qe, __status) do {     \
0133         (__hcb_qe)->fw_status = (__status);         \
0134         list_add_tail(&(__hcb_qe)->qe, &(__bfa)->comp_q);   \
0135 } while (0)
0136 
0137 #define bfa_cb_queue_done(__hcb_qe) do {    \
0138         (__hcb_qe)->once = BFA_FALSE;   \
0139     } while (0)
0140 
0141 
0142 /*
0143  * PCI devices supported by the current BFA
0144  */
0145 struct bfa_pciid_s {
0146     u16 device_id;
0147     u16 vendor_id;
0148 };
0149 
0150 extern char     bfa_version[];
0151 
0152 struct bfa_iocfc_regs_s {
0153     void __iomem    *intr_status;
0154     void __iomem    *intr_mask;
0155     void __iomem    *cpe_q_pi[BFI_IOC_MAX_CQS];
0156     void __iomem    *cpe_q_ci[BFI_IOC_MAX_CQS];
0157     void __iomem    *cpe_q_ctrl[BFI_IOC_MAX_CQS];
0158     void __iomem    *rme_q_ci[BFI_IOC_MAX_CQS];
0159     void __iomem    *rme_q_pi[BFI_IOC_MAX_CQS];
0160     void __iomem    *rme_q_ctrl[BFI_IOC_MAX_CQS];
0161 };
0162 
0163 /*
0164  * MSIX vector handlers
0165  */
0166 #define BFA_MSIX_MAX_VECTORS    22
0167 typedef void (*bfa_msix_handler_t)(struct bfa_s *bfa, int vec);
0168 struct bfa_msix_s {
0169     int nvecs;
0170     bfa_msix_handler_t handler[BFA_MSIX_MAX_VECTORS];
0171 };
0172 
0173 /*
0174  * Chip specific interfaces
0175  */
0176 struct bfa_hwif_s {
0177     void (*hw_reginit)(struct bfa_s *bfa);
0178     void (*hw_reqq_ack)(struct bfa_s *bfa, int reqq);
0179     void (*hw_rspq_ack)(struct bfa_s *bfa, int rspq, u32 ci);
0180     void (*hw_msix_init)(struct bfa_s *bfa, int nvecs);
0181     void (*hw_msix_ctrl_install)(struct bfa_s *bfa);
0182     void (*hw_msix_queue_install)(struct bfa_s *bfa);
0183     void (*hw_msix_uninstall)(struct bfa_s *bfa);
0184     void (*hw_isr_mode_set)(struct bfa_s *bfa, bfa_boolean_t msix);
0185     void (*hw_msix_getvecs)(struct bfa_s *bfa, u32 *vecmap,
0186                 u32 *nvecs, u32 *maxvec);
0187     void (*hw_msix_get_rme_range) (struct bfa_s *bfa, u32 *start,
0188                        u32 *end);
0189     int cpe_vec_q0;
0190     int rme_vec_q0;
0191 };
0192 typedef void (*bfa_cb_iocfc_t) (void *cbarg, enum bfa_status status);
0193 
0194 struct bfa_faa_cbfn_s {
0195     bfa_cb_iocfc_t  faa_cbfn;
0196     void        *faa_cbarg;
0197 };
0198 
0199 #define BFA_FAA_ENABLED     1
0200 #define BFA_FAA_DISABLED    2
0201 
0202 /*
0203  *  FAA attributes
0204  */
0205 struct bfa_faa_attr_s {
0206     wwn_t   faa;
0207     u8  faa_state;
0208     u8  pwwn_source;
0209     u8  rsvd[6];
0210 };
0211 
0212 struct bfa_faa_args_s {
0213     struct bfa_faa_attr_s   *faa_attr;
0214     struct bfa_faa_cbfn_s   faa_cb;
0215     u8          faa_state;
0216     bfa_boolean_t       busy;
0217 };
0218 
0219 struct bfa_iocfc_s {
0220     bfa_fsm_t       fsm;
0221     struct bfa_s        *bfa;
0222     struct bfa_iocfc_cfg_s  cfg;
0223     u32     req_cq_pi[BFI_IOC_MAX_CQS];
0224     u32     rsp_cq_ci[BFI_IOC_MAX_CQS];
0225     u8      hw_qid[BFI_IOC_MAX_CQS];
0226     struct bfa_cb_qe_s  init_hcb_qe;
0227     struct bfa_cb_qe_s  stop_hcb_qe;
0228     struct bfa_cb_qe_s  dis_hcb_qe;
0229     struct bfa_cb_qe_s  en_hcb_qe;
0230     struct bfa_cb_qe_s  stats_hcb_qe;
0231     bfa_boolean_t       submod_enabled;
0232     bfa_boolean_t       cb_reqd;    /* Driver call back reqd */
0233     bfa_status_t        op_status;  /* Status of bfa iocfc op */
0234 
0235     struct bfa_dma_s    cfg_info;
0236     struct bfi_iocfc_cfg_s *cfginfo;
0237     struct bfa_dma_s    cfgrsp_dma;
0238     struct bfi_iocfc_cfgrsp_s *cfgrsp;
0239     struct bfa_dma_s    req_cq_ba[BFI_IOC_MAX_CQS];
0240     struct bfa_dma_s    req_cq_shadow_ci[BFI_IOC_MAX_CQS];
0241     struct bfa_dma_s    rsp_cq_ba[BFI_IOC_MAX_CQS];
0242     struct bfa_dma_s    rsp_cq_shadow_pi[BFI_IOC_MAX_CQS];
0243     struct bfa_iocfc_regs_s bfa_regs;   /*  BFA device registers */
0244     struct bfa_hwif_s   hwif;
0245     bfa_cb_iocfc_t      updateq_cbfn; /*  bios callback function */
0246     void            *updateq_cbarg; /*  bios callback arg */
0247     u32 intr_mask;
0248     struct bfa_faa_args_s   faa_args;
0249     struct bfa_mem_dma_s    ioc_dma;
0250     struct bfa_mem_dma_s    iocfc_dma;
0251     struct bfa_mem_dma_s    reqq_dma[BFI_IOC_MAX_CQS];
0252     struct bfa_mem_dma_s    rspq_dma[BFI_IOC_MAX_CQS];
0253     struct bfa_mem_kva_s    kva_seg;
0254 };
0255 
0256 #define BFA_MEM_IOC_DMA(_bfa)       (&((_bfa)->iocfc.ioc_dma))
0257 #define BFA_MEM_IOCFC_DMA(_bfa)     (&((_bfa)->iocfc.iocfc_dma))
0258 #define BFA_MEM_REQQ_DMA(_bfa, _qno)    (&((_bfa)->iocfc.reqq_dma[(_qno)]))
0259 #define BFA_MEM_RSPQ_DMA(_bfa, _qno)    (&((_bfa)->iocfc.rspq_dma[(_qno)]))
0260 #define BFA_MEM_IOCFC_KVA(_bfa)     (&((_bfa)->iocfc.kva_seg))
0261 
0262 #define bfa_fn_lpu(__bfa)   \
0263     bfi_fn_lpu(bfa_ioc_pcifn(&(__bfa)->ioc), bfa_ioc_portid(&(__bfa)->ioc))
0264 #define bfa_msix_init(__bfa, __nvecs)                   \
0265     ((__bfa)->iocfc.hwif.hw_msix_init(__bfa, __nvecs))
0266 #define bfa_msix_ctrl_install(__bfa)                    \
0267     ((__bfa)->iocfc.hwif.hw_msix_ctrl_install(__bfa))
0268 #define bfa_msix_queue_install(__bfa)                   \
0269     ((__bfa)->iocfc.hwif.hw_msix_queue_install(__bfa))
0270 #define bfa_msix_uninstall(__bfa)                   \
0271     ((__bfa)->iocfc.hwif.hw_msix_uninstall(__bfa))
0272 #define bfa_isr_rspq_ack(__bfa, __queue, __ci)              \
0273     ((__bfa)->iocfc.hwif.hw_rspq_ack(__bfa, __queue, __ci))
0274 #define bfa_isr_reqq_ack(__bfa, __queue) do {               \
0275     if ((__bfa)->iocfc.hwif.hw_reqq_ack)                \
0276         (__bfa)->iocfc.hwif.hw_reqq_ack(__bfa, __queue);    \
0277 } while (0)
0278 #define bfa_isr_mode_set(__bfa, __msix) do {                \
0279     if ((__bfa)->iocfc.hwif.hw_isr_mode_set)            \
0280         (__bfa)->iocfc.hwif.hw_isr_mode_set(__bfa, __msix); \
0281 } while (0)
0282 #define bfa_msix_getvecs(__bfa, __vecmap, __nvecs, __maxvec)        \
0283     ((__bfa)->iocfc.hwif.hw_msix_getvecs(__bfa, __vecmap,       \
0284                     __nvecs, __maxvec))
0285 #define bfa_msix_get_rme_range(__bfa, __start, __end)           \
0286     ((__bfa)->iocfc.hwif.hw_msix_get_rme_range(__bfa, __start, __end))
0287 #define bfa_msix(__bfa, __vec)                      \
0288     ((__bfa)->msix.handler[__vec](__bfa, __vec))
0289 
0290 /*
0291  * FC specific IOC functions.
0292  */
0293 void bfa_iocfc_meminfo(struct bfa_iocfc_cfg_s *cfg,
0294             struct bfa_meminfo_s *meminfo,
0295             struct bfa_s *bfa);
0296 void bfa_iocfc_attach(struct bfa_s *bfa, void *bfad,
0297               struct bfa_iocfc_cfg_s *cfg,
0298               struct bfa_pcidev_s *pcidev);
0299 void bfa_iocfc_init(struct bfa_s *bfa);
0300 void bfa_iocfc_start(struct bfa_s *bfa);
0301 void bfa_iocfc_stop(struct bfa_s *bfa);
0302 void bfa_iocfc_isr(void *bfa, struct bfi_mbmsg_s *msg);
0303 void bfa_iocfc_set_snsbase(struct bfa_s *bfa, int seg_no, u64 snsbase_pa);
0304 bfa_boolean_t bfa_iocfc_is_operational(struct bfa_s *bfa);
0305 void bfa_iocfc_reset_queues(struct bfa_s *bfa);
0306 
0307 void bfa_msix_all(struct bfa_s *bfa, int vec);
0308 void bfa_msix_reqq(struct bfa_s *bfa, int vec);
0309 void bfa_msix_rspq(struct bfa_s *bfa, int vec);
0310 void bfa_msix_lpu_err(struct bfa_s *bfa, int vec);
0311 
0312 void bfa_hwcb_reginit(struct bfa_s *bfa);
0313 void bfa_hwcb_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci);
0314 void bfa_hwcb_msix_init(struct bfa_s *bfa, int nvecs);
0315 void bfa_hwcb_msix_ctrl_install(struct bfa_s *bfa);
0316 void bfa_hwcb_msix_queue_install(struct bfa_s *bfa);
0317 void bfa_hwcb_msix_uninstall(struct bfa_s *bfa);
0318 void bfa_hwcb_isr_mode_set(struct bfa_s *bfa, bfa_boolean_t msix);
0319 void bfa_hwcb_msix_getvecs(struct bfa_s *bfa, u32 *vecmap, u32 *nvecs,
0320                u32 *maxvec);
0321 void bfa_hwcb_msix_get_rme_range(struct bfa_s *bfa, u32 *start,
0322                  u32 *end);
0323 void bfa_hwct_reginit(struct bfa_s *bfa);
0324 void bfa_hwct2_reginit(struct bfa_s *bfa);
0325 void bfa_hwct_reqq_ack(struct bfa_s *bfa, int rspq);
0326 void bfa_hwct_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci);
0327 void bfa_hwct2_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci);
0328 void bfa_hwct_msix_init(struct bfa_s *bfa, int nvecs);
0329 void bfa_hwct_msix_ctrl_install(struct bfa_s *bfa);
0330 void bfa_hwct_msix_queue_install(struct bfa_s *bfa);
0331 void bfa_hwct_msix_uninstall(struct bfa_s *bfa);
0332 void bfa_hwct_isr_mode_set(struct bfa_s *bfa, bfa_boolean_t msix);
0333 void bfa_hwct_msix_getvecs(struct bfa_s *bfa, u32 *vecmap, u32 *nvecs,
0334                u32 *maxvec);
0335 void bfa_hwct_msix_get_rme_range(struct bfa_s *bfa, u32 *start,
0336                  u32 *end);
0337 void bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns);
0338 int bfa_iocfc_get_pbc_vports(struct bfa_s *bfa,
0339                 struct bfi_pbc_vport_s *pbc_vport);
0340 
0341 
0342 /*
0343  *----------------------------------------------------------------------
0344  *      BFA public interfaces
0345  *----------------------------------------------------------------------
0346  */
0347 #define bfa_stats(_mod, _stats) ((_mod)->stats._stats++)
0348 #define bfa_ioc_get_stats(__bfa, __ioc_stats)       \
0349     bfa_ioc_fetch_stats(&(__bfa)->ioc, __ioc_stats)
0350 #define bfa_ioc_clear_stats(__bfa)      \
0351     bfa_ioc_clr_stats(&(__bfa)->ioc)
0352 #define bfa_get_nports(__bfa)           \
0353     bfa_ioc_get_nports(&(__bfa)->ioc)
0354 #define bfa_get_adapter_manufacturer(__bfa, __manufacturer)     \
0355     bfa_ioc_get_adapter_manufacturer(&(__bfa)->ioc, __manufacturer)
0356 #define bfa_get_adapter_model(__bfa, __model)           \
0357     bfa_ioc_get_adapter_model(&(__bfa)->ioc, __model)
0358 #define bfa_get_adapter_serial_num(__bfa, __serial_num)         \
0359     bfa_ioc_get_adapter_serial_num(&(__bfa)->ioc, __serial_num)
0360 #define bfa_get_adapter_fw_ver(__bfa, __fw_ver)         \
0361     bfa_ioc_get_adapter_fw_ver(&(__bfa)->ioc, __fw_ver)
0362 #define bfa_get_adapter_optrom_ver(__bfa, __optrom_ver)         \
0363     bfa_ioc_get_adapter_optrom_ver(&(__bfa)->ioc, __optrom_ver)
0364 #define bfa_get_pci_chip_rev(__bfa, __chip_rev)         \
0365     bfa_ioc_get_pci_chip_rev(&(__bfa)->ioc, __chip_rev)
0366 #define bfa_get_ioc_state(__bfa)        \
0367     bfa_ioc_get_state(&(__bfa)->ioc)
0368 #define bfa_get_type(__bfa)         \
0369     bfa_ioc_get_type(&(__bfa)->ioc)
0370 #define bfa_get_mac(__bfa)          \
0371     bfa_ioc_get_mac(&(__bfa)->ioc)
0372 #define bfa_get_mfg_mac(__bfa)          \
0373     bfa_ioc_get_mfg_mac(&(__bfa)->ioc)
0374 #define bfa_get_fw_clock_res(__bfa)     \
0375     ((__bfa)->iocfc.cfgrsp->fwcfg.fw_tick_res)
0376 
0377 /*
0378  * lun mask macros return NULL when min cfg is enabled and there is
0379  * no memory allocated for lunmask.
0380  */
0381 #define bfa_get_lun_mask(__bfa)                 \
0382     ((&(__bfa)->modules.dconf_mod)->min_cfg) ? NULL :   \
0383      (&(BFA_DCONF_MOD(__bfa)->dconf->lun_mask))
0384 
0385 #define bfa_get_lun_mask_list(_bfa)             \
0386     ((&(_bfa)->modules.dconf_mod)->min_cfg) ? NULL :    \
0387      (bfa_get_lun_mask(_bfa)->lun_list)
0388 
0389 #define bfa_get_lun_mask_status(_bfa)               \
0390     (((&(_bfa)->modules.dconf_mod)->min_cfg)        \
0391      ? BFA_LUNMASK_MINCFG : ((bfa_get_lun_mask(_bfa))->status))
0392 
0393 void bfa_get_pciids(struct bfa_pciid_s **pciids, int *npciids);
0394 void bfa_cfg_get_default(struct bfa_iocfc_cfg_s *cfg);
0395 void bfa_cfg_get_min(struct bfa_iocfc_cfg_s *cfg);
0396 void bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg,
0397             struct bfa_meminfo_s *meminfo,
0398             struct bfa_s *bfa);
0399 void bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
0400         struct bfa_meminfo_s *meminfo,
0401         struct bfa_pcidev_s *pcidev);
0402 void bfa_detach(struct bfa_s *bfa);
0403 void bfa_cb_init(void *bfad, bfa_status_t status);
0404 void bfa_cb_updateq(void *bfad, bfa_status_t status);
0405 
0406 bfa_boolean_t bfa_intx(struct bfa_s *bfa);
0407 void bfa_isr_enable(struct bfa_s *bfa);
0408 void bfa_isr_disable(struct bfa_s *bfa);
0409 
0410 void bfa_comp_deq(struct bfa_s *bfa, struct list_head *comp_q);
0411 void bfa_comp_process(struct bfa_s *bfa, struct list_head *comp_q);
0412 void bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q);
0413 
0414 typedef void (*bfa_cb_ioc_t) (void *cbarg, enum bfa_status status);
0415 void bfa_iocfc_get_attr(struct bfa_s *bfa, struct bfa_iocfc_attr_s *attr);
0416 
0417 
0418 bfa_status_t bfa_iocfc_israttr_set(struct bfa_s *bfa,
0419                    struct bfa_iocfc_intr_attr_s *attr);
0420 
0421 void bfa_iocfc_enable(struct bfa_s *bfa);
0422 void bfa_iocfc_disable(struct bfa_s *bfa);
0423 #define bfa_timer_start(_bfa, _timer, _timercb, _arg, _timeout)     \
0424     bfa_timer_begin(&(_bfa)->timer_mod, _timer, _timercb, _arg, _timeout)
0425 
0426 struct bfa_cb_pending_q_s {
0427     struct bfa_cb_qe_s  hcb_qe;
0428     void            *data;  /* Driver buffer */
0429 };
0430 
0431 /* Common macros to operate on pending stats/attr apis */
0432 #define bfa_pending_q_init(__qe, __cbfn, __cbarg, __data) do {  \
0433     bfa_q_qe_init(&((__qe)->hcb_qe.qe));            \
0434     (__qe)->hcb_qe.cbfn = (__cbfn);             \
0435     (__qe)->hcb_qe.cbarg = (__cbarg);           \
0436     (__qe)->hcb_qe.pre_rmv = BFA_TRUE;          \
0437     (__qe)->data = (__data);                \
0438 } while (0)
0439 
0440 #endif /* __BFA_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!