Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
bfa_core.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
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 #include "bfad_drv.h"
19 #include "bfa_modules.h"
20 #include "bfi_reg.h"
21 
22 BFA_TRC_FILE(HAL, CORE);
23 
24 /*
25  * BFA module list terminated by NULL
26  */
27 static struct bfa_module_s *hal_mods[] = {
29  &hal_mod_sgpg,
31  &hal_mod_fcxp,
32  &hal_mod_lps,
33  &hal_mod_uf,
35  &hal_mod_fcp,
37  NULL
38 };
39 
40 /*
41  * Message handlers for various modules.
42  */
43 static bfa_isr_func_t bfa_isrs[BFI_MC_MAX] = {
44  bfa_isr_unhandled, /* NONE */
45  bfa_isr_unhandled, /* BFI_MC_IOC */
46  bfa_fcdiag_intr, /* BFI_MC_DIAG */
47  bfa_isr_unhandled, /* BFI_MC_FLASH */
48  bfa_isr_unhandled, /* BFI_MC_CEE */
49  bfa_fcport_isr, /* BFI_MC_FCPORT */
50  bfa_isr_unhandled, /* BFI_MC_IOCFC */
51  bfa_isr_unhandled, /* BFI_MC_LL */
52  bfa_uf_isr, /* BFI_MC_UF */
53  bfa_fcxp_isr, /* BFI_MC_FCXP */
54  bfa_lps_isr, /* BFI_MC_LPS */
55  bfa_rport_isr, /* BFI_MC_RPORT */
56  bfa_itn_isr, /* BFI_MC_ITN */
57  bfa_isr_unhandled, /* BFI_MC_IOIM_READ */
58  bfa_isr_unhandled, /* BFI_MC_IOIM_WRITE */
59  bfa_isr_unhandled, /* BFI_MC_IOIM_IO */
60  bfa_ioim_isr, /* BFI_MC_IOIM */
61  bfa_ioim_good_comp_isr, /* BFI_MC_IOIM_IOCOM */
62  bfa_tskim_isr, /* BFI_MC_TSKIM */
63  bfa_isr_unhandled, /* BFI_MC_SBOOT */
64  bfa_isr_unhandled, /* BFI_MC_IPFC */
65  bfa_isr_unhandled, /* BFI_MC_PORT */
66  bfa_isr_unhandled, /* --------- */
67  bfa_isr_unhandled, /* --------- */
68  bfa_isr_unhandled, /* --------- */
69  bfa_isr_unhandled, /* --------- */
70  bfa_isr_unhandled, /* --------- */
71  bfa_isr_unhandled, /* --------- */
72  bfa_isr_unhandled, /* --------- */
73  bfa_isr_unhandled, /* --------- */
74  bfa_isr_unhandled, /* --------- */
75  bfa_isr_unhandled, /* --------- */
76 };
77 /*
78  * Message handlers for mailbox command classes
79  */
80 static bfa_ioc_mbox_mcfunc_t bfa_mbox_isrs[BFI_MC_MAX] = {
81  NULL,
82  NULL, /* BFI_MC_IOC */
83  NULL, /* BFI_MC_DIAG */
84  NULL, /* BFI_MC_FLASH */
85  NULL, /* BFI_MC_CEE */
86  NULL, /* BFI_MC_PORT */
87  bfa_iocfc_isr, /* BFI_MC_IOCFC */
88  NULL,
89 };
90 
91 
92 
93 static void
94 bfa_com_port_attach(struct bfa_s *bfa)
95 {
96  struct bfa_port_s *port = &bfa->modules.port;
97  struct bfa_mem_dma_s *port_dma = BFA_MEM_PORT_DMA(bfa);
98 
99  bfa_port_attach(port, &bfa->ioc, bfa, bfa->trcmod);
100  bfa_port_mem_claim(port, port_dma->kva_curp, port_dma->dma_curp);
101 }
102 
103 /*
104  * ablk module attach
105  */
106 static void
107 bfa_com_ablk_attach(struct bfa_s *bfa)
108 {
109  struct bfa_ablk_s *ablk = &bfa->modules.ablk;
110  struct bfa_mem_dma_s *ablk_dma = BFA_MEM_ABLK_DMA(bfa);
111 
112  bfa_ablk_attach(ablk, &bfa->ioc);
113  bfa_ablk_memclaim(ablk, ablk_dma->kva_curp, ablk_dma->dma_curp);
114 }
115 
116 static void
117 bfa_com_cee_attach(struct bfa_s *bfa)
118 {
119  struct bfa_cee_s *cee = &bfa->modules.cee;
120  struct bfa_mem_dma_s *cee_dma = BFA_MEM_CEE_DMA(bfa);
121 
122  cee->trcmod = bfa->trcmod;
123  bfa_cee_attach(cee, &bfa->ioc, bfa);
124  bfa_cee_mem_claim(cee, cee_dma->kva_curp, cee_dma->dma_curp);
125 }
126 
127 static void
128 bfa_com_sfp_attach(struct bfa_s *bfa)
129 {
130  struct bfa_sfp_s *sfp = BFA_SFP_MOD(bfa);
131  struct bfa_mem_dma_s *sfp_dma = BFA_MEM_SFP_DMA(bfa);
132 
133  bfa_sfp_attach(sfp, &bfa->ioc, bfa, bfa->trcmod);
134  bfa_sfp_memclaim(sfp, sfp_dma->kva_curp, sfp_dma->dma_curp);
135 }
136 
137 static void
138 bfa_com_flash_attach(struct bfa_s *bfa, bfa_boolean_t mincfg)
139 {
140  struct bfa_flash_s *flash = BFA_FLASH(bfa);
141  struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa);
142 
143  bfa_flash_attach(flash, &bfa->ioc, bfa, bfa->trcmod, mincfg);
144  bfa_flash_memclaim(flash, flash_dma->kva_curp,
145  flash_dma->dma_curp, mincfg);
146 }
147 
148 static void
149 bfa_com_diag_attach(struct bfa_s *bfa)
150 {
151  struct bfa_diag_s *diag = BFA_DIAG_MOD(bfa);
152  struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa);
153 
154  bfa_diag_attach(diag, &bfa->ioc, bfa, bfa_fcport_beacon, bfa->trcmod);
155  bfa_diag_memclaim(diag, diag_dma->kva_curp, diag_dma->dma_curp);
156 }
157 
158 static void
159 bfa_com_phy_attach(struct bfa_s *bfa, bfa_boolean_t mincfg)
160 {
161  struct bfa_phy_s *phy = BFA_PHY(bfa);
162  struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa);
163 
164  bfa_phy_attach(phy, &bfa->ioc, bfa, bfa->trcmod, mincfg);
165  bfa_phy_memclaim(phy, phy_dma->kva_curp, phy_dma->dma_curp, mincfg);
166 }
167 
168 static void
169 bfa_com_fru_attach(struct bfa_s *bfa, bfa_boolean_t mincfg)
170 {
171  struct bfa_fru_s *fru = BFA_FRU(bfa);
172  struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa);
173 
174  bfa_fru_attach(fru, &bfa->ioc, bfa, bfa->trcmod, mincfg);
175  bfa_fru_memclaim(fru, fru_dma->kva_curp, fru_dma->dma_curp, mincfg);
176 }
177 
178 /*
179  * BFA IOC FC related definitions
180  */
181 
182 /*
183  * IOC local definitions
184  */
185 #define BFA_IOCFC_TOV 5000 /* msecs */
186 
187 enum {
193 };
194 
195 #define DEF_CFG_NUM_FABRICS 1
196 #define DEF_CFG_NUM_LPORTS 256
197 #define DEF_CFG_NUM_CQS 4
198 #define DEF_CFG_NUM_IOIM_REQS (BFA_IOIM_MAX)
199 #define DEF_CFG_NUM_TSKIM_REQS 128
200 #define DEF_CFG_NUM_FCXP_REQS 64
201 #define DEF_CFG_NUM_UF_BUFS 64
202 #define DEF_CFG_NUM_RPORTS 1024
203 #define DEF_CFG_NUM_ITNIMS (DEF_CFG_NUM_RPORTS)
204 #define DEF_CFG_NUM_TINS 256
205 
206 #define DEF_CFG_NUM_SGPGS 2048
207 #define DEF_CFG_NUM_REQQ_ELEMS 256
208 #define DEF_CFG_NUM_RSPQ_ELEMS 64
209 #define DEF_CFG_NUM_SBOOT_TGTS 16
210 #define DEF_CFG_NUM_SBOOT_LUNS 16
211 
212 /*
213  * IOCFC state machine definitions/declarations
214  */
215 bfa_fsm_state_decl(bfa_iocfc, stopped, struct bfa_iocfc_s, enum iocfc_event);
216 bfa_fsm_state_decl(bfa_iocfc, initing, struct bfa_iocfc_s, enum iocfc_event);
217 bfa_fsm_state_decl(bfa_iocfc, dconf_read, struct bfa_iocfc_s, enum iocfc_event);
218 bfa_fsm_state_decl(bfa_iocfc, init_cfg_wait,
219  struct bfa_iocfc_s, enum iocfc_event);
220 bfa_fsm_state_decl(bfa_iocfc, init_cfg_done,
221  struct bfa_iocfc_s, enum iocfc_event);
222 bfa_fsm_state_decl(bfa_iocfc, operational,
223  struct bfa_iocfc_s, enum iocfc_event);
224 bfa_fsm_state_decl(bfa_iocfc, dconf_write,
225  struct bfa_iocfc_s, enum iocfc_event);
226 bfa_fsm_state_decl(bfa_iocfc, stopping, struct bfa_iocfc_s, enum iocfc_event);
227 bfa_fsm_state_decl(bfa_iocfc, enabling, struct bfa_iocfc_s, enum iocfc_event);
228 bfa_fsm_state_decl(bfa_iocfc, cfg_wait, struct bfa_iocfc_s, enum iocfc_event);
229 bfa_fsm_state_decl(bfa_iocfc, disabling, struct bfa_iocfc_s, enum iocfc_event);
230 bfa_fsm_state_decl(bfa_iocfc, disabled, struct bfa_iocfc_s, enum iocfc_event);
231 bfa_fsm_state_decl(bfa_iocfc, failed, struct bfa_iocfc_s, enum iocfc_event);
232 bfa_fsm_state_decl(bfa_iocfc, init_failed,
233  struct bfa_iocfc_s, enum iocfc_event);
234 
235 /*
236  * forward declaration for IOC FC functions
237  */
238 static void bfa_iocfc_start_submod(struct bfa_s *bfa);
239 static void bfa_iocfc_disable_submod(struct bfa_s *bfa);
240 static void bfa_iocfc_send_cfg(void *bfa_arg);
241 static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status);
242 static void bfa_iocfc_disable_cbfn(void *bfa_arg);
243 static void bfa_iocfc_hbfail_cbfn(void *bfa_arg);
244 static void bfa_iocfc_reset_cbfn(void *bfa_arg);
245 static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn;
246 static void bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete);
247 static void bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl);
248 static void bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl);
249 static void bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl);
250 
251 static void
252 bfa_iocfc_sm_stopped_entry(struct bfa_iocfc_s *iocfc)
253 {
254 }
255 
256 static void
257 bfa_iocfc_sm_stopped(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
258 {
259  bfa_trc(iocfc->bfa, event);
260 
261  switch (event) {
262  case IOCFC_E_INIT:
263  case IOCFC_E_ENABLE:
264  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_initing);
265  break;
266  default:
267  bfa_sm_fault(iocfc->bfa, event);
268  break;
269  }
270 }
271 
272 static void
273 bfa_iocfc_sm_initing_entry(struct bfa_iocfc_s *iocfc)
274 {
275  bfa_ioc_enable(&iocfc->bfa->ioc);
276 }
277 
278 static void
279 bfa_iocfc_sm_initing(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
280 {
281  bfa_trc(iocfc->bfa, event);
282 
283  switch (event) {
284  case IOCFC_E_IOC_ENABLED:
285  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
286  break;
287 
288  case IOCFC_E_DISABLE:
289  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
290  break;
291 
292  case IOCFC_E_STOP:
293  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
294  break;
295 
296  case IOCFC_E_IOC_FAILED:
297  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
298  break;
299  default:
300  bfa_sm_fault(iocfc->bfa, event);
301  break;
302  }
303 }
304 
305 static void
306 bfa_iocfc_sm_dconf_read_entry(struct bfa_iocfc_s *iocfc)
307 {
308  bfa_dconf_modinit(iocfc->bfa);
309 }
310 
311 static void
312 bfa_iocfc_sm_dconf_read(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
313 {
314  bfa_trc(iocfc->bfa, event);
315 
316  switch (event) {
317  case IOCFC_E_DCONF_DONE:
318  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_wait);
319  break;
320 
321  case IOCFC_E_DISABLE:
322  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
323  break;
324 
325  case IOCFC_E_STOP:
326  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
327  break;
328 
329  case IOCFC_E_IOC_FAILED:
330  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
331  break;
332  default:
333  bfa_sm_fault(iocfc->bfa, event);
334  break;
335  }
336 }
337 
338 static void
339 bfa_iocfc_sm_init_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
340 {
341  bfa_iocfc_send_cfg(iocfc->bfa);
342 }
343 
344 static void
345 bfa_iocfc_sm_init_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
346 {
347  bfa_trc(iocfc->bfa, event);
348 
349  switch (event) {
350  case IOCFC_E_CFG_DONE:
351  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_done);
352  break;
353 
354  case IOCFC_E_DISABLE:
355  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
356  break;
357 
358  case IOCFC_E_STOP:
359  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
360  break;
361 
362  case IOCFC_E_IOC_FAILED:
363  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
364  break;
365  default:
366  bfa_sm_fault(iocfc->bfa, event);
367  break;
368  }
369 }
370 
371 static void
372 bfa_iocfc_sm_init_cfg_done_entry(struct bfa_iocfc_s *iocfc)
373 {
374  iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
375  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
376  bfa_iocfc_init_cb, iocfc->bfa);
377 }
378 
379 static void
380 bfa_iocfc_sm_init_cfg_done(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
381 {
382  bfa_trc(iocfc->bfa, event);
383 
384  switch (event) {
385  case IOCFC_E_START:
386  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
387  break;
388  case IOCFC_E_STOP:
389  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
390  break;
391  case IOCFC_E_DISABLE:
392  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
393  break;
394  case IOCFC_E_IOC_FAILED:
395  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
396  break;
397  default:
398  bfa_sm_fault(iocfc->bfa, event);
399  break;
400  }
401 }
402 
403 static void
404 bfa_iocfc_sm_operational_entry(struct bfa_iocfc_s *iocfc)
405 {
406  bfa_fcport_init(iocfc->bfa);
407  bfa_iocfc_start_submod(iocfc->bfa);
408 }
409 
410 static void
411 bfa_iocfc_sm_operational(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
412 {
413  bfa_trc(iocfc->bfa, event);
414 
415  switch (event) {
416  case IOCFC_E_STOP:
417  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
418  break;
419  case IOCFC_E_DISABLE:
420  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
421  break;
422  case IOCFC_E_IOC_FAILED:
423  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
424  break;
425  default:
426  bfa_sm_fault(iocfc->bfa, event);
427  break;
428  }
429 }
430 
431 static void
432 bfa_iocfc_sm_dconf_write_entry(struct bfa_iocfc_s *iocfc)
433 {
434  bfa_dconf_modexit(iocfc->bfa);
435 }
436 
437 static void
438 bfa_iocfc_sm_dconf_write(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
439 {
440  bfa_trc(iocfc->bfa, event);
441 
442  switch (event) {
443  case IOCFC_E_DCONF_DONE:
444  case IOCFC_E_IOC_FAILED:
445  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
446  break;
447  default:
448  bfa_sm_fault(iocfc->bfa, event);
449  break;
450  }
451 }
452 
453 static void
454 bfa_iocfc_sm_stopping_entry(struct bfa_iocfc_s *iocfc)
455 {
456  bfa_ioc_disable(&iocfc->bfa->ioc);
457 }
458 
459 static void
460 bfa_iocfc_sm_stopping(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
461 {
462  bfa_trc(iocfc->bfa, event);
463 
464  switch (event) {
466  bfa_isr_disable(iocfc->bfa);
467  bfa_iocfc_disable_submod(iocfc->bfa);
468  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
469  iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
470  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.stop_hcb_qe,
471  bfa_iocfc_stop_cb, iocfc->bfa);
472  break;
473 
474  case IOCFC_E_IOC_ENABLED:
475  case IOCFC_E_DCONF_DONE:
476  case IOCFC_E_CFG_DONE:
477  break;
478 
479  default:
480  bfa_sm_fault(iocfc->bfa, event);
481  break;
482  }
483 }
484 
485 static void
486 bfa_iocfc_sm_enabling_entry(struct bfa_iocfc_s *iocfc)
487 {
488  bfa_ioc_enable(&iocfc->bfa->ioc);
489 }
490 
491 static void
492 bfa_iocfc_sm_enabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
493 {
494  bfa_trc(iocfc->bfa, event);
495 
496  switch (event) {
497  case IOCFC_E_IOC_ENABLED:
498  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
499  break;
500 
501  case IOCFC_E_DISABLE:
502  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
503  break;
504 
505  case IOCFC_E_STOP:
506  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
507  break;
508 
509  case IOCFC_E_IOC_FAILED:
510  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
511 
512  if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
513  break;
514 
515  iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
516  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
517  bfa_iocfc_enable_cb, iocfc->bfa);
518  iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
519  break;
520  default:
521  bfa_sm_fault(iocfc->bfa, event);
522  break;
523  }
524 }
525 
526 static void
527 bfa_iocfc_sm_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
528 {
529  bfa_iocfc_send_cfg(iocfc->bfa);
530 }
531 
532 static void
533 bfa_iocfc_sm_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
534 {
535  bfa_trc(iocfc->bfa, event);
536 
537  switch (event) {
538  case IOCFC_E_CFG_DONE:
539  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
540  if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
541  break;
542 
543  iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
544  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
545  bfa_iocfc_enable_cb, iocfc->bfa);
546  iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
547  break;
548  case IOCFC_E_DISABLE:
549  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
550  break;
551 
552  case IOCFC_E_STOP:
553  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
554  break;
555  case IOCFC_E_IOC_FAILED:
556  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
557  if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
558  break;
559 
560  iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
561  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
562  bfa_iocfc_enable_cb, iocfc->bfa);
563  iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
564  break;
565  default:
566  bfa_sm_fault(iocfc->bfa, event);
567  break;
568  }
569 }
570 
571 static void
572 bfa_iocfc_sm_disabling_entry(struct bfa_iocfc_s *iocfc)
573 {
574  bfa_ioc_disable(&iocfc->bfa->ioc);
575 }
576 
577 static void
578 bfa_iocfc_sm_disabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
579 {
580  bfa_trc(iocfc->bfa, event);
581 
582  switch (event) {
584  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabled);
585  break;
586  case IOCFC_E_IOC_ENABLED:
587  case IOCFC_E_DCONF_DONE:
588  case IOCFC_E_CFG_DONE:
589  break;
590  default:
591  bfa_sm_fault(iocfc->bfa, event);
592  break;
593  }
594 }
595 
596 static void
597 bfa_iocfc_sm_disabled_entry(struct bfa_iocfc_s *iocfc)
598 {
599  bfa_isr_disable(iocfc->bfa);
600  bfa_iocfc_disable_submod(iocfc->bfa);
601  iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
602  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
603  bfa_iocfc_disable_cb, iocfc->bfa);
604 }
605 
606 static void
607 bfa_iocfc_sm_disabled(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
608 {
609  bfa_trc(iocfc->bfa, event);
610 
611  switch (event) {
612  case IOCFC_E_STOP:
613  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
614  break;
615  case IOCFC_E_ENABLE:
616  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_enabling);
617  break;
618  default:
619  bfa_sm_fault(iocfc->bfa, event);
620  break;
621  }
622 }
623 
624 static void
625 bfa_iocfc_sm_failed_entry(struct bfa_iocfc_s *iocfc)
626 {
627  bfa_isr_disable(iocfc->bfa);
628  bfa_iocfc_disable_submod(iocfc->bfa);
629 }
630 
631 static void
632 bfa_iocfc_sm_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
633 {
634  bfa_trc(iocfc->bfa, event);
635 
636  switch (event) {
637  case IOCFC_E_STOP:
638  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
639  break;
640  case IOCFC_E_DISABLE:
641  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
642  break;
643  case IOCFC_E_IOC_ENABLED:
644  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
645  break;
646  case IOCFC_E_IOC_FAILED:
647  break;
648  default:
649  bfa_sm_fault(iocfc->bfa, event);
650  break;
651  }
652 }
653 
654 static void
655 bfa_iocfc_sm_init_failed_entry(struct bfa_iocfc_s *iocfc)
656 {
657  bfa_isr_disable(iocfc->bfa);
658  iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
659  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
660  bfa_iocfc_init_cb, iocfc->bfa);
661 }
662 
663 static void
664 bfa_iocfc_sm_init_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
665 {
666  bfa_trc(iocfc->bfa, event);
667 
668  switch (event) {
669  case IOCFC_E_STOP:
670  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
671  break;
672  case IOCFC_E_DISABLE:
673  bfa_ioc_disable(&iocfc->bfa->ioc);
674  break;
675  case IOCFC_E_IOC_ENABLED:
676  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
677  break;
679  bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
680  iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
681  bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
682  bfa_iocfc_disable_cb, iocfc->bfa);
683  break;
684  case IOCFC_E_IOC_FAILED:
685  break;
686  default:
687  bfa_sm_fault(iocfc->bfa, event);
688  break;
689  }
690 }
691 
692 /*
693  * BFA Interrupt handling functions
694  */
695 static void
696 bfa_reqq_resume(struct bfa_s *bfa, int qid)
697 {
698  struct list_head *waitq, *qe, *qen;
699  struct bfa_reqq_wait_s *wqe;
700 
701  waitq = bfa_reqq(bfa, qid);
702  list_for_each_safe(qe, qen, waitq) {
703  /*
704  * Callback only as long as there is room in request queue
705  */
706  if (bfa_reqq_full(bfa, qid))
707  break;
708 
709  list_del(qe);
710  wqe = (struct bfa_reqq_wait_s *) qe;
711  wqe->qresume(wqe->cbarg);
712  }
713 }
714 
716 bfa_isr_rspq(struct bfa_s *bfa, int qid)
717 {
718  struct bfi_msg_s *m;
719  u32 pi, ci;
720  struct list_head *waitq;
722 
723  ci = bfa_rspq_ci(bfa, qid);
724  pi = bfa_rspq_pi(bfa, qid);
725 
726  ret = (ci != pi);
727 
728  while (ci != pi) {
729  m = bfa_rspq_elem(bfa, qid, ci);
730  WARN_ON(m->mhdr.msg_class >= BFI_MC_MAX);
731 
732  bfa_isrs[m->mhdr.msg_class] (bfa, m);
733  CQ_INCR(ci, bfa->iocfc.cfg.drvcfg.num_rspq_elems);
734  }
735 
736  /*
737  * acknowledge RME completions and update CI
738  */
739  bfa_isr_rspq_ack(bfa, qid, ci);
740 
741  /*
742  * Resume any pending requests in the corresponding reqq.
743  */
744  waitq = bfa_reqq(bfa, qid);
745  if (!list_empty(waitq))
746  bfa_reqq_resume(bfa, qid);
747 
748  return ret;
749 }
750 
751 static inline void
752 bfa_isr_reqq(struct bfa_s *bfa, int qid)
753 {
754  struct list_head *waitq;
755 
756  bfa_isr_reqq_ack(bfa, qid);
757 
758  /*
759  * Resume any pending requests in the corresponding reqq.
760  */
761  waitq = bfa_reqq(bfa, qid);
762  if (!list_empty(waitq))
763  bfa_reqq_resume(bfa, qid);
764 }
765 
766 void
767 bfa_msix_all(struct bfa_s *bfa, int vec)
768 {
769  u32 intr, qintr;
770  int queue;
771 
772  intr = readl(bfa->iocfc.bfa_regs.intr_status);
773  if (!intr)
774  return;
775 
776  /*
777  * RME completion queue interrupt
778  */
779  qintr = intr & __HFN_INT_RME_MASK;
780  if (qintr && bfa->queue_process) {
781  for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
782  bfa_isr_rspq(bfa, queue);
783  }
784 
785  intr &= ~qintr;
786  if (!intr)
787  return;
788 
789  /*
790  * CPE completion queue interrupt
791  */
792  qintr = intr & __HFN_INT_CPE_MASK;
793  if (qintr && bfa->queue_process) {
794  for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
795  bfa_isr_reqq(bfa, queue);
796  }
797  intr &= ~qintr;
798  if (!intr)
799  return;
800 
801  bfa_msix_lpu_err(bfa, intr);
802 }
803 
805 bfa_intx(struct bfa_s *bfa)
806 {
807  u32 intr, qintr;
808  int queue;
809  bfa_boolean_t rspq_comp = BFA_FALSE;
810 
811  intr = readl(bfa->iocfc.bfa_regs.intr_status);
812 
813  qintr = intr & (__HFN_INT_RME_MASK | __HFN_INT_CPE_MASK);
814  if (qintr)
815  writel(qintr, bfa->iocfc.bfa_regs.intr_status);
816 
817  /*
818  * Unconditional RME completion queue interrupt
819  */
820  if (bfa->queue_process) {
821  for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
822  if (bfa_isr_rspq(bfa, queue))
823  rspq_comp = BFA_TRUE;
824  }
825 
826  if (!intr)
827  return (qintr | rspq_comp) ? BFA_TRUE : BFA_FALSE;
828 
829  /*
830  * CPE completion queue interrupt
831  */
832  qintr = intr & __HFN_INT_CPE_MASK;
833  if (qintr && bfa->queue_process) {
834  for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
835  bfa_isr_reqq(bfa, queue);
836  }
837  intr &= ~qintr;
838  if (!intr)
839  return BFA_TRUE;
840 
841  if (bfa->intr_enabled)
842  bfa_msix_lpu_err(bfa, intr);
843 
844  return BFA_TRUE;
845 }
846 
847 void
848 bfa_isr_enable(struct bfa_s *bfa)
849 {
850  u32 umsk;
851  int port_id = bfa_ioc_portid(&bfa->ioc);
852 
853  bfa_trc(bfa, bfa_ioc_pcifn(&bfa->ioc));
854  bfa_trc(bfa, port_id);
855 
857 
858  if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) {
859  umsk = __HFN_INT_ERR_MASK_CT2;
860  umsk |= port_id == 0 ?
862  } else {
863  umsk = __HFN_INT_ERR_MASK;
864  umsk |= port_id == 0 ? __HFN_INT_FN0_MASK : __HFN_INT_FN1_MASK;
865  }
866 
867  writel(umsk, bfa->iocfc.bfa_regs.intr_status);
868  writel(~umsk, bfa->iocfc.bfa_regs.intr_mask);
869  bfa->iocfc.intr_mask = ~umsk;
870  bfa_isr_mode_set(bfa, bfa->msix.nvecs != 0);
871 
872  /*
873  * Set the flag indicating successful enabling of interrupts
874  */
875  bfa->intr_enabled = BFA_TRUE;
876 }
877 
878 void
879 bfa_isr_disable(struct bfa_s *bfa)
880 {
881  bfa->intr_enabled = BFA_FALSE;
883  writel(-1L, bfa->iocfc.bfa_regs.intr_mask);
884  bfa_msix_uninstall(bfa);
885 }
886 
887 void
888 bfa_msix_reqq(struct bfa_s *bfa, int vec)
889 {
890  bfa_isr_reqq(bfa, vec - bfa->iocfc.hwif.cpe_vec_q0);
891 }
892 
893 void
894 bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m)
895 {
896  bfa_trc(bfa, m->mhdr.msg_class);
897  bfa_trc(bfa, m->mhdr.msg_id);
898  bfa_trc(bfa, m->mhdr.mtag.i2htok);
899  WARN_ON(1);
900  bfa_trc_stop(bfa->trcmod);
901 }
902 
903 void
904 bfa_msix_rspq(struct bfa_s *bfa, int vec)
905 {
906  bfa_isr_rspq(bfa, vec - bfa->iocfc.hwif.rme_vec_q0);
907 }
908 
909 void
910 bfa_msix_lpu_err(struct bfa_s *bfa, int vec)
911 {
912  u32 intr, curr_value;
913  bfa_boolean_t lpu_isr, halt_isr, pss_isr;
914 
915  intr = readl(bfa->iocfc.bfa_regs.intr_status);
916 
917  if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) {
918  halt_isr = intr & __HFN_INT_CPQ_HALT_CT2;
919  pss_isr = intr & __HFN_INT_ERR_PSS_CT2;
920  lpu_isr = intr & (__HFN_INT_MBOX_LPU0_CT2 |
922  intr &= __HFN_INT_ERR_MASK_CT2;
923  } else {
924  halt_isr = bfa_asic_id_ct(bfa->ioc.pcidev.device_id) ?
925  (intr & __HFN_INT_LL_HALT) : 0;
926  pss_isr = intr & __HFN_INT_ERR_PSS;
927  lpu_isr = intr & (__HFN_INT_MBOX_LPU0 | __HFN_INT_MBOX_LPU1);
928  intr &= __HFN_INT_ERR_MASK;
929  }
930 
931  if (lpu_isr)
932  bfa_ioc_mbox_isr(&bfa->ioc);
933 
934  if (intr) {
935  if (halt_isr) {
936  /*
937  * If LL_HALT bit is set then FW Init Halt LL Port
938  * Register needs to be cleared as well so Interrupt
939  * Status Register will be cleared.
940  */
941  curr_value = readl(bfa->ioc.ioc_regs.ll_halt);
942  curr_value &= ~__FW_INIT_HALT_P;
943  writel(curr_value, bfa->ioc.ioc_regs.ll_halt);
944  }
945 
946  if (pss_isr) {
947  /*
948  * ERR_PSS bit needs to be cleared as well in case
949  * interrups are shared so driver's interrupt handler is
950  * still called even though it is already masked out.
951  */
952  curr_value = readl(
953  bfa->ioc.ioc_regs.pss_err_status_reg);
954  writel(curr_value,
955  bfa->ioc.ioc_regs.pss_err_status_reg);
956  }
957 
958  writel(intr, bfa->iocfc.bfa_regs.intr_status);
959  bfa_ioc_error_isr(&bfa->ioc);
960  }
961 }
962 
963 /*
964  * BFA IOC FC related functions
965  */
966 
967 /*
968  * BFA IOC private functions
969  */
970 
971 /*
972  * Use the Mailbox interface to send BFI_IOCFC_H2I_CFG_REQ
973  */
974 static void
975 bfa_iocfc_send_cfg(void *bfa_arg)
976 {
977  struct bfa_s *bfa = bfa_arg;
978  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
979  struct bfi_iocfc_cfg_req_s cfg_req;
980  struct bfi_iocfc_cfg_s *cfg_info = iocfc->cfginfo;
981  struct bfa_iocfc_cfg_s *cfg = &iocfc->cfg;
982  int i;
983 
984  WARN_ON(cfg->fwcfg.num_cqs > BFI_IOC_MAX_CQS);
985  bfa_trc(bfa, cfg->fwcfg.num_cqs);
986 
988 
989  /*
990  * initialize IOC configuration info
991  */
992  cfg_info->single_msix_vec = 0;
993  if (bfa->msix.nvecs == 1)
994  cfg_info->single_msix_vec = 1;
995  cfg_info->endian_sig = BFI_IOC_ENDIAN_SIG;
996  cfg_info->num_cqs = cfg->fwcfg.num_cqs;
998  cfg->fwcfg.num_ioim_reqs));
999  cfg_info->num_fwtio_reqs = cpu_to_be16(cfg->fwcfg.num_fwtio_reqs);
1000 
1001  bfa_dma_be_addr_set(cfg_info->cfgrsp_addr, iocfc->cfgrsp_dma.pa);
1002  /*
1003  * dma map REQ and RSP circular queues and shadow pointers
1004  */
1005  for (i = 0; i < cfg->fwcfg.num_cqs; i++) {
1006  bfa_dma_be_addr_set(cfg_info->req_cq_ba[i],
1007  iocfc->req_cq_ba[i].pa);
1008  bfa_dma_be_addr_set(cfg_info->req_shadow_ci[i],
1009  iocfc->req_cq_shadow_ci[i].pa);
1010  cfg_info->req_cq_elems[i] =
1011  cpu_to_be16(cfg->drvcfg.num_reqq_elems);
1012 
1013  bfa_dma_be_addr_set(cfg_info->rsp_cq_ba[i],
1014  iocfc->rsp_cq_ba[i].pa);
1015  bfa_dma_be_addr_set(cfg_info->rsp_shadow_pi[i],
1016  iocfc->rsp_cq_shadow_pi[i].pa);
1017  cfg_info->rsp_cq_elems[i] =
1018  cpu_to_be16(cfg->drvcfg.num_rspq_elems);
1019  }
1020 
1021  /*
1022  * Enable interrupt coalescing if it is driver init path
1023  * and not ioc disable/enable path.
1024  */
1025  if (bfa_fsm_cmp_state(iocfc, bfa_iocfc_sm_init_cfg_wait))
1026  cfg_info->intr_attr.coalesce = BFA_TRUE;
1027 
1028  /*
1029  * dma map IOC configuration itself
1030  */
1032  bfa_fn_lpu(bfa));
1033  bfa_dma_be_addr_set(cfg_req.ioc_cfg_dma_addr, iocfc->cfg_info.pa);
1034 
1035  bfa_ioc_mbox_send(&bfa->ioc, &cfg_req,
1036  sizeof(struct bfi_iocfc_cfg_req_s));
1037 }
1038 
1039 static void
1040 bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1041  struct bfa_pcidev_s *pcidev)
1042 {
1043  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1044 
1045  bfa->bfad = bfad;
1046  iocfc->bfa = bfa;
1047  iocfc->cfg = *cfg;
1048 
1049  /*
1050  * Initialize chip specific handlers.
1051  */
1052  if (bfa_asic_id_ctc(bfa_ioc_devid(&bfa->ioc))) {
1053  iocfc->hwif.hw_reginit = bfa_hwct_reginit;
1054  iocfc->hwif.hw_reqq_ack = bfa_hwct_reqq_ack;
1055  iocfc->hwif.hw_rspq_ack = bfa_hwct_rspq_ack;
1056  iocfc->hwif.hw_msix_init = bfa_hwct_msix_init;
1057  iocfc->hwif.hw_msix_ctrl_install = bfa_hwct_msix_ctrl_install;
1058  iocfc->hwif.hw_msix_queue_install = bfa_hwct_msix_queue_install;
1059  iocfc->hwif.hw_msix_uninstall = bfa_hwct_msix_uninstall;
1060  iocfc->hwif.hw_isr_mode_set = bfa_hwct_isr_mode_set;
1061  iocfc->hwif.hw_msix_getvecs = bfa_hwct_msix_getvecs;
1062  iocfc->hwif.hw_msix_get_rme_range = bfa_hwct_msix_get_rme_range;
1063  iocfc->hwif.rme_vec_q0 = BFI_MSIX_RME_QMIN_CT;
1064  iocfc->hwif.cpe_vec_q0 = BFI_MSIX_CPE_QMIN_CT;
1065  } else {
1066  iocfc->hwif.hw_reginit = bfa_hwcb_reginit;
1067  iocfc->hwif.hw_reqq_ack = NULL;
1068  iocfc->hwif.hw_rspq_ack = bfa_hwcb_rspq_ack;
1069  iocfc->hwif.hw_msix_init = bfa_hwcb_msix_init;
1070  iocfc->hwif.hw_msix_ctrl_install = bfa_hwcb_msix_ctrl_install;
1071  iocfc->hwif.hw_msix_queue_install = bfa_hwcb_msix_queue_install;
1072  iocfc->hwif.hw_msix_uninstall = bfa_hwcb_msix_uninstall;
1073  iocfc->hwif.hw_isr_mode_set = bfa_hwcb_isr_mode_set;
1074  iocfc->hwif.hw_msix_getvecs = bfa_hwcb_msix_getvecs;
1075  iocfc->hwif.hw_msix_get_rme_range = bfa_hwcb_msix_get_rme_range;
1076  iocfc->hwif.rme_vec_q0 = BFI_MSIX_RME_QMIN_CB +
1078  iocfc->hwif.cpe_vec_q0 = BFI_MSIX_CPE_QMIN_CB +
1080  }
1081 
1082  if (bfa_asic_id_ct2(bfa_ioc_devid(&bfa->ioc))) {
1083  iocfc->hwif.hw_reginit = bfa_hwct2_reginit;
1084  iocfc->hwif.hw_isr_mode_set = NULL;
1085  iocfc->hwif.hw_rspq_ack = bfa_hwct2_rspq_ack;
1086  }
1087 
1088  iocfc->hwif.hw_reginit(bfa);
1089  bfa->msix.nvecs = 0;
1090 }
1091 
1092 static void
1093 bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg)
1094 {
1095  u8 *dm_kva = NULL;
1096  u64 dm_pa = 0;
1097  int i, per_reqq_sz, per_rspq_sz;
1098  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1099  struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa);
1100  struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa);
1101  struct bfa_mem_dma_s *reqq_dma, *rspq_dma;
1102 
1103  /* First allocate dma memory for IOC */
1104  bfa_ioc_mem_claim(&bfa->ioc, bfa_mem_dma_virt(ioc_dma),
1105  bfa_mem_dma_phys(ioc_dma));
1106 
1107  /* Claim DMA-able memory for the request/response queues */
1108  per_reqq_sz = BFA_ROUNDUP((cfg->drvcfg.num_reqq_elems * BFI_LMSG_SZ),
1110  per_rspq_sz = BFA_ROUNDUP((cfg->drvcfg.num_rspq_elems * BFI_LMSG_SZ),
1112 
1113  for (i = 0; i < cfg->fwcfg.num_cqs; i++) {
1114  reqq_dma = BFA_MEM_REQQ_DMA(bfa, i);
1115  iocfc->req_cq_ba[i].kva = bfa_mem_dma_virt(reqq_dma);
1116  iocfc->req_cq_ba[i].pa = bfa_mem_dma_phys(reqq_dma);
1117  memset(iocfc->req_cq_ba[i].kva, 0, per_reqq_sz);
1118 
1119  rspq_dma = BFA_MEM_RSPQ_DMA(bfa, i);
1120  iocfc->rsp_cq_ba[i].kva = bfa_mem_dma_virt(rspq_dma);
1121  iocfc->rsp_cq_ba[i].pa = bfa_mem_dma_phys(rspq_dma);
1122  memset(iocfc->rsp_cq_ba[i].kva, 0, per_rspq_sz);
1123  }
1124 
1125  /* Claim IOCFC dma memory - for shadow CI/PI */
1126  dm_kva = bfa_mem_dma_virt(iocfc_dma);
1127  dm_pa = bfa_mem_dma_phys(iocfc_dma);
1128 
1129  for (i = 0; i < cfg->fwcfg.num_cqs; i++) {
1130  iocfc->req_cq_shadow_ci[i].kva = dm_kva;
1131  iocfc->req_cq_shadow_ci[i].pa = dm_pa;
1132  dm_kva += BFA_CACHELINE_SZ;
1133  dm_pa += BFA_CACHELINE_SZ;
1134 
1135  iocfc->rsp_cq_shadow_pi[i].kva = dm_kva;
1136  iocfc->rsp_cq_shadow_pi[i].pa = dm_pa;
1137  dm_kva += BFA_CACHELINE_SZ;
1138  dm_pa += BFA_CACHELINE_SZ;
1139  }
1140 
1141  /* Claim IOCFC dma memory - for the config info page */
1142  bfa->iocfc.cfg_info.kva = dm_kva;
1143  bfa->iocfc.cfg_info.pa = dm_pa;
1144  bfa->iocfc.cfginfo = (struct bfi_iocfc_cfg_s *) dm_kva;
1145  dm_kva += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ);
1146  dm_pa += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ);
1147 
1148  /* Claim IOCFC dma memory - for the config response */
1149  bfa->iocfc.cfgrsp_dma.kva = dm_kva;
1150  bfa->iocfc.cfgrsp_dma.pa = dm_pa;
1151  bfa->iocfc.cfgrsp = (struct bfi_iocfc_cfgrsp_s *) dm_kva;
1152  dm_kva += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s),
1154  dm_pa += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s),
1156 
1157  /* Claim IOCFC kva memory */
1160 }
1161 
1162 /*
1163  * Start BFA submodules.
1164  */
1165 static void
1166 bfa_iocfc_start_submod(struct bfa_s *bfa)
1167 {
1168  int i;
1169 
1170  bfa->queue_process = BFA_TRUE;
1171  for (i = 0; i < BFI_IOC_MAX_CQS; i++)
1172  bfa_isr_rspq_ack(bfa, i, bfa_rspq_ci(bfa, i));
1173 
1174  for (i = 0; hal_mods[i]; i++)
1175  hal_mods[i]->start(bfa);
1176 
1177  bfa->iocfc.submod_enabled = BFA_TRUE;
1178 }
1179 
1180 /*
1181  * Disable BFA submodules.
1182  */
1183 static void
1184 bfa_iocfc_disable_submod(struct bfa_s *bfa)
1185 {
1186  int i;
1187 
1188  if (bfa->iocfc.submod_enabled == BFA_FALSE)
1189  return;
1190 
1191  for (i = 0; hal_mods[i]; i++)
1192  hal_mods[i]->iocdisable(bfa);
1193 
1194  bfa->iocfc.submod_enabled = BFA_FALSE;
1195 }
1196 
1197 static void
1198 bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete)
1199 {
1200  struct bfa_s *bfa = bfa_arg;
1201 
1202  if (complete)
1203  bfa_cb_init(bfa->bfad, bfa->iocfc.op_status);
1204 }
1205 
1206 static void
1207 bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl)
1208 {
1209  struct bfa_s *bfa = bfa_arg;
1210  struct bfad_s *bfad = bfa->bfad;
1211 
1212  if (compl)
1213  complete(&bfad->comp);
1214 }
1215 
1216 static void
1217 bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl)
1218 {
1219  struct bfa_s *bfa = bfa_arg;
1220  struct bfad_s *bfad = bfa->bfad;
1221 
1222  if (compl)
1223  complete(&bfad->enable_comp);
1224 }
1225 
1226 static void
1227 bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl)
1228 {
1229  struct bfa_s *bfa = bfa_arg;
1230  struct bfad_s *bfad = bfa->bfad;
1231 
1232  if (compl)
1233  complete(&bfad->disable_comp);
1234 }
1235 
1239 static void
1240 bfa_iocfc_qreg(struct bfa_s *bfa, struct bfi_iocfc_qreg_s *qreg)
1241 {
1242  int i;
1243  struct bfa_iocfc_regs_s *r = &bfa->iocfc.bfa_regs;
1244  void __iomem *kva = bfa_ioc_bar0(&bfa->ioc);
1245 
1246  for (i = 0; i < BFI_IOC_MAX_CQS; i++) {
1247  bfa->iocfc.hw_qid[i] = qreg->hw_qid[i];
1248  r->cpe_q_ci[i] = kva + be32_to_cpu(qreg->cpe_q_ci_off[i]);
1249  r->cpe_q_pi[i] = kva + be32_to_cpu(qreg->cpe_q_pi_off[i]);
1250  r->cpe_q_ctrl[i] = kva + be32_to_cpu(qreg->cpe_qctl_off[i]);
1251  r->rme_q_ci[i] = kva + be32_to_cpu(qreg->rme_q_ci_off[i]);
1252  r->rme_q_pi[i] = kva + be32_to_cpu(qreg->rme_q_pi_off[i]);
1253  r->rme_q_ctrl[i] = kva + be32_to_cpu(qreg->rme_qctl_off[i]);
1254  }
1255 }
1256 
1257 static void
1258 bfa_iocfc_res_recfg(struct bfa_s *bfa, struct bfa_iocfc_fwcfg_s *fwcfg)
1259 {
1260  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1261  struct bfi_iocfc_cfg_s *cfg_info = iocfc->cfginfo;
1262 
1263  bfa_fcxp_res_recfg(bfa, fwcfg->num_fcxp_reqs);
1264  bfa_uf_res_recfg(bfa, fwcfg->num_uf_bufs);
1265  bfa_rport_res_recfg(bfa, fwcfg->num_rports);
1267  fwcfg->num_ioim_reqs);
1268  bfa_tskim_res_recfg(bfa, fwcfg->num_tskim_reqs);
1269 }
1270 
1271 /*
1272  * Update BFA configuration from firmware configuration.
1273  */
1274 static void
1275 bfa_iocfc_cfgrsp(struct bfa_s *bfa)
1276 {
1277  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1278  struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1279  struct bfa_iocfc_fwcfg_s *fwcfg = &cfgrsp->fwcfg;
1280 
1281  fwcfg->num_cqs = fwcfg->num_cqs;
1282  fwcfg->num_ioim_reqs = be16_to_cpu(fwcfg->num_ioim_reqs);
1283  fwcfg->num_fwtio_reqs = be16_to_cpu(fwcfg->num_fwtio_reqs);
1284  fwcfg->num_tskim_reqs = be16_to_cpu(fwcfg->num_tskim_reqs);
1285  fwcfg->num_fcxp_reqs = be16_to_cpu(fwcfg->num_fcxp_reqs);
1286  fwcfg->num_uf_bufs = be16_to_cpu(fwcfg->num_uf_bufs);
1287  fwcfg->num_rports = be16_to_cpu(fwcfg->num_rports);
1288 
1289  /*
1290  * configure queue register offsets as learnt from firmware
1291  */
1292  bfa_iocfc_qreg(bfa, &cfgrsp->qreg);
1293 
1294  /*
1295  * Re-configure resources as learnt from Firmware
1296  */
1297  bfa_iocfc_res_recfg(bfa, fwcfg);
1298 
1299  /*
1300  * Install MSIX queue handlers
1301  */
1303 
1304  if (bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn != 0) {
1305  bfa->ioc.attr->pwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn;
1306  bfa->ioc.attr->nwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_nwwn;
1308  }
1309 }
1310 
1311 void
1313 {
1314  int q;
1315 
1316  for (q = 0; q < BFI_IOC_MAX_CQS; q++) {
1317  bfa_reqq_ci(bfa, q) = 0;
1318  bfa_reqq_pi(bfa, q) = 0;
1319  bfa_rspq_ci(bfa, q) = 0;
1320  bfa_rspq_pi(bfa, q) = 0;
1321  }
1322 }
1323 
1324 /*
1325  * Process FAA pwwn msg from fw.
1326  */
1327 static void
1328 bfa_iocfc_process_faa_addr(struct bfa_s *bfa, struct bfi_faa_addr_msg_s *msg)
1329 {
1330  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1331  struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1332 
1333  cfgrsp->pbc_cfg.pbc_pwwn = msg->pwwn;
1334  cfgrsp->pbc_cfg.pbc_nwwn = msg->nwwn;
1335 
1336  bfa->ioc.attr->pwwn = msg->pwwn;
1337  bfa->ioc.attr->nwwn = msg->nwwn;
1339 }
1340 
1341 /* Fabric Assigned Address specific functions */
1342 
1343 /*
1344  * Check whether IOC is ready before sending command down
1345  */
1346 static bfa_status_t
1347 bfa_faa_validate_request(struct bfa_s *bfa)
1348 {
1349  enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
1350  u32 card_type = bfa->ioc.attr->card_type;
1351 
1352  if (bfa_ioc_is_operational(&bfa->ioc)) {
1353  if ((ioc_type != BFA_IOC_TYPE_FC) || bfa_mfg_is_mezz(card_type))
1355  } else {
1356  return BFA_STATUS_IOC_NON_OP;
1357  }
1358 
1359  return BFA_STATUS_OK;
1360 }
1361 
1364  bfa_cb_iocfc_t cbfn, void *cbarg)
1365 {
1366  struct bfi_faa_query_s faa_attr_req;
1367  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1369 
1370  iocfc->faa_args.faa_attr = attr;
1371  iocfc->faa_args.faa_cb.faa_cbfn = cbfn;
1372  iocfc->faa_args.faa_cb.faa_cbarg = cbarg;
1373 
1374  status = bfa_faa_validate_request(bfa);
1375  if (status != BFA_STATUS_OK)
1376  return status;
1377 
1378  if (iocfc->faa_args.busy == BFA_TRUE)
1379  return BFA_STATUS_DEVBUSY;
1380 
1381  iocfc->faa_args.busy = BFA_TRUE;
1382  memset(&faa_attr_req, 0, sizeof(struct bfi_faa_query_s));
1383  bfi_h2i_set(faa_attr_req.mh, BFI_MC_IOCFC,
1385 
1386  bfa_ioc_mbox_send(&bfa->ioc, &faa_attr_req,
1387  sizeof(struct bfi_faa_query_s));
1388 
1389  return BFA_STATUS_OK;
1390 }
1391 
1392 /*
1393  * FAA query response
1394  */
1395 static void
1396 bfa_faa_query_reply(struct bfa_iocfc_s *iocfc,
1398 {
1399  void *cbarg = iocfc->faa_args.faa_cb.faa_cbarg;
1400 
1401  if (iocfc->faa_args.faa_attr) {
1402  iocfc->faa_args.faa_attr->faa = rsp->faa;
1403  iocfc->faa_args.faa_attr->faa_state = rsp->faa_status;
1404  iocfc->faa_args.faa_attr->pwwn_source = rsp->addr_source;
1405  }
1406 
1407  WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn);
1408 
1409  iocfc->faa_args.faa_cb.faa_cbfn(cbarg, BFA_STATUS_OK);
1410  iocfc->faa_args.busy = BFA_FALSE;
1411 }
1412 
1413 /*
1414  * IOC enable request is complete
1415  */
1416 static void
1417 bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status)
1418 {
1419  struct bfa_s *bfa = bfa_arg;
1420 
1421  if (status == BFA_STATUS_OK)
1423  else
1425 }
1426 
1427 /*
1428  * IOC disable request is complete
1429  */
1430 static void
1431 bfa_iocfc_disable_cbfn(void *bfa_arg)
1432 {
1433  struct bfa_s *bfa = bfa_arg;
1434 
1436 }
1437 
1438 /*
1439  * Notify sub-modules of hardware failure.
1440  */
1441 static void
1442 bfa_iocfc_hbfail_cbfn(void *bfa_arg)
1443 {
1444  struct bfa_s *bfa = bfa_arg;
1445 
1446  bfa->queue_process = BFA_FALSE;
1448 }
1449 
1450 /*
1451  * Actions on chip-reset completion.
1452  */
1453 static void
1454 bfa_iocfc_reset_cbfn(void *bfa_arg)
1455 {
1456  struct bfa_s *bfa = bfa_arg;
1457 
1459  bfa_isr_enable(bfa);
1460 }
1461 
1462 /*
1463  * Query IOC memory requirement information.
1464  */
1465 void
1467  struct bfa_s *bfa)
1468 {
1469  int q, per_reqq_sz, per_rspq_sz;
1470  struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa);
1471  struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa);
1472  struct bfa_mem_kva_s *iocfc_kva = BFA_MEM_IOCFC_KVA(bfa);
1473  u32 dm_len = 0;
1474 
1475  /* dma memory setup for IOC */
1476  bfa_mem_dma_setup(meminfo, ioc_dma,
1477  BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ));
1478 
1479  /* dma memory setup for REQ/RSP queues */
1480  per_reqq_sz = BFA_ROUNDUP((cfg->drvcfg.num_reqq_elems * BFI_LMSG_SZ),
1482  per_rspq_sz = BFA_ROUNDUP((cfg->drvcfg.num_rspq_elems * BFI_LMSG_SZ),
1484 
1485  for (q = 0; q < cfg->fwcfg.num_cqs; q++) {
1486  bfa_mem_dma_setup(meminfo, BFA_MEM_REQQ_DMA(bfa, q),
1487  per_reqq_sz);
1488  bfa_mem_dma_setup(meminfo, BFA_MEM_RSPQ_DMA(bfa, q),
1489  per_rspq_sz);
1490  }
1491 
1492  /* IOCFC dma memory - calculate Shadow CI/PI size */
1493  for (q = 0; q < cfg->fwcfg.num_cqs; q++)
1494  dm_len += (2 * BFA_CACHELINE_SZ);
1495 
1496  /* IOCFC dma memory - calculate config info / rsp size */
1497  dm_len += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ);
1498  dm_len += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s),
1500 
1501  /* dma memory setup for IOCFC */
1502  bfa_mem_dma_setup(meminfo, iocfc_dma, dm_len);
1503 
1504  /* kva memory setup for IOCFC */
1505  bfa_mem_kva_setup(meminfo, iocfc_kva, BFA_DBG_FWTRC_LEN);
1506 }
1507 
1508 /*
1509  * Query IOC memory requirement information.
1510  */
1511 void
1512 bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1513  struct bfa_pcidev_s *pcidev)
1514 {
1515  int i;
1516  struct bfa_ioc_s *ioc = &bfa->ioc;
1517 
1518  bfa_iocfc_cbfn.enable_cbfn = bfa_iocfc_enable_cbfn;
1519  bfa_iocfc_cbfn.disable_cbfn = bfa_iocfc_disable_cbfn;
1520  bfa_iocfc_cbfn.hbfail_cbfn = bfa_iocfc_hbfail_cbfn;
1521  bfa_iocfc_cbfn.reset_cbfn = bfa_iocfc_reset_cbfn;
1522 
1523  ioc->trcmod = bfa->trcmod;
1524  bfa_ioc_attach(&bfa->ioc, bfa, &bfa_iocfc_cbfn, &bfa->timer_mod);
1525 
1526  bfa_ioc_pci_init(&bfa->ioc, pcidev, BFI_PCIFN_CLASS_FC);
1527  bfa_ioc_mbox_register(&bfa->ioc, bfa_mbox_isrs);
1528 
1529  bfa_iocfc_init_mem(bfa, bfad, cfg, pcidev);
1530  bfa_iocfc_mem_claim(bfa, cfg);
1531  INIT_LIST_HEAD(&bfa->timer_mod.timer_q);
1532 
1533  INIT_LIST_HEAD(&bfa->comp_q);
1534  for (i = 0; i < BFI_IOC_MAX_CQS; i++)
1535  INIT_LIST_HEAD(&bfa->reqq_waitq[i]);
1536 
1537  bfa->iocfc.cb_reqd = BFA_FALSE;
1538  bfa->iocfc.op_status = BFA_STATUS_OK;
1539  bfa->iocfc.submod_enabled = BFA_FALSE;
1540 
1541  bfa_fsm_set_state(&bfa->iocfc, bfa_iocfc_sm_stopped);
1542 }
1543 
1544 /*
1545  * Query IOC memory requirement information.
1546  */
1547 void
1548 bfa_iocfc_init(struct bfa_s *bfa)
1549 {
1551 }
1552 
1553 /*
1554  * IOC start called from bfa_start(). Called to start IOC operations
1555  * at driver instantiation for this instance.
1556  */
1557 void
1559 {
1561 }
1562 
1563 /*
1564  * IOC stop called from bfa_stop(). Called only when driver is unloaded
1565  * for this instance.
1566  */
1567 void
1568 bfa_iocfc_stop(struct bfa_s *bfa)
1569 {
1570  bfa->queue_process = BFA_FALSE;
1572 }
1573 
1574 void
1575 bfa_iocfc_isr(void *bfaarg, struct bfi_mbmsg_s *m)
1576 {
1577  struct bfa_s *bfa = bfaarg;
1578  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1579  union bfi_iocfc_i2h_msg_u *msg;
1580 
1581  msg = (union bfi_iocfc_i2h_msg_u *) m;
1582  bfa_trc(bfa, msg->mh.msg_id);
1583 
1584  switch (msg->mh.msg_id) {
1586  bfa_iocfc_cfgrsp(bfa);
1587  break;
1589  iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK);
1590  break;
1592  bfa_iocfc_process_faa_addr(bfa,
1593  (struct bfi_faa_addr_msg_s *)msg);
1594  break;
1596  bfa_faa_query_reply(iocfc, (bfi_faa_query_rsp_t *)msg);
1597  break;
1598  default:
1599  WARN_ON(1);
1600  }
1601 }
1602 
1603 void
1605 {
1606  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1607 
1608  attr->intr_attr.coalesce = iocfc->cfginfo->intr_attr.coalesce;
1609 
1610  attr->intr_attr.delay = iocfc->cfginfo->intr_attr.delay ?
1611  be16_to_cpu(iocfc->cfginfo->intr_attr.delay) :
1612  be16_to_cpu(iocfc->cfgrsp->intr_attr.delay);
1613 
1614  attr->intr_attr.latency = iocfc->cfginfo->intr_attr.latency ?
1615  be16_to_cpu(iocfc->cfginfo->intr_attr.latency) :
1616  be16_to_cpu(iocfc->cfgrsp->intr_attr.latency);
1617 
1618  attr->config = iocfc->cfg;
1619 }
1620 
1623 {
1624  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1625  struct bfi_iocfc_set_intr_req_s *m;
1626 
1627  iocfc->cfginfo->intr_attr.coalesce = attr->coalesce;
1628  iocfc->cfginfo->intr_attr.delay = cpu_to_be16(attr->delay);
1629  iocfc->cfginfo->intr_attr.latency = cpu_to_be16(attr->latency);
1630 
1631  if (!bfa_iocfc_is_operational(bfa))
1632  return BFA_STATUS_OK;
1633 
1634  m = bfa_reqq_next(bfa, BFA_REQQ_IOC);
1635  if (!m)
1636  return BFA_STATUS_DEVBUSY;
1637 
1639  bfa_fn_lpu(bfa));
1640  m->coalesce = iocfc->cfginfo->intr_attr.coalesce;
1641  m->delay = iocfc->cfginfo->intr_attr.delay;
1642  m->latency = iocfc->cfginfo->intr_attr.latency;
1643 
1644  bfa_trc(bfa, attr->delay);
1645  bfa_trc(bfa, attr->latency);
1646 
1647  bfa_reqq_produce(bfa, BFA_REQQ_IOC, m->mh);
1648  return BFA_STATUS_OK;
1649 }
1650 
1651 void
1652 bfa_iocfc_set_snsbase(struct bfa_s *bfa, int seg_no, u64 snsbase_pa)
1653 {
1654  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1655 
1656  iocfc->cfginfo->sense_buf_len = (BFI_IOIM_SNSLEN - 1);
1657  bfa_dma_be_addr_set(iocfc->cfginfo->ioim_snsbase[seg_no], snsbase_pa);
1658 }
1659 /*
1660  * Enable IOC after it is disabled.
1661  */
1662 void
1664 {
1666  "IOC Enable");
1667  bfa->iocfc.cb_reqd = BFA_TRUE;
1669 }
1670 
1671 void
1673 {
1675  "IOC Disable");
1676 
1677  bfa->queue_process = BFA_FALSE;
1679 }
1680 
1683 {
1684  return bfa_ioc_is_operational(&bfa->ioc) &&
1685  bfa_fsm_cmp_state(&bfa->iocfc, bfa_iocfc_sm_operational);
1686 }
1687 
1688 /*
1689  * Return boot target port wwns -- read from boot information in flash.
1690  */
1691 void
1692 bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t *wwns)
1693 {
1694  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1695  struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1696  int i;
1697 
1698  if (cfgrsp->pbc_cfg.boot_enabled && cfgrsp->pbc_cfg.nbluns) {
1699  bfa_trc(bfa, cfgrsp->pbc_cfg.nbluns);
1700  *nwwns = cfgrsp->pbc_cfg.nbluns;
1701  for (i = 0; i < cfgrsp->pbc_cfg.nbluns; i++)
1702  wwns[i] = cfgrsp->pbc_cfg.blun[i].tgt_pwwn;
1703 
1704  return;
1705  }
1706 
1707  *nwwns = cfgrsp->bootwwns.nwwns;
1708  memcpy(wwns, cfgrsp->bootwwns.wwn, sizeof(cfgrsp->bootwwns.wwn));
1709 }
1710 
1711 int
1712 bfa_iocfc_get_pbc_vports(struct bfa_s *bfa, struct bfi_pbc_vport_s *pbc_vport)
1713 {
1714  struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1715  struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1716 
1717  memcpy(pbc_vport, cfgrsp->pbc_cfg.vport, sizeof(cfgrsp->pbc_cfg.vport));
1718  return cfgrsp->pbc_cfg.nvports;
1719 }
1720 
1721 
1722 /*
1723  * Use this function query the memory requirement of the BFA library.
1724  * This function needs to be called before bfa_attach() to get the
1725  * memory required of the BFA layer for a given driver configuration.
1726  *
1727  * This call will fail, if the cap is out of range compared to pre-defined
1728  * values within the BFA library
1729  *
1730  * @param[in] cfg - pointer to bfa_ioc_cfg_t. Driver layer should indicate
1731  * its configuration in this structure.
1732  * The default values for struct bfa_iocfc_cfg_s can be
1733  * fetched using bfa_cfg_get_default() API.
1734  *
1735  * If cap's boundary check fails, the library will use
1736  * the default bfa_cap_t values (and log a warning msg).
1737  *
1738  * @param[out] meminfo - pointer to bfa_meminfo_t. This content
1739  * indicates the memory type (see bfa_mem_type_t) and
1740  * amount of memory required.
1741  *
1742  * Driver should allocate the memory, populate the
1743  * starting address for each block and provide the same
1744  * structure as input parameter to bfa_attach() call.
1745  *
1746  * @param[in] bfa - pointer to the bfa structure, used while fetching the
1747  * dma, kva memory information of the bfa sub-modules.
1748  *
1749  * @return void
1750  *
1751  * Special Considerations: @note
1752  */
1753 void
1755  struct bfa_s *bfa)
1756 {
1757  int i;
1758  struct bfa_mem_dma_s *port_dma = BFA_MEM_PORT_DMA(bfa);
1759  struct bfa_mem_dma_s *ablk_dma = BFA_MEM_ABLK_DMA(bfa);
1760  struct bfa_mem_dma_s *cee_dma = BFA_MEM_CEE_DMA(bfa);
1761  struct bfa_mem_dma_s *sfp_dma = BFA_MEM_SFP_DMA(bfa);
1762  struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa);
1763  struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa);
1764  struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa);
1765  struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa);
1766 
1767  WARN_ON((cfg == NULL) || (meminfo == NULL));
1768 
1769  memset((void *)meminfo, 0, sizeof(struct bfa_meminfo_s));
1770 
1771  /* Initialize the DMA & KVA meminfo queues */
1772  INIT_LIST_HEAD(&meminfo->dma_info.qe);
1773  INIT_LIST_HEAD(&meminfo->kva_info.qe);
1774 
1775  bfa_iocfc_meminfo(cfg, meminfo, bfa);
1776 
1777  for (i = 0; hal_mods[i]; i++)
1778  hal_mods[i]->meminfo(cfg, meminfo, bfa);
1779 
1780  /* dma info setup */
1781  bfa_mem_dma_setup(meminfo, port_dma, bfa_port_meminfo());
1782  bfa_mem_dma_setup(meminfo, ablk_dma, bfa_ablk_meminfo());
1783  bfa_mem_dma_setup(meminfo, cee_dma, bfa_cee_meminfo());
1784  bfa_mem_dma_setup(meminfo, sfp_dma, bfa_sfp_meminfo());
1785  bfa_mem_dma_setup(meminfo, flash_dma,
1786  bfa_flash_meminfo(cfg->drvcfg.min_cfg));
1787  bfa_mem_dma_setup(meminfo, diag_dma, bfa_diag_meminfo());
1788  bfa_mem_dma_setup(meminfo, phy_dma,
1789  bfa_phy_meminfo(cfg->drvcfg.min_cfg));
1790  bfa_mem_dma_setup(meminfo, fru_dma,
1791  bfa_fru_meminfo(cfg->drvcfg.min_cfg));
1792 }
1793 
1794 /*
1795  * Use this function to do attach the driver instance with the BFA
1796  * library. This function will not trigger any HW initialization
1797  * process (which will be done in bfa_init() call)
1798  *
1799  * This call will fail, if the cap is out of range compared to
1800  * pre-defined values within the BFA library
1801  *
1802  * @param[out] bfa Pointer to bfa_t.
1803  * @param[in] bfad Opaque handle back to the driver's IOC structure
1804  * @param[in] cfg Pointer to bfa_ioc_cfg_t. Should be same structure
1805  * that was used in bfa_cfg_get_meminfo().
1806  * @param[in] meminfo Pointer to bfa_meminfo_t. The driver should
1807  * use the bfa_cfg_get_meminfo() call to
1808  * find the memory blocks required, allocate the
1809  * required memory and provide the starting addresses.
1810  * @param[in] pcidev pointer to struct bfa_pcidev_s
1811  *
1812  * @return
1813  * void
1814  *
1815  * Special Considerations:
1816  *
1817  * @note
1818  *
1819  */
1820 void
1821 bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1822  struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
1823 {
1824  int i;
1825  struct bfa_mem_dma_s *dma_info, *dma_elem;
1826  struct bfa_mem_kva_s *kva_info, *kva_elem;
1827  struct list_head *dm_qe, *km_qe;
1828 
1829  bfa->fcs = BFA_FALSE;
1830 
1831  WARN_ON((cfg == NULL) || (meminfo == NULL));
1832 
1833  /* Initialize memory pointers for iterative allocation */
1834  dma_info = &meminfo->dma_info;
1835  dma_info->kva_curp = dma_info->kva;
1836  dma_info->dma_curp = dma_info->dma;
1837 
1838  kva_info = &meminfo->kva_info;
1839  kva_info->kva_curp = kva_info->kva;
1840 
1841  list_for_each(dm_qe, &dma_info->qe) {
1842  dma_elem = (struct bfa_mem_dma_s *) dm_qe;
1843  dma_elem->kva_curp = dma_elem->kva;
1844  dma_elem->dma_curp = dma_elem->dma;
1845  }
1846 
1847  list_for_each(km_qe, &kva_info->qe) {
1848  kva_elem = (struct bfa_mem_kva_s *) km_qe;
1849  kva_elem->kva_curp = kva_elem->kva;
1850  }
1851 
1852  bfa_iocfc_attach(bfa, bfad, cfg, pcidev);
1853 
1854  for (i = 0; hal_mods[i]; i++)
1855  hal_mods[i]->attach(bfa, bfad, cfg, pcidev);
1856 
1857  bfa_com_port_attach(bfa);
1858  bfa_com_ablk_attach(bfa);
1859  bfa_com_cee_attach(bfa);
1860  bfa_com_sfp_attach(bfa);
1861  bfa_com_flash_attach(bfa, cfg->drvcfg.min_cfg);
1862  bfa_com_diag_attach(bfa);
1863  bfa_com_phy_attach(bfa, cfg->drvcfg.min_cfg);
1864  bfa_com_fru_attach(bfa, cfg->drvcfg.min_cfg);
1865 }
1866 
1867 /*
1868  * Use this function to delete a BFA IOC. IOC should be stopped (by
1869  * calling bfa_stop()) before this function call.
1870  *
1871  * @param[in] bfa - pointer to bfa_t.
1872  *
1873  * @return
1874  * void
1875  *
1876  * Special Considerations:
1877  *
1878  * @note
1879  */
1880 void
1881 bfa_detach(struct bfa_s *bfa)
1882 {
1883  int i;
1884 
1885  for (i = 0; hal_mods[i]; i++)
1886  hal_mods[i]->detach(bfa);
1887  bfa_ioc_detach(&bfa->ioc);
1888 }
1889 
1890 void
1891 bfa_comp_deq(struct bfa_s *bfa, struct list_head *comp_q)
1892 {
1893  INIT_LIST_HEAD(comp_q);
1894  list_splice_tail_init(&bfa->comp_q, comp_q);
1895 }
1896 
1897 void
1898 bfa_comp_process(struct bfa_s *bfa, struct list_head *comp_q)
1899 {
1900  struct list_head *qe;
1901  struct list_head *qen;
1902  struct bfa_cb_qe_s *hcb_qe;
1904 
1905  list_for_each_safe(qe, qen, comp_q) {
1906  hcb_qe = (struct bfa_cb_qe_s *) qe;
1907  if (hcb_qe->pre_rmv) {
1908  /* qe is invalid after return, dequeue before cbfn() */
1909  list_del(qe);
1910  cbfn = (bfa_cb_cbfn_status_t)(hcb_qe->cbfn);
1911  cbfn(hcb_qe->cbarg, hcb_qe->fw_status);
1912  } else
1913  hcb_qe->cbfn(hcb_qe->cbarg, BFA_TRUE);
1914  }
1915 }
1916 
1917 void
1918 bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q)
1919 {
1920  struct list_head *qe;
1921  struct bfa_cb_qe_s *hcb_qe;
1922 
1923  while (!list_empty(comp_q)) {
1924  bfa_q_deq(comp_q, &qe);
1925  hcb_qe = (struct bfa_cb_qe_s *) qe;
1926  WARN_ON(hcb_qe->pre_rmv);
1927  hcb_qe->cbfn(hcb_qe->cbarg, BFA_FALSE);
1928  }
1929 }
1930 
1931 /*
1932  * Return the list of PCI vendor/device id lists supported by this
1933  * BFA instance.
1934  */
1935 void
1936 bfa_get_pciids(struct bfa_pciid_s **pciids, int *npciids)
1937 {
1938  static struct bfa_pciid_s __pciids[] = {
1943  };
1944 
1945  *npciids = sizeof(__pciids) / sizeof(__pciids[0]);
1946  *pciids = __pciids;
1947 }
1948 
1949 /*
1950  * Use this function query the default struct bfa_iocfc_cfg_s value (compiled
1951  * into BFA layer). The OS driver can then turn back and overwrite entries that
1952  * have been configured by the user.
1953  *
1954  * @param[in] cfg - pointer to bfa_ioc_cfg_t
1955  *
1956  * @return
1957  * void
1958  *
1959  * Special Considerations:
1960  * note
1961  */
1962 void
1964 {
1965  cfg->fwcfg.num_fabrics = DEF_CFG_NUM_FABRICS;
1966  cfg->fwcfg.num_lports = DEF_CFG_NUM_LPORTS;
1967  cfg->fwcfg.num_rports = DEF_CFG_NUM_RPORTS;
1968  cfg->fwcfg.num_ioim_reqs = DEF_CFG_NUM_IOIM_REQS;
1969  cfg->fwcfg.num_tskim_reqs = DEF_CFG_NUM_TSKIM_REQS;
1970  cfg->fwcfg.num_fcxp_reqs = DEF_CFG_NUM_FCXP_REQS;
1971  cfg->fwcfg.num_uf_bufs = DEF_CFG_NUM_UF_BUFS;
1972  cfg->fwcfg.num_cqs = DEF_CFG_NUM_CQS;
1973  cfg->fwcfg.num_fwtio_reqs = 0;
1974 
1975  cfg->drvcfg.num_reqq_elems = DEF_CFG_NUM_REQQ_ELEMS;
1976  cfg->drvcfg.num_rspq_elems = DEF_CFG_NUM_RSPQ_ELEMS;
1977  cfg->drvcfg.num_sgpgs = DEF_CFG_NUM_SGPGS;
1978  cfg->drvcfg.num_sboot_tgts = DEF_CFG_NUM_SBOOT_TGTS;
1979  cfg->drvcfg.num_sboot_luns = DEF_CFG_NUM_SBOOT_LUNS;
1980  cfg->drvcfg.path_tov = BFA_FCPIM_PATHTOV_DEF;
1981  cfg->drvcfg.ioc_recover = BFA_FALSE;
1982  cfg->drvcfg.delay_comp = BFA_FALSE;
1983 
1984 }
1985 
1986 void
1988 {
1989  bfa_cfg_get_default(cfg);
1990  cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MIN;
1991  cfg->fwcfg.num_tskim_reqs = BFA_TSKIM_MIN;
1992  cfg->fwcfg.num_fcxp_reqs = BFA_FCXP_MIN;
1993  cfg->fwcfg.num_uf_bufs = BFA_UF_MIN;
1994  cfg->fwcfg.num_rports = BFA_RPORT_MIN;
1995  cfg->fwcfg.num_fwtio_reqs = 0;
1996 
1997  cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
1998  cfg->drvcfg.num_reqq_elems = BFA_REQQ_NELEMS_MIN;
1999  cfg->drvcfg.num_rspq_elems = BFA_RSPQ_NELEMS_MIN;
2000  cfg->drvcfg.min_cfg = BFA_TRUE;
2001 }