aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/bfa/bfa_core.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/bfa/bfa_core.c')
-rw-r--r--drivers/scsi/bfa/bfa_core.c799
1 files changed, 224 insertions, 575 deletions
diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 342d7d9c099..4bd546bcc24 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -165,16 +165,6 @@ bfa_com_phy_attach(struct bfa_s *bfa, bfa_boolean_t mincfg)
165 bfa_phy_memclaim(phy, phy_dma->kva_curp, phy_dma->dma_curp, mincfg); 165 bfa_phy_memclaim(phy, phy_dma->kva_curp, phy_dma->dma_curp, mincfg);
166} 166}
167 167
168static void
169bfa_com_fru_attach(struct bfa_s *bfa, bfa_boolean_t mincfg)
170{
171 struct bfa_fru_s *fru = BFA_FRU(bfa);
172 struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa);
173
174 bfa_fru_attach(fru, &bfa->ioc, bfa, bfa->trcmod, mincfg);
175 bfa_fru_memclaim(fru, fru_dma->kva_curp, fru_dma->dma_curp, mincfg);
176}
177
178/* 168/*
179 * BFA IOC FC related definitions 169 * BFA IOC FC related definitions
180 */ 170 */
@@ -210,484 +200,13 @@ enum {
210#define DEF_CFG_NUM_SBOOT_LUNS 16 200#define DEF_CFG_NUM_SBOOT_LUNS 16
211 201
212/* 202/*
213 * IOCFC state machine definitions/declarations
214 */
215bfa_fsm_state_decl(bfa_iocfc, stopped, struct bfa_iocfc_s, enum iocfc_event);
216bfa_fsm_state_decl(bfa_iocfc, initing, struct bfa_iocfc_s, enum iocfc_event);
217bfa_fsm_state_decl(bfa_iocfc, dconf_read, struct bfa_iocfc_s, enum iocfc_event);
218bfa_fsm_state_decl(bfa_iocfc, init_cfg_wait,
219 struct bfa_iocfc_s, enum iocfc_event);
220bfa_fsm_state_decl(bfa_iocfc, init_cfg_done,
221 struct bfa_iocfc_s, enum iocfc_event);
222bfa_fsm_state_decl(bfa_iocfc, operational,
223 struct bfa_iocfc_s, enum iocfc_event);
224bfa_fsm_state_decl(bfa_iocfc, dconf_write,
225 struct bfa_iocfc_s, enum iocfc_event);
226bfa_fsm_state_decl(bfa_iocfc, stopping, struct bfa_iocfc_s, enum iocfc_event);
227bfa_fsm_state_decl(bfa_iocfc, enabling, struct bfa_iocfc_s, enum iocfc_event);
228bfa_fsm_state_decl(bfa_iocfc, cfg_wait, struct bfa_iocfc_s, enum iocfc_event);
229bfa_fsm_state_decl(bfa_iocfc, disabling, struct bfa_iocfc_s, enum iocfc_event);
230bfa_fsm_state_decl(bfa_iocfc, disabled, struct bfa_iocfc_s, enum iocfc_event);
231bfa_fsm_state_decl(bfa_iocfc, failed, struct bfa_iocfc_s, enum iocfc_event);
232bfa_fsm_state_decl(bfa_iocfc, init_failed,
233 struct bfa_iocfc_s, enum iocfc_event);
234
235/*
236 * forward declaration for IOC FC functions 203 * forward declaration for IOC FC functions
237 */ 204 */
238static void bfa_iocfc_start_submod(struct bfa_s *bfa);
239static void bfa_iocfc_disable_submod(struct bfa_s *bfa);
240static void bfa_iocfc_send_cfg(void *bfa_arg);
241static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status); 205static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status);
242static void bfa_iocfc_disable_cbfn(void *bfa_arg); 206static void bfa_iocfc_disable_cbfn(void *bfa_arg);
243static void bfa_iocfc_hbfail_cbfn(void *bfa_arg); 207static void bfa_iocfc_hbfail_cbfn(void *bfa_arg);
244static void bfa_iocfc_reset_cbfn(void *bfa_arg); 208static void bfa_iocfc_reset_cbfn(void *bfa_arg);
245static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn; 209static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn;
246static void bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete);
247static void bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl);
248static void bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl);
249static void bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl);
250
251static void
252bfa_iocfc_sm_stopped_entry(struct bfa_iocfc_s *iocfc)
253{
254}
255
256static void
257bfa_iocfc_sm_stopped(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
258{
259 bfa_trc(iocfc->bfa, event);
260
261 switch (event) {
262 case IOCFC_E_INIT:
263 case IOCFC_E_ENABLE:
264 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_initing);
265 break;
266 default:
267 bfa_sm_fault(iocfc->bfa, event);
268 break;
269 }
270}
271
272static void
273bfa_iocfc_sm_initing_entry(struct bfa_iocfc_s *iocfc)
274{
275 bfa_ioc_enable(&iocfc->bfa->ioc);
276}
277
278static void
279bfa_iocfc_sm_initing(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
280{
281 bfa_trc(iocfc->bfa, event);
282
283 switch (event) {
284 case IOCFC_E_IOC_ENABLED:
285 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
286 break;
287
288 case IOCFC_E_DISABLE:
289 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
290 break;
291
292 case IOCFC_E_STOP:
293 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
294 break;
295
296 case IOCFC_E_IOC_FAILED:
297 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
298 break;
299 default:
300 bfa_sm_fault(iocfc->bfa, event);
301 break;
302 }
303}
304
305static void
306bfa_iocfc_sm_dconf_read_entry(struct bfa_iocfc_s *iocfc)
307{
308 bfa_dconf_modinit(iocfc->bfa);
309}
310
311static void
312bfa_iocfc_sm_dconf_read(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
313{
314 bfa_trc(iocfc->bfa, event);
315
316 switch (event) {
317 case IOCFC_E_DCONF_DONE:
318 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_wait);
319 break;
320
321 case IOCFC_E_DISABLE:
322 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
323 break;
324
325 case IOCFC_E_STOP:
326 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
327 break;
328
329 case IOCFC_E_IOC_FAILED:
330 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
331 break;
332 default:
333 bfa_sm_fault(iocfc->bfa, event);
334 break;
335 }
336}
337
338static void
339bfa_iocfc_sm_init_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
340{
341 bfa_iocfc_send_cfg(iocfc->bfa);
342}
343
344static void
345bfa_iocfc_sm_init_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
346{
347 bfa_trc(iocfc->bfa, event);
348
349 switch (event) {
350 case IOCFC_E_CFG_DONE:
351 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_cfg_done);
352 break;
353
354 case IOCFC_E_DISABLE:
355 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
356 break;
357
358 case IOCFC_E_STOP:
359 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
360 break;
361
362 case IOCFC_E_IOC_FAILED:
363 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_init_failed);
364 break;
365 default:
366 bfa_sm_fault(iocfc->bfa, event);
367 break;
368 }
369}
370
371static void
372bfa_iocfc_sm_init_cfg_done_entry(struct bfa_iocfc_s *iocfc)
373{
374 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
375 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
376 bfa_iocfc_init_cb, iocfc->bfa);
377}
378
379static void
380bfa_iocfc_sm_init_cfg_done(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
381{
382 bfa_trc(iocfc->bfa, event);
383
384 switch (event) {
385 case IOCFC_E_START:
386 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
387 break;
388 case IOCFC_E_STOP:
389 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
390 break;
391 case IOCFC_E_DISABLE:
392 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
393 break;
394 case IOCFC_E_IOC_FAILED:
395 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
396 break;
397 default:
398 bfa_sm_fault(iocfc->bfa, event);
399 break;
400 }
401}
402
403static void
404bfa_iocfc_sm_operational_entry(struct bfa_iocfc_s *iocfc)
405{
406 bfa_fcport_init(iocfc->bfa);
407 bfa_iocfc_start_submod(iocfc->bfa);
408}
409
410static void
411bfa_iocfc_sm_operational(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
412{
413 bfa_trc(iocfc->bfa, event);
414
415 switch (event) {
416 case IOCFC_E_STOP:
417 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
418 break;
419 case IOCFC_E_DISABLE:
420 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
421 break;
422 case IOCFC_E_IOC_FAILED:
423 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
424 break;
425 default:
426 bfa_sm_fault(iocfc->bfa, event);
427 break;
428 }
429}
430
431static void
432bfa_iocfc_sm_dconf_write_entry(struct bfa_iocfc_s *iocfc)
433{
434 bfa_dconf_modexit(iocfc->bfa);
435}
436
437static void
438bfa_iocfc_sm_dconf_write(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
439{
440 bfa_trc(iocfc->bfa, event);
441
442 switch (event) {
443 case IOCFC_E_DCONF_DONE:
444 case IOCFC_E_IOC_FAILED:
445 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
446 break;
447 default:
448 bfa_sm_fault(iocfc->bfa, event);
449 break;
450 }
451}
452
453static void
454bfa_iocfc_sm_stopping_entry(struct bfa_iocfc_s *iocfc)
455{
456 bfa_ioc_disable(&iocfc->bfa->ioc);
457}
458
459static void
460bfa_iocfc_sm_stopping(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
461{
462 bfa_trc(iocfc->bfa, event);
463
464 switch (event) {
465 case IOCFC_E_IOC_DISABLED:
466 bfa_isr_disable(iocfc->bfa);
467 bfa_iocfc_disable_submod(iocfc->bfa);
468 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
469 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
470 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.stop_hcb_qe,
471 bfa_iocfc_stop_cb, iocfc->bfa);
472 break;
473
474 case IOCFC_E_IOC_ENABLED:
475 case IOCFC_E_DCONF_DONE:
476 case IOCFC_E_CFG_DONE:
477 break;
478
479 default:
480 bfa_sm_fault(iocfc->bfa, event);
481 break;
482 }
483}
484
485static void
486bfa_iocfc_sm_enabling_entry(struct bfa_iocfc_s *iocfc)
487{
488 bfa_ioc_enable(&iocfc->bfa->ioc);
489}
490
491static void
492bfa_iocfc_sm_enabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
493{
494 bfa_trc(iocfc->bfa, event);
495
496 switch (event) {
497 case IOCFC_E_IOC_ENABLED:
498 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
499 break;
500
501 case IOCFC_E_DISABLE:
502 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
503 break;
504
505 case IOCFC_E_STOP:
506 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
507 break;
508
509 case IOCFC_E_IOC_FAILED:
510 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
511
512 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
513 break;
514
515 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
516 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
517 bfa_iocfc_enable_cb, iocfc->bfa);
518 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
519 break;
520 default:
521 bfa_sm_fault(iocfc->bfa, event);
522 break;
523 }
524}
525
526static void
527bfa_iocfc_sm_cfg_wait_entry(struct bfa_iocfc_s *iocfc)
528{
529 bfa_iocfc_send_cfg(iocfc->bfa);
530}
531
532static void
533bfa_iocfc_sm_cfg_wait(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
534{
535 bfa_trc(iocfc->bfa, event);
536
537 switch (event) {
538 case IOCFC_E_CFG_DONE:
539 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_operational);
540 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
541 break;
542
543 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
544 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
545 bfa_iocfc_enable_cb, iocfc->bfa);
546 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
547 break;
548 case IOCFC_E_DISABLE:
549 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
550 break;
551
552 case IOCFC_E_STOP:
553 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
554 break;
555 case IOCFC_E_IOC_FAILED:
556 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_failed);
557 if (iocfc->bfa->iocfc.cb_reqd == BFA_FALSE)
558 break;
559
560 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
561 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.en_hcb_qe,
562 bfa_iocfc_enable_cb, iocfc->bfa);
563 iocfc->bfa->iocfc.cb_reqd = BFA_FALSE;
564 break;
565 default:
566 bfa_sm_fault(iocfc->bfa, event);
567 break;
568 }
569}
570
571static void
572bfa_iocfc_sm_disabling_entry(struct bfa_iocfc_s *iocfc)
573{
574 bfa_ioc_disable(&iocfc->bfa->ioc);
575}
576
577static void
578bfa_iocfc_sm_disabling(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
579{
580 bfa_trc(iocfc->bfa, event);
581
582 switch (event) {
583 case IOCFC_E_IOC_DISABLED:
584 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabled);
585 break;
586 case IOCFC_E_IOC_ENABLED:
587 case IOCFC_E_DCONF_DONE:
588 case IOCFC_E_CFG_DONE:
589 break;
590 default:
591 bfa_sm_fault(iocfc->bfa, event);
592 break;
593 }
594}
595
596static void
597bfa_iocfc_sm_disabled_entry(struct bfa_iocfc_s *iocfc)
598{
599 bfa_isr_disable(iocfc->bfa);
600 bfa_iocfc_disable_submod(iocfc->bfa);
601 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
602 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
603 bfa_iocfc_disable_cb, iocfc->bfa);
604}
605
606static void
607bfa_iocfc_sm_disabled(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
608{
609 bfa_trc(iocfc->bfa, event);
610
611 switch (event) {
612 case IOCFC_E_STOP:
613 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
614 break;
615 case IOCFC_E_ENABLE:
616 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_enabling);
617 break;
618 default:
619 bfa_sm_fault(iocfc->bfa, event);
620 break;
621 }
622}
623
624static void
625bfa_iocfc_sm_failed_entry(struct bfa_iocfc_s *iocfc)
626{
627 bfa_isr_disable(iocfc->bfa);
628 bfa_iocfc_disable_submod(iocfc->bfa);
629}
630
631static void
632bfa_iocfc_sm_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
633{
634 bfa_trc(iocfc->bfa, event);
635
636 switch (event) {
637 case IOCFC_E_STOP:
638 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_write);
639 break;
640 case IOCFC_E_DISABLE:
641 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_disabling);
642 break;
643 case IOCFC_E_IOC_ENABLED:
644 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_cfg_wait);
645 break;
646 case IOCFC_E_IOC_FAILED:
647 break;
648 default:
649 bfa_sm_fault(iocfc->bfa, event);
650 break;
651 }
652}
653
654static void
655bfa_iocfc_sm_init_failed_entry(struct bfa_iocfc_s *iocfc)
656{
657 bfa_isr_disable(iocfc->bfa);
658 iocfc->bfa->iocfc.op_status = BFA_STATUS_FAILED;
659 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.init_hcb_qe,
660 bfa_iocfc_init_cb, iocfc->bfa);
661}
662
663static void
664bfa_iocfc_sm_init_failed(struct bfa_iocfc_s *iocfc, enum iocfc_event event)
665{
666 bfa_trc(iocfc->bfa, event);
667
668 switch (event) {
669 case IOCFC_E_STOP:
670 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopping);
671 break;
672 case IOCFC_E_DISABLE:
673 bfa_ioc_disable(&iocfc->bfa->ioc);
674 break;
675 case IOCFC_E_IOC_ENABLED:
676 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_dconf_read);
677 break;
678 case IOCFC_E_IOC_DISABLED:
679 bfa_fsm_set_state(iocfc, bfa_iocfc_sm_stopped);
680 iocfc->bfa->iocfc.op_status = BFA_STATUS_OK;
681 bfa_cb_queue(iocfc->bfa, &iocfc->bfa->iocfc.dis_hcb_qe,
682 bfa_iocfc_disable_cb, iocfc->bfa);
683 break;
684 case IOCFC_E_IOC_FAILED:
685 break;
686 default:
687 bfa_sm_fault(iocfc->bfa, event);
688 break;
689 }
690}
691 210
692/* 211/*
693 * BFA Interrupt handling functions 212 * BFA Interrupt handling functions
@@ -712,19 +231,16 @@ bfa_reqq_resume(struct bfa_s *bfa, int qid)
712 } 231 }
713} 232}
714 233
715bfa_boolean_t 234static inline void
716bfa_isr_rspq(struct bfa_s *bfa, int qid) 235bfa_isr_rspq(struct bfa_s *bfa, int qid)
717{ 236{
718 struct bfi_msg_s *m; 237 struct bfi_msg_s *m;
719 u32 pi, ci; 238 u32 pi, ci;
720 struct list_head *waitq; 239 struct list_head *waitq;
721 bfa_boolean_t ret;
722 240
723 ci = bfa_rspq_ci(bfa, qid); 241 ci = bfa_rspq_ci(bfa, qid);
724 pi = bfa_rspq_pi(bfa, qid); 242 pi = bfa_rspq_pi(bfa, qid);
725 243
726 ret = (ci != pi);
727
728 while (ci != pi) { 244 while (ci != pi) {
729 m = bfa_rspq_elem(bfa, qid, ci); 245 m = bfa_rspq_elem(bfa, qid, ci);
730 WARN_ON(m->mhdr.msg_class >= BFI_MC_MAX); 246 WARN_ON(m->mhdr.msg_class >= BFI_MC_MAX);
@@ -744,8 +260,6 @@ bfa_isr_rspq(struct bfa_s *bfa, int qid)
744 waitq = bfa_reqq(bfa, qid); 260 waitq = bfa_reqq(bfa, qid);
745 if (!list_empty(waitq)) 261 if (!list_empty(waitq))
746 bfa_reqq_resume(bfa, qid); 262 bfa_reqq_resume(bfa, qid);
747
748 return ret;
749} 263}
750 264
751static inline void 265static inline void
@@ -806,7 +320,6 @@ bfa_intx(struct bfa_s *bfa)
806{ 320{
807 u32 intr, qintr; 321 u32 intr, qintr;
808 int queue; 322 int queue;
809 bfa_boolean_t rspq_comp = BFA_FALSE;
810 323
811 intr = readl(bfa->iocfc.bfa_regs.intr_status); 324 intr = readl(bfa->iocfc.bfa_regs.intr_status);
812 325
@@ -819,12 +332,11 @@ bfa_intx(struct bfa_s *bfa)
819 */ 332 */
820 if (bfa->queue_process) { 333 if (bfa->queue_process) {
821 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++) 334 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
822 if (bfa_isr_rspq(bfa, queue)) 335 bfa_isr_rspq(bfa, queue);
823 rspq_comp = BFA_TRUE;
824 } 336 }
825 337
826 if (!intr) 338 if (!intr)
827 return (qintr | rspq_comp) ? BFA_TRUE : BFA_FALSE; 339 return BFA_TRUE;
828 340
829 /* 341 /*
830 * CPE completion queue interrupt 342 * CPE completion queue interrupt
@@ -838,8 +350,7 @@ bfa_intx(struct bfa_s *bfa)
838 if (!intr) 350 if (!intr)
839 return BFA_TRUE; 351 return BFA_TRUE;
840 352
841 if (bfa->intr_enabled) 353 bfa_msix_lpu_err(bfa, intr);
842 bfa_msix_lpu_err(bfa, intr);
843 354
844 return BFA_TRUE; 355 return BFA_TRUE;
845} 356}
@@ -848,37 +359,30 @@ void
848bfa_isr_enable(struct bfa_s *bfa) 359bfa_isr_enable(struct bfa_s *bfa)
849{ 360{
850 u32 umsk; 361 u32 umsk;
851 int port_id = bfa_ioc_portid(&bfa->ioc); 362 int pci_func = bfa_ioc_pcifn(&bfa->ioc);
852 363
853 bfa_trc(bfa, bfa_ioc_pcifn(&bfa->ioc)); 364 bfa_trc(bfa, pci_func);
854 bfa_trc(bfa, port_id);
855 365
856 bfa_msix_ctrl_install(bfa); 366 bfa_msix_ctrl_install(bfa);
857 367
858 if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) { 368 if (bfa_asic_id_ct2(bfa->ioc.pcidev.device_id)) {
859 umsk = __HFN_INT_ERR_MASK_CT2; 369 umsk = __HFN_INT_ERR_MASK_CT2;
860 umsk |= port_id == 0 ? 370 umsk |= pci_func == 0 ?
861 __HFN_INT_FN0_MASK_CT2 : __HFN_INT_FN1_MASK_CT2; 371 __HFN_INT_FN0_MASK_CT2 : __HFN_INT_FN1_MASK_CT2;
862 } else { 372 } else {
863 umsk = __HFN_INT_ERR_MASK; 373 umsk = __HFN_INT_ERR_MASK;
864 umsk |= port_id == 0 ? __HFN_INT_FN0_MASK : __HFN_INT_FN1_MASK; 374 umsk |= pci_func == 0 ? __HFN_INT_FN0_MASK : __HFN_INT_FN1_MASK;
865 } 375 }
866 376
867 writel(umsk, bfa->iocfc.bfa_regs.intr_status); 377 writel(umsk, bfa->iocfc.bfa_regs.intr_status);
868 writel(~umsk, bfa->iocfc.bfa_regs.intr_mask); 378 writel(~umsk, bfa->iocfc.bfa_regs.intr_mask);
869 bfa->iocfc.intr_mask = ~umsk; 379 bfa->iocfc.intr_mask = ~umsk;
870 bfa_isr_mode_set(bfa, bfa->msix.nvecs != 0); 380 bfa_isr_mode_set(bfa, bfa->msix.nvecs != 0);
871
872 /*
873 * Set the flag indicating successful enabling of interrupts
874 */
875 bfa->intr_enabled = BFA_TRUE;
876} 381}
877 382
878void 383void
879bfa_isr_disable(struct bfa_s *bfa) 384bfa_isr_disable(struct bfa_s *bfa)
880{ 385{
881 bfa->intr_enabled = BFA_FALSE;
882 bfa_isr_mode_set(bfa, BFA_FALSE); 386 bfa_isr_mode_set(bfa, BFA_FALSE);
883 writel(-1L, bfa->iocfc.bfa_regs.intr_mask); 387 writel(-1L, bfa->iocfc.bfa_regs.intr_mask);
884 bfa_msix_uninstall(bfa); 388 bfa_msix_uninstall(bfa);
@@ -994,8 +498,7 @@ bfa_iocfc_send_cfg(void *bfa_arg)
994 cfg_info->single_msix_vec = 1; 498 cfg_info->single_msix_vec = 1;
995 cfg_info->endian_sig = BFI_IOC_ENDIAN_SIG; 499 cfg_info->endian_sig = BFI_IOC_ENDIAN_SIG;
996 cfg_info->num_cqs = cfg->fwcfg.num_cqs; 500 cfg_info->num_cqs = cfg->fwcfg.num_cqs;
997 cfg_info->num_ioim_reqs = cpu_to_be16(bfa_fcpim_get_throttle_cfg(bfa, 501 cfg_info->num_ioim_reqs = cpu_to_be16(cfg->fwcfg.num_ioim_reqs);
998 cfg->fwcfg.num_ioim_reqs));
999 cfg_info->num_fwtio_reqs = cpu_to_be16(cfg->fwcfg.num_fwtio_reqs); 502 cfg_info->num_fwtio_reqs = cpu_to_be16(cfg->fwcfg.num_fwtio_reqs);
1000 503
1001 bfa_dma_be_addr_set(cfg_info->cfgrsp_addr, iocfc->cfgrsp_dma.pa); 504 bfa_dma_be_addr_set(cfg_info->cfgrsp_addr, iocfc->cfgrsp_dma.pa);
@@ -1022,9 +525,11 @@ bfa_iocfc_send_cfg(void *bfa_arg)
1022 * Enable interrupt coalescing if it is driver init path 525 * Enable interrupt coalescing if it is driver init path
1023 * and not ioc disable/enable path. 526 * and not ioc disable/enable path.
1024 */ 527 */
1025 if (bfa_fsm_cmp_state(iocfc, bfa_iocfc_sm_init_cfg_wait)) 528 if (!iocfc->cfgdone)
1026 cfg_info->intr_attr.coalesce = BFA_TRUE; 529 cfg_info->intr_attr.coalesce = BFA_TRUE;
1027 530
531 iocfc->cfgdone = BFA_FALSE;
532
1028 /* 533 /*
1029 * dma map IOC configuration itself 534 * dma map IOC configuration itself
1030 */ 535 */
@@ -1044,6 +549,8 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1044 549
1045 bfa->bfad = bfad; 550 bfa->bfad = bfad;
1046 iocfc->bfa = bfa; 551 iocfc->bfa = bfa;
552 iocfc->action = BFA_IOCFC_ACT_NONE;
553
1047 iocfc->cfg = *cfg; 554 iocfc->cfg = *cfg;
1048 555
1049 /* 556 /*
@@ -1094,7 +601,7 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg)
1094{ 601{
1095 u8 *dm_kva = NULL; 602 u8 *dm_kva = NULL;
1096 u64 dm_pa = 0; 603 u64 dm_pa = 0;
1097 int i, per_reqq_sz, per_rspq_sz; 604 int i, per_reqq_sz, per_rspq_sz, dbgsz;
1098 struct bfa_iocfc_s *iocfc = &bfa->iocfc; 605 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1099 struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa); 606 struct bfa_mem_dma_s *ioc_dma = BFA_MEM_IOC_DMA(bfa);
1100 struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa); 607 struct bfa_mem_dma_s *iocfc_dma = BFA_MEM_IOCFC_DMA(bfa);
@@ -1155,8 +662,11 @@ bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg)
1155 BFA_CACHELINE_SZ); 662 BFA_CACHELINE_SZ);
1156 663
1157 /* Claim IOCFC kva memory */ 664 /* Claim IOCFC kva memory */
1158 bfa_ioc_debug_memclaim(&bfa->ioc, bfa_mem_kva_curp(iocfc)); 665 dbgsz = (bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
1159 bfa_mem_kva_curp(iocfc) += BFA_DBG_FWTRC_LEN; 666 if (dbgsz > 0) {
667 bfa_ioc_debug_memclaim(&bfa->ioc, bfa_mem_kva_curp(iocfc));
668 bfa_mem_kva_curp(iocfc) += dbgsz;
669 }
1160} 670}
1161 671
1162/* 672/*
@@ -1173,8 +683,6 @@ bfa_iocfc_start_submod(struct bfa_s *bfa)
1173 683
1174 for (i = 0; hal_mods[i]; i++) 684 for (i = 0; hal_mods[i]; i++)
1175 hal_mods[i]->start(bfa); 685 hal_mods[i]->start(bfa);
1176
1177 bfa->iocfc.submod_enabled = BFA_TRUE;
1178} 686}
1179 687
1180/* 688/*
@@ -1185,13 +693,8 @@ bfa_iocfc_disable_submod(struct bfa_s *bfa)
1185{ 693{
1186 int i; 694 int i;
1187 695
1188 if (bfa->iocfc.submod_enabled == BFA_FALSE)
1189 return;
1190
1191 for (i = 0; hal_mods[i]; i++) 696 for (i = 0; hal_mods[i]; i++)
1192 hal_mods[i]->iocdisable(bfa); 697 hal_mods[i]->iocdisable(bfa);
1193
1194 bfa->iocfc.submod_enabled = BFA_FALSE;
1195} 698}
1196 699
1197static void 700static void
@@ -1199,8 +702,15 @@ bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete)
1199{ 702{
1200 struct bfa_s *bfa = bfa_arg; 703 struct bfa_s *bfa = bfa_arg;
1201 704
1202 if (complete) 705 if (complete) {
1203 bfa_cb_init(bfa->bfad, bfa->iocfc.op_status); 706 if (bfa->iocfc.cfgdone && BFA_DCONF_MOD(bfa)->flashdone)
707 bfa_cb_init(bfa->bfad, BFA_STATUS_OK);
708 else
709 bfa_cb_init(bfa->bfad, BFA_STATUS_FAILED);
710 } else {
711 if (bfa->iocfc.cfgdone)
712 bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
713 }
1204} 714}
1205 715
1206static void 716static void
@@ -1211,6 +721,8 @@ bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl)
1211 721
1212 if (compl) 722 if (compl)
1213 complete(&bfad->comp); 723 complete(&bfad->comp);
724 else
725 bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
1214} 726}
1215 727
1216static void 728static void
@@ -1257,14 +769,10 @@ bfa_iocfc_qreg(struct bfa_s *bfa, struct bfi_iocfc_qreg_s *qreg)
1257static void 769static void
1258bfa_iocfc_res_recfg(struct bfa_s *bfa, struct bfa_iocfc_fwcfg_s *fwcfg) 770bfa_iocfc_res_recfg(struct bfa_s *bfa, struct bfa_iocfc_fwcfg_s *fwcfg)
1259{ 771{
1260 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1261 struct bfi_iocfc_cfg_s *cfg_info = iocfc->cfginfo;
1262
1263 bfa_fcxp_res_recfg(bfa, fwcfg->num_fcxp_reqs); 772 bfa_fcxp_res_recfg(bfa, fwcfg->num_fcxp_reqs);
1264 bfa_uf_res_recfg(bfa, fwcfg->num_uf_bufs); 773 bfa_uf_res_recfg(bfa, fwcfg->num_uf_bufs);
1265 bfa_rport_res_recfg(bfa, fwcfg->num_rports); 774 bfa_rport_res_recfg(bfa, fwcfg->num_rports);
1266 bfa_fcp_res_recfg(bfa, cpu_to_be16(cfg_info->num_ioim_reqs), 775 bfa_fcp_res_recfg(bfa, fwcfg->num_ioim_reqs);
1267 fwcfg->num_ioim_reqs);
1268 bfa_tskim_res_recfg(bfa, fwcfg->num_tskim_reqs); 776 bfa_tskim_res_recfg(bfa, fwcfg->num_tskim_reqs);
1269} 777}
1270 778
@@ -1286,6 +794,8 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
1286 fwcfg->num_uf_bufs = be16_to_cpu(fwcfg->num_uf_bufs); 794 fwcfg->num_uf_bufs = be16_to_cpu(fwcfg->num_uf_bufs);
1287 fwcfg->num_rports = be16_to_cpu(fwcfg->num_rports); 795 fwcfg->num_rports = be16_to_cpu(fwcfg->num_rports);
1288 796
797 iocfc->cfgdone = BFA_TRUE;
798
1289 /* 799 /*
1290 * configure queue register offsets as learnt from firmware 800 * configure queue register offsets as learnt from firmware
1291 */ 801 */
@@ -1301,13 +811,22 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
1301 */ 811 */
1302 bfa_msix_queue_install(bfa); 812 bfa_msix_queue_install(bfa);
1303 813
1304 if (bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn != 0) { 814 /*
1305 bfa->ioc.attr->pwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_pwwn; 815 * Configuration is complete - initialize/start submodules
1306 bfa->ioc.attr->nwwn = bfa->iocfc.cfgrsp->pbc_cfg.pbc_nwwn; 816 */
1307 bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE); 817 bfa_fcport_init(bfa);
818
819 if (iocfc->action == BFA_IOCFC_ACT_INIT) {
820 if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
821 bfa_cb_queue(bfa, &iocfc->init_hcb_qe,
822 bfa_iocfc_init_cb, bfa);
823 } else {
824 if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
825 bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
826 bfa_iocfc_enable_cb, bfa);
827 bfa_iocfc_start_submod(bfa);
1308 } 828 }
1309} 829}
1310
1311void 830void
1312bfa_iocfc_reset_queues(struct bfa_s *bfa) 831bfa_iocfc_reset_queues(struct bfa_s *bfa)
1313{ 832{
@@ -1321,23 +840,6 @@ bfa_iocfc_reset_queues(struct bfa_s *bfa)
1321 } 840 }
1322} 841}
1323 842
1324/*
1325 * Process FAA pwwn msg from fw.
1326 */
1327static void
1328bfa_iocfc_process_faa_addr(struct bfa_s *bfa, struct bfi_faa_addr_msg_s *msg)
1329{
1330 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
1331 struct bfi_iocfc_cfgrsp_s *cfgrsp = iocfc->cfgrsp;
1332
1333 cfgrsp->pbc_cfg.pbc_pwwn = msg->pwwn;
1334 cfgrsp->pbc_cfg.pbc_nwwn = msg->nwwn;
1335
1336 bfa->ioc.attr->pwwn = msg->pwwn;
1337 bfa->ioc.attr->nwwn = msg->nwwn;
1338 bfa_fsm_send_event(iocfc, IOCFC_E_CFG_DONE);
1339}
1340
1341/* Fabric Assigned Address specific functions */ 843/* Fabric Assigned Address specific functions */
1342 844
1343/* 845/*
@@ -1353,13 +855,84 @@ bfa_faa_validate_request(struct bfa_s *bfa)
1353 if ((ioc_type != BFA_IOC_TYPE_FC) || bfa_mfg_is_mezz(card_type)) 855 if ((ioc_type != BFA_IOC_TYPE_FC) || bfa_mfg_is_mezz(card_type))
1354 return BFA_STATUS_FEATURE_NOT_SUPPORTED; 856 return BFA_STATUS_FEATURE_NOT_SUPPORTED;
1355 } else { 857 } else {
1356 return BFA_STATUS_IOC_NON_OP; 858 if (!bfa_ioc_is_acq_addr(&bfa->ioc))
859 return BFA_STATUS_IOC_NON_OP;
1357 } 860 }
1358 861
1359 return BFA_STATUS_OK; 862 return BFA_STATUS_OK;
1360} 863}
1361 864
1362bfa_status_t 865bfa_status_t
866bfa_faa_enable(struct bfa_s *bfa, bfa_cb_iocfc_t cbfn, void *cbarg)
867{
868 struct bfi_faa_en_dis_s faa_enable_req;
869 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
870 bfa_status_t status;
871
872 iocfc->faa_args.faa_cb.faa_cbfn = cbfn;
873 iocfc->faa_args.faa_cb.faa_cbarg = cbarg;
874
875 status = bfa_faa_validate_request(bfa);
876 if (status != BFA_STATUS_OK)
877 return status;
878
879 if (iocfc->faa_args.busy == BFA_TRUE)
880 return BFA_STATUS_DEVBUSY;
881
882 if (iocfc->faa_args.faa_state == BFA_FAA_ENABLED)
883 return BFA_STATUS_FAA_ENABLED;
884
885 if (bfa_fcport_is_trunk_enabled(bfa))
886 return BFA_STATUS_ERROR_TRUNK_ENABLED;
887
888 bfa_fcport_cfg_faa(bfa, BFA_FAA_ENABLED);
889 iocfc->faa_args.busy = BFA_TRUE;
890
891 memset(&faa_enable_req, 0, sizeof(struct bfi_faa_en_dis_s));
892 bfi_h2i_set(faa_enable_req.mh, BFI_MC_IOCFC,
893 BFI_IOCFC_H2I_FAA_ENABLE_REQ, bfa_fn_lpu(bfa));
894
895 bfa_ioc_mbox_send(&bfa->ioc, &faa_enable_req,
896 sizeof(struct bfi_faa_en_dis_s));
897
898 return BFA_STATUS_OK;
899}
900
901bfa_status_t
902bfa_faa_disable(struct bfa_s *bfa, bfa_cb_iocfc_t cbfn,
903 void *cbarg)
904{
905 struct bfi_faa_en_dis_s faa_disable_req;
906 struct bfa_iocfc_s *iocfc = &bfa->iocfc;
907 bfa_status_t status;
908
909 iocfc->faa_args.faa_cb.faa_cbfn = cbfn;
910 iocfc->faa_args.faa_cb.faa_cbarg = cbarg;
911
912 status = bfa_faa_validate_request(bfa);
913 if (status != BFA_STATUS_OK)
914 return status;
915
916 if (iocfc->faa_args.busy == BFA_TRUE)
917 return BFA_STATUS_DEVBUSY;
918
919 if (iocfc->faa_args.faa_state == BFA_FAA_DISABLED)
920 return BFA_STATUS_FAA_DISABLED;
921
922 bfa_fcport_cfg_faa(bfa, BFA_FAA_DISABLED);
923 iocfc->faa_args.busy = BFA_TRUE;
924
925 memset(&faa_disable_req, 0, sizeof(struct bfi_faa_en_dis_s));
926 bfi_h2i_set(faa_disable_req.mh, BFI_MC_IOCFC,
927 BFI_IOCFC_H2I_FAA_DISABLE_REQ, bfa_fn_lpu(bfa));
928
929 bfa_ioc_mbox_send(&bfa->ioc, &faa_disable_req,
930 sizeof(struct bfi_faa_en_dis_s));
931
932 return BFA_STATUS_OK;
933}
934
935bfa_status_t
1363bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr, 936bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
1364 bfa_cb_iocfc_t cbfn, void *cbarg) 937 bfa_cb_iocfc_t cbfn, void *cbarg)
1365{ 938{
@@ -1390,6 +963,38 @@ bfa_faa_query(struct bfa_s *bfa, struct bfa_faa_attr_s *attr,
1390} 963}
1391 964
1392/* 965/*
966 * FAA enable response
967 */
968static void
969bfa_faa_enable_reply(struct bfa_iocfc_s *iocfc,
970 struct bfi_faa_en_dis_rsp_s *rsp)
971{
972 void *cbarg = iocfc->faa_args.faa_cb.faa_cbarg;
973 bfa_status_t status = rsp->status;
974
975 WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn);
976
977 iocfc->faa_args.faa_cb.faa_cbfn(cbarg, status);
978 iocfc->faa_args.busy = BFA_FALSE;
979}
980
981/*
982 * FAA disable response
983 */
984static void
985bfa_faa_disable_reply(struct bfa_iocfc_s *iocfc,
986 struct bfi_faa_en_dis_rsp_s *rsp)
987{
988 void *cbarg = iocfc->faa_args.faa_cb.faa_cbarg;
989 bfa_status_t status = rsp->status;
990
991 WARN_ON(!iocfc->faa_args.faa_cb.faa_cbfn);
992
993 iocfc->faa_args.faa_cb.faa_cbfn(cbarg, status);
994 iocfc->faa_args.busy = BFA_FALSE;
995}
996
997/*
1393 * FAA query response 998 * FAA query response
1394 */ 999 */
1395static void 1000static void
@@ -1418,10 +1023,25 @@ bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status)
1418{ 1023{
1419 struct bfa_s *bfa = bfa_arg; 1024 struct bfa_s *bfa = bfa_arg;
1420 1025
1421 if (status == BFA_STATUS_OK) 1026 if (status == BFA_STATUS_FAA_ACQ_ADDR) {
1422 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_ENABLED); 1027 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
1423 else 1028 bfa_iocfc_init_cb, bfa);
1424 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED); 1029 return;
1030 }
1031
1032 if (status != BFA_STATUS_OK) {
1033 bfa_isr_disable(bfa);
1034 if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
1035 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
1036 bfa_iocfc_init_cb, bfa);
1037 else if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
1038 bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
1039 bfa_iocfc_enable_cb, bfa);
1040 return;
1041 }
1042
1043 bfa_iocfc_send_cfg(bfa);
1044 bfa_dconf_modinit(bfa);
1425} 1045}
1426 1046
1427/* 1047/*
@@ -1432,7 +1052,17 @@ bfa_iocfc_disable_cbfn(void *bfa_arg)
1432{ 1052{
1433 struct bfa_s *bfa = bfa_arg; 1053 struct bfa_s *bfa = bfa_arg;
1434 1054
1435 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_DISABLED); 1055 bfa_isr_disable(bfa);
1056 bfa_iocfc_disable_submod(bfa);
1057
1058 if (bfa->iocfc.action == BFA_IOCFC_ACT_STOP)
1059 bfa_cb_queue(bfa, &bfa->iocfc.stop_hcb_qe, bfa_iocfc_stop_cb,
1060 bfa);
1061 else {
1062 WARN_ON(bfa->iocfc.action != BFA_IOCFC_ACT_DISABLE);
1063 bfa_cb_queue(bfa, &bfa->iocfc.dis_hcb_qe, bfa_iocfc_disable_cb,
1064 bfa);
1065 }
1436} 1066}
1437 1067
1438/* 1068/*
@@ -1444,7 +1074,13 @@ bfa_iocfc_hbfail_cbfn(void *bfa_arg)
1444 struct bfa_s *bfa = bfa_arg; 1074 struct bfa_s *bfa = bfa_arg;
1445 1075
1446 bfa->queue_process = BFA_FALSE; 1076 bfa->queue_process = BFA_FALSE;
1447 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_IOC_FAILED); 1077
1078 bfa_isr_disable(bfa);
1079 bfa_iocfc_disable_submod(bfa);
1080
1081 if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
1082 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe, bfa_iocfc_init_cb,
1083 bfa);
1448} 1084}
1449 1085
1450/* 1086/*
@@ -1459,6 +1095,7 @@ bfa_iocfc_reset_cbfn(void *bfa_arg)
1459 bfa_isr_enable(bfa); 1095 bfa_isr_enable(bfa);
1460} 1096}
1461 1097
1098
1462/* 1099/*
1463 * Query IOC memory requirement information. 1100 * Query IOC memory requirement information.
1464 */ 1101 */
@@ -1502,7 +1139,8 @@ bfa_iocfc_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
1502 bfa_mem_dma_setup(meminfo, iocfc_dma, dm_len); 1139 bfa_mem_dma_setup(meminfo, iocfc_dma, dm_len);
1503 1140
1504 /* kva memory setup for IOCFC */ 1141 /* kva memory setup for IOCFC */
1505 bfa_mem_kva_setup(meminfo, iocfc_kva, BFA_DBG_FWTRC_LEN); 1142 bfa_mem_kva_setup(meminfo, iocfc_kva,
1143 ((bfa_auto_recover) ? BFA_DBG_FWTRC_LEN : 0));
1506} 1144}
1507 1145
1508/* 1146/*
@@ -1533,12 +1171,6 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1533 INIT_LIST_HEAD(&bfa->comp_q); 1171 INIT_LIST_HEAD(&bfa->comp_q);
1534 for (i = 0; i < BFI_IOC_MAX_CQS; i++) 1172 for (i = 0; i < BFI_IOC_MAX_CQS; i++)
1535 INIT_LIST_HEAD(&bfa->reqq_waitq[i]); 1173 INIT_LIST_HEAD(&bfa->reqq_waitq[i]);
1536
1537 bfa->iocfc.cb_reqd = BFA_FALSE;
1538 bfa->iocfc.op_status = BFA_STATUS_OK;
1539 bfa->iocfc.submod_enabled = BFA_FALSE;
1540
1541 bfa_fsm_set_state(&bfa->iocfc, bfa_iocfc_sm_stopped);
1542} 1174}
1543 1175
1544/* 1176/*
@@ -1547,7 +1179,8 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1547void 1179void
1548bfa_iocfc_init(struct bfa_s *bfa) 1180bfa_iocfc_init(struct bfa_s *bfa)
1549{ 1181{
1550 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_INIT); 1182 bfa->iocfc.action = BFA_IOCFC_ACT_INIT;
1183 bfa_ioc_enable(&bfa->ioc);
1551} 1184}
1552 1185
1553/* 1186/*
@@ -1557,7 +1190,8 @@ bfa_iocfc_init(struct bfa_s *bfa)
1557void 1190void
1558bfa_iocfc_start(struct bfa_s *bfa) 1191bfa_iocfc_start(struct bfa_s *bfa)
1559{ 1192{
1560 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_START); 1193 if (bfa->iocfc.cfgdone)
1194 bfa_iocfc_start_submod(bfa);
1561} 1195}
1562 1196
1563/* 1197/*
@@ -1567,8 +1201,12 @@ bfa_iocfc_start(struct bfa_s *bfa)
1567void 1201void
1568bfa_iocfc_stop(struct bfa_s *bfa) 1202bfa_iocfc_stop(struct bfa_s *bfa)
1569{ 1203{
1204 bfa->iocfc.action = BFA_IOCFC_ACT_STOP;
1205
1570 bfa->queue_process = BFA_FALSE; 1206 bfa->queue_process = BFA_FALSE;
1571 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_STOP); 1207 bfa_dconf_modexit(bfa);
1208 if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
1209 bfa_ioc_disable(&bfa->ioc);
1572} 1210}
1573 1211
1574void 1212void
@@ -1588,9 +1226,13 @@ bfa_iocfc_isr(void *bfaarg, struct bfi_mbmsg_s *m)
1588 case BFI_IOCFC_I2H_UPDATEQ_RSP: 1226 case BFI_IOCFC_I2H_UPDATEQ_RSP:
1589 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK); 1227 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK);
1590 break; 1228 break;
1591 case BFI_IOCFC_I2H_ADDR_MSG: 1229 case BFI_IOCFC_I2H_FAA_ENABLE_RSP:
1592 bfa_iocfc_process_faa_addr(bfa, 1230 bfa_faa_enable_reply(iocfc,
1593 (struct bfi_faa_addr_msg_s *)msg); 1231 (struct bfi_faa_en_dis_rsp_s *)msg);
1232 break;
1233 case BFI_IOCFC_I2H_FAA_DISABLE_RSP:
1234 bfa_faa_disable_reply(iocfc,
1235 (struct bfi_faa_en_dis_rsp_s *)msg);
1594 break; 1236 break;
1595 case BFI_IOCFC_I2H_FAA_QUERY_RSP: 1237 case BFI_IOCFC_I2H_FAA_QUERY_RSP:
1596 bfa_faa_query_reply(iocfc, (bfi_faa_query_rsp_t *)msg); 1238 bfa_faa_query_reply(iocfc, (bfi_faa_query_rsp_t *)msg);
@@ -1664,8 +1306,8 @@ bfa_iocfc_enable(struct bfa_s *bfa)
1664{ 1306{
1665 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0, 1307 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
1666 "IOC Enable"); 1308 "IOC Enable");
1667 bfa->iocfc.cb_reqd = BFA_TRUE; 1309 bfa->iocfc.action = BFA_IOCFC_ACT_ENABLE;
1668 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_ENABLE); 1310 bfa_ioc_enable(&bfa->ioc);
1669} 1311}
1670 1312
1671void 1313void
@@ -1673,16 +1315,17 @@ bfa_iocfc_disable(struct bfa_s *bfa)
1673{ 1315{
1674 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0, 1316 bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
1675 "IOC Disable"); 1317 "IOC Disable");
1318 bfa->iocfc.action = BFA_IOCFC_ACT_DISABLE;
1676 1319
1677 bfa->queue_process = BFA_FALSE; 1320 bfa->queue_process = BFA_FALSE;
1678 bfa_fsm_send_event(&bfa->iocfc, IOCFC_E_DISABLE); 1321 bfa_ioc_disable(&bfa->ioc);
1679} 1322}
1680 1323
1324
1681bfa_boolean_t 1325bfa_boolean_t
1682bfa_iocfc_is_operational(struct bfa_s *bfa) 1326bfa_iocfc_is_operational(struct bfa_s *bfa)
1683{ 1327{
1684 return bfa_ioc_is_operational(&bfa->ioc) && 1328 return bfa_ioc_is_operational(&bfa->ioc) && bfa->iocfc.cfgdone;
1685 bfa_fsm_cmp_state(&bfa->iocfc, bfa_iocfc_sm_operational);
1686} 1329}
1687 1330
1688/* 1331/*
@@ -1762,7 +1405,6 @@ bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
1762 struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa); 1405 struct bfa_mem_dma_s *flash_dma = BFA_MEM_FLASH_DMA(bfa);
1763 struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa); 1406 struct bfa_mem_dma_s *diag_dma = BFA_MEM_DIAG_DMA(bfa);
1764 struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa); 1407 struct bfa_mem_dma_s *phy_dma = BFA_MEM_PHY_DMA(bfa);
1765 struct bfa_mem_dma_s *fru_dma = BFA_MEM_FRU_DMA(bfa);
1766 1408
1767 WARN_ON((cfg == NULL) || (meminfo == NULL)); 1409 WARN_ON((cfg == NULL) || (meminfo == NULL));
1768 1410
@@ -1787,8 +1429,6 @@ bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
1787 bfa_mem_dma_setup(meminfo, diag_dma, bfa_diag_meminfo()); 1429 bfa_mem_dma_setup(meminfo, diag_dma, bfa_diag_meminfo());
1788 bfa_mem_dma_setup(meminfo, phy_dma, 1430 bfa_mem_dma_setup(meminfo, phy_dma,
1789 bfa_phy_meminfo(cfg->drvcfg.min_cfg)); 1431 bfa_phy_meminfo(cfg->drvcfg.min_cfg));
1790 bfa_mem_dma_setup(meminfo, fru_dma,
1791 bfa_fru_meminfo(cfg->drvcfg.min_cfg));
1792} 1432}
1793 1433
1794/* 1434/*
@@ -1861,7 +1501,6 @@ bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
1861 bfa_com_flash_attach(bfa, cfg->drvcfg.min_cfg); 1501 bfa_com_flash_attach(bfa, cfg->drvcfg.min_cfg);
1862 bfa_com_diag_attach(bfa); 1502 bfa_com_diag_attach(bfa);
1863 bfa_com_phy_attach(bfa, cfg->drvcfg.min_cfg); 1503 bfa_com_phy_attach(bfa, cfg->drvcfg.min_cfg);
1864 bfa_com_fru_attach(bfa, cfg->drvcfg.min_cfg);
1865} 1504}
1866 1505
1867/* 1506/*
@@ -1928,6 +1567,16 @@ bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q)
1928 } 1567 }
1929} 1568}
1930 1569
1570void
1571bfa_iocfc_cb_dconf_modinit(struct bfa_s *bfa, bfa_status_t status)
1572{
1573 if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT) {
1574 if (bfa->iocfc.cfgdone == BFA_TRUE)
1575 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
1576 bfa_iocfc_init_cb, bfa);
1577 }
1578}
1579
1931/* 1580/*
1932 * Return the list of PCI vendor/device id lists supported by this 1581 * Return the list of PCI vendor/device id lists supported by this
1933 * BFA instance. 1582 * BFA instance.
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-19 15:25:27 -0400