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