drivers/scsi/bfa/bfa_ioc.c

   1 /*
   2  * Copyright (c) 2005-2009 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.h>
  19 #include <bfa_ioc.h>
  20 #include <bfa_fwimg_priv.h>
  21 #include <cna/bfa_cna_trcmod.h>
  22 #include <cs/bfa_debug.h>
  23 #include <bfi/bfi_ioc.h>
  24 #include <bfi/bfi_ctreg.h>
  25 #include <aen/bfa_aen_ioc.h>
  26 #include <aen/bfa_aen.h>
  27 #include <log/bfa_log_hal.h>
  28 #include <defs/bfa_defs_pci.h>
  29
  30 BFA_TRC_FILE(CNA, IOC);
  31
  32 /**
  33  * IOC local definitions
  34  */
  35 #define BFA_IOC_TOV             2000    /* msecs */
  36 #define BFA_IOC_HWSEM_TOV       500     /* msecs */
  37 #define BFA_IOC_HB_TOV          500     /* msecs */
  38 #define BFA_IOC_HWINIT_MAX      2
  39 #define BFA_IOC_FWIMG_MINSZ     (16 * 1024)
  40 #define BFA_IOC_TOV_RECOVER      BFA_IOC_HB_TOV
  41
  42 #define bfa_ioc_timer_start(__ioc)                                      \
  43         bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer,        \
  44                         bfa_ioc_timeout, (__ioc), BFA_IOC_TOV)
  45 #define bfa_ioc_timer_stop(__ioc)   bfa_timer_stop(&(__ioc)->ioc_timer)
  46
  47 #define BFA_DBG_FWTRC_ENTS      (BFI_IOC_TRC_ENTS)
  48 #define BFA_DBG_FWTRC_LEN                                       \
  49         (BFA_DBG_FWTRC_ENTS * sizeof(struct bfa_trc_s) +        \
  50          (sizeof(struct bfa_trc_mod_s) -                        \
  51           BFA_TRC_MAX * sizeof(struct bfa_trc_s)))
  52 #define BFA_DBG_FWTRC_OFF(_fn)  (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))
  53
  54 /**
  55  * Asic specific macros : see bfa_hw_cb.c and bfa_hw_ct.c for details.
  56  */
  57
  58 #define bfa_ioc_firmware_lock(__ioc)                    \
  59                         ((__ioc)->ioc_hwif->ioc_firmware_lock(__ioc))
  60 #define bfa_ioc_firmware_unlock(__ioc)                  \
  61                         ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
  62 #define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
  63 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
  64 #define bfa_ioc_notify_hbfail(__ioc)                    \
  65                         ((__ioc)->ioc_hwif->ioc_notify_hbfail(__ioc))
  66 #define bfa_ioc_is_optrom(__ioc)        \
  67         (bfi_image_get_size(BFA_IOC_FWIMG_TYPE(__ioc)) < BFA_IOC_FWIMG_MINSZ)
  68
  69 bfa_boolean_t   bfa_auto_recover = BFA_TRUE;
  70
  71 /*
  72  * forward declarations
  73  */
  74 static void     bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc);
  75 static void     bfa_ioc_hw_sem_get_cancel(struct bfa_ioc_s *ioc);
  76 static void     bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force);
  77 static void     bfa_ioc_timeout(void *ioc);
  78 static void     bfa_ioc_send_enable(struct bfa_ioc_s *ioc);
  79 static void     bfa_ioc_send_disable(struct bfa_ioc_s *ioc);
  80 static void     bfa_ioc_send_getattr(struct bfa_ioc_s *ioc);
  81 static void     bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc);
  82 static void     bfa_ioc_hb_stop(struct bfa_ioc_s *ioc);
  83 static void     bfa_ioc_reset(struct bfa_ioc_s *ioc, bfa_boolean_t force);
  84 static void     bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
  85 static void     bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc);
  86 static void     bfa_ioc_recover(struct bfa_ioc_s *ioc);
  87 static void     bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc);
  88 static void     bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
  89 static void     bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
  90
  91 /**
  92  *  bfa_ioc_sm
  93  */
  94
  95 /**
  96  * IOC state machine events
  97  */
  98 enum ioc_event {
  99         IOC_E_ENABLE = 1,       /*  IOC enable request */
 100         IOC_E_DISABLE = 2,      /*  IOC disable request */
 101         IOC_E_TIMEOUT = 3,      /*  f/w response timeout */
 102         IOC_E_FWREADY = 4,      /*  f/w initialization done */
 103         IOC_E_FWRSP_GETATTR = 5,        /*  IOC get attribute response */
 104         IOC_E_FWRSP_ENABLE = 6, /*  enable f/w response */
 105         IOC_E_FWRSP_DISABLE = 7,        /*  disable f/w response */
 106         IOC_E_HBFAIL = 8,       /*  heartbeat failure */
 107         IOC_E_HWERROR = 9,      /*  hardware error interrupt */
 108         IOC_E_SEMLOCKED = 10,   /*  h/w semaphore is locked */
 109         IOC_E_DETACH = 11,      /*  driver detach cleanup */
 110 };
 111
 112 bfa_fsm_state_decl(bfa_ioc, reset, struct bfa_ioc_s, enum ioc_event);
 113 bfa_fsm_state_decl(bfa_ioc, fwcheck, struct bfa_ioc_s, enum ioc_event);
 114 bfa_fsm_state_decl(bfa_ioc, mismatch, struct bfa_ioc_s, enum ioc_event);
 115 bfa_fsm_state_decl(bfa_ioc, semwait, struct bfa_ioc_s, enum ioc_event);
 116 bfa_fsm_state_decl(bfa_ioc, hwinit, struct bfa_ioc_s, enum ioc_event);
 117 bfa_fsm_state_decl(bfa_ioc, enabling, struct bfa_ioc_s, enum ioc_event);
 118 bfa_fsm_state_decl(bfa_ioc, getattr, struct bfa_ioc_s, enum ioc_event);
 119 bfa_fsm_state_decl(bfa_ioc, op, struct bfa_ioc_s, enum ioc_event);
 120 bfa_fsm_state_decl(bfa_ioc, initfail, struct bfa_ioc_s, enum ioc_event);
 121 bfa_fsm_state_decl(bfa_ioc, hbfail, struct bfa_ioc_s, enum ioc_event);
 122 bfa_fsm_state_decl(bfa_ioc, disabling, struct bfa_ioc_s, enum ioc_event);
 123 bfa_fsm_state_decl(bfa_ioc, disabled, struct bfa_ioc_s, enum ioc_event);
 124
 125 static struct bfa_sm_table_s ioc_sm_table[] = {
 126         {BFA_SM(bfa_ioc_sm_reset), BFA_IOC_RESET},
 127         {BFA_SM(bfa_ioc_sm_fwcheck), BFA_IOC_FWMISMATCH},
 128         {BFA_SM(bfa_ioc_sm_mismatch), BFA_IOC_FWMISMATCH},
 129         {BFA_SM(bfa_ioc_sm_semwait), BFA_IOC_SEMWAIT},
 130         {BFA_SM(bfa_ioc_sm_hwinit), BFA_IOC_HWINIT},
 131         {BFA_SM(bfa_ioc_sm_enabling), BFA_IOC_HWINIT},
 132         {BFA_SM(bfa_ioc_sm_getattr), BFA_IOC_GETATTR},
 133         {BFA_SM(bfa_ioc_sm_op), BFA_IOC_OPERATIONAL},
 134         {BFA_SM(bfa_ioc_sm_initfail), BFA_IOC_INITFAIL},
 135         {BFA_SM(bfa_ioc_sm_hbfail), BFA_IOC_HBFAIL},
 136         {BFA_SM(bfa_ioc_sm_disabling), BFA_IOC_DISABLING},
 137         {BFA_SM(bfa_ioc_sm_disabled), BFA_IOC_DISABLED},
 138 };
 139
 140 /**
 141  * Reset entry actions -- initialize state machine
 142  */
 143 static void
 144 bfa_ioc_sm_reset_entry(struct bfa_ioc_s *ioc)
 145 {
 146         ioc->retry_count = 0;
 147         ioc->auto_recover = bfa_auto_recover;
 148 }
 149
 150 /**
 151  * Beginning state. IOC is in reset state.
 152  */
 153 static void
 154 bfa_ioc_sm_reset(struct bfa_ioc_s *ioc, enum ioc_event event)
 155 {
 156         bfa_trc(ioc, event);
 157
 158         switch (event) {
 159         case IOC_E_ENABLE:
 160                 bfa_fsm_set_state(ioc, bfa_ioc_sm_fwcheck);
 161                 break;
 162
 163         case IOC_E_DISABLE:
 164                 bfa_ioc_disable_comp(ioc);
 165                 break;
 166
 167         case IOC_E_DETACH:
 168                 break;
 169
 170         default:
 171                 bfa_sm_fault(ioc, event);
 172         }
 173 }
 174
 175 /**
 176  * Semaphore should be acquired for version check.
 177  */
 178 static void
 179 bfa_ioc_sm_fwcheck_entry(struct bfa_ioc_s *ioc)
 180 {
 181         bfa_ioc_hw_sem_get(ioc);
 182 }
 183
 184 /**
 185  * Awaiting h/w semaphore to continue with version check.
 186  */
 187 static void
 188 bfa_ioc_sm_fwcheck(struct bfa_ioc_s *ioc, enum ioc_event event)
 189 {
 190         bfa_trc(ioc, event);
 191
 192         switch (event) {
 193         case IOC_E_SEMLOCKED:
 194                 if (bfa_ioc_firmware_lock(ioc)) {
 195                         ioc->retry_count = 0;
 196                         bfa_fsm_set_state(ioc, bfa_ioc_sm_hwinit);
 197                 } else {
 198                         bfa_ioc_hw_sem_release(ioc);
 199                         bfa_fsm_set_state(ioc, bfa_ioc_sm_mismatch);
 200                 }
 201                 break;
 202
 203         case IOC_E_DISABLE:
 204                 bfa_ioc_disable_comp(ioc);
 205                 /*
 206                  * fall through
 207                  */
 208
 209         case IOC_E_DETACH:
 210                 bfa_ioc_hw_sem_get_cancel(ioc);
 211                 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
 212                 break;
 213
 214         case IOC_E_FWREADY:
 215                 break;
 216
 217         default:
 218                 bfa_sm_fault(ioc, event);
 219         }
 220 }
 221
 222 /**
 223  * Notify enable completion callback and generate mismatch AEN.
 224  */
 225 static void
 226 bfa_ioc_sm_mismatch_entry(struct bfa_ioc_s *ioc)
 227 {
 228         /**
 229          * Provide enable completion callback and AEN notification only once.
 230          */
 231         if (ioc->retry_count == 0) {
 232                 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
 233                 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_FWMISMATCH);
 234         }
 235         ioc->retry_count++;
 236         bfa_ioc_timer_start(ioc);
 237 }
 238
 239 /**
 240  * Awaiting firmware version match.
 241  */
 242 static void
 243 bfa_ioc_sm_mismatch(struct bfa_ioc_s *ioc, enum ioc_event event)
 244 {
 245         bfa_trc(ioc, event);
 246
 247         switch (event) {
 248         case IOC_E_TIMEOUT:
 249                 bfa_fsm_set_state(ioc, bfa_ioc_sm_fwcheck);
 250                 break;
 251
 252         case IOC_E_DISABLE:
 253                 bfa_ioc_disable_comp(ioc);
 254                 /*
 255                  * fall through
 256                  */
 257
 258         case IOC_E_DETACH:
 259                 bfa_ioc_timer_stop(ioc);
 260                 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
 261                 break;
 262
 263         case IOC_E_FWREADY:
 264                 break;
 265
 266         default:
 267                 bfa_sm_fault(ioc, event);
 268         }
 269 }
 270
 271 /**
 272  * Request for semaphore.
 273  */
 274 static void
 275 bfa_ioc_sm_semwait_entry(struct bfa_ioc_s *ioc)
 276 {
 277         bfa_ioc_hw_sem_get(ioc);
 278 }
 279
 280 /**
 281  * Awaiting semaphore for h/w initialzation.
 282  */
 283 static void
 284 bfa_ioc_sm_semwait(struct bfa_ioc_s *ioc, enum ioc_event event)
 285 {
 286         bfa_trc(ioc, event);
 287
 288         switch (event) {
 289         case IOC_E_SEMLOCKED:
 290                 ioc->retry_count = 0;
 291                 bfa_fsm_set_state(ioc, bfa_ioc_sm_hwinit);
 292                 break;
 293
 294         case IOC_E_DISABLE:
 295                 bfa_ioc_hw_sem_get_cancel(ioc);
 296                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 297                 break;
 298
 299         default:
 300                 bfa_sm_fault(ioc, event);
 301         }
 302 }
 303
 304
 305 static void
 306 bfa_ioc_sm_hwinit_entry(struct bfa_ioc_s *ioc)
 307 {
 308         bfa_ioc_timer_start(ioc);
 309         bfa_ioc_reset(ioc, BFA_FALSE);
 310 }
 311
 312 /**
 313  * Hardware is being initialized. Interrupts are enabled.
 314  * Holding hardware semaphore lock.
 315  */
 316 static void
 317 bfa_ioc_sm_hwinit(struct bfa_ioc_s *ioc, enum ioc_event event)
 318 {
 319         bfa_trc(ioc, event);
 320
 321         switch (event) {
 322         case IOC_E_FWREADY:
 323                 bfa_ioc_timer_stop(ioc);
 324                 bfa_fsm_set_state(ioc, bfa_ioc_sm_enabling);
 325                 break;
 326
 327         case IOC_E_HWERROR:
 328                 bfa_ioc_timer_stop(ioc);
 329                 /*
 330                  * fall through
 331                  */
 332
 333         case IOC_E_TIMEOUT:
 334                 ioc->retry_count++;
 335                 if (ioc->retry_count < BFA_IOC_HWINIT_MAX) {
 336                         bfa_ioc_timer_start(ioc);
 337                         bfa_ioc_reset(ioc, BFA_TRUE);
 338                         break;
 339                 }
 340
 341                 bfa_ioc_hw_sem_release(ioc);
 342                 bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
 343                 break;
 344
 345         case IOC_E_DISABLE:
 346                 bfa_ioc_hw_sem_release(ioc);
 347                 bfa_ioc_timer_stop(ioc);
 348                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 349                 break;
 350
 351         default:
 352                 bfa_sm_fault(ioc, event);
 353         }
 354 }
 355
 356
 357 static void
 358 bfa_ioc_sm_enabling_entry(struct bfa_ioc_s *ioc)
 359 {
 360         bfa_ioc_timer_start(ioc);
 361         bfa_ioc_send_enable(ioc);
 362 }
 363
 364 /**
 365  * Host IOC function is being enabled, awaiting response from firmware.
 366  * Semaphore is acquired.
 367  */
 368 static void
 369 bfa_ioc_sm_enabling(struct bfa_ioc_s *ioc, enum ioc_event event)
 370 {
 371         bfa_trc(ioc, event);
 372
 373         switch (event) {
 374         case IOC_E_FWRSP_ENABLE:
 375                 bfa_ioc_timer_stop(ioc);
 376                 bfa_ioc_hw_sem_release(ioc);
 377                 bfa_fsm_set_state(ioc, bfa_ioc_sm_getattr);
 378                 break;
 379
 380         case IOC_E_HWERROR:
 381                 bfa_ioc_timer_stop(ioc);
 382                 /*
 383                  * fall through
 384                  */
 385
 386         case IOC_E_TIMEOUT:
 387                 ioc->retry_count++;
 388                 if (ioc->retry_count < BFA_IOC_HWINIT_MAX) {
 389                         bfa_reg_write(ioc->ioc_regs.ioc_fwstate,
 390                                       BFI_IOC_UNINIT);
 391                         bfa_fsm_set_state(ioc, bfa_ioc_sm_hwinit);
 392                         break;
 393                 }
 394
 395                 bfa_ioc_hw_sem_release(ioc);
 396                 bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
 397                 break;
 398
 399         case IOC_E_DISABLE:
 400                 bfa_ioc_timer_stop(ioc);
 401                 bfa_ioc_hw_sem_release(ioc);
 402                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 403                 break;
 404
 405         case IOC_E_FWREADY:
 406                 bfa_ioc_send_enable(ioc);
 407                 break;
 408
 409         default:
 410                 bfa_sm_fault(ioc, event);
 411         }
 412 }
 413
 414
 415 static void
 416 bfa_ioc_sm_getattr_entry(struct bfa_ioc_s *ioc)
 417 {
 418         bfa_ioc_timer_start(ioc);
 419         bfa_ioc_send_getattr(ioc);
 420 }
 421
 422 /**
 423  * IOC configuration in progress. Timer is active.
 424  */
 425 static void
 426 bfa_ioc_sm_getattr(struct bfa_ioc_s *ioc, enum ioc_event event)
 427 {
 428         bfa_trc(ioc, event);
 429
 430         switch (event) {
 431         case IOC_E_FWRSP_GETATTR:
 432                 bfa_ioc_timer_stop(ioc);
 433                 bfa_ioc_check_attr_wwns(ioc);
 434                 bfa_fsm_set_state(ioc, bfa_ioc_sm_op);
 435                 break;
 436
 437         case IOC_E_HWERROR:
 438                 bfa_ioc_timer_stop(ioc);
 439                 /*
 440                  * fall through
 441                  */
 442
 443         case IOC_E_TIMEOUT:
 444                 bfa_fsm_set_state(ioc, bfa_ioc_sm_initfail);
 445                 break;
 446
 447         case IOC_E_DISABLE:
 448                 bfa_ioc_timer_stop(ioc);
 449                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 450                 break;
 451
 452         default:
 453                 bfa_sm_fault(ioc, event);
 454         }
 455 }
 456
 457
 458 static void
 459 bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
 460 {
 461         ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
 462         bfa_ioc_hb_monitor(ioc);
 463         bfa_ioc_aen_post(ioc, BFA_IOC_AEN_ENABLE);
 464 }
 465
 466 static void
 467 bfa_ioc_sm_op(struct bfa_ioc_s *ioc, enum ioc_event event)
 468 {
 469         bfa_trc(ioc, event);
 470
 471         switch (event) {
 472         case IOC_E_ENABLE:
 473                 break;
 474
 475         case IOC_E_DISABLE:
 476                 bfa_ioc_hb_stop(ioc);
 477                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabling);
 478                 break;
 479
 480         case IOC_E_HWERROR:
 481         case IOC_E_FWREADY:
 482                 /**
 483                  * Hard error or IOC recovery by other function.
 484                  * Treat it same as heartbeat failure.
 485                  */
 486                 bfa_ioc_hb_stop(ioc);
 487                 /*
 488                  * !!! fall through !!!
 489                  */
 490
 491         case IOC_E_HBFAIL:
 492                 bfa_fsm_set_state(ioc, bfa_ioc_sm_hbfail);
 493                 break;
 494
 495         default:
 496                 bfa_sm_fault(ioc, event);
 497         }
 498 }
 499
 500
 501 static void
 502 bfa_ioc_sm_disabling_entry(struct bfa_ioc_s *ioc)
 503 {
 504         bfa_ioc_aen_post(ioc, BFA_IOC_AEN_DISABLE);
 505         bfa_ioc_timer_start(ioc);
 506         bfa_ioc_send_disable(ioc);
 507 }
 508
 509 /**
 510  * IOC is being disabled
 511  */
 512 static void
 513 bfa_ioc_sm_disabling(struct bfa_ioc_s *ioc, enum ioc_event event)
 514 {
 515         bfa_trc(ioc, event);
 516
 517         switch (event) {
 518         case IOC_E_FWRSP_DISABLE:
 519                 bfa_ioc_timer_stop(ioc);
 520                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 521                 break;
 522
 523         case IOC_E_HWERROR:
 524                 bfa_ioc_timer_stop(ioc);
 525                 /*
 526                  * !!! fall through !!!
 527                  */
 528
 529         case IOC_E_TIMEOUT:
 530                 bfa_reg_write(ioc->ioc_regs.ioc_fwstate, BFI_IOC_FAIL);
 531                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 532                 break;
 533
 534         default:
 535                 bfa_sm_fault(ioc, event);
 536         }
 537 }
 538
 539 /**
 540  * IOC disable completion entry.
 541  */
 542 static void
 543 bfa_ioc_sm_disabled_entry(struct bfa_ioc_s *ioc)
 544 {
 545         bfa_ioc_disable_comp(ioc);
 546 }
 547
 548 static void
 549 bfa_ioc_sm_disabled(struct bfa_ioc_s *ioc, enum ioc_event event)
 550 {
 551         bfa_trc(ioc, event);
 552
 553         switch (event) {
 554         case IOC_E_ENABLE:
 555                 bfa_fsm_set_state(ioc, bfa_ioc_sm_semwait);
 556                 break;
 557
 558         case IOC_E_DISABLE:
 559                 ioc->cbfn->disable_cbfn(ioc->bfa);
 560                 break;
 561
 562         case IOC_E_FWREADY:
 563                 break;
 564
 565         case IOC_E_DETACH:
 566                 bfa_ioc_firmware_unlock(ioc);
 567                 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
 568                 break;
 569
 570         default:
 571                 bfa_sm_fault(ioc, event);
 572         }
 573 }
 574
 575
 576 static void
 577 bfa_ioc_sm_initfail_entry(struct bfa_ioc_s *ioc)
 578 {
 579         ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
 580         bfa_ioc_timer_start(ioc);
 581 }
 582
 583 /**
 584  * Hardware initialization failed.
 585  */
 586 static void
 587 bfa_ioc_sm_initfail(struct bfa_ioc_s *ioc, enum ioc_event event)
 588 {
 589         bfa_trc(ioc, event);
 590
 591         switch (event) {
 592         case IOC_E_DISABLE:
 593                 bfa_ioc_timer_stop(ioc);
 594                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 595                 break;
 596
 597         case IOC_E_DETACH:
 598                 bfa_ioc_timer_stop(ioc);
 599                 bfa_ioc_firmware_unlock(ioc);
 600                 bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
 601                 break;
 602
 603         case IOC_E_TIMEOUT:
 604                 bfa_fsm_set_state(ioc, bfa_ioc_sm_semwait);
 605                 break;
 606
 607         default:
 608                 bfa_sm_fault(ioc, event);
 609         }
 610 }
 611
 612
 613 static void
 614 bfa_ioc_sm_hbfail_entry(struct bfa_ioc_s *ioc)
 615 {
 616         struct list_head *qe;
 617         struct bfa_ioc_hbfail_notify_s *notify;
 618
 619         /**
 620          * Mark IOC as failed in hardware and stop firmware.
 621          */
 622         bfa_ioc_lpu_stop(ioc);
 623         bfa_reg_write(ioc->ioc_regs.ioc_fwstate, BFI_IOC_FAIL);
 624
 625         /**
 626          * Notify other functions on HB failure.
 627          */
 628         bfa_ioc_notify_hbfail(ioc);
 629
 630         /**
 631          * Notify driver and common modules registered for notification.
 632          */
 633         ioc->cbfn->hbfail_cbfn(ioc->bfa);
 634         list_for_each(qe, &ioc->hb_notify_q) {
 635                 notify = (struct bfa_ioc_hbfail_notify_s *)qe;
 636                 notify->cbfn(notify->cbarg);
 637         }
 638
 639         /**
 640          * Flush any queued up mailbox requests.
 641          */
 642         bfa_ioc_mbox_hbfail(ioc);
 643         bfa_ioc_aen_post(ioc, BFA_IOC_AEN_HBFAIL);
 644
 645         /**
 646          * Trigger auto-recovery after a delay.
 647          */
 648         if (ioc->auto_recover) {
 649                 bfa_timer_begin(ioc->timer_mod, &ioc->ioc_timer,
 650                                 bfa_ioc_timeout, ioc, BFA_IOC_TOV_RECOVER);
 651         }
 652 }
 653
 654 /**
 655  * IOC heartbeat failure.
 656  */
 657 static void
 658 bfa_ioc_sm_hbfail(struct bfa_ioc_s *ioc, enum ioc_event event)
 659 {
 660         bfa_trc(ioc, event);
 661
 662         switch (event) {
 663
 664         case IOC_E_ENABLE:
 665                 ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_IOC_FAILURE);
 666                 break;
 667
 668         case IOC_E_DISABLE:
 669                 if (ioc->auto_recover)
 670                         bfa_ioc_timer_stop(ioc);
 671                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
 672                 break;
 673
 674         case IOC_E_TIMEOUT:
 675                 bfa_fsm_set_state(ioc, bfa_ioc_sm_semwait);
 676                 break;
 677
 678         case IOC_E_FWREADY:
 679                 /**
 680                  * Recovery is already initiated by other function.
 681                  */
 682                 break;
 683
 684         case IOC_E_HWERROR:
 685                 /*
 686                  * HB failure notification, ignore.
 687                  */
 688                 break;
 689
 690         default:
 691                 bfa_sm_fault(ioc, event);
 692         }
 693 }
 694
 695
 696
 697 /**
 698  *  bfa_ioc_pvt BFA IOC private functions
 699  */
 700
 701 static void
 702 bfa_ioc_disable_comp(struct bfa_ioc_s *ioc)
 703 {
 704         struct list_head *qe;
 705         struct bfa_ioc_hbfail_notify_s *notify;
 706
 707         ioc->cbfn->disable_cbfn(ioc->bfa);
 708
 709         /**
 710          * Notify common modules registered for notification.
 711          */
 712         list_for_each(qe, &ioc->hb_notify_q) {
 713                 notify = (struct bfa_ioc_hbfail_notify_s *)qe;
 714                 notify->cbfn(notify->cbarg);
 715         }
 716 }
 717
 718 void
 719 bfa_ioc_sem_timeout(void *ioc_arg)
 720 {
 721         struct bfa_ioc_s *ioc = (struct bfa_ioc_s *)ioc_arg;
 722
 723         bfa_ioc_hw_sem_get(ioc);
 724 }
 725
 726 bfa_boolean_t
 727 bfa_ioc_sem_get(bfa_os_addr_t sem_reg)
 728 {
 729         u32 r32;
 730         int cnt = 0;
 731 #define BFA_SEM_SPINCNT 3000
 732
 733         r32 = bfa_reg_read(sem_reg);
 734
 735         while (r32 && (cnt < BFA_SEM_SPINCNT)) {
 736                 cnt++;
 737                 bfa_os_udelay(2);
 738                 r32 = bfa_reg_read(sem_reg);
 739         }
 740
 741         if (r32 == 0)
 742                 return BFA_TRUE;
 743
 744         bfa_assert(cnt < BFA_SEM_SPINCNT);
 745         return BFA_FALSE;
 746 }
 747
 748 void
 749 bfa_ioc_sem_release(bfa_os_addr_t sem_reg)
 750 {
 751         bfa_reg_write(sem_reg, 1);
 752 }
 753
 754 static void
 755 bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
 756 {
 757         u32        r32;
 758
 759         /**
 760          * First read to the semaphore register will return 0, subsequent reads
 761          * will return 1. Semaphore is released by writing 1 to the register
 762          */
 763         r32 = bfa_reg_read(ioc->ioc_regs.ioc_sem_reg);
 764         if (r32 == 0) {
 765                 bfa_fsm_send_event(ioc, IOC_E_SEMLOCKED);
 766                 return;
 767         }
 768
 769         bfa_timer_begin(ioc->timer_mod, &ioc->sem_timer, bfa_ioc_sem_timeout,
 770                         ioc, BFA_IOC_HWSEM_TOV);
 771 }
 772
 773 void
 774 bfa_ioc_hw_sem_release(struct bfa_ioc_s *ioc)
 775 {
 776         bfa_reg_write(ioc->ioc_regs.ioc_sem_reg, 1);
 777 }
 778
 779 static void
 780 bfa_ioc_hw_sem_get_cancel(struct bfa_ioc_s *ioc)
 781 {
 782         bfa_timer_stop(&ioc->sem_timer);
 783 }
 784
 785 /**
 786  * Initialize LPU local memory (aka secondary memory / SRAM)
 787  */
 788 static void
 789 bfa_ioc_lmem_init(struct bfa_ioc_s *ioc)
 790 {
 791         u32        pss_ctl;
 792         int             i;
 793 #define PSS_LMEM_INIT_TIME  10000
 794
 795         pss_ctl = bfa_reg_read(ioc->ioc_regs.pss_ctl_reg);
 796         pss_ctl &= ~__PSS_LMEM_RESET;
 797         pss_ctl |= __PSS_LMEM_INIT_EN;
 798         pss_ctl |= __PSS_I2C_CLK_DIV(3UL); /* i2c workaround 12.5khz clock */
 799         bfa_reg_write(ioc->ioc_regs.pss_ctl_reg, pss_ctl);
 800
 801         /**
 802          * wait for memory initialization to be complete
 803          */
 804         i = 0;
 805         do {
 806                 pss_ctl = bfa_reg_read(ioc->ioc_regs.pss_ctl_reg);
 807                 i++;
 808         } while (!(pss_ctl & __PSS_LMEM_INIT_DONE) && (i < PSS_LMEM_INIT_TIME));
 809
 810         /**
 811          * If memory initialization is not successful, IOC timeout will catch
 812          * such failures.
 813          */
 814         bfa_assert(pss_ctl & __PSS_LMEM_INIT_DONE);
 815         bfa_trc(ioc, pss_ctl);
 816
 817         pss_ctl &= ~(__PSS_LMEM_INIT_DONE | __PSS_LMEM_INIT_EN);
 818         bfa_reg_write(ioc->ioc_regs.pss_ctl_reg, pss_ctl);
 819 }
 820
 821 static void
 822 bfa_ioc_lpu_start(struct bfa_ioc_s *ioc)
 823 {
 824         u32        pss_ctl;
 825
 826         /**
 827          * Take processor out of reset.
 828          */
 829         pss_ctl = bfa_reg_read(ioc->ioc_regs.pss_ctl_reg);
 830         pss_ctl &= ~__PSS_LPU0_RESET;
 831
 832         bfa_reg_write(ioc->ioc_regs.pss_ctl_reg, pss_ctl);
 833 }
 834
 835 static void
 836 bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc)
 837 {
 838         u32        pss_ctl;
 839
 840         /**
 841          * Put processors in reset.
 842          */
 843         pss_ctl = bfa_reg_read(ioc->ioc_regs.pss_ctl_reg);
 844         pss_ctl |= (__PSS_LPU0_RESET | __PSS_LPU1_RESET);
 845
 846         bfa_reg_write(ioc->ioc_regs.pss_ctl_reg, pss_ctl);
 847 }
 848
 849 /**
 850  * Get driver and firmware versions.
 851  */
 852 void
 853 bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
 854 {
 855         u32        pgnum, pgoff;
 856         u32        loff = 0;
 857         int             i;
 858         u32       *fwsig = (u32 *) fwhdr;
 859
 860         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
 861         pgoff = bfa_ioc_smem_pgoff(ioc, loff);
 862         bfa_reg_write(ioc->ioc_regs.host_page_num_fn, pgnum);
 863
 864         for (i = 0; i < (sizeof(struct bfi_ioc_image_hdr_s) / sizeof(u32));
 865              i++) {
 866                 fwsig[i] = bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
 867                 loff += sizeof(u32);
 868         }
 869 }
 870
 871 /**
 872  * Returns TRUE if same.
 873  */
 874 bfa_boolean_t
 875 bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
 876 {
 877         struct bfi_ioc_image_hdr_s *drv_fwhdr;
 878         int             i;
 879
 880         drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
 881                         bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), 0);
 882
 883         for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) {
 884                 if (fwhdr->md5sum[i] != drv_fwhdr->md5sum[i]) {
 885                         bfa_trc(ioc, i);
 886                         bfa_trc(ioc, fwhdr->md5sum[i]);
 887                         bfa_trc(ioc, drv_fwhdr->md5sum[i]);
 888                         return BFA_FALSE;
 889                 }
 890         }
 891
 892         bfa_trc(ioc, fwhdr->md5sum[0]);
 893         return BFA_TRUE;
 894 }
 895
 896 /**
 897  * Return true if current running version is valid. Firmware signature and
 898  * execution context (driver/bios) must match.
 899  */
 900 static          bfa_boolean_t
 901 bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc)
 902 {
 903         struct bfi_ioc_image_hdr_s fwhdr, *drv_fwhdr;
 904
 905         /**
 906          * If bios/efi boot (flash based) -- return true
 907          */
 908         if (bfa_ioc_is_optrom(ioc))
 909                 return BFA_TRUE;
 910
 911         bfa_ioc_fwver_get(ioc, &fwhdr);
 912         drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
 913                         bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), 0);
 914
 915
 916         if (fwhdr.signature != drv_fwhdr->signature) {
 917                 bfa_trc(ioc, fwhdr.signature);
 918                 bfa_trc(ioc, drv_fwhdr->signature);
 919                 return BFA_FALSE;
 920         }
 921
 922         if (fwhdr.exec != drv_fwhdr->exec) {
 923                 bfa_trc(ioc, fwhdr.exec);
 924                 bfa_trc(ioc, drv_fwhdr->exec);
 925                 return BFA_FALSE;
 926         }
 927
 928         return bfa_ioc_fwver_cmp(ioc, &fwhdr);
 929 }
 930
 931 /**
 932  * Conditionally flush any pending message from firmware at start.
 933  */
 934 static void
 935 bfa_ioc_msgflush(struct bfa_ioc_s *ioc)
 936 {
 937         u32        r32;
 938
 939         r32 = bfa_reg_read(ioc->ioc_regs.lpu_mbox_cmd);
 940         if (r32)
 941                 bfa_reg_write(ioc->ioc_regs.lpu_mbox_cmd, 1);
 942 }
 943
 944
 945 static void
 946 bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force)
 947 {
 948         enum bfi_ioc_state ioc_fwstate;
 949         bfa_boolean_t   fwvalid;
 950
 951         ioc_fwstate = bfa_reg_read(ioc->ioc_regs.ioc_fwstate);
 952
 953         if (force)
 954                 ioc_fwstate = BFI_IOC_UNINIT;
 955
 956         bfa_trc(ioc, ioc_fwstate);
 957
 958         /**
 959          * check if firmware is valid
 960          */
 961         fwvalid = (ioc_fwstate == BFI_IOC_UNINIT) ?
 962                         BFA_FALSE : bfa_ioc_fwver_valid(ioc);
 963
 964         if (!fwvalid) {
 965                 bfa_ioc_boot(ioc, BFI_BOOT_TYPE_NORMAL, ioc->pcidev.device_id);
 966                 return;
 967         }
 968
 969         /**
 970          * If hardware initialization is in progress (initialized by other IOC),
 971          * just wait for an initialization completion interrupt.
 972          */
 973         if (ioc_fwstate == BFI_IOC_INITING) {
 974                 bfa_trc(ioc, ioc_fwstate);
 975                 ioc->cbfn->reset_cbfn(ioc->bfa);
 976                 return;
 977         }
 978
 979         /**
 980          * If IOC function is disabled and firmware version is same,
 981          * just re-enable IOC.
 982          *
 983          * If option rom, IOC must not be in operational state. With
 984          * convergence, IOC will be in operational state when 2nd driver
 985          * is loaded.
 986          */
 987         if (ioc_fwstate == BFI_IOC_DISABLED ||
 988                 (!bfa_ioc_is_optrom(ioc) && ioc_fwstate == BFI_IOC_OP)) {
 989                 bfa_trc(ioc, ioc_fwstate);
 990
 991                 /**
 992                  * When using MSI-X any pending firmware ready event should
 993                  * be flushed. Otherwise MSI-X interrupts are not delivered.
 994                  */
 995                 bfa_ioc_msgflush(ioc);
 996                 ioc->cbfn->reset_cbfn(ioc->bfa);
 997                 bfa_fsm_send_event(ioc, IOC_E_FWREADY);
 998                 return;
 999         }
1000
1001         /**
1002          * Initialize the h/w for any other states.
1003          */
1004         bfa_ioc_boot(ioc, BFI_BOOT_TYPE_NORMAL, ioc->pcidev.device_id);
1005 }
1006
1007 static void
1008 bfa_ioc_timeout(void *ioc_arg)
1009 {
1010         struct bfa_ioc_s *ioc = (struct bfa_ioc_s *)ioc_arg;
1011
1012         bfa_trc(ioc, 0);
1013         bfa_fsm_send_event(ioc, IOC_E_TIMEOUT);
1014 }
1015
1016 void
1017 bfa_ioc_mbox_send(struct bfa_ioc_s *ioc, void *ioc_msg, int len)
1018 {
1019         u32       *msgp = (u32 *) ioc_msg;
1020         u32        i;
1021
1022         bfa_trc(ioc, msgp[0]);
1023         bfa_trc(ioc, len);
1024
1025         bfa_assert(len <= BFI_IOC_MSGLEN_MAX);
1026
1027         /*
1028          * first write msg to mailbox registers
1029          */
1030         for (i = 0; i < len / sizeof(u32); i++)
1031                 bfa_reg_write(ioc->ioc_regs.hfn_mbox + i * sizeof(u32),
1032                               bfa_os_wtole(msgp[i]));
1033
1034         for (; i < BFI_IOC_MSGLEN_MAX / sizeof(u32); i++)
1035                 bfa_reg_write(ioc->ioc_regs.hfn_mbox + i * sizeof(u32), 0);
1036
1037         /*
1038          * write 1 to mailbox CMD to trigger LPU event
1039          */
1040         bfa_reg_write(ioc->ioc_regs.hfn_mbox_cmd, 1);
1041         (void)bfa_reg_read(ioc->ioc_regs.hfn_mbox_cmd);
1042 }
1043
1044 static void
1045 bfa_ioc_send_enable(struct bfa_ioc_s *ioc)
1046 {
1047         struct bfi_ioc_ctrl_req_s enable_req;
1048
1049         bfi_h2i_set(enable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_ENABLE_REQ,
1050                     bfa_ioc_portid(ioc));
1051         enable_req.ioc_class = ioc->ioc_mc;
1052         bfa_ioc_mbox_send(ioc, &enable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1053 }
1054
1055 static void
1056 bfa_ioc_send_disable(struct bfa_ioc_s *ioc)
1057 {
1058         struct bfi_ioc_ctrl_req_s disable_req;
1059
1060         bfi_h2i_set(disable_req.mh, BFI_MC_IOC, BFI_IOC_H2I_DISABLE_REQ,
1061                     bfa_ioc_portid(ioc));
1062         bfa_ioc_mbox_send(ioc, &disable_req, sizeof(struct bfi_ioc_ctrl_req_s));
1063 }
1064
1065 static void
1066 bfa_ioc_send_getattr(struct bfa_ioc_s *ioc)
1067 {
1068         struct bfi_ioc_getattr_req_s attr_req;
1069
1070         bfi_h2i_set(attr_req.mh, BFI_MC_IOC, BFI_IOC_H2I_GETATTR_REQ,
1071                     bfa_ioc_portid(ioc));
1072         bfa_dma_be_addr_set(attr_req.attr_addr, ioc->attr_dma.pa);
1073         bfa_ioc_mbox_send(ioc, &attr_req, sizeof(attr_req));
1074 }
1075
1076 static void
1077 bfa_ioc_hb_check(void *cbarg)
1078 {
1079         struct bfa_ioc_s  *ioc = cbarg;
1080         u32     hb_count;
1081
1082         hb_count = bfa_reg_read(ioc->ioc_regs.heartbeat);
1083         if (ioc->hb_count == hb_count) {
1084                 bfa_log(ioc->logm, BFA_LOG_HAL_HEARTBEAT_FAILURE,
1085                         hb_count);
1086                 bfa_ioc_recover(ioc);
1087                 return;
1088         } else {
1089                 ioc->hb_count = hb_count;
1090         }
1091
1092         bfa_ioc_mbox_poll(ioc);
1093         bfa_timer_begin(ioc->timer_mod, &ioc->ioc_timer, bfa_ioc_hb_check,
1094                         ioc, BFA_IOC_HB_TOV);
1095 }
1096
1097 static void
1098 bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc)
1099 {
1100         ioc->hb_count = bfa_reg_read(ioc->ioc_regs.heartbeat);
1101         bfa_timer_begin(ioc->timer_mod, &ioc->ioc_timer, bfa_ioc_hb_check, ioc,
1102                         BFA_IOC_HB_TOV);
1103 }
1104
1105 static void
1106 bfa_ioc_hb_stop(struct bfa_ioc_s *ioc)
1107 {
1108         bfa_timer_stop(&ioc->ioc_timer);
1109 }
1110
1111 /**
1112  *      Initiate a full firmware download.
1113  */
1114 static void
1115 bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
1116                     u32 boot_param)
1117 {
1118         u32       *fwimg;
1119         u32        pgnum, pgoff;
1120         u32        loff = 0;
1121         u32        chunkno = 0;
1122         u32        i;
1123
1124         /**
1125          * Initialize LMEM first before code download
1126          */
1127         bfa_ioc_lmem_init(ioc);
1128
1129         /**
1130          * Flash based firmware boot
1131          */
1132         bfa_trc(ioc, bfi_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)));
1133         if (bfa_ioc_is_optrom(ioc))
1134                 boot_type = BFI_BOOT_TYPE_FLASH;
1135         fwimg = bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), chunkno);
1136
1137
1138         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
1139         pgoff = bfa_ioc_smem_pgoff(ioc, loff);
1140
1141         bfa_reg_write(ioc->ioc_regs.host_page_num_fn, pgnum);
1142
1143         for (i = 0; i < bfi_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)); i++) {
1144
1145                 if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {
1146                         chunkno = BFA_IOC_FLASH_CHUNK_NO(i);
1147                         fwimg = bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc),
1148                                         BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
1149                 }
1150
1151                 /**
1152                  * write smem
1153                  */
1154                 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff,
1155                               fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]);
1156
1157                 loff += sizeof(u32);
1158
1159                 /**
1160                  * handle page offset wrap around
1161                  */
1162                 loff = PSS_SMEM_PGOFF(loff);
1163                 if (loff == 0) {
1164                         pgnum++;
1165                         bfa_reg_write(ioc->ioc_regs.host_page_num_fn, pgnum);
1166                 }
1167         }
1168
1169         bfa_reg_write(ioc->ioc_regs.host_page_num_fn,
1170                       bfa_ioc_smem_pgnum(ioc, 0));
1171
1172         /*
1173          * Set boot type and boot param at the end.
1174          */
1175         bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_BOOT_TYPE_OFF,
1176                         bfa_os_swap32(boot_type));
1177         bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_BOOT_PARAM_OFF,
1178                         bfa_os_swap32(boot_param));
1179 }
1180
1181 static void
1182 bfa_ioc_reset(struct bfa_ioc_s *ioc, bfa_boolean_t force)
1183 {
1184         bfa_ioc_hwinit(ioc, force);
1185 }
1186
1187 /**
1188  * Update BFA configuration from firmware configuration.
1189  */
1190 static void
1191 bfa_ioc_getattr_reply(struct bfa_ioc_s *ioc)
1192 {
1193         struct bfi_ioc_attr_s *attr = ioc->attr;
1194
1195         attr->adapter_prop = bfa_os_ntohl(attr->adapter_prop);
1196         attr->card_type     = bfa_os_ntohl(attr->card_type);
1197         attr->maxfrsize = bfa_os_ntohs(attr->maxfrsize);
1198
1199         bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR);
1200 }
1201
1202 /**
1203  * Attach time initialization of mbox logic.
1204  */
1205 static void
1206 bfa_ioc_mbox_attach(struct bfa_ioc_s *ioc)
1207 {
1208         struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1209         int             mc;
1210
1211         INIT_LIST_HEAD(&mod->cmd_q);
1212         for (mc = 0; mc < BFI_MC_MAX; mc++) {
1213                 mod->mbhdlr[mc].cbfn = NULL;
1214                 mod->mbhdlr[mc].cbarg = ioc->bfa;
1215         }
1216 }
1217
1218 /**
1219  * Mbox poll timer -- restarts any pending mailbox requests.
1220  */
1221 static void
1222 bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc)
1223 {
1224         struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1225         struct bfa_mbox_cmd_s *cmd;
1226         u32        stat;
1227
1228         /**
1229          * If no command pending, do nothing
1230          */
1231         if (list_empty(&mod->cmd_q))
1232                 return;
1233
1234         /**
1235          * If previous command is not yet fetched by firmware, do nothing
1236          */
1237         stat = bfa_reg_read(ioc->ioc_regs.hfn_mbox_cmd);
1238         if (stat)
1239                 return;
1240
1241         /**
1242          * Enqueue command to firmware.
1243          */
1244         bfa_q_deq(&mod->cmd_q, &cmd);
1245         bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
1246 }
1247
1248 /**
1249  * Cleanup any pending requests.
1250  */
1251 static void
1252 bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc)
1253 {
1254         struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1255         struct bfa_mbox_cmd_s *cmd;
1256
1257         while (!list_empty(&mod->cmd_q))
1258                 bfa_q_deq(&mod->cmd_q, &cmd);
1259 }
1260
1261 /**
1262  *  bfa_ioc_public
1263  */
1264
1265 /**
1266  * Interface used by diag module to do firmware boot with memory test
1267  * as the entry vector.
1268  */
1269 void
1270 bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type, u32 boot_param)
1271 {
1272         bfa_os_addr_t   rb;
1273
1274         bfa_ioc_stats(ioc, ioc_boots);
1275
1276         if (bfa_ioc_pll_init(ioc) != BFA_STATUS_OK)
1277                 return;
1278
1279         /**
1280          * Initialize IOC state of all functions on a chip reset.
1281          */
1282         rb = ioc->pcidev.pci_bar_kva;
1283         if (boot_param == BFI_BOOT_TYPE_MEMTEST) {
1284                 bfa_reg_write((rb + BFA_IOC0_STATE_REG), BFI_IOC_MEMTEST);
1285                 bfa_reg_write((rb + BFA_IOC1_STATE_REG), BFI_IOC_MEMTEST);
1286         } else {
1287                 bfa_reg_write((rb + BFA_IOC0_STATE_REG), BFI_IOC_INITING);
1288                 bfa_reg_write((rb + BFA_IOC1_STATE_REG), BFI_IOC_INITING);
1289         }
1290
1291         bfa_ioc_msgflush(ioc);
1292         bfa_ioc_download_fw(ioc, boot_type, boot_param);
1293
1294         /**
1295          * Enable interrupts just before starting LPU
1296          */
1297         ioc->cbfn->reset_cbfn(ioc->bfa);
1298         bfa_ioc_lpu_start(ioc);
1299 }
1300
1301 /**
1302  * Enable/disable IOC failure auto recovery.
1303  */
1304 void
1305 bfa_ioc_auto_recover(bfa_boolean_t auto_recover)
1306 {
1307         bfa_auto_recover = auto_recover;
1308 }
1309
1310
1311 bfa_boolean_t
1312 bfa_ioc_is_operational(struct bfa_ioc_s *ioc)
1313 {
1314         return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_op);
1315 }
1316
1317 void
1318 bfa_ioc_msgget(struct bfa_ioc_s *ioc, void *mbmsg)
1319 {
1320         u32       *msgp = mbmsg;
1321         u32        r32;
1322         int             i;
1323
1324         /**
1325          * read the MBOX msg
1326          */
1327         for (i = 0; i < (sizeof(union bfi_ioc_i2h_msg_u) / sizeof(u32));
1328              i++) {
1329                 r32 = bfa_reg_read(ioc->ioc_regs.lpu_mbox +
1330                                    i * sizeof(u32));
1331                 msgp[i] = bfa_os_htonl(r32);
1332         }
1333
1334         /**
1335          * turn off mailbox interrupt by clearing mailbox status
1336          */
1337         bfa_reg_write(ioc->ioc_regs.lpu_mbox_cmd, 1);
1338         bfa_reg_read(ioc->ioc_regs.lpu_mbox_cmd);
1339 }
1340
1341 void
1342 bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *m)
1343 {
1344         union bfi_ioc_i2h_msg_u *msg;
1345
1346         msg = (union bfi_ioc_i2h_msg_u *)m;
1347
1348         bfa_ioc_stats(ioc, ioc_isrs);
1349
1350         switch (msg->mh.msg_id) {
1351         case BFI_IOC_I2H_HBEAT:
1352                 break;
1353
1354         case BFI_IOC_I2H_READY_EVENT:
1355                 bfa_fsm_send_event(ioc, IOC_E_FWREADY);
1356                 break;
1357
1358         case BFI_IOC_I2H_ENABLE_REPLY:
1359                 bfa_fsm_send_event(ioc, IOC_E_FWRSP_ENABLE);
1360                 break;
1361
1362         case BFI_IOC_I2H_DISABLE_REPLY:
1363                 bfa_fsm_send_event(ioc, IOC_E_FWRSP_DISABLE);
1364                 break;
1365
1366         case BFI_IOC_I2H_GETATTR_REPLY:
1367                 bfa_ioc_getattr_reply(ioc);
1368                 break;
1369
1370         default:
1371                 bfa_trc(ioc, msg->mh.msg_id);
1372                 bfa_assert(0);
1373         }
1374 }
1375
1376 /**
1377  * IOC attach time initialization and setup.
1378  *
1379  * @param[in]   ioc     memory for IOC
1380  * @param[in]   bfa     driver instance structure
1381  * @param[in]   trcmod  kernel trace module
1382  * @param[in]   aen     kernel aen event module
1383  * @param[in]   logm    kernel logging module
1384  */
1385 void
1386 bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa, struct bfa_ioc_cbfn_s *cbfn,
1387                struct bfa_timer_mod_s *timer_mod, struct bfa_trc_mod_s *trcmod,
1388                struct bfa_aen_s *aen, struct bfa_log_mod_s *logm)
1389 {
1390         ioc->bfa = bfa;
1391         ioc->cbfn = cbfn;
1392         ioc->timer_mod = timer_mod;
1393         ioc->trcmod = trcmod;
1394         ioc->aen = aen;
1395         ioc->logm = logm;
1396         ioc->fcmode = BFA_FALSE;
1397         ioc->pllinit = BFA_FALSE;
1398         ioc->dbg_fwsave_once = BFA_TRUE;
1399
1400         bfa_ioc_mbox_attach(ioc);
1401         INIT_LIST_HEAD(&ioc->hb_notify_q);
1402
1403         bfa_fsm_set_state(ioc, bfa_ioc_sm_reset);
1404 }
1405
1406 /**
1407  * Driver detach time IOC cleanup.
1408  */
1409 void
1410 bfa_ioc_detach(struct bfa_ioc_s *ioc)
1411 {
1412         bfa_fsm_send_event(ioc, IOC_E_DETACH);
1413 }
1414
1415 /**
1416  * Setup IOC PCI properties.
1417  *
1418  * @param[in]   pcidev  PCI device information for this IOC
1419  */
1420 void
1421 bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
1422                  enum bfi_mclass mc)
1423 {
1424         ioc->ioc_mc = mc;
1425         ioc->pcidev = *pcidev;
1426         ioc->ctdev  = bfa_asic_id_ct(ioc->pcidev.device_id);
1427         ioc->cna = ioc->ctdev && !ioc->fcmode;
1428
1429         /**
1430          * Set asic specific interfaces. See bfa_ioc_cb.c and bfa_ioc_ct.c
1431          */
1432         if (ioc->ctdev)
1433                 bfa_ioc_set_ct_hwif(ioc);
1434         else
1435                 bfa_ioc_set_cb_hwif(ioc);
1436
1437         bfa_ioc_map_port(ioc);
1438         bfa_ioc_reg_init(ioc);
1439 }
1440
1441 /**
1442  * Initialize IOC dma memory
1443  *
1444  * @param[in]   dm_kva  kernel virtual address of IOC dma memory
1445  * @param[in]   dm_pa   physical address of IOC dma memory
1446  */
1447 void
1448 bfa_ioc_mem_claim(struct bfa_ioc_s *ioc, u8 *dm_kva, u64 dm_pa)
1449 {
1450         /**
1451          * dma memory for firmware attribute
1452          */
1453         ioc->attr_dma.kva = dm_kva;
1454         ioc->attr_dma.pa = dm_pa;
1455         ioc->attr = (struct bfi_ioc_attr_s *)dm_kva;
1456 }
1457
1458 /**
1459  * Return size of dma memory required.
1460  */
1461 u32
1462 bfa_ioc_meminfo(void)
1463 {
1464         return BFA_ROUNDUP(sizeof(struct bfi_ioc_attr_s), BFA_DMA_ALIGN_SZ);
1465 }
1466
1467 void
1468 bfa_ioc_enable(struct bfa_ioc_s *ioc)
1469 {
1470         bfa_ioc_stats(ioc, ioc_enables);
1471         ioc->dbg_fwsave_once = BFA_TRUE;
1472
1473         bfa_fsm_send_event(ioc, IOC_E_ENABLE);
1474 }
1475
1476 void
1477 bfa_ioc_disable(struct bfa_ioc_s *ioc)
1478 {
1479         bfa_ioc_stats(ioc, ioc_disables);
1480         bfa_fsm_send_event(ioc, IOC_E_DISABLE);
1481 }
1482
1483 /**
1484  * Returns memory required for saving firmware trace in case of crash.
1485  * Driver must call this interface to allocate memory required for
1486  * automatic saving of firmware trace. Driver should call
1487  * bfa_ioc_debug_memclaim() right after bfa_ioc_attach() to setup this
1488  * trace memory.
1489  */
1490 int
1491 bfa_ioc_debug_trcsz(bfa_boolean_t auto_recover)
1492 {
1493 return (auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
1494 }
1495
1496 /**
1497  * Initialize memory for saving firmware trace. Driver must initialize
1498  * trace memory before call bfa_ioc_enable().
1499  */
1500 void
1501 bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
1502 {
1503         ioc->dbg_fwsave = dbg_fwsave;
1504         ioc->dbg_fwsave_len = bfa_ioc_debug_trcsz(ioc->auto_recover);
1505 }
1506
1507 u32
1508 bfa_ioc_smem_pgnum(struct bfa_ioc_s *ioc, u32 fmaddr)
1509 {
1510         return PSS_SMEM_PGNUM(ioc->ioc_regs.smem_pg0, fmaddr);
1511 }
1512
1513 u32
1514 bfa_ioc_smem_pgoff(struct bfa_ioc_s *ioc, u32 fmaddr)
1515 {
1516         return PSS_SMEM_PGOFF(fmaddr);
1517 }
1518
1519 /**
1520  * Register mailbox message handler functions
1521  *
1522  * @param[in]   ioc             IOC instance
1523  * @param[in]   mcfuncs         message class handler functions
1524  */
1525 void
1526 bfa_ioc_mbox_register(struct bfa_ioc_s *ioc, bfa_ioc_mbox_mcfunc_t *mcfuncs)
1527 {
1528         struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1529         int             mc;
1530
1531         for (mc = 0; mc < BFI_MC_MAX; mc++)
1532                 mod->mbhdlr[mc].cbfn = mcfuncs[mc];
1533 }
1534
1535 /**
1536  * Register mailbox message handler function, to be called by common modules
1537  */
1538 void
1539 bfa_ioc_mbox_regisr(struct bfa_ioc_s *ioc, enum bfi_mclass mc,
1540                     bfa_ioc_mbox_mcfunc_t cbfn, void *cbarg)
1541 {
1542         struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1543
1544         mod->mbhdlr[mc].cbfn = cbfn;
1545         mod->mbhdlr[mc].cbarg = cbarg;
1546 }
1547
1548 /**
1549  * Queue a mailbox command request to firmware. Waits if mailbox is busy.
1550  * Responsibility of caller to serialize
1551  *
1552  * @param[in]   ioc     IOC instance
1553  * @param[i]    cmd     Mailbox command
1554  */
1555 void
1556 bfa_ioc_mbox_queue(struct bfa_ioc_s *ioc, struct bfa_mbox_cmd_s *cmd)
1557 {
1558         struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1559         u32        stat;
1560
1561         /**
1562          * If a previous command is pending, queue new command
1563          */
1564         if (!list_empty(&mod->cmd_q)) {
1565                 list_add_tail(&cmd->qe, &mod->cmd_q);
1566                 return;
1567         }
1568
1569         /**
1570          * If mailbox is busy, queue command for poll timer
1571          */
1572         stat = bfa_reg_read(ioc->ioc_regs.hfn_mbox_cmd);
1573         if (stat) {
1574                 list_add_tail(&cmd->qe, &mod->cmd_q);
1575                 return;
1576         }
1577
1578         /**
1579          * mailbox is free -- queue command to firmware
1580          */
1581         bfa_ioc_mbox_send(ioc, cmd->msg, sizeof(cmd->msg));
1582 }
1583
1584 /**
1585  * Handle mailbox interrupts
1586  */
1587 void
1588 bfa_ioc_mbox_isr(struct bfa_ioc_s *ioc)
1589 {
1590         struct bfa_ioc_mbox_mod_s *mod = &ioc->mbox_mod;
1591         struct bfi_mbmsg_s m;
1592         int             mc;
1593
1594         bfa_ioc_msgget(ioc, &m);
1595
1596         /**
1597          * Treat IOC message class as special.
1598          */
1599         mc = m.mh.msg_class;
1600         if (mc == BFI_MC_IOC) {
1601                 bfa_ioc_isr(ioc, &m);
1602                 return;
1603         }
1604
1605         if ((mc > BFI_MC_MAX) || (mod->mbhdlr[mc].cbfn == NULL))
1606                 return;
1607
1608         mod->mbhdlr[mc].cbfn(mod->mbhdlr[mc].cbarg, &m);
1609 }
1610
1611 void
1612 bfa_ioc_error_isr(struct bfa_ioc_s *ioc)
1613 {
1614         bfa_fsm_send_event(ioc, IOC_E_HWERROR);
1615 }
1616
1617 void
1618 bfa_ioc_set_fcmode(struct bfa_ioc_s *ioc)
1619 {
1620         ioc->fcmode  = BFA_TRUE;
1621         ioc->port_id = bfa_ioc_pcifn(ioc);
1622 }
1623
1624 #ifndef BFA_BIOS_BUILD
1625
1626 /**
1627  * return true if IOC is disabled
1628  */
1629 bfa_boolean_t
1630 bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
1631 {
1632         return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling)
1633                 || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
1634 }
1635
1636 /**
1637  * return true if IOC firmware is different.
1638  */
1639 bfa_boolean_t
1640 bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc)
1641 {
1642         return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset)
1643                 || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_fwcheck)
1644                 || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_mismatch);
1645 }
1646
1647 #define bfa_ioc_state_disabled(__sm)            \
1648         (((__sm) == BFI_IOC_UNINIT) ||          \
1649          ((__sm) == BFI_IOC_INITING) ||         \
1650          ((__sm) == BFI_IOC_HWINIT) ||          \
1651          ((__sm) == BFI_IOC_DISABLED) ||        \
1652          ((__sm) == BFI_IOC_FAIL) ||            \
1653          ((__sm) == BFI_IOC_CFG_DISABLED))
1654
1655 /**
1656  * Check if adapter is disabled -- both IOCs should be in a disabled
1657  * state.
1658  */
1659 bfa_boolean_t
1660 bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc)
1661 {
1662         u32        ioc_state;
1663         bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
1664
1665         if (!bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled))
1666                 return BFA_FALSE;
1667
1668         ioc_state = bfa_reg_read(rb + BFA_IOC0_STATE_REG);
1669         if (!bfa_ioc_state_disabled(ioc_state))
1670                 return BFA_FALSE;
1671
1672         ioc_state = bfa_reg_read(rb + BFA_IOC1_STATE_REG);
1673         if (!bfa_ioc_state_disabled(ioc_state))
1674                 return BFA_FALSE;
1675
1676         return BFA_TRUE;
1677 }
1678
1679 /**
1680  * Add to IOC heartbeat failure notification queue. To be used by common
1681  * modules such as
1682  */
1683 void
1684 bfa_ioc_hbfail_register(struct bfa_ioc_s *ioc,
1685                         struct bfa_ioc_hbfail_notify_s *notify)
1686 {
1687         list_add_tail(&notify->qe, &ioc->hb_notify_q);
1688 }
1689
1690 #define BFA_MFG_NAME "Brocade"
1691 void
1692 bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
1693                          struct bfa_adapter_attr_s *ad_attr)
1694 {
1695         struct bfi_ioc_attr_s *ioc_attr;
1696
1697         ioc_attr = ioc->attr;
1698
1699         bfa_ioc_get_adapter_serial_num(ioc, ad_attr->serial_num);
1700         bfa_ioc_get_adapter_fw_ver(ioc, ad_attr->fw_ver);
1701         bfa_ioc_get_adapter_optrom_ver(ioc, ad_attr->optrom_ver);
1702         bfa_ioc_get_adapter_manufacturer(ioc, ad_attr->manufacturer);
1703         bfa_os_memcpy(&ad_attr->vpd, &ioc_attr->vpd,
1704                       sizeof(struct bfa_mfg_vpd_s));
1705
1706         ad_attr->nports = bfa_ioc_get_nports(ioc);
1707         ad_attr->max_speed = bfa_ioc_speed_sup(ioc);
1708
1709         bfa_ioc_get_adapter_model(ioc, ad_attr->model);
1710         /* For now, model descr uses same model string */
1711         bfa_ioc_get_adapter_model(ioc, ad_attr->model_descr);
1712
1713         ad_attr->card_type = ioc_attr->card_type;
1714         ad_attr->is_mezz = bfa_mfg_is_mezz(ioc_attr->card_type);
1715
1716         if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))
1717                 ad_attr->prototype = 1;
1718         else
1719                 ad_attr->prototype = 0;
1720
1721         ad_attr->pwwn = bfa_ioc_get_pwwn(ioc);
1722         ad_attr->mac = bfa_ioc_get_mac(ioc);
1723
1724         ad_attr->pcie_gen = ioc_attr->pcie_gen;
1725         ad_attr->pcie_lanes = ioc_attr->pcie_lanes;
1726         ad_attr->pcie_lanes_orig = ioc_attr->pcie_lanes_orig;
1727         ad_attr->asic_rev = ioc_attr->asic_rev;
1728
1729         bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);
1730
1731         ad_attr->cna_capable = ioc->cna;
1732 }
1733
1734 enum bfa_ioc_type_e
1735 bfa_ioc_get_type(struct bfa_ioc_s *ioc)
1736 {
1737         if (!ioc->ctdev || ioc->fcmode)
1738                 return BFA_IOC_TYPE_FC;
1739         else if (ioc->ioc_mc == BFI_MC_IOCFC)
1740                 return BFA_IOC_TYPE_FCoE;
1741         else if (ioc->ioc_mc == BFI_MC_LL)
1742                 return BFA_IOC_TYPE_LL;
1743         else {
1744                 bfa_assert(ioc->ioc_mc == BFI_MC_LL);
1745                 return BFA_IOC_TYPE_LL;
1746         }
1747 }
1748
1749 void
1750 bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num)
1751 {
1752         bfa_os_memset((void *)serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);
1753         bfa_os_memcpy((void *)serial_num,
1754                         (void *)ioc->attr->brcd_serialnum,
1755                         BFA_ADAPTER_SERIAL_NUM_LEN);
1756 }
1757
1758 void
1759 bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver)
1760 {
1761         bfa_os_memset((void *)fw_ver, 0, BFA_VERSION_LEN);
1762         bfa_os_memcpy(fw_ver, ioc->attr->fw_version, BFA_VERSION_LEN);
1763 }
1764
1765 void
1766 bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev)
1767 {
1768         bfa_assert(chip_rev);
1769
1770         bfa_os_memset((void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);
1771
1772         chip_rev[0] = 'R';
1773         chip_rev[1] = 'e';
1774         chip_rev[2] = 'v';
1775         chip_rev[3] = '-';
1776         chip_rev[4] = ioc->attr->asic_rev;
1777         chip_rev[5] = '\0';
1778 }
1779
1780 void
1781 bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver)
1782 {
1783         bfa_os_memset((void *)optrom_ver, 0, BFA_VERSION_LEN);
1784         bfa_os_memcpy(optrom_ver, ioc->attr->optrom_version,
1785                 BFA_VERSION_LEN);
1786 }
1787
1788 void
1789 bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc, char *manufacturer)
1790 {
1791         bfa_os_memset((void *)manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);
1792         bfa_os_memcpy(manufacturer, BFA_MFG_NAME, BFA_ADAPTER_MFG_NAME_LEN);
1793 }
1794
1795 void
1796 bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model)
1797 {
1798         struct bfi_ioc_attr_s   *ioc_attr;
1799
1800         bfa_assert(model);
1801         bfa_os_memset((void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);
1802
1803         ioc_attr = ioc->attr;
1804
1805         /**
1806          * model name
1807          */
1808         snprintf(model, BFA_ADAPTER_MODEL_NAME_LEN, "%s-%u",
1809                         BFA_MFG_NAME, ioc_attr->card_type);
1810 }
1811
1812 enum bfa_ioc_state
1813 bfa_ioc_get_state(struct bfa_ioc_s *ioc)
1814 {
1815         return bfa_sm_to_state(ioc_sm_table, ioc->fsm);
1816 }
1817
1818 void
1819 bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr)
1820 {
1821         bfa_os_memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr_s));
1822
1823         ioc_attr->state = bfa_ioc_get_state(ioc);
1824         ioc_attr->port_id = ioc->port_id;
1825
1826         ioc_attr->ioc_type = bfa_ioc_get_type(ioc);
1827
1828         bfa_ioc_get_adapter_attr(ioc, &ioc_attr->adapter_attr);
1829
1830         ioc_attr->pci_attr.device_id = ioc->pcidev.device_id;
1831         ioc_attr->pci_attr.pcifn = ioc->pcidev.pci_func;
1832         bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
1833 }
1834
1835 /**
1836  *  bfa_wwn_public
1837  */
1838 wwn_t
1839 bfa_ioc_get_pwwn(struct bfa_ioc_s *ioc)
1840 {
1841         return ioc->attr->pwwn;
1842 }
1843
1844 wwn_t
1845 bfa_ioc_get_nwwn(struct bfa_ioc_s *ioc)
1846 {
1847         return ioc->attr->nwwn;
1848 }
1849
1850 u64
1851 bfa_ioc_get_adid(struct bfa_ioc_s *ioc)
1852 {
1853         return ioc->attr->mfg_pwwn;
1854 }
1855
1856 mac_t
1857 bfa_ioc_get_mac(struct bfa_ioc_s *ioc)
1858 {
1859         /*
1860          * Currently mfg mac is used as FCoE enode mac (not configured by PBC)
1861          */
1862         if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_FCoE)
1863                 return bfa_ioc_get_mfg_mac(ioc);
1864         else
1865                 return ioc->attr->mac;
1866 }
1867
1868 wwn_t
1869 bfa_ioc_get_mfg_pwwn(struct bfa_ioc_s *ioc)
1870 {
1871         return ioc->attr->mfg_pwwn;
1872 }
1873
1874 wwn_t
1875 bfa_ioc_get_mfg_nwwn(struct bfa_ioc_s *ioc)
1876 {
1877         return ioc->attr->mfg_nwwn;
1878 }
1879
1880 mac_t
1881 bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc)
1882 {
1883         mac_t   mac;
1884
1885         mac = ioc->attr->mfg_mac;
1886         mac.mac[MAC_ADDRLEN - 1] += bfa_ioc_pcifn(ioc);
1887
1888         return mac;
1889 }
1890
1891 bfa_boolean_t
1892 bfa_ioc_get_fcmode(struct bfa_ioc_s *ioc)
1893 {
1894         return ioc->fcmode || !bfa_asic_id_ct(ioc->pcidev.device_id);
1895 }
1896
1897 /**
1898  * Send AEN notification
1899  */
1900 void
1901 bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event)
1902 {
1903         union bfa_aen_data_u aen_data;
1904         struct bfa_log_mod_s *logmod = ioc->logm;
1905         s32         inst_num = 0;
1906         enum bfa_ioc_type_e ioc_type;
1907
1908         bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_IOC, event), inst_num);
1909
1910         memset(&aen_data.ioc.pwwn, 0, sizeof(aen_data.ioc.pwwn));
1911         memset(&aen_data.ioc.mac, 0, sizeof(aen_data.ioc.mac));
1912         ioc_type = bfa_ioc_get_type(ioc);
1913         switch (ioc_type) {
1914         case BFA_IOC_TYPE_FC:
1915                 aen_data.ioc.pwwn = bfa_ioc_get_pwwn(ioc);
1916                 break;
1917         case BFA_IOC_TYPE_FCoE:
1918                 aen_data.ioc.pwwn = bfa_ioc_get_pwwn(ioc);
1919                 aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
1920                 break;
1921         case BFA_IOC_TYPE_LL:
1922                 aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
1923                 break;
1924         default:
1925                 bfa_assert(ioc_type == BFA_IOC_TYPE_FC);
1926                 break;
1927         }
1928         aen_data.ioc.ioc_type = ioc_type;
1929 }
1930
1931 /**
1932  * Retrieve saved firmware trace from a prior IOC failure.
1933  */
1934 bfa_status_t
1935 bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
1936 {
1937         int             tlen;
1938
1939         if (ioc->dbg_fwsave_len == 0)
1940                 return BFA_STATUS_ENOFSAVE;
1941
1942         tlen = *trclen;
1943         if (tlen > ioc->dbg_fwsave_len)
1944                 tlen = ioc->dbg_fwsave_len;
1945
1946         bfa_os_memcpy(trcdata, ioc->dbg_fwsave, tlen);
1947         *trclen = tlen;
1948         return BFA_STATUS_OK;
1949 }
1950
1951 /**
1952  * Clear saved firmware trace
1953  */
1954 void
1955 bfa_ioc_debug_fwsave_clear(struct bfa_ioc_s *ioc)
1956 {
1957         ioc->dbg_fwsave_once = BFA_TRUE;
1958 }
1959
1960 /**
1961  * Retrieve saved firmware trace from a prior IOC failure.
1962  */
1963 bfa_status_t
1964 bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
1965 {
1966         u32        pgnum;
1967         u32        loff = BFA_DBG_FWTRC_OFF(bfa_ioc_portid(ioc));
1968         int             i, tlen;
1969         u32       *tbuf = trcdata, r32;
1970
1971         bfa_trc(ioc, *trclen);
1972
1973         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
1974         loff = bfa_ioc_smem_pgoff(ioc, loff);
1975
1976         /*
1977          *  Hold semaphore to serialize pll init and fwtrc.
1978          */
1979         if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg))
1980                 return BFA_STATUS_FAILED;
1981
1982         bfa_reg_write(ioc->ioc_regs.host_page_num_fn, pgnum);
1983
1984         tlen = *trclen;
1985         if (tlen > BFA_DBG_FWTRC_LEN)
1986                 tlen = BFA_DBG_FWTRC_LEN;
1987         tlen /= sizeof(u32);
1988
1989         bfa_trc(ioc, tlen);
1990
1991         for (i = 0; i < tlen; i++) {
1992                 r32 = bfa_mem_read(ioc->ioc_regs.smem_page_start, loff);
1993                 tbuf[i] = bfa_os_ntohl(r32);
1994                 loff += sizeof(u32);
1995
1996                 /**
1997                  * handle page offset wrap around
1998                  */
1999                 loff = PSS_SMEM_PGOFF(loff);
2000                 if (loff == 0) {
2001                         pgnum++;
2002                         bfa_reg_write(ioc->ioc_regs.host_page_num_fn, pgnum);
2003                 }
2004         }
2005         bfa_reg_write(ioc->ioc_regs.host_page_num_fn,
2006                       bfa_ioc_smem_pgnum(ioc, 0));
2007
2008         /*
2009          *  release semaphore.
2010          */
2011         bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
2012
2013         bfa_trc(ioc, pgnum);
2014
2015         *trclen = tlen * sizeof(u32);
2016         return BFA_STATUS_OK;
2017 }
2018
2019 /**
2020  * Save firmware trace if configured.
2021  */
2022 static void
2023 bfa_ioc_debug_save(struct bfa_ioc_s *ioc)
2024 {
2025         int             tlen;
2026
2027         if (ioc->dbg_fwsave_len) {
2028                 tlen = ioc->dbg_fwsave_len;
2029                 bfa_ioc_debug_fwtrc(ioc, ioc->dbg_fwsave, &tlen);
2030         }
2031 }
2032
2033 /**
2034  * Firmware failure detected. Start recovery actions.
2035  */
2036 static void
2037 bfa_ioc_recover(struct bfa_ioc_s *ioc)
2038 {
2039         if (ioc->dbg_fwsave_once) {
2040                 ioc->dbg_fwsave_once = BFA_FALSE;
2041                 bfa_ioc_debug_save(ioc);
2042         }
2043
2044         bfa_ioc_stats(ioc, ioc_hbfails);
2045         bfa_fsm_send_event(ioc, IOC_E_HBFAIL);
2046 }
2047
2048 static void
2049 bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc)
2050 {
2051         if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_LL)
2052                 return;
2053
2054         if (ioc->attr->nwwn == 0)
2055                 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_NWWN);
2056         if (ioc->attr->pwwn == 0)
2057                 bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_PWWN);
2058 }
2059
2060 #endif