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