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