drivers/net/wireless/quantenna/qtnfmac/pearl/pcie.c

   1 /*
   2  * Copyright (c) 2015-2016 Quantenna Communications, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/firmware.h>
  20 #include <linux/pci.h>
  21 #include <linux/vmalloc.h>
  22 #include <linux/delay.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/sched.h>
  25 #include <linux/completion.h>
  26 #include <linux/crc32.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/circ_buf.h>
  29 #include <linux/log2.h>
  30
  31 #include "qtn_hw_ids.h"
  32 #include "pcie_bus_priv.h"
  33 #include "core.h"
  34 #include "bus.h"
  35 #include "debug.h"
  36
  37 static bool use_msi = true;
  38 module_param(use_msi, bool, 0644);
  39 MODULE_PARM_DESC(use_msi, "set 0 to use legacy interrupt");
  40
  41 static unsigned int tx_bd_size_param = 32;
  42 module_param(tx_bd_size_param, uint, 0644);
  43 MODULE_PARM_DESC(tx_bd_size_param, "Tx descriptors queue size, power of two");
  44
  45 static unsigned int rx_bd_size_param = 256;
  46 module_param(rx_bd_size_param, uint, 0644);
  47 MODULE_PARM_DESC(rx_bd_size_param, "Rx descriptors queue size, power of two");
  48
  49 static u8 flashboot = 1;
  50 module_param(flashboot, byte, 0644);
  51 MODULE_PARM_DESC(flashboot, "set to 0 to use FW binary file on FS");
  52
  53 #define DRV_NAME        "qtnfmac_pearl_pcie"
  54
  55 static inline void qtnf_non_posted_write(u32 val, void __iomem *basereg)
  56 {
  57         writel(val, basereg);
  58
  59         /* flush posted write */
  60         readl(basereg);
  61 }
  62
  63 static inline void qtnf_init_hdp_irqs(struct qtnf_pcie_bus_priv *priv)
  64 {
  65         unsigned long flags;
  66
  67         spin_lock_irqsave(&priv->irq_lock, flags);
  68         priv->pcie_irq_mask = (PCIE_HDP_INT_RX_BITS | PCIE_HDP_INT_TX_BITS);
  69         spin_unlock_irqrestore(&priv->irq_lock, flags);
  70 }
  71
  72 static inline void qtnf_enable_hdp_irqs(struct qtnf_pcie_bus_priv *priv)
  73 {
  74         unsigned long flags;
  75
  76         spin_lock_irqsave(&priv->irq_lock, flags);
  77         writel(priv->pcie_irq_mask, PCIE_HDP_INT_EN(priv->pcie_reg_base));
  78         spin_unlock_irqrestore(&priv->irq_lock, flags);
  79 }
  80
  81 static inline void qtnf_disable_hdp_irqs(struct qtnf_pcie_bus_priv *priv)
  82 {
  83         unsigned long flags;
  84
  85         spin_lock_irqsave(&priv->irq_lock, flags);
  86         writel(0x0, PCIE_HDP_INT_EN(priv->pcie_reg_base));
  87         spin_unlock_irqrestore(&priv->irq_lock, flags);
  88 }
  89
  90 static inline void qtnf_en_rxdone_irq(struct qtnf_pcie_bus_priv *priv)
  91 {
  92         unsigned long flags;
  93
  94         spin_lock_irqsave(&priv->irq_lock, flags);
  95         priv->pcie_irq_mask |= PCIE_HDP_INT_RX_BITS;
  96         writel(priv->pcie_irq_mask, PCIE_HDP_INT_EN(priv->pcie_reg_base));
  97         spin_unlock_irqrestore(&priv->irq_lock, flags);
  98 }
  99
 100 static inline void qtnf_dis_rxdone_irq(struct qtnf_pcie_bus_priv *priv)
 101 {
 102         unsigned long flags;
 103
 104         spin_lock_irqsave(&priv->irq_lock, flags);
 105         priv->pcie_irq_mask &= ~PCIE_HDP_INT_RX_BITS;
 106         writel(priv->pcie_irq_mask, PCIE_HDP_INT_EN(priv->pcie_reg_base));
 107         spin_unlock_irqrestore(&priv->irq_lock, flags);
 108 }
 109
 110 static inline void qtnf_en_txdone_irq(struct qtnf_pcie_bus_priv *priv)
 111 {
 112         unsigned long flags;
 113
 114         spin_lock_irqsave(&priv->irq_lock, flags);
 115         priv->pcie_irq_mask |= PCIE_HDP_INT_TX_BITS;
 116         writel(priv->pcie_irq_mask, PCIE_HDP_INT_EN(priv->pcie_reg_base));
 117         spin_unlock_irqrestore(&priv->irq_lock, flags);
 118 }
 119
 120 static inline void qtnf_dis_txdone_irq(struct qtnf_pcie_bus_priv *priv)
 121 {
 122         unsigned long flags;
 123
 124         spin_lock_irqsave(&priv->irq_lock, flags);
 125         priv->pcie_irq_mask &= ~PCIE_HDP_INT_TX_BITS;
 126         writel(priv->pcie_irq_mask, PCIE_HDP_INT_EN(priv->pcie_reg_base));
 127         spin_unlock_irqrestore(&priv->irq_lock, flags);
 128 }
 129
 130 static int qtnf_pcie_init_irq(struct qtnf_pcie_bus_priv *priv)
 131 {
 132         struct pci_dev *pdev = priv->pdev;
 133
 134         /* fall back to legacy INTx interrupts by default */
 135         priv->msi_enabled = 0;
 136
 137         /* check if MSI capability is available */
 138         if (use_msi) {
 139                 if (!pci_enable_msi(pdev)) {
 140                         pr_debug("MSI interrupt enabled\n");
 141                         priv->msi_enabled = 1;
 142                 } else {
 143                         pr_warn("failed to enable MSI interrupts");
 144                 }
 145         }
 146
 147         if (!priv->msi_enabled) {
 148                 pr_warn("legacy PCIE interrupts enabled\n");
 149                 pci_intx(pdev, 1);
 150         }
 151
 152         return 0;
 153 }
 154
 155 static void qtnf_deassert_intx(struct qtnf_pcie_bus_priv *priv)
 156 {
 157         void __iomem *reg = priv->sysctl_bar + PEARL_PCIE_CFG0_OFFSET;
 158         u32 cfg;
 159
 160         cfg = readl(reg);
 161         cfg &= ~PEARL_ASSERT_INTX;
 162         qtnf_non_posted_write(cfg, reg);
 163 }
 164
 165 static void qtnf_ipc_gen_ep_int(void *arg)
 166 {
 167         const struct qtnf_pcie_bus_priv *priv = arg;
 168         const u32 data = QTN_PEARL_IPC_IRQ_WORD(QTN_PEARL_LHOST_IPC_IRQ);
 169         void __iomem *reg = priv->sysctl_bar +
 170                             QTN_PEARL_SYSCTL_LHOST_IRQ_OFFSET;
 171
 172         qtnf_non_posted_write(data, reg);
 173 }
 174
 175 static void __iomem *qtnf_map_bar(struct qtnf_pcie_bus_priv *priv, u8 index)
 176 {
 177         void __iomem *vaddr;
 178         dma_addr_t busaddr;
 179         size_t len;
 180         int ret;
 181
 182         ret = pcim_iomap_regions(priv->pdev, 1 << index, DRV_NAME);
 183         if (ret)
 184                 return IOMEM_ERR_PTR(ret);
 185
 186         busaddr = pci_resource_start(priv->pdev, index);
 187         len = pci_resource_len(priv->pdev, index);
 188         vaddr = pcim_iomap_table(priv->pdev)[index];
 189         if (!vaddr)
 190                 return IOMEM_ERR_PTR(-ENOMEM);
 191
 192         pr_debug("BAR%u vaddr=0x%p busaddr=%pad len=%u\n",
 193                  index, vaddr, &busaddr, (int)len);
 194
 195         return vaddr;
 196 }
 197
 198 static void qtnf_pcie_control_rx_callback(void *arg, const u8 *buf, size_t len)
 199 {
 200         struct qtnf_pcie_bus_priv *priv = arg;
 201         struct qtnf_bus *bus = pci_get_drvdata(priv->pdev);
 202         struct sk_buff *skb;
 203
 204         if (unlikely(len == 0)) {
 205                 pr_warn("zero length packet received\n");
 206                 return;
 207         }
 208
 209         skb = __dev_alloc_skb(len, GFP_KERNEL);
 210
 211         if (unlikely(!skb)) {
 212                 pr_err("failed to allocate skb\n");
 213                 return;
 214         }
 215
 216         skb_put_data(skb, buf, len);
 217
 218         qtnf_trans_handle_rx_ctl_packet(bus, skb);
 219 }
 220
 221 static int qtnf_pcie_init_shm_ipc(struct qtnf_pcie_bus_priv *priv)
 222 {
 223         struct qtnf_shm_ipc_region __iomem *ipc_tx_reg;
 224         struct qtnf_shm_ipc_region __iomem *ipc_rx_reg;
 225         const struct qtnf_shm_ipc_int ipc_int = { qtnf_ipc_gen_ep_int, priv };
 226         const struct qtnf_shm_ipc_rx_callback rx_callback = {
 227                                         qtnf_pcie_control_rx_callback, priv };
 228
 229         ipc_tx_reg = &priv->bda->bda_shm_reg1;
 230         ipc_rx_reg = &priv->bda->bda_shm_reg2;
 231
 232         qtnf_shm_ipc_init(&priv->shm_ipc_ep_in, QTNF_SHM_IPC_OUTBOUND,
 233                           ipc_tx_reg, priv->workqueue,
 234                           &ipc_int, &rx_callback);
 235         qtnf_shm_ipc_init(&priv->shm_ipc_ep_out, QTNF_SHM_IPC_INBOUND,
 236                           ipc_rx_reg, priv->workqueue,
 237                           &ipc_int, &rx_callback);
 238
 239         return 0;
 240 }
 241
 242 static void qtnf_pcie_free_shm_ipc(struct qtnf_pcie_bus_priv *priv)
 243 {
 244         qtnf_shm_ipc_free(&priv->shm_ipc_ep_in);
 245         qtnf_shm_ipc_free(&priv->shm_ipc_ep_out);
 246 }
 247
 248 static int qtnf_pcie_init_memory(struct qtnf_pcie_bus_priv *priv)
 249 {
 250         int ret = -ENOMEM;
 251
 252         priv->sysctl_bar = qtnf_map_bar(priv, QTN_SYSCTL_BAR);
 253         if (IS_ERR(priv->sysctl_bar)) {
 254                 pr_err("failed to map BAR%u\n", QTN_SYSCTL_BAR);
 255                 return ret;
 256         }
 257
 258         priv->dmareg_bar = qtnf_map_bar(priv, QTN_DMA_BAR);
 259         if (IS_ERR(priv->dmareg_bar)) {
 260                 pr_err("failed to map BAR%u\n", QTN_DMA_BAR);
 261                 return ret;
 262         }
 263
 264         priv->epmem_bar = qtnf_map_bar(priv, QTN_SHMEM_BAR);
 265         if (IS_ERR(priv->epmem_bar)) {
 266                 pr_err("failed to map BAR%u\n", QTN_SHMEM_BAR);
 267                 return ret;
 268         }
 269
 270         priv->pcie_reg_base = priv->dmareg_bar;
 271         priv->bda = priv->epmem_bar;
 272         writel(priv->msi_enabled, &priv->bda->bda_rc_msi_enabled);
 273
 274         return 0;
 275 }
 276
 277 static void qtnf_tune_pcie_mps(struct qtnf_pcie_bus_priv *priv)
 278 {
 279         struct pci_dev *pdev = priv->pdev;
 280         struct pci_dev *parent;
 281         int mps_p, mps_o, mps_m, mps;
 282         int ret;
 283
 284         /* current mps */
 285         mps_o = pcie_get_mps(pdev);
 286
 287         /* maximum supported mps */
 288         mps_m = 128 << pdev->pcie_mpss;
 289
 290         /* suggested new mps value */
 291         mps = mps_m;
 292
 293         if (pdev->bus && pdev->bus->self) {
 294                 /* parent (bus) mps */
 295                 parent = pdev->bus->self;
 296
 297                 if (pci_is_pcie(parent)) {
 298                         mps_p = pcie_get_mps(parent);
 299                         mps = min(mps_m, mps_p);
 300                 }
 301         }
 302
 303         ret = pcie_set_mps(pdev, mps);
 304         if (ret) {
 305                 pr_err("failed to set mps to %d, keep using current %d\n",
 306                        mps, mps_o);
 307                 priv->mps = mps_o;
 308                 return;
 309         }
 310
 311         pr_debug("set mps to %d (was %d, max %d)\n", mps, mps_o, mps_m);
 312         priv->mps = mps;
 313 }
 314
 315 static int qtnf_is_state(__le32 __iomem *reg, u32 state)
 316 {
 317         u32 s = readl(reg);
 318
 319         return s & state;
 320 }
 321
 322 static void qtnf_set_state(__le32 __iomem *reg, u32 state)
 323 {
 324         u32 s = readl(reg);
 325
 326         qtnf_non_posted_write(state | s, reg);
 327 }
 328
 329 static void qtnf_clear_state(__le32 __iomem *reg, u32 state)
 330 {
 331         u32 s = readl(reg);
 332
 333         qtnf_non_posted_write(s & ~state, reg);
 334 }
 335
 336 static int qtnf_poll_state(__le32 __iomem *reg, u32 state, u32 delay_in_ms)
 337 {
 338         u32 timeout = 0;
 339
 340         while ((qtnf_is_state(reg, state) == 0)) {
 341                 usleep_range(1000, 1200);
 342                 if (++timeout > delay_in_ms)
 343                         return -1;
 344         }
 345
 346         return 0;
 347 }
 348
 349 static int alloc_skb_array(struct qtnf_pcie_bus_priv *priv)
 350 {
 351         struct sk_buff **vaddr;
 352         int len;
 353
 354         len = priv->tx_bd_num * sizeof(*priv->tx_skb) +
 355                 priv->rx_bd_num * sizeof(*priv->rx_skb);
 356         vaddr = devm_kzalloc(&priv->pdev->dev, len, GFP_KERNEL);
 357
 358         if (!vaddr)
 359                 return -ENOMEM;
 360
 361         priv->tx_skb = vaddr;
 362
 363         vaddr += priv->tx_bd_num;
 364         priv->rx_skb = vaddr;
 365
 366         return 0;
 367 }
 368
 369 static int alloc_bd_table(struct qtnf_pcie_bus_priv *priv)
 370 {
 371         dma_addr_t paddr;
 372         void *vaddr;
 373         int len;
 374
 375         len = priv->tx_bd_num * sizeof(struct qtnf_tx_bd) +
 376                 priv->rx_bd_num * sizeof(struct qtnf_rx_bd);
 377
 378         vaddr = dmam_alloc_coherent(&priv->pdev->dev, len, &paddr, GFP_KERNEL);
 379         if (!vaddr)
 380                 return -ENOMEM;
 381
 382         /* tx bd */
 383
 384         memset(vaddr, 0, len);
 385
 386         priv->bd_table_vaddr = vaddr;
 387         priv->bd_table_paddr = paddr;
 388         priv->bd_table_len = len;
 389
 390         priv->tx_bd_vbase = vaddr;
 391         priv->tx_bd_pbase = paddr;
 392
 393         pr_debug("TX descriptor table: vaddr=0x%p paddr=%pad\n", vaddr, &paddr);
 394
 395         priv->tx_bd_r_index = 0;
 396         priv->tx_bd_w_index = 0;
 397
 398         /* rx bd */
 399
 400         vaddr = ((struct qtnf_tx_bd *)vaddr) + priv->tx_bd_num;
 401         paddr += priv->tx_bd_num * sizeof(struct qtnf_tx_bd);
 402
 403         priv->rx_bd_vbase = vaddr;
 404         priv->rx_bd_pbase = paddr;
 405
 406 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 407         writel(QTN_HOST_HI32(paddr),
 408                PCIE_HDP_TX_HOST_Q_BASE_H(priv->pcie_reg_base));
 409 #endif
 410         writel(QTN_HOST_LO32(paddr),
 411                PCIE_HDP_TX_HOST_Q_BASE_L(priv->pcie_reg_base));
 412         writel(priv->rx_bd_num | (sizeof(struct qtnf_rx_bd)) << 16,
 413                PCIE_HDP_TX_HOST_Q_SZ_CTRL(priv->pcie_reg_base));
 414
 415         pr_debug("RX descriptor table: vaddr=0x%p paddr=%pad\n", vaddr, &paddr);
 416
 417         return 0;
 418 }
 419
 420 static int skb2rbd_attach(struct qtnf_pcie_bus_priv *priv, u16 index)
 421 {
 422         struct qtnf_rx_bd *rxbd;
 423         struct sk_buff *skb;
 424         dma_addr_t paddr;
 425
 426         skb = __netdev_alloc_skb_ip_align(NULL, SKB_BUF_SIZE, GFP_ATOMIC);
 427         if (!skb) {
 428                 priv->rx_skb[index] = NULL;
 429                 return -ENOMEM;
 430         }
 431
 432         priv->rx_skb[index] = skb;
 433         rxbd = &priv->rx_bd_vbase[index];
 434
 435         paddr = pci_map_single(priv->pdev, skb->data,
 436                                SKB_BUF_SIZE, PCI_DMA_FROMDEVICE);
 437         if (pci_dma_mapping_error(priv->pdev, paddr)) {
 438                 pr_err("skb DMA mapping error: %pad\n", &paddr);
 439                 return -ENOMEM;
 440         }
 441
 442         /* keep rx skb paddrs in rx buffer descriptors for cleanup purposes */
 443         rxbd->addr = cpu_to_le32(QTN_HOST_LO32(paddr));
 444         rxbd->addr_h = cpu_to_le32(QTN_HOST_HI32(paddr));
 445         rxbd->info = 0x0;
 446
 447         priv->rx_bd_w_index = index;
 448
 449         /* sync up all descriptor updates */
 450         wmb();
 451
 452 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 453         writel(QTN_HOST_HI32(paddr),
 454                PCIE_HDP_HHBM_BUF_PTR_H(priv->pcie_reg_base));
 455 #endif
 456         writel(QTN_HOST_LO32(paddr),
 457                PCIE_HDP_HHBM_BUF_PTR(priv->pcie_reg_base));
 458
 459         writel(index, PCIE_HDP_TX_HOST_Q_WR_PTR(priv->pcie_reg_base));
 460         return 0;
 461 }
 462
 463 static int alloc_rx_buffers(struct qtnf_pcie_bus_priv *priv)
 464 {
 465         u16 i;
 466         int ret = 0;
 467
 468         memset(priv->rx_bd_vbase, 0x0,
 469                priv->rx_bd_num * sizeof(struct qtnf_rx_bd));
 470
 471         for (i = 0; i < priv->rx_bd_num; i++) {
 472                 ret = skb2rbd_attach(priv, i);
 473                 if (ret)
 474                         break;
 475         }
 476
 477         return ret;
 478 }
 479
 480 /* all rx/tx activity should have ceased before calling this function */
 481 static void free_xfer_buffers(void *data)
 482 {
 483         struct qtnf_pcie_bus_priv *priv = (struct qtnf_pcie_bus_priv *)data;
 484         struct qtnf_rx_bd *rxbd;
 485         dma_addr_t paddr;
 486         int i;
 487
 488         /* free rx buffers */
 489         for (i = 0; i < priv->rx_bd_num; i++) {
 490                 if (priv->rx_skb && priv->rx_skb[i]) {
 491                         rxbd = &priv->rx_bd_vbase[i];
 492                         paddr = QTN_HOST_ADDR(le32_to_cpu(rxbd->addr_h),
 493                                               le32_to_cpu(rxbd->addr));
 494                         pci_unmap_single(priv->pdev, paddr, SKB_BUF_SIZE,
 495                                          PCI_DMA_FROMDEVICE);
 496
 497                         dev_kfree_skb_any(priv->rx_skb[i]);
 498                 }
 499         }
 500
 501         /* free tx buffers */
 502         for (i = 0; i < priv->tx_bd_num; i++) {
 503                 if (priv->tx_skb && priv->tx_skb[i]) {
 504                         dev_kfree_skb_any(priv->tx_skb[i]);
 505                         priv->tx_skb[i] = NULL;
 506                 }
 507         }
 508 }
 509
 510 static int qtnf_hhbm_init(struct qtnf_pcie_bus_priv *priv)
 511 {
 512         u32 val;
 513
 514         val = readl(PCIE_HHBM_CONFIG(priv->pcie_reg_base));
 515         val |= HHBM_CONFIG_SOFT_RESET;
 516         writel(val, PCIE_HHBM_CONFIG(priv->pcie_reg_base));
 517         usleep_range(50, 100);
 518         val &= ~HHBM_CONFIG_SOFT_RESET;
 519 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 520         val |= HHBM_64BIT;
 521 #endif
 522         writel(val, PCIE_HHBM_CONFIG(priv->pcie_reg_base));
 523         writel(priv->rx_bd_num, PCIE_HHBM_Q_LIMIT_REG(priv->pcie_reg_base));
 524
 525         return 0;
 526 }
 527
 528 static int qtnf_pcie_init_xfer(struct qtnf_pcie_bus_priv *priv)
 529 {
 530         int ret;
 531         u32 val;
 532
 533         priv->tx_bd_num = tx_bd_size_param;
 534         priv->rx_bd_num = rx_bd_size_param;
 535         priv->rx_bd_w_index = 0;
 536         priv->rx_bd_r_index = 0;
 537
 538         if (!priv->tx_bd_num || !is_power_of_2(priv->tx_bd_num)) {
 539                 pr_err("tx_bd_size_param %u is not power of two\n",
 540                        priv->tx_bd_num);
 541                 return -EINVAL;
 542         }
 543
 544         val = priv->tx_bd_num * sizeof(struct qtnf_tx_bd);
 545         if (val > PCIE_HHBM_MAX_SIZE) {
 546                 pr_err("tx_bd_size_param %u is too large\n",
 547                        priv->tx_bd_num);
 548                 return -EINVAL;
 549         }
 550
 551         if (!priv->rx_bd_num || !is_power_of_2(priv->rx_bd_num)) {
 552                 pr_err("rx_bd_size_param %u is not power of two\n",
 553                        priv->rx_bd_num);
 554                 return -EINVAL;
 555         }
 556
 557         val = priv->rx_bd_num * sizeof(dma_addr_t);
 558         if (val > PCIE_HHBM_MAX_SIZE) {
 559                 pr_err("rx_bd_size_param %u is too large\n",
 560                        priv->rx_bd_num);
 561                 return -EINVAL;
 562         }
 563
 564         ret = qtnf_hhbm_init(priv);
 565         if (ret) {
 566                 pr_err("failed to init h/w queues\n");
 567                 return ret;
 568         }
 569
 570         ret = alloc_skb_array(priv);
 571         if (ret) {
 572                 pr_err("failed to allocate skb array\n");
 573                 return ret;
 574         }
 575
 576         ret = alloc_bd_table(priv);
 577         if (ret) {
 578                 pr_err("failed to allocate bd table\n");
 579                 return ret;
 580         }
 581
 582         ret = alloc_rx_buffers(priv);
 583         if (ret) {
 584                 pr_err("failed to allocate rx buffers\n");
 585                 return ret;
 586         }
 587
 588         return ret;
 589 }
 590
 591 static void qtnf_pcie_data_tx_reclaim(struct qtnf_pcie_bus_priv *priv)
 592 {
 593         struct qtnf_tx_bd *txbd;
 594         struct sk_buff *skb;
 595         unsigned long flags;
 596         dma_addr_t paddr;
 597         u32 tx_done_index;
 598         int count = 0;
 599         int i;
 600
 601         spin_lock_irqsave(&priv->tx_reclaim_lock, flags);
 602
 603         tx_done_index = readl(PCIE_HDP_RX0DMA_CNT(priv->pcie_reg_base))
 604                         & (priv->tx_bd_num - 1);
 605
 606         i = priv->tx_bd_r_index;
 607
 608         while (CIRC_CNT(tx_done_index, i, priv->tx_bd_num)) {
 609                 skb = priv->tx_skb[i];
 610                 if (likely(skb)) {
 611                         txbd = &priv->tx_bd_vbase[i];
 612                         paddr = QTN_HOST_ADDR(le32_to_cpu(txbd->addr_h),
 613                                               le32_to_cpu(txbd->addr));
 614                         pci_unmap_single(priv->pdev, paddr, skb->len,
 615                                          PCI_DMA_TODEVICE);
 616
 617                         if (skb->dev) {
 618                                 skb->dev->stats.tx_packets++;
 619                                 skb->dev->stats.tx_bytes += skb->len;
 620
 621                                 if (netif_queue_stopped(skb->dev))
 622                                         netif_wake_queue(skb->dev);
 623                         }
 624
 625                         dev_kfree_skb_any(skb);
 626                 }
 627
 628                 priv->tx_skb[i] = NULL;
 629                 count++;
 630
 631                 if (++i >= priv->tx_bd_num)
 632                         i = 0;
 633         }
 634
 635         priv->tx_reclaim_done += count;
 636         priv->tx_reclaim_req++;
 637         priv->tx_bd_r_index = i;
 638
 639         spin_unlock_irqrestore(&priv->tx_reclaim_lock, flags);
 640 }
 641
 642 static int qtnf_tx_queue_ready(struct qtnf_pcie_bus_priv *priv)
 643 {
 644         if (!CIRC_SPACE(priv->tx_bd_w_index, priv->tx_bd_r_index,
 645                         priv->tx_bd_num)) {
 646                 pr_err_ratelimited("reclaim full Tx queue\n");
 647                 qtnf_pcie_data_tx_reclaim(priv);
 648
 649                 if (!CIRC_SPACE(priv->tx_bd_w_index, priv->tx_bd_r_index,
 650                                 priv->tx_bd_num)) {
 651                         priv->tx_full_count++;
 652                         return 0;
 653                 }
 654         }
 655
 656         return 1;
 657 }
 658
 659 static int qtnf_pcie_data_tx(struct qtnf_bus *bus, struct sk_buff *skb)
 660 {
 661         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
 662         dma_addr_t txbd_paddr, skb_paddr;
 663         struct qtnf_tx_bd *txbd;
 664         unsigned long flags;
 665         int len, i;
 666         u32 info;
 667         int ret = 0;
 668
 669         spin_lock_irqsave(&priv->tx0_lock, flags);
 670
 671         if (!qtnf_tx_queue_ready(priv)) {
 672                 if (skb->dev)
 673                         netif_stop_queue(skb->dev);
 674
 675                 spin_unlock_irqrestore(&priv->tx0_lock, flags);
 676                 return NETDEV_TX_BUSY;
 677         }
 678
 679         i = priv->tx_bd_w_index;
 680         priv->tx_skb[i] = skb;
 681         len = skb->len;
 682
 683         skb_paddr = pci_map_single(priv->pdev, skb->data,
 684                                    skb->len, PCI_DMA_TODEVICE);
 685         if (pci_dma_mapping_error(priv->pdev, skb_paddr)) {
 686                 pr_err("skb DMA mapping error: %pad\n", &skb_paddr);
 687                 ret = -ENOMEM;
 688                 goto tx_done;
 689         }
 690
 691         txbd = &priv->tx_bd_vbase[i];
 692         txbd->addr = cpu_to_le32(QTN_HOST_LO32(skb_paddr));
 693         txbd->addr_h = cpu_to_le32(QTN_HOST_HI32(skb_paddr));
 694
 695         info = (len & QTN_PCIE_TX_DESC_LEN_MASK) << QTN_PCIE_TX_DESC_LEN_SHIFT;
 696         txbd->info = cpu_to_le32(info);
 697
 698         /* sync up all descriptor updates before passing them to EP */
 699         dma_wmb();
 700
 701         /* write new TX descriptor to PCIE_RX_FIFO on EP */
 702         txbd_paddr = priv->tx_bd_pbase + i * sizeof(struct qtnf_tx_bd);
 703
 704 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 705         writel(QTN_HOST_HI32(txbd_paddr),
 706                PCIE_HDP_HOST_WR_DESC0_H(priv->pcie_reg_base));
 707 #endif
 708         writel(QTN_HOST_LO32(txbd_paddr),
 709                PCIE_HDP_HOST_WR_DESC0(priv->pcie_reg_base));
 710
 711         if (++i >= priv->tx_bd_num)
 712                 i = 0;
 713
 714         priv->tx_bd_w_index = i;
 715
 716 tx_done:
 717         if (ret && skb) {
 718                 pr_err_ratelimited("drop skb\n");
 719                 if (skb->dev)
 720                         skb->dev->stats.tx_dropped++;
 721                 dev_kfree_skb_any(skb);
 722         }
 723
 724         priv->tx_done_count++;
 725         spin_unlock_irqrestore(&priv->tx0_lock, flags);
 726
 727         qtnf_pcie_data_tx_reclaim(priv);
 728
 729         return NETDEV_TX_OK;
 730 }
 731
 732 static int qtnf_pcie_control_tx(struct qtnf_bus *bus, struct sk_buff *skb)
 733 {
 734         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
 735
 736         return qtnf_shm_ipc_send(&priv->shm_ipc_ep_in, skb->data, skb->len);
 737 }
 738
 739 static irqreturn_t qtnf_interrupt(int irq, void *data)
 740 {
 741         struct qtnf_bus *bus = (struct qtnf_bus *)data;
 742         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
 743         u32 status;
 744
 745         priv->pcie_irq_count++;
 746         status = readl(PCIE_HDP_INT_STATUS(priv->pcie_reg_base));
 747
 748         qtnf_shm_ipc_irq_handler(&priv->shm_ipc_ep_in);
 749         qtnf_shm_ipc_irq_handler(&priv->shm_ipc_ep_out);
 750
 751         if (!(status & priv->pcie_irq_mask))
 752                 goto irq_done;
 753
 754         if (status & PCIE_HDP_INT_RX_BITS)
 755                 priv->pcie_irq_rx_count++;
 756
 757         if (status & PCIE_HDP_INT_TX_BITS)
 758                 priv->pcie_irq_tx_count++;
 759
 760         if (status & PCIE_HDP_INT_HHBM_UF)
 761                 priv->pcie_irq_uf_count++;
 762
 763         if (status & PCIE_HDP_INT_RX_BITS) {
 764                 qtnf_dis_rxdone_irq(priv);
 765                 napi_schedule(&bus->mux_napi);
 766         }
 767
 768         if (status & PCIE_HDP_INT_TX_BITS) {
 769                 qtnf_dis_txdone_irq(priv);
 770                 tasklet_hi_schedule(&priv->reclaim_tq);
 771         }
 772
 773 irq_done:
 774         /* H/W workaround: clean all bits, not only enabled */
 775         qtnf_non_posted_write(~0U, PCIE_HDP_INT_STATUS(priv->pcie_reg_base));
 776
 777         if (!priv->msi_enabled)
 778                 qtnf_deassert_intx(priv);
 779
 780         return IRQ_HANDLED;
 781 }
 782
 783 static int qtnf_rx_data_ready(struct qtnf_pcie_bus_priv *priv)
 784 {
 785         u16 index = priv->rx_bd_r_index;
 786         struct qtnf_rx_bd *rxbd;
 787         u32 descw;
 788
 789         rxbd = &priv->rx_bd_vbase[index];
 790         descw = le32_to_cpu(rxbd->info);
 791
 792         if (descw & QTN_TXDONE_MASK)
 793                 return 1;
 794
 795         return 0;
 796 }
 797
 798 static int qtnf_rx_poll(struct napi_struct *napi, int budget)
 799 {
 800         struct qtnf_bus *bus = container_of(napi, struct qtnf_bus, mux_napi);
 801         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
 802         struct net_device *ndev = NULL;
 803         struct sk_buff *skb = NULL;
 804         int processed = 0;
 805         struct qtnf_rx_bd *rxbd;
 806         dma_addr_t skb_paddr;
 807         int consume;
 808         u32 descw;
 809         u32 psize;
 810         u16 r_idx;
 811         u16 w_idx;
 812         int ret;
 813
 814         while (processed < budget) {
 815
 816
 817                 if (!qtnf_rx_data_ready(priv))
 818                         goto rx_out;
 819
 820                 r_idx = priv->rx_bd_r_index;
 821                 rxbd = &priv->rx_bd_vbase[r_idx];
 822                 descw = le32_to_cpu(rxbd->info);
 823
 824                 skb = priv->rx_skb[r_idx];
 825                 psize = QTN_GET_LEN(descw);
 826                 consume = 1;
 827
 828                 if (!(descw & QTN_TXDONE_MASK)) {
 829                         pr_warn("skip invalid rxbd[%d]\n", r_idx);
 830                         consume = 0;
 831                 }
 832
 833                 if (!skb) {
 834                         pr_warn("skip missing rx_skb[%d]\n", r_idx);
 835                         consume = 0;
 836                 }
 837
 838                 if (skb && (skb_tailroom(skb) <  psize)) {
 839                         pr_err("skip packet with invalid length: %u > %u\n",
 840                                psize, skb_tailroom(skb));
 841                         consume = 0;
 842                 }
 843
 844                 if (skb) {
 845                         skb_paddr = QTN_HOST_ADDR(le32_to_cpu(rxbd->addr_h),
 846                                                   le32_to_cpu(rxbd->addr));
 847                         pci_unmap_single(priv->pdev, skb_paddr, SKB_BUF_SIZE,
 848                                          PCI_DMA_FROMDEVICE);
 849                 }
 850
 851                 if (consume) {
 852                         skb_put(skb, psize);
 853                         ndev = qtnf_classify_skb(bus, skb);
 854                         if (likely(ndev)) {
 855                                 ndev->stats.rx_packets++;
 856                                 ndev->stats.rx_bytes += skb->len;
 857
 858                                 skb->protocol = eth_type_trans(skb, ndev);
 859                                 napi_gro_receive(napi, skb);
 860                         } else {
 861                                 pr_debug("drop untagged skb\n");
 862                                 bus->mux_dev.stats.rx_dropped++;
 863                                 dev_kfree_skb_any(skb);
 864                         }
 865                 } else {
 866                         if (skb) {
 867                                 bus->mux_dev.stats.rx_dropped++;
 868                                 dev_kfree_skb_any(skb);
 869                         }
 870                 }
 871
 872                 priv->rx_skb[r_idx] = NULL;
 873                 if (++r_idx >= priv->rx_bd_num)
 874                         r_idx = 0;
 875
 876                 priv->rx_bd_r_index = r_idx;
 877
 878                 /* repalce processed buffer by a new one */
 879                 w_idx = priv->rx_bd_w_index;
 880                 while (CIRC_SPACE(priv->rx_bd_w_index, priv->rx_bd_r_index,
 881                                   priv->rx_bd_num) > 0) {
 882                         if (++w_idx >= priv->rx_bd_num)
 883                                 w_idx = 0;
 884
 885                         ret = skb2rbd_attach(priv, w_idx);
 886                         if (ret) {
 887                                 pr_err("failed to allocate new rx_skb[%d]\n",
 888                                        w_idx);
 889                                 break;
 890                         }
 891                 }
 892
 893                 processed++;
 894         }
 895
 896 rx_out:
 897         if (processed < budget) {
 898                 napi_complete(napi);
 899                 qtnf_en_rxdone_irq(priv);
 900         }
 901
 902         return processed;
 903 }
 904
 905 static void
 906 qtnf_pcie_data_tx_timeout(struct qtnf_bus *bus, struct net_device *ndev)
 907 {
 908         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
 909
 910         tasklet_hi_schedule(&priv->reclaim_tq);
 911 }
 912
 913 static void qtnf_pcie_data_rx_start(struct qtnf_bus *bus)
 914 {
 915         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
 916
 917         qtnf_enable_hdp_irqs(priv);
 918         napi_enable(&bus->mux_napi);
 919 }
 920
 921 static void qtnf_pcie_data_rx_stop(struct qtnf_bus *bus)
 922 {
 923         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
 924
 925         napi_disable(&bus->mux_napi);
 926         qtnf_disable_hdp_irqs(priv);
 927 }
 928
 929 static const struct qtnf_bus_ops qtnf_pcie_bus_ops = {
 930         /* control path methods */
 931         .control_tx     = qtnf_pcie_control_tx,
 932
 933         /* data path methods */
 934         .data_tx                = qtnf_pcie_data_tx,
 935         .data_tx_timeout        = qtnf_pcie_data_tx_timeout,
 936         .data_rx_start          = qtnf_pcie_data_rx_start,
 937         .data_rx_stop           = qtnf_pcie_data_rx_stop,
 938 };
 939
 940 static int qtnf_ep_fw_send(struct qtnf_pcie_bus_priv *priv, uint32_t size,
 941                            int blk, const u8 *pblk, const u8 *fw)
 942 {
 943         struct pci_dev *pdev = priv->pdev;
 944         struct qtnf_bus *bus = pci_get_drvdata(pdev);
 945
 946         struct qtnf_pcie_fw_hdr *hdr;
 947         u8 *pdata;
 948
 949         int hds = sizeof(*hdr);
 950         struct sk_buff *skb = NULL;
 951         int len = 0;
 952         int ret;
 953
 954         skb = __dev_alloc_skb(QTN_PCIE_FW_BUFSZ, GFP_KERNEL);
 955         if (!skb)
 956                 return -ENOMEM;
 957
 958         skb->len = QTN_PCIE_FW_BUFSZ;
 959         skb->dev = NULL;
 960
 961         hdr = (struct qtnf_pcie_fw_hdr *)skb->data;
 962         memcpy(hdr->boardflg, QTN_PCIE_BOARDFLG, strlen(QTN_PCIE_BOARDFLG));
 963         hdr->fwsize = cpu_to_le32(size);
 964         hdr->seqnum = cpu_to_le32(blk);
 965
 966         if (blk)
 967                 hdr->type = cpu_to_le32(QTN_FW_DSUB);
 968         else
 969                 hdr->type = cpu_to_le32(QTN_FW_DBEGIN);
 970
 971         pdata = skb->data + hds;
 972
 973         len = QTN_PCIE_FW_BUFSZ - hds;
 974         if (pblk >= (fw + size - len)) {
 975                 len = fw + size - pblk;
 976                 hdr->type = cpu_to_le32(QTN_FW_DEND);
 977         }
 978
 979         hdr->pktlen = cpu_to_le32(len);
 980         memcpy(pdata, pblk, len);
 981         hdr->crc = cpu_to_le32(~crc32(0, pdata, len));
 982
 983         ret = qtnf_pcie_data_tx(bus, skb);
 984
 985         return (ret == NETDEV_TX_OK) ? len : 0;
 986 }
 987
 988 static int
 989 qtnf_ep_fw_load(struct qtnf_pcie_bus_priv *priv, const u8 *fw, u32 fw_size)
 990 {
 991         int blk_size = QTN_PCIE_FW_BUFSZ - sizeof(struct qtnf_pcie_fw_hdr);
 992         int blk_count = fw_size / blk_size + ((fw_size % blk_size) ? 1 : 0);
 993         const u8 *pblk = fw;
 994         int threshold = 0;
 995         int blk = 0;
 996         int len;
 997
 998         pr_debug("FW upload started: fw_addr=0x%p size=%d\n", fw, fw_size);
 999
1000         while (blk < blk_count) {
1001                 if (++threshold > 10000) {
1002                         pr_err("FW upload failed: too many retries\n");
1003                         return -ETIMEDOUT;
1004                 }
1005
1006                 len = qtnf_ep_fw_send(priv, fw_size, blk, pblk, fw);
1007                 if (len <= 0)
1008                         continue;
1009
1010                 if (!((blk + 1) & QTN_PCIE_FW_DLMASK) ||
1011                     (blk == (blk_count - 1))) {
1012                         qtnf_set_state(&priv->bda->bda_rc_state,
1013                                        QTN_RC_FW_SYNC);
1014                         if (qtnf_poll_state(&priv->bda->bda_ep_state,
1015                                             QTN_EP_FW_SYNC,
1016                                             QTN_FW_DL_TIMEOUT_MS)) {
1017                                 pr_err("FW upload failed: SYNC timed out\n");
1018                                 return -ETIMEDOUT;
1019                         }
1020
1021                         qtnf_clear_state(&priv->bda->bda_ep_state,
1022                                          QTN_EP_FW_SYNC);
1023
1024                         if (qtnf_is_state(&priv->bda->bda_ep_state,
1025                                           QTN_EP_FW_RETRY)) {
1026                                 if (blk == (blk_count - 1)) {
1027                                         int last_round =
1028                                                 blk_count & QTN_PCIE_FW_DLMASK;
1029                                         blk -= last_round;
1030                                         pblk -= ((last_round - 1) *
1031                                                 blk_size + len);
1032                                 } else {
1033                                         blk -= QTN_PCIE_FW_DLMASK;
1034                                         pblk -= QTN_PCIE_FW_DLMASK * blk_size;
1035                                 }
1036
1037                                 qtnf_clear_state(&priv->bda->bda_ep_state,
1038                                                  QTN_EP_FW_RETRY);
1039
1040                                 pr_warn("FW upload retry: block #%d\n", blk);
1041                                 continue;
1042                         }
1043
1044                         qtnf_pcie_data_tx_reclaim(priv);
1045                 }
1046
1047                 pblk += len;
1048                 blk++;
1049         }
1050
1051         pr_debug("FW upload completed: totally sent %d blocks\n", blk);
1052         return 0;
1053 }
1054
1055 static void qtnf_firmware_load(const struct firmware *fw, void *context)
1056 {
1057         struct qtnf_pcie_bus_priv *priv = (void *)context;
1058         struct pci_dev *pdev = priv->pdev;
1059         struct qtnf_bus *bus = pci_get_drvdata(pdev);
1060         int ret;
1061
1062         if (!fw) {
1063                 pr_err("failed to get firmware %s\n", bus->fwname);
1064                 goto fw_load_err;
1065         }
1066
1067         ret = qtnf_ep_fw_load(priv, fw->data, fw->size);
1068         if (ret) {
1069                 pr_err("FW upload error\n");
1070                 goto fw_load_err;
1071         }
1072
1073         if (qtnf_poll_state(&priv->bda->bda_ep_state, QTN_EP_FW_DONE,
1074                             QTN_FW_DL_TIMEOUT_MS)) {
1075                 pr_err("FW bringup timed out\n");
1076                 goto fw_load_err;
1077         }
1078
1079         bus->fw_state = QTNF_FW_STATE_FW_DNLD_DONE;
1080         pr_info("firmware is up and running\n");
1081
1082 fw_load_err:
1083
1084         if (fw)
1085                 release_firmware(fw);
1086
1087         complete(&bus->request_firmware_complete);
1088 }
1089
1090 static int qtnf_bringup_fw(struct qtnf_bus *bus)
1091 {
1092         struct qtnf_pcie_bus_priv *priv = (void *)get_bus_priv(bus);
1093         struct pci_dev *pdev = priv->pdev;
1094         int ret;
1095         u32 state = QTN_RC_FW_LOADRDY | QTN_RC_FW_QLINK;
1096
1097         if (flashboot)
1098                 state |= QTN_RC_FW_FLASHBOOT;
1099
1100         qtnf_set_state(&priv->bda->bda_rc_state, state);
1101
1102         if (qtnf_poll_state(&priv->bda->bda_ep_state, QTN_EP_FW_LOADRDY,
1103                             QTN_FW_DL_TIMEOUT_MS)) {
1104                 pr_err("card is not ready\n");
1105                 return -ETIMEDOUT;
1106         }
1107
1108         qtnf_clear_state(&priv->bda->bda_ep_state, QTN_EP_FW_LOADRDY);
1109
1110         if (flashboot) {
1111                 pr_info("Booting FW from flash\n");
1112
1113                 if (!qtnf_poll_state(&priv->bda->bda_ep_state, QTN_EP_FW_DONE,
1114                                      QTN_FW_DL_TIMEOUT_MS))
1115                         bus->fw_state = QTNF_FW_STATE_FW_DNLD_DONE;
1116
1117                 return 0;
1118         }
1119
1120         pr_info("starting firmware upload: %s\n", bus->fwname);
1121
1122         ret = request_firmware_nowait(THIS_MODULE, 1, bus->fwname, &pdev->dev,
1123                                       GFP_KERNEL, priv, qtnf_firmware_load);
1124         if (ret < 0)
1125                 pr_err("request_firmware_nowait error %d\n", ret);
1126         else
1127                 ret = 1;
1128
1129         return ret;
1130 }
1131
1132 static void qtnf_reclaim_tasklet_fn(unsigned long data)
1133 {
1134         struct qtnf_pcie_bus_priv *priv = (void *)data;
1135
1136         qtnf_pcie_data_tx_reclaim(priv);
1137         qtnf_en_txdone_irq(priv);
1138 }
1139
1140 static int qtnf_dbg_mps_show(struct seq_file *s, void *data)
1141 {
1142         struct qtnf_bus *bus = dev_get_drvdata(s->private);
1143         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
1144
1145         seq_printf(s, "%d\n", priv->mps);
1146
1147         return 0;
1148 }
1149
1150 static int qtnf_dbg_msi_show(struct seq_file *s, void *data)
1151 {
1152         struct qtnf_bus *bus = dev_get_drvdata(s->private);
1153         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
1154
1155         seq_printf(s, "%u\n", priv->msi_enabled);
1156
1157         return 0;
1158 }
1159
1160 static int qtnf_dbg_irq_stats(struct seq_file *s, void *data)
1161 {
1162         struct qtnf_bus *bus = dev_get_drvdata(s->private);
1163         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
1164         u32 reg = readl(PCIE_HDP_INT_EN(priv->pcie_reg_base));
1165         u32 status;
1166
1167         seq_printf(s, "pcie_irq_count(%u)\n", priv->pcie_irq_count);
1168         seq_printf(s, "pcie_irq_tx_count(%u)\n", priv->pcie_irq_tx_count);
1169         status = reg &  PCIE_HDP_INT_TX_BITS;
1170         seq_printf(s, "pcie_irq_tx_status(%s)\n",
1171                    (status == PCIE_HDP_INT_TX_BITS) ? "EN" : "DIS");
1172         seq_printf(s, "pcie_irq_rx_count(%u)\n", priv->pcie_irq_rx_count);
1173         status = reg &  PCIE_HDP_INT_RX_BITS;
1174         seq_printf(s, "pcie_irq_rx_status(%s)\n",
1175                    (status == PCIE_HDP_INT_RX_BITS) ? "EN" : "DIS");
1176         seq_printf(s, "pcie_irq_uf_count(%u)\n", priv->pcie_irq_uf_count);
1177         status = reg &  PCIE_HDP_INT_HHBM_UF;
1178         seq_printf(s, "pcie_irq_hhbm_uf_status(%s)\n",
1179                    (status == PCIE_HDP_INT_HHBM_UF) ? "EN" : "DIS");
1180
1181         return 0;
1182 }
1183
1184 static int qtnf_dbg_hdp_stats(struct seq_file *s, void *data)
1185 {
1186         struct qtnf_bus *bus = dev_get_drvdata(s->private);
1187         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
1188
1189         seq_printf(s, "tx_full_count(%u)\n", priv->tx_full_count);
1190         seq_printf(s, "tx_done_count(%u)\n", priv->tx_done_count);
1191         seq_printf(s, "tx_reclaim_done(%u)\n", priv->tx_reclaim_done);
1192         seq_printf(s, "tx_reclaim_req(%u)\n", priv->tx_reclaim_req);
1193
1194         seq_printf(s, "tx_bd_r_index(%u)\n", priv->tx_bd_r_index);
1195         seq_printf(s, "tx_bd_p_index(%u)\n",
1196                    readl(PCIE_HDP_RX0DMA_CNT(priv->pcie_reg_base))
1197                         & (priv->tx_bd_num - 1));
1198         seq_printf(s, "tx_bd_w_index(%u)\n", priv->tx_bd_w_index);
1199         seq_printf(s, "tx queue len(%u)\n",
1200                    CIRC_CNT(priv->tx_bd_w_index, priv->tx_bd_r_index,
1201                             priv->tx_bd_num));
1202
1203         seq_printf(s, "rx_bd_r_index(%u)\n", priv->rx_bd_r_index);
1204         seq_printf(s, "rx_bd_p_index(%u)\n",
1205                    readl(PCIE_HDP_TX0DMA_CNT(priv->pcie_reg_base))
1206                         & (priv->rx_bd_num - 1));
1207         seq_printf(s, "rx_bd_w_index(%u)\n", priv->rx_bd_w_index);
1208         seq_printf(s, "rx alloc queue len(%u)\n",
1209                    CIRC_SPACE(priv->rx_bd_w_index, priv->rx_bd_r_index,
1210                               priv->rx_bd_num));
1211
1212         return 0;
1213 }
1214
1215 static int qtnf_dbg_shm_stats(struct seq_file *s, void *data)
1216 {
1217         struct qtnf_bus *bus = dev_get_drvdata(s->private);
1218         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
1219
1220         seq_printf(s, "shm_ipc_ep_in.tx_packet_count(%zu)\n",
1221                    priv->shm_ipc_ep_in.tx_packet_count);
1222         seq_printf(s, "shm_ipc_ep_in.rx_packet_count(%zu)\n",
1223                    priv->shm_ipc_ep_in.rx_packet_count);
1224         seq_printf(s, "shm_ipc_ep_out.tx_packet_count(%zu)\n",
1225                    priv->shm_ipc_ep_out.tx_timeout_count);
1226         seq_printf(s, "shm_ipc_ep_out.rx_packet_count(%zu)\n",
1227                    priv->shm_ipc_ep_out.rx_packet_count);
1228
1229         return 0;
1230 }
1231
1232 static int qtnf_pcie_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1233 {
1234         struct qtnf_pcie_bus_priv *pcie_priv;
1235         struct qtnf_bus *bus;
1236         int ret;
1237
1238         bus = devm_kzalloc(&pdev->dev,
1239                            sizeof(*bus) + sizeof(*pcie_priv), GFP_KERNEL);
1240         if (!bus) {
1241                 ret = -ENOMEM;
1242                 goto err_init;
1243         }
1244
1245         pcie_priv = get_bus_priv(bus);
1246
1247         pci_set_drvdata(pdev, bus);
1248         bus->bus_ops = &qtnf_pcie_bus_ops;
1249         bus->dev = &pdev->dev;
1250         bus->fw_state = QTNF_FW_STATE_RESET;
1251         pcie_priv->pdev = pdev;
1252
1253         strcpy(bus->fwname, QTN_PCI_PEARL_FW_NAME);
1254         init_completion(&bus->request_firmware_complete);
1255         mutex_init(&bus->bus_lock);
1256         spin_lock_init(&pcie_priv->tx0_lock);
1257         spin_lock_init(&pcie_priv->irq_lock);
1258         spin_lock_init(&pcie_priv->tx_reclaim_lock);
1259
1260         /* init stats */
1261         pcie_priv->tx_full_count = 0;
1262         pcie_priv->tx_done_count = 0;
1263         pcie_priv->pcie_irq_count = 0;
1264         pcie_priv->pcie_irq_rx_count = 0;
1265         pcie_priv->pcie_irq_tx_count = 0;
1266         pcie_priv->pcie_irq_uf_count = 0;
1267         pcie_priv->tx_reclaim_done = 0;
1268         pcie_priv->tx_reclaim_req = 0;
1269
1270         pcie_priv->workqueue = create_singlethread_workqueue("QTNF_PEARL_PCIE");
1271         if (!pcie_priv->workqueue) {
1272                 pr_err("failed to alloc bus workqueue\n");
1273                 ret = -ENODEV;
1274                 goto err_priv;
1275         }
1276
1277         if (!pci_is_pcie(pdev)) {
1278                 pr_err("device %s is not PCI Express\n", pci_name(pdev));
1279                 ret = -EIO;
1280                 goto err_base;
1281         }
1282
1283         qtnf_tune_pcie_mps(pcie_priv);
1284
1285         ret = pcim_enable_device(pdev);
1286         if (ret) {
1287                 pr_err("failed to init PCI device %x\n", pdev->device);
1288                 goto err_base;
1289         } else {
1290                 pr_debug("successful init of PCI device %x\n", pdev->device);
1291         }
1292
1293 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1294         ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
1295 #else
1296         ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1297 #endif
1298         if (ret) {
1299                 pr_err("PCIE DMA coherent mask init failed\n");
1300                 goto err_base;
1301         }
1302
1303         pcim_pin_device(pdev);
1304         pci_set_master(pdev);
1305
1306         ret = qtnf_pcie_init_irq(pcie_priv);
1307         if (ret < 0) {
1308                 pr_err("irq init failed\n");
1309                 goto err_base;
1310         }
1311
1312         ret = qtnf_pcie_init_memory(pcie_priv);
1313         if (ret < 0) {
1314                 pr_err("PCIE memory init failed\n");
1315                 goto err_base;
1316         }
1317
1318         ret = qtnf_pcie_init_shm_ipc(pcie_priv);
1319         if (ret < 0) {
1320                 pr_err("PCIE SHM IPC init failed\n");
1321                 goto err_base;
1322         }
1323
1324         ret = devm_add_action(&pdev->dev, free_xfer_buffers, (void *)pcie_priv);
1325         if (ret) {
1326                 pr_err("custom release callback init failed\n");
1327                 goto err_base;
1328         }
1329
1330         ret = qtnf_pcie_init_xfer(pcie_priv);
1331         if (ret) {
1332                 pr_err("PCIE xfer init failed\n");
1333                 goto err_base;
1334         }
1335
1336         /* init default irq settings */
1337         qtnf_init_hdp_irqs(pcie_priv);
1338
1339         /* start with disabled irqs */
1340         qtnf_disable_hdp_irqs(pcie_priv);
1341
1342         ret = devm_request_irq(&pdev->dev, pdev->irq, &qtnf_interrupt, 0,
1343                                "qtnf_pcie_irq", (void *)bus);
1344         if (ret) {
1345                 pr_err("failed to request pcie irq %d\n", pdev->irq);
1346                 goto err_base;
1347         }
1348
1349         tasklet_init(&pcie_priv->reclaim_tq, qtnf_reclaim_tasklet_fn,
1350                      (unsigned long)pcie_priv);
1351         init_dummy_netdev(&bus->mux_dev);
1352         netif_napi_add(&bus->mux_dev, &bus->mux_napi,
1353                        qtnf_rx_poll, 10);
1354
1355         ret = qtnf_bringup_fw(bus);
1356         if (ret < 0)
1357                 goto err_bringup_fw;
1358         else if (ret)
1359                 wait_for_completion(&bus->request_firmware_complete);
1360
1361         if (bus->fw_state != QTNF_FW_STATE_FW_DNLD_DONE) {
1362                 pr_err("failed to start FW\n");
1363                 goto err_bringup_fw;
1364         }
1365
1366         if (qtnf_poll_state(&pcie_priv->bda->bda_ep_state, QTN_EP_FW_QLINK_DONE,
1367                             QTN_FW_QLINK_TIMEOUT_MS)) {
1368                 pr_err("FW runtime failure\n");
1369                 goto err_bringup_fw;
1370         }
1371
1372         ret = qtnf_core_attach(bus);
1373         if (ret) {
1374                 pr_err("failed to attach core\n");
1375                 goto err_bringup_fw;
1376         }
1377
1378         qtnf_debugfs_init(bus, DRV_NAME);
1379         qtnf_debugfs_add_entry(bus, "mps", qtnf_dbg_mps_show);
1380         qtnf_debugfs_add_entry(bus, "msi_enabled", qtnf_dbg_msi_show);
1381         qtnf_debugfs_add_entry(bus, "hdp_stats", qtnf_dbg_hdp_stats);
1382         qtnf_debugfs_add_entry(bus, "irq_stats", qtnf_dbg_irq_stats);
1383         qtnf_debugfs_add_entry(bus, "shm_stats", qtnf_dbg_shm_stats);
1384
1385         return 0;
1386
1387 err_bringup_fw:
1388         netif_napi_del(&bus->mux_napi);
1389
1390 err_base:
1391         flush_workqueue(pcie_priv->workqueue);
1392         destroy_workqueue(pcie_priv->workqueue);
1393
1394 err_priv:
1395         pci_set_drvdata(pdev, NULL);
1396
1397 err_init:
1398         return ret;
1399 }
1400
1401 static void qtnf_pcie_remove(struct pci_dev *pdev)
1402 {
1403         struct qtnf_pcie_bus_priv *priv;
1404         struct qtnf_bus *bus;
1405
1406         bus = pci_get_drvdata(pdev);
1407         if (!bus)
1408                 return;
1409
1410         priv = get_bus_priv(bus);
1411
1412         qtnf_core_detach(bus);
1413         netif_napi_del(&bus->mux_napi);
1414
1415         flush_workqueue(priv->workqueue);
1416         destroy_workqueue(priv->workqueue);
1417         tasklet_kill(&priv->reclaim_tq);
1418
1419         qtnf_debugfs_remove(bus);
1420
1421         qtnf_pcie_free_shm_ipc(priv);
1422 }
1423
1424 #ifdef CONFIG_PM_SLEEP
1425 static int qtnf_pcie_suspend(struct device *dev)
1426 {
1427         return -EOPNOTSUPP;
1428 }
1429
1430 static int qtnf_pcie_resume(struct device *dev)
1431 {
1432         return 0;
1433 }
1434 #endif /* CONFIG_PM_SLEEP */
1435
1436 #ifdef CONFIG_PM_SLEEP
1437 /* Power Management Hooks */
1438 static SIMPLE_DEV_PM_OPS(qtnf_pcie_pm_ops, qtnf_pcie_suspend,
1439                          qtnf_pcie_resume);
1440 #endif
1441
1442 static const struct pci_device_id qtnf_pcie_devid_table[] = {
1443         {
1444                 PCIE_VENDOR_ID_QUANTENNA, PCIE_DEVICE_ID_QTN_PEARL,
1445                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
1446         },
1447         { },
1448 };
1449
1450 MODULE_DEVICE_TABLE(pci, qtnf_pcie_devid_table);
1451
1452 static struct pci_driver qtnf_pcie_drv_data = {
1453         .name = DRV_NAME,
1454         .id_table = qtnf_pcie_devid_table,
1455         .probe = qtnf_pcie_probe,
1456         .remove = qtnf_pcie_remove,
1457 #ifdef CONFIG_PM_SLEEP
1458         .driver = {
1459                 .pm = &qtnf_pcie_pm_ops,
1460         },
1461 #endif
1462 };
1463
1464 static int __init qtnf_pcie_register(void)
1465 {
1466         pr_info("register Quantenna QSR10g FullMAC PCIE driver\n");
1467         return pci_register_driver(&qtnf_pcie_drv_data);
1468 }
1469
1470 static void __exit qtnf_pcie_exit(void)
1471 {
1472         pr_info("unregister Quantenna QSR10g FullMAC PCIE driver\n");
1473         pci_unregister_driver(&qtnf_pcie_drv_data);
1474 }
1475
1476 module_init(qtnf_pcie_register);
1477 module_exit(qtnf_pcie_exit);
1478
1479 MODULE_AUTHOR("Quantenna Communications");
1480 MODULE_DESCRIPTION("Quantenna QSR10g PCIe bus driver for 802.11 wireless LAN.");
1481 MODULE_LICENSE("GPL");