?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bna: Brocade 1860 HW Enablement
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / ethernet / brocade / bna / bfa_ioc.c
blobf89ac7a6569d8a672dd35ebcff9f20fc126fe850
1 /*
2 * Linux network driver for Brocade Converged Network Adapter.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License (GPL) Version 2 as
6 * published by the Free Software Foundation
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 */
13 /*
14 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
15 * All rights reserved
16 * www.brocade.com
17 */
18
19 #include "bfa_ioc.h"
20 #include "cna.h"
21 #include "bfi.h"
22 #include "bfi_reg.h"
23 #include "bfa_defs.h"
24
25 /**
26 * IOC local definitions
27 */
28
29 /**
30 * Asic specific macros : see bfa_hw_cb.c and bfa_hw_ct.c for details.
31 */
32
33 #define bfa_ioc_firmware_lock(__ioc) \
34 ((__ioc)->ioc_hwif->ioc_firmware_lock(__ioc))
35 #define bfa_ioc_firmware_unlock(__ioc) \
36 ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
37 #define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
38 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
39 #define bfa_ioc_notify_fail(__ioc) \
40 ((__ioc)->ioc_hwif->ioc_notify_fail(__ioc))
41 #define bfa_ioc_sync_start(__ioc) \
42 ((__ioc)->ioc_hwif->ioc_sync_start(__ioc))
43 #define bfa_ioc_sync_join(__ioc) \
44 ((__ioc)->ioc_hwif->ioc_sync_join(__ioc))
45 #define bfa_ioc_sync_leave(__ioc) \
46 ((__ioc)->ioc_hwif->ioc_sync_leave(__ioc))
47 #define bfa_ioc_sync_ack(__ioc) \
48 ((__ioc)->ioc_hwif->ioc_sync_ack(__ioc))
49 #define bfa_ioc_sync_complete(__ioc) \
50 ((__ioc)->ioc_hwif->ioc_sync_complete(__ioc))
51
52 #define bfa_ioc_mbox_cmd_pending(__ioc) \
53 (!list_empty(&((__ioc)->mbox_mod.cmd_q)) || \
54 readl((__ioc)->ioc_regs.hfn_mbox_cmd))
55
56 static bool bfa_nw_auto_recover = true;
57
58 /*
59 * forward declarations
60 */
61 static void bfa_ioc_hw_sem_init(struct bfa_ioc *ioc);
62 static void bfa_ioc_hw_sem_get(struct bfa_ioc *ioc);
63 static void bfa_ioc_hw_sem_get_cancel(struct bfa_ioc *ioc);
64 static void bfa_ioc_hwinit(struct bfa_ioc *ioc, bool force);
65 static void bfa_ioc_poll_fwinit(struct bfa_ioc *ioc);
66 static void bfa_ioc_send_enable(struct bfa_ioc *ioc);
67 static void bfa_ioc_send_disable(struct bfa_ioc *ioc);
68 static void bfa_ioc_send_getattr(struct bfa_ioc *ioc);
69 static void bfa_ioc_hb_monitor(struct bfa_ioc *ioc);
70 static void bfa_ioc_hb_stop(struct bfa_ioc *ioc);
71 static void bfa_ioc_reset(struct bfa_ioc *ioc, bool force);
72 static void bfa_ioc_mbox_poll(struct bfa_ioc *ioc);
73 static void bfa_ioc_mbox_flush(struct bfa_ioc *ioc);
74 static void bfa_ioc_recover(struct bfa_ioc *ioc);
75 static void bfa_ioc_check_attr_wwns(struct bfa_ioc *ioc);
76 static void bfa_ioc_event_notify(struct bfa_ioc *, enum bfa_ioc_event);
77 static void bfa_ioc_disable_comp(struct bfa_ioc *ioc);
78 static void bfa_ioc_lpu_stop(struct bfa_ioc *ioc);
79 static void bfa_ioc_fail_notify(struct bfa_ioc *ioc);
80 static void bfa_ioc_pf_enabled(struct bfa_ioc *ioc);
81 static void bfa_ioc_pf_disabled(struct bfa_ioc *ioc);
82 static void bfa_ioc_pf_failed(struct bfa_ioc *ioc);
83 static void bfa_ioc_pf_hwfailed(struct bfa_ioc *ioc);
84 static void bfa_ioc_pf_fwmismatch(struct bfa_ioc *ioc);
85 static void bfa_ioc_boot(struct bfa_ioc *ioc, u32 boot_type,
86 u32 boot_param);
87 static u32 bfa_ioc_smem_pgnum(struct bfa_ioc *ioc, u32 fmaddr);
88 static void bfa_ioc_get_adapter_serial_num(struct bfa_ioc *ioc,
89 char *serial_num);
90 static void bfa_ioc_get_adapter_fw_ver(struct bfa_ioc *ioc,
91 char *fw_ver);
92 static void bfa_ioc_get_pci_chip_rev(struct bfa_ioc *ioc,
93 char *chip_rev);
94 static void bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc *ioc,
95 char *optrom_ver);
96 static void bfa_ioc_get_adapter_manufacturer(struct bfa_ioc *ioc,
97 char *manufacturer);
98 static void bfa_ioc_get_adapter_model(struct bfa_ioc *ioc, char *model);
99 static u64 bfa_ioc_get_pwwn(struct bfa_ioc *ioc);
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 };
118
119 bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc, enum ioc_event);
120 bfa_fsm_state_decl(bfa_ioc, reset, struct bfa_ioc, enum ioc_event);
121 bfa_fsm_state_decl(bfa_ioc, enabling, struct bfa_ioc, enum ioc_event);
122 bfa_fsm_state_decl(bfa_ioc, getattr, struct bfa_ioc, enum ioc_event);
123 bfa_fsm_state_decl(bfa_ioc, op, struct bfa_ioc, enum ioc_event);
124 bfa_fsm_state_decl(bfa_ioc, fail_retry, struct bfa_ioc, enum ioc_event);
125 bfa_fsm_state_decl(bfa_ioc, fail, struct bfa_ioc, enum ioc_event);
126 bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc, enum ioc_event);
127 bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc, enum ioc_event);
128 bfa_fsm_state_decl(bfa_ioc, hwfail, struct bfa_ioc, enum ioc_event);
129
130 static struct bfa_sm_table ioc_sm_table[] = {
131 {BFA_SM(bfa_ioc_sm_uninit), BFA_IOC_UNINIT},
132 {BFA_SM(bfa_ioc_sm_reset), BFA_IOC_RESET},
133 {BFA_SM(bfa_ioc_sm_enabling), BFA_IOC_ENABLING},
134 {BFA_SM(bfa_ioc_sm_getattr), BFA_IOC_GETATTR},
135 {BFA_SM(bfa_ioc_sm_op), BFA_IOC_OPERATIONAL},
136 {BFA_SM(bfa_ioc_sm_fail_retry), BFA_IOC_INITFAIL},
137 {BFA_SM(bfa_ioc_sm_fail), BFA_IOC_FAIL},
138 {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
139 {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
140 {BFA_SM(bfa_ioc_sm_hwfail), BFA_IOC_HWFAIL},
141 };
142
143 /**
144 * IOCPF state machine definitions/declarations
145 */
146
147 /*
148 * Forward declareations for iocpf state machine
149 */
150 static void bfa_iocpf_enable(struct bfa_ioc *ioc);
151 static void bfa_iocpf_disable(struct bfa_ioc *ioc);
152 static void bfa_iocpf_fail(struct bfa_ioc *ioc);
153 static void bfa_iocpf_initfail(struct bfa_ioc *ioc);
154 static void bfa_iocpf_getattrfail(struct bfa_ioc *ioc);
155 static void bfa_iocpf_stop(struct bfa_ioc *ioc);
156
157 /**
158 * IOCPF state machine events
159 */
160 enum iocpf_event {
161 IOCPF_E_ENABLE = 1, /*!< IOCPF enable request */
162 IOCPF_E_DISABLE = 2, /*!< IOCPF disable request */
163 IOCPF_E_STOP = 3, /*!< stop on driver detach */
164 IOCPF_E_FWREADY = 4, /*!< f/w initialization done */
165 IOCPF_E_FWRSP_ENABLE = 5, /*!< enable f/w response */
166 IOCPF_E_FWRSP_DISABLE = 6, /*!< disable f/w response */
167 IOCPF_E_FAIL = 7, /*!< failure notice by ioc sm */
168 IOCPF_E_INITFAIL = 8, /*!< init fail notice by ioc sm */
169 IOCPF_E_GETATTRFAIL = 9, /*!< init fail notice by ioc sm */
170 IOCPF_E_SEMLOCKED = 10, /*!< h/w semaphore is locked */
171 IOCPF_E_TIMEOUT = 11, /*!< f/w response timeout */
172 IOCPF_E_SEM_ERROR = 12, /*!< h/w sem mapping error */
173 };
174
175 /**
176 * IOCPF states
177 */
178 enum bfa_iocpf_state {
179 BFA_IOCPF_RESET = 1, /*!< IOC is in reset state */
180 BFA_IOCPF_SEMWAIT = 2, /*!< Waiting for IOC h/w semaphore */
181 BFA_IOCPF_HWINIT = 3, /*!< IOC h/w is being initialized */
182 BFA_IOCPF_READY = 4, /*!< IOCPF is initialized */
183 BFA_IOCPF_INITFAIL = 5, /*!< IOCPF failed */
184 BFA_IOCPF_FAIL = 6, /*!< IOCPF failed */
185 BFA_IOCPF_DISABLING = 7, /*!< IOCPF is being disabled */
186 BFA_IOCPF_DISABLED = 8, /*!< IOCPF is disabled */
187 BFA_IOCPF_FWMISMATCH = 9, /*!< IOC f/w different from drivers */
188 };
189
190 bfa_fsm_state_decl(bfa_iocpf, reset, struct bfa_iocpf, enum iocpf_event);
191 bfa_fsm_state_decl(bfa_iocpf, fwcheck, struct bfa_iocpf, enum iocpf_event);
192 bfa_fsm_state_decl(bfa_iocpf, mismatch, struct bfa_iocpf, enum iocpf_event);
193 bfa_fsm_state_decl(bfa_iocpf, semwait, struct bfa_iocpf, enum iocpf_event);
194 bfa_fsm_state_decl(bfa_iocpf, hwinit, struct bfa_iocpf, enum iocpf_event);
195 bfa_fsm_state_decl(bfa_iocpf, enabling, struct bfa_iocpf, enum iocpf_event);
196 bfa_fsm_state_decl(bfa_iocpf, ready, struct bfa_iocpf, enum iocpf_event);
197 bfa_fsm_state_decl(bfa_iocpf, initfail_sync, struct bfa_iocpf,
198 enum iocpf_event);
199 bfa_fsm_state_decl(bfa_iocpf, initfail, struct bfa_iocpf, enum iocpf_event);
200 bfa_fsm_state_decl(bfa_iocpf, fail_sync, struct bfa_iocpf, enum iocpf_event);
201 bfa_fsm_state_decl(bfa_iocpf, fail, struct bfa_iocpf, enum iocpf_event);
202 bfa_fsm_state_decl(bfa_iocpf, disabling, struct bfa_iocpf, enum iocpf_event);
203 bfa_fsm_state_decl(bfa_iocpf, disabling_sync, struct bfa_iocpf,
204 enum iocpf_event);
205 bfa_fsm_state_decl(bfa_iocpf, disabled, struct bfa_iocpf, enum iocpf_event);
206
207 static struct bfa_sm_table iocpf_sm_table[] = {
208 {BFA_SM(bfa_iocpf_sm_reset), BFA_IOCPF_RESET},
209 {BFA_SM(bfa_iocpf_sm_fwcheck), BFA_IOCPF_FWMISMATCH},
210 {BFA_SM(bfa_iocpf_sm_mismatch), BFA_IOCPF_FWMISMATCH},
211 {BFA_SM(bfa_iocpf_sm_semwait), BFA_IOCPF_SEMWAIT},
212 {BFA_SM(bfa_iocpf_sm_hwinit), BFA_IOCPF_HWINIT},
213 {BFA_SM(bfa_iocpf_sm_enabling), BFA_IOCPF_HWINIT},
214 {BFA_SM(bfa_iocpf_sm_ready), BFA_IOCPF_READY},
215 {BFA_SM(bfa_iocpf_sm_initfail_sync), BFA_IOCPF_INITFAIL},
216 {BFA_SM(bfa_iocpf_sm_initfail), BFA_IOCPF_INITFAIL},
217 {BFA_SM(bfa_iocpf_sm_fail_sync), BFA_IOCPF_FAIL},
218 {BFA_SM(bfa_iocpf_sm_fail), BFA_IOCPF_FAIL},
219 {BFA_SM(bfa_iocpf_sm_disabling), BFA_IOCPF_DISABLING},
220 {BFA_SM(bfa_iocpf_sm_disabling_sync), BFA_IOCPF_DISABLING},
221 {BFA_SM(bfa_iocpf_sm_disabled), BFA_IOCPF_DISABLED},
222 };
223
224 /**
225 * IOC State Machine
226 */
227
228 /**
229 * Beginning state. IOC uninit state.
230 */
231 static void
232 bfa_ioc_sm_uninit_entry(struct bfa_ioc *ioc)
233 {
234 }
235
236 /**
237 * IOC is in uninit state.
238 */
239 static void
240 bfa_ioc_sm_uninit(struct bfa_ioc *ioc, enum ioc_event event)
241 {
242 switch (event) {
243 case IOC_E_RESET:
244 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
245 break;
246
247 default:
248 bfa_sm_fault(event);
249 }
250 }
251
252 /**
253 * Reset entry actions -- initialize state machine
254 */
255 static void
256 bfa_ioc_sm_reset_entry(struct bfa_ioc *ioc)
257 {
258 bfa_fsm_set_state(&ioc->iocpf, bfa_iocpf_sm_reset);
259 }
260
261 /**
262 * IOC is in reset state.
263 */
264 static void
265 bfa_ioc_sm_reset(struct bfa_ioc *ioc, enum ioc_event event)
266 {
267 switch (event) {
268 case IOC_E_ENABLE:
269 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
270 break;
271
272 case IOC_E_DISABLE:
273 bfa_ioc_disable_comp(ioc);
274 break;
275
276 case IOC_E_DETACH:
277 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
278 break;
279
280 default:
281 bfa_sm_fault(event);
282 }
283 }
284
285 static void
286 bfa_ioc_sm_enabling_entry(struct bfa_ioc *ioc)
287 {
288 bfa_iocpf_enable(ioc);
289 }
290
291 /**
292 * Host IOC function is being enabled, awaiting response from firmware.
293 * Semaphore is acquired.
294 */
295 static void
296 bfa_ioc_sm_enabling(struct bfa_ioc *ioc, enum ioc_event event)
297 {
298 switch (event) {
299 case IOC_E_ENABLED:
300 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
301 break;
302
303 case IOC_E_PFFAILED:
304 /* !!! fall through !!! */
305 case IOC_E_HWERROR:
306 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
307 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
308 if (event != IOC_E_PFFAILED)
309 bfa_iocpf_initfail(ioc);
310 break;
311
312 case IOC_E_HWFAILED:
313 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
314 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
315 break;
316
317 case IOC_E_DISABLE:
318 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
319 break;
320
321 case IOC_E_DETACH:
322 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
323 bfa_iocpf_stop(ioc);
324 break;
325
326 case IOC_E_ENABLE:
327 break;
328
329 default:
330 bfa_sm_fault(event);
331 }
332 }
333
334 /**
335 * Semaphore should be acquired for version check.
336 */
337 static void
338 bfa_ioc_sm_getattr_entry(struct bfa_ioc *ioc)
339 {
340 mod_timer(&ioc->ioc_timer, jiffies +
341 msecs_to_jiffies(BFA_IOC_TOV));
342 bfa_ioc_send_getattr(ioc);
343 }
344
345 /**
346 * IOC configuration in progress. Timer is active.
347 */
348 static void
349 bfa_ioc_sm_getattr(struct bfa_ioc *ioc, enum ioc_event event)
350 {
351 switch (event) {
352 case IOC_E_FWRSP_GETATTR:
353 del_timer(&ioc->ioc_timer);
354 bfa_ioc_check_attr_wwns(ioc);
355 bfa_ioc_hb_monitor(ioc);
356 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
357 break;
358
359 case IOC_E_PFFAILED:
360 case IOC_E_HWERROR:
361 del_timer(&ioc->ioc_timer);
362 /* fall through */
363 case IOC_E_TIMEOUT:
364 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
365 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
366 if (event != IOC_E_PFFAILED)
367 bfa_iocpf_getattrfail(ioc);
368 break;
369
370 case IOC_E_DISABLE:
371 del_timer(&ioc->ioc_timer);
372 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
373 break;
374
375 case IOC_E_ENABLE:
376 break;
377
378 default:
379 bfa_sm_fault(event);
380 }
381 }
382
383 static void
384 bfa_ioc_sm_op_entry(struct bfa_ioc *ioc)
385 {
386 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
387 bfa_ioc_event_notify(ioc, BFA_IOC_E_ENABLED);
388 }
389
390 static void
391 bfa_ioc_sm_op(struct bfa_ioc *ioc, enum ioc_event event)
392 {
393 switch (event) {
394 case IOC_E_ENABLE:
395 break;
396
397 case IOC_E_DISABLE:
398 bfa_ioc_hb_stop(ioc);
399 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
400 break;
401
402 case IOC_E_PFFAILED:
403 case IOC_E_HWERROR:
404 bfa_ioc_hb_stop(ioc);
405 /* !!! fall through !!! */
406 case IOC_E_HBFAIL:
407 if (ioc->iocpf.auto_recover)
408 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail_retry);
409 else
410 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
411
412 bfa_ioc_fail_notify(ioc);
413
414 if (event != IOC_E_PFFAILED)
415 bfa_iocpf_fail(ioc);
416 break;
417
418 default:
419 bfa_sm_fault(event);
420 }
421 }
422
423 static void
424 bfa_ioc_sm_disabling_entry(struct bfa_ioc *ioc)
425 {
426 bfa_iocpf_disable(ioc);
427 }
428
429 /**
430 * IOC is being desabled
431 */
432 static void
433 bfa_ioc_sm_disabling(struct bfa_ioc *ioc, enum ioc_event event)
434 {
435 switch (event) {
436 case IOC_E_DISABLED:
437 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
438 break;
439
440 case IOC_E_HWERROR:
441 /*
442 * No state change. Will move to disabled state
443 * after iocpf sm completes failure processing and
444 * moves to disabled state.
445 */
446 bfa_iocpf_fail(ioc);
447 break;
448
449 case IOC_E_HWFAILED:
450 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
451 bfa_ioc_disable_comp(ioc);
452 break;
453
454 default:
455 bfa_sm_fault(event);
456 }
457 }
458
459 /**
460 * IOC desable completion entry.
461 */
462 static void
463 bfa_ioc_sm_disabled_entry(struct bfa_ioc *ioc)
464 {
465 bfa_ioc_disable_comp(ioc);
466 }
467
468 static void
469 bfa_ioc_sm_disabled(struct bfa_ioc *ioc, enum ioc_event event)
470 {
471 switch (event) {
472 case IOC_E_ENABLE:
473 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
474 break;
475
476 case IOC_E_DISABLE:
477 ioc->cbfn->disable_cbfn(ioc->bfa);
478 break;
479
480 case IOC_E_DETACH:
481 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
482 bfa_iocpf_stop(ioc);
483 break;
484
485 default:
486 bfa_sm_fault(event);
487 }
488 }
489
490 static void
491 bfa_ioc_sm_fail_retry_entry(struct bfa_ioc *ioc)
492 {
493 }
494
495 /**
496 * Hardware initialization retry.
497 */
498 static void
499 bfa_ioc_sm_fail_retry(struct bfa_ioc *ioc, enum ioc_event event)
500 {
501 switch (event) {
502 case IOC_E_ENABLED:
503 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
504 break;
505
506 case IOC_E_PFFAILED:
507 case IOC_E_HWERROR:
508 /**
509 * Initialization retry failed.
510 */
511 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
512 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
513 if (event != IOC_E_PFFAILED)
514 bfa_iocpf_initfail(ioc);
515 break;
516
517 case IOC_E_HWFAILED:
518 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
519 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwfail);
520 break;
521
522 case IOC_E_ENABLE:
523 break;
524
525 case IOC_E_DISABLE:
526 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
527 break;
528
529 case IOC_E_DETACH:
530 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
531 bfa_iocpf_stop(ioc);
532 break;
533
534 default:
535 bfa_sm_fault(event);
536 }
537 }
538
539 static void
540 bfa_ioc_sm_fail_entry(struct bfa_ioc *ioc)
541 {
542 }
543
544 /**
545 * IOC failure.
546 */
547 static void
548 bfa_ioc_sm_fail(struct bfa_ioc *ioc, enum ioc_event event)
549 {
550 switch (event) {
551 case IOC_E_ENABLE:
552 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
553 break;
554
555 case IOC_E_DISABLE:
556 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
557 break;
558
559 case IOC_E_DETACH:
560 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
561 bfa_iocpf_stop(ioc);
562 break;
563
564 case IOC_E_HWERROR:
565 /* HB failure notification, ignore. */
566 break;
567
568 default:
569 bfa_sm_fault(event);
570 }
571 }
572
573 static void
574 bfa_ioc_sm_hwfail_entry(struct bfa_ioc *ioc)
575 {
576 }
577
578 /**
579 * IOC failure.
580 */
581 static void
582 bfa_ioc_sm_hwfail(struct bfa_ioc *ioc, enum ioc_event event)
583 {
584 switch (event) {
585
586 case IOC_E_ENABLE:
587 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
588 break;
589
590 case IOC_E_DISABLE:
591 ioc->cbfn->disable_cbfn(ioc->bfa);
592 break;
593
594 case IOC_E_DETACH:
595 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
596 break;
597
598 default:
599 bfa_sm_fault(event);
600 }
601 }
602
603 /**
604 * IOCPF State Machine
605 */
606
607 /**
608 * Reset entry actions -- initialize state machine
609 */
610 static void
611 bfa_iocpf_sm_reset_entry(struct bfa_iocpf *iocpf)
612 {
613 iocpf->fw_mismatch_notified = false;
614 iocpf->auto_recover = bfa_nw_auto_recover;
615 }
616
617 /**
618 * Beginning state. IOC is in reset state.
619 */
620 static void
621 bfa_iocpf_sm_reset(struct bfa_iocpf *iocpf, enum iocpf_event event)
622 {
623 switch (event) {
624 case IOCPF_E_ENABLE:
625 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
626 break;
627
628 case IOCPF_E_STOP:
629 break;
630
631 default:
632 bfa_sm_fault(event);
633 }
634 }
635
636 /**
637 * Semaphore should be acquired for version check.
638 */
639 static void
640 bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf *iocpf)
641 {
642 bfa_ioc_hw_sem_init(iocpf->ioc);
643 bfa_ioc_hw_sem_get(iocpf->ioc);
644 }
645
646 /**
647 * Awaiting h/w semaphore to continue with version check.
648 */
649 static void
650 bfa_iocpf_sm_fwcheck(struct bfa_iocpf *iocpf, enum iocpf_event event)
651 {
652 struct bfa_ioc *ioc = iocpf->ioc;
653
654 switch (event) {
655 case IOCPF_E_SEMLOCKED:
656 if (bfa_ioc_firmware_lock(ioc)) {
657 if (bfa_ioc_sync_start(ioc)) {
658 bfa_ioc_sync_join(ioc);
659 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
660 } else {
661 bfa_ioc_firmware_unlock(ioc);
662 bfa_nw_ioc_hw_sem_release(ioc);
663 mod_timer(&ioc->sem_timer, jiffies +
664 msecs_to_jiffies(BFA_IOC_HWSEM_TOV));
665 }
666 } else {
667 bfa_nw_ioc_hw_sem_release(ioc);
668 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_mismatch);
669 }
670 break;
671
672 case IOCPF_E_SEM_ERROR:
673 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
674 bfa_ioc_pf_hwfailed(ioc);
675 break;
676
677 case IOCPF_E_DISABLE:
678 bfa_ioc_hw_sem_get_cancel(ioc);
679 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
680 bfa_ioc_pf_disabled(ioc);
681 break;
682
683 case IOCPF_E_STOP:
684 bfa_ioc_hw_sem_get_cancel(ioc);
685 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
686 break;
687
688 default:
689 bfa_sm_fault(event);
690 }
691 }
692
693 /**
694 * Notify enable completion callback
695 */
696 static void
697 bfa_iocpf_sm_mismatch_entry(struct bfa_iocpf *iocpf)
698 {
699 /* Call only the first time sm enters fwmismatch state. */
700 if (iocpf->fw_mismatch_notified == false)
701 bfa_ioc_pf_fwmismatch(iocpf->ioc);
702
703 iocpf->fw_mismatch_notified = true;
704 mod_timer(&(iocpf->ioc)->iocpf_timer, jiffies +
705 msecs_to_jiffies(BFA_IOC_TOV));
706 }
707
708 /**
709 * Awaiting firmware version match.
710 */
711 static void
712 bfa_iocpf_sm_mismatch(struct bfa_iocpf *iocpf, enum iocpf_event event)
713 {
714 struct bfa_ioc *ioc = iocpf->ioc;
715
716 switch (event) {
717 case IOCPF_E_TIMEOUT:
718 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
719 break;
720
721 case IOCPF_E_DISABLE:
722 del_timer(&ioc->iocpf_timer);
723 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
724 bfa_ioc_pf_disabled(ioc);
725 break;
726
727 case IOCPF_E_STOP:
728 del_timer(&ioc->iocpf_timer);
729 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
730 break;
731
732 default:
733 bfa_sm_fault(event);
734 }
735 }
736
737 /**
738 * Request for semaphore.
739 */
740 static void
741 bfa_iocpf_sm_semwait_entry(struct bfa_iocpf *iocpf)
742 {
743 bfa_ioc_hw_sem_get(iocpf->ioc);
744 }
745
746 /**
747 * Awaiting semaphore for h/w initialzation.
748 */
749 static void
750 bfa_iocpf_sm_semwait(struct bfa_iocpf *iocpf, enum iocpf_event event)
751 {
752 struct bfa_ioc *ioc = iocpf->ioc;
753
754 switch (event) {
755 case IOCPF_E_SEMLOCKED:
756 if (bfa_ioc_sync_complete(ioc)) {
757 bfa_ioc_sync_join(ioc);
758 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
759 } else {
760 bfa_nw_ioc_hw_sem_release(ioc);
761 mod_timer(&ioc->sem_timer, jiffies +
762 msecs_to_jiffies(BFA_IOC_HWSEM_TOV));
763 }
764 break;
765
766 case IOCPF_E_SEM_ERROR:
767 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
768 bfa_ioc_pf_hwfailed(ioc);
769 break;
770
771 case IOCPF_E_DISABLE:
772 bfa_ioc_hw_sem_get_cancel(ioc);
773 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
774 break;
775
776 default:
777 bfa_sm_fault(event);
778 }
779 }
780
781 static void
782 bfa_iocpf_sm_hwinit_entry(struct bfa_iocpf *iocpf)
783 {
784 iocpf->poll_time = 0;
785 bfa_ioc_reset(iocpf->ioc, 0);
786 }
787
788 /**
789 * Hardware is being initialized. Interrupts are enabled.
790 * Holding hardware semaphore lock.
791 */
792 static void
793 bfa_iocpf_sm_hwinit(struct bfa_iocpf *iocpf, enum iocpf_event event)
794 {
795 struct bfa_ioc *ioc = iocpf->ioc;
796
797 switch (event) {
798 case IOCPF_E_FWREADY:
799 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_enabling);
800 break;
801
802 case IOCPF_E_TIMEOUT:
803 bfa_nw_ioc_hw_sem_release(ioc);
804 bfa_ioc_pf_failed(ioc);
805 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
806 break;
807
808 case IOCPF_E_DISABLE:
809 del_timer(&ioc->iocpf_timer);
810 bfa_ioc_sync_leave(ioc);
811 bfa_nw_ioc_hw_sem_release(ioc);
812 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
813 break;
814
815 default:
816 bfa_sm_fault(event);
817 }
818 }
819
820 static void
821 bfa_iocpf_sm_enabling_entry(struct bfa_iocpf *iocpf)
822 {
823 mod_timer(&(iocpf->ioc)->iocpf_timer, jiffies +
824 msecs_to_jiffies(BFA_IOC_TOV));
825 /**
826 * Enable Interrupts before sending fw IOC ENABLE cmd.
827 */
828 iocpf->ioc->cbfn->reset_cbfn(iocpf->ioc->bfa);
829 bfa_ioc_send_enable(iocpf->ioc);
830 }
831
832 /**
833 * Host IOC function is being enabled, awaiting response from firmware.
834 * Semaphore is acquired.
835 */
836 static void
837 bfa_iocpf_sm_enabling(struct bfa_iocpf *iocpf, enum iocpf_event event)
838 {
839 struct bfa_ioc *ioc = iocpf->ioc;
840
841 switch (event) {
842 case IOCPF_E_FWRSP_ENABLE:
843 del_timer(&ioc->iocpf_timer);
844 bfa_nw_ioc_hw_sem_release(ioc);
845 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_ready);
846 break;
847
848 case IOCPF_E_INITFAIL:
849 del_timer(&ioc->iocpf_timer);
850 /*
851 * !!! fall through !!!
852 */
853 case IOCPF_E_TIMEOUT:
854 bfa_nw_ioc_hw_sem_release(ioc);
855 if (event == IOCPF_E_TIMEOUT)
856 bfa_ioc_pf_failed(ioc);
857 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
858 break;
859
860 case IOCPF_E_DISABLE:
861 del_timer(&ioc->iocpf_timer);
862 bfa_nw_ioc_hw_sem_release(ioc);
863 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
864 break;
865
866 default:
867 bfa_sm_fault(event);
868 }
869 }
870
871 static void
872 bfa_iocpf_sm_ready_entry(struct bfa_iocpf *iocpf)
873 {
874 bfa_ioc_pf_enabled(iocpf->ioc);
875 }
876
877 static void
878 bfa_iocpf_sm_ready(struct bfa_iocpf *iocpf, enum iocpf_event event)
879 {
880 switch (event) {
881 case IOCPF_E_DISABLE:
882 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
883 break;
884
885 case IOCPF_E_GETATTRFAIL:
886 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail_sync);
887 break;
888
889 case IOCPF_E_FAIL:
890 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail_sync);
891 break;
892
893 default:
894 bfa_sm_fault(event);
895 }
896 }
897
898 static void
899 bfa_iocpf_sm_disabling_entry(struct bfa_iocpf *iocpf)
900 {
901 mod_timer(&(iocpf->ioc)->iocpf_timer, jiffies +
902 msecs_to_jiffies(BFA_IOC_TOV));
903 bfa_ioc_send_disable(iocpf->ioc);
904 }
905
906 /**
907 * IOC is being disabled
908 */
909 static void
910 bfa_iocpf_sm_disabling(struct bfa_iocpf *iocpf, enum iocpf_event event)
911 {
912 struct bfa_ioc *ioc = iocpf->ioc;
913
914 switch (event) {
915 case IOCPF_E_FWRSP_DISABLE:
916 del_timer(&ioc->iocpf_timer);
917 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
918 break;
919
920 case IOCPF_E_FAIL:
921 del_timer(&ioc->iocpf_timer);
922 /*
923 * !!! fall through !!!
924 */
925
926 case IOCPF_E_TIMEOUT:
927 writel(BFI_IOC_FAIL, ioc->ioc_regs.ioc_fwstate);
928 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
929 break;
930
931 case IOCPF_E_FWRSP_ENABLE:
932 break;
933
934 default:
935 bfa_sm_fault(event);
936 }
937 }
938
939 static void
940 bfa_iocpf_sm_disabling_sync_entry(struct bfa_iocpf *iocpf)
941 {
942 bfa_ioc_hw_sem_get(iocpf->ioc);
943 }
944
945 /**
946 * IOC hb ack request is being removed.
947 */
948 static void
949 bfa_iocpf_sm_disabling_sync(struct bfa_iocpf *iocpf, enum iocpf_event event)
950 {
951 struct bfa_ioc *ioc = iocpf->ioc;
952
953 switch (event) {
954 case IOCPF_E_SEMLOCKED:
955 bfa_ioc_sync_leave(ioc);
956 bfa_nw_ioc_hw_sem_release(ioc);
957 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
958 break;
959
960 case IOCPF_E_SEM_ERROR:
961 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
962 bfa_ioc_pf_hwfailed(ioc);
963 break;
964
965 case IOCPF_E_FAIL:
966 break;
967
968 default:
969 bfa_sm_fault(event);
970 }
971 }
972
973 /**
974 * IOC disable completion entry.
975 */
976 static void
977 bfa_iocpf_sm_disabled_entry(struct bfa_iocpf *iocpf)
978 {
979 bfa_ioc_mbox_flush(iocpf->ioc);
980 bfa_ioc_pf_disabled(iocpf->ioc);
981 }
982
983 static void
984 bfa_iocpf_sm_disabled(struct bfa_iocpf *iocpf, enum iocpf_event event)
985 {
986 struct bfa_ioc *ioc = iocpf->ioc;
987
988 switch (event) {
989 case IOCPF_E_ENABLE:
990 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
991 break;
992
993 case IOCPF_E_STOP:
994 bfa_ioc_firmware_unlock(ioc);
995 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
996 break;
997
998 default:
999 bfa_sm_fault(event);
1000 }
1001 }
1002
1003 static void
1004 bfa_iocpf_sm_initfail_sync_entry(struct bfa_iocpf *iocpf)
1005 {
1006 bfa_ioc_hw_sem_get(iocpf->ioc);
1007 }
1008
1009 /**
1010 * Hardware initialization failed.
1011 */
1012 static void
1013 bfa_iocpf_sm_initfail_sync(struct bfa_iocpf *iocpf, enum iocpf_event event)
1014 {
1015 struct bfa_ioc *ioc = iocpf->ioc;
1016
1017 switch (event) {
1018 case IOCPF_E_SEMLOCKED:
1019 bfa_ioc_notify_fail(ioc);
1020 bfa_ioc_sync_leave(ioc);
1021 writel(BFI_IOC_FAIL, ioc->ioc_regs.ioc_fwstate);
1022 bfa_nw_ioc_hw_sem_release(ioc);
1023 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
1024 break;
1025
1026 case IOCPF_E_SEM_ERROR:
1027 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1028 bfa_ioc_pf_hwfailed(ioc);
1029 break;
1030
1031 case IOCPF_E_DISABLE:
1032 bfa_ioc_hw_sem_get_cancel(ioc);
1033 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1034 break;
1035
1036 case IOCPF_E_STOP:
1037 bfa_ioc_hw_sem_get_cancel(ioc);
1038 bfa_ioc_firmware_unlock(ioc);
1039 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1040 break;
1041
1042 case IOCPF_E_FAIL:
1043 break;
1044
1045 default:
1046 bfa_sm_fault(event);
1047 }
1048 }
1049
1050 static void
1051 bfa_iocpf_sm_initfail_entry(struct bfa_iocpf *iocpf)
1052 {
1053 }
1054
1055 /**
1056 * Hardware initialization failed.
1057 */
1058 static void
1059 bfa_iocpf_sm_initfail(struct bfa_iocpf *iocpf, enum iocpf_event event)
1060 {
1061 struct bfa_ioc *ioc = iocpf->ioc;
1062
1063 switch (event) {
1064 case IOCPF_E_DISABLE:
1065 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1066 break;
1067
1068 case IOCPF_E_STOP:
1069 bfa_ioc_firmware_unlock(ioc);
1070 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1071 break;
1072
1073 default:
1074 bfa_sm_fault(event);
1075 }
1076 }
1077
1078 static void
1079 bfa_iocpf_sm_fail_sync_entry(struct bfa_iocpf *iocpf)
1080 {
1081 /**
1082 * Mark IOC as failed in hardware and stop firmware.
1083 */
1084 bfa_ioc_lpu_stop(iocpf->ioc);
1085
1086 /**
1087 * Flush any queued up mailbox requests.
1088 */
1089 bfa_ioc_mbox_flush(iocpf->ioc);
1090 bfa_ioc_hw_sem_get(iocpf->ioc);
1091 }
1092
1093 /**
1094 * IOC is in failed state.
1095 */
1096 static void
1097 bfa_iocpf_sm_fail_sync(struct bfa_iocpf *iocpf, enum iocpf_event event)
1098 {
1099 struct bfa_ioc *ioc = iocpf->ioc;
1100
1101 switch (event) {
1102 case IOCPF_E_SEMLOCKED:
1103 bfa_ioc_sync_ack(ioc);
1104 bfa_ioc_notify_fail(ioc);
1105 if (!iocpf->auto_recover) {
1106 bfa_ioc_sync_leave(ioc);
1107 writel(BFI_IOC_FAIL, ioc->ioc_regs.ioc_fwstate);
1108 bfa_nw_ioc_hw_sem_release(ioc);
1109 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1110 } else {
1111 if (bfa_ioc_sync_complete(ioc))
1112 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
1113 else {
1114 bfa_nw_ioc_hw_sem_release(ioc);
1115 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1116 }
1117 }
1118 break;
1119
1120 case IOCPF_E_SEM_ERROR:
1121 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
1122 bfa_ioc_pf_hwfailed(ioc);
1123 break;
1124
1125 case IOCPF_E_DISABLE:
1126 bfa_ioc_hw_sem_get_cancel(ioc);
1127 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling_sync);
1128 break;
1129
1130 case IOCPF_E_FAIL:
1131 break;
1132
1133 default:
1134 bfa_sm_fault(event);
1135 }
1136 }
1137
1138 static void
1139 bfa_iocpf_sm_fail_entry(struct bfa_iocpf *iocpf)
1140 {
1141 }
1142
1143 /**
1144 * @brief
1145 * IOC is in failed state.
1146 */
1147 static void
1148 bfa_iocpf_sm_fail(struct bfa_iocpf *iocpf, enum iocpf_event event)
1149 {
1150 switch (event) {
1151 case IOCPF_E_DISABLE:
1152 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1153 break;
1154
1155 default:
1156 bfa_sm_fault(event);
1157 }
1158 }
1159
1160 /**
1161 * BFA IOC private functions
1162 */
1163
1164 /**
1165 * Notify common modules registered for notification.
1166 */
1167 static void
1168 bfa_ioc_event_notify(struct bfa_ioc *ioc, enum bfa_ioc_event event)
1169 {
1170 struct bfa_ioc_notify *notify;
1171 struct list_head *qe;
1172
1173 list_for_each(qe, &ioc->notify_q) {
1174 notify = (struct bfa_ioc_notify *)qe;
1175 notify->cbfn(notify->cbarg, event);
1176 }
1177 }
1178
1179 static void
1180 bfa_ioc_disable_comp(struct bfa_ioc *ioc)
1181 {
1182 ioc->cbfn->disable_cbfn(ioc->bfa);
1183 bfa_ioc_event_notify(ioc, BFA_IOC_E_DISABLED);
1184 }
1185
1186 bool
1187 bfa_nw_ioc_sem_get(void __iomem *sem_reg)
1188 {
1189 u32 r32;
1190 int cnt = 0;
1191 #define BFA_SEM_SPINCNT 3000
1192
1193 r32 = readl(sem_reg);
1194
1195 while ((r32 & 1) && (cnt < BFA_SEM_SPINCNT)) {
1196 cnt++;
1197 udelay(2);
1198 r32 = readl(sem_reg);
1199 }
1200
1201 if (!(r32 & 1))
1202 return true;
1203
1204 return false;
1205 }
1206
1207 void
1208 bfa_nw_ioc_sem_release(void __iomem *sem_reg)
1209 {
1210 readl(sem_reg);
1211 writel(1, sem_reg);
1212 }
1213
1214 static void
1215 bfa_ioc_hw_sem_init(struct bfa_ioc *ioc)
1216 {
1217 struct bfi_ioc_image_hdr fwhdr;
1218 u32 fwstate = readl(ioc->ioc_regs.ioc_fwstate);
1219
1220 if (fwstate == BFI_IOC_UNINIT)
1221 return;
1222
1223 bfa_nw_ioc_fwver_get(ioc, &fwhdr);
1224
1225 if (swab32(fwhdr.exec) == BFI_FWBOOT_TYPE_NORMAL)
1226 return;
1227
1228 writel(BFI_IOC_UNINIT, ioc->ioc_regs.ioc_fwstate);
1229
1230 /*
1231 * Try to lock and then unlock the semaphore.
1232 */
1233 readl(ioc->ioc_regs.ioc_sem_reg);
1234 writel(1, ioc->ioc_regs.ioc_sem_reg);
1235 }
1236
1237 static void
1238 bfa_ioc_hw_sem_get(struct bfa_ioc *ioc)
1239 {
1240 u32 r32;
1241
1242 /**
1243 * First read to the semaphore register will return 0, subsequent reads
1244 * will return 1. Semaphore is released by writing 1 to the register
1245 */
1246 r32 = readl(ioc->ioc_regs.ioc_sem_reg);
1247 if (r32 == ~0) {
1248 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_SEM_ERROR);
1249 return;
1250 }
1251 if (!(r32 & 1)) {
1252 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_SEMLOCKED);
1253 return;
1254 }
1255
1256 mod_timer(&ioc->sem_timer, jiffies +
1257 msecs_to_jiffies(BFA_IOC_HWSEM_TOV));
1258 }
1259
1260 void
1261 bfa_nw_ioc_hw_sem_release(struct bfa_ioc *ioc)
1262 {
1263 writel(1, ioc->ioc_regs.ioc_sem_reg);
1264 }
1265
1266 static void
1267 bfa_ioc_hw_sem_get_cancel(struct bfa_ioc *ioc)
1268 {
1269 del_timer(&ioc->sem_timer);
1270 }
1271
1272 /**
1273 * @brief
1274 * Initialize LPU local memory (aka secondary memory / SRAM)
1275 */
1276 static void
1277 bfa_ioc_lmem_init(struct bfa_ioc *ioc)
1278 {
1279 u32 pss_ctl;
1280 int i;
1281 #define PSS_LMEM_INIT_TIME 10000
1282
1283 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1284 pss_ctl &= ~__PSS_LMEM_RESET;
1285 pss_ctl |= __PSS_LMEM_INIT_EN;
1286
1287 /*
1288 * i2c workaround 12.5khz clock
1289 */
1290 pss_ctl |= __PSS_I2C_CLK_DIV(3UL);
1291 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1292
1293 /**
1294 * wait for memory initialization to be complete
1295 */
1296 i = 0;
1297 do {
1298 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1299 i++;
1300 } while (!(pss_ctl & __PSS_LMEM_INIT_DONE) && (i < PSS_LMEM_INIT_TIME));
1301
1302 /**
1303 * If memory initialization is not successful, IOC timeout will catch
1304 * such failures.
1305 */
1306 BUG_ON(!(pss_ctl & __PSS_LMEM_INIT_DONE));
1307
1308 pss_ctl &= ~(__PSS_LMEM_INIT_DONE | __PSS_LMEM_INIT_EN);
1309 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1310 }
1311
1312 static void
1313 bfa_ioc_lpu_start(struct bfa_ioc *ioc)
1314 {
1315 u32 pss_ctl;
1316
1317 /**
1318 * Take processor out of reset.
1319 */
1320 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1321 pss_ctl &= ~__PSS_LPU0_RESET;
1322
1323 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1324 }
1325
1326 static void
1327 bfa_ioc_lpu_stop(struct bfa_ioc *ioc)
1328 {
1329 u32 pss_ctl;
1330
1331 /**
1332 * Put processors in reset.
1333 */
1334 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1335 pss_ctl |= (__PSS_LPU0_RESET | __PSS_LPU1_RESET);
1336
1337 writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1338 }
1339
1340 /**
1341 * Get driver and firmware versions.
1342 */
1343 void
1344 bfa_nw_ioc_fwver_get(struct bfa_ioc *ioc, struct bfi_ioc_image_hdr *fwhdr)
1345 {
1346 u32 pgnum;
1347 u32 loff = 0;
1348 int i;
1349 u32 *fwsig = (u32 *) fwhdr;
1350
1351 pgnum = bfa_ioc_smem_pgnum(ioc, loff);
1352 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1353
1354 for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr) / sizeof(u32));
1355 i++) {
1356 fwsig[i] =
1357 swab32(readl((loff) + (ioc->ioc_regs.smem_page_start)));
1358 loff += sizeof(u32);
1359 }
1360 }
1361
1362 /**
1363 * Returns TRUE if same.
1364 */
1365 bool
1366 bfa_nw_ioc_fwver_cmp(struct bfa_ioc *ioc, struct bfi_ioc_image_hdr *fwhdr)
1367 {
1368 struct bfi_ioc_image_hdr *drv_fwhdr;
1369 int i;
1370
1371 drv_fwhdr = (struct bfi_ioc_image_hdr *)
1372 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
1373
1374 for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) {
1375 if (fwhdr->md5sum[i] != drv_fwhdr->md5sum[i])
1376 return false;
1377 }
1378
1379 return true;
1380 }
1381
1382 /**
1383 * Return true if current running version is valid. Firmware signature and
1384 * execution context (driver/bios) must match.
1385 */
1386 static bool
1387 bfa_ioc_fwver_valid(struct bfa_ioc *ioc, u32 boot_env)
1388 {
1389 struct bfi_ioc_image_hdr fwhdr, *drv_fwhdr;
1390
1391 bfa_nw_ioc_fwver_get(ioc, &fwhdr);
1392 drv_fwhdr = (struct bfi_ioc_image_hdr *)
1393 bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), 0);
1394
1395 if (fwhdr.signature != drv_fwhdr->signature)
1396 return false;
1397
1398 if (swab32(fwhdr.bootenv) != boot_env)
1399 return false;
1400
1401 return bfa_nw_ioc_fwver_cmp(ioc, &fwhdr);
1402 }
1403
1404 /**
1405 * Conditionally flush any pending message from firmware at start.
1406 */
1407 static void
1408 bfa_ioc_msgflush(struct bfa_ioc *ioc)
1409 {
1410 u32 r32;
1411
1412 r32 = readl(ioc->ioc_regs.lpu_mbox_cmd);
1413 if (r32)
1414 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
1415 }
1416
1417 /**
1418 * @img ioc_init_logic.jpg
1419 */
1420 static void
1421 bfa_ioc_hwinit(struct bfa_ioc *ioc, bool force)
1422 {
1423 enum bfi_ioc_state ioc_fwstate;
1424 bool fwvalid;
1425 u32 boot_env;
1426
1427 ioc_fwstate = readl(ioc->ioc_regs.ioc_fwstate);
1428
1429 if (force)
1430 ioc_fwstate = BFI_IOC_UNINIT;
1431
1432 boot_env = BFI_FWBOOT_ENV_OS;
1433
1434 /**
1435 * check if firmware is valid
1436 */
1437 fwvalid = (ioc_fwstate == BFI_IOC_UNINIT) ?
1438 false : bfa_ioc_fwver_valid(ioc, boot_env);
1439
1440 if (!fwvalid) {
1441 bfa_ioc_boot(ioc, BFI_FWBOOT_TYPE_NORMAL, boot_env);
1442 bfa_ioc_poll_fwinit(ioc);
1443 return;
1444 }
1445
1446 /**
1447 * If hardware initialization is in progress (initialized by other IOC),
1448 * just wait for an initialization completion interrupt.
1449 */
1450 if (ioc_fwstate == BFI_IOC_INITING) {
1451 bfa_ioc_poll_fwinit(ioc);
1452 return;
1453 }
1454
1455 /**
1456 * If IOC function is disabled and firmware version is same,
1457 * just re-enable IOC.
1458 */
1459 if (ioc_fwstate == BFI_IOC_DISABLED || ioc_fwstate == BFI_IOC_OP) {
1460 /**
1461 * When using MSI-X any pending firmware ready event should
1462 * be flushed. Otherwise MSI-X interrupts are not delivered.
1463 */
1464 bfa_ioc_msgflush(ioc);
1465 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FWREADY);
1466 return;
1467 }
1468
1469 /**
1470 * Initialize the h/w for any other states.
1471 */
1472 bfa_ioc_boot(ioc, BFI_FWBOOT_TYPE_NORMAL, boot_env);
1473 bfa_ioc_poll_fwinit(ioc);
1474 }
1475
1476 void
1477 bfa_nw_ioc_timeout(void *ioc_arg)
1478 {
1479 struct bfa_ioc *ioc = (struct bfa_ioc *) ioc_arg;
1480
1481 bfa_fsm_send_event(ioc, IOC_E_TIMEOUT);
1482 }
1483
1484 static void
1485 bfa_ioc_mbox_send(struct bfa_ioc *ioc, void *ioc_msg, int len)
1486 {
1487 u32 *msgp = (u32 *) ioc_msg;
1488 u32 i;
1489
1490 BUG_ON(!(len <= BFI_IOC_MSGLEN_MAX));
1491
1492 /*
1493 * first write msg to mailbox registers
1494 */
1495 for (i = 0; i < len / sizeof(u32); i++)
1496 writel(cpu_to_le32(msgp[i]),
1497 ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1498
1499 for (; i < BFI_IOC_MSGLEN_MAX / sizeof(u32); i++)
1500 writel(0, ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1501
1502 /*
1503 * write 1 to mailbox CMD to trigger LPU event
1504 */
1505 writel(1, ioc->ioc_regs.hfn_mbox_cmd);
1506 (void) readl(ioc->ioc_regs.hfn_mbox_cmd);
1507 }
1508
1509 static void
1510 bfa_ioc_send_enable(struct bfa_ioc *ioc)
1511 {
1512 struct bfi_ioc_ctrl_req enable_req;
1513 struct timeval tv;
1514
1515 bfi_h2i_set(enable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_ENABLE_REQ,
1516 bfa_ioc_portid(ioc));
1517 enable_req.clscode = htons(ioc->clscode);
1518 do_gettimeofday(&tv);
1519 enable_req.tv_sec = ntohl(tv.tv_sec);
1520 bfa_ioc_mbox_send(ioc, &enable_req, sizeof(struct bfi_ioc_ctrl_req));
1521 }
1522
1523 static void
1524 bfa_ioc_send_disable(struct bfa_ioc *ioc)
1525 {
1526 struct bfi_ioc_ctrl_req disable_req;
1527
1528 bfi_h2i_set(disable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_DISABLE_REQ,
1529 bfa_ioc_portid(ioc));
1530 bfa_ioc_mbox_send(ioc, &disable_req, sizeof(struct bfi_ioc_ctrl_req));
1531 }
1532
1533 static void
1534 bfa_ioc_send_getattr(struct bfa_ioc *ioc)
1535 {
1536 struct bfi_ioc_getattr_req attr_req;
1537
1538 bfi_h2i_set(attr_req.mh, BFI_MC_IOC, BFI_IOC_H2I_GETATTR_REQ,
1539 bfa_ioc_portid(ioc));
1540 bfa_dma_be_addr_set(attr_req.attr_addr, ioc->attr_dma.pa);
1541 bfa_ioc_mbox_send(ioc, &attr_req, sizeof(attr_req));
1542 }
1543
1544 void
1545 bfa_nw_ioc_hb_check(void *cbarg)
1546 {
1547 struct bfa_ioc *ioc = cbarg;
1548 u32 hb_count;
1549
1550 hb_count = readl(ioc->ioc_regs.heartbeat);
1551 if (ioc->hb_count == hb_count) {
1552 bfa_ioc_recover(ioc);
1553 return;
1554 } else {
1555 ioc->hb_count = hb_count;
1556 }
1557
1558 bfa_ioc_mbox_poll(ioc);
1559 mod_timer(&ioc->hb_timer, jiffies +
1560 msecs_to_jiffies(BFA_IOC_HB_TOV));
1561 }
1562
1563 static void
1564 bfa_ioc_hb_monitor(struct bfa_ioc *ioc)
1565 {
1566 ioc->hb_count = readl(ioc->ioc_regs.heartbeat);
1567 mod_timer(&ioc->hb_timer, jiffies +
1568 msecs_to_jiffies(BFA_IOC_HB_TOV));
1569 }
1570
1571 static void
1572 bfa_ioc_hb_stop(struct bfa_ioc *ioc)
1573 {
1574 del_timer(&ioc->hb_timer);
1575 }
1576
1577 /**
1578 * @brief
1579 * Initiate a full firmware download.
1580 */
1581 static void
1582 bfa_ioc_download_fw(struct bfa_ioc *ioc, u32 boot_type,
1583 u32 boot_env)
1584 {
1585 u32 *fwimg;
1586 u32 pgnum;
1587 u32 loff = 0;
1588 u32 chunkno = 0;
1589 u32 i;
1590 u32 asicmode;
1591
1592 /**
1593 * Initialize LMEM first before code download
1594 */
1595 bfa_ioc_lmem_init(ioc);
1596
1597 fwimg = bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc), chunkno);
1598
1599 pgnum = bfa_ioc_smem_pgnum(ioc, loff);
1600
1601 writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1602
1603 for (i = 0; i < bfa_cb_image_get_size(bfa_ioc_asic_gen(ioc)); i++) {
1604 if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {
1605 chunkno = BFA_IOC_FLASH_CHUNK_NO(i);
1606 fwimg = bfa_cb_image_get_chunk(bfa_ioc_asic_gen(ioc),
1607 BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
1608 }
1609
1610 /**
1611 * write smem
1612 */
1613 writel((swab32(fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)])),
1614 ((ioc->ioc_regs.smem_page_start) + (loff)));
1615
1616 loff += sizeof(u32);
1617
1618 /**
1619 * handle page offset wrap around
1620 */
1621 loff = PSS_SMEM_PGOFF(loff);
1622 if (loff == 0) {
1623 pgnum++;
1624 writel(pgnum,
1625 ioc->ioc_regs.host_page_num_fn);
1626 }
1627 }
1628
1629 writel(bfa_ioc_smem_pgnum(ioc, 0),
1630 ioc->ioc_regs.host_page_num_fn);
1631
1632 /*
1633 * Set boot type, env and device mode at the end.
1634 */
1635 asicmode = BFI_FWBOOT_DEVMODE(ioc->asic_gen, ioc->asic_mode,
1636 ioc->port0_mode, ioc->port1_mode);
1637 writel(asicmode, ((ioc->ioc_regs.smem_page_start)
1638 + BFI_FWBOOT_DEVMODE_OFF));
1639 writel(boot_type, ((ioc->ioc_regs.smem_page_start)
1640 + (BFI_FWBOOT_TYPE_OFF)));
1641 writel(boot_env, ((ioc->ioc_regs.smem_page_start)
1642 + (BFI_FWBOOT_ENV_OFF)));
1643 }
1644
1645 static void
1646 bfa_ioc_reset(struct bfa_ioc *ioc, bool force)
1647 {
1648 bfa_ioc_hwinit(ioc, force);
1649 }
1650
1651 /**
1652 * BFA ioc enable reply by firmware
1653 */
1654 static void
1655 bfa_ioc_enable_reply(struct bfa_ioc *ioc, enum bfa_mode port_mode,
1656 u8 cap_bm)
1657 {
1658 struct bfa_iocpf *iocpf = &ioc->iocpf;
1659
1660 ioc->port_mode = ioc->port_mode_cfg = port_mode;
1661 ioc->ad_cap_bm = cap_bm;
1662 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_ENABLE);
1663 }
1664
1665 /**
1666 * @brief
1667 * Update BFA configuration from firmware configuration.
1668 */
1669 static void
1670 bfa_ioc_getattr_reply(struct bfa_ioc *ioc)
1671 {
1672 struct bfi_ioc_attr *attr = ioc->attr;
1673
1674 attr->adapter_prop = ntohl(attr->adapter_prop);
1675 attr->card_type = ntohl(attr->card_type);
1676 attr->maxfrsize = ntohs(attr->maxfrsize);
1677
1678 bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR);
1679 }
1680
1681 /**
1682 * Attach time initialization of mbox logic.
1683 */
1684 static void
1685 bfa_ioc_mbox_attach(struct bfa_ioc *ioc)
1686 {
1687 struct bfa_ioc_mbox_mod *mod = &ioc->mbox_mod;
1688 int mc;
1689
1690 INIT_LIST_HEAD(&mod->cmd_q);
1691 for (mc = 0; mc < BFI_MC_MAX; mc++) {
1692 mod->mbhdlr[mc].cbfn = NULL;
1693 mod->mbhdlr[mc].cbarg = ioc->bfa;
1694 }
1695 }
1696
1697 /**
1698 * Mbox poll timer -- restarts any pending mailbox requests.
1699 */
1700 static void
1701 bfa_ioc_mbox_poll(struct bfa_ioc *ioc)
1702 {
1703 struct bfa_ioc_mbox_mod *mod = &ioc->mbox_mod;
1704 struct bfa_mbox_cmd *cmd;
1705 bfa_mbox_cmd_cbfn_t cbfn;
1706 void *cbarg;
1707 u32 stat;
1708
1709 /**
1710 * If no command pending, do nothing
1711 */
1712 if (list_empty(&mod->cmd_q))
1713 return;
1714
1715 /**
1716 * If previous command is not yet fetched by firmware, do nothing
1717 */
1718 stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
1719 if (stat)
1720 return;
1721
1722 /**
1723 * Enqueue command to firmware.
1724 */
1725 bfa_q_deq(&mod->cmd_q, &cmd);
1726 bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
1727
1728 /**
1729 * Give a callback to the client, indicating that the command is sent
1730 */
1731 if (cmd->cbfn) {
1732 cbfn = cmd->cbfn;
1733 cbarg = cmd->cbarg;
1734 cmd->cbfn = NULL;
1735 cbfn(cbarg);
1736 }
1737 }
1738
1739 /**
1740 * Cleanup any pending requests.
1741 */
1742 static void
1743 bfa_ioc_mbox_flush(struct bfa_ioc *ioc)
1744 {
1745 struct bfa_ioc_mbox_mod *mod = &ioc->mbox_mod;
1746 struct bfa_mbox_cmd *cmd;
1747
1748 while (!list_empty(&mod->cmd_q))
1749 bfa_q_deq(&mod->cmd_q, &cmd);
1750 }
1751
1752 static void
1753 bfa_ioc_fail_notify(struct bfa_ioc *ioc)
1754 {
1755 /**
1756 * Notify driver and common modules registered for notification.
1757 */
1758 ioc->cbfn->hbfail_cbfn(ioc->bfa);
1759 bfa_ioc_event_notify(ioc, BFA_IOC_E_FAILED);
1760 }
1761
1762 static void
1763 bfa_ioc_pf_enabled(struct bfa_ioc *ioc)
1764 {
1765 bfa_fsm_send_event(ioc, IOC_E_ENABLED);
1766 }
1767
1768 static void
1769 bfa_ioc_pf_disabled(struct bfa_ioc *ioc)
1770 {
1771 bfa_fsm_send_event(ioc, IOC_E_DISABLED);
1772 }
1773
1774 static void
1775 bfa_ioc_pf_failed(struct bfa_ioc *ioc)
1776 {
1777 bfa_fsm_send_event(ioc, IOC_E_PFFAILED);
1778 }
1779
1780 static void
1781 bfa_ioc_pf_hwfailed(struct bfa_ioc *ioc)
1782 {
1783 bfa_fsm_send_event(ioc, IOC_E_HWFAILED);
1784 }
1785
1786 static void
1787 bfa_ioc_pf_fwmismatch(struct bfa_ioc *ioc)
1788 {
1789 /**
1790 * Provide enable completion callback and AEN notification.
1791 */
1792 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
1793 }
1794
1795 /**
1796 * IOC public
1797 */
1798 static enum bfa_status
1799 bfa_ioc_pll_init(struct bfa_ioc *ioc)
1800 {
1801 /*
1802 * Hold semaphore so that nobody can access the chip during init.
1803 */
1804 bfa_nw_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg);
1805
1806 bfa_ioc_pll_init_asic(ioc);
1807
1808 ioc->pllinit = true;
1809 /*
1810 * release semaphore.
1811 */
1812 bfa_nw_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
1813
1814 return BFA_STATUS_OK;
1815 }
1816
1817 /**
1818 * Interface used by diag module to do firmware boot with memory test
1819 * as the entry vector.
1820 */
1821 static void
1822 bfa_ioc_boot(struct bfa_ioc *ioc, enum bfi_fwboot_type boot_type,
1823 u32 boot_env)
1824 {
1825 bfa_ioc_stats(ioc, ioc_boots);
1826
1827 if (bfa_ioc_pll_init(ioc) != BFA_STATUS_OK)
1828 return;
1829
1830 /**
1831 * Initialize IOC state of all functions on a chip reset.
1832 */
1833 if (boot_type == BFI_FWBOOT_TYPE_MEMTEST) {
1834 writel(BFI_IOC_MEMTEST, ioc->ioc_regs.ioc_fwstate);
1835 writel(BFI_IOC_MEMTEST, ioc->ioc_regs.alt_ioc_fwstate);
1836 } else {
1837 writel(BFI_IOC_INITING, ioc->ioc_regs.ioc_fwstate);
1838 writel(BFI_IOC_INITING, ioc->ioc_regs.alt_ioc_fwstate);
1839 }
1840
1841 bfa_ioc_msgflush(ioc);
1842 bfa_ioc_download_fw(ioc, boot_type, boot_env);
1843 bfa_ioc_lpu_start(ioc);
1844 }
1845
1846 /**
1847 * Enable/disable IOC failure auto recovery.
1848 */
1849 void
1850 bfa_nw_ioc_auto_recover(bool auto_recover)
1851 {
1852 bfa_nw_auto_recover = auto_recover;
1853 }
1854
1855 static bool
1856 bfa_ioc_msgget(struct bfa_ioc *ioc, void *mbmsg)
1857 {
1858 u32 *msgp = mbmsg;
1859 u32 r32;
1860 int i;
1861
1862 r32 = readl(ioc->ioc_regs.lpu_mbox_cmd);
1863 if ((r32 & 1) == 0)
1864 return false;
1865
1866 /**
1867 * read the MBOX msg
1868 */
1869 for (i = 0; i < (sizeof(union bfi_ioc_i2h_msg_u) / sizeof(u32));
1870 i++) {
1871 r32 = readl(ioc->ioc_regs.lpu_mbox +
1872 i * sizeof(u32));
1873 msgp[i] = htonl(r32);
1874 }
1875
1876 /**
1877 * turn off mailbox interrupt by clearing mailbox status
1878 */
1879 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
1880 readl(ioc->ioc_regs.lpu_mbox_cmd);
1881
1882 return true;
1883 }
1884
1885 static void
1886 bfa_ioc_isr(struct bfa_ioc *ioc, struct bfi_mbmsg *m)
1887 {
1888 union bfi_ioc_i2h_msg_u *msg;
1889 struct bfa_iocpf *iocpf = &ioc->iocpf;
1890
1891 msg = (union bfi_ioc_i2h_msg_u *) m;
1892
1893 bfa_ioc_stats(ioc, ioc_isrs);
1894
1895 switch (msg->mh.msg_id) {
1896 case BFI_IOC_I2H_HBEAT:
1897 break;
1898
1899 case BFI_IOC_I2H_ENABLE_REPLY:
1900 bfa_ioc_enable_reply(ioc,
1901 (enum bfa_mode)msg->fw_event.port_mode,
1902 msg->fw_event.cap_bm);
1903 break;
1904
1905 case BFI_IOC_I2H_DISABLE_REPLY:
1906 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_DISABLE);
1907 break;
1908
1909 case BFI_IOC_I2H_GETATTR_REPLY:
1910 bfa_ioc_getattr_reply(ioc);
1911 break;
1912
1913 default:
1914 BUG_ON(1);
1915 }
1916 }
1917
1918 /**
1919 * IOC attach time initialization and setup.
1920 *
1921 * @param[in] ioc memory for IOC
1922 * @param[in] bfa driver instance structure
1923 */
1924 void
1925 bfa_nw_ioc_attach(struct bfa_ioc *ioc, void *bfa, struct bfa_ioc_cbfn *cbfn)
1926 {
1927 ioc->bfa = bfa;
1928 ioc->cbfn = cbfn;
1929 ioc->fcmode = false;
1930 ioc->pllinit = false;
1931 ioc->dbg_fwsave_once = true;
1932 ioc->iocpf.ioc = ioc;
1933
1934 bfa_ioc_mbox_attach(ioc);
1935 INIT_LIST_HEAD(&ioc->notify_q);
1936
1937 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
1938 bfa_fsm_send_event(ioc, IOC_E_RESET);
1939 }
1940
1941 /**
1942 * Driver detach time IOC cleanup.
1943 */
1944 void
1945 bfa_nw_ioc_detach(struct bfa_ioc *ioc)
1946 {
1947 bfa_fsm_send_event(ioc, IOC_E_DETACH);
1948
1949 /* Done with detach, empty the notify_q. */
1950 INIT_LIST_HEAD(&ioc->notify_q);
1951 }
1952
1953 /**
1954 * Setup IOC PCI properties.
1955 *
1956 * @param[in] pcidev PCI device information for this IOC
1957 */
1958 void
1959 bfa_nw_ioc_pci_init(struct bfa_ioc *ioc, struct bfa_pcidev *pcidev,
1960 enum bfi_pcifn_class clscode)
1961 {
1962 ioc->clscode = clscode;
1963 ioc->pcidev = *pcidev;
1964
1965 /**
1966 * Initialize IOC and device personality
1967 */
1968 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_FC;
1969 ioc->asic_mode = BFI_ASIC_MODE_FC;
1970
1971 switch (pcidev->device_id) {
1972 case PCI_DEVICE_ID_BROCADE_CT:
1973 ioc->asic_gen = BFI_ASIC_GEN_CT;
1974 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_ETH;
1975 ioc->asic_mode = BFI_ASIC_MODE_ETH;
1976 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_CNA;
1977 ioc->ad_cap_bm = BFA_CM_CNA;
1978 break;
1979
1980 case BFA_PCI_DEVICE_ID_CT2:
1981 ioc->asic_gen = BFI_ASIC_GEN_CT2;
1982 if (clscode == BFI_PCIFN_CLASS_FC &&
1983 pcidev->ssid == BFA_PCI_CT2_SSID_FC) {
1984 ioc->asic_mode = BFI_ASIC_MODE_FC16;
1985 ioc->fcmode = true;
1986 ioc->port_mode = ioc->port_mode_cfg = BFA_MODE_HBA;
1987 ioc->ad_cap_bm = BFA_CM_HBA;
1988 } else {
1989 ioc->port0_mode = ioc->port1_mode = BFI_PORT_MODE_ETH;
1990 ioc->asic_mode = BFI_ASIC_MODE_ETH;
1991 if (pcidev->ssid == BFA_PCI_CT2_SSID_FCoE) {
1992 ioc->port_mode =
1993 ioc->port_mode_cfg = BFA_MODE_CNA;
1994 ioc->ad_cap_bm = BFA_CM_CNA;
1995 } else {
1996 ioc->port_mode =
1997 ioc->port_mode_cfg = BFA_MODE_NIC;
1998 ioc->ad_cap_bm = BFA_CM_NIC;
1999 }
2000 }
2001 break;
2002
2003 default:
2004 BUG_ON(1);
2005 }
2006
2007 /**
2008 * Set asic specific interfaces.
2009 */
2010 if (ioc->asic_gen == BFI_ASIC_GEN_CT)
2011 bfa_nw_ioc_set_ct_hwif(ioc);
2012 else
2013 bfa_nw_ioc_set_ct2_hwif(ioc);
2014
2015 bfa_ioc_map_port(ioc);
2016 bfa_ioc_reg_init(ioc);
2017 }
2018
2019 /**
2020 * Initialize IOC dma memory
2021 *
2022 * @param[in] dm_kva kernel virtual address of IOC dma memory
2023 * @param[in] dm_pa physical address of IOC dma memory
2024 */
2025 void
2026 bfa_nw_ioc_mem_claim(struct bfa_ioc *ioc, u8 *dm_kva, u64 dm_pa)
2027 {
2028 /**
2029 * dma memory for firmware attribute
2030 */
2031 ioc->attr_dma.kva = dm_kva;
2032 ioc->attr_dma.pa = dm_pa;
2033 ioc->attr = (struct bfi_ioc_attr *) dm_kva;
2034 }
2035
2036 /**
2037 * Return size of dma memory required.
2038 */
2039 u32
2040 bfa_nw_ioc_meminfo(void)
2041 {
2042 return roundup(sizeof(struct bfi_ioc_attr), BFA_DMA_ALIGN_SZ);
2043 }
2044
2045 void
2046 bfa_nw_ioc_enable(struct bfa_ioc *ioc)
2047 {
2048 bfa_ioc_stats(ioc, ioc_enables);
2049 ioc->dbg_fwsave_once = true;
2050
2051 bfa_fsm_send_event(ioc, IOC_E_ENABLE);
2052 }
2053
2054 void
2055 bfa_nw_ioc_disable(struct bfa_ioc *ioc)
2056 {
2057 bfa_ioc_stats(ioc, ioc_disables);
2058 bfa_fsm_send_event(ioc, IOC_E_DISABLE);
2059 }
2060
2061 static u32
2062 bfa_ioc_smem_pgnum(struct bfa_ioc *ioc, u32 fmaddr)
2063 {
2064 return PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, fmaddr);
2065 }
2066
2067 /**
2068 * Register mailbox message handler function, to be called by common modules
2069 */
2070 void
2071 bfa_nw_ioc_mbox_regisr(struct bfa_ioc *ioc, enum bfi_mclass mc,
2072 bfa_ioc_mbox_mcfunc_t cbfn, void *cbarg)
2073 {
2074 struct bfa_ioc_mbox_mod *mod = &ioc->mbox_mod;
2075
2076 mod->mbhdlr[mc].cbfn = cbfn;
2077 mod->mbhdlr[mc].cbarg = cbarg;
2078 }
2079
2080 /**
2081 * Queue a mailbox command request to firmware. Waits if mailbox is busy.
2082 * Responsibility of caller to serialize
2083 *
2084 * @param[in] ioc IOC instance
2085 * @param[i] cmd Mailbox command
2086 */
2087 bool
2088 bfa_nw_ioc_mbox_queue(struct bfa_ioc *ioc, struct bfa_mbox_cmd *cmd,
2089 bfa_mbox_cmd_cbfn_t cbfn, void *cbarg)
2090 {
2091 struct bfa_ioc_mbox_mod *mod = &ioc->mbox_mod;
2092 u32 stat;
2093
2094 cmd->cbfn = cbfn;
2095 cmd->cbarg = cbarg;
2096
2097 /**
2098 * If a previous command is pending, queue new command
2099 */
2100 if (!list_empty(&mod->cmd_q)) {
2101 list_add_tail(&cmd->qe, &mod->cmd_q);
2102 return true;
2103 }
2104
2105 /**
2106 * If mailbox is busy, queue command for poll timer
2107 */
2108 stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
2109 if (stat) {
2110 list_add_tail(&cmd->qe, &mod->cmd_q);
2111 return true;
2112 }
2113
2114 /**
2115 * mailbox is free -- queue command to firmware
2116 */
2117 bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
2118
2119 return false;
2120 }
2121
2122 /**
2123 * Handle mailbox interrupts
2124 */
2125 void
2126 bfa_nw_ioc_mbox_isr(struct bfa_ioc *ioc)
2127 {
2128 struct bfa_ioc_mbox_mod *mod = &ioc->mbox_mod;
2129 struct bfi_mbmsg m;
2130 int mc;
2131
2132 if (bfa_ioc_msgget(ioc, &m)) {
2133 /**
2134 * Treat IOC message class as special.
2135 */
2136 mc = m.mh.msg_class;
2137 if (mc == BFI_MC_IOC) {
2138 bfa_ioc_isr(ioc, &m);
2139 return;
2140 }
2141
2142 if ((mc >= BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL))
2143 return;
2144
2145 mod->mbhdlr[mc].cbfn(mod->mbhdlr[mc].cbarg, &m);
2146 }
2147
2148 bfa_ioc_lpu_read_stat(ioc);
2149
2150 /**
2151 * Try to send pending mailbox commands
2152 */
2153 bfa_ioc_mbox_poll(ioc);
2154 }
2155
2156 void
2157 bfa_nw_ioc_error_isr(struct bfa_ioc *ioc)
2158 {
2159 bfa_ioc_stats(ioc, ioc_hbfails);
2160 bfa_ioc_stats_hb_count(ioc, ioc->hb_count);
2161 bfa_fsm_send_event(ioc, IOC_E_HWERROR);
2162 }
2163
2164 /**
2165 * return true if IOC is disabled
2166 */
2167 bool
2168 bfa_nw_ioc_is_disabled(struct bfa_ioc *ioc)
2169 {
2170 return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling) ||
2171 bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
2172 }
2173
2174 /**
2175 * Add to IOC heartbeat failure notification queue. To be used by common
2176 * modules such as cee, port, diag.
2177 */
2178 void
2179 bfa_nw_ioc_notify_register(struct bfa_ioc *ioc,
2180 struct bfa_ioc_notify *notify)
2181 {
2182 list_add_tail(&notify->qe, &ioc->notify_q);
2183 }
2184
2185 #define BFA_MFG_NAME "Brocade"
2186 static void
2187 bfa_ioc_get_adapter_attr(struct bfa_ioc *ioc,
2188 struct bfa_adapter_attr *ad_attr)
2189 {
2190 struct bfi_ioc_attr *ioc_attr;
2191
2192 ioc_attr = ioc->attr;
2193
2194 bfa_ioc_get_adapter_serial_num(ioc, ad_attr->serial_num);
2195 bfa_ioc_get_adapter_fw_ver(ioc, ad_attr->fw_ver);
2196 bfa_ioc_get_adapter_optrom_ver(ioc, ad_attr->optrom_ver);
2197 bfa_ioc_get_adapter_manufacturer(ioc, ad_attr->manufacturer);
2198 memcpy(&ad_attr->vpd, &ioc_attr->vpd,
2199 sizeof(struct bfa_mfg_vpd));
2200
2201 ad_attr->nports = bfa_ioc_get_nports(ioc);
2202 ad_attr->max_speed = bfa_ioc_speed_sup(ioc);
2203
2204 bfa_ioc_get_adapter_model(ioc, ad_attr->model);
2205 /* For now, model descr uses same model string */
2206 bfa_ioc_get_adapter_model(ioc, ad_attr->model_descr);
2207
2208 ad_attr->card_type = ioc_attr->card_type;
2209 ad_attr->is_mezz = bfa_mfg_is_mezz(ioc_attr->card_type);
2210
2211 if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))
2212 ad_attr->prototype = 1;
2213 else
2214 ad_attr->prototype = 0;
2215
2216 ad_attr->pwwn = bfa_ioc_get_pwwn(ioc);
2217 ad_attr->mac = bfa_nw_ioc_get_mac(ioc);
2218
2219 ad_attr->pcie_gen = ioc_attr->pcie_gen;
2220 ad_attr->pcie_lanes = ioc_attr->pcie_lanes;
2221 ad_attr->pcie_lanes_orig = ioc_attr->pcie_lanes_orig;
2222 ad_attr->asic_rev = ioc_attr->asic_rev;
2223
2224 bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);
2225 }
2226
2227 static enum bfa_ioc_type
2228 bfa_ioc_get_type(struct bfa_ioc *ioc)
2229 {
2230 if (ioc->clscode == BFI_PCIFN_CLASS_ETH)
2231 return BFA_IOC_TYPE_LL;
2232
2233 BUG_ON(!(ioc->clscode == BFI_PCIFN_CLASS_FC));
2234
2235 return (ioc->attr->port_mode == BFI_PORT_MODE_FC)
2236 ? BFA_IOC_TYPE_FC : BFA_IOC_TYPE_FCoE;
2237 }
2238
2239 static void
2240 bfa_ioc_get_adapter_serial_num(struct bfa_ioc *ioc, char *serial_num)
2241 {
2242 memset(serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);
2243 memcpy(serial_num,
2244 (void *)ioc->attr->brcd_serialnum,
2245 BFA_ADAPTER_SERIAL_NUM_LEN);
2246 }
2247
2248 static void
2249 bfa_ioc_get_adapter_fw_ver(struct bfa_ioc *ioc, char *fw_ver)
2250 {
2251 memset(fw_ver, 0, BFA_VERSION_LEN);
2252 memcpy(fw_ver, ioc->attr->fw_version, BFA_VERSION_LEN);
2253 }
2254
2255 static void
2256 bfa_ioc_get_pci_chip_rev(struct bfa_ioc *ioc, char *chip_rev)
2257 {
2258 BUG_ON(!(chip_rev));
2259
2260 memset(chip_rev, 0, BFA_IOC_CHIP_REV_LEN);
2261
2262 chip_rev[0] = 'R';
2263 chip_rev[1] = 'e';
2264 chip_rev[2] = 'v';
2265 chip_rev[3] = '-';
2266 chip_rev[4] = ioc->attr->asic_rev;
2267 chip_rev[5] = '\0';
2268 }
2269
2270 static void
2271 bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc *ioc, char *optrom_ver)
2272 {
2273 memset(optrom_ver, 0, BFA_VERSION_LEN);
2274 memcpy(optrom_ver, ioc->attr->optrom_version,
2275 BFA_VERSION_LEN);
2276 }
2277
2278 static void
2279 bfa_ioc_get_adapter_manufacturer(struct bfa_ioc *ioc, char *manufacturer)
2280 {
2281 memset(manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);
2282 memcpy(manufacturer, BFA_MFG_NAME, BFA_ADAPTER_MFG_NAME_LEN);
2283 }
2284
2285 static void
2286 bfa_ioc_get_adapter_model(struct bfa_ioc *ioc, char *model)
2287 {
2288 struct bfi_ioc_attr *ioc_attr;
2289
2290 BUG_ON(!(model));
2291 memset(model, 0, BFA_ADAPTER_MODEL_NAME_LEN);
2292
2293 ioc_attr = ioc->attr;
2294
2295 /**
2296 * model name
2297 */
2298 snprintf(model, BFA_ADAPTER_MODEL_NAME_LEN, "%s-%u",
2299 BFA_MFG_NAME, ioc_attr->card_type);
2300 }
2301
2302 static enum bfa_ioc_state
2303 bfa_ioc_get_state(struct bfa_ioc *ioc)
2304 {
2305 enum bfa_iocpf_state iocpf_st;
2306 enum bfa_ioc_state ioc_st = bfa_sm_to_state(ioc_sm_table, ioc->fsm);
2307
2308 if (ioc_st == BFA_IOC_ENABLING ||
2309 ioc_st == BFA_IOC_FAIL || ioc_st == BFA_IOC_INITFAIL) {
2310
2311 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm);
2312
2313 switch (iocpf_st) {
2314 case BFA_IOCPF_SEMWAIT:
2315 ioc_st = BFA_IOC_SEMWAIT;
2316 break;
2317
2318 case BFA_IOCPF_HWINIT:
2319 ioc_st = BFA_IOC_HWINIT;
2320 break;
2321
2322 case BFA_IOCPF_FWMISMATCH:
2323 ioc_st = BFA_IOC_FWMISMATCH;
2324 break;
2325
2326 case BFA_IOCPF_FAIL:
2327 ioc_st = BFA_IOC_FAIL;
2328 break;
2329
2330 case BFA_IOCPF_INITFAIL:
2331 ioc_st = BFA_IOC_INITFAIL;
2332 break;
2333
2334 default:
2335 break;
2336 }
2337 }
2338 return ioc_st;
2339 }
2340
2341 void
2342 bfa_nw_ioc_get_attr(struct bfa_ioc *ioc, struct bfa_ioc_attr *ioc_attr)
2343 {
2344 memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr));
2345
2346 ioc_attr->state = bfa_ioc_get_state(ioc);
2347 ioc_attr->port_id = ioc->port_id;
2348 ioc_attr->port_mode = ioc->port_mode;
2349
2350 ioc_attr->port_mode_cfg = ioc->port_mode_cfg;
2351 ioc_attr->cap_bm = ioc->ad_cap_bm;
2352
2353 ioc_attr->ioc_type = bfa_ioc_get_type(ioc);
2354
2355 bfa_ioc_get_adapter_attr(ioc, &ioc_attr->adapter_attr);
2356
2357 ioc_attr->pci_attr.device_id = ioc->pcidev.device_id;
2358 ioc_attr->pci_attr.pcifn = ioc->pcidev.pci_func;
2359 bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
2360 }
2361
2362 /**
2363 * WWN public
2364 */
2365 static u64
2366 bfa_ioc_get_pwwn(struct bfa_ioc *ioc)
2367 {
2368 return ioc->attr->pwwn;
2369 }
2370
2371 mac_t
2372 bfa_nw_ioc_get_mac(struct bfa_ioc *ioc)
2373 {
2374 return ioc->attr->mac;
2375 }
2376
2377 /**
2378 * Firmware failure detected. Start recovery actions.
2379 */
2380 static void
2381 bfa_ioc_recover(struct bfa_ioc *ioc)
2382 {
2383 pr_crit("Heart Beat of IOC has failed\n");
2384 bfa_ioc_stats(ioc, ioc_hbfails);
2385 bfa_ioc_stats_hb_count(ioc, ioc->hb_count);
2386 bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
2387 }
2388
2389 static void
2390 bfa_ioc_check_attr_wwns(struct bfa_ioc *ioc)
2391 {
2392 if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_LL)
2393 return;
2394 }
2395
2396 /**
2397 * @dg hal_iocpf_pvt BFA IOC PF private functions
2398 * @{
2399 */
2400
2401 static void
2402 bfa_iocpf_enable(struct bfa_ioc *ioc)
2403 {
2404 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_ENABLE);
2405 }
2406
2407 static void
2408 bfa_iocpf_disable(struct bfa_ioc *ioc)
2409 {
2410 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_DISABLE);
2411 }
2412
2413 static void
2414 bfa_iocpf_fail(struct bfa_ioc *ioc)
2415 {
2416 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
2417 }
2418
2419 static void
2420 bfa_iocpf_initfail(struct bfa_ioc *ioc)
2421 {
2422 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
2423 }
2424
2425 static void
2426 bfa_iocpf_getattrfail(struct bfa_ioc *ioc)
2427 {
2428 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
2429 }
2430
2431 static void
2432 bfa_iocpf_stop(struct bfa_ioc *ioc)
2433 {
2434 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
2435 }
2436
2437 void
2438 bfa_nw_iocpf_timeout(void *ioc_arg)
2439 {
2440 struct bfa_ioc *ioc = (struct bfa_ioc *) ioc_arg;
2441 enum bfa_iocpf_state iocpf_st;
2442
2443 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm);
2444
2445 if (iocpf_st == BFA_IOCPF_HWINIT)
2446 bfa_ioc_poll_fwinit(ioc);
2447 else
2448 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_TIMEOUT);
2449 }
2450
2451 void
2452 bfa_nw_iocpf_sem_timeout(void *ioc_arg)
2453 {
2454 struct bfa_ioc *ioc = (struct bfa_ioc *) ioc_arg;
2455
2456 bfa_ioc_hw_sem_get(ioc);
2457 }
2458
2459 static void
2460 bfa_ioc_poll_fwinit(struct bfa_ioc *ioc)
2461 {
2462 u32 fwstate = readl(ioc->ioc_regs.ioc_fwstate);
2463
2464 if (fwstate == BFI_IOC_DISABLED) {
2465 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FWREADY);
2466 return;
2467 }
2468
2469 if (ioc->iocpf.poll_time >= BFA_IOC_TOV) {
2470 bfa_nw_iocpf_timeout(ioc);
2471 } else {
2472 ioc->iocpf.poll_time += BFA_IOC_POLL_TOV;
2473 mod_timer(&ioc->iocpf_timer, jiffies +
2474 msecs_to_jiffies(BFA_IOC_POLL_TOV));
2475 }
2476 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree