service: add count per lcore
[dpdk.git] / lib / librte_eal / linuxapp / eal / eal_pci_uio.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
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
57 void *pci_map_addr = NULL;
58
59 #define OFF_MAX              ((uint64_t)(off_t)-1)
60
61 int
62 pci_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
68 int
69 pci_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
75 static int
76 pci_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
104 static int
105 pci_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  */
152 static int
153 pci_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         unsigned int uio_num;
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
224 void
225 pci_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 >= 0) {
235                 close(dev->intr_handle.fd);
236                 dev->intr_handle.fd = -1;
237                 dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
238         }
239 }
240
241 int
242 pci_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
304 error:
305         pci_uio_free_resource(dev, *uio_res);
306         return -1;
307 }
308
309 int
310 pci_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, strlen(devname) + 1, 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
369 error:
370         rte_free(maps[map_idx].path);
371         return -1;
372 }
373
374 #if defined(RTE_ARCH_X86)
375 int
376 pci_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
421 int
422 pci_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
483 error:
484         fclose(f);
485         return -1;
486 }
487 #endif
488
489 void
490 pci_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
523 void
524 pci_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
557 int
558 pci_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 }