[ceph.git] / ceph / src / dpdk / lib / librte_eal / common / eal_common_pci.c

/*-
 *   BSD LICENSE
 *
 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*   BSD LICENSE
 *
 *   Copyright 2013-2014 6WIND S.A.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of 6WIND S.A. nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <string.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/queue.h>
#include <sys/mman.h>

#include <rte_interrupts.h>
#include <rte_log.h>
#include <rte_pci.h>
#include <rte_per_lcore.h>
#include <rte_memory.h>
#include <rte_memzone.h>
#include <rte_eal.h>
#include <rte_string_fns.h>
#include <rte_common.h>
#include <rte_devargs.h>

#include "eal_private.h"

struct pci_driver_list pci_driver_list =
	TAILQ_HEAD_INITIALIZER(pci_driver_list);
struct pci_device_list pci_device_list =
	TAILQ_HEAD_INITIALIZER(pci_device_list);

#define SYSFS_PCI_DEVICES "/sys/bus/pci/devices"

const char *pci_get_sysfs_path(void)
{
	const char *path = NULL;

	path = getenv("SYSFS_PCI_DEVICES");
	if (path == NULL)
		return SYSFS_PCI_DEVICES;

	return path;
}

static struct rte_devargs *pci_devargs_lookup(struct rte_pci_device *dev)
{
	struct rte_devargs *devargs;

	TAILQ_FOREACH(devargs, &devargs_list, next) {
		if (devargs->type != RTE_DEVTYPE_BLACKLISTED_PCI &&
			devargs->type != RTE_DEVTYPE_WHITELISTED_PCI)
			continue;
		if (!rte_eal_compare_pci_addr(&dev->addr, &devargs->pci.addr))
			return devargs;
	}
	return NULL;
}

/* map a particular resource from a file */
void *
pci_map_resource(void *requested_addr, int fd, off_t offset, size_t size,
		 int additional_flags)
{
	void *mapaddr;

	/* Map the PCI memory resource of device */
	mapaddr = mmap(requested_addr, size, PROT_READ | PROT_WRITE,
			MAP_SHARED | additional_flags, fd, offset);
	if (mapaddr == MAP_FAILED) {
		RTE_LOG(ERR, EAL, "%s(): cannot mmap(%d, %p, 0x%lx, 0x%lx): %s (%p)\n",
			__func__, fd, requested_addr,
			(unsigned long)size, (unsigned long)offset,
			strerror(errno), mapaddr);
	} else
		RTE_LOG(DEBUG, EAL, "  PCI memory mapped at %p\n", mapaddr);

	return mapaddr;
}

/* unmap a particular resource */
void
pci_unmap_resource(void *requested_addr, size_t size)
{
	if (requested_addr == NULL)
		return;

	/* Unmap the PCI memory resource of device */
	if (munmap(requested_addr, size)) {
		RTE_LOG(ERR, EAL, "%s(): cannot munmap(%p, 0x%lx): %s\n",
			__func__, requested_addr, (unsigned long)size,
			strerror(errno));
	} else
		RTE_LOG(DEBUG, EAL, "  PCI memory unmapped at %p\n",
				requested_addr);
}

/*
 * If vendor/device ID match, call the probe() function of the
 * driver.
 */
static int
rte_eal_pci_probe_one_driver(struct rte_pci_driver *dr, struct rte_pci_device *dev)
{
	int ret;
	const struct rte_pci_id *id_table;

	for (id_table = dr->id_table; id_table->vendor_id != 0; id_table++) {

		/* check if device's identifiers match the driver's ones */
		if (id_table->vendor_id != dev->id.vendor_id &&
				id_table->vendor_id != PCI_ANY_ID)
			continue;
		if (id_table->device_id != dev->id.device_id &&
				id_table->device_id != PCI_ANY_ID)
			continue;
		if (id_table->subsystem_vendor_id != dev->id.subsystem_vendor_id &&
				id_table->subsystem_vendor_id != PCI_ANY_ID)
			continue;
		if (id_table->subsystem_device_id != dev->id.subsystem_device_id &&
				id_table->subsystem_device_id != PCI_ANY_ID)
			continue;
		if (id_table->class_id != dev->id.class_id &&
				id_table->class_id != RTE_CLASS_ANY_ID)
			continue;

		struct rte_pci_addr *loc = &dev->addr;

		RTE_LOG(INFO, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n",
				loc->domain, loc->bus, loc->devid, loc->function,
				dev->device.numa_node);

		/* no initialization when blacklisted, return without error */
		if (dev->device.devargs != NULL &&
			dev->device.devargs->type ==
				RTE_DEVTYPE_BLACKLISTED_PCI) {
			RTE_LOG(INFO, EAL, "  Device is blacklisted, not initializing\n");
			return 1;
		}

		RTE_LOG(INFO, EAL, "  probe driver: %x:%x %s\n", dev->id.vendor_id,
				dev->id.device_id, dr->driver.name);

		if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) {
			/* map resources for devices that use igb_uio */
			ret = rte_eal_pci_map_device(dev);
			if (ret != 0)
				return ret;
		} else if (dr->drv_flags & RTE_PCI_DRV_FORCE_UNBIND &&
				rte_eal_process_type() == RTE_PROC_PRIMARY) {
			/* unbind current driver */
			if (pci_unbind_kernel_driver(dev) < 0)
				return -1;
		}

		/* reference driver structure */
		dev->driver = dr;

		/* call the driver probe() function */
		ret = dr->probe(dr, dev);
		if (ret)
			dev->driver = NULL;

		return ret;
	}
	/* return positive value if driver doesn't support this device */
	return 1;
}

/*
 * If vendor/device ID match, call the remove() function of the
 * driver.
 */
static int
rte_eal_pci_detach_dev(struct rte_pci_driver *dr,
		struct rte_pci_device *dev)
{
	const struct rte_pci_id *id_table;

	if ((dr == NULL) || (dev == NULL))
		return -EINVAL;

	for (id_table = dr->id_table; id_table->vendor_id != 0; id_table++) {

		/* check if device's identifiers match the driver's ones */
		if (id_table->vendor_id != dev->id.vendor_id &&
				id_table->vendor_id != PCI_ANY_ID)
			continue;
		if (id_table->device_id != dev->id.device_id &&
				id_table->device_id != PCI_ANY_ID)
			continue;
		if (id_table->subsystem_vendor_id != dev->id.subsystem_vendor_id &&
				id_table->subsystem_vendor_id != PCI_ANY_ID)
			continue;
		if (id_table->subsystem_device_id != dev->id.subsystem_device_id &&
				id_table->subsystem_device_id != PCI_ANY_ID)
			continue;

		struct rte_pci_addr *loc = &dev->addr;

		RTE_LOG(DEBUG, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n",
				loc->domain, loc->bus, loc->devid,
				loc->function, dev->device.numa_node);

		RTE_LOG(DEBUG, EAL, "  remove driver: %x:%x %s\n", dev->id.vendor_id,
				dev->id.device_id, dr->driver.name);

		if (dr->remove && (dr->remove(dev) < 0))
			return -1;	/* negative value is an error */

		/* clear driver structure */
		dev->driver = NULL;

		if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING)
			/* unmap resources for devices that use igb_uio */
			rte_eal_pci_unmap_device(dev);

		return 0;
	}

	/* return positive value if driver doesn't support this device */
	return 1;
}

/*
 * If vendor/device ID match, call the probe() function of all
 * registered driver for the given device. Return -1 if initialization
 * failed, return 1 if no driver is found for this device.
 */
static int
pci_probe_all_drivers(struct rte_pci_device *dev)
{
	struct rte_pci_driver *dr = NULL;
	int rc = 0;

	if (dev == NULL)
		return -1;

	/* Check if a driver is already loaded */
	if (dev->driver != NULL)
		return 0;

	TAILQ_FOREACH(dr, &pci_driver_list, next) {
		rc = rte_eal_pci_probe_one_driver(dr, dev);
		if (rc < 0)
			/* negative value is an error */
			return -1;
		if (rc > 0)
			/* positive value means driver doesn't support it */
			continue;
		return 0;
	}
	return 1;
}

/*
 * If vendor/device ID match, call the remove() function of all
 * registered driver for the given device. Return -1 if initialization
 * failed, return 1 if no driver is found for this device.
 */
static int
pci_detach_all_drivers(struct rte_pci_device *dev)
{
	struct rte_pci_driver *dr = NULL;
	int rc = 0;

	if (dev == NULL)
		return -1;

	TAILQ_FOREACH(dr, &pci_driver_list, next) {
		rc = rte_eal_pci_detach_dev(dr, dev);
		if (rc < 0)
			/* negative value is an error */
			return -1;
		if (rc > 0)
			/* positive value means driver doesn't support it */
			continue;
		return 0;
	}
	return 1;
}

/*
 * Find the pci device specified by pci address, then invoke probe function of
 * the driver of the devive.
 */
int
rte_eal_pci_probe_one(const struct rte_pci_addr *addr)
{
	struct rte_pci_device *dev = NULL;
	int ret = 0;

	if (addr == NULL)
		return -1;

	/* update current pci device in global list, kernel bindings might have
	 * changed since last time we looked at it.
	 */
	if (pci_update_device(addr) < 0)
		goto err_return;

	TAILQ_FOREACH(dev, &pci_device_list, next) {
		if (rte_eal_compare_pci_addr(&dev->addr, addr))
			continue;

		ret = pci_probe_all_drivers(dev);
		if (ret)
			goto err_return;
		return 0;
	}
	return -1;

err_return:
	RTE_LOG(WARNING, EAL,
		"Requested device " PCI_PRI_FMT " cannot be used\n",
		addr->domain, addr->bus, addr->devid, addr->function);
	return -1;
}

/*
 * Detach device specified by its pci address.
 */
int
rte_eal_pci_detach(const struct rte_pci_addr *addr)
{
	struct rte_pci_device *dev = NULL;
	int ret = 0;

	if (addr == NULL)
		return -1;

	TAILQ_FOREACH(dev, &pci_device_list, next) {
		if (rte_eal_compare_pci_addr(&dev->addr, addr))
			continue;

		ret = pci_detach_all_drivers(dev);
		if (ret < 0)
			goto err_return;

		TAILQ_REMOVE(&pci_device_list, dev, next);
		free(dev);
		return 0;
	}
	return -1;

err_return:
	RTE_LOG(WARNING, EAL, "Requested device " PCI_PRI_FMT
			" cannot be used\n", dev->addr.domain, dev->addr.bus,
			dev->addr.devid, dev->addr.function);
	return -1;
}

/*
 * Scan the content of the PCI bus, and call the probe() function for
 * all registered drivers that have a matching entry in its id_table
 * for discovered devices.
 */
int
rte_eal_pci_probe(void)
{
	struct rte_pci_device *dev = NULL;
	struct rte_devargs *devargs;
	int probe_all = 0;
	int ret = 0;

	if (rte_eal_devargs_type_count(RTE_DEVTYPE_WHITELISTED_PCI) == 0)
		probe_all = 1;

	TAILQ_FOREACH(dev, &pci_device_list, next) {

		/* set devargs in PCI structure */
		devargs = pci_devargs_lookup(dev);
		if (devargs != NULL)
			dev->device.devargs = devargs;

		/* probe all or only whitelisted devices */
		if (probe_all)
			ret = pci_probe_all_drivers(dev);
		else if (devargs != NULL &&
			devargs->type == RTE_DEVTYPE_WHITELISTED_PCI)
			ret = pci_probe_all_drivers(dev);
		if (ret < 0)
			rte_exit(EXIT_FAILURE, "Requested device " PCI_PRI_FMT
				 " cannot be used\n", dev->addr.domain, dev->addr.bus,
				 dev->addr.devid, dev->addr.function);
	}

	return 0;
}

/* dump one device */
static int
pci_dump_one_device(FILE *f, struct rte_pci_device *dev)
{
	int i;

	fprintf(f, PCI_PRI_FMT, dev->addr.domain, dev->addr.bus,
	       dev->addr.devid, dev->addr.function);
	fprintf(f, " - vendor:%x device:%x\n", dev->id.vendor_id,
	       dev->id.device_id);

	for (i = 0; i != sizeof(dev->mem_resource) /
		sizeof(dev->mem_resource[0]); i++) {
		fprintf(f, "   %16.16"PRIx64" %16.16"PRIx64"\n",
			dev->mem_resource[i].phys_addr,
			dev->mem_resource[i].len);
	}
	return 0;
}

/* dump devices on the bus */
void
rte_eal_pci_dump(FILE *f)
{
	struct rte_pci_device *dev = NULL;

	TAILQ_FOREACH(dev, &pci_device_list, next) {
		pci_dump_one_device(f, dev);
	}
}

/* register a driver */
void
rte_eal_pci_register(struct rte_pci_driver *driver)
{
	TAILQ_INSERT_TAIL(&pci_driver_list, driver, next);
	rte_eal_driver_register(&driver->driver);
}

/* unregister a driver */
void
rte_eal_pci_unregister(struct rte_pci_driver *driver)
{
	rte_eal_driver_unregister(&driver->driver);
	TAILQ_REMOVE(&pci_driver_list, driver, next);
}
Commit	Line	Data
7c673cae FG	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	} else if (dr->drv_flags & RTE_PCI_DRV_FORCE_UNBIND &&
207	rte_eal_process_type() == RTE_PROC_PRIMARY) {
208	/* unbind current driver */
209	if (pci_unbind_kernel_driver(dev) < 0)
210	return -1;
211	}
212
213	/* reference driver structure */
214	dev->driver = dr;
215
216	/* call the driver probe() function */
217	ret = dr->probe(dr, dev);
218	if (ret)
219	dev->driver = NULL;
220
221	return ret;
222	}
223	/* return positive value if driver doesn't support this device */
224	return 1;
225	}
226
227	/*
228	* If vendor/device ID match, call the remove() function of the
229	* driver.
230	*/
231	static int
232	rte_eal_pci_detach_dev(struct rte_pci_driver *dr,
233	struct rte_pci_device *dev)
234	{
235	const struct rte_pci_id *id_table;
236
237	if ((dr == NULL) \|\| (dev == NULL))
238	return -EINVAL;
239
240	for (id_table = dr->id_table; id_table->vendor_id != 0; id_table++) {
241
242	/* check if device's identifiers match the driver's ones */
243	if (id_table->vendor_id != dev->id.vendor_id &&
244	id_table->vendor_id != PCI_ANY_ID)
245	continue;
246	if (id_table->device_id != dev->id.device_id &&
247	id_table->device_id != PCI_ANY_ID)
248	continue;
249	if (id_table->subsystem_vendor_id != dev->id.subsystem_vendor_id &&
250	id_table->subsystem_vendor_id != PCI_ANY_ID)
251	continue;
252	if (id_table->subsystem_device_id != dev->id.subsystem_device_id &&
253	id_table->subsystem_device_id != PCI_ANY_ID)
254	continue;
255
256	struct rte_pci_addr *loc = &dev->addr;
257
258	RTE_LOG(DEBUG, EAL, "PCI device "PCI_PRI_FMT" on NUMA socket %i\n",
259	loc->domain, loc->bus, loc->devid,
260	loc->function, dev->device.numa_node);
261
262	RTE_LOG(DEBUG, EAL, " remove driver: %x:%x %s\n", dev->id.vendor_id,
263	dev->id.device_id, dr->driver.name);
264
265	if (dr->remove && (dr->remove(dev) < 0))
266	return -1; /* negative value is an error */
267
268	/* clear driver structure */
269	dev->driver = NULL;
270
271	if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING)
272	/* unmap resources for devices that use igb_uio */
273	rte_eal_pci_unmap_device(dev);
274
275	return 0;
276	}
277
278	/* return positive value if driver doesn't support this device */
279	return 1;
280	}
281
282	/*
283	* If vendor/device ID match, call the probe() function of all
284	* registered driver for the given device. Return -1 if initialization
285	* failed, return 1 if no driver is found for this device.
286	*/
287	static int
288	pci_probe_all_drivers(struct rte_pci_device *dev)
289	{
290	struct rte_pci_driver *dr = NULL;
291	int rc = 0;
292
293	if (dev == NULL)
294	return -1;
295
296	/* Check if a driver is already loaded */
297	if (dev->driver != NULL)
298	return 0;
299
300	TAILQ_FOREACH(dr, &pci_driver_list, next) {
301	rc = rte_eal_pci_probe_one_driver(dr, dev);
302	if (rc < 0)
303	/* negative value is an error */
304	return -1;
305	if (rc > 0)
306	/* positive value means driver doesn't support it */
307	continue;
308	return 0;
309	}
310	return 1;
311	}
312
313	/*
314	* If vendor/device ID match, call the remove() function of all
315	* registered driver for the given device. Return -1 if initialization
316	* failed, return 1 if no driver is found for this device.
317	*/
318	static int
319	pci_detach_all_drivers(struct rte_pci_device *dev)
320	{
321	struct rte_pci_driver *dr = NULL;
322	int rc = 0;
323
324	if (dev == NULL)
325	return -1;
326
327	TAILQ_FOREACH(dr, &pci_driver_list, next) {
328	rc = rte_eal_pci_detach_dev(dr, dev);
329	if (rc < 0)
330	/* negative value is an error */
331	return -1;
332	if (rc > 0)
333	/* positive value means driver doesn't support it */
334	continue;
335	return 0;
336	}
337	return 1;
338	}
339
340	/*
341	* Find the pci device specified by pci address, then invoke probe function of
342	* the driver of the devive.
343	*/
344	int
345	rte_eal_pci_probe_one(const struct rte_pci_addr *addr)
346	{
347	struct rte_pci_device *dev = NULL;
348	int ret = 0;
349
350	if (addr == NULL)
351	return -1;
352
353	/* update current pci device in global list, kernel bindings might have
354	* changed since last time we looked at it.
355	*/
356	if (pci_update_device(addr) < 0)
357	goto err_return;
358
359	TAILQ_FOREACH(dev, &pci_device_list, next) {
360	if (rte_eal_compare_pci_addr(&dev->addr, addr))
361	continue;
362
363	ret = pci_probe_all_drivers(dev);
364	if (ret)
365	goto err_return;
366	return 0;
367	}
368	return -1;
369
370	err_return:
371	RTE_LOG(WARNING, EAL,
372	"Requested device " PCI_PRI_FMT " cannot be used\n",
373	addr->domain, addr->bus, addr->devid, addr->function);
374	return -1;
375	}
376
377	/*
378	* Detach device specified by its pci address.
379	*/
380	int
381	rte_eal_pci_detach(const struct rte_pci_addr *addr)
382	{
383	struct rte_pci_device *dev = NULL;
384	int ret = 0;
385
386	if (addr == NULL)
387	return -1;
388
389	TAILQ_FOREACH(dev, &pci_device_list, next) {
390	if (rte_eal_compare_pci_addr(&dev->addr, addr))
391	continue;
392
393	ret = pci_detach_all_drivers(dev);
394	if (ret < 0)
395	goto err_return;
396
397	TAILQ_REMOVE(&pci_device_list, dev, next);
398	free(dev);
399	return 0;
400	}
401	return -1;
402
403	err_return:
404	RTE_LOG(WARNING, EAL, "Requested device " PCI_PRI_FMT
405	" cannot be used\n", dev->addr.domain, dev->addr.bus,
406	dev->addr.devid, dev->addr.function);
407	return -1;
408	}
409
410	/*
411	* Scan the content of the PCI bus, and call the probe() function for
412	* all registered drivers that have a matching entry in its id_table
413	* for discovered devices.
414	*/
415	int
416	rte_eal_pci_probe(void)
417	{
418	struct rte_pci_device *dev = NULL;
419	struct rte_devargs *devargs;
420	int probe_all = 0;
421	int ret = 0;
422
423	if (rte_eal_devargs_type_count(RTE_DEVTYPE_WHITELISTED_PCI) == 0)
424	probe_all = 1;
425
426	TAILQ_FOREACH(dev, &pci_device_list, next) {
427
428	/* set devargs in PCI structure */
429	devargs = pci_devargs_lookup(dev);
430	if (devargs != NULL)
431	dev->device.devargs = devargs;
432
433	/* probe all or only whitelisted devices */
434	if (probe_all)
435	ret = pci_probe_all_drivers(dev);
436	else if (devargs != NULL &&
437	devargs->type == RTE_DEVTYPE_WHITELISTED_PCI)
438	ret = pci_probe_all_drivers(dev);
439	if (ret < 0)
440	rte_exit(EXIT_FAILURE, "Requested device " PCI_PRI_FMT
441	" cannot be used\n", dev->addr.domain, dev->addr.bus,
442	dev->addr.devid, dev->addr.function);
443	}
444
445	return 0;
446	}
447
448	/* dump one device */
449	static int
450	pci_dump_one_device(FILE f, struct rte_pci_device dev)
451	{
452	int i;
453
454	fprintf(f, PCI_PRI_FMT, dev->addr.domain, dev->addr.bus,
455	dev->addr.devid, dev->addr.function);
456	fprintf(f, " - vendor:%x device:%x\n", dev->id.vendor_id,
457	dev->id.device_id);
458
459	for (i = 0; i != sizeof(dev->mem_resource) /
460	sizeof(dev->mem_resource[0]); i++) {
461	fprintf(f, " %16.16"PRIx64" %16.16"PRIx64"\n",
462	dev->mem_resource[i].phys_addr,
463	dev->mem_resource[i].len);
464	}
465	return 0;
466	}
467
468	/* dump devices on the bus */
469	void
470	rte_eal_pci_dump(FILE *f)
471	{
472	struct rte_pci_device *dev = NULL;
473
474	TAILQ_FOREACH(dev, &pci_device_list, next) {
475	pci_dump_one_device(f, dev);
476	}
477	}
478
479	/* register a driver */
480	void
481	rte_eal_pci_register(struct rte_pci_driver *driver)
482	{
483	TAILQ_INSERT_TAIL(&pci_driver_list, driver, next);
484	rte_eal_driver_register(&driver->driver);
485	}
486
487	/* unregister a driver */
488	void
489	rte_eal_pci_unregister(struct rte_pci_driver *driver)
490	{
491	rte_eal_driver_unregister(&driver->driver);
492	TAILQ_REMOVE(&pci_driver_list, driver, next);
493	}