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