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