drivers/net/wireless/mediatek/mt76/mt7915/pci.c

   1 // SPDX-License-Identifier: ISC
   2 /* Copyright (C) 2020 MediaTek Inc.
   3  *
   4  * Author: Ryder Lee <ryder.lee@mediatek.com>
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/pci.h>
  10
  11 #include "mt7915.h"
  12 #include "mac.h"
  13 #include "../trace.h"
  14
  15 static LIST_HEAD(hif_list);
  16 static DEFINE_SPINLOCK(hif_lock);
  17 static u32 hif_idx;
  18
  19 static const struct pci_device_id mt7915_pci_device_table[] = {
  20         { PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x7915) },
  21         { PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x7906) },
  22         { },
  23 };
  24
  25 static const struct pci_device_id mt7915_hif_device_table[] = {
  26         { PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x7916) },
  27         { PCI_DEVICE(PCI_VENDOR_ID_MEDIATEK, 0x790a) },
  28         { },
  29 };
  30
  31 static struct mt7915_hif *mt7915_pci_get_hif2(u32 idx)
  32 {
  33         struct mt7915_hif *hif;
  34         u32 val;
  35
  36         spin_lock_bh(&hif_lock);
  37
  38         list_for_each_entry(hif, &hif_list, list) {
  39                 val = readl(hif->regs + MT_PCIE_RECOG_ID);
  40                 val &= MT_PCIE_RECOG_ID_MASK;
  41                 if (val != idx)
  42                         continue;
  43
  44                 get_device(hif->dev);
  45                 goto out;
  46         }
  47         hif = NULL;
  48
  49 out:
  50         spin_unlock_bh(&hif_lock);
  51
  52         return hif;
  53 }
  54
  55 static void mt7915_put_hif2(struct mt7915_hif *hif)
  56 {
  57         if (!hif)
  58                 return;
  59
  60         put_device(hif->dev);
  61 }
  62
  63 static struct mt7915_hif *mt7915_pci_init_hif2(struct pci_dev *pdev)
  64 {
  65         struct pci_dev *tmp_pdev;
  66
  67         hif_idx++;
  68
  69         tmp_pdev = pci_get_device(PCI_VENDOR_ID_MEDIATEK, 0x7916, NULL);
  70         if (!tmp_pdev) {
  71                 tmp_pdev = pci_get_device(PCI_VENDOR_ID_MEDIATEK, 0x790a, NULL);
  72                 if (!tmp_pdev)
  73                         return NULL;
  74         }
  75         pci_dev_put(tmp_pdev);
  76
  77         writel(hif_idx | MT_PCIE_RECOG_ID_SEM,
  78                pcim_iomap_table(pdev)[0] + MT_PCIE_RECOG_ID);
  79
  80         return mt7915_pci_get_hif2(hif_idx);
  81 }
  82
  83 static int mt7915_pci_hif2_probe(struct pci_dev *pdev)
  84 {
  85         struct mt7915_hif *hif;
  86
  87         hif = devm_kzalloc(&pdev->dev, sizeof(*hif), GFP_KERNEL);
  88         if (!hif)
  89                 return -ENOMEM;
  90
  91         hif->dev = &pdev->dev;
  92         hif->regs = pcim_iomap_table(pdev)[0];
  93         hif->irq = pdev->irq;
  94         spin_lock_bh(&hif_lock);
  95         list_add(&hif->list, &hif_list);
  96         spin_unlock_bh(&hif_lock);
  97         pci_set_drvdata(pdev, hif);
  98
  99         return 0;
 100 }
 101
 102 static int mt7915_pci_probe(struct pci_dev *pdev,
 103                             const struct pci_device_id *id)
 104 {
 105         struct mt7915_hif *hif2 = NULL;
 106         struct mt7915_dev *dev;
 107         struct mt76_dev *mdev;
 108         int irq;
 109         int ret;
 110
 111         ret = pcim_enable_device(pdev);
 112         if (ret)
 113                 return ret;
 114
 115         ret = pcim_iomap_regions(pdev, BIT(0), pci_name(pdev));
 116         if (ret)
 117                 return ret;
 118
 119         pci_set_master(pdev);
 120
 121         ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
 122         if (ret)
 123                 return ret;
 124
 125         mt76_pci_disable_aspm(pdev);
 126
 127         if (id->device == 0x7916 || id->device == 0x790a)
 128                 return mt7915_pci_hif2_probe(pdev);
 129
 130         dev = mt7915_mmio_probe(&pdev->dev, pcim_iomap_table(pdev)[0],
 131                                 id->device);
 132         if (IS_ERR(dev))
 133                 return PTR_ERR(dev);
 134
 135         mdev = &dev->mt76;
 136         mt7915_wfsys_reset(dev);
 137         hif2 = mt7915_pci_init_hif2(pdev);
 138
 139         ret = mt7915_mmio_wed_init(dev, pdev, true, &irq);
 140         if (ret < 0)
 141                 goto free_wed_or_irq_vector;
 142
 143         if (!ret) {
 144                 hif2 = mt7915_pci_init_hif2(pdev);
 145
 146                 ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
 147                 if (ret < 0)
 148                         goto free_device;
 149
 150                 irq = pdev->irq;
 151         }
 152
 153         ret = devm_request_irq(mdev->dev, irq, mt7915_irq_handler,
 154                                IRQF_SHARED, KBUILD_MODNAME, dev);
 155         if (ret)
 156                 goto free_wed_or_irq_vector;
 157
 158         /* master switch of PCIe tnterrupt enable */
 159         mt76_wr(dev, MT_PCIE_MAC_INT_ENABLE, 0xff);
 160
 161         if (hif2) {
 162                 dev->hif2 = hif2;
 163
 164                 mt76_wr(dev, MT_INT1_MASK_CSR, 0);
 165                 /* master switch of PCIe tnterrupt enable */
 166                 if (is_mt7915(mdev))
 167                         mt76_wr(dev, MT_PCIE1_MAC_INT_ENABLE, 0xff);
 168                 else
 169                         mt76_wr(dev, MT_PCIE1_MAC_INT_ENABLE_MT7916, 0xff);
 170
 171                 ret = devm_request_irq(mdev->dev, dev->hif2->irq,
 172                                        mt7915_irq_handler, IRQF_SHARED,
 173                                        KBUILD_MODNAME "-hif", dev);
 174                 if (ret)
 175                         goto free_hif2;
 176         }
 177
 178         ret = mt7915_register_device(dev);
 179         if (ret)
 180                 goto free_hif2_irq;
 181
 182         return 0;
 183
 184 free_hif2_irq:
 185         if (dev->hif2)
 186                 devm_free_irq(mdev->dev, dev->hif2->irq, dev);
 187 free_hif2:
 188         if (dev->hif2)
 189                 put_device(dev->hif2->dev);
 190         devm_free_irq(mdev->dev, irq, dev);
 191 free_wed_or_irq_vector:
 192         if (mtk_wed_device_active(&mdev->mmio.wed))
 193                 mtk_wed_device_detach(&mdev->mmio.wed);
 194         else
 195                 pci_free_irq_vectors(pdev);
 196 free_device:
 197         mt76_free_device(&dev->mt76);
 198
 199         return ret;
 200 }
 201
 202 static void mt7915_hif_remove(struct pci_dev *pdev)
 203 {
 204         struct mt7915_hif *hif = pci_get_drvdata(pdev);
 205
 206         list_del(&hif->list);
 207 }
 208
 209 static void mt7915_pci_remove(struct pci_dev *pdev)
 210 {
 211         struct mt76_dev *mdev;
 212         struct mt7915_dev *dev;
 213
 214         mdev = pci_get_drvdata(pdev);
 215         dev = container_of(mdev, struct mt7915_dev, mt76);
 216         mt7915_put_hif2(dev->hif2);
 217         mt7915_unregister_device(dev);
 218 }
 219
 220 struct pci_driver mt7915_hif_driver = {
 221         .name           = KBUILD_MODNAME "_hif",
 222         .id_table       = mt7915_hif_device_table,
 223         .probe          = mt7915_pci_probe,
 224         .remove         = mt7915_hif_remove,
 225 };
 226
 227 struct pci_driver mt7915_pci_driver = {
 228         .name           = KBUILD_MODNAME,
 229         .id_table       = mt7915_pci_device_table,
 230         .probe          = mt7915_pci_probe,
 231         .remove         = mt7915_pci_remove,
 232 };
 233
 234 MODULE_DEVICE_TABLE(pci, mt7915_pci_device_table);
 235 MODULE_DEVICE_TABLE(pci, mt7915_hif_device_table);
 236 MODULE_FIRMWARE(MT7915_FIRMWARE_WA);
 237 MODULE_FIRMWARE(MT7915_FIRMWARE_WM);
 238 MODULE_FIRMWARE(MT7915_ROM_PATCH);
 239 MODULE_FIRMWARE(MT7916_FIRMWARE_WA);
 240 MODULE_FIRMWARE(MT7916_FIRMWARE_WM);
 241 MODULE_FIRMWARE(MT7916_ROM_PATCH);