1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation. 3 * Copyright 2013-2014 6WIND S.A. 4 */ 5 6 #include <string.h> 7 #include <inttypes.h> 8 #include <stdint.h> 9 #include <stdlib.h> 10 #include <stdio.h> 11 #include <sys/queue.h> 12 #include <sys/mman.h> 13 14 #include <rte_errno.h> 15 #include <rte_interrupts.h> 16 #include <rte_log.h> 17 #include <rte_bus.h> 18 #include <rte_pci.h> 19 #include <rte_bus_pci.h> 20 #include <rte_per_lcore.h> 21 #include <rte_memory.h> 22 #include <rte_eal.h> 23 #include <rte_string_fns.h> 24 #include <rte_common.h> 25 #include <rte_devargs.h> 26 27 #include "private.h" 28 29 30 #define SYSFS_PCI_DEVICES "/sys/bus/pci/devices" 31 32 const char *rte_pci_get_sysfs_path(void) 33 { 34 const char *path = NULL; 35 36 path = getenv("SYSFS_PCI_DEVICES"); 37 if (path == NULL) 38 return SYSFS_PCI_DEVICES; 39 40 return path; 41 } 42 43 static struct rte_devargs *pci_devargs_lookup(struct rte_pci_device *dev) 44 { 45 struct rte_devargs *devargs; 46 struct rte_pci_addr addr; 47 48 RTE_EAL_DEVARGS_FOREACH("pci", devargs) { 49 devargs->bus->parse(devargs->name, &addr); 50 if (!rte_pci_addr_cmp(&dev->addr, &addr)) 51 return devargs; 52 } 53 return NULL; 54 } 55 56 void 57 pci_name_set(struct rte_pci_device *dev) 58 { 59 struct rte_devargs *devargs; 60 61 /* Each device has its internal, canonical name set. */ 62 rte_pci_device_name(&dev->addr, 63 dev->name, sizeof(dev->name)); 64 devargs = pci_devargs_lookup(dev); 65 dev->device.devargs = devargs; 66 /* In blacklist mode, if the device is not blacklisted, no 67 * rte_devargs exists for it. 68 */ 69 if (devargs != NULL) 70 /* If an rte_devargs exists, the generic rte_device uses the 71 * given name as its name. 72 */ 73 dev->device.name = dev->device.devargs->name; 74 else 75 /* Otherwise, it uses the internal, canonical form. */ 76 dev->device.name = dev->name; 77 } 78 79 /* 80 * Match the PCI Driver and Device using the ID Table 81 */ 82 int 83 rte_pci_match(const struct rte_pci_driver *pci_drv, 84 const struct rte_pci_device *pci_dev) 85 { 86 const struct rte_pci_id *id_table; 87 88 for (id_table = pci_drv->id_table; id_table->vendor_id != 0; 89 id_table++) { 90 /* check if device's identifiers match the driver's ones */ 91 if (id_table->vendor_id != pci_dev->id.vendor_id && 92 id_table->vendor_id != PCI_ANY_ID) 93 continue; 94 if (id_table->device_id != pci_dev->id.device_id && 95 id_table->device_id != PCI_ANY_ID) 96 continue; 97 if (id_table->subsystem_vendor_id != 98 pci_dev->id.subsystem_vendor_id && 99 id_table->subsystem_vendor_id != PCI_ANY_ID) 100 continue; 101 if (id_table->subsystem_device_id != 102 pci_dev->id.subsystem_device_id && 103 id_table->subsystem_device_id != PCI_ANY_ID) 104 continue; 105 if (id_table->class_id != pci_dev->id.class_id && 106 id_table->class_id != RTE_CLASS_ANY_ID) 107 continue; 108 109 return 1; 110 } 111 112 return 0; 113 } 114 115 /* 116 * If vendor/device ID match, call the probe() function of the 117 * driver. 118 */ 119 static int 120 rte_pci_probe_one_driver(struct rte_pci_driver *dr, 121 struct rte_pci_device *dev) 122 { 123 int ret; 124 struct rte_pci_addr *loc; 125 126 if ((dr == NULL) || (dev == NULL)) 127 return -EINVAL; 128 129 loc = &dev->addr; 130 131 /* The device is not blacklisted; Check if driver supports it */ 132 if (!rte_pci_match(dr, dev)) 133 /* Match of device and driver failed */ 134 return 1; 135 136 RTE_LOG(INFO, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n", 137 loc->domain, loc->bus, loc->devid, loc->function, 138 dev->device.numa_node); 139 140 /* no initialization when blacklisted, return without error */ 141 if (dev->device.devargs != NULL && 142 dev->device.devargs->policy == 143 RTE_DEV_BLACKLISTED) { 144 RTE_LOG(INFO, EAL, " Device is blacklisted, not" 145 " initializing\n"); 146 return 1; 147 } 148 149 if (dev->device.numa_node < 0) { 150 RTE_LOG(WARNING, EAL, " Invalid NUMA socket, default to 0\n"); 151 dev->device.numa_node = 0; 152 } 153 154 RTE_LOG(INFO, EAL, " probe driver: %x:%x %s\n", dev->id.vendor_id, 155 dev->id.device_id, dr->driver.name); 156 157 /* 158 * reference driver structure 159 * This needs to be before rte_pci_map_device(), as it enables to use 160 * driver flags for adjusting configuration. 161 */ 162 dev->driver = dr; 163 dev->device.driver = &dr->driver; 164 165 if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) { 166 /* map resources for devices that use igb_uio */ 167 ret = rte_pci_map_device(dev); 168 if (ret != 0) { 169 dev->driver = NULL; 170 dev->device.driver = NULL; 171 return ret; 172 } 173 } 174 175 /* call the driver probe() function */ 176 ret = dr->probe(dr, dev); 177 if (ret) { 178 dev->driver = NULL; 179 dev->device.driver = NULL; 180 if ((dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) && 181 /* Don't unmap if device is unsupported and 182 * driver needs mapped resources. 183 */ 184 !(ret > 0 && 185 (dr->drv_flags & RTE_PCI_DRV_KEEP_MAPPED_RES))) 186 rte_pci_unmap_device(dev); 187 } 188 189 return ret; 190 } 191 192 /* 193 * If vendor/device ID match, call the remove() function of the 194 * driver. 195 */ 196 static int 197 rte_pci_detach_dev(struct rte_pci_device *dev) 198 { 199 struct rte_pci_addr *loc; 200 struct rte_pci_driver *dr; 201 int ret = 0; 202 203 if (dev == NULL) 204 return -EINVAL; 205 206 dr = dev->driver; 207 loc = &dev->addr; 208 209 RTE_LOG(DEBUG, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n", 210 loc->domain, loc->bus, loc->devid, 211 loc->function, dev->device.numa_node); 212 213 RTE_LOG(DEBUG, EAL, " remove driver: %x:%x %s\n", dev->id.vendor_id, 214 dev->id.device_id, dr->driver.name); 215 216 if (dr->remove) { 217 ret = dr->remove(dev); 218 if (ret < 0) 219 return ret; 220 } 221 222 /* clear driver structure */ 223 dev->driver = NULL; 224 225 if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) 226 /* unmap resources for devices that use igb_uio */ 227 rte_pci_unmap_device(dev); 228 229 return 0; 230 } 231 232 /* 233 * If vendor/device ID match, call the probe() function of all 234 * registered driver for the given device. Return -1 if initialization 235 * failed, return 1 if no driver is found for this device. 236 */ 237 static int 238 pci_probe_all_drivers(struct rte_pci_device *dev) 239 { 240 struct rte_pci_driver *dr = NULL; 241 int rc = 0; 242 243 if (dev == NULL) 244 return -1; 245 246 /* Check if a driver is already loaded */ 247 if (dev->driver != NULL) 248 return 0; 249 250 FOREACH_DRIVER_ON_PCIBUS(dr) { 251 rc = rte_pci_probe_one_driver(dr, dev); 252 if (rc < 0) 253 /* negative value is an error */ 254 return -1; 255 if (rc > 0) 256 /* positive value means driver doesn't support it */ 257 continue; 258 return 0; 259 } 260 return 1; 261 } 262 263 /* 264 * Scan the content of the PCI bus, and call the probe() function for 265 * all registered drivers that have a matching entry in its id_table 266 * for discovered devices. 267 */ 268 int 269 rte_pci_probe(void) 270 { 271 struct rte_pci_device *dev = NULL; 272 size_t probed = 0, failed = 0; 273 struct rte_devargs *devargs; 274 int probe_all = 0; 275 int ret = 0; 276 277 if (rte_pci_bus.bus.conf.scan_mode != RTE_BUS_SCAN_WHITELIST) 278 probe_all = 1; 279 280 FOREACH_DEVICE_ON_PCIBUS(dev) { 281 probed++; 282 283 devargs = dev->device.devargs; 284 /* probe all or only whitelisted devices */ 285 if (probe_all) 286 ret = pci_probe_all_drivers(dev); 287 else if (devargs != NULL && 288 devargs->policy == RTE_DEV_WHITELISTED) 289 ret = pci_probe_all_drivers(dev); 290 if (ret < 0) { 291 RTE_LOG(ERR, EAL, "Requested device " PCI_PRI_FMT 292 " cannot be used\n", dev->addr.domain, dev->addr.bus, 293 dev->addr.devid, dev->addr.function); 294 rte_errno = errno; 295 failed++; 296 ret = 0; 297 } 298 } 299 300 return (probed && probed == failed) ? -1 : 0; 301 } 302 303 /* dump one device */ 304 static int 305 pci_dump_one_device(FILE *f, struct rte_pci_device *dev) 306 { 307 int i; 308 309 fprintf(f, PCI_PRI_FMT, dev->addr.domain, dev->addr.bus, 310 dev->addr.devid, dev->addr.function); 311 fprintf(f, " - vendor:%x device:%x\n", dev->id.vendor_id, 312 dev->id.device_id); 313 314 for (i = 0; i != sizeof(dev->mem_resource) / 315 sizeof(dev->mem_resource[0]); i++) { 316 fprintf(f, " %16.16"PRIx64" %16.16"PRIx64"\n", 317 dev->mem_resource[i].phys_addr, 318 dev->mem_resource[i].len); 319 } 320 return 0; 321 } 322 323 /* dump devices on the bus */ 324 void 325 rte_pci_dump(FILE *f) 326 { 327 struct rte_pci_device *dev = NULL; 328 329 FOREACH_DEVICE_ON_PCIBUS(dev) { 330 pci_dump_one_device(f, dev); 331 } 332 } 333 334 static int 335 pci_parse(const char *name, void *addr) 336 { 337 struct rte_pci_addr *out = addr; 338 struct rte_pci_addr pci_addr; 339 bool parse; 340 341 parse = (rte_pci_addr_parse(name, &pci_addr) == 0); 342 if (parse && addr != NULL) 343 *out = pci_addr; 344 return parse == false; 345 } 346 347 /* register a driver */ 348 void 349 rte_pci_register(struct rte_pci_driver *driver) 350 { 351 TAILQ_INSERT_TAIL(&rte_pci_bus.driver_list, driver, next); 352 driver->bus = &rte_pci_bus; 353 } 354 355 /* unregister a driver */ 356 void 357 rte_pci_unregister(struct rte_pci_driver *driver) 358 { 359 TAILQ_REMOVE(&rte_pci_bus.driver_list, driver, next); 360 driver->bus = NULL; 361 } 362 363 /* Add a device to PCI bus */ 364 void 365 rte_pci_add_device(struct rte_pci_device *pci_dev) 366 { 367 TAILQ_INSERT_TAIL(&rte_pci_bus.device_list, pci_dev, next); 368 } 369 370 /* Insert a device into a predefined position in PCI bus */ 371 void 372 rte_pci_insert_device(struct rte_pci_device *exist_pci_dev, 373 struct rte_pci_device *new_pci_dev) 374 { 375 TAILQ_INSERT_BEFORE(exist_pci_dev, new_pci_dev, next); 376 } 377 378 /* Remove a device from PCI bus */ 379 static void 380 rte_pci_remove_device(struct rte_pci_device *pci_dev) 381 { 382 TAILQ_REMOVE(&rte_pci_bus.device_list, pci_dev, next); 383 } 384 385 static struct rte_device * 386 pci_find_device(const struct rte_device *start, rte_dev_cmp_t cmp, 387 const void *data) 388 { 389 const struct rte_pci_device *pstart; 390 struct rte_pci_device *pdev; 391 392 if (start != NULL) { 393 pstart = RTE_DEV_TO_PCI_CONST(start); 394 pdev = TAILQ_NEXT(pstart, next); 395 } else { 396 pdev = TAILQ_FIRST(&rte_pci_bus.device_list); 397 } 398 while (pdev != NULL) { 399 if (cmp(&pdev->device, data) == 0) 400 return &pdev->device; 401 pdev = TAILQ_NEXT(pdev, next); 402 } 403 return NULL; 404 } 405 406 static int 407 pci_plug(struct rte_device *dev) 408 { 409 return pci_probe_all_drivers(RTE_DEV_TO_PCI(dev)); 410 } 411 412 static int 413 pci_unplug(struct rte_device *dev) 414 { 415 struct rte_pci_device *pdev; 416 int ret; 417 418 pdev = RTE_DEV_TO_PCI(dev); 419 ret = rte_pci_detach_dev(pdev); 420 if (ret == 0) { 421 rte_pci_remove_device(pdev); 422 free(pdev); 423 } 424 return ret; 425 } 426 427 struct rte_pci_bus rte_pci_bus = { 428 .bus = { 429 .scan = rte_pci_scan, 430 .probe = rte_pci_probe, 431 .find_device = pci_find_device, 432 .plug = pci_plug, 433 .unplug = pci_unplug, 434 .parse = pci_parse, 435 .get_iommu_class = rte_pci_get_iommu_class, 436 .dev_iterate = rte_pci_dev_iterate, 437 }, 438 .device_list = TAILQ_HEAD_INITIALIZER(rte_pci_bus.device_list), 439 .driver_list = TAILQ_HEAD_INITIALIZER(rte_pci_bus.driver_list), 440 }; 441 442 RTE_REGISTER_BUS(pci, rte_pci_bus.bus); 443