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         unsigned long flags;
1241
1242         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1243                 mwifiex_pm_wakeup_card(adapter);
1244
1245         /* Read the RX ring Write pointer set by firmware */
1246         if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1247                 dev_err(adapter->dev,
1248                         "RECV DATA: failed to read reg->rx_wrptr\n");
1249                 ret = -1;
1250                 goto done;
1251         }
1252         card->rxbd_wrptr = wrptr;
1253
1254         while (((wrptr & reg->rx_mask) !=
1255                 (card->rxbd_rdptr & reg->rx_mask)) ||
1256                ((wrptr & reg->rx_rollover_ind) ==
1257                 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1258                 struct sk_buff *skb_data;
1259                 u16 rx_len;
1260                 __le16 pkt_len;
1261
1262                 rd_index = card->rxbd_rdptr & reg->rx_mask;
1263                 skb_data = card->rx_buf_list[rd_index];
1264
1265                 /* If skb allocation was failed earlier for Rx packet,
1266                  * rx_buf_list[rd_index] would have been left with a NULL.
1267                  */
1268                 if (!skb_data)
1269                         return -ENOMEM;
1270
1271                 mwifiex_unmap_pci_memory(adapter, skb_data, PCI_DMA_FROMDEVICE);
1272                 card->rx_buf_list[rd_index] = NULL;
1273
1274                 /* Get data length from interface header -
1275                  * first 2 bytes for len, next 2 bytes is for type
1276                  */
1277                 pkt_len = *((__le16 *)skb_data->data);
1278                 rx_len = le16_to_cpu(pkt_len);
1279                 if (WARN_ON(rx_len <= INTF_HEADER_LEN ||
1280                             rx_len > MWIFIEX_RX_DATA_BUF_SIZE)) {
1281                         dev_err(adapter->dev,
1282                                 "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1283                                 rx_len, card->rxbd_rdptr, wrptr);
1284                         dev_kfree_skb_any(skb_data);
1285                 } else {
1286                         skb_put(skb_data, rx_len);
1287                         dev_dbg(adapter->dev,
1288                                 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1289                                 card->rxbd_rdptr, wrptr, rx_len);
1290                         skb_pull(skb_data, INTF_HEADER_LEN);
1291                         if (adapter->rx_work_enabled) {
1292                                 spin_lock_irqsave(&adapter->rx_q_lock, flags);
1293                                 skb_queue_tail(&adapter->rx_data_q, skb_data);
1294                                 spin_unlock_irqrestore(&adapter->rx_q_lock,
1295                                                        flags);
1296                                 adapter->data_received = true;
1297                                 atomic_inc(&adapter->rx_pending);
1298                         } else {
1299                                 mwifiex_handle_rx_packet(adapter, skb_data);
1300                         }
1301                 }
1302
1303                 skb_tmp = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
1304                 if (!skb_tmp) {
1305                         dev_err(adapter->dev,
1306                                 "Unable to allocate skb.\n");
1307                         return -ENOMEM;
1308                 }
1309
1310                 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1311                                            MWIFIEX_RX_DATA_BUF_SIZE,
1312                                            PCI_DMA_FROMDEVICE))
1313                         return -1;
1314
1315                 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb_tmp);
1316
1317                 dev_dbg(adapter->dev,
1318                         "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1319                         skb_tmp, rd_index);
1320                 card->rx_buf_list[rd_index] = skb_tmp;
1321
1322                 if (reg->pfu_enabled) {
1323                         desc2 = card->rxbd_ring[rd_index];
1324                         desc2->paddr = buf_pa;
1325                         desc2->len = skb_tmp->len;
1326                         desc2->frag_len = skb_tmp->len;
1327                         desc2->offset = 0;
1328                         desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1329                 } else {
1330                         desc = card->rxbd_ring[rd_index];
1331                         desc->paddr = buf_pa;
1332                         desc->len = skb_tmp->len;
1333                         desc->flags = 0;
1334                 }
1335
1336                 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1337                                                         MWIFIEX_MAX_TXRX_BD) {
1338                         card->rxbd_rdptr = ((card->rxbd_rdptr &
1339                                              reg->rx_rollover_ind) ^
1340                                              reg->rx_rollover_ind);
1341                 }
1342                 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1343                         card->rxbd_rdptr, wrptr);
1344
1345                 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1346                 /* Write the RX ring read pointer in to reg->rx_rdptr */
1347                 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1348                                       card->rxbd_rdptr | tx_val)) {
1349                         dev_err(adapter->dev,
1350                                 "RECV DATA: failed to write reg->rx_rdptr\n");
1351                         ret = -1;
1352                         goto done;
1353                 }
1354
1355                 /* Read the RX ring Write pointer set by firmware */
1356                 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1357                         dev_err(adapter->dev,
1358                                 "RECV DATA: failed to read reg->rx_wrptr\n");
1359                         ret = -1;
1360                         goto done;
1361                 }
1362                 dev_dbg(adapter->dev,
1363                         "info: RECV DATA: Rcvd packet from fw successfully\n");
1364                 card->rxbd_wrptr = wrptr;
1365         }
1366
1367 done:
1368         return ret;
1369 }
1370
1371 /*
1372  * This function downloads the boot command to device
1373  */
1374 static int
1375 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1376 {
1377         dma_addr_t buf_pa;
1378         struct pcie_service_card *card = adapter->card;
1379         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1380
1381         if (!(skb->data && skb->len)) {
1382                 dev_err(adapter->dev,
1383                         "Invalid parameter in %s <%p. len %d>\n",
1384                         __func__, skb->data, skb->len);
1385                 return -1;
1386         }
1387
1388         if (mwifiex_map_pci_memory(adapter, skb, skb->len , PCI_DMA_TODEVICE))
1389                 return -1;
1390
1391         buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1392
1393         /* Write the lower 32bits of the physical address to low command
1394          * address scratch register
1395          */
1396         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1397                 dev_err(adapter->dev,
1398                         "%s: failed to write download command to boot code.\n",
1399                         __func__);
1400                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1401                 return -1;
1402         }
1403
1404         /* Write the upper 32bits of the physical address to high command
1405          * address scratch register
1406          */
1407         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1408                               (u32)((u64)buf_pa >> 32))) {
1409                 dev_err(adapter->dev,
1410                         "%s: failed to write download command to boot code.\n",
1411                         __func__);
1412                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1413                 return -1;
1414         }
1415
1416         /* Write the command length to cmd_size scratch register */
1417         if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1418                 dev_err(adapter->dev,
1419                         "%s: failed to write command len to cmd_size scratch reg\n",
1420                         __func__);
1421                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1422                 return -1;
1423         }
1424
1425         /* Ring the door bell */
1426         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1427                               CPU_INTR_DOOR_BELL)) {
1428                 dev_err(adapter->dev,
1429                         "%s: failed to assert door-bell intr\n", __func__);
1430                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1431                 return -1;
1432         }
1433
1434         return 0;
1435 }
1436
1437 /* This function init rx port in firmware which in turn enables to receive data
1438  * from device before transmitting any packet.
1439  */
1440 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1441 {
1442         struct pcie_service_card *card = adapter->card;
1443         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1444         int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1445
1446         /* Write the RX ring read pointer in to reg->rx_rdptr */
1447         if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1448                               tx_wrap)) {
1449                 dev_err(adapter->dev,
1450                         "RECV DATA: failed to write reg->rx_rdptr\n");
1451                 return -1;
1452         }
1453         return 0;
1454 }
1455
1456 /* This function downloads commands to the device
1457  */
1458 static int
1459 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1460 {
1461         struct pcie_service_card *card = adapter->card;
1462         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1463         int ret = 0;
1464         dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1465         u8 *payload = (u8 *)skb->data;
1466
1467         if (!(skb->data && skb->len)) {
1468                 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
1469                         __func__, skb->data, skb->len);
1470                 return -1;
1471         }
1472
1473         /* Make sure a command response buffer is available */
1474         if (!card->cmdrsp_buf) {
1475                 dev_err(adapter->dev,
1476                         "No response buffer available, send command failed\n");
1477                 return -EBUSY;
1478         }
1479
1480         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1481                 mwifiex_pm_wakeup_card(adapter);
1482
1483         adapter->cmd_sent = true;
1484
1485         *(__le16 *)&payload[0] = cpu_to_le16((u16)skb->len);
1486         *(__le16 *)&payload[2] = cpu_to_le16(MWIFIEX_TYPE_CMD);
1487
1488         if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1489                 return -1;
1490
1491         card->cmd_buf = skb;
1492
1493         /* To send a command, the driver will:
1494                 1. Write the 64bit physical address of the data buffer to
1495                    cmd response address low  + cmd response address high
1496                 2. Ring the door bell (i.e. set the door bell interrupt)
1497
1498                 In response to door bell interrupt, the firmware will perform
1499                 the DMA of the command packet (first header to obtain the total
1500                 length and then rest of the command).
1501         */
1502
1503         if (card->cmdrsp_buf) {
1504                 cmdrsp_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmdrsp_buf);
1505                 /* Write the lower 32bits of the cmdrsp buffer physical
1506                    address */
1507                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1508                                       (u32)cmdrsp_buf_pa)) {
1509                         dev_err(adapter->dev,
1510                                 "Failed to write download cmd to boot code.\n");
1511                         ret = -1;
1512                         goto done;
1513                 }
1514                 /* Write the upper 32bits of the cmdrsp buffer physical
1515                    address */
1516                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1517                                       (u32)((u64)cmdrsp_buf_pa >> 32))) {
1518                         dev_err(adapter->dev,
1519                                 "Failed to write download cmd to boot code.\n");
1520                         ret = -1;
1521                         goto done;
1522                 }
1523         }
1524
1525         cmd_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmd_buf);
1526         /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1527         if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1528                               (u32)cmd_buf_pa)) {
1529                 dev_err(adapter->dev,
1530                         "Failed to write download cmd to boot code.\n");
1531                 ret = -1;
1532                 goto done;
1533         }
1534         /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1535         if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1536                               (u32)((u64)cmd_buf_pa >> 32))) {
1537                 dev_err(adapter->dev,
1538                         "Failed to write download cmd to boot code.\n");
1539                 ret = -1;
1540                 goto done;
1541         }
1542
1543         /* Write the command length to reg->cmd_size */
1544         if (mwifiex_write_reg(adapter, reg->cmd_size,
1545                               card->cmd_buf->len)) {
1546                 dev_err(adapter->dev,
1547                         "Failed to write cmd len to reg->cmd_size\n");
1548                 ret = -1;
1549                 goto done;
1550         }
1551
1552         /* Ring the door bell */
1553         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1554                               CPU_INTR_DOOR_BELL)) {
1555                 dev_err(adapter->dev,
1556                         "Failed to assert door-bell intr\n");
1557                 ret = -1;
1558                 goto done;
1559         }
1560
1561 done:
1562         if (ret)
1563                 adapter->cmd_sent = false;
1564
1565         return 0;
1566 }
1567
1568 /*
1569  * This function handles command complete interrupt
1570  */
1571 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1572 {
1573         struct pcie_service_card *card = adapter->card;
1574         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1575         struct sk_buff *skb = card->cmdrsp_buf;
1576         int count = 0;
1577         u16 rx_len;
1578         __le16 pkt_len;
1579
1580         dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1581
1582         mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_FROMDEVICE);
1583
1584         /* Unmap the command as a response has been received. */
1585         if (card->cmd_buf) {
1586                 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1587                                          PCI_DMA_TODEVICE);
1588                 card->cmd_buf = NULL;
1589         }
1590
1591         pkt_len = *((__le16 *)skb->data);
1592         rx_len = le16_to_cpu(pkt_len);
1593         skb_trim(skb, rx_len);
1594         skb_pull(skb, INTF_HEADER_LEN);
1595
1596         if (!adapter->curr_cmd) {
1597                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1598                         mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1599                                                            skb->len);
1600                         mwifiex_pcie_enable_host_int(adapter);
1601                         if (mwifiex_write_reg(adapter,
1602                                               PCIE_CPU_INT_EVENT,
1603                                               CPU_INTR_SLEEP_CFM_DONE)) {
1604                                 dev_warn(adapter->dev,
1605                                          "Write register failed\n");
1606                                 return -1;
1607                         }
1608                         mwifiex_delay_for_sleep_cookie(adapter,
1609                                                        MWIFIEX_MAX_DELAY_COUNT);
1610                         while (reg->sleep_cookie && (count++ < 10) &&
1611                                mwifiex_pcie_ok_to_access_hw(adapter))
1612                                 usleep_range(50, 60);
1613                 } else {
1614                         dev_err(adapter->dev,
1615                                 "There is no command but got cmdrsp\n");
1616                 }
1617                 memcpy(adapter->upld_buf, skb->data,
1618                        min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1619                 skb_push(skb, INTF_HEADER_LEN);
1620                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1621                                            PCI_DMA_FROMDEVICE))
1622                         return -1;
1623         } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1624                 adapter->curr_cmd->resp_skb = skb;
1625                 adapter->cmd_resp_received = true;
1626                 /* Take the pointer and set it to CMD node and will
1627                    return in the response complete callback */
1628                 card->cmdrsp_buf = NULL;
1629
1630                 /* Clear the cmd-rsp buffer address in scratch registers. This
1631                    will prevent firmware from writing to the same response
1632                    buffer again. */
1633                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1634                         dev_err(adapter->dev,
1635                                 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1636                         return -1;
1637                 }
1638                 /* Write the upper 32bits of the cmdrsp buffer physical
1639                    address */
1640                 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1641                         dev_err(adapter->dev,
1642                                 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1643                         return -1;
1644                 }
1645         }
1646
1647         return 0;
1648 }
1649
1650 /*
1651  * Command Response processing complete handler
1652  */
1653 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1654                                         struct sk_buff *skb)
1655 {
1656         struct pcie_service_card *card = adapter->card;
1657
1658         if (skb) {
1659                 card->cmdrsp_buf = skb;
1660                 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1661                 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1662                                            PCI_DMA_FROMDEVICE))
1663                         return -1;
1664         }
1665
1666         return 0;
1667 }
1668
1669 /*
1670  * This function handles firmware event ready interrupt
1671  */
1672 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1673 {
1674         struct pcie_service_card *card = adapter->card;
1675         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1676         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1677         u32 wrptr, event;
1678         struct mwifiex_evt_buf_desc *desc;
1679
1680         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1681                 mwifiex_pm_wakeup_card(adapter);
1682
1683         if (adapter->event_received) {
1684                 dev_dbg(adapter->dev, "info: Event being processed, "
1685                         "do not process this interrupt just yet\n");
1686                 return 0;
1687         }
1688
1689         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1690                 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1691                 return -1;
1692         }
1693
1694         /* Read the event ring write pointer set by firmware */
1695         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1696                 dev_err(adapter->dev,
1697                         "EventReady: failed to read reg->evt_wrptr\n");
1698                 return -1;
1699         }
1700
1701         dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1702                 card->evtbd_rdptr, wrptr);
1703         if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1704                                               & MWIFIEX_EVTBD_MASK)) ||
1705             ((wrptr & reg->evt_rollover_ind) ==
1706              (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1707                 struct sk_buff *skb_cmd;
1708                 __le16 data_len = 0;
1709                 u16 evt_len;
1710
1711                 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1712                 skb_cmd = card->evt_buf_list[rdptr];
1713                 mwifiex_unmap_pci_memory(adapter, skb_cmd, PCI_DMA_FROMDEVICE);
1714
1715                 /* Take the pointer and set it to event pointer in adapter
1716                    and will return back after event handling callback */
1717                 card->evt_buf_list[rdptr] = NULL;
1718                 desc = card->evtbd_ring[rdptr];
1719                 memset(desc, 0, sizeof(*desc));
1720
1721                 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1722                 adapter->event_cause = event;
1723                 /* The first 4bytes will be the event transfer header
1724                    len is 2 bytes followed by type which is 2 bytes */
1725                 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1726                 evt_len = le16_to_cpu(data_len);
1727
1728                 skb_pull(skb_cmd, INTF_HEADER_LEN);
1729                 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1730
1731                 if ((evt_len > 0) && (evt_len  < MAX_EVENT_SIZE))
1732                         memcpy(adapter->event_body, skb_cmd->data +
1733                                MWIFIEX_EVENT_HEADER_LEN, evt_len -
1734                                MWIFIEX_EVENT_HEADER_LEN);
1735
1736                 adapter->event_received = true;
1737                 adapter->event_skb = skb_cmd;
1738
1739                 /* Do not update the event read pointer here, wait till the
1740                    buffer is released. This is just to make things simpler,
1741                    we need to find a better method of managing these buffers.
1742                 */
1743         } else {
1744                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1745                                       CPU_INTR_EVENT_DONE)) {
1746                         dev_warn(adapter->dev,
1747                                  "Write register failed\n");
1748                         return -1;
1749                 }
1750         }
1751
1752         return 0;
1753 }
1754
1755 /*
1756  * Event processing complete handler
1757  */
1758 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1759                                        struct sk_buff *skb)
1760 {
1761         struct pcie_service_card *card = adapter->card;
1762         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1763         int ret = 0;
1764         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1765         u32 wrptr;
1766         struct mwifiex_evt_buf_desc *desc;
1767
1768         if (!skb)
1769                 return 0;
1770
1771         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1772                 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1773                         rdptr);
1774                 return -EINVAL;
1775         }
1776
1777         /* Read the event ring write pointer set by firmware */
1778         if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1779                 dev_err(adapter->dev,
1780                         "event_complete: failed to read reg->evt_wrptr\n");
1781                 return -1;
1782         }
1783
1784         if (!card->evt_buf_list[rdptr]) {
1785                 skb_push(skb, INTF_HEADER_LEN);
1786                 if (mwifiex_map_pci_memory(adapter, skb,
1787                                            MAX_EVENT_SIZE,
1788                                            PCI_DMA_FROMDEVICE))
1789                         return -1;
1790                 card->evt_buf_list[rdptr] = skb;
1791                 desc = card->evtbd_ring[rdptr];
1792                 desc->paddr = MWIFIEX_SKB_DMA_ADDR(skb);
1793                 desc->len = (u16)skb->len;
1794                 desc->flags = 0;
1795                 skb = NULL;
1796         } else {
1797                 dev_dbg(adapter->dev,
1798                         "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1799                         rdptr, card->evt_buf_list[rdptr], skb);
1800         }
1801
1802         if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1803                 card->evtbd_rdptr = ((card->evtbd_rdptr &
1804                                         reg->evt_rollover_ind) ^
1805                                         reg->evt_rollover_ind);
1806         }
1807
1808         dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1809                 card->evtbd_rdptr, wrptr);
1810
1811         /* Write the event ring read pointer in to reg->evt_rdptr */
1812         if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1813                               card->evtbd_rdptr)) {
1814                 dev_err(adapter->dev,
1815                         "event_complete: failed to read reg->evt_rdptr\n");
1816                 return -1;
1817         }
1818
1819         dev_dbg(adapter->dev, "info: Check Events Again\n");
1820         ret = mwifiex_pcie_process_event_ready(adapter);
1821
1822         return ret;
1823 }
1824
1825 /*
1826  * This function downloads the firmware to the card.
1827  *
1828  * Firmware is downloaded to the card in blocks. Every block download
1829  * is tested for CRC errors, and retried a number of times before
1830  * returning failure.
1831  */
1832 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1833                                     struct mwifiex_fw_image *fw)
1834 {
1835         int ret;
1836         u8 *firmware = fw->fw_buf;
1837         u32 firmware_len = fw->fw_len;
1838         u32 offset = 0;
1839         struct sk_buff *skb;
1840         u32 txlen, tx_blocks = 0, tries, len;
1841         u32 block_retry_cnt = 0;
1842         struct pcie_service_card *card = adapter->card;
1843         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1844
1845         if (!firmware || !firmware_len) {
1846                 dev_err(adapter->dev,
1847                         "No firmware image found! Terminating download\n");
1848                 return -1;
1849         }
1850
1851         dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1852                 firmware_len);
1853
1854         if (mwifiex_pcie_disable_host_int(adapter)) {
1855                 dev_err(adapter->dev,
1856                         "%s: Disabling interrupts failed.\n", __func__);
1857                 return -1;
1858         }
1859
1860         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1861         if (!skb) {
1862                 ret = -ENOMEM;
1863                 goto done;
1864         }
1865
1866         /* Perform firmware data transfer */
1867         do {
1868                 u32 ireg_intr = 0;
1869
1870                 /* More data? */
1871                 if (offset >= firmware_len)
1872                         break;
1873
1874                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1875                         ret = mwifiex_read_reg(adapter, reg->cmd_size,
1876                                                &len);
1877                         if (ret) {
1878                                 dev_warn(adapter->dev,
1879                                          "Failed reading len from boot code\n");
1880                                 goto done;
1881                         }
1882                         if (len)
1883                                 break;
1884                         usleep_range(10, 20);
1885                 }
1886
1887                 if (!len) {
1888                         break;
1889                 } else if (len > MWIFIEX_UPLD_SIZE) {
1890                         pr_err("FW download failure @ %d, invalid length %d\n",
1891                                offset, len);
1892                         ret = -1;
1893                         goto done;
1894                 }
1895
1896                 txlen = len;
1897
1898                 if (len & BIT(0)) {
1899                         block_retry_cnt++;
1900                         if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1901                                 pr_err("FW download failure @ %d, over max "
1902                                        "retry count\n", offset);
1903                                 ret = -1;
1904                                 goto done;
1905                         }
1906                         dev_err(adapter->dev, "FW CRC error indicated by the "
1907                                 "helper: len = 0x%04X, txlen = %d\n",
1908                                 len, txlen);
1909                         len &= ~BIT(0);
1910                         /* Setting this to 0 to resend from same offset */
1911                         txlen = 0;
1912                 } else {
1913                         block_retry_cnt = 0;
1914                         /* Set blocksize to transfer - checking for
1915                            last block */
1916                         if (firmware_len - offset < txlen)
1917                                 txlen = firmware_len - offset;
1918
1919                         dev_dbg(adapter->dev, ".");
1920
1921                         tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1922                                     card->pcie.blksz_fw_dl;
1923
1924                         /* Copy payload to buffer */
1925                         memmove(skb->data, &firmware[offset], txlen);
1926                 }
1927
1928                 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1929                 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1930
1931                 /* Send the boot command to device */
1932                 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1933                         dev_err(adapter->dev,
1934                                 "Failed to send firmware download command\n");
1935                         ret = -1;
1936                         goto done;
1937                 }
1938
1939                 /* Wait for the command done interrupt */
1940                 do {
1941                         if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1942                                              &ireg_intr)) {
1943                                 dev_err(adapter->dev, "%s: Failed to read "
1944                                         "interrupt status during fw dnld.\n",
1945                                         __func__);
1946                                 mwifiex_unmap_pci_memory(adapter, skb,
1947                                                          PCI_DMA_TODEVICE);
1948                                 ret = -1;
1949                                 goto done;
1950                         }
1951                 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1952                          CPU_INTR_DOOR_BELL);
1953
1954                 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1955
1956                 offset += txlen;
1957         } while (true);
1958
1959         dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1960                 offset);
1961
1962         ret = 0;
1963
1964 done:
1965         dev_kfree_skb_any(skb);
1966         return ret;
1967 }
1968
1969 /*
1970  * This function checks the firmware status in card.
1971  *
1972  * The winner interface is also determined by this function.
1973  */
1974 static int
1975 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1976 {
1977         int ret = 0;
1978         u32 firmware_stat, winner_status;
1979         struct pcie_service_card *card = adapter->card;
1980         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1981         u32 tries;
1982
1983         /* Mask spurios interrupts */
1984         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1985                               HOST_INTR_MASK)) {
1986                 dev_warn(adapter->dev, "Write register failed\n");
1987                 return -1;
1988         }
1989
1990         dev_dbg(adapter->dev, "Setting driver ready signature\n");
1991         if (mwifiex_write_reg(adapter, reg->drv_rdy,
1992                               FIRMWARE_READY_PCIE)) {
1993                 dev_err(adapter->dev,
1994                         "Failed to write driver ready signature\n");
1995                 return -1;
1996         }
1997
1998         /* Wait for firmware initialization event */
1999         for (tries = 0; tries < poll_num; tries++) {
2000                 if (mwifiex_read_reg(adapter, reg->fw_status,
2001                                      &firmware_stat))
2002                         ret = -1;
2003                 else
2004                         ret = 0;
2005                 if (ret)
2006                         continue;
2007                 if (firmware_stat == FIRMWARE_READY_PCIE) {
2008                         ret = 0;
2009                         break;
2010                 } else {
2011                         msleep(100);
2012                         ret = -1;
2013                 }
2014         }
2015
2016         if (ret) {
2017                 if (mwifiex_read_reg(adapter, reg->fw_status,
2018                                      &winner_status))
2019                         ret = -1;
2020                 else if (!winner_status) {
2021                         dev_err(adapter->dev, "PCI-E is the winner\n");
2022                         adapter->winner = 1;
2023                 } else {
2024                         dev_err(adapter->dev,
2025                                 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
2026                                 ret, adapter->winner);
2027                 }
2028         }
2029
2030         return ret;
2031 }
2032
2033 /*
2034  * This function reads the interrupt status from card.
2035  */
2036 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
2037 {
2038         u32 pcie_ireg;
2039         unsigned long flags;
2040
2041         if (!mwifiex_pcie_ok_to_access_hw(adapter))
2042                 return;
2043
2044         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
2045                 dev_warn(adapter->dev, "Read register failed\n");
2046                 return;
2047         }
2048
2049         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2050
2051                 mwifiex_pcie_disable_host_int(adapter);
2052
2053                 /* Clear the pending interrupts */
2054                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
2055                                       ~pcie_ireg)) {
2056                         dev_warn(adapter->dev, "Write register failed\n");
2057                         return;
2058                 }
2059                 spin_lock_irqsave(&adapter->int_lock, flags);
2060                 adapter->int_status |= pcie_ireg;
2061                 spin_unlock_irqrestore(&adapter->int_lock, flags);
2062
2063                 if (!adapter->pps_uapsd_mode &&
2064                     adapter->ps_state == PS_STATE_SLEEP &&
2065                     mwifiex_pcie_ok_to_access_hw(adapter)) {
2066                                 /* Potentially for PCIe we could get other
2067                                  * interrupts like shared. Don't change power
2068                                  * state until cookie is set */
2069                                 adapter->ps_state = PS_STATE_AWAKE;
2070                                 adapter->pm_wakeup_fw_try = false;
2071                 }
2072         }
2073 }
2074
2075 /*
2076  * Interrupt handler for PCIe root port
2077  *
2078  * This function reads the interrupt status from firmware and assigns
2079  * the main process in workqueue which will handle the interrupt.
2080  */
2081 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2082 {
2083         struct pci_dev *pdev = (struct pci_dev *)context;
2084         struct pcie_service_card *card;
2085         struct mwifiex_adapter *adapter;
2086
2087         if (!pdev) {
2088                 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2089                 goto exit;
2090         }
2091
2092         card = pci_get_drvdata(pdev);
2093         if (!card || !card->adapter) {
2094                 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2095                          card ? card->adapter : NULL);
2096                 goto exit;
2097         }
2098         adapter = card->adapter;
2099
2100         if (adapter->surprise_removed)
2101                 goto exit;
2102
2103         mwifiex_interrupt_status(adapter);
2104         queue_work(adapter->workqueue, &adapter->main_work);
2105
2106 exit:
2107         return IRQ_HANDLED;
2108 }
2109
2110 /*
2111  * This function checks the current interrupt status.
2112  *
2113  * The following interrupts are checked and handled by this function -
2114  *      - Data sent
2115  *      - Command sent
2116  *      - Command received
2117  *      - Packets received
2118  *      - Events received
2119  *
2120  * In case of Rx packets received, the packets are uploaded from card to
2121  * host and processed accordingly.
2122  */
2123 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2124 {
2125         int ret;
2126         u32 pcie_ireg;
2127         unsigned long flags;
2128
2129         spin_lock_irqsave(&adapter->int_lock, flags);
2130         /* Clear out unused interrupts */
2131         pcie_ireg = adapter->int_status;
2132         adapter->int_status = 0;
2133         spin_unlock_irqrestore(&adapter->int_lock, flags);
2134
2135         while (pcie_ireg & HOST_INTR_MASK) {
2136                 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2137                         pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2138                         dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2139                         ret = mwifiex_pcie_send_data_complete(adapter);
2140                         if (ret)
2141                                 return ret;
2142                 }
2143                 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2144                         pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2145                         dev_dbg(adapter->dev, "info: Rx DATA\n");
2146                         ret = mwifiex_pcie_process_recv_data(adapter);
2147                         if (ret)
2148                                 return ret;
2149                 }
2150                 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2151                         pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2152                         dev_dbg(adapter->dev, "info: Rx EVENT\n");
2153                         ret = mwifiex_pcie_process_event_ready(adapter);
2154                         if (ret)
2155                                 return ret;
2156                 }
2157
2158                 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2159                         pcie_ireg &= ~HOST_INTR_CMD_DONE;
2160                         if (adapter->cmd_sent) {
2161                                 dev_dbg(adapter->dev,
2162                                         "info: CMD sent Interrupt\n");
2163                                 adapter->cmd_sent = false;
2164                         }
2165                         /* Handle command response */
2166                         ret = mwifiex_pcie_process_cmd_complete(adapter);
2167                         if (ret)
2168                                 return ret;
2169                 }
2170
2171                 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2172                         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2173                                              &pcie_ireg)) {
2174                                 dev_warn(adapter->dev,
2175                                          "Read register failed\n");
2176                                 return -1;
2177                         }
2178
2179                         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2180                                 if (mwifiex_write_reg(adapter,
2181                                                       PCIE_HOST_INT_STATUS,
2182                                                       ~pcie_ireg)) {
2183                                         dev_warn(adapter->dev,
2184                                                  "Write register failed\n");
2185                                         return -1;
2186                                 }
2187                         }
2188
2189                 }
2190         }
2191         dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2192                 adapter->cmd_sent, adapter->data_sent);
2193         if (adapter->ps_state != PS_STATE_SLEEP)
2194                 mwifiex_pcie_enable_host_int(adapter);
2195
2196         return 0;
2197 }
2198
2199 /*
2200  * This function downloads data from driver to card.
2201  *
2202  * Both commands and data packets are transferred to the card by this
2203  * function.
2204  *
2205  * This function adds the PCIE specific header to the front of the buffer
2206  * before transferring. The header contains the length of the packet and
2207  * the type. The firmware handles the packets based upon this set type.
2208  */
2209 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2210                                      struct sk_buff *skb,
2211                                      struct mwifiex_tx_param *tx_param)
2212 {
2213         if (!skb) {
2214                 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2215                 return -1;
2216         }
2217
2218         if (type == MWIFIEX_TYPE_DATA)
2219                 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2220         else if (type == MWIFIEX_TYPE_CMD)
2221                 return mwifiex_pcie_send_cmd(adapter, skb);
2222
2223         return 0;
2224 }
2225
2226 /* This function read/write firmware */
2227 static enum rdwr_status
2228 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter *adapter, u8 doneflag)
2229 {
2230         int ret, tries;
2231         u8 ctrl_data;
2232         struct pcie_service_card *card = adapter->card;
2233         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2234
2235         ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl, FW_DUMP_HOST_READY);
2236         if (ret) {
2237                 dev_err(adapter->dev, "PCIE write err\n");
2238                 return RDWR_STATUS_FAILURE;
2239         }
2240
2241         for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2242                 mwifiex_read_reg_byte(adapter, reg->fw_dump_ctrl, &ctrl_data);
2243                 if (ctrl_data == FW_DUMP_DONE)
2244                         return RDWR_STATUS_SUCCESS;
2245                 if (doneflag && ctrl_data == doneflag)
2246                         return RDWR_STATUS_DONE;
2247                 if (ctrl_data != FW_DUMP_HOST_READY) {
2248                         dev_info(adapter->dev,
2249                                  "The ctrl reg was changed, re-try again!\n");
2250                         ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2251                                                 FW_DUMP_HOST_READY);
2252                         if (ret) {
2253                                 dev_err(adapter->dev, "PCIE write err\n");
2254                                 return RDWR_STATUS_FAILURE;
2255                         }
2256                 }
2257                 usleep_range(100, 200);
2258         }
2259
2260         dev_err(adapter->dev, "Fail to pull ctrl_data\n");
2261         return RDWR_STATUS_FAILURE;
2262 }
2263
2264 /* This function dump firmware memory to file */
2265 static void mwifiex_pcie_fw_dump_work(struct mwifiex_adapter *adapter)
2266 {
2267         struct pcie_service_card *card = adapter->card;
2268         const struct mwifiex_pcie_card_reg *creg = card->pcie.reg;
2269         unsigned int reg, reg_start, reg_end;
2270         u8 *dbg_ptr, *end_ptr, dump_num, idx, i, read_reg, doneflag = 0;
2271         enum rdwr_status stat;
2272         u32 memory_size;
2273         int ret;
2274         static char *env[] = { "DRIVER=mwifiex_pcie", "EVENT=fw_dump", NULL };
2275
2276         if (!card->pcie.supports_fw_dump)
2277                 return;
2278
2279         for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) {
2280                 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
2281
2282                 if (entry->mem_ptr) {
2283                         vfree(entry->mem_ptr);
2284                         entry->mem_ptr = NULL;
2285                 }
2286                 entry->mem_size = 0;
2287         }
2288
2289         dev_info(adapter->dev, "== mwifiex firmware dump start ==\n");
2290
2291         /* Read the number of the memories which will dump */
2292         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2293         if (stat == RDWR_STATUS_FAILURE)
2294                 goto done;
2295
2296         reg = creg->fw_dump_start;
2297         mwifiex_read_reg_byte(adapter, reg, &dump_num);
2298
2299         /* Read the length of every memory which will dump */
2300         for (idx = 0; idx < dump_num; idx++) {
2301                 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
2302
2303                 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2304                 if (stat == RDWR_STATUS_FAILURE)
2305                         goto done;
2306
2307                 memory_size = 0;
2308                 reg = creg->fw_dump_start;
2309                 for (i = 0; i < 4; i++) {
2310                         mwifiex_read_reg_byte(adapter, reg, &read_reg);
2311                         memory_size |= (read_reg << (i * 8));
2312                         reg++;
2313                 }
2314
2315                 if (memory_size == 0) {
2316                         dev_info(adapter->dev, "Firmware dump Finished!\n");
2317                         ret = mwifiex_write_reg(adapter, creg->fw_dump_ctrl,
2318                                                 FW_DUMP_READ_DONE);
2319                         if (ret) {
2320                                 dev_err(adapter->dev, "PCIE write err\n");
2321                                 goto done;
2322                         }
2323                         break;
2324                 }
2325
2326                 dev_info(adapter->dev,
2327                          "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2328                 entry->mem_ptr = vmalloc(memory_size + 1);
2329                 entry->mem_size = memory_size;
2330                 if (!entry->mem_ptr) {
2331                         dev_err(adapter->dev,
2332                                 "Vmalloc %s failed\n", entry->mem_name);
2333                         goto done;
2334                 }
2335                 dbg_ptr = entry->mem_ptr;
2336                 end_ptr = dbg_ptr + memory_size;
2337
2338                 doneflag = entry->done_flag;
2339                 dev_info(adapter->dev, "Start %s output, please wait...\n",
2340                          entry->mem_name);
2341
2342                 do {
2343                         stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2344                         if (RDWR_STATUS_FAILURE == stat)
2345                                 goto done;
2346
2347                         reg_start = creg->fw_dump_start;
2348                         reg_end = creg->fw_dump_end;
2349                         for (reg = reg_start; reg <= reg_end; reg++) {
2350                                 mwifiex_read_reg_byte(adapter, reg, dbg_ptr);
2351                                 if (dbg_ptr < end_ptr) {
2352                                         dbg_ptr++;
2353                                 } else {
2354                                         dev_err(adapter->dev,
2355                                                 "Allocated buf not enough\n");
2356                                         goto done;
2357                                 }
2358                         }
2359
2360                         if (stat != RDWR_STATUS_DONE)
2361                                 continue;
2362
2363                         dev_info(adapter->dev, "%s done: size=0x%tx\n",
2364                                  entry->mem_name, dbg_ptr - entry->mem_ptr);
2365                         break;
2366                 } while (true);
2367         }
2368         dev_info(adapter->dev, "== mwifiex firmware dump end ==\n");
2369
2370         kobject_uevent_env(&adapter->wiphy->dev.kobj, KOBJ_CHANGE, env);
2371
2372 done:
2373         adapter->curr_mem_idx = 0;
2374 }
2375
2376 static void mwifiex_pcie_work(struct work_struct *work)
2377 {
2378         struct mwifiex_adapter *adapter =
2379                         container_of(work, struct mwifiex_adapter, iface_work);
2380
2381         if (test_and_clear_bit(MWIFIEX_IFACE_WORK_FW_DUMP,
2382                                &adapter->iface_work_flags))
2383                 mwifiex_pcie_fw_dump_work(adapter);
2384 }
2385
2386 /* This function dumps FW information */
2387 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter *adapter)
2388 {
2389         if (test_bit(MWIFIEX_IFACE_WORK_FW_DUMP, &adapter->iface_work_flags))
2390                 return;
2391
2392         set_bit(MWIFIEX_IFACE_WORK_FW_DUMP, &adapter->iface_work_flags);
2393
2394         schedule_work(&adapter->iface_work);
2395 }
2396
2397 /*
2398  * This function initializes the PCI-E host memory space, WCB rings, etc.
2399  *
2400  * The following initializations steps are followed -
2401  *      - Allocate TXBD ring buffers
2402  *      - Allocate RXBD ring buffers
2403  *      - Allocate event BD ring buffers
2404  *      - Allocate command response ring buffer
2405  *      - Allocate sleep cookie buffer
2406  */
2407 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2408 {
2409         struct pcie_service_card *card = adapter->card;
2410         int ret;
2411         struct pci_dev *pdev = card->dev;
2412         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2413
2414         pci_set_drvdata(pdev, card);
2415
2416         ret = pci_enable_device(pdev);
2417         if (ret)
2418                 goto err_enable_dev;
2419
2420         pci_set_master(pdev);
2421
2422         dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2423         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2424         if (ret) {
2425                 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2426                 goto err_set_dma_mask;
2427         }
2428
2429         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2430         if (ret) {
2431                 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2432                 goto err_set_dma_mask;
2433         }
2434
2435         ret = pci_request_region(pdev, 0, DRV_NAME);
2436         if (ret) {
2437                 dev_err(adapter->dev, "req_reg(0) error\n");
2438                 goto err_req_region0;
2439         }
2440         card->pci_mmap = pci_iomap(pdev, 0, 0);
2441         if (!card->pci_mmap) {
2442                 dev_err(adapter->dev, "iomap(0) error\n");
2443                 ret = -EIO;
2444                 goto err_iomap0;
2445         }
2446         ret = pci_request_region(pdev, 2, DRV_NAME);
2447         if (ret) {
2448                 dev_err(adapter->dev, "req_reg(2) error\n");
2449                 goto err_req_region2;
2450         }
2451         card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2452         if (!card->pci_mmap1) {
2453                 dev_err(adapter->dev, "iomap(2) error\n");
2454                 ret = -EIO;
2455                 goto err_iomap2;
2456         }
2457
2458         dev_dbg(adapter->dev,
2459                 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2460                 card->pci_mmap, card->pci_mmap1);
2461
2462         card->cmdrsp_buf = NULL;
2463         ret = mwifiex_pcie_create_txbd_ring(adapter);
2464         if (ret)
2465                 goto err_cre_txbd;
2466         ret = mwifiex_pcie_create_rxbd_ring(adapter);
2467         if (ret)
2468                 goto err_cre_rxbd;
2469         ret = mwifiex_pcie_create_evtbd_ring(adapter);
2470         if (ret)
2471                 goto err_cre_evtbd;
2472         ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2473         if (ret)
2474                 goto err_alloc_cmdbuf;
2475         if (reg->sleep_cookie) {
2476                 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2477                 if (ret)
2478                         goto err_alloc_cookie;
2479         } else {
2480                 card->sleep_cookie_vbase = NULL;
2481         }
2482         return ret;
2483
2484 err_alloc_cookie:
2485         mwifiex_pcie_delete_cmdrsp_buf(adapter);
2486 err_alloc_cmdbuf:
2487         mwifiex_pcie_delete_evtbd_ring(adapter);
2488 err_cre_evtbd:
2489         mwifiex_pcie_delete_rxbd_ring(adapter);
2490 err_cre_rxbd:
2491         mwifiex_pcie_delete_txbd_ring(adapter);
2492 err_cre_txbd:
2493         pci_iounmap(pdev, card->pci_mmap1);
2494 err_iomap2:
2495         pci_release_region(pdev, 2);
2496 err_req_region2:
2497         pci_iounmap(pdev, card->pci_mmap);
2498 err_iomap0:
2499         pci_release_region(pdev, 0);
2500 err_req_region0:
2501 err_set_dma_mask:
2502         pci_disable_device(pdev);
2503 err_enable_dev:
2504         pci_set_drvdata(pdev, NULL);
2505         return ret;
2506 }
2507
2508 /*
2509  * This function cleans up the allocated card buffers.
2510  *
2511  * The following are freed by this function -
2512  *      - TXBD ring buffers
2513  *      - RXBD ring buffers
2514  *      - Event BD ring buffers
2515  *      - Command response ring buffer
2516  *      - Sleep cookie buffer
2517  */
2518 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2519 {
2520         struct pcie_service_card *card = adapter->card;
2521         struct pci_dev *pdev = card->dev;
2522         const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2523
2524         if (user_rmmod) {
2525                 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2526                 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2527                         dev_err(adapter->dev,
2528                                 "Failed to write driver not-ready signature\n");
2529         }
2530
2531         if (pdev) {
2532                 pci_iounmap(pdev, card->pci_mmap);
2533                 pci_iounmap(pdev, card->pci_mmap1);
2534                 pci_disable_device(pdev);
2535                 pci_release_region(pdev, 2);
2536                 pci_release_region(pdev, 0);
2537                 pci_set_drvdata(pdev, NULL);
2538         }
2539         kfree(card);
2540 }
2541
2542 /*
2543  * This function registers the PCIE device.
2544  *
2545  * PCIE IRQ is claimed, block size is set and driver data is initialized.
2546  */
2547 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2548 {
2549         int ret;
2550         struct pcie_service_card *card = adapter->card;
2551         struct pci_dev *pdev = card->dev;
2552
2553         /* save adapter pointer in card */
2554         card->adapter = adapter;
2555
2556         ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2557                           "MRVL_PCIE", pdev);
2558         if (ret) {
2559                 pr_err("request_irq failed: ret=%d\n", ret);
2560                 adapter->card = NULL;
2561                 return -1;
2562         }
2563
2564         adapter->dev = &pdev->dev;
2565         adapter->tx_buf_size = card->pcie.tx_buf_size;
2566         adapter->mem_type_mapping_tbl = mem_type_mapping_tbl;
2567         adapter->num_mem_types = ARRAY_SIZE(mem_type_mapping_tbl);
2568         strcpy(adapter->fw_name, card->pcie.firmware);
2569
2570         return 0;
2571 }
2572
2573 /*
2574  * This function unregisters the PCIE device.
2575  *
2576  * The PCIE IRQ is released, the function is disabled and driver
2577  * data is set to null.
2578  */
2579 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2580 {
2581         struct pcie_service_card *card = adapter->card;
2582         const struct mwifiex_pcie_card_reg *reg;
2583
2584         if (card) {
2585                 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2586                 free_irq(card->dev->irq, card->dev);
2587
2588                 reg = card->pcie.reg;
2589                 if (reg->sleep_cookie)
2590                         mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2591
2592                 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2593                 mwifiex_pcie_delete_evtbd_ring(adapter);
2594                 mwifiex_pcie_delete_rxbd_ring(adapter);
2595                 mwifiex_pcie_delete_txbd_ring(adapter);
2596                 card->cmdrsp_buf = NULL;
2597         }
2598 }
2599
2600 static struct mwifiex_if_ops pcie_ops = {
2601         .init_if =                      mwifiex_pcie_init,
2602         .cleanup_if =                   mwifiex_pcie_cleanup,
2603         .check_fw_status =              mwifiex_check_fw_status,
2604         .prog_fw =                      mwifiex_prog_fw_w_helper,
2605         .register_dev =                 mwifiex_register_dev,
2606         .unregister_dev =               mwifiex_unregister_dev,
2607         .enable_int =                   mwifiex_pcie_enable_host_int,
2608         .process_int_status =           mwifiex_process_int_status,
2609         .host_to_card =                 mwifiex_pcie_host_to_card,
2610         .wakeup =                       mwifiex_pm_wakeup_card,
2611         .wakeup_complete =              mwifiex_pm_wakeup_card_complete,
2612
2613         /* PCIE specific */
2614         .cmdrsp_complete =              mwifiex_pcie_cmdrsp_complete,
2615         .event_complete =               mwifiex_pcie_event_complete,
2616         .update_mp_end_port =           NULL,
2617         .cleanup_mpa_buf =              NULL,
2618         .init_fw_port =                 mwifiex_pcie_init_fw_port,
2619         .clean_pcie_ring =              mwifiex_clean_pcie_ring_buf,
2620         .fw_dump =                      mwifiex_pcie_fw_dump,
2621         .iface_work =                   mwifiex_pcie_work,
2622 };
2623
2624 /*
2625  * This function initializes the PCIE driver module.
2626  *
2627  * This initiates the semaphore and registers the device with
2628  * PCIE bus.
2629  */
2630 static int mwifiex_pcie_init_module(void)
2631 {
2632         int ret;
2633
2634         pr_debug("Marvell PCIe Driver\n");
2635
2636         sema_init(&add_remove_card_sem, 1);
2637
2638         /* Clear the flag in case user removes the card. */
2639         user_rmmod = 0;
2640
2641         ret = pci_register_driver(&mwifiex_pcie);
2642         if (ret)
2643                 pr_err("Driver register failed!\n");
2644         else
2645                 pr_debug("info: Driver registered successfully!\n");
2646
2647         return ret;
2648 }
2649
2650 /*
2651  * This function cleans up the PCIE driver.
2652  *
2653  * The following major steps are followed for cleanup -
2654  *      - Resume the device if its suspended
2655  *      - Disconnect the device if connected
2656  *      - Shutdown the firmware
2657  *      - Unregister the device from PCIE bus.
2658  */
2659 static void mwifiex_pcie_cleanup_module(void)
2660 {
2661         if (!down_interruptible(&add_remove_card_sem))
2662                 up(&add_remove_card_sem);
2663
2664         /* Set the flag as user is removing this module. */
2665         user_rmmod = 1;
2666
2667         pci_unregister_driver(&mwifiex_pcie);
2668 }
2669
2670 module_init(mwifiex_pcie_init_module);
2671 module_exit(mwifiex_pcie_cleanup_module);
2672
2673 MODULE_AUTHOR("Marvell International Ltd.");
2674 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2675 MODULE_VERSION(PCIE_VERSION);
2676 MODULE_LICENSE("GPL v2");
2677 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2678 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);