eal_pci_uio.c revision f7a9461e
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
34#include <string.h>
35#include <unistd.h>
36#include <fcntl.h>
37#include <dirent.h>
38#include <inttypes.h>
39#include <sys/stat.h>
40#include <sys/mman.h>
41#include <sys/sysmacros.h>
42#include <linux/pci_regs.h>
43
44#if defined(RTE_ARCH_X86)
45#include <sys/io.h>
46#endif
47
48#include <rte_log.h>
49#include <rte_pci.h>
50#include <rte_eal_memconfig.h>
51#include <rte_common.h>
52#include <rte_malloc.h>
53
54#include "eal_filesystem.h"
55#include "eal_pci_init.h"
56
57void *pci_map_addr = NULL;
58
59#define OFF_MAX              ((uint64_t)(off_t)-1)
60
61int
62pci_uio_read_config(const struct rte_intr_handle *intr_handle,
63		    void *buf, size_t len, off_t offset)
64{
65	return pread(intr_handle->uio_cfg_fd, buf, len, offset);
66}
67
68int
69pci_uio_write_config(const struct rte_intr_handle *intr_handle,
70		     const void *buf, size_t len, off_t offset)
71{
72	return pwrite(intr_handle->uio_cfg_fd, buf, len, offset);
73}
74
75static int
76pci_uio_set_bus_master(int dev_fd)
77{
78	uint16_t reg;
79	int ret;
80
81	ret = pread(dev_fd, &reg, sizeof(reg), PCI_COMMAND);
82	if (ret != sizeof(reg)) {
83		RTE_LOG(ERR, EAL,
84			"Cannot read command from PCI config space!\n");
85		return -1;
86	}
87
88	/* return if bus mastering is already on */
89	if (reg & PCI_COMMAND_MASTER)
90		return 0;
91
92	reg |= PCI_COMMAND_MASTER;
93
94	ret = pwrite(dev_fd, &reg, sizeof(reg), PCI_COMMAND);
95	if (ret != sizeof(reg)) {
96		RTE_LOG(ERR, EAL,
97			"Cannot write command to PCI config space!\n");
98		return -1;
99	}
100
101	return 0;
102}
103
104static int
105pci_mknod_uio_dev(const char *sysfs_uio_path, unsigned uio_num)
106{
107	FILE *f;
108	char filename[PATH_MAX];
109	int ret;
110	unsigned major, minor;
111	dev_t dev;
112
113	/* get the name of the sysfs file that contains the major and minor
114	 * of the uio device and read its content */
115	snprintf(filename, sizeof(filename), "%s/dev", sysfs_uio_path);
116
117	f = fopen(filename, "r");
118	if (f == NULL) {
119		RTE_LOG(ERR, EAL, "%s(): cannot open sysfs to get major:minor\n",
120			__func__);
121		return -1;
122	}
123
124	ret = fscanf(f, "%u:%u", &major, &minor);
125	if (ret != 2) {
126		RTE_LOG(ERR, EAL, "%s(): cannot parse sysfs to get major:minor\n",
127			__func__);
128		fclose(f);
129		return -1;
130	}
131	fclose(f);
132
133	/* create the char device "mknod /dev/uioX c major minor" */
134	snprintf(filename, sizeof(filename), "/dev/uio%u", uio_num);
135	dev = makedev(major, minor);
136	ret = mknod(filename, S_IFCHR | S_IRUSR | S_IWUSR, dev);
137	if (ret != 0) {
138		RTE_LOG(ERR, EAL, "%s(): mknod() failed %s\n",
139			__func__, strerror(errno));
140		return -1;
141	}
142
143	return ret;
144}
145
146/*
147 * Return the uioX char device used for a pci device. On success, return
148 * the UIO number and fill dstbuf string with the path of the device in
149 * sysfs. On error, return a negative value. In this case dstbuf is
150 * invalid.
151 */
152static int
153pci_get_uio_dev(struct rte_pci_device *dev, char *dstbuf,
154			   unsigned int buflen, int create)
155{
156	struct rte_pci_addr *loc = &dev->addr;
157	int uio_num = -1;
158	struct dirent *e;
159	DIR *dir;
160	char dirname[PATH_MAX];
161
162	/* depending on kernel version, uio can be located in uio/uioX
163	 * or uio:uioX */
164
165	snprintf(dirname, sizeof(dirname),
166			"%s/" PCI_PRI_FMT "/uio", pci_get_sysfs_path(),
167			loc->domain, loc->bus, loc->devid, loc->function);
168
169	dir = opendir(dirname);
170	if (dir == NULL) {
171		/* retry with the parent directory */
172		snprintf(dirname, sizeof(dirname),
173				"%s/" PCI_PRI_FMT, pci_get_sysfs_path(),
174				loc->domain, loc->bus, loc->devid, loc->function);
175		dir = opendir(dirname);
176
177		if (dir == NULL) {
178			RTE_LOG(ERR, EAL, "Cannot opendir %s\n", dirname);
179			return -1;
180		}
181	}
182
183	/* take the first file starting with "uio" */
184	while ((e = readdir(dir)) != NULL) {
185		/* format could be uio%d ...*/
186		int shortprefix_len = sizeof("uio") - 1;
187		/* ... or uio:uio%d */
188		int longprefix_len = sizeof("uio:uio") - 1;
189		char *endptr;
190
191		if (strncmp(e->d_name, "uio", 3) != 0)
192			continue;
193
194		/* first try uio%d */
195		errno = 0;
196		uio_num = strtoull(e->d_name + shortprefix_len, &endptr, 10);
197		if (errno == 0 && endptr != (e->d_name + shortprefix_len)) {
198			snprintf(dstbuf, buflen, "%s/uio%u", dirname, uio_num);
199			break;
200		}
201
202		/* then try uio:uio%d */
203		errno = 0;
204		uio_num = strtoull(e->d_name + longprefix_len, &endptr, 10);
205		if (errno == 0 && endptr != (e->d_name + longprefix_len)) {
206			snprintf(dstbuf, buflen, "%s/uio:uio%u", dirname, uio_num);
207			break;
208		}
209	}
210	closedir(dir);
211
212	/* No uio resource found */
213	if (e == NULL)
214		return -1;
215
216	/* create uio device if we've been asked to */
217	if (internal_config.create_uio_dev && create &&
218			pci_mknod_uio_dev(dstbuf, uio_num) < 0)
219		RTE_LOG(WARNING, EAL, "Cannot create /dev/uio%u\n", uio_num);
220
221	return uio_num;
222}
223
224void
225pci_uio_free_resource(struct rte_pci_device *dev,
226		struct mapped_pci_resource *uio_res)
227{
228	rte_free(uio_res);
229
230	if (dev->intr_handle.uio_cfg_fd >= 0) {
231		close(dev->intr_handle.uio_cfg_fd);
232		dev->intr_handle.uio_cfg_fd = -1;
233	}
234	if (dev->intr_handle.fd) {
235		close(dev->intr_handle.fd);
236		dev->intr_handle.fd = -1;
237		dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
238	}
239}
240
241int
242pci_uio_alloc_resource(struct rte_pci_device *dev,
243		struct mapped_pci_resource **uio_res)
244{
245	char dirname[PATH_MAX];
246	char cfgname[PATH_MAX];
247	char devname[PATH_MAX]; /* contains the /dev/uioX */
248	int uio_num;
249	struct rte_pci_addr *loc;
250
251	loc = &dev->addr;
252
253	/* find uio resource */
254	uio_num = pci_get_uio_dev(dev, dirname, sizeof(dirname), 1);
255	if (uio_num < 0) {
256		RTE_LOG(WARNING, EAL, "  "PCI_PRI_FMT" not managed by UIO driver, "
257				"skipping\n", loc->domain, loc->bus, loc->devid, loc->function);
258		return 1;
259	}
260	snprintf(devname, sizeof(devname), "/dev/uio%u", uio_num);
261
262	/* save fd if in primary process */
263	dev->intr_handle.fd = open(devname, O_RDWR);
264	if (dev->intr_handle.fd < 0) {
265		RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
266			devname, strerror(errno));
267		goto error;
268	}
269
270	snprintf(cfgname, sizeof(cfgname),
271			"/sys/class/uio/uio%u/device/config", uio_num);
272	dev->intr_handle.uio_cfg_fd = open(cfgname, O_RDWR);
273	if (dev->intr_handle.uio_cfg_fd < 0) {
274		RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
275			cfgname, strerror(errno));
276		goto error;
277	}
278
279	if (dev->kdrv == RTE_KDRV_IGB_UIO)
280		dev->intr_handle.type = RTE_INTR_HANDLE_UIO;
281	else {
282		dev->intr_handle.type = RTE_INTR_HANDLE_UIO_INTX;
283
284		/* set bus master that is not done by uio_pci_generic */
285		if (pci_uio_set_bus_master(dev->intr_handle.uio_cfg_fd)) {
286			RTE_LOG(ERR, EAL, "Cannot set up bus mastering!\n");
287			goto error;
288		}
289	}
290
291	/* allocate the mapping details for secondary processes*/
292	*uio_res = rte_zmalloc("UIO_RES", sizeof(**uio_res), 0);
293	if (*uio_res == NULL) {
294		RTE_LOG(ERR, EAL,
295			"%s(): cannot store uio mmap details\n", __func__);
296		goto error;
297	}
298
299	snprintf((*uio_res)->path, sizeof((*uio_res)->path), "%s", devname);
300	memcpy(&(*uio_res)->pci_addr, &dev->addr, sizeof((*uio_res)->pci_addr));
301
302	return 0;
303
304error:
305	pci_uio_free_resource(dev, *uio_res);
306	return -1;
307}
308
309int
310pci_uio_map_resource_by_index(struct rte_pci_device *dev, int res_idx,
311		struct mapped_pci_resource *uio_res, int map_idx)
312{
313	int fd;
314	char devname[PATH_MAX];
315	void *mapaddr;
316	struct rte_pci_addr *loc;
317	struct pci_map *maps;
318
319	loc = &dev->addr;
320	maps = uio_res->maps;
321
322	/* update devname for mmap  */
323	snprintf(devname, sizeof(devname),
324			"%s/" PCI_PRI_FMT "/resource%d",
325			pci_get_sysfs_path(),
326			loc->domain, loc->bus, loc->devid,
327			loc->function, res_idx);
328
329	/* allocate memory to keep path */
330	maps[map_idx].path = rte_malloc(NULL, sizeof(devname), 0);
331	if (maps[map_idx].path == NULL) {
332		RTE_LOG(ERR, EAL, "Cannot allocate memory for path: %s\n",
333				strerror(errno));
334		return -1;
335	}
336
337	/*
338	 * open resource file, to mmap it
339	 */
340	fd = open(devname, O_RDWR);
341	if (fd < 0) {
342		RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
343				devname, strerror(errno));
344		goto error;
345	}
346
347	/* try mapping somewhere close to the end of hugepages */
348	if (pci_map_addr == NULL)
349		pci_map_addr = pci_find_max_end_va();
350
351	mapaddr = pci_map_resource(pci_map_addr, fd, 0,
352			(size_t)dev->mem_resource[res_idx].len, 0);
353	close(fd);
354	if (mapaddr == MAP_FAILED)
355		goto error;
356
357	pci_map_addr = RTE_PTR_ADD(mapaddr,
358			(size_t)dev->mem_resource[res_idx].len);
359
360	maps[map_idx].phaddr = dev->mem_resource[res_idx].phys_addr;
361	maps[map_idx].size = dev->mem_resource[res_idx].len;
362	maps[map_idx].addr = mapaddr;
363	maps[map_idx].offset = 0;
364	strcpy(maps[map_idx].path, devname);
365	dev->mem_resource[res_idx].addr = mapaddr;
366
367	return 0;
368
369error:
370	rte_free(maps[map_idx].path);
371	return -1;
372}
373
374#if defined(RTE_ARCH_X86)
375int
376pci_uio_ioport_map(struct rte_pci_device *dev, int bar,
377		   struct rte_pci_ioport *p)
378{
379	char dirname[PATH_MAX];
380	char filename[PATH_MAX];
381	int uio_num;
382	unsigned long start;
383
384	uio_num = pci_get_uio_dev(dev, dirname, sizeof(dirname), 0);
385	if (uio_num < 0)
386		return -1;
387
388	/* get portio start */
389	snprintf(filename, sizeof(filename),
390		 "%s/portio/port%d/start", dirname, bar);
391	if (eal_parse_sysfs_value(filename, &start) < 0) {
392		RTE_LOG(ERR, EAL, "%s(): cannot parse portio start\n",
393			__func__);
394		return -1;
395	}
396	/* ensure we don't get anything funny here, read/write will cast to
397	 * uin16_t */
398	if (start > UINT16_MAX)
399		return -1;
400
401	/* FIXME only for primary process ? */
402	if (dev->intr_handle.type == RTE_INTR_HANDLE_UNKNOWN) {
403
404		snprintf(filename, sizeof(filename), "/dev/uio%u", uio_num);
405		dev->intr_handle.fd = open(filename, O_RDWR);
406		if (dev->intr_handle.fd < 0) {
407			RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
408				filename, strerror(errno));
409			return -1;
410		}
411		dev->intr_handle.type = RTE_INTR_HANDLE_UIO;
412	}
413
414	RTE_LOG(DEBUG, EAL, "PCI Port IO found start=0x%lx\n", start);
415
416	p->base = start;
417	p->len = 0;
418	return 0;
419}
420#else
421int
422pci_uio_ioport_map(struct rte_pci_device *dev, int bar,
423		   struct rte_pci_ioport *p)
424{
425	FILE *f;
426	char buf[BUFSIZ];
427	char filename[PATH_MAX];
428	uint64_t phys_addr, end_addr, flags;
429	int fd, i;
430	void *addr;
431
432	/* open and read addresses of the corresponding resource in sysfs */
433	snprintf(filename, sizeof(filename), "%s/" PCI_PRI_FMT "/resource",
434		pci_get_sysfs_path(), dev->addr.domain, dev->addr.bus,
435		dev->addr.devid, dev->addr.function);
436	f = fopen(filename, "r");
437	if (f == NULL) {
438		RTE_LOG(ERR, EAL, "Cannot open sysfs resource: %s\n",
439			strerror(errno));
440		return -1;
441	}
442	for (i = 0; i < bar + 1; i++) {
443		if (fgets(buf, sizeof(buf), f) == NULL) {
444			RTE_LOG(ERR, EAL, "Cannot read sysfs resource\n");
445			goto error;
446		}
447	}
448	if (pci_parse_one_sysfs_resource(buf, sizeof(buf), &phys_addr,
449			&end_addr, &flags) < 0)
450		goto error;
451	if ((flags & IORESOURCE_IO) == 0) {
452		RTE_LOG(ERR, EAL, "BAR %d is not an IO resource\n", bar);
453		goto error;
454	}
455	snprintf(filename, sizeof(filename), "%s/" PCI_PRI_FMT "/resource%d",
456		pci_get_sysfs_path(), dev->addr.domain, dev->addr.bus,
457		dev->addr.devid, dev->addr.function, bar);
458
459	/* mmap the pci resource */
460	fd = open(filename, O_RDWR);
461	if (fd < 0) {
462		RTE_LOG(ERR, EAL, "Cannot open %s: %s\n", filename,
463			strerror(errno));
464		goto error;
465	}
466	addr = mmap(NULL, end_addr + 1, PROT_READ | PROT_WRITE,
467		MAP_SHARED, fd, 0);
468	close(fd);
469	if (addr == MAP_FAILED) {
470		RTE_LOG(ERR, EAL, "Cannot mmap IO port resource: %s\n",
471			strerror(errno));
472		goto error;
473	}
474
475	/* strangely, the base address is mmap addr + phys_addr */
476	p->base = (uintptr_t)addr + phys_addr;
477	p->len = end_addr + 1;
478	RTE_LOG(DEBUG, EAL, "PCI Port IO found start=0x%"PRIx64"\n", p->base);
479	fclose(f);
480
481	return 0;
482
483error:
484	fclose(f);
485	return -1;
486}
487#endif
488
489void
490pci_uio_ioport_read(struct rte_pci_ioport *p,
491		    void *data, size_t len, off_t offset)
492{
493	uint8_t *d;
494	int size;
495	uintptr_t reg = p->base + offset;
496
497	for (d = data; len > 0; d += size, reg += size, len -= size) {
498		if (len >= 4) {
499			size = 4;
500#if defined(RTE_ARCH_X86)
501			*(uint32_t *)d = inl(reg);
502#else
503			*(uint32_t *)d = *(volatile uint32_t *)reg;
504#endif
505		} else if (len >= 2) {
506			size = 2;
507#if defined(RTE_ARCH_X86)
508			*(uint16_t *)d = inw(reg);
509#else
510			*(uint16_t *)d = *(volatile uint16_t *)reg;
511#endif
512		} else {
513			size = 1;
514#if defined(RTE_ARCH_X86)
515			*d = inb(reg);
516#else
517			*d = *(volatile uint8_t *)reg;
518#endif
519		}
520	}
521}
522
523void
524pci_uio_ioport_write(struct rte_pci_ioport *p,
525		     const void *data, size_t len, off_t offset)
526{
527	const uint8_t *s;
528	int size;
529	uintptr_t reg = p->base + offset;
530
531	for (s = data; len > 0; s += size, reg += size, len -= size) {
532		if (len >= 4) {
533			size = 4;
534#if defined(RTE_ARCH_X86)
535			outl_p(*(const uint32_t *)s, reg);
536#else
537			*(volatile uint32_t *)reg = *(const uint32_t *)s;
538#endif
539		} else if (len >= 2) {
540			size = 2;
541#if defined(RTE_ARCH_X86)
542			outw_p(*(const uint16_t *)s, reg);
543#else
544			*(volatile uint16_t *)reg = *(const uint16_t *)s;
545#endif
546		} else {
547			size = 1;
548#if defined(RTE_ARCH_X86)
549			outb_p(*s, reg);
550#else
551			*(volatile uint8_t *)reg = *s;
552#endif
553		}
554	}
555}
556
557int
558pci_uio_ioport_unmap(struct rte_pci_ioport *p)
559{
560#if defined(RTE_ARCH_X86)
561	RTE_SET_USED(p);
562	/* FIXME close intr fd ? */
563	return 0;
564#else
565	return munmap((void *)(uintptr_t)p->base, p->len);
566#endif
567}
568