1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2023 Advanced Micro Devices, Inc */ 3 4 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 5 6 #include <linux/pci.h> 7 8 #include <linux/pds/pds_common.h> 9 10 #include "core.h" 11 12 MODULE_DESCRIPTION(PDSC_DRV_DESCRIPTION); 13 MODULE_AUTHOR("Advanced Micro Devices, Inc"); 14 MODULE_LICENSE("GPL"); 15 16 /* Supported devices */ 17 static const struct pci_device_id pdsc_id_table[] = { 18 { PCI_VDEVICE(PENSANDO, PCI_DEVICE_ID_PENSANDO_CORE_PF) }, 19 { 0, } /* end of table */ 20 }; 21 MODULE_DEVICE_TABLE(pci, pdsc_id_table); 22 23 static void pdsc_unmap_bars(struct pdsc *pdsc) 24 { 25 struct pdsc_dev_bar *bars = pdsc->bars; 26 unsigned int i; 27 28 for (i = 0; i < PDS_CORE_BARS_MAX; i++) { 29 if (bars[i].vaddr) 30 pci_iounmap(pdsc->pdev, bars[i].vaddr); 31 } 32 } 33 34 static int pdsc_map_bars(struct pdsc *pdsc) 35 { 36 struct pdsc_dev_bar *bar = pdsc->bars; 37 struct pci_dev *pdev = pdsc->pdev; 38 struct device *dev = pdsc->dev; 39 struct pdsc_dev_bar *bars; 40 unsigned int i, j; 41 int num_bars = 0; 42 int err; 43 u32 sig; 44 45 bars = pdsc->bars; 46 47 /* Since the PCI interface in the hardware is configurable, 48 * we need to poke into all the bars to find the set we're 49 * expecting. 50 */ 51 for (i = 0, j = 0; i < PDS_CORE_BARS_MAX; i++) { 52 if (!(pci_resource_flags(pdev, i) & IORESOURCE_MEM)) 53 continue; 54 55 bars[j].len = pci_resource_len(pdev, i); 56 bars[j].bus_addr = pci_resource_start(pdev, i); 57 bars[j].res_index = i; 58 59 /* only map the whole bar 0 */ 60 if (j > 0) { 61 bars[j].vaddr = NULL; 62 } else { 63 bars[j].vaddr = pci_iomap(pdev, i, bars[j].len); 64 if (!bars[j].vaddr) { 65 dev_err(dev, "Cannot map BAR %d, aborting\n", i); 66 return -ENODEV; 67 } 68 } 69 70 j++; 71 } 72 num_bars = j; 73 74 /* BAR0: dev_cmd and interrupts */ 75 if (num_bars < 1) { 76 dev_err(dev, "No bars found\n"); 77 err = -EFAULT; 78 goto err_out; 79 } 80 81 if (bar->len < PDS_CORE_BAR0_SIZE) { 82 dev_err(dev, "Resource bar size %lu too small\n", bar->len); 83 err = -EFAULT; 84 goto err_out; 85 } 86 87 pdsc->info_regs = bar->vaddr + PDS_CORE_BAR0_DEV_INFO_REGS_OFFSET; 88 pdsc->cmd_regs = bar->vaddr + PDS_CORE_BAR0_DEV_CMD_REGS_OFFSET; 89 pdsc->intr_status = bar->vaddr + PDS_CORE_BAR0_INTR_STATUS_OFFSET; 90 pdsc->intr_ctrl = bar->vaddr + PDS_CORE_BAR0_INTR_CTRL_OFFSET; 91 92 sig = ioread32(&pdsc->info_regs->signature); 93 if (sig != PDS_CORE_DEV_INFO_SIGNATURE) { 94 dev_err(dev, "Incompatible firmware signature %x", sig); 95 err = -EFAULT; 96 goto err_out; 97 } 98 99 /* BAR1: doorbells */ 100 bar++; 101 if (num_bars < 2) { 102 dev_err(dev, "Doorbell bar missing\n"); 103 err = -EFAULT; 104 goto err_out; 105 } 106 107 pdsc->db_pages = bar->vaddr; 108 pdsc->phy_db_pages = bar->bus_addr; 109 110 return 0; 111 112 err_out: 113 pdsc_unmap_bars(pdsc); 114 return err; 115 } 116 117 static int pdsc_init_vf(struct pdsc *vf) 118 { 119 return -1; 120 } 121 122 static int pdsc_init_pf(struct pdsc *pdsc) 123 { 124 struct devlink *dl; 125 int err; 126 127 pcie_print_link_status(pdsc->pdev); 128 129 err = pci_request_regions(pdsc->pdev, PDS_CORE_DRV_NAME); 130 if (err) { 131 dev_err(pdsc->dev, "Cannot request PCI regions: %pe\n", 132 ERR_PTR(err)); 133 return err; 134 } 135 136 err = pdsc_map_bars(pdsc); 137 if (err) 138 goto err_out_release_regions; 139 140 dl = priv_to_devlink(pdsc); 141 devl_lock(dl); 142 devl_register(dl); 143 devl_unlock(dl); 144 145 return 0; 146 147 err_out_release_regions: 148 pci_release_regions(pdsc->pdev); 149 150 return err; 151 } 152 153 static const struct devlink_ops pdsc_dl_ops = { 154 }; 155 156 static const struct devlink_ops pdsc_dl_vf_ops = { 157 }; 158 159 static DEFINE_IDA(pdsc_ida); 160 161 static int pdsc_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 162 { 163 struct device *dev = &pdev->dev; 164 const struct devlink_ops *ops; 165 struct devlink *dl; 166 struct pdsc *pdsc; 167 bool is_pf; 168 int err; 169 170 is_pf = !pdev->is_virtfn; 171 ops = is_pf ? &pdsc_dl_ops : &pdsc_dl_vf_ops; 172 dl = devlink_alloc(ops, sizeof(struct pdsc), dev); 173 if (!dl) 174 return -ENOMEM; 175 pdsc = devlink_priv(dl); 176 177 pdsc->pdev = pdev; 178 pdsc->dev = &pdev->dev; 179 set_bit(PDSC_S_INITING_DRIVER, &pdsc->state); 180 pci_set_drvdata(pdev, pdsc); 181 pdsc_debugfs_add_dev(pdsc); 182 183 err = ida_alloc(&pdsc_ida, GFP_KERNEL); 184 if (err < 0) { 185 dev_err(pdsc->dev, "%s: id alloc failed: %pe\n", 186 __func__, ERR_PTR(err)); 187 goto err_out_free_devlink; 188 } 189 pdsc->uid = err; 190 191 /* Query system for DMA addressing limitation for the device. */ 192 err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(PDS_CORE_ADDR_LEN)); 193 if (err) { 194 dev_err(dev, "Unable to obtain 64-bit DMA for consistent allocations, aborting: %pe\n", 195 ERR_PTR(err)); 196 goto err_out_free_ida; 197 } 198 199 err = pci_enable_device(pdev); 200 if (err) { 201 dev_err(dev, "Cannot enable PCI device: %pe\n", ERR_PTR(err)); 202 goto err_out_free_ida; 203 } 204 pci_set_master(pdev); 205 206 if (is_pf) 207 err = pdsc_init_pf(pdsc); 208 else 209 err = pdsc_init_vf(pdsc); 210 if (err) { 211 dev_err(dev, "Cannot init device: %pe\n", ERR_PTR(err)); 212 goto err_out_clear_master; 213 } 214 215 clear_bit(PDSC_S_INITING_DRIVER, &pdsc->state); 216 return 0; 217 218 err_out_clear_master: 219 pci_clear_master(pdev); 220 pci_disable_device(pdev); 221 err_out_free_ida: 222 ida_free(&pdsc_ida, pdsc->uid); 223 err_out_free_devlink: 224 pdsc_debugfs_del_dev(pdsc); 225 devlink_free(dl); 226 227 return err; 228 } 229 230 static void pdsc_remove(struct pci_dev *pdev) 231 { 232 struct pdsc *pdsc = pci_get_drvdata(pdev); 233 struct devlink *dl; 234 235 /* Unhook the registrations first to be sure there 236 * are no requests while we're stopping. 237 */ 238 dl = priv_to_devlink(pdsc); 239 devl_lock(dl); 240 devl_unregister(dl); 241 devl_unlock(dl); 242 243 pdsc_unmap_bars(pdsc); 244 pci_release_regions(pdev); 245 246 pci_clear_master(pdev); 247 pci_disable_device(pdev); 248 249 ida_free(&pdsc_ida, pdsc->uid); 250 pdsc_debugfs_del_dev(pdsc); 251 devlink_free(dl); 252 } 253 254 static struct pci_driver pdsc_driver = { 255 .name = PDS_CORE_DRV_NAME, 256 .id_table = pdsc_id_table, 257 .probe = pdsc_probe, 258 .remove = pdsc_remove, 259 }; 260 261 static int __init pdsc_init_module(void) 262 { 263 if (strcmp(KBUILD_MODNAME, PDS_CORE_DRV_NAME)) 264 return -EINVAL; 265 266 pdsc_debugfs_create(); 267 return pci_register_driver(&pdsc_driver); 268 } 269 270 static void __exit pdsc_cleanup_module(void) 271 { 272 pci_unregister_driver(&pdsc_driver); 273 pdsc_debugfs_destroy(); 274 } 275 276 module_init(pdsc_init_module); 277 module_exit(pdsc_cleanup_module); 278