Pileus Git - ~andy/linux/blob - drivers/scsi/bfa/bfa_ioc.c

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