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

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /* Copyright (c) 2018 Quantenna Communications, Inc. All rights reserved. */
   3
   4 #include <linux/printk.h>
   5 #include <linux/pci.h>
   6 #include <linux/spinlock.h>
   7 #include <linux/mutex.h>
   8 #include <linux/netdevice.h>
   9 #include <linux/seq_file.h>
  10 #include <linux/workqueue.h>
  11 #include <linux/completion.h>
  12
  13 #include "pcie_priv.h"
  14 #include "bus.h"
  15 #include "shm_ipc.h"
  16 #include "core.h"
  17 #include "debug.h"
  18
  19 #undef pr_fmt
  20 #define pr_fmt(fmt)     "qtnf_pcie: %s: " fmt, __func__
  21
  22 #define QTN_SYSCTL_BAR  0
  23 #define QTN_SHMEM_BAR   2
  24 #define QTN_DMA_BAR     3
  25
  26 int qtnf_pcie_control_tx(struct qtnf_bus *bus, struct sk_buff *skb)
  27 {
  28         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
  29         int ret;
  30
  31         ret = qtnf_shm_ipc_send(&priv->shm_ipc_ep_in, skb->data, skb->len);
  32
  33         if (ret == -ETIMEDOUT) {
  34                 pr_err("EP firmware is dead\n");
  35                 bus->fw_state = QTNF_FW_STATE_EP_DEAD;
  36         }
  37
  38         return ret;
  39 }
  40
  41 int qtnf_pcie_alloc_skb_array(struct qtnf_pcie_bus_priv *priv)
  42 {
  43         struct sk_buff **vaddr;
  44         int len;
  45
  46         len = priv->tx_bd_num * sizeof(*priv->tx_skb) +
  47                 priv->rx_bd_num * sizeof(*priv->rx_skb);
  48         vaddr = devm_kzalloc(&priv->pdev->dev, len, GFP_KERNEL);
  49
  50         if (!vaddr)
  51                 return -ENOMEM;
  52
  53         priv->tx_skb = vaddr;
  54
  55         vaddr += priv->tx_bd_num;
  56         priv->rx_skb = vaddr;
  57
  58         return 0;
  59 }
  60
  61 void qtnf_pcie_bringup_fw_async(struct qtnf_bus *bus)
  62 {
  63         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
  64         struct pci_dev *pdev = priv->pdev;
  65
  66         get_device(&pdev->dev);
  67         schedule_work(&bus->fw_work);
  68 }
  69
  70 static int qtnf_dbg_mps_show(struct seq_file *s, void *data)
  71 {
  72         struct qtnf_bus *bus = dev_get_drvdata(s->private);
  73         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
  74
  75         seq_printf(s, "%d\n", priv->mps);
  76
  77         return 0;
  78 }
  79
  80 static int qtnf_dbg_msi_show(struct seq_file *s, void *data)
  81 {
  82         struct qtnf_bus *bus = dev_get_drvdata(s->private);
  83         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
  84
  85         seq_printf(s, "%u\n", priv->msi_enabled);
  86
  87         return 0;
  88 }
  89
  90 static int qtnf_dbg_shm_stats(struct seq_file *s, void *data)
  91 {
  92         struct qtnf_bus *bus = dev_get_drvdata(s->private);
  93         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
  94
  95         seq_printf(s, "shm_ipc_ep_in.tx_packet_count(%zu)\n",
  96                    priv->shm_ipc_ep_in.tx_packet_count);
  97         seq_printf(s, "shm_ipc_ep_in.rx_packet_count(%zu)\n",
  98                    priv->shm_ipc_ep_in.rx_packet_count);
  99         seq_printf(s, "shm_ipc_ep_out.tx_packet_count(%zu)\n",
 100                    priv->shm_ipc_ep_out.tx_timeout_count);
 101         seq_printf(s, "shm_ipc_ep_out.rx_packet_count(%zu)\n",
 102                    priv->shm_ipc_ep_out.rx_packet_count);
 103
 104         return 0;
 105 }
 106
 107 void qtnf_pcie_fw_boot_done(struct qtnf_bus *bus, bool boot_success,
 108                             const char *drv_name)
 109 {
 110         struct qtnf_pcie_bus_priv *priv = get_bus_priv(bus);
 111         struct pci_dev *pdev = priv->pdev;
 112         int ret;
 113
 114         if (boot_success) {
 115                 bus->fw_state = QTNF_FW_STATE_FW_DNLD_DONE;
 116
 117                 ret = qtnf_core_attach(bus);
 118                 if (ret) {
 119                         pr_err("failed to attach core\n");
 120                         boot_success = false;
 121                 }
 122         }
 123
 124         if (boot_success) {
 125                 qtnf_debugfs_init(bus, drv_name);
 126                 qtnf_debugfs_add_entry(bus, "mps", qtnf_dbg_mps_show);
 127                 qtnf_debugfs_add_entry(bus, "msi_enabled", qtnf_dbg_msi_show);
 128                 qtnf_debugfs_add_entry(bus, "shm_stats", qtnf_dbg_shm_stats);
 129         } else {
 130                 bus->fw_state = QTNF_FW_STATE_DETACHED;
 131         }
 132
 133         put_device(&pdev->dev);
 134 }
 135
 136 static void qtnf_tune_pcie_mps(struct qtnf_pcie_bus_priv *priv)
 137 {
 138         struct pci_dev *pdev = priv->pdev;
 139         struct pci_dev *parent;
 140         int mps_p, mps_o, mps_m, mps;
 141         int ret;
 142
 143         /* current mps */
 144         mps_o = pcie_get_mps(pdev);
 145
 146         /* maximum supported mps */
 147         mps_m = 128 << pdev->pcie_mpss;
 148
 149         /* suggested new mps value */
 150         mps = mps_m;
 151
 152         if (pdev->bus && pdev->bus->self) {
 153                 /* parent (bus) mps */
 154                 parent = pdev->bus->self;
 155
 156                 if (pci_is_pcie(parent)) {
 157                         mps_p = pcie_get_mps(parent);
 158                         mps = min(mps_m, mps_p);
 159                 }
 160         }
 161
 162         ret = pcie_set_mps(pdev, mps);
 163         if (ret) {
 164                 pr_err("failed to set mps to %d, keep using current %d\n",
 165                        mps, mps_o);
 166                 priv->mps = mps_o;
 167                 return;
 168         }
 169
 170         pr_debug("set mps to %d (was %d, max %d)\n", mps, mps_o, mps_m);
 171         priv->mps = mps;
 172 }
 173
 174 static void qtnf_pcie_init_irq(struct qtnf_pcie_bus_priv *priv, bool use_msi)
 175 {
 176         struct pci_dev *pdev = priv->pdev;
 177
 178         /* fall back to legacy INTx interrupts by default */
 179         priv->msi_enabled = 0;
 180
 181         /* check if MSI capability is available */
 182         if (use_msi) {
 183                 if (!pci_enable_msi(pdev)) {
 184                         pr_debug("enabled MSI interrupt\n");
 185                         priv->msi_enabled = 1;
 186                 } else {
 187                         pr_warn("failed to enable MSI interrupts");
 188                 }
 189         }
 190
 191         if (!priv->msi_enabled) {
 192                 pr_warn("legacy PCIE interrupts enabled\n");
 193                 pci_intx(pdev, 1);
 194         }
 195 }
 196
 197 static void __iomem *qtnf_map_bar(struct qtnf_pcie_bus_priv *priv, u8 index)
 198 {
 199         void __iomem *vaddr;
 200         dma_addr_t busaddr;
 201         size_t len;
 202         int ret;
 203
 204         ret = pcim_iomap_regions(priv->pdev, 1 << index, "qtnfmac_pcie");
 205         if (ret)
 206                 return IOMEM_ERR_PTR(ret);
 207
 208         busaddr = pci_resource_start(priv->pdev, index);
 209         len = pci_resource_len(priv->pdev, index);
 210         vaddr = pcim_iomap_table(priv->pdev)[index];
 211         if (!vaddr)
 212                 return IOMEM_ERR_PTR(-ENOMEM);
 213
 214         pr_debug("BAR%u vaddr=0x%p busaddr=%pad len=%u\n",
 215                  index, vaddr, &busaddr, (int)len);
 216
 217         return vaddr;
 218 }
 219
 220 static int qtnf_pcie_init_memory(struct qtnf_pcie_bus_priv *priv)
 221 {
 222         int ret = -ENOMEM;
 223
 224         priv->sysctl_bar = qtnf_map_bar(priv, QTN_SYSCTL_BAR);
 225         if (IS_ERR(priv->sysctl_bar)) {
 226                 pr_err("failed to map BAR%u\n", QTN_SYSCTL_BAR);
 227                 return ret;
 228         }
 229
 230         priv->dmareg_bar = qtnf_map_bar(priv, QTN_DMA_BAR);
 231         if (IS_ERR(priv->dmareg_bar)) {
 232                 pr_err("failed to map BAR%u\n", QTN_DMA_BAR);
 233                 return ret;
 234         }
 235
 236         priv->epmem_bar = qtnf_map_bar(priv, QTN_SHMEM_BAR);
 237         if (IS_ERR(priv->epmem_bar)) {
 238                 pr_err("failed to map BAR%u\n", QTN_SHMEM_BAR);
 239                 return ret;
 240         }
 241
 242         return 0;
 243 }
 244
 245 static void qtnf_pcie_control_rx_callback(void *arg, const u8 __iomem *buf,
 246                                           size_t len)
 247 {
 248         struct qtnf_pcie_bus_priv *priv = arg;
 249         struct qtnf_bus *bus = pci_get_drvdata(priv->pdev);
 250         struct sk_buff *skb;
 251
 252         if (unlikely(len == 0)) {
 253                 pr_warn("zero length packet received\n");
 254                 return;
 255         }
 256
 257         skb = __dev_alloc_skb(len, GFP_KERNEL);
 258
 259         if (unlikely(!skb)) {
 260                 pr_err("failed to allocate skb\n");
 261                 return;
 262         }
 263
 264         memcpy_fromio(skb_put(skb, len), buf, len);
 265
 266         qtnf_trans_handle_rx_ctl_packet(bus, skb);
 267 }
 268
 269 void qtnf_pcie_init_shm_ipc(struct qtnf_pcie_bus_priv *priv,
 270                             struct qtnf_shm_ipc_region __iomem *ipc_tx_reg,
 271                             struct qtnf_shm_ipc_region __iomem *ipc_rx_reg,
 272                             const struct qtnf_shm_ipc_int *ipc_int)
 273 {
 274         const struct qtnf_shm_ipc_rx_callback rx_callback = {
 275                                         qtnf_pcie_control_rx_callback, priv };
 276
 277         qtnf_shm_ipc_init(&priv->shm_ipc_ep_in, QTNF_SHM_IPC_OUTBOUND,
 278                           ipc_tx_reg, priv->workqueue,
 279                           ipc_int, &rx_callback);
 280         qtnf_shm_ipc_init(&priv->shm_ipc_ep_out, QTNF_SHM_IPC_INBOUND,
 281                           ipc_rx_reg, priv->workqueue,
 282                           ipc_int, &rx_callback);
 283 }
 284
 285 int qtnf_pcie_probe(struct pci_dev *pdev, size_t priv_size,
 286                     const struct qtnf_bus_ops *bus_ops, u64 dma_mask,
 287                     bool use_msi)
 288 {
 289         struct qtnf_pcie_bus_priv *pcie_priv;
 290         struct qtnf_bus *bus;
 291         int ret;
 292
 293         bus = devm_kzalloc(&pdev->dev,
 294                            sizeof(*bus) + priv_size, GFP_KERNEL);
 295         if (!bus)
 296                 return -ENOMEM;
 297
 298         pcie_priv = get_bus_priv(bus);
 299
 300         pci_set_drvdata(pdev, bus);
 301         bus->bus_ops = bus_ops;
 302         bus->dev = &pdev->dev;
 303         bus->fw_state = QTNF_FW_STATE_RESET;
 304         pcie_priv->pdev = pdev;
 305         pcie_priv->tx_stopped = 0;
 306
 307         mutex_init(&bus->bus_lock);
 308         spin_lock_init(&pcie_priv->tx_lock);
 309         spin_lock_init(&pcie_priv->tx_reclaim_lock);
 310
 311         pcie_priv->tx_full_count = 0;
 312         pcie_priv->tx_done_count = 0;
 313         pcie_priv->pcie_irq_count = 0;
 314         pcie_priv->tx_reclaim_done = 0;
 315         pcie_priv->tx_reclaim_req = 0;
 316
 317         pcie_priv->workqueue = create_singlethread_workqueue("QTNF_PCIE");
 318         if (!pcie_priv->workqueue) {
 319                 pr_err("failed to alloc bus workqueue\n");
 320                 ret = -ENODEV;
 321                 goto err_init;
 322         }
 323
 324         init_dummy_netdev(&bus->mux_dev);
 325
 326         if (!pci_is_pcie(pdev)) {
 327                 pr_err("device %s is not PCI Express\n", pci_name(pdev));
 328                 ret = -EIO;
 329                 goto err_base;
 330         }
 331
 332         qtnf_tune_pcie_mps(pcie_priv);
 333
 334         ret = pcim_enable_device(pdev);
 335         if (ret) {
 336                 pr_err("failed to init PCI device %x\n", pdev->device);
 337                 goto err_base;
 338         } else {
 339                 pr_debug("successful init of PCI device %x\n", pdev->device);
 340         }
 341
 342         ret = dma_set_mask_and_coherent(&pdev->dev, dma_mask);
 343         if (ret) {
 344                 pr_err("PCIE DMA coherent mask init failed\n");
 345                 goto err_base;
 346         }
 347
 348         pci_set_master(pdev);
 349         qtnf_pcie_init_irq(pcie_priv, use_msi);
 350
 351         ret = qtnf_pcie_init_memory(pcie_priv);
 352         if (ret < 0) {
 353                 pr_err("PCIE memory init failed\n");
 354                 goto err_base;
 355         }
 356
 357         pci_save_state(pdev);
 358
 359         return 0;
 360
 361 err_base:
 362         flush_workqueue(pcie_priv->workqueue);
 363         destroy_workqueue(pcie_priv->workqueue);
 364 err_init:
 365         pci_set_drvdata(pdev, NULL);
 366
 367         return ret;
 368 }
 369
 370 static void qtnf_pcie_free_shm_ipc(struct qtnf_pcie_bus_priv *priv)
 371 {
 372         qtnf_shm_ipc_free(&priv->shm_ipc_ep_in);
 373         qtnf_shm_ipc_free(&priv->shm_ipc_ep_out);
 374 }
 375
 376 void qtnf_pcie_remove(struct qtnf_bus *bus, struct qtnf_pcie_bus_priv *priv)
 377 {
 378         cancel_work_sync(&bus->fw_work);
 379
 380         if (bus->fw_state == QTNF_FW_STATE_ACTIVE ||
 381             bus->fw_state == QTNF_FW_STATE_EP_DEAD)
 382                 qtnf_core_detach(bus);
 383
 384         netif_napi_del(&bus->mux_napi);
 385         flush_workqueue(priv->workqueue);
 386         destroy_workqueue(priv->workqueue);
 387         tasklet_kill(&priv->reclaim_tq);
 388
 389         qtnf_pcie_free_shm_ipc(priv);
 390         qtnf_debugfs_remove(bus);
 391         pci_set_drvdata(priv->pdev, NULL);
 392 }