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                 if ((mwifiex_pcie_txbd_not_full(card)) &&
1320                     tx_param->next_pkt_len) {
1321                         /* have more packets and TxBD still can hold more */
1322                         mwifiex_dbg(adapter, DATA,
1323                                     "SEND DATA: delay dnld-rdy interrupt.\n");
1324                         adapter->data_sent = false;
1325                 } else {
1326                         /* Send the TX ready interrupt */
1327                         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1328                                               CPU_INTR_DNLD_RDY)) {
1329                                 mwifiex_dbg(adapter, ERROR,
1330                                             "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1331                                 ret = -1;
1332                                 goto done_unmap;
1333                         }
1334                 }
1335                 mwifiex_dbg(adapter, DATA,
1336                             "info: SEND DATA: Updated <Rd: %#x, Wr:\t"
1337                             "%#x> and sent packet to firmware successfully\n",
1338                             card->txbd_rdptr, card->txbd_wrptr);
1339         } else {
1340                 mwifiex_dbg(adapter, DATA,
1341                             "info: TX Ring full, can't send packets to fw\n");
1342                 adapter->data_sent = true;
1343                 /* Send the TX ready interrupt */
1344                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1345                                       CPU_INTR_DNLD_RDY))
1346                         mwifiex_dbg(adapter, ERROR,
1347                                     "SEND DATA: failed to assert door-bell intr\n");
1348                 return -EBUSY;
1349         }
1350
1351         return -EINPROGRESS;
1352 done_unmap:
1353         mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1354         card->tx_buf_list[wrindx] = NULL;
1355         atomic_dec(&adapter->tx_hw_pending);
1356         if (reg->pfu_enabled)
1357                 memset(desc2, 0, sizeof(*desc2));
1358         else
1359                 memset(desc, 0, sizeof(*desc));
1360
1361         return ret;
1362 }
1363
1364 /*
1365  * This function handles received buffer ring and
1366  * dispatches packets to upper
1367  */
1368 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1369 {
1370         struct pcie_service_card *card = adapter->card;
1371         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1372         u32 wrptr, rd_index, tx_val;
1373         dma_addr_t buf_pa;
1374         int ret = 0;
1375         struct sk_buff *skb_tmp = NULL;
1376         struct mwifiex_pcie_buf_desc *desc;
1377         struct mwifiex_pfu_buf_desc *desc2;
1378
1379         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1380                 mwifiex_pm_wakeup_card(adapter);
1381
1382         /* Read the RX ring Write pointer set by firmware */
1383         if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1384                 mwifiex_dbg(adapter, ERROR,
1385                             "RECV DATA: failed to read reg->rx_wrptr\n");
1386                 ret = -1;
1387                 goto done;
1388         }
1389         card->rxbd_wrptr = wrptr;
1390
1391         while (((wrptr & reg->rx_mask) !=
1392                 (card->rxbd_rdptr & reg->rx_mask)) ||
1393                ((wrptr & reg->rx_rollover_ind) ==
1394                 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1395                 struct sk_buff *skb_data;
1396                 u16 rx_len;
1397
1398                 rd_index = card->rxbd_rdptr & reg->rx_mask;
1399                 skb_data = card->rx_buf_list[rd_index];
1400
1401                 /* If skb allocation was failed earlier for Rx packet,
1402                  * rx_buf_list[rd_index] would have been left with a NULL.
1403                  */
1404                 if (!skb_data)
1405                         return -ENOMEM;
1406
1407                 mwifiex_unmap_pci_memory(adapter, skb_data, PCI_DMA_FROMDEVICE);
1408                 card->rx_buf_list[rd_index] = NULL;
1409
1410                 /* Get data length from interface header -
1411                  * first 2 bytes for len, next 2 bytes is for type
1412                  */
1413                 rx_len = get_unaligned_le16(skb_data->data);
1414                 if (WARN_ON(rx_len <= adapter->intf_hdr_len ||
1415                             rx_len > MWIFIEX_RX_DATA_BUF_SIZE)) {
1416                         mwifiex_dbg(adapter, ERROR,
1417                                     "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1418                                     rx_len, card->rxbd_rdptr, wrptr);
1419                         dev_kfree_skb_any(skb_data);
1420                 } else {
1421                         skb_put(skb_data, rx_len);
1422                         mwifiex_dbg(adapter, DATA,
1423                                     "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1424                                     card->rxbd_rdptr, wrptr, rx_len);
1425                         skb_pull(skb_data, adapter->intf_hdr_len);
1426                         if (adapter->rx_work_enabled) {
1427                                 skb_queue_tail(&adapter->rx_data_q, skb_data);
1428                                 adapter->data_received = true;
1429                                 atomic_inc(&adapter->rx_pending);
1430                         } else {
1431                                 mwifiex_handle_rx_packet(adapter, skb_data);
1432                         }
1433                 }
1434
1435                 skb_tmp = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
1436                                                       GFP_KERNEL);
1437                 if (!skb_tmp) {
1438                         mwifiex_dbg(adapter, ERROR,
1439                                     "Unable to allocate skb.\n");
1440                         return -ENOMEM;
1441                 }
1442
1443                 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1444                                            MWIFIEX_RX_DATA_BUF_SIZE,
1445                                            PCI_DMA_FROMDEVICE))
1446                         return -1;
1447
1448                 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb_tmp);
1449
1450                 mwifiex_dbg(adapter, INFO,
1451                             "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1452                             skb_tmp, rd_index);
1453                 card->rx_buf_list[rd_index] = skb_tmp;
1454
1455                 if (reg->pfu_enabled) {
1456                         desc2 = card->rxbd_ring[rd_index];
1457                         desc2->paddr = buf_pa;
1458                         desc2->len = skb_tmp->len;
1459                         desc2->frag_len = skb_tmp->len;
1460                         desc2->offset = 0;
1461                         desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1462                 } else {
1463                         desc = card->rxbd_ring[rd_index];
1464                         desc->paddr = buf_pa;
1465                         desc->len = skb_tmp->len;
1466                         desc->flags = 0;
1467                 }
1468
1469                 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1470                                                         MWIFIEX_MAX_TXRX_BD) {
1471                         card->rxbd_rdptr = ((card->rxbd_rdptr &
1472                                              reg->rx_rollover_ind) ^
1473                                              reg->rx_rollover_ind);
1474                 }
1475                 mwifiex_dbg(adapter, DATA,
1476                             "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1477                             card->rxbd_rdptr, wrptr);
1478
1479                 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1480                 /* Write the RX ring read pointer in to reg->rx_rdptr */
1481                 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1482                                       card->rxbd_rdptr | tx_val)) {
1483                         mwifiex_dbg(adapter, DATA,
1484                                     "RECV DATA: failed to write reg->rx_rdptr\n");
1485                         ret = -1;
1486                         goto done;
1487                 }
1488
1489                 /* Read the RX ring Write pointer set by firmware */
1490                 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1491                         mwifiex_dbg(adapter, ERROR,
1492                                     "RECV DATA: failed to read reg->rx_wrptr\n");
1493                         ret = -1;
1494                         goto done;
1495                 }
1496                 mwifiex_dbg(adapter, DATA,
1497                             "info: RECV DATA: Rcvd packet from fw successfully\n");
1498                 card->rxbd_wrptr = wrptr;
1499         }
1500
1501 done:
1502         return ret;
1503 }
1504
1505 /*
1506  * This function downloads the boot command to device
1507  */
1508 static int
1509 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1510 {
1511         dma_addr_t buf_pa;
1512         struct pcie_service_card *card = adapter->card;
1513         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1514
1515         if (!(skb->data && skb->len)) {
1516                 mwifiex_dbg(adapter, ERROR,
1517                             "Invalid parameter in %s <%p. len %d>\n",
1518                             __func__, skb->data, skb->len);
1519                 return -1;
1520         }
1521
1522         if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1523                 return -1;
1524
1525         buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1526
1527         /* Write the lower 32bits of the physical address to low command
1528          * address scratch register
1529          */
1530         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1531                 mwifiex_dbg(adapter, ERROR,
1532                             "%s: failed to write download command to boot code.\n",
1533                             __func__);
1534                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1535                 return -1;
1536         }
1537
1538         /* Write the upper 32bits of the physical address to high command
1539          * address scratch register
1540          */
1541         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1542                               (u32)((u64)buf_pa >> 32))) {
1543                 mwifiex_dbg(adapter, ERROR,
1544                             "%s: failed to write download command to boot code.\n",
1545                             __func__);
1546                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1547                 return -1;
1548         }
1549
1550         /* Write the command length to cmd_size scratch register */
1551         if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1552                 mwifiex_dbg(adapter, ERROR,
1553                             "%s: failed to write command len to cmd_size scratch reg\n",
1554                             __func__);
1555                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1556                 return -1;
1557         }
1558
1559         /* Ring the door bell */
1560         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1561                               CPU_INTR_DOOR_BELL)) {
1562                 mwifiex_dbg(adapter, ERROR,
1563                             "%s: failed to assert door-bell intr\n", __func__);
1564                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1565                 return -1;
1566         }
1567
1568         return 0;
1569 }
1570
1571 /* This function init rx port in firmware which in turn enables to receive data
1572  * from device before transmitting any packet.
1573  */
1574 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1575 {
1576         struct pcie_service_card *card = adapter->card;
1577         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1578         int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1579
1580         /* Write the RX ring read pointer in to reg->rx_rdptr */
1581         if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1582                               tx_wrap)) {
1583                 mwifiex_dbg(adapter, ERROR,
1584                             "RECV DATA: failed to write reg->rx_rdptr\n");
1585                 return -1;
1586         }
1587         return 0;
1588 }
1589
1590 /* This function downloads commands to the device
1591  */
1592 static int
1593 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1594 {
1595         struct pcie_service_card *card = adapter->card;
1596         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1597         int ret = 0;
1598         dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1599         u8 *payload = (u8 *)skb->data;
1600
1601         if (!(skb->data && skb->len)) {
1602                 mwifiex_dbg(adapter, ERROR,
1603                             "Invalid parameter in %s <%p, %#x>\n",
1604                             __func__, skb->data, skb->len);
1605                 return -1;
1606         }
1607
1608         /* Make sure a command response buffer is available */
1609         if (!card->cmdrsp_buf) {
1610                 mwifiex_dbg(adapter, ERROR,
1611                             "No response buffer available, send command failed\n");
1612                 return -EBUSY;
1613         }
1614
1615         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1616                 mwifiex_pm_wakeup_card(adapter);
1617
1618         adapter->cmd_sent = true;
1619
1620         put_unaligned_le16((u16)skb->len, &payload[0]);
1621         put_unaligned_le16(MWIFIEX_TYPE_CMD, &payload[2]);
1622
1623         if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1624                 return -1;
1625
1626         card->cmd_buf = skb;
1627         /*
1628          * Need to keep a reference, since core driver might free up this
1629          * buffer before we've unmapped it.
1630          */
1631         skb_get(skb);
1632
1633         /* To send a command, the driver will:
1634                 1. Write the 64bit physical address of the data buffer to
1635                    cmd response address low  + cmd response address high
1636                 2. Ring the door bell (i.e. set the door bell interrupt)
1637
1638                 In response to door bell interrupt, the firmware will perform
1639                 the DMA of the command packet (first header to obtain the total
1640                 length and then rest of the command).
1641         */
1642
1643         if (card->cmdrsp_buf) {
1644                 cmdrsp_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmdrsp_buf);
1645                 /* Write the lower 32bits of the cmdrsp buffer physical
1646                    address */
1647                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1648                                       (u32)cmdrsp_buf_pa)) {
1649                         mwifiex_dbg(adapter, ERROR,
1650                                     "Failed to write download cmd to boot code.\n");
1651                         ret = -1;
1652                         goto done;
1653                 }
1654                 /* Write the upper 32bits of the cmdrsp buffer physical
1655                    address */
1656                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1657                                       (u32)((u64)cmdrsp_buf_pa >> 32))) {
1658                         mwifiex_dbg(adapter, ERROR,
1659                                     "Failed to write download cmd to boot code.\n");
1660                         ret = -1;
1661                         goto done;
1662                 }
1663         }
1664
1665         cmd_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmd_buf);
1666         /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1667         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1668                               (u32)cmd_buf_pa)) {
1669                 mwifiex_dbg(adapter, ERROR,
1670                             "Failed to write download cmd to boot code.\n");
1671                 ret = -1;
1672                 goto done;
1673         }
1674         /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1675         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1676                               (u32)((u64)cmd_buf_pa >> 32))) {
1677                 mwifiex_dbg(adapter, ERROR,
1678                             "Failed to write download cmd to boot code.\n");
1679                 ret = -1;
1680                 goto done;
1681         }
1682
1683         /* Write the command length to reg->cmd_size */
1684         if (mwifiex_write_reg(adapter, reg->cmd_size,
1685                               card->cmd_buf->len)) {
1686                 mwifiex_dbg(adapter, ERROR,
1687                             "Failed to write cmd len to reg->cmd_size\n");
1688                 ret = -1;
1689                 goto done;
1690         }
1691
1692         /* Ring the door bell */
1693         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1694                               CPU_INTR_DOOR_BELL)) {
1695                 mwifiex_dbg(adapter, ERROR,
1696                             "Failed to assert door-bell intr\n");
1697                 ret = -1;
1698                 goto done;
1699         }
1700
1701 done:
1702         if (ret)
1703                 adapter->cmd_sent = false;
1704
1705         return 0;
1706 }
1707
1708 /*
1709  * This function handles command complete interrupt
1710  */
1711 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1712 {
1713         struct pcie_service_card *card = adapter->card;
1714         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1715         struct sk_buff *skb = card->cmdrsp_buf;
1716         int count = 0;
1717         u16 rx_len;
1718
1719         mwifiex_dbg(adapter, CMD,
1720                     "info: Rx CMD Response\n");
1721
1722         if (adapter->curr_cmd)
1723                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_FROMDEVICE);
1724         else
1725                 pci_dma_sync_single_for_cpu(card->dev,
1726                                             MWIFIEX_SKB_DMA_ADDR(skb),
1727                                             MWIFIEX_UPLD_SIZE,
1728                                             PCI_DMA_FROMDEVICE);
1729
1730         /* Unmap the command as a response has been received. */
1731         if (card->cmd_buf) {
1732                 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1733                                          PCI_DMA_TODEVICE);
1734                 dev_kfree_skb_any(card->cmd_buf);
1735                 card->cmd_buf = NULL;
1736         }
1737
1738         rx_len = get_unaligned_le16(skb->data);
1739         skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1740         skb_trim(skb, rx_len);
1741
1742         if (!adapter->curr_cmd) {
1743                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1744                         pci_dma_sync_single_for_device(card->dev,
1745                                                 MWIFIEX_SKB_DMA_ADDR(skb),
1746                                                 MWIFIEX_SLEEP_COOKIE_SIZE,
1747                                                 PCI_DMA_FROMDEVICE);
1748                         if (mwifiex_write_reg(adapter,
1749                                               PCIE_CPU_INT_EVENT,
1750                                               CPU_INTR_SLEEP_CFM_DONE)) {
1751                                 mwifiex_dbg(adapter, ERROR,
1752                                             "Write register failed\n");
1753                                 return -1;
1754                         }
1755                         mwifiex_delay_for_sleep_cookie(adapter,
1756                                                        MWIFIEX_MAX_DELAY_COUNT);
1757                         mwifiex_unmap_pci_memory(adapter, skb,
1758                                                  PCI_DMA_FROMDEVICE);
1759                         skb_pull(skb, adapter->intf_hdr_len);
1760                         while (reg->sleep_cookie && (count++ < 10) &&
1761                                mwifiex_pcie_ok_to_access_hw(adapter))
1762                                 usleep_range(50, 60);
1763                         mwifiex_pcie_enable_host_int(adapter);
1764                         mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1765                                                            skb->len);
1766                 } else {
1767                         mwifiex_dbg(adapter, ERROR,
1768                                     "There is no command but got cmdrsp\n");
1769                 }
1770                 memcpy(adapter->upld_buf, skb->data,
1771                        min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1772                 skb_push(skb, adapter->intf_hdr_len);
1773                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1774                                            PCI_DMA_FROMDEVICE))
1775                         return -1;
1776         } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1777                 skb_pull(skb, adapter->intf_hdr_len);
1778                 adapter->curr_cmd->resp_skb = skb;
1779                 adapter->cmd_resp_received = true;
1780                 /* Take the pointer and set it to CMD node and will
1781                    return in the response complete callback */
1782                 card->cmdrsp_buf = NULL;
1783
1784                 /* Clear the cmd-rsp buffer address in scratch registers. This
1785                    will prevent firmware from writing to the same response
1786                    buffer again. */
1787                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1788                         mwifiex_dbg(adapter, ERROR,
1789                                     "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1790                         return -1;
1791                 }
1792                 /* Write the upper 32bits of the cmdrsp buffer physical
1793                    address */
1794                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1795                         mwifiex_dbg(adapter, ERROR,
1796                                     "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1797                         return -1;
1798                 }
1799         }
1800
1801         return 0;
1802 }
1803
1804 /*
1805  * Command Response processing complete handler
1806  */
1807 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1808                                         struct sk_buff *skb)
1809 {
1810         struct pcie_service_card *card = adapter->card;
1811
1812         if (skb) {
1813                 card->cmdrsp_buf = skb;
1814                 skb_push(card->cmdrsp_buf, adapter->intf_hdr_len);
1815                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1816                                            PCI_DMA_FROMDEVICE))
1817                         return -1;
1818         }
1819
1820         return 0;
1821 }
1822
1823 /*
1824  * This function handles firmware event ready interrupt
1825  */
1826 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1827 {
1828         struct pcie_service_card *card = adapter->card;
1829         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1830         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1831         u32 wrptr, event;
1832         struct mwifiex_evt_buf_desc *desc;
1833
1834         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1835                 mwifiex_pm_wakeup_card(adapter);
1836
1837         if (adapter->event_received) {
1838                 mwifiex_dbg(adapter, EVENT,
1839                             "info: Event being processed,\t"
1840                             "do not process this interrupt just yet\n");
1841                 return 0;
1842         }
1843
1844         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1845                 mwifiex_dbg(adapter, ERROR,
1846                             "info: Invalid read pointer...\n");
1847                 return -1;
1848         }
1849
1850         /* Read the event ring write pointer set by firmware */
1851         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1852                 mwifiex_dbg(adapter, ERROR,
1853                             "EventReady: failed to read reg->evt_wrptr\n");
1854                 return -1;
1855         }
1856
1857         mwifiex_dbg(adapter, EVENT,
1858                     "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1859                     card->evtbd_rdptr, wrptr);
1860         if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1861                                               & MWIFIEX_EVTBD_MASK)) ||
1862             ((wrptr & reg->evt_rollover_ind) ==
1863              (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1864                 struct sk_buff *skb_cmd;
1865                 __le16 data_len = 0;
1866                 u16 evt_len;
1867
1868                 mwifiex_dbg(adapter, INFO,
1869                             "info: Read Index: %d\n", rdptr);
1870                 skb_cmd = card->evt_buf_list[rdptr];
1871                 mwifiex_unmap_pci_memory(adapter, skb_cmd, PCI_DMA_FROMDEVICE);
1872
1873                 /* Take the pointer and set it to event pointer in adapter
1874                    and will return back after event handling callback */
1875                 card->evt_buf_list[rdptr] = NULL;
1876                 desc = card->evtbd_ring[rdptr];
1877                 memset(desc, 0, sizeof(*desc));
1878
1879                 event = get_unaligned_le32(
1880                         &skb_cmd->data[adapter->intf_hdr_len]);
1881                 adapter->event_cause = event;
1882                 /* The first 4bytes will be the event transfer header
1883                    len is 2 bytes followed by type which is 2 bytes */
1884                 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1885                 evt_len = le16_to_cpu(data_len);
1886                 skb_trim(skb_cmd, evt_len);
1887                 skb_pull(skb_cmd, adapter->intf_hdr_len);
1888                 mwifiex_dbg(adapter, EVENT,
1889                             "info: Event length: %d\n", evt_len);
1890
1891                 if ((evt_len > 0) && (evt_len  < MAX_EVENT_SIZE))
1892                         memcpy(adapter->event_body, skb_cmd->data +
1893                                MWIFIEX_EVENT_HEADER_LEN, evt_len -
1894                                MWIFIEX_EVENT_HEADER_LEN);
1895
1896                 adapter->event_received = true;
1897                 adapter->event_skb = skb_cmd;
1898
1899                 /* Do not update the event read pointer here, wait till the
1900                    buffer is released. This is just to make things simpler,
1901                    we need to find a better method of managing these buffers.
1902                 */
1903         } else {
1904                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1905                                       CPU_INTR_EVENT_DONE)) {
1906                         mwifiex_dbg(adapter, ERROR,
1907                                     "Write register failed\n");
1908                         return -1;
1909                 }
1910         }
1911
1912         return 0;
1913 }
1914
1915 /*
1916  * Event processing complete handler
1917  */
1918 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1919                                        struct sk_buff *skb)
1920 {
1921         struct pcie_service_card *card = adapter->card;
1922         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1923         int ret = 0;
1924         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1925         u32 wrptr;
1926         struct mwifiex_evt_buf_desc *desc;
1927
1928         if (!skb)
1929                 return 0;
1930
1931         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1932                 mwifiex_dbg(adapter, ERROR,
1933                             "event_complete: Invalid rdptr 0x%x\n",
1934                             rdptr);
1935                 return -EINVAL;
1936         }
1937
1938         /* Read the event ring write pointer set by firmware */
1939         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1940                 mwifiex_dbg(adapter, ERROR,
1941                             "event_complete: failed to read reg->evt_wrptr\n");
1942                 return -1;
1943         }
1944
1945         if (!card->evt_buf_list[rdptr]) {
1946                 skb_push(skb, adapter->intf_hdr_len);
1947                 skb_put(skb, MAX_EVENT_SIZE - skb->len);
1948                 if (mwifiex_map_pci_memory(adapter, skb,
1949                                            MAX_EVENT_SIZE,
1950                                            PCI_DMA_FROMDEVICE))
1951                         return -1;
1952                 card->evt_buf_list[rdptr] = skb;
1953                 desc = card->evtbd_ring[rdptr];
1954                 desc->paddr = MWIFIEX_SKB_DMA_ADDR(skb);
1955                 desc->len = (u16)skb->len;
1956                 desc->flags = 0;
1957                 skb = NULL;
1958         } else {
1959                 mwifiex_dbg(adapter, ERROR,
1960                             "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1961                             rdptr, card->evt_buf_list[rdptr], skb);
1962         }
1963
1964         if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1965                 card->evtbd_rdptr = ((card->evtbd_rdptr &
1966                                         reg->evt_rollover_ind) ^
1967                                         reg->evt_rollover_ind);
1968         }
1969
1970         mwifiex_dbg(adapter, EVENT,
1971                     "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1972                     card->evtbd_rdptr, wrptr);
1973
1974         /* Write the event ring read pointer in to reg->evt_rdptr */
1975         if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1976                               card->evtbd_rdptr)) {
1977                 mwifiex_dbg(adapter, ERROR,
1978                             "event_complete: failed to read reg->evt_rdptr\n");
1979                 return -1;
1980         }
1981
1982         mwifiex_dbg(adapter, EVENT,
1983                     "info: Check Events Again\n");
1984         ret = mwifiex_pcie_process_event_ready(adapter);
1985
1986         return ret;
1987 }
1988
1989 /* Combo firmware image is a combination of
1990  * (1) combo crc heaer, start with CMD5
1991  * (2) bluetooth image, start with CMD7, end with CMD6, data wrapped in CMD1.
1992  * (3) wifi image.
1993  *
1994  * This function bypass the header and bluetooth part, return
1995  * the offset of tail wifi-only part. If the image is already wifi-only,
1996  * that is start with CMD1, return 0.
1997  */
1998
1999 static int mwifiex_extract_wifi_fw(struct mwifiex_adapter *adapter,
2000                                    const void *firmware, u32 firmware_len) {
2001         const struct mwifiex_fw_data *fwdata;
2002         u32 offset = 0, data_len, dnld_cmd;
2003         int ret = 0;
2004         bool cmd7_before = false, first_cmd = false;
2005
2006         while (1) {
2007                 /* Check for integer and buffer overflow */
2008                 if (offset + sizeof(fwdata->header) < sizeof(fwdata->header) ||
2009                     offset + sizeof(fwdata->header) >= firmware_len) {
2010                         mwifiex_dbg(adapter, ERROR,
2011                                     "extract wifi-only fw failure!\n");
2012                         ret = -1;
2013                         goto done;
2014                 }
2015
2016                 fwdata = firmware + offset;
2017                 dnld_cmd = le32_to_cpu(fwdata->header.dnld_cmd);
2018                 data_len = le32_to_cpu(fwdata->header.data_length);
2019
2020                 /* Skip past header */
2021                 offset += sizeof(fwdata->header);
2022
2023                 switch (dnld_cmd) {
2024                 case MWIFIEX_FW_DNLD_CMD_1:
2025                         if (offset + data_len < data_len) {
2026                                 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2027                                 ret = -1;
2028                                 goto done;
2029                         }
2030
2031                         /* Image start with cmd1, already wifi-only firmware */
2032                         if (!first_cmd) {
2033                                 mwifiex_dbg(adapter, MSG,
2034                                             "input wifi-only firmware\n");
2035                                 return 0;
2036                         }
2037
2038                         if (!cmd7_before) {
2039                                 mwifiex_dbg(adapter, ERROR,
2040                                             "no cmd7 before cmd1!\n");
2041                                 ret = -1;
2042                                 goto done;
2043                         }
2044                         offset += data_len;
2045                         break;
2046                 case MWIFIEX_FW_DNLD_CMD_5:
2047                         first_cmd = true;
2048                         /* Check for integer overflow */
2049                         if (offset + data_len < data_len) {
2050                                 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2051                                 ret = -1;
2052                                 goto done;
2053                         }
2054                         offset += data_len;
2055                         break;
2056                 case MWIFIEX_FW_DNLD_CMD_6:
2057                         first_cmd = true;
2058                         /* Check for integer overflow */
2059                         if (offset + data_len < data_len) {
2060                                 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2061                                 ret = -1;
2062                                 goto done;
2063                         }
2064                         offset += data_len;
2065                         if (offset >= firmware_len) {
2066                                 mwifiex_dbg(adapter, ERROR,
2067                                             "extract wifi-only fw failure!\n");
2068                                 ret = -1;
2069                         } else {
2070                                 ret = offset;
2071                         }
2072                         goto done;
2073                 case MWIFIEX_FW_DNLD_CMD_7:
2074                         first_cmd = true;
2075                         cmd7_before = true;
2076                         break;
2077                 default:
2078                         mwifiex_dbg(adapter, ERROR, "unknown dnld_cmd %d\n",
2079                                     dnld_cmd);
2080                         ret = -1;
2081                         goto done;
2082                 }
2083         }
2084
2085 done:
2086         return ret;
2087 }
2088
2089 /*
2090  * This function downloads the firmware to the card.
2091  *
2092  * Firmware is downloaded to the card in blocks. Every block download
2093  * is tested for CRC errors, and retried a number of times before
2094  * returning failure.
2095  */
2096 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
2097                                     struct mwifiex_fw_image *fw)
2098 {
2099         int ret;
2100         u8 *firmware = fw->fw_buf;
2101         u32 firmware_len = fw->fw_len;
2102         u32 offset = 0;
2103         struct sk_buff *skb;
2104         u32 txlen, tx_blocks = 0, tries, len, val;
2105         u32 block_retry_cnt = 0;
2106         struct pcie_service_card *card = adapter->card;
2107         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2108
2109         if (!firmware || !firmware_len) {
2110                 mwifiex_dbg(adapter, ERROR,
2111                             "No firmware image found! Terminating download\n");
2112                 return -1;
2113         }
2114
2115         mwifiex_dbg(adapter, INFO,
2116                     "info: Downloading FW image (%d bytes)\n",
2117                     firmware_len);
2118
2119         if (mwifiex_pcie_disable_host_int(adapter)) {
2120                 mwifiex_dbg(adapter, ERROR,
2121                             "%s: Disabling interrupts failed.\n", __func__);
2122                 return -1;
2123         }
2124
2125         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
2126         if (!skb) {
2127                 ret = -ENOMEM;
2128                 goto done;
2129         }
2130
2131         ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_13_REG, &val);
2132         if (ret) {
2133                 mwifiex_dbg(adapter, FATAL, "Failed to read scratch register 13\n");
2134                 goto done;
2135         }
2136
2137         /* PCIE FLR case: extract wifi part from combo firmware*/
2138         if (val == MWIFIEX_PCIE_FLR_HAPPENS) {
2139                 ret = mwifiex_extract_wifi_fw(adapter, firmware, firmware_len);
2140                 if (ret < 0) {
2141                         mwifiex_dbg(adapter, ERROR, "Failed to extract wifi fw\n");
2142                         goto done;
2143                 }
2144                 offset = ret;
2145                 mwifiex_dbg(adapter, MSG,
2146                             "info: dnld wifi firmware from %d bytes\n", offset);
2147         }
2148
2149         /* Perform firmware data transfer */
2150         do {
2151                 u32 ireg_intr = 0;
2152
2153                 /* More data? */
2154                 if (offset >= firmware_len)
2155                         break;
2156
2157                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2158                         ret = mwifiex_read_reg(adapter, reg->cmd_size,
2159                                                &len);
2160                         if (ret) {
2161                                 mwifiex_dbg(adapter, FATAL,
2162                                             "Failed reading len from boot code\n");
2163                                 goto done;
2164                         }
2165                         if (len)
2166                                 break;
2167                         usleep_range(10, 20);
2168                 }
2169
2170                 if (!len) {
2171                         break;
2172                 } else if (len > MWIFIEX_UPLD_SIZE) {
2173                         mwifiex_dbg(adapter, ERROR,
2174                                     "FW download failure @ %d, invalid length %d\n",
2175                                     offset, len);
2176                         ret = -1;
2177                         goto done;
2178                 }
2179
2180                 txlen = len;
2181
2182                 if (len & BIT(0)) {
2183                         block_retry_cnt++;
2184                         if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
2185                                 mwifiex_dbg(adapter, ERROR,
2186                                             "FW download failure @ %d, over max\t"
2187                                             "retry count\n", offset);
2188                                 ret = -1;
2189                                 goto done;
2190                         }
2191                         mwifiex_dbg(adapter, ERROR,
2192                                     "FW CRC error indicated by the\t"
2193                                     "helper: len = 0x%04X, txlen = %d\n",
2194                                     len, txlen);
2195                         len &= ~BIT(0);
2196                         /* Setting this to 0 to resend from same offset */
2197                         txlen = 0;
2198                 } else {
2199                         block_retry_cnt = 0;
2200                         /* Set blocksize to transfer - checking for
2201                            last block */
2202                         if (firmware_len - offset < txlen)
2203                                 txlen = firmware_len - offset;
2204
2205                         tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
2206                                     card->pcie.blksz_fw_dl;
2207
2208                         /* Copy payload to buffer */
2209                         memmove(skb->data, &firmware[offset], txlen);
2210                 }
2211
2212                 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
2213                 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
2214
2215                 /* Send the boot command to device */
2216                 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
2217                         mwifiex_dbg(adapter, ERROR,
2218                                     "Failed to send firmware download command\n");
2219                         ret = -1;
2220                         goto done;
2221                 }
2222
2223                 /* Wait for the command done interrupt */
2224                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2225                         if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
2226                                              &ireg_intr)) {
2227                                 mwifiex_dbg(adapter, ERROR,
2228                                             "%s: Failed to read\t"
2229                                             "interrupt status during fw dnld.\n",
2230                                             __func__);
2231                                 mwifiex_unmap_pci_memory(adapter, skb,
2232                                                          PCI_DMA_TODEVICE);
2233                                 ret = -1;
2234                                 goto done;
2235                         }
2236                         if (!(ireg_intr & CPU_INTR_DOOR_BELL))
2237                                 break;
2238                         usleep_range(10, 20);
2239                 }
2240                 if (ireg_intr & CPU_INTR_DOOR_BELL) {
2241                         mwifiex_dbg(adapter, ERROR, "%s: Card failed to ACK download\n",
2242                                     __func__);
2243                         mwifiex_unmap_pci_memory(adapter, skb,
2244                                                  PCI_DMA_TODEVICE);
2245                         ret = -1;
2246                         goto done;
2247                 }
2248
2249                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
2250
2251                 offset += txlen;
2252         } while (true);
2253
2254         mwifiex_dbg(adapter, MSG,
2255                     "info: FW download over, size %d bytes\n", offset);
2256
2257         ret = 0;
2258
2259 done:
2260         dev_kfree_skb_any(skb);
2261         return ret;
2262 }
2263
2264 /*
2265  * This function checks the firmware status in card.
2266  */
2267 static int
2268 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
2269 {
2270         int ret = 0;
2271         u32 firmware_stat;
2272         struct pcie_service_card *card = adapter->card;
2273         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2274         u32 tries;
2275
2276         /* Mask spurios interrupts */
2277         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
2278                               HOST_INTR_MASK)) {
2279                 mwifiex_dbg(adapter, ERROR,
2280                             "Write register failed\n");
2281                 return -1;
2282         }
2283
2284         mwifiex_dbg(adapter, INFO,
2285                     "Setting driver ready signature\n");
2286         if (mwifiex_write_reg(adapter, reg->drv_rdy,
2287                               FIRMWARE_READY_PCIE)) {
2288                 mwifiex_dbg(adapter, ERROR,
2289                             "Failed to write driver ready signature\n");
2290                 return -1;
2291         }
2292
2293         /* Wait for firmware initialization event */
2294         for (tries = 0; tries < poll_num; tries++) {
2295                 if (mwifiex_read_reg(adapter, reg->fw_status,
2296                                      &firmware_stat))
2297                         ret = -1;
2298                 else
2299                         ret = 0;
2300
2301                 mwifiex_dbg(adapter, INFO, "Try %d if FW is ready <%d,%#x>",
2302                             tries, ret, firmware_stat);
2303
2304                 if (ret)
2305                         continue;
2306                 if (firmware_stat == FIRMWARE_READY_PCIE) {
2307                         ret = 0;
2308                         break;
2309                 } else {
2310                         msleep(100);
2311                         ret = -1;
2312                 }
2313         }
2314
2315         return ret;
2316 }
2317
2318 /* This function checks if WLAN is the winner.
2319  */
2320 static int
2321 mwifiex_check_winner_status(struct mwifiex_adapter *adapter)
2322 {
2323         u32 winner = 0;
2324         int ret = 0;
2325         struct pcie_service_card *card = adapter->card;
2326         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2327
2328         if (mwifiex_read_reg(adapter, reg->fw_status, &winner)) {
2329                 ret = -1;
2330         } else if (!winner) {
2331                 mwifiex_dbg(adapter, INFO, "PCI-E is the winner\n");
2332                 adapter->winner = 1;
2333         } else {
2334                 mwifiex_dbg(adapter, ERROR,
2335                             "PCI-E is not the winner <%#x>", winner);
2336         }
2337
2338         return ret;
2339 }
2340
2341 /*
2342  * This function reads the interrupt status from card.
2343  */
2344 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter,
2345                                      int msg_id)
2346 {
2347         u32 pcie_ireg;
2348         unsigned long flags;
2349         struct pcie_service_card *card = adapter->card;
2350
2351         if (card->msi_enable) {
2352                 spin_lock_irqsave(&adapter->int_lock, flags);
2353                 adapter->int_status = 1;
2354                 spin_unlock_irqrestore(&adapter->int_lock, flags);
2355                 return;
2356         }
2357
2358         if (!mwifiex_pcie_ok_to_access_hw(adapter))
2359                 return;
2360
2361         if (card->msix_enable && msg_id >= 0) {
2362                 pcie_ireg = BIT(msg_id);
2363         } else {
2364                 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2365                                      &pcie_ireg)) {
2366                         mwifiex_dbg(adapter, ERROR, "Read register failed\n");
2367                         return;
2368                 }
2369
2370                 if ((pcie_ireg == 0xFFFFFFFF) || !pcie_ireg)
2371                         return;
2372
2373
2374                 mwifiex_pcie_disable_host_int(adapter);
2375
2376                 /* Clear the pending interrupts */
2377                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
2378                                       ~pcie_ireg)) {
2379                         mwifiex_dbg(adapter, ERROR,
2380                                     "Write register failed\n");
2381                         return;
2382                 }
2383         }
2384
2385         if (!adapter->pps_uapsd_mode &&
2386             adapter->ps_state == PS_STATE_SLEEP &&
2387             mwifiex_pcie_ok_to_access_hw(adapter)) {
2388                 /* Potentially for PCIe we could get other
2389                  * interrupts like shared. Don't change power
2390                  * state until cookie is set
2391                  */
2392                 adapter->ps_state = PS_STATE_AWAKE;
2393                 adapter->pm_wakeup_fw_try = false;
2394                 del_timer(&adapter->wakeup_timer);
2395         }
2396
2397         spin_lock_irqsave(&adapter->int_lock, flags);
2398         adapter->int_status |= pcie_ireg;
2399         spin_unlock_irqrestore(&adapter->int_lock, flags);
2400         mwifiex_dbg(adapter, INTR, "ireg: 0x%08x\n", pcie_ireg);
2401 }
2402
2403 /*
2404  * Interrupt handler for PCIe root port
2405  *
2406  * This function reads the interrupt status from firmware and assigns
2407  * the main process in workqueue which will handle the interrupt.
2408  */
2409 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2410 {
2411         struct mwifiex_msix_context *ctx = context;
2412         struct pci_dev *pdev = ctx->dev;
2413         struct pcie_service_card *card;
2414         struct mwifiex_adapter *adapter;
2415
2416         card = pci_get_drvdata(pdev);
2417
2418         if (!card->adapter) {
2419                 pr_err("info: %s: card=%p adapter=%p\n", __func__, card,
2420                        card ? card->adapter : NULL);
2421                 goto exit;
2422         }
2423         adapter = card->adapter;
2424
2425         if (adapter->surprise_removed)
2426                 goto exit;
2427
2428         if (card->msix_enable)
2429                 mwifiex_interrupt_status(adapter, ctx->msg_id);
2430         else
2431                 mwifiex_interrupt_status(adapter, -1);
2432
2433         mwifiex_queue_main_work(adapter);
2434
2435 exit:
2436         return IRQ_HANDLED;
2437 }
2438
2439 /*
2440  * This function checks the current interrupt status.
2441  *
2442  * The following interrupts are checked and handled by this function -
2443  *      - Data sent
2444  *      - Command sent
2445  *      - Command received
2446  *      - Packets received
2447  *      - Events received
2448  *
2449  * In case of Rx packets received, the packets are uploaded from card to
2450  * host and processed accordingly.
2451  */
2452 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2453 {
2454         int ret;
2455         u32 pcie_ireg = 0;
2456         unsigned long flags;
2457         struct pcie_service_card *card = adapter->card;
2458
2459         spin_lock_irqsave(&adapter->int_lock, flags);
2460         if (!card->msi_enable) {
2461                 /* Clear out unused interrupts */
2462                 pcie_ireg = adapter->int_status;
2463         }
2464         adapter->int_status = 0;
2465         spin_unlock_irqrestore(&adapter->int_lock, flags);
2466
2467         if (card->msi_enable) {
2468                 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2469                         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2470                                              &pcie_ireg)) {
2471                                 mwifiex_dbg(adapter, ERROR,
2472                                             "Read register failed\n");
2473                                 return -1;
2474                         }
2475
2476                         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2477                                 if (mwifiex_write_reg(adapter,
2478                                                       PCIE_HOST_INT_STATUS,
2479                                                       ~pcie_ireg)) {
2480                                         mwifiex_dbg(adapter, ERROR,
2481                                                     "Write register failed\n");
2482                                         return -1;
2483                                 }
2484                                 if (!adapter->pps_uapsd_mode &&
2485                                     adapter->ps_state == PS_STATE_SLEEP) {
2486                                         adapter->ps_state = PS_STATE_AWAKE;
2487                                         adapter->pm_wakeup_fw_try = false;
2488                                         del_timer(&adapter->wakeup_timer);
2489                                 }
2490                         }
2491                 }
2492         }
2493
2494         if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2495                 mwifiex_dbg(adapter, INTR, "info: TX DNLD Done\n");
2496                 ret = mwifiex_pcie_send_data_complete(adapter);
2497                 if (ret)
2498                         return ret;
2499         }
2500         if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2501                 mwifiex_dbg(adapter, INTR, "info: Rx DATA\n");
2502                 ret = mwifiex_pcie_process_recv_data(adapter);
2503                 if (ret)
2504                         return ret;
2505         }
2506         if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2507                 mwifiex_dbg(adapter, INTR, "info: Rx EVENT\n");
2508                 ret = mwifiex_pcie_process_event_ready(adapter);
2509                 if (ret)
2510                         return ret;
2511         }
2512         if (pcie_ireg & HOST_INTR_CMD_DONE) {
2513                 if (adapter->cmd_sent) {
2514                         mwifiex_dbg(adapter, INTR,
2515                                     "info: CMD sent Interrupt\n");
2516                         adapter->cmd_sent = false;
2517                 }
2518                 /* Handle command response */
2519                 ret = mwifiex_pcie_process_cmd_complete(adapter);
2520                 if (ret)
2521                         return ret;
2522         }
2523
2524         mwifiex_dbg(adapter, INTR,
2525                     "info: cmd_sent=%d data_sent=%d\n",
2526                     adapter->cmd_sent, adapter->data_sent);
2527         if (!card->msi_enable && !card->msix_enable &&
2528                                  adapter->ps_state != PS_STATE_SLEEP)
2529                 mwifiex_pcie_enable_host_int(adapter);
2530
2531         return 0;
2532 }
2533
2534 /*
2535  * This function downloads data from driver to card.
2536  *
2537  * Both commands and data packets are transferred to the card by this
2538  * function.
2539  *
2540  * This function adds the PCIE specific header to the front of the buffer
2541  * before transferring. The header contains the length of the packet and
2542  * the type. The firmware handles the packets based upon this set type.
2543  */
2544 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2545                                      struct sk_buff *skb,
2546                                      struct mwifiex_tx_param *tx_param)
2547 {
2548         if (!skb) {
2549                 mwifiex_dbg(adapter, ERROR,
2550                             "Passed NULL skb to %s\n", __func__);
2551                 return -1;
2552         }
2553
2554         if (type == MWIFIEX_TYPE_DATA)
2555                 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2556         else if (type == MWIFIEX_TYPE_CMD)
2557                 return mwifiex_pcie_send_cmd(adapter, skb);
2558
2559         return 0;
2560 }
2561
2562 /* Function to dump PCIE scratch registers in case of FW crash
2563  */
2564 static int
2565 mwifiex_pcie_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
2566 {
2567         char *p = drv_buf;
2568         char buf[256], *ptr;
2569         int i;
2570         u32 value;
2571         struct pcie_service_card *card = adapter->card;
2572         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2573         int pcie_scratch_reg[] = {PCIE_SCRATCH_12_REG,
2574                                   PCIE_SCRATCH_14_REG,
2575                                   PCIE_SCRATCH_15_REG};
2576
2577         if (!p)
2578                 return 0;
2579
2580         mwifiex_dbg(adapter, MSG, "PCIE register dump start\n");
2581
2582         if (mwifiex_read_reg(adapter, reg->fw_status, &value)) {
2583                 mwifiex_dbg(adapter, ERROR, "failed to read firmware status");
2584                 return 0;
2585         }
2586
2587         ptr = buf;
2588         mwifiex_dbg(adapter, MSG, "pcie scratch register:");
2589         for (i = 0; i < ARRAY_SIZE(pcie_scratch_reg); i++) {
2590                 mwifiex_read_reg(adapter, pcie_scratch_reg[i], &value);
2591                 ptr += sprintf(ptr, "reg:0x%x, value=0x%x\n",
2592                                pcie_scratch_reg[i], value);
2593         }
2594
2595         mwifiex_dbg(adapter, MSG, "%s\n", buf);
2596         p += sprintf(p, "%s\n", buf);
2597
2598         mwifiex_dbg(adapter, MSG, "PCIE register dump end\n");
2599
2600         return p - drv_buf;
2601 }
2602
2603 /* This function read/write firmware */
2604 static enum rdwr_status
2605 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter *adapter, u8 doneflag)
2606 {
2607         int ret, tries;
2608         u8 ctrl_data;
2609         u32 fw_status;
2610         struct pcie_service_card *card = adapter->card;
2611         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2612
2613         if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status))
2614                 return RDWR_STATUS_FAILURE;
2615
2616         ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2617                                 reg->fw_dump_host_ready);
2618         if (ret) {
2619                 mwifiex_dbg(adapter, ERROR,
2620                             "PCIE write err\n");
2621                 return RDWR_STATUS_FAILURE;
2622         }
2623
2624         for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2625                 mwifiex_read_reg_byte(adapter, reg->fw_dump_ctrl, &ctrl_data);
2626                 if (ctrl_data == FW_DUMP_DONE)
2627                         return RDWR_STATUS_SUCCESS;
2628                 if (doneflag && ctrl_data == doneflag)
2629                         return RDWR_STATUS_DONE;
2630                 if (ctrl_data != reg->fw_dump_host_ready) {
2631                         mwifiex_dbg(adapter, WARN,
2632                                     "The ctrl reg was changed, re-try again!\n");
2633                         ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2634                                                 reg->fw_dump_host_ready);
2635                         if (ret) {
2636                                 mwifiex_dbg(adapter, ERROR,
2637                                             "PCIE write err\n");
2638                                 return RDWR_STATUS_FAILURE;
2639                         }
2640                 }
2641                 usleep_range(100, 200);
2642         }
2643
2644         mwifiex_dbg(adapter, ERROR, "Fail to pull ctrl_data\n");
2645         return RDWR_STATUS_FAILURE;
2646 }
2647
2648 /* This function dump firmware memory to file */
2649 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter *adapter)
2650 {
2651         struct pcie_service_card *card = adapter->card;
2652         const struct mwifiex_pcie_card_reg *creg = card->pcie.reg;
2653         unsigned int reg, reg_start, reg_end;
2654         u8 *dbg_ptr, *end_ptr, *tmp_ptr, fw_dump_num, dump_num;
2655         u8 idx, i, read_reg, doneflag = 0;
2656         enum rdwr_status stat;
2657         u32 memory_size;
2658         int ret;
2659
2660         if (!card->pcie.can_dump_fw)
2661                 return;
2662
2663         for (idx = 0; idx < adapter->num_mem_types; idx++) {
2664                 struct memory_type_mapping *entry =
2665                                 &adapter->mem_type_mapping_tbl[idx];
2666
2667                 if (entry->mem_ptr) {
2668                         vfree(entry->mem_ptr);
2669                         entry->mem_ptr = NULL;
2670                 }
2671                 entry->mem_size = 0;
2672         }
2673
2674         mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2675
2676         /* Read the number of the memories which will dump */
2677         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2678         if (stat == RDWR_STATUS_FAILURE)
2679                 return;
2680
2681         reg = creg->fw_dump_start;
2682         mwifiex_read_reg_byte(adapter, reg, &fw_dump_num);
2683
2684         /* W8997 chipset firmware dump will be restore in single region*/
2685         if (fw_dump_num == 0)
2686                 dump_num = 1;
2687         else
2688                 dump_num = fw_dump_num;
2689
2690         /* Read the length of every memory which will dump */
2691         for (idx = 0; idx < dump_num; idx++) {
2692                 struct memory_type_mapping *entry =
2693                                 &adapter->mem_type_mapping_tbl[idx];
2694                 memory_size = 0;
2695                 if (fw_dump_num != 0) {
2696                         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2697                         if (stat == RDWR_STATUS_FAILURE)
2698                                 return;
2699
2700                         reg = creg->fw_dump_start;
2701                         for (i = 0; i < 4; i++) {
2702                                 mwifiex_read_reg_byte(adapter, reg, &read_reg);
2703                                 memory_size |= (read_reg << (i * 8));
2704                                 reg++;
2705                         }
2706                 } else {
2707                         memory_size = MWIFIEX_FW_DUMP_MAX_MEMSIZE;
2708                 }
2709
2710                 if (memory_size == 0) {
2711                         mwifiex_dbg(adapter, MSG, "Firmware dump Finished!\n");
2712                         ret = mwifiex_write_reg(adapter, creg->fw_dump_ctrl,
2713                                                 creg->fw_dump_read_done);
2714                         if (ret) {
2715                                 mwifiex_dbg(adapter, ERROR, "PCIE write err\n");
2716                                 return;
2717                         }
2718                         break;
2719                 }
2720
2721                 mwifiex_dbg(adapter, DUMP,
2722                             "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2723                 entry->mem_ptr = vmalloc(memory_size + 1);
2724                 entry->mem_size = memory_size;
2725                 if (!entry->mem_ptr) {
2726                         mwifiex_dbg(adapter, ERROR,
2727                                     "Vmalloc %s failed\n", entry->mem_name);
2728                         return;
2729                 }
2730                 dbg_ptr = entry->mem_ptr;
2731                 end_ptr = dbg_ptr + memory_size;
2732
2733                 doneflag = entry->done_flag;
2734                 mwifiex_dbg(adapter, DUMP, "Start %s output, please wait...\n",
2735                             entry->mem_name);
2736
2737                 do {
2738                         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2739                         if (RDWR_STATUS_FAILURE == stat)
2740                                 return;
2741
2742                         reg_start = creg->fw_dump_start;
2743                         reg_end = creg->fw_dump_end;
2744                         for (reg = reg_start; reg <= reg_end; reg++) {
2745                                 mwifiex_read_reg_byte(adapter, reg, dbg_ptr);
2746                                 if (dbg_ptr < end_ptr) {
2747                                         dbg_ptr++;
2748                                         continue;
2749                                 }
2750                                 mwifiex_dbg(adapter, ERROR,
2751                                             "pre-allocated buf not enough\n");
2752                                 tmp_ptr =
2753                                         vzalloc(memory_size + MWIFIEX_SIZE_4K);
2754                                 if (!tmp_ptr)
2755                                         return;
2756                                 memcpy(tmp_ptr, entry->mem_ptr, memory_size);
2757                                 vfree(entry->mem_ptr);
2758                                 entry->mem_ptr = tmp_ptr;
2759                                 tmp_ptr = NULL;
2760                                 dbg_ptr = entry->mem_ptr + memory_size;
2761                                 memory_size += MWIFIEX_SIZE_4K;
2762                                 end_ptr = entry->mem_ptr + memory_size;
2763                         }
2764
2765                         if (stat != RDWR_STATUS_DONE)
2766                                 continue;
2767
2768                         mwifiex_dbg(adapter, DUMP,
2769                                     "%s done: size=0x%tx\n",
2770                                     entry->mem_name, dbg_ptr - entry->mem_ptr);
2771                         break;
2772                 } while (true);
2773         }
2774         mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2775 }
2776
2777 static void mwifiex_pcie_device_dump_work(struct mwifiex_adapter *adapter)
2778 {
2779         int drv_info_size;
2780         void *drv_info;
2781
2782         drv_info_size = mwifiex_drv_info_dump(adapter, &drv_info);
2783         mwifiex_pcie_fw_dump(adapter);
2784         mwifiex_upload_device_dump(adapter, drv_info, drv_info_size);
2785 }
2786
2787 static void mwifiex_pcie_card_reset_work(struct mwifiex_adapter *adapter)
2788 {
2789         struct pcie_service_card *card = adapter->card;
2790
2791         /* We can't afford to wait here; remove() might be waiting on us. If we
2792          * can't grab the device lock, maybe we'll get another chance later.
2793          */
2794         pci_try_reset_function(card->dev);
2795 }
2796
2797 static void mwifiex_pcie_work(struct work_struct *work)
2798 {
2799         struct pcie_service_card *card =
2800                 container_of(work, struct pcie_service_card, work);
2801
2802         if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2803                                &card->work_flags))
2804                 mwifiex_pcie_device_dump_work(card->adapter);
2805         if (test_and_clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET,
2806                                &card->work_flags))
2807                 mwifiex_pcie_card_reset_work(card->adapter);
2808 }
2809
2810 /* This function dumps FW information */
2811 static void mwifiex_pcie_device_dump(struct mwifiex_adapter *adapter)
2812 {
2813         struct pcie_service_card *card = adapter->card;
2814
2815         if (!test_and_set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2816                               &card->work_flags))
2817                 schedule_work(&card->work);
2818 }
2819
2820 static void mwifiex_pcie_card_reset(struct mwifiex_adapter *adapter)
2821 {
2822         struct pcie_service_card *card = adapter->card;
2823
2824         if (!test_and_set_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags))
2825                 schedule_work(&card->work);
2826 }
2827
2828 static int mwifiex_pcie_alloc_buffers(struct mwifiex_adapter *adapter)
2829 {
2830         struct pcie_service_card *card = adapter->card;
2831         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2832         int ret;
2833
2834         card->cmdrsp_buf = NULL;
2835         ret = mwifiex_pcie_create_txbd_ring(adapter);
2836         if (ret) {
2837                 mwifiex_dbg(adapter, ERROR, "Failed to create txbd ring\n");
2838                 goto err_cre_txbd;
2839         }
2840
2841         ret = mwifiex_pcie_create_rxbd_ring(adapter);
2842         if (ret) {
2843                 mwifiex_dbg(adapter, ERROR, "Failed to create rxbd ring\n");
2844                 goto err_cre_rxbd;
2845         }
2846
2847         ret = mwifiex_pcie_create_evtbd_ring(adapter);
2848         if (ret) {
2849                 mwifiex_dbg(adapter, ERROR, "Failed to create evtbd ring\n");
2850                 goto err_cre_evtbd;
2851         }
2852
2853         ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2854         if (ret) {
2855                 mwifiex_dbg(adapter, ERROR, "Failed to allocate cmdbuf buffer\n");
2856                 goto err_alloc_cmdbuf;
2857         }
2858
2859         if (reg->sleep_cookie) {
2860                 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2861                 if (ret) {
2862                         mwifiex_dbg(adapter, ERROR, "Failed to allocate sleep_cookie buffer\n");
2863                         goto err_alloc_cookie;
2864                 }
2865         } else {
2866                 card->sleep_cookie_vbase = NULL;
2867         }
2868
2869         return 0;
2870
2871 err_alloc_cookie:
2872         mwifiex_pcie_delete_cmdrsp_buf(adapter);
2873 err_alloc_cmdbuf:
2874         mwifiex_pcie_delete_evtbd_ring(adapter);
2875 err_cre_evtbd:
2876         mwifiex_pcie_delete_rxbd_ring(adapter);
2877 err_cre_rxbd:
2878         mwifiex_pcie_delete_txbd_ring(adapter);
2879 err_cre_txbd:
2880         return ret;
2881 }
2882
2883 static void mwifiex_pcie_free_buffers(struct mwifiex_adapter *adapter)
2884 {
2885         struct pcie_service_card *card = adapter->card;
2886         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2887
2888         if (reg->sleep_cookie)
2889                 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2890
2891         mwifiex_pcie_delete_cmdrsp_buf(adapter);
2892         mwifiex_pcie_delete_evtbd_ring(adapter);
2893         mwifiex_pcie_delete_rxbd_ring(adapter);
2894         mwifiex_pcie_delete_txbd_ring(adapter);
2895 }
2896
2897 /*
2898  * This function initializes the PCI-E host memory space, WCB rings, etc.
2899  */
2900 static int mwifiex_init_pcie(struct mwifiex_adapter *adapter)
2901 {
2902         struct pcie_service_card *card = adapter->card;
2903         int ret;
2904         struct pci_dev *pdev = card->dev;
2905
2906         pci_set_drvdata(pdev, card);
2907
2908         ret = pci_enable_device(pdev);
2909         if (ret)
2910                 goto err_enable_dev;
2911
2912         pci_set_master(pdev);
2913
2914         pr_notice("try set_consistent_dma_mask(32)\n");
2915         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2916         if (ret) {
2917                 pr_err("set_dma_mask(32) failed\n");
2918                 goto err_set_dma_mask;
2919         }
2920
2921         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2922         if (ret) {
2923                 pr_err("set_consistent_dma_mask(64) failed\n");
2924                 goto err_set_dma_mask;
2925         }
2926
2927         ret = pci_request_region(pdev, 0, DRV_NAME);
2928         if (ret) {
2929                 pr_err("req_reg(0) error\n");
2930                 goto err_req_region0;
2931         }
2932         card->pci_mmap = pci_iomap(pdev, 0, 0);
2933         if (!card->pci_mmap) {
2934                 pr_err("iomap(0) error\n");
2935                 ret = -EIO;
2936                 goto err_iomap0;
2937         }
2938         ret = pci_request_region(pdev, 2, DRV_NAME);
2939         if (ret) {
2940                 pr_err("req_reg(2) error\n");
2941                 goto err_req_region2;
2942         }
2943         card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2944         if (!card->pci_mmap1) {
2945                 pr_err("iomap(2) error\n");
2946                 ret = -EIO;
2947                 goto err_iomap2;
2948         }
2949
2950         pr_notice("PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2951                   card->pci_mmap, card->pci_mmap1);
2952
2953         ret = mwifiex_pcie_alloc_buffers(adapter);
2954         if (ret)
2955                 goto err_alloc_buffers;
2956
2957         return 0;
2958
2959 err_alloc_buffers:
2960         pci_iounmap(pdev, card->pci_mmap1);
2961 err_iomap2:
2962         pci_release_region(pdev, 2);
2963 err_req_region2:
2964         pci_iounmap(pdev, card->pci_mmap);
2965 err_iomap0:
2966         pci_release_region(pdev, 0);
2967 err_req_region0:
2968 err_set_dma_mask:
2969         pci_disable_device(pdev);
2970 err_enable_dev:
2971         return ret;
2972 }
2973
2974 /*
2975  * This function cleans up the allocated card buffers.
2976  */
2977 static void mwifiex_cleanup_pcie(struct mwifiex_adapter *adapter)
2978 {
2979         struct pcie_service_card *card = adapter->card;
2980         struct pci_dev *pdev = card->dev;
2981         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2982         int ret;
2983         u32 fw_status;
2984
2985         /* Perform the cancel_work_sync() only when we're not resetting
2986          * the card. It's because that function never returns if we're
2987          * in reset path. If we're here when resetting the card, it means
2988          * that we failed to reset the card (reset failure path).
2989          */
2990         if (!card->pci_reset_ongoing) {
2991                 mwifiex_dbg(adapter, MSG, "performing cancel_work_sync()...\n");
2992                 cancel_work_sync(&card->work);
2993                 mwifiex_dbg(adapter, MSG, "cancel_work_sync() done\n");
2994         } else {
2995                 mwifiex_dbg(adapter, MSG,
2996                             "skipped cancel_work_sync() because we're in card reset failure path\n");
2997         }
2998
2999         ret = mwifiex_read_reg(adapter, reg->fw_status, &fw_status);
3000         if (fw_status == FIRMWARE_READY_PCIE) {
3001                 mwifiex_dbg(adapter, INFO,
3002                             "Clearing driver ready signature\n");
3003                 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3004                         mwifiex_dbg(adapter, ERROR,
3005                                     "Failed to write driver not-ready signature\n");
3006         }
3007
3008         pci_disable_device(pdev);
3009
3010         pci_iounmap(pdev, card->pci_mmap);
3011         pci_iounmap(pdev, card->pci_mmap1);
3012         pci_release_region(pdev, 2);
3013         pci_release_region(pdev, 0);
3014
3015         mwifiex_pcie_free_buffers(adapter);
3016 }
3017
3018 static int mwifiex_pcie_request_irq(struct mwifiex_adapter *adapter)
3019 {
3020         int ret, i, j;
3021         struct pcie_service_card *card = adapter->card;
3022         struct pci_dev *pdev = card->dev;
3023
3024         if (card->pcie.reg->msix_support) {
3025                 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3026                         card->msix_entries[i].entry = i;
3027                 ret = pci_enable_msix_exact(pdev, card->msix_entries,
3028                                             MWIFIEX_NUM_MSIX_VECTORS);
3029                 if (!ret) {
3030                         for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++) {
3031                                 card->msix_ctx[i].dev = pdev;
3032                                 card->msix_ctx[i].msg_id = i;
3033
3034                                 ret = request_irq(card->msix_entries[i].vector,
3035                                                   mwifiex_pcie_interrupt, 0,
3036                                                   "MWIFIEX_PCIE_MSIX",
3037                                                   &card->msix_ctx[i]);
3038                                 if (ret)
3039                                         break;
3040                         }
3041
3042                         if (ret) {
3043                                 mwifiex_dbg(adapter, INFO, "request_irq fail: %d\n",
3044                                             ret);
3045                                 for (j = 0; j < i; j++)
3046                                         free_irq(card->msix_entries[j].vector,
3047                                                  &card->msix_ctx[i]);
3048                                 pci_disable_msix(pdev);
3049                         } else {
3050                                 mwifiex_dbg(adapter, MSG, "MSIx enabled!");
3051                                 card->msix_enable = 1;
3052                                 return 0;
3053                         }
3054                 }
3055         }
3056
3057         if (pci_enable_msi(pdev) != 0)
3058                 pci_disable_msi(pdev);
3059         else
3060                 card->msi_enable = 1;
3061
3062         mwifiex_dbg(adapter, INFO, "msi_enable = %d\n", card->msi_enable);
3063
3064         card->share_irq_ctx.dev = pdev;
3065         card->share_irq_ctx.msg_id = -1;
3066         ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
3067                           "MRVL_PCIE", &card->share_irq_ctx);
3068         if (ret) {
3069                 pr_err("request_irq failed: ret=%d\n", ret);
3070                 return -1;
3071         }
3072
3073         return 0;
3074 }
3075
3076 /*
3077  * This function gets the firmware name for downloading by revision id
3078  *
3079  * Read revision id register to get revision id
3080  */
3081 static void mwifiex_pcie_get_fw_name(struct mwifiex_adapter *adapter)
3082 {
3083         int revision_id = 0;
3084         int version, magic;
3085         struct pcie_service_card *card = adapter->card;
3086
3087         switch (card->dev->device) {
3088         case PCIE_DEVICE_ID_MARVELL_88W8766P:
3089                 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
3090                 break;
3091         case PCIE_DEVICE_ID_MARVELL_88W8897:
3092                 mwifiex_write_reg(adapter, 0x0c58, 0x80c00000);
3093                 mwifiex_read_reg(adapter, 0x0c58, &revision_id);
3094                 revision_id &= 0xff00;
3095                 switch (revision_id) {
3096                 case PCIE8897_A0:
3097                         strcpy(adapter->fw_name, PCIE8897_A0_FW_NAME);
3098                         break;
3099                 case PCIE8897_B0:
3100                         strcpy(adapter->fw_name, PCIE8897_B0_FW_NAME);
3101                         break;
3102                 default:
3103                         strcpy(adapter->fw_name, PCIE8897_DEFAULT_FW_NAME);
3104
3105                         break;
3106                 }
3107                 break;
3108         case PCIE_DEVICE_ID_MARVELL_88W8997:
3109                 mwifiex_read_reg(adapter, 0x8, &revision_id);
3110                 mwifiex_read_reg(adapter, 0x0cd0, &version);
3111                 mwifiex_read_reg(adapter, 0x0cd4, &magic);
3112                 revision_id &= 0xff;
3113                 version &= 0x7;
3114                 magic &= 0xff;
3115                 if (revision_id == PCIE8997_A1 &&
3116                     magic == CHIP_MAGIC_VALUE &&
3117                     version == CHIP_VER_PCIEUART)
3118                         strcpy(adapter->fw_name, PCIEUART8997_FW_NAME_V4);
3119                 else
3120                         strcpy(adapter->fw_name, PCIEUSB8997_FW_NAME_V4);
3121                 break;
3122         default:
3123                 break;
3124         }
3125 }
3126
3127 /*
3128  * This function registers the PCIE device.
3129  *
3130  * PCIE IRQ is claimed, block size is set and driver data is initialized.
3131  */
3132 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
3133 {
3134         struct pcie_service_card *card = adapter->card;
3135
3136         /* save adapter pointer in card */
3137         card->adapter = adapter;
3138
3139         if (mwifiex_pcie_request_irq(adapter))
3140                 return -1;
3141
3142         adapter->tx_buf_size = card->pcie.tx_buf_size;
3143         adapter->mem_type_mapping_tbl = card->pcie.mem_type_mapping_tbl;
3144         adapter->num_mem_types = card->pcie.num_mem_types;
3145         adapter->ext_scan = card->pcie.can_ext_scan;
3146         mwifiex_pcie_get_fw_name(adapter);
3147
3148         return 0;
3149 }
3150
3151 /*
3152  * This function unregisters the PCIE device.
3153  *
3154  * The PCIE IRQ is released, the function is disabled and driver
3155  * data is set to null.
3156  */
3157 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
3158 {
3159         struct pcie_service_card *card = adapter->card;
3160         struct pci_dev *pdev = card->dev;
3161         int i;
3162
3163         if (card->msix_enable) {
3164                 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3165                         synchronize_irq(card->msix_entries[i].vector);
3166
3167                 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3168                         free_irq(card->msix_entries[i].vector,
3169                                  &card->msix_ctx[i]);
3170
3171                 card->msix_enable = 0;
3172                 pci_disable_msix(pdev);
3173         } else {
3174                 mwifiex_dbg(adapter, INFO,
3175                             "%s(): calling free_irq()\n", __func__);
3176                free_irq(card->dev->irq, &card->share_irq_ctx);
3177
3178                 if (card->msi_enable)
3179                         pci_disable_msi(pdev);
3180         }
3181         card->adapter = NULL;
3182 }
3183
3184 /*
3185  * This function initializes the PCI-E host memory space, WCB rings, etc.,
3186  * similar to mwifiex_init_pcie(), but without resetting PCI-E state.
3187  */
3188 static void mwifiex_pcie_up_dev(struct mwifiex_adapter *adapter)
3189 {
3190         struct pcie_service_card *card = adapter->card;
3191         struct pci_dev *pdev = card->dev;
3192
3193         /* tx_buf_size might be changed to 3584 by firmware during
3194          * data transfer, we should reset it to default size.
3195          */
3196         adapter->tx_buf_size = card->pcie.tx_buf_size;
3197
3198         mwifiex_pcie_alloc_buffers(adapter);
3199
3200         pci_set_master(pdev);
3201 }
3202
3203 /* This function cleans up the PCI-E host memory space. */
3204 static void mwifiex_pcie_down_dev(struct mwifiex_adapter *adapter)
3205 {
3206         struct pcie_service_card *card = adapter->card;
3207         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
3208         struct pci_dev *pdev = card->dev;
3209
3210         if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3211                 mwifiex_dbg(adapter, ERROR, "Failed to write driver not-ready signature\n");
3212
3213         pci_clear_master(pdev);
3214
3215         adapter->seq_num = 0;
3216
3217         mwifiex_pcie_free_buffers(adapter);
3218 }
3219
3220 static struct mwifiex_if_ops pcie_ops = {
3221         .init_if =                      mwifiex_init_pcie,
3222         .cleanup_if =                   mwifiex_cleanup_pcie,
3223         .check_fw_status =              mwifiex_check_fw_status,
3224         .check_winner_status =          mwifiex_check_winner_status,
3225         .prog_fw =                      mwifiex_prog_fw_w_helper,
3226         .register_dev =                 mwifiex_register_dev,
3227         .unregister_dev =               mwifiex_unregister_dev,
3228         .enable_int =                   mwifiex_pcie_enable_host_int,
3229         .disable_int =                  mwifiex_pcie_disable_host_int_noerr,
3230         .process_int_status =           mwifiex_process_int_status,
3231         .host_to_card =                 mwifiex_pcie_host_to_card,
3232         .wakeup =                       mwifiex_pm_wakeup_card,
3233         .wakeup_complete =              mwifiex_pm_wakeup_card_complete,
3234
3235         /* PCIE specific */
3236         .cmdrsp_complete =              mwifiex_pcie_cmdrsp_complete,
3237         .event_complete =               mwifiex_pcie_event_complete,
3238         .update_mp_end_port =           NULL,
3239         .cleanup_mpa_buf =              NULL,
3240         .init_fw_port =                 mwifiex_pcie_init_fw_port,
3241         .clean_pcie_ring =              mwifiex_clean_pcie_ring_buf,
3242         .card_reset =                   mwifiex_pcie_card_reset,
3243         .reg_dump =                     mwifiex_pcie_reg_dump,
3244         .device_dump =                  mwifiex_pcie_device_dump,
3245         .down_dev =                     mwifiex_pcie_down_dev,
3246         .up_dev =                       mwifiex_pcie_up_dev,
3247 };
3248
3249 module_pci_driver(mwifiex_pcie);
3250
3251 MODULE_AUTHOR("Marvell International Ltd.");
3252 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
3253 MODULE_VERSION(PCIE_VERSION);
3254 MODULE_LICENSE("GPL v2");