drivers/net/wireless/mwifiex/pcie.c

   1 /*
   2  * Marvell Wireless LAN device driver: PCIE specific handling
   3  *
   4  * Copyright (C) 2011, 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 u8 user_rmmod;
  35
  36 static struct mwifiex_if_ops pcie_ops;
  37
  38 static struct semaphore add_remove_card_sem;
  39 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter);
  40 static int mwifiex_pcie_resume(struct pci_dev *pdev);
  41
  42 static int
  43 mwifiex_map_pci_memory(struct mwifiex_adapter *adapter, struct sk_buff *skb,
  44                        int size, int flags)
  45 {
  46         struct pcie_service_card *card = adapter->card;
  47         dma_addr_t buf_pa;
  48
  49         buf_pa = pci_map_single(card->dev, skb->data, size, flags);
  50         if (pci_dma_mapping_error(card->dev, buf_pa)) {
  51                 dev_err(adapter->dev, "failed to map pci memory!\n");
  52                 return -1;
  53         }
  54         memcpy(skb->cb, &buf_pa, sizeof(dma_addr_t));
  55         return 0;
  56 }
  57
  58 /*
  59  * This function reads sleep cookie and checks if FW is ready
  60  */
  61 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
  62 {
  63         u32 *cookie_addr;
  64         struct pcie_service_card *card = adapter->card;
  65         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
  66
  67         if (!reg->sleep_cookie)
  68                 return true;
  69
  70         if (card->sleep_cookie_vbase) {
  71                 cookie_addr = (u32 *)card->sleep_cookie_vbase;
  72                 dev_dbg(adapter->dev, "info: ACCESS_HW: sleep cookie=0x%x\n",
  73                         *cookie_addr);
  74                 if (*cookie_addr == FW_AWAKE_COOKIE)
  75                         return true;
  76         }
  77
  78         return false;
  79 }
  80
  81 /*
  82  * This function probes an mwifiex device and registers it. It allocates
  83  * the card structure, enables PCIE function number and initiates the
  84  * device registration and initialization procedure by adding a logical
  85  * interface.
  86  */
  87 static int mwifiex_pcie_probe(struct pci_dev *pdev,
  88                                         const struct pci_device_id *ent)
  89 {
  90         struct pcie_service_card *card;
  91
  92         pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
  93                  pdev->vendor, pdev->device, pdev->revision);
  94
  95         card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
  96         if (!card)
  97                 return -ENOMEM;
  98
  99         card->dev = pdev;
 100
 101         if (ent->driver_data) {
 102                 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
 103                 card->pcie.firmware = data->firmware;
 104                 card->pcie.reg = data->reg;
 105                 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
 106         }
 107
 108         if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
 109                              MWIFIEX_PCIE)) {
 110                 pr_err("%s failed\n", __func__);
 111                 kfree(card);
 112                 return -1;
 113         }
 114
 115         return 0;
 116 }
 117
 118 /*
 119  * This function removes the interface and frees up the card structure.
 120  */
 121 static void mwifiex_pcie_remove(struct pci_dev *pdev)
 122 {
 123         struct pcie_service_card *card;
 124         struct mwifiex_adapter *adapter;
 125         struct mwifiex_private *priv;
 126         int i;
 127
 128         card = pci_get_drvdata(pdev);
 129         if (!card)
 130                 return;
 131
 132         adapter = card->adapter;
 133         if (!adapter || !adapter->priv_num)
 134                 return;
 135
 136         /* In case driver is removed when asynchronous FW load is in progress */
 137         wait_for_completion(&adapter->fw_load);
 138
 139         if (user_rmmod) {
 140 #ifdef CONFIG_PM
 141                 if (adapter->is_suspended)
 142                         mwifiex_pcie_resume(pdev);
 143 #endif
 144
 145                 for (i = 0; i < adapter->priv_num; i++)
 146                         if ((GET_BSS_ROLE(adapter->priv[i]) ==
 147                              MWIFIEX_BSS_ROLE_STA) &&
 148                             adapter->priv[i]->media_connected)
 149                                 mwifiex_deauthenticate(adapter->priv[i], NULL);
 150
 151                 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
 152
 153                 mwifiex_disable_auto_ds(priv);
 154
 155                 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
 156         }
 157
 158         mwifiex_remove_card(card->adapter, &add_remove_card_sem);
 159         kfree(card);
 160 }
 161
 162 /*
 163  * Kernel needs to suspend all functions separately. Therefore all
 164  * registered functions must have drivers with suspend and resume
 165  * methods. Failing that the kernel simply removes the whole card.
 166  *
 167  * If already not suspended, this function allocates and sends a host
 168  * sleep activate request to the firmware and turns off the traffic.
 169  */
 170 static int mwifiex_pcie_suspend(struct pci_dev *pdev, pm_message_t state)
 171 {
 172         struct mwifiex_adapter *adapter;
 173         struct pcie_service_card *card;
 174         int hs_actived;
 175
 176         if (pdev) {
 177                 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
 178                 if (!card || !card->adapter) {
 179                         pr_err("Card or adapter structure is not valid\n");
 180                         return 0;
 181                 }
 182         } else {
 183                 pr_err("PCIE device is not specified\n");
 184                 return 0;
 185         }
 186
 187         adapter = card->adapter;
 188
 189         hs_actived = mwifiex_enable_hs(adapter);
 190
 191         /* Indicate device suspended */
 192         adapter->is_suspended = true;
 193
 194         return 0;
 195 }
 196
 197 /*
 198  * Kernel needs to suspend all functions separately. Therefore all
 199  * registered functions must have drivers with suspend and resume
 200  * methods. Failing that the kernel simply removes the whole card.
 201  *
 202  * If already not resumed, this function turns on the traffic and
 203  * sends a host sleep cancel request to the firmware.
 204  */
 205 static int mwifiex_pcie_resume(struct pci_dev *pdev)
 206 {
 207         struct mwifiex_adapter *adapter;
 208         struct pcie_service_card *card;
 209
 210         if (pdev) {
 211                 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
 212                 if (!card || !card->adapter) {
 213                         pr_err("Card or adapter structure is not valid\n");
 214                         return 0;
 215                 }
 216         } else {
 217                 pr_err("PCIE device is not specified\n");
 218                 return 0;
 219         }
 220
 221         adapter = card->adapter;
 222
 223         if (!adapter->is_suspended) {
 224                 dev_warn(adapter->dev, "Device already resumed\n");
 225                 return 0;
 226         }
 227
 228         adapter->is_suspended = false;
 229
 230         mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
 231                           MWIFIEX_ASYNC_CMD);
 232
 233         return 0;
 234 }
 235
 236 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
 237         {
 238                 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
 239                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 240                 .driver_data = (unsigned long) &mwifiex_pcie8766,
 241         },
 242         {
 243                 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
 244                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 245                 .driver_data = (unsigned long) &mwifiex_pcie8897,
 246         },
 247         {},
 248 };
 249
 250 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
 251
 252 /* PCI Device Driver */
 253 static struct pci_driver __refdata mwifiex_pcie = {
 254         .name     = "mwifiex_pcie",
 255         .id_table = mwifiex_ids,
 256         .probe    = mwifiex_pcie_probe,
 257         .remove   = mwifiex_pcie_remove,
 258 #ifdef CONFIG_PM
 259         /* Power Management Hooks */
 260         .suspend  = mwifiex_pcie_suspend,
 261         .resume   = mwifiex_pcie_resume,
 262 #endif
 263 };
 264
 265 /*
 266  * This function writes data into PCIE card register.
 267  */
 268 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
 269 {
 270         struct pcie_service_card *card = adapter->card;
 271
 272         iowrite32(data, card->pci_mmap1 + reg);
 273
 274         return 0;
 275 }
 276
 277 /*
 278  * This function reads data from PCIE card register.
 279  */
 280 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
 281 {
 282         struct pcie_service_card *card = adapter->card;
 283
 284         *data = ioread32(card->pci_mmap1 + reg);
 285
 286         return 0;
 287 }
 288
 289 /*
 290  * This function wakes up the card.
 291  *
 292  * A host power up command is written to the card configuration
 293  * register to wake up the card.
 294  */
 295 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
 296 {
 297         int i = 0;
 298         struct pcie_service_card *card = adapter->card;
 299         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 300
 301         while (reg->sleep_cookie && mwifiex_pcie_ok_to_access_hw(adapter)) {
 302                 i++;
 303                 usleep_range(10, 20);
 304                 /* 50ms max wait */
 305                 if (i == 5000)
 306                         break;
 307         }
 308
 309         dev_dbg(adapter->dev, "event: Wakeup device...\n");
 310
 311         /* Enable interrupts or any chip access will wakeup device */
 312         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK, HOST_INTR_MASK)) {
 313                 dev_warn(adapter->dev, "Enable host interrupt failed\n");
 314                 return -1;
 315         }
 316
 317         dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
 318         adapter->ps_state = PS_STATE_AWAKE;
 319
 320         return 0;
 321 }
 322
 323 /*
 324  * This function is called after the card has woken up.
 325  *
 326  * The card configuration register is reset.
 327  */
 328 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
 329 {
 330         dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
 331
 332         return 0;
 333 }
 334
 335 /*
 336  * This function disables the host interrupt.
 337  *
 338  * The host interrupt mask is read, the disable bit is reset and
 339  * written back to the card host interrupt mask register.
 340  */
 341 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
 342 {
 343         if (mwifiex_pcie_ok_to_access_hw(adapter)) {
 344                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
 345                                       0x00000000)) {
 346                         dev_warn(adapter->dev, "Disable host interrupt failed\n");
 347                         return -1;
 348                 }
 349         }
 350
 351         return 0;
 352 }
 353
 354 /*
 355  * This function enables the host interrupt.
 356  *
 357  * The host interrupt enable mask is written to the card
 358  * host interrupt mask register.
 359  */
 360 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
 361 {
 362         if (mwifiex_pcie_ok_to_access_hw(adapter)) {
 363                 /* Simply write the mask to the register */
 364                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
 365                                       HOST_INTR_MASK)) {
 366                         dev_warn(adapter->dev, "Enable host interrupt failed\n");
 367                         return -1;
 368                 }
 369         }
 370
 371         return 0;
 372 }
 373
 374 /*
 375  * This function initializes TX buffer ring descriptors
 376  */
 377 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
 378 {
 379         struct pcie_service_card *card = adapter->card;
 380         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 381         struct mwifiex_pcie_buf_desc *desc;
 382         struct mwifiex_pfu_buf_desc *desc2;
 383         int i;
 384
 385         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 386                 card->tx_buf_list[i] = NULL;
 387                 if (reg->pfu_enabled) {
 388                         card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
 389                                              (sizeof(*desc2) * i);
 390                         desc2 = card->txbd_ring[i];
 391                         memset(desc2, 0, sizeof(*desc2));
 392                 } else {
 393                         card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
 394                                              (sizeof(*desc) * i);
 395                         desc = card->txbd_ring[i];
 396                         memset(desc, 0, sizeof(*desc));
 397                 }
 398         }
 399
 400         return 0;
 401 }
 402
 403 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
 404  * here and after mapping PCI memory, its physical address is assigned to
 405  * PCIE Rx buffer descriptor's physical address.
 406  */
 407 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
 408 {
 409         struct pcie_service_card *card = adapter->card;
 410         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 411         struct sk_buff *skb;
 412         struct mwifiex_pcie_buf_desc *desc;
 413         struct mwifiex_pfu_buf_desc *desc2;
 414         dma_addr_t buf_pa;
 415         int i;
 416
 417         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 418                 /* Allocate skb here so that firmware can DMA data from it */
 419                 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
 420                 if (!skb) {
 421                         dev_err(adapter->dev,
 422                                 "Unable to allocate skb for RX ring.\n");
 423                         kfree(card->rxbd_ring_vbase);
 424                         return -ENOMEM;
 425                 }
 426
 427                 if (mwifiex_map_pci_memory(adapter, skb,
 428                                            MWIFIEX_RX_DATA_BUF_SIZE,
 429                                            PCI_DMA_FROMDEVICE))
 430                         return -1;
 431
 432                 MWIFIEX_SKB_PACB(skb, &buf_pa);
 433
 434                 dev_dbg(adapter->dev,
 435                         "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
 436                         skb, skb->len, skb->data, (u32)buf_pa,
 437                         (u32)((u64)buf_pa >> 32));
 438
 439                 card->rx_buf_list[i] = skb;
 440                 if (reg->pfu_enabled) {
 441                         card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
 442                                              (sizeof(*desc2) * i);
 443                         desc2 = card->rxbd_ring[i];
 444                         desc2->paddr = buf_pa;
 445                         desc2->len = (u16)skb->len;
 446                         desc2->frag_len = (u16)skb->len;
 447                         desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
 448                         desc2->offset = 0;
 449                 } else {
 450                         card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
 451                                              (sizeof(*desc) * i));
 452                         desc = card->rxbd_ring[i];
 453                         desc->paddr = buf_pa;
 454                         desc->len = (u16)skb->len;
 455                         desc->flags = 0;
 456                 }
 457         }
 458
 459         return 0;
 460 }
 461
 462 /* This function initializes event buffer ring descriptors. Each SKB is
 463  * allocated here and after mapping PCI memory, its physical address is assigned
 464  * to PCIE Rx buffer descriptor's physical address
 465  */
 466 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
 467 {
 468         struct pcie_service_card *card = adapter->card;
 469         struct mwifiex_evt_buf_desc *desc;
 470         struct sk_buff *skb;
 471         dma_addr_t buf_pa;
 472         int i;
 473
 474         for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
 475                 /* Allocate skb here so that firmware can DMA data from it */
 476                 skb = dev_alloc_skb(MAX_EVENT_SIZE);
 477                 if (!skb) {
 478                         dev_err(adapter->dev,
 479                                 "Unable to allocate skb for EVENT buf.\n");
 480                         kfree(card->evtbd_ring_vbase);
 481                         return -ENOMEM;
 482                 }
 483                 skb_put(skb, MAX_EVENT_SIZE);
 484
 485                 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
 486                                            PCI_DMA_FROMDEVICE))
 487                         return -1;
 488
 489                 MWIFIEX_SKB_PACB(skb, &buf_pa);
 490
 491                 dev_dbg(adapter->dev,
 492                         "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
 493                         skb, skb->len, skb->data, (u32)buf_pa,
 494                         (u32)((u64)buf_pa >> 32));
 495
 496                 card->evt_buf_list[i] = skb;
 497                 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
 498                                       (sizeof(*desc) * i));
 499                 desc = card->evtbd_ring[i];
 500                 desc->paddr = buf_pa;
 501                 desc->len = (u16)skb->len;
 502                 desc->flags = 0;
 503         }
 504
 505         return 0;
 506 }
 507
 508 /* This function cleans up TX buffer rings. If any of the buffer list has valid
 509  * SKB address, associated SKB is freed.
 510  */
 511 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
 512 {
 513         struct pcie_service_card *card = adapter->card;
 514         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 515         struct sk_buff *skb;
 516         struct mwifiex_pcie_buf_desc *desc;
 517         struct mwifiex_pfu_buf_desc *desc2;
 518         int i;
 519
 520         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 521                 if (reg->pfu_enabled) {
 522                         desc2 = card->txbd_ring[i];
 523                         if (card->tx_buf_list[i]) {
 524                                 skb = card->tx_buf_list[i];
 525                                 pci_unmap_single(card->dev, desc2->paddr,
 526                                                  skb->len, PCI_DMA_TODEVICE);
 527                                 dev_kfree_skb_any(skb);
 528                         }
 529                         memset(desc2, 0, sizeof(*desc2));
 530                 } else {
 531                         desc = card->txbd_ring[i];
 532                         if (card->tx_buf_list[i]) {
 533                                 skb = card->tx_buf_list[i];
 534                                 pci_unmap_single(card->dev, desc->paddr,
 535                                                  skb->len, PCI_DMA_TODEVICE);
 536                                 dev_kfree_skb_any(skb);
 537                         }
 538                         memset(desc, 0, sizeof(*desc));
 539                 }
 540                 card->tx_buf_list[i] = NULL;
 541         }
 542
 543         return;
 544 }
 545
 546 /* This function cleans up RX buffer rings. If any of the buffer list has valid
 547  * SKB address, associated SKB is freed.
 548  */
 549 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
 550 {
 551         struct pcie_service_card *card = adapter->card;
 552         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 553         struct mwifiex_pcie_buf_desc *desc;
 554         struct mwifiex_pfu_buf_desc *desc2;
 555         struct sk_buff *skb;
 556         int i;
 557
 558         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 559                 if (reg->pfu_enabled) {
 560                         desc2 = card->rxbd_ring[i];
 561                         if (card->rx_buf_list[i]) {
 562                                 skb = card->rx_buf_list[i];
 563                                 pci_unmap_single(card->dev, desc2->paddr,
 564                                                  skb->len, PCI_DMA_TODEVICE);
 565                                 dev_kfree_skb_any(skb);
 566                         }
 567                         memset(desc2, 0, sizeof(*desc2));
 568                 } else {
 569                         desc = card->rxbd_ring[i];
 570                         if (card->rx_buf_list[i]) {
 571                                 skb = card->rx_buf_list[i];
 572                                 pci_unmap_single(card->dev, desc->paddr,
 573                                                  skb->len, PCI_DMA_TODEVICE);
 574                                 dev_kfree_skb_any(skb);
 575                         }
 576                         memset(desc, 0, sizeof(*desc));
 577                 }
 578                 card->rx_buf_list[i] = NULL;
 579         }
 580
 581         return;
 582 }
 583
 584 /* This function cleans up event buffer rings. If any of the buffer list has
 585  * valid SKB address, associated SKB is freed.
 586  */
 587 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
 588 {
 589         struct pcie_service_card *card = adapter->card;
 590         struct mwifiex_evt_buf_desc *desc;
 591         struct sk_buff *skb;
 592         int i;
 593
 594         for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
 595                 desc = card->evtbd_ring[i];
 596                 if (card->evt_buf_list[i]) {
 597                         skb = card->evt_buf_list[i];
 598                         pci_unmap_single(card->dev, desc->paddr, MAX_EVENT_SIZE,
 599                                          PCI_DMA_FROMDEVICE);
 600                         dev_kfree_skb_any(skb);
 601                 }
 602                 card->evt_buf_list[i] = NULL;
 603                 memset(desc, 0, sizeof(*desc));
 604         }
 605
 606         return;
 607 }
 608
 609 /* This function creates buffer descriptor ring for TX
 610  */
 611 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
 612 {
 613         struct pcie_service_card *card = adapter->card;
 614         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 615
 616         /*
 617          * driver maintaines the write pointer and firmware maintaines the read
 618          * pointer. The write pointer starts at 0 (zero) while the read pointer
 619          * starts at zero with rollover bit set
 620          */
 621         card->txbd_wrptr = 0;
 622
 623         if (reg->pfu_enabled)
 624                 card->txbd_rdptr = 0;
 625         else
 626                 card->txbd_rdptr |= reg->tx_rollover_ind;
 627
 628         /* allocate shared memory for the BD ring and divide the same in to
 629            several descriptors */
 630         if (reg->pfu_enabled)
 631                 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
 632                                        MWIFIEX_MAX_TXRX_BD;
 633         else
 634                 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
 635                                        MWIFIEX_MAX_TXRX_BD;
 636
 637         dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
 638                 card->txbd_ring_size);
 639         card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
 640                                                      card->txbd_ring_size,
 641                                                      &card->txbd_ring_pbase);
 642         if (!card->txbd_ring_vbase) {
 643                 dev_err(adapter->dev,
 644                         "allocate consistent memory (%d bytes) failed!\n",
 645                         card->txbd_ring_size);
 646                 return -ENOMEM;
 647         }
 648         dev_dbg(adapter->dev,
 649                 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
 650                 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
 651                 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
 652
 653         return mwifiex_init_txq_ring(adapter);
 654 }
 655
 656 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
 657 {
 658         struct pcie_service_card *card = adapter->card;
 659         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 660
 661         mwifiex_cleanup_txq_ring(adapter);
 662
 663         if (card->txbd_ring_vbase)
 664                 pci_free_consistent(card->dev, card->txbd_ring_size,
 665                                     card->txbd_ring_vbase,
 666                                     card->txbd_ring_pbase);
 667         card->txbd_ring_size = 0;
 668         card->txbd_wrptr = 0;
 669         card->txbd_rdptr = 0 | reg->tx_rollover_ind;
 670         card->txbd_ring_vbase = NULL;
 671         card->txbd_ring_pbase = 0;
 672
 673         return 0;
 674 }
 675
 676 /*
 677  * This function creates buffer descriptor ring for RX
 678  */
 679 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
 680 {
 681         struct pcie_service_card *card = adapter->card;
 682         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 683
 684         /*
 685          * driver maintaines the read pointer and firmware maintaines the write
 686          * pointer. The write pointer starts at 0 (zero) while the read pointer
 687          * starts at zero with rollover bit set
 688          */
 689         card->rxbd_wrptr = 0;
 690         card->rxbd_rdptr = reg->rx_rollover_ind;
 691
 692         if (reg->pfu_enabled)
 693                 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
 694                                        MWIFIEX_MAX_TXRX_BD;
 695         else
 696                 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
 697                                        MWIFIEX_MAX_TXRX_BD;
 698
 699         dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
 700                 card->rxbd_ring_size);
 701         card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
 702                                                      card->rxbd_ring_size,
 703                                                      &card->rxbd_ring_pbase);
 704         if (!card->rxbd_ring_vbase) {
 705                 dev_err(adapter->dev,
 706                         "allocate consistent memory (%d bytes) failed!\n",
 707                         card->rxbd_ring_size);
 708                 return -ENOMEM;
 709         }
 710
 711         dev_dbg(adapter->dev,
 712                 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
 713                 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
 714                 (u32)((u64)card->rxbd_ring_pbase >> 32),
 715                 card->rxbd_ring_size);
 716
 717         return mwifiex_init_rxq_ring(adapter);
 718 }
 719
 720 /*
 721  * This function deletes Buffer descriptor ring for RX
 722  */
 723 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
 724 {
 725         struct pcie_service_card *card = adapter->card;
 726         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 727
 728         mwifiex_cleanup_rxq_ring(adapter);
 729
 730         if (card->rxbd_ring_vbase)
 731                 pci_free_consistent(card->dev, card->rxbd_ring_size,
 732                                     card->rxbd_ring_vbase,
 733                                     card->rxbd_ring_pbase);
 734         card->rxbd_ring_size = 0;
 735         card->rxbd_wrptr = 0;
 736         card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
 737         card->rxbd_ring_vbase = NULL;
 738         card->rxbd_ring_pbase = 0;
 739
 740         return 0;
 741 }
 742
 743 /*
 744  * This function creates buffer descriptor ring for Events
 745  */
 746 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
 747 {
 748         struct pcie_service_card *card = adapter->card;
 749         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 750
 751         /*
 752          * driver maintaines the read pointer and firmware maintaines the write
 753          * pointer. The write pointer starts at 0 (zero) while the read pointer
 754          * starts at zero with rollover bit set
 755          */
 756         card->evtbd_wrptr = 0;
 757         card->evtbd_rdptr = reg->evt_rollover_ind;
 758
 759         card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
 760                                 MWIFIEX_MAX_EVT_BD;
 761
 762         dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
 763                 card->evtbd_ring_size);
 764         card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
 765                                                       card->evtbd_ring_size,
 766                                                       &card->evtbd_ring_pbase);
 767         if (!card->evtbd_ring_vbase) {
 768                 dev_err(adapter->dev,
 769                         "allocate consistent memory (%d bytes) failed!\n",
 770                         card->evtbd_ring_size);
 771                 return -ENOMEM;
 772         }
 773
 774         dev_dbg(adapter->dev,
 775                 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
 776                 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
 777                 (u32)((u64)card->evtbd_ring_pbase >> 32),
 778                 card->evtbd_ring_size);
 779
 780         return mwifiex_pcie_init_evt_ring(adapter);
 781 }
 782
 783 /*
 784  * This function deletes Buffer descriptor ring for Events
 785  */
 786 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
 787 {
 788         struct pcie_service_card *card = adapter->card;
 789         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 790
 791         mwifiex_cleanup_evt_ring(adapter);
 792
 793         if (card->evtbd_ring_vbase)
 794                 pci_free_consistent(card->dev, card->evtbd_ring_size,
 795                                     card->evtbd_ring_vbase,
 796                                     card->evtbd_ring_pbase);
 797         card->evtbd_wrptr = 0;
 798         card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
 799         card->evtbd_ring_size = 0;
 800         card->evtbd_ring_vbase = NULL;
 801         card->evtbd_ring_pbase = 0;
 802
 803         return 0;
 804 }
 805
 806 /*
 807  * This function allocates a buffer for CMDRSP
 808  */
 809 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
 810 {
 811         struct pcie_service_card *card = adapter->card;
 812         struct sk_buff *skb;
 813
 814         /* Allocate memory for receiving command response data */
 815         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
 816         if (!skb) {
 817                 dev_err(adapter->dev,
 818                         "Unable to allocate skb for command response data.\n");
 819                 return -ENOMEM;
 820         }
 821         skb_put(skb, MWIFIEX_UPLD_SIZE);
 822         if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
 823                                    PCI_DMA_FROMDEVICE))
 824                 return -1;
 825
 826         card->cmdrsp_buf = skb;
 827
 828         return 0;
 829 }
 830
 831 /*
 832  * This function deletes a buffer for CMDRSP
 833  */
 834 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
 835 {
 836         struct pcie_service_card *card;
 837         dma_addr_t buf_pa;
 838
 839         if (!adapter)
 840                 return 0;
 841
 842         card = adapter->card;
 843
 844         if (card && card->cmdrsp_buf) {
 845                 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &buf_pa);
 846                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
 847                                  PCI_DMA_FROMDEVICE);
 848                 dev_kfree_skb_any(card->cmdrsp_buf);
 849         }
 850
 851         if (card && card->cmd_buf) {
 852                 MWIFIEX_SKB_PACB(card->cmd_buf, &buf_pa);
 853                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_SIZE_OF_CMD_BUFFER,
 854                                  PCI_DMA_TODEVICE);
 855                 dev_kfree_skb_any(card->cmd_buf);
 856         }
 857         return 0;
 858 }
 859
 860 /*
 861  * This function allocates a buffer for sleep cookie
 862  */
 863 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
 864 {
 865         struct pcie_service_card *card = adapter->card;
 866
 867         card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
 868                                                      &card->sleep_cookie_pbase);
 869         if (!card->sleep_cookie_vbase) {
 870                 dev_err(adapter->dev, "pci_alloc_consistent failed!\n");
 871                 return -ENOMEM;
 872         }
 873         /* Init val of Sleep Cookie */
 874         *(u32 *)card->sleep_cookie_vbase = FW_AWAKE_COOKIE;
 875
 876         dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
 877                 *((u32 *)card->sleep_cookie_vbase));
 878
 879         return 0;
 880 }
 881
 882 /*
 883  * This function deletes buffer for sleep cookie
 884  */
 885 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
 886 {
 887         struct pcie_service_card *card;
 888
 889         if (!adapter)
 890                 return 0;
 891
 892         card = adapter->card;
 893
 894         if (card && card->sleep_cookie_vbase) {
 895                 pci_free_consistent(card->dev, sizeof(u32),
 896                                     card->sleep_cookie_vbase,
 897                                     card->sleep_cookie_pbase);
 898                 card->sleep_cookie_vbase = NULL;
 899         }
 900
 901         return 0;
 902 }
 903
 904 /* This function flushes the TX buffer descriptor ring
 905  * This function defined as handler is also called while cleaning TXRX
 906  * during disconnect/ bss stop.
 907  */
 908 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
 909 {
 910         struct pcie_service_card *card = adapter->card;
 911
 912         if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
 913                 card->txbd_flush = 1;
 914                 /* write pointer already set at last send
 915                  * send dnld-rdy intr again, wait for completion.
 916                  */
 917                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
 918                                       CPU_INTR_DNLD_RDY)) {
 919                         dev_err(adapter->dev,
 920                                 "failed to assert dnld-rdy interrupt.\n");
 921                         return -1;
 922                 }
 923         }
 924         return 0;
 925 }
 926
 927 /*
 928  * This function unmaps and frees downloaded data buffer
 929  */
 930 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
 931 {
 932         struct sk_buff *skb;
 933         dma_addr_t buf_pa;
 934         u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
 935         struct mwifiex_pcie_buf_desc *desc;
 936         struct mwifiex_pfu_buf_desc *desc2;
 937         struct pcie_service_card *card = adapter->card;
 938         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 939
 940         if (!mwifiex_pcie_ok_to_access_hw(adapter))
 941                 mwifiex_pm_wakeup_card(adapter);
 942
 943         /* Read the TX ring read pointer set by firmware */
 944         if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
 945                 dev_err(adapter->dev,
 946                         "SEND COMP: failed to read reg->tx_rdptr\n");
 947                 return -1;
 948         }
 949
 950         dev_dbg(adapter->dev, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
 951                 card->txbd_rdptr, rdptr);
 952
 953         num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
 954         /* free from previous txbd_rdptr to current txbd_rdptr */
 955         while (((card->txbd_rdptr & reg->tx_mask) !=
 956                 (rdptr & reg->tx_mask)) ||
 957                ((card->txbd_rdptr & reg->tx_rollover_ind) !=
 958                 (rdptr & reg->tx_rollover_ind))) {
 959                 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
 960                             reg->tx_start_ptr;
 961
 962                 skb = card->tx_buf_list[wrdoneidx];
 963                 if (skb) {
 964                         dev_dbg(adapter->dev,
 965                                 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
 966                                 skb, wrdoneidx);
 967                         MWIFIEX_SKB_PACB(skb, &buf_pa);
 968                         pci_unmap_single(card->dev, buf_pa, skb->len,
 969                                          PCI_DMA_TODEVICE);
 970
 971                         unmap_count++;
 972
 973                         if (card->txbd_flush)
 974                                 mwifiex_write_data_complete(adapter, skb, 0,
 975                                                             -1);
 976                         else
 977                                 mwifiex_write_data_complete(adapter, skb, 0, 0);
 978                 }
 979
 980                 card->tx_buf_list[wrdoneidx] = NULL;
 981
 982                 if (reg->pfu_enabled) {
 983                         desc2 = (void *)card->txbd_ring[wrdoneidx];
 984                         memset(desc2, 0, sizeof(*desc2));
 985                 } else {
 986                         desc = card->txbd_ring[wrdoneidx];
 987                         memset(desc, 0, sizeof(*desc));
 988                 }
 989                 switch (card->dev->device) {
 990                 case PCIE_DEVICE_ID_MARVELL_88W8766P:
 991                         card->txbd_rdptr++;
 992                         break;
 993                 case PCIE_DEVICE_ID_MARVELL_88W8897:
 994                         card->txbd_rdptr += reg->ring_tx_start_ptr;
 995                         break;
 996                 }
 997
 998
 999                 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1000                         card->txbd_rdptr = ((card->txbd_rdptr &
1001                                              reg->tx_rollover_ind) ^
1002                                              reg->tx_rollover_ind);
1003         }
1004
1005         if (unmap_count)
1006                 adapter->data_sent = false;
1007
1008         if (card->txbd_flush) {
1009                 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1010                         card->txbd_flush = 0;
1011                 else
1012                         mwifiex_clean_pcie_ring_buf(adapter);
1013         }
1014
1015         return 0;
1016 }
1017
1018 /* This function sends data buffer to device. First 4 bytes of payload
1019  * are filled with payload length and payload type. Then this payload
1020  * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1021  * Download ready interrupt to FW is deffered if Tx ring is not full and
1022  * additional payload can be accomodated.
1023  */
1024 static int
1025 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1026                        struct mwifiex_tx_param *tx_param)
1027 {
1028         struct pcie_service_card *card = adapter->card;
1029         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1030         u32 wrindx, num_tx_buffs, rx_val;
1031         int ret;
1032         dma_addr_t buf_pa;
1033         struct mwifiex_pcie_buf_desc *desc;
1034         struct mwifiex_pfu_buf_desc *desc2;
1035         __le16 *tmp;
1036
1037         if (!(skb->data && skb->len)) {
1038                 dev_err(adapter->dev, "%s(): invalid parameter <%p, %#x>\n",
1039                         __func__, skb->data, skb->len);
1040                 return -1;
1041         }
1042
1043         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1044                 mwifiex_pm_wakeup_card(adapter);
1045
1046         num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1047         dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1048                 card->txbd_rdptr, card->txbd_wrptr);
1049         if (mwifiex_pcie_txbd_not_full(card)) {
1050                 u8 *payload;
1051
1052                 adapter->data_sent = true;
1053                 payload = skb->data;
1054                 tmp = (__le16 *)&payload[0];
1055                 *tmp = cpu_to_le16((u16)skb->len);
1056                 tmp = (__le16 *)&payload[2];
1057                 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
1058
1059                 if (mwifiex_map_pci_memory(adapter, skb, skb->len ,
1060                                            PCI_DMA_TODEVICE))
1061                         return -1;
1062
1063                 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1064                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1065                 card->tx_buf_list[wrindx] = skb;
1066
1067                 if (reg->pfu_enabled) {
1068                         desc2 = (void *)card->txbd_ring[wrindx];
1069                         desc2->paddr = buf_pa;
1070                         desc2->len = (u16)skb->len;
1071                         desc2->frag_len = (u16)skb->len;
1072                         desc2->offset = 0;
1073                         desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1074                                          MWIFIEX_BD_FLAG_LAST_DESC;
1075                 } else {
1076                         desc = card->txbd_ring[wrindx];
1077                         desc->paddr = buf_pa;
1078                         desc->len = (u16)skb->len;
1079                         desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1080                                       MWIFIEX_BD_FLAG_LAST_DESC;
1081                 }
1082
1083                 switch (card->dev->device) {
1084                 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1085                         card->txbd_wrptr++;
1086                         break;
1087                 case PCIE_DEVICE_ID_MARVELL_88W8897:
1088                         card->txbd_wrptr += reg->ring_tx_start_ptr;
1089                         break;
1090                 }
1091
1092                 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1093                         card->txbd_wrptr = ((card->txbd_wrptr &
1094                                                 reg->tx_rollover_ind) ^
1095                                                 reg->tx_rollover_ind);
1096
1097                 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1098                 /* Write the TX ring write pointer in to reg->tx_wrptr */
1099                 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1100                                       card->txbd_wrptr | rx_val)) {
1101                         dev_err(adapter->dev,
1102                                 "SEND DATA: failed to write reg->tx_wrptr\n");
1103                         ret = -1;
1104                         goto done_unmap;
1105                 }
1106                 if ((mwifiex_pcie_txbd_not_full(card)) &&
1107                     tx_param->next_pkt_len) {
1108                         /* have more packets and TxBD still can hold more */
1109                         dev_dbg(adapter->dev,
1110                                 "SEND DATA: delay dnld-rdy interrupt.\n");
1111                         adapter->data_sent = false;
1112                 } else {
1113                         /* Send the TX ready interrupt */
1114                         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1115                                               CPU_INTR_DNLD_RDY)) {
1116                                 dev_err(adapter->dev,
1117                                         "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1118                                 ret = -1;
1119                                 goto done_unmap;
1120                         }
1121                 }
1122                 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1123                         "%#x> and sent packet to firmware successfully\n",
1124                         card->txbd_rdptr, card->txbd_wrptr);
1125         } else {
1126                 dev_dbg(adapter->dev,
1127                         "info: TX Ring full, can't send packets to fw\n");
1128                 adapter->data_sent = true;
1129                 /* Send the TX ready interrupt */
1130                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1131                                       CPU_INTR_DNLD_RDY))
1132                         dev_err(adapter->dev,
1133                                 "SEND DATA: failed to assert door-bell intr\n");
1134                 return -EBUSY;
1135         }
1136
1137         return -EINPROGRESS;
1138 done_unmap:
1139         MWIFIEX_SKB_PACB(skb, &buf_pa);
1140         pci_unmap_single(card->dev, buf_pa, skb->len, PCI_DMA_TODEVICE);
1141         card->tx_buf_list[wrindx] = NULL;
1142         if (reg->pfu_enabled)
1143                 memset(desc2, 0, sizeof(*desc2));
1144         else
1145                 memset(desc, 0, sizeof(*desc));
1146
1147         return ret;
1148 }
1149
1150 /*
1151  * This function handles received buffer ring and
1152  * dispatches packets to upper
1153  */
1154 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1155 {
1156         struct pcie_service_card *card = adapter->card;
1157         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1158         u32 wrptr, rd_index, tx_val;
1159         dma_addr_t buf_pa;
1160         int ret = 0;
1161         struct sk_buff *skb_tmp = NULL;
1162         struct mwifiex_pcie_buf_desc *desc;
1163         struct mwifiex_pfu_buf_desc *desc2;
1164
1165         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1166                 mwifiex_pm_wakeup_card(adapter);
1167
1168         /* Read the RX ring Write pointer set by firmware */
1169         if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1170                 dev_err(adapter->dev,
1171                         "RECV DATA: failed to read reg->rx_wrptr\n");
1172                 ret = -1;
1173                 goto done;
1174         }
1175         card->rxbd_wrptr = wrptr;
1176
1177         while (((wrptr & reg->rx_mask) !=
1178                 (card->rxbd_rdptr & reg->rx_mask)) ||
1179                ((wrptr & reg->rx_rollover_ind) ==
1180                 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1181                 struct sk_buff *skb_data;
1182                 u16 rx_len;
1183                 __le16 pkt_len;
1184
1185                 rd_index = card->rxbd_rdptr & reg->rx_mask;
1186                 skb_data = card->rx_buf_list[rd_index];
1187
1188                 MWIFIEX_SKB_PACB(skb_data, &buf_pa);
1189                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_RX_DATA_BUF_SIZE,
1190                                  PCI_DMA_FROMDEVICE);
1191                 card->rx_buf_list[rd_index] = NULL;
1192
1193                 /* Get data length from interface header -
1194                  * first 2 bytes for len, next 2 bytes is for type
1195                  */
1196                 pkt_len = *((__le16 *)skb_data->data);
1197                 rx_len = le16_to_cpu(pkt_len);
1198                 skb_put(skb_data, rx_len);
1199                 dev_dbg(adapter->dev,
1200                         "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1201                         card->rxbd_rdptr, wrptr, rx_len);
1202                 skb_pull(skb_data, INTF_HEADER_LEN);
1203                 mwifiex_handle_rx_packet(adapter, skb_data);
1204
1205                 skb_tmp = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
1206                 if (!skb_tmp) {
1207                         dev_err(adapter->dev,
1208                                 "Unable to allocate skb.\n");
1209                         return -ENOMEM;
1210                 }
1211
1212                 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1213                                            MWIFIEX_RX_DATA_BUF_SIZE,
1214                                            PCI_DMA_FROMDEVICE))
1215                         return -1;
1216
1217                 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1218
1219                 dev_dbg(adapter->dev,
1220                         "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1221                         skb_tmp, rd_index);
1222                 card->rx_buf_list[rd_index] = skb_tmp;
1223
1224                 if (reg->pfu_enabled) {
1225                         desc2 = (void *)card->rxbd_ring[rd_index];
1226                         desc2->paddr = buf_pa;
1227                         desc2->len = skb_tmp->len;
1228                         desc2->frag_len = skb_tmp->len;
1229                         desc2->offset = 0;
1230                         desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1231                 } else {
1232                         desc = card->rxbd_ring[rd_index];
1233                         desc->paddr = buf_pa;
1234                         desc->len = skb_tmp->len;
1235                         desc->flags = 0;
1236                 }
1237
1238                 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1239                                                         MWIFIEX_MAX_TXRX_BD) {
1240                         card->rxbd_rdptr = ((card->rxbd_rdptr &
1241                                              reg->rx_rollover_ind) ^
1242                                              reg->rx_rollover_ind);
1243                 }
1244                 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1245                         card->rxbd_rdptr, wrptr);
1246
1247                 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1248                 /* Write the RX ring read pointer in to reg->rx_rdptr */
1249                 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1250                                       card->rxbd_rdptr | tx_val)) {
1251                         dev_err(adapter->dev,
1252                                 "RECV DATA: failed to write reg->rx_rdptr\n");
1253                         ret = -1;
1254                         goto done;
1255                 }
1256
1257                 /* Read the RX ring Write pointer set by firmware */
1258                 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1259                         dev_err(adapter->dev,
1260                                 "RECV DATA: failed to read reg->rx_wrptr\n");
1261                         ret = -1;
1262                         goto done;
1263                 }
1264                 dev_dbg(adapter->dev,
1265                         "info: RECV DATA: Rcvd packet from fw successfully\n");
1266                 card->rxbd_wrptr = wrptr;
1267         }
1268
1269 done:
1270         return ret;
1271 }
1272
1273 /*
1274  * This function downloads the boot command to device
1275  */
1276 static int
1277 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1278 {
1279         dma_addr_t buf_pa;
1280         struct pcie_service_card *card = adapter->card;
1281         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1282
1283         if (!(skb->data && skb->len)) {
1284                 dev_err(adapter->dev,
1285                         "Invalid parameter in %s <%p. len %d>\n",
1286                         __func__, skb->data, skb->len);
1287                 return -1;
1288         }
1289
1290         if (mwifiex_map_pci_memory(adapter, skb, skb->len , PCI_DMA_TODEVICE))
1291                 return -1;
1292
1293         MWIFIEX_SKB_PACB(skb, &buf_pa);
1294
1295         /* Write the lower 32bits of the physical address to low command
1296          * address scratch register
1297          */
1298         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1299                 dev_err(adapter->dev,
1300                         "%s: failed to write download command to boot code.\n",
1301                         __func__);
1302                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1303                                  PCI_DMA_TODEVICE);
1304                 return -1;
1305         }
1306
1307         /* Write the upper 32bits of the physical address to high command
1308          * address scratch register
1309          */
1310         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1311                               (u32)((u64)buf_pa >> 32))) {
1312                 dev_err(adapter->dev,
1313                         "%s: failed to write download command to boot code.\n",
1314                         __func__);
1315                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1316                                  PCI_DMA_TODEVICE);
1317                 return -1;
1318         }
1319
1320         /* Write the command length to cmd_size scratch register */
1321         if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1322                 dev_err(adapter->dev,
1323                         "%s: failed to write command len to cmd_size scratch reg\n",
1324                         __func__);
1325                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1326                                  PCI_DMA_TODEVICE);
1327                 return -1;
1328         }
1329
1330         /* Ring the door bell */
1331         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1332                               CPU_INTR_DOOR_BELL)) {
1333                 dev_err(adapter->dev,
1334                         "%s: failed to assert door-bell intr\n", __func__);
1335                 pci_unmap_single(card->dev, buf_pa,
1336                                  MWIFIEX_UPLD_SIZE, PCI_DMA_TODEVICE);
1337                 return -1;
1338         }
1339
1340         return 0;
1341 }
1342
1343 /* This function init rx port in firmware which in turn enables to receive data
1344  * from device before transmitting any packet.
1345  */
1346 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1347 {
1348         struct pcie_service_card *card = adapter->card;
1349         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1350         int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1351
1352         /* Write the RX ring read pointer in to reg->rx_rdptr */
1353         if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1354                               tx_wrap)) {
1355                 dev_err(adapter->dev,
1356                         "RECV DATA: failed to write reg->rx_rdptr\n");
1357                 return -1;
1358         }
1359         return 0;
1360 }
1361
1362 /* This function downloads commands to the device
1363  */
1364 static int
1365 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1366 {
1367         struct pcie_service_card *card = adapter->card;
1368         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1369         int ret = 0;
1370         dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1371         u8 *payload = (u8 *)skb->data;
1372
1373         if (!(skb->data && skb->len)) {
1374                 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
1375                         __func__, skb->data, skb->len);
1376                 return -1;
1377         }
1378
1379         /* Make sure a command response buffer is available */
1380         if (!card->cmdrsp_buf) {
1381                 dev_err(adapter->dev,
1382                         "No response buffer available, send command failed\n");
1383                 return -EBUSY;
1384         }
1385
1386         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1387                 mwifiex_pm_wakeup_card(adapter);
1388
1389         adapter->cmd_sent = true;
1390
1391         *(__le16 *)&payload[0] = cpu_to_le16((u16)skb->len);
1392         *(__le16 *)&payload[2] = cpu_to_le16(MWIFIEX_TYPE_CMD);
1393
1394         if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1395                 return -1;
1396
1397         card->cmd_buf = skb;
1398
1399         /* To send a command, the driver will:
1400                 1. Write the 64bit physical address of the data buffer to
1401                    cmd response address low  + cmd response address high
1402                 2. Ring the door bell (i.e. set the door bell interrupt)
1403
1404                 In response to door bell interrupt, the firmware will perform
1405                 the DMA of the command packet (first header to obtain the total
1406                 length and then rest of the command).
1407         */
1408
1409         if (card->cmdrsp_buf) {
1410                 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &cmdrsp_buf_pa);
1411                 /* Write the lower 32bits of the cmdrsp buffer physical
1412                    address */
1413                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1414                                       (u32)cmdrsp_buf_pa)) {
1415                         dev_err(adapter->dev,
1416                                 "Failed to write download cmd to boot code.\n");
1417                         ret = -1;
1418                         goto done;
1419                 }
1420                 /* Write the upper 32bits of the cmdrsp buffer physical
1421                    address */
1422                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1423                                       (u32)((u64)cmdrsp_buf_pa >> 32))) {
1424                         dev_err(adapter->dev,
1425                                 "Failed to write download cmd to boot code.\n");
1426                         ret = -1;
1427                         goto done;
1428                 }
1429         }
1430
1431         MWIFIEX_SKB_PACB(card->cmd_buf, &cmd_buf_pa);
1432         /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1433         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1434                               (u32)cmd_buf_pa)) {
1435                 dev_err(adapter->dev,
1436                         "Failed to write download cmd to boot code.\n");
1437                 ret = -1;
1438                 goto done;
1439         }
1440         /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1441         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1442                               (u32)((u64)cmd_buf_pa >> 32))) {
1443                 dev_err(adapter->dev,
1444                         "Failed to write download cmd to boot code.\n");
1445                 ret = -1;
1446                 goto done;
1447         }
1448
1449         /* Write the command length to reg->cmd_size */
1450         if (mwifiex_write_reg(adapter, reg->cmd_size,
1451                               card->cmd_buf->len)) {
1452                 dev_err(adapter->dev,
1453                         "Failed to write cmd len to reg->cmd_size\n");
1454                 ret = -1;
1455                 goto done;
1456         }
1457
1458         /* Ring the door bell */
1459         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1460                               CPU_INTR_DOOR_BELL)) {
1461                 dev_err(adapter->dev,
1462                         "Failed to assert door-bell intr\n");
1463                 ret = -1;
1464                 goto done;
1465         }
1466
1467 done:
1468         if (ret)
1469                 adapter->cmd_sent = false;
1470
1471         return 0;
1472 }
1473
1474 /*
1475  * This function handles command complete interrupt
1476  */
1477 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1478 {
1479         struct pcie_service_card *card = adapter->card;
1480         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1481         struct sk_buff *skb = card->cmdrsp_buf;
1482         int count = 0;
1483         u16 rx_len;
1484         __le16 pkt_len;
1485         dma_addr_t buf_pa;
1486
1487         dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1488
1489         MWIFIEX_SKB_PACB(skb, &buf_pa);
1490         pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1491                          PCI_DMA_FROMDEVICE);
1492
1493         pkt_len = *((__le16 *)skb->data);
1494         rx_len = le16_to_cpu(pkt_len);
1495         skb_trim(skb, rx_len);
1496         skb_pull(skb, INTF_HEADER_LEN);
1497
1498         if (!adapter->curr_cmd) {
1499                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1500                         mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1501                                                            skb->len);
1502                         while (reg->sleep_cookie && (count++ < 10) &&
1503                                mwifiex_pcie_ok_to_access_hw(adapter))
1504                                 usleep_range(50, 60);
1505                 } else {
1506                         dev_err(adapter->dev,
1507                                 "There is no command but got cmdrsp\n");
1508                 }
1509                 memcpy(adapter->upld_buf, skb->data,
1510                        min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1511                 skb_push(skb, INTF_HEADER_LEN);
1512                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1513                                            PCI_DMA_FROMDEVICE))
1514                         return -1;
1515
1516                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1517         } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1518                 adapter->curr_cmd->resp_skb = skb;
1519                 adapter->cmd_resp_received = true;
1520                 /* Take the pointer and set it to CMD node and will
1521                    return in the response complete callback */
1522                 card->cmdrsp_buf = NULL;
1523
1524                 /* Clear the cmd-rsp buffer address in scratch registers. This
1525                    will prevent firmware from writing to the same response
1526                    buffer again. */
1527                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1528                         dev_err(adapter->dev,
1529                                 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1530                         return -1;
1531                 }
1532                 /* Write the upper 32bits of the cmdrsp buffer physical
1533                    address */
1534                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1535                         dev_err(adapter->dev,
1536                                 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1537                         return -1;
1538                 }
1539         }
1540
1541         return 0;
1542 }
1543
1544 /*
1545  * Command Response processing complete handler
1546  */
1547 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1548                                         struct sk_buff *skb)
1549 {
1550         struct pcie_service_card *card = adapter->card;
1551         dma_addr_t buf_pa;
1552         struct sk_buff *skb_tmp;
1553
1554         if (skb) {
1555                 card->cmdrsp_buf = skb;
1556                 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1557                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1558                                            PCI_DMA_FROMDEVICE))
1559                         return -1;
1560         }
1561
1562         skb_tmp = card->cmd_buf;
1563         if (skb_tmp) {
1564                 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1565                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1566                                  PCI_DMA_FROMDEVICE);
1567                 card->cmd_buf = NULL;
1568         }
1569
1570         return 0;
1571 }
1572
1573 /*
1574  * This function handles firmware event ready interrupt
1575  */
1576 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1577 {
1578         struct pcie_service_card *card = adapter->card;
1579         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1580         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1581         u32 wrptr, event;
1582         dma_addr_t buf_pa;
1583         struct mwifiex_evt_buf_desc *desc;
1584
1585         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1586                 mwifiex_pm_wakeup_card(adapter);
1587
1588         if (adapter->event_received) {
1589                 dev_dbg(adapter->dev, "info: Event being processed, "
1590                         "do not process this interrupt just yet\n");
1591                 return 0;
1592         }
1593
1594         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1595                 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1596                 return -1;
1597         }
1598
1599         /* Read the event ring write pointer set by firmware */
1600         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1601                 dev_err(adapter->dev,
1602                         "EventReady: failed to read reg->evt_wrptr\n");
1603                 return -1;
1604         }
1605
1606         dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1607                 card->evtbd_rdptr, wrptr);
1608         if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1609                                               & MWIFIEX_EVTBD_MASK)) ||
1610             ((wrptr & reg->evt_rollover_ind) ==
1611              (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1612                 struct sk_buff *skb_cmd;
1613                 __le16 data_len = 0;
1614                 u16 evt_len;
1615
1616                 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1617                 skb_cmd = card->evt_buf_list[rdptr];
1618                 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1619                 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1620                                  PCI_DMA_FROMDEVICE);
1621
1622                 /* Take the pointer and set it to event pointer in adapter
1623                    and will return back after event handling callback */
1624                 card->evt_buf_list[rdptr] = NULL;
1625                 desc = card->evtbd_ring[rdptr];
1626                 memset(desc, 0, sizeof(*desc));
1627
1628                 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1629                 adapter->event_cause = event;
1630                 /* The first 4bytes will be the event transfer header
1631                    len is 2 bytes followed by type which is 2 bytes */
1632                 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1633                 evt_len = le16_to_cpu(data_len);
1634
1635                 skb_pull(skb_cmd, INTF_HEADER_LEN);
1636                 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1637
1638                 if ((evt_len > 0) && (evt_len  < MAX_EVENT_SIZE))
1639                         memcpy(adapter->event_body, skb_cmd->data +
1640                                MWIFIEX_EVENT_HEADER_LEN, evt_len -
1641                                MWIFIEX_EVENT_HEADER_LEN);
1642
1643                 adapter->event_received = true;
1644                 adapter->event_skb = skb_cmd;
1645
1646                 /* Do not update the event read pointer here, wait till the
1647                    buffer is released. This is just to make things simpler,
1648                    we need to find a better method of managing these buffers.
1649                 */
1650         }
1651
1652         return 0;
1653 }
1654
1655 /*
1656  * Event processing complete handler
1657  */
1658 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1659                                        struct sk_buff *skb)
1660 {
1661         struct pcie_service_card *card = adapter->card;
1662         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1663         int ret = 0;
1664         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1665         u32 wrptr;
1666         dma_addr_t buf_pa;
1667         struct mwifiex_evt_buf_desc *desc;
1668
1669         if (!skb)
1670                 return 0;
1671
1672         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1673                 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1674                         rdptr);
1675                 return -EINVAL;
1676         }
1677
1678         /* Read the event ring write pointer set by firmware */
1679         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1680                 dev_err(adapter->dev,
1681                         "event_complete: failed to read reg->evt_wrptr\n");
1682                 return -1;
1683         }
1684
1685         if (!card->evt_buf_list[rdptr]) {
1686                 skb_push(skb, INTF_HEADER_LEN);
1687                 if (mwifiex_map_pci_memory(adapter, skb,
1688                                            MAX_EVENT_SIZE,
1689                                            PCI_DMA_FROMDEVICE))
1690                         return -1;
1691                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1692                 card->evt_buf_list[rdptr] = skb;
1693                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1694                 desc = card->evtbd_ring[rdptr];
1695                 desc->paddr = buf_pa;
1696                 desc->len = (u16)skb->len;
1697                 desc->flags = 0;
1698                 skb = NULL;
1699         } else {
1700                 dev_dbg(adapter->dev,
1701                         "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1702                         rdptr, card->evt_buf_list[rdptr], skb);
1703         }
1704
1705         if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1706                 card->evtbd_rdptr = ((card->evtbd_rdptr &
1707                                         reg->evt_rollover_ind) ^
1708                                         reg->evt_rollover_ind);
1709         }
1710
1711         dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1712                 card->evtbd_rdptr, wrptr);
1713
1714         /* Write the event ring read pointer in to reg->evt_rdptr */
1715         if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1716                               card->evtbd_rdptr)) {
1717                 dev_err(adapter->dev,
1718                         "event_complete: failed to read reg->evt_rdptr\n");
1719                 return -1;
1720         }
1721
1722         dev_dbg(adapter->dev, "info: Check Events Again\n");
1723         ret = mwifiex_pcie_process_event_ready(adapter);
1724
1725         return ret;
1726 }
1727
1728 /*
1729  * This function downloads the firmware to the card.
1730  *
1731  * Firmware is downloaded to the card in blocks. Every block download
1732  * is tested for CRC errors, and retried a number of times before
1733  * returning failure.
1734  */
1735 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1736                                     struct mwifiex_fw_image *fw)
1737 {
1738         int ret;
1739         u8 *firmware = fw->fw_buf;
1740         u32 firmware_len = fw->fw_len;
1741         u32 offset = 0;
1742         struct sk_buff *skb;
1743         u32 txlen, tx_blocks = 0, tries, len;
1744         u32 block_retry_cnt = 0;
1745         dma_addr_t buf_pa;
1746         struct pcie_service_card *card = adapter->card;
1747         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1748
1749         if (!firmware || !firmware_len) {
1750                 dev_err(adapter->dev,
1751                         "No firmware image found! Terminating download\n");
1752                 return -1;
1753         }
1754
1755         dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1756                 firmware_len);
1757
1758         if (mwifiex_pcie_disable_host_int(adapter)) {
1759                 dev_err(adapter->dev,
1760                         "%s: Disabling interrupts failed.\n", __func__);
1761                 return -1;
1762         }
1763
1764         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1765         if (!skb) {
1766                 ret = -ENOMEM;
1767                 goto done;
1768         }
1769
1770         /* Perform firmware data transfer */
1771         do {
1772                 u32 ireg_intr = 0;
1773
1774                 /* More data? */
1775                 if (offset >= firmware_len)
1776                         break;
1777
1778                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1779                         ret = mwifiex_read_reg(adapter, reg->cmd_size,
1780                                                &len);
1781                         if (ret) {
1782                                 dev_warn(adapter->dev,
1783                                          "Failed reading len from boot code\n");
1784                                 goto done;
1785                         }
1786                         if (len)
1787                                 break;
1788                         usleep_range(10, 20);
1789                 }
1790
1791                 if (!len) {
1792                         break;
1793                 } else if (len > MWIFIEX_UPLD_SIZE) {
1794                         pr_err("FW download failure @ %d, invalid length %d\n",
1795                                offset, len);
1796                         ret = -1;
1797                         goto done;
1798                 }
1799
1800                 txlen = len;
1801
1802                 if (len & BIT(0)) {
1803                         block_retry_cnt++;
1804                         if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1805                                 pr_err("FW download failure @ %d, over max "
1806                                        "retry count\n", offset);
1807                                 ret = -1;
1808                                 goto done;
1809                         }
1810                         dev_err(adapter->dev, "FW CRC error indicated by the "
1811                                 "helper: len = 0x%04X, txlen = %d\n",
1812                                 len, txlen);
1813                         len &= ~BIT(0);
1814                         /* Setting this to 0 to resend from same offset */
1815                         txlen = 0;
1816                 } else {
1817                         block_retry_cnt = 0;
1818                         /* Set blocksize to transfer - checking for
1819                            last block */
1820                         if (firmware_len - offset < txlen)
1821                                 txlen = firmware_len - offset;
1822
1823                         dev_dbg(adapter->dev, ".");
1824
1825                         tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1826                                     card->pcie.blksz_fw_dl;
1827
1828                         /* Copy payload to buffer */
1829                         memmove(skb->data, &firmware[offset], txlen);
1830                 }
1831
1832                 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1833                 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1834
1835                 /* Send the boot command to device */
1836                 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1837                         dev_err(adapter->dev,
1838                                 "Failed to send firmware download command\n");
1839                         ret = -1;
1840                         goto done;
1841                 }
1842
1843                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1844
1845                 /* Wait for the command done interrupt */
1846                 do {
1847                         if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1848                                              &ireg_intr)) {
1849                                 dev_err(adapter->dev, "%s: Failed to read "
1850                                         "interrupt status during fw dnld.\n",
1851                                         __func__);
1852                                 pci_unmap_single(card->dev, buf_pa, skb->len,
1853                                                  PCI_DMA_TODEVICE);
1854                                 ret = -1;
1855                                 goto done;
1856                         }
1857                 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1858                          CPU_INTR_DOOR_BELL);
1859
1860                 pci_unmap_single(card->dev, buf_pa, skb->len,
1861                                  PCI_DMA_TODEVICE);
1862
1863                 offset += txlen;
1864         } while (true);
1865
1866         dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1867                 offset);
1868
1869         ret = 0;
1870
1871 done:
1872         dev_kfree_skb_any(skb);
1873         return ret;
1874 }
1875
1876 /*
1877  * This function checks the firmware status in card.
1878  *
1879  * The winner interface is also determined by this function.
1880  */
1881 static int
1882 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1883 {
1884         int ret = 0;
1885         u32 firmware_stat, winner_status;
1886         struct pcie_service_card *card = adapter->card;
1887         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1888         u32 tries;
1889
1890         /* Mask spurios interrupts */
1891         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1892                               HOST_INTR_MASK)) {
1893                 dev_warn(adapter->dev, "Write register failed\n");
1894                 return -1;
1895         }
1896
1897         dev_dbg(adapter->dev, "Setting driver ready signature\n");
1898         if (mwifiex_write_reg(adapter, reg->drv_rdy,
1899                               FIRMWARE_READY_PCIE)) {
1900                 dev_err(adapter->dev,
1901                         "Failed to write driver ready signature\n");
1902                 return -1;
1903         }
1904
1905         /* Wait for firmware initialization event */
1906         for (tries = 0; tries < poll_num; tries++) {
1907                 if (mwifiex_read_reg(adapter, reg->fw_status,
1908                                      &firmware_stat))
1909                         ret = -1;
1910                 else
1911                         ret = 0;
1912                 if (ret)
1913                         continue;
1914                 if (firmware_stat == FIRMWARE_READY_PCIE) {
1915                         ret = 0;
1916                         break;
1917                 } else {
1918                         mdelay(100);
1919                         ret = -1;
1920                 }
1921         }
1922
1923         if (ret) {
1924                 if (mwifiex_read_reg(adapter, reg->fw_status,
1925                                      &winner_status))
1926                         ret = -1;
1927                 else if (!winner_status) {
1928                         dev_err(adapter->dev, "PCI-E is the winner\n");
1929                         adapter->winner = 1;
1930                         ret = -1;
1931                 } else {
1932                         dev_err(adapter->dev,
1933                                 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1934                                 ret, adapter->winner);
1935                         ret = 0;
1936                 }
1937         }
1938
1939         return ret;
1940 }
1941
1942 /*
1943  * This function reads the interrupt status from card.
1944  */
1945 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1946 {
1947         u32 pcie_ireg;
1948         unsigned long flags;
1949
1950         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1951                 return;
1952
1953         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1954                 dev_warn(adapter->dev, "Read register failed\n");
1955                 return;
1956         }
1957
1958         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1959
1960                 mwifiex_pcie_disable_host_int(adapter);
1961
1962                 /* Clear the pending interrupts */
1963                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1964                                       ~pcie_ireg)) {
1965                         dev_warn(adapter->dev, "Write register failed\n");
1966                         return;
1967                 }
1968                 spin_lock_irqsave(&adapter->int_lock, flags);
1969                 adapter->int_status |= pcie_ireg;
1970                 spin_unlock_irqrestore(&adapter->int_lock, flags);
1971
1972                 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1973                         if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1974                             (adapter->ps_state == PS_STATE_SLEEP)) {
1975                                 mwifiex_pcie_enable_host_int(adapter);
1976                                 if (mwifiex_write_reg(adapter,
1977                                                       PCIE_CPU_INT_EVENT,
1978                                                       CPU_INTR_SLEEP_CFM_DONE)
1979                                                       ) {
1980                                         dev_warn(adapter->dev,
1981                                                  "Write register failed\n");
1982                                         return;
1983
1984                                 }
1985                         }
1986                 } else if (!adapter->pps_uapsd_mode &&
1987                            adapter->ps_state == PS_STATE_SLEEP) {
1988                                 /* Potentially for PCIe we could get other
1989                                  * interrupts like shared. Don't change power
1990                                  * state until cookie is set */
1991                                 if (mwifiex_pcie_ok_to_access_hw(adapter))
1992                                         adapter->ps_state = PS_STATE_AWAKE;
1993                 }
1994         }
1995 }
1996
1997 /*
1998  * Interrupt handler for PCIe root port
1999  *
2000  * This function reads the interrupt status from firmware and assigns
2001  * the main process in workqueue which will handle the interrupt.
2002  */
2003 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2004 {
2005         struct pci_dev *pdev = (struct pci_dev *)context;
2006         struct pcie_service_card *card;
2007         struct mwifiex_adapter *adapter;
2008
2009         if (!pdev) {
2010                 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2011                 goto exit;
2012         }
2013
2014         card = (struct pcie_service_card *) pci_get_drvdata(pdev);
2015         if (!card || !card->adapter) {
2016                 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2017                          card ? card->adapter : NULL);
2018                 goto exit;
2019         }
2020         adapter = card->adapter;
2021
2022         if (adapter->surprise_removed)
2023                 goto exit;
2024
2025         mwifiex_interrupt_status(adapter);
2026         queue_work(adapter->workqueue, &adapter->main_work);
2027
2028 exit:
2029         return IRQ_HANDLED;
2030 }
2031
2032 /*
2033  * This function checks the current interrupt status.
2034  *
2035  * The following interrupts are checked and handled by this function -
2036  *      - Data sent
2037  *      - Command sent
2038  *      - Command received
2039  *      - Packets received
2040  *      - Events received
2041  *
2042  * In case of Rx packets received, the packets are uploaded from card to
2043  * host and processed accordingly.
2044  */
2045 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2046 {
2047         int ret;
2048         u32 pcie_ireg;
2049         unsigned long flags;
2050
2051         spin_lock_irqsave(&adapter->int_lock, flags);
2052         /* Clear out unused interrupts */
2053         pcie_ireg = adapter->int_status;
2054         adapter->int_status = 0;
2055         spin_unlock_irqrestore(&adapter->int_lock, flags);
2056
2057         while (pcie_ireg & HOST_INTR_MASK) {
2058                 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2059                         pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2060                         dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2061                         ret = mwifiex_pcie_send_data_complete(adapter);
2062                         if (ret)
2063                                 return ret;
2064                 }
2065                 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2066                         pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2067                         dev_dbg(adapter->dev, "info: Rx DATA\n");
2068                         ret = mwifiex_pcie_process_recv_data(adapter);
2069                         if (ret)
2070                                 return ret;
2071                 }
2072                 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2073                         pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2074                         dev_dbg(adapter->dev, "info: Rx EVENT\n");
2075                         ret = mwifiex_pcie_process_event_ready(adapter);
2076                         if (ret)
2077                                 return ret;
2078                 }
2079
2080                 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2081                         pcie_ireg &= ~HOST_INTR_CMD_DONE;
2082                         if (adapter->cmd_sent) {
2083                                 dev_dbg(adapter->dev,
2084                                         "info: CMD sent Interrupt\n");
2085                                 adapter->cmd_sent = false;
2086                         }
2087                         /* Handle command response */
2088                         ret = mwifiex_pcie_process_cmd_complete(adapter);
2089                         if (ret)
2090                                 return ret;
2091                 }
2092
2093                 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2094                         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2095                                              &pcie_ireg)) {
2096                                 dev_warn(adapter->dev,
2097                                          "Read register failed\n");
2098                                 return -1;
2099                         }
2100
2101                         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2102                                 if (mwifiex_write_reg(adapter,
2103                                                       PCIE_HOST_INT_STATUS,
2104                                                       ~pcie_ireg)) {
2105                                         dev_warn(adapter->dev,
2106                                                  "Write register failed\n");
2107                                         return -1;
2108                                 }
2109                         }
2110
2111                 }
2112         }
2113         dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2114                 adapter->cmd_sent, adapter->data_sent);
2115         mwifiex_pcie_enable_host_int(adapter);
2116
2117         return 0;
2118 }
2119
2120 /*
2121  * This function downloads data from driver to card.
2122  *
2123  * Both commands and data packets are transferred to the card by this
2124  * function.
2125  *
2126  * This function adds the PCIE specific header to the front of the buffer
2127  * before transferring. The header contains the length of the packet and
2128  * the type. The firmware handles the packets based upon this set type.
2129  */
2130 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2131                                      struct sk_buff *skb,
2132                                      struct mwifiex_tx_param *tx_param)
2133 {
2134         if (!skb) {
2135                 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2136                 return -1;
2137         }
2138
2139         if (type == MWIFIEX_TYPE_DATA)
2140                 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2141         else if (type == MWIFIEX_TYPE_CMD)
2142                 return mwifiex_pcie_send_cmd(adapter, skb);
2143
2144         return 0;
2145 }
2146
2147 /*
2148  * This function initializes the PCI-E host memory space, WCB rings, etc.
2149  *
2150  * The following initializations steps are followed -
2151  *      - Allocate TXBD ring buffers
2152  *      - Allocate RXBD ring buffers
2153  *      - Allocate event BD ring buffers
2154  *      - Allocate command response ring buffer
2155  *      - Allocate sleep cookie buffer
2156  */
2157 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2158 {
2159         struct pcie_service_card *card = adapter->card;
2160         int ret;
2161         struct pci_dev *pdev = card->dev;
2162         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2163
2164         pci_set_drvdata(pdev, card);
2165
2166         ret = pci_enable_device(pdev);
2167         if (ret)
2168                 goto err_enable_dev;
2169
2170         pci_set_master(pdev);
2171
2172         dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2173         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2174         if (ret) {
2175                 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2176                 goto err_set_dma_mask;
2177         }
2178
2179         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2180         if (ret) {
2181                 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2182                 goto err_set_dma_mask;
2183         }
2184
2185         ret = pci_request_region(pdev, 0, DRV_NAME);
2186         if (ret) {
2187                 dev_err(adapter->dev, "req_reg(0) error\n");
2188                 goto err_req_region0;
2189         }
2190         card->pci_mmap = pci_iomap(pdev, 0, 0);
2191         if (!card->pci_mmap) {
2192                 dev_err(adapter->dev, "iomap(0) error\n");
2193                 ret = -EIO;
2194                 goto err_iomap0;
2195         }
2196         ret = pci_request_region(pdev, 2, DRV_NAME);
2197         if (ret) {
2198                 dev_err(adapter->dev, "req_reg(2) error\n");
2199                 goto err_req_region2;
2200         }
2201         card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2202         if (!card->pci_mmap1) {
2203                 dev_err(adapter->dev, "iomap(2) error\n");
2204                 ret = -EIO;
2205                 goto err_iomap2;
2206         }
2207
2208         dev_dbg(adapter->dev,
2209                 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2210                 card->pci_mmap, card->pci_mmap1);
2211
2212         card->cmdrsp_buf = NULL;
2213         ret = mwifiex_pcie_create_txbd_ring(adapter);
2214         if (ret)
2215                 goto err_cre_txbd;
2216         ret = mwifiex_pcie_create_rxbd_ring(adapter);
2217         if (ret)
2218                 goto err_cre_rxbd;
2219         ret = mwifiex_pcie_create_evtbd_ring(adapter);
2220         if (ret)
2221                 goto err_cre_evtbd;
2222         ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2223         if (ret)
2224                 goto err_alloc_cmdbuf;
2225         if (reg->sleep_cookie) {
2226                 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2227                 if (ret)
2228                         goto err_alloc_cookie;
2229         } else {
2230                 card->sleep_cookie_vbase = NULL;
2231         }
2232         return ret;
2233
2234 err_alloc_cookie:
2235         mwifiex_pcie_delete_cmdrsp_buf(adapter);
2236 err_alloc_cmdbuf:
2237         mwifiex_pcie_delete_evtbd_ring(adapter);
2238 err_cre_evtbd:
2239         mwifiex_pcie_delete_rxbd_ring(adapter);
2240 err_cre_rxbd:
2241         mwifiex_pcie_delete_txbd_ring(adapter);
2242 err_cre_txbd:
2243         pci_iounmap(pdev, card->pci_mmap1);
2244 err_iomap2:
2245         pci_release_region(pdev, 2);
2246 err_req_region2:
2247         pci_iounmap(pdev, card->pci_mmap);
2248 err_iomap0:
2249         pci_release_region(pdev, 0);
2250 err_req_region0:
2251 err_set_dma_mask:
2252         pci_disable_device(pdev);
2253 err_enable_dev:
2254         pci_set_drvdata(pdev, NULL);
2255         return ret;
2256 }
2257
2258 /*
2259  * This function cleans up the allocated card buffers.
2260  *
2261  * The following are freed by this function -
2262  *      - TXBD ring buffers
2263  *      - RXBD ring buffers
2264  *      - Event BD ring buffers
2265  *      - Command response ring buffer
2266  *      - Sleep cookie buffer
2267  */
2268 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2269 {
2270         struct pcie_service_card *card = adapter->card;
2271         struct pci_dev *pdev = card->dev;
2272         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2273
2274         if (user_rmmod) {
2275                 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2276                 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2277                         dev_err(adapter->dev,
2278                                 "Failed to write driver not-ready signature\n");
2279         }
2280
2281         if (pdev) {
2282                 pci_iounmap(pdev, card->pci_mmap);
2283                 pci_iounmap(pdev, card->pci_mmap1);
2284
2285                 pci_release_regions(pdev);
2286                 pci_disable_device(pdev);
2287                 pci_set_drvdata(pdev, NULL);
2288         }
2289 }
2290
2291 /*
2292  * This function registers the PCIE device.
2293  *
2294  * PCIE IRQ is claimed, block size is set and driver data is initialized.
2295  */
2296 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2297 {
2298         int ret;
2299         struct pcie_service_card *card = adapter->card;
2300         struct pci_dev *pdev = card->dev;
2301
2302         /* save adapter pointer in card */
2303         card->adapter = adapter;
2304
2305         ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2306                           "MRVL_PCIE", pdev);
2307         if (ret) {
2308                 pr_err("request_irq failed: ret=%d\n", ret);
2309                 adapter->card = NULL;
2310                 return -1;
2311         }
2312
2313         adapter->dev = &pdev->dev;
2314         strcpy(adapter->fw_name, card->pcie.firmware);
2315
2316         return 0;
2317 }
2318
2319 /*
2320  * This function unregisters the PCIE device.
2321  *
2322  * The PCIE IRQ is released, the function is disabled and driver
2323  * data is set to null.
2324  */
2325 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2326 {
2327         struct pcie_service_card *card = adapter->card;
2328         const struct mwifiex_pcie_card_reg *reg;
2329
2330         if (card) {
2331                 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2332                 free_irq(card->dev->irq, card->dev);
2333
2334                 reg = card->pcie.reg;
2335                 if (reg->sleep_cookie)
2336                         mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2337
2338                 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2339                 mwifiex_pcie_delete_evtbd_ring(adapter);
2340                 mwifiex_pcie_delete_rxbd_ring(adapter);
2341                 mwifiex_pcie_delete_txbd_ring(adapter);
2342                 card->cmdrsp_buf = NULL;
2343         }
2344 }
2345
2346 static struct mwifiex_if_ops pcie_ops = {
2347         .init_if =                      mwifiex_pcie_init,
2348         .cleanup_if =                   mwifiex_pcie_cleanup,
2349         .check_fw_status =              mwifiex_check_fw_status,
2350         .prog_fw =                      mwifiex_prog_fw_w_helper,
2351         .register_dev =                 mwifiex_register_dev,
2352         .unregister_dev =               mwifiex_unregister_dev,
2353         .enable_int =                   mwifiex_pcie_enable_host_int,
2354         .process_int_status =           mwifiex_process_int_status,
2355         .host_to_card =                 mwifiex_pcie_host_to_card,
2356         .wakeup =                       mwifiex_pm_wakeup_card,
2357         .wakeup_complete =              mwifiex_pm_wakeup_card_complete,
2358
2359         /* PCIE specific */
2360         .cmdrsp_complete =              mwifiex_pcie_cmdrsp_complete,
2361         .event_complete =               mwifiex_pcie_event_complete,
2362         .update_mp_end_port =           NULL,
2363         .cleanup_mpa_buf =              NULL,
2364         .init_fw_port =                 mwifiex_pcie_init_fw_port,
2365         .clean_pcie_ring =              mwifiex_clean_pcie_ring_buf,
2366 };
2367
2368 /*
2369  * This function initializes the PCIE driver module.
2370  *
2371  * This initiates the semaphore and registers the device with
2372  * PCIE bus.
2373  */
2374 static int mwifiex_pcie_init_module(void)
2375 {
2376         int ret;
2377
2378         pr_debug("Marvell PCIe Driver\n");
2379
2380         sema_init(&add_remove_card_sem, 1);
2381
2382         /* Clear the flag in case user removes the card. */
2383         user_rmmod = 0;
2384
2385         ret = pci_register_driver(&mwifiex_pcie);
2386         if (ret)
2387                 pr_err("Driver register failed!\n");
2388         else
2389                 pr_debug("info: Driver registered successfully!\n");
2390
2391         return ret;
2392 }
2393
2394 /*
2395  * This function cleans up the PCIE driver.
2396  *
2397  * The following major steps are followed for cleanup -
2398  *      - Resume the device if its suspended
2399  *      - Disconnect the device if connected
2400  *      - Shutdown the firmware
2401  *      - Unregister the device from PCIE bus.
2402  */
2403 static void mwifiex_pcie_cleanup_module(void)
2404 {
2405         if (!down_interruptible(&add_remove_card_sem))
2406                 up(&add_remove_card_sem);
2407
2408         /* Set the flag as user is removing this module. */
2409         user_rmmod = 1;
2410
2411         pci_unregister_driver(&mwifiex_pcie);
2412 }
2413
2414 module_init(mwifiex_pcie_init_module);
2415 module_exit(mwifiex_pcie_cleanup_module);
2416
2417 MODULE_AUTHOR("Marvell International Ltd.");
2418 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2419 MODULE_VERSION(PCIE_VERSION);
2420 MODULE_LICENSE("GPL v2");
2421 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2422 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);