2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
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
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.
23 #include "bfa_defs_svc.h"
25 BFA_TRC_FILE(CNA, IOC);
28 * IOC local definitions
30 #define BFA_IOC_TOV 3000 /* msecs */
31 #define BFA_IOC_HWSEM_TOV 500 /* msecs */
32 #define BFA_IOC_HB_TOV 500 /* msecs */
33 #define BFA_IOC_TOV_RECOVER BFA_IOC_HB_TOV
34 #define BFA_IOC_POLL_TOV BFA_TIMER_FREQ
36 #define bfa_ioc_timer_start(__ioc) \
37 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer, \
38 bfa_ioc_timeout, (__ioc), BFA_IOC_TOV)
39 #define bfa_ioc_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->ioc_timer)
41 #define bfa_hb_timer_start(__ioc) \
42 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->hb_timer, \
43 bfa_ioc_hb_check, (__ioc), BFA_IOC_HB_TOV)
44 #define bfa_hb_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->hb_timer)
46 #define BFA_DBG_FWTRC_OFF(_fn) (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))
49 * Asic specific macros : see bfa_hw_cb.c and bfa_hw_ct.c for details.
52 #define bfa_ioc_firmware_lock(__ioc) \
53 ((__ioc)->ioc_hwif->ioc_firmware_lock(__ioc))
54 #define bfa_ioc_firmware_unlock(__ioc) \
55 ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
56 #define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
57 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
58 #define bfa_ioc_notify_fail(__ioc) \
59 ((__ioc)->ioc_hwif->ioc_notify_fail(__ioc))
60 #define bfa_ioc_sync_start(__ioc) \
61 ((__ioc)->ioc_hwif->ioc_sync_start(__ioc))
62 #define bfa_ioc_sync_join(__ioc) \
63 ((__ioc)->ioc_hwif->ioc_sync_join(__ioc))
64 #define bfa_ioc_sync_leave(__ioc) \
65 ((__ioc)->ioc_hwif->ioc_sync_leave(__ioc))
66 #define bfa_ioc_sync_ack(__ioc) \
67 ((__ioc)->ioc_hwif->ioc_sync_ack(__ioc))
68 #define bfa_ioc_sync_complete(__ioc) \
69 ((__ioc)->ioc_hwif->ioc_sync_complete(__ioc))
70 #define bfa_ioc_set_cur_ioc_fwstate(__ioc, __fwstate) \
71 ((__ioc)->ioc_hwif->ioc_set_fwstate(__ioc, __fwstate))
72 #define bfa_ioc_get_cur_ioc_fwstate(__ioc) \
73 ((__ioc)->ioc_hwif->ioc_get_fwstate(__ioc))
74 #define bfa_ioc_set_alt_ioc_fwstate(__ioc, __fwstate) \
75 ((__ioc)->ioc_hwif->ioc_set_alt_fwstate(__ioc, __fwstate))
76 #define bfa_ioc_get_alt_ioc_fwstate(__ioc) \
77 ((__ioc)->ioc_hwif->ioc_get_alt_fwstate(__ioc))
79 #define bfa_ioc_mbox_cmd_pending(__ioc) \
80 (!list_empty(&((__ioc)->mbox_mod.cmd_q)) || \
81 readl((__ioc)->ioc_regs.hfn_mbox_cmd))
83 bfa_boolean_t bfa_auto_recover = BFA_TRUE;
86 * forward declarations
88 static void bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc);
89 static void bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force);
90 static void bfa_ioc_timeout(void *ioc);
91 static void bfa_ioc_poll_fwinit(struct bfa_ioc_s *ioc);
92 static void bfa_ioc_send_enable(struct bfa_ioc_s *ioc);
93 static void bfa_ioc_send_disable(struct bfa_ioc_s *ioc);
94 static void bfa_ioc_send_getattr(struct bfa_ioc_s *ioc);
95 static void bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc);
96 static void bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
97 static void bfa_ioc_mbox_flush(struct bfa_ioc_s *ioc);
98 static void bfa_ioc_recover(struct bfa_ioc_s *ioc);
99 static void bfa_ioc_event_notify(struct bfa_ioc_s *ioc ,
100 enum bfa_ioc_event_e event);
101 static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
102 static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
103 static void bfa_ioc_fail_notify(struct bfa_ioc_s *ioc);
104 static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc);
107 * IOC state machine definitions/declarations
110 IOC_E_RESET = 1, /* IOC reset request */
111 IOC_E_ENABLE = 2, /* IOC enable request */
112 IOC_E_DISABLE = 3, /* IOC disable request */
113 IOC_E_DETACH = 4, /* driver detach cleanup */
114 IOC_E_ENABLED = 5, /* f/w enabled */
115 IOC_E_FWRSP_GETATTR = 6, /* IOC get attribute response */
116 IOC_E_DISABLED = 7, /* f/w disabled */
117 IOC_E_PFFAILED = 8, /* failure notice by iocpf sm */
118 IOC_E_HBFAIL = 9, /* heartbeat failure */
119 IOC_E_HWERROR = 10, /* hardware error interrupt */
120 IOC_E_TIMEOUT = 11, /* timeout */
121 IOC_E_HWFAILED = 12, /* PCI mapping failure notice */
124 bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc_s, enum ioc_event);
125 bfa_fsm_state_decl(bfa_ioc, reset, struct bfa_ioc_s, enum ioc_event);
126 bfa_fsm_state_decl(bfa_ioc, enabling, struct bfa_ioc_s, enum ioc_event);
127 bfa_fsm_state_decl(bfa_ioc, getattr, struct bfa_ioc_s, enum ioc_event);
128 bfa_fsm_state_decl(bfa_ioc, op, struct bfa_ioc_s, enum ioc_event);
129 bfa_fsm_state_decl(bfa_ioc, fail_retry, struct bfa_ioc_s, enum ioc_event);
130 bfa_fsm_state_decl(bfa_ioc, fail, struct bfa_ioc_s, enum ioc_event);
131 bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event);
132 bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event);
133 bfa_fsm_state_decl(bfa_ioc, hwfail, struct bfa_ioc_s, enum ioc_event);
135 static struct bfa_sm_table_s ioc_sm_table[] = {
136 {BFA_SM(bfa_ioc_sm_uninit), BFA_IOC_UNINIT},
137 {BFA_SM(bfa_ioc_sm_reset), BFA_IOC_RESET},
138 {BFA_SM(bfa_ioc_sm_enabling), BFA_IOC_ENABLING},
139 {BFA_SM(bfa_ioc_sm_getattr), BFA_IOC_GETATTR},
140 {BFA_SM(bfa_ioc_sm_op), BFA_IOC_OPERATIONAL},
141 {BFA_SM(bfa_ioc_sm_fail_retry), BFA_IOC_INITFAIL},
142 {BFA_SM(bfa_ioc_sm_fail), BFA_IOC_FAIL},
143 {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
144 {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
145 {BFA_SM(bfa_ioc_sm_hwfail), BFA_IOC_HWFAIL},
149 * IOCPF state machine definitions/declarations
152 #define bfa_iocpf_timer_start(__ioc) \
153 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer, \
154 bfa_iocpf_timeout, (__ioc), BFA_IOC_TOV)
155 #define bfa_iocpf_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->ioc_timer)
157 #define bfa_iocpf_poll_timer_start(__ioc) \
158 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer, \
159 bfa_iocpf_poll_timeout, (__ioc), BFA_IOC_POLL_TOV)
161 #define bfa_sem_timer_start(__ioc) \
162 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->sem_timer, \
163 bfa_iocpf_sem_timeout, (__ioc), BFA_IOC_HWSEM_TOV)
164 #define bfa_sem_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->sem_timer)
167 * Forward declareations for iocpf state machine
169 static void bfa_iocpf_timeout(void *ioc_arg);
170 static void bfa_iocpf_sem_timeout(void *ioc_arg);
171 static void bfa_iocpf_poll_timeout(void *ioc_arg);
174 * IOCPF state machine events
177 IOCPF_E_ENABLE = 1, /* IOCPF enable request */
178 IOCPF_E_DISABLE = 2, /* IOCPF disable request */
179 IOCPF_E_STOP = 3, /* stop on driver detach */
180 IOCPF_E_FWREADY = 4, /* f/w initialization done */
181 IOCPF_E_FWRSP_ENABLE = 5, /* enable f/w response */
182 IOCPF_E_FWRSP_DISABLE = 6, /* disable f/w response */
183 IOCPF_E_FAIL = 7, /* failure notice by ioc sm */
184 IOCPF_E_INITFAIL = 8, /* init fail notice by ioc sm */
185 IOCPF_E_GETATTRFAIL = 9, /* init fail notice by ioc sm */
186 IOCPF_E_SEMLOCKED = 10, /* h/w semaphore is locked */
187 IOCPF_E_TIMEOUT = 11, /* f/w response timeout */
188 IOCPF_E_SEM_ERROR = 12, /* h/w sem mapping error */
194 enum bfa_iocpf_state {
195 BFA_IOCPF_RESET = 1, /* IOC is in reset state */
196 BFA_IOCPF_SEMWAIT = 2, /* Waiting for IOC h/w semaphore */
197 BFA_IOCPF_HWINIT = 3, /* IOC h/w is being initialized */
198 BFA_IOCPF_READY = 4, /* IOCPF is initialized */
199 BFA_IOCPF_INITFAIL = 5, /* IOCPF failed */
200 BFA_IOCPF_FAIL = 6, /* IOCPF failed */
201 BFA_IOCPF_DISABLING = 7, /* IOCPF is being disabled */
202 BFA_IOCPF_DISABLED = 8, /* IOCPF is disabled */
203 BFA_IOCPF_FWMISMATCH = 9, /* IOC f/w different from drivers */
206 bfa_fsm_state_decl(bfa_iocpf, reset, struct bfa_iocpf_s, enum iocpf_event);
207 bfa_fsm_state_decl(bfa_iocpf, fwcheck, struct bfa_iocpf_s, enum iocpf_event);
208 bfa_fsm_state_decl(bfa_iocpf, mismatch, struct bfa_iocpf_s, enum iocpf_event);
209 bfa_fsm_state_decl(bfa_iocpf, semwait, struct bfa_iocpf_s, enum iocpf_event);
210 bfa_fsm_state_decl(bfa_iocpf, hwinit, struct bfa_iocpf_s, enum iocpf_event);
211 bfa_fsm_state_decl(bfa_iocpf, enabling, struct bfa_iocpf_s, enum iocpf_event);
212 bfa_fsm_state_decl(bfa_iocpf, ready, struct bfa_iocpf_s, enum iocpf_event);
213 bfa_fsm_state_decl(bfa_iocpf, initfail_sync, struct bfa_iocpf_s,
215 bfa_fsm_state_decl(bfa_iocpf, initfail, struct bfa_iocpf_s, enum iocpf_event);
216 bfa_fsm_state_decl(bfa_iocpf, fail_sync, struct bfa_iocpf_s, enum iocpf_event);
217 bfa_fsm_state_decl(bfa_iocpf, fail, struct bfa_iocpf_s, enum iocpf_event);
218 bfa_fsm_state_decl(bfa_iocpf, disabling, struct bfa_iocpf_s, enum iocpf_event);
219 bfa_fsm_state_decl(bfa_iocpf, disabling_sync, struct bfa_iocpf_s,
221 bfa_fsm_state_decl(bfa_iocpf, disabled, struct bfa_iocpf_s, enum iocpf_event);
223 static struct bfa_sm_table_s iocpf_sm_table[] = {
224 {BFA_SM(bfa_iocpf_sm_reset), BFA_IOCPF_RESET},
225 {BFA_SM(bfa_iocpf_sm_fwcheck), BFA_IOCPF_FWMISMATCH},
226 {BFA_SM(bfa_iocpf_sm_mismatch), BFA_IOCPF_FWMISMATCH},
227 {BFA_SM(bfa_iocpf_sm_semwait), BFA_IOCPF_SEMWAIT},
228 {BFA_SM(bfa_iocpf_sm_hwinit), BFA_IOCPF_HWINIT},
229 {BFA_SM(bfa_iocpf_sm_enabling), BFA_IOCPF_HWINIT},
230 {BFA_SM(bfa_iocpf_sm_ready), BFA_IOCPF_READY},
231 {BFA_SM(bfa_iocpf_sm_initfail_sync), BFA_IOCPF_INITFAIL},
232 {BFA_SM(bfa_iocpf_sm_initfail), BFA_IOCPF_INITFAIL},
233 {BFA_SM(bfa_iocpf_sm_fail_sync), BFA_IOCPF_FAIL},
234 {BFA_SM(bfa_iocpf_sm_fail), BFA_IOCPF_FAIL},
235 {BFA_SM(bfa_iocpf_sm_disabling), BFA_IOCPF_DISABLING},
236 {BFA_SM(bfa_iocpf_sm_disabling_sync), BFA_IOCPF_DISABLING},
237 {BFA_SM(bfa_iocpf_sm_disabled), BFA_IOCPF_DISABLED},
245 * Beginning state. IOC uninit state.
249 bfa_ioc_sm_uninit_entry(struct bfa_ioc_s *ioc)
254 * IOC is in uninit state.
257 bfa_ioc_sm_uninit(struct bfa_ioc_s *ioc, enum ioc_event event)
263 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
267 bfa_sm_fault(ioc, event);
271 * Reset entry actions -- initialize state machine
274 bfa_ioc_sm_reset_entry(struct bfa_ioc_s *ioc)
276 bfa_fsm_set_state(&ioc->iocpf, bfa_iocpf_sm_reset);
280 * IOC is in reset state.
283 bfa_ioc_sm_reset(struct bfa_ioc_s *ioc, enum ioc_event event)
289 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
293 bfa_ioc_disable_comp(ioc);
297 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
301 bfa_sm_fault(ioc, event);
307 bfa_ioc_sm_enabling_entry(struct bfa_ioc_s *ioc)
309 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_ENABLE);
313 * Host IOC function is being enabled, awaiting response from firmware.
314 * Semaphore is acquired.
317 bfa_ioc_sm_enabling(struct bfa_ioc_s *ioc, enum ioc_event event)
323 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
327 /* !!! fall through !!! */
329 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
330 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
331 if (event != IOC_E_PFFAILED)
332 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
336 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
337 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
341 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
345 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
346 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
353 bfa_sm_fault(ioc, event);
359 bfa_ioc_sm_getattr_entry(struct bfa_ioc_s *ioc)
361 bfa_ioc_timer_start(ioc);
362 bfa_ioc_send_getattr(ioc);
366 * IOC configuration in progress. Timer is active.
369 bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
374 case IOC_E_FWRSP_GETATTR:
375 bfa_ioc_timer_stop(ioc);
376 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
381 bfa_ioc_timer_stop(ioc);
382 /* !!! fall through !!! */
384 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
385 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
386 if (event != IOC_E_PFFAILED)
387 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
391 bfa_ioc_timer_stop(ioc);
392 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
399 bfa_sm_fault(ioc, event);
404 bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
406 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
408 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
409 bfa_ioc_event_notify(ioc, BFA_IOC_E_ENABLED);
410 bfa_ioc_hb_monitor(ioc);
411 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC enabled\n");
412 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_ENABLE);
416 bfa_ioc_sm_op(struct bfa_ioc_s *ioc, enum ioc_event event)
425 bfa_hb_timer_stop(ioc);
426 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
431 bfa_hb_timer_stop(ioc);
432 /* !!! fall through !!! */
434 if (ioc->iocpf.auto_recover)
435 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail_retry);
437 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
439 bfa_ioc_fail_notify(ioc);
441 if (event != IOC_E_PFFAILED)
442 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
446 bfa_sm_fault(ioc, event);
452 bfa_ioc_sm_disabling_entry(struct bfa_ioc_s *ioc)
454 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
455 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_DISABLE);
456 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC disabled\n");
457 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_DISABLE);
461 * IOC is being disabled
464 bfa_ioc_sm_disabling(struct bfa_ioc_s *ioc, enum ioc_event event)
470 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
475 * No state change. Will move to disabled state
476 * after iocpf sm completes failure processing and
477 * moves to disabled state.
479 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
483 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
484 bfa_ioc_disable_comp(ioc);
488 bfa_sm_fault(ioc, event);
493 * IOC disable completion entry.
496 bfa_ioc_sm_disabled_entry(struct bfa_ioc_s *ioc)
498 bfa_ioc_disable_comp(ioc);
502 bfa_ioc_sm_disabled(struct bfa_ioc_s *ioc, enum ioc_event event)
508 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
512 ioc->cbfn->disable_cbfn(ioc->bfa);
516 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
517 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
521 bfa_sm_fault(ioc, event);
527 bfa_ioc_sm_fail_retry_entry(struct bfa_ioc_s *ioc)
533 * Hardware initialization retry.
536 bfa_ioc_sm_fail_retry(struct bfa_ioc_s *ioc, enum ioc_event event)
542 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
548 * Initialization retry failed.
550 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
551 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
552 if (event != IOC_E_PFFAILED)
553 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
557 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
558 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
565 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
569 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
570 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
574 bfa_sm_fault(ioc, event);
580 bfa_ioc_sm_fail_entry(struct bfa_ioc_s *ioc)
589 bfa_ioc_sm_fail(struct bfa_ioc_s *ioc, enum ioc_event event)
596 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
600 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
604 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
605 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
611 * HB failure / HW error notification, ignore.
615 bfa_sm_fault(ioc, event);
620 bfa_ioc_sm_hwfail_entry(struct bfa_ioc_s *ioc)
626 bfa_ioc_sm_hwfail(struct bfa_ioc_s *ioc, enum ioc_event event)
632 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
636 ioc->cbfn->disable_cbfn(ioc->bfa);
640 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
644 /* Ignore - already in hwfail state */
648 bfa_sm_fault(ioc, event);
653 * IOCPF State Machine
657 * Reset entry actions -- initialize state machine
660 bfa_iocpf_sm_reset_entry(struct bfa_iocpf_s *iocpf)
662 iocpf->fw_mismatch_notified = BFA_FALSE;
663 iocpf->auto_recover = bfa_auto_recover;
667 * Beginning state. IOC is in reset state.
670 bfa_iocpf_sm_reset(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
672 struct bfa_ioc_s *ioc = iocpf->ioc;
678 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
685 bfa_sm_fault(ioc, event);
690 * Semaphore should be acquired for version check.
693 bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf)
695 struct bfi_ioc_image_hdr_s fwhdr;
696 u32 r32, fwstate, pgnum, pgoff, loff = 0;
700 * Spin on init semaphore to serialize.
702 r32 = readl(iocpf->ioc->ioc_regs.ioc_init_sem_reg);
705 r32 = readl(iocpf->ioc->ioc_regs.ioc_init_sem_reg);
709 fwstate = bfa_ioc_get_cur_ioc_fwstate(iocpf->ioc);
710 if (fwstate == BFI_IOC_UNINIT) {
711 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
715 bfa_ioc_fwver_get(iocpf->ioc, &fwhdr);
717 if (swab32(fwhdr.exec) == BFI_FWBOOT_TYPE_NORMAL) {
718 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
725 pgnum = PSS_SMEM_PGNUM(iocpf->ioc->ioc_regs.smem_pg0, loff);
726 pgoff = PSS_SMEM_PGOFF(loff);
727 writel(pgnum, iocpf->ioc->ioc_regs.host_page_num_fn);
729 for (i = 0; i < sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32); i++) {
730 bfa_mem_write(iocpf->ioc->ioc_regs.smem_page_start, loff, 0);
734 bfa_trc(iocpf->ioc, fwstate);
735 bfa_trc(iocpf->ioc, swab32(fwhdr.exec));
736 bfa_ioc_set_cur_ioc_fwstate(iocpf->ioc, BFI_IOC_UNINIT);
737 bfa_ioc_set_alt_ioc_fwstate(iocpf->ioc, BFI_IOC_UNINIT);
740 * Unlock the hw semaphore. Should be here only once per boot.
742 bfa_ioc_ownership_reset(iocpf->ioc);
745 * unlock init semaphore.
747 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
750 bfa_ioc_hw_sem_get(iocpf->ioc);
754 * Awaiting h/w semaphore to continue with version check.
757 bfa_iocpf_sm_fwcheck(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
759 struct bfa_ioc_s *ioc = iocpf->ioc;
764 case IOCPF_E_SEMLOCKED:
765 if (bfa_ioc_firmware_lock(ioc)) {
766 if (bfa_ioc_sync_start(ioc)) {
767 bfa_ioc_sync_join(ioc);
768 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
770 bfa_ioc_firmware_unlock(ioc);
771 writel(1, ioc->ioc_regs.ioc_sem_reg);
772 bfa_sem_timer_start(ioc);
775 writel(1, ioc->ioc_regs.ioc_sem_reg);
776 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_mismatch);
780 case IOCPF_E_SEM_ERROR:
781 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
782 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
785 case IOCPF_E_DISABLE:
786 bfa_sem_timer_stop(ioc);
787 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
788 bfa_fsm_send_event(ioc, IOC_E_DISABLED);
792 bfa_sem_timer_stop(ioc);
793 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
797 bfa_sm_fault(ioc, event);
802 * Notify enable completion callback.
805 bfa_iocpf_sm_mismatch_entry(struct bfa_iocpf_s *iocpf)
808 * Call only the first time sm enters fwmismatch state.
810 if (iocpf->fw_mismatch_notified == BFA_FALSE)
811 bfa_ioc_pf_fwmismatch(iocpf->ioc);
813 iocpf->fw_mismatch_notified = BFA_TRUE;
814 bfa_iocpf_timer_start(iocpf->ioc);
818 * Awaiting firmware version match.
821 bfa_iocpf_sm_mismatch(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
823 struct bfa_ioc_s *ioc = iocpf->ioc;
828 case IOCPF_E_TIMEOUT:
829 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
832 case IOCPF_E_DISABLE:
833 bfa_iocpf_timer_stop(ioc);
834 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
835 bfa_fsm_send_event(ioc, IOC_E_DISABLED);
839 bfa_iocpf_timer_stop(ioc);
840 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
844 bfa_sm_fault(ioc, event);
849 * Request for semaphore.
852 bfa_iocpf_sm_semwait_entry(struct bfa_iocpf_s *iocpf)
854 bfa_ioc_hw_sem_get(iocpf->ioc);
858 * Awaiting semaphore for h/w initialzation.
861 bfa_iocpf_sm_semwait(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
863 struct bfa_ioc_s *ioc = iocpf->ioc;
868 case IOCPF_E_SEMLOCKED:
869 if (bfa_ioc_sync_complete(ioc)) {
870 bfa_ioc_sync_join(ioc);
871 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
873 writel(1, ioc->ioc_regs.ioc_sem_reg);
874 bfa_sem_timer_start(ioc);
878 case IOCPF_E_SEM_ERROR:
879 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
880 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
883 case IOCPF_E_DISABLE:
884 bfa_sem_timer_stop(ioc);
885 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
889 bfa_sm_fault(ioc, event);
894 bfa_iocpf_sm_hwinit_entry(struct bfa_iocpf_s *iocpf)
896 iocpf->poll_time = 0;
897 bfa_ioc_hwinit(iocpf->ioc, BFA_FALSE);
901 * Hardware is being initialized. Interrupts are enabled.
902 * Holding hardware semaphore lock.
905 bfa_iocpf_sm_hwinit(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
907 struct bfa_ioc_s *ioc = iocpf->ioc;
912 case IOCPF_E_FWREADY:
913 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_enabling);
916 case IOCPF_E_TIMEOUT:
917 writel(1, ioc->ioc_regs.ioc_sem_reg);
918 bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
919 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
922 case IOCPF_E_DISABLE:
923 bfa_iocpf_timer_stop(ioc);
924 bfa_ioc_sync_leave(ioc);
925 writel(1, ioc->ioc_regs.ioc_sem_reg);
926 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
930 bfa_sm_fault(ioc, event);
935 bfa_iocpf_sm_enabling_entry(struct bfa_iocpf_s *iocpf)
937 bfa_iocpf_timer_start(iocpf->ioc);
939 * Enable Interrupts before sending fw IOC ENABLE cmd.
941 iocpf->ioc->cbfn->reset_cbfn(iocpf->ioc->bfa);
942 bfa_ioc_send_enable(iocpf->ioc);
946 * Host IOC function is being enabled, awaiting response from firmware.
947 * Semaphore is acquired.
950 bfa_iocpf_sm_enabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
952 struct bfa_ioc_s *ioc = iocpf->ioc;
957 case IOCPF_E_FWRSP_ENABLE:
958 bfa_iocpf_timer_stop(ioc);
959 writel(1, ioc->ioc_regs.ioc_sem_reg);
960 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_ready);
963 case IOCPF_E_INITFAIL:
964 bfa_iocpf_timer_stop(ioc);
966 * !!! fall through !!!
969 case IOCPF_E_TIMEOUT:
970 writel(1, ioc->ioc_regs.ioc_sem_reg);
971 if (event == IOCPF_E_TIMEOUT)
972 bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
973 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
976 case IOCPF_E_DISABLE:
977 bfa_iocpf_timer_stop(ioc);
978 writel(1, ioc->ioc_regs.ioc_sem_reg);
979 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
983 bfa_sm_fault(ioc, event);
988 bfa_iocpf_sm_ready_entry(struct bfa_iocpf_s *iocpf)
990 bfa_fsm_send_event(iocpf->ioc, IOC_E_ENABLED);
994 bfa_iocpf_sm_ready(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
996 struct bfa_ioc_s *ioc = iocpf->ioc;
1001 case IOCPF_E_DISABLE:
1002 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
1005 case IOCPF_E_GETATTRFAIL:
1006 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
1010 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail_sync);
1014 bfa_sm_fault(ioc, event);
1019 bfa_iocpf_sm_disabling_entry(struct bfa_iocpf_s *iocpf)
1021 bfa_iocpf_timer_start(iocpf->ioc);
1022 bfa_ioc_send_disable(iocpf->ioc);
1026 * IOC is being disabled
1029 bfa_iocpf_sm_disabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1031 struct bfa_ioc_s *ioc = iocpf->ioc;
1033 bfa_trc(ioc, event);
1036 case IOCPF_E_FWRSP_DISABLE:
1037 bfa_iocpf_timer_stop(ioc);
1038 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1042 bfa_iocpf_timer_stop(ioc);
1044 * !!! fall through !!!
1047 case IOCPF_E_TIMEOUT:
1048 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_FAIL);
1049 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1052 case IOCPF_E_FWRSP_ENABLE:
1056 bfa_sm_fault(ioc, event);
1061 bfa_iocpf_sm_disabling_sync_entry(struct bfa_iocpf_s *iocpf)
1063 bfa_ioc_hw_sem_get(iocpf->ioc);
1067 * IOC hb ack request is being removed.
1070 bfa_iocpf_sm_disabling_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1072 struct bfa_ioc_s *ioc = iocpf->ioc;
1074 bfa_trc(ioc, event);
1077 case IOCPF_E_SEMLOCKED:
1078 bfa_ioc_sync_leave(ioc);
1079 writel(1, ioc->ioc_regs.ioc_sem_reg);
1080 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1083 case IOCPF_E_SEM_ERROR:
1084 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1085 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
1092 bfa_sm_fault(ioc, event);
1097 * IOC disable completion entry.
1100 bfa_iocpf_sm_disabled_entry(struct bfa_iocpf_s *iocpf)
1102 bfa_ioc_mbox_flush(iocpf->ioc);
1103 bfa_fsm_send_event(iocpf->ioc, IOC_E_DISABLED);
1107 bfa_iocpf_sm_disabled(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1109 struct bfa_ioc_s *ioc = iocpf->ioc;
1111 bfa_trc(ioc, event);
1114 case IOCPF_E_ENABLE:
1115 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1119 bfa_ioc_firmware_unlock(ioc);
1120 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1124 bfa_sm_fault(ioc, event);
1129 bfa_iocpf_sm_initfail_sync_entry(struct bfa_iocpf_s *iocpf)
1131 bfa_ioc_debug_save_ftrc(iocpf->ioc);
1132 bfa_ioc_hw_sem_get(iocpf->ioc);
1136 * Hardware initialization failed.
1139 bfa_iocpf_sm_initfail_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1141 struct bfa_ioc_s *ioc = iocpf->ioc;
1143 bfa_trc(ioc, event);
1146 case IOCPF_E_SEMLOCKED:
1147 bfa_ioc_notify_fail(ioc);
1148 bfa_ioc_sync_leave(ioc);
1149 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_FAIL);
1150 writel(1, ioc->ioc_regs.ioc_sem_reg);
1151 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
1154 case IOCPF_E_SEM_ERROR:
1155 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1156 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
1159 case IOCPF_E_DISABLE:
1160 bfa_sem_timer_stop(ioc);
1161 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1165 bfa_sem_timer_stop(ioc);
1166 bfa_ioc_firmware_unlock(ioc);
1167 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1174 bfa_sm_fault(ioc, event);
1179 bfa_iocpf_sm_initfail_entry(struct bfa_iocpf_s *iocpf)
1181 bfa_trc(iocpf->ioc, 0);
1185 * Hardware initialization failed.
1188 bfa_iocpf_sm_initfail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1190 struct bfa_ioc_s *ioc = iocpf->ioc;
1192 bfa_trc(ioc, event);
1195 case IOCPF_E_DISABLE:
1196 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1200 bfa_ioc_firmware_unlock(ioc);
1201 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1205 bfa_sm_fault(ioc, event);
1210 bfa_iocpf_sm_fail_sync_entry(struct bfa_iocpf_s *iocpf)
1213 * Mark IOC as failed in hardware and stop firmware.
1215 bfa_ioc_lpu_stop(iocpf->ioc);
1218 * Flush any queued up mailbox requests.
1220 bfa_ioc_mbox_flush(iocpf->ioc);
1222 bfa_ioc_hw_sem_get(iocpf->ioc);
1226 bfa_iocpf_sm_fail_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1228 struct bfa_ioc_s *ioc = iocpf->ioc;
1230 bfa_trc(ioc, event);
1233 case IOCPF_E_SEMLOCKED:
1234 bfa_ioc_sync_ack(ioc);
1235 bfa_ioc_notify_fail(ioc);
1236 if (!iocpf->auto_recover) {
1237 bfa_ioc_sync_leave(ioc);
1238 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_FAIL);
1239 writel(1, ioc->ioc_regs.ioc_sem_reg);
1240 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1242 if (bfa_ioc_sync_complete(ioc))
1243 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
1245 writel(1, ioc->ioc_regs.ioc_sem_reg);
1246 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1251 case IOCPF_E_SEM_ERROR:
1252 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1253 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
1256 case IOCPF_E_DISABLE:
1257 bfa_sem_timer_stop(ioc);
1258 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1265 bfa_sm_fault(ioc, event);
1270 bfa_iocpf_sm_fail_entry(struct bfa_iocpf_s *iocpf)
1272 bfa_trc(iocpf->ioc, 0);
1276 * IOC is in failed state.
1279 bfa_iocpf_sm_fail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1281 struct bfa_ioc_s *ioc = iocpf->ioc;
1283 bfa_trc(ioc, event);
1286 case IOCPF_E_DISABLE:
1287 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1291 bfa_sm_fault(ioc, event);
1296 * BFA IOC private functions
1300 * Notify common modules registered for notification.
1303 bfa_ioc_event_notify(struct bfa_ioc_s *ioc, enum bfa_ioc_event_e event)
1305 struct bfa_ioc_notify_s *notify;
1306 struct list_head *qe;
1308 list_for_each(qe, &ioc->notify_q) {
1309 notify = (struct bfa_ioc_notify_s *)qe;
1310 notify->cbfn(notify->cbarg, event);
1315 bfa_ioc_disable_comp(struct bfa_ioc_s *ioc)
1317 ioc->cbfn->disable_cbfn(ioc->bfa);
1318 bfa_ioc_event_notify(ioc, BFA_IOC_E_DISABLED);
1322 bfa_ioc_sem_get(void __iomem *sem_reg)
1326 #define BFA_SEM_SPINCNT 3000
1328 r32 = readl(sem_reg);
1330 while ((r32 & 1) && (cnt < BFA_SEM_SPINCNT)) {
1333 r32 = readl(sem_reg);
1343 bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
1348 * First read to the semaphore register will return 0, subsequent reads
1349 * will return 1. Semaphore is released by writing 1 to the register
1351 r32 = readl(ioc->ioc_regs.ioc_sem_reg);
1354 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_SEM_ERROR);
1358 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_SEMLOCKED);
1362 bfa_sem_timer_start(ioc);
1366 * Initialize LPU local memory (aka secondary memory / SRAM)
1369 bfa_ioc_lmem_init(struct bfa_ioc_s *ioc)
1373 #define PSS_LMEM_INIT_TIME 10000
1375 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1376 pss_ctl &= ~__PSS_LMEM_RESET;
1377 pss_ctl |= __PSS_LMEM_INIT_EN;
1380 * i2c workaround 12.5khz clock
1382 pss_ctl |= __PSS_I2C_CLK_DIV(3UL);
1383 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1386 * wait for memory initialization to be complete
1390 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1392 } while (!(pss_ctl & __PSS_LMEM_INIT_DONE) && (i < PSS_LMEM_INIT_TIME));
1395 * If memory initialization is not successful, IOC timeout will catch
1398 WARN_ON(!(pss_ctl & __PSS_LMEM_INIT_DONE));
1399 bfa_trc(ioc, pss_ctl);
1401 pss_ctl &= ~(__PSS_LMEM_INIT_DONE | __PSS_LMEM_INIT_EN);
1402 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1406 bfa_ioc_lpu_start(struct bfa_ioc_s *ioc)
1411 * Take processor out of reset.
1413 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1414 pss_ctl &= ~__PSS_LPU0_RESET;
1416 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1420 bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc)
1425 * Put processors in reset.
1427 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1428 pss_ctl |= (__PSS_LPU0_RESET | __PSS_LPU1_RESET);
1430 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1434 * Get driver and firmware versions.
1437 bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
1442 u32 *fwsig = (u32 *) fwhdr;
1444 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1445 pgoff = PSS_SMEM_PGOFF(loff);
1446 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1448 for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32));
1451 bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
1452 loff += sizeof(u32);
1457 * Returns TRUE if same.
1460 bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
1462 struct bfi_ioc_image_hdr_s *drv_fwhdr;
1465 drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
1466 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
1468 for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) {
1469 if (fwhdr->md5sum[i] != cpu_to_le32(drv_fwhdr->md5sum[i])) {
1471 bfa_trc(ioc, fwhdr->md5sum[i]);
1472 bfa_trc(ioc, drv_fwhdr->md5sum[i]);
1477 bfa_trc(ioc, fwhdr->md5sum[0]);
1482 * Return true if current running version is valid. Firmware signature and
1483 * execution context (driver/bios) must match.
1485 static bfa_boolean_t
1486 bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc, u32 boot_env)
1488 struct bfi_ioc_image_hdr_s fwhdr, *drv_fwhdr;
1490 bfa_ioc_fwver_get(ioc, &fwhdr);
1491 drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
1492 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
1494 if (fwhdr.signature != cpu_to_le32(drv_fwhdr->signature)) {
1495 bfa_trc(ioc, fwhdr.signature);
1496 bfa_trc(ioc, drv_fwhdr->signature);
1500 if (swab32(fwhdr.bootenv) != boot_env) {
1501 bfa_trc(ioc, fwhdr.bootenv);
1502 bfa_trc(ioc, boot_env);
1506 return bfa_ioc_fwver_cmp(ioc, &fwhdr);
1510 * Conditionally flush any pending message from firmware at start.
1513 bfa_ioc_msgflush(struct bfa_ioc_s *ioc)
1517 r32 = readl(ioc->ioc_regs.lpu_mbox_cmd);
1519 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
1523 bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force)
1525 enum bfi_ioc_state ioc_fwstate;
1526 bfa_boolean_t fwvalid;
1530 ioc_fwstate = bfa_ioc_get_cur_ioc_fwstate(ioc);
1533 ioc_fwstate = BFI_IOC_UNINIT;
1535 bfa_trc(ioc, ioc_fwstate);
1537 boot_type = BFI_FWBOOT_TYPE_NORMAL;
1538 boot_env = BFI_FWBOOT_ENV_OS;
1541 * check if firmware is valid
1543 fwvalid = (ioc_fwstate == BFI_IOC_UNINIT) ?
1544 BFA_FALSE : bfa_ioc_fwver_valid(ioc, boot_env);
1547 bfa_ioc_boot(ioc, boot_type, boot_env);
1548 bfa_ioc_poll_fwinit(ioc);
1553 * If hardware initialization is in progress (initialized by other IOC),
1554 * just wait for an initialization completion interrupt.
1556 if (ioc_fwstate == BFI_IOC_INITING) {
1557 bfa_ioc_poll_fwinit(ioc);
1562 * If IOC function is disabled and firmware version is same,
1563 * just re-enable IOC.
1565 * If option rom, IOC must not be in operational state. With
1566 * convergence, IOC will be in operational state when 2nd driver
1569 if (ioc_fwstate == BFI_IOC_DISABLED || ioc_fwstate == BFI_IOC_OP) {
1572 * When using MSI-X any pending firmware ready event should
1573 * be flushed. Otherwise MSI-X interrupts are not delivered.
1575 bfa_ioc_msgflush(ioc);
1576 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FWREADY);
1581 * Initialize the h/w for any other states.
1583 bfa_ioc_boot(ioc, boot_type, boot_env);
1584 bfa_ioc_poll_fwinit(ioc);
1588 bfa_ioc_timeout(void *ioc_arg)
1590 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
1593 bfa_fsm_send_event(ioc, IOC_E_TIMEOUT);
1597 bfa_ioc_mbox_send(struct bfa_ioc_s *ioc, void *ioc_msg, int len)
1599 u32 *msgp = (u32 *) ioc_msg;
1602 bfa_trc(ioc, msgp[0]);
1605 WARN_ON(len > BFI_IOC_MSGLEN_MAX);
1608 * first write msg to mailbox registers
1610 for (i = 0; i < len / sizeof(u32); i++)
1611 writel(cpu_to_le32(msgp[i]),
1612 ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1614 for (; i < BFI_IOC_MSGLEN_MAX / sizeof(u32); i++)
1615 writel(0, ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1618 * write 1 to mailbox CMD to trigger LPU event
1620 writel(1, ioc->ioc_regs.hfn_mbox_cmd);
1621 (void) readl(ioc->ioc_regs.hfn_mbox_cmd);
1625 bfa_ioc_send_enable(struct bfa_ioc_s *ioc)
1627 struct bfi_ioc_ctrl_req_s enable_req;
1630 bfi_h2i_set(enable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_ENABLE_REQ,
1631 bfa_ioc_portid(ioc));
1632 enable_req.clscode = cpu_to_be16(ioc->clscode);
1633 do_gettimeofday(&tv);
1634 enable_req.tv_sec = be32_to_cpu(tv.tv_sec);
1635 bfa_ioc_mbox_send(ioc, &enable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1639 bfa_ioc_send_disable(struct bfa_ioc_s *ioc)
1641 struct bfi_ioc_ctrl_req_s disable_req;
1643 bfi_h2i_set(disable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_DISABLE_REQ,
1644 bfa_ioc_portid(ioc));
1645 bfa_ioc_mbox_send(ioc, &disable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1649 bfa_ioc_send_getattr(struct bfa_ioc_s *ioc)
1651 struct bfi_ioc_getattr_req_s attr_req;
1653 bfi_h2i_set(attr_req.mh, BFI_MC_IOC, BFI_IOC_H2I_GETATTR_REQ,
1654 bfa_ioc_portid(ioc));
1655 bfa_dma_be_addr_set(attr_req.attr_addr, ioc->attr_dma.pa);
1656 bfa_ioc_mbox_send(ioc, &attr_req, sizeof(attr_req));
1660 bfa_ioc_hb_check(void *cbarg)
1662 struct bfa_ioc_s *ioc = cbarg;
1665 hb_count = readl(ioc->ioc_regs.heartbeat);
1666 if (ioc->hb_count == hb_count) {
1667 bfa_ioc_recover(ioc);
1670 ioc->hb_count = hb_count;
1673 bfa_ioc_mbox_poll(ioc);
1674 bfa_hb_timer_start(ioc);
1678 bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc)
1680 ioc->hb_count = readl(ioc->ioc_regs.heartbeat);
1681 bfa_hb_timer_start(ioc);
1685 * Initiate a full firmware download.
1688 bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
1698 bfa_trc(ioc, bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc)));
1699 fwimg = bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), chunkno);
1701 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1702 pgoff = PSS_SMEM_PGOFF(loff);
1704 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1706 for (i = 0; i < bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc)); i++) {
1708 if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {
1709 chunkno = BFA_IOC_FLASH_CHUNK_NO(i);
1710 fwimg = bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc),
1711 BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
1717 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff,
1718 cpu_to_le32(fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]));
1720 loff += sizeof(u32);
1723 * handle page offset wrap around
1725 loff = PSS_SMEM_PGOFF(loff);
1728 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1732 writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
1733 ioc->ioc_regs.host_page_num_fn);
1736 * Set boot type and device mode at the end.
1738 asicmode = BFI_FWBOOT_DEVMODE(ioc->asic_gen, ioc->asic_mode,
1739 ioc->port0_mode, ioc->port1_mode);
1740 bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_FWBOOT_DEVMODE_OFF,
1742 bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_FWBOOT_TYPE_OFF,
1744 bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_FWBOOT_ENV_OFF,
1750 * Update BFA configuration from firmware configuration.
1753 bfa_ioc_getattr_reply(struct bfa_ioc_s *ioc)
1755 struct bfi_ioc_attr_s *attr = ioc->attr;
1757 attr->adapter_prop = be32_to_cpu(attr->adapter_prop);
1758 attr->card_type = be32_to_cpu(attr->card_type);
1759 attr->maxfrsize = be16_to_cpu(attr->maxfrsize);
1760 ioc->fcmode = (attr->port_mode == BFI_PORT_MODE_FC);
1761 attr->mfg_year = be16_to_cpu(attr->mfg_year);
1763 bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR);
1767 * Attach time initialization of mbox logic.
1770 bfa_ioc_mbox_attach(struct bfa_ioc_s *ioc)
1772 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1775 INIT_LIST_HEAD(&mod->cmd_q);
1776 for (mc = 0; mc < BFI_MC_MAX; mc++) {
1777 mod->mbhdlr[mc].cbfn = NULL;
1778 mod->mbhdlr[mc].cbarg = ioc->bfa;
1783 * Mbox poll timer -- restarts any pending mailbox requests.
1786 bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc)
1788 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1789 struct bfa_mbox_cmd_s *cmd;
1793 * If no command pending, do nothing
1795 if (list_empty(&mod->cmd_q))
1799 * If previous command is not yet fetched by firmware, do nothing
1801 stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
1806 * Enqueue command to firmware.
1808 bfa_q_deq(&mod->cmd_q, &cmd);
1809 bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
1813 * Cleanup any pending requests.
1816 bfa_ioc_mbox_flush(struct bfa_ioc_s *ioc)
1818 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1819 struct bfa_mbox_cmd_s *cmd;
1821 while (!list_empty(&mod->cmd_q))
1822 bfa_q_deq(&mod->cmd_q, &cmd);
1826 * Read data from SMEM to host through PCI memmap
1828 * @param[in] ioc memory for IOC
1829 * @param[in] tbuf app memory to store data from smem
1830 * @param[in] soff smem offset
1831 * @param[in] sz size of smem in bytes
1834 bfa_ioc_smem_read(struct bfa_ioc_s *ioc, void *tbuf, u32 soff, u32 sz)
1841 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, soff);
1842 loff = PSS_SMEM_PGOFF(soff);
1843 bfa_trc(ioc, pgnum);
1848 * Hold semaphore to serialize pll init and fwtrc.
1850 if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {
1852 return BFA_STATUS_FAILED;
1855 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1857 len = sz/sizeof(u32);
1859 for (i = 0; i < len; i++) {
1860 r32 = bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
1861 buf[i] = swab32(r32);
1862 loff += sizeof(u32);
1865 * handle page offset wrap around
1867 loff = PSS_SMEM_PGOFF(loff);
1870 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1873 writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
1874 ioc->ioc_regs.host_page_num_fn);
1876 * release semaphore.
1878 readl(ioc->ioc_regs.ioc_init_sem_reg);
1879 writel(1, ioc->ioc_regs.ioc_init_sem_reg);
1881 bfa_trc(ioc, pgnum);
1882 return BFA_STATUS_OK;
1886 * Clear SMEM data from host through PCI memmap
1888 * @param[in] ioc memory for IOC
1889 * @param[in] soff smem offset
1890 * @param[in] sz size of smem in bytes
1893 bfa_ioc_smem_clr(struct bfa_ioc_s *ioc, u32 soff, u32 sz)
1898 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, soff);
1899 loff = PSS_SMEM_PGOFF(soff);
1900 bfa_trc(ioc, pgnum);
1905 * Hold semaphore to serialize pll init and fwtrc.
1907 if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {
1909 return BFA_STATUS_FAILED;
1912 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1914 len = sz/sizeof(u32); /* len in words */
1916 for (i = 0; i < len; i++) {
1917 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff, 0);
1918 loff += sizeof(u32);
1921 * handle page offset wrap around
1923 loff = PSS_SMEM_PGOFF(loff);
1926 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1929 writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
1930 ioc->ioc_regs.host_page_num_fn);
1933 * release semaphore.
1935 readl(ioc->ioc_regs.ioc_init_sem_reg);
1936 writel(1, ioc->ioc_regs.ioc_init_sem_reg);
1937 bfa_trc(ioc, pgnum);
1938 return BFA_STATUS_OK;
1942 bfa_ioc_fail_notify(struct bfa_ioc_s *ioc)
1944 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
1947 * Notify driver and common modules registered for notification.
1949 ioc->cbfn->hbfail_cbfn(ioc->bfa);
1950 bfa_ioc_event_notify(ioc, BFA_IOC_E_FAILED);
1952 bfa_ioc_debug_save_ftrc(ioc);
1954 BFA_LOG(KERN_CRIT, bfad, bfa_log_level,
1955 "Heart Beat of IOC has failed\n");
1956 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_HBFAIL);
1961 bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc)
1963 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
1965 * Provide enable completion callback.
1967 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
1968 BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
1969 "Running firmware version is incompatible "
1970 "with the driver version\n");
1971 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_FWMISMATCH);
1975 bfa_ioc_pll_init(struct bfa_ioc_s *ioc)
1979 * Hold semaphore so that nobody can access the chip during init.
1981 bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg);
1983 bfa_ioc_pll_init_asic(ioc);
1985 ioc->pllinit = BFA_TRUE;
1990 bfa_ioc_lmem_init(ioc);
1993 * release semaphore.
1995 readl(ioc->ioc_regs.ioc_init_sem_reg);
1996 writel(1, ioc->ioc_regs.ioc_init_sem_reg);
1998 return BFA_STATUS_OK;
2002 * Interface used by diag module to do firmware boot with memory test
2003 * as the entry vector.
2006 bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type, u32 boot_env)
2008 bfa_ioc_stats(ioc, ioc_boots);
2010 if (bfa_ioc_pll_init(ioc) != BFA_STATUS_OK)
2014 * Initialize IOC state of all functions on a chip reset.
2016 if (boot_type == BFI_FWBOOT_TYPE_MEMTEST) {
2017 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_MEMTEST);
2018 bfa_ioc_set_alt_ioc_fwstate(ioc, BFI_IOC_MEMTEST);
2020 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_INITING);
2021 bfa_ioc_set_alt_ioc_fwstate(ioc, BFI_IOC_INITING);
2024 bfa_ioc_msgflush(ioc);
2025 bfa_ioc_download_fw(ioc, boot_type, boot_env);
2026 bfa_ioc_lpu_start(ioc);
2030 * Enable/disable IOC failure auto recovery.
2033 bfa_ioc_auto_recover(bfa_boolean_t auto_recover)
2035 bfa_auto_recover = auto_recover;
2041 bfa_ioc_is_operational(struct bfa_ioc_s *ioc)
2043 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_op);
2047 bfa_ioc_is_initialized(struct bfa_ioc_s *ioc)
2049 u32 r32 = bfa_ioc_get_cur_ioc_fwstate(ioc);
2051 return ((r32 != BFI_IOC_UNINIT) &&
2052 (r32 != BFI_IOC_INITING) &&
2053 (r32 != BFI_IOC_MEMTEST));
2057 bfa_ioc_msgget(struct bfa_ioc_s *ioc, void *mbmsg)
2059 __be32 *msgp = mbmsg;
2063 r32 = readl(ioc->ioc_regs.lpu_mbox_cmd);
2070 for (i = 0; i < (sizeof(union bfi_ioc_i2h_msg_u) / sizeof(u32));
2072 r32 = readl(ioc->ioc_regs.lpu_mbox +
2074 msgp[i] = cpu_to_be32(r32);
2078 * turn off mailbox interrupt by clearing mailbox status
2080 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
2081 readl(ioc->ioc_regs.lpu_mbox_cmd);
2087 bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)
2089 union bfi_ioc_i2h_msg_u *msg;
2090 struct bfa_iocpf_s *iocpf = &ioc->iocpf;
2092 msg = (union bfi_ioc_i2h_msg_u *) m;
2094 bfa_ioc_stats(ioc, ioc_isrs);
2096 switch (msg->mh.msg_id) {
2097 case BFI_IOC_I2H_HBEAT:
2100 case BFI_IOC_I2H_ENABLE_REPLY:
2101 ioc->port_mode = ioc->port_mode_cfg =
2102 (enum bfa_mode_s)msg->fw_event.port_mode;
2103 ioc->ad_cap_bm = msg->fw_event.cap_bm;
2104 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_ENABLE);
2107 case BFI_IOC_I2H_DISABLE_REPLY:
2108 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_DISABLE);
2111 case BFI_IOC_I2H_GETATTR_REPLY:
2112 bfa_ioc_getattr_reply(ioc);
2116 bfa_trc(ioc, msg->mh.msg_id);
2122 * IOC attach time initialization and setup.
2124 * @param[in] ioc memory for IOC
2125 * @param[in] bfa driver instance structure
2128 bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa, struct bfa_ioc_cbfn_s *cbfn,
2129 struct bfa_timer_mod_s *timer_mod)
2133 ioc->timer_mod = timer_mod;
2134 ioc->fcmode = BFA_FALSE;
2135 ioc->pllinit = BFA_FALSE;
2136 ioc->dbg_fwsave_once = BFA_TRUE;
2137 ioc->iocpf.ioc = ioc;
2139 bfa_ioc_mbox_attach(ioc);
2140 INIT_LIST_HEAD(&ioc->notify_q);
2142 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
2143 bfa_fsm_send_event(ioc, IOC_E_RESET);
2147 * Driver detach time IOC cleanup.
2150 bfa_ioc_detach(struct bfa_ioc_s *ioc)
2152 bfa_fsm_send_event(ioc, IOC_E_DETACH);
2153 INIT_LIST_HEAD(&ioc->notify_q);
2157 * Setup IOC PCI properties.
2159 * @param[in] pcidev PCI device information for this IOC
2162 bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
2163 enum bfi_pcifn_class clscode)
2165 ioc->clscode = clscode;
2166 ioc->pcidev = *pcidev;
2169 * Initialize IOC and device personality
2171 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_FC;
2172 ioc->asic_mode = BFI_ASIC_MODE_FC;
2174 switch (pcidev->device_id) {
2175 case BFA_PCI_DEVICE_ID_FC_8G1P:
2176 case BFA_PCI_DEVICE_ID_FC_8G2P:
2177 ioc->asic_gen = BFI_ASIC_GEN_CB;
2178 ioc->fcmode = BFA_TRUE;
2179 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_HBA;
2180 ioc->ad_cap_bm = BFA_CM_HBA;
2183 case BFA_PCI_DEVICE_ID_CT:
2184 ioc->asic_gen = BFI_ASIC_GEN_CT;
2185 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_ETH;
2186 ioc->asic_mode = BFI_ASIC_MODE_ETH;
2187 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_CNA;
2188 ioc->ad_cap_bm = BFA_CM_CNA;
2191 case BFA_PCI_DEVICE_ID_CT_FC:
2192 ioc->asic_gen = BFI_ASIC_GEN_CT;
2193 ioc->fcmode = BFA_TRUE;
2194 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_HBA;
2195 ioc->ad_cap_bm = BFA_CM_HBA;
2198 case BFA_PCI_DEVICE_ID_CT2:
2199 case BFA_PCI_DEVICE_ID_CT2_QUAD:
2200 ioc->asic_gen = BFI_ASIC_GEN_CT2;
2201 if (clscode == BFI_PCIFN_CLASS_FC &&
2202 pcidev->ssid == BFA_PCI_CT2_SSID_FC) {
2203 ioc->asic_mode = BFI_ASIC_MODE_FC16;
2204 ioc->fcmode = BFA_TRUE;
2205 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_HBA;
2206 ioc->ad_cap_bm = BFA_CM_HBA;
2208 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_ETH;
2209 ioc->asic_mode = BFI_ASIC_MODE_ETH;
2210 if (pcidev->ssid == BFA_PCI_CT2_SSID_FCoE) {
2212 ioc->port_mode_cfg = BFA_MODE_CNA;
2213 ioc->ad_cap_bm = BFA_CM_CNA;
2216 ioc->port_mode_cfg = BFA_MODE_NIC;
2217 ioc->ad_cap_bm = BFA_CM_NIC;
2227 * Set asic specific interfaces. See bfa_ioc_cb.c and bfa_ioc_ct.c
2229 if (ioc->asic_gen == BFI_ASIC_GEN_CB)
2230 bfa_ioc_set_cb_hwif(ioc);
2231 else if (ioc->asic_gen == BFI_ASIC_GEN_CT)
2232 bfa_ioc_set_ct_hwif(ioc);
2234 WARN_ON(ioc->asic_gen != BFI_ASIC_GEN_CT2);
2235 bfa_ioc_set_ct2_hwif(ioc);
2236 bfa_ioc_ct2_poweron(ioc);
2239 bfa_ioc_map_port(ioc);
2240 bfa_ioc_reg_init(ioc);
2244 * Initialize IOC dma memory
2246 * @param[in] dm_kva kernel virtual address of IOC dma memory
2247 * @param[in] dm_pa physical address of IOC dma memory
2250 bfa_ioc_mem_claim(struct bfa_ioc_s *ioc, u8 *dm_kva, u64 dm_pa)
2253 * dma memory for firmware attribute
2255 ioc->attr_dma.kva = dm_kva;
2256 ioc->attr_dma.pa = dm_pa;
2257 ioc->attr = (struct bfi_ioc_attr_s *) dm_kva;
2261 bfa_ioc_enable(struct bfa_ioc_s *ioc)
2263 bfa_ioc_stats(ioc, ioc_enables);
2264 ioc->dbg_fwsave_once = BFA_TRUE;
2266 bfa_fsm_send_event(ioc, IOC_E_ENABLE);
2270 bfa_ioc_disable(struct bfa_ioc_s *ioc)
2272 bfa_ioc_stats(ioc, ioc_disables);
2273 bfa_fsm_send_event(ioc, IOC_E_DISABLE);
2277 bfa_ioc_suspend(struct bfa_ioc_s *ioc)
2279 ioc->dbg_fwsave_once = BFA_TRUE;
2280 bfa_fsm_send_event(ioc, IOC_E_HWERROR);
2284 * Initialize memory for saving firmware trace. Driver must initialize
2285 * trace memory before call bfa_ioc_enable().
2288 bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
2290 ioc->dbg_fwsave = dbg_fwsave;
2291 ioc->dbg_fwsave_len = BFA_DBG_FWTRC_LEN;
2295 * Register mailbox message handler functions
2297 * @param[in] ioc IOC instance
2298 * @param[in] mcfuncs message class handler functions
2301 bfa_ioc_mbox_register(struct bfa_ioc_s *ioc, bfa_ioc_mbox_mcfunc_t *mcfuncs)
2303 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2306 for (mc = 0; mc < BFI_MC_MAX; mc++)
2307 mod->mbhdlr[mc].cbfn = mcfuncs[mc];
2311 * Register mailbox message handler function, to be called by common modules
2314 bfa_ioc_mbox_regisr(struct bfa_ioc_s *ioc, enum bfi_mclass mc,
2315 bfa_ioc_mbox_mcfunc_t cbfn, void *cbarg)
2317 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2319 mod->mbhdlr[mc].cbfn = cbfn;
2320 mod->mbhdlr[mc].cbarg = cbarg;
2324 * Queue a mailbox command request to firmware. Waits if mailbox is busy.
2325 * Responsibility of caller to serialize
2327 * @param[in] ioc IOC instance
2328 * @param[i] cmd Mailbox command
2331 bfa_ioc_mbox_queue(struct bfa_ioc_s *ioc, struct bfa_mbox_cmd_s *cmd)
2333 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2337 * If a previous command is pending, queue new command
2339 if (!list_empty(&mod->cmd_q)) {
2340 list_add_tail(&cmd->qe, &mod->cmd_q);
2345 * If mailbox is busy, queue command for poll timer
2347 stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
2349 list_add_tail(&cmd->qe, &mod->cmd_q);
2354 * mailbox is free -- queue command to firmware
2356 bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
2360 * Handle mailbox interrupts
2363 bfa_ioc_mbox_isr(struct bfa_ioc_s *ioc)
2365 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2366 struct bfi_mbmsg_s m;
2369 if (bfa_ioc_msgget(ioc, &m)) {
2371 * Treat IOC message class as special.
2373 mc = m.mh.msg_class;
2374 if (mc == BFI_MC_IOC) {
2375 bfa_ioc_isr(ioc, &m);
2379 if ((mc >= BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL))
2382 mod->mbhdlr[mc].cbfn(mod->mbhdlr[mc].cbarg, &m);
2385 bfa_ioc_lpu_read_stat(ioc);
2388 * Try to send pending mailbox commands
2390 bfa_ioc_mbox_poll(ioc);
2394 bfa_ioc_error_isr(struct bfa_ioc_s *ioc)
2396 bfa_ioc_stats(ioc, ioc_hbfails);
2397 ioc->stats.hb_count = ioc->hb_count;
2398 bfa_fsm_send_event(ioc, IOC_E_HWERROR);
2402 * return true if IOC is disabled
2405 bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
2407 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling) ||
2408 bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
2412 * return true if IOC firmware is different.
2415 bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc)
2417 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset) ||
2418 bfa_fsm_cmp_state(&ioc->iocpf, bfa_iocpf_sm_fwcheck) ||
2419 bfa_fsm_cmp_state(&ioc->iocpf, bfa_iocpf_sm_mismatch);
2422 #define bfa_ioc_state_disabled(__sm) \
2423 (((__sm) == BFI_IOC_UNINIT) || \
2424 ((__sm) == BFI_IOC_INITING) || \
2425 ((__sm) == BFI_IOC_HWINIT) || \
2426 ((__sm) == BFI_IOC_DISABLED) || \
2427 ((__sm) == BFI_IOC_FAIL) || \
2428 ((__sm) == BFI_IOC_CFG_DISABLED))
2431 * Check if adapter is disabled -- both IOCs should be in a disabled
2435 bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc)
2439 if (!bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled))
2442 ioc_state = bfa_ioc_get_cur_ioc_fwstate(ioc);
2443 if (!bfa_ioc_state_disabled(ioc_state))
2446 if (ioc->pcidev.device_id != BFA_PCI_DEVICE_ID_FC_8G1P) {
2447 ioc_state = bfa_ioc_get_cur_ioc_fwstate(ioc);
2448 if (!bfa_ioc_state_disabled(ioc_state))
2456 * Reset IOC fwstate registers.
2459 bfa_ioc_reset_fwstate(struct bfa_ioc_s *ioc)
2461 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_UNINIT);
2462 bfa_ioc_set_alt_ioc_fwstate(ioc, BFI_IOC_UNINIT);
2465 #define BFA_MFG_NAME "Brocade"
2467 bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
2468 struct bfa_adapter_attr_s *ad_attr)
2470 struct bfi_ioc_attr_s *ioc_attr;
2472 ioc_attr = ioc->attr;
2474 bfa_ioc_get_adapter_serial_num(ioc, ad_attr->serial_num);
2475 bfa_ioc_get_adapter_fw_ver(ioc, ad_attr->fw_ver);
2476 bfa_ioc_get_adapter_optrom_ver(ioc, ad_attr->optrom_ver);
2477 bfa_ioc_get_adapter_manufacturer(ioc, ad_attr->manufacturer);
2478 memcpy(&ad_attr->vpd, &ioc_attr->vpd,
2479 sizeof(struct bfa_mfg_vpd_s));
2481 ad_attr->nports = bfa_ioc_get_nports(ioc);
2482 ad_attr->max_speed = bfa_ioc_speed_sup(ioc);
2484 bfa_ioc_get_adapter_model(ioc, ad_attr->model);
2485 /* For now, model descr uses same model string */
2486 bfa_ioc_get_adapter_model(ioc, ad_attr->model_descr);
2488 ad_attr->card_type = ioc_attr->card_type;
2489 ad_attr->is_mezz = bfa_mfg_is_mezz(ioc_attr->card_type);
2491 if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))
2492 ad_attr->prototype = 1;
2494 ad_attr->prototype = 0;
2496 ad_attr->pwwn = ioc->attr->pwwn;
2497 ad_attr->mac = bfa_ioc_get_mac(ioc);
2499 ad_attr->pcie_gen = ioc_attr->pcie_gen;
2500 ad_attr->pcie_lanes = ioc_attr->pcie_lanes;
2501 ad_attr->pcie_lanes_orig = ioc_attr->pcie_lanes_orig;
2502 ad_attr->asic_rev = ioc_attr->asic_rev;
2504 bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);
2506 ad_attr->cna_capable = bfa_ioc_is_cna(ioc);
2507 ad_attr->trunk_capable = (ad_attr->nports > 1) &&
2508 !bfa_ioc_is_cna(ioc) && !ad_attr->is_mezz;
2509 ad_attr->mfg_day = ioc_attr->mfg_day;
2510 ad_attr->mfg_month = ioc_attr->mfg_month;
2511 ad_attr->mfg_year = ioc_attr->mfg_year;
2512 memcpy(ad_attr->uuid, ioc_attr->uuid, BFA_ADAPTER_UUID_LEN);
2516 bfa_ioc_get_type(struct bfa_ioc_s *ioc)
2518 if (ioc->clscode == BFI_PCIFN_CLASS_ETH)
2519 return BFA_IOC_TYPE_LL;
2521 WARN_ON(ioc->clscode != BFI_PCIFN_CLASS_FC);
2523 return (ioc->attr->port_mode == BFI_PORT_MODE_FC)
2524 ? BFA_IOC_TYPE_FC : BFA_IOC_TYPE_FCoE;
2528 bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num)
2530 memset((void *)serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);
2531 memcpy((void *)serial_num,
2532 (void *)ioc->attr->brcd_serialnum,
2533 BFA_ADAPTER_SERIAL_NUM_LEN);
2537 bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver)
2539 memset((void *)fw_ver, 0, BFA_VERSION_LEN);
2540 memcpy(fw_ver, ioc->attr->fw_version, BFA_VERSION_LEN);
2544 bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev)
2548 memset((void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);
2554 chip_rev[4] = ioc->attr->asic_rev;
2559 bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver)
2561 memset((void *)optrom_ver, 0, BFA_VERSION_LEN);
2562 memcpy(optrom_ver, ioc->attr->optrom_version,
2567 bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc, char *manufacturer)
2569 memset((void *)manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);
2570 memcpy(manufacturer, BFA_MFG_NAME, BFA_ADAPTER_MFG_NAME_LEN);
2574 bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model)
2576 struct bfi_ioc_attr_s *ioc_attr;
2577 u8 nports = bfa_ioc_get_nports(ioc);
2580 memset((void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);
2582 ioc_attr = ioc->attr;
2584 if (bfa_asic_id_ct2(ioc->pcidev.device_id) &&
2585 (!bfa_mfg_is_mezz(ioc_attr->card_type)))
2586 snprintf(model, BFA_ADAPTER_MODEL_NAME_LEN, "%s-%u-%u%s",
2587 BFA_MFG_NAME, ioc_attr->card_type, nports, "p");
2589 snprintf(model, BFA_ADAPTER_MODEL_NAME_LEN, "%s-%u",
2590 BFA_MFG_NAME, ioc_attr->card_type);
2594 bfa_ioc_get_state(struct bfa_ioc_s *ioc)
2596 enum bfa_iocpf_state iocpf_st;
2597 enum bfa_ioc_state ioc_st = bfa_sm_to_state(ioc_sm_table, ioc->fsm);
2599 if (ioc_st == BFA_IOC_ENABLING ||
2600 ioc_st == BFA_IOC_FAIL || ioc_st == BFA_IOC_INITFAIL) {
2602 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm);
2605 case BFA_IOCPF_SEMWAIT:
2606 ioc_st = BFA_IOC_SEMWAIT;
2609 case BFA_IOCPF_HWINIT:
2610 ioc_st = BFA_IOC_HWINIT;
2613 case BFA_IOCPF_FWMISMATCH:
2614 ioc_st = BFA_IOC_FWMISMATCH;
2617 case BFA_IOCPF_FAIL:
2618 ioc_st = BFA_IOC_FAIL;
2621 case BFA_IOCPF_INITFAIL:
2622 ioc_st = BFA_IOC_INITFAIL;
2634 bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr)
2636 memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr_s));
2638 ioc_attr->state = bfa_ioc_get_state(ioc);
2639 ioc_attr->port_id = bfa_ioc_portid(ioc);
2640 ioc_attr->port_mode = ioc->port_mode;
2641 ioc_attr->port_mode_cfg = ioc->port_mode_cfg;
2642 ioc_attr->cap_bm = ioc->ad_cap_bm;
2644 ioc_attr->ioc_type = bfa_ioc_get_type(ioc);
2646 bfa_ioc_get_adapter_attr(ioc, &ioc_attr->adapter_attr);
2648 ioc_attr->pci_attr.device_id = bfa_ioc_devid(ioc);
2649 ioc_attr->pci_attr.pcifn = bfa_ioc_pcifn(ioc);
2650 ioc_attr->def_fn = (bfa_ioc_pcifn(ioc) == bfa_ioc_portid(ioc));
2651 bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
2655 bfa_ioc_get_mac(struct bfa_ioc_s *ioc)
2658 * Check the IOC type and return the appropriate MAC
2660 if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_FCoE)
2661 return ioc->attr->fcoe_mac;
2663 return ioc->attr->mac;
2667 bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc)
2671 m = ioc->attr->mfg_mac;
2672 if (bfa_mfg_is_old_wwn_mac_model(ioc->attr->card_type))
2673 m.mac[MAC_ADDRLEN - 1] += bfa_ioc_pcifn(ioc);
2675 bfa_mfg_increment_wwn_mac(&(m.mac[MAC_ADDRLEN-3]),
2676 bfa_ioc_pcifn(ioc));
2682 * Send AEN notification
2685 bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event)
2687 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
2688 struct bfa_aen_entry_s *aen_entry;
2689 enum bfa_ioc_type_e ioc_type;
2691 bfad_get_aen_entry(bfad, aen_entry);
2695 ioc_type = bfa_ioc_get_type(ioc);
2697 case BFA_IOC_TYPE_FC:
2698 aen_entry->aen_data.ioc.pwwn = ioc->attr->pwwn;
2700 case BFA_IOC_TYPE_FCoE:
2701 aen_entry->aen_data.ioc.pwwn = ioc->attr->pwwn;
2702 aen_entry->aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
2704 case BFA_IOC_TYPE_LL:
2705 aen_entry->aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
2708 WARN_ON(ioc_type != BFA_IOC_TYPE_FC);
2712 /* Send the AEN notification */
2713 aen_entry->aen_data.ioc.ioc_type = ioc_type;
2714 bfad_im_post_vendor_event(aen_entry, bfad, ++ioc->ioc_aen_seq,
2715 BFA_AEN_CAT_IOC, event);
2719 * Retrieve saved firmware trace from a prior IOC failure.
2722 bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
2726 if (ioc->dbg_fwsave_len == 0)
2727 return BFA_STATUS_ENOFSAVE;
2730 if (tlen > ioc->dbg_fwsave_len)
2731 tlen = ioc->dbg_fwsave_len;
2733 memcpy(trcdata, ioc->dbg_fwsave, tlen);
2735 return BFA_STATUS_OK;
2740 * Retrieve saved firmware trace from a prior IOC failure.
2743 bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
2745 u32 loff = BFA_DBG_FWTRC_OFF(bfa_ioc_portid(ioc));
2747 bfa_status_t status;
2749 bfa_trc(ioc, *trclen);
2752 if (tlen > BFA_DBG_FWTRC_LEN)
2753 tlen = BFA_DBG_FWTRC_LEN;
2755 status = bfa_ioc_smem_read(ioc, trcdata, loff, tlen);
2761 bfa_ioc_send_fwsync(struct bfa_ioc_s *ioc)
2763 struct bfa_mbox_cmd_s cmd;
2764 struct bfi_ioc_ctrl_req_s *req = (struct bfi_ioc_ctrl_req_s *) cmd.msg;
2766 bfi_h2i_set(req->mh, BFI_MC_IOC, BFI_IOC_H2I_DBG_SYNC,
2767 bfa_ioc_portid(ioc));
2768 req->clscode = cpu_to_be16(ioc->clscode);
2769 bfa_ioc_mbox_queue(ioc, &cmd);
2773 bfa_ioc_fwsync(struct bfa_ioc_s *ioc)
2775 u32 fwsync_iter = 1000;
2777 bfa_ioc_send_fwsync(ioc);
2780 * After sending a fw sync mbox command wait for it to
2781 * take effect. We will not wait for a response because
2782 * 1. fw_sync mbox cmd doesn't have a response.
2783 * 2. Even if we implement that, interrupts might not
2784 * be enabled when we call this function.
2785 * So, just keep checking if any mbox cmd is pending, and
2786 * after waiting for a reasonable amount of time, go ahead.
2787 * It is possible that fw has crashed and the mbox command
2788 * is never acknowledged.
2790 while (bfa_ioc_mbox_cmd_pending(ioc) && fwsync_iter > 0)
2795 * Dump firmware smem
2798 bfa_ioc_debug_fwcore(struct bfa_ioc_s *ioc, void *buf,
2799 u32 *offset, int *buflen)
2803 bfa_status_t status;
2804 u32 smem_len = BFA_IOC_FW_SMEM_SIZE(ioc);
2806 if (*offset >= smem_len) {
2807 *offset = *buflen = 0;
2808 return BFA_STATUS_EINVAL;
2815 * First smem read, sync smem before proceeding
2816 * No need to sync before reading every chunk.
2819 bfa_ioc_fwsync(ioc);
2821 if ((loff + dlen) >= smem_len)
2822 dlen = smem_len - loff;
2824 status = bfa_ioc_smem_read(ioc, buf, loff, dlen);
2826 if (status != BFA_STATUS_OK) {
2827 *offset = *buflen = 0;
2833 if (*offset >= smem_len)
2842 * Firmware statistics
2845 bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats)
2847 u32 loff = BFI_IOC_FWSTATS_OFF + \
2848 BFI_IOC_FWSTATS_SZ * (bfa_ioc_portid(ioc));
2850 bfa_status_t status;
2852 if (ioc->stats_busy) {
2853 bfa_trc(ioc, ioc->stats_busy);
2854 return BFA_STATUS_DEVBUSY;
2856 ioc->stats_busy = BFA_TRUE;
2858 tlen = sizeof(struct bfa_fw_stats_s);
2859 status = bfa_ioc_smem_read(ioc, stats, loff, tlen);
2861 ioc->stats_busy = BFA_FALSE;
2866 bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc)
2868 u32 loff = BFI_IOC_FWSTATS_OFF + \
2869 BFI_IOC_FWSTATS_SZ * (bfa_ioc_portid(ioc));
2871 bfa_status_t status;
2873 if (ioc->stats_busy) {
2874 bfa_trc(ioc, ioc->stats_busy);
2875 return BFA_STATUS_DEVBUSY;
2877 ioc->stats_busy = BFA_TRUE;
2879 tlen = sizeof(struct bfa_fw_stats_s);
2880 status = bfa_ioc_smem_clr(ioc, loff, tlen);
2882 ioc->stats_busy = BFA_FALSE;
2887 * Save firmware trace if configured.
2890 bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc)
2894 if (ioc->dbg_fwsave_once) {
2895 ioc->dbg_fwsave_once = BFA_FALSE;
2896 if (ioc->dbg_fwsave_len) {
2897 tlen = ioc->dbg_fwsave_len;
2898 bfa_ioc_debug_fwtrc(ioc, ioc->dbg_fwsave, &tlen);
2904 * Firmware failure detected. Start recovery actions.
2907 bfa_ioc_recover(struct bfa_ioc_s *ioc)
2909 bfa_ioc_stats(ioc, ioc_hbfails);
2910 ioc->stats.hb_count = ioc->hb_count;
2911 bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
2915 * BFA IOC PF private functions
2918 bfa_iocpf_timeout(void *ioc_arg)
2920 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
2923 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_TIMEOUT);
2927 bfa_iocpf_sem_timeout(void *ioc_arg)
2929 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
2931 bfa_ioc_hw_sem_get(ioc);
2935 bfa_ioc_poll_fwinit(struct bfa_ioc_s *ioc)
2937 u32 fwstate = bfa_ioc_get_cur_ioc_fwstate(ioc);
2939 bfa_trc(ioc, fwstate);
2941 if (fwstate == BFI_IOC_DISABLED) {
2942 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FWREADY);
2946 if (ioc->iocpf.poll_time >= (3 * BFA_IOC_TOV))
2947 bfa_iocpf_timeout(ioc);
2949 ioc->iocpf.poll_time += BFA_IOC_POLL_TOV;
2950 bfa_iocpf_poll_timer_start(ioc);
2955 bfa_iocpf_poll_timeout(void *ioc_arg)
2957 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
2959 bfa_ioc_poll_fwinit(ioc);
2963 * bfa timer function
2966 bfa_timer_beat(struct bfa_timer_mod_s *mod)
2968 struct list_head *qh = &mod->timer_q;
2969 struct list_head *qe, *qe_next;
2970 struct bfa_timer_s *elem;
2971 struct list_head timedout_q;
2973 INIT_LIST_HEAD(&timedout_q);
2975 qe = bfa_q_next(qh);
2978 qe_next = bfa_q_next(qe);
2980 elem = (struct bfa_timer_s *) qe;
2981 if (elem->timeout <= BFA_TIMER_FREQ) {
2983 list_del(&elem->qe);
2984 list_add_tail(&elem->qe, &timedout_q);
2986 elem->timeout -= BFA_TIMER_FREQ;
2989 qe = qe_next; /* go to next elem */
2993 * Pop all the timeout entries
2995 while (!list_empty(&timedout_q)) {
2996 bfa_q_deq(&timedout_q, &elem);
2997 elem->timercb(elem->arg);
3002 * Should be called with lock protection
3005 bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer,
3006 void (*timercb) (void *), void *arg, unsigned int timeout)
3009 WARN_ON(timercb == NULL);
3010 WARN_ON(bfa_q_is_on_q(&mod->timer_q, timer));
3012 timer->timeout = timeout;
3013 timer->timercb = timercb;
3016 list_add_tail(&timer->qe, &mod->timer_q);
3020 * Should be called with lock protection
3023 bfa_timer_stop(struct bfa_timer_s *timer)
3025 WARN_ON(list_empty(&timer->qe));
3027 list_del(&timer->qe);
3031 * ASIC block related
3034 bfa_ablk_config_swap(struct bfa_ablk_cfg_s *cfg)
3036 struct bfa_ablk_cfg_inst_s *cfg_inst;
3040 for (i = 0; i < BFA_ABLK_MAX; i++) {
3041 cfg_inst = &cfg->inst[i];
3042 for (j = 0; j < BFA_ABLK_MAX_PFS; j++) {
3043 be16 = cfg_inst->pf_cfg[j].pers;
3044 cfg_inst->pf_cfg[j].pers = be16_to_cpu(be16);
3045 be16 = cfg_inst->pf_cfg[j].num_qpairs;
3046 cfg_inst->pf_cfg[j].num_qpairs = be16_to_cpu(be16);
3047 be16 = cfg_inst->pf_cfg[j].num_vectors;
3048 cfg_inst->pf_cfg[j].num_vectors = be16_to_cpu(be16);
3049 be16 = cfg_inst->pf_cfg[j].bw_min;
3050 cfg_inst->pf_cfg[j].bw_min = be16_to_cpu(be16);
3051 be16 = cfg_inst->pf_cfg[j].bw_max;
3052 cfg_inst->pf_cfg[j].bw_max = be16_to_cpu(be16);
3058 bfa_ablk_isr(void *cbarg, struct bfi_mbmsg_s *msg)
3060 struct bfa_ablk_s *ablk = (struct bfa_ablk_s *)cbarg;
3061 struct bfi_ablk_i2h_rsp_s *rsp = (struct bfi_ablk_i2h_rsp_s *)msg;
3062 bfa_ablk_cbfn_t cbfn;
3064 WARN_ON(msg->mh.msg_class != BFI_MC_ABLK);
3065 bfa_trc(ablk->ioc, msg->mh.msg_id);
3067 switch (msg->mh.msg_id) {
3068 case BFI_ABLK_I2H_QUERY:
3069 if (rsp->status == BFA_STATUS_OK) {
3070 memcpy(ablk->cfg, ablk->dma_addr.kva,
3071 sizeof(struct bfa_ablk_cfg_s));
3072 bfa_ablk_config_swap(ablk->cfg);
3077 case BFI_ABLK_I2H_ADPT_CONFIG:
3078 case BFI_ABLK_I2H_PORT_CONFIG:
3079 /* update config port mode */
3080 ablk->ioc->port_mode_cfg = rsp->port_mode;
3082 case BFI_ABLK_I2H_PF_DELETE:
3083 case BFI_ABLK_I2H_PF_UPDATE:
3084 case BFI_ABLK_I2H_OPTROM_ENABLE:
3085 case BFI_ABLK_I2H_OPTROM_DISABLE:
3089 case BFI_ABLK_I2H_PF_CREATE:
3090 *(ablk->pcifn) = rsp->pcifn;
3098 ablk->busy = BFA_FALSE;
3102 cbfn(ablk->cbarg, rsp->status);
3107 bfa_ablk_notify(void *cbarg, enum bfa_ioc_event_e event)
3109 struct bfa_ablk_s *ablk = (struct bfa_ablk_s *)cbarg;
3111 bfa_trc(ablk->ioc, event);
3114 case BFA_IOC_E_ENABLED:
3115 WARN_ON(ablk->busy != BFA_FALSE);
3118 case BFA_IOC_E_DISABLED:
3119 case BFA_IOC_E_FAILED:
3120 /* Fail any pending requests */
3124 ablk->cbfn(ablk->cbarg, BFA_STATUS_FAILED);
3126 ablk->busy = BFA_FALSE;
3137 bfa_ablk_meminfo(void)
3139 return BFA_ROUNDUP(sizeof(struct bfa_ablk_cfg_s), BFA_DMA_ALIGN_SZ);
3143 bfa_ablk_memclaim(struct bfa_ablk_s *ablk, u8 *dma_kva, u64 dma_pa)
3145 ablk->dma_addr.kva = dma_kva;
3146 ablk->dma_addr.pa = dma_pa;
3150 bfa_ablk_attach(struct bfa_ablk_s *ablk, struct bfa_ioc_s *ioc)
3154 bfa_ioc_mbox_regisr(ablk->ioc, BFI_MC_ABLK, bfa_ablk_isr, ablk);
3155 bfa_q_qe_init(&ablk->ioc_notify);
3156 bfa_ioc_notify_init(&ablk->ioc_notify, bfa_ablk_notify, ablk);
3157 list_add_tail(&ablk->ioc_notify.qe, &ablk->ioc->notify_q);
3161 bfa_ablk_query(struct bfa_ablk_s *ablk, struct bfa_ablk_cfg_s *ablk_cfg,
3162 bfa_ablk_cbfn_t cbfn, void *cbarg)
3164 struct bfi_ablk_h2i_query_s *m;
3168 if (!bfa_ioc_is_operational(ablk->ioc)) {
3169 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3170 return BFA_STATUS_IOC_FAILURE;
3174 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3175 return BFA_STATUS_DEVBUSY;
3178 ablk->cfg = ablk_cfg;
3180 ablk->cbarg = cbarg;
3181 ablk->busy = BFA_TRUE;
3183 m = (struct bfi_ablk_h2i_query_s *)ablk->mb.msg;
3184 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_QUERY,
3185 bfa_ioc_portid(ablk->ioc));
3186 bfa_dma_be_addr_set(m->addr, ablk->dma_addr.pa);
3187 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3189 return BFA_STATUS_OK;
3193 bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn,
3194 u8 port, enum bfi_pcifn_class personality,
3195 u16 bw_min, u16 bw_max,
3196 bfa_ablk_cbfn_t cbfn, void *cbarg)
3198 struct bfi_ablk_h2i_pf_req_s *m;
3200 if (!bfa_ioc_is_operational(ablk->ioc)) {
3201 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3202 return BFA_STATUS_IOC_FAILURE;
3206 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3207 return BFA_STATUS_DEVBUSY;
3210 ablk->pcifn = pcifn;
3212 ablk->cbarg = cbarg;
3213 ablk->busy = BFA_TRUE;
3215 m = (struct bfi_ablk_h2i_pf_req_s *)ablk->mb.msg;
3216 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_CREATE,
3217 bfa_ioc_portid(ablk->ioc));
3218 m->pers = cpu_to_be16((u16)personality);
3219 m->bw_min = cpu_to_be16(bw_min);
3220 m->bw_max = cpu_to_be16(bw_max);
3222 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3224 return BFA_STATUS_OK;
3228 bfa_ablk_pf_delete(struct bfa_ablk_s *ablk, int pcifn,
3229 bfa_ablk_cbfn_t cbfn, void *cbarg)
3231 struct bfi_ablk_h2i_pf_req_s *m;
3233 if (!bfa_ioc_is_operational(ablk->ioc)) {
3234 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3235 return BFA_STATUS_IOC_FAILURE;
3239 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3240 return BFA_STATUS_DEVBUSY;
3244 ablk->cbarg = cbarg;
3245 ablk->busy = BFA_TRUE;
3247 m = (struct bfi_ablk_h2i_pf_req_s *)ablk->mb.msg;
3248 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_DELETE,
3249 bfa_ioc_portid(ablk->ioc));
3250 m->pcifn = (u8)pcifn;
3251 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3253 return BFA_STATUS_OK;
3257 bfa_ablk_adapter_config(struct bfa_ablk_s *ablk, enum bfa_mode_s mode,
3258 int max_pf, int max_vf, bfa_ablk_cbfn_t cbfn, void *cbarg)
3260 struct bfi_ablk_h2i_cfg_req_s *m;
3262 if (!bfa_ioc_is_operational(ablk->ioc)) {
3263 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3264 return BFA_STATUS_IOC_FAILURE;
3268 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3269 return BFA_STATUS_DEVBUSY;
3273 ablk->cbarg = cbarg;
3274 ablk->busy = BFA_TRUE;
3276 m = (struct bfi_ablk_h2i_cfg_req_s *)ablk->mb.msg;
3277 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_ADPT_CONFIG,
3278 bfa_ioc_portid(ablk->ioc));
3280 m->max_pf = (u8)max_pf;
3281 m->max_vf = (u8)max_vf;
3282 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3284 return BFA_STATUS_OK;
3288 bfa_ablk_port_config(struct bfa_ablk_s *ablk, int port, enum bfa_mode_s mode,
3289 int max_pf, int max_vf, bfa_ablk_cbfn_t cbfn, void *cbarg)
3291 struct bfi_ablk_h2i_cfg_req_s *m;
3293 if (!bfa_ioc_is_operational(ablk->ioc)) {
3294 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3295 return BFA_STATUS_IOC_FAILURE;
3299 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3300 return BFA_STATUS_DEVBUSY;
3304 ablk->cbarg = cbarg;
3305 ablk->busy = BFA_TRUE;
3307 m = (struct bfi_ablk_h2i_cfg_req_s *)ablk->mb.msg;
3308 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PORT_CONFIG,
3309 bfa_ioc_portid(ablk->ioc));
3312 m->max_pf = (u8)max_pf;
3313 m->max_vf = (u8)max_vf;
3314 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3316 return BFA_STATUS_OK;
3320 bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, u16 bw_min,
3321 u16 bw_max, bfa_ablk_cbfn_t cbfn, void *cbarg)
3323 struct bfi_ablk_h2i_pf_req_s *m;
3325 if (!bfa_ioc_is_operational(ablk->ioc)) {
3326 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3327 return BFA_STATUS_IOC_FAILURE;
3331 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3332 return BFA_STATUS_DEVBUSY;
3336 ablk->cbarg = cbarg;
3337 ablk->busy = BFA_TRUE;
3339 m = (struct bfi_ablk_h2i_pf_req_s *)ablk->mb.msg;
3340 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_UPDATE,
3341 bfa_ioc_portid(ablk->ioc));
3342 m->pcifn = (u8)pcifn;
3343 m->bw_min = cpu_to_be16(bw_min);
3344 m->bw_max = cpu_to_be16(bw_max);
3345 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3347 return BFA_STATUS_OK;
3351 bfa_ablk_optrom_en(struct bfa_ablk_s *ablk, bfa_ablk_cbfn_t cbfn, void *cbarg)
3353 struct bfi_ablk_h2i_optrom_s *m;
3355 if (!bfa_ioc_is_operational(ablk->ioc)) {
3356 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3357 return BFA_STATUS_IOC_FAILURE;
3361 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3362 return BFA_STATUS_DEVBUSY;
3366 ablk->cbarg = cbarg;
3367 ablk->busy = BFA_TRUE;
3369 m = (struct bfi_ablk_h2i_optrom_s *)ablk->mb.msg;
3370 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_OPTROM_ENABLE,
3371 bfa_ioc_portid(ablk->ioc));
3372 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3374 return BFA_STATUS_OK;
3378 bfa_ablk_optrom_dis(struct bfa_ablk_s *ablk, bfa_ablk_cbfn_t cbfn, void *cbarg)
3380 struct bfi_ablk_h2i_optrom_s *m;
3382 if (!bfa_ioc_is_operational(ablk->ioc)) {
3383 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3384 return BFA_STATUS_IOC_FAILURE;
3388 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3389 return BFA_STATUS_DEVBUSY;
3393 ablk->cbarg = cbarg;
3394 ablk->busy = BFA_TRUE;
3396 m = (struct bfi_ablk_h2i_optrom_s *)ablk->mb.msg;
3397 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_OPTROM_DISABLE,
3398 bfa_ioc_portid(ablk->ioc));
3399 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3401 return BFA_STATUS_OK;
3405 * SFP module specific
3408 /* forward declarations */
3409 static void bfa_sfp_getdata_send(struct bfa_sfp_s *sfp);
3410 static void bfa_sfp_media_get(struct bfa_sfp_s *sfp);
3411 static bfa_status_t bfa_sfp_speed_valid(struct bfa_sfp_s *sfp,
3412 enum bfa_port_speed portspeed);
3415 bfa_cb_sfp_show(struct bfa_sfp_s *sfp)
3417 bfa_trc(sfp, sfp->lock);
3419 sfp->cbfn(sfp->cbarg, sfp->status);
3425 bfa_cb_sfp_state_query(struct bfa_sfp_s *sfp)
3427 bfa_trc(sfp, sfp->portspeed);
3429 bfa_sfp_media_get(sfp);
3430 if (sfp->state_query_cbfn)
3431 sfp->state_query_cbfn(sfp->state_query_cbarg,
3436 if (sfp->portspeed) {
3437 sfp->status = bfa_sfp_speed_valid(sfp, sfp->portspeed);
3438 if (sfp->state_query_cbfn)
3439 sfp->state_query_cbfn(sfp->state_query_cbarg,
3441 sfp->portspeed = BFA_PORT_SPEED_UNKNOWN;
3444 sfp->state_query_lock = 0;
3445 sfp->state_query_cbfn = NULL;
3449 * IOC event handler.
3452 bfa_sfp_notify(void *sfp_arg, enum bfa_ioc_event_e event)
3454 struct bfa_sfp_s *sfp = sfp_arg;
3456 bfa_trc(sfp, event);
3457 bfa_trc(sfp, sfp->lock);
3458 bfa_trc(sfp, sfp->state_query_lock);
3461 case BFA_IOC_E_DISABLED:
3462 case BFA_IOC_E_FAILED:
3464 sfp->status = BFA_STATUS_IOC_FAILURE;
3465 bfa_cb_sfp_show(sfp);
3468 if (sfp->state_query_lock) {
3469 sfp->status = BFA_STATUS_IOC_FAILURE;
3470 bfa_cb_sfp_state_query(sfp);
3480 * SFP's State Change Notification post to AEN
3483 bfa_sfp_scn_aen_post(struct bfa_sfp_s *sfp, struct bfi_sfp_scn_s *rsp)
3485 struct bfad_s *bfad = (struct bfad_s *)sfp->ioc->bfa->bfad;
3486 struct bfa_aen_entry_s *aen_entry;
3487 enum bfa_port_aen_event aen_evt = 0;
3489 bfa_trc(sfp, (((u64)rsp->pomlvl) << 16) | (((u64)rsp->sfpid) << 8) |
3492 bfad_get_aen_entry(bfad, aen_entry);
3496 aen_entry->aen_data.port.ioc_type = bfa_ioc_get_type(sfp->ioc);
3497 aen_entry->aen_data.port.pwwn = sfp->ioc->attr->pwwn;
3498 aen_entry->aen_data.port.mac = bfa_ioc_get_mac(sfp->ioc);
3500 switch (rsp->event) {
3501 case BFA_SFP_SCN_INSERTED:
3502 aen_evt = BFA_PORT_AEN_SFP_INSERT;
3504 case BFA_SFP_SCN_REMOVED:
3505 aen_evt = BFA_PORT_AEN_SFP_REMOVE;
3507 case BFA_SFP_SCN_FAILED:
3508 aen_evt = BFA_PORT_AEN_SFP_ACCESS_ERROR;
3510 case BFA_SFP_SCN_UNSUPPORT:
3511 aen_evt = BFA_PORT_AEN_SFP_UNSUPPORT;
3513 case BFA_SFP_SCN_POM:
3514 aen_evt = BFA_PORT_AEN_SFP_POM;
3515 aen_entry->aen_data.port.level = rsp->pomlvl;
3518 bfa_trc(sfp, rsp->event);
3522 /* Send the AEN notification */
3523 bfad_im_post_vendor_event(aen_entry, bfad, ++sfp->ioc->ioc_aen_seq,
3524 BFA_AEN_CAT_PORT, aen_evt);
3531 bfa_sfp_getdata_send(struct bfa_sfp_s *sfp)
3533 struct bfi_sfp_req_s *req = (struct bfi_sfp_req_s *)sfp->mbcmd.msg;
3535 bfa_trc(sfp, req->memtype);
3537 /* build host command */
3538 bfi_h2i_set(req->mh, BFI_MC_SFP, BFI_SFP_H2I_SHOW,
3539 bfa_ioc_portid(sfp->ioc));
3542 bfa_ioc_mbox_queue(sfp->ioc, &sfp->mbcmd);
3546 * SFP is valid, read sfp data
3549 bfa_sfp_getdata(struct bfa_sfp_s *sfp, enum bfi_sfp_mem_e memtype)
3551 struct bfi_sfp_req_s *req = (struct bfi_sfp_req_s *)sfp->mbcmd.msg;
3553 WARN_ON(sfp->lock != 0);
3554 bfa_trc(sfp, sfp->state);
3557 sfp->memtype = memtype;
3558 req->memtype = memtype;
3561 bfa_alen_set(&req->alen, sizeof(struct sfp_mem_s), sfp->dbuf_pa);
3563 bfa_sfp_getdata_send(sfp);
3570 bfa_sfp_scn(struct bfa_sfp_s *sfp, struct bfi_mbmsg_s *msg)
3572 struct bfi_sfp_scn_s *rsp = (struct bfi_sfp_scn_s *) msg;
3574 switch (rsp->event) {
3575 case BFA_SFP_SCN_INSERTED:
3576 sfp->state = BFA_SFP_STATE_INSERTED;
3577 sfp->data_valid = 0;
3578 bfa_sfp_scn_aen_post(sfp, rsp);
3580 case BFA_SFP_SCN_REMOVED:
3581 sfp->state = BFA_SFP_STATE_REMOVED;
3582 sfp->data_valid = 0;
3583 bfa_sfp_scn_aen_post(sfp, rsp);
3585 case BFA_SFP_SCN_FAILED:
3586 sfp->state = BFA_SFP_STATE_FAILED;
3587 sfp->data_valid = 0;
3588 bfa_sfp_scn_aen_post(sfp, rsp);
3590 case BFA_SFP_SCN_UNSUPPORT:
3591 sfp->state = BFA_SFP_STATE_UNSUPPORT;
3592 bfa_sfp_scn_aen_post(sfp, rsp);
3594 bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
3596 case BFA_SFP_SCN_POM:
3597 bfa_sfp_scn_aen_post(sfp, rsp);
3599 case BFA_SFP_SCN_VALID:
3600 sfp->state = BFA_SFP_STATE_VALID;
3602 bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
3605 bfa_trc(sfp, rsp->event);
3614 bfa_sfp_show_comp(struct bfa_sfp_s *sfp, struct bfi_mbmsg_s *msg)
3616 struct bfi_sfp_rsp_s *rsp = (struct bfi_sfp_rsp_s *) msg;
3620 * receiving response after ioc failure
3622 bfa_trc(sfp, sfp->lock);
3626 bfa_trc(sfp, rsp->status);
3627 if (rsp->status == BFA_STATUS_OK) {
3628 sfp->data_valid = 1;
3629 if (sfp->state == BFA_SFP_STATE_VALID)
3630 sfp->status = BFA_STATUS_OK;
3631 else if (sfp->state == BFA_SFP_STATE_UNSUPPORT)
3632 sfp->status = BFA_STATUS_SFP_UNSUPP;
3634 bfa_trc(sfp, sfp->state);
3636 sfp->data_valid = 0;
3637 sfp->status = rsp->status;
3638 /* sfpshow shouldn't change sfp state */
3641 bfa_trc(sfp, sfp->memtype);
3642 if (sfp->memtype == BFI_SFP_MEM_DIAGEXT) {
3643 bfa_trc(sfp, sfp->data_valid);
3644 if (sfp->data_valid) {
3645 u32 size = sizeof(struct sfp_mem_s);
3646 u8 *des = (u8 *) &(sfp->sfpmem->srlid_base);
3647 memcpy(des, sfp->dbuf_kva, size);
3650 * Queue completion callback.
3652 bfa_cb_sfp_show(sfp);
3656 bfa_trc(sfp, sfp->state_query_lock);
3657 if (sfp->state_query_lock) {
3658 sfp->state = rsp->state;
3659 /* Complete callback */
3660 bfa_cb_sfp_state_query(sfp);
3665 * SFP query fw sfp state
3668 bfa_sfp_state_query(struct bfa_sfp_s *sfp)
3670 struct bfi_sfp_req_s *req = (struct bfi_sfp_req_s *)sfp->mbcmd.msg;
3672 /* Should not be doing query if not in _INIT state */
3673 WARN_ON(sfp->state != BFA_SFP_STATE_INIT);
3674 WARN_ON(sfp->state_query_lock != 0);
3675 bfa_trc(sfp, sfp->state);
3677 sfp->state_query_lock = 1;
3681 bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
3685 bfa_sfp_media_get(struct bfa_sfp_s *sfp)
3687 enum bfa_defs_sfp_media_e *media = sfp->media;
3689 *media = BFA_SFP_MEDIA_UNKNOWN;
3691 if (sfp->state == BFA_SFP_STATE_UNSUPPORT)
3692 *media = BFA_SFP_MEDIA_UNSUPPORT;
3693 else if (sfp->state == BFA_SFP_STATE_VALID) {
3694 union sfp_xcvr_e10g_code_u e10g;
3695 struct sfp_mem_s *sfpmem = (struct sfp_mem_s *)sfp->dbuf_kva;
3696 u16 xmtr_tech = (sfpmem->srlid_base.xcvr[4] & 0x3) << 7 |
3697 (sfpmem->srlid_base.xcvr[5] >> 1);
3699 e10g.b = sfpmem->srlid_base.xcvr[0];
3700 bfa_trc(sfp, e10g.b);
3701 bfa_trc(sfp, xmtr_tech);
3702 /* check fc transmitter tech */
3703 if ((xmtr_tech & SFP_XMTR_TECH_CU) ||
3704 (xmtr_tech & SFP_XMTR_TECH_CP) ||
3705 (xmtr_tech & SFP_XMTR_TECH_CA))
3706 *media = BFA_SFP_MEDIA_CU;
3707 else if ((xmtr_tech & SFP_XMTR_TECH_EL_INTRA) ||
3708 (xmtr_tech & SFP_XMTR_TECH_EL_INTER))
3709 *media = BFA_SFP_MEDIA_EL;
3710 else if ((xmtr_tech & SFP_XMTR_TECH_LL) ||
3711 (xmtr_tech & SFP_XMTR_TECH_LC))
3712 *media = BFA_SFP_MEDIA_LW;
3713 else if ((xmtr_tech & SFP_XMTR_TECH_SL) ||
3714 (xmtr_tech & SFP_XMTR_TECH_SN) ||
3715 (xmtr_tech & SFP_XMTR_TECH_SA))
3716 *media = BFA_SFP_MEDIA_SW;
3717 /* Check 10G Ethernet Compilance code */
3718 else if (e10g.r.e10g_sr)
3719 *media = BFA_SFP_MEDIA_SW;
3720 else if (e10g.r.e10g_lrm && e10g.r.e10g_lr)
3721 *media = BFA_SFP_MEDIA_LW;
3722 else if (e10g.r.e10g_unall)
3723 *media = BFA_SFP_MEDIA_UNKNOWN;
3727 bfa_trc(sfp, sfp->state);
3731 bfa_sfp_speed_valid(struct bfa_sfp_s *sfp, enum bfa_port_speed portspeed)
3733 struct sfp_mem_s *sfpmem = (struct sfp_mem_s *)sfp->dbuf_kva;
3734 struct sfp_xcvr_s *xcvr = (struct sfp_xcvr_s *) sfpmem->srlid_base.xcvr;
3735 union sfp_xcvr_fc3_code_u fc3 = xcvr->fc3;
3736 union sfp_xcvr_e10g_code_u e10g = xcvr->e10g;
3738 if (portspeed == BFA_PORT_SPEED_10GBPS) {
3739 if (e10g.r.e10g_sr || e10g.r.e10g_lr)
3740 return BFA_STATUS_OK;
3742 bfa_trc(sfp, e10g.b);
3743 return BFA_STATUS_UNSUPP_SPEED;
3746 if (((portspeed & BFA_PORT_SPEED_16GBPS) && fc3.r.mb1600) ||
3747 ((portspeed & BFA_PORT_SPEED_8GBPS) && fc3.r.mb800) ||
3748 ((portspeed & BFA_PORT_SPEED_4GBPS) && fc3.r.mb400) ||
3749 ((portspeed & BFA_PORT_SPEED_2GBPS) && fc3.r.mb200) ||
3750 ((portspeed & BFA_PORT_SPEED_1GBPS) && fc3.r.mb100))
3751 return BFA_STATUS_OK;
3753 bfa_trc(sfp, portspeed);
3754 bfa_trc(sfp, fc3.b);
3755 bfa_trc(sfp, e10g.b);
3756 return BFA_STATUS_UNSUPP_SPEED;
3764 bfa_sfp_intr(void *sfparg, struct bfi_mbmsg_s *msg)
3766 struct bfa_sfp_s *sfp = sfparg;
3768 switch (msg->mh.msg_id) {
3769 case BFI_SFP_I2H_SHOW:
3770 bfa_sfp_show_comp(sfp, msg);
3773 case BFI_SFP_I2H_SCN:
3774 bfa_sfp_scn(sfp, msg);
3778 bfa_trc(sfp, msg->mh.msg_id);
3784 * Return DMA memory needed by sfp module.
3787 bfa_sfp_meminfo(void)
3789 return BFA_ROUNDUP(sizeof(struct sfp_mem_s), BFA_DMA_ALIGN_SZ);
3793 * Attach virtual and physical memory for SFP.
3796 bfa_sfp_attach(struct bfa_sfp_s *sfp, struct bfa_ioc_s *ioc, void *dev,
3797 struct bfa_trc_mod_s *trcmod)
3801 sfp->trcmod = trcmod;
3807 sfp->data_valid = 0;
3808 sfp->state = BFA_SFP_STATE_INIT;
3809 sfp->state_query_lock = 0;
3810 sfp->state_query_cbfn = NULL;
3811 sfp->state_query_cbarg = NULL;
3813 sfp->portspeed = BFA_PORT_SPEED_UNKNOWN;
3814 sfp->is_elb = BFA_FALSE;
3816 bfa_ioc_mbox_regisr(sfp->ioc, BFI_MC_SFP, bfa_sfp_intr, sfp);
3817 bfa_q_qe_init(&sfp->ioc_notify);
3818 bfa_ioc_notify_init(&sfp->ioc_notify, bfa_sfp_notify, sfp);
3819 list_add_tail(&sfp->ioc_notify.qe, &sfp->ioc->notify_q);
3823 * Claim Memory for SFP
3826 bfa_sfp_memclaim(struct bfa_sfp_s *sfp, u8 *dm_kva, u64 dm_pa)
3828 sfp->dbuf_kva = dm_kva;
3829 sfp->dbuf_pa = dm_pa;
3830 memset(sfp->dbuf_kva, 0, sizeof(struct sfp_mem_s));
3832 dm_kva += BFA_ROUNDUP(sizeof(struct sfp_mem_s), BFA_DMA_ALIGN_SZ);
3833 dm_pa += BFA_ROUNDUP(sizeof(struct sfp_mem_s), BFA_DMA_ALIGN_SZ);
3837 * Show SFP eeprom content
3839 * @param[in] sfp - bfa sfp module
3841 * @param[out] sfpmem - sfp eeprom data
3845 bfa_sfp_show(struct bfa_sfp_s *sfp, struct sfp_mem_s *sfpmem,
3846 bfa_cb_sfp_t cbfn, void *cbarg)
3849 if (!bfa_ioc_is_operational(sfp->ioc)) {
3851 return BFA_STATUS_IOC_NON_OP;
3856 return BFA_STATUS_DEVBUSY;
3861 sfp->sfpmem = sfpmem;
3863 bfa_sfp_getdata(sfp, BFI_SFP_MEM_DIAGEXT);
3864 return BFA_STATUS_OK;
3868 * Return SFP Media type
3870 * @param[in] sfp - bfa sfp module
3872 * @param[out] media - port speed from user
3876 bfa_sfp_media(struct bfa_sfp_s *sfp, enum bfa_defs_sfp_media_e *media,
3877 bfa_cb_sfp_t cbfn, void *cbarg)
3879 if (!bfa_ioc_is_operational(sfp->ioc)) {
3881 return BFA_STATUS_IOC_NON_OP;
3885 if (sfp->state == BFA_SFP_STATE_INIT) {
3886 if (sfp->state_query_lock) {
3888 return BFA_STATUS_DEVBUSY;
3890 sfp->state_query_cbfn = cbfn;
3891 sfp->state_query_cbarg = cbarg;
3892 bfa_sfp_state_query(sfp);
3893 return BFA_STATUS_SFP_NOT_READY;
3897 bfa_sfp_media_get(sfp);
3898 return BFA_STATUS_OK;
3902 * Check if user set port speed is allowed by the SFP
3904 * @param[in] sfp - bfa sfp module
3905 * @param[in] portspeed - port speed from user
3909 bfa_sfp_speed(struct bfa_sfp_s *sfp, enum bfa_port_speed portspeed,
3910 bfa_cb_sfp_t cbfn, void *cbarg)
3912 WARN_ON(portspeed == BFA_PORT_SPEED_UNKNOWN);
3914 if (!bfa_ioc_is_operational(sfp->ioc))
3915 return BFA_STATUS_IOC_NON_OP;
3917 /* For Mezz card, all speed is allowed */
3918 if (bfa_mfg_is_mezz(sfp->ioc->attr->card_type))
3919 return BFA_STATUS_OK;
3921 /* Check SFP state */
3922 sfp->portspeed = portspeed;
3923 if (sfp->state == BFA_SFP_STATE_INIT) {
3924 if (sfp->state_query_lock) {
3926 return BFA_STATUS_DEVBUSY;
3928 sfp->state_query_cbfn = cbfn;
3929 sfp->state_query_cbarg = cbarg;
3930 bfa_sfp_state_query(sfp);
3931 return BFA_STATUS_SFP_NOT_READY;
3935 if (sfp->state == BFA_SFP_STATE_REMOVED ||
3936 sfp->state == BFA_SFP_STATE_FAILED) {
3937 bfa_trc(sfp, sfp->state);
3938 return BFA_STATUS_NO_SFP_DEV;
3941 if (sfp->state == BFA_SFP_STATE_INSERTED) {
3942 bfa_trc(sfp, sfp->state);
3943 return BFA_STATUS_DEVBUSY; /* sfp is reading data */
3946 /* For eloopback, all speed is allowed */
3948 return BFA_STATUS_OK;
3950 return bfa_sfp_speed_valid(sfp, portspeed);
3954 * Flash module specific
3958 * FLASH DMA buffer should be big enough to hold both MFG block and
3959 * asic block(64k) at the same time and also should be 2k aligned to
3960 * avoid write segement to cross sector boundary.
3962 #define BFA_FLASH_SEG_SZ 2048
3963 #define BFA_FLASH_DMA_BUF_SZ \
3964 BFA_ROUNDUP(0x010000 + sizeof(struct bfa_mfg_block_s), BFA_FLASH_SEG_SZ)
3967 bfa_flash_aen_audit_post(struct bfa_ioc_s *ioc, enum bfa_audit_aen_event event,
3970 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
3971 struct bfa_aen_entry_s *aen_entry;
3973 bfad_get_aen_entry(bfad, aen_entry);
3977 aen_entry->aen_data.audit.pwwn = ioc->attr->pwwn;
3978 aen_entry->aen_data.audit.partition_inst = inst;
3979 aen_entry->aen_data.audit.partition_type = type;
3981 /* Send the AEN notification */
3982 bfad_im_post_vendor_event(aen_entry, bfad, ++ioc->ioc_aen_seq,
3983 BFA_AEN_CAT_AUDIT, event);
3987 bfa_flash_cb(struct bfa_flash_s *flash)
3991 flash->cbfn(flash->cbarg, flash->status);
3995 bfa_flash_notify(void *cbarg, enum bfa_ioc_event_e event)
3997 struct bfa_flash_s *flash = cbarg;
3999 bfa_trc(flash, event);
4001 case BFA_IOC_E_DISABLED:
4002 case BFA_IOC_E_FAILED:
4003 if (flash->op_busy) {
4004 flash->status = BFA_STATUS_IOC_FAILURE;
4005 flash->cbfn(flash->cbarg, flash->status);
4016 * Send flash attribute query request.
4018 * @param[in] cbarg - callback argument
4021 bfa_flash_query_send(void *cbarg)
4023 struct bfa_flash_s *flash = cbarg;
4024 struct bfi_flash_query_req_s *msg =
4025 (struct bfi_flash_query_req_s *) flash->mb.msg;
4027 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_QUERY_REQ,
4028 bfa_ioc_portid(flash->ioc));
4029 bfa_alen_set(&msg->alen, sizeof(struct bfa_flash_attr_s),
4031 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4035 * Send flash write request.
4037 * @param[in] cbarg - callback argument
4040 bfa_flash_write_send(struct bfa_flash_s *flash)
4042 struct bfi_flash_write_req_s *msg =
4043 (struct bfi_flash_write_req_s *) flash->mb.msg;
4046 msg->type = be32_to_cpu(flash->type);
4047 msg->instance = flash->instance;
4048 msg->offset = be32_to_cpu(flash->addr_off + flash->offset);
4049 len = (flash->residue < BFA_FLASH_DMA_BUF_SZ) ?
4050 flash->residue : BFA_FLASH_DMA_BUF_SZ;
4051 msg->length = be32_to_cpu(len);
4053 /* indicate if it's the last msg of the whole write operation */
4054 msg->last = (len == flash->residue) ? 1 : 0;
4056 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_WRITE_REQ,
4057 bfa_ioc_portid(flash->ioc));
4058 bfa_alen_set(&msg->alen, len, flash->dbuf_pa);
4059 memcpy(flash->dbuf_kva, flash->ubuf + flash->offset, len);
4060 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4062 flash->residue -= len;
4063 flash->offset += len;
4067 * Send flash read request.
4069 * @param[in] cbarg - callback argument
4072 bfa_flash_read_send(void *cbarg)
4074 struct bfa_flash_s *flash = cbarg;
4075 struct bfi_flash_read_req_s *msg =
4076 (struct bfi_flash_read_req_s *) flash->mb.msg;
4079 msg->type = be32_to_cpu(flash->type);
4080 msg->instance = flash->instance;
4081 msg->offset = be32_to_cpu(flash->addr_off + flash->offset);
4082 len = (flash->residue < BFA_FLASH_DMA_BUF_SZ) ?
4083 flash->residue : BFA_FLASH_DMA_BUF_SZ;
4084 msg->length = be32_to_cpu(len);
4085 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_READ_REQ,
4086 bfa_ioc_portid(flash->ioc));
4087 bfa_alen_set(&msg->alen, len, flash->dbuf_pa);
4088 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4092 * Send flash erase request.
4094 * @param[in] cbarg - callback argument
4097 bfa_flash_erase_send(void *cbarg)
4099 struct bfa_flash_s *flash = cbarg;
4100 struct bfi_flash_erase_req_s *msg =
4101 (struct bfi_flash_erase_req_s *) flash->mb.msg;
4103 msg->type = be32_to_cpu(flash->type);
4104 msg->instance = flash->instance;
4105 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_ERASE_REQ,
4106 bfa_ioc_portid(flash->ioc));
4107 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4111 * Process flash response messages upon receiving interrupts.
4113 * @param[in] flasharg - flash structure
4114 * @param[in] msg - message structure
4117 bfa_flash_intr(void *flasharg, struct bfi_mbmsg_s *msg)
4119 struct bfa_flash_s *flash = flasharg;
4123 struct bfi_flash_query_rsp_s *query;
4124 struct bfi_flash_erase_rsp_s *erase;
4125 struct bfi_flash_write_rsp_s *write;
4126 struct bfi_flash_read_rsp_s *read;
4127 struct bfi_flash_event_s *event;
4128 struct bfi_mbmsg_s *msg;
4132 bfa_trc(flash, msg->mh.msg_id);
4134 if (!flash->op_busy && msg->mh.msg_id != BFI_FLASH_I2H_EVENT) {
4135 /* receiving response after ioc failure */
4136 bfa_trc(flash, 0x9999);
4140 switch (msg->mh.msg_id) {
4141 case BFI_FLASH_I2H_QUERY_RSP:
4142 status = be32_to_cpu(m.query->status);
4143 bfa_trc(flash, status);
4144 if (status == BFA_STATUS_OK) {
4146 struct bfa_flash_attr_s *attr, *f;
4148 attr = (struct bfa_flash_attr_s *) flash->ubuf;
4149 f = (struct bfa_flash_attr_s *) flash->dbuf_kva;
4150 attr->status = be32_to_cpu(f->status);
4151 attr->npart = be32_to_cpu(f->npart);
4152 bfa_trc(flash, attr->status);
4153 bfa_trc(flash, attr->npart);
4154 for (i = 0; i < attr->npart; i++) {
4155 attr->part[i].part_type =
4156 be32_to_cpu(f->part[i].part_type);
4157 attr->part[i].part_instance =
4158 be32_to_cpu(f->part[i].part_instance);
4159 attr->part[i].part_off =
4160 be32_to_cpu(f->part[i].part_off);
4161 attr->part[i].part_size =
4162 be32_to_cpu(f->part[i].part_size);
4163 attr->part[i].part_len =
4164 be32_to_cpu(f->part[i].part_len);
4165 attr->part[i].part_status =
4166 be32_to_cpu(f->part[i].part_status);
4169 flash->status = status;
4170 bfa_flash_cb(flash);
4172 case BFI_FLASH_I2H_ERASE_RSP:
4173 status = be32_to_cpu(m.erase->status);
4174 bfa_trc(flash, status);
4175 flash->status = status;
4176 bfa_flash_cb(flash);
4178 case BFI_FLASH_I2H_WRITE_RSP:
4179 status = be32_to_cpu(m.write->status);
4180 bfa_trc(flash, status);
4181 if (status != BFA_STATUS_OK || flash->residue == 0) {
4182 flash->status = status;
4183 bfa_flash_cb(flash);
4185 bfa_trc(flash, flash->offset);
4186 bfa_flash_write_send(flash);
4189 case BFI_FLASH_I2H_READ_RSP:
4190 status = be32_to_cpu(m.read->status);
4191 bfa_trc(flash, status);
4192 if (status != BFA_STATUS_OK) {
4193 flash->status = status;
4194 bfa_flash_cb(flash);
4196 u32 len = be32_to_cpu(m.read->length);
4197 bfa_trc(flash, flash->offset);
4198 bfa_trc(flash, len);
4199 memcpy(flash->ubuf + flash->offset,
4200 flash->dbuf_kva, len);
4201 flash->residue -= len;
4202 flash->offset += len;
4203 if (flash->residue == 0) {
4204 flash->status = status;
4205 bfa_flash_cb(flash);
4207 bfa_flash_read_send(flash);
4210 case BFI_FLASH_I2H_BOOT_VER_RSP:
4212 case BFI_FLASH_I2H_EVENT:
4213 status = be32_to_cpu(m.event->status);
4214 bfa_trc(flash, status);
4215 if (status == BFA_STATUS_BAD_FWCFG)
4216 bfa_ioc_aen_post(flash->ioc, BFA_IOC_AEN_FWCFG_ERROR);
4217 else if (status == BFA_STATUS_INVALID_VENDOR) {
4219 param = be32_to_cpu(m.event->param);
4220 bfa_trc(flash, param);
4221 bfa_ioc_aen_post(flash->ioc,
4222 BFA_IOC_AEN_INVALID_VENDOR);
4232 * Flash memory info API.
4234 * @param[in] mincfg - minimal cfg variable
4237 bfa_flash_meminfo(bfa_boolean_t mincfg)
4239 /* min driver doesn't need flash */
4242 return BFA_ROUNDUP(BFA_FLASH_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
4248 * @param[in] flash - flash structure
4249 * @param[in] ioc - ioc structure
4250 * @param[in] dev - device structure
4251 * @param[in] trcmod - trace module
4252 * @param[in] logmod - log module
4255 bfa_flash_attach(struct bfa_flash_s *flash, struct bfa_ioc_s *ioc, void *dev,
4256 struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg)
4259 flash->trcmod = trcmod;
4261 flash->cbarg = NULL;
4264 bfa_ioc_mbox_regisr(flash->ioc, BFI_MC_FLASH, bfa_flash_intr, flash);
4265 bfa_q_qe_init(&flash->ioc_notify);
4266 bfa_ioc_notify_init(&flash->ioc_notify, bfa_flash_notify, flash);
4267 list_add_tail(&flash->ioc_notify.qe, &flash->ioc->notify_q);
4269 /* min driver doesn't need flash */
4271 flash->dbuf_kva = NULL;
4277 * Claim memory for flash
4279 * @param[in] flash - flash structure
4280 * @param[in] dm_kva - pointer to virtual memory address
4281 * @param[in] dm_pa - physical memory address
4282 * @param[in] mincfg - minimal cfg variable
4285 bfa_flash_memclaim(struct bfa_flash_s *flash, u8 *dm_kva, u64 dm_pa,
4286 bfa_boolean_t mincfg)
4291 flash->dbuf_kva = dm_kva;
4292 flash->dbuf_pa = dm_pa;
4293 memset(flash->dbuf_kva, 0, BFA_FLASH_DMA_BUF_SZ);
4294 dm_kva += BFA_ROUNDUP(BFA_FLASH_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
4295 dm_pa += BFA_ROUNDUP(BFA_FLASH_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
4299 * Get flash attribute.
4301 * @param[in] flash - flash structure
4302 * @param[in] attr - flash attribute structure
4303 * @param[in] cbfn - callback function
4304 * @param[in] cbarg - callback argument
4309 bfa_flash_get_attr(struct bfa_flash_s *flash, struct bfa_flash_attr_s *attr,
4310 bfa_cb_flash_t cbfn, void *cbarg)
4312 bfa_trc(flash, BFI_FLASH_H2I_QUERY_REQ);
4314 if (!bfa_ioc_is_operational(flash->ioc))
4315 return BFA_STATUS_IOC_NON_OP;
4317 if (flash->op_busy) {
4318 bfa_trc(flash, flash->op_busy);
4319 return BFA_STATUS_DEVBUSY;
4324 flash->cbarg = cbarg;
4325 flash->ubuf = (u8 *) attr;
4326 bfa_flash_query_send(flash);
4328 return BFA_STATUS_OK;
4332 * Erase flash partition.
4334 * @param[in] flash - flash structure
4335 * @param[in] type - flash partition type
4336 * @param[in] instance - flash partition instance
4337 * @param[in] cbfn - callback function
4338 * @param[in] cbarg - callback argument
4343 bfa_flash_erase_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
4344 u8 instance, bfa_cb_flash_t cbfn, void *cbarg)
4346 bfa_trc(flash, BFI_FLASH_H2I_ERASE_REQ);
4347 bfa_trc(flash, type);
4348 bfa_trc(flash, instance);
4350 if (!bfa_ioc_is_operational(flash->ioc))
4351 return BFA_STATUS_IOC_NON_OP;
4353 if (flash->op_busy) {
4354 bfa_trc(flash, flash->op_busy);
4355 return BFA_STATUS_DEVBUSY;
4360 flash->cbarg = cbarg;
4362 flash->instance = instance;
4364 bfa_flash_erase_send(flash);
4365 bfa_flash_aen_audit_post(flash->ioc, BFA_AUDIT_AEN_FLASH_ERASE,
4367 return BFA_STATUS_OK;
4371 * Update flash partition.
4373 * @param[in] flash - flash structure
4374 * @param[in] type - flash partition type
4375 * @param[in] instance - flash partition instance
4376 * @param[in] buf - update data buffer
4377 * @param[in] len - data buffer length
4378 * @param[in] offset - offset relative to the partition starting address
4379 * @param[in] cbfn - callback function
4380 * @param[in] cbarg - callback argument
4385 bfa_flash_update_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
4386 u8 instance, void *buf, u32 len, u32 offset,
4387 bfa_cb_flash_t cbfn, void *cbarg)
4389 bfa_trc(flash, BFI_FLASH_H2I_WRITE_REQ);
4390 bfa_trc(flash, type);
4391 bfa_trc(flash, instance);
4392 bfa_trc(flash, len);
4393 bfa_trc(flash, offset);
4395 if (!bfa_ioc_is_operational(flash->ioc))
4396 return BFA_STATUS_IOC_NON_OP;
4399 * 'len' must be in word (4-byte) boundary
4400 * 'offset' must be in sector (16kb) boundary
4402 if (!len || (len & 0x03) || (offset & 0x00003FFF))
4403 return BFA_STATUS_FLASH_BAD_LEN;
4405 if (type == BFA_FLASH_PART_MFG)
4406 return BFA_STATUS_EINVAL;
4408 if (flash->op_busy) {
4409 bfa_trc(flash, flash->op_busy);
4410 return BFA_STATUS_DEVBUSY;
4415 flash->cbarg = cbarg;
4417 flash->instance = instance;
4418 flash->residue = len;
4420 flash->addr_off = offset;
4423 bfa_flash_write_send(flash);
4424 return BFA_STATUS_OK;
4428 * Read flash partition.
4430 * @param[in] flash - flash structure
4431 * @param[in] type - flash partition type
4432 * @param[in] instance - flash partition instance
4433 * @param[in] buf - read data buffer
4434 * @param[in] len - data buffer length
4435 * @param[in] offset - offset relative to the partition starting address
4436 * @param[in] cbfn - callback function
4437 * @param[in] cbarg - callback argument
4442 bfa_flash_read_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
4443 u8 instance, void *buf, u32 len, u32 offset,
4444 bfa_cb_flash_t cbfn, void *cbarg)
4446 bfa_trc(flash, BFI_FLASH_H2I_READ_REQ);
4447 bfa_trc(flash, type);
4448 bfa_trc(flash, instance);
4449 bfa_trc(flash, len);
4450 bfa_trc(flash, offset);
4452 if (!bfa_ioc_is_operational(flash->ioc))
4453 return BFA_STATUS_IOC_NON_OP;
4456 * 'len' must be in word (4-byte) boundary
4457 * 'offset' must be in sector (16kb) boundary
4459 if (!len || (len & 0x03) || (offset & 0x00003FFF))
4460 return BFA_STATUS_FLASH_BAD_LEN;
4462 if (flash->op_busy) {
4463 bfa_trc(flash, flash->op_busy);
4464 return BFA_STATUS_DEVBUSY;
4469 flash->cbarg = cbarg;
4471 flash->instance = instance;
4472 flash->residue = len;
4474 flash->addr_off = offset;
4476 bfa_flash_read_send(flash);
4478 return BFA_STATUS_OK;
4482 * DIAG module specific
4485 #define BFA_DIAG_MEMTEST_TOV 50000 /* memtest timeout in msec */
4486 #define CT2_BFA_DIAG_MEMTEST_TOV (9*30*1000) /* 4.5 min */
4488 /* IOC event handler */
4490 bfa_diag_notify(void *diag_arg, enum bfa_ioc_event_e event)
4492 struct bfa_diag_s *diag = diag_arg;
4494 bfa_trc(diag, event);
4495 bfa_trc(diag, diag->block);
4496 bfa_trc(diag, diag->fwping.lock);
4497 bfa_trc(diag, diag->tsensor.lock);
4500 case BFA_IOC_E_DISABLED:
4501 case BFA_IOC_E_FAILED:
4502 if (diag->fwping.lock) {
4503 diag->fwping.status = BFA_STATUS_IOC_FAILURE;
4504 diag->fwping.cbfn(diag->fwping.cbarg,
4505 diag->fwping.status);
4506 diag->fwping.lock = 0;
4509 if (diag->tsensor.lock) {
4510 diag->tsensor.status = BFA_STATUS_IOC_FAILURE;
4511 diag->tsensor.cbfn(diag->tsensor.cbarg,
4512 diag->tsensor.status);
4513 diag->tsensor.lock = 0;
4517 if (diag->timer_active) {
4518 bfa_timer_stop(&diag->timer);
4519 diag->timer_active = 0;
4522 diag->status = BFA_STATUS_IOC_FAILURE;
4523 diag->cbfn(diag->cbarg, diag->status);
4534 bfa_diag_memtest_done(void *cbarg)
4536 struct bfa_diag_s *diag = cbarg;
4537 struct bfa_ioc_s *ioc = diag->ioc;
4538 struct bfa_diag_memtest_result *res = diag->result;
4539 u32 loff = BFI_BOOT_MEMTEST_RES_ADDR;
4540 u32 pgnum, pgoff, i;
4542 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
4543 pgoff = PSS_SMEM_PGOFF(loff);
4545 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
4547 for (i = 0; i < (sizeof(struct bfa_diag_memtest_result) /
4548 sizeof(u32)); i++) {
4549 /* read test result from smem */
4550 *((u32 *) res + i) =
4551 bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
4552 loff += sizeof(u32);
4555 /* Reset IOC fwstates to BFI_IOC_UNINIT */
4556 bfa_ioc_reset_fwstate(ioc);
4558 res->status = swab32(res->status);
4559 bfa_trc(diag, res->status);
4561 if (res->status == BFI_BOOT_MEMTEST_RES_SIG)
4562 diag->status = BFA_STATUS_OK;
4564 diag->status = BFA_STATUS_MEMTEST_FAILED;
4565 res->addr = swab32(res->addr);
4566 res->exp = swab32(res->exp);
4567 res->act = swab32(res->act);
4568 res->err_status = swab32(res->err_status);
4569 res->err_status1 = swab32(res->err_status1);
4570 res->err_addr = swab32(res->err_addr);
4571 bfa_trc(diag, res->addr);
4572 bfa_trc(diag, res->exp);
4573 bfa_trc(diag, res->act);
4574 bfa_trc(diag, res->err_status);
4575 bfa_trc(diag, res->err_status1);
4576 bfa_trc(diag, res->err_addr);
4578 diag->timer_active = 0;
4579 diag->cbfn(diag->cbarg, diag->status);
4588 * Perform DMA test directly
4591 diag_fwping_send(struct bfa_diag_s *diag)
4593 struct bfi_diag_fwping_req_s *fwping_req;
4596 bfa_trc(diag, diag->fwping.dbuf_pa);
4598 /* fill DMA area with pattern */
4599 for (i = 0; i < (BFI_DIAG_DMA_BUF_SZ >> 2); i++)
4600 *((u32 *)diag->fwping.dbuf_kva + i) = diag->fwping.data;
4603 fwping_req = (struct bfi_diag_fwping_req_s *)diag->fwping.mbcmd.msg;
4606 bfa_alen_set(&fwping_req->alen, BFI_DIAG_DMA_BUF_SZ,
4607 diag->fwping.dbuf_pa);
4608 /* Set up dma count */
4609 fwping_req->count = cpu_to_be32(diag->fwping.count);
4610 /* Set up data pattern */
4611 fwping_req->data = diag->fwping.data;
4613 /* build host command */
4614 bfi_h2i_set(fwping_req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_FWPING,
4615 bfa_ioc_portid(diag->ioc));
4618 bfa_ioc_mbox_queue(diag->ioc, &diag->fwping.mbcmd);
4622 diag_fwping_comp(struct bfa_diag_s *diag,
4623 struct bfi_diag_fwping_rsp_s *diag_rsp)
4625 u32 rsp_data = diag_rsp->data;
4626 u8 rsp_dma_status = diag_rsp->dma_status;
4628 bfa_trc(diag, rsp_data);
4629 bfa_trc(diag, rsp_dma_status);
4631 if (rsp_dma_status == BFA_STATUS_OK) {
4633 pat = (diag->fwping.count & 0x1) ? ~(diag->fwping.data) :
4635 /* Check mbox data */
4636 if (diag->fwping.data != rsp_data) {
4637 bfa_trc(diag, rsp_data);
4638 diag->fwping.result->dmastatus =
4639 BFA_STATUS_DATACORRUPTED;
4640 diag->fwping.status = BFA_STATUS_DATACORRUPTED;
4641 diag->fwping.cbfn(diag->fwping.cbarg,
4642 diag->fwping.status);
4643 diag->fwping.lock = 0;
4646 /* Check dma pattern */
4647 for (i = 0; i < (BFI_DIAG_DMA_BUF_SZ >> 2); i++) {
4648 if (*((u32 *)diag->fwping.dbuf_kva + i) != pat) {
4652 *((u32 *)diag->fwping.dbuf_kva + i));
4653 diag->fwping.result->dmastatus =
4654 BFA_STATUS_DATACORRUPTED;
4655 diag->fwping.status = BFA_STATUS_DATACORRUPTED;
4656 diag->fwping.cbfn(diag->fwping.cbarg,
4657 diag->fwping.status);
4658 diag->fwping.lock = 0;
4662 diag->fwping.result->dmastatus = BFA_STATUS_OK;
4663 diag->fwping.status = BFA_STATUS_OK;
4664 diag->fwping.cbfn(diag->fwping.cbarg, diag->fwping.status);
4665 diag->fwping.lock = 0;
4667 diag->fwping.status = BFA_STATUS_HDMA_FAILED;
4668 diag->fwping.cbfn(diag->fwping.cbarg, diag->fwping.status);
4669 diag->fwping.lock = 0;
4674 * Temperature Sensor
4678 diag_tempsensor_send(struct bfa_diag_s *diag)
4680 struct bfi_diag_ts_req_s *msg;
4682 msg = (struct bfi_diag_ts_req_s *)diag->tsensor.mbcmd.msg;
4683 bfa_trc(diag, msg->temp);
4684 /* build host command */
4685 bfi_h2i_set(msg->mh, BFI_MC_DIAG, BFI_DIAG_H2I_TEMPSENSOR,
4686 bfa_ioc_portid(diag->ioc));
4688 bfa_ioc_mbox_queue(diag->ioc, &diag->tsensor.mbcmd);
4692 diag_tempsensor_comp(struct bfa_diag_s *diag, bfi_diag_ts_rsp_t *rsp)
4694 if (!diag->tsensor.lock) {
4695 /* receiving response after ioc failure */
4696 bfa_trc(diag, diag->tsensor.lock);
4701 * ASIC junction tempsensor is a reg read operation
4702 * it will always return OK
4704 diag->tsensor.temp->temp = be16_to_cpu(rsp->temp);
4705 diag->tsensor.temp->ts_junc = rsp->ts_junc;
4706 diag->tsensor.temp->ts_brd = rsp->ts_brd;
4709 /* tsensor.temp->status is brd_temp status */
4710 diag->tsensor.temp->status = rsp->status;
4711 if (rsp->status == BFA_STATUS_OK) {
4712 diag->tsensor.temp->brd_temp =
4713 be16_to_cpu(rsp->brd_temp);
4715 diag->tsensor.temp->brd_temp = 0;
4718 bfa_trc(diag, rsp->status);
4719 bfa_trc(diag, rsp->ts_junc);
4720 bfa_trc(diag, rsp->temp);
4721 bfa_trc(diag, rsp->ts_brd);
4722 bfa_trc(diag, rsp->brd_temp);
4724 /* tsensor status is always good bcos we always have junction temp */
4725 diag->tsensor.status = BFA_STATUS_OK;
4726 diag->tsensor.cbfn(diag->tsensor.cbarg, diag->tsensor.status);
4727 diag->tsensor.lock = 0;
4734 diag_ledtest_send(struct bfa_diag_s *diag, struct bfa_diag_ledtest_s *ledtest)
4736 struct bfi_diag_ledtest_req_s *msg;
4738 msg = (struct bfi_diag_ledtest_req_s *)diag->ledtest.mbcmd.msg;
4739 /* build host command */
4740 bfi_h2i_set(msg->mh, BFI_MC_DIAG, BFI_DIAG_H2I_LEDTEST,
4741 bfa_ioc_portid(diag->ioc));
4744 * convert the freq from N blinks per 10 sec to
4745 * crossbow ontime value. We do it here because division is need
4748 ledtest->freq = 500 / ledtest->freq;
4750 if (ledtest->freq == 0)
4753 bfa_trc(diag, ledtest->freq);
4754 /* mcpy(&ledtest_req->req, ledtest, sizeof(bfa_diag_ledtest_t)); */
4755 msg->cmd = (u8) ledtest->cmd;
4756 msg->color = (u8) ledtest->color;
4757 msg->portid = bfa_ioc_portid(diag->ioc);
4758 msg->led = ledtest->led;
4759 msg->freq = cpu_to_be16(ledtest->freq);
4762 bfa_ioc_mbox_queue(diag->ioc, &diag->ledtest.mbcmd);
4766 diag_ledtest_comp(struct bfa_diag_s *diag, struct bfi_diag_ledtest_rsp_s *msg)
4768 bfa_trc(diag, diag->ledtest.lock);
4769 diag->ledtest.lock = BFA_FALSE;
4770 /* no bfa_cb_queue is needed because driver is not waiting */
4777 diag_portbeacon_send(struct bfa_diag_s *diag, bfa_boolean_t beacon, u32 sec)
4779 struct bfi_diag_portbeacon_req_s *msg;
4781 msg = (struct bfi_diag_portbeacon_req_s *)diag->beacon.mbcmd.msg;
4782 /* build host command */
4783 bfi_h2i_set(msg->mh, BFI_MC_DIAG, BFI_DIAG_H2I_PORTBEACON,
4784 bfa_ioc_portid(diag->ioc));
4785 msg->beacon = beacon;
4786 msg->period = cpu_to_be32(sec);
4788 bfa_ioc_mbox_queue(diag->ioc, &diag->beacon.mbcmd);
4792 diag_portbeacon_comp(struct bfa_diag_s *diag)
4794 bfa_trc(diag, diag->beacon.state);
4795 diag->beacon.state = BFA_FALSE;
4796 if (diag->cbfn_beacon)
4797 diag->cbfn_beacon(diag->dev, BFA_FALSE, diag->beacon.link_e2e);
4801 * Diag hmbox handler
4804 bfa_diag_intr(void *diagarg, struct bfi_mbmsg_s *msg)
4806 struct bfa_diag_s *diag = diagarg;
4808 switch (msg->mh.msg_id) {
4809 case BFI_DIAG_I2H_PORTBEACON:
4810 diag_portbeacon_comp(diag);
4812 case BFI_DIAG_I2H_FWPING:
4813 diag_fwping_comp(diag, (struct bfi_diag_fwping_rsp_s *) msg);
4815 case BFI_DIAG_I2H_TEMPSENSOR:
4816 diag_tempsensor_comp(diag, (bfi_diag_ts_rsp_t *) msg);
4818 case BFI_DIAG_I2H_LEDTEST:
4819 diag_ledtest_comp(diag, (struct bfi_diag_ledtest_rsp_s *) msg);
4822 bfa_trc(diag, msg->mh.msg_id);
4830 * @param[in] *diag - diag data struct
4831 * @param[in] *memtest - mem test params input from upper layer,
4832 * @param[in] pattern - mem test pattern
4833 * @param[in] *result - mem test result
4834 * @param[in] cbfn - mem test callback functioin
4835 * @param[in] cbarg - callback functioin arg
4840 bfa_diag_memtest(struct bfa_diag_s *diag, struct bfa_diag_memtest_s *memtest,
4841 u32 pattern, struct bfa_diag_memtest_result *result,
4842 bfa_cb_diag_t cbfn, void *cbarg)
4846 bfa_trc(diag, pattern);
4848 if (!bfa_ioc_adapter_is_disabled(diag->ioc))
4849 return BFA_STATUS_ADAPTER_ENABLED;
4851 /* check to see if there is another destructive diag cmd running */
4853 bfa_trc(diag, diag->block);
4854 return BFA_STATUS_DEVBUSY;
4858 diag->result = result;
4860 diag->cbarg = cbarg;
4862 /* download memtest code and take LPU0 out of reset */
4863 bfa_ioc_boot(diag->ioc, BFI_FWBOOT_TYPE_MEMTEST, BFI_FWBOOT_ENV_OS);
4865 memtest_tov = (bfa_ioc_asic_gen(diag->ioc) == BFI_ASIC_GEN_CT2) ?
4866 CT2_BFA_DIAG_MEMTEST_TOV : BFA_DIAG_MEMTEST_TOV;
4867 bfa_timer_begin(diag->ioc->timer_mod, &diag->timer,
4868 bfa_diag_memtest_done, diag, memtest_tov);
4869 diag->timer_active = 1;
4870 return BFA_STATUS_OK;
4874 * DIAG firmware ping command
4876 * @param[in] *diag - diag data struct
4877 * @param[in] cnt - dma loop count for testing PCIE
4878 * @param[in] data - data pattern to pass in fw
4879 * @param[in] *result - pt to bfa_diag_fwping_result_t data struct
4880 * @param[in] cbfn - callback function
4881 * @param[in] *cbarg - callback functioin arg
4886 bfa_diag_fwping(struct bfa_diag_s *diag, u32 cnt, u32 data,
4887 struct bfa_diag_results_fwping *result, bfa_cb_diag_t cbfn,
4891 bfa_trc(diag, data);
4893 if (!bfa_ioc_is_operational(diag->ioc))
4894 return BFA_STATUS_IOC_NON_OP;
4896 if (bfa_asic_id_ct2(bfa_ioc_devid((diag->ioc))) &&
4897 ((diag->ioc)->clscode == BFI_PCIFN_CLASS_ETH))
4898 return BFA_STATUS_CMD_NOTSUPP;
4900 /* check to see if there is another destructive diag cmd running */
4901 if (diag->block || diag->fwping.lock) {
4902 bfa_trc(diag, diag->block);
4903 bfa_trc(diag, diag->fwping.lock);
4904 return BFA_STATUS_DEVBUSY;
4907 /* Initialization */
4908 diag->fwping.lock = 1;
4909 diag->fwping.cbfn = cbfn;
4910 diag->fwping.cbarg = cbarg;
4911 diag->fwping.result = result;
4912 diag->fwping.data = data;
4913 diag->fwping.count = cnt;
4915 /* Init test results */
4916 diag->fwping.result->data = 0;
4917 diag->fwping.result->status = BFA_STATUS_OK;
4919 /* kick off the first ping */
4920 diag_fwping_send(diag);
4921 return BFA_STATUS_OK;
4925 * Read Temperature Sensor
4927 * @param[in] *diag - diag data struct
4928 * @param[in] *result - pt to bfa_diag_temp_t data struct
4929 * @param[in] cbfn - callback function
4930 * @param[in] *cbarg - callback functioin arg
4935 bfa_diag_tsensor_query(struct bfa_diag_s *diag,
4936 struct bfa_diag_results_tempsensor_s *result,
4937 bfa_cb_diag_t cbfn, void *cbarg)
4939 /* check to see if there is a destructive diag cmd running */
4940 if (diag->block || diag->tsensor.lock) {
4941 bfa_trc(diag, diag->block);
4942 bfa_trc(diag, diag->tsensor.lock);
4943 return BFA_STATUS_DEVBUSY;
4946 if (!bfa_ioc_is_operational(diag->ioc))
4947 return BFA_STATUS_IOC_NON_OP;
4949 /* Init diag mod params */
4950 diag->tsensor.lock = 1;
4951 diag->tsensor.temp = result;
4952 diag->tsensor.cbfn = cbfn;
4953 diag->tsensor.cbarg = cbarg;
4954 diag->tsensor.status = BFA_STATUS_OK;
4956 /* Send msg to fw */
4957 diag_tempsensor_send(diag);
4959 return BFA_STATUS_OK;
4965 * @param[in] *diag - diag data struct
4966 * @param[in] *ledtest - pt to ledtest data structure
4971 bfa_diag_ledtest(struct bfa_diag_s *diag, struct bfa_diag_ledtest_s *ledtest)
4973 bfa_trc(diag, ledtest->cmd);
4975 if (!bfa_ioc_is_operational(diag->ioc))
4976 return BFA_STATUS_IOC_NON_OP;
4978 if (diag->beacon.state)
4979 return BFA_STATUS_BEACON_ON;
4981 if (diag->ledtest.lock)
4982 return BFA_STATUS_LEDTEST_OP;
4984 /* Send msg to fw */
4985 diag->ledtest.lock = BFA_TRUE;
4986 diag_ledtest_send(diag, ledtest);
4988 return BFA_STATUS_OK;
4992 * Port beaconing command
4994 * @param[in] *diag - diag data struct
4995 * @param[in] beacon - port beaconing 1:ON 0:OFF
4996 * @param[in] link_e2e_beacon - link beaconing 1:ON 0:OFF
4997 * @param[in] sec - beaconing duration in seconds
5002 bfa_diag_beacon_port(struct bfa_diag_s *diag, bfa_boolean_t beacon,
5003 bfa_boolean_t link_e2e_beacon, uint32_t sec)
5005 bfa_trc(diag, beacon);
5006 bfa_trc(diag, link_e2e_beacon);
5009 if (!bfa_ioc_is_operational(diag->ioc))
5010 return BFA_STATUS_IOC_NON_OP;
5012 if (diag->ledtest.lock)
5013 return BFA_STATUS_LEDTEST_OP;
5015 if (diag->beacon.state && beacon) /* beacon alread on */
5016 return BFA_STATUS_BEACON_ON;
5018 diag->beacon.state = beacon;
5019 diag->beacon.link_e2e = link_e2e_beacon;
5020 if (diag->cbfn_beacon)
5021 diag->cbfn_beacon(diag->dev, beacon, link_e2e_beacon);
5023 /* Send msg to fw */
5024 diag_portbeacon_send(diag, beacon, sec);
5026 return BFA_STATUS_OK;
5030 * Return DMA memory needed by diag module.
5033 bfa_diag_meminfo(void)
5035 return BFA_ROUNDUP(BFI_DIAG_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5039 * Attach virtual and physical memory for Diag.
5042 bfa_diag_attach(struct bfa_diag_s *diag, struct bfa_ioc_s *ioc, void *dev,
5043 bfa_cb_diag_beacon_t cbfn_beacon, struct bfa_trc_mod_s *trcmod)
5047 diag->trcmod = trcmod;
5052 diag->result = NULL;
5053 diag->cbfn_beacon = cbfn_beacon;
5055 bfa_ioc_mbox_regisr(diag->ioc, BFI_MC_DIAG, bfa_diag_intr, diag);
5056 bfa_q_qe_init(&diag->ioc_notify);
5057 bfa_ioc_notify_init(&diag->ioc_notify, bfa_diag_notify, diag);
5058 list_add_tail(&diag->ioc_notify.qe, &diag->ioc->notify_q);
5062 bfa_diag_memclaim(struct bfa_diag_s *diag, u8 *dm_kva, u64 dm_pa)
5064 diag->fwping.dbuf_kva = dm_kva;
5065 diag->fwping.dbuf_pa = dm_pa;
5066 memset(diag->fwping.dbuf_kva, 0, BFI_DIAG_DMA_BUF_SZ);
5070 * PHY module specific
5072 #define BFA_PHY_DMA_BUF_SZ 0x02000 /* 8k dma buffer */
5073 #define BFA_PHY_LOCK_STATUS 0x018878 /* phy semaphore status reg */
5076 bfa_phy_ntoh32(u32 *obuf, u32 *ibuf, int sz)
5080 for (i = 0; i < m; i++)
5081 obuf[i] = be32_to_cpu(ibuf[i]);
5084 static bfa_boolean_t
5085 bfa_phy_present(struct bfa_phy_s *phy)
5087 return (phy->ioc->attr->card_type == BFA_MFG_TYPE_LIGHTNING);
5091 bfa_phy_notify(void *cbarg, enum bfa_ioc_event_e event)
5093 struct bfa_phy_s *phy = cbarg;
5095 bfa_trc(phy, event);
5098 case BFA_IOC_E_DISABLED:
5099 case BFA_IOC_E_FAILED:
5101 phy->status = BFA_STATUS_IOC_FAILURE;
5102 phy->cbfn(phy->cbarg, phy->status);
5113 * Send phy attribute query request.
5115 * @param[in] cbarg - callback argument
5118 bfa_phy_query_send(void *cbarg)
5120 struct bfa_phy_s *phy = cbarg;
5121 struct bfi_phy_query_req_s *msg =
5122 (struct bfi_phy_query_req_s *) phy->mb.msg;
5124 msg->instance = phy->instance;
5125 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_QUERY_REQ,
5126 bfa_ioc_portid(phy->ioc));
5127 bfa_alen_set(&msg->alen, sizeof(struct bfa_phy_attr_s), phy->dbuf_pa);
5128 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5132 * Send phy write request.
5134 * @param[in] cbarg - callback argument
5137 bfa_phy_write_send(void *cbarg)
5139 struct bfa_phy_s *phy = cbarg;
5140 struct bfi_phy_write_req_s *msg =
5141 (struct bfi_phy_write_req_s *) phy->mb.msg;
5146 msg->instance = phy->instance;
5147 msg->offset = cpu_to_be32(phy->addr_off + phy->offset);
5148 len = (phy->residue < BFA_PHY_DMA_BUF_SZ) ?
5149 phy->residue : BFA_PHY_DMA_BUF_SZ;
5150 msg->length = cpu_to_be32(len);
5152 /* indicate if it's the last msg of the whole write operation */
5153 msg->last = (len == phy->residue) ? 1 : 0;
5155 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_WRITE_REQ,
5156 bfa_ioc_portid(phy->ioc));
5157 bfa_alen_set(&msg->alen, len, phy->dbuf_pa);
5159 buf = (u16 *) (phy->ubuf + phy->offset);
5160 dbuf = (u16 *)phy->dbuf_kva;
5162 for (i = 0; i < sz; i++)
5163 buf[i] = cpu_to_be16(dbuf[i]);
5165 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5167 phy->residue -= len;
5172 * Send phy read request.
5174 * @param[in] cbarg - callback argument
5177 bfa_phy_read_send(void *cbarg)
5179 struct bfa_phy_s *phy = cbarg;
5180 struct bfi_phy_read_req_s *msg =
5181 (struct bfi_phy_read_req_s *) phy->mb.msg;
5184 msg->instance = phy->instance;
5185 msg->offset = cpu_to_be32(phy->addr_off + phy->offset);
5186 len = (phy->residue < BFA_PHY_DMA_BUF_SZ) ?
5187 phy->residue : BFA_PHY_DMA_BUF_SZ;
5188 msg->length = cpu_to_be32(len);
5189 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_READ_REQ,
5190 bfa_ioc_portid(phy->ioc));
5191 bfa_alen_set(&msg->alen, len, phy->dbuf_pa);
5192 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5196 * Send phy stats request.
5198 * @param[in] cbarg - callback argument
5201 bfa_phy_stats_send(void *cbarg)
5203 struct bfa_phy_s *phy = cbarg;
5204 struct bfi_phy_stats_req_s *msg =
5205 (struct bfi_phy_stats_req_s *) phy->mb.msg;
5207 msg->instance = phy->instance;
5208 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_STATS_REQ,
5209 bfa_ioc_portid(phy->ioc));
5210 bfa_alen_set(&msg->alen, sizeof(struct bfa_phy_stats_s), phy->dbuf_pa);
5211 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5215 * Flash memory info API.
5217 * @param[in] mincfg - minimal cfg variable
5220 bfa_phy_meminfo(bfa_boolean_t mincfg)
5222 /* min driver doesn't need phy */
5226 return BFA_ROUNDUP(BFA_PHY_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5232 * @param[in] phy - phy structure
5233 * @param[in] ioc - ioc structure
5234 * @param[in] dev - device structure
5235 * @param[in] trcmod - trace module
5236 * @param[in] logmod - log module
5239 bfa_phy_attach(struct bfa_phy_s *phy, struct bfa_ioc_s *ioc, void *dev,
5240 struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg)
5243 phy->trcmod = trcmod;
5248 bfa_ioc_mbox_regisr(phy->ioc, BFI_MC_PHY, bfa_phy_intr, phy);
5249 bfa_q_qe_init(&phy->ioc_notify);
5250 bfa_ioc_notify_init(&phy->ioc_notify, bfa_phy_notify, phy);
5251 list_add_tail(&phy->ioc_notify.qe, &phy->ioc->notify_q);
5253 /* min driver doesn't need phy */
5255 phy->dbuf_kva = NULL;
5261 * Claim memory for phy
5263 * @param[in] phy - phy structure
5264 * @param[in] dm_kva - pointer to virtual memory address
5265 * @param[in] dm_pa - physical memory address
5266 * @param[in] mincfg - minimal cfg variable
5269 bfa_phy_memclaim(struct bfa_phy_s *phy, u8 *dm_kva, u64 dm_pa,
5270 bfa_boolean_t mincfg)
5275 phy->dbuf_kva = dm_kva;
5276 phy->dbuf_pa = dm_pa;
5277 memset(phy->dbuf_kva, 0, BFA_PHY_DMA_BUF_SZ);
5278 dm_kva += BFA_ROUNDUP(BFA_PHY_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5279 dm_pa += BFA_ROUNDUP(BFA_PHY_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5283 bfa_phy_busy(struct bfa_ioc_s *ioc)
5287 rb = bfa_ioc_bar0(ioc);
5288 return readl(rb + BFA_PHY_LOCK_STATUS);
5292 * Get phy attribute.
5294 * @param[in] phy - phy structure
5295 * @param[in] attr - phy attribute structure
5296 * @param[in] cbfn - callback function
5297 * @param[in] cbarg - callback argument
5302 bfa_phy_get_attr(struct bfa_phy_s *phy, u8 instance,
5303 struct bfa_phy_attr_s *attr, bfa_cb_phy_t cbfn, void *cbarg)
5305 bfa_trc(phy, BFI_PHY_H2I_QUERY_REQ);
5306 bfa_trc(phy, instance);
5308 if (!bfa_phy_present(phy))
5309 return BFA_STATUS_PHY_NOT_PRESENT;
5311 if (!bfa_ioc_is_operational(phy->ioc))
5312 return BFA_STATUS_IOC_NON_OP;
5314 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5315 bfa_trc(phy, phy->op_busy);
5316 return BFA_STATUS_DEVBUSY;
5322 phy->instance = instance;
5323 phy->ubuf = (uint8_t *) attr;
5324 bfa_phy_query_send(phy);
5326 return BFA_STATUS_OK;
5332 * @param[in] phy - phy structure
5333 * @param[in] instance - phy image instance
5334 * @param[in] stats - pointer to phy stats
5335 * @param[in] cbfn - callback function
5336 * @param[in] cbarg - callback argument
5341 bfa_phy_get_stats(struct bfa_phy_s *phy, u8 instance,
5342 struct bfa_phy_stats_s *stats,
5343 bfa_cb_phy_t cbfn, void *cbarg)
5345 bfa_trc(phy, BFI_PHY_H2I_STATS_REQ);
5346 bfa_trc(phy, instance);
5348 if (!bfa_phy_present(phy))
5349 return BFA_STATUS_PHY_NOT_PRESENT;
5351 if (!bfa_ioc_is_operational(phy->ioc))
5352 return BFA_STATUS_IOC_NON_OP;
5354 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5355 bfa_trc(phy, phy->op_busy);
5356 return BFA_STATUS_DEVBUSY;
5362 phy->instance = instance;
5363 phy->ubuf = (u8 *) stats;
5364 bfa_phy_stats_send(phy);
5366 return BFA_STATUS_OK;
5372 * @param[in] phy - phy structure
5373 * @param[in] instance - phy image instance
5374 * @param[in] buf - update data buffer
5375 * @param[in] len - data buffer length
5376 * @param[in] offset - offset relative to starting address
5377 * @param[in] cbfn - callback function
5378 * @param[in] cbarg - callback argument
5383 bfa_phy_update(struct bfa_phy_s *phy, u8 instance,
5384 void *buf, u32 len, u32 offset,
5385 bfa_cb_phy_t cbfn, void *cbarg)
5387 bfa_trc(phy, BFI_PHY_H2I_WRITE_REQ);
5388 bfa_trc(phy, instance);
5390 bfa_trc(phy, offset);
5392 if (!bfa_phy_present(phy))
5393 return BFA_STATUS_PHY_NOT_PRESENT;
5395 if (!bfa_ioc_is_operational(phy->ioc))
5396 return BFA_STATUS_IOC_NON_OP;
5398 /* 'len' must be in word (4-byte) boundary */
5399 if (!len || (len & 0x03))
5400 return BFA_STATUS_FAILED;
5402 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5403 bfa_trc(phy, phy->op_busy);
5404 return BFA_STATUS_DEVBUSY;
5410 phy->instance = instance;
5413 phy->addr_off = offset;
5416 bfa_phy_write_send(phy);
5417 return BFA_STATUS_OK;
5423 * @param[in] phy - phy structure
5424 * @param[in] instance - phy image instance
5425 * @param[in] buf - read data buffer
5426 * @param[in] len - data buffer length
5427 * @param[in] offset - offset relative to starting address
5428 * @param[in] cbfn - callback function
5429 * @param[in] cbarg - callback argument
5434 bfa_phy_read(struct bfa_phy_s *phy, u8 instance,
5435 void *buf, u32 len, u32 offset,
5436 bfa_cb_phy_t cbfn, void *cbarg)
5438 bfa_trc(phy, BFI_PHY_H2I_READ_REQ);
5439 bfa_trc(phy, instance);
5441 bfa_trc(phy, offset);
5443 if (!bfa_phy_present(phy))
5444 return BFA_STATUS_PHY_NOT_PRESENT;
5446 if (!bfa_ioc_is_operational(phy->ioc))
5447 return BFA_STATUS_IOC_NON_OP;
5449 /* 'len' must be in word (4-byte) boundary */
5450 if (!len || (len & 0x03))
5451 return BFA_STATUS_FAILED;
5453 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5454 bfa_trc(phy, phy->op_busy);
5455 return BFA_STATUS_DEVBUSY;
5461 phy->instance = instance;
5464 phy->addr_off = offset;
5466 bfa_phy_read_send(phy);
5468 return BFA_STATUS_OK;
5472 * Process phy response messages upon receiving interrupts.
5474 * @param[in] phyarg - phy structure
5475 * @param[in] msg - message structure
5478 bfa_phy_intr(void *phyarg, struct bfi_mbmsg_s *msg)
5480 struct bfa_phy_s *phy = phyarg;
5484 struct bfi_phy_query_rsp_s *query;
5485 struct bfi_phy_stats_rsp_s *stats;
5486 struct bfi_phy_write_rsp_s *write;
5487 struct bfi_phy_read_rsp_s *read;
5488 struct bfi_mbmsg_s *msg;
5492 bfa_trc(phy, msg->mh.msg_id);
5494 if (!phy->op_busy) {
5495 /* receiving response after ioc failure */
5496 bfa_trc(phy, 0x9999);
5500 switch (msg->mh.msg_id) {
5501 case BFI_PHY_I2H_QUERY_RSP:
5502 status = be32_to_cpu(m.query->status);
5503 bfa_trc(phy, status);
5505 if (status == BFA_STATUS_OK) {
5506 struct bfa_phy_attr_s *attr =
5507 (struct bfa_phy_attr_s *) phy->ubuf;
5508 bfa_phy_ntoh32((u32 *)attr, (u32 *)phy->dbuf_kva,
5509 sizeof(struct bfa_phy_attr_s));
5510 bfa_trc(phy, attr->status);
5511 bfa_trc(phy, attr->length);
5514 phy->status = status;
5517 phy->cbfn(phy->cbarg, phy->status);
5519 case BFI_PHY_I2H_STATS_RSP:
5520 status = be32_to_cpu(m.stats->status);
5521 bfa_trc(phy, status);
5523 if (status == BFA_STATUS_OK) {
5524 struct bfa_phy_stats_s *stats =
5525 (struct bfa_phy_stats_s *) phy->ubuf;
5526 bfa_phy_ntoh32((u32 *)stats, (u32 *)phy->dbuf_kva,
5527 sizeof(struct bfa_phy_stats_s));
5528 bfa_trc(phy, stats->status);
5531 phy->status = status;
5534 phy->cbfn(phy->cbarg, phy->status);
5536 case BFI_PHY_I2H_WRITE_RSP:
5537 status = be32_to_cpu(m.write->status);
5538 bfa_trc(phy, status);
5540 if (status != BFA_STATUS_OK || phy->residue == 0) {
5541 phy->status = status;
5544 phy->cbfn(phy->cbarg, phy->status);
5546 bfa_trc(phy, phy->offset);
5547 bfa_phy_write_send(phy);
5550 case BFI_PHY_I2H_READ_RSP:
5551 status = be32_to_cpu(m.read->status);
5552 bfa_trc(phy, status);
5554 if (status != BFA_STATUS_OK) {
5555 phy->status = status;
5558 phy->cbfn(phy->cbarg, phy->status);
5560 u32 len = be32_to_cpu(m.read->length);
5561 u16 *buf = (u16 *)(phy->ubuf + phy->offset);
5562 u16 *dbuf = (u16 *)phy->dbuf_kva;
5563 int i, sz = len >> 1;
5565 bfa_trc(phy, phy->offset);
5568 for (i = 0; i < sz; i++)
5569 buf[i] = be16_to_cpu(dbuf[i]);
5571 phy->residue -= len;
5574 if (phy->residue == 0) {
5575 phy->status = status;
5578 phy->cbfn(phy->cbarg, phy->status);
5580 bfa_phy_read_send(phy);
5589 * DCONF module specific
5595 * DCONF state machine events
5597 enum bfa_dconf_event {
5598 BFA_DCONF_SM_INIT = 1, /* dconf Init */
5599 BFA_DCONF_SM_FLASH_COMP = 2, /* read/write to flash */
5600 BFA_DCONF_SM_WR = 3, /* binding change, map */
5601 BFA_DCONF_SM_TIMEOUT = 4, /* Start timer */
5602 BFA_DCONF_SM_EXIT = 5, /* exit dconf module */
5603 BFA_DCONF_SM_IOCDISABLE = 6, /* IOC disable event */
5606 /* forward declaration of DCONF state machine */
5607 static void bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf,
5608 enum bfa_dconf_event event);
5609 static void bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
5610 enum bfa_dconf_event event);
5611 static void bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf,
5612 enum bfa_dconf_event event);
5613 static void bfa_dconf_sm_dirty(struct bfa_dconf_mod_s *dconf,
5614 enum bfa_dconf_event event);
5615 static void bfa_dconf_sm_sync(struct bfa_dconf_mod_s *dconf,
5616 enum bfa_dconf_event event);
5617 static void bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
5618 enum bfa_dconf_event event);
5619 static void bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
5620 enum bfa_dconf_event event);
5622 static void bfa_dconf_cbfn(void *dconf, bfa_status_t status);
5623 static void bfa_dconf_timer(void *cbarg);
5624 static bfa_status_t bfa_dconf_flash_write(struct bfa_dconf_mod_s *dconf);
5625 static void bfa_dconf_init_cb(void *arg, bfa_status_t status);
5628 * Beginning state of dconf module. Waiting for an event to start.
5631 bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5633 bfa_status_t bfa_status;
5634 bfa_trc(dconf->bfa, event);
5637 case BFA_DCONF_SM_INIT:
5638 if (dconf->min_cfg) {
5639 bfa_trc(dconf->bfa, dconf->min_cfg);
5640 bfa_fsm_send_event(&dconf->bfa->iocfc,
5641 IOCFC_E_DCONF_DONE);
5644 bfa_sm_set_state(dconf, bfa_dconf_sm_flash_read);
5645 bfa_timer_start(dconf->bfa, &dconf->timer,
5646 bfa_dconf_timer, dconf, 2 * BFA_DCONF_UPDATE_TOV);
5647 bfa_status = bfa_flash_read_part(BFA_FLASH(dconf->bfa),
5648 BFA_FLASH_PART_DRV, dconf->instance,
5650 sizeof(struct bfa_dconf_s), 0,
5651 bfa_dconf_init_cb, dconf->bfa);
5652 if (bfa_status != BFA_STATUS_OK) {
5653 bfa_timer_stop(&dconf->timer);
5654 bfa_dconf_init_cb(dconf->bfa, BFA_STATUS_FAILED);
5655 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5659 case BFA_DCONF_SM_EXIT:
5660 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5661 case BFA_DCONF_SM_IOCDISABLE:
5662 case BFA_DCONF_SM_WR:
5663 case BFA_DCONF_SM_FLASH_COMP:
5666 bfa_sm_fault(dconf->bfa, event);
5671 * Read flash for dconf entries and make a call back to the driver once done.
5674 bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
5675 enum bfa_dconf_event event)
5677 bfa_trc(dconf->bfa, event);
5680 case BFA_DCONF_SM_FLASH_COMP:
5681 bfa_timer_stop(&dconf->timer);
5682 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
5684 case BFA_DCONF_SM_TIMEOUT:
5685 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
5686 bfa_ioc_suspend(&dconf->bfa->ioc);
5688 case BFA_DCONF_SM_EXIT:
5689 bfa_timer_stop(&dconf->timer);
5690 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5691 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5693 case BFA_DCONF_SM_IOCDISABLE:
5694 bfa_timer_stop(&dconf->timer);
5695 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5698 bfa_sm_fault(dconf->bfa, event);
5703 * DCONF Module is in ready state. Has completed the initialization.
5706 bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5708 bfa_trc(dconf->bfa, event);
5711 case BFA_DCONF_SM_WR:
5712 bfa_timer_start(dconf->bfa, &dconf->timer,
5713 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5714 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
5716 case BFA_DCONF_SM_EXIT:
5717 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5718 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5720 case BFA_DCONF_SM_INIT:
5721 case BFA_DCONF_SM_IOCDISABLE:
5724 bfa_sm_fault(dconf->bfa, event);
5729 * entries are dirty, write back to the flash.
5733 bfa_dconf_sm_dirty(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5735 bfa_trc(dconf->bfa, event);
5738 case BFA_DCONF_SM_TIMEOUT:
5739 bfa_sm_set_state(dconf, bfa_dconf_sm_sync);
5740 bfa_dconf_flash_write(dconf);
5742 case BFA_DCONF_SM_WR:
5743 bfa_timer_stop(&dconf->timer);
5744 bfa_timer_start(dconf->bfa, &dconf->timer,
5745 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5747 case BFA_DCONF_SM_EXIT:
5748 bfa_timer_stop(&dconf->timer);
5749 bfa_timer_start(dconf->bfa, &dconf->timer,
5750 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5751 bfa_sm_set_state(dconf, bfa_dconf_sm_final_sync);
5752 bfa_dconf_flash_write(dconf);
5754 case BFA_DCONF_SM_FLASH_COMP:
5756 case BFA_DCONF_SM_IOCDISABLE:
5757 bfa_timer_stop(&dconf->timer);
5758 bfa_sm_set_state(dconf, bfa_dconf_sm_iocdown_dirty);
5761 bfa_sm_fault(dconf->bfa, event);
5766 * Sync the dconf entries to the flash.
5769 bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
5770 enum bfa_dconf_event event)
5772 bfa_trc(dconf->bfa, event);
5775 case BFA_DCONF_SM_IOCDISABLE:
5776 case BFA_DCONF_SM_FLASH_COMP:
5777 bfa_timer_stop(&dconf->timer);
5778 case BFA_DCONF_SM_TIMEOUT:
5779 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5780 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5783 bfa_sm_fault(dconf->bfa, event);
5788 bfa_dconf_sm_sync(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5790 bfa_trc(dconf->bfa, event);
5793 case BFA_DCONF_SM_FLASH_COMP:
5794 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
5796 case BFA_DCONF_SM_WR:
5797 bfa_timer_start(dconf->bfa, &dconf->timer,
5798 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5799 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
5801 case BFA_DCONF_SM_EXIT:
5802 bfa_timer_start(dconf->bfa, &dconf->timer,
5803 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5804 bfa_sm_set_state(dconf, bfa_dconf_sm_final_sync);
5806 case BFA_DCONF_SM_IOCDISABLE:
5807 bfa_sm_set_state(dconf, bfa_dconf_sm_iocdown_dirty);
5810 bfa_sm_fault(dconf->bfa, event);
5815 bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
5816 enum bfa_dconf_event event)
5818 bfa_trc(dconf->bfa, event);
5821 case BFA_DCONF_SM_INIT:
5822 bfa_timer_start(dconf->bfa, &dconf->timer,
5823 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5824 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
5826 case BFA_DCONF_SM_EXIT:
5827 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5828 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5830 case BFA_DCONF_SM_IOCDISABLE:
5833 bfa_sm_fault(dconf->bfa, event);
5838 * Compute and return memory needed by DRV_CFG module.
5841 bfa_dconf_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
5844 struct bfa_mem_kva_s *dconf_kva = BFA_MEM_DCONF_KVA(bfa);
5846 if (cfg->drvcfg.min_cfg)
5847 bfa_mem_kva_setup(meminfo, dconf_kva,
5848 sizeof(struct bfa_dconf_hdr_s));
5850 bfa_mem_kva_setup(meminfo, dconf_kva,
5851 sizeof(struct bfa_dconf_s));
5855 bfa_dconf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
5856 struct bfa_pcidev_s *pcidev)
5858 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5862 dconf->instance = bfa->ioc.port_id;
5863 bfa_trc(bfa, dconf->instance);
5865 dconf->dconf = (struct bfa_dconf_s *) bfa_mem_kva_curp(dconf);
5866 if (cfg->drvcfg.min_cfg) {
5867 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_hdr_s);
5868 dconf->min_cfg = BFA_TRUE;
5870 dconf->min_cfg = BFA_FALSE;
5871 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_s);
5874 bfa_dconf_read_data_valid(bfa) = BFA_FALSE;
5875 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5879 bfa_dconf_init_cb(void *arg, bfa_status_t status)
5881 struct bfa_s *bfa = arg;
5882 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5884 if (status == BFA_STATUS_OK) {
5885 bfa_dconf_read_data_valid(bfa) = BFA_TRUE;
5886 if (dconf->dconf->hdr.signature != BFI_DCONF_SIGNATURE)
5887 dconf->dconf->hdr.signature = BFI_DCONF_SIGNATURE;
5888 if (dconf->dconf->hdr.version != BFI_DCONF_VERSION)
5889 dconf->dconf->hdr.version = BFI_DCONF_VERSION;
5891 bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
5892 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DCONF_DONE);
5896 bfa_dconf_modinit(struct bfa_s *bfa)
5898 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5899 bfa_sm_send_event(dconf, BFA_DCONF_SM_INIT);
5902 bfa_dconf_start(struct bfa_s *bfa)
5907 bfa_dconf_stop(struct bfa_s *bfa)
5911 static void bfa_dconf_timer(void *cbarg)
5913 struct bfa_dconf_mod_s *dconf = cbarg;
5914 bfa_sm_send_event(dconf, BFA_DCONF_SM_TIMEOUT);
5917 bfa_dconf_iocdisable(struct bfa_s *bfa)
5919 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5920 bfa_sm_send_event(dconf, BFA_DCONF_SM_IOCDISABLE);
5924 bfa_dconf_detach(struct bfa_s *bfa)
5929 bfa_dconf_flash_write(struct bfa_dconf_mod_s *dconf)
5931 bfa_status_t bfa_status;
5932 bfa_trc(dconf->bfa, 0);
5934 bfa_status = bfa_flash_update_part(BFA_FLASH(dconf->bfa),
5935 BFA_FLASH_PART_DRV, dconf->instance,
5936 dconf->dconf, sizeof(struct bfa_dconf_s), 0,
5937 bfa_dconf_cbfn, dconf);
5938 if (bfa_status != BFA_STATUS_OK)
5939 WARN_ON(bfa_status);
5940 bfa_trc(dconf->bfa, bfa_status);
5946 bfa_dconf_update(struct bfa_s *bfa)
5948 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5949 bfa_trc(dconf->bfa, 0);
5950 if (bfa_sm_cmp_state(dconf, bfa_dconf_sm_iocdown_dirty))
5951 return BFA_STATUS_FAILED;
5953 if (dconf->min_cfg) {
5954 bfa_trc(dconf->bfa, dconf->min_cfg);
5955 return BFA_STATUS_FAILED;
5958 bfa_sm_send_event(dconf, BFA_DCONF_SM_WR);
5959 return BFA_STATUS_OK;
5963 bfa_dconf_cbfn(void *arg, bfa_status_t status)
5965 struct bfa_dconf_mod_s *dconf = arg;
5967 bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
5971 bfa_dconf_modexit(struct bfa_s *bfa)
5973 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
5974 bfa_sm_send_event(dconf, BFA_DCONF_SM_EXIT);
5978 * FRU specific functions
5981 #define BFA_FRU_DMA_BUF_SZ 0x02000 /* 8k dma buffer */
5982 #define BFA_FRU_CHINOOK_MAX_SIZE 0x10000
5983 #define BFA_FRU_LIGHTNING_MAX_SIZE 0x200
5986 bfa_fru_notify(void *cbarg, enum bfa_ioc_event_e event)
5988 struct bfa_fru_s *fru = cbarg;
5990 bfa_trc(fru, event);
5993 case BFA_IOC_E_DISABLED:
5994 case BFA_IOC_E_FAILED:
5996 fru->status = BFA_STATUS_IOC_FAILURE;
5997 fru->cbfn(fru->cbarg, fru->status);
6008 * Send fru write request.
6010 * @param[in] cbarg - callback argument
6013 bfa_fru_write_send(void *cbarg, enum bfi_fru_h2i_msgs msg_type)
6015 struct bfa_fru_s *fru = cbarg;
6016 struct bfi_fru_write_req_s *msg =
6017 (struct bfi_fru_write_req_s *) fru->mb.msg;
6020 msg->offset = cpu_to_be32(fru->addr_off + fru->offset);
6021 len = (fru->residue < BFA_FRU_DMA_BUF_SZ) ?
6022 fru->residue : BFA_FRU_DMA_BUF_SZ;
6023 msg->length = cpu_to_be32(len);
6026 * indicate if it's the last msg of the whole write operation
6028 msg->last = (len == fru->residue) ? 1 : 0;
6030 msg->trfr_cmpl = (len == fru->residue) ? fru->trfr_cmpl : 0;
6031 bfi_h2i_set(msg->mh, BFI_MC_FRU, msg_type, bfa_ioc_portid(fru->ioc));
6032 bfa_alen_set(&msg->alen, len, fru->dbuf_pa);
6034 memcpy(fru->dbuf_kva, fru->ubuf + fru->offset, len);
6035 bfa_ioc_mbox_queue(fru->ioc, &fru->mb);
6037 fru->residue -= len;
6042 * Send fru read request.
6044 * @param[in] cbarg - callback argument
6047 bfa_fru_read_send(void *cbarg, enum bfi_fru_h2i_msgs msg_type)
6049 struct bfa_fru_s *fru = cbarg;
6050 struct bfi_fru_read_req_s *msg =
6051 (struct bfi_fru_read_req_s *) fru->mb.msg;
6054 msg->offset = cpu_to_be32(fru->addr_off + fru->offset);
6055 len = (fru->residue < BFA_FRU_DMA_BUF_SZ) ?
6056 fru->residue : BFA_FRU_DMA_BUF_SZ;
6057 msg->length = cpu_to_be32(len);
6058 bfi_h2i_set(msg->mh, BFI_MC_FRU, msg_type, bfa_ioc_portid(fru->ioc));
6059 bfa_alen_set(&msg->alen, len, fru->dbuf_pa);
6060 bfa_ioc_mbox_queue(fru->ioc, &fru->mb);
6064 * Flash memory info API.
6066 * @param[in] mincfg - minimal cfg variable
6069 bfa_fru_meminfo(bfa_boolean_t mincfg)
6071 /* min driver doesn't need fru */
6075 return BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6081 * @param[in] fru - fru structure
6082 * @param[in] ioc - ioc structure
6083 * @param[in] dev - device structure
6084 * @param[in] trcmod - trace module
6085 * @param[in] logmod - log module
6088 bfa_fru_attach(struct bfa_fru_s *fru, struct bfa_ioc_s *ioc, void *dev,
6089 struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg)
6092 fru->trcmod = trcmod;
6097 bfa_ioc_mbox_regisr(fru->ioc, BFI_MC_FRU, bfa_fru_intr, fru);
6098 bfa_q_qe_init(&fru->ioc_notify);
6099 bfa_ioc_notify_init(&fru->ioc_notify, bfa_fru_notify, fru);
6100 list_add_tail(&fru->ioc_notify.qe, &fru->ioc->notify_q);
6102 /* min driver doesn't need fru */
6104 fru->dbuf_kva = NULL;
6110 * Claim memory for fru
6112 * @param[in] fru - fru structure
6113 * @param[in] dm_kva - pointer to virtual memory address
6114 * @param[in] dm_pa - frusical memory address
6115 * @param[in] mincfg - minimal cfg variable
6118 bfa_fru_memclaim(struct bfa_fru_s *fru, u8 *dm_kva, u64 dm_pa,
6119 bfa_boolean_t mincfg)
6124 fru->dbuf_kva = dm_kva;
6125 fru->dbuf_pa = dm_pa;
6126 memset(fru->dbuf_kva, 0, BFA_FRU_DMA_BUF_SZ);
6127 dm_kva += BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6128 dm_pa += BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6132 * Update fru vpd image.
6134 * @param[in] fru - fru structure
6135 * @param[in] buf - update data buffer
6136 * @param[in] len - data buffer length
6137 * @param[in] offset - offset relative to starting address
6138 * @param[in] cbfn - callback function
6139 * @param[in] cbarg - callback argument
6144 bfa_fruvpd_update(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6145 bfa_cb_fru_t cbfn, void *cbarg, u8 trfr_cmpl)
6147 bfa_trc(fru, BFI_FRUVPD_H2I_WRITE_REQ);
6149 bfa_trc(fru, offset);
6151 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2 &&
6152 fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK2)
6153 return BFA_STATUS_FRU_NOT_PRESENT;
6155 if (fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK)
6156 return BFA_STATUS_CMD_NOTSUPP;
6158 if (!bfa_ioc_is_operational(fru->ioc))
6159 return BFA_STATUS_IOC_NON_OP;
6162 bfa_trc(fru, fru->op_busy);
6163 return BFA_STATUS_DEVBUSY;
6172 fru->addr_off = offset;
6174 fru->trfr_cmpl = trfr_cmpl;
6176 bfa_fru_write_send(fru, BFI_FRUVPD_H2I_WRITE_REQ);
6178 return BFA_STATUS_OK;
6182 * Read fru vpd image.
6184 * @param[in] fru - fru structure
6185 * @param[in] buf - read data buffer
6186 * @param[in] len - data buffer length
6187 * @param[in] offset - offset relative to starting address
6188 * @param[in] cbfn - callback function
6189 * @param[in] cbarg - callback argument
6194 bfa_fruvpd_read(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6195 bfa_cb_fru_t cbfn, void *cbarg)
6197 bfa_trc(fru, BFI_FRUVPD_H2I_READ_REQ);
6199 bfa_trc(fru, offset);
6201 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6202 return BFA_STATUS_FRU_NOT_PRESENT;
6204 if (fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK &&
6205 fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK2)
6206 return BFA_STATUS_CMD_NOTSUPP;
6208 if (!bfa_ioc_is_operational(fru->ioc))
6209 return BFA_STATUS_IOC_NON_OP;
6212 bfa_trc(fru, fru->op_busy);
6213 return BFA_STATUS_DEVBUSY;
6222 fru->addr_off = offset;
6224 bfa_fru_read_send(fru, BFI_FRUVPD_H2I_READ_REQ);
6226 return BFA_STATUS_OK;
6230 * Get maximum size fru vpd image.
6232 * @param[in] fru - fru structure
6233 * @param[out] size - maximum size of fru vpd data
6238 bfa_fruvpd_get_max_size(struct bfa_fru_s *fru, u32 *max_size)
6240 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6241 return BFA_STATUS_FRU_NOT_PRESENT;
6243 if (!bfa_ioc_is_operational(fru->ioc))
6244 return BFA_STATUS_IOC_NON_OP;
6246 if (fru->ioc->attr->card_type == BFA_MFG_TYPE_CHINOOK ||
6247 fru->ioc->attr->card_type == BFA_MFG_TYPE_CHINOOK2)
6248 *max_size = BFA_FRU_CHINOOK_MAX_SIZE;
6250 return BFA_STATUS_CMD_NOTSUPP;
6251 return BFA_STATUS_OK;
6256 * @param[in] fru - fru structure
6257 * @param[in] buf - update data buffer
6258 * @param[in] len - data buffer length
6259 * @param[in] offset - offset relative to starting address
6260 * @param[in] cbfn - callback function
6261 * @param[in] cbarg - callback argument
6266 bfa_tfru_write(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6267 bfa_cb_fru_t cbfn, void *cbarg)
6269 bfa_trc(fru, BFI_TFRU_H2I_WRITE_REQ);
6271 bfa_trc(fru, offset);
6272 bfa_trc(fru, *((u8 *) buf));
6274 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6275 return BFA_STATUS_FRU_NOT_PRESENT;
6277 if (!bfa_ioc_is_operational(fru->ioc))
6278 return BFA_STATUS_IOC_NON_OP;
6281 bfa_trc(fru, fru->op_busy);
6282 return BFA_STATUS_DEVBUSY;
6291 fru->addr_off = offset;
6294 bfa_fru_write_send(fru, BFI_TFRU_H2I_WRITE_REQ);
6296 return BFA_STATUS_OK;
6302 * @param[in] fru - fru structure
6303 * @param[in] buf - read data buffer
6304 * @param[in] len - data buffer length
6305 * @param[in] offset - offset relative to starting address
6306 * @param[in] cbfn - callback function
6307 * @param[in] cbarg - callback argument
6312 bfa_tfru_read(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6313 bfa_cb_fru_t cbfn, void *cbarg)
6315 bfa_trc(fru, BFI_TFRU_H2I_READ_REQ);
6317 bfa_trc(fru, offset);
6319 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6320 return BFA_STATUS_FRU_NOT_PRESENT;
6322 if (!bfa_ioc_is_operational(fru->ioc))
6323 return BFA_STATUS_IOC_NON_OP;
6326 bfa_trc(fru, fru->op_busy);
6327 return BFA_STATUS_DEVBUSY;
6336 fru->addr_off = offset;
6338 bfa_fru_read_send(fru, BFI_TFRU_H2I_READ_REQ);
6340 return BFA_STATUS_OK;
6344 * Process fru response messages upon receiving interrupts.
6346 * @param[in] fruarg - fru structure
6347 * @param[in] msg - message structure
6350 bfa_fru_intr(void *fruarg, struct bfi_mbmsg_s *msg)
6352 struct bfa_fru_s *fru = fruarg;
6353 struct bfi_fru_rsp_s *rsp = (struct bfi_fru_rsp_s *)msg;
6356 bfa_trc(fru, msg->mh.msg_id);
6358 if (!fru->op_busy) {
6360 * receiving response after ioc failure
6362 bfa_trc(fru, 0x9999);
6366 switch (msg->mh.msg_id) {
6367 case BFI_FRUVPD_I2H_WRITE_RSP:
6368 case BFI_TFRU_I2H_WRITE_RSP:
6369 status = be32_to_cpu(rsp->status);
6370 bfa_trc(fru, status);
6372 if (status != BFA_STATUS_OK || fru->residue == 0) {
6373 fru->status = status;
6376 fru->cbfn(fru->cbarg, fru->status);
6378 bfa_trc(fru, fru->offset);
6379 if (msg->mh.msg_id == BFI_FRUVPD_I2H_WRITE_RSP)
6380 bfa_fru_write_send(fru,
6381 BFI_FRUVPD_H2I_WRITE_REQ);
6383 bfa_fru_write_send(fru,
6384 BFI_TFRU_H2I_WRITE_REQ);
6387 case BFI_FRUVPD_I2H_READ_RSP:
6388 case BFI_TFRU_I2H_READ_RSP:
6389 status = be32_to_cpu(rsp->status);
6390 bfa_trc(fru, status);
6392 if (status != BFA_STATUS_OK) {
6393 fru->status = status;
6396 fru->cbfn(fru->cbarg, fru->status);
6398 u32 len = be32_to_cpu(rsp->length);
6400 bfa_trc(fru, fru->offset);
6403 memcpy(fru->ubuf + fru->offset, fru->dbuf_kva, len);
6404 fru->residue -= len;
6407 if (fru->residue == 0) {
6408 fru->status = status;
6411 fru->cbfn(fru->cbarg, fru->status);
6413 if (msg->mh.msg_id == BFI_FRUVPD_I2H_READ_RSP)
6414 bfa_fru_read_send(fru,
6415 BFI_FRUVPD_H2I_READ_REQ);
6417 bfa_fru_read_send(fru,
6418 BFI_TFRU_H2I_READ_REQ);