SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/bfa/bfa_iocfc.c

   1 /*
   2  * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
   3  * All rights reserved
   4  * www.brocade.com
   5  *
   6  * Linux driver for Brocade Fibre Channel Host Bus Adapter.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License (GPL) Version 2 as
  10  * published by the Free Software Foundation
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  */
  17
  18 #include <cs/bfa_debug.h>
  19 #include <bfa_priv.h>
  20 #include <log/bfa_log_hal.h>
  21 #include <bfi/bfi_boot.h>
  22 #include <bfi/bfi_cbreg.h>
  23 #include <aen/bfa_aen_ioc.h>
  24 #include <defs/bfa_defs_iocfc.h>
  25 #include <defs/bfa_defs_pci.h>
  26 #include "bfa_callback_priv.h"
  27 #include "bfad_drv.h"
  28
  29 BFA_TRC_FILE(HAL, IOCFC);
  30
  31 /**
  32  * IOC local definitions
  33  */
  34 #define BFA_IOCFC_TOV           5000    /* msecs */
  35
  36 enum {
  37         BFA_IOCFC_ACT_NONE      = 0,
  38         BFA_IOCFC_ACT_INIT      = 1,
  39         BFA_IOCFC_ACT_STOP      = 2,
  40         BFA_IOCFC_ACT_DISABLE   = 3,
  41 };
  42
  43 /*
  44  * forward declarations
  45  */
  46 static void bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status);
  47 static void bfa_iocfc_disable_cbfn(void *bfa_arg);
  48 static void bfa_iocfc_hbfail_cbfn(void *bfa_arg);
  49 static void bfa_iocfc_reset_cbfn(void *bfa_arg);
  50 static void bfa_iocfc_stats_clear(void *bfa_arg);
  51 static void bfa_iocfc_stats_swap(struct bfa_fw_stats_s *d,
  52                         struct bfa_fw_stats_s *s);
  53 static void bfa_iocfc_stats_clr_cb(void *bfa_arg, bfa_boolean_t complete);
  54 static void bfa_iocfc_stats_clr_timeout(void *bfa_arg);
  55 static void bfa_iocfc_stats_cb(void *bfa_arg, bfa_boolean_t complete);
  56 static void bfa_iocfc_stats_timeout(void *bfa_arg);
  57
  58 static struct bfa_ioc_cbfn_s bfa_iocfc_cbfn;
  59
  60 /**
  61  *  bfa_ioc_pvt BFA IOC private functions
  62  */
  63
  64 static void
  65 bfa_iocfc_cqs_sz(struct bfa_iocfc_cfg_s *cfg, u32 *dm_len)
  66 {
  67         int             i, per_reqq_sz, per_rspq_sz;
  68
  69         per_reqq_sz = BFA_ROUNDUP((cfg->drvcfg.num_reqq_elems * BFI_LMSG_SZ),
  70                                                         BFA_DMA_ALIGN_SZ);
  71         per_rspq_sz = BFA_ROUNDUP((cfg->drvcfg.num_rspq_elems * BFI_LMSG_SZ),
  72                                                         BFA_DMA_ALIGN_SZ);
  73
  74         /*
  75          * Calculate CQ size
  76          */
  77         for (i = 0; i < cfg->fwcfg.num_cqs; i++) {
  78                 *dm_len = *dm_len + per_reqq_sz;
  79                 *dm_len = *dm_len + per_rspq_sz;
  80         }
  81
  82         /*
  83          * Calculate Shadow CI/PI size
  84          */
  85         for (i = 0; i < cfg->fwcfg.num_cqs; i++)
  86                 *dm_len += (2 * BFA_CACHELINE_SZ);
  87 }
  88
  89 static void
  90 bfa_iocfc_fw_cfg_sz(struct bfa_iocfc_cfg_s *cfg, u32 *dm_len)
  91 {
  92         *dm_len +=
  93                 BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ);
  94         *dm_len +=
  95                 BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s),
  96                             BFA_CACHELINE_SZ);
  97         *dm_len += BFA_ROUNDUP(sizeof(struct bfa_fw_stats_s), BFA_CACHELINE_SZ);
  98 }
  99
 100 /**
 101  * Use the Mailbox interface to send BFI_IOCFC_H2I_CFG_REQ
 102  */
 103 static void
 104 bfa_iocfc_send_cfg(void *bfa_arg)
 105 {
 106         struct bfa_s *bfa = bfa_arg;
 107         struct bfa_iocfc_s *iocfc = &bfa->iocfc;
 108         struct bfi_iocfc_cfg_req_s cfg_req;
 109         struct bfi_iocfc_cfg_s *cfg_info = iocfc->cfginfo;
 110         struct bfa_iocfc_cfg_s  *cfg = &iocfc->cfg;
 111         int             i;
 112
 113         bfa_assert(cfg->fwcfg.num_cqs <= BFI_IOC_MAX_CQS);
 114         bfa_trc(bfa, cfg->fwcfg.num_cqs);
 115
 116         iocfc->cfgdone = BFA_FALSE;
 117         bfa_iocfc_reset_queues(bfa);
 118
 119         /**
 120          * initialize IOC configuration info
 121          */
 122         cfg_info->endian_sig = BFI_IOC_ENDIAN_SIG;
 123         cfg_info->num_cqs = cfg->fwcfg.num_cqs;
 124
 125         bfa_dma_be_addr_set(cfg_info->cfgrsp_addr, iocfc->cfgrsp_dma.pa);
 126         bfa_dma_be_addr_set(cfg_info->stats_addr, iocfc->stats_pa);
 127
 128         /**
 129          * dma map REQ and RSP circular queues and shadow pointers
 130          */
 131         for (i = 0; i < cfg->fwcfg.num_cqs; i++) {
 132                 bfa_dma_be_addr_set(cfg_info->req_cq_ba[i],
 133                                        iocfc->req_cq_ba[i].pa);
 134                 bfa_dma_be_addr_set(cfg_info->req_shadow_ci[i],
 135                                        iocfc->req_cq_shadow_ci[i].pa);
 136                 cfg_info->req_cq_elems[i] =
 137                         bfa_os_htons(cfg->drvcfg.num_reqq_elems);
 138
 139                 bfa_dma_be_addr_set(cfg_info->rsp_cq_ba[i],
 140                                        iocfc->rsp_cq_ba[i].pa);
 141                 bfa_dma_be_addr_set(cfg_info->rsp_shadow_pi[i],
 142                                        iocfc->rsp_cq_shadow_pi[i].pa);
 143                 cfg_info->rsp_cq_elems[i] =
 144                         bfa_os_htons(cfg->drvcfg.num_rspq_elems);
 145         }
 146
 147         /**
 148          * dma map IOC configuration itself
 149          */
 150         bfi_h2i_set(cfg_req.mh, BFI_MC_IOCFC, BFI_IOCFC_H2I_CFG_REQ,
 151                         bfa_lpuid(bfa));
 152         bfa_dma_be_addr_set(cfg_req.ioc_cfg_dma_addr, iocfc->cfg_info.pa);
 153
 154         bfa_ioc_mbox_send(&bfa->ioc, &cfg_req,
 155                         sizeof(struct bfi_iocfc_cfg_req_s));
 156 }
 157
 158 static void
 159 bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 160                     struct bfa_pcidev_s *pcidev)
 161 {
 162         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 163
 164         bfa->bfad = bfad;
 165         iocfc->bfa = bfa;
 166         iocfc->action = BFA_IOCFC_ACT_NONE;
 167
 168         bfa_os_assign(iocfc->cfg, *cfg);
 169
 170         /**
 171          * Initialize chip specific handlers.
 172          */
 173         if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT) {
 174                 iocfc->hwif.hw_reginit = bfa_hwct_reginit;
 175                 iocfc->hwif.hw_reqq_ack = bfa_hwct_reqq_ack;
 176                 iocfc->hwif.hw_rspq_ack = bfa_hwct_rspq_ack;
 177                 iocfc->hwif.hw_msix_init = bfa_hwct_msix_init;
 178                 iocfc->hwif.hw_msix_install = bfa_hwct_msix_install;
 179                 iocfc->hwif.hw_msix_uninstall = bfa_hwct_msix_uninstall;
 180                 iocfc->hwif.hw_isr_mode_set = bfa_hwct_isr_mode_set;
 181                 iocfc->hwif.hw_msix_getvecs = bfa_hwct_msix_getvecs;
 182         } else {
 183                 iocfc->hwif.hw_reginit = bfa_hwcb_reginit;
 184                 iocfc->hwif.hw_reqq_ack = bfa_hwcb_reqq_ack;
 185                 iocfc->hwif.hw_rspq_ack = bfa_hwcb_rspq_ack;
 186                 iocfc->hwif.hw_msix_init = bfa_hwcb_msix_init;
 187                 iocfc->hwif.hw_msix_install = bfa_hwcb_msix_install;
 188                 iocfc->hwif.hw_msix_uninstall = bfa_hwcb_msix_uninstall;
 189                 iocfc->hwif.hw_isr_mode_set = bfa_hwcb_isr_mode_set;
 190                 iocfc->hwif.hw_msix_getvecs = bfa_hwcb_msix_getvecs;
 191         }
 192
 193         iocfc->hwif.hw_reginit(bfa);
 194         bfa->msix.nvecs = 0;
 195 }
 196
 197 static void
 198 bfa_iocfc_mem_claim(struct bfa_s *bfa, struct bfa_iocfc_cfg_s *cfg,
 199                       struct bfa_meminfo_s *meminfo)
 200 {
 201         u8        *dm_kva;
 202         u64        dm_pa;
 203         int             i, per_reqq_sz, per_rspq_sz;
 204         struct bfa_iocfc_s  *iocfc = &bfa->iocfc;
 205         int             dbgsz;
 206
 207         dm_kva = bfa_meminfo_dma_virt(meminfo);
 208         dm_pa = bfa_meminfo_dma_phys(meminfo);
 209
 210         /*
 211          * First allocate dma memory for IOC.
 212          */
 213         bfa_ioc_mem_claim(&bfa->ioc, dm_kva, dm_pa);
 214         dm_kva += bfa_ioc_meminfo();
 215         dm_pa  += bfa_ioc_meminfo();
 216
 217         /*
 218          * Claim DMA-able memory for the request/response queues and for shadow
 219          * ci/pi registers
 220          */
 221         per_reqq_sz = BFA_ROUNDUP((cfg->drvcfg.num_reqq_elems * BFI_LMSG_SZ),
 222                                                         BFA_DMA_ALIGN_SZ);
 223         per_rspq_sz = BFA_ROUNDUP((cfg->drvcfg.num_rspq_elems * BFI_LMSG_SZ),
 224                                                         BFA_DMA_ALIGN_SZ);
 225
 226         for (i = 0; i < cfg->fwcfg.num_cqs; i++) {
 227                 iocfc->req_cq_ba[i].kva = dm_kva;
 228                 iocfc->req_cq_ba[i].pa = dm_pa;
 229                 bfa_os_memset(dm_kva, 0, per_reqq_sz);
 230                 dm_kva += per_reqq_sz;
 231                 dm_pa += per_reqq_sz;
 232
 233                 iocfc->rsp_cq_ba[i].kva = dm_kva;
 234                 iocfc->rsp_cq_ba[i].pa = dm_pa;
 235                 bfa_os_memset(dm_kva, 0, per_rspq_sz);
 236                 dm_kva += per_rspq_sz;
 237                 dm_pa += per_rspq_sz;
 238         }
 239
 240         for (i = 0; i < cfg->fwcfg.num_cqs; i++) {
 241                 iocfc->req_cq_shadow_ci[i].kva = dm_kva;
 242                 iocfc->req_cq_shadow_ci[i].pa = dm_pa;
 243                 dm_kva += BFA_CACHELINE_SZ;
 244                 dm_pa += BFA_CACHELINE_SZ;
 245
 246                 iocfc->rsp_cq_shadow_pi[i].kva = dm_kva;
 247                 iocfc->rsp_cq_shadow_pi[i].pa = dm_pa;
 248                 dm_kva += BFA_CACHELINE_SZ;
 249                 dm_pa += BFA_CACHELINE_SZ;
 250         }
 251
 252         /*
 253          * Claim DMA-able memory for the config info page
 254          */
 255         bfa->iocfc.cfg_info.kva = dm_kva;
 256         bfa->iocfc.cfg_info.pa = dm_pa;
 257         bfa->iocfc.cfginfo = (struct bfi_iocfc_cfg_s *) dm_kva;
 258         dm_kva += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ);
 259         dm_pa += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfg_s), BFA_CACHELINE_SZ);
 260
 261         /*
 262          * Claim DMA-able memory for the config response
 263          */
 264         bfa->iocfc.cfgrsp_dma.kva = dm_kva;
 265         bfa->iocfc.cfgrsp_dma.pa = dm_pa;
 266         bfa->iocfc.cfgrsp = (struct bfi_iocfc_cfgrsp_s *) dm_kva;
 267
 268         dm_kva +=
 269                 BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s),
 270                             BFA_CACHELINE_SZ);
 271         dm_pa += BFA_ROUNDUP(sizeof(struct bfi_iocfc_cfgrsp_s),
 272                              BFA_CACHELINE_SZ);
 273
 274         /*
 275          * Claim DMA-able memory for iocfc stats
 276          */
 277         bfa->iocfc.stats_kva = dm_kva;
 278         bfa->iocfc.stats_pa = dm_pa;
 279         bfa->iocfc.fw_stats = (struct bfa_fw_stats_s *) dm_kva;
 280         dm_kva += BFA_ROUNDUP(sizeof(struct bfa_fw_stats_s), BFA_CACHELINE_SZ);
 281         dm_pa += BFA_ROUNDUP(sizeof(struct bfa_fw_stats_s), BFA_CACHELINE_SZ);
 282
 283         bfa_meminfo_dma_virt(meminfo) = dm_kva;
 284         bfa_meminfo_dma_phys(meminfo) = dm_pa;
 285
 286         dbgsz = bfa_ioc_debug_trcsz(bfa_auto_recover);
 287         if (dbgsz > 0) {
 288                 bfa_ioc_debug_memclaim(&bfa->ioc, bfa_meminfo_kva(meminfo));
 289                 bfa_meminfo_kva(meminfo) += dbgsz;
 290         }
 291 }
 292
 293 /**
 294  * BFA submodules initialization completion notification.
 295  */
 296 static void
 297 bfa_iocfc_initdone_submod(struct bfa_s *bfa)
 298 {
 299         int             i;
 300
 301         for (i = 0; hal_mods[i]; i++)
 302                 hal_mods[i]->initdone(bfa);
 303 }
 304
 305 /**
 306  * Start BFA submodules.
 307  */
 308 static void
 309 bfa_iocfc_start_submod(struct bfa_s *bfa)
 310 {
 311         int             i;
 312
 313         bfa->rme_process = BFA_TRUE;
 314
 315         for (i = 0; hal_mods[i]; i++)
 316                 hal_mods[i]->start(bfa);
 317 }
 318
 319 /**
 320  * Disable BFA submodules.
 321  */
 322 static void
 323 bfa_iocfc_disable_submod(struct bfa_s *bfa)
 324 {
 325         int             i;
 326
 327         for (i = 0; hal_mods[i]; i++)
 328                 hal_mods[i]->iocdisable(bfa);
 329 }
 330
 331 static void
 332 bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete)
 333 {
 334         struct bfa_s    *bfa = bfa_arg;
 335
 336         if (complete) {
 337                 if (bfa->iocfc.cfgdone)
 338                         bfa_cb_init(bfa->bfad, BFA_STATUS_OK);
 339                 else
 340                         bfa_cb_init(bfa->bfad, BFA_STATUS_FAILED);
 341         } else {
 342                 if (bfa->iocfc.cfgdone)
 343                         bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
 344         }
 345 }
 346
 347 static void
 348 bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl)
 349 {
 350         struct bfa_s  *bfa = bfa_arg;
 351         struct bfad_s *bfad = bfa->bfad;
 352
 353         if (compl)
 354                 complete(&bfad->comp);
 355
 356         else
 357                 bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
 358 }
 359
 360 static void
 361 bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl)
 362 {
 363         struct bfa_s  *bfa = bfa_arg;
 364         struct bfad_s *bfad = bfa->bfad;
 365
 366         if (compl)
 367                 complete(&bfad->disable_comp);
 368 }
 369
 370 /**
 371  * Update BFA configuration from firmware configuration.
 372  */
 373 static void
 374 bfa_iocfc_cfgrsp(struct bfa_s *bfa)
 375 {
 376         struct bfa_iocfc_s              *iocfc   = &bfa->iocfc;
 377         struct bfi_iocfc_cfgrsp_s       *cfgrsp  = iocfc->cfgrsp;
 378         struct bfa_iocfc_fwcfg_s        *fwcfg   = &cfgrsp->fwcfg;
 379         struct bfi_iocfc_cfg_s          *cfginfo = iocfc->cfginfo;
 380
 381         fwcfg->num_cqs        = fwcfg->num_cqs;
 382         fwcfg->num_ioim_reqs  = bfa_os_ntohs(fwcfg->num_ioim_reqs);
 383         fwcfg->num_tskim_reqs = bfa_os_ntohs(fwcfg->num_tskim_reqs);
 384         fwcfg->num_fcxp_reqs  = bfa_os_ntohs(fwcfg->num_fcxp_reqs);
 385         fwcfg->num_uf_bufs    = bfa_os_ntohs(fwcfg->num_uf_bufs);
 386         fwcfg->num_rports     = bfa_os_ntohs(fwcfg->num_rports);
 387
 388         cfginfo->intr_attr.coalesce = cfgrsp->intr_attr.coalesce;
 389         cfginfo->intr_attr.delay    = bfa_os_ntohs(cfgrsp->intr_attr.delay);
 390         cfginfo->intr_attr.latency  = bfa_os_ntohs(cfgrsp->intr_attr.latency);
 391
 392         iocfc->cfgdone = BFA_TRUE;
 393
 394         /**
 395          * Configuration is complete - initialize/start submodules
 396          */
 397         if (iocfc->action == BFA_IOCFC_ACT_INIT)
 398                 bfa_cb_queue(bfa, &iocfc->init_hcb_qe, bfa_iocfc_init_cb, bfa);
 399         else
 400                 bfa_iocfc_start_submod(bfa);
 401 }
 402
 403 static void
 404 bfa_iocfc_stats_clear(void *bfa_arg)
 405 {
 406         struct bfa_s            *bfa = bfa_arg;
 407         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 408         struct bfi_iocfc_stats_req_s stats_req;
 409
 410         bfa_timer_start(bfa, &iocfc->stats_timer,
 411                             bfa_iocfc_stats_clr_timeout, bfa,
 412                             BFA_IOCFC_TOV);
 413
 414         bfi_h2i_set(stats_req.mh, BFI_MC_IOCFC, BFI_IOCFC_H2I_CLEAR_STATS_REQ,
 415                 bfa_lpuid(bfa));
 416         bfa_ioc_mbox_send(&bfa->ioc, &stats_req,
 417                 sizeof(struct bfi_iocfc_stats_req_s));
 418 }
 419
 420 static void
 421 bfa_iocfc_stats_swap(struct bfa_fw_stats_s *d, struct bfa_fw_stats_s *s)
 422 {
 423         u32       *dip = (u32 *) d;
 424         u32       *sip = (u32 *) s;
 425         int             i;
 426
 427         for (i = 0; i < (sizeof(struct bfa_fw_stats_s) / sizeof(u32)); i++)
 428                 dip[i] = bfa_os_ntohl(sip[i]);
 429 }
 430
 431 static void
 432 bfa_iocfc_stats_clr_cb(void *bfa_arg, bfa_boolean_t complete)
 433 {
 434         struct bfa_s *bfa = bfa_arg;
 435         struct bfa_iocfc_s *iocfc = &bfa->iocfc;
 436
 437         if (complete) {
 438                 bfa_ioc_clr_stats(&bfa->ioc);
 439                 iocfc->stats_cbfn(iocfc->stats_cbarg, iocfc->stats_status);
 440         } else {
 441                 iocfc->stats_busy = BFA_FALSE;
 442                 iocfc->stats_status = BFA_STATUS_OK;
 443         }
 444 }
 445
 446 static void
 447 bfa_iocfc_stats_clr_timeout(void *bfa_arg)
 448 {
 449         struct bfa_s            *bfa = bfa_arg;
 450         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 451
 452         bfa_trc(bfa, 0);
 453
 454         iocfc->stats_status = BFA_STATUS_ETIMER;
 455         bfa_cb_queue(bfa, &iocfc->stats_hcb_qe, bfa_iocfc_stats_clr_cb, bfa);
 456 }
 457
 458 static void
 459 bfa_iocfc_stats_cb(void *bfa_arg, bfa_boolean_t complete)
 460 {
 461         struct bfa_s            *bfa = bfa_arg;
 462         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 463
 464         if (complete) {
 465                 if (iocfc->stats_status == BFA_STATUS_OK) {
 466                         bfa_os_memset(iocfc->stats_ret, 0,
 467                                 sizeof(*iocfc->stats_ret));
 468                         bfa_iocfc_stats_swap(&iocfc->stats_ret->fw_stats,
 469                                 iocfc->fw_stats);
 470                 }
 471                 iocfc->stats_cbfn(iocfc->stats_cbarg, iocfc->stats_status);
 472         } else {
 473                 iocfc->stats_busy = BFA_FALSE;
 474                 iocfc->stats_status = BFA_STATUS_OK;
 475         }
 476 }
 477
 478 static void
 479 bfa_iocfc_stats_timeout(void *bfa_arg)
 480 {
 481         struct bfa_s            *bfa = bfa_arg;
 482         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 483
 484         bfa_trc(bfa, 0);
 485
 486         iocfc->stats_status = BFA_STATUS_ETIMER;
 487         bfa_cb_queue(bfa, &iocfc->stats_hcb_qe, bfa_iocfc_stats_cb, bfa);
 488 }
 489
 490 static void
 491 bfa_iocfc_stats_query(struct bfa_s *bfa)
 492 {
 493         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 494         struct bfi_iocfc_stats_req_s stats_req;
 495
 496         bfa_timer_start(bfa, &iocfc->stats_timer,
 497                             bfa_iocfc_stats_timeout, bfa, BFA_IOCFC_TOV);
 498
 499         bfi_h2i_set(stats_req.mh, BFI_MC_IOCFC, BFI_IOCFC_H2I_GET_STATS_REQ,
 500                         bfa_lpuid(bfa));
 501         bfa_ioc_mbox_send(&bfa->ioc, &stats_req,
 502                 sizeof(struct bfi_iocfc_stats_req_s));
 503 }
 504
 505 void
 506 bfa_iocfc_reset_queues(struct bfa_s *bfa)
 507 {
 508         int             q;
 509
 510         for (q = 0; q < BFI_IOC_MAX_CQS; q++) {
 511                 bfa_reqq_ci(bfa, q) = 0;
 512                 bfa_reqq_pi(bfa, q) = 0;
 513                 bfa_rspq_ci(bfa, q) = 0;
 514                 bfa_rspq_pi(bfa, q) = 0;
 515         }
 516 }
 517
 518 /**
 519  * IOC enable request is complete
 520  */
 521 static void
 522 bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status)
 523 {
 524         struct bfa_s    *bfa = bfa_arg;
 525
 526         if (status != BFA_STATUS_OK) {
 527                 bfa_isr_disable(bfa);
 528                 if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
 529                         bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
 530                                      bfa_iocfc_init_cb, bfa);
 531                 return;
 532         }
 533
 534         bfa_iocfc_initdone_submod(bfa);
 535         bfa_iocfc_send_cfg(bfa);
 536 }
 537
 538 /**
 539  * IOC disable request is complete
 540  */
 541 static void
 542 bfa_iocfc_disable_cbfn(void *bfa_arg)
 543 {
 544         struct bfa_s    *bfa = bfa_arg;
 545
 546         bfa_isr_disable(bfa);
 547         bfa_iocfc_disable_submod(bfa);
 548
 549         if (bfa->iocfc.action == BFA_IOCFC_ACT_STOP)
 550                 bfa_cb_queue(bfa, &bfa->iocfc.stop_hcb_qe, bfa_iocfc_stop_cb,
 551                              bfa);
 552         else {
 553                 bfa_assert(bfa->iocfc.action == BFA_IOCFC_ACT_DISABLE);
 554                 bfa_cb_queue(bfa, &bfa->iocfc.dis_hcb_qe, bfa_iocfc_disable_cb,
 555                              bfa);
 556         }
 557 }
 558
 559 /**
 560  * Notify sub-modules of hardware failure.
 561  */
 562 static void
 563 bfa_iocfc_hbfail_cbfn(void *bfa_arg)
 564 {
 565         struct bfa_s    *bfa = bfa_arg;
 566
 567         bfa->rme_process = BFA_FALSE;
 568
 569         bfa_isr_disable(bfa);
 570         bfa_iocfc_disable_submod(bfa);
 571
 572         if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
 573                 bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe, bfa_iocfc_init_cb,
 574                              bfa);
 575 }
 576
 577 /**
 578  * Actions on chip-reset completion.
 579  */
 580 static void
 581 bfa_iocfc_reset_cbfn(void *bfa_arg)
 582 {
 583         struct bfa_s    *bfa = bfa_arg;
 584
 585         bfa_iocfc_reset_queues(bfa);
 586         bfa_isr_enable(bfa);
 587 }
 588
 589
 590
 591 /**
 592  *  bfa_ioc_public
 593  */
 594
 595 /**
 596  * Query IOC memory requirement information.
 597  */
 598 void
 599 bfa_iocfc_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len,
 600                 u32 *dm_len)
 601 {
 602         /* dma memory for IOC */
 603         *dm_len += bfa_ioc_meminfo();
 604
 605         bfa_iocfc_fw_cfg_sz(cfg, dm_len);
 606         bfa_iocfc_cqs_sz(cfg, dm_len);
 607         *km_len += bfa_ioc_debug_trcsz(bfa_auto_recover);
 608 }
 609
 610 /**
 611  * Query IOC memory requirement information.
 612  */
 613 void
 614 bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 615                    struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
 616 {
 617         int             i;
 618
 619         bfa_iocfc_cbfn.enable_cbfn = bfa_iocfc_enable_cbfn;
 620         bfa_iocfc_cbfn.disable_cbfn = bfa_iocfc_disable_cbfn;
 621         bfa_iocfc_cbfn.hbfail_cbfn = bfa_iocfc_hbfail_cbfn;
 622         bfa_iocfc_cbfn.reset_cbfn = bfa_iocfc_reset_cbfn;
 623
 624         bfa_ioc_attach(&bfa->ioc, bfa, &bfa_iocfc_cbfn, &bfa->timer_mod,
 625                 bfa->trcmod, bfa->aen, bfa->logm);
 626
 627         /**
 628          * Choose FC (ssid: 0x1C) v/s FCoE (ssid: 0x14) mode.
 629          */
 630         if (0)
 631                 bfa_ioc_set_fcmode(&bfa->ioc);
 632
 633         bfa_ioc_pci_init(&bfa->ioc, pcidev, BFI_MC_IOCFC);
 634         bfa_ioc_mbox_register(&bfa->ioc, bfa_mbox_isrs);
 635
 636         bfa_iocfc_init_mem(bfa, bfad, cfg, pcidev);
 637         bfa_iocfc_mem_claim(bfa, cfg, meminfo);
 638         bfa_timer_init(&bfa->timer_mod);
 639
 640         INIT_LIST_HEAD(&bfa->comp_q);
 641         for (i = 0; i < BFI_IOC_MAX_CQS; i++)
 642                 INIT_LIST_HEAD(&bfa->reqq_waitq[i]);
 643 }
 644
 645 /**
 646  * Query IOC memory requirement information.
 647  */
 648 void
 649 bfa_iocfc_detach(struct bfa_s *bfa)
 650 {
 651         bfa_ioc_detach(&bfa->ioc);
 652 }
 653
 654 /**
 655  * Query IOC memory requirement information.
 656  */
 657 void
 658 bfa_iocfc_init(struct bfa_s *bfa)
 659 {
 660         bfa->iocfc.action = BFA_IOCFC_ACT_INIT;
 661         bfa_ioc_enable(&bfa->ioc);
 662 }
 663
 664 /**
 665  * IOC start called from bfa_start(). Called to start IOC operations
 666  * at driver instantiation for this instance.
 667  */
 668 void
 669 bfa_iocfc_start(struct bfa_s *bfa)
 670 {
 671         if (bfa->iocfc.cfgdone)
 672                 bfa_iocfc_start_submod(bfa);
 673 }
 674
 675 /**
 676  * IOC stop called from bfa_stop(). Called only when driver is unloaded
 677  * for this instance.
 678  */
 679 void
 680 bfa_iocfc_stop(struct bfa_s *bfa)
 681 {
 682         bfa->iocfc.action = BFA_IOCFC_ACT_STOP;
 683
 684         bfa->rme_process = BFA_FALSE;
 685         bfa_ioc_disable(&bfa->ioc);
 686 }
 687
 688 void
 689 bfa_iocfc_isr(void *bfaarg, struct bfi_mbmsg_s *m)
 690 {
 691         struct bfa_s            *bfa = bfaarg;
 692         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 693         union bfi_iocfc_i2h_msg_u       *msg;
 694
 695         msg = (union bfi_iocfc_i2h_msg_u *) m;
 696         bfa_trc(bfa, msg->mh.msg_id);
 697
 698         switch (msg->mh.msg_id) {
 699         case BFI_IOCFC_I2H_CFG_REPLY:
 700                 iocfc->cfg_reply = &msg->cfg_reply;
 701                 bfa_iocfc_cfgrsp(bfa);
 702                 break;
 703
 704         case BFI_IOCFC_I2H_GET_STATS_RSP:
 705                 if (iocfc->stats_busy == BFA_FALSE
 706                     || iocfc->stats_status == BFA_STATUS_ETIMER)
 707                         break;
 708
 709                 bfa_timer_stop(&iocfc->stats_timer);
 710                 iocfc->stats_status = BFA_STATUS_OK;
 711                 bfa_cb_queue(bfa, &iocfc->stats_hcb_qe, bfa_iocfc_stats_cb,
 712                               bfa);
 713                 break;
 714         case BFI_IOCFC_I2H_CLEAR_STATS_RSP:
 715                 /*
 716                  * check for timer pop before processing the rsp
 717                  */
 718                 if (iocfc->stats_busy == BFA_FALSE
 719                     || iocfc->stats_status == BFA_STATUS_ETIMER)
 720                         break;
 721
 722                 bfa_timer_stop(&iocfc->stats_timer);
 723                 iocfc->stats_status = BFA_STATUS_OK;
 724                 bfa_cb_queue(bfa, &iocfc->stats_hcb_qe,
 725                               bfa_iocfc_stats_clr_cb, bfa);
 726                 break;
 727         case BFI_IOCFC_I2H_UPDATEQ_RSP:
 728                 iocfc->updateq_cbfn(iocfc->updateq_cbarg, BFA_STATUS_OK);
 729                 break;
 730         default:
 731                 bfa_assert(0);
 732         }
 733 }
 734
 735 #ifndef BFA_BIOS_BUILD
 736 void
 737 bfa_adapter_get_attr(struct bfa_s *bfa, struct bfa_adapter_attr_s *ad_attr)
 738 {
 739         bfa_ioc_get_adapter_attr(&bfa->ioc, ad_attr);
 740 }
 741
 742 u64
 743 bfa_adapter_get_id(struct bfa_s *bfa)
 744 {
 745         return bfa_ioc_get_adid(&bfa->ioc);
 746 }
 747
 748 void
 749 bfa_iocfc_get_attr(struct bfa_s *bfa, struct bfa_iocfc_attr_s *attr)
 750 {
 751         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 752
 753         attr->intr_attr = iocfc->cfginfo->intr_attr;
 754         attr->config    = iocfc->cfg;
 755 }
 756
 757 bfa_status_t
 758 bfa_iocfc_israttr_set(struct bfa_s *bfa, struct bfa_iocfc_intr_attr_s *attr)
 759 {
 760         struct bfa_iocfc_s              *iocfc = &bfa->iocfc;
 761         struct bfi_iocfc_set_intr_req_s *m;
 762
 763         iocfc->cfginfo->intr_attr = *attr;
 764         if (!bfa_iocfc_is_operational(bfa))
 765                 return BFA_STATUS_OK;
 766
 767         m = bfa_reqq_next(bfa, BFA_REQQ_IOC);
 768         if (!m)
 769                 return BFA_STATUS_DEVBUSY;
 770
 771         bfi_h2i_set(m->mh, BFI_MC_IOCFC, BFI_IOCFC_H2I_SET_INTR_REQ,
 772                         bfa_lpuid(bfa));
 773         m->coalesce = attr->coalesce;
 774         m->delay    = bfa_os_htons(attr->delay);
 775         m->latency  = bfa_os_htons(attr->latency);
 776
 777         bfa_trc(bfa, attr->delay);
 778         bfa_trc(bfa, attr->latency);
 779
 780         bfa_reqq_produce(bfa, BFA_REQQ_IOC);
 781         return BFA_STATUS_OK;
 782 }
 783
 784 void
 785 bfa_iocfc_set_snsbase(struct bfa_s *bfa, u64 snsbase_pa)
 786 {
 787         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 788
 789         iocfc->cfginfo->sense_buf_len = (BFI_IOIM_SNSLEN - 1);
 790         bfa_dma_be_addr_set(iocfc->cfginfo->ioim_snsbase, snsbase_pa);
 791 }
 792
 793 bfa_status_t
 794 bfa_iocfc_get_stats(struct bfa_s *bfa, struct bfa_iocfc_stats_s *stats,
 795                       bfa_cb_ioc_t cbfn, void *cbarg)
 796 {
 797         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 798
 799         if (iocfc->stats_busy) {
 800                 bfa_trc(bfa, iocfc->stats_busy);
 801                 return BFA_STATUS_DEVBUSY;
 802         }
 803
 804         if (!bfa_iocfc_is_operational(bfa)) {
 805                 bfa_trc(bfa, 0);
 806                 return BFA_STATUS_IOC_NON_OP;
 807         }
 808
 809         iocfc->stats_busy = BFA_TRUE;
 810         iocfc->stats_ret = stats;
 811         iocfc->stats_cbfn = cbfn;
 812         iocfc->stats_cbarg = cbarg;
 813
 814         bfa_iocfc_stats_query(bfa);
 815
 816         return BFA_STATUS_OK;
 817 }
 818
 819 bfa_status_t
 820 bfa_iocfc_clear_stats(struct bfa_s *bfa, bfa_cb_ioc_t cbfn, void *cbarg)
 821 {
 822         struct bfa_iocfc_s      *iocfc = &bfa->iocfc;
 823
 824         if (iocfc->stats_busy) {
 825                 bfa_trc(bfa, iocfc->stats_busy);
 826                 return BFA_STATUS_DEVBUSY;
 827         }
 828
 829         if (!bfa_iocfc_is_operational(bfa)) {
 830                 bfa_trc(bfa, 0);
 831                 return BFA_STATUS_IOC_NON_OP;
 832         }
 833
 834         iocfc->stats_busy = BFA_TRUE;
 835         iocfc->stats_cbfn = cbfn;
 836         iocfc->stats_cbarg = cbarg;
 837
 838         bfa_iocfc_stats_clear(bfa);
 839         return BFA_STATUS_OK;
 840 }
 841
 842 /**
 843  * Enable IOC after it is disabled.
 844  */
 845 void
 846 bfa_iocfc_enable(struct bfa_s *bfa)
 847 {
 848         bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
 849                      "IOC Enable");
 850         bfa_ioc_enable(&bfa->ioc);
 851 }
 852
 853 void
 854 bfa_iocfc_disable(struct bfa_s *bfa)
 855 {
 856         bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
 857                      "IOC Disable");
 858         bfa->iocfc.action = BFA_IOCFC_ACT_DISABLE;
 859
 860         bfa->rme_process = BFA_FALSE;
 861         bfa_ioc_disable(&bfa->ioc);
 862 }
 863
 864
 865 bfa_boolean_t
 866 bfa_iocfc_is_operational(struct bfa_s *bfa)
 867 {
 868         return bfa_ioc_is_operational(&bfa->ioc) && bfa->iocfc.cfgdone;
 869 }
 870
 871 /**
 872  * Return boot target port wwns -- read from boot information in flash.
 873  */
 874 void
 875 bfa_iocfc_get_bootwwns(struct bfa_s *bfa, u8 *nwwns, wwn_t **wwns)
 876 {
 877         struct bfa_iocfc_s              *iocfc   = &bfa->iocfc;
 878         struct bfi_iocfc_cfgrsp_s       *cfgrsp  = iocfc->cfgrsp;
 879
 880         *nwwns = cfgrsp->bootwwns.nwwns;
 881         *wwns = cfgrsp->bootwwns.wwn;
 882 }
 883
 884 #endif
 885
 886