drivers/net/wireless/mwifiex/pcie.c

   1 /*
   2  * Marvell Wireless LAN device driver: PCIE specific handling
   3  *
   4  * Copyright (C) 2011, Marvell International Ltd.
   5  *
   6  * This software file (the "File") is distributed by Marvell International
   7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
   8  * (the "License").  You may use, redistribute and/or modify this File in
   9  * accordance with the terms and conditions of the License, a copy of which
  10  * is available by writing to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
  12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  13  *
  14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
  17  * this warranty disclaimer.
  18  */
  19
  20 #include <linux/firmware.h>
  21
  22 #include "decl.h"
  23 #include "ioctl.h"
  24 #include "util.h"
  25 #include "fw.h"
  26 #include "main.h"
  27 #include "wmm.h"
  28 #include "11n.h"
  29 #include "pcie.h"
  30
  31 #define PCIE_VERSION    "1.0"
  32 #define DRV_NAME        "Marvell mwifiex PCIe"
  33
  34 static u8 user_rmmod;
  35
  36 static struct mwifiex_if_ops pcie_ops;
  37
  38 static struct semaphore add_remove_card_sem;
  39 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter);
  40 static int mwifiex_pcie_resume(struct pci_dev *pdev);
  41
  42 /*
  43  * This function is called after skb allocation to update
  44  * "skb->cb" with physical address of data pointer.
  45  */
  46 static phys_addr_t *mwifiex_update_sk_buff_pa(struct sk_buff *skb)
  47 {
  48         phys_addr_t *buf_pa = MWIFIEX_SKB_PACB(skb);
  49
  50         *buf_pa = (phys_addr_t)virt_to_phys(skb->data);
  51
  52         return buf_pa;
  53 }
  54
  55 /*
  56  * This function reads sleep cookie and checks if FW is ready
  57  */
  58 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
  59 {
  60         u32 *cookie_addr;
  61         struct pcie_service_card *card = adapter->card;
  62
  63         if (card->sleep_cookie) {
  64                 cookie_addr = (u32 *)card->sleep_cookie->data;
  65                 dev_dbg(adapter->dev, "info: ACCESS_HW: sleep cookie=0x%x\n",
  66                         *cookie_addr);
  67                 if (*cookie_addr == FW_AWAKE_COOKIE)
  68                         return true;
  69         }
  70
  71         return false;
  72 }
  73
  74 /*
  75  * This function probes an mwifiex device and registers it. It allocates
  76  * the card structure, enables PCIE function number and initiates the
  77  * device registration and initialization procedure by adding a logical
  78  * interface.
  79  */
  80 static int mwifiex_pcie_probe(struct pci_dev *pdev,
  81                                         const struct pci_device_id *ent)
  82 {
  83         struct pcie_service_card *card;
  84
  85         pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
  86                  pdev->vendor, pdev->device, pdev->revision);
  87
  88         card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
  89         if (!card) {
  90                 pr_err("%s: failed to alloc memory\n", __func__);
  91                 return -ENOMEM;
  92         }
  93
  94         card->dev = pdev;
  95
  96         if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
  97                              MWIFIEX_PCIE)) {
  98                 pr_err("%s failed\n", __func__);
  99                 kfree(card);
 100                 return -1;
 101         }
 102
 103         return 0;
 104 }
 105
 106 /*
 107  * This function removes the interface and frees up the card structure.
 108  */
 109 static void mwifiex_pcie_remove(struct pci_dev *pdev)
 110 {
 111         struct pcie_service_card *card;
 112         struct mwifiex_adapter *adapter;
 113         struct mwifiex_private *priv;
 114         int i;
 115
 116         card = pci_get_drvdata(pdev);
 117         if (!card)
 118                 return;
 119
 120         adapter = card->adapter;
 121         if (!adapter || !adapter->priv_num)
 122                 return;
 123
 124         if (user_rmmod) {
 125 #ifdef CONFIG_PM
 126                 if (adapter->is_suspended)
 127                         mwifiex_pcie_resume(pdev);
 128 #endif
 129
 130                 for (i = 0; i < adapter->priv_num; i++)
 131                         if ((GET_BSS_ROLE(adapter->priv[i]) ==
 132                              MWIFIEX_BSS_ROLE_STA) &&
 133                             adapter->priv[i]->media_connected)
 134                                 mwifiex_deauthenticate(adapter->priv[i], NULL);
 135
 136                 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
 137
 138                 mwifiex_disable_auto_ds(priv);
 139
 140                 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
 141         }
 142
 143         mwifiex_remove_card(card->adapter, &add_remove_card_sem);
 144         kfree(card);
 145 }
 146
 147 /*
 148  * Kernel needs to suspend all functions separately. Therefore all
 149  * registered functions must have drivers with suspend and resume
 150  * methods. Failing that the kernel simply removes the whole card.
 151  *
 152  * If already not suspended, this function allocates and sends a host
 153  * sleep activate request to the firmware and turns off the traffic.
 154  */
 155 static int mwifiex_pcie_suspend(struct pci_dev *pdev, pm_message_t state)
 156 {
 157         struct mwifiex_adapter *adapter;
 158         struct pcie_service_card *card;
 159         int hs_actived, i;
 160
 161         if (pdev) {
 162                 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
 163                 if (!card || card->adapter) {
 164                         pr_err("Card or adapter structure is not valid\n");
 165                         return 0;
 166                 }
 167         } else {
 168                 pr_err("PCIE device is not specified\n");
 169                 return 0;
 170         }
 171
 172         adapter = card->adapter;
 173
 174         hs_actived = mwifiex_enable_hs(adapter);
 175
 176         /* Indicate device suspended */
 177         adapter->is_suspended = true;
 178
 179         for (i = 0; i < adapter->priv_num; i++)
 180                 netif_carrier_off(adapter->priv[i]->netdev);
 181
 182         return 0;
 183 }
 184
 185 /*
 186  * Kernel needs to suspend all functions separately. Therefore all
 187  * registered functions must have drivers with suspend and resume
 188  * methods. Failing that the kernel simply removes the whole card.
 189  *
 190  * If already not resumed, this function turns on the traffic and
 191  * sends a host sleep cancel request to the firmware.
 192  */
 193 static int mwifiex_pcie_resume(struct pci_dev *pdev)
 194 {
 195         struct mwifiex_adapter *adapter;
 196         struct pcie_service_card *card;
 197         int i;
 198
 199         if (pdev) {
 200                 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
 201                 if (!card || !card->adapter) {
 202                         pr_err("Card or adapter structure is not valid\n");
 203                         return 0;
 204                 }
 205         } else {
 206                 pr_err("PCIE device is not specified\n");
 207                 return 0;
 208         }
 209
 210         adapter = card->adapter;
 211
 212         if (!adapter->is_suspended) {
 213                 dev_warn(adapter->dev, "Device already resumed\n");
 214                 return 0;
 215         }
 216
 217         adapter->is_suspended = false;
 218
 219         for (i = 0; i < adapter->priv_num; i++)
 220                 if (adapter->priv[i]->media_connected)
 221                         netif_carrier_on(adapter->priv[i]->netdev);
 222
 223         mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
 224                           MWIFIEX_ASYNC_CMD);
 225
 226         return 0;
 227 }
 228
 229 #define PCIE_VENDOR_ID_MARVELL              (0x11ab)
 230 #define PCIE_DEVICE_ID_MARVELL_88W8766P         (0x2b30)
 231
 232 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
 233         {
 234                 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
 235                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 236         },
 237         {},
 238 };
 239
 240 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
 241
 242 /* PCI Device Driver */
 243 static struct pci_driver __refdata mwifiex_pcie = {
 244         .name     = "mwifiex_pcie",
 245         .id_table = mwifiex_ids,
 246         .probe    = mwifiex_pcie_probe,
 247         .remove   = mwifiex_pcie_remove,
 248 #ifdef CONFIG_PM
 249         /* Power Management Hooks */
 250         .suspend  = mwifiex_pcie_suspend,
 251         .resume   = mwifiex_pcie_resume,
 252 #endif
 253 };
 254
 255 /*
 256  * This function writes data into PCIE card register.
 257  */
 258 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
 259 {
 260         struct pcie_service_card *card = adapter->card;
 261
 262         iowrite32(data, card->pci_mmap1 + reg);
 263
 264         return 0;
 265 }
 266
 267 /*
 268  * This function reads data from PCIE card register.
 269  */
 270 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
 271 {
 272         struct pcie_service_card *card = adapter->card;
 273
 274         *data = ioread32(card->pci_mmap1 + reg);
 275
 276         return 0;
 277 }
 278
 279 /*
 280  * This function wakes up the card.
 281  *
 282  * A host power up command is written to the card configuration
 283  * register to wake up the card.
 284  */
 285 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
 286 {
 287         int i = 0;
 288
 289         while (mwifiex_pcie_ok_to_access_hw(adapter)) {
 290                 i++;
 291                 usleep_range(10, 20);
 292                 /* 50ms max wait */
 293                 if (i == 50000)
 294                         break;
 295         }
 296
 297         dev_dbg(adapter->dev, "event: Wakeup device...\n");
 298
 299         /* Enable interrupts or any chip access will wakeup device */
 300         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK, HOST_INTR_MASK)) {
 301                 dev_warn(adapter->dev, "Enable host interrupt failed\n");
 302                 return -1;
 303         }
 304
 305         dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
 306         adapter->ps_state = PS_STATE_AWAKE;
 307
 308         return 0;
 309 }
 310
 311 /*
 312  * This function is called after the card has woken up.
 313  *
 314  * The card configuration register is reset.
 315  */
 316 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
 317 {
 318         dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
 319
 320         return 0;
 321 }
 322
 323 /*
 324  * This function disables the host interrupt.
 325  *
 326  * The host interrupt mask is read, the disable bit is reset and
 327  * written back to the card host interrupt mask register.
 328  */
 329 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
 330 {
 331         if (mwifiex_pcie_ok_to_access_hw(adapter)) {
 332                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
 333                                       0x00000000)) {
 334                         dev_warn(adapter->dev, "Disable host interrupt failed\n");
 335                         return -1;
 336                 }
 337         }
 338
 339         return 0;
 340 }
 341
 342 /*
 343  * This function enables the host interrupt.
 344  *
 345  * The host interrupt enable mask is written to the card
 346  * host interrupt mask register.
 347  */
 348 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
 349 {
 350         if (mwifiex_pcie_ok_to_access_hw(adapter)) {
 351                 /* Simply write the mask to the register */
 352                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
 353                                       HOST_INTR_MASK)) {
 354                         dev_warn(adapter->dev, "Enable host interrupt failed\n");
 355                         return -1;
 356                 }
 357         }
 358
 359         return 0;
 360 }
 361
 362 /*
 363  * This function creates buffer descriptor ring for TX
 364  */
 365 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
 366 {
 367         struct pcie_service_card *card = adapter->card;
 368         struct sk_buff *skb;
 369         int i;
 370         phys_addr_t *buf_pa;
 371
 372         /*
 373          * driver maintaines the write pointer and firmware maintaines the read
 374          * pointer. The write pointer starts at 0 (zero) while the read pointer
 375          * starts at zero with rollover bit set
 376          */
 377         card->txbd_wrptr = 0;
 378         card->txbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
 379
 380         /* allocate shared memory for the BD ring and divide the same in to
 381            several descriptors */
 382         card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
 383                                                         MWIFIEX_MAX_TXRX_BD;
 384         dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
 385                 card->txbd_ring_size);
 386         card->txbd_ring_vbase = kzalloc(card->txbd_ring_size, GFP_KERNEL);
 387         if (!card->txbd_ring_vbase) {
 388                 dev_err(adapter->dev, "Unable to alloc buffer for txbd ring\n");
 389                 return -ENOMEM;
 390         }
 391         card->txbd_ring_pbase = virt_to_phys(card->txbd_ring_vbase);
 392
 393         dev_dbg(adapter->dev,
 394                 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
 395                 card->txbd_ring_vbase, (u32)card->txbd_ring_pbase,
 396                 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
 397
 398         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 399                 card->txbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
 400                                      (card->txbd_ring_vbase +
 401                                       (sizeof(struct mwifiex_pcie_buf_desc)
 402                                        * i));
 403
 404                 /* Allocate buffer here so that firmware can DMA data from it */
 405                 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
 406                 if (!skb) {
 407                         dev_err(adapter->dev, "Unable to allocate skb for TX ring.\n");
 408                         kfree(card->txbd_ring_vbase);
 409                         return -ENOMEM;
 410                 }
 411                 buf_pa = mwifiex_update_sk_buff_pa(skb);
 412
 413                 skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE);
 414                 dev_dbg(adapter->dev, "info: TX ring: add new skb base: %p, "
 415                         "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
 416                         skb, skb->data, (u32)*buf_pa,
 417                         (u32)(((u64)*buf_pa >> 32)), skb->len);
 418
 419                 card->tx_buf_list[i] = skb;
 420                 card->txbd_ring[i]->paddr = *buf_pa;
 421                 card->txbd_ring[i]->len = (u16)skb->len;
 422                 card->txbd_ring[i]->flags = 0;
 423         }
 424
 425         return 0;
 426 }
 427
 428 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
 429 {
 430         struct pcie_service_card *card = adapter->card;
 431         int i;
 432
 433         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 434                 if (card->tx_buf_list[i])
 435                         dev_kfree_skb_any(card->tx_buf_list[i]);
 436                 card->tx_buf_list[i] = NULL;
 437                 card->txbd_ring[i]->paddr = 0;
 438                 card->txbd_ring[i]->len = 0;
 439                 card->txbd_ring[i]->flags = 0;
 440                 card->txbd_ring[i] = NULL;
 441         }
 442
 443         kfree(card->txbd_ring_vbase);
 444         card->txbd_ring_size = 0;
 445         card->txbd_wrptr = 0;
 446         card->txbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
 447         card->txbd_ring_vbase = NULL;
 448
 449         return 0;
 450 }
 451
 452 /*
 453  * This function creates buffer descriptor ring for RX
 454  */
 455 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
 456 {
 457         struct pcie_service_card *card = adapter->card;
 458         struct sk_buff *skb;
 459         int i;
 460         phys_addr_t *buf_pa;
 461
 462         /*
 463          * driver maintaines the read pointer and firmware maintaines the write
 464          * pointer. The write pointer starts at 0 (zero) while the read pointer
 465          * starts at zero with rollover bit set
 466          */
 467         card->rxbd_wrptr = 0;
 468         card->rxbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
 469
 470         card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
 471                                                         MWIFIEX_MAX_TXRX_BD;
 472         dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
 473                 card->rxbd_ring_size);
 474         card->rxbd_ring_vbase = kzalloc(card->rxbd_ring_size, GFP_KERNEL);
 475         if (!card->rxbd_ring_vbase) {
 476                 dev_err(adapter->dev, "Unable to allocate buffer for "
 477                                 "rxbd_ring.\n");
 478                 return -ENOMEM;
 479         }
 480         card->rxbd_ring_pbase = virt_to_phys(card->rxbd_ring_vbase);
 481
 482         dev_dbg(adapter->dev,
 483                 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
 484                 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
 485                 (u32)((u64)card->rxbd_ring_pbase >> 32),
 486                 card->rxbd_ring_size);
 487
 488         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 489                 card->rxbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
 490                                      (card->rxbd_ring_vbase +
 491                                       (sizeof(struct mwifiex_pcie_buf_desc)
 492                                        * i));
 493
 494                 /* Allocate skb here so that firmware can DMA data from it */
 495                 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
 496                 if (!skb) {
 497                         dev_err(adapter->dev,
 498                                 "Unable to allocate skb for RX ring.\n");
 499                         kfree(card->rxbd_ring_vbase);
 500                         return -ENOMEM;
 501                 }
 502                 buf_pa = mwifiex_update_sk_buff_pa(skb);
 503                 skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE);
 504
 505                 dev_dbg(adapter->dev, "info: RX ring: add new skb base: %p, "
 506                         "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
 507                         skb, skb->data, (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
 508                         skb->len);
 509
 510                 card->rx_buf_list[i] = skb;
 511                 card->rxbd_ring[i]->paddr = *buf_pa;
 512                 card->rxbd_ring[i]->len = (u16)skb->len;
 513                 card->rxbd_ring[i]->flags = 0;
 514         }
 515
 516         return 0;
 517 }
 518
 519 /*
 520  * This function deletes Buffer descriptor ring for RX
 521  */
 522 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
 523 {
 524         struct pcie_service_card *card = adapter->card;
 525         int i;
 526
 527         for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
 528                 if (card->rx_buf_list[i])
 529                         dev_kfree_skb_any(card->rx_buf_list[i]);
 530                 card->rx_buf_list[i] = NULL;
 531                 card->rxbd_ring[i]->paddr = 0;
 532                 card->rxbd_ring[i]->len = 0;
 533                 card->rxbd_ring[i]->flags = 0;
 534                 card->rxbd_ring[i] = NULL;
 535         }
 536
 537         kfree(card->rxbd_ring_vbase);
 538         card->rxbd_ring_size = 0;
 539         card->rxbd_wrptr = 0;
 540         card->rxbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
 541         card->rxbd_ring_vbase = NULL;
 542
 543         return 0;
 544 }
 545
 546 /*
 547  * This function creates buffer descriptor ring for Events
 548  */
 549 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
 550 {
 551         struct pcie_service_card *card = adapter->card;
 552         struct sk_buff *skb;
 553         int i;
 554         phys_addr_t *buf_pa;
 555
 556         /*
 557          * driver maintaines the read pointer and firmware maintaines the write
 558          * pointer. The write pointer starts at 0 (zero) while the read pointer
 559          * starts at zero with rollover bit set
 560          */
 561         card->evtbd_wrptr = 0;
 562         card->evtbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
 563
 564         card->evtbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
 565                                                         MWIFIEX_MAX_EVT_BD;
 566         dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
 567                 card->evtbd_ring_size);
 568         card->evtbd_ring_vbase = kzalloc(card->evtbd_ring_size, GFP_KERNEL);
 569         if (!card->evtbd_ring_vbase) {
 570                 dev_err(adapter->dev,
 571                         "Unable to allocate buffer. Terminating download\n");
 572                 return -ENOMEM;
 573         }
 574         card->evtbd_ring_pbase = virt_to_phys(card->evtbd_ring_vbase);
 575
 576         dev_dbg(adapter->dev,
 577                 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
 578                 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
 579                 (u32)((u64)card->evtbd_ring_pbase >> 32),
 580                 card->evtbd_ring_size);
 581
 582         for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
 583                 card->evtbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
 584                                       (card->evtbd_ring_vbase +
 585                                        (sizeof(struct mwifiex_pcie_buf_desc)
 586                                         * i));
 587
 588                 /* Allocate skb here so that firmware can DMA data from it */
 589                 skb = dev_alloc_skb(MAX_EVENT_SIZE);
 590                 if (!skb) {
 591                         dev_err(adapter->dev,
 592                                 "Unable to allocate skb for EVENT buf.\n");
 593                         kfree(card->evtbd_ring_vbase);
 594                         return -ENOMEM;
 595                 }
 596                 buf_pa = mwifiex_update_sk_buff_pa(skb);
 597                 skb_put(skb, MAX_EVENT_SIZE);
 598
 599                 dev_dbg(adapter->dev, "info: Evt ring: add new skb. base: %p, "
 600                         "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
 601                         skb, skb->data, (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
 602                         skb->len);
 603
 604                 card->evt_buf_list[i] = skb;
 605                 card->evtbd_ring[i]->paddr = *buf_pa;
 606                 card->evtbd_ring[i]->len = (u16)skb->len;
 607                 card->evtbd_ring[i]->flags = 0;
 608         }
 609
 610         return 0;
 611 }
 612
 613 /*
 614  * This function deletes Buffer descriptor ring for Events
 615  */
 616 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
 617 {
 618         struct pcie_service_card *card = adapter->card;
 619         int i;
 620
 621         for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
 622                 if (card->evt_buf_list[i])
 623                         dev_kfree_skb_any(card->evt_buf_list[i]);
 624                 card->evt_buf_list[i] = NULL;
 625                 card->evtbd_ring[i]->paddr = 0;
 626                 card->evtbd_ring[i]->len = 0;
 627                 card->evtbd_ring[i]->flags = 0;
 628                 card->evtbd_ring[i] = NULL;
 629         }
 630
 631         kfree(card->evtbd_ring_vbase);
 632         card->evtbd_wrptr = 0;
 633         card->evtbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
 634         card->evtbd_ring_size = 0;
 635         card->evtbd_ring_vbase = NULL;
 636
 637         return 0;
 638 }
 639
 640 /*
 641  * This function allocates a buffer for CMDRSP
 642  */
 643 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
 644 {
 645         struct pcie_service_card *card = adapter->card;
 646         struct sk_buff *skb;
 647
 648         /* Allocate memory for receiving command response data */
 649         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
 650         if (!skb) {
 651                 dev_err(adapter->dev,
 652                         "Unable to allocate skb for command response data.\n");
 653                 return -ENOMEM;
 654         }
 655         mwifiex_update_sk_buff_pa(skb);
 656         skb_put(skb, MWIFIEX_UPLD_SIZE);
 657         card->cmdrsp_buf = skb;
 658
 659         skb = NULL;
 660         /* Allocate memory for sending command to firmware */
 661         skb = dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER);
 662         if (!skb) {
 663                 dev_err(adapter->dev,
 664                         "Unable to allocate skb for command data.\n");
 665                 return -ENOMEM;
 666         }
 667         mwifiex_update_sk_buff_pa(skb);
 668         skb_put(skb, MWIFIEX_SIZE_OF_CMD_BUFFER);
 669         card->cmd_buf = skb;
 670
 671         return 0;
 672 }
 673
 674 /*
 675  * This function deletes a buffer for CMDRSP
 676  */
 677 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
 678 {
 679         struct pcie_service_card *card;
 680
 681         if (!adapter)
 682                 return 0;
 683
 684         card = adapter->card;
 685
 686         if (card && card->cmdrsp_buf)
 687                 dev_kfree_skb_any(card->cmdrsp_buf);
 688
 689         if (card && card->cmd_buf)
 690                 dev_kfree_skb_any(card->cmd_buf);
 691
 692         return 0;
 693 }
 694
 695 /*
 696  * This function allocates a buffer for sleep cookie
 697  */
 698 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
 699 {
 700         struct sk_buff *skb;
 701         struct pcie_service_card *card = adapter->card;
 702
 703         /* Allocate memory for sleep cookie */
 704         skb = dev_alloc_skb(sizeof(u32));
 705         if (!skb) {
 706                 dev_err(adapter->dev,
 707                         "Unable to allocate skb for sleep cookie!\n");
 708                 return -ENOMEM;
 709         }
 710         mwifiex_update_sk_buff_pa(skb);
 711         skb_put(skb, sizeof(u32));
 712
 713         /* Init val of Sleep Cookie */
 714         *(u32 *)skb->data = FW_AWAKE_COOKIE;
 715
 716         dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
 717                 *((u32 *)skb->data));
 718
 719         /* Save the sleep cookie */
 720         card->sleep_cookie = skb;
 721
 722         return 0;
 723 }
 724
 725 /*
 726  * This function deletes buffer for sleep cookie
 727  */
 728 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
 729 {
 730         struct pcie_service_card *card;
 731
 732         if (!adapter)
 733                 return 0;
 734
 735         card = adapter->card;
 736
 737         if (card && card->sleep_cookie) {
 738                 dev_kfree_skb_any(card->sleep_cookie);
 739                 card->sleep_cookie = NULL;
 740         }
 741
 742         return 0;
 743 }
 744
 745 /*
 746  * This function sends data buffer to device
 747  */
 748 static int
 749 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 750 {
 751         struct pcie_service_card *card = adapter->card;
 752         u32 wrindx, rdptr;
 753         phys_addr_t *buf_pa;
 754         __le16 *tmp;
 755
 756         if (!mwifiex_pcie_ok_to_access_hw(adapter))
 757                 mwifiex_pm_wakeup_card(adapter);
 758
 759         /* Read the TX ring read pointer set by firmware */
 760         if (mwifiex_read_reg(adapter, REG_TXBD_RDPTR, &rdptr)) {
 761                 dev_err(adapter->dev,
 762                         "SEND DATA: failed to read REG_TXBD_RDPTR\n");
 763                 return -1;
 764         }
 765
 766         wrindx = card->txbd_wrptr & MWIFIEX_TXBD_MASK;
 767
 768         dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n", rdptr,
 769                 card->txbd_wrptr);
 770         if (((card->txbd_wrptr & MWIFIEX_TXBD_MASK) !=
 771                         (rdptr & MWIFIEX_TXBD_MASK)) ||
 772             ((card->txbd_wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) !=
 773                         (rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
 774                 struct sk_buff *skb_data;
 775                 u8 *payload;
 776
 777                 adapter->data_sent = true;
 778                 skb_data = card->tx_buf_list[wrindx];
 779                 memcpy(skb_data->data, skb->data, skb->len);
 780                 payload = skb_data->data;
 781                 tmp = (__le16 *)&payload[0];
 782                 *tmp = cpu_to_le16((u16)skb->len);
 783                 tmp = (__le16 *)&payload[2];
 784                 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
 785                 skb_put(skb_data, MWIFIEX_RX_DATA_BUF_SIZE - skb_data->len);
 786                 skb_trim(skb_data, skb->len);
 787                 buf_pa = MWIFIEX_SKB_PACB(skb_data);
 788                 card->txbd_ring[wrindx]->paddr = *buf_pa;
 789                 card->txbd_ring[wrindx]->len = (u16)skb_data->len;
 790                 card->txbd_ring[wrindx]->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
 791                                                 MWIFIEX_BD_FLAG_LAST_DESC;
 792
 793                 if ((++card->txbd_wrptr & MWIFIEX_TXBD_MASK) ==
 794                                                         MWIFIEX_MAX_TXRX_BD)
 795                         card->txbd_wrptr = ((card->txbd_wrptr &
 796                                                 MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
 797                                                 MWIFIEX_BD_FLAG_ROLLOVER_IND);
 798
 799                 /* Write the TX ring write pointer in to REG_TXBD_WRPTR */
 800                 if (mwifiex_write_reg(adapter, REG_TXBD_WRPTR,
 801                                       card->txbd_wrptr)) {
 802                         dev_err(adapter->dev,
 803                                 "SEND DATA: failed to write REG_TXBD_WRPTR\n");
 804                         return 0;
 805                 }
 806
 807                 /* Send the TX ready interrupt */
 808                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
 809                                       CPU_INTR_DNLD_RDY)) {
 810                         dev_err(adapter->dev,
 811                                 "SEND DATA: failed to assert door-bell intr\n");
 812                         return -1;
 813                 }
 814                 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
 815                         "%#x> and sent packet to firmware successfully\n",
 816                         rdptr, card->txbd_wrptr);
 817         } else {
 818                 dev_dbg(adapter->dev,
 819                         "info: TX Ring full, can't send packets to fw\n");
 820                 adapter->data_sent = true;
 821                 /* Send the TX ready interrupt */
 822                 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
 823                                       CPU_INTR_DNLD_RDY))
 824                         dev_err(adapter->dev,
 825                                 "SEND DATA: failed to assert door-bell intr\n");
 826                 return -EBUSY;
 827         }
 828
 829         return 0;
 830 }
 831
 832 /*
 833  * This function handles received buffer ring and
 834  * dispatches packets to upper
 835  */
 836 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
 837 {
 838         struct pcie_service_card *card = adapter->card;
 839         u32 wrptr, rd_index;
 840         int ret = 0;
 841         struct sk_buff *skb_tmp = NULL;
 842
 843         /* Read the RX ring Write pointer set by firmware */
 844         if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
 845                 dev_err(adapter->dev,
 846                         "RECV DATA: failed to read REG_TXBD_RDPTR\n");
 847                 ret = -1;
 848                 goto done;
 849         }
 850
 851         while (((wrptr & MWIFIEX_RXBD_MASK) !=
 852                 (card->rxbd_rdptr & MWIFIEX_RXBD_MASK)) ||
 853                ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
 854                 (card->rxbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
 855                 struct sk_buff *skb_data;
 856                 u16 rx_len;
 857
 858                 rd_index = card->rxbd_rdptr & MWIFIEX_RXBD_MASK;
 859                 skb_data = card->rx_buf_list[rd_index];
 860
 861                 /* Get data length from interface header -
 862                    first byte is len, second byte is type */
 863                 rx_len = *((u16 *)skb_data->data);
 864                 dev_dbg(adapter->dev,
 865                         "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
 866                         card->rxbd_rdptr, wrptr, rx_len);
 867                 skb_tmp = dev_alloc_skb(rx_len);
 868                 if (!skb_tmp) {
 869                         dev_dbg(adapter->dev,
 870                                 "info: Failed to alloc skb for RX\n");
 871                         ret = -EBUSY;
 872                         goto done;
 873                 }
 874
 875                 skb_put(skb_tmp, rx_len);
 876
 877                 memcpy(skb_tmp->data, skb_data->data + INTF_HEADER_LEN, rx_len);
 878                 if ((++card->rxbd_rdptr & MWIFIEX_RXBD_MASK) ==
 879                                                         MWIFIEX_MAX_TXRX_BD) {
 880                         card->rxbd_rdptr = ((card->rxbd_rdptr &
 881                                              MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
 882                                             MWIFIEX_BD_FLAG_ROLLOVER_IND);
 883                 }
 884                 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
 885                         card->rxbd_rdptr, wrptr);
 886
 887                 /* Write the RX ring read pointer in to REG_RXBD_RDPTR */
 888                 if (mwifiex_write_reg(adapter, REG_RXBD_RDPTR,
 889                                       card->rxbd_rdptr)) {
 890                         dev_err(adapter->dev,
 891                                 "RECV DATA: failed to write REG_RXBD_RDPTR\n");
 892                         ret = -1;
 893                         goto done;
 894                 }
 895
 896                 /* Read the RX ring Write pointer set by firmware */
 897                 if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
 898                         dev_err(adapter->dev,
 899                                 "RECV DATA: failed to read REG_TXBD_RDPTR\n");
 900                         ret = -1;
 901                         goto done;
 902                 }
 903                 dev_dbg(adapter->dev,
 904                         "info: RECV DATA: Rcvd packet from fw successfully\n");
 905                 mwifiex_handle_rx_packet(adapter, skb_tmp);
 906         }
 907
 908 done:
 909         if (ret && skb_tmp)
 910                 dev_kfree_skb_any(skb_tmp);
 911         return ret;
 912 }
 913
 914 /*
 915  * This function downloads the boot command to device
 916  */
 917 static int
 918 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 919 {
 920         phys_addr_t *buf_pa = MWIFIEX_SKB_PACB(skb);
 921
 922         if (!(skb->data && skb->len && *buf_pa)) {
 923                 dev_err(adapter->dev,
 924                         "Invalid parameter in %s <%p, %#x:%x, %x>\n",
 925                         __func__, skb->data, skb->len,
 926                         (u32)*buf_pa, (u32)((u64)*buf_pa >> 32));
 927                 return -1;
 928         }
 929
 930         /* Write the lower 32bits of the physical address to scratch
 931          * register 0 */
 932         if (mwifiex_write_reg(adapter, PCIE_SCRATCH_0_REG, (u32)*buf_pa)) {
 933                 dev_err(adapter->dev,
 934                         "%s: failed to write download command to boot code.\n",
 935                         __func__);
 936                 return -1;
 937         }
 938
 939         /* Write the upper 32bits of the physical address to scratch
 940          * register 1 */
 941         if (mwifiex_write_reg(adapter, PCIE_SCRATCH_1_REG,
 942                               (u32)((u64)*buf_pa >> 32))) {
 943                 dev_err(adapter->dev,
 944                         "%s: failed to write download command to boot code.\n",
 945                         __func__);
 946                 return -1;
 947         }
 948
 949         /* Write the command length to scratch register 2 */
 950         if (mwifiex_write_reg(adapter, PCIE_SCRATCH_2_REG, skb->len)) {
 951                 dev_err(adapter->dev,
 952                         "%s: failed to write command len to scratch reg 2\n",
 953                         __func__);
 954                 return -1;
 955         }
 956
 957         /* Ring the door bell */
 958         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
 959                               CPU_INTR_DOOR_BELL)) {
 960                 dev_err(adapter->dev,
 961                         "%s: failed to assert door-bell intr\n", __func__);
 962                 return -1;
 963         }
 964
 965         return 0;
 966 }
 967
 968 /*
 969  * This function downloads commands to the device
 970  */
 971 static int
 972 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 973 {
 974         struct pcie_service_card *card = adapter->card;
 975         int ret = 0;
 976         phys_addr_t *cmd_buf_pa;
 977         phys_addr_t *cmdrsp_buf_pa;
 978
 979         if (!(skb->data && skb->len)) {
 980                 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
 981                         __func__, skb->data, skb->len);
 982                 return -1;
 983         }
 984
 985         /* Make sure a command response buffer is available */
 986         if (!card->cmdrsp_buf) {
 987                 dev_err(adapter->dev,
 988                         "No response buffer available, send command failed\n");
 989                 return -EBUSY;
 990         }
 991
 992         /* Make sure a command buffer is available */
 993         if (!card->cmd_buf) {
 994                 dev_err(adapter->dev, "Command buffer not available\n");
 995                 return -EBUSY;
 996         }
 997
 998         adapter->cmd_sent = true;
 999         /* Copy the given skb in to DMA accessable shared buffer */
1000         skb_put(card->cmd_buf, MWIFIEX_SIZE_OF_CMD_BUFFER - card->cmd_buf->len);
1001         skb_trim(card->cmd_buf, skb->len);
1002         memcpy(card->cmd_buf->data, skb->data, skb->len);
1003
1004         /* To send a command, the driver will:
1005                 1. Write the 64bit physical address of the data buffer to
1006                    SCRATCH1 + SCRATCH0
1007                 2. Ring the door bell (i.e. set the door bell interrupt)
1008
1009                 In response to door bell interrupt, the firmware will perform
1010                 the DMA of the command packet (first header to obtain the total
1011                 length and then rest of the command).
1012         */
1013
1014         if (card->cmdrsp_buf) {
1015                 cmdrsp_buf_pa = MWIFIEX_SKB_PACB(card->cmdrsp_buf);
1016                 /* Write the lower 32bits of the cmdrsp buffer physical
1017                    address */
1018                 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO,
1019                                       (u32)*cmdrsp_buf_pa)) {
1020                         dev_err(adapter->dev,
1021                                 "Failed to write download cmd to boot code.\n");
1022                         ret = -1;
1023                         goto done;
1024                 }
1025                 /* Write the upper 32bits of the cmdrsp buffer physical
1026                    address */
1027                 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI,
1028                                       (u32)((u64)*cmdrsp_buf_pa >> 32))) {
1029                         dev_err(adapter->dev,
1030                                 "Failed to write download cmd to boot code.\n");
1031                         ret = -1;
1032                         goto done;
1033                 }
1034         }
1035
1036         cmd_buf_pa = MWIFIEX_SKB_PACB(card->cmd_buf);
1037         /* Write the lower 32bits of the physical address to REG_CMD_ADDR_LO */
1038         if (mwifiex_write_reg(adapter, REG_CMD_ADDR_LO, (u32)*cmd_buf_pa)) {
1039                 dev_err(adapter->dev,
1040                         "Failed to write download cmd to boot code.\n");
1041                 ret = -1;
1042                 goto done;
1043         }
1044         /* Write the upper 32bits of the physical address to REG_CMD_ADDR_HI */
1045         if (mwifiex_write_reg(adapter, REG_CMD_ADDR_HI,
1046                               (u32)((u64)*cmd_buf_pa >> 32))) {
1047                 dev_err(adapter->dev,
1048                         "Failed to write download cmd to boot code.\n");
1049                 ret = -1;
1050                 goto done;
1051         }
1052
1053         /* Write the command length to REG_CMD_SIZE */
1054         if (mwifiex_write_reg(adapter, REG_CMD_SIZE, card->cmd_buf->len)) {
1055                 dev_err(adapter->dev,
1056                         "Failed to write cmd len to REG_CMD_SIZE\n");
1057                 ret = -1;
1058                 goto done;
1059         }
1060
1061         /* Ring the door bell */
1062         if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1063                               CPU_INTR_DOOR_BELL)) {
1064                 dev_err(adapter->dev,
1065                         "Failed to assert door-bell intr\n");
1066                 ret = -1;
1067                 goto done;
1068         }
1069
1070 done:
1071         if (ret)
1072                 adapter->cmd_sent = false;
1073
1074         return 0;
1075 }
1076
1077 /*
1078  * This function handles command complete interrupt
1079  */
1080 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1081 {
1082         struct pcie_service_card *card = adapter->card;
1083         struct sk_buff *skb = card->cmdrsp_buf;
1084         int count = 0;
1085
1086         dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1087
1088         if (!adapter->curr_cmd) {
1089                 skb_pull(skb, INTF_HEADER_LEN);
1090                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1091                         mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1092                                                            skb->len);
1093                         while (mwifiex_pcie_ok_to_access_hw(adapter) &&
1094                                                         (count++ < 10))
1095                                 usleep_range(50, 60);
1096                 } else {
1097                         dev_err(adapter->dev,
1098                                 "There is no command but got cmdrsp\n");
1099                 }
1100                 memcpy(adapter->upld_buf, skb->data,
1101                        min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1102                 skb_push(skb, INTF_HEADER_LEN);
1103         } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1104                 skb_pull(skb, INTF_HEADER_LEN);
1105                 adapter->curr_cmd->resp_skb = skb;
1106                 adapter->cmd_resp_received = true;
1107                 /* Take the pointer and set it to CMD node and will
1108                    return in the response complete callback */
1109                 card->cmdrsp_buf = NULL;
1110
1111                 /* Clear the cmd-rsp buffer address in scratch registers. This
1112                    will prevent firmware from writing to the same response
1113                    buffer again. */
1114                 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO, 0)) {
1115                         dev_err(adapter->dev,
1116                                 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1117                         return -1;
1118                 }
1119                 /* Write the upper 32bits of the cmdrsp buffer physical
1120                    address */
1121                 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI, 0)) {
1122                         dev_err(adapter->dev,
1123                                 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1124                         return -1;
1125                 }
1126         }
1127
1128         return 0;
1129 }
1130
1131 /*
1132  * Command Response processing complete handler
1133  */
1134 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1135                                         struct sk_buff *skb)
1136 {
1137         struct pcie_service_card *card = adapter->card;
1138
1139         if (skb) {
1140                 card->cmdrsp_buf = skb;
1141                 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1142         }
1143
1144         return 0;
1145 }
1146
1147 /*
1148  * This function handles firmware event ready interrupt
1149  */
1150 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1151 {
1152         struct pcie_service_card *card = adapter->card;
1153         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1154         u32 wrptr, event;
1155
1156         if (adapter->event_received) {
1157                 dev_dbg(adapter->dev, "info: Event being processed, "
1158                         "do not process this interrupt just yet\n");
1159                 return 0;
1160         }
1161
1162         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1163                 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1164                 return -1;
1165         }
1166
1167         /* Read the event ring write pointer set by firmware */
1168         if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
1169                 dev_err(adapter->dev,
1170                         "EventReady: failed to read REG_EVTBD_WRPTR\n");
1171                 return -1;
1172         }
1173
1174         dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1175                 card->evtbd_rdptr, wrptr);
1176         if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1177                                               & MWIFIEX_EVTBD_MASK)) ||
1178             ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
1179              (card->evtbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
1180                 struct sk_buff *skb_cmd;
1181                 __le16 data_len = 0;
1182                 u16 evt_len;
1183
1184                 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1185                 skb_cmd = card->evt_buf_list[rdptr];
1186                 /* Take the pointer and set it to event pointer in adapter
1187                    and will return back after event handling callback */
1188                 card->evt_buf_list[rdptr] = NULL;
1189                 card->evtbd_ring[rdptr]->paddr = 0;
1190                 card->evtbd_ring[rdptr]->len = 0;
1191                 card->evtbd_ring[rdptr]->flags = 0;
1192
1193                 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1194                 adapter->event_cause = event;
1195                 /* The first 4bytes will be the event transfer header
1196                    len is 2 bytes followed by type which is 2 bytes */
1197                 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1198                 evt_len = le16_to_cpu(data_len);
1199
1200                 skb_pull(skb_cmd, INTF_HEADER_LEN);
1201                 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1202
1203                 if ((evt_len > 0) && (evt_len  < MAX_EVENT_SIZE))
1204                         memcpy(adapter->event_body, skb_cmd->data +
1205                                MWIFIEX_EVENT_HEADER_LEN, evt_len -
1206                                MWIFIEX_EVENT_HEADER_LEN);
1207
1208                 adapter->event_received = true;
1209                 adapter->event_skb = skb_cmd;
1210
1211                 /* Do not update the event read pointer here, wait till the
1212                    buffer is released. This is just to make things simpler,
1213                    we need to find a better method of managing these buffers.
1214                 */
1215         }
1216
1217         return 0;
1218 }
1219
1220 /*
1221  * Event processing complete handler
1222  */
1223 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1224                                        struct sk_buff *skb)
1225 {
1226         struct pcie_service_card *card = adapter->card;
1227         int ret = 0;
1228         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1229         u32 wrptr;
1230         phys_addr_t *buf_pa;
1231
1232         if (!skb)
1233                 return 0;
1234
1235         if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1236                 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1237                         rdptr);
1238                 return -EINVAL;
1239         }
1240
1241         /* Read the event ring write pointer set by firmware */
1242         if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
1243                 dev_err(adapter->dev,
1244                         "event_complete: failed to read REG_EVTBD_WRPTR\n");
1245                 return -1;
1246         }
1247
1248         if (!card->evt_buf_list[rdptr]) {
1249                 skb_push(skb, INTF_HEADER_LEN);
1250                 card->evt_buf_list[rdptr] = skb;
1251                 buf_pa = MWIFIEX_SKB_PACB(skb);
1252                 card->evtbd_ring[rdptr]->paddr = *buf_pa;
1253                 card->evtbd_ring[rdptr]->len = (u16)skb->len;
1254                 card->evtbd_ring[rdptr]->flags = 0;
1255                 skb = NULL;
1256         } else {
1257                 dev_dbg(adapter->dev,
1258                         "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1259                         rdptr, card->evt_buf_list[rdptr], skb);
1260         }
1261
1262         if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1263                 card->evtbd_rdptr = ((card->evtbd_rdptr &
1264                                         MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
1265                                         MWIFIEX_BD_FLAG_ROLLOVER_IND);
1266         }
1267
1268         dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1269                 card->evtbd_rdptr, wrptr);
1270
1271         /* Write the event ring read pointer in to REG_EVTBD_RDPTR */
1272         if (mwifiex_write_reg(adapter, REG_EVTBD_RDPTR, card->evtbd_rdptr)) {
1273                 dev_err(adapter->dev,
1274                         "event_complete: failed to read REG_EVTBD_RDPTR\n");
1275                 return -1;
1276         }
1277
1278         dev_dbg(adapter->dev, "info: Check Events Again\n");
1279         ret = mwifiex_pcie_process_event_ready(adapter);
1280
1281         return ret;
1282 }
1283
1284 /*
1285  * This function downloads the firmware to the card.
1286  *
1287  * Firmware is downloaded to the card in blocks. Every block download
1288  * is tested for CRC errors, and retried a number of times before
1289  * returning failure.
1290  */
1291 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1292                                     struct mwifiex_fw_image *fw)
1293 {
1294         int ret;
1295         u8 *firmware = fw->fw_buf;
1296         u32 firmware_len = fw->fw_len;
1297         u32 offset = 0;
1298         struct sk_buff *skb;
1299         u32 txlen, tx_blocks = 0, tries, len;
1300         u32 block_retry_cnt = 0;
1301
1302         if (!adapter) {
1303                 pr_err("adapter structure is not valid\n");
1304                 return -1;
1305         }
1306
1307         if (!firmware || !firmware_len) {
1308                 dev_err(adapter->dev,
1309                         "No firmware image found! Terminating download\n");
1310                 return -1;
1311         }
1312
1313         dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1314                 firmware_len);
1315
1316         if (mwifiex_pcie_disable_host_int(adapter)) {
1317                 dev_err(adapter->dev,
1318                         "%s: Disabling interrupts failed.\n", __func__);
1319                 return -1;
1320         }
1321
1322         skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1323         if (!skb) {
1324                 ret = -ENOMEM;
1325                 goto done;
1326         }
1327         mwifiex_update_sk_buff_pa(skb);
1328
1329         /* Perform firmware data transfer */
1330         do {
1331                 u32 ireg_intr = 0;
1332
1333                 /* More data? */
1334                 if (offset >= firmware_len)
1335                         break;
1336
1337                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1338                         ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_2_REG,
1339                                                &len);
1340                         if (ret) {
1341                                 dev_warn(adapter->dev,
1342                                          "Failed reading len from boot code\n");
1343                                 goto done;
1344                         }
1345                         if (len)
1346                                 break;
1347                         usleep_range(10, 20);
1348                 }
1349
1350                 if (!len) {
1351                         break;
1352                 } else if (len > MWIFIEX_UPLD_SIZE) {
1353                         pr_err("FW download failure @ %d, invalid length %d\n",
1354                                offset, len);
1355                         ret = -1;
1356                         goto done;
1357                 }
1358
1359                 txlen = len;
1360
1361                 if (len & BIT(0)) {
1362                         block_retry_cnt++;
1363                         if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1364                                 pr_err("FW download failure @ %d, over max "
1365                                        "retry count\n", offset);
1366                                 ret = -1;
1367                                 goto done;
1368                         }
1369                         dev_err(adapter->dev, "FW CRC error indicated by the "
1370                                 "helper: len = 0x%04X, txlen = %d\n",
1371                                 len, txlen);
1372                         len &= ~BIT(0);
1373                         /* Setting this to 0 to resend from same offset */
1374                         txlen = 0;
1375                 } else {
1376                         block_retry_cnt = 0;
1377                         /* Set blocksize to transfer - checking for
1378                            last block */
1379                         if (firmware_len - offset < txlen)
1380                                 txlen = firmware_len - offset;
1381
1382                         dev_dbg(adapter->dev, ".");
1383
1384                         tx_blocks = (txlen +
1385                                      MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD - 1) /
1386                                      MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD;
1387
1388                         /* Copy payload to buffer */
1389                         memmove(skb->data, &firmware[offset], txlen);
1390                 }
1391
1392                 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1393                 skb_trim(skb, tx_blocks * MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD);
1394
1395                 /* Send the boot command to device */
1396                 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1397                         dev_err(adapter->dev,
1398                                 "Failed to send firmware download command\n");
1399                         ret = -1;
1400                         goto done;
1401                 }
1402                 /* Wait for the command done interrupt */
1403                 do {
1404                         if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1405                                              &ireg_intr)) {
1406                                 dev_err(adapter->dev, "%s: Failed to read "
1407                                         "interrupt status during fw dnld.\n",
1408                                         __func__);
1409                                 ret = -1;
1410                                 goto done;
1411                         }
1412                 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1413                          CPU_INTR_DOOR_BELL);
1414                 offset += txlen;
1415         } while (true);
1416
1417         dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1418                 offset);
1419
1420         ret = 0;
1421
1422 done:
1423         dev_kfree_skb_any(skb);
1424         return ret;
1425 }
1426
1427 /*
1428  * This function checks the firmware status in card.
1429  *
1430  * The winner interface is also determined by this function.
1431  */
1432 static int
1433 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1434 {
1435         int ret = 0;
1436         u32 firmware_stat, winner_status;
1437         u32 tries;
1438
1439         /* Mask spurios interrupts */
1440         if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1441                               HOST_INTR_MASK)) {
1442                 dev_warn(adapter->dev, "Write register failed\n");
1443                 return -1;
1444         }
1445
1446         dev_dbg(adapter->dev, "Setting driver ready signature\n");
1447         if (mwifiex_write_reg(adapter, REG_DRV_READY, FIRMWARE_READY_PCIE)) {
1448                 dev_err(adapter->dev,
1449                         "Failed to write driver ready signature\n");
1450                 return -1;
1451         }
1452
1453         /* Wait for firmware initialization event */
1454         for (tries = 0; tries < poll_num; tries++) {
1455                 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
1456                                      &firmware_stat))
1457                         ret = -1;
1458                 else
1459                         ret = 0;
1460                 if (ret)
1461                         continue;
1462                 if (firmware_stat == FIRMWARE_READY_PCIE) {
1463                         ret = 0;
1464                         break;
1465                 } else {
1466                         mdelay(100);
1467                         ret = -1;
1468                 }
1469         }
1470
1471         if (ret) {
1472                 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
1473                                      &winner_status))
1474                         ret = -1;
1475                 else if (!winner_status) {
1476                         dev_err(adapter->dev, "PCI-E is the winner\n");
1477                         adapter->winner = 1;
1478                         ret = -1;
1479                 } else {
1480                         dev_err(adapter->dev,
1481                                 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1482                                 ret, adapter->winner);
1483                         ret = 0;
1484                 }
1485         }
1486
1487         return ret;
1488 }
1489
1490 /*
1491  * This function reads the interrupt status from card.
1492  */
1493 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1494 {
1495         u32 pcie_ireg;
1496         unsigned long flags;
1497
1498         if (!mwifiex_pcie_ok_to_access_hw(adapter))
1499                 return;
1500
1501         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1502                 dev_warn(adapter->dev, "Read register failed\n");
1503                 return;
1504         }
1505
1506         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1507
1508                 mwifiex_pcie_disable_host_int(adapter);
1509
1510                 /* Clear the pending interrupts */
1511                 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1512                                       ~pcie_ireg)) {
1513                         dev_warn(adapter->dev, "Write register failed\n");
1514                         return;
1515                 }
1516                 spin_lock_irqsave(&adapter->int_lock, flags);
1517                 adapter->int_status |= pcie_ireg;
1518                 spin_unlock_irqrestore(&adapter->int_lock, flags);
1519
1520                 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1521                         if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1522                             (adapter->ps_state == PS_STATE_SLEEP)) {
1523                                 mwifiex_pcie_enable_host_int(adapter);
1524                                 if (mwifiex_write_reg(adapter,
1525                                                       PCIE_CPU_INT_EVENT,
1526                                                       CPU_INTR_SLEEP_CFM_DONE)
1527                                                       ) {
1528                                         dev_warn(adapter->dev,
1529                                                  "Write register failed\n");
1530                                         return;
1531
1532                                 }
1533                         }
1534                 } else if (!adapter->pps_uapsd_mode &&
1535                            adapter->ps_state == PS_STATE_SLEEP) {
1536                                 /* Potentially for PCIe we could get other
1537                                  * interrupts like shared. Don't change power
1538                                  * state until cookie is set */
1539                                 if (mwifiex_pcie_ok_to_access_hw(adapter))
1540                                         adapter->ps_state = PS_STATE_AWAKE;
1541                 }
1542         }
1543 }
1544
1545 /*
1546  * Interrupt handler for PCIe root port
1547  *
1548  * This function reads the interrupt status from firmware and assigns
1549  * the main process in workqueue which will handle the interrupt.
1550  */
1551 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
1552 {
1553         struct pci_dev *pdev = (struct pci_dev *)context;
1554         struct pcie_service_card *card;
1555         struct mwifiex_adapter *adapter;
1556
1557         if (!pdev) {
1558                 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
1559                 goto exit;
1560         }
1561
1562         card = (struct pcie_service_card *) pci_get_drvdata(pdev);
1563         if (!card || !card->adapter) {
1564                 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
1565                          card ? card->adapter : NULL);
1566                 goto exit;
1567         }
1568         adapter = card->adapter;
1569
1570         if (adapter->surprise_removed)
1571                 goto exit;
1572
1573         mwifiex_interrupt_status(adapter);
1574         queue_work(adapter->workqueue, &adapter->main_work);
1575
1576 exit:
1577         return IRQ_HANDLED;
1578 }
1579
1580 /*
1581  * This function checks the current interrupt status.
1582  *
1583  * The following interrupts are checked and handled by this function -
1584  *      - Data sent
1585  *      - Command sent
1586  *      - Command received
1587  *      - Packets received
1588  *      - Events received
1589  *
1590  * In case of Rx packets received, the packets are uploaded from card to
1591  * host and processed accordingly.
1592  */
1593 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
1594 {
1595         int ret;
1596         u32 pcie_ireg = 0;
1597         unsigned long flags;
1598
1599         spin_lock_irqsave(&adapter->int_lock, flags);
1600         /* Clear out unused interrupts */
1601         adapter->int_status &= HOST_INTR_MASK;
1602         spin_unlock_irqrestore(&adapter->int_lock, flags);
1603
1604         while (adapter->int_status & HOST_INTR_MASK) {
1605                 if (adapter->int_status & HOST_INTR_DNLD_DONE) {
1606                         adapter->int_status &= ~HOST_INTR_DNLD_DONE;
1607                         if (adapter->data_sent) {
1608                                 dev_dbg(adapter->dev, "info: DATA sent intr\n");
1609                                 adapter->data_sent = false;
1610                         }
1611                 }
1612                 if (adapter->int_status & HOST_INTR_UPLD_RDY) {
1613                         adapter->int_status &= ~HOST_INTR_UPLD_RDY;
1614                         dev_dbg(adapter->dev, "info: Rx DATA\n");
1615                         ret = mwifiex_pcie_process_recv_data(adapter);
1616                         if (ret)
1617                                 return ret;
1618                 }
1619                 if (adapter->int_status & HOST_INTR_EVENT_RDY) {
1620                         adapter->int_status &= ~HOST_INTR_EVENT_RDY;
1621                         dev_dbg(adapter->dev, "info: Rx EVENT\n");
1622                         ret = mwifiex_pcie_process_event_ready(adapter);
1623                         if (ret)
1624                                 return ret;
1625                 }
1626
1627                 if (adapter->int_status & HOST_INTR_CMD_DONE) {
1628                         adapter->int_status &= ~HOST_INTR_CMD_DONE;
1629                         if (adapter->cmd_sent) {
1630                                 dev_dbg(adapter->dev,
1631                                         "info: CMD sent Interrupt\n");
1632                                 adapter->cmd_sent = false;
1633                         }
1634                         /* Handle command response */
1635                         ret = mwifiex_pcie_process_cmd_complete(adapter);
1636                         if (ret)
1637                                 return ret;
1638                 }
1639
1640                 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1641                         if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
1642                                              &pcie_ireg)) {
1643                                 dev_warn(adapter->dev,
1644                                          "Read register failed\n");
1645                                 return -1;
1646                         }
1647
1648                         if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1649                                 if (mwifiex_write_reg(adapter,
1650                                                       PCIE_HOST_INT_STATUS,
1651                                                       ~pcie_ireg)) {
1652                                         dev_warn(adapter->dev,
1653                                                  "Write register failed\n");
1654                                         return -1;
1655                                 }
1656                                 adapter->int_status |= pcie_ireg;
1657                                 adapter->int_status &= HOST_INTR_MASK;
1658                         }
1659
1660                 }
1661         }
1662         dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
1663                 adapter->cmd_sent, adapter->data_sent);
1664         mwifiex_pcie_enable_host_int(adapter);
1665
1666         return 0;
1667 }
1668
1669 /*
1670  * This function downloads data from driver to card.
1671  *
1672  * Both commands and data packets are transferred to the card by this
1673  * function.
1674  *
1675  * This function adds the PCIE specific header to the front of the buffer
1676  * before transferring. The header contains the length of the packet and
1677  * the type. The firmware handles the packets based upon this set type.
1678  */
1679 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
1680                                      struct sk_buff *skb,
1681                                      struct mwifiex_tx_param *tx_param)
1682 {
1683         if (!skb) {
1684                 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
1685                 return -1;
1686         }
1687
1688         if (type == MWIFIEX_TYPE_DATA)
1689                 return mwifiex_pcie_send_data(adapter, skb);
1690         else if (type == MWIFIEX_TYPE_CMD)
1691                 return mwifiex_pcie_send_cmd(adapter, skb);
1692
1693         return 0;
1694 }
1695
1696 /*
1697  * This function initializes the PCI-E host memory space, WCB rings, etc.
1698  *
1699  * The following initializations steps are followed -
1700  *      - Allocate TXBD ring buffers
1701  *      - Allocate RXBD ring buffers
1702  *      - Allocate event BD ring buffers
1703  *      - Allocate command response ring buffer
1704  *      - Allocate sleep cookie buffer
1705  */
1706 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
1707 {
1708         struct pcie_service_card *card = adapter->card;
1709         int ret;
1710         struct pci_dev *pdev = card->dev;
1711
1712         pci_set_drvdata(pdev, card);
1713
1714         ret = pci_enable_device(pdev);
1715         if (ret)
1716                 goto err_enable_dev;
1717
1718         pci_set_master(pdev);
1719
1720         dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
1721         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1722         if (ret) {
1723                 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
1724                 goto err_set_dma_mask;
1725         }
1726
1727         ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
1728         if (ret) {
1729                 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
1730                 goto err_set_dma_mask;
1731         }
1732
1733         ret = pci_request_region(pdev, 0, DRV_NAME);
1734         if (ret) {
1735                 dev_err(adapter->dev, "req_reg(0) error\n");
1736                 goto err_req_region0;
1737         }
1738         card->pci_mmap = pci_iomap(pdev, 0, 0);
1739         if (!card->pci_mmap) {
1740                 dev_err(adapter->dev, "iomap(0) error\n");
1741                 goto err_iomap0;
1742         }
1743         ret = pci_request_region(pdev, 2, DRV_NAME);
1744         if (ret) {
1745                 dev_err(adapter->dev, "req_reg(2) error\n");
1746                 goto err_req_region2;
1747         }
1748         card->pci_mmap1 = pci_iomap(pdev, 2, 0);
1749         if (!card->pci_mmap1) {
1750                 dev_err(adapter->dev, "iomap(2) error\n");
1751                 goto err_iomap2;
1752         }
1753
1754         dev_dbg(adapter->dev,
1755                 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
1756                 card->pci_mmap, card->pci_mmap1);
1757
1758         card->cmdrsp_buf = NULL;
1759         ret = mwifiex_pcie_create_txbd_ring(adapter);
1760         if (ret)
1761                 goto err_cre_txbd;
1762         ret = mwifiex_pcie_create_rxbd_ring(adapter);
1763         if (ret)
1764                 goto err_cre_rxbd;
1765         ret = mwifiex_pcie_create_evtbd_ring(adapter);
1766         if (ret)
1767                 goto err_cre_evtbd;
1768         ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
1769         if (ret)
1770                 goto err_alloc_cmdbuf;
1771         ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
1772         if (ret)
1773                 goto err_alloc_cookie;
1774
1775         return ret;
1776
1777 err_alloc_cookie:
1778         mwifiex_pcie_delete_cmdrsp_buf(adapter);
1779 err_alloc_cmdbuf:
1780         mwifiex_pcie_delete_evtbd_ring(adapter);
1781 err_cre_evtbd:
1782         mwifiex_pcie_delete_rxbd_ring(adapter);
1783 err_cre_rxbd:
1784         mwifiex_pcie_delete_txbd_ring(adapter);
1785 err_cre_txbd:
1786         pci_iounmap(pdev, card->pci_mmap1);
1787 err_iomap2:
1788         pci_release_region(pdev, 2);
1789 err_req_region2:
1790         pci_iounmap(pdev, card->pci_mmap);
1791 err_iomap0:
1792         pci_release_region(pdev, 0);
1793 err_req_region0:
1794 err_set_dma_mask:
1795         pci_disable_device(pdev);
1796 err_enable_dev:
1797         pci_set_drvdata(pdev, NULL);
1798         return ret;
1799 }
1800
1801 /*
1802  * This function cleans up the allocated card buffers.
1803  *
1804  * The following are freed by this function -
1805  *      - TXBD ring buffers
1806  *      - RXBD ring buffers
1807  *      - Event BD ring buffers
1808  *      - Command response ring buffer
1809  *      - Sleep cookie buffer
1810  */
1811 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
1812 {
1813         struct pcie_service_card *card = adapter->card;
1814         struct pci_dev *pdev = card->dev;
1815
1816         mwifiex_pcie_delete_sleep_cookie_buf(adapter);
1817         mwifiex_pcie_delete_cmdrsp_buf(adapter);
1818         mwifiex_pcie_delete_evtbd_ring(adapter);
1819         mwifiex_pcie_delete_rxbd_ring(adapter);
1820         mwifiex_pcie_delete_txbd_ring(adapter);
1821         card->cmdrsp_buf = NULL;
1822
1823         dev_dbg(adapter->dev, "Clearing driver ready signature\n");
1824         if (user_rmmod) {
1825                 if (mwifiex_write_reg(adapter, REG_DRV_READY, 0x00000000))
1826                         dev_err(adapter->dev,
1827                                 "Failed to write driver not-ready signature\n");
1828         }
1829
1830         if (pdev) {
1831                 pci_iounmap(pdev, card->pci_mmap);
1832                 pci_iounmap(pdev, card->pci_mmap1);
1833
1834                 pci_release_regions(pdev);
1835                 pci_disable_device(pdev);
1836                 pci_set_drvdata(pdev, NULL);
1837         }
1838 }
1839
1840 /*
1841  * This function registers the PCIE device.
1842  *
1843  * PCIE IRQ is claimed, block size is set and driver data is initialized.
1844  */
1845 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
1846 {
1847         int ret;
1848         struct pcie_service_card *card = adapter->card;
1849         struct pci_dev *pdev = card->dev;
1850
1851         /* save adapter pointer in card */
1852         card->adapter = adapter;
1853
1854         ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
1855                           "MRVL_PCIE", pdev);
1856         if (ret) {
1857                 pr_err("request_irq failed: ret=%d\n", ret);
1858                 adapter->card = NULL;
1859                 return -1;
1860         }
1861
1862         adapter->dev = &pdev->dev;
1863         strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
1864
1865         return 0;
1866 }
1867
1868 /*
1869  * This function unregisters the PCIE device.
1870  *
1871  * The PCIE IRQ is released, the function is disabled and driver
1872  * data is set to null.
1873  */
1874 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
1875 {
1876         struct pcie_service_card *card = adapter->card;
1877
1878         if (card) {
1879                 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
1880                 free_irq(card->dev->irq, card->dev);
1881         }
1882 }
1883
1884 static struct mwifiex_if_ops pcie_ops = {
1885         .init_if =                      mwifiex_pcie_init,
1886         .cleanup_if =                   mwifiex_pcie_cleanup,
1887         .check_fw_status =              mwifiex_check_fw_status,
1888         .prog_fw =                      mwifiex_prog_fw_w_helper,
1889         .register_dev =                 mwifiex_register_dev,
1890         .unregister_dev =               mwifiex_unregister_dev,
1891         .enable_int =                   mwifiex_pcie_enable_host_int,
1892         .process_int_status =           mwifiex_process_int_status,
1893         .host_to_card =                 mwifiex_pcie_host_to_card,
1894         .wakeup =                       mwifiex_pm_wakeup_card,
1895         .wakeup_complete =              mwifiex_pm_wakeup_card_complete,
1896
1897         /* PCIE specific */
1898         .cmdrsp_complete =              mwifiex_pcie_cmdrsp_complete,
1899         .event_complete =               mwifiex_pcie_event_complete,
1900         .update_mp_end_port =           NULL,
1901         .cleanup_mpa_buf =              NULL,
1902 };
1903
1904 /*
1905  * This function initializes the PCIE driver module.
1906  *
1907  * This initiates the semaphore and registers the device with
1908  * PCIE bus.
1909  */
1910 static int mwifiex_pcie_init_module(void)
1911 {
1912         int ret;
1913
1914         pr_debug("Marvell 8766 PCIe Driver\n");
1915
1916         sema_init(&add_remove_card_sem, 1);
1917
1918         /* Clear the flag in case user removes the card. */
1919         user_rmmod = 0;
1920
1921         ret = pci_register_driver(&mwifiex_pcie);
1922         if (ret)
1923                 pr_err("Driver register failed!\n");
1924         else
1925                 pr_debug("info: Driver registered successfully!\n");
1926
1927         return ret;
1928 }
1929
1930 /*
1931  * This function cleans up the PCIE driver.
1932  *
1933  * The following major steps are followed for cleanup -
1934  *      - Resume the device if its suspended
1935  *      - Disconnect the device if connected
1936  *      - Shutdown the firmware
1937  *      - Unregister the device from PCIE bus.
1938  */
1939 static void mwifiex_pcie_cleanup_module(void)
1940 {
1941         if (!down_interruptible(&add_remove_card_sem))
1942                 up(&add_remove_card_sem);
1943
1944         /* Set the flag as user is removing this module. */
1945         user_rmmod = 1;
1946
1947         pci_unregister_driver(&mwifiex_pcie);
1948 }
1949
1950 module_init(mwifiex_pcie_init_module);
1951 module_exit(mwifiex_pcie_cleanup_module);
1952
1953 MODULE_AUTHOR("Marvell International Ltd.");
1954 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
1955 MODULE_VERSION(PCIE_VERSION);
1956 MODULE_LICENSE("GPL v2");
1957 MODULE_FIRMWARE("mrvl/pcie8766_uapsta.bin");