bus/pci: make remove function static
[dpdk.git] / drivers / bus / pci / pci_common.c
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 static void rte_pci_remove_device(struct rte_pci_device *pci_device);
31
32 extern struct rte_pci_bus rte_pci_bus;
33
34 #define SYSFS_PCI_DEVICES "/sys/bus/pci/devices"
35
36 const char *rte_pci_get_sysfs_path(void)
37 {
38         const char *path = NULL;
39
40         path = getenv("SYSFS_PCI_DEVICES");
41         if (path == NULL)
42                 return SYSFS_PCI_DEVICES;
43
44         return path;
45 }
46
47 static struct rte_devargs *pci_devargs_lookup(struct rte_pci_device *dev)
48 {
49         struct rte_devargs *devargs;
50         struct rte_pci_addr addr;
51
52         RTE_EAL_DEVARGS_FOREACH("pci", devargs) {
53                 devargs->bus->parse(devargs->name, &addr);
54                 if (!rte_pci_addr_cmp(&dev->addr, &addr))
55                         return devargs;
56         }
57         return NULL;
58 }
59
60 void
61 pci_name_set(struct rte_pci_device *dev)
62 {
63         struct rte_devargs *devargs;
64
65         /* Each device has its internal, canonical name set. */
66         rte_pci_device_name(&dev->addr,
67                         dev->name, sizeof(dev->name));
68         devargs = pci_devargs_lookup(dev);
69         dev->device.devargs = devargs;
70         /* In blacklist mode, if the device is not blacklisted, no
71          * rte_devargs exists for it.
72          */
73         if (devargs != NULL)
74                 /* If an rte_devargs exists, the generic rte_device uses the
75                  * given name as its namea
76                  */
77                 dev->device.name = dev->device.devargs->name;
78         else
79                 /* Otherwise, it uses the internal, canonical form. */
80                 dev->device.name = dev->name;
81 }
82
83 /*
84  * Match the PCI Driver and Device using the ID Table
85  */
86 int
87 rte_pci_match(const struct rte_pci_driver *pci_drv,
88               const struct rte_pci_device *pci_dev)
89 {
90         const struct rte_pci_id *id_table;
91
92         for (id_table = pci_drv->id_table; id_table->vendor_id != 0;
93              id_table++) {
94                 /* check if device's identifiers match the driver's ones */
95                 if (id_table->vendor_id != pci_dev->id.vendor_id &&
96                                 id_table->vendor_id != PCI_ANY_ID)
97                         continue;
98                 if (id_table->device_id != pci_dev->id.device_id &&
99                                 id_table->device_id != PCI_ANY_ID)
100                         continue;
101                 if (id_table->subsystem_vendor_id !=
102                     pci_dev->id.subsystem_vendor_id &&
103                     id_table->subsystem_vendor_id != PCI_ANY_ID)
104                         continue;
105                 if (id_table->subsystem_device_id !=
106                     pci_dev->id.subsystem_device_id &&
107                     id_table->subsystem_device_id != PCI_ANY_ID)
108                         continue;
109                 if (id_table->class_id != pci_dev->id.class_id &&
110                                 id_table->class_id != RTE_CLASS_ANY_ID)
111                         continue;
112
113                 return 1;
114         }
115
116         return 0;
117 }
118
119 /*
120  * If vendor/device ID match, call the probe() function of the
121  * driver.
122  */
123 static int
124 rte_pci_probe_one_driver(struct rte_pci_driver *dr,
125                          struct rte_pci_device *dev)
126 {
127         int ret;
128         struct rte_pci_addr *loc;
129
130         if ((dr == NULL) || (dev == NULL))
131                 return -EINVAL;
132
133         loc = &dev->addr;
134
135         /* The device is not blacklisted; Check if driver supports it */
136         if (!rte_pci_match(dr, dev))
137                 /* Match of device and driver failed */
138                 return 1;
139
140         RTE_LOG(INFO, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n",
141                         loc->domain, loc->bus, loc->devid, loc->function,
142                         dev->device.numa_node);
143
144         /* no initialization when blacklisted, return without error */
145         if (dev->device.devargs != NULL &&
146                 dev->device.devargs->policy ==
147                         RTE_DEV_BLACKLISTED) {
148                 RTE_LOG(INFO, EAL, "  Device is blacklisted, not"
149                         " initializing\n");
150                 return 1;
151         }
152
153         if (dev->device.numa_node < 0) {
154                 RTE_LOG(WARNING, EAL, "  Invalid NUMA socket, default to 0\n");
155                 dev->device.numa_node = 0;
156         }
157
158         RTE_LOG(INFO, EAL, "  probe driver: %x:%x %s\n", dev->id.vendor_id,
159                 dev->id.device_id, dr->driver.name);
160
161         if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) {
162                 /* map resources for devices that use igb_uio */
163                 ret = rte_pci_map_device(dev);
164                 if (ret != 0)
165                         return ret;
166         }
167
168         /* reference driver structure */
169         dev->driver = dr;
170         dev->device.driver = &dr->driver;
171
172         /* call the driver probe() function */
173         ret = dr->probe(dr, dev);
174         if (ret) {
175                 dev->driver = NULL;
176                 dev->device.driver = NULL;
177                 if ((dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) &&
178                         /* Don't unmap if device is unsupported and
179                          * driver needs mapped resources.
180                          */
181                         !(ret > 0 &&
182                                 (dr->drv_flags & RTE_PCI_DRV_KEEP_MAPPED_RES)))
183                         rte_pci_unmap_device(dev);
184         }
185
186         return ret;
187 }
188
189 /*
190  * If vendor/device ID match, call the remove() function of the
191  * driver.
192  */
193 static int
194 rte_pci_detach_dev(struct rte_pci_device *dev)
195 {
196         struct rte_pci_addr *loc;
197         struct rte_pci_driver *dr;
198         int ret = 0;
199
200         if (dev == NULL)
201                 return -EINVAL;
202
203         dr = dev->driver;
204         loc = &dev->addr;
205
206         RTE_LOG(DEBUG, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n",
207                         loc->domain, loc->bus, loc->devid,
208                         loc->function, dev->device.numa_node);
209
210         RTE_LOG(DEBUG, EAL, "  remove driver: %x:%x %s\n", dev->id.vendor_id,
211                         dev->id.device_id, dr->driver.name);
212
213         if (dr->remove) {
214                 ret = dr->remove(dev);
215                 if (ret < 0)
216                         return ret;
217         }
218
219         /* clear driver structure */
220         dev->driver = NULL;
221
222         if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING)
223                 /* unmap resources for devices that use igb_uio */
224                 rte_pci_unmap_device(dev);
225
226         return 0;
227 }
228
229 /*
230  * If vendor/device ID match, call the probe() function of all
231  * registered driver for the given device. Return -1 if initialization
232  * failed, return 1 if no driver is found for this device.
233  */
234 static int
235 pci_probe_all_drivers(struct rte_pci_device *dev)
236 {
237         struct rte_pci_driver *dr = NULL;
238         int rc = 0;
239
240         if (dev == NULL)
241                 return -1;
242
243         /* Check if a driver is already loaded */
244         if (dev->driver != NULL)
245                 return 0;
246
247         FOREACH_DRIVER_ON_PCIBUS(dr) {
248                 rc = rte_pci_probe_one_driver(dr, dev);
249                 if (rc < 0)
250                         /* negative value is an error */
251                         return -1;
252                 if (rc > 0)
253                         /* positive value means driver doesn't support it */
254                         continue;
255                 return 0;
256         }
257         return 1;
258 }
259
260 /*
261  * Find the pci device specified by pci address, then invoke probe function of
262  * the driver of the device.
263  */
264 int
265 rte_pci_probe_one(const struct rte_pci_addr *addr)
266 {
267         struct rte_pci_device *dev = NULL;
268
269         int ret = 0;
270
271         if (addr == NULL)
272                 return -1;
273
274         /* update current pci device in global list, kernel bindings might have
275          * changed since last time we looked at it.
276          */
277         if (pci_update_device(addr) < 0)
278                 goto err_return;
279
280         FOREACH_DEVICE_ON_PCIBUS(dev) {
281                 if (rte_pci_addr_cmp(&dev->addr, addr))
282                         continue;
283
284                 ret = pci_probe_all_drivers(dev);
285                 if (ret)
286                         goto err_return;
287                 return 0;
288         }
289         return -1;
290
291 err_return:
292         RTE_LOG(WARNING, EAL,
293                 "Requested device " PCI_PRI_FMT " cannot be used\n",
294                 addr->domain, addr->bus, addr->devid, addr->function);
295         return -1;
296 }
297
298 /*
299  * Detach device specified by its pci address.
300  */
301 int
302 rte_pci_detach(const struct rte_pci_addr *addr)
303 {
304         struct rte_pci_device *dev = NULL;
305         int ret = 0;
306
307         if (addr == NULL)
308                 return -1;
309
310         FOREACH_DEVICE_ON_PCIBUS(dev) {
311                 if (rte_pci_addr_cmp(&dev->addr, addr))
312                         continue;
313
314                 ret = rte_pci_detach_dev(dev);
315                 if (ret < 0)
316                         /* negative value is an error */
317                         goto err_return;
318                 if (ret > 0)
319                         /* positive value means driver doesn't support it */
320                         continue;
321
322                 rte_pci_remove_device(dev);
323                 free(dev);
324                 return 0;
325         }
326         return -1;
327
328 err_return:
329         RTE_LOG(WARNING, EAL, "Requested device " PCI_PRI_FMT
330                         " cannot be used\n", dev->addr.domain, dev->addr.bus,
331                         dev->addr.devid, dev->addr.function);
332         return -1;
333 }
334
335 /*
336  * Scan the content of the PCI bus, and call the probe() function for
337  * all registered drivers that have a matching entry in its id_table
338  * for discovered devices.
339  */
340 int
341 rte_pci_probe(void)
342 {
343         struct rte_pci_device *dev = NULL;
344         size_t probed = 0, failed = 0;
345         struct rte_devargs *devargs;
346         int probe_all = 0;
347         int ret = 0;
348
349         if (rte_pci_bus.bus.conf.scan_mode != RTE_BUS_SCAN_WHITELIST)
350                 probe_all = 1;
351
352         FOREACH_DEVICE_ON_PCIBUS(dev) {
353                 probed++;
354
355                 devargs = dev->device.devargs;
356                 /* probe all or only whitelisted devices */
357                 if (probe_all)
358                         ret = pci_probe_all_drivers(dev);
359                 else if (devargs != NULL &&
360                         devargs->policy == RTE_DEV_WHITELISTED)
361                         ret = pci_probe_all_drivers(dev);
362                 if (ret < 0) {
363                         RTE_LOG(ERR, EAL, "Requested device " PCI_PRI_FMT
364                                  " cannot be used\n", dev->addr.domain, dev->addr.bus,
365                                  dev->addr.devid, dev->addr.function);
366                         rte_errno = errno;
367                         failed++;
368                         ret = 0;
369                 }
370         }
371
372         return (probed && probed == failed) ? -1 : 0;
373 }
374
375 /* dump one device */
376 static int
377 pci_dump_one_device(FILE *f, struct rte_pci_device *dev)
378 {
379         int i;
380
381         fprintf(f, PCI_PRI_FMT, dev->addr.domain, dev->addr.bus,
382                dev->addr.devid, dev->addr.function);
383         fprintf(f, " - vendor:%x device:%x\n", dev->id.vendor_id,
384                dev->id.device_id);
385
386         for (i = 0; i != sizeof(dev->mem_resource) /
387                 sizeof(dev->mem_resource[0]); i++) {
388                 fprintf(f, "   %16.16"PRIx64" %16.16"PRIx64"\n",
389                         dev->mem_resource[i].phys_addr,
390                         dev->mem_resource[i].len);
391         }
392         return 0;
393 }
394
395 /* dump devices on the bus */
396 void
397 rte_pci_dump(FILE *f)
398 {
399         struct rte_pci_device *dev = NULL;
400
401         FOREACH_DEVICE_ON_PCIBUS(dev) {
402                 pci_dump_one_device(f, dev);
403         }
404 }
405
406 static int
407 pci_parse(const char *name, void *addr)
408 {
409         struct rte_pci_addr *out = addr;
410         struct rte_pci_addr pci_addr;
411         bool parse;
412
413         parse = (rte_pci_addr_parse(name, &pci_addr) == 0);
414         if (parse && addr != NULL)
415                 *out = pci_addr;
416         return parse == false;
417 }
418
419 /* register a driver */
420 void
421 rte_pci_register(struct rte_pci_driver *driver)
422 {
423         TAILQ_INSERT_TAIL(&rte_pci_bus.driver_list, driver, next);
424         driver->bus = &rte_pci_bus;
425 }
426
427 /* unregister a driver */
428 void
429 rte_pci_unregister(struct rte_pci_driver *driver)
430 {
431         TAILQ_REMOVE(&rte_pci_bus.driver_list, driver, next);
432         driver->bus = NULL;
433 }
434
435 /* Add a device to PCI bus */
436 void
437 rte_pci_add_device(struct rte_pci_device *pci_dev)
438 {
439         TAILQ_INSERT_TAIL(&rte_pci_bus.device_list, pci_dev, next);
440 }
441
442 /* Insert a device into a predefined position in PCI bus */
443 void
444 rte_pci_insert_device(struct rte_pci_device *exist_pci_dev,
445                       struct rte_pci_device *new_pci_dev)
446 {
447         TAILQ_INSERT_BEFORE(exist_pci_dev, new_pci_dev, next);
448 }
449
450 /* Remove a device from PCI bus */
451 static void
452 rte_pci_remove_device(struct rte_pci_device *pci_dev)
453 {
454         TAILQ_REMOVE(&rte_pci_bus.device_list, pci_dev, next);
455 }
456
457 static struct rte_device *
458 pci_find_device(const struct rte_device *start, rte_dev_cmp_t cmp,
459                 const void *data)
460 {
461         const struct rte_pci_device *pstart;
462         struct rte_pci_device *pdev;
463
464         if (start != NULL) {
465                 pstart = RTE_DEV_TO_PCI_CONST(start);
466                 pdev = TAILQ_NEXT(pstart, next);
467         } else {
468                 pdev = TAILQ_FIRST(&rte_pci_bus.device_list);
469         }
470         while (pdev != NULL) {
471                 if (cmp(&pdev->device, data) == 0)
472                         return &pdev->device;
473                 pdev = TAILQ_NEXT(pdev, next);
474         }
475         return NULL;
476 }
477
478 static int
479 pci_plug(struct rte_device *dev)
480 {
481         return pci_probe_all_drivers(RTE_DEV_TO_PCI(dev));
482 }
483
484 static int
485 pci_unplug(struct rte_device *dev)
486 {
487         struct rte_pci_device *pdev;
488         int ret;
489
490         pdev = RTE_DEV_TO_PCI(dev);
491         ret = rte_pci_detach_dev(pdev);
492         if (ret == 0) {
493                 rte_pci_remove_device(pdev);
494                 free(pdev);
495         }
496         return ret;
497 }
498
499 struct rte_pci_bus rte_pci_bus = {
500         .bus = {
501                 .scan = rte_pci_scan,
502                 .probe = rte_pci_probe,
503                 .find_device = pci_find_device,
504                 .plug = pci_plug,
505                 .unplug = pci_unplug,
506                 .parse = pci_parse,
507                 .get_iommu_class = rte_pci_get_iommu_class,
508         },
509         .device_list = TAILQ_HEAD_INITIALIZER(rte_pci_bus.device_list),
510         .driver_list = TAILQ_HEAD_INITIALIZER(rte_pci_bus.driver_list),
511 };
512
513 RTE_REGISTER_BUS(pci, rte_pci_bus.bus);