drivers/net/wireless/marvell/mwifiex/pcie.c

   1 /*
   2  * Marvell Wireless LAN device driver: PCIE specific handling
   3  *
   4  * Copyright (C) 2011-2014, Marvell International Ltd.
   5  *
   6  * This software file (the "File") is distributed by Marvell International
   7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
   8  * (the "License").  You may use, redistribute and/or modify this File in
   9  * accordance with the terms and conditions of the License, a copy of which
  10  * is available by writing to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
  12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  13  *
  14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
  17  * this warranty disclaimer.
  18  */
  19
  20 #include <linux/firmware.h>
  21
  22 #include "decl.h"
  23 #include "ioctl.h"
  24 #include "util.h"
  25 #include "fw.h"
  26 #include "main.h"
  27 #include "wmm.h"
  28 #include "11n.h"
  29 #include "pcie.h"
  30
  31 #define PCIE_VERSION    "1.0"
  32 #define DRV_NAME        "Marvell mwifiex PCIe"
  33
  34 static struct mwifiex_if_ops pcie_ops;
  35
  36 static const struct of_device_id mwifiex_pcie_of_match_table[] = {
  37         { .compatible = "pci11ab,2b42" },
  38         { .compatible = "pci1b4b,2b42" },
  39         { }
  40 };
  41
  42 static int mwifiex_pcie_probe_of(struct device *dev)
  43 {
  44         if (!of_match_node(mwifiex_pcie_of_match_table, dev->of_node)) {
  45                 dev_err(dev, "required compatible string missing\n");
  46                 return -EINVAL;
  47         }
  48
  49         return 0;
  50 }
  51
  52 static void mwifiex_pcie_work(struct work_struct *work);
  53
  54 static int
  55 mwifiex_map_pci_memory(struct mwifiex_adapter *adapter, struct sk_buff *skb,
  56                        size_t size, int flags)
  57 {
  58         struct pcie_service_card *card = adapter->card;
  59         struct mwifiex_dma_mapping mapping;
  60
  61         mapping.addr = pci_map_single(card->dev, skb->data, size, flags);
  62         if (pci_dma_mapping_error(card->dev, mapping.addr)) {
  63                 mwifiex_dbg(adapter, ERROR, "failed to map pci memory!\n");
  64                 return -1;
  65         }
  66         mapping.len = size;
  67         mwifiex_store_mapping(skb, &mapping);
  68         return 0;
  69 }
  70
  71 static void mwifiex_unmap_pci_memory(struct mwifiex_adapter *adapter,
  72                                      struct sk_buff *skb, int flags)
  73 {
  74         struct pcie_service_card *card = adapter->card;
  75         struct mwifiex_dma_mapping mapping;
  76
  77         mwifiex_get_mapping(skb, &mapping);
  78         pci_unmap_single(card->dev, mapping.addr, mapping.len, flags);
  79 }
  80
  81 /*
  82  * This function writes data into PCIE card register.
  83  */
  84 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
  85 {
  86         struct pcie_service_card *card = adapter->card;
  87
  88         iowrite32(data, card->pci_mmap1 + reg);
  89
  90         return 0;
  91 }
  92
  93 /* This function reads data from PCIE card register.
  94  */
  95 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
  96 {
  97         struct pcie_service_card *card = adapter->card;
  98
  99         *data = ioread32(card->pci_mmap1 + reg);
 100         if (*data == 0xffffffff)
 101                 return 0xffffffff;
 102
 103         return 0;
 104 }
 105
 106 /* This function reads u8 data from PCIE card register. */
 107 static int mwifiex_read_reg_byte(struct mwifiex_adapter *adapter,
 108                                  int reg, u8 *data)
 109 {
 110         struct pcie_service_card *card = adapter->card;
 111
 112         *data = ioread8(card->pci_mmap1 + reg);
 113
 114         return 0;
 115 }
 116
 117 /*
 118  * This function reads sleep cookie and checks if FW is ready
 119  */
 120 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
 121 {
 122         u32 cookie_value;
 123         struct pcie_service_card *card = adapter->card;
 124         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 125
 126         if (!reg->sleep_cookie)
 127                 return true;
 128
 129         if (card->sleep_cookie_vbase) {
 130                 cookie_value = get_unaligned_le32(card->sleep_cookie_vbase);
 131                 mwifiex_dbg(adapter, INFO,
 132                             "info: ACCESS_HW: sleep cookie=0x%x\n",
 133                             cookie_value);
 134                 if (cookie_value == FW_AWAKE_COOKIE)
 135                         return true;
 136         }
 137
 138         return false;
 139 }
 140
 141 #ifdef CONFIG_PM_SLEEP
 142 /*
 143  * Kernel needs to suspend all functions separately. Therefore all
 144  * registered functions must have drivers with suspend and resume
 145  * methods. Failing that the kernel simply removes the whole card.
 146  *
 147  * If already not suspended, this function allocates and sends a host
 148  * sleep activate request to the firmware and turns off the traffic.
 149  */
 150 static int mwifiex_pcie_suspend(struct device *dev)
 151 {
 152         struct mwifiex_adapter *adapter;
 153         struct pcie_service_card *card;
 154         struct pci_dev *pdev = to_pci_dev(dev);
 155
 156         card = pci_get_drvdata(pdev);
 157
 158         /* Might still be loading firmware */
 159         wait_for_completion(&card->fw_done);
 160
 161         adapter = card->adapter;
 162         if (!adapter) {
 163                 dev_err(dev, "adapter is not valid\n");
 164                 return 0;
 165         }
 166
 167         mwifiex_enable_wake(adapter);
 168
 169         /* Enable the Host Sleep */
 170         if (!mwifiex_enable_hs(adapter)) {
 171                 mwifiex_dbg(adapter, ERROR,
 172                             "cmd: failed to suspend\n");
 173                 adapter->hs_enabling = false;
 174                 mwifiex_disable_wake(adapter);
 175                 return -EFAULT;
 176         }
 177
 178         flush_workqueue(adapter->workqueue);
 179
 180         /* Indicate device suspended */
 181         adapter->is_suspended = true;
 182         adapter->hs_enabling = false;
 183
 184         return 0;
 185 }
 186
 187 /*
 188  * Kernel needs to suspend all functions separately. Therefore all
 189  * registered functions must have drivers with suspend and resume
 190  * methods. Failing that the kernel simply removes the whole card.
 191  *
 192  * If already not resumed, this function turns on the traffic and
 193  * sends a host sleep cancel request to the firmware.
 194  */
 195 static int mwifiex_pcie_resume(struct device *dev)
 196 {
 197         struct mwifiex_adapter *adapter;
 198         struct pcie_service_card *card;
 199         struct pci_dev *pdev = to_pci_dev(dev);
 200
 201         card = pci_get_drvdata(pdev);
 202
 203         if (!card->adapter) {
 204                 dev_err(dev, "adapter structure is not valid\n");
 205                 return 0;
 206         }
 207
 208         adapter = card->adapter;
 209
 210         if (!adapter->is_suspended) {
 211                 mwifiex_dbg(adapter, WARN,
 212                             "Device already resumed\n");
 213                 return 0;
 214         }
 215
 216         adapter->is_suspended = false;
 217
 218         mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
 219                           MWIFIEX_ASYNC_CMD);
 220         mwifiex_disable_wake(adapter);
 221
 222         return 0;
 223 }
 224 #endif
 225
 226 /*
 227  * This function probes an mwifiex device and registers it. It allocates
 228  * the card structure, enables PCIE function number and initiates the
 229  * device registration and initialization procedure by adding a logical
 230  * interface.
 231  */
 232 static int mwifiex_pcie_probe(struct pci_dev *pdev,
 233                                         const struct pci_device_id *ent)
 234 {
 235         struct pcie_service_card *card;
 236         int ret;
 237
 238         pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
 239                  pdev->vendor, pdev->device, pdev->revision);
 240
 241         card = devm_kzalloc(&pdev->dev, sizeof(*card), GFP_KERNEL);
 242         if (!card)
 243                 return -ENOMEM;
 244
 245         init_completion(&card->fw_done);
 246
 247         card->dev = pdev;
 248
 249         if (ent->driver_data) {
 250                 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
 251                 card->pcie.reg = data->reg;
 252                 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
 253                 card->pcie.tx_buf_size = data->tx_buf_size;
 254                 card->pcie.can_dump_fw = data->can_dump_fw;
 255                 card->pcie.mem_type_mapping_tbl = data->mem_type_mapping_tbl;
 256                 card->pcie.num_mem_types = data->num_mem_types;
 257                 card->pcie.can_ext_scan = data->can_ext_scan;
 258                 INIT_WORK(&card->work, mwifiex_pcie_work);
 259         }
 260
 261         /* device tree node parsing and platform specific configuration*/
 262         if (pdev->dev.of_node) {
 263                 ret = mwifiex_pcie_probe_of(&pdev->dev);
 264                 if (ret)
 265                         return ret;
 266         }
 267
 268         if (mwifiex_add_card(card, &card->fw_done, &pcie_ops,
 269                              MWIFIEX_PCIE, &pdev->dev)) {
 270                 pr_err("%s failed\n", __func__);
 271                 return -1;
 272         }
 273
 274         return 0;
 275 }
 276
 277 /*
 278  * This function removes the interface and frees up the card structure.
 279  */
 280 static void mwifiex_pcie_remove(struct pci_dev *pdev)
 281 {
 282         struct pcie_service_card *card;
 283         struct mwifiex_adapter *adapter;
 284         struct mwifiex_private *priv;
 285         const struct mwifiex_pcie_card_reg *reg;
 286         u32 fw_status;
 287         int ret;
 288
 289         card = pci_get_drvdata(pdev);
 290
 291         wait_for_completion(&card->fw_done);
 292
 293         adapter = card->adapter;
 294         if (!adapter || !adapter->priv_num)
 295                 return;
 296
 297         reg = card->pcie.reg;
 298         if (reg)
 299                 ret = mwifiex_read_reg(adapter, reg->fw_status, &fw_status);
 300         else
 301                 fw_status = -1;
 302
 303         if (fw_status == FIRMWARE_READY_PCIE && !adapter->mfg_mode) {
 304                 mwifiex_deauthenticate_all(adapter);
 305
 306                 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
 307
 308                 mwifiex_disable_auto_ds(priv);
 309
 310                 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
 311         }
 312
 313         mwifiex_remove_card(adapter);
 314 }
 315
 316 static void mwifiex_pcie_shutdown(struct pci_dev *pdev)
 317 {
 318         mwifiex_pcie_remove(pdev);
 319
 320         return;
 321 }
 322
 323 static const struct pci_device_id mwifiex_ids[] = {
 324         {
 325                 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
 326                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 327                 .driver_data = (unsigned long)&mwifiex_pcie8766,
 328         },
 329         {
 330                 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
 331                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 332                 .driver_data = (unsigned long)&mwifiex_pcie8897,
 333         },
 334         {
 335                 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8997,
 336                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 337                 .driver_data = (unsigned long)&mwifiex_pcie8997,
 338         },
 339         {
 340                 PCIE_VENDOR_ID_V2_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8997,
 341                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 342                 .driver_data = (unsigned long)&mwifiex_pcie8997,
 343         },
 344         {},
 345 };
 346
 347 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
 348
 349 /*
 350  * Cleanup all software without cleaning anything related to PCIe and HW.
 351  */
 352 static void mwifiex_pcie_reset_prepare(struct pci_dev *pdev)
 353 {
 354         struct pcie_service_card *card = pci_get_drvdata(pdev);
 355         struct mwifiex_adapter *adapter = card->adapter;
 356
 357         if (!adapter) {
 358                 dev_err(&pdev->dev, "%s: adapter structure is not valid\n",
 359                         __func__);
 360                 return;
 361         }
 362
 363         mwifiex_dbg(adapter, INFO,
 364                     "%s: vendor=0x%4.04x device=0x%4.04x rev=%d Pre-FLR\n",
 365                     __func__, pdev->vendor, pdev->device, pdev->revision);
 366
 367         mwifiex_shutdown_sw(adapter);
 368         clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
 369         clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags);
 370         mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
 371
 372         card->pci_reset_ongoing = true;
 373 }
 374
 375 /*
 376  * Kernel stores and restores PCIe function context before and after performing
 377  * FLR respectively. Reconfigure the software and firmware including firmware
 378  * redownload.
 379  */
 380 static void mwifiex_pcie_reset_done(struct pci_dev *pdev)
 381 {
 382         struct pcie_service_card *card = pci_get_drvdata(pdev);
 383         struct mwifiex_adapter *adapter = card->adapter;
 384         int ret;
 385
 386         if (!adapter) {
 387                 dev_err(&pdev->dev, "%s: adapter structure is not valid\n",
 388                         __func__);
 389                 return;
 390         }
 391
 392         mwifiex_dbg(adapter, INFO,
 393                     "%s: vendor=0x%4.04x device=0x%4.04x rev=%d Post-FLR\n",
 394                     __func__, pdev->vendor, pdev->device, pdev->revision);
 395
 396         ret = mwifiex_reinit_sw(adapter);
 397         if (ret)
 398                 dev_err(&pdev->dev, "reinit failed: %d\n", ret);
 399         else
 400                 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
 401
 402         card->pci_reset_ongoing = false;
 403 }
 404
 405 static const struct pci_error_handlers mwifiex_pcie_err_handler = {
 406         .reset_prepare          = mwifiex_pcie_reset_prepare,
 407         .reset_done             = mwifiex_pcie_reset_done,
 408 };
 409
 410 #ifdef CONFIG_PM_SLEEP
 411 /* Power Management Hooks */
 412 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
 413                                 mwifiex_pcie_resume);
 414 #endif
 415
 416 /* PCI Device Driver */
 417 static struct pci_driver __refdata mwifiex_pcie = {
 418         .name     = "mwifiex_pcie",
 419         .id_table = mwifiex_ids,
 420         .probe    = mwifiex_pcie_probe,
 421         .remove   = mwifiex_pcie_remove,
 422 #ifdef CONFIG_PM_SLEEP
 423         .driver   = {
 424                 .pm = &mwifiex_pcie_pm_ops,
 425         },
 426 #endif
 427         .shutdown = mwifiex_pcie_shutdown,
 428         .err_handler = &mwifiex_pcie_err_handler,
 429 };
 430
 431 /*
 432  * This function adds delay loop to ensure FW is awake before proceeding.
 433  */
 434 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
 435 {
 436         int i = 0;
 437
 438         while (mwifiex_pcie_ok_to_access_hw(adapter)) {
 439                 i++;
 440                 usleep_range(10, 20);
 441                 /* 50ms max wait */
 442                 if (i == 5000)
 443                         break;
 444         }
 445
 446         return;
 447 }
 448
 449 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter *adapter,
 450                                            u32 max_delay_loop_cnt)
 451 {
 452         struct pcie_service_card *card = adapter->card;
 453         u8 *buffer;
 454         u32 sleep_cookie, count;
 455         struct sk_buff *cmdrsp = card->cmdrsp_buf;
 456
 457         for (count = 0; count < max_delay_loop_cnt; count++) {
 458                 pci_dma_sync_single_for_cpu(card->dev,
 459                                             MWIFIEX_SKB_DMA_ADDR(cmdrsp),
 460                                             sizeof(sleep_cookie),
 461                                             PCI_DMA_FROMDEVICE);
 462                 buffer = cmdrsp->data;
 463                 sleep_cookie = get_unaligned_le32(buffer);
 464
 465                 if (sleep_cookie == MWIFIEX_DEF_SLEEP_COOKIE) {
 466                         mwifiex_dbg(adapter, INFO,
 467                                     "sleep cookie found at count %d\n", count);
 468                         break;
 469                 }
 470                 pci_dma_sync_single_for_device(card->dev,
 471                                                MWIFIEX_SKB_DMA_ADDR(cmdrsp),
 472                                                sizeof(sleep_cookie),
 473                                                PCI_DMA_FROMDEVICE);
 474                 usleep_range(20, 30);
 475         }
 476
 477         if (count >= max_delay_loop_cnt)
 478                 mwifiex_dbg(adapter, INFO,
 479                             "max count reached while accessing sleep cookie\n");
 480 }
 481
 482 /* This function wakes up the card by reading fw_status register. */
 483 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
 484 {
 485         struct pcie_service_card *card = adapter->card;
 486         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 487
 488         mwifiex_dbg(adapter, EVENT,
 489                     "event: Wakeup device...\n");
 490
 491         if (reg->sleep_cookie)
 492                 mwifiex_pcie_dev_wakeup_delay(adapter);
 493
 494         /* Accessing fw_status register will wakeup device */
 495         if (mwifiex_write_reg(adapter, reg->fw_status, FIRMWARE_READY_PCIE)) {
 496                 mwifiex_dbg(adapter, ERROR,
 497                             "Writing fw_status register failed\n");
 498                 return -1;
 499         }
 500
 501         if (reg->sleep_cookie) {
 502                 mwifiex_pcie_dev_wakeup_delay(adapter);
 503                 mwifiex_dbg(adapter, INFO,
 504                             "PCIE wakeup: Setting PS_STATE_AWAKE\n");
 505                 adapter->ps_state = PS_STATE_AWAKE;
 506         }
 507
 508         return 0;
 509 }
 510
 511 /*
 512  * This function is called after the card has woken up.
 513  *
 514  * The card configuration register is reset.
 515  */
 516 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
 517 {
 518         mwifiex_dbg(adapter, CMD,
 519                     "cmd: Wakeup device completed\n");
 520
 521         return 0;
 522 }
 523
 524 /*
 525  * This function disables the host interrupt.
 526  *
 527  * The host interrupt mask is read, the disable bit is reset and
 528  * written back to the card host interrupt mask register.
 529  */
 530 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
 531 {
 532         if (mwifiex_pcie_ok_to_access_hw(adapter)) {
 533                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
 534                                       0x00000000)) {
 535                         mwifiex_dbg(adapter, ERROR,
 536                                     "Disable host interrupt failed\n");
 537                         return -1;
 538                 }
 539         }
 540
 541         atomic_set(&adapter->tx_hw_pending, 0);
 542         return 0;
 543 }
 544
 545 static void mwifiex_pcie_disable_host_int_noerr(struct mwifiex_adapter *adapter)
 546 {
 547         WARN_ON(mwifiex_pcie_disable_host_int(adapter));
 548 }
 549
 550 /*
 551  * This function enables the host interrupt.
 552  *
 553  * The host interrupt enable mask is written to the card
 554  * host interrupt mask register.
 555  */
 556 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
 557 {
 558         if (mwifiex_pcie_ok_to_access_hw(adapter)) {
 559                 /* Simply write the mask to the register */
 560                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
 561                                       HOST_INTR_MASK)) {
 562                         mwifiex_dbg(adapter, ERROR,
 563                                     "Enable host interrupt failed\n");
 564                         return -1;
 565                 }
 566         }
 567
 568         return 0;
 569 }
 570
 571 /*
 572  * This function initializes TX buffer ring descriptors
 573  */
 574 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
 575 {
 576         struct pcie_service_card *card = adapter->card;
 577         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 578         struct mwifiex_pcie_buf_desc *desc;
 579         struct mwifiex_pfu_buf_desc *desc2;
 580         int i;
 581
 582         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 583                 card->tx_buf_list[i] = NULL;
 584                 if (reg->pfu_enabled) {
 585                         card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
 586                                              (sizeof(*desc2) * i);
 587                         desc2 = card->txbd_ring[i];
 588                         memset(desc2, 0, sizeof(*desc2));
 589                 } else {
 590                         card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
 591                                              (sizeof(*desc) * i);
 592                         desc = card->txbd_ring[i];
 593                         memset(desc, 0, sizeof(*desc));
 594                 }
 595         }
 596
 597         return 0;
 598 }
 599
 600 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
 601  * here and after mapping PCI memory, its physical address is assigned to
 602  * PCIE Rx buffer descriptor's physical address.
 603  */
 604 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
 605 {
 606         struct pcie_service_card *card = adapter->card;
 607         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 608         struct sk_buff *skb;
 609         struct mwifiex_pcie_buf_desc *desc;
 610         struct mwifiex_pfu_buf_desc *desc2;
 611         dma_addr_t buf_pa;
 612         int i;
 613
 614         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 615                 /* Allocate skb here so that firmware can DMA data from it */
 616                 skb = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
 617                                                   GFP_KERNEL);
 618                 if (!skb) {
 619                         mwifiex_dbg(adapter, ERROR,
 620                                     "Unable to allocate skb for RX ring.\n");
 621                         kfree(card->rxbd_ring_vbase);
 622                         return -ENOMEM;
 623                 }
 624
 625                 if (mwifiex_map_pci_memory(adapter, skb,
 626                                            MWIFIEX_RX_DATA_BUF_SIZE,
 627                                            PCI_DMA_FROMDEVICE))
 628                         return -1;
 629
 630                 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
 631
 632                 mwifiex_dbg(adapter, INFO,
 633                             "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
 634                             skb, skb->len, skb->data, (u32)buf_pa,
 635                             (u32)((u64)buf_pa >> 32));
 636
 637                 card->rx_buf_list[i] = skb;
 638                 if (reg->pfu_enabled) {
 639                         card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
 640                                              (sizeof(*desc2) * i);
 641                         desc2 = card->rxbd_ring[i];
 642                         desc2->paddr = buf_pa;
 643                         desc2->len = (u16)skb->len;
 644                         desc2->frag_len = (u16)skb->len;
 645                         desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
 646                         desc2->offset = 0;
 647                 } else {
 648                         card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
 649                                              (sizeof(*desc) * i));
 650                         desc = card->rxbd_ring[i];
 651                         desc->paddr = buf_pa;
 652                         desc->len = (u16)skb->len;
 653                         desc->flags = 0;
 654                 }
 655         }
 656
 657         return 0;
 658 }
 659
 660 /* This function initializes event buffer ring descriptors. Each SKB is
 661  * allocated here and after mapping PCI memory, its physical address is assigned
 662  * to PCIE Rx buffer descriptor's physical address
 663  */
 664 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
 665 {
 666         struct pcie_service_card *card = adapter->card;
 667         struct mwifiex_evt_buf_desc *desc;
 668         struct sk_buff *skb;
 669         dma_addr_t buf_pa;
 670         int i;
 671
 672         for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
 673                 /* Allocate skb here so that firmware can DMA data from it */
 674                 skb = dev_alloc_skb(MAX_EVENT_SIZE);
 675                 if (!skb) {
 676                         mwifiex_dbg(adapter, ERROR,
 677                                     "Unable to allocate skb for EVENT buf.\n");
 678                         kfree(card->evtbd_ring_vbase);
 679                         return -ENOMEM;
 680                 }
 681                 skb_put(skb, MAX_EVENT_SIZE);
 682
 683                 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
 684                                            PCI_DMA_FROMDEVICE)) {
 685                         kfree_skb(skb);
 686                         kfree(card->evtbd_ring_vbase);
 687                         return -1;
 688                 }
 689
 690                 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
 691
 692                 mwifiex_dbg(adapter, EVENT,
 693                             "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
 694                             skb, skb->len, skb->data, (u32)buf_pa,
 695                             (u32)((u64)buf_pa >> 32));
 696
 697                 card->evt_buf_list[i] = skb;
 698                 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
 699                                       (sizeof(*desc) * i));
 700                 desc = card->evtbd_ring[i];
 701                 desc->paddr = buf_pa;
 702                 desc->len = (u16)skb->len;
 703                 desc->flags = 0;
 704         }
 705
 706         return 0;
 707 }
 708
 709 /* This function cleans up TX buffer rings. If any of the buffer list has valid
 710  * SKB address, associated SKB is freed.
 711  */
 712 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
 713 {
 714         struct pcie_service_card *card = adapter->card;
 715         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 716         struct sk_buff *skb;
 717         struct mwifiex_pcie_buf_desc *desc;
 718         struct mwifiex_pfu_buf_desc *desc2;
 719         int i;
 720
 721         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 722                 if (reg->pfu_enabled) {
 723                         desc2 = card->txbd_ring[i];
 724                         if (card->tx_buf_list[i]) {
 725                                 skb = card->tx_buf_list[i];
 726                                 mwifiex_unmap_pci_memory(adapter, skb,
 727                                                          PCI_DMA_TODEVICE);
 728                                 dev_kfree_skb_any(skb);
 729                         }
 730                         memset(desc2, 0, sizeof(*desc2));
 731                 } else {
 732                         desc = card->txbd_ring[i];
 733                         if (card->tx_buf_list[i]) {
 734                                 skb = card->tx_buf_list[i];
 735                                 mwifiex_unmap_pci_memory(adapter, skb,
 736                                                          PCI_DMA_TODEVICE);
 737                                 dev_kfree_skb_any(skb);
 738                         }
 739                         memset(desc, 0, sizeof(*desc));
 740                 }
 741                 card->tx_buf_list[i] = NULL;
 742         }
 743
 744         atomic_set(&adapter->tx_hw_pending, 0);
 745         return;
 746 }
 747
 748 /* This function cleans up RX buffer rings. If any of the buffer list has valid
 749  * SKB address, associated SKB is freed.
 750  */
 751 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
 752 {
 753         struct pcie_service_card *card = adapter->card;
 754         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 755         struct mwifiex_pcie_buf_desc *desc;
 756         struct mwifiex_pfu_buf_desc *desc2;
 757         struct sk_buff *skb;
 758         int i;
 759
 760         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 761                 if (reg->pfu_enabled) {
 762                         desc2 = card->rxbd_ring[i];
 763                         if (card->rx_buf_list[i]) {
 764                                 skb = card->rx_buf_list[i];
 765                                 mwifiex_unmap_pci_memory(adapter, skb,
 766                                                          PCI_DMA_FROMDEVICE);
 767                                 dev_kfree_skb_any(skb);
 768                         }
 769                         memset(desc2, 0, sizeof(*desc2));
 770                 } else {
 771                         desc = card->rxbd_ring[i];
 772                         if (card->rx_buf_list[i]) {
 773                                 skb = card->rx_buf_list[i];
 774                                 mwifiex_unmap_pci_memory(adapter, skb,
 775                                                          PCI_DMA_FROMDEVICE);
 776                                 dev_kfree_skb_any(skb);
 777                         }
 778                         memset(desc, 0, sizeof(*desc));
 779                 }
 780                 card->rx_buf_list[i] = NULL;
 781         }
 782
 783         return;
 784 }
 785
 786 /* This function cleans up event buffer rings. If any of the buffer list has
 787  * valid SKB address, associated SKB is freed.
 788  */
 789 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
 790 {
 791         struct pcie_service_card *card = adapter->card;
 792         struct mwifiex_evt_buf_desc *desc;
 793         struct sk_buff *skb;
 794         int i;
 795
 796         for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
 797                 desc = card->evtbd_ring[i];
 798                 if (card->evt_buf_list[i]) {
 799                         skb = card->evt_buf_list[i];
 800                         mwifiex_unmap_pci_memory(adapter, skb,
 801                                                  PCI_DMA_FROMDEVICE);
 802                         dev_kfree_skb_any(skb);
 803                 }
 804                 card->evt_buf_list[i] = NULL;
 805                 memset(desc, 0, sizeof(*desc));
 806         }
 807
 808         return;
 809 }
 810
 811 /* This function creates buffer descriptor ring for TX
 812  */
 813 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
 814 {
 815         struct pcie_service_card *card = adapter->card;
 816         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 817
 818         /*
 819          * driver maintaines the write pointer and firmware maintaines the read
 820          * pointer. The write pointer starts at 0 (zero) while the read pointer
 821          * starts at zero with rollover bit set
 822          */
 823         card->txbd_wrptr = 0;
 824
 825         if (reg->pfu_enabled)
 826                 card->txbd_rdptr = 0;
 827         else
 828                 card->txbd_rdptr |= reg->tx_rollover_ind;
 829
 830         /* allocate shared memory for the BD ring and divide the same in to
 831            several descriptors */
 832         if (reg->pfu_enabled)
 833                 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
 834                                        MWIFIEX_MAX_TXRX_BD;
 835         else
 836                 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
 837                                        MWIFIEX_MAX_TXRX_BD;
 838
 839         mwifiex_dbg(adapter, INFO,
 840                     "info: txbd_ring: Allocating %d bytes\n",
 841                     card->txbd_ring_size);
 842         card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
 843                                                      card->txbd_ring_size,
 844                                                      &card->txbd_ring_pbase);
 845         if (!card->txbd_ring_vbase) {
 846                 mwifiex_dbg(adapter, ERROR,
 847                             "allocate consistent memory (%d bytes) failed!\n",
 848                             card->txbd_ring_size);
 849                 return -ENOMEM;
 850         }
 851         mwifiex_dbg(adapter, DATA,
 852                     "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
 853                     card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
 854                     (u32)((u64)card->txbd_ring_pbase >> 32),
 855                     card->txbd_ring_size);
 856
 857         return mwifiex_init_txq_ring(adapter);
 858 }
 859
 860 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
 861 {
 862         struct pcie_service_card *card = adapter->card;
 863         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 864
 865         mwifiex_cleanup_txq_ring(adapter);
 866
 867         if (card->txbd_ring_vbase)
 868                 pci_free_consistent(card->dev, card->txbd_ring_size,
 869                                     card->txbd_ring_vbase,
 870                                     card->txbd_ring_pbase);
 871         card->txbd_ring_size = 0;
 872         card->txbd_wrptr = 0;
 873         card->txbd_rdptr = 0 | reg->tx_rollover_ind;
 874         card->txbd_ring_vbase = NULL;
 875         card->txbd_ring_pbase = 0;
 876
 877         return 0;
 878 }
 879
 880 /*
 881  * This function creates buffer descriptor ring for RX
 882  */
 883 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
 884 {
 885         struct pcie_service_card *card = adapter->card;
 886         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 887
 888         /*
 889          * driver maintaines the read pointer and firmware maintaines the write
 890          * pointer. The write pointer starts at 0 (zero) while the read pointer
 891          * starts at zero with rollover bit set
 892          */
 893         card->rxbd_wrptr = 0;
 894         card->rxbd_rdptr = reg->rx_rollover_ind;
 895
 896         if (reg->pfu_enabled)
 897                 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
 898                                        MWIFIEX_MAX_TXRX_BD;
 899         else
 900                 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
 901                                        MWIFIEX_MAX_TXRX_BD;
 902
 903         mwifiex_dbg(adapter, INFO,
 904                     "info: rxbd_ring: Allocating %d bytes\n",
 905                     card->rxbd_ring_size);
 906         card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
 907                                                      card->rxbd_ring_size,
 908                                                      &card->rxbd_ring_pbase);
 909         if (!card->rxbd_ring_vbase) {
 910                 mwifiex_dbg(adapter, ERROR,
 911                             "allocate consistent memory (%d bytes) failed!\n",
 912                             card->rxbd_ring_size);
 913                 return -ENOMEM;
 914         }
 915
 916         mwifiex_dbg(adapter, DATA,
 917                     "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
 918                     card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
 919                     (u32)((u64)card->rxbd_ring_pbase >> 32),
 920                     card->rxbd_ring_size);
 921
 922         return mwifiex_init_rxq_ring(adapter);
 923 }
 924
 925 /*
 926  * This function deletes Buffer descriptor ring for RX
 927  */
 928 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
 929 {
 930         struct pcie_service_card *card = adapter->card;
 931         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 932
 933         mwifiex_cleanup_rxq_ring(adapter);
 934
 935         if (card->rxbd_ring_vbase)
 936                 pci_free_consistent(card->dev, card->rxbd_ring_size,
 937                                     card->rxbd_ring_vbase,
 938                                     card->rxbd_ring_pbase);
 939         card->rxbd_ring_size = 0;
 940         card->rxbd_wrptr = 0;
 941         card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
 942         card->rxbd_ring_vbase = NULL;
 943         card->rxbd_ring_pbase = 0;
 944
 945         return 0;
 946 }
 947
 948 /*
 949  * This function creates buffer descriptor ring for Events
 950  */
 951 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
 952 {
 953         struct pcie_service_card *card = adapter->card;
 954         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 955
 956         /*
 957          * driver maintaines the read pointer and firmware maintaines the write
 958          * pointer. The write pointer starts at 0 (zero) while the read pointer
 959          * starts at zero with rollover bit set
 960          */
 961         card->evtbd_wrptr = 0;
 962         card->evtbd_rdptr = reg->evt_rollover_ind;
 963
 964         card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
 965                                 MWIFIEX_MAX_EVT_BD;
 966
 967         mwifiex_dbg(adapter, INFO,
 968                     "info: evtbd_ring: Allocating %d bytes\n",
 969                 card->evtbd_ring_size);
 970         card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
 971                                                       card->evtbd_ring_size,
 972                                                       &card->evtbd_ring_pbase);
 973         if (!card->evtbd_ring_vbase) {
 974                 mwifiex_dbg(adapter, ERROR,
 975                             "allocate consistent memory (%d bytes) failed!\n",
 976                             card->evtbd_ring_size);
 977                 return -ENOMEM;
 978         }
 979
 980         mwifiex_dbg(adapter, EVENT,
 981                     "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
 982                     card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
 983                     (u32)((u64)card->evtbd_ring_pbase >> 32),
 984                     card->evtbd_ring_size);
 985
 986         return mwifiex_pcie_init_evt_ring(adapter);
 987 }
 988
 989 /*
 990  * This function deletes Buffer descriptor ring for Events
 991  */
 992 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
 993 {
 994         struct pcie_service_card *card = adapter->card;
 995         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 996
 997         mwifiex_cleanup_evt_ring(adapter);
 998
 999         if (card->evtbd_ring_vbase)
1000                 pci_free_consistent(card->dev, card->evtbd_ring_size,
1001                                     card->evtbd_ring_vbase,
1002                                     card->evtbd_ring_pbase);
1003         card->evtbd_wrptr = 0;
1004         card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
1005         card->evtbd_ring_size = 0;
1006         card->evtbd_ring_vbase = NULL;
1007         card->evtbd_ring_pbase = 0;
1008
1009         return 0;
1010 }
1011
1012 /*
1013  * This function allocates a buffer for CMDRSP
1014  */
1015 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
1016 {
1017         struct pcie_service_card *card = adapter->card;
1018         struct sk_buff *skb;
1019
1020         /* Allocate memory for receiving command response data */
1021         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1022         if (!skb) {
1023                 mwifiex_dbg(adapter, ERROR,
1024                             "Unable to allocate skb for command response data.\n");
1025                 return -ENOMEM;
1026         }
1027         skb_put(skb, MWIFIEX_UPLD_SIZE);
1028         if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1029                                    PCI_DMA_FROMDEVICE)) {
1030                 kfree_skb(skb);
1031                 return -1;
1032         }
1033
1034         card->cmdrsp_buf = skb;
1035
1036         return 0;
1037 }
1038
1039 /*
1040  * This function deletes a buffer for CMDRSP
1041  */
1042 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
1043 {
1044         struct pcie_service_card *card;
1045
1046         if (!adapter)
1047                 return 0;
1048
1049         card = adapter->card;
1050
1051         if (card && card->cmdrsp_buf) {
1052                 mwifiex_unmap_pci_memory(adapter, card->cmdrsp_buf,
1053                                          PCI_DMA_FROMDEVICE);
1054                 dev_kfree_skb_any(card->cmdrsp_buf);
1055                 card->cmdrsp_buf = NULL;
1056         }
1057
1058         if (card && card->cmd_buf) {
1059                 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1060                                          PCI_DMA_TODEVICE);
1061                 dev_kfree_skb_any(card->cmd_buf);
1062                 card->cmd_buf = NULL;
1063         }
1064         return 0;
1065 }
1066
1067 /*
1068  * This function allocates a buffer for sleep cookie
1069  */
1070 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1071 {
1072         struct pcie_service_card *card = adapter->card;
1073         u32 *cookie;
1074
1075         card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
1076                                                      &card->sleep_cookie_pbase);
1077         if (!card->sleep_cookie_vbase) {
1078                 mwifiex_dbg(adapter, ERROR,
1079                             "pci_alloc_consistent failed!\n");
1080                 return -ENOMEM;
1081         }
1082         cookie = (u32 *)card->sleep_cookie_vbase;
1083         /* Init val of Sleep Cookie */
1084         *cookie = FW_AWAKE_COOKIE;
1085
1086         mwifiex_dbg(adapter, INFO, "alloc_scook: sleep cookie=0x%x\n", *cookie);
1087
1088         return 0;
1089 }
1090
1091 /*
1092  * This function deletes buffer for sleep cookie
1093  */
1094 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1095 {
1096         struct pcie_service_card *card;
1097
1098         if (!adapter)
1099                 return 0;
1100
1101         card = adapter->card;
1102
1103         if (card && card->sleep_cookie_vbase) {
1104                 pci_free_consistent(card->dev, sizeof(u32),
1105                                     card->sleep_cookie_vbase,
1106                                     card->sleep_cookie_pbase);
1107                 card->sleep_cookie_vbase = NULL;
1108         }
1109
1110         return 0;
1111 }
1112
1113 /* This function flushes the TX buffer descriptor ring
1114  * This function defined as handler is also called while cleaning TXRX
1115  * during disconnect/ bss stop.
1116  */
1117 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
1118 {
1119         struct pcie_service_card *card = adapter->card;
1120
1121         if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
1122                 card->txbd_flush = 1;
1123                 /* write pointer already set at last send
1124                  * send dnld-rdy intr again, wait for completion.
1125                  */
1126                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1127                                       CPU_INTR_DNLD_RDY)) {
1128                         mwifiex_dbg(adapter, ERROR,
1129                                     "failed to assert dnld-rdy interrupt.\n");
1130                         return -1;
1131                 }
1132         }
1133         return 0;
1134 }
1135
1136 /*
1137  * This function unmaps and frees downloaded data buffer
1138  */
1139 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
1140 {
1141         struct sk_buff *skb;
1142         u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
1143         struct mwifiex_pcie_buf_desc *desc;
1144         struct mwifiex_pfu_buf_desc *desc2;
1145         struct pcie_service_card *card = adapter->card;
1146         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1147
1148         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1149                 mwifiex_pm_wakeup_card(adapter);
1150
1151         /* Read the TX ring read pointer set by firmware */
1152         if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
1153                 mwifiex_dbg(adapter, ERROR,
1154                             "SEND COMP: failed to read reg->tx_rdptr\n");
1155                 return -1;
1156         }
1157
1158         mwifiex_dbg(adapter, DATA,
1159                     "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1160                     card->txbd_rdptr, rdptr);
1161
1162         num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1163         /* free from previous txbd_rdptr to current txbd_rdptr */
1164         while (((card->txbd_rdptr & reg->tx_mask) !=
1165                 (rdptr & reg->tx_mask)) ||
1166                ((card->txbd_rdptr & reg->tx_rollover_ind) !=
1167                 (rdptr & reg->tx_rollover_ind))) {
1168                 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
1169                             reg->tx_start_ptr;
1170
1171                 skb = card->tx_buf_list[wrdoneidx];
1172
1173                 if (skb) {
1174                         mwifiex_dbg(adapter, DATA,
1175                                     "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1176                                     skb, wrdoneidx);
1177                         mwifiex_unmap_pci_memory(adapter, skb,
1178                                                  PCI_DMA_TODEVICE);
1179
1180                         unmap_count++;
1181
1182                         if (card->txbd_flush)
1183                                 mwifiex_write_data_complete(adapter, skb, 0,
1184                                                             -1);
1185                         else
1186                                 mwifiex_write_data_complete(adapter, skb, 0, 0);
1187                         atomic_dec(&adapter->tx_hw_pending);
1188                 }
1189
1190                 card->tx_buf_list[wrdoneidx] = NULL;
1191
1192                 if (reg->pfu_enabled) {
1193                         desc2 = card->txbd_ring[wrdoneidx];
1194                         memset(desc2, 0, sizeof(*desc2));
1195                 } else {
1196                         desc = card->txbd_ring[wrdoneidx];
1197                         memset(desc, 0, sizeof(*desc));
1198                 }
1199                 switch (card->dev->device) {
1200                 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1201                         card->txbd_rdptr++;
1202                         break;
1203                 case PCIE_DEVICE_ID_MARVELL_88W8897:
1204                 case PCIE_DEVICE_ID_MARVELL_88W8997:
1205                         card->txbd_rdptr += reg->ring_tx_start_ptr;
1206                         break;
1207                 }
1208
1209
1210                 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1211                         card->txbd_rdptr = ((card->txbd_rdptr &
1212                                              reg->tx_rollover_ind) ^
1213                                              reg->tx_rollover_ind);
1214         }
1215
1216         if (unmap_count)
1217                 adapter->data_sent = false;
1218
1219         if (card->txbd_flush) {
1220                 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1221                         card->txbd_flush = 0;
1222                 else
1223                         mwifiex_clean_pcie_ring_buf(adapter);
1224         }
1225
1226         return 0;
1227 }
1228
1229 /* This function sends data buffer to device. First 4 bytes of payload
1230  * are filled with payload length and payload type. Then this payload
1231  * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1232  * Download ready interrupt to FW is deffered if Tx ring is not full and
1233  * additional payload can be accomodated.
1234  * Caller must ensure tx_param parameter to this function is not NULL.
1235  */
1236 static int
1237 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1238                        struct mwifiex_tx_param *tx_param)
1239 {
1240         struct pcie_service_card *card = adapter->card;
1241         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1242         u32 wrindx, num_tx_buffs, rx_val;
1243         int ret;
1244         dma_addr_t buf_pa;
1245         struct mwifiex_pcie_buf_desc *desc = NULL;
1246         struct mwifiex_pfu_buf_desc *desc2 = NULL;
1247
1248         if (!(skb->data && skb->len)) {
1249                 mwifiex_dbg(adapter, ERROR,
1250                             "%s(): invalid parameter <%p, %#x>\n",
1251                             __func__, skb->data, skb->len);
1252                 return -1;
1253         }
1254
1255         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1256                 mwifiex_pm_wakeup_card(adapter);
1257
1258         num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1259         mwifiex_dbg(adapter, DATA,
1260                     "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1261                 card->txbd_rdptr, card->txbd_wrptr);
1262         if (mwifiex_pcie_txbd_not_full(card)) {
1263                 u8 *payload;
1264
1265                 adapter->data_sent = true;
1266                 payload = skb->data;
1267                 put_unaligned_le16((u16)skb->len, payload + 0);
1268                 put_unaligned_le16(MWIFIEX_TYPE_DATA, payload + 2);
1269
1270                 if (mwifiex_map_pci_memory(adapter, skb, skb->len,
1271                                            PCI_DMA_TODEVICE))
1272                         return -1;
1273
1274                 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1275                 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1276                 card->tx_buf_list[wrindx] = skb;
1277                 atomic_inc(&adapter->tx_hw_pending);
1278
1279                 if (reg->pfu_enabled) {
1280                         desc2 = card->txbd_ring[wrindx];
1281                         desc2->paddr = buf_pa;
1282                         desc2->len = (u16)skb->len;
1283                         desc2->frag_len = (u16)skb->len;
1284                         desc2->offset = 0;
1285                         desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1286                                          MWIFIEX_BD_FLAG_LAST_DESC;
1287                 } else {
1288                         desc = card->txbd_ring[wrindx];
1289                         desc->paddr = buf_pa;
1290                         desc->len = (u16)skb->len;
1291                         desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1292                                       MWIFIEX_BD_FLAG_LAST_DESC;
1293                 }
1294
1295                 switch (card->dev->device) {
1296                 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1297                         card->txbd_wrptr++;
1298                         break;
1299                 case PCIE_DEVICE_ID_MARVELL_88W8897:
1300                 case PCIE_DEVICE_ID_MARVELL_88W8997:
1301                         card->txbd_wrptr += reg->ring_tx_start_ptr;
1302                         break;
1303                 }
1304
1305                 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1306                         card->txbd_wrptr = ((card->txbd_wrptr &
1307                                                 reg->tx_rollover_ind) ^
1308                                                 reg->tx_rollover_ind);
1309
1310                 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1311                 /* Write the TX ring write pointer in to reg->tx_wrptr */
1312                 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1313                                       card->txbd_wrptr | rx_val)) {
1314                         mwifiex_dbg(adapter, ERROR,
1315                                     "SEND DATA: failed to write reg->tx_wrptr\n");
1316                         ret = -1;
1317                         goto done_unmap;
1318                 }
1319
1320                 /* The firmware (latest version 15.68.19.p21) of the 88W8897 PCIe+USB card
1321                  * seems to crash randomly after setting the TX ring write pointer when
1322                  * ASPM powersaving is enabled. A workaround seems to be keeping the bus
1323                  * busy by reading a random register afterwards.
1324                  */
1325                 mwifiex_read_reg(adapter, PCI_VENDOR_ID, &rx_val);
1326
1327                 if ((mwifiex_pcie_txbd_not_full(card)) &&
1328                     tx_param->next_pkt_len) {
1329                         /* have more packets and TxBD still can hold more */
1330                         mwifiex_dbg(adapter, DATA,
1331                                     "SEND DATA: delay dnld-rdy interrupt.\n");
1332                         adapter->data_sent = false;
1333                 } else {
1334                         /* Send the TX ready interrupt */
1335                         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1336                                               CPU_INTR_DNLD_RDY)) {
1337                                 mwifiex_dbg(adapter, ERROR,
1338                                             "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1339                                 ret = -1;
1340                                 goto done_unmap;
1341                         }
1342                 }
1343                 mwifiex_dbg(adapter, DATA,
1344                             "info: SEND DATA: Updated <Rd: %#x, Wr:\t"
1345                             "%#x> and sent packet to firmware successfully\n",
1346                             card->txbd_rdptr, card->txbd_wrptr);
1347         } else {
1348                 mwifiex_dbg(adapter, DATA,
1349                             "info: TX Ring full, can't send packets to fw\n");
1350                 adapter->data_sent = true;
1351                 /* Send the TX ready interrupt */
1352                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1353                                       CPU_INTR_DNLD_RDY))
1354                         mwifiex_dbg(adapter, ERROR,
1355                                     "SEND DATA: failed to assert door-bell intr\n");
1356                 return -EBUSY;
1357         }
1358
1359         return -EINPROGRESS;
1360 done_unmap:
1361         mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1362         card->tx_buf_list[wrindx] = NULL;
1363         atomic_dec(&adapter->tx_hw_pending);
1364         if (reg->pfu_enabled)
1365                 memset(desc2, 0, sizeof(*desc2));
1366         else
1367                 memset(desc, 0, sizeof(*desc));
1368
1369         return ret;
1370 }
1371
1372 /*
1373  * This function handles received buffer ring and
1374  * dispatches packets to upper
1375  */
1376 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1377 {
1378         struct pcie_service_card *card = adapter->card;
1379         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1380         u32 wrptr, rd_index, tx_val;
1381         dma_addr_t buf_pa;
1382         int ret = 0;
1383         struct sk_buff *skb_tmp = NULL;
1384         struct mwifiex_pcie_buf_desc *desc;
1385         struct mwifiex_pfu_buf_desc *desc2;
1386
1387         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1388                 mwifiex_pm_wakeup_card(adapter);
1389
1390         /* Read the RX ring Write pointer set by firmware */
1391         if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1392                 mwifiex_dbg(adapter, ERROR,
1393                             "RECV DATA: failed to read reg->rx_wrptr\n");
1394                 ret = -1;
1395                 goto done;
1396         }
1397         card->rxbd_wrptr = wrptr;
1398
1399         while (((wrptr & reg->rx_mask) !=
1400                 (card->rxbd_rdptr & reg->rx_mask)) ||
1401                ((wrptr & reg->rx_rollover_ind) ==
1402                 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1403                 struct sk_buff *skb_data;
1404                 u16 rx_len;
1405
1406                 rd_index = card->rxbd_rdptr & reg->rx_mask;
1407                 skb_data = card->rx_buf_list[rd_index];
1408
1409                 /* If skb allocation was failed earlier for Rx packet,
1410                  * rx_buf_list[rd_index] would have been left with a NULL.
1411                  */
1412                 if (!skb_data)
1413                         return -ENOMEM;
1414
1415                 mwifiex_unmap_pci_memory(adapter, skb_data, PCI_DMA_FROMDEVICE);
1416                 card->rx_buf_list[rd_index] = NULL;
1417
1418                 /* Get data length from interface header -
1419                  * first 2 bytes for len, next 2 bytes is for type
1420                  */
1421                 rx_len = get_unaligned_le16(skb_data->data);
1422                 if (WARN_ON(rx_len <= adapter->intf_hdr_len ||
1423                             rx_len > MWIFIEX_RX_DATA_BUF_SIZE)) {
1424                         mwifiex_dbg(adapter, ERROR,
1425                                     "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1426                                     rx_len, card->rxbd_rdptr, wrptr);
1427                         dev_kfree_skb_any(skb_data);
1428                 } else {
1429                         skb_put(skb_data, rx_len);
1430                         mwifiex_dbg(adapter, DATA,
1431                                     "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1432                                     card->rxbd_rdptr, wrptr, rx_len);
1433                         skb_pull(skb_data, adapter->intf_hdr_len);
1434                         if (adapter->rx_work_enabled) {
1435                                 skb_queue_tail(&adapter->rx_data_q, skb_data);
1436                                 adapter->data_received = true;
1437                                 atomic_inc(&adapter->rx_pending);
1438                         } else {
1439                                 mwifiex_handle_rx_packet(adapter, skb_data);
1440                         }
1441                 }
1442
1443                 skb_tmp = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
1444                                                       GFP_KERNEL);
1445                 if (!skb_tmp) {
1446                         mwifiex_dbg(adapter, ERROR,
1447                                     "Unable to allocate skb.\n");
1448                         return -ENOMEM;
1449                 }
1450
1451                 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1452                                            MWIFIEX_RX_DATA_BUF_SIZE,
1453                                            PCI_DMA_FROMDEVICE))
1454                         return -1;
1455
1456                 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb_tmp);
1457
1458                 mwifiex_dbg(adapter, INFO,
1459                             "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1460                             skb_tmp, rd_index);
1461                 card->rx_buf_list[rd_index] = skb_tmp;
1462
1463                 if (reg->pfu_enabled) {
1464                         desc2 = card->rxbd_ring[rd_index];
1465                         desc2->paddr = buf_pa;
1466                         desc2->len = skb_tmp->len;
1467                         desc2->frag_len = skb_tmp->len;
1468                         desc2->offset = 0;
1469                         desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1470                 } else {
1471                         desc = card->rxbd_ring[rd_index];
1472                         desc->paddr = buf_pa;
1473                         desc->len = skb_tmp->len;
1474                         desc->flags = 0;
1475                 }
1476
1477                 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1478                                                         MWIFIEX_MAX_TXRX_BD) {
1479                         card->rxbd_rdptr = ((card->rxbd_rdptr &
1480                                              reg->rx_rollover_ind) ^
1481                                              reg->rx_rollover_ind);
1482                 }
1483                 mwifiex_dbg(adapter, DATA,
1484                             "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1485                             card->rxbd_rdptr, wrptr);
1486
1487                 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1488                 /* Write the RX ring read pointer in to reg->rx_rdptr */
1489                 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1490                                       card->rxbd_rdptr | tx_val)) {
1491                         mwifiex_dbg(adapter, DATA,
1492                                     "RECV DATA: failed to write reg->rx_rdptr\n");
1493                         ret = -1;
1494                         goto done;
1495                 }
1496
1497                 /* Read the RX ring Write pointer set by firmware */
1498                 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1499                         mwifiex_dbg(adapter, ERROR,
1500                                     "RECV DATA: failed to read reg->rx_wrptr\n");
1501                         ret = -1;
1502                         goto done;
1503                 }
1504                 mwifiex_dbg(adapter, DATA,
1505                             "info: RECV DATA: Rcvd packet from fw successfully\n");
1506                 card->rxbd_wrptr = wrptr;
1507         }
1508
1509 done:
1510         return ret;
1511 }
1512
1513 /*
1514  * This function downloads the boot command to device
1515  */
1516 static int
1517 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1518 {
1519         dma_addr_t buf_pa;
1520         struct pcie_service_card *card = adapter->card;
1521         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1522
1523         if (!(skb->data && skb->len)) {
1524                 mwifiex_dbg(adapter, ERROR,
1525                             "Invalid parameter in %s <%p. len %d>\n",
1526                             __func__, skb->data, skb->len);
1527                 return -1;
1528         }
1529
1530         if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1531                 return -1;
1532
1533         buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1534
1535         /* Write the lower 32bits of the physical address to low command
1536          * address scratch register
1537          */
1538         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1539                 mwifiex_dbg(adapter, ERROR,
1540                             "%s: failed to write download command to boot code.\n",
1541                             __func__);
1542                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1543                 return -1;
1544         }
1545
1546         /* Write the upper 32bits of the physical address to high command
1547          * address scratch register
1548          */
1549         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1550                               (u32)((u64)buf_pa >> 32))) {
1551                 mwifiex_dbg(adapter, ERROR,
1552                             "%s: failed to write download command to boot code.\n",
1553                             __func__);
1554                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1555                 return -1;
1556         }
1557
1558         /* Write the command length to cmd_size scratch register */
1559         if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1560                 mwifiex_dbg(adapter, ERROR,
1561                             "%s: failed to write command len to cmd_size scratch reg\n",
1562                             __func__);
1563                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1564                 return -1;
1565         }
1566
1567         /* Ring the door bell */
1568         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1569                               CPU_INTR_DOOR_BELL)) {
1570                 mwifiex_dbg(adapter, ERROR,
1571                             "%s: failed to assert door-bell intr\n", __func__);
1572                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1573                 return -1;
1574         }
1575
1576         return 0;
1577 }
1578
1579 /* This function init rx port in firmware which in turn enables to receive data
1580  * from device before transmitting any packet.
1581  */
1582 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1583 {
1584         struct pcie_service_card *card = adapter->card;
1585         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1586         int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1587
1588         /* Write the RX ring read pointer in to reg->rx_rdptr */
1589         if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1590                               tx_wrap)) {
1591                 mwifiex_dbg(adapter, ERROR,
1592                             "RECV DATA: failed to write reg->rx_rdptr\n");
1593                 return -1;
1594         }
1595         return 0;
1596 }
1597
1598 /* This function downloads commands to the device
1599  */
1600 static int
1601 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1602 {
1603         struct pcie_service_card *card = adapter->card;
1604         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1605         int ret = 0;
1606         dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1607         u8 *payload = (u8 *)skb->data;
1608
1609         if (!(skb->data && skb->len)) {
1610                 mwifiex_dbg(adapter, ERROR,
1611                             "Invalid parameter in %s <%p, %#x>\n",
1612                             __func__, skb->data, skb->len);
1613                 return -1;
1614         }
1615
1616         /* Make sure a command response buffer is available */
1617         if (!card->cmdrsp_buf) {
1618                 mwifiex_dbg(adapter, ERROR,
1619                             "No response buffer available, send command failed\n");
1620                 return -EBUSY;
1621         }
1622
1623         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1624                 mwifiex_pm_wakeup_card(adapter);
1625
1626         adapter->cmd_sent = true;
1627
1628         put_unaligned_le16((u16)skb->len, &payload[0]);
1629         put_unaligned_le16(MWIFIEX_TYPE_CMD, &payload[2]);
1630
1631         if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1632                 return -1;
1633
1634         card->cmd_buf = skb;
1635         /*
1636          * Need to keep a reference, since core driver might free up this
1637          * buffer before we've unmapped it.
1638          */
1639         skb_get(skb);
1640
1641         /* To send a command, the driver will:
1642                 1. Write the 64bit physical address of the data buffer to
1643                    cmd response address low  + cmd response address high
1644                 2. Ring the door bell (i.e. set the door bell interrupt)
1645
1646                 In response to door bell interrupt, the firmware will perform
1647                 the DMA of the command packet (first header to obtain the total
1648                 length and then rest of the command).
1649         */
1650
1651         if (card->cmdrsp_buf) {
1652                 cmdrsp_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmdrsp_buf);
1653                 /* Write the lower 32bits of the cmdrsp buffer physical
1654                    address */
1655                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1656                                       (u32)cmdrsp_buf_pa)) {
1657                         mwifiex_dbg(adapter, ERROR,
1658                                     "Failed to write download cmd to boot code.\n");
1659                         ret = -1;
1660                         goto done;
1661                 }
1662                 /* Write the upper 32bits of the cmdrsp buffer physical
1663                    address */
1664                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1665                                       (u32)((u64)cmdrsp_buf_pa >> 32))) {
1666                         mwifiex_dbg(adapter, ERROR,
1667                                     "Failed to write download cmd to boot code.\n");
1668                         ret = -1;
1669                         goto done;
1670                 }
1671         }
1672
1673         cmd_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmd_buf);
1674         /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1675         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1676                               (u32)cmd_buf_pa)) {
1677                 mwifiex_dbg(adapter, ERROR,
1678                             "Failed to write download cmd to boot code.\n");
1679                 ret = -1;
1680                 goto done;
1681         }
1682         /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1683         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1684                               (u32)((u64)cmd_buf_pa >> 32))) {
1685                 mwifiex_dbg(adapter, ERROR,
1686                             "Failed to write download cmd to boot code.\n");
1687                 ret = -1;
1688                 goto done;
1689         }
1690
1691         /* Write the command length to reg->cmd_size */
1692         if (mwifiex_write_reg(adapter, reg->cmd_size,
1693                               card->cmd_buf->len)) {
1694                 mwifiex_dbg(adapter, ERROR,
1695                             "Failed to write cmd len to reg->cmd_size\n");
1696                 ret = -1;
1697                 goto done;
1698         }
1699
1700         /* Ring the door bell */
1701         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1702                               CPU_INTR_DOOR_BELL)) {
1703                 mwifiex_dbg(adapter, ERROR,
1704                             "Failed to assert door-bell intr\n");
1705                 ret = -1;
1706                 goto done;
1707         }
1708
1709 done:
1710         if (ret)
1711                 adapter->cmd_sent = false;
1712
1713         return 0;
1714 }
1715
1716 /*
1717  * This function handles command complete interrupt
1718  */
1719 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1720 {
1721         struct pcie_service_card *card = adapter->card;
1722         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1723         struct sk_buff *skb = card->cmdrsp_buf;
1724         int count = 0;
1725         u16 rx_len;
1726
1727         mwifiex_dbg(adapter, CMD,
1728                     "info: Rx CMD Response\n");
1729
1730         if (adapter->curr_cmd)
1731                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_FROMDEVICE);
1732         else
1733                 pci_dma_sync_single_for_cpu(card->dev,
1734                                             MWIFIEX_SKB_DMA_ADDR(skb),
1735                                             MWIFIEX_UPLD_SIZE,
1736                                             PCI_DMA_FROMDEVICE);
1737
1738         /* Unmap the command as a response has been received. */
1739         if (card->cmd_buf) {
1740                 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1741                                          PCI_DMA_TODEVICE);
1742                 dev_kfree_skb_any(card->cmd_buf);
1743                 card->cmd_buf = NULL;
1744         }
1745
1746         rx_len = get_unaligned_le16(skb->data);
1747         skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1748         skb_trim(skb, rx_len);
1749
1750         if (!adapter->curr_cmd) {
1751                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1752                         pci_dma_sync_single_for_device(card->dev,
1753                                                 MWIFIEX_SKB_DMA_ADDR(skb),
1754                                                 MWIFIEX_SLEEP_COOKIE_SIZE,
1755                                                 PCI_DMA_FROMDEVICE);
1756                         if (mwifiex_write_reg(adapter,
1757                                               PCIE_CPU_INT_EVENT,
1758                                               CPU_INTR_SLEEP_CFM_DONE)) {
1759                                 mwifiex_dbg(adapter, ERROR,
1760                                             "Write register failed\n");
1761                                 return -1;
1762                         }
1763                         mwifiex_delay_for_sleep_cookie(adapter,
1764                                                        MWIFIEX_MAX_DELAY_COUNT);
1765                         mwifiex_unmap_pci_memory(adapter, skb,
1766                                                  PCI_DMA_FROMDEVICE);
1767                         skb_pull(skb, adapter->intf_hdr_len);
1768                         while (reg->sleep_cookie && (count++ < 10) &&
1769                                mwifiex_pcie_ok_to_access_hw(adapter))
1770                                 usleep_range(50, 60);
1771                         mwifiex_pcie_enable_host_int(adapter);
1772                         mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1773                                                            skb->len);
1774                 } else {
1775                         mwifiex_dbg(adapter, ERROR,
1776                                     "There is no command but got cmdrsp\n");
1777                 }
1778                 memcpy(adapter->upld_buf, skb->data,
1779                        min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1780                 skb_push(skb, adapter->intf_hdr_len);
1781                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1782                                            PCI_DMA_FROMDEVICE))
1783                         return -1;
1784         } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1785                 skb_pull(skb, adapter->intf_hdr_len);
1786                 adapter->curr_cmd->resp_skb = skb;
1787                 adapter->cmd_resp_received = true;
1788                 /* Take the pointer and set it to CMD node and will
1789                    return in the response complete callback */
1790                 card->cmdrsp_buf = NULL;
1791
1792                 /* Clear the cmd-rsp buffer address in scratch registers. This
1793                    will prevent firmware from writing to the same response
1794                    buffer again. */
1795                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1796                         mwifiex_dbg(adapter, ERROR,
1797                                     "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1798                         return -1;
1799                 }
1800                 /* Write the upper 32bits of the cmdrsp buffer physical
1801                    address */
1802                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1803                         mwifiex_dbg(adapter, ERROR,
1804                                     "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1805                         return -1;
1806                 }
1807         }
1808
1809         return 0;
1810 }
1811
1812 /*
1813  * Command Response processing complete handler
1814  */
1815 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1816                                         struct sk_buff *skb)
1817 {
1818         struct pcie_service_card *card = adapter->card;
1819
1820         if (skb) {
1821                 card->cmdrsp_buf = skb;
1822                 skb_push(card->cmdrsp_buf, adapter->intf_hdr_len);
1823                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1824                                            PCI_DMA_FROMDEVICE))
1825                         return -1;
1826         }
1827
1828         return 0;
1829 }
1830
1831 /*
1832  * This function handles firmware event ready interrupt
1833  */
1834 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1835 {
1836         struct pcie_service_card *card = adapter->card;
1837         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1838         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1839         u32 wrptr, event;
1840         struct mwifiex_evt_buf_desc *desc;
1841
1842         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1843                 mwifiex_pm_wakeup_card(adapter);
1844
1845         if (adapter->event_received) {
1846                 mwifiex_dbg(adapter, EVENT,
1847                             "info: Event being processed,\t"
1848                             "do not process this interrupt just yet\n");
1849                 return 0;
1850         }
1851
1852         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1853                 mwifiex_dbg(adapter, ERROR,
1854                             "info: Invalid read pointer...\n");
1855                 return -1;
1856         }
1857
1858         /* Read the event ring write pointer set by firmware */
1859         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1860                 mwifiex_dbg(adapter, ERROR,
1861                             "EventReady: failed to read reg->evt_wrptr\n");
1862                 return -1;
1863         }
1864
1865         mwifiex_dbg(adapter, EVENT,
1866                     "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1867                     card->evtbd_rdptr, wrptr);
1868         if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1869                                               & MWIFIEX_EVTBD_MASK)) ||
1870             ((wrptr & reg->evt_rollover_ind) ==
1871              (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1872                 struct sk_buff *skb_cmd;
1873                 __le16 data_len = 0;
1874                 u16 evt_len;
1875
1876                 mwifiex_dbg(adapter, INFO,
1877                             "info: Read Index: %d\n", rdptr);
1878                 skb_cmd = card->evt_buf_list[rdptr];
1879                 mwifiex_unmap_pci_memory(adapter, skb_cmd, PCI_DMA_FROMDEVICE);
1880
1881                 /* Take the pointer and set it to event pointer in adapter
1882                    and will return back after event handling callback */
1883                 card->evt_buf_list[rdptr] = NULL;
1884                 desc = card->evtbd_ring[rdptr];
1885                 memset(desc, 0, sizeof(*desc));
1886
1887                 event = get_unaligned_le32(
1888                         &skb_cmd->data[adapter->intf_hdr_len]);
1889                 adapter->event_cause = event;
1890                 /* The first 4bytes will be the event transfer header
1891                    len is 2 bytes followed by type which is 2 bytes */
1892                 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1893                 evt_len = le16_to_cpu(data_len);
1894                 skb_trim(skb_cmd, evt_len);
1895                 skb_pull(skb_cmd, adapter->intf_hdr_len);
1896                 mwifiex_dbg(adapter, EVENT,
1897                             "info: Event length: %d\n", evt_len);
1898
1899                 if ((evt_len > 0) && (evt_len  < MAX_EVENT_SIZE))
1900                         memcpy(adapter->event_body, skb_cmd->data +
1901                                MWIFIEX_EVENT_HEADER_LEN, evt_len -
1902                                MWIFIEX_EVENT_HEADER_LEN);
1903
1904                 adapter->event_received = true;
1905                 adapter->event_skb = skb_cmd;
1906
1907                 /* Do not update the event read pointer here, wait till the
1908                    buffer is released. This is just to make things simpler,
1909                    we need to find a better method of managing these buffers.
1910                 */
1911         } else {
1912                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1913                                       CPU_INTR_EVENT_DONE)) {
1914                         mwifiex_dbg(adapter, ERROR,
1915                                     "Write register failed\n");
1916                         return -1;
1917                 }
1918         }
1919
1920         return 0;
1921 }
1922
1923 /*
1924  * Event processing complete handler
1925  */
1926 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1927                                        struct sk_buff *skb)
1928 {
1929         struct pcie_service_card *card = adapter->card;
1930         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1931         int ret = 0;
1932         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1933         u32 wrptr;
1934         struct mwifiex_evt_buf_desc *desc;
1935
1936         if (!skb)
1937                 return 0;
1938
1939         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1940                 mwifiex_dbg(adapter, ERROR,
1941                             "event_complete: Invalid rdptr 0x%x\n",
1942                             rdptr);
1943                 return -EINVAL;
1944         }
1945
1946         /* Read the event ring write pointer set by firmware */
1947         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1948                 mwifiex_dbg(adapter, ERROR,
1949                             "event_complete: failed to read reg->evt_wrptr\n");
1950                 return -1;
1951         }
1952
1953         if (!card->evt_buf_list[rdptr]) {
1954                 skb_push(skb, adapter->intf_hdr_len);
1955                 skb_put(skb, MAX_EVENT_SIZE - skb->len);
1956                 if (mwifiex_map_pci_memory(adapter, skb,
1957                                            MAX_EVENT_SIZE,
1958                                            PCI_DMA_FROMDEVICE))
1959                         return -1;
1960                 card->evt_buf_list[rdptr] = skb;
1961                 desc = card->evtbd_ring[rdptr];
1962                 desc->paddr = MWIFIEX_SKB_DMA_ADDR(skb);
1963                 desc->len = (u16)skb->len;
1964                 desc->flags = 0;
1965                 skb = NULL;
1966         } else {
1967                 mwifiex_dbg(adapter, ERROR,
1968                             "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1969                             rdptr, card->evt_buf_list[rdptr], skb);
1970         }
1971
1972         if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1973                 card->evtbd_rdptr = ((card->evtbd_rdptr &
1974                                         reg->evt_rollover_ind) ^
1975                                         reg->evt_rollover_ind);
1976         }
1977
1978         mwifiex_dbg(adapter, EVENT,
1979                     "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1980                     card->evtbd_rdptr, wrptr);
1981
1982         /* Write the event ring read pointer in to reg->evt_rdptr */
1983         if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1984                               card->evtbd_rdptr)) {
1985                 mwifiex_dbg(adapter, ERROR,
1986                             "event_complete: failed to read reg->evt_rdptr\n");
1987                 return -1;
1988         }
1989
1990         mwifiex_dbg(adapter, EVENT,
1991                     "info: Check Events Again\n");
1992         ret = mwifiex_pcie_process_event_ready(adapter);
1993
1994         return ret;
1995 }
1996
1997 /* Combo firmware image is a combination of
1998  * (1) combo crc heaer, start with CMD5
1999  * (2) bluetooth image, start with CMD7, end with CMD6, data wrapped in CMD1.
2000  * (3) wifi image.
2001  *
2002  * This function bypass the header and bluetooth part, return
2003  * the offset of tail wifi-only part. If the image is already wifi-only,
2004  * that is start with CMD1, return 0.
2005  */
2006
2007 static int mwifiex_extract_wifi_fw(struct mwifiex_adapter *adapter,
2008                                    const void *firmware, u32 firmware_len) {
2009         const struct mwifiex_fw_data *fwdata;
2010         u32 offset = 0, data_len, dnld_cmd;
2011         int ret = 0;
2012         bool cmd7_before = false, first_cmd = false;
2013
2014         while (1) {
2015                 /* Check for integer and buffer overflow */
2016                 if (offset + sizeof(fwdata->header) < sizeof(fwdata->header) ||
2017                     offset + sizeof(fwdata->header) >= firmware_len) {
2018                         mwifiex_dbg(adapter, ERROR,
2019                                     "extract wifi-only fw failure!\n");
2020                         ret = -1;
2021                         goto done;
2022                 }
2023
2024                 fwdata = firmware + offset;
2025                 dnld_cmd = le32_to_cpu(fwdata->header.dnld_cmd);
2026                 data_len = le32_to_cpu(fwdata->header.data_length);
2027
2028                 /* Skip past header */
2029                 offset += sizeof(fwdata->header);
2030
2031                 switch (dnld_cmd) {
2032                 case MWIFIEX_FW_DNLD_CMD_1:
2033                         if (offset + data_len < data_len) {
2034                                 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2035                                 ret = -1;
2036                                 goto done;
2037                         }
2038
2039                         /* Image start with cmd1, already wifi-only firmware */
2040                         if (!first_cmd) {
2041                                 mwifiex_dbg(adapter, MSG,
2042                                             "input wifi-only firmware\n");
2043                                 return 0;
2044                         }
2045
2046                         if (!cmd7_before) {
2047                                 mwifiex_dbg(adapter, ERROR,
2048                                             "no cmd7 before cmd1!\n");
2049                                 ret = -1;
2050                                 goto done;
2051                         }
2052                         offset += data_len;
2053                         break;
2054                 case MWIFIEX_FW_DNLD_CMD_5:
2055                         first_cmd = true;
2056                         /* Check for integer overflow */
2057                         if (offset + data_len < data_len) {
2058                                 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2059                                 ret = -1;
2060                                 goto done;
2061                         }
2062                         offset += data_len;
2063                         break;
2064                 case MWIFIEX_FW_DNLD_CMD_6:
2065                         first_cmd = true;
2066                         /* Check for integer overflow */
2067                         if (offset + data_len < data_len) {
2068                                 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2069                                 ret = -1;
2070                                 goto done;
2071                         }
2072                         offset += data_len;
2073                         if (offset >= firmware_len) {
2074                                 mwifiex_dbg(adapter, ERROR,
2075                                             "extract wifi-only fw failure!\n");
2076                                 ret = -1;
2077                         } else {
2078                                 ret = offset;
2079                         }
2080                         goto done;
2081                 case MWIFIEX_FW_DNLD_CMD_7:
2082                         first_cmd = true;
2083                         cmd7_before = true;
2084                         break;
2085                 default:
2086                         mwifiex_dbg(adapter, ERROR, "unknown dnld_cmd %d\n",
2087                                     dnld_cmd);
2088                         ret = -1;
2089                         goto done;
2090                 }
2091         }
2092
2093 done:
2094         return ret;
2095 }
2096
2097 /*
2098  * This function downloads the firmware to the card.
2099  *
2100  * Firmware is downloaded to the card in blocks. Every block download
2101  * is tested for CRC errors, and retried a number of times before
2102  * returning failure.
2103  */
2104 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
2105                                     struct mwifiex_fw_image *fw)
2106 {
2107         int ret;
2108         u8 *firmware = fw->fw_buf;
2109         u32 firmware_len = fw->fw_len;
2110         u32 offset = 0;
2111         struct sk_buff *skb;
2112         u32 txlen, tx_blocks = 0, tries, len, val;
2113         u32 block_retry_cnt = 0;
2114         struct pcie_service_card *card = adapter->card;
2115         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2116
2117         if (!firmware || !firmware_len) {
2118                 mwifiex_dbg(adapter, ERROR,
2119                             "No firmware image found! Terminating download\n");
2120                 return -1;
2121         }
2122
2123         mwifiex_dbg(adapter, INFO,
2124                     "info: Downloading FW image (%d bytes)\n",
2125                     firmware_len);
2126
2127         if (mwifiex_pcie_disable_host_int(adapter)) {
2128                 mwifiex_dbg(adapter, ERROR,
2129                             "%s: Disabling interrupts failed.\n", __func__);
2130                 return -1;
2131         }
2132
2133         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
2134         if (!skb) {
2135                 ret = -ENOMEM;
2136                 goto done;
2137         }
2138
2139         ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_13_REG, &val);
2140         if (ret) {
2141                 mwifiex_dbg(adapter, FATAL, "Failed to read scratch register 13\n");
2142                 goto done;
2143         }
2144
2145         /* PCIE FLR case: extract wifi part from combo firmware*/
2146         if (val == MWIFIEX_PCIE_FLR_HAPPENS) {
2147                 ret = mwifiex_extract_wifi_fw(adapter, firmware, firmware_len);
2148                 if (ret < 0) {
2149                         mwifiex_dbg(adapter, ERROR, "Failed to extract wifi fw\n");
2150                         goto done;
2151                 }
2152                 offset = ret;
2153                 mwifiex_dbg(adapter, MSG,
2154                             "info: dnld wifi firmware from %d bytes\n", offset);
2155         }
2156
2157         /* Perform firmware data transfer */
2158         do {
2159                 u32 ireg_intr = 0;
2160
2161                 /* More data? */
2162                 if (offset >= firmware_len)
2163                         break;
2164
2165                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2166                         ret = mwifiex_read_reg(adapter, reg->cmd_size,
2167                                                &len);
2168                         if (ret) {
2169                                 mwifiex_dbg(adapter, FATAL,
2170                                             "Failed reading len from boot code\n");
2171                                 goto done;
2172                         }
2173                         if (len)
2174                                 break;
2175                         usleep_range(10, 20);
2176                 }
2177
2178                 if (!len) {
2179                         break;
2180                 } else if (len > MWIFIEX_UPLD_SIZE) {
2181                         mwifiex_dbg(adapter, ERROR,
2182                                     "FW download failure @ %d, invalid length %d\n",
2183                                     offset, len);
2184                         ret = -1;
2185                         goto done;
2186                 }
2187
2188                 txlen = len;
2189
2190                 if (len & BIT(0)) {
2191                         block_retry_cnt++;
2192                         if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
2193                                 mwifiex_dbg(adapter, ERROR,
2194                                             "FW download failure @ %d, over max\t"
2195                                             "retry count\n", offset);
2196                                 ret = -1;
2197                                 goto done;
2198                         }
2199                         mwifiex_dbg(adapter, ERROR,
2200                                     "FW CRC error indicated by the\t"
2201                                     "helper: len = 0x%04X, txlen = %d\n",
2202                                     len, txlen);
2203                         len &= ~BIT(0);
2204                         /* Setting this to 0 to resend from same offset */
2205                         txlen = 0;
2206                 } else {
2207                         block_retry_cnt = 0;
2208                         /* Set blocksize to transfer - checking for
2209                            last block */
2210                         if (firmware_len - offset < txlen)
2211                                 txlen = firmware_len - offset;
2212
2213                         tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
2214                                     card->pcie.blksz_fw_dl;
2215
2216                         /* Copy payload to buffer */
2217                         memmove(skb->data, &firmware[offset], txlen);
2218                 }
2219
2220                 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
2221                 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
2222
2223                 /* Send the boot command to device */
2224                 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
2225                         mwifiex_dbg(adapter, ERROR,
2226                                     "Failed to send firmware download command\n");
2227                         ret = -1;
2228                         goto done;
2229                 }
2230
2231                 /* Wait for the command done interrupt */
2232                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2233                         if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
2234                                              &ireg_intr)) {
2235                                 mwifiex_dbg(adapter, ERROR,
2236                                             "%s: Failed to read\t"
2237                                             "interrupt status during fw dnld.\n",
2238                                             __func__);
2239                                 mwifiex_unmap_pci_memory(adapter, skb,
2240                                                          PCI_DMA_TODEVICE);
2241                                 ret = -1;
2242                                 goto done;
2243                         }
2244                         if (!(ireg_intr & CPU_INTR_DOOR_BELL))
2245                                 break;
2246                         usleep_range(10, 20);
2247                 }
2248                 if (ireg_intr & CPU_INTR_DOOR_BELL) {
2249                         mwifiex_dbg(adapter, ERROR, "%s: Card failed to ACK download\n",
2250                                     __func__);
2251                         mwifiex_unmap_pci_memory(adapter, skb,
2252                                                  PCI_DMA_TODEVICE);
2253                         ret = -1;
2254                         goto done;
2255                 }
2256
2257                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
2258
2259                 offset += txlen;
2260         } while (true);
2261
2262         mwifiex_dbg(adapter, MSG,
2263                     "info: FW download over, size %d bytes\n", offset);
2264
2265         ret = 0;
2266
2267 done:
2268         dev_kfree_skb_any(skb);
2269         return ret;
2270 }
2271
2272 /*
2273  * This function checks the firmware status in card.
2274  */
2275 static int
2276 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
2277 {
2278         int ret = 0;
2279         u32 firmware_stat;
2280         struct pcie_service_card *card = adapter->card;
2281         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2282         u32 tries;
2283
2284         /* Mask spurios interrupts */
2285         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
2286                               HOST_INTR_MASK)) {
2287                 mwifiex_dbg(adapter, ERROR,
2288                             "Write register failed\n");
2289                 return -1;
2290         }
2291
2292         mwifiex_dbg(adapter, INFO,
2293                     "Setting driver ready signature\n");
2294         if (mwifiex_write_reg(adapter, reg->drv_rdy,
2295                               FIRMWARE_READY_PCIE)) {
2296                 mwifiex_dbg(adapter, ERROR,
2297                             "Failed to write driver ready signature\n");
2298                 return -1;
2299         }
2300
2301         /* Wait for firmware initialization event */
2302         for (tries = 0; tries < poll_num; tries++) {
2303                 if (mwifiex_read_reg(adapter, reg->fw_status,
2304                                      &firmware_stat))
2305                         ret = -1;
2306                 else
2307                         ret = 0;
2308
2309                 mwifiex_dbg(adapter, INFO, "Try %d if FW is ready <%d,%#x>",
2310                             tries, ret, firmware_stat);
2311
2312                 if (ret)
2313                         continue;
2314                 if (firmware_stat == FIRMWARE_READY_PCIE) {
2315                         ret = 0;
2316                         break;
2317                 } else {
2318                         msleep(100);
2319                         ret = -1;
2320                 }
2321         }
2322
2323         return ret;
2324 }
2325
2326 /* This function checks if WLAN is the winner.
2327  */
2328 static int
2329 mwifiex_check_winner_status(struct mwifiex_adapter *adapter)
2330 {
2331         u32 winner = 0;
2332         int ret = 0;
2333         struct pcie_service_card *card = adapter->card;
2334         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2335
2336         if (mwifiex_read_reg(adapter, reg->fw_status, &winner)) {
2337                 ret = -1;
2338         } else if (!winner) {
2339                 mwifiex_dbg(adapter, INFO, "PCI-E is the winner\n");
2340                 adapter->winner = 1;
2341         } else {
2342                 mwifiex_dbg(adapter, ERROR,
2343                             "PCI-E is not the winner <%#x>", winner);
2344         }
2345
2346         return ret;
2347 }
2348
2349 /*
2350  * This function reads the interrupt status from card.
2351  */
2352 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter,
2353                                      int msg_id)
2354 {
2355         u32 pcie_ireg;
2356         unsigned long flags;
2357         struct pcie_service_card *card = adapter->card;
2358
2359         if (card->msi_enable) {
2360                 spin_lock_irqsave(&adapter->int_lock, flags);
2361                 adapter->int_status = 1;
2362                 spin_unlock_irqrestore(&adapter->int_lock, flags);
2363                 return;
2364         }
2365
2366         if (!mwifiex_pcie_ok_to_access_hw(adapter))
2367                 return;
2368
2369         if (card->msix_enable && msg_id >= 0) {
2370                 pcie_ireg = BIT(msg_id);
2371         } else {
2372                 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2373                                      &pcie_ireg)) {
2374                         mwifiex_dbg(adapter, ERROR, "Read register failed\n");
2375                         return;
2376                 }
2377
2378                 if ((pcie_ireg == 0xFFFFFFFF) || !pcie_ireg)
2379                         return;
2380
2381
2382                 mwifiex_pcie_disable_host_int(adapter);
2383
2384                 /* Clear the pending interrupts */
2385                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
2386                                       ~pcie_ireg)) {
2387                         mwifiex_dbg(adapter, ERROR,
2388                                     "Write register failed\n");
2389                         return;
2390                 }
2391         }
2392
2393         if (!adapter->pps_uapsd_mode &&
2394             adapter->ps_state == PS_STATE_SLEEP &&
2395             mwifiex_pcie_ok_to_access_hw(adapter)) {
2396                 /* Potentially for PCIe we could get other
2397                  * interrupts like shared. Don't change power
2398                  * state until cookie is set
2399                  */
2400                 adapter->ps_state = PS_STATE_AWAKE;
2401                 adapter->pm_wakeup_fw_try = false;
2402                 del_timer(&adapter->wakeup_timer);
2403         }
2404
2405         spin_lock_irqsave(&adapter->int_lock, flags);
2406         adapter->int_status |= pcie_ireg;
2407         spin_unlock_irqrestore(&adapter->int_lock, flags);
2408         mwifiex_dbg(adapter, INTR, "ireg: 0x%08x\n", pcie_ireg);
2409 }
2410
2411 /*
2412  * Interrupt handler for PCIe root port
2413  *
2414  * This function reads the interrupt status from firmware and assigns
2415  * the main process in workqueue which will handle the interrupt.
2416  */
2417 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2418 {
2419         struct mwifiex_msix_context *ctx = context;
2420         struct pci_dev *pdev = ctx->dev;
2421         struct pcie_service_card *card;
2422         struct mwifiex_adapter *adapter;
2423
2424         card = pci_get_drvdata(pdev);
2425
2426         if (!card->adapter) {
2427                 pr_err("info: %s: card=%p adapter=%p\n", __func__, card,
2428                        card ? card->adapter : NULL);
2429                 goto exit;
2430         }
2431         adapter = card->adapter;
2432
2433         if (adapter->surprise_removed)
2434                 goto exit;
2435
2436         if (card->msix_enable)
2437                 mwifiex_interrupt_status(adapter, ctx->msg_id);
2438         else
2439                 mwifiex_interrupt_status(adapter, -1);
2440
2441         mwifiex_queue_main_work(adapter);
2442
2443 exit:
2444         return IRQ_HANDLED;
2445 }
2446
2447 /*
2448  * This function checks the current interrupt status.
2449  *
2450  * The following interrupts are checked and handled by this function -
2451  *      - Data sent
2452  *      - Command sent
2453  *      - Command received
2454  *      - Packets received
2455  *      - Events received
2456  *
2457  * In case of Rx packets received, the packets are uploaded from card to
2458  * host and processed accordingly.
2459  */
2460 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2461 {
2462         int ret;
2463         u32 pcie_ireg = 0;
2464         unsigned long flags;
2465         struct pcie_service_card *card = adapter->card;
2466
2467         spin_lock_irqsave(&adapter->int_lock, flags);
2468         if (!card->msi_enable) {
2469                 /* Clear out unused interrupts */
2470                 pcie_ireg = adapter->int_status;
2471         }
2472         adapter->int_status = 0;
2473         spin_unlock_irqrestore(&adapter->int_lock, flags);
2474
2475         if (card->msi_enable) {
2476                 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2477                         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2478                                              &pcie_ireg)) {
2479                                 mwifiex_dbg(adapter, ERROR,
2480                                             "Read register failed\n");
2481                                 return -1;
2482                         }
2483
2484                         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2485                                 if (mwifiex_write_reg(adapter,
2486                                                       PCIE_HOST_INT_STATUS,
2487                                                       ~pcie_ireg)) {
2488                                         mwifiex_dbg(adapter, ERROR,
2489                                                     "Write register failed\n");
2490                                         return -1;
2491                                 }
2492                                 if (!adapter->pps_uapsd_mode &&
2493                                     adapter->ps_state == PS_STATE_SLEEP) {
2494                                         adapter->ps_state = PS_STATE_AWAKE;
2495                                         adapter->pm_wakeup_fw_try = false;
2496                                         del_timer(&adapter->wakeup_timer);
2497                                 }
2498                         }
2499                 }
2500         }
2501
2502         if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2503                 mwifiex_dbg(adapter, INTR, "info: TX DNLD Done\n");
2504                 ret = mwifiex_pcie_send_data_complete(adapter);
2505                 if (ret)
2506                         return ret;
2507         }
2508         if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2509                 mwifiex_dbg(adapter, INTR, "info: Rx DATA\n");
2510                 ret = mwifiex_pcie_process_recv_data(adapter);
2511                 if (ret)
2512                         return ret;
2513         }
2514         if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2515                 mwifiex_dbg(adapter, INTR, "info: Rx EVENT\n");
2516                 ret = mwifiex_pcie_process_event_ready(adapter);
2517                 if (ret)
2518                         return ret;
2519         }
2520         if (pcie_ireg & HOST_INTR_CMD_DONE) {
2521                 if (adapter->cmd_sent) {
2522                         mwifiex_dbg(adapter, INTR,
2523                                     "info: CMD sent Interrupt\n");
2524                         adapter->cmd_sent = false;
2525                 }
2526                 /* Handle command response */
2527                 ret = mwifiex_pcie_process_cmd_complete(adapter);
2528                 if (ret)
2529                         return ret;
2530         }
2531
2532         mwifiex_dbg(adapter, INTR,
2533                     "info: cmd_sent=%d data_sent=%d\n",
2534                     adapter->cmd_sent, adapter->data_sent);
2535         if (!card->msi_enable && !card->msix_enable &&
2536                                  adapter->ps_state != PS_STATE_SLEEP)
2537                 mwifiex_pcie_enable_host_int(adapter);
2538
2539         return 0;
2540 }
2541
2542 /*
2543  * This function downloads data from driver to card.
2544  *
2545  * Both commands and data packets are transferred to the card by this
2546  * function.
2547  *
2548  * This function adds the PCIE specific header to the front of the buffer
2549  * before transferring. The header contains the length of the packet and
2550  * the type. The firmware handles the packets based upon this set type.
2551  */
2552 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2553                                      struct sk_buff *skb,
2554                                      struct mwifiex_tx_param *tx_param)
2555 {
2556         if (!skb) {
2557                 mwifiex_dbg(adapter, ERROR,
2558                             "Passed NULL skb to %s\n", __func__);
2559                 return -1;
2560         }
2561
2562         if (type == MWIFIEX_TYPE_DATA)
2563                 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2564         else if (type == MWIFIEX_TYPE_CMD)
2565                 return mwifiex_pcie_send_cmd(adapter, skb);
2566
2567         return 0;
2568 }
2569
2570 /* Function to dump PCIE scratch registers in case of FW crash
2571  */
2572 static int
2573 mwifiex_pcie_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
2574 {
2575         char *p = drv_buf;
2576         char buf[256], *ptr;
2577         int i;
2578         u32 value;
2579         struct pcie_service_card *card = adapter->card;
2580         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2581         int pcie_scratch_reg[] = {PCIE_SCRATCH_12_REG,
2582                                   PCIE_SCRATCH_14_REG,
2583                                   PCIE_SCRATCH_15_REG};
2584
2585         if (!p)
2586                 return 0;
2587
2588         mwifiex_dbg(adapter, MSG, "PCIE register dump start\n");
2589
2590         if (mwifiex_read_reg(adapter, reg->fw_status, &value)) {
2591                 mwifiex_dbg(adapter, ERROR, "failed to read firmware status");
2592                 return 0;
2593         }
2594
2595         ptr = buf;
2596         mwifiex_dbg(adapter, MSG, "pcie scratch register:");
2597         for (i = 0; i < ARRAY_SIZE(pcie_scratch_reg); i++) {
2598                 mwifiex_read_reg(adapter, pcie_scratch_reg[i], &value);
2599                 ptr += sprintf(ptr, "reg:0x%x, value=0x%x\n",
2600                                pcie_scratch_reg[i], value);
2601         }
2602
2603         mwifiex_dbg(adapter, MSG, "%s\n", buf);
2604         p += sprintf(p, "%s\n", buf);
2605
2606         mwifiex_dbg(adapter, MSG, "PCIE register dump end\n");
2607
2608         return p - drv_buf;
2609 }
2610
2611 /* This function read/write firmware */
2612 static enum rdwr_status
2613 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter *adapter, u8 doneflag)
2614 {
2615         int ret, tries;
2616         u8 ctrl_data;
2617         u32 fw_status;
2618         struct pcie_service_card *card = adapter->card;
2619         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2620
2621         if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status))
2622                 return RDWR_STATUS_FAILURE;
2623
2624         ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2625                                 reg->fw_dump_host_ready);
2626         if (ret) {
2627                 mwifiex_dbg(adapter, ERROR,
2628                             "PCIE write err\n");
2629                 return RDWR_STATUS_FAILURE;
2630         }
2631
2632         for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2633                 mwifiex_read_reg_byte(adapter, reg->fw_dump_ctrl, &ctrl_data);
2634                 if (ctrl_data == FW_DUMP_DONE)
2635                         return RDWR_STATUS_SUCCESS;
2636                 if (doneflag && ctrl_data == doneflag)
2637                         return RDWR_STATUS_DONE;
2638                 if (ctrl_data != reg->fw_dump_host_ready) {
2639                         mwifiex_dbg(adapter, WARN,
2640                                     "The ctrl reg was changed, re-try again!\n");
2641                         ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2642                                                 reg->fw_dump_host_ready);
2643                         if (ret) {
2644                                 mwifiex_dbg(adapter, ERROR,
2645                                             "PCIE write err\n");
2646                                 return RDWR_STATUS_FAILURE;
2647                         }
2648                 }
2649                 usleep_range(100, 200);
2650         }
2651
2652         mwifiex_dbg(adapter, ERROR, "Fail to pull ctrl_data\n");
2653         return RDWR_STATUS_FAILURE;
2654 }
2655
2656 /* This function dump firmware memory to file */
2657 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter *adapter)
2658 {
2659         struct pcie_service_card *card = adapter->card;
2660         const struct mwifiex_pcie_card_reg *creg = card->pcie.reg;
2661         unsigned int reg, reg_start, reg_end;
2662         u8 *dbg_ptr, *end_ptr, *tmp_ptr, fw_dump_num, dump_num;
2663         u8 idx, i, read_reg, doneflag = 0;
2664         enum rdwr_status stat;
2665         u32 memory_size;
2666         int ret;
2667
2668         if (!card->pcie.can_dump_fw)
2669                 return;
2670
2671         for (idx = 0; idx < adapter->num_mem_types; idx++) {
2672                 struct memory_type_mapping *entry =
2673                                 &adapter->mem_type_mapping_tbl[idx];
2674
2675                 if (entry->mem_ptr) {
2676                         vfree(entry->mem_ptr);
2677                         entry->mem_ptr = NULL;
2678                 }
2679                 entry->mem_size = 0;
2680         }
2681
2682         mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2683
2684         /* Read the number of the memories which will dump */
2685         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2686         if (stat == RDWR_STATUS_FAILURE)
2687                 return;
2688
2689         reg = creg->fw_dump_start;
2690         mwifiex_read_reg_byte(adapter, reg, &fw_dump_num);
2691
2692         /* W8997 chipset firmware dump will be restore in single region*/
2693         if (fw_dump_num == 0)
2694                 dump_num = 1;
2695         else
2696                 dump_num = fw_dump_num;
2697
2698         /* Read the length of every memory which will dump */
2699         for (idx = 0; idx < dump_num; idx++) {
2700                 struct memory_type_mapping *entry =
2701                                 &adapter->mem_type_mapping_tbl[idx];
2702                 memory_size = 0;
2703                 if (fw_dump_num != 0) {
2704                         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2705                         if (stat == RDWR_STATUS_FAILURE)
2706                                 return;
2707
2708                         reg = creg->fw_dump_start;
2709                         for (i = 0; i < 4; i++) {
2710                                 mwifiex_read_reg_byte(adapter, reg, &read_reg);
2711                                 memory_size |= (read_reg << (i * 8));
2712                                 reg++;
2713                         }
2714                 } else {
2715                         memory_size = MWIFIEX_FW_DUMP_MAX_MEMSIZE;
2716                 }
2717
2718                 if (memory_size == 0) {
2719                         mwifiex_dbg(adapter, MSG, "Firmware dump Finished!\n");
2720                         ret = mwifiex_write_reg(adapter, creg->fw_dump_ctrl,
2721                                                 creg->fw_dump_read_done);
2722                         if (ret) {
2723                                 mwifiex_dbg(adapter, ERROR, "PCIE write err\n");
2724                                 return;
2725                         }
2726                         break;
2727                 }
2728
2729                 mwifiex_dbg(adapter, DUMP,
2730                             "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2731                 entry->mem_ptr = vmalloc(memory_size + 1);
2732                 entry->mem_size = memory_size;
2733                 if (!entry->mem_ptr) {
2734                         mwifiex_dbg(adapter, ERROR,
2735                                     "Vmalloc %s failed\n", entry->mem_name);
2736                         return;
2737                 }
2738                 dbg_ptr = entry->mem_ptr;
2739                 end_ptr = dbg_ptr + memory_size;
2740
2741                 doneflag = entry->done_flag;
2742                 mwifiex_dbg(adapter, DUMP, "Start %s output, please wait...\n",
2743                             entry->mem_name);
2744
2745                 do {
2746                         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2747                         if (RDWR_STATUS_FAILURE == stat)
2748                                 return;
2749
2750                         reg_start = creg->fw_dump_start;
2751                         reg_end = creg->fw_dump_end;
2752                         for (reg = reg_start; reg <= reg_end; reg++) {
2753                                 mwifiex_read_reg_byte(adapter, reg, dbg_ptr);
2754                                 if (dbg_ptr < end_ptr) {
2755                                         dbg_ptr++;
2756                                         continue;
2757                                 }
2758                                 mwifiex_dbg(adapter, ERROR,
2759                                             "pre-allocated buf not enough\n");
2760                                 tmp_ptr =
2761                                         vzalloc(memory_size + MWIFIEX_SIZE_4K);
2762                                 if (!tmp_ptr)
2763                                         return;
2764                                 memcpy(tmp_ptr, entry->mem_ptr, memory_size);
2765                                 vfree(entry->mem_ptr);
2766                                 entry->mem_ptr = tmp_ptr;
2767                                 tmp_ptr = NULL;
2768                                 dbg_ptr = entry->mem_ptr + memory_size;
2769                                 memory_size += MWIFIEX_SIZE_4K;
2770                                 end_ptr = entry->mem_ptr + memory_size;
2771                         }
2772
2773                         if (stat != RDWR_STATUS_DONE)
2774                                 continue;
2775
2776                         mwifiex_dbg(adapter, DUMP,
2777                                     "%s done: size=0x%tx\n",
2778                                     entry->mem_name, dbg_ptr - entry->mem_ptr);
2779                         break;
2780                 } while (true);
2781         }
2782         mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2783 }
2784
2785 static void mwifiex_pcie_device_dump_work(struct mwifiex_adapter *adapter)
2786 {
2787         int drv_info_size;
2788         void *drv_info;
2789
2790         drv_info_size = mwifiex_drv_info_dump(adapter, &drv_info);
2791         mwifiex_pcie_fw_dump(adapter);
2792         mwifiex_upload_device_dump(adapter, drv_info, drv_info_size);
2793 }
2794
2795 static void mwifiex_pcie_card_reset_work(struct mwifiex_adapter *adapter)
2796 {
2797         struct pcie_service_card *card = adapter->card;
2798
2799         /* We can't afford to wait here; remove() might be waiting on us. If we
2800          * can't grab the device lock, maybe we'll get another chance later.
2801          */
2802         pci_try_reset_function(card->dev);
2803 }
2804
2805 static void mwifiex_pcie_work(struct work_struct *work)
2806 {
2807         struct pcie_service_card *card =
2808                 container_of(work, struct pcie_service_card, work);
2809
2810         if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2811                                &card->work_flags))
2812                 mwifiex_pcie_device_dump_work(card->adapter);
2813         if (test_and_clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET,
2814                                &card->work_flags))
2815                 mwifiex_pcie_card_reset_work(card->adapter);
2816 }
2817
2818 /* This function dumps FW information */
2819 static void mwifiex_pcie_device_dump(struct mwifiex_adapter *adapter)
2820 {
2821         struct pcie_service_card *card = adapter->card;
2822
2823         if (!test_and_set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2824                               &card->work_flags))
2825                 schedule_work(&card->work);
2826 }
2827
2828 static void mwifiex_pcie_card_reset(struct mwifiex_adapter *adapter)
2829 {
2830         struct pcie_service_card *card = adapter->card;
2831
2832         if (!test_and_set_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags))
2833                 schedule_work(&card->work);
2834 }
2835
2836 static int mwifiex_pcie_alloc_buffers(struct mwifiex_adapter *adapter)
2837 {
2838         struct pcie_service_card *card = adapter->card;
2839         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2840         int ret;
2841
2842         card->cmdrsp_buf = NULL;
2843         ret = mwifiex_pcie_create_txbd_ring(adapter);
2844         if (ret) {
2845                 mwifiex_dbg(adapter, ERROR, "Failed to create txbd ring\n");
2846                 goto err_cre_txbd;
2847         }
2848
2849         ret = mwifiex_pcie_create_rxbd_ring(adapter);
2850         if (ret) {
2851                 mwifiex_dbg(adapter, ERROR, "Failed to create rxbd ring\n");
2852                 goto err_cre_rxbd;
2853         }
2854
2855         ret = mwifiex_pcie_create_evtbd_ring(adapter);
2856         if (ret) {
2857                 mwifiex_dbg(adapter, ERROR, "Failed to create evtbd ring\n");
2858                 goto err_cre_evtbd;
2859         }
2860
2861         ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2862         if (ret) {
2863                 mwifiex_dbg(adapter, ERROR, "Failed to allocate cmdbuf buffer\n");
2864                 goto err_alloc_cmdbuf;
2865         }
2866
2867         if (reg->sleep_cookie) {
2868                 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2869                 if (ret) {
2870                         mwifiex_dbg(adapter, ERROR, "Failed to allocate sleep_cookie buffer\n");
2871                         goto err_alloc_cookie;
2872                 }
2873         } else {
2874                 card->sleep_cookie_vbase = NULL;
2875         }
2876
2877         return 0;
2878
2879 err_alloc_cookie:
2880         mwifiex_pcie_delete_cmdrsp_buf(adapter);
2881 err_alloc_cmdbuf:
2882         mwifiex_pcie_delete_evtbd_ring(adapter);
2883 err_cre_evtbd:
2884         mwifiex_pcie_delete_rxbd_ring(adapter);
2885 err_cre_rxbd:
2886         mwifiex_pcie_delete_txbd_ring(adapter);
2887 err_cre_txbd:
2888         return ret;
2889 }
2890
2891 static void mwifiex_pcie_free_buffers(struct mwifiex_adapter *adapter)
2892 {
2893         struct pcie_service_card *card = adapter->card;
2894         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2895
2896         if (reg->sleep_cookie)
2897                 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2898
2899         mwifiex_pcie_delete_cmdrsp_buf(adapter);
2900         mwifiex_pcie_delete_evtbd_ring(adapter);
2901         mwifiex_pcie_delete_rxbd_ring(adapter);
2902         mwifiex_pcie_delete_txbd_ring(adapter);
2903 }
2904
2905 /*
2906  * This function initializes the PCI-E host memory space, WCB rings, etc.
2907  */
2908 static int mwifiex_init_pcie(struct mwifiex_adapter *adapter)
2909 {
2910         struct pcie_service_card *card = adapter->card;
2911         int ret;
2912         struct pci_dev *pdev = card->dev;
2913
2914         pci_set_drvdata(pdev, card);
2915
2916         ret = pci_enable_device(pdev);
2917         if (ret)
2918                 goto err_enable_dev;
2919
2920         pci_set_master(pdev);
2921
2922         pr_notice("try set_consistent_dma_mask(32)\n");
2923         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2924         if (ret) {
2925                 pr_err("set_dma_mask(32) failed\n");
2926                 goto err_set_dma_mask;
2927         }
2928
2929         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2930         if (ret) {
2931                 pr_err("set_consistent_dma_mask(64) failed\n");
2932                 goto err_set_dma_mask;
2933         }
2934
2935         ret = pci_request_region(pdev, 0, DRV_NAME);
2936         if (ret) {
2937                 pr_err("req_reg(0) error\n");
2938                 goto err_req_region0;
2939         }
2940         card->pci_mmap = pci_iomap(pdev, 0, 0);
2941         if (!card->pci_mmap) {
2942                 pr_err("iomap(0) error\n");
2943                 ret = -EIO;
2944                 goto err_iomap0;
2945         }
2946         ret = pci_request_region(pdev, 2, DRV_NAME);
2947         if (ret) {
2948                 pr_err("req_reg(2) error\n");
2949                 goto err_req_region2;
2950         }
2951         card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2952         if (!card->pci_mmap1) {
2953                 pr_err("iomap(2) error\n");
2954                 ret = -EIO;
2955                 goto err_iomap2;
2956         }
2957
2958         pr_notice("PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2959                   card->pci_mmap, card->pci_mmap1);
2960
2961         ret = mwifiex_pcie_alloc_buffers(adapter);
2962         if (ret)
2963                 goto err_alloc_buffers;
2964
2965         return 0;
2966
2967 err_alloc_buffers:
2968         pci_iounmap(pdev, card->pci_mmap1);
2969 err_iomap2:
2970         pci_release_region(pdev, 2);
2971 err_req_region2:
2972         pci_iounmap(pdev, card->pci_mmap);
2973 err_iomap0:
2974         pci_release_region(pdev, 0);
2975 err_req_region0:
2976 err_set_dma_mask:
2977         pci_disable_device(pdev);
2978 err_enable_dev:
2979         return ret;
2980 }
2981
2982 /*
2983  * This function cleans up the allocated card buffers.
2984  */
2985 static void mwifiex_cleanup_pcie(struct mwifiex_adapter *adapter)
2986 {
2987         struct pcie_service_card *card = adapter->card;
2988         struct pci_dev *pdev = card->dev;
2989         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2990         int ret;
2991         u32 fw_status;
2992
2993         /* Perform the cancel_work_sync() only when we're not resetting
2994          * the card. It's because that function never returns if we're
2995          * in reset path. If we're here when resetting the card, it means
2996          * that we failed to reset the card (reset failure path).
2997          */
2998         if (!card->pci_reset_ongoing) {
2999                 mwifiex_dbg(adapter, MSG, "performing cancel_work_sync()...\n");
3000                 cancel_work_sync(&card->work);
3001                 mwifiex_dbg(adapter, MSG, "cancel_work_sync() done\n");
3002         } else {
3003                 mwifiex_dbg(adapter, MSG,
3004                             "skipped cancel_work_sync() because we're in card reset failure path\n");
3005         }
3006
3007         ret = mwifiex_read_reg(adapter, reg->fw_status, &fw_status);
3008         if (fw_status == FIRMWARE_READY_PCIE) {
3009                 mwifiex_dbg(adapter, INFO,
3010                             "Clearing driver ready signature\n");
3011                 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3012                         mwifiex_dbg(adapter, ERROR,
3013                                     "Failed to write driver not-ready signature\n");
3014         }
3015
3016         pci_disable_device(pdev);
3017
3018         pci_iounmap(pdev, card->pci_mmap);
3019         pci_iounmap(pdev, card->pci_mmap1);
3020         pci_release_region(pdev, 2);
3021         pci_release_region(pdev, 0);
3022
3023         mwifiex_pcie_free_buffers(adapter);
3024 }
3025
3026 static int mwifiex_pcie_request_irq(struct mwifiex_adapter *adapter)
3027 {
3028         int ret, i, j;
3029         struct pcie_service_card *card = adapter->card;
3030         struct pci_dev *pdev = card->dev;
3031
3032         if (card->pcie.reg->msix_support) {
3033                 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3034                         card->msix_entries[i].entry = i;
3035                 ret = pci_enable_msix_exact(pdev, card->msix_entries,
3036                                             MWIFIEX_NUM_MSIX_VECTORS);
3037                 if (!ret) {
3038                         for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++) {
3039                                 card->msix_ctx[i].dev = pdev;
3040                                 card->msix_ctx[i].msg_id = i;
3041
3042                                 ret = request_irq(card->msix_entries[i].vector,
3043                                                   mwifiex_pcie_interrupt, 0,
3044                                                   "MWIFIEX_PCIE_MSIX",
3045                                                   &card->msix_ctx[i]);
3046                                 if (ret)
3047                                         break;
3048                         }
3049
3050                         if (ret) {
3051                                 mwifiex_dbg(adapter, INFO, "request_irq fail: %d\n",
3052                                             ret);
3053                                 for (j = 0; j < i; j++)
3054                                         free_irq(card->msix_entries[j].vector,
3055                                                  &card->msix_ctx[i]);
3056                                 pci_disable_msix(pdev);
3057                         } else {
3058                                 mwifiex_dbg(adapter, MSG, "MSIx enabled!");
3059                                 card->msix_enable = 1;
3060                                 return 0;
3061                         }
3062                 }
3063         }
3064
3065         if (pci_enable_msi(pdev) != 0)
3066                 pci_disable_msi(pdev);
3067         else
3068                 card->msi_enable = 1;
3069
3070         mwifiex_dbg(adapter, INFO, "msi_enable = %d\n", card->msi_enable);
3071
3072         card->share_irq_ctx.dev = pdev;
3073         card->share_irq_ctx.msg_id = -1;
3074         ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
3075                           "MRVL_PCIE", &card->share_irq_ctx);
3076         if (ret) {
3077                 pr_err("request_irq failed: ret=%d\n", ret);
3078                 return -1;
3079         }
3080
3081         return 0;
3082 }
3083
3084 /*
3085  * This function gets the firmware name for downloading by revision id
3086  *
3087  * Read revision id register to get revision id
3088  */
3089 static void mwifiex_pcie_get_fw_name(struct mwifiex_adapter *adapter)
3090 {
3091         int revision_id = 0;
3092         int version, magic;
3093         struct pcie_service_card *card = adapter->card;
3094
3095         switch (card->dev->device) {
3096         case PCIE_DEVICE_ID_MARVELL_88W8766P:
3097                 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
3098                 break;
3099         case PCIE_DEVICE_ID_MARVELL_88W8897:
3100                 mwifiex_write_reg(adapter, 0x0c58, 0x80c00000);
3101                 mwifiex_read_reg(adapter, 0x0c58, &revision_id);
3102                 revision_id &= 0xff00;
3103                 switch (revision_id) {
3104                 case PCIE8897_A0:
3105                         strcpy(adapter->fw_name, PCIE8897_A0_FW_NAME);
3106                         break;
3107                 case PCIE8897_B0:
3108                         strcpy(adapter->fw_name, PCIE8897_B0_FW_NAME);
3109                         break;
3110                 default:
3111                         strcpy(adapter->fw_name, PCIE8897_DEFAULT_FW_NAME);
3112
3113                         break;
3114                 }
3115                 break;
3116         case PCIE_DEVICE_ID_MARVELL_88W8997:
3117                 mwifiex_read_reg(adapter, 0x8, &revision_id);
3118                 mwifiex_read_reg(adapter, 0x0cd0, &version);
3119                 mwifiex_read_reg(adapter, 0x0cd4, &magic);
3120                 revision_id &= 0xff;
3121                 version &= 0x7;
3122                 magic &= 0xff;
3123                 if (revision_id == PCIE8997_A1 &&
3124                     magic == CHIP_MAGIC_VALUE &&
3125                     version == CHIP_VER_PCIEUART)
3126                         strcpy(adapter->fw_name, PCIEUART8997_FW_NAME_V4);
3127                 else
3128                         strcpy(adapter->fw_name, PCIEUSB8997_FW_NAME_V4);
3129                 break;
3130         default:
3131                 break;
3132         }
3133 }
3134
3135 /*
3136  * This function registers the PCIE device.
3137  *
3138  * PCIE IRQ is claimed, block size is set and driver data is initialized.
3139  */
3140 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
3141 {
3142         struct pcie_service_card *card = adapter->card;
3143
3144         /* save adapter pointer in card */
3145         card->adapter = adapter;
3146
3147         if (mwifiex_pcie_request_irq(adapter))
3148                 return -1;
3149
3150         adapter->tx_buf_size = card->pcie.tx_buf_size;
3151         adapter->mem_type_mapping_tbl = card->pcie.mem_type_mapping_tbl;
3152         adapter->num_mem_types = card->pcie.num_mem_types;
3153         adapter->ext_scan = card->pcie.can_ext_scan;
3154         mwifiex_pcie_get_fw_name(adapter);
3155
3156         return 0;
3157 }
3158
3159 /*
3160  * This function unregisters the PCIE device.
3161  *
3162  * The PCIE IRQ is released, the function is disabled and driver
3163  * data is set to null.
3164  */
3165 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
3166 {
3167         struct pcie_service_card *card = adapter->card;
3168         struct pci_dev *pdev = card->dev;
3169         int i;
3170
3171         if (card->msix_enable) {
3172                 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3173                         synchronize_irq(card->msix_entries[i].vector);
3174
3175                 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3176                         free_irq(card->msix_entries[i].vector,
3177                                  &card->msix_ctx[i]);
3178
3179                 card->msix_enable = 0;
3180                 pci_disable_msix(pdev);
3181         } else {
3182                 mwifiex_dbg(adapter, INFO,
3183                             "%s(): calling free_irq()\n", __func__);
3184                free_irq(card->dev->irq, &card->share_irq_ctx);
3185
3186                 if (card->msi_enable)
3187                         pci_disable_msi(pdev);
3188         }
3189         card->adapter = NULL;
3190 }
3191
3192 /*
3193  * This function initializes the PCI-E host memory space, WCB rings, etc.,
3194  * similar to mwifiex_init_pcie(), but without resetting PCI-E state.
3195  */
3196 static void mwifiex_pcie_up_dev(struct mwifiex_adapter *adapter)
3197 {
3198         struct pcie_service_card *card = adapter->card;
3199         struct pci_dev *pdev = card->dev;
3200
3201         /* tx_buf_size might be changed to 3584 by firmware during
3202          * data transfer, we should reset it to default size.
3203          */
3204         adapter->tx_buf_size = card->pcie.tx_buf_size;
3205
3206         mwifiex_pcie_alloc_buffers(adapter);
3207
3208         pci_set_master(pdev);
3209 }
3210
3211 /* This function cleans up the PCI-E host memory space. */
3212 static void mwifiex_pcie_down_dev(struct mwifiex_adapter *adapter)
3213 {
3214         struct pcie_service_card *card = adapter->card;
3215         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
3216         struct pci_dev *pdev = card->dev;
3217
3218         if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3219                 mwifiex_dbg(adapter, ERROR, "Failed to write driver not-ready signature\n");
3220
3221         pci_clear_master(pdev);
3222
3223         adapter->seq_num = 0;
3224
3225         mwifiex_pcie_free_buffers(adapter);
3226 }
3227
3228 static struct mwifiex_if_ops pcie_ops = {
3229         .init_if =                      mwifiex_init_pcie,
3230         .cleanup_if =                   mwifiex_cleanup_pcie,
3231         .check_fw_status =              mwifiex_check_fw_status,
3232         .check_winner_status =          mwifiex_check_winner_status,
3233         .prog_fw =                      mwifiex_prog_fw_w_helper,
3234         .register_dev =                 mwifiex_register_dev,
3235         .unregister_dev =               mwifiex_unregister_dev,
3236         .enable_int =                   mwifiex_pcie_enable_host_int,
3237         .disable_int =                  mwifiex_pcie_disable_host_int_noerr,
3238         .process_int_status =           mwifiex_process_int_status,
3239         .host_to_card =                 mwifiex_pcie_host_to_card,
3240         .wakeup =                       mwifiex_pm_wakeup_card,
3241         .wakeup_complete =              mwifiex_pm_wakeup_card_complete,
3242
3243         /* PCIE specific */
3244         .cmdrsp_complete =              mwifiex_pcie_cmdrsp_complete,
3245         .event_complete =               mwifiex_pcie_event_complete,
3246         .update_mp_end_port =           NULL,
3247         .cleanup_mpa_buf =              NULL,
3248         .init_fw_port =                 mwifiex_pcie_init_fw_port,
3249         .clean_pcie_ring =              mwifiex_clean_pcie_ring_buf,
3250         .card_reset =                   mwifiex_pcie_card_reset,
3251         .reg_dump =                     mwifiex_pcie_reg_dump,
3252         .device_dump =                  mwifiex_pcie_device_dump,
3253         .down_dev =                     mwifiex_pcie_down_dev,
3254         .up_dev =                       mwifiex_pcie_up_dev,
3255 };
3256
3257 module_pci_driver(mwifiex_pcie);
3258
3259 MODULE_AUTHOR("Marvell International Ltd.");
3260 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
3261 MODULE_VERSION(PCIE_VERSION);
3262 MODULE_LICENSE("GPL v2");