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