4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
40 #include <linux/pci_regs.h>
44 #include <rte_common.h>
45 #include <rte_malloc.h>
46 #include <rte_tailq.h>
48 #include "rte_pci_dev_ids.h"
49 #include "eal_filesystem.h"
50 #include "eal_pci_init.h"
52 void *pci_map_addr = NULL;
55 #define OFF_MAX ((uint64_t)(off_t)-1)
58 pci_uio_set_bus_master(int dev_fd)
63 ret = pread(dev_fd, ®, sizeof(reg), PCI_COMMAND);
64 if (ret != sizeof(reg)) {
66 "Cannot read command from PCI config space!\n");
70 /* return if bus mastering is already on */
71 if (reg & PCI_COMMAND_MASTER)
74 reg |= PCI_COMMAND_MASTER;
76 ret = pwrite(dev_fd, ®, sizeof(reg), PCI_COMMAND);
77 if (ret != sizeof(reg)) {
79 "Cannot write command to PCI config space!\n");
87 pci_uio_map_secondary(struct rte_pci_device *dev)
90 struct mapped_pci_resource *uio_res;
92 TAILQ_FOREACH(uio_res, pci_res_list, next) {
94 /* skip this element if it doesn't match our PCI address */
95 if (rte_eal_compare_pci_addr(&uio_res->pci_addr, &dev->addr))
98 for (i = 0; i != uio_res->nb_maps; i++) {
100 * open devname, to mmap it
102 fd = open(uio_res->maps[i].path, O_RDWR);
104 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
105 uio_res->maps[i].path, strerror(errno));
109 void *mapaddr = pci_map_resource(uio_res->maps[i].addr,
110 fd, (off_t)uio_res->maps[i].offset,
111 (size_t)uio_res->maps[i].size, 0);
112 if (mapaddr != uio_res->maps[i].addr) {
113 if (mapaddr == MAP_FAILED)
115 "Cannot mmap device resource file %s: %s\n",
116 uio_res->maps[i].path,
120 "Cannot mmap device resource file %s to address: %p\n",
121 uio_res->maps[i].path,
122 uio_res->maps[i].addr);
127 /* fd is not needed in slave process, close it */
133 RTE_LOG(ERR, EAL, "Cannot find resource for device\n");
138 pci_mknod_uio_dev(const char *sysfs_uio_path, unsigned uio_num)
141 char filename[PATH_MAX];
143 unsigned major, minor;
146 /* get the name of the sysfs file that contains the major and minor
147 * of the uio device and read its content */
148 snprintf(filename, sizeof(filename), "%s/dev", sysfs_uio_path);
150 f = fopen(filename, "r");
152 RTE_LOG(ERR, EAL, "%s(): cannot open sysfs to get major:minor\n",
157 ret = fscanf(f, "%u:%u", &major, &minor);
159 RTE_LOG(ERR, EAL, "%s(): cannot parse sysfs to get major:minor\n",
166 /* create the char device "mknod /dev/uioX c major minor" */
167 snprintf(filename, sizeof(filename), "/dev/uio%u", uio_num);
168 dev = makedev(major, minor);
169 ret = mknod(filename, S_IFCHR | S_IRUSR | S_IWUSR, dev);
171 RTE_LOG(ERR, EAL, "%s(): mknod() failed %s\n",
172 __func__, strerror(errno));
180 * Return the uioX char device used for a pci device. On success, return
181 * the UIO number and fill dstbuf string with the path of the device in
182 * sysfs. On error, return a negative value. In this case dstbuf is
186 pci_get_uio_dev(struct rte_pci_device *dev, char *dstbuf,
189 struct rte_pci_addr *loc = &dev->addr;
190 unsigned int uio_num;
193 char dirname[PATH_MAX];
195 /* depending on kernel version, uio can be located in uio/uioX
198 snprintf(dirname, sizeof(dirname),
199 SYSFS_PCI_DEVICES "/" PCI_PRI_FMT "/uio",
200 loc->domain, loc->bus, loc->devid, loc->function);
202 dir = opendir(dirname);
204 /* retry with the parent directory */
205 snprintf(dirname, sizeof(dirname),
206 SYSFS_PCI_DEVICES "/" PCI_PRI_FMT,
207 loc->domain, loc->bus, loc->devid, loc->function);
208 dir = opendir(dirname);
211 RTE_LOG(ERR, EAL, "Cannot opendir %s\n", dirname);
216 /* take the first file starting with "uio" */
217 while ((e = readdir(dir)) != NULL) {
218 /* format could be uio%d ...*/
219 int shortprefix_len = sizeof("uio") - 1;
220 /* ... or uio:uio%d */
221 int longprefix_len = sizeof("uio:uio") - 1;
224 if (strncmp(e->d_name, "uio", 3) != 0)
227 /* first try uio%d */
229 uio_num = strtoull(e->d_name + shortprefix_len, &endptr, 10);
230 if (errno == 0 && endptr != (e->d_name + shortprefix_len)) {
231 snprintf(dstbuf, buflen, "%s/uio%u", dirname, uio_num);
235 /* then try uio:uio%d */
237 uio_num = strtoull(e->d_name + longprefix_len, &endptr, 10);
238 if (errno == 0 && endptr != (e->d_name + longprefix_len)) {
239 snprintf(dstbuf, buflen, "%s/uio:uio%u", dirname, uio_num);
245 /* No uio resource found */
249 /* create uio device if we've been asked to */
250 if (internal_config.create_uio_dev &&
251 pci_mknod_uio_dev(dstbuf, uio_num) < 0)
252 RTE_LOG(WARNING, EAL, "Cannot create /dev/uio%u\n", uio_num);
257 /* map the PCI resource of a PCI device in virtual memory */
259 pci_uio_map_resource(struct rte_pci_device *dev)
262 char dirname[PATH_MAX];
263 char cfgname[PATH_MAX];
264 char devname[PATH_MAX]; /* contains the /dev/uioX */
268 struct rte_pci_addr *loc = &dev->addr;
269 struct mapped_pci_resource *uio_res;
270 struct pci_map *maps;
272 dev->intr_handle.fd = -1;
273 dev->intr_handle.uio_cfg_fd = -1;
274 dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
276 /* secondary processes - use already recorded details */
277 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
278 return pci_uio_map_secondary(dev);
280 /* find uio resource */
281 uio_num = pci_get_uio_dev(dev, dirname, sizeof(dirname));
283 RTE_LOG(WARNING, EAL, " "PCI_PRI_FMT" not managed by UIO driver, "
284 "skipping\n", loc->domain, loc->bus, loc->devid, loc->function);
287 snprintf(devname, sizeof(devname), "/dev/uio%u", uio_num);
289 /* save fd if in primary process */
290 dev->intr_handle.fd = open(devname, O_RDWR);
291 if (dev->intr_handle.fd < 0) {
292 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
293 devname, strerror(errno));
296 dev->intr_handle.type = RTE_INTR_HANDLE_UIO;
298 snprintf(cfgname, sizeof(cfgname),
299 "/sys/class/uio/uio%u/device/config", uio_num);
300 dev->intr_handle.uio_cfg_fd = open(cfgname, O_RDWR);
301 if (dev->intr_handle.uio_cfg_fd < 0) {
302 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
303 cfgname, strerror(errno));
307 /* set bus master that is not done by uio_pci_generic */
308 if (pci_uio_set_bus_master(dev->intr_handle.uio_cfg_fd)) {
309 RTE_LOG(ERR, EAL, "Cannot set up bus mastering!\n");
313 /* allocate the mapping details for secondary processes*/
314 uio_res = rte_zmalloc("UIO_RES", sizeof(*uio_res), 0);
315 if (uio_res == NULL) {
317 "%s(): cannot store uio mmap details\n", __func__);
321 snprintf(uio_res->path, sizeof(uio_res->path), "%s", devname);
322 memcpy(&uio_res->pci_addr, &dev->addr, sizeof(uio_res->pci_addr));
325 maps = uio_res->maps;
326 for (i = 0, map_idx = 0; i != PCI_MAX_RESOURCE; i++) {
331 phaddr = dev->mem_resource[i].phys_addr;
336 /* update devname for mmap */
337 snprintf(devname, sizeof(devname),
338 SYSFS_PCI_DEVICES "/" PCI_PRI_FMT "/resource%d",
339 loc->domain, loc->bus, loc->devid, loc->function,
343 * open resource file, to mmap it
345 fd = open(devname, O_RDWR);
347 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
348 devname, strerror(errno));
352 /* try mapping somewhere close to the end of hugepages */
353 if (pci_map_addr == NULL)
354 pci_map_addr = pci_find_max_end_va();
356 mapaddr = pci_map_resource(pci_map_addr, fd, 0,
357 (size_t)dev->mem_resource[i].len, 0);
358 if (mapaddr == MAP_FAILED)
361 pci_map_addr = RTE_PTR_ADD(mapaddr,
362 (size_t)dev->mem_resource[i].len);
364 maps[map_idx].path = rte_malloc(NULL, strlen(devname) + 1, 0);
365 if (maps[map_idx].path == NULL)
375 maps[map_idx].phaddr = dev->mem_resource[i].phys_addr;
376 maps[map_idx].size = dev->mem_resource[i].len;
377 maps[map_idx].addr = mapaddr;
378 maps[map_idx].offset = 0;
379 strcpy(maps[map_idx].path, devname);
381 dev->mem_resource[i].addr = mapaddr;
384 uio_res->nb_maps = map_idx;
386 TAILQ_INSERT_TAIL(pci_res_list, uio_res, next);
391 #ifdef RTE_LIBRTE_EAL_HOTPLUG
393 pci_uio_unmap(struct mapped_pci_resource *uio_res)
400 for (i = 0; i != uio_res->nb_maps; i++)
401 pci_unmap_resource(uio_res->maps[i].addr,
402 (size_t)uio_res->maps[i].size);
405 static struct mapped_pci_resource *
406 pci_uio_find_resource(struct rte_pci_device *dev)
408 struct mapped_pci_resource *uio_res;
413 TAILQ_FOREACH(uio_res, pci_res_list, next) {
415 /* skip this element if it doesn't match our PCI address */
416 if (!rte_eal_compare_pci_addr(&uio_res->pci_addr, &dev->addr))
422 /* unmap the PCI resource of a PCI device in virtual memory */
424 pci_uio_unmap_resource(struct rte_pci_device *dev)
426 struct mapped_pci_resource *uio_res;
431 /* find an entry for the device */
432 uio_res = pci_uio_find_resource(dev);
436 /* secondary processes - just free maps */
437 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
438 return pci_uio_unmap(uio_res);
440 TAILQ_REMOVE(pci_res_list, uio_res, next);
442 /* unmap all resources */
443 pci_uio_unmap(uio_res);
445 /* free uio resource */
448 /* close fd if in primary process */
449 close(dev->intr_handle.fd);
451 dev->intr_handle.fd = -1;
452 dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
454 #endif /* RTE_LIBRTE_EAL_HOTPLUG */