drivers/scsi/bfa/bfa_port.c

   1 /*
   2  * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
   3  * Copyright (c) 2014- QLogic Corporation.
   4  * All rights reserved
   5  * www.qlogic.com
   6  *
   7  * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License (GPL) Version 2 as
  11  * published by the Free Software Foundation
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  */
  18
  19 #include "bfad_drv.h"
  20 #include "bfa_defs_svc.h"
  21 #include "bfa_port.h"
  22 #include "bfi.h"
  23 #include "bfa_ioc.h"
  24
  25
  26 BFA_TRC_FILE(CNA, PORT);
  27
  28 static void
  29 bfa_port_stats_swap(struct bfa_port_s *port, union bfa_port_stats_u *stats)
  30 {
  31         u32    *dip = (u32 *) stats;
  32         __be32    t0, t1;
  33         int         i;
  34
  35         for (i = 0; i < sizeof(union bfa_port_stats_u)/sizeof(u32);
  36                 i += 2) {
  37                 t0 = dip[i];
  38                 t1 = dip[i + 1];
  39 #ifdef __BIG_ENDIAN
  40                 dip[i] = be32_to_cpu(t0);
  41                 dip[i + 1] = be32_to_cpu(t1);
  42 #else
  43                 dip[i] = be32_to_cpu(t1);
  44                 dip[i + 1] = be32_to_cpu(t0);
  45 #endif
  46         }
  47 }
  48
  49 /*
  50  * bfa_port_enable_isr()
  51  *
  52  *
  53  * @param[in] port - Pointer to the port module
  54  *            status - Return status from the f/w
  55  *
  56  * @return void
  57  */
  58 static void
  59 bfa_port_enable_isr(struct bfa_port_s *port, bfa_status_t status)
  60 {
  61         bfa_trc(port, status);
  62         port->endis_pending = BFA_FALSE;
  63         port->endis_cbfn(port->endis_cbarg, status);
  64 }
  65
  66 /*
  67  * bfa_port_disable_isr()
  68  *
  69  *
  70  * @param[in] port - Pointer to the port module
  71  *            status - Return status from the f/w
  72  *
  73  * @return void
  74  */
  75 static void
  76 bfa_port_disable_isr(struct bfa_port_s *port, bfa_status_t status)
  77 {
  78         bfa_trc(port, status);
  79         port->endis_pending = BFA_FALSE;
  80         port->endis_cbfn(port->endis_cbarg, status);
  81 }
  82
  83 /*
  84  * bfa_port_get_stats_isr()
  85  *
  86  *
  87  * @param[in] port - Pointer to the Port module
  88  *            status - Return status from the f/w
  89  *
  90  * @return void
  91  */
  92 static void
  93 bfa_port_get_stats_isr(struct bfa_port_s *port, bfa_status_t status)
  94 {
  95         port->stats_status = status;
  96         port->stats_busy = BFA_FALSE;
  97
  98         if (status == BFA_STATUS_OK) {
  99                 memcpy(port->stats, port->stats_dma.kva,
 100                        sizeof(union bfa_port_stats_u));
 101                 bfa_port_stats_swap(port, port->stats);
 102
 103                 port->stats->fc.secs_reset = ktime_get_seconds() - port->stats_reset_time;
 104         }
 105
 106         if (port->stats_cbfn) {
 107                 port->stats_cbfn(port->stats_cbarg, status);
 108                 port->stats_cbfn = NULL;
 109         }
 110 }
 111
 112 /*
 113  * bfa_port_clear_stats_isr()
 114  *
 115  *
 116  * @param[in] port - Pointer to the Port module
 117  *            status - Return status from the f/w
 118  *
 119  * @return void
 120  */
 121 static void
 122 bfa_port_clear_stats_isr(struct bfa_port_s *port, bfa_status_t status)
 123 {
 124         port->stats_status = status;
 125         port->stats_busy   = BFA_FALSE;
 126
 127         /*
 128         * re-initialize time stamp for stats reset
 129         */
 130         port->stats_reset_time = ktime_get_seconds();
 131
 132         if (port->stats_cbfn) {
 133                 port->stats_cbfn(port->stats_cbarg, status);
 134                 port->stats_cbfn = NULL;
 135         }
 136 }
 137
 138 /*
 139  * bfa_port_isr()
 140  *
 141  *
 142  * @param[in] Pointer to the Port module data structure.
 143  *
 144  * @return void
 145  */
 146 static void
 147 bfa_port_isr(void *cbarg, struct bfi_mbmsg_s *m)
 148 {
 149         struct bfa_port_s *port = (struct bfa_port_s *) cbarg;
 150         union bfi_port_i2h_msg_u *i2hmsg;
 151
 152         i2hmsg = (union bfi_port_i2h_msg_u *) m;
 153         bfa_trc(port, m->mh.msg_id);
 154
 155         switch (m->mh.msg_id) {
 156         case BFI_PORT_I2H_ENABLE_RSP:
 157                 if (port->endis_pending == BFA_FALSE)
 158                         break;
 159                 bfa_port_enable_isr(port, i2hmsg->enable_rsp.status);
 160                 break;
 161
 162         case BFI_PORT_I2H_DISABLE_RSP:
 163                 if (port->endis_pending == BFA_FALSE)
 164                         break;
 165                 bfa_port_disable_isr(port, i2hmsg->disable_rsp.status);
 166                 break;
 167
 168         case BFI_PORT_I2H_GET_STATS_RSP:
 169                 /* Stats busy flag is still set? (may be cmd timed out) */
 170                 if (port->stats_busy == BFA_FALSE)
 171                         break;
 172                 bfa_port_get_stats_isr(port, i2hmsg->getstats_rsp.status);
 173                 break;
 174
 175         case BFI_PORT_I2H_CLEAR_STATS_RSP:
 176                 if (port->stats_busy == BFA_FALSE)
 177                         break;
 178                 bfa_port_clear_stats_isr(port, i2hmsg->clearstats_rsp.status);
 179                 break;
 180
 181         default:
 182                 WARN_ON(1);
 183         }
 184 }
 185
 186 /*
 187  * bfa_port_meminfo()
 188  *
 189  *
 190  * @param[in] void
 191  *
 192  * @return Size of DMA region
 193  */
 194 u32
 195 bfa_port_meminfo(void)
 196 {
 197         return BFA_ROUNDUP(sizeof(union bfa_port_stats_u), BFA_DMA_ALIGN_SZ);
 198 }
 199
 200 /*
 201  * bfa_port_mem_claim()
 202  *
 203  *
 204  * @param[in] port Port module pointer
 205  *            dma_kva Kernel Virtual Address of Port DMA Memory
 206  *            dma_pa  Physical Address of Port DMA Memory
 207  *
 208  * @return void
 209  */
 210 void
 211 bfa_port_mem_claim(struct bfa_port_s *port, u8 *dma_kva, u64 dma_pa)
 212 {
 213         port->stats_dma.kva = dma_kva;
 214         port->stats_dma.pa  = dma_pa;
 215 }
 216
 217 /*
 218  * bfa_port_enable()
 219  *
 220  *   Send the Port enable request to the f/w
 221  *
 222  * @param[in] Pointer to the Port module data structure.
 223  *
 224  * @return Status
 225  */
 226 bfa_status_t
 227 bfa_port_enable(struct bfa_port_s *port, bfa_port_endis_cbfn_t cbfn,
 228                  void *cbarg)
 229 {
 230         struct bfi_port_generic_req_s *m;
 231
 232         /* If port is PBC disabled, return error */
 233         if (port->pbc_disabled) {
 234                 bfa_trc(port, BFA_STATUS_PBC);
 235                 return BFA_STATUS_PBC;
 236         }
 237
 238         if (bfa_ioc_is_disabled(port->ioc)) {
 239                 bfa_trc(port, BFA_STATUS_IOC_DISABLED);
 240                 return BFA_STATUS_IOC_DISABLED;
 241         }
 242
 243         if (!bfa_ioc_is_operational(port->ioc)) {
 244                 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
 245                 return BFA_STATUS_IOC_FAILURE;
 246         }
 247
 248         /* if port is d-port enabled, return error */
 249         if (port->dport_enabled) {
 250                 bfa_trc(port, BFA_STATUS_DPORT_ERR);
 251                 return BFA_STATUS_DPORT_ERR;
 252         }
 253
 254         if (port->endis_pending) {
 255                 bfa_trc(port, BFA_STATUS_DEVBUSY);
 256                 return BFA_STATUS_DEVBUSY;
 257         }
 258
 259         m = (struct bfi_port_generic_req_s *) port->endis_mb.msg;
 260
 261         port->msgtag++;
 262         port->endis_cbfn    = cbfn;
 263         port->endis_cbarg   = cbarg;
 264         port->endis_pending = BFA_TRUE;
 265
 266         bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_ENABLE_REQ,
 267                     bfa_ioc_portid(port->ioc));
 268         bfa_ioc_mbox_queue(port->ioc, &port->endis_mb);
 269
 270         return BFA_STATUS_OK;
 271 }
 272
 273 /*
 274  * bfa_port_disable()
 275  *
 276  *   Send the Port disable request to the f/w
 277  *
 278  * @param[in] Pointer to the Port module data structure.
 279  *
 280  * @return Status
 281  */
 282 bfa_status_t
 283 bfa_port_disable(struct bfa_port_s *port, bfa_port_endis_cbfn_t cbfn,
 284                   void *cbarg)
 285 {
 286         struct bfi_port_generic_req_s *m;
 287
 288         /* If port is PBC disabled, return error */
 289         if (port->pbc_disabled) {
 290                 bfa_trc(port, BFA_STATUS_PBC);
 291                 return BFA_STATUS_PBC;
 292         }
 293
 294         if (bfa_ioc_is_disabled(port->ioc)) {
 295                 bfa_trc(port, BFA_STATUS_IOC_DISABLED);
 296                 return BFA_STATUS_IOC_DISABLED;
 297         }
 298
 299         if (!bfa_ioc_is_operational(port->ioc)) {
 300                 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
 301                 return BFA_STATUS_IOC_FAILURE;
 302         }
 303
 304         /* if port is d-port enabled, return error */
 305         if (port->dport_enabled) {
 306                 bfa_trc(port, BFA_STATUS_DPORT_ERR);
 307                 return BFA_STATUS_DPORT_ERR;
 308         }
 309
 310         if (port->endis_pending) {
 311                 bfa_trc(port, BFA_STATUS_DEVBUSY);
 312                 return BFA_STATUS_DEVBUSY;
 313         }
 314
 315         m = (struct bfi_port_generic_req_s *) port->endis_mb.msg;
 316
 317         port->msgtag++;
 318         port->endis_cbfn    = cbfn;
 319         port->endis_cbarg   = cbarg;
 320         port->endis_pending = BFA_TRUE;
 321
 322         bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_DISABLE_REQ,
 323                     bfa_ioc_portid(port->ioc));
 324         bfa_ioc_mbox_queue(port->ioc, &port->endis_mb);
 325
 326         return BFA_STATUS_OK;
 327 }
 328
 329 /*
 330  * bfa_port_get_stats()
 331  *
 332  *   Send the request to the f/w to fetch Port statistics.
 333  *
 334  * @param[in] Pointer to the Port module data structure.
 335  *
 336  * @return Status
 337  */
 338 bfa_status_t
 339 bfa_port_get_stats(struct bfa_port_s *port, union bfa_port_stats_u *stats,
 340                     bfa_port_stats_cbfn_t cbfn, void *cbarg)
 341 {
 342         struct bfi_port_get_stats_req_s *m;
 343
 344         if (!bfa_ioc_is_operational(port->ioc)) {
 345                 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
 346                 return BFA_STATUS_IOC_FAILURE;
 347         }
 348
 349         if (port->stats_busy) {
 350                 bfa_trc(port, BFA_STATUS_DEVBUSY);
 351                 return BFA_STATUS_DEVBUSY;
 352         }
 353
 354         m = (struct bfi_port_get_stats_req_s *) port->stats_mb.msg;
 355
 356         port->stats       = stats;
 357         port->stats_cbfn  = cbfn;
 358         port->stats_cbarg = cbarg;
 359         port->stats_busy  = BFA_TRUE;
 360         bfa_dma_be_addr_set(m->dma_addr, port->stats_dma.pa);
 361
 362         bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_GET_STATS_REQ,
 363                     bfa_ioc_portid(port->ioc));
 364         bfa_ioc_mbox_queue(port->ioc, &port->stats_mb);
 365
 366         return BFA_STATUS_OK;
 367 }
 368
 369 /*
 370  * bfa_port_clear_stats()
 371  *
 372  *
 373  * @param[in] Pointer to the Port module data structure.
 374  *
 375  * @return Status
 376  */
 377 bfa_status_t
 378 bfa_port_clear_stats(struct bfa_port_s *port, bfa_port_stats_cbfn_t cbfn,
 379                       void *cbarg)
 380 {
 381         struct bfi_port_generic_req_s *m;
 382
 383         if (!bfa_ioc_is_operational(port->ioc)) {
 384                 bfa_trc(port, BFA_STATUS_IOC_FAILURE);
 385                 return BFA_STATUS_IOC_FAILURE;
 386         }
 387
 388         if (port->stats_busy) {
 389                 bfa_trc(port, BFA_STATUS_DEVBUSY);
 390                 return BFA_STATUS_DEVBUSY;
 391         }
 392
 393         m = (struct bfi_port_generic_req_s *) port->stats_mb.msg;
 394
 395         port->stats_cbfn  = cbfn;
 396         port->stats_cbarg = cbarg;
 397         port->stats_busy  = BFA_TRUE;
 398
 399         bfi_h2i_set(m->mh, BFI_MC_PORT, BFI_PORT_H2I_CLEAR_STATS_REQ,
 400                     bfa_ioc_portid(port->ioc));
 401         bfa_ioc_mbox_queue(port->ioc, &port->stats_mb);
 402
 403         return BFA_STATUS_OK;
 404 }
 405
 406 /*
 407  * bfa_port_notify()
 408  *
 409  * Port module IOC event handler
 410  *
 411  * @param[in] Pointer to the Port module data structure.
 412  * @param[in] IOC event structure
 413  *
 414  * @return void
 415  */
 416 void
 417 bfa_port_notify(void *arg, enum bfa_ioc_event_e event)
 418 {
 419         struct bfa_port_s *port = (struct bfa_port_s *) arg;
 420
 421         switch (event) {
 422         case BFA_IOC_E_DISABLED:
 423         case BFA_IOC_E_FAILED:
 424                 /* Fail any pending get_stats/clear_stats requests */
 425                 if (port->stats_busy) {
 426                         if (port->stats_cbfn)
 427                                 port->stats_cbfn(port->stats_cbarg,
 428                                                 BFA_STATUS_FAILED);
 429                         port->stats_cbfn = NULL;
 430                         port->stats_busy = BFA_FALSE;
 431                 }
 432
 433                 /* Clear any enable/disable is pending */
 434                 if (port->endis_pending) {
 435                         if (port->endis_cbfn)
 436                                 port->endis_cbfn(port->endis_cbarg,
 437                                                 BFA_STATUS_FAILED);
 438                         port->endis_cbfn = NULL;
 439                         port->endis_pending = BFA_FALSE;
 440                 }
 441
 442                 /* clear D-port mode */
 443                 if (port->dport_enabled)
 444                         bfa_port_set_dportenabled(port, BFA_FALSE);
 445                 break;
 446         default:
 447                 break;
 448         }
 449 }
 450
 451 /*
 452  * bfa_port_attach()
 453  *
 454  *
 455  * @param[in] port - Pointer to the Port module data structure
 456  *            ioc  - Pointer to the ioc module data structure
 457  *            dev  - Pointer to the device driver module data structure
 458  *                   The device driver specific mbox ISR functions have
 459  *                   this pointer as one of the parameters.
 460  *            trcmod -
 461  *
 462  * @return void
 463  */
 464 void
 465 bfa_port_attach(struct bfa_port_s *port, struct bfa_ioc_s *ioc,
 466                  void *dev, struct bfa_trc_mod_s *trcmod)
 467 {
 468         WARN_ON(!port);
 469
 470         port->dev    = dev;
 471         port->ioc    = ioc;
 472         port->trcmod = trcmod;
 473
 474         port->stats_busy = BFA_FALSE;
 475         port->endis_pending = BFA_FALSE;
 476         port->stats_cbfn = NULL;
 477         port->endis_cbfn = NULL;
 478         port->pbc_disabled = BFA_FALSE;
 479         port->dport_enabled = BFA_FALSE;
 480
 481         bfa_ioc_mbox_regisr(port->ioc, BFI_MC_PORT, bfa_port_isr, port);
 482         bfa_q_qe_init(&port->ioc_notify);
 483         bfa_ioc_notify_init(&port->ioc_notify, bfa_port_notify, port);
 484         list_add_tail(&port->ioc_notify.qe, &port->ioc->notify_q);
 485
 486         /*
 487          * initialize time stamp for stats reset
 488          */
 489         port->stats_reset_time = ktime_get_seconds();
 490
 491         bfa_trc(port, 0);
 492 }
 493
 494 /*
 495  * bfa_port_set_dportenabled();
 496  *
 497  * Port module- set pbc disabled flag
 498  *
 499  * @param[in] port - Pointer to the Port module data structure
 500  *
 501  * @return void
 502  */
 503 void
 504 bfa_port_set_dportenabled(struct bfa_port_s *port, bfa_boolean_t enabled)
 505 {
 506         port->dport_enabled = enabled;
 507 }
 508
 509 /*
 510  *      CEE module specific definitions
 511  */
 512
 513 /*
 514  * bfa_cee_get_attr_isr()
 515  *
 516  * @brief CEE ISR for get-attributes responses from f/w
 517  *
 518  * @param[in] cee - Pointer to the CEE module
 519  *                  status - Return status from the f/w
 520  *
 521  * @return void
 522  */
 523 static void
 524 bfa_cee_get_attr_isr(struct bfa_cee_s *cee, bfa_status_t status)
 525 {
 526         struct bfa_cee_lldp_cfg_s *lldp_cfg = &cee->attr->lldp_remote;
 527
 528         cee->get_attr_status = status;
 529         bfa_trc(cee, 0);
 530         if (status == BFA_STATUS_OK) {
 531                 bfa_trc(cee, 0);
 532                 memcpy(cee->attr, cee->attr_dma.kva,
 533                         sizeof(struct bfa_cee_attr_s));
 534                 lldp_cfg->time_to_live = be16_to_cpu(lldp_cfg->time_to_live);
 535                 lldp_cfg->enabled_system_cap =
 536                                 be16_to_cpu(lldp_cfg->enabled_system_cap);
 537         }
 538         cee->get_attr_pending = BFA_FALSE;
 539         if (cee->cbfn.get_attr_cbfn) {
 540                 bfa_trc(cee, 0);
 541                 cee->cbfn.get_attr_cbfn(cee->cbfn.get_attr_cbarg, status);
 542         }
 543 }
 544
 545 /*
 546  * bfa_cee_get_stats_isr()
 547  *
 548  * @brief CEE ISR for get-stats responses from f/w
 549  *
 550  * @param[in] cee - Pointer to the CEE module
 551  *            status - Return status from the f/w
 552  *
 553  * @return void
 554  */
 555 static void
 556 bfa_cee_get_stats_isr(struct bfa_cee_s *cee, bfa_status_t status)
 557 {
 558         u32 *buffer;
 559         int i;
 560
 561         cee->get_stats_status = status;
 562         bfa_trc(cee, 0);
 563         if (status == BFA_STATUS_OK) {
 564                 bfa_trc(cee, 0);
 565                 memcpy(cee->stats, cee->stats_dma.kva,
 566                         sizeof(struct bfa_cee_stats_s));
 567                 /* swap the cee stats */
 568                 buffer = (u32 *)cee->stats;
 569                 for (i = 0; i < (sizeof(struct bfa_cee_stats_s) /
 570                                  sizeof(u32)); i++)
 571                         buffer[i] = cpu_to_be32(buffer[i]);
 572         }
 573         cee->get_stats_pending = BFA_FALSE;
 574         bfa_trc(cee, 0);
 575         if (cee->cbfn.get_stats_cbfn) {
 576                 bfa_trc(cee, 0);
 577                 cee->cbfn.get_stats_cbfn(cee->cbfn.get_stats_cbarg, status);
 578         }
 579 }
 580
 581 /*
 582  * bfa_cee_reset_stats_isr()
 583  *
 584  * @brief CEE ISR for reset-stats responses from f/w
 585  *
 586  * @param[in] cee - Pointer to the CEE module
 587  *            status - Return status from the f/w
 588  *
 589  * @return void
 590  */
 591 static void
 592 bfa_cee_reset_stats_isr(struct bfa_cee_s *cee, bfa_status_t status)
 593 {
 594         cee->reset_stats_status = status;
 595         cee->reset_stats_pending = BFA_FALSE;
 596         if (cee->cbfn.reset_stats_cbfn)
 597                 cee->cbfn.reset_stats_cbfn(cee->cbfn.reset_stats_cbarg, status);
 598 }
 599
 600 /*
 601  * bfa_cee_meminfo()
 602  *
 603  * @brief Returns the size of the DMA memory needed by CEE module
 604  *
 605  * @param[in] void
 606  *
 607  * @return Size of DMA region
 608  */
 609 u32
 610 bfa_cee_meminfo(void)
 611 {
 612         return BFA_ROUNDUP(sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ) +
 613                 BFA_ROUNDUP(sizeof(struct bfa_cee_stats_s), BFA_DMA_ALIGN_SZ);
 614 }
 615
 616 /*
 617  * bfa_cee_mem_claim()
 618  *
 619  * @brief Initialized CEE DMA Memory
 620  *
 621  * @param[in] cee CEE module pointer
 622  *            dma_kva Kernel Virtual Address of CEE DMA Memory
 623  *            dma_pa  Physical Address of CEE DMA Memory
 624  *
 625  * @return void
 626  */
 627 void
 628 bfa_cee_mem_claim(struct bfa_cee_s *cee, u8 *dma_kva, u64 dma_pa)
 629 {
 630         cee->attr_dma.kva = dma_kva;
 631         cee->attr_dma.pa = dma_pa;
 632         cee->stats_dma.kva = dma_kva + BFA_ROUNDUP(
 633                              sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ);
 634         cee->stats_dma.pa = dma_pa + BFA_ROUNDUP(
 635                              sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ);
 636         cee->attr = (struct bfa_cee_attr_s *) dma_kva;
 637         cee->stats = (struct bfa_cee_stats_s *) (dma_kva + BFA_ROUNDUP(
 638                         sizeof(struct bfa_cee_attr_s), BFA_DMA_ALIGN_SZ));
 639 }
 640
 641 /*
 642  * bfa_cee_get_attr()
 643  *
 644  * @brief
 645  *   Send the request to the f/w to fetch CEE attributes.
 646  *
 647  * @param[in] Pointer to the CEE module data structure.
 648  *
 649  * @return Status
 650  */
 651
 652 bfa_status_t
 653 bfa_cee_get_attr(struct bfa_cee_s *cee, struct bfa_cee_attr_s *attr,
 654                  bfa_cee_get_attr_cbfn_t cbfn, void *cbarg)
 655 {
 656         struct bfi_cee_get_req_s *cmd;
 657
 658         WARN_ON((cee == NULL) || (cee->ioc == NULL));
 659         bfa_trc(cee, 0);
 660         if (!bfa_ioc_is_operational(cee->ioc)) {
 661                 bfa_trc(cee, 0);
 662                 return BFA_STATUS_IOC_FAILURE;
 663         }
 664         if (cee->get_attr_pending == BFA_TRUE) {
 665                 bfa_trc(cee, 0);
 666                 return  BFA_STATUS_DEVBUSY;
 667         }
 668         cee->get_attr_pending = BFA_TRUE;
 669         cmd = (struct bfi_cee_get_req_s *) cee->get_cfg_mb.msg;
 670         cee->attr = attr;
 671         cee->cbfn.get_attr_cbfn = cbfn;
 672         cee->cbfn.get_attr_cbarg = cbarg;
 673         bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_GET_CFG_REQ,
 674                 bfa_ioc_portid(cee->ioc));
 675         bfa_dma_be_addr_set(cmd->dma_addr, cee->attr_dma.pa);
 676         bfa_ioc_mbox_queue(cee->ioc, &cee->get_cfg_mb);
 677
 678         return BFA_STATUS_OK;
 679 }
 680
 681 /*
 682  * bfa_cee_get_stats()
 683  *
 684  * @brief
 685  *   Send the request to the f/w to fetch CEE statistics.
 686  *
 687  * @param[in] Pointer to the CEE module data structure.
 688  *
 689  * @return Status
 690  */
 691
 692 bfa_status_t
 693 bfa_cee_get_stats(struct bfa_cee_s *cee, struct bfa_cee_stats_s *stats,
 694                   bfa_cee_get_stats_cbfn_t cbfn, void *cbarg)
 695 {
 696         struct bfi_cee_get_req_s *cmd;
 697
 698         WARN_ON((cee == NULL) || (cee->ioc == NULL));
 699
 700         if (!bfa_ioc_is_operational(cee->ioc)) {
 701                 bfa_trc(cee, 0);
 702                 return BFA_STATUS_IOC_FAILURE;
 703         }
 704         if (cee->get_stats_pending == BFA_TRUE) {
 705                 bfa_trc(cee, 0);
 706                 return  BFA_STATUS_DEVBUSY;
 707         }
 708         cee->get_stats_pending = BFA_TRUE;
 709         cmd = (struct bfi_cee_get_req_s *) cee->get_stats_mb.msg;
 710         cee->stats = stats;
 711         cee->cbfn.get_stats_cbfn = cbfn;
 712         cee->cbfn.get_stats_cbarg = cbarg;
 713         bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_GET_STATS_REQ,
 714                 bfa_ioc_portid(cee->ioc));
 715         bfa_dma_be_addr_set(cmd->dma_addr, cee->stats_dma.pa);
 716         bfa_ioc_mbox_queue(cee->ioc, &cee->get_stats_mb);
 717
 718         return BFA_STATUS_OK;
 719 }
 720
 721 /*
 722  * bfa_cee_reset_stats()
 723  *
 724  * @brief Clears CEE Stats in the f/w.
 725  *
 726  * @param[in] Pointer to the CEE module data structure.
 727  *
 728  * @return Status
 729  */
 730
 731 bfa_status_t
 732 bfa_cee_reset_stats(struct bfa_cee_s *cee,
 733                     bfa_cee_reset_stats_cbfn_t cbfn, void *cbarg)
 734 {
 735         struct bfi_cee_reset_stats_s *cmd;
 736
 737         WARN_ON((cee == NULL) || (cee->ioc == NULL));
 738         if (!bfa_ioc_is_operational(cee->ioc)) {
 739                 bfa_trc(cee, 0);
 740                 return BFA_STATUS_IOC_FAILURE;
 741         }
 742         if (cee->reset_stats_pending == BFA_TRUE) {
 743                 bfa_trc(cee, 0);
 744                 return  BFA_STATUS_DEVBUSY;
 745         }
 746         cee->reset_stats_pending = BFA_TRUE;
 747         cmd = (struct bfi_cee_reset_stats_s *) cee->reset_stats_mb.msg;
 748         cee->cbfn.reset_stats_cbfn = cbfn;
 749         cee->cbfn.reset_stats_cbarg = cbarg;
 750         bfi_h2i_set(cmd->mh, BFI_MC_CEE, BFI_CEE_H2I_RESET_STATS,
 751                 bfa_ioc_portid(cee->ioc));
 752         bfa_ioc_mbox_queue(cee->ioc, &cee->reset_stats_mb);
 753
 754         return BFA_STATUS_OK;
 755 }
 756
 757 /*
 758  * bfa_cee_isrs()
 759  *
 760  * @brief Handles Mail-box interrupts for CEE module.
 761  *
 762  * @param[in] Pointer to the CEE module data structure.
 763  *
 764  * @return void
 765  */
 766
 767 void
 768 bfa_cee_isr(void *cbarg, struct bfi_mbmsg_s *m)
 769 {
 770         union bfi_cee_i2h_msg_u *msg;
 771         struct bfi_cee_get_rsp_s *get_rsp;
 772         struct bfa_cee_s *cee = (struct bfa_cee_s *) cbarg;
 773         msg = (union bfi_cee_i2h_msg_u *) m;
 774         get_rsp = (struct bfi_cee_get_rsp_s *) m;
 775         bfa_trc(cee, msg->mh.msg_id);
 776         switch (msg->mh.msg_id) {
 777         case BFI_CEE_I2H_GET_CFG_RSP:
 778                 bfa_trc(cee, get_rsp->cmd_status);
 779                 bfa_cee_get_attr_isr(cee, get_rsp->cmd_status);
 780                 break;
 781         case BFI_CEE_I2H_GET_STATS_RSP:
 782                 bfa_cee_get_stats_isr(cee, get_rsp->cmd_status);
 783                 break;
 784         case BFI_CEE_I2H_RESET_STATS_RSP:
 785                 bfa_cee_reset_stats_isr(cee, get_rsp->cmd_status);
 786                 break;
 787         default:
 788                 WARN_ON(1);
 789         }
 790 }
 791
 792 /*
 793  * bfa_cee_notify()
 794  *
 795  * @brief CEE module IOC event handler.
 796  *
 797  * @param[in] Pointer to the CEE module data structure.
 798  * @param[in] IOC event type
 799  *
 800  * @return void
 801  */
 802
 803 void
 804 bfa_cee_notify(void *arg, enum bfa_ioc_event_e event)
 805 {
 806         struct bfa_cee_s *cee = (struct bfa_cee_s *) arg;
 807
 808         bfa_trc(cee, event);
 809
 810         switch (event) {
 811         case BFA_IOC_E_DISABLED:
 812         case BFA_IOC_E_FAILED:
 813                 if (cee->get_attr_pending == BFA_TRUE) {
 814                         cee->get_attr_status = BFA_STATUS_FAILED;
 815                         cee->get_attr_pending  = BFA_FALSE;
 816                         if (cee->cbfn.get_attr_cbfn) {
 817                                 cee->cbfn.get_attr_cbfn(
 818                                         cee->cbfn.get_attr_cbarg,
 819                                         BFA_STATUS_FAILED);
 820                         }
 821                 }
 822                 if (cee->get_stats_pending == BFA_TRUE) {
 823                         cee->get_stats_status = BFA_STATUS_FAILED;
 824                         cee->get_stats_pending  = BFA_FALSE;
 825                         if (cee->cbfn.get_stats_cbfn) {
 826                                 cee->cbfn.get_stats_cbfn(
 827                                 cee->cbfn.get_stats_cbarg,
 828                                 BFA_STATUS_FAILED);
 829                         }
 830                 }
 831                 if (cee->reset_stats_pending == BFA_TRUE) {
 832                         cee->reset_stats_status = BFA_STATUS_FAILED;
 833                         cee->reset_stats_pending  = BFA_FALSE;
 834                         if (cee->cbfn.reset_stats_cbfn) {
 835                                 cee->cbfn.reset_stats_cbfn(
 836                                 cee->cbfn.reset_stats_cbarg,
 837                                 BFA_STATUS_FAILED);
 838                         }
 839                 }
 840                 break;
 841
 842         default:
 843                 break;
 844         }
 845 }
 846
 847 /*
 848  * bfa_cee_attach()
 849  *
 850  * @brief CEE module-attach API
 851  *
 852  * @param[in] cee - Pointer to the CEE module data structure
 853  *            ioc - Pointer to the ioc module data structure
 854  *            dev - Pointer to the device driver module data structure
 855  *                  The device driver specific mbox ISR functions have
 856  *                  this pointer as one of the parameters.
 857  *
 858  * @return void
 859  */
 860 void
 861 bfa_cee_attach(struct bfa_cee_s *cee, struct bfa_ioc_s *ioc,
 862                 void *dev)
 863 {
 864         WARN_ON(cee == NULL);
 865         cee->dev = dev;
 866         cee->ioc = ioc;
 867
 868         bfa_ioc_mbox_regisr(cee->ioc, BFI_MC_CEE, bfa_cee_isr, cee);
 869         bfa_q_qe_init(&cee->ioc_notify);
 870         bfa_ioc_notify_init(&cee->ioc_notify, bfa_cee_notify, cee);
 871         list_add_tail(&cee->ioc_notify.qe, &cee->ioc->notify_q);
 872 }