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_wdtimer_cb(struct timer_list *t) 24 { 25 struct pdsc *pdsc = from_timer(pdsc, t, wdtimer); 26 27 dev_dbg(pdsc->dev, "%s: jiffies %ld\n", __func__, jiffies); 28 mod_timer(&pdsc->wdtimer, 29 round_jiffies(jiffies + pdsc->wdtimer_period)); 30 31 queue_work(pdsc->wq, &pdsc->health_work); 32 } 33 34 static void pdsc_unmap_bars(struct pdsc *pdsc) 35 { 36 struct pdsc_dev_bar *bars = pdsc->bars; 37 unsigned int i; 38 39 for (i = 0; i < PDS_CORE_BARS_MAX; i++) { 40 if (bars[i].vaddr) 41 pci_iounmap(pdsc->pdev, bars[i].vaddr); 42 } 43 } 44 45 static int pdsc_map_bars(struct pdsc *pdsc) 46 { 47 struct pdsc_dev_bar *bar = pdsc->bars; 48 struct pci_dev *pdev = pdsc->pdev; 49 struct device *dev = pdsc->dev; 50 struct pdsc_dev_bar *bars; 51 unsigned int i, j; 52 int num_bars = 0; 53 int err; 54 u32 sig; 55 56 bars = pdsc->bars; 57 58 /* Since the PCI interface in the hardware is configurable, 59 * we need to poke into all the bars to find the set we're 60 * expecting. 61 */ 62 for (i = 0, j = 0; i < PDS_CORE_BARS_MAX; i++) { 63 if (!(pci_resource_flags(pdev, i) & IORESOURCE_MEM)) 64 continue; 65 66 bars[j].len = pci_resource_len(pdev, i); 67 bars[j].bus_addr = pci_resource_start(pdev, i); 68 bars[j].res_index = i; 69 70 /* only map the whole bar 0 */ 71 if (j > 0) { 72 bars[j].vaddr = NULL; 73 } else { 74 bars[j].vaddr = pci_iomap(pdev, i, bars[j].len); 75 if (!bars[j].vaddr) { 76 dev_err(dev, "Cannot map BAR %d, aborting\n", i); 77 return -ENODEV; 78 } 79 } 80 81 j++; 82 } 83 num_bars = j; 84 85 /* BAR0: dev_cmd and interrupts */ 86 if (num_bars < 1) { 87 dev_err(dev, "No bars found\n"); 88 err = -EFAULT; 89 goto err_out; 90 } 91 92 if (bar->len < PDS_CORE_BAR0_SIZE) { 93 dev_err(dev, "Resource bar size %lu too small\n", bar->len); 94 err = -EFAULT; 95 goto err_out; 96 } 97 98 pdsc->info_regs = bar->vaddr + PDS_CORE_BAR0_DEV_INFO_REGS_OFFSET; 99 pdsc->cmd_regs = bar->vaddr + PDS_CORE_BAR0_DEV_CMD_REGS_OFFSET; 100 pdsc->intr_status = bar->vaddr + PDS_CORE_BAR0_INTR_STATUS_OFFSET; 101 pdsc->intr_ctrl = bar->vaddr + PDS_CORE_BAR0_INTR_CTRL_OFFSET; 102 103 sig = ioread32(&pdsc->info_regs->signature); 104 if (sig != PDS_CORE_DEV_INFO_SIGNATURE) { 105 dev_err(dev, "Incompatible firmware signature %x", sig); 106 err = -EFAULT; 107 goto err_out; 108 } 109 110 /* BAR1: doorbells */ 111 bar++; 112 if (num_bars < 2) { 113 dev_err(dev, "Doorbell bar missing\n"); 114 err = -EFAULT; 115 goto err_out; 116 } 117 118 pdsc->db_pages = bar->vaddr; 119 pdsc->phy_db_pages = bar->bus_addr; 120 121 return 0; 122 123 err_out: 124 pdsc_unmap_bars(pdsc); 125 return err; 126 } 127 128 void __iomem *pdsc_map_dbpage(struct pdsc *pdsc, int page_num) 129 { 130 return pci_iomap_range(pdsc->pdev, 131 pdsc->bars[PDS_CORE_PCI_BAR_DBELL].res_index, 132 (u64)page_num << PAGE_SHIFT, PAGE_SIZE); 133 } 134 135 static int pdsc_init_vf(struct pdsc *vf) 136 { 137 return -1; 138 } 139 140 static const struct devlink_health_reporter_ops pdsc_fw_reporter_ops = { 141 .name = "fw", 142 .diagnose = pdsc_fw_reporter_diagnose, 143 }; 144 145 #define PDSC_WQ_NAME_LEN 24 146 147 static int pdsc_init_pf(struct pdsc *pdsc) 148 { 149 struct devlink_health_reporter *hr; 150 char wq_name[PDSC_WQ_NAME_LEN]; 151 struct devlink *dl; 152 int err; 153 154 pcie_print_link_status(pdsc->pdev); 155 156 err = pci_request_regions(pdsc->pdev, PDS_CORE_DRV_NAME); 157 if (err) { 158 dev_err(pdsc->dev, "Cannot request PCI regions: %pe\n", 159 ERR_PTR(err)); 160 return err; 161 } 162 163 err = pdsc_map_bars(pdsc); 164 if (err) 165 goto err_out_release_regions; 166 167 /* General workqueue and timer, but don't start timer yet */ 168 snprintf(wq_name, sizeof(wq_name), "%s.%d", PDS_CORE_DRV_NAME, pdsc->uid); 169 pdsc->wq = create_singlethread_workqueue(wq_name); 170 INIT_WORK(&pdsc->health_work, pdsc_health_thread); 171 timer_setup(&pdsc->wdtimer, pdsc_wdtimer_cb, 0); 172 pdsc->wdtimer_period = PDSC_WATCHDOG_SECS * HZ; 173 174 mutex_init(&pdsc->devcmd_lock); 175 mutex_init(&pdsc->config_lock); 176 spin_lock_init(&pdsc->adminq_lock); 177 178 mutex_lock(&pdsc->config_lock); 179 set_bit(PDSC_S_FW_DEAD, &pdsc->state); 180 181 err = pdsc_setup(pdsc, PDSC_SETUP_INIT); 182 if (err) 183 goto err_out_unmap_bars; 184 err = pdsc_start(pdsc); 185 if (err) 186 goto err_out_teardown; 187 188 mutex_unlock(&pdsc->config_lock); 189 190 dl = priv_to_devlink(pdsc); 191 devl_lock(dl); 192 193 hr = devl_health_reporter_create(dl, &pdsc_fw_reporter_ops, 0, pdsc); 194 if (IS_ERR(hr)) { 195 dev_warn(pdsc->dev, "Failed to create fw reporter: %pe\n", hr); 196 err = PTR_ERR(hr); 197 devl_unlock(dl); 198 goto err_out_stop; 199 } 200 pdsc->fw_reporter = hr; 201 202 devl_register(dl); 203 devl_unlock(dl); 204 205 /* Lastly, start the health check timer */ 206 mod_timer(&pdsc->wdtimer, round_jiffies(jiffies + pdsc->wdtimer_period)); 207 208 return 0; 209 210 err_out_stop: 211 pdsc_stop(pdsc); 212 err_out_teardown: 213 pdsc_teardown(pdsc, PDSC_TEARDOWN_REMOVING); 214 err_out_unmap_bars: 215 mutex_unlock(&pdsc->config_lock); 216 del_timer_sync(&pdsc->wdtimer); 217 if (pdsc->wq) 218 destroy_workqueue(pdsc->wq); 219 mutex_destroy(&pdsc->config_lock); 220 mutex_destroy(&pdsc->devcmd_lock); 221 pci_free_irq_vectors(pdsc->pdev); 222 pdsc_unmap_bars(pdsc); 223 err_out_release_regions: 224 pci_release_regions(pdsc->pdev); 225 226 return err; 227 } 228 229 static const struct devlink_ops pdsc_dl_ops = { 230 .info_get = pdsc_dl_info_get, 231 }; 232 233 static const struct devlink_ops pdsc_dl_vf_ops = { 234 }; 235 236 static DEFINE_IDA(pdsc_ida); 237 238 static int pdsc_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 239 { 240 struct device *dev = &pdev->dev; 241 const struct devlink_ops *ops; 242 struct devlink *dl; 243 struct pdsc *pdsc; 244 bool is_pf; 245 int err; 246 247 is_pf = !pdev->is_virtfn; 248 ops = is_pf ? &pdsc_dl_ops : &pdsc_dl_vf_ops; 249 dl = devlink_alloc(ops, sizeof(struct pdsc), dev); 250 if (!dl) 251 return -ENOMEM; 252 pdsc = devlink_priv(dl); 253 254 pdsc->pdev = pdev; 255 pdsc->dev = &pdev->dev; 256 set_bit(PDSC_S_INITING_DRIVER, &pdsc->state); 257 pci_set_drvdata(pdev, pdsc); 258 pdsc_debugfs_add_dev(pdsc); 259 260 err = ida_alloc(&pdsc_ida, GFP_KERNEL); 261 if (err < 0) { 262 dev_err(pdsc->dev, "%s: id alloc failed: %pe\n", 263 __func__, ERR_PTR(err)); 264 goto err_out_free_devlink; 265 } 266 pdsc->uid = err; 267 268 /* Query system for DMA addressing limitation for the device. */ 269 err = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(PDS_CORE_ADDR_LEN)); 270 if (err) { 271 dev_err(dev, "Unable to obtain 64-bit DMA for consistent allocations, aborting: %pe\n", 272 ERR_PTR(err)); 273 goto err_out_free_ida; 274 } 275 276 err = pci_enable_device(pdev); 277 if (err) { 278 dev_err(dev, "Cannot enable PCI device: %pe\n", ERR_PTR(err)); 279 goto err_out_free_ida; 280 } 281 pci_set_master(pdev); 282 283 if (is_pf) 284 err = pdsc_init_pf(pdsc); 285 else 286 err = pdsc_init_vf(pdsc); 287 if (err) { 288 dev_err(dev, "Cannot init device: %pe\n", ERR_PTR(err)); 289 goto err_out_clear_master; 290 } 291 292 clear_bit(PDSC_S_INITING_DRIVER, &pdsc->state); 293 return 0; 294 295 err_out_clear_master: 296 pci_clear_master(pdev); 297 pci_disable_device(pdev); 298 err_out_free_ida: 299 ida_free(&pdsc_ida, pdsc->uid); 300 err_out_free_devlink: 301 pdsc_debugfs_del_dev(pdsc); 302 devlink_free(dl); 303 304 return err; 305 } 306 307 static void pdsc_remove(struct pci_dev *pdev) 308 { 309 struct pdsc *pdsc = pci_get_drvdata(pdev); 310 struct devlink *dl; 311 312 /* Unhook the registrations first to be sure there 313 * are no requests while we're stopping. 314 */ 315 dl = priv_to_devlink(pdsc); 316 devl_lock(dl); 317 devl_unregister(dl); 318 if (pdsc->fw_reporter) { 319 devl_health_reporter_destroy(pdsc->fw_reporter); 320 pdsc->fw_reporter = NULL; 321 } 322 devl_unlock(dl); 323 324 if (!pdev->is_virtfn) { 325 del_timer_sync(&pdsc->wdtimer); 326 if (pdsc->wq) 327 destroy_workqueue(pdsc->wq); 328 329 mutex_lock(&pdsc->config_lock); 330 set_bit(PDSC_S_STOPPING_DRIVER, &pdsc->state); 331 332 pdsc_stop(pdsc); 333 pdsc_teardown(pdsc, PDSC_TEARDOWN_REMOVING); 334 mutex_unlock(&pdsc->config_lock); 335 mutex_destroy(&pdsc->config_lock); 336 mutex_destroy(&pdsc->devcmd_lock); 337 338 pci_free_irq_vectors(pdev); 339 pdsc_unmap_bars(pdsc); 340 pci_release_regions(pdev); 341 } 342 343 pci_clear_master(pdev); 344 pci_disable_device(pdev); 345 346 ida_free(&pdsc_ida, pdsc->uid); 347 pdsc_debugfs_del_dev(pdsc); 348 devlink_free(dl); 349 } 350 351 static struct pci_driver pdsc_driver = { 352 .name = PDS_CORE_DRV_NAME, 353 .id_table = pdsc_id_table, 354 .probe = pdsc_probe, 355 .remove = pdsc_remove, 356 }; 357 358 static int __init pdsc_init_module(void) 359 { 360 if (strcmp(KBUILD_MODNAME, PDS_CORE_DRV_NAME)) 361 return -EINVAL; 362 363 pdsc_debugfs_create(); 364 return pci_register_driver(&pdsc_driver); 365 } 366 367 static void __exit pdsc_cleanup_module(void) 368 { 369 pci_unregister_driver(&pdsc_driver); 370 pdsc_debugfs_destroy(); 371 } 372 373 module_init(pdsc_init_module); 374 module_exit(pdsc_cleanup_module); 375