drivers/net/wireless/mwifiex/pcie.c

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