Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 1 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 2 | * Copyright (c) 2005-2010 Brocade Communications Systems, Inc. |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 3 | * All rights reserved |
| 4 | * www.brocade.com |
| 5 | * |
| 6 | * Linux driver for Brocade Fibre Channel Host Bus Adapter. |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify it |
| 9 | * under the terms of the GNU General Public License (GPL) Version 2 as |
| 10 | * published by the Free Software Foundation |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, but |
| 13 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * General Public License for more details. |
| 16 | */ |
| 17 | |
| 18 | #ifndef __BFA_IOC_H__ |
| 19 | #define __BFA_IOC_H__ |
| 20 | |
Maggie Zhang | f16a175 | 2010-12-09 19:12:32 -0800 | [diff] [blame] | 21 | #include "bfad_drv.h" |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 22 | #include "bfa_cs.h" |
| 23 | #include "bfi.h" |
| 24 | |
Maggie Zhang | f7f73812 | 2010-12-09 19:08:43 -0800 | [diff] [blame] | 25 | #define BFA_DBG_FWTRC_ENTS (BFI_IOC_TRC_ENTS) |
| 26 | #define BFA_DBG_FWTRC_LEN \ |
| 27 | (BFA_DBG_FWTRC_ENTS * sizeof(struct bfa_trc_s) + \ |
| 28 | (sizeof(struct bfa_trc_mod_s) - \ |
| 29 | BFA_TRC_MAX * sizeof(struct bfa_trc_s))) |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 30 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 31 | * BFA timer declarations |
| 32 | */ |
| 33 | typedef void (*bfa_timer_cbfn_t)(void *); |
| 34 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 35 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 36 | * BFA timer data structure |
| 37 | */ |
| 38 | struct bfa_timer_s { |
| 39 | struct list_head qe; |
| 40 | bfa_timer_cbfn_t timercb; |
| 41 | void *arg; |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 42 | int timeout; /* in millisecs */ |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 43 | }; |
| 44 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 45 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 46 | * Timer module structure |
| 47 | */ |
| 48 | struct bfa_timer_mod_s { |
| 49 | struct list_head timer_q; |
| 50 | }; |
| 51 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 52 | #define BFA_TIMER_FREQ 200 /* specified in millisecs */ |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 53 | |
| 54 | void bfa_timer_beat(struct bfa_timer_mod_s *mod); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 55 | void bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer, |
| 56 | bfa_timer_cbfn_t timercb, void *arg, |
| 57 | unsigned int timeout); |
| 58 | void bfa_timer_stop(struct bfa_timer_s *timer); |
| 59 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 60 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 61 | * Generic Scatter Gather Element used by driver |
| 62 | */ |
| 63 | struct bfa_sge_s { |
| 64 | u32 sg_len; |
| 65 | void *sg_addr; |
| 66 | }; |
| 67 | |
| 68 | #define bfa_sge_word_swap(__sge) do { \ |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 69 | ((u32 *)(__sge))[0] = swab32(((u32 *)(__sge))[0]); \ |
| 70 | ((u32 *)(__sge))[1] = swab32(((u32 *)(__sge))[1]); \ |
| 71 | ((u32 *)(__sge))[2] = swab32(((u32 *)(__sge))[2]); \ |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 72 | } while (0) |
| 73 | |
| 74 | #define bfa_swap_words(_x) ( \ |
| 75 | ((_x) << 32) | ((_x) >> 32)) |
| 76 | |
Maggie Zhang | f16a175 | 2010-12-09 19:12:32 -0800 | [diff] [blame] | 77 | #ifdef __BIG_ENDIAN |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 78 | #define bfa_sge_to_be(_x) |
| 79 | #define bfa_sge_to_le(_x) bfa_sge_word_swap(_x) |
| 80 | #define bfa_sgaddr_le(_x) bfa_swap_words(_x) |
| 81 | #else |
| 82 | #define bfa_sge_to_be(_x) bfa_sge_word_swap(_x) |
| 83 | #define bfa_sge_to_le(_x) |
| 84 | #define bfa_sgaddr_le(_x) (_x) |
| 85 | #endif |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 86 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 87 | /* |
Krishna Gudipati | 4507025 | 2011-06-24 20:24:29 -0700 | [diff] [blame] | 88 | * BFA memory resources |
| 89 | */ |
| 90 | struct bfa_mem_dma_s { |
| 91 | struct list_head qe; /* Queue of DMA elements */ |
| 92 | u32 mem_len; /* Total Length in Bytes */ |
| 93 | u8 *kva; /* kernel virtual address */ |
| 94 | u64 dma; /* dma address if DMA memory */ |
| 95 | u8 *kva_curp; /* kva allocation cursor */ |
| 96 | u64 dma_curp; /* dma allocation cursor */ |
| 97 | }; |
| 98 | #define bfa_mem_dma_t struct bfa_mem_dma_s |
| 99 | |
| 100 | struct bfa_mem_kva_s { |
| 101 | struct list_head qe; /* Queue of KVA elements */ |
| 102 | u32 mem_len; /* Total Length in Bytes */ |
| 103 | u8 *kva; /* kernel virtual address */ |
| 104 | u8 *kva_curp; /* kva allocation cursor */ |
| 105 | }; |
| 106 | #define bfa_mem_kva_t struct bfa_mem_kva_s |
| 107 | |
| 108 | struct bfa_meminfo_s { |
| 109 | struct bfa_mem_dma_s dma_info; |
| 110 | struct bfa_mem_kva_s kva_info; |
| 111 | }; |
| 112 | |
| 113 | /* BFA memory segment setup macros */ |
| 114 | #define bfa_mem_dma_setup(_meminfo, _dm_ptr, _seg_sz) do { \ |
| 115 | ((bfa_mem_dma_t *)(_dm_ptr))->mem_len = (_seg_sz); \ |
| 116 | if (_seg_sz) \ |
| 117 | list_add_tail(&((bfa_mem_dma_t *)_dm_ptr)->qe, \ |
| 118 | &(_meminfo)->dma_info.qe); \ |
| 119 | } while (0) |
| 120 | |
| 121 | #define bfa_mem_kva_setup(_meminfo, _kva_ptr, _seg_sz) do { \ |
| 122 | ((bfa_mem_kva_t *)(_kva_ptr))->mem_len = (_seg_sz); \ |
| 123 | if (_seg_sz) \ |
| 124 | list_add_tail(&((bfa_mem_kva_t *)_kva_ptr)->qe, \ |
| 125 | &(_meminfo)->kva_info.qe); \ |
| 126 | } while (0) |
| 127 | |
| 128 | /* BFA dma memory segments iterator */ |
| 129 | #define bfa_mem_dma_sptr(_mod, _i) (&(_mod)->dma_seg[(_i)]) |
| 130 | #define bfa_mem_dma_seg_iter(_mod, _sptr, _nr, _i) \ |
| 131 | for (_i = 0, _sptr = bfa_mem_dma_sptr(_mod, _i); _i < (_nr); \ |
| 132 | _i++, _sptr = bfa_mem_dma_sptr(_mod, _i)) |
| 133 | |
| 134 | #define bfa_mem_kva_curp(_mod) ((_mod)->kva_seg.kva_curp) |
| 135 | #define bfa_mem_dma_virt(_sptr) ((_sptr)->kva_curp) |
| 136 | #define bfa_mem_dma_phys(_sptr) ((_sptr)->dma_curp) |
| 137 | #define bfa_mem_dma_len(_sptr) ((_sptr)->mem_len) |
| 138 | |
| 139 | /* Get the corresponding dma buf kva for a req - from the tag */ |
| 140 | #define bfa_mem_get_dmabuf_kva(_mod, _tag, _rqsz) \ |
| 141 | (((u8 *)(_mod)->dma_seg[BFI_MEM_SEG_FROM_TAG(_tag, _rqsz)].kva_curp) +\ |
| 142 | BFI_MEM_SEG_REQ_OFFSET(_tag, _rqsz) * (_rqsz)) |
| 143 | |
| 144 | /* Get the corresponding dma buf pa for a req - from the tag */ |
| 145 | #define bfa_mem_get_dmabuf_pa(_mod, _tag, _rqsz) \ |
| 146 | ((_mod)->dma_seg[BFI_MEM_SEG_FROM_TAG(_tag, _rqsz)].dma_curp + \ |
| 147 | BFI_MEM_SEG_REQ_OFFSET(_tag, _rqsz) * (_rqsz)) |
| 148 | |
| 149 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 150 | * PCI device information required by IOC |
| 151 | */ |
| 152 | struct bfa_pcidev_s { |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 153 | int pci_slot; |
| 154 | u8 pci_func; |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 155 | u16 device_id; |
Krishna Gudipati | 1a4d8e1 | 2011-06-24 20:22:28 -0700 | [diff] [blame] | 156 | u16 ssid; |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 157 | void __iomem *pci_bar_kva; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 158 | }; |
| 159 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 160 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 161 | * Structure used to remember the DMA-able memory block's KVA and Physical |
| 162 | * Address |
| 163 | */ |
| 164 | struct bfa_dma_s { |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 165 | void *kva; /* ! Kernel virtual address */ |
| 166 | u64 pa; /* ! Physical address */ |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 167 | }; |
| 168 | |
| 169 | #define BFA_DMA_ALIGN_SZ 256 |
| 170 | #define BFA_ROUNDUP(_l, _s) (((_l) + ((_s) - 1)) & ~((_s) - 1)) |
| 171 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 172 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 173 | * smem size for Crossbow and Catapult |
| 174 | */ |
| 175 | #define BFI_SMEM_CB_SIZE 0x200000U /* ! 2MB for crossbow */ |
| 176 | #define BFI_SMEM_CT_SIZE 0x280000U /* ! 2.5MB for catapult */ |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 177 | |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 178 | #define bfa_dma_be_addr_set(dma_addr, pa) \ |
| 179 | __bfa_dma_be_addr_set(&dma_addr, (u64)pa) |
| 180 | static inline void |
| 181 | __bfa_dma_be_addr_set(union bfi_addr_u *dma_addr, u64 pa) |
| 182 | { |
Maggie | 50444a3 | 2010-11-29 18:26:32 -0800 | [diff] [blame] | 183 | dma_addr->a32.addr_lo = cpu_to_be32(pa); |
Maggie Zhang | f16a175 | 2010-12-09 19:12:32 -0800 | [diff] [blame] | 184 | dma_addr->a32.addr_hi = cpu_to_be32(pa >> 32); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 185 | } |
| 186 | |
Krishna Gudipati | 85ce928 | 2011-06-13 15:39:36 -0700 | [diff] [blame] | 187 | #define bfa_alen_set(__alen, __len, __pa) \ |
| 188 | __bfa_alen_set(__alen, __len, (u64)__pa) |
| 189 | |
| 190 | static inline void |
| 191 | __bfa_alen_set(struct bfi_alen_s *alen, u32 len, u64 pa) |
| 192 | { |
| 193 | alen->al_len = cpu_to_be32(len); |
| 194 | bfa_dma_be_addr_set(alen->al_addr, pa); |
| 195 | } |
| 196 | |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 197 | struct bfa_ioc_regs_s { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 198 | void __iomem *hfn_mbox_cmd; |
| 199 | void __iomem *hfn_mbox; |
| 200 | void __iomem *lpu_mbox_cmd; |
| 201 | void __iomem *lpu_mbox; |
Krishna Gudipati | 8b070b4 | 2011-06-13 15:52:40 -0700 | [diff] [blame] | 202 | void __iomem *lpu_read_stat; |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 203 | void __iomem *pss_ctl_reg; |
| 204 | void __iomem *pss_err_status_reg; |
| 205 | void __iomem *app_pll_fast_ctl_reg; |
| 206 | void __iomem *app_pll_slow_ctl_reg; |
| 207 | void __iomem *ioc_sem_reg; |
| 208 | void __iomem *ioc_usage_sem_reg; |
| 209 | void __iomem *ioc_init_sem_reg; |
| 210 | void __iomem *ioc_usage_reg; |
| 211 | void __iomem *host_page_num_fn; |
| 212 | void __iomem *heartbeat; |
| 213 | void __iomem *ioc_fwstate; |
Krishna Gudipati | f1d584d | 2010-12-13 16:17:11 -0800 | [diff] [blame] | 214 | void __iomem *alt_ioc_fwstate; |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 215 | void __iomem *ll_halt; |
Krishna Gudipati | f1d584d | 2010-12-13 16:17:11 -0800 | [diff] [blame] | 216 | void __iomem *alt_ll_halt; |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 217 | void __iomem *err_set; |
Krishna Gudipati | f1d584d | 2010-12-13 16:17:11 -0800 | [diff] [blame] | 218 | void __iomem *ioc_fail_sync; |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 219 | void __iomem *shirq_isr_next; |
| 220 | void __iomem *shirq_msk_next; |
| 221 | void __iomem *smem_page_start; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 222 | u32 smem_pg0; |
| 223 | }; |
| 224 | |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 225 | #define bfa_mem_read(_raddr, _off) swab32(readl(((_raddr) + (_off)))) |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 226 | #define bfa_mem_write(_raddr, _off, _val) \ |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 227 | writel(swab32((_val)), ((_raddr) + (_off))) |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 228 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 229 | * IOC Mailbox structures |
| 230 | */ |
| 231 | struct bfa_mbox_cmd_s { |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 232 | struct list_head qe; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 233 | u32 msg[BFI_IOC_MSGSZ]; |
| 234 | }; |
| 235 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 236 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 237 | * IOC mailbox module |
| 238 | */ |
| 239 | typedef void (*bfa_ioc_mbox_mcfunc_t)(void *cbarg, struct bfi_mbmsg_s *m); |
| 240 | struct bfa_ioc_mbox_mod_s { |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 241 | struct list_head cmd_q; /* pending mbox queue */ |
| 242 | int nmclass; /* number of handlers */ |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 243 | struct { |
| 244 | bfa_ioc_mbox_mcfunc_t cbfn; /* message handlers */ |
| 245 | void *cbarg; |
| 246 | } mbhdlr[BFI_MC_MAX]; |
| 247 | }; |
| 248 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 249 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 250 | * IOC callback function interfaces |
| 251 | */ |
| 252 | typedef void (*bfa_ioc_enable_cbfn_t)(void *bfa, enum bfa_status status); |
| 253 | typedef void (*bfa_ioc_disable_cbfn_t)(void *bfa); |
| 254 | typedef void (*bfa_ioc_hbfail_cbfn_t)(void *bfa); |
| 255 | typedef void (*bfa_ioc_reset_cbfn_t)(void *bfa); |
| 256 | struct bfa_ioc_cbfn_s { |
| 257 | bfa_ioc_enable_cbfn_t enable_cbfn; |
| 258 | bfa_ioc_disable_cbfn_t disable_cbfn; |
| 259 | bfa_ioc_hbfail_cbfn_t hbfail_cbfn; |
| 260 | bfa_ioc_reset_cbfn_t reset_cbfn; |
| 261 | }; |
| 262 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 263 | /* |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 264 | * IOC event notification mechanism. |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 265 | */ |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 266 | enum bfa_ioc_event_e { |
| 267 | BFA_IOC_E_ENABLED = 1, |
| 268 | BFA_IOC_E_DISABLED = 2, |
| 269 | BFA_IOC_E_FAILED = 3, |
| 270 | }; |
| 271 | |
| 272 | typedef void (*bfa_ioc_notify_cbfn_t)(void *, enum bfa_ioc_event_e); |
| 273 | |
| 274 | struct bfa_ioc_notify_s { |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 275 | struct list_head qe; |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 276 | bfa_ioc_notify_cbfn_t cbfn; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 277 | void *cbarg; |
| 278 | }; |
| 279 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 280 | /* |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 281 | * Initialize a IOC event notification structure |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 282 | */ |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 283 | #define bfa_ioc_notify_init(__notify, __cbfn, __cbarg) do { \ |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 284 | (__notify)->cbfn = (__cbfn); \ |
| 285 | (__notify)->cbarg = (__cbarg); \ |
| 286 | } while (0) |
| 287 | |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 288 | struct bfa_iocpf_s { |
| 289 | bfa_fsm_t fsm; |
| 290 | struct bfa_ioc_s *ioc; |
Krishna Gudipati | 775c774 | 2011-06-13 15:52:12 -0700 | [diff] [blame] | 291 | bfa_boolean_t fw_mismatch_notified; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 292 | bfa_boolean_t auto_recover; |
Krishna Gudipati | 775c774 | 2011-06-13 15:52:12 -0700 | [diff] [blame] | 293 | u32 poll_time; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 294 | }; |
| 295 | |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 296 | struct bfa_ioc_s { |
| 297 | bfa_fsm_t fsm; |
| 298 | struct bfa_s *bfa; |
| 299 | struct bfa_pcidev_s pcidev; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 300 | struct bfa_timer_mod_s *timer_mod; |
| 301 | struct bfa_timer_s ioc_timer; |
| 302 | struct bfa_timer_s sem_timer; |
| 303 | struct bfa_timer_s hb_timer; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 304 | u32 hb_count; |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 305 | struct list_head notify_q; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 306 | void *dbg_fwsave; |
| 307 | int dbg_fwsave_len; |
| 308 | bfa_boolean_t dbg_fwsave_once; |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 309 | enum bfi_pcifn_class clscode; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 310 | struct bfa_ioc_regs_s ioc_regs; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 311 | struct bfa_trc_mod_s *trcmod; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 312 | struct bfa_ioc_drv_stats_s stats; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 313 | bfa_boolean_t fcmode; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 314 | bfa_boolean_t pllinit; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 315 | bfa_boolean_t stats_busy; /* outstanding stats */ |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 316 | u8 port_id; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 317 | struct bfa_dma_s attr_dma; |
| 318 | struct bfi_ioc_attr_s *attr; |
| 319 | struct bfa_ioc_cbfn_s *cbfn; |
| 320 | struct bfa_ioc_mbox_mod_s mbox_mod; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 321 | struct bfa_ioc_hwif_s *ioc_hwif; |
| 322 | struct bfa_iocpf_s iocpf; |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 323 | enum bfi_asic_gen asic_gen; |
| 324 | enum bfi_asic_mode asic_mode; |
| 325 | enum bfi_port_mode port0_mode; |
| 326 | enum bfi_port_mode port1_mode; |
Krishna Gudipati | 1a4d8e1 | 2011-06-24 20:22:28 -0700 | [diff] [blame] | 327 | enum bfa_mode_s port_mode; |
| 328 | u8 ad_cap_bm; /* adapter cap bit mask */ |
| 329 | u8 port_mode_cfg; /* config port mode */ |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 330 | }; |
| 331 | |
| 332 | struct bfa_ioc_hwif_s { |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 333 | bfa_status_t (*ioc_pll_init) (void __iomem *rb, enum bfi_asic_mode m); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 334 | bfa_boolean_t (*ioc_firmware_lock) (struct bfa_ioc_s *ioc); |
| 335 | void (*ioc_firmware_unlock) (struct bfa_ioc_s *ioc); |
| 336 | void (*ioc_reg_init) (struct bfa_ioc_s *ioc); |
| 337 | void (*ioc_map_port) (struct bfa_ioc_s *ioc); |
| 338 | void (*ioc_isr_mode_set) (struct bfa_ioc_s *ioc, |
| 339 | bfa_boolean_t msix); |
Krishna Gudipati | f1d584d | 2010-12-13 16:17:11 -0800 | [diff] [blame] | 340 | void (*ioc_notify_fail) (struct bfa_ioc_s *ioc); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 341 | void (*ioc_ownership_reset) (struct bfa_ioc_s *ioc); |
Jing Huang | 45d7f0c | 2011-04-13 11:45:53 -0700 | [diff] [blame] | 342 | bfa_boolean_t (*ioc_sync_start) (struct bfa_ioc_s *ioc); |
Krishna Gudipati | f1d584d | 2010-12-13 16:17:11 -0800 | [diff] [blame] | 343 | void (*ioc_sync_join) (struct bfa_ioc_s *ioc); |
| 344 | void (*ioc_sync_leave) (struct bfa_ioc_s *ioc); |
| 345 | void (*ioc_sync_ack) (struct bfa_ioc_s *ioc); |
| 346 | bfa_boolean_t (*ioc_sync_complete) (struct bfa_ioc_s *ioc); |
Krishna Gudipati | 8b070b4 | 2011-06-13 15:52:40 -0700 | [diff] [blame] | 347 | bfa_boolean_t (*ioc_lpu_read_stat) (struct bfa_ioc_s *ioc); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 348 | }; |
| 349 | |
Krishna Gudipati | 1a4d8e1 | 2011-06-24 20:22:28 -0700 | [diff] [blame] | 350 | /* |
Krishna Gudipati | 5a54b1d | 2011-06-24 20:27:13 -0700 | [diff] [blame^] | 351 | * Queue element to wait for room in request queue. FIFO order is |
| 352 | * maintained when fullfilling requests. |
| 353 | */ |
| 354 | struct bfa_reqq_wait_s { |
| 355 | struct list_head qe; |
| 356 | void (*qresume) (void *cbarg); |
| 357 | void *cbarg; |
| 358 | }; |
| 359 | |
| 360 | typedef void (*bfa_cb_cbfn_t) (void *cbarg, bfa_boolean_t complete); |
| 361 | |
| 362 | /* |
| 363 | * Generic BFA callback element. |
| 364 | */ |
| 365 | struct bfa_cb_qe_s { |
| 366 | struct list_head qe; |
| 367 | bfa_cb_cbfn_t cbfn; |
| 368 | bfa_boolean_t once; |
| 369 | void *cbarg; |
| 370 | }; |
| 371 | |
| 372 | /* |
Krishna Gudipati | 1a4d8e1 | 2011-06-24 20:22:28 -0700 | [diff] [blame] | 373 | * ASIC block configurtion related |
| 374 | */ |
| 375 | |
| 376 | typedef void (*bfa_ablk_cbfn_t)(void *, enum bfa_status); |
| 377 | |
| 378 | struct bfa_ablk_s { |
| 379 | struct bfa_ioc_s *ioc; |
| 380 | struct bfa_ablk_cfg_s *cfg; |
| 381 | u16 *pcifn; |
| 382 | struct bfa_dma_s dma_addr; |
| 383 | bfa_boolean_t busy; |
| 384 | struct bfa_mbox_cmd_s mb; |
| 385 | bfa_ablk_cbfn_t cbfn; |
| 386 | void *cbarg; |
| 387 | struct bfa_ioc_notify_s ioc_notify; |
Krishna Gudipati | 4507025 | 2011-06-24 20:24:29 -0700 | [diff] [blame] | 388 | struct bfa_mem_dma_s ablk_dma; |
Krishna Gudipati | 1a4d8e1 | 2011-06-24 20:22:28 -0700 | [diff] [blame] | 389 | }; |
Krishna Gudipati | 4507025 | 2011-06-24 20:24:29 -0700 | [diff] [blame] | 390 | #define BFA_MEM_ABLK_DMA(__bfa) (&((__bfa)->modules.ablk.ablk_dma)) |
Krishna Gudipati | 1a4d8e1 | 2011-06-24 20:22:28 -0700 | [diff] [blame] | 391 | |
Krishna Gudipati | 51e569a | 2011-06-24 20:26:25 -0700 | [diff] [blame] | 392 | /* |
| 393 | * SFP module specific |
| 394 | */ |
| 395 | typedef void (*bfa_cb_sfp_t) (void *cbarg, bfa_status_t status); |
| 396 | |
| 397 | struct bfa_sfp_s { |
| 398 | void *dev; |
| 399 | struct bfa_ioc_s *ioc; |
| 400 | struct bfa_trc_mod_s *trcmod; |
| 401 | struct sfp_mem_s *sfpmem; |
| 402 | bfa_cb_sfp_t cbfn; |
| 403 | void *cbarg; |
| 404 | enum bfi_sfp_mem_e memtype; /* mem access type */ |
| 405 | u32 status; |
| 406 | struct bfa_mbox_cmd_s mbcmd; |
| 407 | u8 *dbuf_kva; /* dma buf virtual address */ |
| 408 | u64 dbuf_pa; /* dma buf physical address */ |
| 409 | struct bfa_ioc_notify_s ioc_notify; |
| 410 | enum bfa_defs_sfp_media_e *media; |
| 411 | enum bfa_port_speed portspeed; |
| 412 | bfa_cb_sfp_t state_query_cbfn; |
| 413 | void *state_query_cbarg; |
| 414 | u8 lock; |
| 415 | u8 data_valid; /* data in dbuf is valid */ |
| 416 | u8 state; /* sfp state */ |
| 417 | u8 state_query_lock; |
| 418 | struct bfa_mem_dma_s sfp_dma; |
| 419 | u8 is_elb; /* eloopback */ |
| 420 | }; |
| 421 | |
| 422 | #define BFA_SFP_MOD(__bfa) (&(__bfa)->modules.sfp) |
| 423 | #define BFA_MEM_SFP_DMA(__bfa) (&(BFA_SFP_MOD(__bfa)->sfp_dma)) |
| 424 | |
| 425 | u32 bfa_sfp_meminfo(void); |
| 426 | |
| 427 | void bfa_sfp_attach(struct bfa_sfp_s *sfp, struct bfa_ioc_s *ioc, |
| 428 | void *dev, struct bfa_trc_mod_s *trcmod); |
| 429 | |
| 430 | void bfa_sfp_memclaim(struct bfa_sfp_s *diag, u8 *dm_kva, u64 dm_pa); |
| 431 | void bfa_sfp_intr(void *bfaarg, struct bfi_mbmsg_s *msg); |
| 432 | |
| 433 | bfa_status_t bfa_sfp_show(struct bfa_sfp_s *sfp, struct sfp_mem_s *sfpmem, |
| 434 | bfa_cb_sfp_t cbfn, void *cbarg); |
| 435 | |
| 436 | bfa_status_t bfa_sfp_media(struct bfa_sfp_s *sfp, |
| 437 | enum bfa_defs_sfp_media_e *media, |
| 438 | bfa_cb_sfp_t cbfn, void *cbarg); |
| 439 | |
| 440 | bfa_status_t bfa_sfp_speed(struct bfa_sfp_s *sfp, |
| 441 | enum bfa_port_speed portspeed, |
| 442 | bfa_cb_sfp_t cbfn, void *cbarg); |
| 443 | |
Krishna Gudipati | 5a54b1d | 2011-06-24 20:27:13 -0700 | [diff] [blame^] | 444 | /* |
| 445 | * Flash module specific |
| 446 | */ |
| 447 | typedef void (*bfa_cb_flash_t) (void *cbarg, bfa_status_t status); |
| 448 | |
| 449 | struct bfa_flash_s { |
| 450 | struct bfa_ioc_s *ioc; /* back pointer to ioc */ |
| 451 | struct bfa_trc_mod_s *trcmod; |
| 452 | u32 type; /* partition type */ |
| 453 | u8 instance; /* partition instance */ |
| 454 | u8 rsv[3]; |
| 455 | u32 op_busy; /* operation busy flag */ |
| 456 | u32 residue; /* residual length */ |
| 457 | u32 offset; /* offset */ |
| 458 | bfa_status_t status; /* status */ |
| 459 | u8 *dbuf_kva; /* dma buf virtual address */ |
| 460 | u64 dbuf_pa; /* dma buf physical address */ |
| 461 | struct bfa_reqq_wait_s reqq_wait; /* to wait for room in reqq */ |
| 462 | bfa_cb_flash_t cbfn; /* user callback function */ |
| 463 | void *cbarg; /* user callback arg */ |
| 464 | u8 *ubuf; /* user supplied buffer */ |
| 465 | struct bfa_cb_qe_s hcb_qe; /* comp: BFA callback qelem */ |
| 466 | u32 addr_off; /* partition address offset */ |
| 467 | struct bfa_mbox_cmd_s mb; /* mailbox */ |
| 468 | struct bfa_ioc_notify_s ioc_notify; /* ioc event notify */ |
| 469 | struct bfa_mem_dma_s flash_dma; |
| 470 | }; |
| 471 | |
| 472 | #define BFA_FLASH(__bfa) (&(__bfa)->modules.flash) |
| 473 | #define BFA_MEM_FLASH_DMA(__bfa) (&(BFA_FLASH(__bfa)->flash_dma)) |
| 474 | |
| 475 | bfa_status_t bfa_flash_get_attr(struct bfa_flash_s *flash, |
| 476 | struct bfa_flash_attr_s *attr, |
| 477 | bfa_cb_flash_t cbfn, void *cbarg); |
| 478 | bfa_status_t bfa_flash_erase_part(struct bfa_flash_s *flash, |
| 479 | enum bfa_flash_part_type type, u8 instance, |
| 480 | bfa_cb_flash_t cbfn, void *cbarg); |
| 481 | bfa_status_t bfa_flash_update_part(struct bfa_flash_s *flash, |
| 482 | enum bfa_flash_part_type type, u8 instance, |
| 483 | void *buf, u32 len, u32 offset, |
| 484 | bfa_cb_flash_t cbfn, void *cbarg); |
| 485 | bfa_status_t bfa_flash_read_part(struct bfa_flash_s *flash, |
| 486 | enum bfa_flash_part_type type, u8 instance, void *buf, |
| 487 | u32 len, u32 offset, bfa_cb_flash_t cbfn, void *cbarg); |
| 488 | u32 bfa_flash_meminfo(bfa_boolean_t mincfg); |
| 489 | void bfa_flash_attach(struct bfa_flash_s *flash, struct bfa_ioc_s *ioc, |
| 490 | void *dev, struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg); |
| 491 | void bfa_flash_memclaim(struct bfa_flash_s *flash, |
| 492 | u8 *dm_kva, u64 dm_pa, bfa_boolean_t mincfg); |
| 493 | |
Jing Huang | f8ceafd | 2009-09-25 12:29:54 -0700 | [diff] [blame] | 494 | #define bfa_ioc_pcifn(__ioc) ((__ioc)->pcidev.pci_func) |
| 495 | #define bfa_ioc_devid(__ioc) ((__ioc)->pcidev.device_id) |
| 496 | #define bfa_ioc_bar0(__ioc) ((__ioc)->pcidev.pci_bar_kva) |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 497 | #define bfa_ioc_portid(__ioc) ((__ioc)->port_id) |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 498 | #define bfa_ioc_asic_gen(__ioc) ((__ioc)->asic_gen) |
| 499 | #define bfa_ioc_is_cna(__ioc) \ |
Krishna Gudipati | 75332a7 | 2011-06-13 15:54:31 -0700 | [diff] [blame] | 500 | ((bfa_ioc_get_type(__ioc) == BFA_IOC_TYPE_FCoE) || \ |
| 501 | (bfa_ioc_get_type(__ioc) == BFA_IOC_TYPE_LL)) |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 502 | #define bfa_ioc_fetch_stats(__ioc, __stats) \ |
Jing Huang | f8ceafd | 2009-09-25 12:29:54 -0700 | [diff] [blame] | 503 | (((__stats)->drv_stats) = (__ioc)->stats) |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 504 | #define bfa_ioc_clr_stats(__ioc) \ |
Jing Huang | 6a18b16 | 2010-10-18 17:08:54 -0700 | [diff] [blame] | 505 | memset(&(__ioc)->stats, 0, sizeof((__ioc)->stats)) |
Jing Huang | f8ceafd | 2009-09-25 12:29:54 -0700 | [diff] [blame] | 506 | #define bfa_ioc_maxfrsize(__ioc) ((__ioc)->attr->maxfrsize) |
| 507 | #define bfa_ioc_rx_bbcredit(__ioc) ((__ioc)->attr->rx_bbcredit) |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 508 | #define bfa_ioc_speed_sup(__ioc) \ |
| 509 | BFI_ADAPTER_GETP(SPEED, (__ioc)->attr->adapter_prop) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 510 | #define bfa_ioc_get_nports(__ioc) \ |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 511 | BFI_ADAPTER_GETP(NPORTS, (__ioc)->attr->adapter_prop) |
| 512 | |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 513 | #define bfa_ioc_stats(_ioc, _stats) ((_ioc)->stats._stats++) |
| 514 | #define BFA_IOC_FWIMG_MINSZ (16 * 1024) |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 515 | #define BFA_IOC_FW_SMEM_SIZE(__ioc) \ |
| 516 | ((bfa_ioc_asic_gen(__ioc) == BFI_ASIC_GEN_CB) \ |
| 517 | ? BFI_SMEM_CB_SIZE : BFI_SMEM_CT_SIZE) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 518 | #define BFA_IOC_FLASH_CHUNK_NO(off) (off / BFI_FLASH_CHUNK_SZ_WORDS) |
| 519 | #define BFA_IOC_FLASH_OFFSET_IN_CHUNK(off) (off % BFI_FLASH_CHUNK_SZ_WORDS) |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 520 | #define BFA_IOC_FLASH_CHUNK_ADDR(chunkno) (chunkno * BFI_FLASH_CHUNK_SZ_WORDS) |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 521 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 522 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 523 | * IOC mailbox interface |
| 524 | */ |
| 525 | void bfa_ioc_mbox_queue(struct bfa_ioc_s *ioc, struct bfa_mbox_cmd_s *cmd); |
| 526 | void bfa_ioc_mbox_register(struct bfa_ioc_s *ioc, |
| 527 | bfa_ioc_mbox_mcfunc_t *mcfuncs); |
| 528 | void bfa_ioc_mbox_isr(struct bfa_ioc_s *ioc); |
| 529 | void bfa_ioc_mbox_send(struct bfa_ioc_s *ioc, void *ioc_msg, int len); |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 530 | bfa_boolean_t bfa_ioc_msgget(struct bfa_ioc_s *ioc, void *mbmsg); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 531 | void bfa_ioc_mbox_regisr(struct bfa_ioc_s *ioc, enum bfi_mclass mc, |
| 532 | bfa_ioc_mbox_mcfunc_t cbfn, void *cbarg); |
| 533 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 534 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 535 | * IOC interfaces |
| 536 | */ |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 537 | |
| 538 | #define bfa_ioc_pll_init_asic(__ioc) \ |
| 539 | ((__ioc)->ioc_hwif->ioc_pll_init((__ioc)->pcidev.pci_bar_kva, \ |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 540 | (__ioc)->asic_mode)) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 541 | |
| 542 | bfa_status_t bfa_ioc_pll_init(struct bfa_ioc_s *ioc); |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 543 | bfa_status_t bfa_ioc_cb_pll_init(void __iomem *rb, enum bfi_asic_mode mode); |
| 544 | bfa_status_t bfa_ioc_ct_pll_init(void __iomem *rb, enum bfi_asic_mode mode); |
| 545 | bfa_status_t bfa_ioc_ct2_pll_init(void __iomem *rb, enum bfi_asic_mode mode); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 546 | |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 547 | #define bfa_ioc_isr_mode_set(__ioc, __msix) do { \ |
| 548 | if ((__ioc)->ioc_hwif->ioc_isr_mode_set) \ |
| 549 | ((__ioc)->ioc_hwif->ioc_isr_mode_set(__ioc, __msix)); \ |
| 550 | } while (0) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 551 | #define bfa_ioc_ownership_reset(__ioc) \ |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 552 | ((__ioc)->ioc_hwif->ioc_ownership_reset(__ioc)) |
Krishna Gudipati | 10a0737 | 2011-06-24 20:23:38 -0700 | [diff] [blame] | 553 | #define bfa_ioc_get_fcmode(__ioc) ((__ioc)->fcmode) |
Krishna Gudipati | 8b070b4 | 2011-06-13 15:52:40 -0700 | [diff] [blame] | 554 | #define bfa_ioc_lpu_read_stat(__ioc) do { \ |
| 555 | if ((__ioc)->ioc_hwif->ioc_lpu_read_stat) \ |
| 556 | ((__ioc)->ioc_hwif->ioc_lpu_read_stat(__ioc)); \ |
| 557 | } while (0) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 558 | |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 559 | void bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc); |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 560 | void bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc); |
| 561 | void bfa_ioc_set_ct2_hwif(struct bfa_ioc_s *ioc); |
| 562 | void bfa_ioc_ct2_poweron(struct bfa_ioc_s *ioc); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 563 | |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 564 | void bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa, |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 565 | struct bfa_ioc_cbfn_s *cbfn, struct bfa_timer_mod_s *timer_mod); |
| 566 | void bfa_ioc_auto_recover(bfa_boolean_t auto_recover); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 567 | void bfa_ioc_detach(struct bfa_ioc_s *ioc); |
| 568 | void bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev, |
Krishna Gudipati | d37779f | 2011-06-13 15:42:10 -0700 | [diff] [blame] | 569 | enum bfi_pcifn_class clscode); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 570 | void bfa_ioc_mem_claim(struct bfa_ioc_s *ioc, u8 *dm_kva, u64 dm_pa); |
| 571 | void bfa_ioc_enable(struct bfa_ioc_s *ioc); |
| 572 | void bfa_ioc_disable(struct bfa_ioc_s *ioc); |
| 573 | bfa_boolean_t bfa_ioc_intx_claim(struct bfa_ioc_s *ioc); |
| 574 | |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 575 | void bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type, |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 576 | u32 boot_env); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 577 | void bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *msg); |
| 578 | void bfa_ioc_error_isr(struct bfa_ioc_s *ioc); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 579 | bfa_boolean_t bfa_ioc_is_operational(struct bfa_ioc_s *ioc); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 580 | bfa_boolean_t bfa_ioc_is_initialized(struct bfa_ioc_s *ioc); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 581 | bfa_boolean_t bfa_ioc_is_disabled(struct bfa_ioc_s *ioc); |
Krishna Gudipati | a714134 | 2011-06-24 20:23:19 -0700 | [diff] [blame] | 582 | bfa_boolean_t bfa_ioc_is_acq_addr(struct bfa_ioc_s *ioc); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 583 | bfa_boolean_t bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc); |
| 584 | bfa_boolean_t bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc); |
Krishna Gudipati | f1d584d | 2010-12-13 16:17:11 -0800 | [diff] [blame] | 585 | void bfa_ioc_reset_fwstate(struct bfa_ioc_s *ioc); |
Krishna Gudipati | 0a4b1fc | 2010-03-05 19:37:57 -0800 | [diff] [blame] | 586 | enum bfa_ioc_type_e bfa_ioc_get_type(struct bfa_ioc_s *ioc); |
| 587 | void bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num); |
| 588 | void bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver); |
| 589 | void bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver); |
| 590 | void bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model); |
| 591 | void bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc, |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 592 | char *manufacturer); |
Krishna Gudipati | 0a4b1fc | 2010-03-05 19:37:57 -0800 | [diff] [blame] | 593 | void bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev); |
| 594 | enum bfa_ioc_state bfa_ioc_get_state(struct bfa_ioc_s *ioc); |
| 595 | |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 596 | void bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr); |
| 597 | void bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc, |
| 598 | struct bfa_adapter_attr_s *ad_attr); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 599 | void bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave); |
| 600 | bfa_status_t bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata, |
| 601 | int *trclen); |
| 602 | bfa_status_t bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata, |
| 603 | int *trclen); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 604 | bfa_status_t bfa_ioc_debug_fwcore(struct bfa_ioc_s *ioc, void *buf, |
| 605 | u32 *offset, int *buflen); |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 606 | bfa_boolean_t bfa_ioc_sem_get(void __iomem *sem_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 607 | void bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, |
| 608 | struct bfi_ioc_image_hdr_s *fwhdr); |
| 609 | bfa_boolean_t bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, |
| 610 | struct bfi_ioc_image_hdr_s *fwhdr); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 611 | bfa_status_t bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats); |
| 612 | bfa_status_t bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 613 | |
| 614 | /* |
Krishna Gudipati | 1a4d8e1 | 2011-06-24 20:22:28 -0700 | [diff] [blame] | 615 | * asic block configuration related APIs |
| 616 | */ |
| 617 | u32 bfa_ablk_meminfo(void); |
| 618 | void bfa_ablk_memclaim(struct bfa_ablk_s *ablk, u8 *dma_kva, u64 dma_pa); |
| 619 | void bfa_ablk_attach(struct bfa_ablk_s *ablk, struct bfa_ioc_s *ioc); |
| 620 | bfa_status_t bfa_ablk_query(struct bfa_ablk_s *ablk, |
| 621 | struct bfa_ablk_cfg_s *ablk_cfg, |
| 622 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 623 | bfa_status_t bfa_ablk_adapter_config(struct bfa_ablk_s *ablk, |
| 624 | enum bfa_mode_s mode, int max_pf, int max_vf, |
| 625 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 626 | bfa_status_t bfa_ablk_port_config(struct bfa_ablk_s *ablk, int port, |
| 627 | enum bfa_mode_s mode, int max_pf, int max_vf, |
| 628 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 629 | bfa_status_t bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn, |
| 630 | u8 port, enum bfi_pcifn_class personality, int bw, |
| 631 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 632 | bfa_status_t bfa_ablk_pf_delete(struct bfa_ablk_s *ablk, int pcifn, |
| 633 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 634 | bfa_status_t bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, int bw, |
| 635 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 636 | bfa_status_t bfa_ablk_optrom_en(struct bfa_ablk_s *ablk, |
| 637 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 638 | bfa_status_t bfa_ablk_optrom_dis(struct bfa_ablk_s *ablk, |
| 639 | bfa_ablk_cbfn_t cbfn, void *cbarg); |
| 640 | |
| 641 | /* |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 642 | * bfa mfg wwn API functions |
| 643 | */ |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 644 | mac_t bfa_ioc_get_mac(struct bfa_ioc_s *ioc); |
Jing Huang | 15b64a8 | 2010-07-08 19:48:12 -0700 | [diff] [blame] | 645 | mac_t bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc); |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 646 | |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 647 | /* |
| 648 | * F/W Image Size & Chunk |
| 649 | */ |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 650 | extern u32 bfi_image_cb_size; |
| 651 | extern u32 bfi_image_ct_size; |
| 652 | extern u32 bfi_image_ct2_size; |
| 653 | extern u32 *bfi_image_cb; |
| 654 | extern u32 *bfi_image_ct; |
| 655 | extern u32 *bfi_image_ct2; |
Jing Huang | 7725ccf | 2009-09-23 17:46:15 -0700 | [diff] [blame] | 656 | |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 657 | static inline u32 * |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 658 | bfi_image_cb_get_chunk(u32 off) |
| 659 | { |
| 660 | return (u32 *)(bfi_image_cb + off); |
| 661 | } |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 662 | |
| 663 | static inline u32 * |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 664 | bfi_image_ct_get_chunk(u32 off) |
| 665 | { |
| 666 | return (u32 *)(bfi_image_ct + off); |
| 667 | } |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 668 | |
| 669 | static inline u32 * |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 670 | bfi_image_ct2_get_chunk(u32 off) |
| 671 | { |
| 672 | return (u32 *)(bfi_image_ct2 + off); |
| 673 | } |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 674 | |
| 675 | static inline u32* |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 676 | bfa_cb_image_get_chunk(enum bfi_asic_gen asic_gen, u32 off) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 677 | { |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 678 | switch (asic_gen) { |
| 679 | case BFI_ASIC_GEN_CB: |
| 680 | return bfi_image_cb_get_chunk(off); |
| 681 | break; |
| 682 | case BFI_ASIC_GEN_CT: |
| 683 | return bfi_image_ct_get_chunk(off); |
| 684 | break; |
| 685 | case BFI_ASIC_GEN_CT2: |
| 686 | return bfi_image_ct2_get_chunk(off); |
| 687 | break; |
| 688 | default: |
| 689 | return NULL; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 690 | } |
| 691 | } |
| 692 | |
| 693 | static inline u32 |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 694 | bfa_cb_image_get_size(enum bfi_asic_gen asic_gen) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 695 | { |
Krishna Gudipati | 1118920 | 2011-06-13 15:50:35 -0700 | [diff] [blame] | 696 | switch (asic_gen) { |
| 697 | case BFI_ASIC_GEN_CB: |
| 698 | return bfi_image_cb_size; |
| 699 | break; |
| 700 | case BFI_ASIC_GEN_CT: |
| 701 | return bfi_image_ct_size; |
| 702 | break; |
| 703 | case BFI_ASIC_GEN_CT2: |
| 704 | return bfi_image_ct2_size; |
| 705 | break; |
| 706 | default: |
| 707 | return 0; |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 708 | } |
| 709 | } |
| 710 | |
Jing Huang | acdc79a | 2010-10-18 17:15:55 -0700 | [diff] [blame] | 711 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 712 | * CNA TRCMOD declaration |
| 713 | */ |
| 714 | /* |
| 715 | * !!! Only append to the enums defined here to avoid any versioning |
| 716 | * !!! needed between trace utility and driver version |
| 717 | */ |
| 718 | enum { |
| 719 | BFA_TRC_CNA_PORT = 1, |
| 720 | BFA_TRC_CNA_IOC = 2, |
| 721 | BFA_TRC_CNA_IOC_CB = 3, |
| 722 | BFA_TRC_CNA_IOC_CT = 4, |
| 723 | }; |
| 724 | |
| 725 | #endif /* __BFA_IOC_H__ */ |