projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'drm-fixes' of git://people.freedesktop.org/~airlied/linux
[deliverable/linux.git] / drivers / scsi / bfa / bfa_ioc.c
1 /*
2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
3 * All rights reserved
4 * www.brocade.com
5 *
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18 #include "bfad_drv.h"
19 #include "bfad_im.h"
20 #include "bfa_ioc.h"
21 #include "bfi_reg.h"
22 #include "bfa_defs.h"
23 #include "bfa_defs_svc.h"
24 #include "bfi.h"
25
26 BFA_TRC_FILE(CNA, IOC);
27
28 /*
29 * IOC local definitions
30 */
31 #define BFA_IOC_TOV 3000 /* msecs */
32 #define BFA_IOC_HWSEM_TOV 500 /* msecs */
33 #define BFA_IOC_HB_TOV 500 /* msecs */
34 #define BFA_IOC_TOV_RECOVER BFA_IOC_HB_TOV
35 #define BFA_IOC_POLL_TOV BFA_TIMER_FREQ
36
37 #define bfa_ioc_timer_start(__ioc) \
38 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer, \
39 bfa_ioc_timeout, (__ioc), BFA_IOC_TOV)
40 #define bfa_ioc_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->ioc_timer)
41
42 #define bfa_hb_timer_start(__ioc) \
43 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->hb_timer, \
44 bfa_ioc_hb_check, (__ioc), BFA_IOC_HB_TOV)
45 #define bfa_hb_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->hb_timer)
46
47 #define BFA_DBG_FWTRC_OFF(_fn) (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))
48
49 #define bfa_ioc_state_disabled(__sm) \
50 (((__sm) == BFI_IOC_UNINIT) || \
51 ((__sm) == BFI_IOC_INITING) || \
52 ((__sm) == BFI_IOC_HWINIT) || \
53 ((__sm) == BFI_IOC_DISABLED) || \
54 ((__sm) == BFI_IOC_FAIL) || \
55 ((__sm) == BFI_IOC_CFG_DISABLED))
56
57 /*
58 * Asic specific macros : see bfa_hw_cb.c and bfa_hw_ct.c for details.
59 */
60
61 #define bfa_ioc_firmware_lock(__ioc) \
62 ((__ioc)->ioc_hwif->ioc_firmware_lock(__ioc))
63 #define bfa_ioc_firmware_unlock(__ioc) \
64 ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
65 #define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
66 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
67 #define bfa_ioc_notify_fail(__ioc) \
68 ((__ioc)->ioc_hwif->ioc_notify_fail(__ioc))
69 #define bfa_ioc_sync_start(__ioc) \
70 ((__ioc)->ioc_hwif->ioc_sync_start(__ioc))
71 #define bfa_ioc_sync_join(__ioc) \
72 ((__ioc)->ioc_hwif->ioc_sync_join(__ioc))
73 #define bfa_ioc_sync_leave(__ioc) \
74 ((__ioc)->ioc_hwif->ioc_sync_leave(__ioc))
75 #define bfa_ioc_sync_ack(__ioc) \
76 ((__ioc)->ioc_hwif->ioc_sync_ack(__ioc))
77 #define bfa_ioc_sync_complete(__ioc) \
78 ((__ioc)->ioc_hwif->ioc_sync_complete(__ioc))
79 #define bfa_ioc_set_cur_ioc_fwstate(__ioc, __fwstate) \
80 ((__ioc)->ioc_hwif->ioc_set_fwstate(__ioc, __fwstate))
81 #define bfa_ioc_get_cur_ioc_fwstate(__ioc) \
82 ((__ioc)->ioc_hwif->ioc_get_fwstate(__ioc))
83 #define bfa_ioc_set_alt_ioc_fwstate(__ioc, __fwstate) \
84 ((__ioc)->ioc_hwif->ioc_set_alt_fwstate(__ioc, __fwstate))
85 #define bfa_ioc_get_alt_ioc_fwstate(__ioc) \
86 ((__ioc)->ioc_hwif->ioc_get_alt_fwstate(__ioc))
87
88 #define bfa_ioc_mbox_cmd_pending(__ioc) \
89 (!list_empty(&((__ioc)->mbox_mod.cmd_q)) || \
90 readl((__ioc)->ioc_regs.hfn_mbox_cmd))
91
92 bfa_boolean_t bfa_auto_recover = BFA_TRUE;
93
94 /*
95 * forward declarations
96 */
97 static void bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc);
98 static void bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force);
99 static void bfa_ioc_timeout(void *ioc);
100 static void bfa_ioc_poll_fwinit(struct bfa_ioc_s *ioc);
101 static void bfa_ioc_send_enable(struct bfa_ioc_s *ioc);
102 static void bfa_ioc_send_disable(struct bfa_ioc_s *ioc);
103 static void bfa_ioc_send_getattr(struct bfa_ioc_s *ioc);
104 static void bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc);
105 static void bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
106 static void bfa_ioc_mbox_flush(struct bfa_ioc_s *ioc);
107 static void bfa_ioc_recover(struct bfa_ioc_s *ioc);
108 static void bfa_ioc_event_notify(struct bfa_ioc_s *ioc ,
109 enum bfa_ioc_event_e event);
110 static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
111 static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
112 static void bfa_ioc_fail_notify(struct bfa_ioc_s *ioc);
113 static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc);
114 static enum bfi_ioc_img_ver_cmp_e bfa_ioc_fw_ver_patch_cmp(
115 struct bfi_ioc_image_hdr_s *base_fwhdr,
116 struct bfi_ioc_image_hdr_s *fwhdr_to_cmp);
117 static enum bfi_ioc_img_ver_cmp_e bfa_ioc_flash_fwver_cmp(
118 struct bfa_ioc_s *ioc,
119 struct bfi_ioc_image_hdr_s *base_fwhdr);
120
121 /*
122 * IOC state machine definitions/declarations
123 */
124 enum ioc_event {
125 IOC_E_RESET = 1, /* IOC reset request */
126 IOC_E_ENABLE = 2, /* IOC enable request */
127 IOC_E_DISABLE = 3, /* IOC disable request */
128 IOC_E_DETACH = 4, /* driver detach cleanup */
129 IOC_E_ENABLED = 5, /* f/w enabled */
130 IOC_E_FWRSP_GETATTR = 6, /* IOC get attribute response */
131 IOC_E_DISABLED = 7, /* f/w disabled */
132 IOC_E_PFFAILED = 8, /* failure notice by iocpf sm */
133 IOC_E_HBFAIL = 9, /* heartbeat failure */
134 IOC_E_HWERROR = 10, /* hardware error interrupt */
135 IOC_E_TIMEOUT = 11, /* timeout */
136 IOC_E_HWFAILED = 12, /* PCI mapping failure notice */
137 };
138
139 bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc_s, enum ioc_event);
140 bfa_fsm_state_decl(bfa_ioc, reset, struct bfa_ioc_s, enum ioc_event);
141 bfa_fsm_state_decl(bfa_ioc, enabling, struct bfa_ioc_s, enum ioc_event);
142 bfa_fsm_state_decl(bfa_ioc, getattr, struct bfa_ioc_s, enum ioc_event);
143 bfa_fsm_state_decl(bfa_ioc, op, struct bfa_ioc_s, enum ioc_event);
144 bfa_fsm_state_decl(bfa_ioc, fail_retry, struct bfa_ioc_s, enum ioc_event);
145 bfa_fsm_state_decl(bfa_ioc, fail, struct bfa_ioc_s, enum ioc_event);
146 bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event);
147 bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event);
148 bfa_fsm_state_decl(bfa_ioc, hwfail, struct bfa_ioc_s, enum ioc_event);
149
150 static struct bfa_sm_table_s ioc_sm_table[] = {
151 {BFA_SM(bfa_ioc_sm_uninit), BFA_IOC_UNINIT},
152 {BFA_SM(bfa_ioc_sm_reset), BFA_IOC_RESET},
153 {BFA_SM(bfa_ioc_sm_enabling), BFA_IOC_ENABLING},
154 {BFA_SM(bfa_ioc_sm_getattr), BFA_IOC_GETATTR},
155 {BFA_SM(bfa_ioc_sm_op), BFA_IOC_OPERATIONAL},
156 {BFA_SM(bfa_ioc_sm_fail_retry), BFA_IOC_INITFAIL},
157 {BFA_SM(bfa_ioc_sm_fail), BFA_IOC_FAIL},
158 {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
159 {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
160 {BFA_SM(bfa_ioc_sm_hwfail), BFA_IOC_HWFAIL},
161 };
162
163 /*
164 * IOCPF state machine definitions/declarations
165 */
166
167 #define bfa_iocpf_timer_start(__ioc) \
168 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer, \
169 bfa_iocpf_timeout, (__ioc), BFA_IOC_TOV)
170 #define bfa_iocpf_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->ioc_timer)
171
172 #define bfa_iocpf_poll_timer_start(__ioc) \
173 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer, \
174 bfa_iocpf_poll_timeout, (__ioc), BFA_IOC_POLL_TOV)
175
176 #define bfa_sem_timer_start(__ioc) \
177 bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->sem_timer, \
178 bfa_iocpf_sem_timeout, (__ioc), BFA_IOC_HWSEM_TOV)
179 #define bfa_sem_timer_stop(__ioc) bfa_timer_stop(&(__ioc)->sem_timer)
180
181 /*
182 * Forward declareations for iocpf state machine
183 */
184 static void bfa_iocpf_timeout(void *ioc_arg);
185 static void bfa_iocpf_sem_timeout(void *ioc_arg);
186 static void bfa_iocpf_poll_timeout(void *ioc_arg);
187
188 /*
189 * IOCPF state machine events
190 */
191 enum iocpf_event {
192 IOCPF_E_ENABLE = 1, /* IOCPF enable request */
193 IOCPF_E_DISABLE = 2, /* IOCPF disable request */
194 IOCPF_E_STOP = 3, /* stop on driver detach */
195 IOCPF_E_FWREADY = 4, /* f/w initialization done */
196 IOCPF_E_FWRSP_ENABLE = 5, /* enable f/w response */
197 IOCPF_E_FWRSP_DISABLE = 6, /* disable f/w response */
198 IOCPF_E_FAIL = 7, /* failure notice by ioc sm */
199 IOCPF_E_INITFAIL = 8, /* init fail notice by ioc sm */
200 IOCPF_E_GETATTRFAIL = 9, /* init fail notice by ioc sm */
201 IOCPF_E_SEMLOCKED = 10, /* h/w semaphore is locked */
202 IOCPF_E_TIMEOUT = 11, /* f/w response timeout */
203 IOCPF_E_SEM_ERROR = 12, /* h/w sem mapping error */
204 };
205
206 /*
207 * IOCPF states
208 */
209 enum bfa_iocpf_state {
210 BFA_IOCPF_RESET = 1, /* IOC is in reset state */
211 BFA_IOCPF_SEMWAIT = 2, /* Waiting for IOC h/w semaphore */
212 BFA_IOCPF_HWINIT = 3, /* IOC h/w is being initialized */
213 BFA_IOCPF_READY = 4, /* IOCPF is initialized */
214 BFA_IOCPF_INITFAIL = 5, /* IOCPF failed */
215 BFA_IOCPF_FAIL = 6, /* IOCPF failed */
216 BFA_IOCPF_DISABLING = 7, /* IOCPF is being disabled */
217 BFA_IOCPF_DISABLED = 8, /* IOCPF is disabled */
218 BFA_IOCPF_FWMISMATCH = 9, /* IOC f/w different from drivers */
219 };
220
221 bfa_fsm_state_decl(bfa_iocpf, reset, struct bfa_iocpf_s, enum iocpf_event);
222 bfa_fsm_state_decl(bfa_iocpf, fwcheck, struct bfa_iocpf_s, enum iocpf_event);
223 bfa_fsm_state_decl(bfa_iocpf, mismatch, struct bfa_iocpf_s, enum iocpf_event);
224 bfa_fsm_state_decl(bfa_iocpf, semwait, struct bfa_iocpf_s, enum iocpf_event);
225 bfa_fsm_state_decl(bfa_iocpf, hwinit, struct bfa_iocpf_s, enum iocpf_event);
226 bfa_fsm_state_decl(bfa_iocpf, enabling, struct bfa_iocpf_s, enum iocpf_event);
227 bfa_fsm_state_decl(bfa_iocpf, ready, struct bfa_iocpf_s, enum iocpf_event);
228 bfa_fsm_state_decl(bfa_iocpf, initfail_sync, struct bfa_iocpf_s,
229 enum iocpf_event);
230 bfa_fsm_state_decl(bfa_iocpf, initfail, struct bfa_iocpf_s, enum iocpf_event);
231 bfa_fsm_state_decl(bfa_iocpf, fail_sync, struct bfa_iocpf_s, enum iocpf_event);
232 bfa_fsm_state_decl(bfa_iocpf, fail, struct bfa_iocpf_s, enum iocpf_event);
233 bfa_fsm_state_decl(bfa_iocpf, disabling, struct bfa_iocpf_s, enum iocpf_event);
234 bfa_fsm_state_decl(bfa_iocpf, disabling_sync, struct bfa_iocpf_s,
235 enum iocpf_event);
236 bfa_fsm_state_decl(bfa_iocpf, disabled, struct bfa_iocpf_s, enum iocpf_event);
237
238 static struct bfa_sm_table_s iocpf_sm_table[] = {
239 {BFA_SM(bfa_iocpf_sm_reset), BFA_IOCPF_RESET},
240 {BFA_SM(bfa_iocpf_sm_fwcheck), BFA_IOCPF_FWMISMATCH},
241 {BFA_SM(bfa_iocpf_sm_mismatch), BFA_IOCPF_FWMISMATCH},
242 {BFA_SM(bfa_iocpf_sm_semwait), BFA_IOCPF_SEMWAIT},
243 {BFA_SM(bfa_iocpf_sm_hwinit), BFA_IOCPF_HWINIT},
244 {BFA_SM(bfa_iocpf_sm_enabling), BFA_IOCPF_HWINIT},
245 {BFA_SM(bfa_iocpf_sm_ready), BFA_IOCPF_READY},
246 {BFA_SM(bfa_iocpf_sm_initfail_sync), BFA_IOCPF_INITFAIL},
247 {BFA_SM(bfa_iocpf_sm_initfail), BFA_IOCPF_INITFAIL},
248 {BFA_SM(bfa_iocpf_sm_fail_sync), BFA_IOCPF_FAIL},
249 {BFA_SM(bfa_iocpf_sm_fail), BFA_IOCPF_FAIL},
250 {BFA_SM(bfa_iocpf_sm_disabling), BFA_IOCPF_DISABLING},
251 {BFA_SM(bfa_iocpf_sm_disabling_sync), BFA_IOCPF_DISABLING},
252 {BFA_SM(bfa_iocpf_sm_disabled), BFA_IOCPF_DISABLED},
253 };
254
255 /*
256 * IOC State Machine
257 */
258
259 /*
260 * Beginning state. IOC uninit state.
261 */
262
263 static void
264 bfa_ioc_sm_uninit_entry(struct bfa_ioc_s *ioc)
265 {
266 }
267
268 /*
269 * IOC is in uninit state.
270 */
271 static void
272 bfa_ioc_sm_uninit(struct bfa_ioc_s *ioc, enum ioc_event event)
273 {
274 bfa_trc(ioc, event);
275
276 switch (event) {
277 case IOC_E_RESET:
278 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
279 break;
280
281 default:
282 bfa_sm_fault(ioc, event);
283 }
284 }
285 /*
286 * Reset entry actions -- initialize state machine
287 */
288 static void
289 bfa_ioc_sm_reset_entry(struct bfa_ioc_s *ioc)
290 {
291 bfa_fsm_set_state(&ioc->iocpf, bfa_iocpf_sm_reset);
292 }
293
294 /*
295 * IOC is in reset state.
296 */
297 static void
298 bfa_ioc_sm_reset(struct bfa_ioc_s *ioc, enum ioc_event event)
299 {
300 bfa_trc(ioc, event);
301
302 switch (event) {
303 case IOC_E_ENABLE:
304 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
305 break;
306
307 case IOC_E_DISABLE:
308 bfa_ioc_disable_comp(ioc);
309 break;
310
311 case IOC_E_DETACH:
312 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
313 break;
314
315 default:
316 bfa_sm_fault(ioc, event);
317 }
318 }
319
320
321 static void
322 bfa_ioc_sm_enabling_entry(struct bfa_ioc_s *ioc)
323 {
324 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_ENABLE);
325 }
326
327 /*
328 * Host IOC function is being enabled, awaiting response from firmware.
329 * Semaphore is acquired.
330 */
331 static void
332 bfa_ioc_sm_enabling(struct bfa_ioc_s *ioc, enum ioc_event event)
333 {
334 bfa_trc(ioc, event);
335
336 switch (event) {
337 case IOC_E_ENABLED:
338 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
339 break;
340
341 case IOC_E_PFFAILED:
342 /* !!! fall through !!! */
343 case IOC_E_HWERROR:
344 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
345 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
346 if (event != IOC_E_PFFAILED)
347 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
348 break;
349
350 case IOC_E_HWFAILED:
351 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
352 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
353 break;
354
355 case IOC_E_DISABLE:
356 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
357 break;
358
359 case IOC_E_DETACH:
360 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
361 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
362 break;
363
364 case IOC_E_ENABLE:
365 break;
366
367 default:
368 bfa_sm_fault(ioc, event);
369 }
370 }
371
372
373 static void
374 bfa_ioc_sm_getattr_entry(struct bfa_ioc_s *ioc)
375 {
376 bfa_ioc_timer_start(ioc);
377 bfa_ioc_send_getattr(ioc);
378 }
379
380 /*
381 * IOC configuration in progress. Timer is active.
382 */
383 static void
384 bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
385 {
386 bfa_trc(ioc, event);
387
388 switch (event) {
389 case IOC_E_FWRSP_GETATTR:
390 bfa_ioc_timer_stop(ioc);
391 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
392 break;
393
394 case IOC_E_PFFAILED:
395 case IOC_E_HWERROR:
396 bfa_ioc_timer_stop(ioc);
397 /* !!! fall through !!! */
398 case IOC_E_TIMEOUT:
399 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
400 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
401 if (event != IOC_E_PFFAILED)
402 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
403 break;
404
405 case IOC_E_DISABLE:
406 bfa_ioc_timer_stop(ioc);
407 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
408 break;
409
410 case IOC_E_ENABLE:
411 break;
412
413 default:
414 bfa_sm_fault(ioc, event);
415 }
416 }
417
418 static void
419 bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
420 {
421 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
422
423 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
424 bfa_ioc_event_notify(ioc, BFA_IOC_E_ENABLED);
425 bfa_ioc_hb_monitor(ioc);
426 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC enabled\n");
427 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_ENABLE);
428 }
429
430 static void
431 bfa_ioc_sm_op(struct bfa_ioc_s *ioc, enum ioc_event event)
432 {
433 bfa_trc(ioc, event);
434
435 switch (event) {
436 case IOC_E_ENABLE:
437 break;
438
439 case IOC_E_DISABLE:
440 bfa_hb_timer_stop(ioc);
441 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
442 break;
443
444 case IOC_E_PFFAILED:
445 case IOC_E_HWERROR:
446 bfa_hb_timer_stop(ioc);
447 /* !!! fall through !!! */
448 case IOC_E_HBFAIL:
449 if (ioc->iocpf.auto_recover)
450 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail_retry);
451 else
452 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
453
454 bfa_ioc_fail_notify(ioc);
455
456 if (event != IOC_E_PFFAILED)
457 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
458 break;
459
460 default:
461 bfa_sm_fault(ioc, event);
462 }
463 }
464
465
466 static void
467 bfa_ioc_sm_disabling_entry(struct bfa_ioc_s *ioc)
468 {
469 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
470 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_DISABLE);
471 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC disabled\n");
472 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_DISABLE);
473 }
474
475 /*
476 * IOC is being disabled
477 */
478 static void
479 bfa_ioc_sm_disabling(struct bfa_ioc_s *ioc, enum ioc_event event)
480 {
481 bfa_trc(ioc, event);
482
483 switch (event) {
484 case IOC_E_DISABLED:
485 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
486 break;
487
488 case IOC_E_HWERROR:
489 /*
490 * No state change. Will move to disabled state
491 * after iocpf sm completes failure processing and
492 * moves to disabled state.
493 */
494 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
495 break;
496
497 case IOC_E_HWFAILED:
498 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
499 bfa_ioc_disable_comp(ioc);
500 break;
501
502 default:
503 bfa_sm_fault(ioc, event);
504 }
505 }
506
507 /*
508 * IOC disable completion entry.
509 */
510 static void
511 bfa_ioc_sm_disabled_entry(struct bfa_ioc_s *ioc)
512 {
513 bfa_ioc_disable_comp(ioc);
514 }
515
516 static void
517 bfa_ioc_sm_disabled(struct bfa_ioc_s *ioc, enum ioc_event event)
518 {
519 bfa_trc(ioc, event);
520
521 switch (event) {
522 case IOC_E_ENABLE:
523 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
524 break;
525
526 case IOC_E_DISABLE:
527 ioc->cbfn->disable_cbfn(ioc->bfa);
528 break;
529
530 case IOC_E_DETACH:
531 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
532 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
533 break;
534
535 default:
536 bfa_sm_fault(ioc, event);
537 }
538 }
539
540
541 static void
542 bfa_ioc_sm_fail_retry_entry(struct bfa_ioc_s *ioc)
543 {
544 bfa_trc(ioc, 0);
545 }
546
547 /*
548 * Hardware initialization retry.
549 */
550 static void
551 bfa_ioc_sm_fail_retry(struct bfa_ioc_s *ioc, enum ioc_event event)
552 {
553 bfa_trc(ioc, event);
554
555 switch (event) {
556 case IOC_E_ENABLED:
557 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
558 break;
559
560 case IOC_E_PFFAILED:
561 case IOC_E_HWERROR:
562 /*
563 * Initialization retry failed.
564 */
565 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
566 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
567 if (event != IOC_E_PFFAILED)
568 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
569 break;
570
571 case IOC_E_HWFAILED:
572 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
573 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
574 break;
575
576 case IOC_E_ENABLE:
577 break;
578
579 case IOC_E_DISABLE:
580 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
581 break;
582
583 case IOC_E_DETACH:
584 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
585 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
586 break;
587
588 default:
589 bfa_sm_fault(ioc, event);
590 }
591 }
592
593
594 static void
595 bfa_ioc_sm_fail_entry(struct bfa_ioc_s *ioc)
596 {
597 bfa_trc(ioc, 0);
598 }
599
600 /*
601 * IOC failure.
602 */
603 static void
604 bfa_ioc_sm_fail(struct bfa_ioc_s *ioc, enum ioc_event event)
605 {
606 bfa_trc(ioc, event);
607
608 switch (event) {
609
610 case IOC_E_ENABLE:
611 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
612 break;
613
614 case IOC_E_DISABLE:
615 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
616 break;
617
618 case IOC_E_DETACH:
619 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
620 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
621 break;
622
623 case IOC_E_HWERROR:
624 case IOC_E_HWFAILED:
625 /*
626 * HB failure / HW error notification, ignore.
627 */
628 break;
629 default:
630 bfa_sm_fault(ioc, event);
631 }
632 }
633
634 static void
635 bfa_ioc_sm_hwfail_entry(struct bfa_ioc_s *ioc)
636 {
637 bfa_trc(ioc, 0);
638 }
639
640 static void
641 bfa_ioc_sm_hwfail(struct bfa_ioc_s *ioc, enum ioc_event event)
642 {
643 bfa_trc(ioc, event);
644
645 switch (event) {
646 case IOC_E_ENABLE:
647 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
648 break;
649
650 case IOC_E_DISABLE:
651 ioc->cbfn->disable_cbfn(ioc->bfa);
652 break;
653
654 case IOC_E_DETACH:
655 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
656 break;
657
658 case IOC_E_HWERROR:
659 /* Ignore - already in hwfail state */
660 break;
661
662 default:
663 bfa_sm_fault(ioc, event);
664 }
665 }
666
667 /*
668 * IOCPF State Machine
669 */
670
671 /*
672 * Reset entry actions -- initialize state machine
673 */
674 static void
675 bfa_iocpf_sm_reset_entry(struct bfa_iocpf_s *iocpf)
676 {
677 iocpf->fw_mismatch_notified = BFA_FALSE;
678 iocpf->auto_recover = bfa_auto_recover;
679 }
680
681 /*
682 * Beginning state. IOC is in reset state.
683 */
684 static void
685 bfa_iocpf_sm_reset(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
686 {
687 struct bfa_ioc_s *ioc = iocpf->ioc;
688
689 bfa_trc(ioc, event);
690
691 switch (event) {
692 case IOCPF_E_ENABLE:
693 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
694 break;
695
696 case IOCPF_E_STOP:
697 break;
698
699 default:
700 bfa_sm_fault(ioc, event);
701 }
702 }
703
704 /*
705 * Semaphore should be acquired for version check.
706 */
707 static void
708 bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf)
709 {
710 struct bfi_ioc_image_hdr_s fwhdr;
711 u32 r32, fwstate, pgnum, pgoff, loff = 0;
712 int i;
713
714 /*
715 * Spin on init semaphore to serialize.
716 */
717 r32 = readl(iocpf->ioc->ioc_regs.ioc_init_sem_reg);
718 while (r32 & 0x1) {
719 udelay(20);
720 r32 = readl(iocpf->ioc->ioc_regs.ioc_init_sem_reg);
721 }
722
723 /* h/w sem init */
724 fwstate = bfa_ioc_get_cur_ioc_fwstate(iocpf->ioc);
725 if (fwstate == BFI_IOC_UNINIT) {
726 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
727 goto sem_get;
728 }
729
730 bfa_ioc_fwver_get(iocpf->ioc, &fwhdr);
731
732 if (swab32(fwhdr.exec) == BFI_FWBOOT_TYPE_NORMAL) {
733 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
734 goto sem_get;
735 }
736
737 /*
738 * Clear fwver hdr
739 */
740 pgnum = PSS_SMEM_PGNUM(iocpf->ioc->ioc_regs.smem_pg0, loff);
741 pgoff = PSS_SMEM_PGOFF(loff);
742 writel(pgnum, iocpf->ioc->ioc_regs.host_page_num_fn);
743
744 for (i = 0; i < sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32); i++) {
745 bfa_mem_write(iocpf->ioc->ioc_regs.smem_page_start, loff, 0);
746 loff += sizeof(u32);
747 }
748
749 bfa_trc(iocpf->ioc, fwstate);
750 bfa_trc(iocpf->ioc, swab32(fwhdr.exec));
751 bfa_ioc_set_cur_ioc_fwstate(iocpf->ioc, BFI_IOC_UNINIT);
752 bfa_ioc_set_alt_ioc_fwstate(iocpf->ioc, BFI_IOC_UNINIT);
753
754 /*
755 * Unlock the hw semaphore. Should be here only once per boot.
756 */
757 bfa_ioc_ownership_reset(iocpf->ioc);
758
759 /*
760 * unlock init semaphore.
761 */
762 writel(1, iocpf->ioc->ioc_regs.ioc_init_sem_reg);
763
764 sem_get:
765 bfa_ioc_hw_sem_get(iocpf->ioc);
766 }
767
768 /*
769 * Awaiting h/w semaphore to continue with version check.
770 */
771 static void
772 bfa_iocpf_sm_fwcheck(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
773 {
774 struct bfa_ioc_s *ioc = iocpf->ioc;
775
776 bfa_trc(ioc, event);
777
778 switch (event) {
779 case IOCPF_E_SEMLOCKED:
780 if (bfa_ioc_firmware_lock(ioc)) {
781 if (bfa_ioc_sync_start(ioc)) {
782 bfa_ioc_sync_join(ioc);
783 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
784 } else {
785 bfa_ioc_firmware_unlock(ioc);
786 writel(1, ioc->ioc_regs.ioc_sem_reg);
787 bfa_sem_timer_start(ioc);
788 }
789 } else {
790 writel(1, ioc->ioc_regs.ioc_sem_reg);
791 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_mismatch);
792 }
793 break;
794
795 case IOCPF_E_SEM_ERROR:
796 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
797 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
798 break;
799
800 case IOCPF_E_DISABLE:
801 bfa_sem_timer_stop(ioc);
802 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
803 bfa_fsm_send_event(ioc, IOC_E_DISABLED);
804 break;
805
806 case IOCPF_E_STOP:
807 bfa_sem_timer_stop(ioc);
808 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
809 break;
810
811 default:
812 bfa_sm_fault(ioc, event);
813 }
814 }
815
816 /*
817 * Notify enable completion callback.
818 */
819 static void
820 bfa_iocpf_sm_mismatch_entry(struct bfa_iocpf_s *iocpf)
821 {
822 /*
823 * Call only the first time sm enters fwmismatch state.
824 */
825 if (iocpf->fw_mismatch_notified == BFA_FALSE)
826 bfa_ioc_pf_fwmismatch(iocpf->ioc);
827
828 iocpf->fw_mismatch_notified = BFA_TRUE;
829 bfa_iocpf_timer_start(iocpf->ioc);
830 }
831
832 /*
833 * Awaiting firmware version match.
834 */
835 static void
836 bfa_iocpf_sm_mismatch(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
837 {
838 struct bfa_ioc_s *ioc = iocpf->ioc;
839
840 bfa_trc(ioc, event);
841
842 switch (event) {
843 case IOCPF_E_TIMEOUT:
844 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
845 break;
846
847 case IOCPF_E_DISABLE:
848 bfa_iocpf_timer_stop(ioc);
849 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
850 bfa_fsm_send_event(ioc, IOC_E_DISABLED);
851 break;
852
853 case IOCPF_E_STOP:
854 bfa_iocpf_timer_stop(ioc);
855 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
856 break;
857
858 default:
859 bfa_sm_fault(ioc, event);
860 }
861 }
862
863 /*
864 * Request for semaphore.
865 */
866 static void
867 bfa_iocpf_sm_semwait_entry(struct bfa_iocpf_s *iocpf)
868 {
869 bfa_ioc_hw_sem_get(iocpf->ioc);
870 }
871
872 /*
873 * Awaiting semaphore for h/w initialzation.
874 */
875 static void
876 bfa_iocpf_sm_semwait(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
877 {
878 struct bfa_ioc_s *ioc = iocpf->ioc;
879
880 bfa_trc(ioc, event);
881
882 switch (event) {
883 case IOCPF_E_SEMLOCKED:
884 if (bfa_ioc_sync_complete(ioc)) {
885 bfa_ioc_sync_join(ioc);
886 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
887 } else {
888 writel(1, ioc->ioc_regs.ioc_sem_reg);
889 bfa_sem_timer_start(ioc);
890 }
891 break;
892
893 case IOCPF_E_SEM_ERROR:
894 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
895 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
896 break;
897
898 case IOCPF_E_DISABLE:
899 bfa_sem_timer_stop(ioc);
900 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
901 break;
902
903 default:
904 bfa_sm_fault(ioc, event);
905 }
906 }
907
908 static void
909 bfa_iocpf_sm_hwinit_entry(struct bfa_iocpf_s *iocpf)
910 {
911 iocpf->poll_time = 0;
912 bfa_ioc_hwinit(iocpf->ioc, BFA_FALSE);
913 }
914
915 /*
916 * Hardware is being initialized. Interrupts are enabled.
917 * Holding hardware semaphore lock.
918 */
919 static void
920 bfa_iocpf_sm_hwinit(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
921 {
922 struct bfa_ioc_s *ioc = iocpf->ioc;
923
924 bfa_trc(ioc, event);
925
926 switch (event) {
927 case IOCPF_E_FWREADY:
928 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_enabling);
929 break;
930
931 case IOCPF_E_TIMEOUT:
932 writel(1, ioc->ioc_regs.ioc_sem_reg);
933 bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
934 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
935 break;
936
937 case IOCPF_E_DISABLE:
938 bfa_iocpf_timer_stop(ioc);
939 bfa_ioc_sync_leave(ioc);
940 writel(1, ioc->ioc_regs.ioc_sem_reg);
941 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
942 break;
943
944 default:
945 bfa_sm_fault(ioc, event);
946 }
947 }
948
949 static void
950 bfa_iocpf_sm_enabling_entry(struct bfa_iocpf_s *iocpf)
951 {
952 bfa_iocpf_timer_start(iocpf->ioc);
953 /*
954 * Enable Interrupts before sending fw IOC ENABLE cmd.
955 */
956 iocpf->ioc->cbfn->reset_cbfn(iocpf->ioc->bfa);
957 bfa_ioc_send_enable(iocpf->ioc);
958 }
959
960 /*
961 * Host IOC function is being enabled, awaiting response from firmware.
962 * Semaphore is acquired.
963 */
964 static void
965 bfa_iocpf_sm_enabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
966 {
967 struct bfa_ioc_s *ioc = iocpf->ioc;
968
969 bfa_trc(ioc, event);
970
971 switch (event) {
972 case IOCPF_E_FWRSP_ENABLE:
973 bfa_iocpf_timer_stop(ioc);
974 writel(1, ioc->ioc_regs.ioc_sem_reg);
975 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_ready);
976 break;
977
978 case IOCPF_E_INITFAIL:
979 bfa_iocpf_timer_stop(ioc);
980 /*
981 * !!! fall through !!!
982 */
983
984 case IOCPF_E_TIMEOUT:
985 writel(1, ioc->ioc_regs.ioc_sem_reg);
986 if (event == IOCPF_E_TIMEOUT)
987 bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
988 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
989 break;
990
991 case IOCPF_E_DISABLE:
992 bfa_iocpf_timer_stop(ioc);
993 writel(1, ioc->ioc_regs.ioc_sem_reg);
994 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
995 break;
996
997 default:
998 bfa_sm_fault(ioc, event);
999 }
1000 }
1001
1002 static void
1003 bfa_iocpf_sm_ready_entry(struct bfa_iocpf_s *iocpf)
1004 {
1005 bfa_fsm_send_event(iocpf->ioc, IOC_E_ENABLED);
1006 }
1007
1008 static void
1009 bfa_iocpf_sm_ready(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1010 {
1011 struct bfa_ioc_s *ioc = iocpf->ioc;
1012
1013 bfa_trc(ioc, event);
1014
1015 switch (event) {
1016 case IOCPF_E_DISABLE:
1017 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
1018 break;
1019
1020 case IOCPF_E_GETATTRFAIL:
1021 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
1022 break;
1023
1024 case IOCPF_E_FAIL:
1025 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail_sync);
1026 break;
1027
1028 default:
1029 bfa_sm_fault(ioc, event);
1030 }
1031 }
1032
1033 static void
1034 bfa_iocpf_sm_disabling_entry(struct bfa_iocpf_s *iocpf)
1035 {
1036 bfa_iocpf_timer_start(iocpf->ioc);
1037 bfa_ioc_send_disable(iocpf->ioc);
1038 }
1039
1040 /*
1041 * IOC is being disabled
1042 */
1043 static void
1044 bfa_iocpf_sm_disabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1045 {
1046 struct bfa_ioc_s *ioc = iocpf->ioc;
1047
1048 bfa_trc(ioc, event);
1049
1050 switch (event) {
1051 case IOCPF_E_FWRSP_DISABLE:
1052 bfa_iocpf_timer_stop(ioc);
1053 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1054 break;
1055
1056 case IOCPF_E_FAIL:
1057 bfa_iocpf_timer_stop(ioc);
1058 /*
1059 * !!! fall through !!!
1060 */
1061
1062 case IOCPF_E_TIMEOUT:
1063 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_FAIL);
1064 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1065 break;
1066
1067 case IOCPF_E_FWRSP_ENABLE:
1068 break;
1069
1070 default:
1071 bfa_sm_fault(ioc, event);
1072 }
1073 }
1074
1075 static void
1076 bfa_iocpf_sm_disabling_sync_entry(struct bfa_iocpf_s *iocpf)
1077 {
1078 bfa_ioc_hw_sem_get(iocpf->ioc);
1079 }
1080
1081 /*
1082 * IOC hb ack request is being removed.
1083 */
1084 static void
1085 bfa_iocpf_sm_disabling_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1086 {
1087 struct bfa_ioc_s *ioc = iocpf->ioc;
1088
1089 bfa_trc(ioc, event);
1090
1091 switch (event) {
1092 case IOCPF_E_SEMLOCKED:
1093 bfa_ioc_sync_leave(ioc);
1094 writel(1, ioc->ioc_regs.ioc_sem_reg);
1095 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1096 break;
1097
1098 case IOCPF_E_SEM_ERROR:
1099 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1100 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
1101 break;
1102
1103 case IOCPF_E_FAIL:
1104 break;
1105
1106 default:
1107 bfa_sm_fault(ioc, event);
1108 }
1109 }
1110
1111 /*
1112 * IOC disable completion entry.
1113 */
1114 static void
1115 bfa_iocpf_sm_disabled_entry(struct bfa_iocpf_s *iocpf)
1116 {
1117 bfa_ioc_mbox_flush(iocpf->ioc);
1118 bfa_fsm_send_event(iocpf->ioc, IOC_E_DISABLED);
1119 }
1120
1121 static void
1122 bfa_iocpf_sm_disabled(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1123 {
1124 struct bfa_ioc_s *ioc = iocpf->ioc;
1125
1126 bfa_trc(ioc, event);
1127
1128 switch (event) {
1129 case IOCPF_E_ENABLE:
1130 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1131 break;
1132
1133 case IOCPF_E_STOP:
1134 bfa_ioc_firmware_unlock(ioc);
1135 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1136 break;
1137
1138 default:
1139 bfa_sm_fault(ioc, event);
1140 }
1141 }
1142
1143 static void
1144 bfa_iocpf_sm_initfail_sync_entry(struct bfa_iocpf_s *iocpf)
1145 {
1146 bfa_ioc_debug_save_ftrc(iocpf->ioc);
1147 bfa_ioc_hw_sem_get(iocpf->ioc);
1148 }
1149
1150 /*
1151 * Hardware initialization failed.
1152 */
1153 static void
1154 bfa_iocpf_sm_initfail_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1155 {
1156 struct bfa_ioc_s *ioc = iocpf->ioc;
1157
1158 bfa_trc(ioc, event);
1159
1160 switch (event) {
1161 case IOCPF_E_SEMLOCKED:
1162 bfa_ioc_notify_fail(ioc);
1163 bfa_ioc_sync_leave(ioc);
1164 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_FAIL);
1165 writel(1, ioc->ioc_regs.ioc_sem_reg);
1166 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
1167 break;
1168
1169 case IOCPF_E_SEM_ERROR:
1170 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1171 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
1172 break;
1173
1174 case IOCPF_E_DISABLE:
1175 bfa_sem_timer_stop(ioc);
1176 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1177 break;
1178
1179 case IOCPF_E_STOP:
1180 bfa_sem_timer_stop(ioc);
1181 bfa_ioc_firmware_unlock(ioc);
1182 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1183 break;
1184
1185 case IOCPF_E_FAIL:
1186 break;
1187
1188 default:
1189 bfa_sm_fault(ioc, event);
1190 }
1191 }
1192
1193 static void
1194 bfa_iocpf_sm_initfail_entry(struct bfa_iocpf_s *iocpf)
1195 {
1196 bfa_trc(iocpf->ioc, 0);
1197 }
1198
1199 /*
1200 * Hardware initialization failed.
1201 */
1202 static void
1203 bfa_iocpf_sm_initfail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1204 {
1205 struct bfa_ioc_s *ioc = iocpf->ioc;
1206
1207 bfa_trc(ioc, event);
1208
1209 switch (event) {
1210 case IOCPF_E_DISABLE:
1211 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1212 break;
1213
1214 case IOCPF_E_STOP:
1215 bfa_ioc_firmware_unlock(ioc);
1216 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1217 break;
1218
1219 default:
1220 bfa_sm_fault(ioc, event);
1221 }
1222 }
1223
1224 static void
1225 bfa_iocpf_sm_fail_sync_entry(struct bfa_iocpf_s *iocpf)
1226 {
1227 /*
1228 * Mark IOC as failed in hardware and stop firmware.
1229 */
1230 bfa_ioc_lpu_stop(iocpf->ioc);
1231
1232 /*
1233 * Flush any queued up mailbox requests.
1234 */
1235 bfa_ioc_mbox_flush(iocpf->ioc);
1236
1237 bfa_ioc_hw_sem_get(iocpf->ioc);
1238 }
1239
1240 static void
1241 bfa_iocpf_sm_fail_sync(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1242 {
1243 struct bfa_ioc_s *ioc = iocpf->ioc;
1244
1245 bfa_trc(ioc, event);
1246
1247 switch (event) {
1248 case IOCPF_E_SEMLOCKED:
1249 bfa_ioc_sync_ack(ioc);
1250 bfa_ioc_notify_fail(ioc);
1251 if (!iocpf->auto_recover) {
1252 bfa_ioc_sync_leave(ioc);
1253 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_FAIL);
1254 writel(1, ioc->ioc_regs.ioc_sem_reg);
1255 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1256 } else {
1257 if (bfa_ioc_sync_complete(ioc))
1258 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
1259 else {
1260 writel(1, ioc->ioc_regs.ioc_sem_reg);
1261 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1262 }
1263 }
1264 break;
1265
1266 case IOCPF_E_SEM_ERROR:
1267 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1268 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
1269 break;
1270
1271 case IOCPF_E_DISABLE:
1272 bfa_sem_timer_stop(ioc);
1273 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1274 break;
1275
1276 case IOCPF_E_FAIL:
1277 break;
1278
1279 default:
1280 bfa_sm_fault(ioc, event);
1281 }
1282 }
1283
1284 static void
1285 bfa_iocpf_sm_fail_entry(struct bfa_iocpf_s *iocpf)
1286 {
1287 bfa_trc(iocpf->ioc, 0);
1288 }
1289
1290 /*
1291 * IOC is in failed state.
1292 */
1293 static void
1294 bfa_iocpf_sm_fail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1295 {
1296 struct bfa_ioc_s *ioc = iocpf->ioc;
1297
1298 bfa_trc(ioc, event);
1299
1300 switch (event) {
1301 case IOCPF_E_DISABLE:
1302 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1303 break;
1304
1305 default:
1306 bfa_sm_fault(ioc, event);
1307 }
1308 }
1309
1310 /*
1311 * BFA IOC private functions
1312 */
1313
1314 /*
1315 * Notify common modules registered for notification.
1316 */
1317 static void
1318 bfa_ioc_event_notify(struct bfa_ioc_s *ioc, enum bfa_ioc_event_e event)
1319 {
1320 struct bfa_ioc_notify_s *notify;
1321 struct list_head *qe;
1322
1323 list_for_each(qe, &ioc->notify_q) {
1324 notify = (struct bfa_ioc_notify_s *)qe;
1325 notify->cbfn(notify->cbarg, event);
1326 }
1327 }
1328
1329 static void
1330 bfa_ioc_disable_comp(struct bfa_ioc_s *ioc)
1331 {
1332 ioc->cbfn->disable_cbfn(ioc->bfa);
1333 bfa_ioc_event_notify(ioc, BFA_IOC_E_DISABLED);
1334 }
1335
1336 bfa_boolean_t
1337 bfa_ioc_sem_get(void __iomem *sem_reg)
1338 {
1339 u32 r32;
1340 int cnt = 0;
1341 #define BFA_SEM_SPINCNT 3000
1342
1343 r32 = readl(sem_reg);
1344
1345 while ((r32 & 1) && (cnt < BFA_SEM_SPINCNT)) {
1346 cnt++;
1347 udelay(2);
1348 r32 = readl(sem_reg);
1349 }
1350
1351 if (!(r32 & 1))
1352 return BFA_TRUE;
1353
1354 return BFA_FALSE;
1355 }
1356
1357 static void
1358 bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
1359 {
1360 u32 r32;
1361
1362 /*
1363 * First read to the semaphore register will return 0, subsequent reads
1364 * will return 1. Semaphore is released by writing 1 to the register
1365 */
1366 r32 = readl(ioc->ioc_regs.ioc_sem_reg);
1367 if (r32 == ~0) {
1368 WARN_ON(r32 == ~0);
1369 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_SEM_ERROR);
1370 return;
1371 }
1372 if (!(r32 & 1)) {
1373 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_SEMLOCKED);
1374 return;
1375 }
1376
1377 bfa_sem_timer_start(ioc);
1378 }
1379
1380 /*
1381 * Initialize LPU local memory (aka secondary memory / SRAM)
1382 */
1383 static void
1384 bfa_ioc_lmem_init(struct bfa_ioc_s *ioc)
1385 {
1386 u32 pss_ctl;
1387 int i;
1388 #define PSS_LMEM_INIT_TIME 10000
1389
1390 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1391 pss_ctl &= ~__PSS_LMEM_RESET;
1392 pss_ctl |= __PSS_LMEM_INIT_EN;
1393
1394 /*
1395 * i2c workaround 12.5khz clock
1396 */
1397 pss_ctl |= __PSS_I2C_CLK_DIV(3UL);
1398 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1399
1400 /*
1401 * wait for memory initialization to be complete
1402 */
1403 i = 0;
1404 do {
1405 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1406 i++;
1407 } while (!(pss_ctl & __PSS_LMEM_INIT_DONE) && (i < PSS_LMEM_INIT_TIME));
1408
1409 /*
1410 * If memory initialization is not successful, IOC timeout will catch
1411 * such failures.
1412 */
1413 WARN_ON(!(pss_ctl & __PSS_LMEM_INIT_DONE));
1414 bfa_trc(ioc, pss_ctl);
1415
1416 pss_ctl &= ~(__PSS_LMEM_INIT_DONE | __PSS_LMEM_INIT_EN);
1417 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1418 }
1419
1420 static void
1421 bfa_ioc_lpu_start(struct bfa_ioc_s *ioc)
1422 {
1423 u32 pss_ctl;
1424
1425 /*
1426 * Take processor out of reset.
1427 */
1428 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1429 pss_ctl &= ~__PSS_LPU0_RESET;
1430
1431 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1432 }
1433
1434 static void
1435 bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc)
1436 {
1437 u32 pss_ctl;
1438
1439 /*
1440 * Put processors in reset.
1441 */
1442 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1443 pss_ctl |= (__PSS_LPU0_RESET | __PSS_LPU1_RESET);
1444
1445 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1446 }
1447
1448 /*
1449 * Get driver and firmware versions.
1450 */
1451 void
1452 bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
1453 {
1454 u32 pgnum, pgoff;
1455 u32 loff = 0;
1456 int i;
1457 u32 *fwsig = (u32 *) fwhdr;
1458
1459 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1460 pgoff = PSS_SMEM_PGOFF(loff);
1461 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1462
1463 for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32));
1464 i++) {
1465 fwsig[i] =
1466 bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
1467 loff += sizeof(u32);
1468 }
1469 }
1470
1471 /*
1472 * Returns TRUE if driver is willing to work with current smem f/w version.
1473 */
1474 bfa_boolean_t
1475 bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc,
1476 struct bfi_ioc_image_hdr_s *smem_fwhdr)
1477 {
1478 struct bfi_ioc_image_hdr_s *drv_fwhdr;
1479 enum bfi_ioc_img_ver_cmp_e smem_flash_cmp, drv_smem_cmp;
1480
1481 drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
1482 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
1483
1484 /*
1485 * If smem is incompatible or old, driver should not work with it.
1486 */
1487 drv_smem_cmp = bfa_ioc_fw_ver_patch_cmp(drv_fwhdr, smem_fwhdr);
1488 if (drv_smem_cmp == BFI_IOC_IMG_VER_INCOMP ||
1489 drv_smem_cmp == BFI_IOC_IMG_VER_OLD) {
1490 return BFA_FALSE;
1491 }
1492
1493 /*
1494 * IF Flash has a better F/W than smem do not work with smem.
1495 * If smem f/w == flash f/w, as smem f/w not old | incmp, work with it.
1496 * If Flash is old or incomp work with smem iff smem f/w == drv f/w.
1497 */
1498 smem_flash_cmp = bfa_ioc_flash_fwver_cmp(ioc, smem_fwhdr);
1499
1500 if (smem_flash_cmp == BFI_IOC_IMG_VER_BETTER) {
1501 return BFA_FALSE;
1502 } else if (smem_flash_cmp == BFI_IOC_IMG_VER_SAME) {
1503 return BFA_TRUE;
1504 } else {
1505 return (drv_smem_cmp == BFI_IOC_IMG_VER_SAME) ?
1506 BFA_TRUE : BFA_FALSE;
1507 }
1508 }
1509
1510 /*
1511 * Return true if current running version is valid. Firmware signature and
1512 * execution context (driver/bios) must match.
1513 */
1514 static bfa_boolean_t
1515 bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc, u32 boot_env)
1516 {
1517 struct bfi_ioc_image_hdr_s fwhdr;
1518
1519 bfa_ioc_fwver_get(ioc, &fwhdr);
1520
1521 if (swab32(fwhdr.bootenv) != boot_env) {
1522 bfa_trc(ioc, fwhdr.bootenv);
1523 bfa_trc(ioc, boot_env);
1524 return BFA_FALSE;
1525 }
1526
1527 return bfa_ioc_fwver_cmp(ioc, &fwhdr);
1528 }
1529
1530 static bfa_boolean_t
1531 bfa_ioc_fwver_md5_check(struct bfi_ioc_image_hdr_s *fwhdr_1,
1532 struct bfi_ioc_image_hdr_s *fwhdr_2)
1533 {
1534 int i;
1535
1536 for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++)
1537 if (fwhdr_1->md5sum[i] != fwhdr_2->md5sum[i])
1538 return BFA_FALSE;
1539
1540 return BFA_TRUE;
1541 }
1542
1543 /*
1544 * Returns TRUE if major minor and maintainence are same.
1545 * If patch versions are same, check for MD5 Checksum to be same.
1546 */
1547 static bfa_boolean_t
1548 bfa_ioc_fw_ver_compatible(struct bfi_ioc_image_hdr_s *drv_fwhdr,
1549 struct bfi_ioc_image_hdr_s *fwhdr_to_cmp)
1550 {
1551 if (drv_fwhdr->signature != fwhdr_to_cmp->signature)
1552 return BFA_FALSE;
1553
1554 if (drv_fwhdr->fwver.major != fwhdr_to_cmp->fwver.major)
1555 return BFA_FALSE;
1556
1557 if (drv_fwhdr->fwver.minor != fwhdr_to_cmp->fwver.minor)
1558 return BFA_FALSE;
1559
1560 if (drv_fwhdr->fwver.maint != fwhdr_to_cmp->fwver.maint)
1561 return BFA_FALSE;
1562
1563 if (drv_fwhdr->fwver.patch == fwhdr_to_cmp->fwver.patch &&
1564 drv_fwhdr->fwver.phase == fwhdr_to_cmp->fwver.phase &&
1565 drv_fwhdr->fwver.build == fwhdr_to_cmp->fwver.build) {
1566 return bfa_ioc_fwver_md5_check(drv_fwhdr, fwhdr_to_cmp);
1567 }
1568
1569 return BFA_TRUE;
1570 }
1571
1572 static bfa_boolean_t
1573 bfa_ioc_flash_fwver_valid(struct bfi_ioc_image_hdr_s *flash_fwhdr)
1574 {
1575 if (flash_fwhdr->fwver.major == 0 || flash_fwhdr->fwver.major == 0xFF)
1576 return BFA_FALSE;
1577
1578 return BFA_TRUE;
1579 }
1580
1581 static bfa_boolean_t fwhdr_is_ga(struct bfi_ioc_image_hdr_s *fwhdr)
1582 {
1583 if (fwhdr->fwver.phase == 0 &&
1584 fwhdr->fwver.build == 0)
1585 return BFA_TRUE;
1586
1587 return BFA_FALSE;
1588 }
1589
1590 /*
1591 * Returns TRUE if both are compatible and patch of fwhdr_to_cmp is better.
1592 */
1593 static enum bfi_ioc_img_ver_cmp_e
1594 bfa_ioc_fw_ver_patch_cmp(struct bfi_ioc_image_hdr_s *base_fwhdr,
1595 struct bfi_ioc_image_hdr_s *fwhdr_to_cmp)
1596 {
1597 if (bfa_ioc_fw_ver_compatible(base_fwhdr, fwhdr_to_cmp) == BFA_FALSE)
1598 return BFI_IOC_IMG_VER_INCOMP;
1599
1600 if (fwhdr_to_cmp->fwver.patch > base_fwhdr->fwver.patch)
1601 return BFI_IOC_IMG_VER_BETTER;
1602
1603 else if (fwhdr_to_cmp->fwver.patch < base_fwhdr->fwver.patch)
1604 return BFI_IOC_IMG_VER_OLD;
1605
1606 /*
1607 * GA takes priority over internal builds of the same patch stream.
1608 * At this point major minor maint and patch numbers are same.
1609 */
1610
1611 if (fwhdr_is_ga(base_fwhdr) == BFA_TRUE) {
1612 if (fwhdr_is_ga(fwhdr_to_cmp))
1613 return BFI_IOC_IMG_VER_SAME;
1614 else
1615 return BFI_IOC_IMG_VER_OLD;
1616 } else {
1617 if (fwhdr_is_ga(fwhdr_to_cmp))
1618 return BFI_IOC_IMG_VER_BETTER;
1619 }
1620
1621 if (fwhdr_to_cmp->fwver.phase > base_fwhdr->fwver.phase)
1622 return BFI_IOC_IMG_VER_BETTER;
1623 else if (fwhdr_to_cmp->fwver.phase < base_fwhdr->fwver.phase)
1624 return BFI_IOC_IMG_VER_OLD;
1625
1626 if (fwhdr_to_cmp->fwver.build > base_fwhdr->fwver.build)
1627 return BFI_IOC_IMG_VER_BETTER;
1628 else if (fwhdr_to_cmp->fwver.build < base_fwhdr->fwver.build)
1629 return BFI_IOC_IMG_VER_OLD;
1630
1631 /*
1632 * All Version Numbers are equal.
1633 * Md5 check to be done as a part of compatibility check.
1634 */
1635 return BFI_IOC_IMG_VER_SAME;
1636 }
1637
1638 #define BFA_FLASH_PART_FWIMG_ADDR 0x100000 /* fw image address */
1639
1640 bfa_status_t
1641 bfa_ioc_flash_img_get_chnk(struct bfa_ioc_s *ioc, u32 off,
1642 u32 *fwimg)
1643 {
1644 return bfa_flash_raw_read(ioc->pcidev.pci_bar_kva,
1645 BFA_FLASH_PART_FWIMG_ADDR + (off * sizeof(u32)),
1646 (char *)fwimg, BFI_FLASH_CHUNK_SZ);
1647 }
1648
1649 static enum bfi_ioc_img_ver_cmp_e
1650 bfa_ioc_flash_fwver_cmp(struct bfa_ioc_s *ioc,
1651 struct bfi_ioc_image_hdr_s *base_fwhdr)
1652 {
1653 struct bfi_ioc_image_hdr_s *flash_fwhdr;
1654 bfa_status_t status;
1655 u32 fwimg[BFI_FLASH_CHUNK_SZ_WORDS];
1656
1657 status = bfa_ioc_flash_img_get_chnk(ioc, 0, fwimg);
1658 if (status != BFA_STATUS_OK)
1659 return BFI_IOC_IMG_VER_INCOMP;
1660
1661 flash_fwhdr = (struct bfi_ioc_image_hdr_s *) fwimg;
1662 if (bfa_ioc_flash_fwver_valid(flash_fwhdr) == BFA_TRUE)
1663 return bfa_ioc_fw_ver_patch_cmp(base_fwhdr, flash_fwhdr);
1664 else
1665 return BFI_IOC_IMG_VER_INCOMP;
1666 }
1667
1668
1669 /*
1670 * Invalidate fwver signature
1671 */
1672 bfa_status_t
1673 bfa_ioc_fwsig_invalidate(struct bfa_ioc_s *ioc)
1674 {
1675
1676 u32 pgnum, pgoff;
1677 u32 loff = 0;
1678 enum bfi_ioc_state ioc_fwstate;
1679
1680 ioc_fwstate = bfa_ioc_get_cur_ioc_fwstate(ioc);
1681 if (!bfa_ioc_state_disabled(ioc_fwstate))
1682 return BFA_STATUS_ADAPTER_ENABLED;
1683
1684 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1685 pgoff = PSS_SMEM_PGOFF(loff);
1686 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1687 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff, BFA_IOC_FW_INV_SIGN);
1688
1689 return BFA_STATUS_OK;
1690 }
1691
1692 /*
1693 * Conditionally flush any pending message from firmware at start.
1694 */
1695 static void
1696 bfa_ioc_msgflush(struct bfa_ioc_s *ioc)
1697 {
1698 u32 r32;
1699
1700 r32 = readl(ioc->ioc_regs.lpu_mbox_cmd);
1701 if (r32)
1702 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
1703 }
1704
1705 static void
1706 bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force)
1707 {
1708 enum bfi_ioc_state ioc_fwstate;
1709 bfa_boolean_t fwvalid;
1710 u32 boot_type;
1711 u32 boot_env;
1712
1713 ioc_fwstate = bfa_ioc_get_cur_ioc_fwstate(ioc);
1714
1715 if (force)
1716 ioc_fwstate = BFI_IOC_UNINIT;
1717
1718 bfa_trc(ioc, ioc_fwstate);
1719
1720 boot_type = BFI_FWBOOT_TYPE_NORMAL;
1721 boot_env = BFI_FWBOOT_ENV_OS;
1722
1723 /*
1724 * check if firmware is valid
1725 */
1726 fwvalid = (ioc_fwstate == BFI_IOC_UNINIT) ?
1727 BFA_FALSE : bfa_ioc_fwver_valid(ioc, boot_env);
1728
1729 if (!fwvalid) {
1730 if (bfa_ioc_boot(ioc, boot_type, boot_env) == BFA_STATUS_OK)
1731 bfa_ioc_poll_fwinit(ioc);
1732 return;
1733 }
1734
1735 /*
1736 * If hardware initialization is in progress (initialized by other IOC),
1737 * just wait for an initialization completion interrupt.
1738 */
1739 if (ioc_fwstate == BFI_IOC_INITING) {
1740 bfa_ioc_poll_fwinit(ioc);
1741 return;
1742 }
1743
1744 /*
1745 * If IOC function is disabled and firmware version is same,
1746 * just re-enable IOC.
1747 *
1748 * If option rom, IOC must not be in operational state. With
1749 * convergence, IOC will be in operational state when 2nd driver
1750 * is loaded.
1751 */
1752 if (ioc_fwstate == BFI_IOC_DISABLED || ioc_fwstate == BFI_IOC_OP) {
1753
1754 /*
1755 * When using MSI-X any pending firmware ready event should
1756 * be flushed. Otherwise MSI-X interrupts are not delivered.
1757 */
1758 bfa_ioc_msgflush(ioc);
1759 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FWREADY);
1760 return;
1761 }
1762
1763 /*
1764 * Initialize the h/w for any other states.
1765 */
1766 if (bfa_ioc_boot(ioc, boot_type, boot_env) == BFA_STATUS_OK)
1767 bfa_ioc_poll_fwinit(ioc);
1768 }
1769
1770 static void
1771 bfa_ioc_timeout(void *ioc_arg)
1772 {
1773 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
1774
1775 bfa_trc(ioc, 0);
1776 bfa_fsm_send_event(ioc, IOC_E_TIMEOUT);
1777 }
1778
1779 void
1780 bfa_ioc_mbox_send(struct bfa_ioc_s *ioc, void *ioc_msg, int len)
1781 {
1782 u32 *msgp = (u32 *) ioc_msg;
1783 u32 i;
1784
1785 bfa_trc(ioc, msgp[0]);
1786 bfa_trc(ioc, len);
1787
1788 WARN_ON(len > BFI_IOC_MSGLEN_MAX);
1789
1790 /*
1791 * first write msg to mailbox registers
1792 */
1793 for (i = 0; i < len / sizeof(u32); i++)
1794 writel(cpu_to_le32(msgp[i]),
1795 ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1796
1797 for (; i < BFI_IOC_MSGLEN_MAX / sizeof(u32); i++)
1798 writel(0, ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1799
1800 /*
1801 * write 1 to mailbox CMD to trigger LPU event
1802 */
1803 writel(1, ioc->ioc_regs.hfn_mbox_cmd);
1804 (void) readl(ioc->ioc_regs.hfn_mbox_cmd);
1805 }
1806
1807 static void
1808 bfa_ioc_send_enable(struct bfa_ioc_s *ioc)
1809 {
1810 struct bfi_ioc_ctrl_req_s enable_req;
1811 struct timeval tv;
1812
1813 bfi_h2i_set(enable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_ENABLE_REQ,
1814 bfa_ioc_portid(ioc));
1815 enable_req.clscode = cpu_to_be16(ioc->clscode);
1816 do_gettimeofday(&tv);
1817 enable_req.tv_sec = be32_to_cpu(tv.tv_sec);
1818 bfa_ioc_mbox_send(ioc, &enable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1819 }
1820
1821 static void
1822 bfa_ioc_send_disable(struct bfa_ioc_s *ioc)
1823 {
1824 struct bfi_ioc_ctrl_req_s disable_req;
1825
1826 bfi_h2i_set(disable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_DISABLE_REQ,
1827 bfa_ioc_portid(ioc));
1828 bfa_ioc_mbox_send(ioc, &disable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1829 }
1830
1831 static void
1832 bfa_ioc_send_getattr(struct bfa_ioc_s *ioc)
1833 {
1834 struct bfi_ioc_getattr_req_s attr_req;
1835
1836 bfi_h2i_set(attr_req.mh, BFI_MC_IOC, BFI_IOC_H2I_GETATTR_REQ,
1837 bfa_ioc_portid(ioc));
1838 bfa_dma_be_addr_set(attr_req.attr_addr, ioc->attr_dma.pa);
1839 bfa_ioc_mbox_send(ioc, &attr_req, sizeof(attr_req));
1840 }
1841
1842 static void
1843 bfa_ioc_hb_check(void *cbarg)
1844 {
1845 struct bfa_ioc_s *ioc = cbarg;
1846 u32 hb_count;
1847
1848 hb_count = readl(ioc->ioc_regs.heartbeat);
1849 if (ioc->hb_count == hb_count) {
1850 bfa_ioc_recover(ioc);
1851 return;
1852 } else {
1853 ioc->hb_count = hb_count;
1854 }
1855
1856 bfa_ioc_mbox_poll(ioc);
1857 bfa_hb_timer_start(ioc);
1858 }
1859
1860 static void
1861 bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc)
1862 {
1863 ioc->hb_count = readl(ioc->ioc_regs.heartbeat);
1864 bfa_hb_timer_start(ioc);
1865 }
1866
1867 /*
1868 * Initiate a full firmware download.
1869 */
1870 static bfa_status_t
1871 bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
1872 u32 boot_env)
1873 {
1874 u32 *fwimg;
1875 u32 pgnum, pgoff;
1876 u32 loff = 0;
1877 u32 chunkno = 0;
1878 u32 i;
1879 u32 asicmode;
1880 u32 fwimg_size;
1881 u32 fwimg_buf[BFI_FLASH_CHUNK_SZ_WORDS];
1882 bfa_status_t status;
1883
1884 if (boot_env == BFI_FWBOOT_ENV_OS &&
1885 boot_type == BFI_FWBOOT_TYPE_FLASH) {
1886 fwimg_size = BFI_FLASH_IMAGE_SZ/sizeof(u32);
1887
1888 status = bfa_ioc_flash_img_get_chnk(ioc,
1889 BFA_IOC_FLASH_CHUNK_ADDR(chunkno), fwimg_buf);
1890 if (status != BFA_STATUS_OK)
1891 return status;
1892
1893 fwimg = fwimg_buf;
1894 } else {
1895 fwimg_size = bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc));
1896 fwimg = bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc),
1897 BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
1898 }
1899
1900 bfa_trc(ioc, fwimg_size);
1901
1902
1903 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
1904 pgoff = PSS_SMEM_PGOFF(loff);
1905
1906 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1907
1908 for (i = 0; i < fwimg_size; i++) {
1909
1910 if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {
1911 chunkno = BFA_IOC_FLASH_CHUNK_NO(i);
1912
1913 if (boot_env == BFI_FWBOOT_ENV_OS &&
1914 boot_type == BFI_FWBOOT_TYPE_FLASH) {
1915 status = bfa_ioc_flash_img_get_chnk(ioc,
1916 BFA_IOC_FLASH_CHUNK_ADDR(chunkno),
1917 fwimg_buf);
1918 if (status != BFA_STATUS_OK)
1919 return status;
1920
1921 fwimg = fwimg_buf;
1922 } else {
1923 fwimg = bfa_cb_image_get_chunk(
1924 bfa_ioc_asic_gen(ioc),
1925 BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
1926 }
1927 }
1928
1929 /*
1930 * write smem
1931 */
1932 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff,
1933 fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]);
1934
1935 loff += sizeof(u32);
1936
1937 /*
1938 * handle page offset wrap around
1939 */
1940 loff = PSS_SMEM_PGOFF(loff);
1941 if (loff == 0) {
1942 pgnum++;
1943 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1944 }
1945 }
1946
1947 writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
1948 ioc->ioc_regs.host_page_num_fn);
1949
1950 /*
1951 * Set boot type, env and device mode at the end.
1952 */
1953 if (boot_env == BFI_FWBOOT_ENV_OS &&
1954 boot_type == BFI_FWBOOT_TYPE_FLASH) {
1955 boot_type = BFI_FWBOOT_TYPE_NORMAL;
1956 }
1957 asicmode = BFI_FWBOOT_DEVMODE(ioc->asic_gen, ioc->asic_mode,
1958 ioc->port0_mode, ioc->port1_mode);
1959 bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_FWBOOT_DEVMODE_OFF,
1960 swab32(asicmode));
1961 bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_FWBOOT_TYPE_OFF,
1962 swab32(boot_type));
1963 bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_FWBOOT_ENV_OFF,
1964 swab32(boot_env));
1965 return BFA_STATUS_OK;
1966 }
1967
1968
1969 /*
1970 * Update BFA configuration from firmware configuration.
1971 */
1972 static void
1973 bfa_ioc_getattr_reply(struct bfa_ioc_s *ioc)
1974 {
1975 struct bfi_ioc_attr_s *attr = ioc->attr;
1976
1977 attr->adapter_prop = be32_to_cpu(attr->adapter_prop);
1978 attr->card_type = be32_to_cpu(attr->card_type);
1979 attr->maxfrsize = be16_to_cpu(attr->maxfrsize);
1980 ioc->fcmode = (attr->port_mode == BFI_PORT_MODE_FC);
1981 attr->mfg_year = be16_to_cpu(attr->mfg_year);
1982
1983 bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR);
1984 }
1985
1986 /*
1987 * Attach time initialization of mbox logic.
1988 */
1989 static void
1990 bfa_ioc_mbox_attach(struct bfa_ioc_s *ioc)
1991 {
1992 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1993 int mc;
1994
1995 INIT_LIST_HEAD(&mod->cmd_q);
1996 for (mc = 0; mc < BFI_MC_MAX; mc++) {
1997 mod->mbhdlr[mc].cbfn = NULL;
1998 mod->mbhdlr[mc].cbarg = ioc->bfa;
1999 }
2000 }
2001
2002 /*
2003 * Mbox poll timer -- restarts any pending mailbox requests.
2004 */
2005 static void
2006 bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc)
2007 {
2008 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2009 struct bfa_mbox_cmd_s *cmd;
2010 u32 stat;
2011
2012 /*
2013 * If no command pending, do nothing
2014 */
2015 if (list_empty(&mod->cmd_q))
2016 return;
2017
2018 /*
2019 * If previous command is not yet fetched by firmware, do nothing
2020 */
2021 stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
2022 if (stat)
2023 return;
2024
2025 /*
2026 * Enqueue command to firmware.
2027 */
2028 bfa_q_deq(&mod->cmd_q, &cmd);
2029 bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
2030 }
2031
2032 /*
2033 * Cleanup any pending requests.
2034 */
2035 static void
2036 bfa_ioc_mbox_flush(struct bfa_ioc_s *ioc)
2037 {
2038 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2039 struct bfa_mbox_cmd_s *cmd;
2040
2041 while (!list_empty(&mod->cmd_q))
2042 bfa_q_deq(&mod->cmd_q, &cmd);
2043 }
2044
2045 /*
2046 * Read data from SMEM to host through PCI memmap
2047 *
2048 * @param[in] ioc memory for IOC
2049 * @param[in] tbuf app memory to store data from smem
2050 * @param[in] soff smem offset
2051 * @param[in] sz size of smem in bytes
2052 */
2053 static bfa_status_t
2054 bfa_ioc_smem_read(struct bfa_ioc_s *ioc, void *tbuf, u32 soff, u32 sz)
2055 {
2056 u32 pgnum, loff;
2057 __be32 r32;
2058 int i, len;
2059 u32 *buf = tbuf;
2060
2061 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, soff);
2062 loff = PSS_SMEM_PGOFF(soff);
2063 bfa_trc(ioc, pgnum);
2064 bfa_trc(ioc, loff);
2065 bfa_trc(ioc, sz);
2066
2067 /*
2068 * Hold semaphore to serialize pll init and fwtrc.
2069 */
2070 if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {
2071 bfa_trc(ioc, 0);
2072 return BFA_STATUS_FAILED;
2073 }
2074
2075 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
2076
2077 len = sz/sizeof(u32);
2078 bfa_trc(ioc, len);
2079 for (i = 0; i < len; i++) {
2080 r32 = bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
2081 buf[i] = swab32(r32);
2082 loff += sizeof(u32);
2083
2084 /*
2085 * handle page offset wrap around
2086 */
2087 loff = PSS_SMEM_PGOFF(loff);
2088 if (loff == 0) {
2089 pgnum++;
2090 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
2091 }
2092 }
2093 writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
2094 ioc->ioc_regs.host_page_num_fn);
2095 /*
2096 * release semaphore.
2097 */
2098 readl(ioc->ioc_regs.ioc_init_sem_reg);
2099 writel(1, ioc->ioc_regs.ioc_init_sem_reg);
2100
2101 bfa_trc(ioc, pgnum);
2102 return BFA_STATUS_OK;
2103 }
2104
2105 /*
2106 * Clear SMEM data from host through PCI memmap
2107 *
2108 * @param[in] ioc memory for IOC
2109 * @param[in] soff smem offset
2110 * @param[in] sz size of smem in bytes
2111 */
2112 static bfa_status_t
2113 bfa_ioc_smem_clr(struct bfa_ioc_s *ioc, u32 soff, u32 sz)
2114 {
2115 int i, len;
2116 u32 pgnum, loff;
2117
2118 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, soff);
2119 loff = PSS_SMEM_PGOFF(soff);
2120 bfa_trc(ioc, pgnum);
2121 bfa_trc(ioc, loff);
2122 bfa_trc(ioc, sz);
2123
2124 /*
2125 * Hold semaphore to serialize pll init and fwtrc.
2126 */
2127 if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {
2128 bfa_trc(ioc, 0);
2129 return BFA_STATUS_FAILED;
2130 }
2131
2132 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
2133
2134 len = sz/sizeof(u32); /* len in words */
2135 bfa_trc(ioc, len);
2136 for (i = 0; i < len; i++) {
2137 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff, 0);
2138 loff += sizeof(u32);
2139
2140 /*
2141 * handle page offset wrap around
2142 */
2143 loff = PSS_SMEM_PGOFF(loff);
2144 if (loff == 0) {
2145 pgnum++;
2146 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
2147 }
2148 }
2149 writel(PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, 0),
2150 ioc->ioc_regs.host_page_num_fn);
2151
2152 /*
2153 * release semaphore.
2154 */
2155 readl(ioc->ioc_regs.ioc_init_sem_reg);
2156 writel(1, ioc->ioc_regs.ioc_init_sem_reg);
2157 bfa_trc(ioc, pgnum);
2158 return BFA_STATUS_OK;
2159 }
2160
2161 static void
2162 bfa_ioc_fail_notify(struct bfa_ioc_s *ioc)
2163 {
2164 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
2165
2166 /*
2167 * Notify driver and common modules registered for notification.
2168 */
2169 ioc->cbfn->hbfail_cbfn(ioc->bfa);
2170 bfa_ioc_event_notify(ioc, BFA_IOC_E_FAILED);
2171
2172 bfa_ioc_debug_save_ftrc(ioc);
2173
2174 BFA_LOG(KERN_CRIT, bfad, bfa_log_level,
2175 "Heart Beat of IOC has failed\n");
2176 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_HBFAIL);
2177
2178 }
2179
2180 static void
2181 bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc)
2182 {
2183 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
2184 /*
2185 * Provide enable completion callback.
2186 */
2187 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
2188 BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
2189 "Running firmware version is incompatible "
2190 "with the driver version\n");
2191 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_FWMISMATCH);
2192 }
2193
2194 bfa_status_t
2195 bfa_ioc_pll_init(struct bfa_ioc_s *ioc)
2196 {
2197
2198 /*
2199 * Hold semaphore so that nobody can access the chip during init.
2200 */
2201 bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg);
2202
2203 bfa_ioc_pll_init_asic(ioc);
2204
2205 ioc->pllinit = BFA_TRUE;
2206
2207 /*
2208 * Initialize LMEM
2209 */
2210 bfa_ioc_lmem_init(ioc);
2211
2212 /*
2213 * release semaphore.
2214 */
2215 readl(ioc->ioc_regs.ioc_init_sem_reg);
2216 writel(1, ioc->ioc_regs.ioc_init_sem_reg);
2217
2218 return BFA_STATUS_OK;
2219 }
2220
2221 /*
2222 * Interface used by diag module to do firmware boot with memory test
2223 * as the entry vector.
2224 */
2225 bfa_status_t
2226 bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type, u32 boot_env)
2227 {
2228 struct bfi_ioc_image_hdr_s *drv_fwhdr;
2229 bfa_status_t status;
2230 bfa_ioc_stats(ioc, ioc_boots);
2231
2232 if (bfa_ioc_pll_init(ioc) != BFA_STATUS_OK)
2233 return BFA_STATUS_FAILED;
2234
2235 if (boot_env == BFI_FWBOOT_ENV_OS &&
2236 boot_type == BFI_FWBOOT_TYPE_NORMAL) {
2237
2238 drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
2239 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
2240
2241 /*
2242 * Work with Flash iff flash f/w is better than driver f/w.
2243 * Otherwise push drivers firmware.
2244 */
2245 if (bfa_ioc_flash_fwver_cmp(ioc, drv_fwhdr) ==
2246 BFI_IOC_IMG_VER_BETTER)
2247 boot_type = BFI_FWBOOT_TYPE_FLASH;
2248 }
2249
2250 /*
2251 * Initialize IOC state of all functions on a chip reset.
2252 */
2253 if (boot_type == BFI_FWBOOT_TYPE_MEMTEST) {
2254 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_MEMTEST);
2255 bfa_ioc_set_alt_ioc_fwstate(ioc, BFI_IOC_MEMTEST);
2256 } else {
2257 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_INITING);
2258 bfa_ioc_set_alt_ioc_fwstate(ioc, BFI_IOC_INITING);
2259 }
2260
2261 bfa_ioc_msgflush(ioc);
2262 status = bfa_ioc_download_fw(ioc, boot_type, boot_env);
2263 if (status == BFA_STATUS_OK)
2264 bfa_ioc_lpu_start(ioc);
2265 else {
2266 WARN_ON(boot_type == BFI_FWBOOT_TYPE_MEMTEST);
2267 bfa_iocpf_timeout(ioc);
2268 }
2269 return status;
2270 }
2271
2272 /*
2273 * Enable/disable IOC failure auto recovery.
2274 */
2275 void
2276 bfa_ioc_auto_recover(bfa_boolean_t auto_recover)
2277 {
2278 bfa_auto_recover = auto_recover;
2279 }
2280
2281
2282
2283 bfa_boolean_t
2284 bfa_ioc_is_operational(struct bfa_ioc_s *ioc)
2285 {
2286 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_op);
2287 }
2288
2289 bfa_boolean_t
2290 bfa_ioc_is_initialized(struct bfa_ioc_s *ioc)
2291 {
2292 u32 r32 = bfa_ioc_get_cur_ioc_fwstate(ioc);
2293
2294 return ((r32 != BFI_IOC_UNINIT) &&
2295 (r32 != BFI_IOC_INITING) &&
2296 (r32 != BFI_IOC_MEMTEST));
2297 }
2298
2299 bfa_boolean_t
2300 bfa_ioc_msgget(struct bfa_ioc_s *ioc, void *mbmsg)
2301 {
2302 __be32 *msgp = mbmsg;
2303 u32 r32;
2304 int i;
2305
2306 r32 = readl(ioc->ioc_regs.lpu_mbox_cmd);
2307 if ((r32 & 1) == 0)
2308 return BFA_FALSE;
2309
2310 /*
2311 * read the MBOX msg
2312 */
2313 for (i = 0; i < (sizeof(union bfi_ioc_i2h_msg_u) / sizeof(u32));
2314 i++) {
2315 r32 = readl(ioc->ioc_regs.lpu_mbox +
2316 i * sizeof(u32));
2317 msgp[i] = cpu_to_be32(r32);
2318 }
2319
2320 /*
2321 * turn off mailbox interrupt by clearing mailbox status
2322 */
2323 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
2324 readl(ioc->ioc_regs.lpu_mbox_cmd);
2325
2326 return BFA_TRUE;
2327 }
2328
2329 void
2330 bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)
2331 {
2332 union bfi_ioc_i2h_msg_u *msg;
2333 struct bfa_iocpf_s *iocpf = &ioc->iocpf;
2334
2335 msg = (union bfi_ioc_i2h_msg_u *) m;
2336
2337 bfa_ioc_stats(ioc, ioc_isrs);
2338
2339 switch (msg->mh.msg_id) {
2340 case BFI_IOC_I2H_HBEAT:
2341 break;
2342
2343 case BFI_IOC_I2H_ENABLE_REPLY:
2344 ioc->port_mode = ioc->port_mode_cfg =
2345 (enum bfa_mode_s)msg->fw_event.port_mode;
2346 ioc->ad_cap_bm = msg->fw_event.cap_bm;
2347 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_ENABLE);
2348 break;
2349
2350 case BFI_IOC_I2H_DISABLE_REPLY:
2351 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_DISABLE);
2352 break;
2353
2354 case BFI_IOC_I2H_GETATTR_REPLY:
2355 bfa_ioc_getattr_reply(ioc);
2356 break;
2357
2358 default:
2359 bfa_trc(ioc, msg->mh.msg_id);
2360 WARN_ON(1);
2361 }
2362 }
2363
2364 /*
2365 * IOC attach time initialization and setup.
2366 *
2367 * @param[in] ioc memory for IOC
2368 * @param[in] bfa driver instance structure
2369 */
2370 void
2371 bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa, struct bfa_ioc_cbfn_s *cbfn,
2372 struct bfa_timer_mod_s *timer_mod)
2373 {
2374 ioc->bfa = bfa;
2375 ioc->cbfn = cbfn;
2376 ioc->timer_mod = timer_mod;
2377 ioc->fcmode = BFA_FALSE;
2378 ioc->pllinit = BFA_FALSE;
2379 ioc->dbg_fwsave_once = BFA_TRUE;
2380 ioc->iocpf.ioc = ioc;
2381
2382 bfa_ioc_mbox_attach(ioc);
2383 INIT_LIST_HEAD(&ioc->notify_q);
2384
2385 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
2386 bfa_fsm_send_event(ioc, IOC_E_RESET);
2387 }
2388
2389 /*
2390 * Driver detach time IOC cleanup.
2391 */
2392 void
2393 bfa_ioc_detach(struct bfa_ioc_s *ioc)
2394 {
2395 bfa_fsm_send_event(ioc, IOC_E_DETACH);
2396 INIT_LIST_HEAD(&ioc->notify_q);
2397 }
2398
2399 /*
2400 * Setup IOC PCI properties.
2401 *
2402 * @param[in] pcidev PCI device information for this IOC
2403 */
2404 void
2405 bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
2406 enum bfi_pcifn_class clscode)
2407 {
2408 ioc->clscode = clscode;
2409 ioc->pcidev = *pcidev;
2410
2411 /*
2412 * Initialize IOC and device personality
2413 */
2414 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_FC;
2415 ioc->asic_mode = BFI_ASIC_MODE_FC;
2416
2417 switch (pcidev->device_id) {
2418 case BFA_PCI_DEVICE_ID_FC_8G1P:
2419 case BFA_PCI_DEVICE_ID_FC_8G2P:
2420 ioc->asic_gen = BFI_ASIC_GEN_CB;
2421 ioc->fcmode = BFA_TRUE;
2422 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_HBA;
2423 ioc->ad_cap_bm = BFA_CM_HBA;
2424 break;
2425
2426 case BFA_PCI_DEVICE_ID_CT:
2427 ioc->asic_gen = BFI_ASIC_GEN_CT;
2428 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_ETH;
2429 ioc->asic_mode = BFI_ASIC_MODE_ETH;
2430 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_CNA;
2431 ioc->ad_cap_bm = BFA_CM_CNA;
2432 break;
2433
2434 case BFA_PCI_DEVICE_ID_CT_FC:
2435 ioc->asic_gen = BFI_ASIC_GEN_CT;
2436 ioc->fcmode = BFA_TRUE;
2437 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_HBA;
2438 ioc->ad_cap_bm = BFA_CM_HBA;
2439 break;
2440
2441 case BFA_PCI_DEVICE_ID_CT2:
2442 case BFA_PCI_DEVICE_ID_CT2_QUAD:
2443 ioc->asic_gen = BFI_ASIC_GEN_CT2;
2444 if (clscode == BFI_PCIFN_CLASS_FC &&
2445 pcidev->ssid == BFA_PCI_CT2_SSID_FC) {
2446 ioc->asic_mode = BFI_ASIC_MODE_FC16;
2447 ioc->fcmode = BFA_TRUE;
2448 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_HBA;
2449 ioc->ad_cap_bm = BFA_CM_HBA;
2450 } else {
2451 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_ETH;
2452 ioc->asic_mode = BFI_ASIC_MODE_ETH;
2453 if (pcidev->ssid == BFA_PCI_CT2_SSID_FCoE) {
2454 ioc->port_mode =
2455 ioc->port_mode_cfg = BFA_MODE_CNA;
2456 ioc->ad_cap_bm = BFA_CM_CNA;
2457 } else {
2458 ioc->port_mode =
2459 ioc->port_mode_cfg = BFA_MODE_NIC;
2460 ioc->ad_cap_bm = BFA_CM_NIC;
2461 }
2462 }
2463 break;
2464
2465 default:
2466 WARN_ON(1);
2467 }
2468
2469 /*
2470 * Set asic specific interfaces. See bfa_ioc_cb.c and bfa_ioc_ct.c
2471 */
2472 if (ioc->asic_gen == BFI_ASIC_GEN_CB)
2473 bfa_ioc_set_cb_hwif(ioc);
2474 else if (ioc->asic_gen == BFI_ASIC_GEN_CT)
2475 bfa_ioc_set_ct_hwif(ioc);
2476 else {
2477 WARN_ON(ioc->asic_gen != BFI_ASIC_GEN_CT2);
2478 bfa_ioc_set_ct2_hwif(ioc);
2479 bfa_ioc_ct2_poweron(ioc);
2480 }
2481
2482 bfa_ioc_map_port(ioc);
2483 bfa_ioc_reg_init(ioc);
2484 }
2485
2486 /*
2487 * Initialize IOC dma memory
2488 *
2489 * @param[in] dm_kva kernel virtual address of IOC dma memory
2490 * @param[in] dm_pa physical address of IOC dma memory
2491 */
2492 void
2493 bfa_ioc_mem_claim(struct bfa_ioc_s *ioc, u8 *dm_kva, u64 dm_pa)
2494 {
2495 /*
2496 * dma memory for firmware attribute
2497 */
2498 ioc->attr_dma.kva = dm_kva;
2499 ioc->attr_dma.pa = dm_pa;
2500 ioc->attr = (struct bfi_ioc_attr_s *) dm_kva;
2501 }
2502
2503 void
2504 bfa_ioc_enable(struct bfa_ioc_s *ioc)
2505 {
2506 bfa_ioc_stats(ioc, ioc_enables);
2507 ioc->dbg_fwsave_once = BFA_TRUE;
2508
2509 bfa_fsm_send_event(ioc, IOC_E_ENABLE);
2510 }
2511
2512 void
2513 bfa_ioc_disable(struct bfa_ioc_s *ioc)
2514 {
2515 bfa_ioc_stats(ioc, ioc_disables);
2516 bfa_fsm_send_event(ioc, IOC_E_DISABLE);
2517 }
2518
2519 void
2520 bfa_ioc_suspend(struct bfa_ioc_s *ioc)
2521 {
2522 ioc->dbg_fwsave_once = BFA_TRUE;
2523 bfa_fsm_send_event(ioc, IOC_E_HWERROR);
2524 }
2525
2526 /*
2527 * Initialize memory for saving firmware trace. Driver must initialize
2528 * trace memory before call bfa_ioc_enable().
2529 */
2530 void
2531 bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
2532 {
2533 ioc->dbg_fwsave = dbg_fwsave;
2534 ioc->dbg_fwsave_len = BFA_DBG_FWTRC_LEN;
2535 }
2536
2537 /*
2538 * Register mailbox message handler functions
2539 *
2540 * @param[in] ioc IOC instance
2541 * @param[in] mcfuncs message class handler functions
2542 */
2543 void
2544 bfa_ioc_mbox_register(struct bfa_ioc_s *ioc, bfa_ioc_mbox_mcfunc_t *mcfuncs)
2545 {
2546 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2547 int mc;
2548
2549 for (mc = 0; mc < BFI_MC_MAX; mc++)
2550 mod->mbhdlr[mc].cbfn = mcfuncs[mc];
2551 }
2552
2553 /*
2554 * Register mailbox message handler function, to be called by common modules
2555 */
2556 void
2557 bfa_ioc_mbox_regisr(struct bfa_ioc_s *ioc, enum bfi_mclass mc,
2558 bfa_ioc_mbox_mcfunc_t cbfn, void *cbarg)
2559 {
2560 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2561
2562 mod->mbhdlr[mc].cbfn = cbfn;
2563 mod->mbhdlr[mc].cbarg = cbarg;
2564 }
2565
2566 /*
2567 * Queue a mailbox command request to firmware. Waits if mailbox is busy.
2568 * Responsibility of caller to serialize
2569 *
2570 * @param[in] ioc IOC instance
2571 * @param[i] cmd Mailbox command
2572 */
2573 void
2574 bfa_ioc_mbox_queue(struct bfa_ioc_s *ioc, struct bfa_mbox_cmd_s *cmd)
2575 {
2576 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2577 u32 stat;
2578
2579 /*
2580 * If a previous command is pending, queue new command
2581 */
2582 if (!list_empty(&mod->cmd_q)) {
2583 list_add_tail(&cmd->qe, &mod->cmd_q);
2584 return;
2585 }
2586
2587 /*
2588 * If mailbox is busy, queue command for poll timer
2589 */
2590 stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
2591 if (stat) {
2592 list_add_tail(&cmd->qe, &mod->cmd_q);
2593 return;
2594 }
2595
2596 /*
2597 * mailbox is free -- queue command to firmware
2598 */
2599 bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
2600 }
2601
2602 /*
2603 * Handle mailbox interrupts
2604 */
2605 void
2606 bfa_ioc_mbox_isr(struct bfa_ioc_s *ioc)
2607 {
2608 struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
2609 struct bfi_mbmsg_s m;
2610 int mc;
2611
2612 if (bfa_ioc_msgget(ioc, &m)) {
2613 /*
2614 * Treat IOC message class as special.
2615 */
2616 mc = m.mh.msg_class;
2617 if (mc == BFI_MC_IOC) {
2618 bfa_ioc_isr(ioc, &m);
2619 return;
2620 }
2621
2622 if ((mc >= BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL))
2623 return;
2624
2625 mod->mbhdlr[mc].cbfn(mod->mbhdlr[mc].cbarg, &m);
2626 }
2627
2628 bfa_ioc_lpu_read_stat(ioc);
2629
2630 /*
2631 * Try to send pending mailbox commands
2632 */
2633 bfa_ioc_mbox_poll(ioc);
2634 }
2635
2636 void
2637 bfa_ioc_error_isr(struct bfa_ioc_s *ioc)
2638 {
2639 bfa_ioc_stats(ioc, ioc_hbfails);
2640 ioc->stats.hb_count = ioc->hb_count;
2641 bfa_fsm_send_event(ioc, IOC_E_HWERROR);
2642 }
2643
2644 /*
2645 * return true if IOC is disabled
2646 */
2647 bfa_boolean_t
2648 bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
2649 {
2650 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling) ||
2651 bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
2652 }
2653
2654 /*
2655 * return true if IOC firmware is different.
2656 */
2657 bfa_boolean_t
2658 bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc)
2659 {
2660 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset) ||
2661 bfa_fsm_cmp_state(&ioc->iocpf, bfa_iocpf_sm_fwcheck) ||
2662 bfa_fsm_cmp_state(&ioc->iocpf, bfa_iocpf_sm_mismatch);
2663 }
2664
2665 /*
2666 * Check if adapter is disabled -- both IOCs should be in a disabled
2667 * state.
2668 */
2669 bfa_boolean_t
2670 bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc)
2671 {
2672 u32 ioc_state;
2673
2674 if (!bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled))
2675 return BFA_FALSE;
2676
2677 ioc_state = bfa_ioc_get_cur_ioc_fwstate(ioc);
2678 if (!bfa_ioc_state_disabled(ioc_state))
2679 return BFA_FALSE;
2680
2681 if (ioc->pcidev.device_id != BFA_PCI_DEVICE_ID_FC_8G1P) {
2682 ioc_state = bfa_ioc_get_cur_ioc_fwstate(ioc);
2683 if (!bfa_ioc_state_disabled(ioc_state))
2684 return BFA_FALSE;
2685 }
2686
2687 return BFA_TRUE;
2688 }
2689
2690 /*
2691 * Reset IOC fwstate registers.
2692 */
2693 void
2694 bfa_ioc_reset_fwstate(struct bfa_ioc_s *ioc)
2695 {
2696 bfa_ioc_set_cur_ioc_fwstate(ioc, BFI_IOC_UNINIT);
2697 bfa_ioc_set_alt_ioc_fwstate(ioc, BFI_IOC_UNINIT);
2698 }
2699
2700 #define BFA_MFG_NAME "Brocade"
2701 void
2702 bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
2703 struct bfa_adapter_attr_s *ad_attr)
2704 {
2705 struct bfi_ioc_attr_s *ioc_attr;
2706
2707 ioc_attr = ioc->attr;
2708
2709 bfa_ioc_get_adapter_serial_num(ioc, ad_attr->serial_num);
2710 bfa_ioc_get_adapter_fw_ver(ioc, ad_attr->fw_ver);
2711 bfa_ioc_get_adapter_optrom_ver(ioc, ad_attr->optrom_ver);
2712 bfa_ioc_get_adapter_manufacturer(ioc, ad_attr->manufacturer);
2713 memcpy(&ad_attr->vpd, &ioc_attr->vpd,
2714 sizeof(struct bfa_mfg_vpd_s));
2715
2716 ad_attr->nports = bfa_ioc_get_nports(ioc);
2717 ad_attr->max_speed = bfa_ioc_speed_sup(ioc);
2718
2719 bfa_ioc_get_adapter_model(ioc, ad_attr->model);
2720 /* For now, model descr uses same model string */
2721 bfa_ioc_get_adapter_model(ioc, ad_attr->model_descr);
2722
2723 ad_attr->card_type = ioc_attr->card_type;
2724 ad_attr->is_mezz = bfa_mfg_is_mezz(ioc_attr->card_type);
2725
2726 if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))
2727 ad_attr->prototype = 1;
2728 else
2729 ad_attr->prototype = 0;
2730
2731 ad_attr->pwwn = ioc->attr->pwwn;
2732 ad_attr->mac = bfa_ioc_get_mac(ioc);
2733
2734 ad_attr->pcie_gen = ioc_attr->pcie_gen;
2735 ad_attr->pcie_lanes = ioc_attr->pcie_lanes;
2736 ad_attr->pcie_lanes_orig = ioc_attr->pcie_lanes_orig;
2737 ad_attr->asic_rev = ioc_attr->asic_rev;
2738
2739 bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);
2740
2741 ad_attr->cna_capable = bfa_ioc_is_cna(ioc);
2742 ad_attr->trunk_capable = (ad_attr->nports > 1) &&
2743 !bfa_ioc_is_cna(ioc) && !ad_attr->is_mezz;
2744 ad_attr->mfg_day = ioc_attr->mfg_day;
2745 ad_attr->mfg_month = ioc_attr->mfg_month;
2746 ad_attr->mfg_year = ioc_attr->mfg_year;
2747 memcpy(ad_attr->uuid, ioc_attr->uuid, BFA_ADAPTER_UUID_LEN);
2748 }
2749
2750 enum bfa_ioc_type_e
2751 bfa_ioc_get_type(struct bfa_ioc_s *ioc)
2752 {
2753 if (ioc->clscode == BFI_PCIFN_CLASS_ETH)
2754 return BFA_IOC_TYPE_LL;
2755
2756 WARN_ON(ioc->clscode != BFI_PCIFN_CLASS_FC);
2757
2758 return (ioc->attr->port_mode == BFI_PORT_MODE_FC)
2759 ? BFA_IOC_TYPE_FC : BFA_IOC_TYPE_FCoE;
2760 }
2761
2762 void
2763 bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num)
2764 {
2765 memset((void *)serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);
2766 memcpy((void *)serial_num,
2767 (void *)ioc->attr->brcd_serialnum,
2768 BFA_ADAPTER_SERIAL_NUM_LEN);
2769 }
2770
2771 void
2772 bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver)
2773 {
2774 memset((void *)fw_ver, 0, BFA_VERSION_LEN);
2775 memcpy(fw_ver, ioc->attr->fw_version, BFA_VERSION_LEN);
2776 }
2777
2778 void
2779 bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev)
2780 {
2781 WARN_ON(!chip_rev);
2782
2783 memset((void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);
2784
2785 chip_rev[0] = 'R';
2786 chip_rev[1] = 'e';
2787 chip_rev[2] = 'v';
2788 chip_rev[3] = '-';
2789 chip_rev[4] = ioc->attr->asic_rev;
2790 chip_rev[5] = '\0';
2791 }
2792
2793 void
2794 bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver)
2795 {
2796 memset((void *)optrom_ver, 0, BFA_VERSION_LEN);
2797 memcpy(optrom_ver, ioc->attr->optrom_version,
2798 BFA_VERSION_LEN);
2799 }
2800
2801 void
2802 bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc, char *manufacturer)
2803 {
2804 memset((void *)manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);
2805 memcpy(manufacturer, BFA_MFG_NAME, BFA_ADAPTER_MFG_NAME_LEN);
2806 }
2807
2808 void
2809 bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model)
2810 {
2811 struct bfi_ioc_attr_s *ioc_attr;
2812 u8 nports = bfa_ioc_get_nports(ioc);
2813
2814 WARN_ON(!model);
2815 memset((void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);
2816
2817 ioc_attr = ioc->attr;
2818
2819 if (bfa_asic_id_ct2(ioc->pcidev.device_id) &&
2820 (!bfa_mfg_is_mezz(ioc_attr->card_type)))
2821 snprintf(model, BFA_ADAPTER_MODEL_NAME_LEN, "%s-%u-%u%s",
2822 BFA_MFG_NAME, ioc_attr->card_type, nports, "p");
2823 else
2824 snprintf(model, BFA_ADAPTER_MODEL_NAME_LEN, "%s-%u",
2825 BFA_MFG_NAME, ioc_attr->card_type);
2826 }
2827
2828 enum bfa_ioc_state
2829 bfa_ioc_get_state(struct bfa_ioc_s *ioc)
2830 {
2831 enum bfa_iocpf_state iocpf_st;
2832 enum bfa_ioc_state ioc_st = bfa_sm_to_state(ioc_sm_table, ioc->fsm);
2833
2834 if (ioc_st == BFA_IOC_ENABLING ||
2835 ioc_st == BFA_IOC_FAIL || ioc_st == BFA_IOC_INITFAIL) {
2836
2837 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm);
2838
2839 switch (iocpf_st) {
2840 case BFA_IOCPF_SEMWAIT:
2841 ioc_st = BFA_IOC_SEMWAIT;
2842 break;
2843
2844 case BFA_IOCPF_HWINIT:
2845 ioc_st = BFA_IOC_HWINIT;
2846 break;
2847
2848 case BFA_IOCPF_FWMISMATCH:
2849 ioc_st = BFA_IOC_FWMISMATCH;
2850 break;
2851
2852 case BFA_IOCPF_FAIL:
2853 ioc_st = BFA_IOC_FAIL;
2854 break;
2855
2856 case BFA_IOCPF_INITFAIL:
2857 ioc_st = BFA_IOC_INITFAIL;
2858 break;
2859
2860 default:
2861 break;
2862 }
2863 }
2864
2865 return ioc_st;
2866 }
2867
2868 void
2869 bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr)
2870 {
2871 memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr_s));
2872
2873 ioc_attr->state = bfa_ioc_get_state(ioc);
2874 ioc_attr->port_id = bfa_ioc_portid(ioc);
2875 ioc_attr->port_mode = ioc->port_mode;
2876 ioc_attr->port_mode_cfg = ioc->port_mode_cfg;
2877 ioc_attr->cap_bm = ioc->ad_cap_bm;
2878
2879 ioc_attr->ioc_type = bfa_ioc_get_type(ioc);
2880
2881 bfa_ioc_get_adapter_attr(ioc, &ioc_attr->adapter_attr);
2882
2883 ioc_attr->pci_attr.device_id = bfa_ioc_devid(ioc);
2884 ioc_attr->pci_attr.pcifn = bfa_ioc_pcifn(ioc);
2885 ioc_attr->def_fn = (bfa_ioc_pcifn(ioc) == bfa_ioc_portid(ioc));
2886 bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
2887 }
2888
2889 mac_t
2890 bfa_ioc_get_mac(struct bfa_ioc_s *ioc)
2891 {
2892 /*
2893 * Check the IOC type and return the appropriate MAC
2894 */
2895 if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_FCoE)
2896 return ioc->attr->fcoe_mac;
2897 else
2898 return ioc->attr->mac;
2899 }
2900
2901 mac_t
2902 bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc)
2903 {
2904 mac_t m;
2905
2906 m = ioc->attr->mfg_mac;
2907 if (bfa_mfg_is_old_wwn_mac_model(ioc->attr->card_type))
2908 m.mac[MAC_ADDRLEN - 1] += bfa_ioc_pcifn(ioc);
2909 else
2910 bfa_mfg_increment_wwn_mac(&(m.mac[MAC_ADDRLEN-3]),
2911 bfa_ioc_pcifn(ioc));
2912
2913 return m;
2914 }
2915
2916 /*
2917 * Send AEN notification
2918 */
2919 void
2920 bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event)
2921 {
2922 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
2923 struct bfa_aen_entry_s *aen_entry;
2924 enum bfa_ioc_type_e ioc_type;
2925
2926 bfad_get_aen_entry(bfad, aen_entry);
2927 if (!aen_entry)
2928 return;
2929
2930 ioc_type = bfa_ioc_get_type(ioc);
2931 switch (ioc_type) {
2932 case BFA_IOC_TYPE_FC:
2933 aen_entry->aen_data.ioc.pwwn = ioc->attr->pwwn;
2934 break;
2935 case BFA_IOC_TYPE_FCoE:
2936 aen_entry->aen_data.ioc.pwwn = ioc->attr->pwwn;
2937 aen_entry->aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
2938 break;
2939 case BFA_IOC_TYPE_LL:
2940 aen_entry->aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
2941 break;
2942 default:
2943 WARN_ON(ioc_type != BFA_IOC_TYPE_FC);
2944 break;
2945 }
2946
2947 /* Send the AEN notification */
2948 aen_entry->aen_data.ioc.ioc_type = ioc_type;
2949 bfad_im_post_vendor_event(aen_entry, bfad, ++ioc->ioc_aen_seq,
2950 BFA_AEN_CAT_IOC, event);
2951 }
2952
2953 /*
2954 * Retrieve saved firmware trace from a prior IOC failure.
2955 */
2956 bfa_status_t
2957 bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
2958 {
2959 int tlen;
2960
2961 if (ioc->dbg_fwsave_len == 0)
2962 return BFA_STATUS_ENOFSAVE;
2963
2964 tlen = *trclen;
2965 if (tlen > ioc->dbg_fwsave_len)
2966 tlen = ioc->dbg_fwsave_len;
2967
2968 memcpy(trcdata, ioc->dbg_fwsave, tlen);
2969 *trclen = tlen;
2970 return BFA_STATUS_OK;
2971 }
2972
2973
2974 /*
2975 * Retrieve saved firmware trace from a prior IOC failure.
2976 */
2977 bfa_status_t
2978 bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
2979 {
2980 u32 loff = BFA_DBG_FWTRC_OFF(bfa_ioc_portid(ioc));
2981 int tlen;
2982 bfa_status_t status;
2983
2984 bfa_trc(ioc, *trclen);
2985
2986 tlen = *trclen;
2987 if (tlen > BFA_DBG_FWTRC_LEN)
2988 tlen = BFA_DBG_FWTRC_LEN;
2989
2990 status = bfa_ioc_smem_read(ioc, trcdata, loff, tlen);
2991 *trclen = tlen;
2992 return status;
2993 }
2994
2995 static void
2996 bfa_ioc_send_fwsync(struct bfa_ioc_s *ioc)
2997 {
2998 struct bfa_mbox_cmd_s cmd;
2999 struct bfi_ioc_ctrl_req_s *req = (struct bfi_ioc_ctrl_req_s *) cmd.msg;
3000
3001 bfi_h2i_set(req->mh, BFI_MC_IOC, BFI_IOC_H2I_DBG_SYNC,
3002 bfa_ioc_portid(ioc));
3003 req->clscode = cpu_to_be16(ioc->clscode);
3004 bfa_ioc_mbox_queue(ioc, &cmd);
3005 }
3006
3007 static void
3008 bfa_ioc_fwsync(struct bfa_ioc_s *ioc)
3009 {
3010 u32 fwsync_iter = 1000;
3011
3012 bfa_ioc_send_fwsync(ioc);
3013
3014 /*
3015 * After sending a fw sync mbox command wait for it to
3016 * take effect. We will not wait for a response because
3017 * 1. fw_sync mbox cmd doesn't have a response.
3018 * 2. Even if we implement that, interrupts might not
3019 * be enabled when we call this function.
3020 * So, just keep checking if any mbox cmd is pending, and
3021 * after waiting for a reasonable amount of time, go ahead.
3022 * It is possible that fw has crashed and the mbox command
3023 * is never acknowledged.
3024 */
3025 while (bfa_ioc_mbox_cmd_pending(ioc) && fwsync_iter > 0)
3026 fwsync_iter--;
3027 }
3028
3029 /*
3030 * Dump firmware smem
3031 */
3032 bfa_status_t
3033 bfa_ioc_debug_fwcore(struct bfa_ioc_s *ioc, void *buf,
3034 u32 *offset, int *buflen)
3035 {
3036 u32 loff;
3037 int dlen;
3038 bfa_status_t status;
3039 u32 smem_len = BFA_IOC_FW_SMEM_SIZE(ioc);
3040
3041 if (*offset >= smem_len) {
3042 *offset = *buflen = 0;
3043 return BFA_STATUS_EINVAL;
3044 }
3045
3046 loff = *offset;
3047 dlen = *buflen;
3048
3049 /*
3050 * First smem read, sync smem before proceeding
3051 * No need to sync before reading every chunk.
3052 */
3053 if (loff == 0)
3054 bfa_ioc_fwsync(ioc);
3055
3056 if ((loff + dlen) >= smem_len)
3057 dlen = smem_len - loff;
3058
3059 status = bfa_ioc_smem_read(ioc, buf, loff, dlen);
3060
3061 if (status != BFA_STATUS_OK) {
3062 *offset = *buflen = 0;
3063 return status;
3064 }
3065
3066 *offset += dlen;
3067
3068 if (*offset >= smem_len)
3069 *offset = 0;
3070
3071 *buflen = dlen;
3072
3073 return status;
3074 }
3075
3076 /*
3077 * Firmware statistics
3078 */
3079 bfa_status_t
3080 bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats)
3081 {
3082 u32 loff = BFI_IOC_FWSTATS_OFF + \
3083 BFI_IOC_FWSTATS_SZ * (bfa_ioc_portid(ioc));
3084 int tlen;
3085 bfa_status_t status;
3086
3087 if (ioc->stats_busy) {
3088 bfa_trc(ioc, ioc->stats_busy);
3089 return BFA_STATUS_DEVBUSY;
3090 }
3091 ioc->stats_busy = BFA_TRUE;
3092
3093 tlen = sizeof(struct bfa_fw_stats_s);
3094 status = bfa_ioc_smem_read(ioc, stats, loff, tlen);
3095
3096 ioc->stats_busy = BFA_FALSE;
3097 return status;
3098 }
3099
3100 bfa_status_t
3101 bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc)
3102 {
3103 u32 loff = BFI_IOC_FWSTATS_OFF + \
3104 BFI_IOC_FWSTATS_SZ * (bfa_ioc_portid(ioc));
3105 int tlen;
3106 bfa_status_t status;
3107
3108 if (ioc->stats_busy) {
3109 bfa_trc(ioc, ioc->stats_busy);
3110 return BFA_STATUS_DEVBUSY;
3111 }
3112 ioc->stats_busy = BFA_TRUE;
3113
3114 tlen = sizeof(struct bfa_fw_stats_s);
3115 status = bfa_ioc_smem_clr(ioc, loff, tlen);
3116
3117 ioc->stats_busy = BFA_FALSE;
3118 return status;
3119 }
3120
3121 /*
3122 * Save firmware trace if configured.
3123 */
3124 void
3125 bfa_ioc_debug_save_ftrc(struct bfa_ioc_s *ioc)
3126 {
3127 int tlen;
3128
3129 if (ioc->dbg_fwsave_once) {
3130 ioc->dbg_fwsave_once = BFA_FALSE;
3131 if (ioc->dbg_fwsave_len) {
3132 tlen = ioc->dbg_fwsave_len;
3133 bfa_ioc_debug_fwtrc(ioc, ioc->dbg_fwsave, &tlen);
3134 }
3135 }
3136 }
3137
3138 /*
3139 * Firmware failure detected. Start recovery actions.
3140 */
3141 static void
3142 bfa_ioc_recover(struct bfa_ioc_s *ioc)
3143 {
3144 bfa_ioc_stats(ioc, ioc_hbfails);
3145 ioc->stats.hb_count = ioc->hb_count;
3146 bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
3147 }
3148
3149 /*
3150 * BFA IOC PF private functions
3151 */
3152 static void
3153 bfa_iocpf_timeout(void *ioc_arg)
3154 {
3155 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
3156
3157 bfa_trc(ioc, 0);
3158 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_TIMEOUT);
3159 }
3160
3161 static void
3162 bfa_iocpf_sem_timeout(void *ioc_arg)
3163 {
3164 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
3165
3166 bfa_ioc_hw_sem_get(ioc);
3167 }
3168
3169 static void
3170 bfa_ioc_poll_fwinit(struct bfa_ioc_s *ioc)
3171 {
3172 u32 fwstate = bfa_ioc_get_cur_ioc_fwstate(ioc);
3173
3174 bfa_trc(ioc, fwstate);
3175
3176 if (fwstate == BFI_IOC_DISABLED) {
3177 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FWREADY);
3178 return;
3179 }
3180
3181 if (ioc->iocpf.poll_time >= (3 * BFA_IOC_TOV))
3182 bfa_iocpf_timeout(ioc);
3183 else {
3184 ioc->iocpf.poll_time += BFA_IOC_POLL_TOV;
3185 bfa_iocpf_poll_timer_start(ioc);
3186 }
3187 }
3188
3189 static void
3190 bfa_iocpf_poll_timeout(void *ioc_arg)
3191 {
3192 struct bfa_ioc_s *ioc = (struct bfa_ioc_s *) ioc_arg;
3193
3194 bfa_ioc_poll_fwinit(ioc);
3195 }
3196
3197 /*
3198 * bfa timer function
3199 */
3200 void
3201 bfa_timer_beat(struct bfa_timer_mod_s *mod)
3202 {
3203 struct list_head *qh = &mod->timer_q;
3204 struct list_head *qe, *qe_next;
3205 struct bfa_timer_s *elem;
3206 struct list_head timedout_q;
3207
3208 INIT_LIST_HEAD(&timedout_q);
3209
3210 qe = bfa_q_next(qh);
3211
3212 while (qe != qh) {
3213 qe_next = bfa_q_next(qe);
3214
3215 elem = (struct bfa_timer_s *) qe;
3216 if (elem->timeout <= BFA_TIMER_FREQ) {
3217 elem->timeout = 0;
3218 list_del(&elem->qe);
3219 list_add_tail(&elem->qe, &timedout_q);
3220 } else {
3221 elem->timeout -= BFA_TIMER_FREQ;
3222 }
3223
3224 qe = qe_next; /* go to next elem */
3225 }
3226
3227 /*
3228 * Pop all the timeout entries
3229 */
3230 while (!list_empty(&timedout_q)) {
3231 bfa_q_deq(&timedout_q, &elem);
3232 elem->timercb(elem->arg);
3233 }
3234 }
3235
3236 /*
3237 * Should be called with lock protection
3238 */
3239 void
3240 bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer,
3241 void (*timercb) (void *), void *arg, unsigned int timeout)
3242 {
3243
3244 WARN_ON(timercb == NULL);
3245 WARN_ON(bfa_q_is_on_q(&mod->timer_q, timer));
3246
3247 timer->timeout = timeout;
3248 timer->timercb = timercb;
3249 timer->arg = arg;
3250
3251 list_add_tail(&timer->qe, &mod->timer_q);
3252 }
3253
3254 /*
3255 * Should be called with lock protection
3256 */
3257 void
3258 bfa_timer_stop(struct bfa_timer_s *timer)
3259 {
3260 WARN_ON(list_empty(&timer->qe));
3261
3262 list_del(&timer->qe);
3263 }
3264
3265 /*
3266 * ASIC block related
3267 */
3268 static void
3269 bfa_ablk_config_swap(struct bfa_ablk_cfg_s *cfg)
3270 {
3271 struct bfa_ablk_cfg_inst_s *cfg_inst;
3272 int i, j;
3273 u16 be16;
3274
3275 for (i = 0; i < BFA_ABLK_MAX; i++) {
3276 cfg_inst = &cfg->inst[i];
3277 for (j = 0; j < BFA_ABLK_MAX_PFS; j++) {
3278 be16 = cfg_inst->pf_cfg[j].pers;
3279 cfg_inst->pf_cfg[j].pers = be16_to_cpu(be16);
3280 be16 = cfg_inst->pf_cfg[j].num_qpairs;
3281 cfg_inst->pf_cfg[j].num_qpairs = be16_to_cpu(be16);
3282 be16 = cfg_inst->pf_cfg[j].num_vectors;
3283 cfg_inst->pf_cfg[j].num_vectors = be16_to_cpu(be16);
3284 be16 = cfg_inst->pf_cfg[j].bw_min;
3285 cfg_inst->pf_cfg[j].bw_min = be16_to_cpu(be16);
3286 be16 = cfg_inst->pf_cfg[j].bw_max;
3287 cfg_inst->pf_cfg[j].bw_max = be16_to_cpu(be16);
3288 }
3289 }
3290 }
3291
3292 static void
3293 bfa_ablk_isr(void *cbarg, struct bfi_mbmsg_s *msg)
3294 {
3295 struct bfa_ablk_s *ablk = (struct bfa_ablk_s *)cbarg;
3296 struct bfi_ablk_i2h_rsp_s *rsp = (struct bfi_ablk_i2h_rsp_s *)msg;
3297 bfa_ablk_cbfn_t cbfn;
3298
3299 WARN_ON(msg->mh.msg_class != BFI_MC_ABLK);
3300 bfa_trc(ablk->ioc, msg->mh.msg_id);
3301
3302 switch (msg->mh.msg_id) {
3303 case BFI_ABLK_I2H_QUERY:
3304 if (rsp->status == BFA_STATUS_OK) {
3305 memcpy(ablk->cfg, ablk->dma_addr.kva,
3306 sizeof(struct bfa_ablk_cfg_s));
3307 bfa_ablk_config_swap(ablk->cfg);
3308 ablk->cfg = NULL;
3309 }
3310 break;
3311
3312 case BFI_ABLK_I2H_ADPT_CONFIG:
3313 case BFI_ABLK_I2H_PORT_CONFIG:
3314 /* update config port mode */
3315 ablk->ioc->port_mode_cfg = rsp->port_mode;
3316
3317 case BFI_ABLK_I2H_PF_DELETE:
3318 case BFI_ABLK_I2H_PF_UPDATE:
3319 case BFI_ABLK_I2H_OPTROM_ENABLE:
3320 case BFI_ABLK_I2H_OPTROM_DISABLE:
3321 /* No-op */
3322 break;
3323
3324 case BFI_ABLK_I2H_PF_CREATE:
3325 *(ablk->pcifn) = rsp->pcifn;
3326 ablk->pcifn = NULL;
3327 break;
3328
3329 default:
3330 WARN_ON(1);
3331 }
3332
3333 ablk->busy = BFA_FALSE;
3334 if (ablk->cbfn) {
3335 cbfn = ablk->cbfn;
3336 ablk->cbfn = NULL;
3337 cbfn(ablk->cbarg, rsp->status);
3338 }
3339 }
3340
3341 static void
3342 bfa_ablk_notify(void *cbarg, enum bfa_ioc_event_e event)
3343 {
3344 struct bfa_ablk_s *ablk = (struct bfa_ablk_s *)cbarg;
3345
3346 bfa_trc(ablk->ioc, event);
3347
3348 switch (event) {
3349 case BFA_IOC_E_ENABLED:
3350 WARN_ON(ablk->busy != BFA_FALSE);
3351 break;
3352
3353 case BFA_IOC_E_DISABLED:
3354 case BFA_IOC_E_FAILED:
3355 /* Fail any pending requests */
3356 ablk->pcifn = NULL;
3357 if (ablk->busy) {
3358 if (ablk->cbfn)
3359 ablk->cbfn(ablk->cbarg, BFA_STATUS_FAILED);
3360 ablk->cbfn = NULL;
3361 ablk->busy = BFA_FALSE;
3362 }
3363 break;
3364
3365 default:
3366 WARN_ON(1);
3367 break;
3368 }
3369 }
3370
3371 u32
3372 bfa_ablk_meminfo(void)
3373 {
3374 return BFA_ROUNDUP(sizeof(struct bfa_ablk_cfg_s), BFA_DMA_ALIGN_SZ);
3375 }
3376
3377 void
3378 bfa_ablk_memclaim(struct bfa_ablk_s *ablk, u8 *dma_kva, u64 dma_pa)
3379 {
3380 ablk->dma_addr.kva = dma_kva;
3381 ablk->dma_addr.pa = dma_pa;
3382 }
3383
3384 void
3385 bfa_ablk_attach(struct bfa_ablk_s *ablk, struct bfa_ioc_s *ioc)
3386 {
3387 ablk->ioc = ioc;
3388
3389 bfa_ioc_mbox_regisr(ablk->ioc, BFI_MC_ABLK, bfa_ablk_isr, ablk);
3390 bfa_q_qe_init(&ablk->ioc_notify);
3391 bfa_ioc_notify_init(&ablk->ioc_notify, bfa_ablk_notify, ablk);
3392 list_add_tail(&ablk->ioc_notify.qe, &ablk->ioc->notify_q);
3393 }
3394
3395 bfa_status_t
3396 bfa_ablk_query(struct bfa_ablk_s *ablk, struct bfa_ablk_cfg_s *ablk_cfg,
3397 bfa_ablk_cbfn_t cbfn, void *cbarg)
3398 {
3399 struct bfi_ablk_h2i_query_s *m;
3400
3401 WARN_ON(!ablk_cfg);
3402
3403 if (!bfa_ioc_is_operational(ablk->ioc)) {
3404 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3405 return BFA_STATUS_IOC_FAILURE;
3406 }
3407
3408 if (ablk->busy) {
3409 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3410 return BFA_STATUS_DEVBUSY;
3411 }
3412
3413 ablk->cfg = ablk_cfg;
3414 ablk->cbfn = cbfn;
3415 ablk->cbarg = cbarg;
3416 ablk->busy = BFA_TRUE;
3417
3418 m = (struct bfi_ablk_h2i_query_s *)ablk->mb.msg;
3419 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_QUERY,
3420 bfa_ioc_portid(ablk->ioc));
3421 bfa_dma_be_addr_set(m->addr, ablk->dma_addr.pa);
3422 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3423
3424 return BFA_STATUS_OK;
3425 }
3426
3427 bfa_status_t
3428 bfa_ablk_pf_create(struct bfa_ablk_s *ablk, u16 *pcifn,
3429 u8 port, enum bfi_pcifn_class personality,
3430 u16 bw_min, u16 bw_max,
3431 bfa_ablk_cbfn_t cbfn, void *cbarg)
3432 {
3433 struct bfi_ablk_h2i_pf_req_s *m;
3434
3435 if (!bfa_ioc_is_operational(ablk->ioc)) {
3436 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3437 return BFA_STATUS_IOC_FAILURE;
3438 }
3439
3440 if (ablk->busy) {
3441 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3442 return BFA_STATUS_DEVBUSY;
3443 }
3444
3445 ablk->pcifn = pcifn;
3446 ablk->cbfn = cbfn;
3447 ablk->cbarg = cbarg;
3448 ablk->busy = BFA_TRUE;
3449
3450 m = (struct bfi_ablk_h2i_pf_req_s *)ablk->mb.msg;
3451 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_CREATE,
3452 bfa_ioc_portid(ablk->ioc));
3453 m->pers = cpu_to_be16((u16)personality);
3454 m->bw_min = cpu_to_be16(bw_min);
3455 m->bw_max = cpu_to_be16(bw_max);
3456 m->port = port;
3457 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3458
3459 return BFA_STATUS_OK;
3460 }
3461
3462 bfa_status_t
3463 bfa_ablk_pf_delete(struct bfa_ablk_s *ablk, int pcifn,
3464 bfa_ablk_cbfn_t cbfn, void *cbarg)
3465 {
3466 struct bfi_ablk_h2i_pf_req_s *m;
3467
3468 if (!bfa_ioc_is_operational(ablk->ioc)) {
3469 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3470 return BFA_STATUS_IOC_FAILURE;
3471 }
3472
3473 if (ablk->busy) {
3474 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3475 return BFA_STATUS_DEVBUSY;
3476 }
3477
3478 ablk->cbfn = cbfn;
3479 ablk->cbarg = cbarg;
3480 ablk->busy = BFA_TRUE;
3481
3482 m = (struct bfi_ablk_h2i_pf_req_s *)ablk->mb.msg;
3483 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_DELETE,
3484 bfa_ioc_portid(ablk->ioc));
3485 m->pcifn = (u8)pcifn;
3486 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3487
3488 return BFA_STATUS_OK;
3489 }
3490
3491 bfa_status_t
3492 bfa_ablk_adapter_config(struct bfa_ablk_s *ablk, enum bfa_mode_s mode,
3493 int max_pf, int max_vf, bfa_ablk_cbfn_t cbfn, void *cbarg)
3494 {
3495 struct bfi_ablk_h2i_cfg_req_s *m;
3496
3497 if (!bfa_ioc_is_operational(ablk->ioc)) {
3498 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3499 return BFA_STATUS_IOC_FAILURE;
3500 }
3501
3502 if (ablk->busy) {
3503 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3504 return BFA_STATUS_DEVBUSY;
3505 }
3506
3507 ablk->cbfn = cbfn;
3508 ablk->cbarg = cbarg;
3509 ablk->busy = BFA_TRUE;
3510
3511 m = (struct bfi_ablk_h2i_cfg_req_s *)ablk->mb.msg;
3512 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_ADPT_CONFIG,
3513 bfa_ioc_portid(ablk->ioc));
3514 m->mode = (u8)mode;
3515 m->max_pf = (u8)max_pf;
3516 m->max_vf = (u8)max_vf;
3517 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3518
3519 return BFA_STATUS_OK;
3520 }
3521
3522 bfa_status_t
3523 bfa_ablk_port_config(struct bfa_ablk_s *ablk, int port, enum bfa_mode_s mode,
3524 int max_pf, int max_vf, bfa_ablk_cbfn_t cbfn, void *cbarg)
3525 {
3526 struct bfi_ablk_h2i_cfg_req_s *m;
3527
3528 if (!bfa_ioc_is_operational(ablk->ioc)) {
3529 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3530 return BFA_STATUS_IOC_FAILURE;
3531 }
3532
3533 if (ablk->busy) {
3534 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3535 return BFA_STATUS_DEVBUSY;
3536 }
3537
3538 ablk->cbfn = cbfn;
3539 ablk->cbarg = cbarg;
3540 ablk->busy = BFA_TRUE;
3541
3542 m = (struct bfi_ablk_h2i_cfg_req_s *)ablk->mb.msg;
3543 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PORT_CONFIG,
3544 bfa_ioc_portid(ablk->ioc));
3545 m->port = (u8)port;
3546 m->mode = (u8)mode;
3547 m->max_pf = (u8)max_pf;
3548 m->max_vf = (u8)max_vf;
3549 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3550
3551 return BFA_STATUS_OK;
3552 }
3553
3554 bfa_status_t
3555 bfa_ablk_pf_update(struct bfa_ablk_s *ablk, int pcifn, u16 bw_min,
3556 u16 bw_max, bfa_ablk_cbfn_t cbfn, void *cbarg)
3557 {
3558 struct bfi_ablk_h2i_pf_req_s *m;
3559
3560 if (!bfa_ioc_is_operational(ablk->ioc)) {
3561 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3562 return BFA_STATUS_IOC_FAILURE;
3563 }
3564
3565 if (ablk->busy) {
3566 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3567 return BFA_STATUS_DEVBUSY;
3568 }
3569
3570 ablk->cbfn = cbfn;
3571 ablk->cbarg = cbarg;
3572 ablk->busy = BFA_TRUE;
3573
3574 m = (struct bfi_ablk_h2i_pf_req_s *)ablk->mb.msg;
3575 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_PF_UPDATE,
3576 bfa_ioc_portid(ablk->ioc));
3577 m->pcifn = (u8)pcifn;
3578 m->bw_min = cpu_to_be16(bw_min);
3579 m->bw_max = cpu_to_be16(bw_max);
3580 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3581
3582 return BFA_STATUS_OK;
3583 }
3584
3585 bfa_status_t
3586 bfa_ablk_optrom_en(struct bfa_ablk_s *ablk, bfa_ablk_cbfn_t cbfn, void *cbarg)
3587 {
3588 struct bfi_ablk_h2i_optrom_s *m;
3589
3590 if (!bfa_ioc_is_operational(ablk->ioc)) {
3591 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3592 return BFA_STATUS_IOC_FAILURE;
3593 }
3594
3595 if (ablk->busy) {
3596 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3597 return BFA_STATUS_DEVBUSY;
3598 }
3599
3600 ablk->cbfn = cbfn;
3601 ablk->cbarg = cbarg;
3602 ablk->busy = BFA_TRUE;
3603
3604 m = (struct bfi_ablk_h2i_optrom_s *)ablk->mb.msg;
3605 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_OPTROM_ENABLE,
3606 bfa_ioc_portid(ablk->ioc));
3607 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3608
3609 return BFA_STATUS_OK;
3610 }
3611
3612 bfa_status_t
3613 bfa_ablk_optrom_dis(struct bfa_ablk_s *ablk, bfa_ablk_cbfn_t cbfn, void *cbarg)
3614 {
3615 struct bfi_ablk_h2i_optrom_s *m;
3616
3617 if (!bfa_ioc_is_operational(ablk->ioc)) {
3618 bfa_trc(ablk->ioc, BFA_STATUS_IOC_FAILURE);
3619 return BFA_STATUS_IOC_FAILURE;
3620 }
3621
3622 if (ablk->busy) {
3623 bfa_trc(ablk->ioc, BFA_STATUS_DEVBUSY);
3624 return BFA_STATUS_DEVBUSY;
3625 }
3626
3627 ablk->cbfn = cbfn;
3628 ablk->cbarg = cbarg;
3629 ablk->busy = BFA_TRUE;
3630
3631 m = (struct bfi_ablk_h2i_optrom_s *)ablk->mb.msg;
3632 bfi_h2i_set(m->mh, BFI_MC_ABLK, BFI_ABLK_H2I_OPTROM_DISABLE,
3633 bfa_ioc_portid(ablk->ioc));
3634 bfa_ioc_mbox_queue(ablk->ioc, &ablk->mb);
3635
3636 return BFA_STATUS_OK;
3637 }
3638
3639 /*
3640 * SFP module specific
3641 */
3642
3643 /* forward declarations */
3644 static void bfa_sfp_getdata_send(struct bfa_sfp_s *sfp);
3645 static void bfa_sfp_media_get(struct bfa_sfp_s *sfp);
3646 static bfa_status_t bfa_sfp_speed_valid(struct bfa_sfp_s *sfp,
3647 enum bfa_port_speed portspeed);
3648
3649 static void
3650 bfa_cb_sfp_show(struct bfa_sfp_s *sfp)
3651 {
3652 bfa_trc(sfp, sfp->lock);
3653 if (sfp->cbfn)
3654 sfp->cbfn(sfp->cbarg, sfp->status);
3655 sfp->lock = 0;
3656 sfp->cbfn = NULL;
3657 }
3658
3659 static void
3660 bfa_cb_sfp_state_query(struct bfa_sfp_s *sfp)
3661 {
3662 bfa_trc(sfp, sfp->portspeed);
3663 if (sfp->media) {
3664 bfa_sfp_media_get(sfp);
3665 if (sfp->state_query_cbfn)
3666 sfp->state_query_cbfn(sfp->state_query_cbarg,
3667 sfp->status);
3668 sfp->media = NULL;
3669 }
3670
3671 if (sfp->portspeed) {
3672 sfp->status = bfa_sfp_speed_valid(sfp, sfp->portspeed);
3673 if (sfp->state_query_cbfn)
3674 sfp->state_query_cbfn(sfp->state_query_cbarg,
3675 sfp->status);
3676 sfp->portspeed = BFA_PORT_SPEED_UNKNOWN;
3677 }
3678
3679 sfp->state_query_lock = 0;
3680 sfp->state_query_cbfn = NULL;
3681 }
3682
3683 /*
3684 * IOC event handler.
3685 */
3686 static void
3687 bfa_sfp_notify(void *sfp_arg, enum bfa_ioc_event_e event)
3688 {
3689 struct bfa_sfp_s *sfp = sfp_arg;
3690
3691 bfa_trc(sfp, event);
3692 bfa_trc(sfp, sfp->lock);
3693 bfa_trc(sfp, sfp->state_query_lock);
3694
3695 switch (event) {
3696 case BFA_IOC_E_DISABLED:
3697 case BFA_IOC_E_FAILED:
3698 if (sfp->lock) {
3699 sfp->status = BFA_STATUS_IOC_FAILURE;
3700 bfa_cb_sfp_show(sfp);
3701 }
3702
3703 if (sfp->state_query_lock) {
3704 sfp->status = BFA_STATUS_IOC_FAILURE;
3705 bfa_cb_sfp_state_query(sfp);
3706 }
3707 break;
3708
3709 default:
3710 break;
3711 }
3712 }
3713
3714 /*
3715 * SFP's State Change Notification post to AEN
3716 */
3717 static void
3718 bfa_sfp_scn_aen_post(struct bfa_sfp_s *sfp, struct bfi_sfp_scn_s *rsp)
3719 {
3720 struct bfad_s *bfad = (struct bfad_s *)sfp->ioc->bfa->bfad;
3721 struct bfa_aen_entry_s *aen_entry;
3722 enum bfa_port_aen_event aen_evt = 0;
3723
3724 bfa_trc(sfp, (((u64)rsp->pomlvl) << 16) | (((u64)rsp->sfpid) << 8) |
3725 ((u64)rsp->event));
3726
3727 bfad_get_aen_entry(bfad, aen_entry);
3728 if (!aen_entry)
3729 return;
3730
3731 aen_entry->aen_data.port.ioc_type = bfa_ioc_get_type(sfp->ioc);
3732 aen_entry->aen_data.port.pwwn = sfp->ioc->attr->pwwn;
3733 aen_entry->aen_data.port.mac = bfa_ioc_get_mac(sfp->ioc);
3734
3735 switch (rsp->event) {
3736 case BFA_SFP_SCN_INSERTED:
3737 aen_evt = BFA_PORT_AEN_SFP_INSERT;
3738 break;
3739 case BFA_SFP_SCN_REMOVED:
3740 aen_evt = BFA_PORT_AEN_SFP_REMOVE;
3741 break;
3742 case BFA_SFP_SCN_FAILED:
3743 aen_evt = BFA_PORT_AEN_SFP_ACCESS_ERROR;
3744 break;
3745 case BFA_SFP_SCN_UNSUPPORT:
3746 aen_evt = BFA_PORT_AEN_SFP_UNSUPPORT;
3747 break;
3748 case BFA_SFP_SCN_POM:
3749 aen_evt = BFA_PORT_AEN_SFP_POM;
3750 aen_entry->aen_data.port.level = rsp->pomlvl;
3751 break;
3752 default:
3753 bfa_trc(sfp, rsp->event);
3754 WARN_ON(1);
3755 }
3756
3757 /* Send the AEN notification */
3758 bfad_im_post_vendor_event(aen_entry, bfad, ++sfp->ioc->ioc_aen_seq,
3759 BFA_AEN_CAT_PORT, aen_evt);
3760 }
3761
3762 /*
3763 * SFP get data send
3764 */
3765 static void
3766 bfa_sfp_getdata_send(struct bfa_sfp_s *sfp)
3767 {
3768 struct bfi_sfp_req_s *req = (struct bfi_sfp_req_s *)sfp->mbcmd.msg;
3769
3770 bfa_trc(sfp, req->memtype);
3771
3772 /* build host command */
3773 bfi_h2i_set(req->mh, BFI_MC_SFP, BFI_SFP_H2I_SHOW,
3774 bfa_ioc_portid(sfp->ioc));
3775
3776 /* send mbox cmd */
3777 bfa_ioc_mbox_queue(sfp->ioc, &sfp->mbcmd);
3778 }
3779
3780 /*
3781 * SFP is valid, read sfp data
3782 */
3783 static void
3784 bfa_sfp_getdata(struct bfa_sfp_s *sfp, enum bfi_sfp_mem_e memtype)
3785 {
3786 struct bfi_sfp_req_s *req = (struct bfi_sfp_req_s *)sfp->mbcmd.msg;
3787
3788 WARN_ON(sfp->lock != 0);
3789 bfa_trc(sfp, sfp->state);
3790
3791 sfp->lock = 1;
3792 sfp->memtype = memtype;
3793 req->memtype = memtype;
3794
3795 /* Setup SG list */
3796 bfa_alen_set(&req->alen, sizeof(struct sfp_mem_s), sfp->dbuf_pa);
3797
3798 bfa_sfp_getdata_send(sfp);
3799 }
3800
3801 /*
3802 * SFP scn handler
3803 */
3804 static void
3805 bfa_sfp_scn(struct bfa_sfp_s *sfp, struct bfi_mbmsg_s *msg)
3806 {
3807 struct bfi_sfp_scn_s *rsp = (struct bfi_sfp_scn_s *) msg;
3808
3809 switch (rsp->event) {
3810 case BFA_SFP_SCN_INSERTED:
3811 sfp->state = BFA_SFP_STATE_INSERTED;
3812 sfp->data_valid = 0;
3813 bfa_sfp_scn_aen_post(sfp, rsp);
3814 break;
3815 case BFA_SFP_SCN_REMOVED:
3816 sfp->state = BFA_SFP_STATE_REMOVED;
3817 sfp->data_valid = 0;
3818 bfa_sfp_scn_aen_post(sfp, rsp);
3819 break;
3820 case BFA_SFP_SCN_FAILED:
3821 sfp->state = BFA_SFP_STATE_FAILED;
3822 sfp->data_valid = 0;
3823 bfa_sfp_scn_aen_post(sfp, rsp);
3824 break;
3825 case BFA_SFP_SCN_UNSUPPORT:
3826 sfp->state = BFA_SFP_STATE_UNSUPPORT;
3827 bfa_sfp_scn_aen_post(sfp, rsp);
3828 if (!sfp->lock)
3829 bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
3830 break;
3831 case BFA_SFP_SCN_POM:
3832 bfa_sfp_scn_aen_post(sfp, rsp);
3833 break;
3834 case BFA_SFP_SCN_VALID:
3835 sfp->state = BFA_SFP_STATE_VALID;
3836 if (!sfp->lock)
3837 bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
3838 break;
3839 default:
3840 bfa_trc(sfp, rsp->event);
3841 WARN_ON(1);
3842 }
3843 }
3844
3845 /*
3846 * SFP show complete
3847 */
3848 static void
3849 bfa_sfp_show_comp(struct bfa_sfp_s *sfp, struct bfi_mbmsg_s *msg)
3850 {
3851 struct bfi_sfp_rsp_s *rsp = (struct bfi_sfp_rsp_s *) msg;
3852
3853 if (!sfp->lock) {
3854 /*
3855 * receiving response after ioc failure
3856 */
3857 bfa_trc(sfp, sfp->lock);
3858 return;
3859 }
3860
3861 bfa_trc(sfp, rsp->status);
3862 if (rsp->status == BFA_STATUS_OK) {
3863 sfp->data_valid = 1;
3864 if (sfp->state == BFA_SFP_STATE_VALID)
3865 sfp->status = BFA_STATUS_OK;
3866 else if (sfp->state == BFA_SFP_STATE_UNSUPPORT)
3867 sfp->status = BFA_STATUS_SFP_UNSUPP;
3868 else
3869 bfa_trc(sfp, sfp->state);
3870 } else {
3871 sfp->data_valid = 0;
3872 sfp->status = rsp->status;
3873 /* sfpshow shouldn't change sfp state */
3874 }
3875
3876 bfa_trc(sfp, sfp->memtype);
3877 if (sfp->memtype == BFI_SFP_MEM_DIAGEXT) {
3878 bfa_trc(sfp, sfp->data_valid);
3879 if (sfp->data_valid) {
3880 u32 size = sizeof(struct sfp_mem_s);
3881 u8 *des = (u8 *) &(sfp->sfpmem);
3882 memcpy(des, sfp->dbuf_kva, size);
3883 }
3884 /*
3885 * Queue completion callback.
3886 */
3887 bfa_cb_sfp_show(sfp);
3888 } else
3889 sfp->lock = 0;
3890
3891 bfa_trc(sfp, sfp->state_query_lock);
3892 if (sfp->state_query_lock) {
3893 sfp->state = rsp->state;
3894 /* Complete callback */
3895 bfa_cb_sfp_state_query(sfp);
3896 }
3897 }
3898
3899 /*
3900 * SFP query fw sfp state
3901 */
3902 static void
3903 bfa_sfp_state_query(struct bfa_sfp_s *sfp)
3904 {
3905 struct bfi_sfp_req_s *req = (struct bfi_sfp_req_s *)sfp->mbcmd.msg;
3906
3907 /* Should not be doing query if not in _INIT state */
3908 WARN_ON(sfp->state != BFA_SFP_STATE_INIT);
3909 WARN_ON(sfp->state_query_lock != 0);
3910 bfa_trc(sfp, sfp->state);
3911
3912 sfp->state_query_lock = 1;
3913 req->memtype = 0;
3914
3915 if (!sfp->lock)
3916 bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
3917 }
3918
3919 static void
3920 bfa_sfp_media_get(struct bfa_sfp_s *sfp)
3921 {
3922 enum bfa_defs_sfp_media_e *media = sfp->media;
3923
3924 *media = BFA_SFP_MEDIA_UNKNOWN;
3925
3926 if (sfp->state == BFA_SFP_STATE_UNSUPPORT)
3927 *media = BFA_SFP_MEDIA_UNSUPPORT;
3928 else if (sfp->state == BFA_SFP_STATE_VALID) {
3929 union sfp_xcvr_e10g_code_u e10g;
3930 struct sfp_mem_s *sfpmem = (struct sfp_mem_s *)sfp->dbuf_kva;
3931 u16 xmtr_tech = (sfpmem->srlid_base.xcvr[4] & 0x3) << 7 |
3932 (sfpmem->srlid_base.xcvr[5] >> 1);
3933
3934 e10g.b = sfpmem->srlid_base.xcvr[0];
3935 bfa_trc(sfp, e10g.b);
3936 bfa_trc(sfp, xmtr_tech);
3937 /* check fc transmitter tech */
3938 if ((xmtr_tech & SFP_XMTR_TECH_CU) ||
3939 (xmtr_tech & SFP_XMTR_TECH_CP) ||
3940 (xmtr_tech & SFP_XMTR_TECH_CA))
3941 *media = BFA_SFP_MEDIA_CU;
3942 else if ((xmtr_tech & SFP_XMTR_TECH_EL_INTRA) ||
3943 (xmtr_tech & SFP_XMTR_TECH_EL_INTER))
3944 *media = BFA_SFP_MEDIA_EL;
3945 else if ((xmtr_tech & SFP_XMTR_TECH_LL) ||
3946 (xmtr_tech & SFP_XMTR_TECH_LC))
3947 *media = BFA_SFP_MEDIA_LW;
3948 else if ((xmtr_tech & SFP_XMTR_TECH_SL) ||
3949 (xmtr_tech & SFP_XMTR_TECH_SN) ||
3950 (xmtr_tech & SFP_XMTR_TECH_SA))
3951 *media = BFA_SFP_MEDIA_SW;
3952 /* Check 10G Ethernet Compilance code */
3953 else if (e10g.r.e10g_sr)
3954 *media = BFA_SFP_MEDIA_SW;
3955 else if (e10g.r.e10g_lrm && e10g.r.e10g_lr)
3956 *media = BFA_SFP_MEDIA_LW;
3957 else if (e10g.r.e10g_unall)
3958 *media = BFA_SFP_MEDIA_UNKNOWN;
3959 else
3960 bfa_trc(sfp, 0);
3961 } else
3962 bfa_trc(sfp, sfp->state);
3963 }
3964
3965 static bfa_status_t
3966 bfa_sfp_speed_valid(struct bfa_sfp_s *sfp, enum bfa_port_speed portspeed)
3967 {
3968 struct sfp_mem_s *sfpmem = (struct sfp_mem_s *)sfp->dbuf_kva;
3969 struct sfp_xcvr_s *xcvr = (struct sfp_xcvr_s *) sfpmem->srlid_base.xcvr;
3970 union sfp_xcvr_fc3_code_u fc3 = xcvr->fc3;
3971 union sfp_xcvr_e10g_code_u e10g = xcvr->e10g;
3972
3973 if (portspeed == BFA_PORT_SPEED_10GBPS) {
3974 if (e10g.r.e10g_sr || e10g.r.e10g_lr)
3975 return BFA_STATUS_OK;
3976 else {
3977 bfa_trc(sfp, e10g.b);
3978 return BFA_STATUS_UNSUPP_SPEED;
3979 }
3980 }
3981 if (((portspeed & BFA_PORT_SPEED_16GBPS) && fc3.r.mb1600) ||
3982 ((portspeed & BFA_PORT_SPEED_8GBPS) && fc3.r.mb800) ||
3983 ((portspeed & BFA_PORT_SPEED_4GBPS) && fc3.r.mb400) ||
3984 ((portspeed & BFA_PORT_SPEED_2GBPS) && fc3.r.mb200) ||
3985 ((portspeed & BFA_PORT_SPEED_1GBPS) && fc3.r.mb100))
3986 return BFA_STATUS_OK;
3987 else {
3988 bfa_trc(sfp, portspeed);
3989 bfa_trc(sfp, fc3.b);
3990 bfa_trc(sfp, e10g.b);
3991 return BFA_STATUS_UNSUPP_SPEED;
3992 }
3993 }
3994
3995 /*
3996 * SFP hmbox handler
3997 */
3998 void
3999 bfa_sfp_intr(void *sfparg, struct bfi_mbmsg_s *msg)
4000 {
4001 struct bfa_sfp_s *sfp = sfparg;
4002
4003 switch (msg->mh.msg_id) {
4004 case BFI_SFP_I2H_SHOW:
4005 bfa_sfp_show_comp(sfp, msg);
4006 break;
4007
4008 case BFI_SFP_I2H_SCN:
4009 bfa_sfp_scn(sfp, msg);
4010 break;
4011
4012 default:
4013 bfa_trc(sfp, msg->mh.msg_id);
4014 WARN_ON(1);
4015 }
4016 }
4017
4018 /*
4019 * Return DMA memory needed by sfp module.
4020 */
4021 u32
4022 bfa_sfp_meminfo(void)
4023 {
4024 return BFA_ROUNDUP(sizeof(struct sfp_mem_s), BFA_DMA_ALIGN_SZ);
4025 }
4026
4027 /*
4028 * Attach virtual and physical memory for SFP.
4029 */
4030 void
4031 bfa_sfp_attach(struct bfa_sfp_s *sfp, struct bfa_ioc_s *ioc, void *dev,
4032 struct bfa_trc_mod_s *trcmod)
4033 {
4034 sfp->dev = dev;
4035 sfp->ioc = ioc;
4036 sfp->trcmod = trcmod;
4037
4038 sfp->cbfn = NULL;
4039 sfp->cbarg = NULL;
4040 sfp->sfpmem = NULL;
4041 sfp->lock = 0;
4042 sfp->data_valid = 0;
4043 sfp->state = BFA_SFP_STATE_INIT;
4044 sfp->state_query_lock = 0;
4045 sfp->state_query_cbfn = NULL;
4046 sfp->state_query_cbarg = NULL;
4047 sfp->media = NULL;
4048 sfp->portspeed = BFA_PORT_SPEED_UNKNOWN;
4049 sfp->is_elb = BFA_FALSE;
4050
4051 bfa_ioc_mbox_regisr(sfp->ioc, BFI_MC_SFP, bfa_sfp_intr, sfp);
4052 bfa_q_qe_init(&sfp->ioc_notify);
4053 bfa_ioc_notify_init(&sfp->ioc_notify, bfa_sfp_notify, sfp);
4054 list_add_tail(&sfp->ioc_notify.qe, &sfp->ioc->notify_q);
4055 }
4056
4057 /*
4058 * Claim Memory for SFP
4059 */
4060 void
4061 bfa_sfp_memclaim(struct bfa_sfp_s *sfp, u8 *dm_kva, u64 dm_pa)
4062 {
4063 sfp->dbuf_kva = dm_kva;
4064 sfp->dbuf_pa = dm_pa;
4065 memset(sfp->dbuf_kva, 0, sizeof(struct sfp_mem_s));
4066
4067 dm_kva += BFA_ROUNDUP(sizeof(struct sfp_mem_s), BFA_DMA_ALIGN_SZ);
4068 dm_pa += BFA_ROUNDUP(sizeof(struct sfp_mem_s), BFA_DMA_ALIGN_SZ);
4069 }
4070
4071 /*
4072 * Show SFP eeprom content
4073 *
4074 * @param[in] sfp - bfa sfp module
4075 *
4076 * @param[out] sfpmem - sfp eeprom data
4077 *
4078 */
4079 bfa_status_t
4080 bfa_sfp_show(struct bfa_sfp_s *sfp, struct sfp_mem_s *sfpmem,
4081 bfa_cb_sfp_t cbfn, void *cbarg)
4082 {
4083
4084 if (!bfa_ioc_is_operational(sfp->ioc)) {
4085 bfa_trc(sfp, 0);
4086 return BFA_STATUS_IOC_NON_OP;
4087 }
4088
4089 if (sfp->lock) {
4090 bfa_trc(sfp, 0);
4091 return BFA_STATUS_DEVBUSY;
4092 }
4093
4094 sfp->cbfn = cbfn;
4095 sfp->cbarg = cbarg;
4096 sfp->sfpmem = sfpmem;
4097
4098 bfa_sfp_getdata(sfp, BFI_SFP_MEM_DIAGEXT);
4099 return BFA_STATUS_OK;
4100 }
4101
4102 /*
4103 * Return SFP Media type
4104 *
4105 * @param[in] sfp - bfa sfp module
4106 *
4107 * @param[out] media - port speed from user
4108 *
4109 */
4110 bfa_status_t
4111 bfa_sfp_media(struct bfa_sfp_s *sfp, enum bfa_defs_sfp_media_e *media,
4112 bfa_cb_sfp_t cbfn, void *cbarg)
4113 {
4114 if (!bfa_ioc_is_operational(sfp->ioc)) {
4115 bfa_trc(sfp, 0);
4116 return BFA_STATUS_IOC_NON_OP;
4117 }
4118
4119 sfp->media = media;
4120 if (sfp->state == BFA_SFP_STATE_INIT) {
4121 if (sfp->state_query_lock) {
4122 bfa_trc(sfp, 0);
4123 return BFA_STATUS_DEVBUSY;
4124 } else {
4125 sfp->state_query_cbfn = cbfn;
4126 sfp->state_query_cbarg = cbarg;
4127 bfa_sfp_state_query(sfp);
4128 return BFA_STATUS_SFP_NOT_READY;
4129 }
4130 }
4131
4132 bfa_sfp_media_get(sfp);
4133 return BFA_STATUS_OK;
4134 }
4135
4136 /*
4137 * Check if user set port speed is allowed by the SFP
4138 *
4139 * @param[in] sfp - bfa sfp module
4140 * @param[in] portspeed - port speed from user
4141 *
4142 */
4143 bfa_status_t
4144 bfa_sfp_speed(struct bfa_sfp_s *sfp, enum bfa_port_speed portspeed,
4145 bfa_cb_sfp_t cbfn, void *cbarg)
4146 {
4147 WARN_ON(portspeed == BFA_PORT_SPEED_UNKNOWN);
4148
4149 if (!bfa_ioc_is_operational(sfp->ioc))
4150 return BFA_STATUS_IOC_NON_OP;
4151
4152 /* For Mezz card, all speed is allowed */
4153 if (bfa_mfg_is_mezz(sfp->ioc->attr->card_type))
4154 return BFA_STATUS_OK;
4155
4156 /* Check SFP state */
4157 sfp->portspeed = portspeed;
4158 if (sfp->state == BFA_SFP_STATE_INIT) {
4159 if (sfp->state_query_lock) {
4160 bfa_trc(sfp, 0);
4161 return BFA_STATUS_DEVBUSY;
4162 } else {
4163 sfp->state_query_cbfn = cbfn;
4164 sfp->state_query_cbarg = cbarg;
4165 bfa_sfp_state_query(sfp);
4166 return BFA_STATUS_SFP_NOT_READY;
4167 }
4168 }
4169
4170 if (sfp->state == BFA_SFP_STATE_REMOVED ||
4171 sfp->state == BFA_SFP_STATE_FAILED) {
4172 bfa_trc(sfp, sfp->state);
4173 return BFA_STATUS_NO_SFP_DEV;
4174 }
4175
4176 if (sfp->state == BFA_SFP_STATE_INSERTED) {
4177 bfa_trc(sfp, sfp->state);
4178 return BFA_STATUS_DEVBUSY; /* sfp is reading data */
4179 }
4180
4181 /* For eloopback, all speed is allowed */
4182 if (sfp->is_elb)
4183 return BFA_STATUS_OK;
4184
4185 return bfa_sfp_speed_valid(sfp, portspeed);
4186 }
4187
4188 /*
4189 * Flash module specific
4190 */
4191
4192 /*
4193 * FLASH DMA buffer should be big enough to hold both MFG block and
4194 * asic block(64k) at the same time and also should be 2k aligned to
4195 * avoid write segement to cross sector boundary.
4196 */
4197 #define BFA_FLASH_SEG_SZ 2048
4198 #define BFA_FLASH_DMA_BUF_SZ \
4199 BFA_ROUNDUP(0x010000 + sizeof(struct bfa_mfg_block_s), BFA_FLASH_SEG_SZ)
4200
4201 static void
4202 bfa_flash_aen_audit_post(struct bfa_ioc_s *ioc, enum bfa_audit_aen_event event,
4203 int inst, int type)
4204 {
4205 struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
4206 struct bfa_aen_entry_s *aen_entry;
4207
4208 bfad_get_aen_entry(bfad, aen_entry);
4209 if (!aen_entry)
4210 return;
4211
4212 aen_entry->aen_data.audit.pwwn = ioc->attr->pwwn;
4213 aen_entry->aen_data.audit.partition_inst = inst;
4214 aen_entry->aen_data.audit.partition_type = type;
4215
4216 /* Send the AEN notification */
4217 bfad_im_post_vendor_event(aen_entry, bfad, ++ioc->ioc_aen_seq,
4218 BFA_AEN_CAT_AUDIT, event);
4219 }
4220
4221 static void
4222 bfa_flash_cb(struct bfa_flash_s *flash)
4223 {
4224 flash->op_busy = 0;
4225 if (flash->cbfn)
4226 flash->cbfn(flash->cbarg, flash->status);
4227 }
4228
4229 static void
4230 bfa_flash_notify(void *cbarg, enum bfa_ioc_event_e event)
4231 {
4232 struct bfa_flash_s *flash = cbarg;
4233
4234 bfa_trc(flash, event);
4235 switch (event) {
4236 case BFA_IOC_E_DISABLED:
4237 case BFA_IOC_E_FAILED:
4238 if (flash->op_busy) {
4239 flash->status = BFA_STATUS_IOC_FAILURE;
4240 flash->cbfn(flash->cbarg, flash->status);
4241 flash->op_busy = 0;
4242 }
4243 break;
4244
4245 default:
4246 break;
4247 }
4248 }
4249
4250 /*
4251 * Send flash attribute query request.
4252 *
4253 * @param[in] cbarg - callback argument
4254 */
4255 static void
4256 bfa_flash_query_send(void *cbarg)
4257 {
4258 struct bfa_flash_s *flash = cbarg;
4259 struct bfi_flash_query_req_s *msg =
4260 (struct bfi_flash_query_req_s *) flash->mb.msg;
4261
4262 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_QUERY_REQ,
4263 bfa_ioc_portid(flash->ioc));
4264 bfa_alen_set(&msg->alen, sizeof(struct bfa_flash_attr_s),
4265 flash->dbuf_pa);
4266 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4267 }
4268
4269 /*
4270 * Send flash write request.
4271 *
4272 * @param[in] cbarg - callback argument
4273 */
4274 static void
4275 bfa_flash_write_send(struct bfa_flash_s *flash)
4276 {
4277 struct bfi_flash_write_req_s *msg =
4278 (struct bfi_flash_write_req_s *) flash->mb.msg;
4279 u32 len;
4280
4281 msg->type = be32_to_cpu(flash->type);
4282 msg->instance = flash->instance;
4283 msg->offset = be32_to_cpu(flash->addr_off + flash->offset);
4284 len = (flash->residue < BFA_FLASH_DMA_BUF_SZ) ?
4285 flash->residue : BFA_FLASH_DMA_BUF_SZ;
4286 msg->length = be32_to_cpu(len);
4287
4288 /* indicate if it's the last msg of the whole write operation */
4289 msg->last = (len == flash->residue) ? 1 : 0;
4290
4291 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_WRITE_REQ,
4292 bfa_ioc_portid(flash->ioc));
4293 bfa_alen_set(&msg->alen, len, flash->dbuf_pa);
4294 memcpy(flash->dbuf_kva, flash->ubuf + flash->offset, len);
4295 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4296
4297 flash->residue -= len;
4298 flash->offset += len;
4299 }
4300
4301 /*
4302 * Send flash read request.
4303 *
4304 * @param[in] cbarg - callback argument
4305 */
4306 static void
4307 bfa_flash_read_send(void *cbarg)
4308 {
4309 struct bfa_flash_s *flash = cbarg;
4310 struct bfi_flash_read_req_s *msg =
4311 (struct bfi_flash_read_req_s *) flash->mb.msg;
4312 u32 len;
4313
4314 msg->type = be32_to_cpu(flash->type);
4315 msg->instance = flash->instance;
4316 msg->offset = be32_to_cpu(flash->addr_off + flash->offset);
4317 len = (flash->residue < BFA_FLASH_DMA_BUF_SZ) ?
4318 flash->residue : BFA_FLASH_DMA_BUF_SZ;
4319 msg->length = be32_to_cpu(len);
4320 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_READ_REQ,
4321 bfa_ioc_portid(flash->ioc));
4322 bfa_alen_set(&msg->alen, len, flash->dbuf_pa);
4323 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4324 }
4325
4326 /*
4327 * Send flash erase request.
4328 *
4329 * @param[in] cbarg - callback argument
4330 */
4331 static void
4332 bfa_flash_erase_send(void *cbarg)
4333 {
4334 struct bfa_flash_s *flash = cbarg;
4335 struct bfi_flash_erase_req_s *msg =
4336 (struct bfi_flash_erase_req_s *) flash->mb.msg;
4337
4338 msg->type = be32_to_cpu(flash->type);
4339 msg->instance = flash->instance;
4340 bfi_h2i_set(msg->mh, BFI_MC_FLASH, BFI_FLASH_H2I_ERASE_REQ,
4341 bfa_ioc_portid(flash->ioc));
4342 bfa_ioc_mbox_queue(flash->ioc, &flash->mb);
4343 }
4344
4345 /*
4346 * Process flash response messages upon receiving interrupts.
4347 *
4348 * @param[in] flasharg - flash structure
4349 * @param[in] msg - message structure
4350 */
4351 static void
4352 bfa_flash_intr(void *flasharg, struct bfi_mbmsg_s *msg)
4353 {
4354 struct bfa_flash_s *flash = flasharg;
4355 u32 status;
4356
4357 union {
4358 struct bfi_flash_query_rsp_s *query;
4359 struct bfi_flash_erase_rsp_s *erase;
4360 struct bfi_flash_write_rsp_s *write;
4361 struct bfi_flash_read_rsp_s *read;
4362 struct bfi_flash_event_s *event;
4363 struct bfi_mbmsg_s *msg;
4364 } m;
4365
4366 m.msg = msg;
4367 bfa_trc(flash, msg->mh.msg_id);
4368
4369 if (!flash->op_busy && msg->mh.msg_id != BFI_FLASH_I2H_EVENT) {
4370 /* receiving response after ioc failure */
4371 bfa_trc(flash, 0x9999);
4372 return;
4373 }
4374
4375 switch (msg->mh.msg_id) {
4376 case BFI_FLASH_I2H_QUERY_RSP:
4377 status = be32_to_cpu(m.query->status);
4378 bfa_trc(flash, status);
4379 if (status == BFA_STATUS_OK) {
4380 u32 i;
4381 struct bfa_flash_attr_s *attr, *f;
4382
4383 attr = (struct bfa_flash_attr_s *) flash->ubuf;
4384 f = (struct bfa_flash_attr_s *) flash->dbuf_kva;
4385 attr->status = be32_to_cpu(f->status);
4386 attr->npart = be32_to_cpu(f->npart);
4387 bfa_trc(flash, attr->status);
4388 bfa_trc(flash, attr->npart);
4389 for (i = 0; i < attr->npart; i++) {
4390 attr->part[i].part_type =
4391 be32_to_cpu(f->part[i].part_type);
4392 attr->part[i].part_instance =
4393 be32_to_cpu(f->part[i].part_instance);
4394 attr->part[i].part_off =
4395 be32_to_cpu(f->part[i].part_off);
4396 attr->part[i].part_size =
4397 be32_to_cpu(f->part[i].part_size);
4398 attr->part[i].part_len =
4399 be32_to_cpu(f->part[i].part_len);
4400 attr->part[i].part_status =
4401 be32_to_cpu(f->part[i].part_status);
4402 }
4403 }
4404 flash->status = status;
4405 bfa_flash_cb(flash);
4406 break;
4407 case BFI_FLASH_I2H_ERASE_RSP:
4408 status = be32_to_cpu(m.erase->status);
4409 bfa_trc(flash, status);
4410 flash->status = status;
4411 bfa_flash_cb(flash);
4412 break;
4413 case BFI_FLASH_I2H_WRITE_RSP:
4414 status = be32_to_cpu(m.write->status);
4415 bfa_trc(flash, status);
4416 if (status != BFA_STATUS_OK || flash->residue == 0) {
4417 flash->status = status;
4418 bfa_flash_cb(flash);
4419 } else {
4420 bfa_trc(flash, flash->offset);
4421 bfa_flash_write_send(flash);
4422 }
4423 break;
4424 case BFI_FLASH_I2H_READ_RSP:
4425 status = be32_to_cpu(m.read->status);
4426 bfa_trc(flash, status);
4427 if (status != BFA_STATUS_OK) {
4428 flash->status = status;
4429 bfa_flash_cb(flash);
4430 } else {
4431 u32 len = be32_to_cpu(m.read->length);
4432 bfa_trc(flash, flash->offset);
4433 bfa_trc(flash, len);
4434 memcpy(flash->ubuf + flash->offset,
4435 flash->dbuf_kva, len);
4436 flash->residue -= len;
4437 flash->offset += len;
4438 if (flash->residue == 0) {
4439 flash->status = status;
4440 bfa_flash_cb(flash);
4441 } else
4442 bfa_flash_read_send(flash);
4443 }
4444 break;
4445 case BFI_FLASH_I2H_BOOT_VER_RSP:
4446 break;
4447 case BFI_FLASH_I2H_EVENT:
4448 status = be32_to_cpu(m.event->status);
4449 bfa_trc(flash, status);
4450 if (status == BFA_STATUS_BAD_FWCFG)
4451 bfa_ioc_aen_post(flash->ioc, BFA_IOC_AEN_FWCFG_ERROR);
4452 else if (status == BFA_STATUS_INVALID_VENDOR) {
4453 u32 param;
4454 param = be32_to_cpu(m.event->param);
4455 bfa_trc(flash, param);
4456 bfa_ioc_aen_post(flash->ioc,
4457 BFA_IOC_AEN_INVALID_VENDOR);
4458 }
4459 break;
4460
4461 default:
4462 WARN_ON(1);
4463 }
4464 }
4465
4466 /*
4467 * Flash memory info API.
4468 *
4469 * @param[in] mincfg - minimal cfg variable
4470 */
4471 u32
4472 bfa_flash_meminfo(bfa_boolean_t mincfg)
4473 {
4474 /* min driver doesn't need flash */
4475 if (mincfg)
4476 return 0;
4477 return BFA_ROUNDUP(BFA_FLASH_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
4478 }
4479
4480 /*
4481 * Flash attach API.
4482 *
4483 * @param[in] flash - flash structure
4484 * @param[in] ioc - ioc structure
4485 * @param[in] dev - device structure
4486 * @param[in] trcmod - trace module
4487 * @param[in] logmod - log module
4488 */
4489 void
4490 bfa_flash_attach(struct bfa_flash_s *flash, struct bfa_ioc_s *ioc, void *dev,
4491 struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg)
4492 {
4493 flash->ioc = ioc;
4494 flash->trcmod = trcmod;
4495 flash->cbfn = NULL;
4496 flash->cbarg = NULL;
4497 flash->op_busy = 0;
4498
4499 bfa_ioc_mbox_regisr(flash->ioc, BFI_MC_FLASH, bfa_flash_intr, flash);
4500 bfa_q_qe_init(&flash->ioc_notify);
4501 bfa_ioc_notify_init(&flash->ioc_notify, bfa_flash_notify, flash);
4502 list_add_tail(&flash->ioc_notify.qe, &flash->ioc->notify_q);
4503
4504 /* min driver doesn't need flash */
4505 if (mincfg) {
4506 flash->dbuf_kva = NULL;
4507 flash->dbuf_pa = 0;
4508 }
4509 }
4510
4511 /*
4512 * Claim memory for flash
4513 *
4514 * @param[in] flash - flash structure
4515 * @param[in] dm_kva - pointer to virtual memory address
4516 * @param[in] dm_pa - physical memory address
4517 * @param[in] mincfg - minimal cfg variable
4518 */
4519 void
4520 bfa_flash_memclaim(struct bfa_flash_s *flash, u8 *dm_kva, u64 dm_pa,
4521 bfa_boolean_t mincfg)
4522 {
4523 if (mincfg)
4524 return;
4525
4526 flash->dbuf_kva = dm_kva;
4527 flash->dbuf_pa = dm_pa;
4528 memset(flash->dbuf_kva, 0, BFA_FLASH_DMA_BUF_SZ);
4529 dm_kva += BFA_ROUNDUP(BFA_FLASH_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
4530 dm_pa += BFA_ROUNDUP(BFA_FLASH_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
4531 }
4532
4533 /*
4534 * Get flash attribute.
4535 *
4536 * @param[in] flash - flash structure
4537 * @param[in] attr - flash attribute structure
4538 * @param[in] cbfn - callback function
4539 * @param[in] cbarg - callback argument
4540 *
4541 * Return status.
4542 */
4543 bfa_status_t
4544 bfa_flash_get_attr(struct bfa_flash_s *flash, struct bfa_flash_attr_s *attr,
4545 bfa_cb_flash_t cbfn, void *cbarg)
4546 {
4547 bfa_trc(flash, BFI_FLASH_H2I_QUERY_REQ);
4548
4549 if (!bfa_ioc_is_operational(flash->ioc))
4550 return BFA_STATUS_IOC_NON_OP;
4551
4552 if (flash->op_busy) {
4553 bfa_trc(flash, flash->op_busy);
4554 return BFA_STATUS_DEVBUSY;
4555 }
4556
4557 flash->op_busy = 1;
4558 flash->cbfn = cbfn;
4559 flash->cbarg = cbarg;
4560 flash->ubuf = (u8 *) attr;
4561 bfa_flash_query_send(flash);
4562
4563 return BFA_STATUS_OK;
4564 }
4565
4566 /*
4567 * Erase flash partition.
4568 *
4569 * @param[in] flash - flash structure
4570 * @param[in] type - flash partition type
4571 * @param[in] instance - flash partition instance
4572 * @param[in] cbfn - callback function
4573 * @param[in] cbarg - callback argument
4574 *
4575 * Return status.
4576 */
4577 bfa_status_t
4578 bfa_flash_erase_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
4579 u8 instance, bfa_cb_flash_t cbfn, void *cbarg)
4580 {
4581 bfa_trc(flash, BFI_FLASH_H2I_ERASE_REQ);
4582 bfa_trc(flash, type);
4583 bfa_trc(flash, instance);
4584
4585 if (!bfa_ioc_is_operational(flash->ioc))
4586 return BFA_STATUS_IOC_NON_OP;
4587
4588 if (flash->op_busy) {
4589 bfa_trc(flash, flash->op_busy);
4590 return BFA_STATUS_DEVBUSY;
4591 }
4592
4593 flash->op_busy = 1;
4594 flash->cbfn = cbfn;
4595 flash->cbarg = cbarg;
4596 flash->type = type;
4597 flash->instance = instance;
4598
4599 bfa_flash_erase_send(flash);
4600 bfa_flash_aen_audit_post(flash->ioc, BFA_AUDIT_AEN_FLASH_ERASE,
4601 instance, type);
4602 return BFA_STATUS_OK;
4603 }
4604
4605 /*
4606 * Update flash partition.
4607 *
4608 * @param[in] flash - flash structure
4609 * @param[in] type - flash partition type
4610 * @param[in] instance - flash partition instance
4611 * @param[in] buf - update data buffer
4612 * @param[in] len - data buffer length
4613 * @param[in] offset - offset relative to the partition starting address
4614 * @param[in] cbfn - callback function
4615 * @param[in] cbarg - callback argument
4616 *
4617 * Return status.
4618 */
4619 bfa_status_t
4620 bfa_flash_update_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
4621 u8 instance, void *buf, u32 len, u32 offset,
4622 bfa_cb_flash_t cbfn, void *cbarg)
4623 {
4624 bfa_trc(flash, BFI_FLASH_H2I_WRITE_REQ);
4625 bfa_trc(flash, type);
4626 bfa_trc(flash, instance);
4627 bfa_trc(flash, len);
4628 bfa_trc(flash, offset);
4629
4630 if (!bfa_ioc_is_operational(flash->ioc))
4631 return BFA_STATUS_IOC_NON_OP;
4632
4633 /*
4634 * 'len' must be in word (4-byte) boundary
4635 * 'offset' must be in sector (16kb) boundary
4636 */
4637 if (!len || (len & 0x03) || (offset & 0x00003FFF))
4638 return BFA_STATUS_FLASH_BAD_LEN;
4639
4640 if (type == BFA_FLASH_PART_MFG)
4641 return BFA_STATUS_EINVAL;
4642
4643 if (flash->op_busy) {
4644 bfa_trc(flash, flash->op_busy);
4645 return BFA_STATUS_DEVBUSY;
4646 }
4647
4648 flash->op_busy = 1;
4649 flash->cbfn = cbfn;
4650 flash->cbarg = cbarg;
4651 flash->type = type;
4652 flash->instance = instance;
4653 flash->residue = len;
4654 flash->offset = 0;
4655 flash->addr_off = offset;
4656 flash->ubuf = buf;
4657
4658 bfa_flash_write_send(flash);
4659 return BFA_STATUS_OK;
4660 }
4661
4662 /*
4663 * Read flash partition.
4664 *
4665 * @param[in] flash - flash structure
4666 * @param[in] type - flash partition type
4667 * @param[in] instance - flash partition instance
4668 * @param[in] buf - read data buffer
4669 * @param[in] len - data buffer length
4670 * @param[in] offset - offset relative to the partition starting address
4671 * @param[in] cbfn - callback function
4672 * @param[in] cbarg - callback argument
4673 *
4674 * Return status.
4675 */
4676 bfa_status_t
4677 bfa_flash_read_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
4678 u8 instance, void *buf, u32 len, u32 offset,
4679 bfa_cb_flash_t cbfn, void *cbarg)
4680 {
4681 bfa_trc(flash, BFI_FLASH_H2I_READ_REQ);
4682 bfa_trc(flash, type);
4683 bfa_trc(flash, instance);
4684 bfa_trc(flash, len);
4685 bfa_trc(flash, offset);
4686
4687 if (!bfa_ioc_is_operational(flash->ioc))
4688 return BFA_STATUS_IOC_NON_OP;
4689
4690 /*
4691 * 'len' must be in word (4-byte) boundary
4692 * 'offset' must be in sector (16kb) boundary
4693 */
4694 if (!len || (len & 0x03) || (offset & 0x00003FFF))
4695 return BFA_STATUS_FLASH_BAD_LEN;
4696
4697 if (flash->op_busy) {
4698 bfa_trc(flash, flash->op_busy);
4699 return BFA_STATUS_DEVBUSY;
4700 }
4701
4702 flash->op_busy = 1;
4703 flash->cbfn = cbfn;
4704 flash->cbarg = cbarg;
4705 flash->type = type;
4706 flash->instance = instance;
4707 flash->residue = len;
4708 flash->offset = 0;
4709 flash->addr_off = offset;
4710 flash->ubuf = buf;
4711 bfa_flash_read_send(flash);
4712
4713 return BFA_STATUS_OK;
4714 }
4715
4716 /*
4717 * DIAG module specific
4718 */
4719
4720 #define BFA_DIAG_MEMTEST_TOV 50000 /* memtest timeout in msec */
4721 #define CT2_BFA_DIAG_MEMTEST_TOV (9*30*1000) /* 4.5 min */
4722
4723 /* IOC event handler */
4724 static void
4725 bfa_diag_notify(void *diag_arg, enum bfa_ioc_event_e event)
4726 {
4727 struct bfa_diag_s *diag = diag_arg;
4728
4729 bfa_trc(diag, event);
4730 bfa_trc(diag, diag->block);
4731 bfa_trc(diag, diag->fwping.lock);
4732 bfa_trc(diag, diag->tsensor.lock);
4733
4734 switch (event) {
4735 case BFA_IOC_E_DISABLED:
4736 case BFA_IOC_E_FAILED:
4737 if (diag->fwping.lock) {
4738 diag->fwping.status = BFA_STATUS_IOC_FAILURE;
4739 diag->fwping.cbfn(diag->fwping.cbarg,
4740 diag->fwping.status);
4741 diag->fwping.lock = 0;
4742 }
4743
4744 if (diag->tsensor.lock) {
4745 diag->tsensor.status = BFA_STATUS_IOC_FAILURE;
4746 diag->tsensor.cbfn(diag->tsensor.cbarg,
4747 diag->tsensor.status);
4748 diag->tsensor.lock = 0;
4749 }
4750
4751 if (diag->block) {
4752 if (diag->timer_active) {
4753 bfa_timer_stop(&diag->timer);
4754 diag->timer_active = 0;
4755 }
4756
4757 diag->status = BFA_STATUS_IOC_FAILURE;
4758 diag->cbfn(diag->cbarg, diag->status);
4759 diag->block = 0;
4760 }
4761 break;
4762
4763 default:
4764 break;
4765 }
4766 }
4767
4768 static void
4769 bfa_diag_memtest_done(void *cbarg)
4770 {
4771 struct bfa_diag_s *diag = cbarg;
4772 struct bfa_ioc_s *ioc = diag->ioc;
4773 struct bfa_diag_memtest_result *res = diag->result;
4774 u32 loff = BFI_BOOT_MEMTEST_RES_ADDR;
4775 u32 pgnum, pgoff, i;
4776
4777 pgnum = PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, loff);
4778 pgoff = PSS_SMEM_PGOFF(loff);
4779
4780 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
4781
4782 for (i = 0; i < (sizeof(struct bfa_diag_memtest_result) /
4783 sizeof(u32)); i++) {
4784 /* read test result from smem */
4785 *((u32 *) res + i) =
4786 bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
4787 loff += sizeof(u32);
4788 }
4789
4790 /* Reset IOC fwstates to BFI_IOC_UNINIT */
4791 bfa_ioc_reset_fwstate(ioc);
4792
4793 res->status = swab32(res->status);
4794 bfa_trc(diag, res->status);
4795
4796 if (res->status == BFI_BOOT_MEMTEST_RES_SIG)
4797 diag->status = BFA_STATUS_OK;
4798 else {
4799 diag->status = BFA_STATUS_MEMTEST_FAILED;
4800 res->addr = swab32(res->addr);
4801 res->exp = swab32(res->exp);
4802 res->act = swab32(res->act);
4803 res->err_status = swab32(res->err_status);
4804 res->err_status1 = swab32(res->err_status1);
4805 res->err_addr = swab32(res->err_addr);
4806 bfa_trc(diag, res->addr);
4807 bfa_trc(diag, res->exp);
4808 bfa_trc(diag, res->act);
4809 bfa_trc(diag, res->err_status);
4810 bfa_trc(diag, res->err_status1);
4811 bfa_trc(diag, res->err_addr);
4812 }
4813 diag->timer_active = 0;
4814 diag->cbfn(diag->cbarg, diag->status);
4815 diag->block = 0;
4816 }
4817
4818 /*
4819 * Firmware ping
4820 */
4821
4822 /*
4823 * Perform DMA test directly
4824 */
4825 static void
4826 diag_fwping_send(struct bfa_diag_s *diag)
4827 {
4828 struct bfi_diag_fwping_req_s *fwping_req;
4829 u32 i;
4830
4831 bfa_trc(diag, diag->fwping.dbuf_pa);
4832
4833 /* fill DMA area with pattern */
4834 for (i = 0; i < (BFI_DIAG_DMA_BUF_SZ >> 2); i++)
4835 *((u32 *)diag->fwping.dbuf_kva + i) = diag->fwping.data;
4836
4837 /* Fill mbox msg */
4838 fwping_req = (struct bfi_diag_fwping_req_s *)diag->fwping.mbcmd.msg;
4839
4840 /* Setup SG list */
4841 bfa_alen_set(&fwping_req->alen, BFI_DIAG_DMA_BUF_SZ,
4842 diag->fwping.dbuf_pa);
4843 /* Set up dma count */
4844 fwping_req->count = cpu_to_be32(diag->fwping.count);
4845 /* Set up data pattern */
4846 fwping_req->data = diag->fwping.data;
4847
4848 /* build host command */
4849 bfi_h2i_set(fwping_req->mh, BFI_MC_DIAG, BFI_DIAG_H2I_FWPING,
4850 bfa_ioc_portid(diag->ioc));
4851
4852 /* send mbox cmd */
4853 bfa_ioc_mbox_queue(diag->ioc, &diag->fwping.mbcmd);
4854 }
4855
4856 static void
4857 diag_fwping_comp(struct bfa_diag_s *diag,
4858 struct bfi_diag_fwping_rsp_s *diag_rsp)
4859 {
4860 u32 rsp_data = diag_rsp->data;
4861 u8 rsp_dma_status = diag_rsp->dma_status;
4862
4863 bfa_trc(diag, rsp_data);
4864 bfa_trc(diag, rsp_dma_status);
4865
4866 if (rsp_dma_status == BFA_STATUS_OK) {
4867 u32 i, pat;
4868 pat = (diag->fwping.count & 0x1) ? ~(diag->fwping.data) :
4869 diag->fwping.data;
4870 /* Check mbox data */
4871 if (diag->fwping.data != rsp_data) {
4872 bfa_trc(diag, rsp_data);
4873 diag->fwping.result->dmastatus =
4874 BFA_STATUS_DATACORRUPTED;
4875 diag->fwping.status = BFA_STATUS_DATACORRUPTED;
4876 diag->fwping.cbfn(diag->fwping.cbarg,
4877 diag->fwping.status);
4878 diag->fwping.lock = 0;
4879 return;
4880 }
4881 /* Check dma pattern */
4882 for (i = 0; i < (BFI_DIAG_DMA_BUF_SZ >> 2); i++) {
4883 if (*((u32 *)diag->fwping.dbuf_kva + i) != pat) {
4884 bfa_trc(diag, i);
4885 bfa_trc(diag, pat);
4886 bfa_trc(diag,
4887 *((u32 *)diag->fwping.dbuf_kva + i));
4888 diag->fwping.result->dmastatus =
4889 BFA_STATUS_DATACORRUPTED;
4890 diag->fwping.status = BFA_STATUS_DATACORRUPTED;
4891 diag->fwping.cbfn(diag->fwping.cbarg,
4892 diag->fwping.status);
4893 diag->fwping.lock = 0;
4894 return;
4895 }
4896 }
4897 diag->fwping.result->dmastatus = BFA_STATUS_OK;
4898 diag->fwping.status = BFA_STATUS_OK;
4899 diag->fwping.cbfn(diag->fwping.cbarg, diag->fwping.status);
4900 diag->fwping.lock = 0;
4901 } else {
4902 diag->fwping.status = BFA_STATUS_HDMA_FAILED;
4903 diag->fwping.cbfn(diag->fwping.cbarg, diag->fwping.status);
4904 diag->fwping.lock = 0;
4905 }
4906 }
4907
4908 /*
4909 * Temperature Sensor
4910 */
4911
4912 static void
4913 diag_tempsensor_send(struct bfa_diag_s *diag)
4914 {
4915 struct bfi_diag_ts_req_s *msg;
4916
4917 msg = (struct bfi_diag_ts_req_s *)diag->tsensor.mbcmd.msg;
4918 bfa_trc(diag, msg->temp);
4919 /* build host command */
4920 bfi_h2i_set(msg->mh, BFI_MC_DIAG, BFI_DIAG_H2I_TEMPSENSOR,
4921 bfa_ioc_portid(diag->ioc));
4922 /* send mbox cmd */
4923 bfa_ioc_mbox_queue(diag->ioc, &diag->tsensor.mbcmd);
4924 }
4925
4926 static void
4927 diag_tempsensor_comp(struct bfa_diag_s *diag, bfi_diag_ts_rsp_t *rsp)
4928 {
4929 if (!diag->tsensor.lock) {
4930 /* receiving response after ioc failure */
4931 bfa_trc(diag, diag->tsensor.lock);
4932 return;
4933 }
4934
4935 /*
4936 * ASIC junction tempsensor is a reg read operation
4937 * it will always return OK
4938 */
4939 diag->tsensor.temp->temp = be16_to_cpu(rsp->temp);
4940 diag->tsensor.temp->ts_junc = rsp->ts_junc;
4941 diag->tsensor.temp->ts_brd = rsp->ts_brd;
4942
4943 if (rsp->ts_brd) {
4944 /* tsensor.temp->status is brd_temp status */
4945 diag->tsensor.temp->status = rsp->status;
4946 if (rsp->status == BFA_STATUS_OK) {
4947 diag->tsensor.temp->brd_temp =
4948 be16_to_cpu(rsp->brd_temp);
4949 } else
4950 diag->tsensor.temp->brd_temp = 0;
4951 }
4952
4953 bfa_trc(diag, rsp->status);
4954 bfa_trc(diag, rsp->ts_junc);
4955 bfa_trc(diag, rsp->temp);
4956 bfa_trc(diag, rsp->ts_brd);
4957 bfa_trc(diag, rsp->brd_temp);
4958
4959 /* tsensor status is always good bcos we always have junction temp */
4960 diag->tsensor.status = BFA_STATUS_OK;
4961 diag->tsensor.cbfn(diag->tsensor.cbarg, diag->tsensor.status);
4962 diag->tsensor.lock = 0;
4963 }
4964
4965 /*
4966 * LED Test command
4967 */
4968 static void
4969 diag_ledtest_send(struct bfa_diag_s *diag, struct bfa_diag_ledtest_s *ledtest)
4970 {
4971 struct bfi_diag_ledtest_req_s *msg;
4972
4973 msg = (struct bfi_diag_ledtest_req_s *)diag->ledtest.mbcmd.msg;
4974 /* build host command */
4975 bfi_h2i_set(msg->mh, BFI_MC_DIAG, BFI_DIAG_H2I_LEDTEST,
4976 bfa_ioc_portid(diag->ioc));
4977
4978 /*
4979 * convert the freq from N blinks per 10 sec to
4980 * crossbow ontime value. We do it here because division is need
4981 */
4982 if (ledtest->freq)
4983 ledtest->freq = 500 / ledtest->freq;
4984
4985 if (ledtest->freq == 0)
4986 ledtest->freq = 1;
4987
4988 bfa_trc(diag, ledtest->freq);
4989 /* mcpy(&ledtest_req->req, ledtest, sizeof(bfa_diag_ledtest_t)); */
4990 msg->cmd = (u8) ledtest->cmd;
4991 msg->color = (u8) ledtest->color;
4992 msg->portid = bfa_ioc_portid(diag->ioc);
4993 msg->led = ledtest->led;
4994 msg->freq = cpu_to_be16(ledtest->freq);
4995
4996 /* send mbox cmd */
4997 bfa_ioc_mbox_queue(diag->ioc, &diag->ledtest.mbcmd);
4998 }
4999
5000 static void
5001 diag_ledtest_comp(struct bfa_diag_s *diag, struct bfi_diag_ledtest_rsp_s *msg)
5002 {
5003 bfa_trc(diag, diag->ledtest.lock);
5004 diag->ledtest.lock = BFA_FALSE;
5005 /* no bfa_cb_queue is needed because driver is not waiting */
5006 }
5007
5008 /*
5009 * Port beaconing
5010 */
5011 static void
5012 diag_portbeacon_send(struct bfa_diag_s *diag, bfa_boolean_t beacon, u32 sec)
5013 {
5014 struct bfi_diag_portbeacon_req_s *msg;
5015
5016 msg = (struct bfi_diag_portbeacon_req_s *)diag->beacon.mbcmd.msg;
5017 /* build host command */
5018 bfi_h2i_set(msg->mh, BFI_MC_DIAG, BFI_DIAG_H2I_PORTBEACON,
5019 bfa_ioc_portid(diag->ioc));
5020 msg->beacon = beacon;
5021 msg->period = cpu_to_be32(sec);
5022 /* send mbox cmd */
5023 bfa_ioc_mbox_queue(diag->ioc, &diag->beacon.mbcmd);
5024 }
5025
5026 static void
5027 diag_portbeacon_comp(struct bfa_diag_s *diag)
5028 {
5029 bfa_trc(diag, diag->beacon.state);
5030 diag->beacon.state = BFA_FALSE;
5031 if (diag->cbfn_beacon)
5032 diag->cbfn_beacon(diag->dev, BFA_FALSE, diag->beacon.link_e2e);
5033 }
5034
5035 /*
5036 * Diag hmbox handler
5037 */
5038 void
5039 bfa_diag_intr(void *diagarg, struct bfi_mbmsg_s *msg)
5040 {
5041 struct bfa_diag_s *diag = diagarg;
5042
5043 switch (msg->mh.msg_id) {
5044 case BFI_DIAG_I2H_PORTBEACON:
5045 diag_portbeacon_comp(diag);
5046 break;
5047 case BFI_DIAG_I2H_FWPING:
5048 diag_fwping_comp(diag, (struct bfi_diag_fwping_rsp_s *) msg);
5049 break;
5050 case BFI_DIAG_I2H_TEMPSENSOR:
5051 diag_tempsensor_comp(diag, (bfi_diag_ts_rsp_t *) msg);
5052 break;
5053 case BFI_DIAG_I2H_LEDTEST:
5054 diag_ledtest_comp(diag, (struct bfi_diag_ledtest_rsp_s *) msg);
5055 break;
5056 default:
5057 bfa_trc(diag, msg->mh.msg_id);
5058 WARN_ON(1);
5059 }
5060 }
5061
5062 /*
5063 * Gen RAM Test
5064 *
5065 * @param[in] *diag - diag data struct
5066 * @param[in] *memtest - mem test params input from upper layer,
5067 * @param[in] pattern - mem test pattern
5068 * @param[in] *result - mem test result
5069 * @param[in] cbfn - mem test callback functioin
5070 * @param[in] cbarg - callback functioin arg
5071 *
5072 * @param[out]
5073 */
5074 bfa_status_t
5075 bfa_diag_memtest(struct bfa_diag_s *diag, struct bfa_diag_memtest_s *memtest,
5076 u32 pattern, struct bfa_diag_memtest_result *result,
5077 bfa_cb_diag_t cbfn, void *cbarg)
5078 {
5079 u32 memtest_tov;
5080
5081 bfa_trc(diag, pattern);
5082
5083 if (!bfa_ioc_adapter_is_disabled(diag->ioc))
5084 return BFA_STATUS_ADAPTER_ENABLED;
5085
5086 /* check to see if there is another destructive diag cmd running */
5087 if (diag->block) {
5088 bfa_trc(diag, diag->block);
5089 return BFA_STATUS_DEVBUSY;
5090 } else
5091 diag->block = 1;
5092
5093 diag->result = result;
5094 diag->cbfn = cbfn;
5095 diag->cbarg = cbarg;
5096
5097 /* download memtest code and take LPU0 out of reset */
5098 bfa_ioc_boot(diag->ioc, BFI_FWBOOT_TYPE_MEMTEST, BFI_FWBOOT_ENV_OS);
5099
5100 memtest_tov = (bfa_ioc_asic_gen(diag->ioc) == BFI_ASIC_GEN_CT2) ?
5101 CT2_BFA_DIAG_MEMTEST_TOV : BFA_DIAG_MEMTEST_TOV;
5102 bfa_timer_begin(diag->ioc->timer_mod, &diag->timer,
5103 bfa_diag_memtest_done, diag, memtest_tov);
5104 diag->timer_active = 1;
5105 return BFA_STATUS_OK;
5106 }
5107
5108 /*
5109 * DIAG firmware ping command
5110 *
5111 * @param[in] *diag - diag data struct
5112 * @param[in] cnt - dma loop count for testing PCIE
5113 * @param[in] data - data pattern to pass in fw
5114 * @param[in] *result - pt to bfa_diag_fwping_result_t data struct
5115 * @param[in] cbfn - callback function
5116 * @param[in] *cbarg - callback functioin arg
5117 *
5118 * @param[out]
5119 */
5120 bfa_status_t
5121 bfa_diag_fwping(struct bfa_diag_s *diag, u32 cnt, u32 data,
5122 struct bfa_diag_results_fwping *result, bfa_cb_diag_t cbfn,
5123 void *cbarg)
5124 {
5125 bfa_trc(diag, cnt);
5126 bfa_trc(diag, data);
5127
5128 if (!bfa_ioc_is_operational(diag->ioc))
5129 return BFA_STATUS_IOC_NON_OP;
5130
5131 if (bfa_asic_id_ct2(bfa_ioc_devid((diag->ioc))) &&
5132 ((diag->ioc)->clscode == BFI_PCIFN_CLASS_ETH))
5133 return BFA_STATUS_CMD_NOTSUPP;
5134
5135 /* check to see if there is another destructive diag cmd running */
5136 if (diag->block || diag->fwping.lock) {
5137 bfa_trc(diag, diag->block);
5138 bfa_trc(diag, diag->fwping.lock);
5139 return BFA_STATUS_DEVBUSY;
5140 }
5141
5142 /* Initialization */
5143 diag->fwping.lock = 1;
5144 diag->fwping.cbfn = cbfn;
5145 diag->fwping.cbarg = cbarg;
5146 diag->fwping.result = result;
5147 diag->fwping.data = data;
5148 diag->fwping.count = cnt;
5149
5150 /* Init test results */
5151 diag->fwping.result->data = 0;
5152 diag->fwping.result->status = BFA_STATUS_OK;
5153
5154 /* kick off the first ping */
5155 diag_fwping_send(diag);
5156 return BFA_STATUS_OK;
5157 }
5158
5159 /*
5160 * Read Temperature Sensor
5161 *
5162 * @param[in] *diag - diag data struct
5163 * @param[in] *result - pt to bfa_diag_temp_t data struct
5164 * @param[in] cbfn - callback function
5165 * @param[in] *cbarg - callback functioin arg
5166 *
5167 * @param[out]
5168 */
5169 bfa_status_t
5170 bfa_diag_tsensor_query(struct bfa_diag_s *diag,
5171 struct bfa_diag_results_tempsensor_s *result,
5172 bfa_cb_diag_t cbfn, void *cbarg)
5173 {
5174 /* check to see if there is a destructive diag cmd running */
5175 if (diag->block || diag->tsensor.lock) {
5176 bfa_trc(diag, diag->block);
5177 bfa_trc(diag, diag->tsensor.lock);
5178 return BFA_STATUS_DEVBUSY;
5179 }
5180
5181 if (!bfa_ioc_is_operational(diag->ioc))
5182 return BFA_STATUS_IOC_NON_OP;
5183
5184 /* Init diag mod params */
5185 diag->tsensor.lock = 1;
5186 diag->tsensor.temp = result;
5187 diag->tsensor.cbfn = cbfn;
5188 diag->tsensor.cbarg = cbarg;
5189 diag->tsensor.status = BFA_STATUS_OK;
5190
5191 /* Send msg to fw */
5192 diag_tempsensor_send(diag);
5193
5194 return BFA_STATUS_OK;
5195 }
5196
5197 /*
5198 * LED Test command
5199 *
5200 * @param[in] *diag - diag data struct
5201 * @param[in] *ledtest - pt to ledtest data structure
5202 *
5203 * @param[out]
5204 */
5205 bfa_status_t
5206 bfa_diag_ledtest(struct bfa_diag_s *diag, struct bfa_diag_ledtest_s *ledtest)
5207 {
5208 bfa_trc(diag, ledtest->cmd);
5209
5210 if (!bfa_ioc_is_operational(diag->ioc))
5211 return BFA_STATUS_IOC_NON_OP;
5212
5213 if (diag->beacon.state)
5214 return BFA_STATUS_BEACON_ON;
5215
5216 if (diag->ledtest.lock)
5217 return BFA_STATUS_LEDTEST_OP;
5218
5219 /* Send msg to fw */
5220 diag->ledtest.lock = BFA_TRUE;
5221 diag_ledtest_send(diag, ledtest);
5222
5223 return BFA_STATUS_OK;
5224 }
5225
5226 /*
5227 * Port beaconing command
5228 *
5229 * @param[in] *diag - diag data struct
5230 * @param[in] beacon - port beaconing 1:ON 0:OFF
5231 * @param[in] link_e2e_beacon - link beaconing 1:ON 0:OFF
5232 * @param[in] sec - beaconing duration in seconds
5233 *
5234 * @param[out]
5235 */
5236 bfa_status_t
5237 bfa_diag_beacon_port(struct bfa_diag_s *diag, bfa_boolean_t beacon,
5238 bfa_boolean_t link_e2e_beacon, uint32_t sec)
5239 {
5240 bfa_trc(diag, beacon);
5241 bfa_trc(diag, link_e2e_beacon);
5242 bfa_trc(diag, sec);
5243
5244 if (!bfa_ioc_is_operational(diag->ioc))
5245 return BFA_STATUS_IOC_NON_OP;
5246
5247 if (diag->ledtest.lock)
5248 return BFA_STATUS_LEDTEST_OP;
5249
5250 if (diag->beacon.state && beacon) /* beacon alread on */
5251 return BFA_STATUS_BEACON_ON;
5252
5253 diag->beacon.state = beacon;
5254 diag->beacon.link_e2e = link_e2e_beacon;
5255 if (diag->cbfn_beacon)
5256 diag->cbfn_beacon(diag->dev, beacon, link_e2e_beacon);
5257
5258 /* Send msg to fw */
5259 diag_portbeacon_send(diag, beacon, sec);
5260
5261 return BFA_STATUS_OK;
5262 }
5263
5264 /*
5265 * Return DMA memory needed by diag module.
5266 */
5267 u32
5268 bfa_diag_meminfo(void)
5269 {
5270 return BFA_ROUNDUP(BFI_DIAG_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5271 }
5272
5273 /*
5274 * Attach virtual and physical memory for Diag.
5275 */
5276 void
5277 bfa_diag_attach(struct bfa_diag_s *diag, struct bfa_ioc_s *ioc, void *dev,
5278 bfa_cb_diag_beacon_t cbfn_beacon, struct bfa_trc_mod_s *trcmod)
5279 {
5280 diag->dev = dev;
5281 diag->ioc = ioc;
5282 diag->trcmod = trcmod;
5283
5284 diag->block = 0;
5285 diag->cbfn = NULL;
5286 diag->cbarg = NULL;
5287 diag->result = NULL;
5288 diag->cbfn_beacon = cbfn_beacon;
5289
5290 bfa_ioc_mbox_regisr(diag->ioc, BFI_MC_DIAG, bfa_diag_intr, diag);
5291 bfa_q_qe_init(&diag->ioc_notify);
5292 bfa_ioc_notify_init(&diag->ioc_notify, bfa_diag_notify, diag);
5293 list_add_tail(&diag->ioc_notify.qe, &diag->ioc->notify_q);
5294 }
5295
5296 void
5297 bfa_diag_memclaim(struct bfa_diag_s *diag, u8 *dm_kva, u64 dm_pa)
5298 {
5299 diag->fwping.dbuf_kva = dm_kva;
5300 diag->fwping.dbuf_pa = dm_pa;
5301 memset(diag->fwping.dbuf_kva, 0, BFI_DIAG_DMA_BUF_SZ);
5302 }
5303
5304 /*
5305 * PHY module specific
5306 */
5307 #define BFA_PHY_DMA_BUF_SZ 0x02000 /* 8k dma buffer */
5308 #define BFA_PHY_LOCK_STATUS 0x018878 /* phy semaphore status reg */
5309
5310 static void
5311 bfa_phy_ntoh32(u32 *obuf, u32 *ibuf, int sz)
5312 {
5313 int i, m = sz >> 2;
5314
5315 for (i = 0; i < m; i++)
5316 obuf[i] = be32_to_cpu(ibuf[i]);
5317 }
5318
5319 static bfa_boolean_t
5320 bfa_phy_present(struct bfa_phy_s *phy)
5321 {
5322 return (phy->ioc->attr->card_type == BFA_MFG_TYPE_LIGHTNING);
5323 }
5324
5325 static void
5326 bfa_phy_notify(void *cbarg, enum bfa_ioc_event_e event)
5327 {
5328 struct bfa_phy_s *phy = cbarg;
5329
5330 bfa_trc(phy, event);
5331
5332 switch (event) {
5333 case BFA_IOC_E_DISABLED:
5334 case BFA_IOC_E_FAILED:
5335 if (phy->op_busy) {
5336 phy->status = BFA_STATUS_IOC_FAILURE;
5337 phy->cbfn(phy->cbarg, phy->status);
5338 phy->op_busy = 0;
5339 }
5340 break;
5341
5342 default:
5343 break;
5344 }
5345 }
5346
5347 /*
5348 * Send phy attribute query request.
5349 *
5350 * @param[in] cbarg - callback argument
5351 */
5352 static void
5353 bfa_phy_query_send(void *cbarg)
5354 {
5355 struct bfa_phy_s *phy = cbarg;
5356 struct bfi_phy_query_req_s *msg =
5357 (struct bfi_phy_query_req_s *) phy->mb.msg;
5358
5359 msg->instance = phy->instance;
5360 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_QUERY_REQ,
5361 bfa_ioc_portid(phy->ioc));
5362 bfa_alen_set(&msg->alen, sizeof(struct bfa_phy_attr_s), phy->dbuf_pa);
5363 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5364 }
5365
5366 /*
5367 * Send phy write request.
5368 *
5369 * @param[in] cbarg - callback argument
5370 */
5371 static void
5372 bfa_phy_write_send(void *cbarg)
5373 {
5374 struct bfa_phy_s *phy = cbarg;
5375 struct bfi_phy_write_req_s *msg =
5376 (struct bfi_phy_write_req_s *) phy->mb.msg;
5377 u32 len;
5378 u16 *buf, *dbuf;
5379 int i, sz;
5380
5381 msg->instance = phy->instance;
5382 msg->offset = cpu_to_be32(phy->addr_off + phy->offset);
5383 len = (phy->residue < BFA_PHY_DMA_BUF_SZ) ?
5384 phy->residue : BFA_PHY_DMA_BUF_SZ;
5385 msg->length = cpu_to_be32(len);
5386
5387 /* indicate if it's the last msg of the whole write operation */
5388 msg->last = (len == phy->residue) ? 1 : 0;
5389
5390 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_WRITE_REQ,
5391 bfa_ioc_portid(phy->ioc));
5392 bfa_alen_set(&msg->alen, len, phy->dbuf_pa);
5393
5394 buf = (u16 *) (phy->ubuf + phy->offset);
5395 dbuf = (u16 *)phy->dbuf_kva;
5396 sz = len >> 1;
5397 for (i = 0; i < sz; i++)
5398 buf[i] = cpu_to_be16(dbuf[i]);
5399
5400 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5401
5402 phy->residue -= len;
5403 phy->offset += len;
5404 }
5405
5406 /*
5407 * Send phy read request.
5408 *
5409 * @param[in] cbarg - callback argument
5410 */
5411 static void
5412 bfa_phy_read_send(void *cbarg)
5413 {
5414 struct bfa_phy_s *phy = cbarg;
5415 struct bfi_phy_read_req_s *msg =
5416 (struct bfi_phy_read_req_s *) phy->mb.msg;
5417 u32 len;
5418
5419 msg->instance = phy->instance;
5420 msg->offset = cpu_to_be32(phy->addr_off + phy->offset);
5421 len = (phy->residue < BFA_PHY_DMA_BUF_SZ) ?
5422 phy->residue : BFA_PHY_DMA_BUF_SZ;
5423 msg->length = cpu_to_be32(len);
5424 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_READ_REQ,
5425 bfa_ioc_portid(phy->ioc));
5426 bfa_alen_set(&msg->alen, len, phy->dbuf_pa);
5427 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5428 }
5429
5430 /*
5431 * Send phy stats request.
5432 *
5433 * @param[in] cbarg - callback argument
5434 */
5435 static void
5436 bfa_phy_stats_send(void *cbarg)
5437 {
5438 struct bfa_phy_s *phy = cbarg;
5439 struct bfi_phy_stats_req_s *msg =
5440 (struct bfi_phy_stats_req_s *) phy->mb.msg;
5441
5442 msg->instance = phy->instance;
5443 bfi_h2i_set(msg->mh, BFI_MC_PHY, BFI_PHY_H2I_STATS_REQ,
5444 bfa_ioc_portid(phy->ioc));
5445 bfa_alen_set(&msg->alen, sizeof(struct bfa_phy_stats_s), phy->dbuf_pa);
5446 bfa_ioc_mbox_queue(phy->ioc, &phy->mb);
5447 }
5448
5449 /*
5450 * Flash memory info API.
5451 *
5452 * @param[in] mincfg - minimal cfg variable
5453 */
5454 u32
5455 bfa_phy_meminfo(bfa_boolean_t mincfg)
5456 {
5457 /* min driver doesn't need phy */
5458 if (mincfg)
5459 return 0;
5460
5461 return BFA_ROUNDUP(BFA_PHY_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5462 }
5463
5464 /*
5465 * Flash attach API.
5466 *
5467 * @param[in] phy - phy structure
5468 * @param[in] ioc - ioc structure
5469 * @param[in] dev - device structure
5470 * @param[in] trcmod - trace module
5471 * @param[in] logmod - log module
5472 */
5473 void
5474 bfa_phy_attach(struct bfa_phy_s *phy, struct bfa_ioc_s *ioc, void *dev,
5475 struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg)
5476 {
5477 phy->ioc = ioc;
5478 phy->trcmod = trcmod;
5479 phy->cbfn = NULL;
5480 phy->cbarg = NULL;
5481 phy->op_busy = 0;
5482
5483 bfa_ioc_mbox_regisr(phy->ioc, BFI_MC_PHY, bfa_phy_intr, phy);
5484 bfa_q_qe_init(&phy->ioc_notify);
5485 bfa_ioc_notify_init(&phy->ioc_notify, bfa_phy_notify, phy);
5486 list_add_tail(&phy->ioc_notify.qe, &phy->ioc->notify_q);
5487
5488 /* min driver doesn't need phy */
5489 if (mincfg) {
5490 phy->dbuf_kva = NULL;
5491 phy->dbuf_pa = 0;
5492 }
5493 }
5494
5495 /*
5496 * Claim memory for phy
5497 *
5498 * @param[in] phy - phy structure
5499 * @param[in] dm_kva - pointer to virtual memory address
5500 * @param[in] dm_pa - physical memory address
5501 * @param[in] mincfg - minimal cfg variable
5502 */
5503 void
5504 bfa_phy_memclaim(struct bfa_phy_s *phy, u8 *dm_kva, u64 dm_pa,
5505 bfa_boolean_t mincfg)
5506 {
5507 if (mincfg)
5508 return;
5509
5510 phy->dbuf_kva = dm_kva;
5511 phy->dbuf_pa = dm_pa;
5512 memset(phy->dbuf_kva, 0, BFA_PHY_DMA_BUF_SZ);
5513 dm_kva += BFA_ROUNDUP(BFA_PHY_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5514 dm_pa += BFA_ROUNDUP(BFA_PHY_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
5515 }
5516
5517 bfa_boolean_t
5518 bfa_phy_busy(struct bfa_ioc_s *ioc)
5519 {
5520 void __iomem *rb;
5521
5522 rb = bfa_ioc_bar0(ioc);
5523 return readl(rb + BFA_PHY_LOCK_STATUS);
5524 }
5525
5526 /*
5527 * Get phy attribute.
5528 *
5529 * @param[in] phy - phy structure
5530 * @param[in] attr - phy attribute structure
5531 * @param[in] cbfn - callback function
5532 * @param[in] cbarg - callback argument
5533 *
5534 * Return status.
5535 */
5536 bfa_status_t
5537 bfa_phy_get_attr(struct bfa_phy_s *phy, u8 instance,
5538 struct bfa_phy_attr_s *attr, bfa_cb_phy_t cbfn, void *cbarg)
5539 {
5540 bfa_trc(phy, BFI_PHY_H2I_QUERY_REQ);
5541 bfa_trc(phy, instance);
5542
5543 if (!bfa_phy_present(phy))
5544 return BFA_STATUS_PHY_NOT_PRESENT;
5545
5546 if (!bfa_ioc_is_operational(phy->ioc))
5547 return BFA_STATUS_IOC_NON_OP;
5548
5549 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5550 bfa_trc(phy, phy->op_busy);
5551 return BFA_STATUS_DEVBUSY;
5552 }
5553
5554 phy->op_busy = 1;
5555 phy->cbfn = cbfn;
5556 phy->cbarg = cbarg;
5557 phy->instance = instance;
5558 phy->ubuf = (uint8_t *) attr;
5559 bfa_phy_query_send(phy);
5560
5561 return BFA_STATUS_OK;
5562 }
5563
5564 /*
5565 * Get phy stats.
5566 *
5567 * @param[in] phy - phy structure
5568 * @param[in] instance - phy image instance
5569 * @param[in] stats - pointer to phy stats
5570 * @param[in] cbfn - callback function
5571 * @param[in] cbarg - callback argument
5572 *
5573 * Return status.
5574 */
5575 bfa_status_t
5576 bfa_phy_get_stats(struct bfa_phy_s *phy, u8 instance,
5577 struct bfa_phy_stats_s *stats,
5578 bfa_cb_phy_t cbfn, void *cbarg)
5579 {
5580 bfa_trc(phy, BFI_PHY_H2I_STATS_REQ);
5581 bfa_trc(phy, instance);
5582
5583 if (!bfa_phy_present(phy))
5584 return BFA_STATUS_PHY_NOT_PRESENT;
5585
5586 if (!bfa_ioc_is_operational(phy->ioc))
5587 return BFA_STATUS_IOC_NON_OP;
5588
5589 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5590 bfa_trc(phy, phy->op_busy);
5591 return BFA_STATUS_DEVBUSY;
5592 }
5593
5594 phy->op_busy = 1;
5595 phy->cbfn = cbfn;
5596 phy->cbarg = cbarg;
5597 phy->instance = instance;
5598 phy->ubuf = (u8 *) stats;
5599 bfa_phy_stats_send(phy);
5600
5601 return BFA_STATUS_OK;
5602 }
5603
5604 /*
5605 * Update phy image.
5606 *
5607 * @param[in] phy - phy structure
5608 * @param[in] instance - phy image instance
5609 * @param[in] buf - update data buffer
5610 * @param[in] len - data buffer length
5611 * @param[in] offset - offset relative to starting address
5612 * @param[in] cbfn - callback function
5613 * @param[in] cbarg - callback argument
5614 *
5615 * Return status.
5616 */
5617 bfa_status_t
5618 bfa_phy_update(struct bfa_phy_s *phy, u8 instance,
5619 void *buf, u32 len, u32 offset,
5620 bfa_cb_phy_t cbfn, void *cbarg)
5621 {
5622 bfa_trc(phy, BFI_PHY_H2I_WRITE_REQ);
5623 bfa_trc(phy, instance);
5624 bfa_trc(phy, len);
5625 bfa_trc(phy, offset);
5626
5627 if (!bfa_phy_present(phy))
5628 return BFA_STATUS_PHY_NOT_PRESENT;
5629
5630 if (!bfa_ioc_is_operational(phy->ioc))
5631 return BFA_STATUS_IOC_NON_OP;
5632
5633 /* 'len' must be in word (4-byte) boundary */
5634 if (!len || (len & 0x03))
5635 return BFA_STATUS_FAILED;
5636
5637 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5638 bfa_trc(phy, phy->op_busy);
5639 return BFA_STATUS_DEVBUSY;
5640 }
5641
5642 phy->op_busy = 1;
5643 phy->cbfn = cbfn;
5644 phy->cbarg = cbarg;
5645 phy->instance = instance;
5646 phy->residue = len;
5647 phy->offset = 0;
5648 phy->addr_off = offset;
5649 phy->ubuf = buf;
5650
5651 bfa_phy_write_send(phy);
5652 return BFA_STATUS_OK;
5653 }
5654
5655 /*
5656 * Read phy image.
5657 *
5658 * @param[in] phy - phy structure
5659 * @param[in] instance - phy image instance
5660 * @param[in] buf - read data buffer
5661 * @param[in] len - data buffer length
5662 * @param[in] offset - offset relative to starting address
5663 * @param[in] cbfn - callback function
5664 * @param[in] cbarg - callback argument
5665 *
5666 * Return status.
5667 */
5668 bfa_status_t
5669 bfa_phy_read(struct bfa_phy_s *phy, u8 instance,
5670 void *buf, u32 len, u32 offset,
5671 bfa_cb_phy_t cbfn, void *cbarg)
5672 {
5673 bfa_trc(phy, BFI_PHY_H2I_READ_REQ);
5674 bfa_trc(phy, instance);
5675 bfa_trc(phy, len);
5676 bfa_trc(phy, offset);
5677
5678 if (!bfa_phy_present(phy))
5679 return BFA_STATUS_PHY_NOT_PRESENT;
5680
5681 if (!bfa_ioc_is_operational(phy->ioc))
5682 return BFA_STATUS_IOC_NON_OP;
5683
5684 /* 'len' must be in word (4-byte) boundary */
5685 if (!len || (len & 0x03))
5686 return BFA_STATUS_FAILED;
5687
5688 if (phy->op_busy || bfa_phy_busy(phy->ioc)) {
5689 bfa_trc(phy, phy->op_busy);
5690 return BFA_STATUS_DEVBUSY;
5691 }
5692
5693 phy->op_busy = 1;
5694 phy->cbfn = cbfn;
5695 phy->cbarg = cbarg;
5696 phy->instance = instance;
5697 phy->residue = len;
5698 phy->offset = 0;
5699 phy->addr_off = offset;
5700 phy->ubuf = buf;
5701 bfa_phy_read_send(phy);
5702
5703 return BFA_STATUS_OK;
5704 }
5705
5706 /*
5707 * Process phy response messages upon receiving interrupts.
5708 *
5709 * @param[in] phyarg - phy structure
5710 * @param[in] msg - message structure
5711 */
5712 void
5713 bfa_phy_intr(void *phyarg, struct bfi_mbmsg_s *msg)
5714 {
5715 struct bfa_phy_s *phy = phyarg;
5716 u32 status;
5717
5718 union {
5719 struct bfi_phy_query_rsp_s *query;
5720 struct bfi_phy_stats_rsp_s *stats;
5721 struct bfi_phy_write_rsp_s *write;
5722 struct bfi_phy_read_rsp_s *read;
5723 struct bfi_mbmsg_s *msg;
5724 } m;
5725
5726 m.msg = msg;
5727 bfa_trc(phy, msg->mh.msg_id);
5728
5729 if (!phy->op_busy) {
5730 /* receiving response after ioc failure */
5731 bfa_trc(phy, 0x9999);
5732 return;
5733 }
5734
5735 switch (msg->mh.msg_id) {
5736 case BFI_PHY_I2H_QUERY_RSP:
5737 status = be32_to_cpu(m.query->status);
5738 bfa_trc(phy, status);
5739
5740 if (status == BFA_STATUS_OK) {
5741 struct bfa_phy_attr_s *attr =
5742 (struct bfa_phy_attr_s *) phy->ubuf;
5743 bfa_phy_ntoh32((u32 *)attr, (u32 *)phy->dbuf_kva,
5744 sizeof(struct bfa_phy_attr_s));
5745 bfa_trc(phy, attr->status);
5746 bfa_trc(phy, attr->length);
5747 }
5748
5749 phy->status = status;
5750 phy->op_busy = 0;
5751 if (phy->cbfn)
5752 phy->cbfn(phy->cbarg, phy->status);
5753 break;
5754 case BFI_PHY_I2H_STATS_RSP:
5755 status = be32_to_cpu(m.stats->status);
5756 bfa_trc(phy, status);
5757
5758 if (status == BFA_STATUS_OK) {
5759 struct bfa_phy_stats_s *stats =
5760 (struct bfa_phy_stats_s *) phy->ubuf;
5761 bfa_phy_ntoh32((u32 *)stats, (u32 *)phy->dbuf_kva,
5762 sizeof(struct bfa_phy_stats_s));
5763 bfa_trc(phy, stats->status);
5764 }
5765
5766 phy->status = status;
5767 phy->op_busy = 0;
5768 if (phy->cbfn)
5769 phy->cbfn(phy->cbarg, phy->status);
5770 break;
5771 case BFI_PHY_I2H_WRITE_RSP:
5772 status = be32_to_cpu(m.write->status);
5773 bfa_trc(phy, status);
5774
5775 if (status != BFA_STATUS_OK || phy->residue == 0) {
5776 phy->status = status;
5777 phy->op_busy = 0;
5778 if (phy->cbfn)
5779 phy->cbfn(phy->cbarg, phy->status);
5780 } else {
5781 bfa_trc(phy, phy->offset);
5782 bfa_phy_write_send(phy);
5783 }
5784 break;
5785 case BFI_PHY_I2H_READ_RSP:
5786 status = be32_to_cpu(m.read->status);
5787 bfa_trc(phy, status);
5788
5789 if (status != BFA_STATUS_OK) {
5790 phy->status = status;
5791 phy->op_busy = 0;
5792 if (phy->cbfn)
5793 phy->cbfn(phy->cbarg, phy->status);
5794 } else {
5795 u32 len = be32_to_cpu(m.read->length);
5796 u16 *buf = (u16 *)(phy->ubuf + phy->offset);
5797 u16 *dbuf = (u16 *)phy->dbuf_kva;
5798 int i, sz = len >> 1;
5799
5800 bfa_trc(phy, phy->offset);
5801 bfa_trc(phy, len);
5802
5803 for (i = 0; i < sz; i++)
5804 buf[i] = be16_to_cpu(dbuf[i]);
5805
5806 phy->residue -= len;
5807 phy->offset += len;
5808
5809 if (phy->residue == 0) {
5810 phy->status = status;
5811 phy->op_busy = 0;
5812 if (phy->cbfn)
5813 phy->cbfn(phy->cbarg, phy->status);
5814 } else
5815 bfa_phy_read_send(phy);
5816 }
5817 break;
5818 default:
5819 WARN_ON(1);
5820 }
5821 }
5822
5823 /*
5824 * DCONF module specific
5825 */
5826
5827 BFA_MODULE(dconf);
5828
5829 /*
5830 * DCONF state machine events
5831 */
5832 enum bfa_dconf_event {
5833 BFA_DCONF_SM_INIT = 1, /* dconf Init */
5834 BFA_DCONF_SM_FLASH_COMP = 2, /* read/write to flash */
5835 BFA_DCONF_SM_WR = 3, /* binding change, map */
5836 BFA_DCONF_SM_TIMEOUT = 4, /* Start timer */
5837 BFA_DCONF_SM_EXIT = 5, /* exit dconf module */
5838 BFA_DCONF_SM_IOCDISABLE = 6, /* IOC disable event */
5839 };
5840
5841 /* forward declaration of DCONF state machine */
5842 static void bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf,
5843 enum bfa_dconf_event event);
5844 static void bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
5845 enum bfa_dconf_event event);
5846 static void bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf,
5847 enum bfa_dconf_event event);
5848 static void bfa_dconf_sm_dirty(struct bfa_dconf_mod_s *dconf,
5849 enum bfa_dconf_event event);
5850 static void bfa_dconf_sm_sync(struct bfa_dconf_mod_s *dconf,
5851 enum bfa_dconf_event event);
5852 static void bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
5853 enum bfa_dconf_event event);
5854 static void bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
5855 enum bfa_dconf_event event);
5856
5857 static void bfa_dconf_cbfn(void *dconf, bfa_status_t status);
5858 static void bfa_dconf_timer(void *cbarg);
5859 static bfa_status_t bfa_dconf_flash_write(struct bfa_dconf_mod_s *dconf);
5860 static void bfa_dconf_init_cb(void *arg, bfa_status_t status);
5861
5862 /*
5863 * Beginning state of dconf module. Waiting for an event to start.
5864 */
5865 static void
5866 bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5867 {
5868 bfa_status_t bfa_status;
5869 bfa_trc(dconf->bfa, event);
5870
5871 switch (event) {
5872 case BFA_DCONF_SM_INIT:
5873 if (dconf->min_cfg) {
5874 bfa_trc(dconf->bfa, dconf->min_cfg);
5875 bfa_fsm_send_event(&dconf->bfa->iocfc,
5876 IOCFC_E_DCONF_DONE);
5877 return;
5878 }
5879 bfa_sm_set_state(dconf, bfa_dconf_sm_flash_read);
5880 bfa_timer_start(dconf->bfa, &dconf->timer,
5881 bfa_dconf_timer, dconf, 2 * BFA_DCONF_UPDATE_TOV);
5882 bfa_status = bfa_flash_read_part(BFA_FLASH(dconf->bfa),
5883 BFA_FLASH_PART_DRV, dconf->instance,
5884 dconf->dconf,
5885 sizeof(struct bfa_dconf_s), 0,
5886 bfa_dconf_init_cb, dconf->bfa);
5887 if (bfa_status != BFA_STATUS_OK) {
5888 bfa_timer_stop(&dconf->timer);
5889 bfa_dconf_init_cb(dconf->bfa, BFA_STATUS_FAILED);
5890 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5891 return;
5892 }
5893 break;
5894 case BFA_DCONF_SM_EXIT:
5895 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5896 case BFA_DCONF_SM_IOCDISABLE:
5897 case BFA_DCONF_SM_WR:
5898 case BFA_DCONF_SM_FLASH_COMP:
5899 break;
5900 default:
5901 bfa_sm_fault(dconf->bfa, event);
5902 }
5903 }
5904
5905 /*
5906 * Read flash for dconf entries and make a call back to the driver once done.
5907 */
5908 static void
5909 bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
5910 enum bfa_dconf_event event)
5911 {
5912 bfa_trc(dconf->bfa, event);
5913
5914 switch (event) {
5915 case BFA_DCONF_SM_FLASH_COMP:
5916 bfa_timer_stop(&dconf->timer);
5917 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
5918 break;
5919 case BFA_DCONF_SM_TIMEOUT:
5920 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
5921 bfa_ioc_suspend(&dconf->bfa->ioc);
5922 break;
5923 case BFA_DCONF_SM_EXIT:
5924 bfa_timer_stop(&dconf->timer);
5925 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5926 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5927 break;
5928 case BFA_DCONF_SM_IOCDISABLE:
5929 bfa_timer_stop(&dconf->timer);
5930 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5931 break;
5932 default:
5933 bfa_sm_fault(dconf->bfa, event);
5934 }
5935 }
5936
5937 /*
5938 * DCONF Module is in ready state. Has completed the initialization.
5939 */
5940 static void
5941 bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5942 {
5943 bfa_trc(dconf->bfa, event);
5944
5945 switch (event) {
5946 case BFA_DCONF_SM_WR:
5947 bfa_timer_start(dconf->bfa, &dconf->timer,
5948 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5949 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
5950 break;
5951 case BFA_DCONF_SM_EXIT:
5952 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
5953 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
5954 break;
5955 case BFA_DCONF_SM_INIT:
5956 case BFA_DCONF_SM_IOCDISABLE:
5957 break;
5958 default:
5959 bfa_sm_fault(dconf->bfa, event);
5960 }
5961 }
5962
5963 /*
5964 * entries are dirty, write back to the flash.
5965 */
5966
5967 static void
5968 bfa_dconf_sm_dirty(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
5969 {
5970 bfa_trc(dconf->bfa, event);
5971
5972 switch (event) {
5973 case BFA_DCONF_SM_TIMEOUT:
5974 bfa_sm_set_state(dconf, bfa_dconf_sm_sync);
5975 bfa_dconf_flash_write(dconf);
5976 break;
5977 case BFA_DCONF_SM_WR:
5978 bfa_timer_stop(&dconf->timer);
5979 bfa_timer_start(dconf->bfa, &dconf->timer,
5980 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5981 break;
5982 case BFA_DCONF_SM_EXIT:
5983 bfa_timer_stop(&dconf->timer);
5984 bfa_timer_start(dconf->bfa, &dconf->timer,
5985 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
5986 bfa_sm_set_state(dconf, bfa_dconf_sm_final_sync);
5987 bfa_dconf_flash_write(dconf);
5988 break;
5989 case BFA_DCONF_SM_FLASH_COMP:
5990 break;
5991 case BFA_DCONF_SM_IOCDISABLE:
5992 bfa_timer_stop(&dconf->timer);
5993 bfa_sm_set_state(dconf, bfa_dconf_sm_iocdown_dirty);
5994 break;
5995 default:
5996 bfa_sm_fault(dconf->bfa, event);
5997 }
5998 }
5999
6000 /*
6001 * Sync the dconf entries to the flash.
6002 */
6003 static void
6004 bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
6005 enum bfa_dconf_event event)
6006 {
6007 bfa_trc(dconf->bfa, event);
6008
6009 switch (event) {
6010 case BFA_DCONF_SM_IOCDISABLE:
6011 case BFA_DCONF_SM_FLASH_COMP:
6012 bfa_timer_stop(&dconf->timer);
6013 case BFA_DCONF_SM_TIMEOUT:
6014 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
6015 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
6016 break;
6017 default:
6018 bfa_sm_fault(dconf->bfa, event);
6019 }
6020 }
6021
6022 static void
6023 bfa_dconf_sm_sync(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
6024 {
6025 bfa_trc(dconf->bfa, event);
6026
6027 switch (event) {
6028 case BFA_DCONF_SM_FLASH_COMP:
6029 bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
6030 break;
6031 case BFA_DCONF_SM_WR:
6032 bfa_timer_start(dconf->bfa, &dconf->timer,
6033 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
6034 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
6035 break;
6036 case BFA_DCONF_SM_EXIT:
6037 bfa_timer_start(dconf->bfa, &dconf->timer,
6038 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
6039 bfa_sm_set_state(dconf, bfa_dconf_sm_final_sync);
6040 break;
6041 case BFA_DCONF_SM_IOCDISABLE:
6042 bfa_sm_set_state(dconf, bfa_dconf_sm_iocdown_dirty);
6043 break;
6044 default:
6045 bfa_sm_fault(dconf->bfa, event);
6046 }
6047 }
6048
6049 static void
6050 bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
6051 enum bfa_dconf_event event)
6052 {
6053 bfa_trc(dconf->bfa, event);
6054
6055 switch (event) {
6056 case BFA_DCONF_SM_INIT:
6057 bfa_timer_start(dconf->bfa, &dconf->timer,
6058 bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
6059 bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
6060 break;
6061 case BFA_DCONF_SM_EXIT:
6062 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
6063 bfa_fsm_send_event(&dconf->bfa->iocfc, IOCFC_E_DCONF_DONE);
6064 break;
6065 case BFA_DCONF_SM_IOCDISABLE:
6066 break;
6067 default:
6068 bfa_sm_fault(dconf->bfa, event);
6069 }
6070 }
6071
6072 /*
6073 * Compute and return memory needed by DRV_CFG module.
6074 */
6075 static void
6076 bfa_dconf_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
6077 struct bfa_s *bfa)
6078 {
6079 struct bfa_mem_kva_s *dconf_kva = BFA_MEM_DCONF_KVA(bfa);
6080
6081 if (cfg->drvcfg.min_cfg)
6082 bfa_mem_kva_setup(meminfo, dconf_kva,
6083 sizeof(struct bfa_dconf_hdr_s));
6084 else
6085 bfa_mem_kva_setup(meminfo, dconf_kva,
6086 sizeof(struct bfa_dconf_s));
6087 }
6088
6089 static void
6090 bfa_dconf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
6091 struct bfa_pcidev_s *pcidev)
6092 {
6093 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
6094
6095 dconf->bfad = bfad;
6096 dconf->bfa = bfa;
6097 dconf->instance = bfa->ioc.port_id;
6098 bfa_trc(bfa, dconf->instance);
6099
6100 dconf->dconf = (struct bfa_dconf_s *) bfa_mem_kva_curp(dconf);
6101 if (cfg->drvcfg.min_cfg) {
6102 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_hdr_s);
6103 dconf->min_cfg = BFA_TRUE;
6104 } else {
6105 dconf->min_cfg = BFA_FALSE;
6106 bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_s);
6107 }
6108
6109 bfa_dconf_read_data_valid(bfa) = BFA_FALSE;
6110 bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
6111 }
6112
6113 static void
6114 bfa_dconf_init_cb(void *arg, bfa_status_t status)
6115 {
6116 struct bfa_s *bfa = arg;
6117 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
6118
6119 if (status == BFA_STATUS_OK) {
6120 bfa_dconf_read_data_valid(bfa) = BFA_TRUE;
6121 if (dconf->dconf->hdr.signature != BFI_DCONF_SIGNATURE)
6122 dconf->dconf->hdr.signature = BFI_DCONF_SIGNATURE;
6123 if (dconf->dconf->hdr.version != BFI_DCONF_VERSION)
6124 dconf->dconf->hdr.version = BFI_DCONF_VERSION;
6125 }
6126 bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
6127 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DCONF_DONE);
6128 }
6129
6130 void
6131 bfa_dconf_modinit(struct bfa_s *bfa)
6132 {
6133 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
6134 bfa_sm_send_event(dconf, BFA_DCONF_SM_INIT);
6135 }
6136 static void
6137 bfa_dconf_start(struct bfa_s *bfa)
6138 {
6139 }
6140
6141 static void
6142 bfa_dconf_stop(struct bfa_s *bfa)
6143 {
6144 }
6145
6146 static void bfa_dconf_timer(void *cbarg)
6147 {
6148 struct bfa_dconf_mod_s *dconf = cbarg;
6149 bfa_sm_send_event(dconf, BFA_DCONF_SM_TIMEOUT);
6150 }
6151 static void
6152 bfa_dconf_iocdisable(struct bfa_s *bfa)
6153 {
6154 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
6155 bfa_sm_send_event(dconf, BFA_DCONF_SM_IOCDISABLE);
6156 }
6157
6158 static void
6159 bfa_dconf_detach(struct bfa_s *bfa)
6160 {
6161 }
6162
6163 static bfa_status_t
6164 bfa_dconf_flash_write(struct bfa_dconf_mod_s *dconf)
6165 {
6166 bfa_status_t bfa_status;
6167 bfa_trc(dconf->bfa, 0);
6168
6169 bfa_status = bfa_flash_update_part(BFA_FLASH(dconf->bfa),
6170 BFA_FLASH_PART_DRV, dconf->instance,
6171 dconf->dconf, sizeof(struct bfa_dconf_s), 0,
6172 bfa_dconf_cbfn, dconf);
6173 if (bfa_status != BFA_STATUS_OK)
6174 WARN_ON(bfa_status);
6175 bfa_trc(dconf->bfa, bfa_status);
6176
6177 return bfa_status;
6178 }
6179
6180 bfa_status_t
6181 bfa_dconf_update(struct bfa_s *bfa)
6182 {
6183 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
6184 bfa_trc(dconf->bfa, 0);
6185 if (bfa_sm_cmp_state(dconf, bfa_dconf_sm_iocdown_dirty))
6186 return BFA_STATUS_FAILED;
6187
6188 if (dconf->min_cfg) {
6189 bfa_trc(dconf->bfa, dconf->min_cfg);
6190 return BFA_STATUS_FAILED;
6191 }
6192
6193 bfa_sm_send_event(dconf, BFA_DCONF_SM_WR);
6194 return BFA_STATUS_OK;
6195 }
6196
6197 static void
6198 bfa_dconf_cbfn(void *arg, bfa_status_t status)
6199 {
6200 struct bfa_dconf_mod_s *dconf = arg;
6201 WARN_ON(status);
6202 bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
6203 }
6204
6205 void
6206 bfa_dconf_modexit(struct bfa_s *bfa)
6207 {
6208 struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
6209 bfa_sm_send_event(dconf, BFA_DCONF_SM_EXIT);
6210 }
6211
6212 /*
6213 * FRU specific functions
6214 */
6215
6216 #define BFA_FRU_DMA_BUF_SZ 0x02000 /* 8k dma buffer */
6217 #define BFA_FRU_CHINOOK_MAX_SIZE 0x10000
6218 #define BFA_FRU_LIGHTNING_MAX_SIZE 0x200
6219
6220 static void
6221 bfa_fru_notify(void *cbarg, enum bfa_ioc_event_e event)
6222 {
6223 struct bfa_fru_s *fru = cbarg;
6224
6225 bfa_trc(fru, event);
6226
6227 switch (event) {
6228 case BFA_IOC_E_DISABLED:
6229 case BFA_IOC_E_FAILED:
6230 if (fru->op_busy) {
6231 fru->status = BFA_STATUS_IOC_FAILURE;
6232 fru->cbfn(fru->cbarg, fru->status);
6233 fru->op_busy = 0;
6234 }
6235 break;
6236
6237 default:
6238 break;
6239 }
6240 }
6241
6242 /*
6243 * Send fru write request.
6244 *
6245 * @param[in] cbarg - callback argument
6246 */
6247 static void
6248 bfa_fru_write_send(void *cbarg, enum bfi_fru_h2i_msgs msg_type)
6249 {
6250 struct bfa_fru_s *fru = cbarg;
6251 struct bfi_fru_write_req_s *msg =
6252 (struct bfi_fru_write_req_s *) fru->mb.msg;
6253 u32 len;
6254
6255 msg->offset = cpu_to_be32(fru->addr_off + fru->offset);
6256 len = (fru->residue < BFA_FRU_DMA_BUF_SZ) ?
6257 fru->residue : BFA_FRU_DMA_BUF_SZ;
6258 msg->length = cpu_to_be32(len);
6259
6260 /*
6261 * indicate if it's the last msg of the whole write operation
6262 */
6263 msg->last = (len == fru->residue) ? 1 : 0;
6264
6265 msg->trfr_cmpl = (len == fru->residue) ? fru->trfr_cmpl : 0;
6266 bfi_h2i_set(msg->mh, BFI_MC_FRU, msg_type, bfa_ioc_portid(fru->ioc));
6267 bfa_alen_set(&msg->alen, len, fru->dbuf_pa);
6268
6269 memcpy(fru->dbuf_kva, fru->ubuf + fru->offset, len);
6270 bfa_ioc_mbox_queue(fru->ioc, &fru->mb);
6271
6272 fru->residue -= len;
6273 fru->offset += len;
6274 }
6275
6276 /*
6277 * Send fru read request.
6278 *
6279 * @param[in] cbarg - callback argument
6280 */
6281 static void
6282 bfa_fru_read_send(void *cbarg, enum bfi_fru_h2i_msgs msg_type)
6283 {
6284 struct bfa_fru_s *fru = cbarg;
6285 struct bfi_fru_read_req_s *msg =
6286 (struct bfi_fru_read_req_s *) fru->mb.msg;
6287 u32 len;
6288
6289 msg->offset = cpu_to_be32(fru->addr_off + fru->offset);
6290 len = (fru->residue < BFA_FRU_DMA_BUF_SZ) ?
6291 fru->residue : BFA_FRU_DMA_BUF_SZ;
6292 msg->length = cpu_to_be32(len);
6293 bfi_h2i_set(msg->mh, BFI_MC_FRU, msg_type, bfa_ioc_portid(fru->ioc));
6294 bfa_alen_set(&msg->alen, len, fru->dbuf_pa);
6295 bfa_ioc_mbox_queue(fru->ioc, &fru->mb);
6296 }
6297
6298 /*
6299 * Flash memory info API.
6300 *
6301 * @param[in] mincfg - minimal cfg variable
6302 */
6303 u32
6304 bfa_fru_meminfo(bfa_boolean_t mincfg)
6305 {
6306 /* min driver doesn't need fru */
6307 if (mincfg)
6308 return 0;
6309
6310 return BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6311 }
6312
6313 /*
6314 * Flash attach API.
6315 *
6316 * @param[in] fru - fru structure
6317 * @param[in] ioc - ioc structure
6318 * @param[in] dev - device structure
6319 * @param[in] trcmod - trace module
6320 * @param[in] logmod - log module
6321 */
6322 void
6323 bfa_fru_attach(struct bfa_fru_s *fru, struct bfa_ioc_s *ioc, void *dev,
6324 struct bfa_trc_mod_s *trcmod, bfa_boolean_t mincfg)
6325 {
6326 fru->ioc = ioc;
6327 fru->trcmod = trcmod;
6328 fru->cbfn = NULL;
6329 fru->cbarg = NULL;
6330 fru->op_busy = 0;
6331
6332 bfa_ioc_mbox_regisr(fru->ioc, BFI_MC_FRU, bfa_fru_intr, fru);
6333 bfa_q_qe_init(&fru->ioc_notify);
6334 bfa_ioc_notify_init(&fru->ioc_notify, bfa_fru_notify, fru);
6335 list_add_tail(&fru->ioc_notify.qe, &fru->ioc->notify_q);
6336
6337 /* min driver doesn't need fru */
6338 if (mincfg) {
6339 fru->dbuf_kva = NULL;
6340 fru->dbuf_pa = 0;
6341 }
6342 }
6343
6344 /*
6345 * Claim memory for fru
6346 *
6347 * @param[in] fru - fru structure
6348 * @param[in] dm_kva - pointer to virtual memory address
6349 * @param[in] dm_pa - frusical memory address
6350 * @param[in] mincfg - minimal cfg variable
6351 */
6352 void
6353 bfa_fru_memclaim(struct bfa_fru_s *fru, u8 *dm_kva, u64 dm_pa,
6354 bfa_boolean_t mincfg)
6355 {
6356 if (mincfg)
6357 return;
6358
6359 fru->dbuf_kva = dm_kva;
6360 fru->dbuf_pa = dm_pa;
6361 memset(fru->dbuf_kva, 0, BFA_FRU_DMA_BUF_SZ);
6362 dm_kva += BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6363 dm_pa += BFA_ROUNDUP(BFA_FRU_DMA_BUF_SZ, BFA_DMA_ALIGN_SZ);
6364 }
6365
6366 /*
6367 * Update fru vpd image.
6368 *
6369 * @param[in] fru - fru structure
6370 * @param[in] buf - update data buffer
6371 * @param[in] len - data buffer length
6372 * @param[in] offset - offset relative to starting address
6373 * @param[in] cbfn - callback function
6374 * @param[in] cbarg - callback argument
6375 *
6376 * Return status.
6377 */
6378 bfa_status_t
6379 bfa_fruvpd_update(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6380 bfa_cb_fru_t cbfn, void *cbarg, u8 trfr_cmpl)
6381 {
6382 bfa_trc(fru, BFI_FRUVPD_H2I_WRITE_REQ);
6383 bfa_trc(fru, len);
6384 bfa_trc(fru, offset);
6385
6386 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2 &&
6387 fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK2)
6388 return BFA_STATUS_FRU_NOT_PRESENT;
6389
6390 if (fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK)
6391 return BFA_STATUS_CMD_NOTSUPP;
6392
6393 if (!bfa_ioc_is_operational(fru->ioc))
6394 return BFA_STATUS_IOC_NON_OP;
6395
6396 if (fru->op_busy) {
6397 bfa_trc(fru, fru->op_busy);
6398 return BFA_STATUS_DEVBUSY;
6399 }
6400
6401 fru->op_busy = 1;
6402
6403 fru->cbfn = cbfn;
6404 fru->cbarg = cbarg;
6405 fru->residue = len;
6406 fru->offset = 0;
6407 fru->addr_off = offset;
6408 fru->ubuf = buf;
6409 fru->trfr_cmpl = trfr_cmpl;
6410
6411 bfa_fru_write_send(fru, BFI_FRUVPD_H2I_WRITE_REQ);
6412
6413 return BFA_STATUS_OK;
6414 }
6415
6416 /*
6417 * Read fru vpd image.
6418 *
6419 * @param[in] fru - fru structure
6420 * @param[in] buf - read data buffer
6421 * @param[in] len - data buffer length
6422 * @param[in] offset - offset relative to starting address
6423 * @param[in] cbfn - callback function
6424 * @param[in] cbarg - callback argument
6425 *
6426 * Return status.
6427 */
6428 bfa_status_t
6429 bfa_fruvpd_read(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6430 bfa_cb_fru_t cbfn, void *cbarg)
6431 {
6432 bfa_trc(fru, BFI_FRUVPD_H2I_READ_REQ);
6433 bfa_trc(fru, len);
6434 bfa_trc(fru, offset);
6435
6436 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6437 return BFA_STATUS_FRU_NOT_PRESENT;
6438
6439 if (fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK &&
6440 fru->ioc->attr->card_type != BFA_MFG_TYPE_CHINOOK2)
6441 return BFA_STATUS_CMD_NOTSUPP;
6442
6443 if (!bfa_ioc_is_operational(fru->ioc))
6444 return BFA_STATUS_IOC_NON_OP;
6445
6446 if (fru->op_busy) {
6447 bfa_trc(fru, fru->op_busy);
6448 return BFA_STATUS_DEVBUSY;
6449 }
6450
6451 fru->op_busy = 1;
6452
6453 fru->cbfn = cbfn;
6454 fru->cbarg = cbarg;
6455 fru->residue = len;
6456 fru->offset = 0;
6457 fru->addr_off = offset;
6458 fru->ubuf = buf;
6459 bfa_fru_read_send(fru, BFI_FRUVPD_H2I_READ_REQ);
6460
6461 return BFA_STATUS_OK;
6462 }
6463
6464 /*
6465 * Get maximum size fru vpd image.
6466 *
6467 * @param[in] fru - fru structure
6468 * @param[out] size - maximum size of fru vpd data
6469 *
6470 * Return status.
6471 */
6472 bfa_status_t
6473 bfa_fruvpd_get_max_size(struct bfa_fru_s *fru, u32 *max_size)
6474 {
6475 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6476 return BFA_STATUS_FRU_NOT_PRESENT;
6477
6478 if (!bfa_ioc_is_operational(fru->ioc))
6479 return BFA_STATUS_IOC_NON_OP;
6480
6481 if (fru->ioc->attr->card_type == BFA_MFG_TYPE_CHINOOK ||
6482 fru->ioc->attr->card_type == BFA_MFG_TYPE_CHINOOK2)
6483 *max_size = BFA_FRU_CHINOOK_MAX_SIZE;
6484 else
6485 return BFA_STATUS_CMD_NOTSUPP;
6486 return BFA_STATUS_OK;
6487 }
6488 /*
6489 * tfru write.
6490 *
6491 * @param[in] fru - fru structure
6492 * @param[in] buf - update data buffer
6493 * @param[in] len - data buffer length
6494 * @param[in] offset - offset relative to starting address
6495 * @param[in] cbfn - callback function
6496 * @param[in] cbarg - callback argument
6497 *
6498 * Return status.
6499 */
6500 bfa_status_t
6501 bfa_tfru_write(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6502 bfa_cb_fru_t cbfn, void *cbarg)
6503 {
6504 bfa_trc(fru, BFI_TFRU_H2I_WRITE_REQ);
6505 bfa_trc(fru, len);
6506 bfa_trc(fru, offset);
6507 bfa_trc(fru, *((u8 *) buf));
6508
6509 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6510 return BFA_STATUS_FRU_NOT_PRESENT;
6511
6512 if (!bfa_ioc_is_operational(fru->ioc))
6513 return BFA_STATUS_IOC_NON_OP;
6514
6515 if (fru->op_busy) {
6516 bfa_trc(fru, fru->op_busy);
6517 return BFA_STATUS_DEVBUSY;
6518 }
6519
6520 fru->op_busy = 1;
6521
6522 fru->cbfn = cbfn;
6523 fru->cbarg = cbarg;
6524 fru->residue = len;
6525 fru->offset = 0;
6526 fru->addr_off = offset;
6527 fru->ubuf = buf;
6528
6529 bfa_fru_write_send(fru, BFI_TFRU_H2I_WRITE_REQ);
6530
6531 return BFA_STATUS_OK;
6532 }
6533
6534 /*
6535 * tfru read.
6536 *
6537 * @param[in] fru - fru structure
6538 * @param[in] buf - read data buffer
6539 * @param[in] len - data buffer length
6540 * @param[in] offset - offset relative to starting address
6541 * @param[in] cbfn - callback function
6542 * @param[in] cbarg - callback argument
6543 *
6544 * Return status.
6545 */
6546 bfa_status_t
6547 bfa_tfru_read(struct bfa_fru_s *fru, void *buf, u32 len, u32 offset,
6548 bfa_cb_fru_t cbfn, void *cbarg)
6549 {
6550 bfa_trc(fru, BFI_TFRU_H2I_READ_REQ);
6551 bfa_trc(fru, len);
6552 bfa_trc(fru, offset);
6553
6554 if (fru->ioc->asic_gen != BFI_ASIC_GEN_CT2)
6555 return BFA_STATUS_FRU_NOT_PRESENT;
6556
6557 if (!bfa_ioc_is_operational(fru->ioc))
6558 return BFA_STATUS_IOC_NON_OP;
6559
6560 if (fru->op_busy) {
6561 bfa_trc(fru, fru->op_busy);
6562 return BFA_STATUS_DEVBUSY;
6563 }
6564
6565 fru->op_busy = 1;
6566
6567 fru->cbfn = cbfn;
6568 fru->cbarg = cbarg;
6569 fru->residue = len;
6570 fru->offset = 0;
6571 fru->addr_off = offset;
6572 fru->ubuf = buf;
6573 bfa_fru_read_send(fru, BFI_TFRU_H2I_READ_REQ);
6574
6575 return BFA_STATUS_OK;
6576 }
6577
6578 /*
6579 * Process fru response messages upon receiving interrupts.
6580 *
6581 * @param[in] fruarg - fru structure
6582 * @param[in] msg - message structure
6583 */
6584 void
6585 bfa_fru_intr(void *fruarg, struct bfi_mbmsg_s *msg)
6586 {
6587 struct bfa_fru_s *fru = fruarg;
6588 struct bfi_fru_rsp_s *rsp = (struct bfi_fru_rsp_s *)msg;
6589 u32 status;
6590
6591 bfa_trc(fru, msg->mh.msg_id);
6592
6593 if (!fru->op_busy) {
6594 /*
6595 * receiving response after ioc failure
6596 */
6597 bfa_trc(fru, 0x9999);
6598 return;
6599 }
6600
6601 switch (msg->mh.msg_id) {
6602 case BFI_FRUVPD_I2H_WRITE_RSP:
6603 case BFI_TFRU_I2H_WRITE_RSP:
6604 status = be32_to_cpu(rsp->status);
6605 bfa_trc(fru, status);
6606
6607 if (status != BFA_STATUS_OK || fru->residue == 0) {
6608 fru->status = status;
6609 fru->op_busy = 0;
6610 if (fru->cbfn)
6611 fru->cbfn(fru->cbarg, fru->status);
6612 } else {
6613 bfa_trc(fru, fru->offset);
6614 if (msg->mh.msg_id == BFI_FRUVPD_I2H_WRITE_RSP)
6615 bfa_fru_write_send(fru,
6616 BFI_FRUVPD_H2I_WRITE_REQ);
6617 else
6618 bfa_fru_write_send(fru,
6619 BFI_TFRU_H2I_WRITE_REQ);
6620 }
6621 break;
6622 case BFI_FRUVPD_I2H_READ_RSP:
6623 case BFI_TFRU_I2H_READ_RSP:
6624 status = be32_to_cpu(rsp->status);
6625 bfa_trc(fru, status);
6626
6627 if (status != BFA_STATUS_OK) {
6628 fru->status = status;
6629 fru->op_busy = 0;
6630 if (fru->cbfn)
6631 fru->cbfn(fru->cbarg, fru->status);
6632 } else {
6633 u32 len = be32_to_cpu(rsp->length);
6634
6635 bfa_trc(fru, fru->offset);
6636 bfa_trc(fru, len);
6637
6638 memcpy(fru->ubuf + fru->offset, fru->dbuf_kva, len);
6639 fru->residue -= len;
6640 fru->offset += len;
6641
6642 if (fru->residue == 0) {
6643 fru->status = status;
6644 fru->op_busy = 0;
6645 if (fru->cbfn)
6646 fru->cbfn(fru->cbarg, fru->status);
6647 } else {
6648 if (msg->mh.msg_id == BFI_FRUVPD_I2H_READ_RSP)
6649 bfa_fru_read_send(fru,
6650 BFI_FRUVPD_H2I_READ_REQ);
6651 else
6652 bfa_fru_read_send(fru,
6653 BFI_TFRU_H2I_READ_REQ);
6654 }
6655 }
6656 break;
6657 default:
6658 WARN_ON(1);
6659 }
6660 }
6661
6662 /*
6663 * register definitions
6664 */
6665 #define FLI_CMD_REG 0x0001d000
6666 #define FLI_RDDATA_REG 0x0001d010
6667 #define FLI_ADDR_REG 0x0001d004
6668 #define FLI_DEV_STATUS_REG 0x0001d014
6669
6670 #define BFA_FLASH_FIFO_SIZE 128 /* fifo size */
6671 #define BFA_FLASH_CHECK_MAX 10000 /* max # of status check */
6672 #define BFA_FLASH_BLOCKING_OP_MAX 1000000 /* max # of blocking op check */
6673 #define BFA_FLASH_WIP_MASK 0x01 /* write in progress bit mask */
6674
6675 enum bfa_flash_cmd {
6676 BFA_FLASH_FAST_READ = 0x0b, /* fast read */
6677 BFA_FLASH_READ_STATUS = 0x05, /* read status */
6678 };
6679
6680 /**
6681 * @brief hardware error definition
6682 */
6683 enum bfa_flash_err {
6684 BFA_FLASH_NOT_PRESENT = -1, /*!< flash not present */
6685 BFA_FLASH_UNINIT = -2, /*!< flash not initialized */
6686 BFA_FLASH_BAD = -3, /*!< flash bad */
6687 BFA_FLASH_BUSY = -4, /*!< flash busy */
6688 BFA_FLASH_ERR_CMD_ACT = -5, /*!< command active never cleared */
6689 BFA_FLASH_ERR_FIFO_CNT = -6, /*!< fifo count never cleared */
6690 BFA_FLASH_ERR_WIP = -7, /*!< write-in-progress never cleared */
6691 BFA_FLASH_ERR_TIMEOUT = -8, /*!< fli timeout */
6692 BFA_FLASH_ERR_LEN = -9, /*!< invalid length */
6693 };
6694
6695 /**
6696 * @brief flash command register data structure
6697 */
6698 union bfa_flash_cmd_reg_u {
6699 struct {
6700 #ifdef __BIG_ENDIAN
6701 u32 act:1;
6702 u32 rsv:1;
6703 u32 write_cnt:9;
6704 u32 read_cnt:9;
6705 u32 addr_cnt:4;
6706 u32 cmd:8;
6707 #else
6708 u32 cmd:8;
6709 u32 addr_cnt:4;
6710 u32 read_cnt:9;
6711 u32 write_cnt:9;
6712 u32 rsv:1;
6713 u32 act:1;
6714 #endif
6715 } r;
6716 u32 i;
6717 };
6718
6719 /**
6720 * @brief flash device status register data structure
6721 */
6722 union bfa_flash_dev_status_reg_u {
6723 struct {
6724 #ifdef __BIG_ENDIAN
6725 u32 rsv:21;
6726 u32 fifo_cnt:6;
6727 u32 busy:1;
6728 u32 init_status:1;
6729 u32 present:1;
6730 u32 bad:1;
6731 u32 good:1;
6732 #else
6733 u32 good:1;
6734 u32 bad:1;
6735 u32 present:1;
6736 u32 init_status:1;
6737 u32 busy:1;
6738 u32 fifo_cnt:6;
6739 u32 rsv:21;
6740 #endif
6741 } r;
6742 u32 i;
6743 };
6744
6745 /**
6746 * @brief flash address register data structure
6747 */
6748 union bfa_flash_addr_reg_u {
6749 struct {
6750 #ifdef __BIG_ENDIAN
6751 u32 addr:24;
6752 u32 dummy:8;
6753 #else
6754 u32 dummy:8;
6755 u32 addr:24;
6756 #endif
6757 } r;
6758 u32 i;
6759 };
6760
6761 /**
6762 * dg flash_raw_private Flash raw private functions
6763 */
6764 static void
6765 bfa_flash_set_cmd(void __iomem *pci_bar, u8 wr_cnt,
6766 u8 rd_cnt, u8 ad_cnt, u8 op)
6767 {
6768 union bfa_flash_cmd_reg_u cmd;
6769
6770 cmd.i = 0;
6771 cmd.r.act = 1;
6772 cmd.r.write_cnt = wr_cnt;
6773 cmd.r.read_cnt = rd_cnt;
6774 cmd.r.addr_cnt = ad_cnt;
6775 cmd.r.cmd = op;
6776 writel(cmd.i, (pci_bar + FLI_CMD_REG));
6777 }
6778
6779 static void
6780 bfa_flash_set_addr(void __iomem *pci_bar, u32 address)
6781 {
6782 union bfa_flash_addr_reg_u addr;
6783
6784 addr.r.addr = address & 0x00ffffff;
6785 addr.r.dummy = 0;
6786 writel(addr.i, (pci_bar + FLI_ADDR_REG));
6787 }
6788
6789 static int
6790 bfa_flash_cmd_act_check(void __iomem *pci_bar)
6791 {
6792 union bfa_flash_cmd_reg_u cmd;
6793
6794 cmd.i = readl(pci_bar + FLI_CMD_REG);
6795
6796 if (cmd.r.act)
6797 return BFA_FLASH_ERR_CMD_ACT;
6798
6799 return 0;
6800 }
6801
6802 /**
6803 * @brief
6804 * Flush FLI data fifo.
6805 *
6806 * @param[in] pci_bar - pci bar address
6807 * @param[in] dev_status - device status
6808 *
6809 * Return 0 on success, negative error number on error.
6810 */
6811 static u32
6812 bfa_flash_fifo_flush(void __iomem *pci_bar)
6813 {
6814 u32 i;
6815 u32 t;
6816 union bfa_flash_dev_status_reg_u dev_status;
6817
6818 dev_status.i = readl(pci_bar + FLI_DEV_STATUS_REG);
6819
6820 if (!dev_status.r.fifo_cnt)
6821 return 0;
6822
6823 /* fifo counter in terms of words */
6824 for (i = 0; i < dev_status.r.fifo_cnt; i++)
6825 t = readl(pci_bar + FLI_RDDATA_REG);
6826
6827 /*
6828 * Check the device status. It may take some time.
6829 */
6830 for (i = 0; i < BFA_FLASH_CHECK_MAX; i++) {
6831 dev_status.i = readl(pci_bar + FLI_DEV_STATUS_REG);
6832 if (!dev_status.r.fifo_cnt)
6833 break;
6834 }
6835
6836 if (dev_status.r.fifo_cnt)
6837 return BFA_FLASH_ERR_FIFO_CNT;
6838
6839 return 0;
6840 }
6841
6842 /**
6843 * @brief
6844 * Read flash status.
6845 *
6846 * @param[in] pci_bar - pci bar address
6847 *
6848 * Return 0 on success, negative error number on error.
6849 */
6850 static u32
6851 bfa_flash_status_read(void __iomem *pci_bar)
6852 {
6853 union bfa_flash_dev_status_reg_u dev_status;
6854 int status;
6855 u32 ret_status;
6856 int i;
6857
6858 status = bfa_flash_fifo_flush(pci_bar);
6859 if (status < 0)
6860 return status;
6861
6862 bfa_flash_set_cmd(pci_bar, 0, 4, 0, BFA_FLASH_READ_STATUS);
6863
6864 for (i = 0; i < BFA_FLASH_CHECK_MAX; i++) {
6865 status = bfa_flash_cmd_act_check(pci_bar);
6866 if (!status)
6867 break;
6868 }
6869
6870 if (status)
6871 return status;
6872
6873 dev_status.i = readl(pci_bar + FLI_DEV_STATUS_REG);
6874 if (!dev_status.r.fifo_cnt)
6875 return BFA_FLASH_BUSY;
6876
6877 ret_status = readl(pci_bar + FLI_RDDATA_REG);
6878 ret_status >>= 24;
6879
6880 status = bfa_flash_fifo_flush(pci_bar);
6881 if (status < 0)
6882 return status;
6883
6884 return ret_status;
6885 }
6886
6887 /**
6888 * @brief
6889 * Start flash read operation.
6890 *
6891 * @param[in] pci_bar - pci bar address
6892 * @param[in] offset - flash address offset
6893 * @param[in] len - read data length
6894 * @param[in] buf - read data buffer
6895 *
6896 * Return 0 on success, negative error number on error.
6897 */
6898 static u32
6899 bfa_flash_read_start(void __iomem *pci_bar, u32 offset, u32 len,
6900 char *buf)
6901 {
6902 int status;
6903
6904 /*
6905 * len must be mutiple of 4 and not exceeding fifo size
6906 */
6907 if (len == 0 || len > BFA_FLASH_FIFO_SIZE || (len & 0x03) != 0)
6908 return BFA_FLASH_ERR_LEN;
6909
6910 /*
6911 * check status
6912 */
6913 status = bfa_flash_status_read(pci_bar);
6914 if (status == BFA_FLASH_BUSY)
6915 status = bfa_flash_status_read(pci_bar);
6916
6917 if (status < 0)
6918 return status;
6919
6920 /*
6921 * check if write-in-progress bit is cleared
6922 */
6923 if (status & BFA_FLASH_WIP_MASK)
6924 return BFA_FLASH_ERR_WIP;
6925
6926 bfa_flash_set_addr(pci_bar, offset);
6927
6928 bfa_flash_set_cmd(pci_bar, 0, (u8)len, 4, BFA_FLASH_FAST_READ);
6929
6930 return 0;
6931 }
6932
6933 /**
6934 * @brief
6935 * Check flash read operation.
6936 *
6937 * @param[in] pci_bar - pci bar address
6938 *
6939 * Return flash device status, 1 if busy, 0 if not.
6940 */
6941 static u32
6942 bfa_flash_read_check(void __iomem *pci_bar)
6943 {
6944 if (bfa_flash_cmd_act_check(pci_bar))
6945 return 1;
6946
6947 return 0;
6948 }
6949 /**
6950 * @brief
6951 * End flash read operation.
6952 *
6953 * @param[in] pci_bar - pci bar address
6954 * @param[in] len - read data length
6955 * @param[in] buf - read data buffer
6956 *
6957 */
6958 static void
6959 bfa_flash_read_end(void __iomem *pci_bar, u32 len, char *buf)
6960 {
6961
6962 u32 i;
6963
6964 /*
6965 * read data fifo up to 32 words
6966 */
6967 for (i = 0; i < len; i += 4) {
6968 u32 w = readl(pci_bar + FLI_RDDATA_REG);
6969 *((u32 *) (buf + i)) = swab32(w);
6970 }
6971
6972 bfa_flash_fifo_flush(pci_bar);
6973 }
6974
6975 /**
6976 * @brief
6977 * Perform flash raw read.
6978 *
6979 * @param[in] pci_bar - pci bar address
6980 * @param[in] offset - flash partition address offset
6981 * @param[in] buf - read data buffer
6982 * @param[in] len - read data length
6983 *
6984 * Return status.
6985 */
6986
6987
6988 #define FLASH_BLOCKING_OP_MAX 500
6989 #define FLASH_SEM_LOCK_REG 0x18820
6990
6991 static int
6992 bfa_raw_sem_get(void __iomem *bar)
6993 {
6994 int locked;
6995
6996 locked = readl((bar + FLASH_SEM_LOCK_REG));
6997 return !locked;
6998
6999 }
7000
7001 bfa_status_t
7002 bfa_flash_sem_get(void __iomem *bar)
7003 {
7004 u32 n = FLASH_BLOCKING_OP_MAX;
7005
7006 while (!bfa_raw_sem_get(bar)) {
7007 if (--n <= 0)
7008 return BFA_STATUS_BADFLASH;
7009 mdelay(10);
7010 }
7011 return BFA_STATUS_OK;
7012 }
7013
7014 void
7015 bfa_flash_sem_put(void __iomem *bar)
7016 {
7017 writel(0, (bar + FLASH_SEM_LOCK_REG));
7018 }
7019
7020 bfa_status_t
7021 bfa_flash_raw_read(void __iomem *pci_bar, u32 offset, char *buf,
7022 u32 len)
7023 {
7024 u32 n;
7025 int status;
7026 u32 off, l, s, residue, fifo_sz;
7027
7028 residue = len;
7029 off = 0;
7030 fifo_sz = BFA_FLASH_FIFO_SIZE;
7031 status = bfa_flash_sem_get(pci_bar);
7032 if (status != BFA_STATUS_OK)
7033 return status;
7034
7035 while (residue) {
7036 s = offset + off;
7037 n = s / fifo_sz;
7038 l = (n + 1) * fifo_sz - s;
7039 if (l > residue)
7040 l = residue;
7041
7042 status = bfa_flash_read_start(pci_bar, offset + off, l,
7043 &buf[off]);
7044 if (status < 0) {
7045 bfa_flash_sem_put(pci_bar);
7046 return BFA_STATUS_FAILED;
7047 }
7048
7049 n = BFA_FLASH_BLOCKING_OP_MAX;
7050 while (bfa_flash_read_check(pci_bar)) {
7051 if (--n <= 0) {
7052 bfa_flash_sem_put(pci_bar);
7053 return BFA_STATUS_FAILED;
7054 }
7055 }
7056
7057 bfa_flash_read_end(pci_bar, l, &buf[off]);
7058
7059 residue -= l;
7060 off += l;
7061 }
7062 bfa_flash_sem_put(pci_bar);
7063
7064 return BFA_STATUS_OK;
7065 }
Linux kernel - Deliverables
This page took 0.194431 seconds and 5 git commands to generate.