Linux 2.6.37-rc6
[linux-2.6.git] / drivers / scsi / bfa / bfa_ioc.c
1 /*
2  * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
3  * All rights reserved
4  * www.brocade.com
5  *
6  * Linux driver for Brocade Fibre Channel Host Bus Adapter.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License (GPL) Version 2 as
10  * published by the Free Software Foundation
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  */
17
18 #include "bfa_ioc.h"
19 #include "bfi_ctreg.h"
20 #include "bfa_defs.h"
21 #include "bfa_defs_svc.h"
22 #include "bfad_drv.h"
23
24 BFA_TRC_FILE(CNA, IOC);
25
26 /*
27  * IOC local definitions
28  */
29 #define BFA_IOC_TOV             3000    /* msecs */
30 #define BFA_IOC_HWSEM_TOV       500     /* msecs */
31 #define BFA_IOC_HB_TOV          500     /* msecs */
32 #define BFA_IOC_HWINIT_MAX      2
33 #define BFA_IOC_TOV_RECOVER      BFA_IOC_HB_TOV
34
35 #define bfa_ioc_timer_start(__ioc)                                      \
36         bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer,        \
37                         bfa_ioc_timeout, (__ioc), BFA_IOC_TOV)
38 #define bfa_ioc_timer_stop(__ioc)   bfa_timer_stop(&(__ioc)->ioc_timer)
39
40 #define bfa_hb_timer_start(__ioc)                                       \
41         bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->hb_timer,         \
42                         bfa_ioc_hb_check, (__ioc), BFA_IOC_HB_TOV)
43 #define bfa_hb_timer_stop(__ioc)        bfa_timer_stop(&(__ioc)->hb_timer)
44
45 #define BFA_DBG_FWTRC_ENTS      (BFI_IOC_TRC_ENTS)
46 #define BFA_DBG_FWTRC_LEN                                       \
47         (BFA_DBG_FWTRC_ENTS * sizeof(struct bfa_trc_s) +        \
48          (sizeof(struct bfa_trc_mod_s) -                        \
49           BFA_TRC_MAX * sizeof(struct bfa_trc_s)))
50 #define BFA_DBG_FWTRC_OFF(_fn)  (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))
51
52 /*
53  * Asic specific macros : see bfa_hw_cb.c and bfa_hw_ct.c for details.
54  */
55
56 #define bfa_ioc_firmware_lock(__ioc)                    \
57                         ((__ioc)->ioc_hwif->ioc_firmware_lock(__ioc))
58 #define bfa_ioc_firmware_unlock(__ioc)                  \
59                         ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
60 #define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
61 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
62 #define bfa_ioc_notify_hbfail(__ioc)                    \
63                         ((__ioc)->ioc_hwif->ioc_notify_hbfail(__ioc))
64
65 #ifdef BFA_IOC_IS_UEFI
66 #define bfa_ioc_is_bios_optrom(__ioc) (0)
67 #define bfa_ioc_is_uefi(__ioc) BFA_IOC_IS_UEFI
68 #else
69 #define bfa_ioc_is_bios_optrom(__ioc)   \
70         (bfa_cb_image_get_size(BFA_IOC_FWIMG_TYPE(__ioc)) < BFA_IOC_FWIMG_MINSZ)
71 #define bfa_ioc_is_uefi(__ioc) (0)
72 #endif
73
74 #define bfa_ioc_mbox_cmd_pending(__ioc)         \
75                         (!list_empty(&((__ioc)->mbox_mod.cmd_q)) || \
76                         readl((__ioc)->ioc_regs.hfn_mbox_cmd))
77
78 bfa_boolean_t bfa_auto_recover = BFA_TRUE;
79
80 /*
81  * forward declarations
82  */
83 static void bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc);
84 static void bfa_ioc_hw_sem_get_cancel(struct bfa_ioc_s *ioc);
85 static void bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force);
86 static void bfa_ioc_timeout(void *ioc);
87 static void bfa_ioc_send_enable(struct bfa_ioc_s *ioc);
88 static void bfa_ioc_send_disable(struct bfa_ioc_s *ioc);
89 static void bfa_ioc_send_getattr(struct bfa_ioc_s *ioc);
90 static void bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc);
91 static void bfa_ioc_hb_stop(struct bfa_ioc_s *ioc);
92 static void bfa_ioc_reset(struct bfa_ioc_s *ioc, bfa_boolean_t force);
93 static void bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
94 static void bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc);
95 static void bfa_ioc_recover(struct bfa_ioc_s *ioc);
96 static void bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc);
97 static void bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
98 static void bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
99 static void bfa_ioc_pf_enabled(struct bfa_ioc_s *ioc);
100 static void bfa_ioc_pf_disabled(struct bfa_ioc_s *ioc);
101 static void bfa_ioc_pf_failed(struct bfa_ioc_s *ioc);
102 static void bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc);
103
104 /*
105  *  hal_ioc_sm
106  */
107
108 /*
109  * IOC state machine definitions/declarations
110  */
111 enum ioc_event {
112         IOC_E_RESET             = 1,    /*  IOC reset request           */
113         IOC_E_ENABLE            = 2,    /*  IOC enable request          */
114         IOC_E_DISABLE           = 3,    /*  IOC disable request */
115         IOC_E_DETACH            = 4,    /*  driver detach cleanup       */
116         IOC_E_ENABLED           = 5,    /*  f/w enabled         */
117         IOC_E_FWRSP_GETATTR     = 6,    /*  IOC get attribute response  */
118         IOC_E_DISABLED          = 7,    /*  f/w disabled                */
119         IOC_E_FAILED            = 8,    /*  failure notice by iocpf sm  */
120         IOC_E_HBFAIL            = 9,    /*  heartbeat failure           */
121         IOC_E_HWERROR           = 10,   /*  hardware error interrupt    */
122         IOC_E_TIMEOUT           = 11,   /*  timeout                     */
123 };
124
125 bfa_fsm_state_decl(bfa_ioc, uninit, struct bfa_ioc_s, enum ioc_event);
126 bfa_fsm_state_decl(bfa_ioc, reset, struct bfa_ioc_s, enum ioc_event);
127 bfa_fsm_state_decl(bfa_ioc, enabling, struct bfa_ioc_s, enum ioc_event);
128 bfa_fsm_state_decl(bfa_ioc, getattr, struct bfa_ioc_s, enum ioc_event);
129 bfa_fsm_state_decl(bfa_ioc, op, struct bfa_ioc_s, enum ioc_event);
130 bfa_fsm_state_decl(bfa_ioc, initfail, struct bfa_ioc_s, enum ioc_event);
131 bfa_fsm_state_decl(bfa_ioc, fail, struct bfa_ioc_s, enum ioc_event);
132 bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event);
133 bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event);
134
135 static struct bfa_sm_table_s ioc_sm_table[] = {
136         {BFA_SM(bfa_ioc_sm_uninit), BFA_IOC_UNINIT},
137         {BFA_SM(bfa_ioc_sm_reset), BFA_IOC_RESET},
138         {BFA_SM(bfa_ioc_sm_enabling), BFA_IOC_ENABLING},
139         {BFA_SM(bfa_ioc_sm_getattr), BFA_IOC_GETATTR},
140         {BFA_SM(bfa_ioc_sm_op), BFA_IOC_OPERATIONAL},
141         {BFA_SM(bfa_ioc_sm_initfail), BFA_IOC_INITFAIL},
142         {BFA_SM(bfa_ioc_sm_fail), BFA_IOC_FAIL},
143         {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
144         {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
145 };
146
147 /*
148  * IOCPF state machine definitions/declarations
149  */
150
151 #define bfa_iocpf_timer_start(__ioc)                                    \
152         bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer,        \
153                         bfa_iocpf_timeout, (__ioc), BFA_IOC_TOV)
154 #define bfa_iocpf_timer_stop(__ioc)     bfa_timer_stop(&(__ioc)->ioc_timer)
155
156 #define bfa_iocpf_recovery_timer_start(__ioc)                           \
157         bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer,        \
158                         bfa_iocpf_timeout, (__ioc), BFA_IOC_TOV_RECOVER)
159
160 #define bfa_sem_timer_start(__ioc)                                      \
161         bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->sem_timer,        \
162                         bfa_iocpf_sem_timeout, (__ioc), BFA_IOC_HWSEM_TOV)
163 #define bfa_sem_timer_stop(__ioc)       bfa_timer_stop(&(__ioc)->sem_timer)
164
165 /*
166  * Forward declareations for iocpf state machine
167  */
168 static void bfa_iocpf_enable(struct bfa_ioc_s *ioc);
169 static void bfa_iocpf_disable(struct bfa_ioc_s *ioc);
170 static void bfa_iocpf_fail(struct bfa_ioc_s *ioc);
171 static void bfa_iocpf_initfail(struct bfa_ioc_s *ioc);
172 static void bfa_iocpf_getattrfail(struct bfa_ioc_s *ioc);
173 static void bfa_iocpf_stop(struct bfa_ioc_s *ioc);
174 static void bfa_iocpf_timeout(void *ioc_arg);
175 static void bfa_iocpf_sem_timeout(void *ioc_arg);
176
177 /*
178  * IOCPF state machine events
179  */
180 enum iocpf_event {
181         IOCPF_E_ENABLE          = 1,    /*  IOCPF enable request        */
182         IOCPF_E_DISABLE         = 2,    /*  IOCPF disable request       */
183         IOCPF_E_STOP            = 3,    /*  stop on driver detach       */
184         IOCPF_E_FWREADY         = 4,    /*  f/w initialization done     */
185         IOCPF_E_FWRSP_ENABLE    = 5,    /*  enable f/w response */
186         IOCPF_E_FWRSP_DISABLE   = 6,    /*  disable f/w response        */
187         IOCPF_E_FAIL            = 7,    /*  failure notice by ioc sm    */
188         IOCPF_E_INITFAIL        = 8,    /*  init fail notice by ioc sm  */
189         IOCPF_E_GETATTRFAIL     = 9,    /*  init fail notice by ioc sm  */
190         IOCPF_E_SEMLOCKED       = 10,   /*  h/w semaphore is locked     */
191         IOCPF_E_TIMEOUT         = 11,   /*  f/w response timeout        */
192 };
193
194 /*
195  * IOCPF states
196  */
197 enum bfa_iocpf_state {
198         BFA_IOCPF_RESET         = 1,    /*  IOC is in reset state */
199         BFA_IOCPF_SEMWAIT       = 2,    /*  Waiting for IOC h/w semaphore */
200         BFA_IOCPF_HWINIT        = 3,    /*  IOC h/w is being initialized */
201         BFA_IOCPF_READY         = 4,    /*  IOCPF is initialized */
202         BFA_IOCPF_INITFAIL      = 5,    /*  IOCPF failed */
203         BFA_IOCPF_FAIL          = 6,    /*  IOCPF failed */
204         BFA_IOCPF_DISABLING     = 7,    /*  IOCPF is being disabled */
205         BFA_IOCPF_DISABLED      = 8,    /*  IOCPF is disabled */
206         BFA_IOCPF_FWMISMATCH    = 9,    /*  IOC f/w different from drivers */
207 };
208
209 bfa_fsm_state_decl(bfa_iocpf, reset, struct bfa_iocpf_s, enum iocpf_event);
210 bfa_fsm_state_decl(bfa_iocpf, fwcheck, struct bfa_iocpf_s, enum iocpf_event);
211 bfa_fsm_state_decl(bfa_iocpf, mismatch, struct bfa_iocpf_s, enum iocpf_event);
212 bfa_fsm_state_decl(bfa_iocpf, semwait, struct bfa_iocpf_s, enum iocpf_event);
213 bfa_fsm_state_decl(bfa_iocpf, hwinit, struct bfa_iocpf_s, enum iocpf_event);
214 bfa_fsm_state_decl(bfa_iocpf, enabling, struct bfa_iocpf_s, enum iocpf_event);
215 bfa_fsm_state_decl(bfa_iocpf, ready, struct bfa_iocpf_s, enum iocpf_event);
216 bfa_fsm_state_decl(bfa_iocpf, initfail, struct bfa_iocpf_s, enum iocpf_event);
217 bfa_fsm_state_decl(bfa_iocpf, fail, struct bfa_iocpf_s, enum iocpf_event);
218 bfa_fsm_state_decl(bfa_iocpf, disabling, struct bfa_iocpf_s, enum iocpf_event);
219 bfa_fsm_state_decl(bfa_iocpf, 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), BFA_IOCPF_INITFAIL},
230         {BFA_SM(bfa_iocpf_sm_fail), BFA_IOCPF_FAIL},
231         {BFA_SM(bfa_iocpf_sm_disabling), BFA_IOCPF_DISABLING},
232         {BFA_SM(bfa_iocpf_sm_disabled), BFA_IOCPF_DISABLED},
233 };
234
235 /*
236  * IOC State Machine
237  */
238
239 /*
240  * Beginning state. IOC uninit state.
241  */
242
243 static void
244 bfa_ioc_sm_uninit_entry(struct bfa_ioc_s *ioc)
245 {
246 }
247
248 /*
249  * IOC is in uninit state.
250  */
251 static void
252 bfa_ioc_sm_uninit(struct bfa_ioc_s *ioc, enum ioc_event event)
253 {
254         bfa_trc(ioc, event);
255
256         switch (event) {
257         case IOC_E_RESET:
258                 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
259                 break;
260
261         default:
262                 bfa_sm_fault(ioc, event);
263         }
264 }
265 /*
266  * Reset entry actions -- initialize state machine
267  */
268 static void
269 bfa_ioc_sm_reset_entry(struct bfa_ioc_s *ioc)
270 {
271         bfa_fsm_set_state(&ioc->iocpf, bfa_iocpf_sm_reset);
272 }
273
274 /*
275  * IOC is in reset state.
276  */
277 static void
278 bfa_ioc_sm_reset(struct bfa_ioc_s *ioc, enum ioc_event event)
279 {
280         bfa_trc(ioc, event);
281
282         switch (event) {
283         case IOC_E_ENABLE:
284                 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
285                 break;
286
287         case IOC_E_DISABLE:
288                 bfa_ioc_disable_comp(ioc);
289                 break;
290
291         case IOC_E_DETACH:
292                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
293                 break;
294
295         default:
296                 bfa_sm_fault(ioc, event);
297         }
298 }
299
300
301 static void
302 bfa_ioc_sm_enabling_entry(struct bfa_ioc_s *ioc)
303 {
304         bfa_iocpf_enable(ioc);
305 }
306
307 /*
308  * Host IOC function is being enabled, awaiting response from firmware.
309  * Semaphore is acquired.
310  */
311 static void
312 bfa_ioc_sm_enabling(struct bfa_ioc_s *ioc, enum ioc_event event)
313 {
314         bfa_trc(ioc, event);
315
316         switch (event) {
317         case IOC_E_ENABLED:
318                 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
319                 break;
320
321         case IOC_E_FAILED:
322                 bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
323                 break;
324
325         case IOC_E_HWERROR:
326                 bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
327                 bfa_iocpf_initfail(ioc);
328                 break;
329
330         case IOC_E_DISABLE:
331                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
332                 break;
333
334         case IOC_E_DETACH:
335                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
336                 bfa_iocpf_stop(ioc);
337                 break;
338
339         case IOC_E_ENABLE:
340                 break;
341
342         default:
343                 bfa_sm_fault(ioc, event);
344         }
345 }
346
347
348 static void
349 bfa_ioc_sm_getattr_entry(struct bfa_ioc_s *ioc)
350 {
351         bfa_ioc_timer_start(ioc);
352         bfa_ioc_send_getattr(ioc);
353 }
354
355 /*
356  * IOC configuration in progress. Timer is active.
357  */
358 static void
359 bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
360 {
361         bfa_trc(ioc, event);
362
363         switch (event) {
364         case IOC_E_FWRSP_GETATTR:
365                 bfa_ioc_timer_stop(ioc);
366                 bfa_ioc_check_attr_wwns(ioc);
367                 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
368                 break;
369
370         case IOC_E_FAILED:
371                 bfa_ioc_timer_stop(ioc);
372                 bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
373                 break;
374
375         case IOC_E_HWERROR:
376                 bfa_ioc_timer_stop(ioc);
377                 /* fall through */
378
379         case IOC_E_TIMEOUT:
380                 bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
381                 bfa_iocpf_getattrfail(ioc);
382                 break;
383
384         case IOC_E_DISABLE:
385                 bfa_ioc_timer_stop(ioc);
386                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
387                 break;
388
389         case IOC_E_ENABLE:
390                 break;
391
392         default:
393                 bfa_sm_fault(ioc, event);
394         }
395 }
396
397
398 static void
399 bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
400 {
401         struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
402
403         ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
404         bfa_ioc_hb_monitor(ioc);
405         BFA_LOG(KERN_INFO, bfad, log_level, "IOC enabled\n");
406 }
407
408 static void
409 bfa_ioc_sm_op(struct bfa_ioc_s *ioc, enum ioc_event event)
410 {
411         bfa_trc(ioc, event);
412
413         switch (event) {
414         case IOC_E_ENABLE:
415                 break;
416
417         case IOC_E_DISABLE:
418                 bfa_ioc_hb_stop(ioc);
419                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
420                 break;
421
422         case IOC_E_FAILED:
423                 bfa_ioc_hb_stop(ioc);
424                 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
425                 break;
426
427         case IOC_E_HWERROR:
428                 bfa_ioc_hb_stop(ioc);
429                 /* !!! fall through !!! */
430
431         case IOC_E_HBFAIL:
432                 bfa_fsm_set_state(ioc, bfa_ioc_sm_fail);
433                 bfa_iocpf_fail(ioc);
434                 break;
435
436         default:
437                 bfa_sm_fault(ioc, event);
438         }
439 }
440
441
442 static void
443 bfa_ioc_sm_disabling_entry(struct bfa_ioc_s *ioc)
444 {
445         struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
446         bfa_iocpf_disable(ioc);
447         BFA_LOG(KERN_INFO, bfad, log_level, "IOC disabled\n");
448 }
449
450 /*
451  * IOC is being disabled
452  */
453 static void
454 bfa_ioc_sm_disabling(struct bfa_ioc_s *ioc, enum ioc_event event)
455 {
456         bfa_trc(ioc, event);
457
458         switch (event) {
459         case IOC_E_DISABLED:
460                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
461                 break;
462
463         case IOC_E_HWERROR:
464                 /*
465                  * No state change.  Will move to disabled state
466                  * after iocpf sm completes failure processing and
467                  * moves to disabled state.
468                  */
469                 bfa_iocpf_fail(ioc);
470                 break;
471
472         default:
473                 bfa_sm_fault(ioc, event);
474         }
475 }
476
477 /*
478  * IOC disable completion entry.
479  */
480 static void
481 bfa_ioc_sm_disabled_entry(struct bfa_ioc_s *ioc)
482 {
483         bfa_ioc_disable_comp(ioc);
484 }
485
486 static void
487 bfa_ioc_sm_disabled(struct bfa_ioc_s *ioc, enum ioc_event event)
488 {
489         bfa_trc(ioc, event);
490
491         switch (event) {
492         case IOC_E_ENABLE:
493                 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
494                 break;
495
496         case IOC_E_DISABLE:
497                 ioc->cbfn->disable_cbfn(ioc->bfa);
498                 break;
499
500         case IOC_E_DETACH:
501                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
502                 bfa_iocpf_stop(ioc);
503                 break;
504
505         default:
506                 bfa_sm_fault(ioc, event);
507         }
508 }
509
510
511 static void
512 bfa_ioc_sm_initfail_entry(struct bfa_ioc_s *ioc)
513 {
514         ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
515 }
516
517 /*
518  * Hardware initialization failed.
519  */
520 static void
521 bfa_ioc_sm_initfail(struct bfa_ioc_s *ioc, enum ioc_event event)
522 {
523         bfa_trc(ioc, event);
524
525         switch (event) {
526         case IOC_E_ENABLED:
527                 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
528                 break;
529
530         case IOC_E_FAILED:
531                 /*
532                  * Initialization failure during iocpf init retry.
533                  */
534                 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
535                 break;
536
537         case IOC_E_DISABLE:
538                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
539                 break;
540
541         case IOC_E_DETACH:
542                 bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
543                 bfa_iocpf_stop(ioc);
544                 break;
545
546         default:
547                 bfa_sm_fault(ioc, event);
548         }
549 }
550
551
552 static void
553 bfa_ioc_sm_fail_entry(struct bfa_ioc_s *ioc)
554 {
555         struct list_head                        *qe;
556         struct bfa_ioc_hbfail_notify_s  *notify;
557         struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
558
559         /*
560          * Notify driver and common modules registered for notification.
561          */
562         ioc->cbfn->hbfail_cbfn(ioc->bfa);
563         list_for_each(qe, &ioc->hb_notify_q) {
564                 notify = (struct bfa_ioc_hbfail_notify_s *) qe;
565                 notify->cbfn(notify->cbarg);
566         }
567
568         BFA_LOG(KERN_CRIT, bfad, log_level,
569                 "Heart Beat of IOC has failed\n");
570 }
571
572 /*
573  * IOC failure.
574  */
575 static void
576 bfa_ioc_sm_fail(struct bfa_ioc_s *ioc, enum ioc_event event)
577 {
578         bfa_trc(ioc, event);
579
580         switch (event) {
581
582         case IOC_E_FAILED:
583                 /*
584                  * Initialization failure during iocpf recovery.
585                  * !!! Fall through !!!
586                  */
587         case IOC_E_ENABLE:
588                 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
589                 break;
590
591         case IOC_E_ENABLED:
592                 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
593                 break;
594
595         case IOC_E_DISABLE:
596                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
597                 break;
598
599         case IOC_E_HWERROR:
600                 /*
601                  * HB failure notification, ignore.
602                  */
603                 break;
604         default:
605                 bfa_sm_fault(ioc, event);
606         }
607 }
608
609
610
611 /*
612  * IOCPF State Machine
613  */
614
615
616 /*
617  * Reset entry actions -- initialize state machine
618  */
619 static void
620 bfa_iocpf_sm_reset_entry(struct bfa_iocpf_s *iocpf)
621 {
622         iocpf->retry_count = 0;
623         iocpf->auto_recover = bfa_auto_recover;
624 }
625
626 /*
627  * Beginning state. IOC is in reset state.
628  */
629 static void
630 bfa_iocpf_sm_reset(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
631 {
632         struct bfa_ioc_s *ioc = iocpf->ioc;
633
634         bfa_trc(ioc, event);
635
636         switch (event) {
637         case IOCPF_E_ENABLE:
638                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
639                 break;
640
641         case IOCPF_E_STOP:
642                 break;
643
644         default:
645                 bfa_sm_fault(ioc, event);
646         }
647 }
648
649 /*
650  * Semaphore should be acquired for version check.
651  */
652 static void
653 bfa_iocpf_sm_fwcheck_entry(struct bfa_iocpf_s *iocpf)
654 {
655         bfa_ioc_hw_sem_get(iocpf->ioc);
656 }
657
658 /*
659  * Awaiting h/w semaphore to continue with version check.
660  */
661 static void
662 bfa_iocpf_sm_fwcheck(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
663 {
664         struct bfa_ioc_s *ioc = iocpf->ioc;
665
666         bfa_trc(ioc, event);
667
668         switch (event) {
669         case IOCPF_E_SEMLOCKED:
670                 if (bfa_ioc_firmware_lock(ioc)) {
671                         iocpf->retry_count = 0;
672                         bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
673                 } else {
674                         bfa_ioc_hw_sem_release(ioc);
675                         bfa_fsm_set_state(iocpf, bfa_iocpf_sm_mismatch);
676                 }
677                 break;
678
679         case IOCPF_E_DISABLE:
680                 bfa_ioc_hw_sem_get_cancel(ioc);
681                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
682                 bfa_ioc_pf_disabled(ioc);
683                 break;
684
685         case IOCPF_E_STOP:
686                 bfa_ioc_hw_sem_get_cancel(ioc);
687                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
688                 break;
689
690         default:
691                 bfa_sm_fault(ioc, event);
692         }
693 }
694
695 /*
696  * Notify enable completion callback.
697  */
698 static void
699 bfa_iocpf_sm_mismatch_entry(struct bfa_iocpf_s *iocpf)
700 {
701         /*
702          * Call only the first time sm enters fwmismatch state.
703          */
704         if (iocpf->retry_count == 0)
705                 bfa_ioc_pf_fwmismatch(iocpf->ioc);
706
707         iocpf->retry_count++;
708         bfa_iocpf_timer_start(iocpf->ioc);
709 }
710
711 /*
712  * Awaiting firmware version match.
713  */
714 static void
715 bfa_iocpf_sm_mismatch(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_TIMEOUT:
723                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fwcheck);
724                 break;
725
726         case IOCPF_E_DISABLE:
727                 bfa_iocpf_timer_stop(ioc);
728                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
729                 bfa_ioc_pf_disabled(ioc);
730                 break;
731
732         case IOCPF_E_STOP:
733                 bfa_iocpf_timer_stop(ioc);
734                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
735                 break;
736
737         default:
738                 bfa_sm_fault(ioc, event);
739         }
740 }
741
742 /*
743  * Request for semaphore.
744  */
745 static void
746 bfa_iocpf_sm_semwait_entry(struct bfa_iocpf_s *iocpf)
747 {
748         bfa_ioc_hw_sem_get(iocpf->ioc);
749 }
750
751 /*
752  * Awaiting semaphore for h/w initialzation.
753  */
754 static void
755 bfa_iocpf_sm_semwait(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
756 {
757         struct bfa_ioc_s *ioc = iocpf->ioc;
758
759         bfa_trc(ioc, event);
760
761         switch (event) {
762         case IOCPF_E_SEMLOCKED:
763                 iocpf->retry_count = 0;
764                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
765                 break;
766
767         case IOCPF_E_DISABLE:
768                 bfa_ioc_hw_sem_get_cancel(ioc);
769                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
770                 break;
771
772         default:
773                 bfa_sm_fault(ioc, event);
774         }
775 }
776
777
778 static void
779 bfa_iocpf_sm_hwinit_entry(struct bfa_iocpf_s *iocpf)
780 {
781         bfa_iocpf_timer_start(iocpf->ioc);
782         bfa_ioc_reset(iocpf->ioc, BFA_FALSE);
783 }
784
785 /*
786  * Hardware is being initialized. Interrupts are enabled.
787  * Holding hardware semaphore lock.
788  */
789 static void
790 bfa_iocpf_sm_hwinit(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
791 {
792         struct bfa_ioc_s *ioc = iocpf->ioc;
793
794         bfa_trc(ioc, event);
795
796         switch (event) {
797         case IOCPF_E_FWREADY:
798                 bfa_iocpf_timer_stop(ioc);
799                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_enabling);
800                 break;
801
802         case IOCPF_E_INITFAIL:
803                 bfa_iocpf_timer_stop(ioc);
804                 /*
805                  * !!! fall through !!!
806                  */
807
808         case IOCPF_E_TIMEOUT:
809                 iocpf->retry_count++;
810                 if (iocpf->retry_count < BFA_IOC_HWINIT_MAX) {
811                         bfa_iocpf_timer_start(ioc);
812                         bfa_ioc_reset(ioc, BFA_TRUE);
813                         break;
814                 }
815
816                 bfa_ioc_hw_sem_release(ioc);
817                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
818
819                 if (event == IOCPF_E_TIMEOUT)
820                         bfa_ioc_pf_failed(ioc);
821                 break;
822
823         case IOCPF_E_DISABLE:
824                 bfa_ioc_hw_sem_release(ioc);
825                 bfa_iocpf_timer_stop(ioc);
826                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
827                 break;
828
829         default:
830                 bfa_sm_fault(ioc, event);
831         }
832 }
833
834
835 static void
836 bfa_iocpf_sm_enabling_entry(struct bfa_iocpf_s *iocpf)
837 {
838         bfa_iocpf_timer_start(iocpf->ioc);
839         bfa_ioc_send_enable(iocpf->ioc);
840 }
841
842 /*
843  * Host IOC function is being enabled, awaiting response from firmware.
844  * Semaphore is acquired.
845  */
846 static void
847 bfa_iocpf_sm_enabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
848 {
849         struct bfa_ioc_s *ioc = iocpf->ioc;
850
851         bfa_trc(ioc, event);
852
853         switch (event) {
854         case IOCPF_E_FWRSP_ENABLE:
855                 bfa_iocpf_timer_stop(ioc);
856                 bfa_ioc_hw_sem_release(ioc);
857                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_ready);
858                 break;
859
860         case IOCPF_E_INITFAIL:
861                 bfa_iocpf_timer_stop(ioc);
862                 /*
863                  * !!! fall through !!!
864                  */
865
866         case IOCPF_E_TIMEOUT:
867                 iocpf->retry_count++;
868                 if (iocpf->retry_count < BFA_IOC_HWINIT_MAX) {
869                         writel(BFI_IOC_UNINIT, ioc->ioc_regs.ioc_fwstate);
870                         bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
871                         break;
872                 }
873
874                 bfa_ioc_hw_sem_release(ioc);
875                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
876
877                 if (event == IOCPF_E_TIMEOUT)
878                         bfa_ioc_pf_failed(ioc);
879                 break;
880
881         case IOCPF_E_DISABLE:
882                 bfa_iocpf_timer_stop(ioc);
883                 bfa_ioc_hw_sem_release(ioc);
884                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
885                 break;
886
887         case IOCPF_E_FWREADY:
888                 bfa_ioc_send_enable(ioc);
889                 break;
890
891         default:
892                 bfa_sm_fault(ioc, event);
893         }
894 }
895
896
897
898 static void
899 bfa_iocpf_sm_ready_entry(struct bfa_iocpf_s *iocpf)
900 {
901         bfa_ioc_pf_enabled(iocpf->ioc);
902 }
903
904 static void
905 bfa_iocpf_sm_ready(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
906 {
907         struct bfa_ioc_s *ioc = iocpf->ioc;
908
909         bfa_trc(ioc, event);
910
911         switch (event) {
912         case IOCPF_E_DISABLE:
913                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabling);
914                 break;
915
916         case IOCPF_E_GETATTRFAIL:
917                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
918                 break;
919
920         case IOCPF_E_FAIL:
921                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
922                 break;
923
924         case IOCPF_E_FWREADY:
925                 if (bfa_ioc_is_operational(ioc))
926                         bfa_fsm_set_state(iocpf, bfa_iocpf_sm_fail);
927                 else
928                         bfa_fsm_set_state(iocpf, bfa_iocpf_sm_initfail);
929
930                 bfa_ioc_pf_failed(ioc);
931                 break;
932
933         default:
934                 bfa_sm_fault(ioc, event);
935         }
936 }
937
938
939 static void
940 bfa_iocpf_sm_disabling_entry(struct bfa_iocpf_s *iocpf)
941 {
942         bfa_iocpf_timer_start(iocpf->ioc);
943         bfa_ioc_send_disable(iocpf->ioc);
944 }
945
946 /*
947  * IOC is being disabled
948  */
949 static void
950 bfa_iocpf_sm_disabling(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
951 {
952         struct bfa_ioc_s *ioc = iocpf->ioc;
953
954         bfa_trc(ioc, event);
955
956         switch (event) {
957         case IOCPF_E_FWRSP_DISABLE:
958         case IOCPF_E_FWREADY:
959                 bfa_iocpf_timer_stop(ioc);
960                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
961                 break;
962
963         case IOCPF_E_FAIL:
964                 bfa_iocpf_timer_stop(ioc);
965                 /*
966                  * !!! fall through !!!
967                  */
968
969         case IOCPF_E_TIMEOUT:
970                 writel(BFI_IOC_FAIL, ioc->ioc_regs.ioc_fwstate);
971                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
972                 break;
973
974         case IOCPF_E_FWRSP_ENABLE:
975                 break;
976
977         default:
978                 bfa_sm_fault(ioc, event);
979         }
980 }
981
982 /*
983  * IOC disable completion entry.
984  */
985 static void
986 bfa_iocpf_sm_disabled_entry(struct bfa_iocpf_s *iocpf)
987 {
988         bfa_ioc_pf_disabled(iocpf->ioc);
989 }
990
991 static void
992 bfa_iocpf_sm_disabled(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
993 {
994         struct bfa_ioc_s *ioc = iocpf->ioc;
995
996         bfa_trc(ioc, event);
997
998         switch (event) {
999         case IOCPF_E_ENABLE:
1000                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1001                 break;
1002
1003         case IOCPF_E_STOP:
1004                 bfa_ioc_firmware_unlock(ioc);
1005                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1006                 break;
1007
1008         default:
1009                 bfa_sm_fault(ioc, event);
1010         }
1011 }
1012
1013
1014 static void
1015 bfa_iocpf_sm_initfail_entry(struct bfa_iocpf_s *iocpf)
1016 {
1017         bfa_iocpf_timer_start(iocpf->ioc);
1018 }
1019
1020 /*
1021  * Hardware initialization failed.
1022  */
1023 static void
1024 bfa_iocpf_sm_initfail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1025 {
1026         struct bfa_ioc_s *ioc = iocpf->ioc;
1027
1028         bfa_trc(ioc, event);
1029
1030         switch (event) {
1031         case IOCPF_E_DISABLE:
1032                 bfa_iocpf_timer_stop(ioc);
1033                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1034                 break;
1035
1036         case IOCPF_E_STOP:
1037                 bfa_iocpf_timer_stop(ioc);
1038                 bfa_ioc_firmware_unlock(ioc);
1039                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_reset);
1040                 break;
1041
1042         case IOCPF_E_TIMEOUT:
1043                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1044                 break;
1045
1046         default:
1047                 bfa_sm_fault(ioc, event);
1048         }
1049 }
1050
1051
1052 static void
1053 bfa_iocpf_sm_fail_entry(struct bfa_iocpf_s *iocpf)
1054 {
1055         /*
1056          * Mark IOC as failed in hardware and stop firmware.
1057          */
1058         bfa_ioc_lpu_stop(iocpf->ioc);
1059         writel(BFI_IOC_FAIL, iocpf->ioc->ioc_regs.ioc_fwstate);
1060
1061         /*
1062          * Notify other functions on HB failure.
1063          */
1064         bfa_ioc_notify_hbfail(iocpf->ioc);
1065
1066         /*
1067          * Flush any queued up mailbox requests.
1068          */
1069         bfa_ioc_mbox_hbfail(iocpf->ioc);
1070
1071         if (iocpf->auto_recover)
1072                 bfa_iocpf_recovery_timer_start(iocpf->ioc);
1073 }
1074
1075 /*
1076  * IOC is in failed state.
1077  */
1078 static void
1079 bfa_iocpf_sm_fail(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
1080 {
1081         struct bfa_ioc_s *ioc = iocpf->ioc;
1082
1083         bfa_trc(ioc, event);
1084
1085         switch (event) {
1086         case IOCPF_E_DISABLE:
1087                 if (iocpf->auto_recover)
1088                         bfa_iocpf_timer_stop(ioc);
1089                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_disabled);
1090                 break;
1091
1092         case IOCPF_E_TIMEOUT:
1093                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_semwait);
1094                 break;
1095
1096         default:
1097                 bfa_sm_fault(ioc, event);
1098         }
1099 }
1100
1101
1102
1103 /*
1104  *  hal_ioc_pvt BFA IOC private functions
1105  */
1106
1107 static void
1108 bfa_ioc_disable_comp(struct bfa_ioc_s *ioc)
1109 {
1110         struct list_head                        *qe;
1111         struct bfa_ioc_hbfail_notify_s  *notify;
1112
1113         ioc->cbfn->disable_cbfn(ioc->bfa);
1114
1115         /*
1116          * Notify common modules registered for notification.
1117          */
1118         list_for_each(qe, &ioc->hb_notify_q) {
1119                 notify = (struct bfa_ioc_hbfail_notify_s *) qe;
1120                 notify->cbfn(notify->cbarg);
1121         }
1122 }
1123
1124 bfa_boolean_t
1125 bfa_ioc_sem_get(void __iomem *sem_reg)
1126 {
1127         u32 r32;
1128         int cnt = 0;
1129 #define BFA_SEM_SPINCNT 3000
1130
1131         r32 = readl(sem_reg);
1132
1133         while (r32 && (cnt < BFA_SEM_SPINCNT)) {
1134                 cnt++;
1135                 udelay(2);
1136                 r32 = readl(sem_reg);
1137         }
1138
1139         if (r32 == 0)
1140                 return BFA_TRUE;
1141
1142         bfa_assert(cnt < BFA_SEM_SPINCNT);
1143         return BFA_FALSE;
1144 }
1145
1146 void
1147 bfa_ioc_sem_release(void __iomem *sem_reg)
1148 {
1149         writel(1, sem_reg);
1150 }
1151
1152 static void
1153 bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
1154 {
1155         u32     r32;
1156
1157         /*
1158          * First read to the semaphore register will return 0, subsequent reads
1159          * will return 1. Semaphore is released by writing 1 to the register
1160          */
1161         r32 = readl(ioc->ioc_regs.ioc_sem_reg);
1162         if (r32 == 0) {
1163                 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_SEMLOCKED);
1164                 return;
1165         }
1166
1167         bfa_sem_timer_start(ioc);
1168 }
1169
1170 void
1171 bfa_ioc_hw_sem_release(struct bfa_ioc_s *ioc)
1172 {
1173         writel(1, ioc->ioc_regs.ioc_sem_reg);
1174 }
1175
1176 static void
1177 bfa_ioc_hw_sem_get_cancel(struct bfa_ioc_s *ioc)
1178 {
1179         bfa_sem_timer_stop(ioc);
1180 }
1181
1182 /*
1183  * Initialize LPU local memory (aka secondary memory / SRAM)
1184  */
1185 static void
1186 bfa_ioc_lmem_init(struct bfa_ioc_s *ioc)
1187 {
1188         u32     pss_ctl;
1189         int             i;
1190 #define PSS_LMEM_INIT_TIME  10000
1191
1192         pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1193         pss_ctl &= ~__PSS_LMEM_RESET;
1194         pss_ctl |= __PSS_LMEM_INIT_EN;
1195
1196         /*
1197          * i2c workaround 12.5khz clock
1198          */
1199         pss_ctl |= __PSS_I2C_CLK_DIV(3UL);
1200         writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1201
1202         /*
1203          * wait for memory initialization to be complete
1204          */
1205         i = 0;
1206         do {
1207                 pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1208                 i++;
1209         } while (!(pss_ctl & __PSS_LMEM_INIT_DONE) && (i < PSS_LMEM_INIT_TIME));
1210
1211         /*
1212          * If memory initialization is not successful, IOC timeout will catch
1213          * such failures.
1214          */
1215         bfa_assert(pss_ctl & __PSS_LMEM_INIT_DONE);
1216         bfa_trc(ioc, pss_ctl);
1217
1218         pss_ctl &= ~(__PSS_LMEM_INIT_DONE | __PSS_LMEM_INIT_EN);
1219         writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1220 }
1221
1222 static void
1223 bfa_ioc_lpu_start(struct bfa_ioc_s *ioc)
1224 {
1225         u32     pss_ctl;
1226
1227         /*
1228          * Take processor out of reset.
1229          */
1230         pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1231         pss_ctl &= ~__PSS_LPU0_RESET;
1232
1233         writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1234 }
1235
1236 static void
1237 bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc)
1238 {
1239         u32     pss_ctl;
1240
1241         /*
1242          * Put processors in reset.
1243          */
1244         pss_ctl = readl(ioc->ioc_regs.pss_ctl_reg);
1245         pss_ctl |= (__PSS_LPU0_RESET | __PSS_LPU1_RESET);
1246
1247         writel(pss_ctl, ioc->ioc_regs.pss_ctl_reg);
1248 }
1249
1250 /*
1251  * Get driver and firmware versions.
1252  */
1253 void
1254 bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
1255 {
1256         u32     pgnum, pgoff;
1257         u32     loff = 0;
1258         int             i;
1259         u32     *fwsig = (u32 *) fwhdr;
1260
1261         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
1262         pgoff = bfa_ioc_smem_pgoff(ioc, loff);
1263         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1264
1265         for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32));
1266              i++) {
1267                 fwsig[i] =
1268                         bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
1269                 loff += sizeof(u32);
1270         }
1271 }
1272
1273 /*
1274  * Returns TRUE if same.
1275  */
1276 bfa_boolean_t
1277 bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
1278 {
1279         struct bfi_ioc_image_hdr_s *drv_fwhdr;
1280         int i;
1281
1282         drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
1283                 bfa_cb_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), 0);
1284
1285         for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) {
1286                 if (fwhdr->md5sum[i] != drv_fwhdr->md5sum[i]) {
1287                         bfa_trc(ioc, i);
1288                         bfa_trc(ioc, fwhdr->md5sum[i]);
1289                         bfa_trc(ioc, drv_fwhdr->md5sum[i]);
1290                         return BFA_FALSE;
1291                 }
1292         }
1293
1294         bfa_trc(ioc, fwhdr->md5sum[0]);
1295         return BFA_TRUE;
1296 }
1297
1298 /*
1299  * Return true if current running version is valid. Firmware signature and
1300  * execution context (driver/bios) must match.
1301  */
1302 static bfa_boolean_t
1303 bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc, u32 boot_env)
1304 {
1305         struct bfi_ioc_image_hdr_s fwhdr, *drv_fwhdr;
1306
1307         /*
1308          * If bios/efi boot (flash based) -- return true
1309          */
1310         if (bfa_ioc_is_bios_optrom(ioc))
1311                 return BFA_TRUE;
1312
1313         bfa_ioc_fwver_get(ioc, &fwhdr);
1314         drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
1315                 bfa_cb_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), 0);
1316
1317         if (fwhdr.signature != drv_fwhdr->signature) {
1318                 bfa_trc(ioc, fwhdr.signature);
1319                 bfa_trc(ioc, drv_fwhdr->signature);
1320                 return BFA_FALSE;
1321         }
1322
1323         if (swab32(fwhdr.param) != boot_env) {
1324                 bfa_trc(ioc, fwhdr.param);
1325                 bfa_trc(ioc, boot_env);
1326                 return BFA_FALSE;
1327         }
1328
1329         return bfa_ioc_fwver_cmp(ioc, &fwhdr);
1330 }
1331
1332 /*
1333  * Conditionally flush any pending message from firmware at start.
1334  */
1335 static void
1336 bfa_ioc_msgflush(struct bfa_ioc_s *ioc)
1337 {
1338         u32     r32;
1339
1340         r32 = readl(ioc->ioc_regs.lpu_mbox_cmd);
1341         if (r32)
1342                 writel(1, ioc->ioc_regs.lpu_mbox_cmd);
1343 }
1344
1345
1346 static void
1347 bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force)
1348 {
1349         enum bfi_ioc_state ioc_fwstate;
1350         bfa_boolean_t fwvalid;
1351         u32 boot_type;
1352         u32 boot_env;
1353
1354         ioc_fwstate = readl(ioc->ioc_regs.ioc_fwstate);
1355
1356         if (force)
1357                 ioc_fwstate = BFI_IOC_UNINIT;
1358
1359         bfa_trc(ioc, ioc_fwstate);
1360
1361         boot_type = BFI_BOOT_TYPE_NORMAL;
1362         boot_env = BFI_BOOT_LOADER_OS;
1363
1364         /*
1365          * Flash based firmware boot BIOS env.
1366          */
1367         if (bfa_ioc_is_bios_optrom(ioc)) {
1368                 boot_type = BFI_BOOT_TYPE_FLASH;
1369                 boot_env = BFI_BOOT_LOADER_BIOS;
1370         }
1371
1372         /*
1373          * Flash based firmware boot UEFI env.
1374          */
1375         if (bfa_ioc_is_uefi(ioc)) {
1376                 boot_type = BFI_BOOT_TYPE_FLASH;
1377                 boot_env = BFI_BOOT_LOADER_UEFI;
1378         }
1379
1380         /*
1381          * check if firmware is valid
1382          */
1383         fwvalid = (ioc_fwstate == BFI_IOC_UNINIT) ?
1384                 BFA_FALSE : bfa_ioc_fwver_valid(ioc, boot_env);
1385
1386         if (!fwvalid) {
1387                 bfa_ioc_boot(ioc, boot_type, boot_env);
1388                 return;
1389         }
1390
1391         /*
1392          * If hardware initialization is in progress (initialized by other IOC),
1393          * just wait for an initialization completion interrupt.
1394          */
1395         if (ioc_fwstate == BFI_IOC_INITING) {
1396                 ioc->cbfn->reset_cbfn(ioc->bfa);
1397                 return;
1398         }
1399
1400         /*
1401          * If IOC function is disabled and firmware version is same,
1402          * just re-enable IOC.
1403          *
1404          * If option rom, IOC must not be in operational state. With
1405          * convergence, IOC will be in operational state when 2nd driver
1406          * is loaded.
1407          */
1408         if (ioc_fwstate == BFI_IOC_DISABLED ||
1409             (!bfa_ioc_is_bios_optrom(ioc) && ioc_fwstate == BFI_IOC_OP)) {
1410
1411                 /*
1412                  * When using MSI-X any pending firmware ready event should
1413                  * be flushed. Otherwise MSI-X interrupts are not delivered.
1414                  */
1415                 bfa_ioc_msgflush(ioc);
1416                 ioc->cbfn->reset_cbfn(ioc->bfa);
1417                 bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FWREADY);
1418                 return;
1419         }
1420
1421         /*
1422          * Initialize the h/w for any other states.
1423          */
1424         bfa_ioc_boot(ioc, boot_type, boot_env);
1425 }
1426
1427 static void
1428 bfa_ioc_timeout(void *ioc_arg)
1429 {
1430         struct bfa_ioc_s  *ioc = (struct bfa_ioc_s *) ioc_arg;
1431
1432         bfa_trc(ioc, 0);
1433         bfa_fsm_send_event(ioc, IOC_E_TIMEOUT);
1434 }
1435
1436 void
1437 bfa_ioc_mbox_send(struct bfa_ioc_s *ioc, void *ioc_msg, int len)
1438 {
1439         u32 *msgp = (u32 *) ioc_msg;
1440         u32 i;
1441
1442         bfa_trc(ioc, msgp[0]);
1443         bfa_trc(ioc, len);
1444
1445         bfa_assert(len <= BFI_IOC_MSGLEN_MAX);
1446
1447         /*
1448          * first write msg to mailbox registers
1449          */
1450         for (i = 0; i < len / sizeof(u32); i++)
1451                 writel(cpu_to_le32(msgp[i]),
1452                         ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1453
1454         for (; i < BFI_IOC_MSGLEN_MAX / sizeof(u32); i++)
1455                 writel(0, ioc->ioc_regs.hfn_mbox + i * sizeof(u32));
1456
1457         /*
1458          * write 1 to mailbox CMD to trigger LPU event
1459          */
1460         writel(1, ioc->ioc_regs.hfn_mbox_cmd);
1461         (void) readl(ioc->ioc_regs.hfn_mbox_cmd);
1462 }
1463
1464 static void
1465 bfa_ioc_send_enable(struct bfa_ioc_s *ioc)
1466 {
1467         struct bfi_ioc_ctrl_req_s enable_req;
1468         struct bfa_timeval_s tv;
1469
1470         bfi_h2i_set(enable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_ENABLE_REQ,
1471                     bfa_ioc_portid(ioc));
1472         enable_req.ioc_class = ioc->ioc_mc;
1473         bfa_os_gettimeofday(&tv);
1474         enable_req.tv_sec = be32_to_cpu(tv.tv_sec);
1475         bfa_ioc_mbox_send(ioc, &enable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1476 }
1477
1478 static void
1479 bfa_ioc_send_disable(struct bfa_ioc_s *ioc)
1480 {
1481         struct bfi_ioc_ctrl_req_s disable_req;
1482
1483         bfi_h2i_set(disable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_DISABLE_REQ,
1484                     bfa_ioc_portid(ioc));
1485         bfa_ioc_mbox_send(ioc, &disable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1486 }
1487
1488 static void
1489 bfa_ioc_send_getattr(struct bfa_ioc_s *ioc)
1490 {
1491         struct bfi_ioc_getattr_req_s    attr_req;
1492
1493         bfi_h2i_set(attr_req.mh, BFI_MC_IOC, BFI_IOC_H2I_GETATTR_REQ,
1494                     bfa_ioc_portid(ioc));
1495         bfa_dma_be_addr_set(attr_req.attr_addr, ioc->attr_dma.pa);
1496         bfa_ioc_mbox_send(ioc, &attr_req, sizeof(attr_req));
1497 }
1498
1499 static void
1500 bfa_ioc_hb_check(void *cbarg)
1501 {
1502         struct bfa_ioc_s  *ioc = cbarg;
1503         u32     hb_count;
1504
1505         hb_count = readl(ioc->ioc_regs.heartbeat);
1506         if (ioc->hb_count == hb_count) {
1507                 printk(KERN_CRIT "Firmware heartbeat failure at %d", hb_count);
1508                 bfa_ioc_recover(ioc);
1509                 return;
1510         } else {
1511                 ioc->hb_count = hb_count;
1512         }
1513
1514         bfa_ioc_mbox_poll(ioc);
1515         bfa_hb_timer_start(ioc);
1516 }
1517
1518 static void
1519 bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc)
1520 {
1521         ioc->hb_count = readl(ioc->ioc_regs.heartbeat);
1522         bfa_hb_timer_start(ioc);
1523 }
1524
1525 static void
1526 bfa_ioc_hb_stop(struct bfa_ioc_s *ioc)
1527 {
1528         bfa_hb_timer_stop(ioc);
1529 }
1530
1531
1532 /*
1533  *      Initiate a full firmware download.
1534  */
1535 static void
1536 bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
1537                     u32 boot_env)
1538 {
1539         u32 *fwimg;
1540         u32 pgnum, pgoff;
1541         u32 loff = 0;
1542         u32 chunkno = 0;
1543         u32 i;
1544
1545         /*
1546          * Initialize LMEM first before code download
1547          */
1548         bfa_ioc_lmem_init(ioc);
1549
1550         bfa_trc(ioc, bfa_cb_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)));
1551         fwimg = bfa_cb_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), chunkno);
1552
1553         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
1554         pgoff = bfa_ioc_smem_pgoff(ioc, loff);
1555
1556         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1557
1558         for (i = 0; i < bfa_cb_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)); i++) {
1559
1560                 if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {
1561                         chunkno = BFA_IOC_FLASH_CHUNK_NO(i);
1562                         fwimg = bfa_cb_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc),
1563                                         BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
1564                 }
1565
1566                 /*
1567                  * write smem
1568                  */
1569                 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff,
1570                               fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]);
1571
1572                 loff += sizeof(u32);
1573
1574                 /*
1575                  * handle page offset wrap around
1576                  */
1577                 loff = PSS_SMEM_PGOFF(loff);
1578                 if (loff == 0) {
1579                         pgnum++;
1580                         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1581                 }
1582         }
1583
1584         writel(bfa_ioc_smem_pgnum(ioc, 0), ioc->ioc_regs.host_page_num_fn);
1585
1586         /*
1587          * Set boot type and boot param at the end.
1588         */
1589         bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_BOOT_TYPE_OFF,
1590                         swab32(boot_type));
1591         bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_BOOT_LOADER_OFF,
1592                         swab32(boot_env));
1593 }
1594
1595 static void
1596 bfa_ioc_reset(struct bfa_ioc_s *ioc, bfa_boolean_t force)
1597 {
1598         bfa_ioc_hwinit(ioc, force);
1599 }
1600
1601 /*
1602  * Update BFA configuration from firmware configuration.
1603  */
1604 static void
1605 bfa_ioc_getattr_reply(struct bfa_ioc_s *ioc)
1606 {
1607         struct bfi_ioc_attr_s   *attr = ioc->attr;
1608
1609         attr->adapter_prop  = be32_to_cpu(attr->adapter_prop);
1610         attr->card_type     = be32_to_cpu(attr->card_type);
1611         attr->maxfrsize     = be16_to_cpu(attr->maxfrsize);
1612
1613         bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR);
1614 }
1615
1616 /*
1617  * Attach time initialization of mbox logic.
1618  */
1619 static void
1620 bfa_ioc_mbox_attach(struct bfa_ioc_s *ioc)
1621 {
1622         struct bfa_ioc_mbox_mod_s       *mod = &ioc->mbox_mod;
1623         int     mc;
1624
1625         INIT_LIST_HEAD(&mod->cmd_q);
1626         for (mc = 0; mc < BFI_MC_MAX; mc++) {
1627                 mod->mbhdlr[mc].cbfn = NULL;
1628                 mod->mbhdlr[mc].cbarg = ioc->bfa;
1629         }
1630 }
1631
1632 /*
1633  * Mbox poll timer -- restarts any pending mailbox requests.
1634  */
1635 static void
1636 bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc)
1637 {
1638         struct bfa_ioc_mbox_mod_s       *mod = &ioc->mbox_mod;
1639         struct bfa_mbox_cmd_s           *cmd;
1640         u32                     stat;
1641
1642         /*
1643          * If no command pending, do nothing
1644          */
1645         if (list_empty(&mod->cmd_q))
1646                 return;
1647
1648         /*
1649          * If previous command is not yet fetched by firmware, do nothing
1650          */
1651         stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
1652         if (stat)
1653                 return;
1654
1655         /*
1656          * Enqueue command to firmware.
1657          */
1658         bfa_q_deq(&mod->cmd_q, &cmd);
1659         bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
1660 }
1661
1662 /*
1663  * Cleanup any pending requests.
1664  */
1665 static void
1666 bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc)
1667 {
1668         struct bfa_ioc_mbox_mod_s       *mod = &ioc->mbox_mod;
1669         struct bfa_mbox_cmd_s           *cmd;
1670
1671         while (!list_empty(&mod->cmd_q))
1672                 bfa_q_deq(&mod->cmd_q, &cmd);
1673 }
1674
1675 /*
1676  * Read data from SMEM to host through PCI memmap
1677  *
1678  * @param[in]   ioc     memory for IOC
1679  * @param[in]   tbuf    app memory to store data from smem
1680  * @param[in]   soff    smem offset
1681  * @param[in]   sz      size of smem in bytes
1682  */
1683 static bfa_status_t
1684 bfa_ioc_smem_read(struct bfa_ioc_s *ioc, void *tbuf, u32 soff, u32 sz)
1685 {
1686         u32 pgnum, loff, r32;
1687         int i, len;
1688         u32 *buf = tbuf;
1689
1690         pgnum = bfa_ioc_smem_pgnum(ioc, soff);
1691         loff = bfa_ioc_smem_pgoff(ioc, soff);
1692         bfa_trc(ioc, pgnum);
1693         bfa_trc(ioc, loff);
1694         bfa_trc(ioc, sz);
1695
1696         /*
1697          *  Hold semaphore to serialize pll init and fwtrc.
1698          */
1699         if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {
1700                 bfa_trc(ioc, 0);
1701                 return BFA_STATUS_FAILED;
1702         }
1703
1704         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1705
1706         len = sz/sizeof(u32);
1707         bfa_trc(ioc, len);
1708         for (i = 0; i < len; i++) {
1709                 r32 = bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
1710                 buf[i] = be32_to_cpu(r32);
1711                 loff += sizeof(u32);
1712
1713                 /*
1714                  * handle page offset wrap around
1715                  */
1716                 loff = PSS_SMEM_PGOFF(loff);
1717                 if (loff == 0) {
1718                         pgnum++;
1719                         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1720                 }
1721         }
1722         writel(bfa_ioc_smem_pgnum(ioc, 0), ioc->ioc_regs.host_page_num_fn);
1723         /*
1724          *  release semaphore.
1725          */
1726         bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
1727
1728         bfa_trc(ioc, pgnum);
1729         return BFA_STATUS_OK;
1730 }
1731
1732 /*
1733  * Clear SMEM data from host through PCI memmap
1734  *
1735  * @param[in]   ioc     memory for IOC
1736  * @param[in]   soff    smem offset
1737  * @param[in]   sz      size of smem in bytes
1738  */
1739 static bfa_status_t
1740 bfa_ioc_smem_clr(struct bfa_ioc_s *ioc, u32 soff, u32 sz)
1741 {
1742         int i, len;
1743         u32 pgnum, loff;
1744
1745         pgnum = bfa_ioc_smem_pgnum(ioc, soff);
1746         loff = bfa_ioc_smem_pgoff(ioc, soff);
1747         bfa_trc(ioc, pgnum);
1748         bfa_trc(ioc, loff);
1749         bfa_trc(ioc, sz);
1750
1751         /*
1752          *  Hold semaphore to serialize pll init and fwtrc.
1753          */
1754         if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg)) {
1755                 bfa_trc(ioc, 0);
1756                 return BFA_STATUS_FAILED;
1757         }
1758
1759         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1760
1761         len = sz/sizeof(u32); /* len in words */
1762         bfa_trc(ioc, len);
1763         for (i = 0; i < len; i++) {
1764                 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff, 0);
1765                 loff += sizeof(u32);
1766
1767                 /*
1768                  * handle page offset wrap around
1769                  */
1770                 loff = PSS_SMEM_PGOFF(loff);
1771                 if (loff == 0) {
1772                         pgnum++;
1773                         writel(pgnum, ioc->ioc_regs.host_page_num_fn);
1774                 }
1775         }
1776         writel(bfa_ioc_smem_pgnum(ioc, 0), ioc->ioc_regs.host_page_num_fn);
1777
1778         /*
1779          *  release semaphore.
1780          */
1781         bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
1782         bfa_trc(ioc, pgnum);
1783         return BFA_STATUS_OK;
1784 }
1785
1786 /*
1787  * hal iocpf to ioc interface
1788  */
1789 static void
1790 bfa_ioc_pf_enabled(struct bfa_ioc_s *ioc)
1791 {
1792         bfa_fsm_send_event(ioc, IOC_E_ENABLED);
1793 }
1794
1795 static void
1796 bfa_ioc_pf_disabled(struct bfa_ioc_s *ioc)
1797 {
1798         bfa_fsm_send_event(ioc, IOC_E_DISABLED);
1799 }
1800
1801 static void
1802 bfa_ioc_pf_failed(struct bfa_ioc_s *ioc)
1803 {
1804         bfa_fsm_send_event(ioc, IOC_E_FAILED);
1805 }
1806
1807 static void
1808 bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc)
1809 {
1810         struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
1811         /*
1812          * Provide enable completion callback.
1813          */
1814         ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
1815         BFA_LOG(KERN_WARNING, bfad, log_level,
1816                 "Running firmware version is incompatible "
1817                 "with the driver version\n");
1818 }
1819
1820
1821
1822 /*
1823  *  hal_ioc_public
1824  */
1825
1826 bfa_status_t
1827 bfa_ioc_pll_init(struct bfa_ioc_s *ioc)
1828 {
1829
1830         /*
1831          *  Hold semaphore so that nobody can access the chip during init.
1832          */
1833         bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg);
1834
1835         bfa_ioc_pll_init_asic(ioc);
1836
1837         ioc->pllinit = BFA_TRUE;
1838         /*
1839          *  release semaphore.
1840          */
1841         bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
1842
1843         return BFA_STATUS_OK;
1844 }
1845
1846 /*
1847  * Interface used by diag module to do firmware boot with memory test
1848  * as the entry vector.
1849  */
1850 void
1851 bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type, u32 boot_env)
1852 {
1853         void __iomem *rb;
1854
1855         bfa_ioc_stats(ioc, ioc_boots);
1856
1857         if (bfa_ioc_pll_init(ioc) != BFA_STATUS_OK)
1858                 return;
1859
1860         /*
1861          * Initialize IOC state of all functions on a chip reset.
1862          */
1863         rb = ioc->pcidev.pci_bar_kva;
1864         if (boot_type == BFI_BOOT_TYPE_MEMTEST) {
1865                 writel(BFI_IOC_MEMTEST, (rb + BFA_IOC0_STATE_REG));
1866                 writel(BFI_IOC_MEMTEST, (rb + BFA_IOC1_STATE_REG));
1867         } else {
1868                 writel(BFI_IOC_INITING, (rb + BFA_IOC0_STATE_REG));
1869                 writel(BFI_IOC_INITING, (rb + BFA_IOC1_STATE_REG));
1870         }
1871
1872         bfa_ioc_msgflush(ioc);
1873         bfa_ioc_download_fw(ioc, boot_type, boot_env);
1874
1875         /*
1876          * Enable interrupts just before starting LPU
1877          */
1878         ioc->cbfn->reset_cbfn(ioc->bfa);
1879         bfa_ioc_lpu_start(ioc);
1880 }
1881
1882 /*
1883  * Enable/disable IOC failure auto recovery.
1884  */
1885 void
1886 bfa_ioc_auto_recover(bfa_boolean_t auto_recover)
1887 {
1888         bfa_auto_recover = auto_recover;
1889 }
1890
1891
1892
1893 bfa_boolean_t
1894 bfa_ioc_is_operational(struct bfa_ioc_s *ioc)
1895 {
1896         return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_op);
1897 }
1898
1899 bfa_boolean_t
1900 bfa_ioc_is_initialized(struct bfa_ioc_s *ioc)
1901 {
1902         u32 r32 = readl(ioc->ioc_regs.ioc_fwstate);
1903
1904         return ((r32 != BFI_IOC_UNINIT) &&
1905                 (r32 != BFI_IOC_INITING) &&
1906                 (r32 != BFI_IOC_MEMTEST));
1907 }
1908
1909 void
1910 bfa_ioc_msgget(struct bfa_ioc_s *ioc, void *mbmsg)
1911 {
1912         u32     *msgp = mbmsg;
1913         u32     r32;
1914         int             i;
1915
1916         /*
1917          * read the MBOX msg
1918          */
1919         for (i = 0; i < (sizeof(union bfi_ioc_i2h_msg_u) / sizeof(u32));
1920              i++) {
1921                 r32 = readl(ioc->ioc_regs.lpu_mbox +
1922                                    i * sizeof(u32));
1923                 msgp[i] = cpu_to_be32(r32);
1924         }
1925
1926         /*
1927          * turn off mailbox interrupt by clearing mailbox status
1928          */
1929         writel(1, ioc->ioc_regs.lpu_mbox_cmd);
1930         readl(ioc->ioc_regs.lpu_mbox_cmd);
1931 }
1932
1933 void
1934 bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)
1935 {
1936         union bfi_ioc_i2h_msg_u *msg;
1937         struct bfa_iocpf_s *iocpf = &ioc->iocpf;
1938
1939         msg = (union bfi_ioc_i2h_msg_u *) m;
1940
1941         bfa_ioc_stats(ioc, ioc_isrs);
1942
1943         switch (msg->mh.msg_id) {
1944         case BFI_IOC_I2H_HBEAT:
1945                 break;
1946
1947         case BFI_IOC_I2H_READY_EVENT:
1948                 bfa_fsm_send_event(iocpf, IOCPF_E_FWREADY);
1949                 break;
1950
1951         case BFI_IOC_I2H_ENABLE_REPLY:
1952                 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_ENABLE);
1953                 break;
1954
1955         case BFI_IOC_I2H_DISABLE_REPLY:
1956                 bfa_fsm_send_event(iocpf, IOCPF_E_FWRSP_DISABLE);
1957                 break;
1958
1959         case BFI_IOC_I2H_GETATTR_REPLY:
1960                 bfa_ioc_getattr_reply(ioc);
1961                 break;
1962
1963         default:
1964                 bfa_trc(ioc, msg->mh.msg_id);
1965                 bfa_assert(0);
1966         }
1967 }
1968
1969 /*
1970  * IOC attach time initialization and setup.
1971  *
1972  * @param[in]   ioc     memory for IOC
1973  * @param[in]   bfa     driver instance structure
1974  */
1975 void
1976 bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa, struct bfa_ioc_cbfn_s *cbfn,
1977                struct bfa_timer_mod_s *timer_mod)
1978 {
1979         ioc->bfa        = bfa;
1980         ioc->cbfn       = cbfn;
1981         ioc->timer_mod  = timer_mod;
1982         ioc->fcmode     = BFA_FALSE;
1983         ioc->pllinit    = BFA_FALSE;
1984         ioc->dbg_fwsave_once = BFA_TRUE;
1985         ioc->iocpf.ioc  = ioc;
1986
1987         bfa_ioc_mbox_attach(ioc);
1988         INIT_LIST_HEAD(&ioc->hb_notify_q);
1989
1990         bfa_fsm_set_state(ioc, bfa_ioc_sm_uninit);
1991         bfa_fsm_send_event(ioc, IOC_E_RESET);
1992 }
1993
1994 /*
1995  * Driver detach time IOC cleanup.
1996  */
1997 void
1998 bfa_ioc_detach(struct bfa_ioc_s *ioc)
1999 {
2000         bfa_fsm_send_event(ioc, IOC_E_DETACH);
2001 }
2002
2003 /*
2004  * Setup IOC PCI properties.
2005  *
2006  * @param[in]   pcidev  PCI device information for this IOC
2007  */
2008 void
2009 bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
2010                  enum bfi_mclass mc)
2011 {
2012         ioc->ioc_mc     = mc;
2013         ioc->pcidev     = *pcidev;
2014         ioc->ctdev      = bfa_asic_id_ct(ioc->pcidev.device_id);
2015         ioc->cna        = ioc->ctdev && !ioc->fcmode;
2016
2017         /*
2018          * Set asic specific interfaces. See bfa_ioc_cb.c and bfa_ioc_ct.c
2019          */
2020         if (ioc->ctdev)
2021                 bfa_ioc_set_ct_hwif(ioc);
2022         else
2023                 bfa_ioc_set_cb_hwif(ioc);
2024
2025         bfa_ioc_map_port(ioc);
2026         bfa_ioc_reg_init(ioc);
2027 }
2028
2029 /*
2030  * Initialize IOC dma memory
2031  *
2032  * @param[in]   dm_kva  kernel virtual address of IOC dma memory
2033  * @param[in]   dm_pa   physical address of IOC dma memory
2034  */
2035 void
2036 bfa_ioc_mem_claim(struct bfa_ioc_s *ioc,  u8 *dm_kva, u64 dm_pa)
2037 {
2038         /*
2039          * dma memory for firmware attribute
2040          */
2041         ioc->attr_dma.kva = dm_kva;
2042         ioc->attr_dma.pa = dm_pa;
2043         ioc->attr = (struct bfi_ioc_attr_s *) dm_kva;
2044 }
2045
2046 /*
2047  * Return size of dma memory required.
2048  */
2049 u32
2050 bfa_ioc_meminfo(void)
2051 {
2052         return BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ);
2053 }
2054
2055 void
2056 bfa_ioc_enable(struct bfa_ioc_s *ioc)
2057 {
2058         bfa_ioc_stats(ioc, ioc_enables);
2059         ioc->dbg_fwsave_once = BFA_TRUE;
2060
2061         bfa_fsm_send_event(ioc, IOC_E_ENABLE);
2062 }
2063
2064 void
2065 bfa_ioc_disable(struct bfa_ioc_s *ioc)
2066 {
2067         bfa_ioc_stats(ioc, ioc_disables);
2068         bfa_fsm_send_event(ioc, IOC_E_DISABLE);
2069 }
2070
2071 /*
2072  * Returns memory required for saving firmware trace in case of crash.
2073  * Driver must call this interface to allocate memory required for
2074  * automatic saving of firmware trace. Driver should call
2075  * bfa_ioc_debug_memclaim() right after bfa_ioc_attach() to setup this
2076  * trace memory.
2077  */
2078 int
2079 bfa_ioc_debug_trcsz(bfa_boolean_t auto_recover)
2080 {
2081         return (auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
2082 }
2083
2084 /*
2085  * Initialize memory for saving firmware trace. Driver must initialize
2086  * trace memory before call bfa_ioc_enable().
2087  */
2088 void
2089 bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
2090 {
2091         ioc->dbg_fwsave     = dbg_fwsave;
2092         ioc->dbg_fwsave_len = bfa_ioc_debug_trcsz(ioc->iocpf.auto_recover);
2093 }
2094
2095 u32
2096 bfa_ioc_smem_pgnum(struct bfa_ioc_s *ioc, u32 fmaddr)
2097 {
2098         return PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, fmaddr);
2099 }
2100
2101 u32
2102 bfa_ioc_smem_pgoff(struct bfa_ioc_s *ioc, u32 fmaddr)
2103 {
2104         return PSS_SMEM_PGOFF(fmaddr);
2105 }
2106
2107 /*
2108  * Register mailbox message handler functions
2109  *
2110  * @param[in]   ioc             IOC instance
2111  * @param[in]   mcfuncs         message class handler functions
2112  */
2113 void
2114 bfa_ioc_mbox_register(struct bfa_ioc_s *ioc, bfa_ioc_mbox_mcfunc_t *mcfuncs)
2115 {
2116         struct bfa_ioc_mbox_mod_s       *mod = &ioc->mbox_mod;
2117         int                             mc;
2118
2119         for (mc = 0; mc < BFI_MC_MAX; mc++)
2120                 mod->mbhdlr[mc].cbfn = mcfuncs[mc];
2121 }
2122
2123 /*
2124  * Register mailbox message handler function, to be called by common modules
2125  */
2126 void
2127 bfa_ioc_mbox_regisr(struct bfa_ioc_s *ioc, enum bfi_mclass mc,
2128                     bfa_ioc_mbox_mcfunc_t cbfn, void *cbarg)
2129 {
2130         struct bfa_ioc_mbox_mod_s       *mod = &ioc->mbox_mod;
2131
2132         mod->mbhdlr[mc].cbfn    = cbfn;
2133         mod->mbhdlr[mc].cbarg   = cbarg;
2134 }
2135
2136 /*
2137  * Queue a mailbox command request to firmware. Waits if mailbox is busy.
2138  * Responsibility of caller to serialize
2139  *
2140  * @param[in]   ioc     IOC instance
2141  * @param[i]    cmd     Mailbox command
2142  */
2143 void
2144 bfa_ioc_mbox_queue(struct bfa_ioc_s *ioc, struct bfa_mbox_cmd_s *cmd)
2145 {
2146         struct bfa_ioc_mbox_mod_s       *mod = &ioc->mbox_mod;
2147         u32                     stat;
2148
2149         /*
2150          * If a previous command is pending, queue new command
2151          */
2152         if (!list_empty(&mod->cmd_q)) {
2153                 list_add_tail(&cmd->qe, &mod->cmd_q);
2154                 return;
2155         }
2156
2157         /*
2158          * If mailbox is busy, queue command for poll timer
2159          */
2160         stat = readl(ioc->ioc_regs.hfn_mbox_cmd);
2161         if (stat) {
2162                 list_add_tail(&cmd->qe, &mod->cmd_q);
2163                 return;
2164         }
2165
2166         /*
2167          * mailbox is free -- queue command to firmware
2168          */
2169         bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
2170 }
2171
2172 /*
2173  * Handle mailbox interrupts
2174  */
2175 void
2176 bfa_ioc_mbox_isr(struct bfa_ioc_s *ioc)
2177 {
2178         struct bfa_ioc_mbox_mod_s       *mod = &ioc->mbox_mod;
2179         struct bfi_mbmsg_s              m;
2180         int                             mc;
2181
2182         bfa_ioc_msgget(ioc, &m);
2183
2184         /*
2185          * Treat IOC message class as special.
2186          */
2187         mc = m.mh.msg_class;
2188         if (mc == BFI_MC_IOC) {
2189                 bfa_ioc_isr(ioc, &m);
2190                 return;
2191         }
2192
2193         if ((mc > BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL))
2194                 return;
2195
2196         mod->mbhdlr[mc].cbfn(mod->mbhdlr[mc].cbarg, &m);
2197 }
2198
2199 void
2200 bfa_ioc_error_isr(struct bfa_ioc_s *ioc)
2201 {
2202         bfa_fsm_send_event(ioc, IOC_E_HWERROR);
2203 }
2204
2205 void
2206 bfa_ioc_set_fcmode(struct bfa_ioc_s *ioc)
2207 {
2208         ioc->fcmode  = BFA_TRUE;
2209         ioc->port_id = bfa_ioc_pcifn(ioc);
2210 }
2211
2212 /*
2213  * return true if IOC is disabled
2214  */
2215 bfa_boolean_t
2216 bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
2217 {
2218         return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling) ||
2219                 bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
2220 }
2221
2222 /*
2223  * return true if IOC firmware is different.
2224  */
2225 bfa_boolean_t
2226 bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc)
2227 {
2228         return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset) ||
2229                 bfa_fsm_cmp_state(&ioc->iocpf, bfa_iocpf_sm_fwcheck) ||
2230                 bfa_fsm_cmp_state(&ioc->iocpf, bfa_iocpf_sm_mismatch);
2231 }
2232
2233 #define bfa_ioc_state_disabled(__sm)            \
2234         (((__sm) == BFI_IOC_UNINIT) ||          \
2235          ((__sm) == BFI_IOC_INITING) ||         \
2236          ((__sm) == BFI_IOC_HWINIT) ||          \
2237          ((__sm) == BFI_IOC_DISABLED) ||        \
2238          ((__sm) == BFI_IOC_FAIL) ||            \
2239          ((__sm) == BFI_IOC_CFG_DISABLED))
2240
2241 /*
2242  * Check if adapter is disabled -- both IOCs should be in a disabled
2243  * state.
2244  */
2245 bfa_boolean_t
2246 bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc)
2247 {
2248         u32     ioc_state;
2249         void __iomem *rb = ioc->pcidev.pci_bar_kva;
2250
2251         if (!bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled))
2252                 return BFA_FALSE;
2253
2254         ioc_state = readl(rb + BFA_IOC0_STATE_REG);
2255         if (!bfa_ioc_state_disabled(ioc_state))
2256                 return BFA_FALSE;
2257
2258         if (ioc->pcidev.device_id != BFA_PCI_DEVICE_ID_FC_8G1P) {
2259                 ioc_state = readl(rb + BFA_IOC1_STATE_REG);
2260                 if (!bfa_ioc_state_disabled(ioc_state))
2261                         return BFA_FALSE;
2262         }
2263
2264         return BFA_TRUE;
2265 }
2266
2267 /*
2268  * Add to IOC heartbeat failure notification queue. To be used by common
2269  * modules such as cee, port, diag.
2270  */
2271 void
2272 bfa_ioc_hbfail_register(struct bfa_ioc_s *ioc,
2273                         struct bfa_ioc_hbfail_notify_s *notify)
2274 {
2275         list_add_tail(&notify->qe, &ioc->hb_notify_q);
2276 }
2277
2278 #define BFA_MFG_NAME "Brocade"
2279 void
2280 bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
2281                          struct bfa_adapter_attr_s *ad_attr)
2282 {
2283         struct bfi_ioc_attr_s   *ioc_attr;
2284
2285         ioc_attr = ioc->attr;
2286
2287         bfa_ioc_get_adapter_serial_num(ioc, ad_attr->serial_num);
2288         bfa_ioc_get_adapter_fw_ver(ioc, ad_attr->fw_ver);
2289         bfa_ioc_get_adapter_optrom_ver(ioc, ad_attr->optrom_ver);
2290         bfa_ioc_get_adapter_manufacturer(ioc, ad_attr->manufacturer);
2291         memcpy(&ad_attr->vpd, &ioc_attr->vpd,
2292                       sizeof(struct bfa_mfg_vpd_s));
2293
2294         ad_attr->nports = bfa_ioc_get_nports(ioc);
2295         ad_attr->max_speed = bfa_ioc_speed_sup(ioc);
2296
2297         bfa_ioc_get_adapter_model(ioc, ad_attr->model);
2298         /* For now, model descr uses same model string */
2299         bfa_ioc_get_adapter_model(ioc, ad_attr->model_descr);
2300
2301         ad_attr->card_type = ioc_attr->card_type;
2302         ad_attr->is_mezz = bfa_mfg_is_mezz(ioc_attr->card_type);
2303
2304         if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))
2305                 ad_attr->prototype = 1;
2306         else
2307                 ad_attr->prototype = 0;
2308
2309         ad_attr->pwwn = bfa_ioc_get_pwwn(ioc);
2310         ad_attr->mac  = bfa_ioc_get_mac(ioc);
2311
2312         ad_attr->pcie_gen = ioc_attr->pcie_gen;
2313         ad_attr->pcie_lanes = ioc_attr->pcie_lanes;
2314         ad_attr->pcie_lanes_orig = ioc_attr->pcie_lanes_orig;
2315         ad_attr->asic_rev = ioc_attr->asic_rev;
2316
2317         bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);
2318
2319         ad_attr->cna_capable = ioc->cna;
2320         ad_attr->trunk_capable = (ad_attr->nports > 1) && !ioc->cna;
2321 }
2322
2323 enum bfa_ioc_type_e
2324 bfa_ioc_get_type(struct bfa_ioc_s *ioc)
2325 {
2326         if (!ioc->ctdev || ioc->fcmode)
2327                 return BFA_IOC_TYPE_FC;
2328         else if (ioc->ioc_mc == BFI_MC_IOCFC)
2329                 return BFA_IOC_TYPE_FCoE;
2330         else if (ioc->ioc_mc == BFI_MC_LL)
2331                 return BFA_IOC_TYPE_LL;
2332         else {
2333                 bfa_assert(ioc->ioc_mc == BFI_MC_LL);
2334                 return BFA_IOC_TYPE_LL;
2335         }
2336 }
2337
2338 void
2339 bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num)
2340 {
2341         memset((void *)serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);
2342         memcpy((void *)serial_num,
2343                         (void *)ioc->attr->brcd_serialnum,
2344                         BFA_ADAPTER_SERIAL_NUM_LEN);
2345 }
2346
2347 void
2348 bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver)
2349 {
2350         memset((void *)fw_ver, 0, BFA_VERSION_LEN);
2351         memcpy(fw_ver, ioc->attr->fw_version, BFA_VERSION_LEN);
2352 }
2353
2354 void
2355 bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev)
2356 {
2357         bfa_assert(chip_rev);
2358
2359         memset((void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);
2360
2361         chip_rev[0] = 'R';
2362         chip_rev[1] = 'e';
2363         chip_rev[2] = 'v';
2364         chip_rev[3] = '-';
2365         chip_rev[4] = ioc->attr->asic_rev;
2366         chip_rev[5] = '\0';
2367 }
2368
2369 void
2370 bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver)
2371 {
2372         memset((void *)optrom_ver, 0, BFA_VERSION_LEN);
2373         memcpy(optrom_ver, ioc->attr->optrom_version,
2374                       BFA_VERSION_LEN);
2375 }
2376
2377 void
2378 bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc, char *manufacturer)
2379 {
2380         memset((void *)manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);
2381         memcpy(manufacturer, BFA_MFG_NAME, BFA_ADAPTER_MFG_NAME_LEN);
2382 }
2383
2384 void
2385 bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model)
2386 {
2387         struct bfi_ioc_attr_s   *ioc_attr;
2388
2389         bfa_assert(model);
2390         memset((void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);
2391
2392         ioc_attr = ioc->attr;
2393
2394         /*
2395          * model name
2396          */
2397         snprintf(model, BFA_ADAPTER_MODEL_NAME_LEN, "%s-%u",
2398                 BFA_MFG_NAME, ioc_attr->card_type);
2399 }
2400
2401 enum bfa_ioc_state
2402 bfa_ioc_get_state(struct bfa_ioc_s *ioc)
2403 {
2404         enum bfa_iocpf_state iocpf_st;
2405         enum bfa_ioc_state ioc_st = bfa_sm_to_state(ioc_sm_table, ioc->fsm);
2406
2407         if (ioc_st == BFA_IOC_ENABLING ||
2408                 ioc_st == BFA_IOC_FAIL || ioc_st == BFA_IOC_INITFAIL) {
2409
2410                 iocpf_st = bfa_sm_to_state(iocpf_sm_table, ioc->iocpf.fsm);
2411
2412                 switch (iocpf_st) {
2413                 case BFA_IOCPF_SEMWAIT:
2414                         ioc_st = BFA_IOC_SEMWAIT;
2415                         break;
2416
2417                 case BFA_IOCPF_HWINIT:
2418                         ioc_st = BFA_IOC_HWINIT;
2419                         break;
2420
2421                 case BFA_IOCPF_FWMISMATCH:
2422                         ioc_st = BFA_IOC_FWMISMATCH;
2423                         break;
2424
2425                 case BFA_IOCPF_FAIL:
2426                         ioc_st = BFA_IOC_FAIL;
2427                         break;
2428
2429                 case BFA_IOCPF_INITFAIL:
2430                         ioc_st = BFA_IOC_INITFAIL;
2431                         break;
2432
2433                 default:
2434                         break;
2435                 }
2436         }
2437
2438         return ioc_st;
2439 }
2440
2441 void
2442 bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr)
2443 {
2444         memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr_s));
2445
2446         ioc_attr->state = bfa_ioc_get_state(ioc);
2447         ioc_attr->port_id = ioc->port_id;
2448
2449         ioc_attr->ioc_type = bfa_ioc_get_type(ioc);
2450
2451         bfa_ioc_get_adapter_attr(ioc, &ioc_attr->adapter_attr);
2452
2453         ioc_attr->pci_attr.device_id = ioc->pcidev.device_id;
2454         ioc_attr->pci_attr.pcifn = ioc->pcidev.pci_func;
2455         bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
2456 }
2457
2458 /*
2459  *  hal_wwn_public
2460  */
2461 wwn_t
2462 bfa_ioc_get_pwwn(struct bfa_ioc_s *ioc)
2463 {
2464         return ioc->attr->pwwn;
2465 }
2466
2467 wwn_t
2468 bfa_ioc_get_nwwn(struct bfa_ioc_s *ioc)
2469 {
2470         return ioc->attr->nwwn;
2471 }
2472
2473 u64
2474 bfa_ioc_get_adid(struct bfa_ioc_s *ioc)
2475 {
2476         return ioc->attr->mfg_pwwn;
2477 }
2478
2479 mac_t
2480 bfa_ioc_get_mac(struct bfa_ioc_s *ioc)
2481 {
2482         /*
2483          * Check the IOC type and return the appropriate MAC
2484          */
2485         if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_FCoE)
2486                 return ioc->attr->fcoe_mac;
2487         else
2488                 return ioc->attr->mac;
2489 }
2490
2491 wwn_t
2492 bfa_ioc_get_mfg_pwwn(struct bfa_ioc_s *ioc)
2493 {
2494         return ioc->attr->mfg_pwwn;
2495 }
2496
2497 wwn_t
2498 bfa_ioc_get_mfg_nwwn(struct bfa_ioc_s *ioc)
2499 {
2500         return ioc->attr->mfg_nwwn;
2501 }
2502
2503 mac_t
2504 bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc)
2505 {
2506         mac_t   m;
2507
2508         m = ioc->attr->mfg_mac;
2509         if (bfa_mfg_is_old_wwn_mac_model(ioc->attr->card_type))
2510                 m.mac[MAC_ADDRLEN - 1] += bfa_ioc_pcifn(ioc);
2511         else
2512                 bfa_mfg_increment_wwn_mac(&(m.mac[MAC_ADDRLEN-3]),
2513                         bfa_ioc_pcifn(ioc));
2514
2515         return m;
2516 }
2517
2518 bfa_boolean_t
2519 bfa_ioc_get_fcmode(struct bfa_ioc_s *ioc)
2520 {
2521         return ioc->fcmode || !bfa_asic_id_ct(ioc->pcidev.device_id);
2522 }
2523
2524 /*
2525  * Retrieve saved firmware trace from a prior IOC failure.
2526  */
2527 bfa_status_t
2528 bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
2529 {
2530         int     tlen;
2531
2532         if (ioc->dbg_fwsave_len == 0)
2533                 return BFA_STATUS_ENOFSAVE;
2534
2535         tlen = *trclen;
2536         if (tlen > ioc->dbg_fwsave_len)
2537                 tlen = ioc->dbg_fwsave_len;
2538
2539         memcpy(trcdata, ioc->dbg_fwsave, tlen);
2540         *trclen = tlen;
2541         return BFA_STATUS_OK;
2542 }
2543
2544 /*
2545  * Clear saved firmware trace
2546  */
2547 void
2548 bfa_ioc_debug_fwsave_clear(struct bfa_ioc_s *ioc)
2549 {
2550         ioc->dbg_fwsave_once = BFA_TRUE;
2551 }
2552
2553 /*
2554  * Retrieve saved firmware trace from a prior IOC failure.
2555  */
2556 bfa_status_t
2557 bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
2558 {
2559         u32 loff = BFA_DBG_FWTRC_OFF(bfa_ioc_portid(ioc));
2560         int tlen;
2561         bfa_status_t status;
2562
2563         bfa_trc(ioc, *trclen);
2564
2565         tlen = *trclen;
2566         if (tlen > BFA_DBG_FWTRC_LEN)
2567                 tlen = BFA_DBG_FWTRC_LEN;
2568
2569         status = bfa_ioc_smem_read(ioc, trcdata, loff, tlen);
2570         *trclen = tlen;
2571         return status;
2572 }
2573
2574 static void
2575 bfa_ioc_send_fwsync(struct bfa_ioc_s *ioc)
2576 {
2577         struct bfa_mbox_cmd_s cmd;
2578         struct bfi_ioc_ctrl_req_s *req = (struct bfi_ioc_ctrl_req_s *) cmd.msg;
2579
2580         bfi_h2i_set(req->mh, BFI_MC_IOC, BFI_IOC_H2I_DBG_SYNC,
2581                     bfa_ioc_portid(ioc));
2582         req->ioc_class = ioc->ioc_mc;
2583         bfa_ioc_mbox_queue(ioc, &cmd);
2584 }
2585
2586 static void
2587 bfa_ioc_fwsync(struct bfa_ioc_s *ioc)
2588 {
2589         u32 fwsync_iter = 1000;
2590
2591         bfa_ioc_send_fwsync(ioc);
2592
2593         /*
2594          * After sending a fw sync mbox command wait for it to
2595          * take effect.  We will not wait for a response because
2596          *    1. fw_sync mbox cmd doesn't have a response.
2597          *    2. Even if we implement that,  interrupts might not
2598          *       be enabled when we call this function.
2599          * So, just keep checking if any mbox cmd is pending, and
2600          * after waiting for a reasonable amount of time, go ahead.
2601          * It is possible that fw has crashed and the mbox command
2602          * is never acknowledged.
2603          */
2604         while (bfa_ioc_mbox_cmd_pending(ioc) && fwsync_iter > 0)
2605                 fwsync_iter--;
2606 }
2607
2608 /*
2609  * Dump firmware smem
2610  */
2611 bfa_status_t
2612 bfa_ioc_debug_fwcore(struct bfa_ioc_s *ioc, void *buf,
2613                                 u32 *offset, int *buflen)
2614 {
2615         u32 loff;
2616         int dlen;
2617         bfa_status_t status;
2618         u32 smem_len = BFA_IOC_FW_SMEM_SIZE(ioc);
2619
2620         if (*offset >= smem_len) {
2621                 *offset = *buflen = 0;
2622                 return BFA_STATUS_EINVAL;
2623         }
2624
2625         loff = *offset;
2626         dlen = *buflen;
2627
2628         /*
2629          * First smem read, sync smem before proceeding
2630          * No need to sync before reading every chunk.
2631          */
2632         if (loff == 0)
2633                 bfa_ioc_fwsync(ioc);
2634
2635         if ((loff + dlen) >= smem_len)
2636                 dlen = smem_len - loff;
2637
2638         status = bfa_ioc_smem_read(ioc, buf, loff, dlen);
2639
2640         if (status != BFA_STATUS_OK) {
2641                 *offset = *buflen = 0;
2642                 return status;
2643         }
2644
2645         *offset += dlen;
2646
2647         if (*offset >= smem_len)
2648                 *offset = 0;
2649
2650         *buflen = dlen;
2651
2652         return status;
2653 }
2654
2655 /*
2656  * Firmware statistics
2657  */
2658 bfa_status_t
2659 bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats)
2660 {
2661         u32 loff = BFI_IOC_FWSTATS_OFF + \
2662                 BFI_IOC_FWSTATS_SZ * (bfa_ioc_portid(ioc));
2663         int tlen;
2664         bfa_status_t status;
2665
2666         if (ioc->stats_busy) {
2667                 bfa_trc(ioc, ioc->stats_busy);
2668                 return BFA_STATUS_DEVBUSY;
2669         }
2670         ioc->stats_busy = BFA_TRUE;
2671
2672         tlen = sizeof(struct bfa_fw_stats_s);
2673         status = bfa_ioc_smem_read(ioc, stats, loff, tlen);
2674
2675         ioc->stats_busy = BFA_FALSE;
2676         return status;
2677 }
2678
2679 bfa_status_t
2680 bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc)
2681 {
2682         u32 loff = BFI_IOC_FWSTATS_OFF + \
2683                 BFI_IOC_FWSTATS_SZ * (bfa_ioc_portid(ioc));
2684         int tlen;
2685         bfa_status_t status;
2686
2687         if (ioc->stats_busy) {
2688                 bfa_trc(ioc, ioc->stats_busy);
2689                 return BFA_STATUS_DEVBUSY;
2690         }
2691         ioc->stats_busy = BFA_TRUE;
2692
2693         tlen = sizeof(struct bfa_fw_stats_s);
2694         status = bfa_ioc_smem_clr(ioc, loff, tlen);
2695
2696         ioc->stats_busy = BFA_FALSE;
2697         return status;
2698 }
2699
2700 /*
2701  * Save firmware trace if configured.
2702  */
2703 static void
2704 bfa_ioc_debug_save(struct bfa_ioc_s *ioc)
2705 {
2706         int             tlen;
2707
2708         if (ioc->dbg_fwsave_len) {
2709                 tlen = ioc->dbg_fwsave_len;
2710                 bfa_ioc_debug_fwtrc(ioc, ioc->dbg_fwsave, &tlen);
2711         }
2712 }
2713
2714 /*
2715  * Firmware failure detected. Start recovery actions.
2716  */
2717 static void
2718 bfa_ioc_recover(struct bfa_ioc_s *ioc)
2719 {
2720         if (ioc->dbg_fwsave_once) {
2721                 ioc->dbg_fwsave_once = BFA_FALSE;
2722                 bfa_ioc_debug_save(ioc);
2723         }
2724
2725         bfa_ioc_stats(ioc, ioc_hbfails);
2726         bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
2727 }
2728
2729 static void
2730 bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc)
2731 {
2732         if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_LL)
2733                 return;
2734 }
2735
2736 /*
2737  *  hal_iocpf_pvt BFA IOC PF private functions
2738  */
2739
2740 static void
2741 bfa_iocpf_enable(struct bfa_ioc_s *ioc)
2742 {
2743         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_ENABLE);
2744 }
2745
2746 static void
2747 bfa_iocpf_disable(struct bfa_ioc_s *ioc)
2748 {
2749         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_DISABLE);
2750 }
2751
2752 static void
2753 bfa_iocpf_fail(struct bfa_ioc_s *ioc)
2754 {
2755         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_FAIL);
2756 }
2757
2758 static void
2759 bfa_iocpf_initfail(struct bfa_ioc_s *ioc)
2760 {
2761         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_INITFAIL);
2762 }
2763
2764 static void
2765 bfa_iocpf_getattrfail(struct bfa_ioc_s *ioc)
2766 {
2767         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_GETATTRFAIL);
2768 }
2769
2770 static void
2771 bfa_iocpf_stop(struct bfa_ioc_s *ioc)
2772 {
2773         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_STOP);
2774 }
2775
2776 static void
2777 bfa_iocpf_timeout(void *ioc_arg)
2778 {
2779         struct bfa_ioc_s  *ioc = (struct bfa_ioc_s *) ioc_arg;
2780
2781         bfa_trc(ioc, 0);
2782         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_TIMEOUT);
2783 }
2784
2785 static void
2786 bfa_iocpf_sem_timeout(void *ioc_arg)
2787 {
2788         struct bfa_ioc_s  *ioc = (struct bfa_ioc_s *) ioc_arg;
2789
2790         bfa_ioc_hw_sem_get(ioc);
2791 }
2792
2793 /*
2794  *  bfa timer function
2795  */
2796 void
2797 bfa_timer_init(struct bfa_timer_mod_s *mod)
2798 {
2799         INIT_LIST_HEAD(&mod->timer_q);
2800 }
2801
2802 void
2803 bfa_timer_beat(struct bfa_timer_mod_s *mod)
2804 {
2805         struct list_head *qh = &mod->timer_q;
2806         struct list_head *qe, *qe_next;
2807         struct bfa_timer_s *elem;
2808         struct list_head timedout_q;
2809
2810         INIT_LIST_HEAD(&timedout_q);
2811
2812         qe = bfa_q_next(qh);
2813
2814         while (qe != qh) {
2815                 qe_next = bfa_q_next(qe);
2816
2817                 elem = (struct bfa_timer_s *) qe;
2818                 if (elem->timeout <= BFA_TIMER_FREQ) {
2819                         elem->timeout = 0;
2820                         list_del(&elem->qe);
2821                         list_add_tail(&elem->qe, &timedout_q);
2822                 } else {
2823                         elem->timeout -= BFA_TIMER_FREQ;
2824                 }
2825
2826                 qe = qe_next;   /* go to next elem */
2827         }
2828
2829         /*
2830          * Pop all the timeout entries
2831          */
2832         while (!list_empty(&timedout_q)) {
2833                 bfa_q_deq(&timedout_q, &elem);
2834                 elem->timercb(elem->arg);
2835         }
2836 }
2837
2838 /*
2839  * Should be called with lock protection
2840  */
2841 void
2842 bfa_timer_begin(struct bfa_timer_mod_s *mod, struct bfa_timer_s *timer,
2843                     void (*timercb) (void *), void *arg, unsigned int timeout)
2844 {
2845
2846         bfa_assert(timercb != NULL);
2847         bfa_assert(!bfa_q_is_on_q(&mod->timer_q, timer));
2848
2849         timer->timeout = timeout;
2850         timer->timercb = timercb;
2851         timer->arg = arg;
2852
2853         list_add_tail(&timer->qe, &mod->timer_q);
2854 }
2855
2856 /*
2857  * Should be called with lock protection
2858  */
2859 void
2860 bfa_timer_stop(struct bfa_timer_s *timer)
2861 {
2862         bfa_assert(!list_empty(&timer->qe));
2863
2864         list_del(&timer->qe);
2865 }