pci: unmap resources if probe fails
[dpdk.git] / lib / librte_eal / common / eal_common_pci.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 /*   BSD LICENSE
34  *
35  *   Copyright 2013-2014 6WIND S.A.
36  *
37  *   Redistribution and use in source and binary forms, with or without
38  *   modification, are permitted provided that the following conditions
39  *   are met:
40  *
41  *     * Redistributions of source code must retain the above copyright
42  *       notice, this list of conditions and the following disclaimer.
43  *     * Redistributions in binary form must reproduce the above copyright
44  *       notice, this list of conditions and the following disclaimer in
45  *       the documentation and/or other materials provided with the
46  *       distribution.
47  *     * Neither the name of 6WIND S.A. nor the names of its
48  *       contributors may be used to endorse or promote products derived
49  *       from this software without specific prior written permission.
50  *
51  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
52  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
53  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
54  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
55  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
56  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
57  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
58  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
59  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
61  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62  */
63
64 #include <string.h>
65 #include <inttypes.h>
66 #include <stdint.h>
67 #include <stdlib.h>
68 #include <stdio.h>
69 #include <sys/queue.h>
70 #include <sys/mman.h>
71
72 #include <rte_interrupts.h>
73 #include <rte_log.h>
74 #include <rte_pci.h>
75 #include <rte_per_lcore.h>
76 #include <rte_memory.h>
77 #include <rte_memzone.h>
78 #include <rte_eal.h>
79 #include <rte_string_fns.h>
80 #include <rte_common.h>
81 #include <rte_devargs.h>
82
83 #include "eal_private.h"
84
85 struct pci_driver_list pci_driver_list =
86         TAILQ_HEAD_INITIALIZER(pci_driver_list);
87 struct pci_device_list pci_device_list =
88         TAILQ_HEAD_INITIALIZER(pci_device_list);
89
90 #define SYSFS_PCI_DEVICES "/sys/bus/pci/devices"
91
92 const char *pci_get_sysfs_path(void)
93 {
94         const char *path = NULL;
95
96         path = getenv("SYSFS_PCI_DEVICES");
97         if (path == NULL)
98                 return SYSFS_PCI_DEVICES;
99
100         return path;
101 }
102
103 static struct rte_devargs *pci_devargs_lookup(struct rte_pci_device *dev)
104 {
105         struct rte_devargs *devargs;
106
107         TAILQ_FOREACH(devargs, &devargs_list, next) {
108                 if (devargs->type != RTE_DEVTYPE_BLACKLISTED_PCI &&
109                         devargs->type != RTE_DEVTYPE_WHITELISTED_PCI)
110                         continue;
111                 if (!rte_eal_compare_pci_addr(&dev->addr, &devargs->pci.addr))
112                         return devargs;
113         }
114         return NULL;
115 }
116
117 /* map a particular resource from a file */
118 void *
119 pci_map_resource(void *requested_addr, int fd, off_t offset, size_t size,
120                  int additional_flags)
121 {
122         void *mapaddr;
123
124         /* Map the PCI memory resource of device */
125         mapaddr = mmap(requested_addr, size, PROT_READ | PROT_WRITE,
126                         MAP_SHARED | additional_flags, fd, offset);
127         if (mapaddr == MAP_FAILED) {
128                 RTE_LOG(ERR, EAL, "%s(): cannot mmap(%d, %p, 0x%lx, 0x%lx): %s (%p)\n",
129                         __func__, fd, requested_addr,
130                         (unsigned long)size, (unsigned long)offset,
131                         strerror(errno), mapaddr);
132         } else
133                 RTE_LOG(DEBUG, EAL, "  PCI memory mapped at %p\n", mapaddr);
134
135         return mapaddr;
136 }
137
138 /* unmap a particular resource */
139 void
140 pci_unmap_resource(void *requested_addr, size_t size)
141 {
142         if (requested_addr == NULL)
143                 return;
144
145         /* Unmap the PCI memory resource of device */
146         if (munmap(requested_addr, size)) {
147                 RTE_LOG(ERR, EAL, "%s(): cannot munmap(%p, 0x%lx): %s\n",
148                         __func__, requested_addr, (unsigned long)size,
149                         strerror(errno));
150         } else
151                 RTE_LOG(DEBUG, EAL, "  PCI memory unmapped at %p\n",
152                                 requested_addr);
153 }
154
155 /*
156  * If vendor/device ID match, call the probe() function of the
157  * driver.
158  */
159 static int
160 rte_eal_pci_probe_one_driver(struct rte_pci_driver *dr, struct rte_pci_device *dev)
161 {
162         int ret;
163         const struct rte_pci_id *id_table;
164
165         for (id_table = dr->id_table; id_table->vendor_id != 0; id_table++) {
166
167                 /* check if device's identifiers match the driver's ones */
168                 if (id_table->vendor_id != dev->id.vendor_id &&
169                                 id_table->vendor_id != PCI_ANY_ID)
170                         continue;
171                 if (id_table->device_id != dev->id.device_id &&
172                                 id_table->device_id != PCI_ANY_ID)
173                         continue;
174                 if (id_table->subsystem_vendor_id != dev->id.subsystem_vendor_id &&
175                                 id_table->subsystem_vendor_id != PCI_ANY_ID)
176                         continue;
177                 if (id_table->subsystem_device_id != dev->id.subsystem_device_id &&
178                                 id_table->subsystem_device_id != PCI_ANY_ID)
179                         continue;
180                 if (id_table->class_id != dev->id.class_id &&
181                                 id_table->class_id != RTE_CLASS_ANY_ID)
182                         continue;
183
184                 struct rte_pci_addr *loc = &dev->addr;
185
186                 RTE_LOG(INFO, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n",
187                                 loc->domain, loc->bus, loc->devid, loc->function,
188                                 dev->device.numa_node);
189
190                 /* no initialization when blacklisted, return without error */
191                 if (dev->device.devargs != NULL &&
192                         dev->device.devargs->type ==
193                                 RTE_DEVTYPE_BLACKLISTED_PCI) {
194                         RTE_LOG(INFO, EAL, "  Device is blacklisted, not initializing\n");
195                         return 1;
196                 }
197
198                 RTE_LOG(INFO, EAL, "  probe driver: %x:%x %s\n", dev->id.vendor_id,
199                                 dev->id.device_id, dr->driver.name);
200
201                 if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) {
202                         /* map resources for devices that use igb_uio */
203                         ret = rte_eal_pci_map_device(dev);
204                         if (ret != 0)
205                                 return ret;
206                 }
207
208                 /* reference driver structure */
209                 dev->driver = dr;
210
211                 /* call the driver probe() function */
212                 ret = dr->probe(dr, dev);
213                 if (ret) {
214                         dev->driver = NULL;
215                         if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING)
216                                 rte_eal_pci_unmap_device(dev);
217                 }
218
219                 return ret;
220         }
221         /* return positive value if driver doesn't support this device */
222         return 1;
223 }
224
225 /*
226  * If vendor/device ID match, call the remove() function of the
227  * driver.
228  */
229 static int
230 rte_eal_pci_detach_dev(struct rte_pci_driver *dr,
231                 struct rte_pci_device *dev)
232 {
233         const struct rte_pci_id *id_table;
234
235         if ((dr == NULL) || (dev == NULL))
236                 return -EINVAL;
237
238         for (id_table = dr->id_table; id_table->vendor_id != 0; id_table++) {
239
240                 /* check if device's identifiers match the driver's ones */
241                 if (id_table->vendor_id != dev->id.vendor_id &&
242                                 id_table->vendor_id != PCI_ANY_ID)
243                         continue;
244                 if (id_table->device_id != dev->id.device_id &&
245                                 id_table->device_id != PCI_ANY_ID)
246                         continue;
247                 if (id_table->subsystem_vendor_id != dev->id.subsystem_vendor_id &&
248                                 id_table->subsystem_vendor_id != PCI_ANY_ID)
249                         continue;
250                 if (id_table->subsystem_device_id != dev->id.subsystem_device_id &&
251                                 id_table->subsystem_device_id != PCI_ANY_ID)
252                         continue;
253
254                 struct rte_pci_addr *loc = &dev->addr;
255
256                 RTE_LOG(DEBUG, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n",
257                                 loc->domain, loc->bus, loc->devid,
258                                 loc->function, dev->device.numa_node);
259
260                 RTE_LOG(DEBUG, EAL, "  remove driver: %x:%x %s\n", dev->id.vendor_id,
261                                 dev->id.device_id, dr->driver.name);
262
263                 if (dr->remove && (dr->remove(dev) < 0))
264                         return -1;      /* negative value is an error */
265
266                 /* clear driver structure */
267                 dev->driver = NULL;
268
269                 if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING)
270                         /* unmap resources for devices that use igb_uio */
271                         rte_eal_pci_unmap_device(dev);
272
273                 return 0;
274         }
275
276         /* return positive value if driver doesn't support this device */
277         return 1;
278 }
279
280 /*
281  * If vendor/device ID match, call the probe() function of all
282  * registered driver for the given device. Return -1 if initialization
283  * failed, return 1 if no driver is found for this device.
284  */
285 static int
286 pci_probe_all_drivers(struct rte_pci_device *dev)
287 {
288         struct rte_pci_driver *dr = NULL;
289         int rc = 0;
290
291         if (dev == NULL)
292                 return -1;
293
294         /* Check if a driver is already loaded */
295         if (dev->driver != NULL)
296                 return 0;
297
298         TAILQ_FOREACH(dr, &pci_driver_list, next) {
299                 rc = rte_eal_pci_probe_one_driver(dr, dev);
300                 if (rc < 0)
301                         /* negative value is an error */
302                         return -1;
303                 if (rc > 0)
304                         /* positive value means driver doesn't support it */
305                         continue;
306                 return 0;
307         }
308         return 1;
309 }
310
311 /*
312  * If vendor/device ID match, call the remove() function of all
313  * registered driver for the given device. Return -1 if initialization
314  * failed, return 1 if no driver is found for this device.
315  */
316 static int
317 pci_detach_all_drivers(struct rte_pci_device *dev)
318 {
319         struct rte_pci_driver *dr = NULL;
320         int rc = 0;
321
322         if (dev == NULL)
323                 return -1;
324
325         TAILQ_FOREACH(dr, &pci_driver_list, next) {
326                 rc = rte_eal_pci_detach_dev(dr, dev);
327                 if (rc < 0)
328                         /* negative value is an error */
329                         return -1;
330                 if (rc > 0)
331                         /* positive value means driver doesn't support it */
332                         continue;
333                 return 0;
334         }
335         return 1;
336 }
337
338 /*
339  * Find the pci device specified by pci address, then invoke probe function of
340  * the driver of the devive.
341  */
342 int
343 rte_eal_pci_probe_one(const struct rte_pci_addr *addr)
344 {
345         struct rte_pci_device *dev = NULL;
346         int ret = 0;
347
348         if (addr == NULL)
349                 return -1;
350
351         /* update current pci device in global list, kernel bindings might have
352          * changed since last time we looked at it.
353          */
354         if (pci_update_device(addr) < 0)
355                 goto err_return;
356
357         TAILQ_FOREACH(dev, &pci_device_list, next) {
358                 if (rte_eal_compare_pci_addr(&dev->addr, addr))
359                         continue;
360
361                 ret = pci_probe_all_drivers(dev);
362                 if (ret)
363                         goto err_return;
364                 return 0;
365         }
366         return -1;
367
368 err_return:
369         RTE_LOG(WARNING, EAL,
370                 "Requested device " PCI_PRI_FMT " cannot be used\n",
371                 addr->domain, addr->bus, addr->devid, addr->function);
372         return -1;
373 }
374
375 /*
376  * Detach device specified by its pci address.
377  */
378 int
379 rte_eal_pci_detach(const struct rte_pci_addr *addr)
380 {
381         struct rte_pci_device *dev = NULL;
382         int ret = 0;
383
384         if (addr == NULL)
385                 return -1;
386
387         TAILQ_FOREACH(dev, &pci_device_list, next) {
388                 if (rte_eal_compare_pci_addr(&dev->addr, addr))
389                         continue;
390
391                 ret = pci_detach_all_drivers(dev);
392                 if (ret < 0)
393                         goto err_return;
394
395                 TAILQ_REMOVE(&pci_device_list, dev, next);
396                 free(dev);
397                 return 0;
398         }
399         return -1;
400
401 err_return:
402         RTE_LOG(WARNING, EAL, "Requested device " PCI_PRI_FMT
403                         " cannot be used\n", dev->addr.domain, dev->addr.bus,
404                         dev->addr.devid, dev->addr.function);
405         return -1;
406 }
407
408 /*
409  * Scan the content of the PCI bus, and call the probe() function for
410  * all registered drivers that have a matching entry in its id_table
411  * for discovered devices.
412  */
413 int
414 rte_eal_pci_probe(void)
415 {
416         struct rte_pci_device *dev = NULL;
417         struct rte_devargs *devargs;
418         int probe_all = 0;
419         int ret = 0;
420
421         if (rte_eal_devargs_type_count(RTE_DEVTYPE_WHITELISTED_PCI) == 0)
422                 probe_all = 1;
423
424         TAILQ_FOREACH(dev, &pci_device_list, next) {
425
426                 /* set devargs in PCI structure */
427                 devargs = pci_devargs_lookup(dev);
428                 if (devargs != NULL)
429                         dev->device.devargs = devargs;
430
431                 /* probe all or only whitelisted devices */
432                 if (probe_all)
433                         ret = pci_probe_all_drivers(dev);
434                 else if (devargs != NULL &&
435                         devargs->type == RTE_DEVTYPE_WHITELISTED_PCI)
436                         ret = pci_probe_all_drivers(dev);
437                 if (ret < 0)
438                         rte_exit(EXIT_FAILURE, "Requested device " PCI_PRI_FMT
439                                  " cannot be used\n", dev->addr.domain, dev->addr.bus,
440                                  dev->addr.devid, dev->addr.function);
441         }
442
443         return 0;
444 }
445
446 /* dump one device */
447 static int
448 pci_dump_one_device(FILE *f, struct rte_pci_device *dev)
449 {
450         int i;
451
452         fprintf(f, PCI_PRI_FMT, dev->addr.domain, dev->addr.bus,
453                dev->addr.devid, dev->addr.function);
454         fprintf(f, " - vendor:%x device:%x\n", dev->id.vendor_id,
455                dev->id.device_id);
456
457         for (i = 0; i != sizeof(dev->mem_resource) /
458                 sizeof(dev->mem_resource[0]); i++) {
459                 fprintf(f, "   %16.16"PRIx64" %16.16"PRIx64"\n",
460                         dev->mem_resource[i].phys_addr,
461                         dev->mem_resource[i].len);
462         }
463         return 0;
464 }
465
466 /* dump devices on the bus */
467 void
468 rte_eal_pci_dump(FILE *f)
469 {
470         struct rte_pci_device *dev = NULL;
471
472         TAILQ_FOREACH(dev, &pci_device_list, next) {
473                 pci_dump_one_device(f, dev);
474         }
475 }
476
477 /* register a driver */
478 void
479 rte_eal_pci_register(struct rte_pci_driver *driver)
480 {
481         TAILQ_INSERT_TAIL(&pci_driver_list, driver, next);
482         rte_eal_driver_register(&driver->driver);
483 }
484
485 /* unregister a driver */
486 void
487 rte_eal_pci_unregister(struct rte_pci_driver *driver)
488 {
489         rte_eal_driver_unregister(&driver->driver);
490         TAILQ_REMOVE(&pci_driver_list, driver, next);
491 }