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                         while (reg->sleep_cookie && (count++ < 10) &&
1535                                mwifiex_pcie_ok_to_access_hw(adapter))
1536                                 usleep_range(50, 60);
1537                 } else {
1538                         dev_err(adapter->dev,
1539                                 "There is no command but got cmdrsp\n");
1540                 }
1541                 memcpy(adapter->upld_buf, skb->data,
1542                        min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1543                 skb_push(skb, INTF_HEADER_LEN);
1544                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1545                                            PCI_DMA_FROMDEVICE))
1546                         return -1;
1547
1548                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1549         } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1550                 adapter->curr_cmd->resp_skb = skb;
1551                 adapter->cmd_resp_received = true;
1552                 /* Take the pointer and set it to CMD node and will
1553                    return in the response complete callback */
1554                 card->cmdrsp_buf = NULL;
1555
1556                 /* Clear the cmd-rsp buffer address in scratch registers. This
1557                    will prevent firmware from writing to the same response
1558                    buffer again. */
1559                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1560                         dev_err(adapter->dev,
1561                                 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1562                         return -1;
1563                 }
1564                 /* Write the upper 32bits of the cmdrsp buffer physical
1565                    address */
1566                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1567                         dev_err(adapter->dev,
1568                                 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1569                         return -1;
1570                 }
1571         }
1572
1573         return 0;
1574 }
1575
1576 /*
1577  * Command Response processing complete handler
1578  */
1579 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1580                                         struct sk_buff *skb)
1581 {
1582         struct pcie_service_card *card = adapter->card;
1583         dma_addr_t buf_pa;
1584         struct sk_buff *skb_tmp;
1585
1586         if (skb) {
1587                 card->cmdrsp_buf = skb;
1588                 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1589                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1590                                            PCI_DMA_FROMDEVICE))
1591                         return -1;
1592         }
1593
1594         skb_tmp = card->cmd_buf;
1595         if (skb_tmp) {
1596                 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1597                 pci_unmap_single(card->dev, buf_pa, skb_tmp->len,
1598                                  PCI_DMA_FROMDEVICE);
1599                 card->cmd_buf = NULL;
1600         }
1601
1602         return 0;
1603 }
1604
1605 /*
1606  * This function handles firmware event ready interrupt
1607  */
1608 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1609 {
1610         struct pcie_service_card *card = adapter->card;
1611         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1612         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1613         u32 wrptr, event;
1614         dma_addr_t buf_pa;
1615         struct mwifiex_evt_buf_desc *desc;
1616
1617         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1618                 mwifiex_pm_wakeup_card(adapter);
1619
1620         if (adapter->event_received) {
1621                 dev_dbg(adapter->dev, "info: Event being processed, "
1622                         "do not process this interrupt just yet\n");
1623                 return 0;
1624         }
1625
1626         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1627                 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1628                 return -1;
1629         }
1630
1631         /* Read the event ring write pointer set by firmware */
1632         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1633                 dev_err(adapter->dev,
1634                         "EventReady: failed to read reg->evt_wrptr\n");
1635                 return -1;
1636         }
1637
1638         dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1639                 card->evtbd_rdptr, wrptr);
1640         if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1641                                               & MWIFIEX_EVTBD_MASK)) ||
1642             ((wrptr & reg->evt_rollover_ind) ==
1643              (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1644                 struct sk_buff *skb_cmd;
1645                 __le16 data_len = 0;
1646                 u16 evt_len;
1647
1648                 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1649                 skb_cmd = card->evt_buf_list[rdptr];
1650                 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1651                 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1652                                  PCI_DMA_FROMDEVICE);
1653
1654                 /* Take the pointer and set it to event pointer in adapter
1655                    and will return back after event handling callback */
1656                 card->evt_buf_list[rdptr] = NULL;
1657                 desc = card->evtbd_ring[rdptr];
1658                 memset(desc, 0, sizeof(*desc));
1659
1660                 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1661                 adapter->event_cause = event;
1662                 /* The first 4bytes will be the event transfer header
1663                    len is 2 bytes followed by type which is 2 bytes */
1664                 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1665                 evt_len = le16_to_cpu(data_len);
1666
1667                 skb_pull(skb_cmd, INTF_HEADER_LEN);
1668                 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1669
1670                 if ((evt_len > 0) && (evt_len  < MAX_EVENT_SIZE))
1671                         memcpy(adapter->event_body, skb_cmd->data +
1672                                MWIFIEX_EVENT_HEADER_LEN, evt_len -
1673                                MWIFIEX_EVENT_HEADER_LEN);
1674
1675                 adapter->event_received = true;
1676                 adapter->event_skb = skb_cmd;
1677
1678                 /* Do not update the event read pointer here, wait till the
1679                    buffer is released. This is just to make things simpler,
1680                    we need to find a better method of managing these buffers.
1681                 */
1682         }
1683
1684         return 0;
1685 }
1686
1687 /*
1688  * Event processing complete handler
1689  */
1690 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1691                                        struct sk_buff *skb)
1692 {
1693         struct pcie_service_card *card = adapter->card;
1694         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1695         int ret = 0;
1696         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1697         u32 wrptr;
1698         dma_addr_t buf_pa;
1699         struct mwifiex_evt_buf_desc *desc;
1700
1701         if (!skb)
1702                 return 0;
1703
1704         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1705                 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1706                         rdptr);
1707                 return -EINVAL;
1708         }
1709
1710         /* Read the event ring write pointer set by firmware */
1711         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1712                 dev_err(adapter->dev,
1713                         "event_complete: failed to read reg->evt_wrptr\n");
1714                 return -1;
1715         }
1716
1717         if (!card->evt_buf_list[rdptr]) {
1718                 skb_push(skb, INTF_HEADER_LEN);
1719                 if (mwifiex_map_pci_memory(adapter, skb,
1720                                            MAX_EVENT_SIZE,
1721                                            PCI_DMA_FROMDEVICE))
1722                         return -1;
1723                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1724                 card->evt_buf_list[rdptr] = skb;
1725                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1726                 desc = card->evtbd_ring[rdptr];
1727                 desc->paddr = buf_pa;
1728                 desc->len = (u16)skb->len;
1729                 desc->flags = 0;
1730                 skb = NULL;
1731         } else {
1732                 dev_dbg(adapter->dev,
1733                         "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1734                         rdptr, card->evt_buf_list[rdptr], skb);
1735         }
1736
1737         if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1738                 card->evtbd_rdptr = ((card->evtbd_rdptr &
1739                                         reg->evt_rollover_ind) ^
1740                                         reg->evt_rollover_ind);
1741         }
1742
1743         dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1744                 card->evtbd_rdptr, wrptr);
1745
1746         /* Write the event ring read pointer in to reg->evt_rdptr */
1747         if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1748                               card->evtbd_rdptr)) {
1749                 dev_err(adapter->dev,
1750                         "event_complete: failed to read reg->evt_rdptr\n");
1751                 return -1;
1752         }
1753
1754         dev_dbg(adapter->dev, "info: Check Events Again\n");
1755         ret = mwifiex_pcie_process_event_ready(adapter);
1756
1757         return ret;
1758 }
1759
1760 /*
1761  * This function downloads the firmware to the card.
1762  *
1763  * Firmware is downloaded to the card in blocks. Every block download
1764  * is tested for CRC errors, and retried a number of times before
1765  * returning failure.
1766  */
1767 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1768                                     struct mwifiex_fw_image *fw)
1769 {
1770         int ret;
1771         u8 *firmware = fw->fw_buf;
1772         u32 firmware_len = fw->fw_len;
1773         u32 offset = 0;
1774         struct sk_buff *skb;
1775         u32 txlen, tx_blocks = 0, tries, len;
1776         u32 block_retry_cnt = 0;
1777         dma_addr_t buf_pa;
1778         struct pcie_service_card *card = adapter->card;
1779         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1780
1781         if (!firmware || !firmware_len) {
1782                 dev_err(adapter->dev,
1783                         "No firmware image found! Terminating download\n");
1784                 return -1;
1785         }
1786
1787         dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1788                 firmware_len);
1789
1790         if (mwifiex_pcie_disable_host_int(adapter)) {
1791                 dev_err(adapter->dev,
1792                         "%s: Disabling interrupts failed.\n", __func__);
1793                 return -1;
1794         }
1795
1796         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1797         if (!skb) {
1798                 ret = -ENOMEM;
1799                 goto done;
1800         }
1801
1802         /* Perform firmware data transfer */
1803         do {
1804                 u32 ireg_intr = 0;
1805
1806                 /* More data? */
1807                 if (offset >= firmware_len)
1808                         break;
1809
1810                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1811                         ret = mwifiex_read_reg(adapter, reg->cmd_size,
1812                                                &len);
1813                         if (ret) {
1814                                 dev_warn(adapter->dev,
1815                                          "Failed reading len from boot code\n");
1816                                 goto done;
1817                         }
1818                         if (len)
1819                                 break;
1820                         usleep_range(10, 20);
1821                 }
1822
1823                 if (!len) {
1824                         break;
1825                 } else if (len > MWIFIEX_UPLD_SIZE) {
1826                         pr_err("FW download failure @ %d, invalid length %d\n",
1827                                offset, len);
1828                         ret = -1;
1829                         goto done;
1830                 }
1831
1832                 txlen = len;
1833
1834                 if (len & BIT(0)) {
1835                         block_retry_cnt++;
1836                         if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1837                                 pr_err("FW download failure @ %d, over max "
1838                                        "retry count\n", offset);
1839                                 ret = -1;
1840                                 goto done;
1841                         }
1842                         dev_err(adapter->dev, "FW CRC error indicated by the "
1843                                 "helper: len = 0x%04X, txlen = %d\n",
1844                                 len, txlen);
1845                         len &= ~BIT(0);
1846                         /* Setting this to 0 to resend from same offset */
1847                         txlen = 0;
1848                 } else {
1849                         block_retry_cnt = 0;
1850                         /* Set blocksize to transfer - checking for
1851                            last block */
1852                         if (firmware_len - offset < txlen)
1853                                 txlen = firmware_len - offset;
1854
1855                         dev_dbg(adapter->dev, ".");
1856
1857                         tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1858                                     card->pcie.blksz_fw_dl;
1859
1860                         /* Copy payload to buffer */
1861                         memmove(skb->data, &firmware[offset], txlen);
1862                 }
1863
1864                 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1865                 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1866
1867                 /* Send the boot command to device */
1868                 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1869                         dev_err(adapter->dev,
1870                                 "Failed to send firmware download command\n");
1871                         ret = -1;
1872                         goto done;
1873                 }
1874
1875                 MWIFIEX_SKB_PACB(skb, &buf_pa);
1876
1877                 /* Wait for the command done interrupt */
1878                 do {
1879                         if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1880                                              &ireg_intr)) {
1881                                 dev_err(adapter->dev, "%s: Failed to read "
1882                                         "interrupt status during fw dnld.\n",
1883                                         __func__);
1884                                 pci_unmap_single(card->dev, buf_pa, skb->len,
1885                                                  PCI_DMA_TODEVICE);
1886                                 ret = -1;
1887                                 goto done;
1888                         }
1889                 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1890                          CPU_INTR_DOOR_BELL);
1891
1892                 pci_unmap_single(card->dev, buf_pa, skb->len,
1893                                  PCI_DMA_TODEVICE);
1894
1895                 offset += txlen;
1896         } while (true);
1897
1898         dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1899                 offset);
1900
1901         ret = 0;
1902
1903 done:
1904         dev_kfree_skb_any(skb);
1905         return ret;
1906 }
1907
1908 /*
1909  * This function checks the firmware status in card.
1910  *
1911  * The winner interface is also determined by this function.
1912  */
1913 static int
1914 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1915 {
1916         int ret = 0;
1917         u32 firmware_stat, winner_status;
1918         struct pcie_service_card *card = adapter->card;
1919         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1920         u32 tries;
1921
1922         /* Mask spurios interrupts */
1923         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1924                               HOST_INTR_MASK)) {
1925                 dev_warn(adapter->dev, "Write register failed\n");
1926                 return -1;
1927         }
1928
1929         dev_dbg(adapter->dev, "Setting driver ready signature\n");
1930         if (mwifiex_write_reg(adapter, reg->drv_rdy,
1931                               FIRMWARE_READY_PCIE)) {
1932                 dev_err(adapter->dev,
1933                         "Failed to write driver ready signature\n");
1934                 return -1;
1935         }
1936
1937         /* Wait for firmware initialization event */
1938         for (tries = 0; tries < poll_num; tries++) {
1939                 if (mwifiex_read_reg(adapter, reg->fw_status,
1940                                      &firmware_stat))
1941                         ret = -1;
1942                 else
1943                         ret = 0;
1944                 if (ret)
1945                         continue;
1946                 if (firmware_stat == FIRMWARE_READY_PCIE) {
1947                         ret = 0;
1948                         break;
1949                 } else {
1950                         msleep(100);
1951                         ret = -1;
1952                 }
1953         }
1954
1955         if (ret) {
1956                 if (mwifiex_read_reg(adapter, reg->fw_status,
1957                                      &winner_status))
1958                         ret = -1;
1959                 else if (!winner_status) {
1960                         dev_err(adapter->dev, "PCI-E is the winner\n");
1961                         adapter->winner = 1;
1962                 } else {
1963                         dev_err(adapter->dev,
1964                                 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1965                                 ret, adapter->winner);
1966                 }
1967         }
1968
1969         return ret;
1970 }
1971
1972 /*
1973  * This function reads the interrupt status from card.
1974  */
1975 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1976 {
1977         u32 pcie_ireg;
1978         unsigned long flags;
1979
1980         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1981                 return;
1982
1983         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1984                 dev_warn(adapter->dev, "Read register failed\n");
1985                 return;
1986         }
1987
1988         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1989
1990                 mwifiex_pcie_disable_host_int(adapter);
1991
1992                 /* Clear the pending interrupts */
1993                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1994                                       ~pcie_ireg)) {
1995                         dev_warn(adapter->dev, "Write register failed\n");
1996                         return;
1997                 }
1998                 spin_lock_irqsave(&adapter->int_lock, flags);
1999                 adapter->int_status |= pcie_ireg;
2000                 spin_unlock_irqrestore(&adapter->int_lock, flags);
2001
2002                 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2003                         if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
2004                             (adapter->ps_state == PS_STATE_SLEEP)) {
2005                                 mwifiex_pcie_enable_host_int(adapter);
2006                                 if (mwifiex_write_reg(adapter,
2007                                                       PCIE_CPU_INT_EVENT,
2008                                                       CPU_INTR_SLEEP_CFM_DONE)
2009                                                       ) {
2010                                         dev_warn(adapter->dev,
2011                                                  "Write register failed\n");
2012                                         return;
2013
2014                                 }
2015                         }
2016                 } else if (!adapter->pps_uapsd_mode &&
2017                            adapter->ps_state == PS_STATE_SLEEP &&
2018                            mwifiex_pcie_ok_to_access_hw(adapter)) {
2019                                 /* Potentially for PCIe we could get other
2020                                  * interrupts like shared. Don't change power
2021                                  * state until cookie is set */
2022                                 adapter->ps_state = PS_STATE_AWAKE;
2023                                 adapter->pm_wakeup_fw_try = false;
2024                 }
2025         }
2026 }
2027
2028 /*
2029  * Interrupt handler for PCIe root port
2030  *
2031  * This function reads the interrupt status from firmware and assigns
2032  * the main process in workqueue which will handle the interrupt.
2033  */
2034 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2035 {
2036         struct pci_dev *pdev = (struct pci_dev *)context;
2037         struct pcie_service_card *card;
2038         struct mwifiex_adapter *adapter;
2039
2040         if (!pdev) {
2041                 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2042                 goto exit;
2043         }
2044
2045         card = pci_get_drvdata(pdev);
2046         if (!card || !card->adapter) {
2047                 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2048                          card ? card->adapter : NULL);
2049                 goto exit;
2050         }
2051         adapter = card->adapter;
2052
2053         if (adapter->surprise_removed)
2054                 goto exit;
2055
2056         mwifiex_interrupt_status(adapter);
2057         queue_work(adapter->workqueue, &adapter->main_work);
2058
2059 exit:
2060         return IRQ_HANDLED;
2061 }
2062
2063 /*
2064  * This function checks the current interrupt status.
2065  *
2066  * The following interrupts are checked and handled by this function -
2067  *      - Data sent
2068  *      - Command sent
2069  *      - Command received
2070  *      - Packets received
2071  *      - Events received
2072  *
2073  * In case of Rx packets received, the packets are uploaded from card to
2074  * host and processed accordingly.
2075  */
2076 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2077 {
2078         int ret;
2079         u32 pcie_ireg;
2080         unsigned long flags;
2081
2082         spin_lock_irqsave(&adapter->int_lock, flags);
2083         /* Clear out unused interrupts */
2084         pcie_ireg = adapter->int_status;
2085         adapter->int_status = 0;
2086         spin_unlock_irqrestore(&adapter->int_lock, flags);
2087
2088         while (pcie_ireg & HOST_INTR_MASK) {
2089                 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2090                         pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2091                         dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2092                         ret = mwifiex_pcie_send_data_complete(adapter);
2093                         if (ret)
2094                                 return ret;
2095                 }
2096                 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2097                         pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2098                         dev_dbg(adapter->dev, "info: Rx DATA\n");
2099                         ret = mwifiex_pcie_process_recv_data(adapter);
2100                         if (ret)
2101                                 return ret;
2102                 }
2103                 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2104                         pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2105                         dev_dbg(adapter->dev, "info: Rx EVENT\n");
2106                         ret = mwifiex_pcie_process_event_ready(adapter);
2107                         if (ret)
2108                                 return ret;
2109                 }
2110
2111                 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2112                         pcie_ireg &= ~HOST_INTR_CMD_DONE;
2113                         if (adapter->cmd_sent) {
2114                                 dev_dbg(adapter->dev,
2115                                         "info: CMD sent Interrupt\n");
2116                                 adapter->cmd_sent = false;
2117                         }
2118                         /* Handle command response */
2119                         ret = mwifiex_pcie_process_cmd_complete(adapter);
2120                         if (ret)
2121                                 return ret;
2122                 }
2123
2124                 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2125                         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2126                                              &pcie_ireg)) {
2127                                 dev_warn(adapter->dev,
2128                                          "Read register failed\n");
2129                                 return -1;
2130                         }
2131
2132                         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2133                                 if (mwifiex_write_reg(adapter,
2134                                                       PCIE_HOST_INT_STATUS,
2135                                                       ~pcie_ireg)) {
2136                                         dev_warn(adapter->dev,
2137                                                  "Write register failed\n");
2138                                         return -1;
2139                                 }
2140                         }
2141
2142                 }
2143         }
2144         dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2145                 adapter->cmd_sent, adapter->data_sent);
2146         if (adapter->ps_state != PS_STATE_SLEEP)
2147                 mwifiex_pcie_enable_host_int(adapter);
2148
2149         return 0;
2150 }
2151
2152 /*
2153  * This function downloads data from driver to card.
2154  *
2155  * Both commands and data packets are transferred to the card by this
2156  * function.
2157  *
2158  * This function adds the PCIE specific header to the front of the buffer
2159  * before transferring. The header contains the length of the packet and
2160  * the type. The firmware handles the packets based upon this set type.
2161  */
2162 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2163                                      struct sk_buff *skb,
2164                                      struct mwifiex_tx_param *tx_param)
2165 {
2166         if (!skb) {
2167                 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2168                 return -1;
2169         }
2170
2171         if (type == MWIFIEX_TYPE_DATA)
2172                 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2173         else if (type == MWIFIEX_TYPE_CMD)
2174                 return mwifiex_pcie_send_cmd(adapter, skb);
2175
2176         return 0;
2177 }
2178
2179 /*
2180  * This function initializes the PCI-E host memory space, WCB rings, etc.
2181  *
2182  * The following initializations steps are followed -
2183  *      - Allocate TXBD ring buffers
2184  *      - Allocate RXBD ring buffers
2185  *      - Allocate event BD ring buffers
2186  *      - Allocate command response ring buffer
2187  *      - Allocate sleep cookie buffer
2188  */
2189 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2190 {
2191         struct pcie_service_card *card = adapter->card;
2192         int ret;
2193         struct pci_dev *pdev = card->dev;
2194         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2195
2196         pci_set_drvdata(pdev, card);
2197
2198         ret = pci_enable_device(pdev);
2199         if (ret)
2200                 goto err_enable_dev;
2201
2202         pci_set_master(pdev);
2203
2204         dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2205         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2206         if (ret) {
2207                 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2208                 goto err_set_dma_mask;
2209         }
2210
2211         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2212         if (ret) {
2213                 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2214                 goto err_set_dma_mask;
2215         }
2216
2217         ret = pci_request_region(pdev, 0, DRV_NAME);
2218         if (ret) {
2219                 dev_err(adapter->dev, "req_reg(0) error\n");
2220                 goto err_req_region0;
2221         }
2222         card->pci_mmap = pci_iomap(pdev, 0, 0);
2223         if (!card->pci_mmap) {
2224                 dev_err(adapter->dev, "iomap(0) error\n");
2225                 ret = -EIO;
2226                 goto err_iomap0;
2227         }
2228         ret = pci_request_region(pdev, 2, DRV_NAME);
2229         if (ret) {
2230                 dev_err(adapter->dev, "req_reg(2) error\n");
2231                 goto err_req_region2;
2232         }
2233         card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2234         if (!card->pci_mmap1) {
2235                 dev_err(adapter->dev, "iomap(2) error\n");
2236                 ret = -EIO;
2237                 goto err_iomap2;
2238         }
2239
2240         dev_dbg(adapter->dev,
2241                 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2242                 card->pci_mmap, card->pci_mmap1);
2243
2244         card->cmdrsp_buf = NULL;
2245         ret = mwifiex_pcie_create_txbd_ring(adapter);
2246         if (ret)
2247                 goto err_cre_txbd;
2248         ret = mwifiex_pcie_create_rxbd_ring(adapter);
2249         if (ret)
2250                 goto err_cre_rxbd;
2251         ret = mwifiex_pcie_create_evtbd_ring(adapter);
2252         if (ret)
2253                 goto err_cre_evtbd;
2254         ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2255         if (ret)
2256                 goto err_alloc_cmdbuf;
2257         if (reg->sleep_cookie) {
2258                 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2259                 if (ret)
2260                         goto err_alloc_cookie;
2261         } else {
2262                 card->sleep_cookie_vbase = NULL;
2263         }
2264         return ret;
2265
2266 err_alloc_cookie:
2267         mwifiex_pcie_delete_cmdrsp_buf(adapter);
2268 err_alloc_cmdbuf:
2269         mwifiex_pcie_delete_evtbd_ring(adapter);
2270 err_cre_evtbd:
2271         mwifiex_pcie_delete_rxbd_ring(adapter);
2272 err_cre_rxbd:
2273         mwifiex_pcie_delete_txbd_ring(adapter);
2274 err_cre_txbd:
2275         pci_iounmap(pdev, card->pci_mmap1);
2276 err_iomap2:
2277         pci_release_region(pdev, 2);
2278 err_req_region2:
2279         pci_iounmap(pdev, card->pci_mmap);
2280 err_iomap0:
2281         pci_release_region(pdev, 0);
2282 err_req_region0:
2283 err_set_dma_mask:
2284         pci_disable_device(pdev);
2285 err_enable_dev:
2286         pci_set_drvdata(pdev, NULL);
2287         return ret;
2288 }
2289
2290 /*
2291  * This function cleans up the allocated card buffers.
2292  *
2293  * The following are freed by this function -
2294  *      - TXBD ring buffers
2295  *      - RXBD ring buffers
2296  *      - Event BD ring buffers
2297  *      - Command response ring buffer
2298  *      - Sleep cookie buffer
2299  */
2300 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2301 {
2302         struct pcie_service_card *card = adapter->card;
2303         struct pci_dev *pdev = card->dev;
2304         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2305
2306         if (user_rmmod) {
2307                 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2308                 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2309                         dev_err(adapter->dev,
2310                                 "Failed to write driver not-ready signature\n");
2311         }
2312
2313         if (pdev) {
2314                 pci_iounmap(pdev, card->pci_mmap);
2315                 pci_iounmap(pdev, card->pci_mmap1);
2316                 pci_disable_device(pdev);
2317                 pci_release_region(pdev, 2);
2318                 pci_release_region(pdev, 0);
2319                 pci_set_drvdata(pdev, NULL);
2320         }
2321         kfree(card);
2322 }
2323
2324 /*
2325  * This function registers the PCIE device.
2326  *
2327  * PCIE IRQ is claimed, block size is set and driver data is initialized.
2328  */
2329 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2330 {
2331         int ret;
2332         struct pcie_service_card *card = adapter->card;
2333         struct pci_dev *pdev = card->dev;
2334
2335         /* save adapter pointer in card */
2336         card->adapter = adapter;
2337
2338         ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2339                           "MRVL_PCIE", pdev);
2340         if (ret) {
2341                 pr_err("request_irq failed: ret=%d\n", ret);
2342                 adapter->card = NULL;
2343                 return -1;
2344         }
2345
2346         adapter->dev = &pdev->dev;
2347         strcpy(adapter->fw_name, card->pcie.firmware);
2348
2349         return 0;
2350 }
2351
2352 /*
2353  * This function unregisters the PCIE device.
2354  *
2355  * The PCIE IRQ is released, the function is disabled and driver
2356  * data is set to null.
2357  */
2358 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2359 {
2360         struct pcie_service_card *card = adapter->card;
2361         const struct mwifiex_pcie_card_reg *reg;
2362
2363         if (card) {
2364                 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2365                 free_irq(card->dev->irq, card->dev);
2366
2367                 reg = card->pcie.reg;
2368                 if (reg->sleep_cookie)
2369                         mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2370
2371                 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2372                 mwifiex_pcie_delete_evtbd_ring(adapter);
2373                 mwifiex_pcie_delete_rxbd_ring(adapter);
2374                 mwifiex_pcie_delete_txbd_ring(adapter);
2375                 card->cmdrsp_buf = NULL;
2376         }
2377 }
2378
2379 static struct mwifiex_if_ops pcie_ops = {
2380         .init_if =                      mwifiex_pcie_init,
2381         .cleanup_if =                   mwifiex_pcie_cleanup,
2382         .check_fw_status =              mwifiex_check_fw_status,
2383         .prog_fw =                      mwifiex_prog_fw_w_helper,
2384         .register_dev =                 mwifiex_register_dev,
2385         .unregister_dev =               mwifiex_unregister_dev,
2386         .enable_int =                   mwifiex_pcie_enable_host_int,
2387         .process_int_status =           mwifiex_process_int_status,
2388         .host_to_card =                 mwifiex_pcie_host_to_card,
2389         .wakeup =                       mwifiex_pm_wakeup_card,
2390         .wakeup_complete =              mwifiex_pm_wakeup_card_complete,
2391
2392         /* PCIE specific */
2393         .cmdrsp_complete =              mwifiex_pcie_cmdrsp_complete,
2394         .event_complete =               mwifiex_pcie_event_complete,
2395         .update_mp_end_port =           NULL,
2396         .cleanup_mpa_buf =              NULL,
2397         .init_fw_port =                 mwifiex_pcie_init_fw_port,
2398         .clean_pcie_ring =              mwifiex_clean_pcie_ring_buf,
2399 };
2400
2401 /*
2402  * This function initializes the PCIE driver module.
2403  *
2404  * This initiates the semaphore and registers the device with
2405  * PCIE bus.
2406  */
2407 static int mwifiex_pcie_init_module(void)
2408 {
2409         int ret;
2410
2411         pr_debug("Marvell PCIe Driver\n");
2412
2413         sema_init(&add_remove_card_sem, 1);
2414
2415         /* Clear the flag in case user removes the card. */
2416         user_rmmod = 0;
2417
2418         ret = pci_register_driver(&mwifiex_pcie);
2419         if (ret)
2420                 pr_err("Driver register failed!\n");
2421         else
2422                 pr_debug("info: Driver registered successfully!\n");
2423
2424         return ret;
2425 }
2426
2427 /*
2428  * This function cleans up the PCIE driver.
2429  *
2430  * The following major steps are followed for cleanup -
2431  *      - Resume the device if its suspended
2432  *      - Disconnect the device if connected
2433  *      - Shutdown the firmware
2434  *      - Unregister the device from PCIE bus.
2435  */
2436 static void mwifiex_pcie_cleanup_module(void)
2437 {
2438         if (!down_interruptible(&add_remove_card_sem))
2439                 up(&add_remove_card_sem);
2440
2441         /* Set the flag as user is removing this module. */
2442         user_rmmod = 1;
2443
2444         pci_unregister_driver(&mwifiex_pcie);
2445 }
2446
2447 module_init(mwifiex_pcie_init_module);
2448 module_exit(mwifiex_pcie_cleanup_module);
2449
2450 MODULE_AUTHOR("Marvell International Ltd.");
2451 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2452 MODULE_VERSION(PCIE_VERSION);
2453 MODULE_LICENSE("GPL v2");
2454 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2455 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);