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