eal/bsd: fix ioport write operation
[dpdk.git] / lib / librte_eal / bsdapp / eal / eal_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
34 #include <ctype.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <stdarg.h>
39 #include <unistd.h>
40 #include <inttypes.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include <fcntl.h>
44 #include <stdarg.h>
45 #include <errno.h>
46 #include <dirent.h>
47 #include <limits.h>
48 #include <sys/queue.h>
49 #include <sys/mman.h>
50 #include <sys/ioctl.h>
51 #include <sys/pciio.h>
52 #include <dev/pci/pcireg.h>
53
54 #if defined(RTE_ARCH_X86)
55 #include <sys/types.h>
56 #include <machine/cpufunc.h>
57 #endif
58
59 #include <rte_interrupts.h>
60 #include <rte_log.h>
61 #include <rte_pci.h>
62 #include <rte_common.h>
63 #include <rte_launch.h>
64 #include <rte_memory.h>
65 #include <rte_memzone.h>
66 #include <rte_eal.h>
67 #include <rte_eal_memconfig.h>
68 #include <rte_per_lcore.h>
69 #include <rte_lcore.h>
70 #include <rte_malloc.h>
71 #include <rte_string_fns.h>
72 #include <rte_debug.h>
73 #include <rte_devargs.h>
74
75 #include "eal_filesystem.h"
76 #include "eal_private.h"
77
78 /**
79  * @file
80  * PCI probing under linux
81  *
82  * This code is used to simulate a PCI probe by parsing information in
83  * sysfs. Moreover, when a registered driver matches a device, the
84  * kernel driver currently using it is unloaded and replaced by
85  * igb_uio module, which is a very minimal userland driver for Intel
86  * network card, only providing access to PCI BAR to applications, and
87  * enabling bus master.
88  */
89
90 extern struct rte_pci_bus rte_pci_bus;
91
92 /* Map pci device */
93 int
94 rte_pci_map_device(struct rte_pci_device *dev)
95 {
96         int ret = -1;
97
98         /* try mapping the NIC resources */
99         switch (dev->kdrv) {
100         case RTE_KDRV_NIC_UIO:
101                 /* map resources for devices that use uio */
102                 ret = pci_uio_map_resource(dev);
103                 break;
104         default:
105                 RTE_LOG(DEBUG, EAL,
106                         "  Not managed by a supported kernel driver, skipped\n");
107                 ret = 1;
108                 break;
109         }
110
111         return ret;
112 }
113
114 /* Unmap pci device */
115 void
116 rte_pci_unmap_device(struct rte_pci_device *dev)
117 {
118         /* try unmapping the NIC resources */
119         switch (dev->kdrv) {
120         case RTE_KDRV_NIC_UIO:
121                 /* unmap resources for devices that use uio */
122                 pci_uio_unmap_resource(dev);
123                 break;
124         default:
125                 RTE_LOG(DEBUG, EAL,
126                         "  Not managed by a supported kernel driver, skipped\n");
127                 break;
128         }
129 }
130
131 void
132 pci_uio_free_resource(struct rte_pci_device *dev,
133                 struct mapped_pci_resource *uio_res)
134 {
135         rte_free(uio_res);
136
137         if (dev->intr_handle.fd) {
138                 close(dev->intr_handle.fd);
139                 dev->intr_handle.fd = -1;
140                 dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
141         }
142 }
143
144 int
145 pci_uio_alloc_resource(struct rte_pci_device *dev,
146                 struct mapped_pci_resource **uio_res)
147 {
148         char devname[PATH_MAX]; /* contains the /dev/uioX */
149         struct rte_pci_addr *loc;
150
151         loc = &dev->addr;
152
153         snprintf(devname, sizeof(devname), "/dev/uio@pci:%u:%u:%u",
154                         dev->addr.bus, dev->addr.devid, dev->addr.function);
155
156         if (access(devname, O_RDWR) < 0) {
157                 RTE_LOG(WARNING, EAL, "  "PCI_PRI_FMT" not managed by UIO driver, "
158                                 "skipping\n", loc->domain, loc->bus, loc->devid, loc->function);
159                 return 1;
160         }
161
162         /* save fd if in primary process */
163         dev->intr_handle.fd = open(devname, O_RDWR);
164         if (dev->intr_handle.fd < 0) {
165                 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
166                         devname, strerror(errno));
167                 goto error;
168         }
169         dev->intr_handle.type = RTE_INTR_HANDLE_UIO;
170
171         /* allocate the mapping details for secondary processes*/
172         *uio_res = rte_zmalloc("UIO_RES", sizeof(**uio_res), 0);
173         if (*uio_res == NULL) {
174                 RTE_LOG(ERR, EAL,
175                         "%s(): cannot store uio mmap details\n", __func__);
176                 goto error;
177         }
178
179         snprintf((*uio_res)->path, sizeof((*uio_res)->path), "%s", devname);
180         memcpy(&(*uio_res)->pci_addr, &dev->addr, sizeof((*uio_res)->pci_addr));
181
182         return 0;
183
184 error:
185         pci_uio_free_resource(dev, *uio_res);
186         return -1;
187 }
188
189 int
190 pci_uio_map_resource_by_index(struct rte_pci_device *dev, int res_idx,
191                 struct mapped_pci_resource *uio_res, int map_idx)
192 {
193         int fd;
194         char *devname;
195         void *mapaddr;
196         uint64_t offset;
197         uint64_t pagesz;
198         struct pci_map *maps;
199
200         maps = uio_res->maps;
201         devname = uio_res->path;
202         pagesz = sysconf(_SC_PAGESIZE);
203
204         /* allocate memory to keep path */
205         maps[map_idx].path = rte_malloc(NULL, strlen(devname) + 1, 0);
206         if (maps[map_idx].path == NULL) {
207                 RTE_LOG(ERR, EAL, "Cannot allocate memory for path: %s\n",
208                                 strerror(errno));
209                 return -1;
210         }
211
212         /*
213          * open resource file, to mmap it
214          */
215         fd = open(devname, O_RDWR);
216         if (fd < 0) {
217                 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
218                                 devname, strerror(errno));
219                 goto error;
220         }
221
222         /* if matching map is found, then use it */
223         offset = res_idx * pagesz;
224         mapaddr = pci_map_resource(NULL, fd, (off_t)offset,
225                         (size_t)dev->mem_resource[res_idx].len, 0);
226         close(fd);
227         if (mapaddr == MAP_FAILED)
228                 goto error;
229
230         maps[map_idx].phaddr = dev->mem_resource[res_idx].phys_addr;
231         maps[map_idx].size = dev->mem_resource[res_idx].len;
232         maps[map_idx].addr = mapaddr;
233         maps[map_idx].offset = offset;
234         strcpy(maps[map_idx].path, devname);
235         dev->mem_resource[res_idx].addr = mapaddr;
236
237         return 0;
238
239 error:
240         rte_free(maps[map_idx].path);
241         return -1;
242 }
243
244 static int
245 pci_scan_one(int dev_pci_fd, struct pci_conf *conf)
246 {
247         struct rte_pci_device *dev;
248         struct pci_bar_io bar;
249         unsigned i, max;
250
251         dev = malloc(sizeof(*dev));
252         if (dev == NULL) {
253                 return -1;
254         }
255
256         memset(dev, 0, sizeof(*dev));
257         dev->addr.domain = conf->pc_sel.pc_domain;
258         dev->addr.bus = conf->pc_sel.pc_bus;
259         dev->addr.devid = conf->pc_sel.pc_dev;
260         dev->addr.function = conf->pc_sel.pc_func;
261
262         /* get vendor id */
263         dev->id.vendor_id = conf->pc_vendor;
264
265         /* get device id */
266         dev->id.device_id = conf->pc_device;
267
268         /* get subsystem_vendor id */
269         dev->id.subsystem_vendor_id = conf->pc_subvendor;
270
271         /* get subsystem_device id */
272         dev->id.subsystem_device_id = conf->pc_subdevice;
273
274         /* get class id */
275         dev->id.class_id = (conf->pc_class << 16) |
276                            (conf->pc_subclass << 8) |
277                            (conf->pc_progif);
278
279         /* TODO: get max_vfs */
280         dev->max_vfs = 0;
281
282         /* FreeBSD has no NUMA support (yet) */
283         dev->device.numa_node = 0;
284
285         rte_pci_device_name(&dev->addr, dev->name, sizeof(dev->name));
286         dev->device.name = dev->name;
287
288         /* FreeBSD has only one pass through driver */
289         dev->kdrv = RTE_KDRV_NIC_UIO;
290
291         /* parse resources */
292         switch (conf->pc_hdr & PCIM_HDRTYPE) {
293         case PCIM_HDRTYPE_NORMAL:
294                 max = PCIR_MAX_BAR_0;
295                 break;
296         case PCIM_HDRTYPE_BRIDGE:
297                 max = PCIR_MAX_BAR_1;
298                 break;
299         case PCIM_HDRTYPE_CARDBUS:
300                 max = PCIR_MAX_BAR_2;
301                 break;
302         default:
303                 goto skipdev;
304         }
305
306         for (i = 0; i <= max; i++) {
307                 bar.pbi_sel = conf->pc_sel;
308                 bar.pbi_reg = PCIR_BAR(i);
309                 if (ioctl(dev_pci_fd, PCIOCGETBAR, &bar) < 0)
310                         continue;
311
312                 dev->mem_resource[i].len = bar.pbi_length;
313                 if (PCI_BAR_IO(bar.pbi_base)) {
314                         dev->mem_resource[i].addr = (void *)(bar.pbi_base & ~((uint64_t)0xf));
315                         continue;
316                 }
317                 dev->mem_resource[i].phys_addr = bar.pbi_base & ~((uint64_t)0xf);
318         }
319
320         /* device is valid, add in list (sorted) */
321         if (TAILQ_EMPTY(&rte_pci_bus.device_list)) {
322                 rte_pci_add_device(dev);
323         }
324         else {
325                 struct rte_pci_device *dev2 = NULL;
326                 int ret;
327
328                 TAILQ_FOREACH(dev2, &rte_pci_bus.device_list, next) {
329                         ret = rte_eal_compare_pci_addr(&dev->addr, &dev2->addr);
330                         if (ret > 0)
331                                 continue;
332                         else if (ret < 0) {
333                                 rte_pci_insert_device(dev2, dev);
334                         } else { /* already registered */
335                                 dev2->kdrv = dev->kdrv;
336                                 dev2->max_vfs = dev->max_vfs;
337                                 memmove(dev2->mem_resource,
338                                         dev->mem_resource,
339                                         sizeof(dev->mem_resource));
340                                 free(dev);
341                         }
342                         return 0;
343                 }
344                 rte_pci_add_device(dev);
345         }
346
347         return 0;
348
349 skipdev:
350         free(dev);
351         return 0;
352 }
353
354 /*
355  * Scan the content of the PCI bus, and add the devices in the devices
356  * list. Call pci_scan_one() for each pci entry found.
357  */
358 int
359 rte_pci_scan(void)
360 {
361         int fd;
362         unsigned dev_count = 0;
363         struct pci_conf matches[16];
364         struct pci_conf_io conf_io = {
365                         .pat_buf_len = 0,
366                         .num_patterns = 0,
367                         .patterns = NULL,
368                         .match_buf_len = sizeof(matches),
369                         .matches = &matches[0],
370         };
371
372         /* for debug purposes, PCI can be disabled */
373         if (internal_config.no_pci)
374                 return 0;
375
376         fd = open("/dev/pci", O_RDONLY);
377         if (fd < 0) {
378                 RTE_LOG(ERR, EAL, "%s(): error opening /dev/pci\n", __func__);
379                 goto error;
380         }
381
382         do {
383                 unsigned i;
384                 if (ioctl(fd, PCIOCGETCONF, &conf_io) < 0) {
385                         RTE_LOG(ERR, EAL, "%s(): error with ioctl on /dev/pci: %s\n",
386                                         __func__, strerror(errno));
387                         goto error;
388                 }
389
390                 for (i = 0; i < conf_io.num_matches; i++)
391                         if (pci_scan_one(fd, &matches[i]) < 0)
392                                 goto error;
393
394                 dev_count += conf_io.num_matches;
395         } while(conf_io.status == PCI_GETCONF_MORE_DEVS);
396
397         close(fd);
398
399         RTE_LOG(ERR, EAL, "PCI scan found %u devices\n", dev_count);
400         return 0;
401
402 error:
403         if (fd >= 0)
404                 close(fd);
405         return -1;
406 }
407
408 int
409 pci_update_device(const struct rte_pci_addr *addr)
410 {
411         int fd;
412         struct pci_conf matches[2];
413         struct pci_match_conf match = {
414                 .pc_sel = {
415                         .pc_domain = addr->domain,
416                         .pc_bus = addr->bus,
417                         .pc_dev = addr->devid,
418                         .pc_func = addr->function,
419                 },
420         };
421         struct pci_conf_io conf_io = {
422                 .pat_buf_len = 0,
423                 .num_patterns = 1,
424                 .patterns = &match,
425                 .match_buf_len = sizeof(matches),
426                 .matches = &matches[0],
427         };
428
429         fd = open("/dev/pci", O_RDONLY);
430         if (fd < 0) {
431                 RTE_LOG(ERR, EAL, "%s(): error opening /dev/pci\n", __func__);
432                 goto error;
433         }
434
435         if (ioctl(fd, PCIOCGETCONF, &conf_io) < 0) {
436                 RTE_LOG(ERR, EAL, "%s(): error with ioctl on /dev/pci: %s\n",
437                                 __func__, strerror(errno));
438                 goto error;
439         }
440
441         if (conf_io.num_matches != 1)
442                 goto error;
443
444         if (pci_scan_one(fd, &matches[0]) < 0)
445                 goto error;
446
447         close(fd);
448
449         return 0;
450
451 error:
452         if (fd >= 0)
453                 close(fd);
454         return -1;
455 }
456
457 /* Read PCI config space. */
458 int rte_pci_read_config(const struct rte_pci_device *dev,
459                 void *buf, size_t len, off_t offset)
460 {
461         int fd = -1;
462         struct pci_io pi = {
463                 .pi_sel = {
464                         .pc_domain = dev->addr.domain,
465                         .pc_bus = dev->addr.bus,
466                         .pc_dev = dev->addr.devid,
467                         .pc_func = dev->addr.function,
468                 },
469                 .pi_reg = offset,
470                 .pi_width = len,
471         };
472
473         if (len == 3 || len > sizeof(pi.pi_data)) {
474                 RTE_LOG(ERR, EAL, "%s(): invalid pci read length\n", __func__);
475                 goto error;
476         }
477
478         fd = open("/dev/pci", O_RDWR);
479         if (fd < 0) {
480                 RTE_LOG(ERR, EAL, "%s(): error opening /dev/pci\n", __func__);
481                 goto error;
482         }
483
484         if (ioctl(fd, PCIOCREAD, &pi) < 0)
485                 goto error;
486         close(fd);
487
488         memcpy(buf, &pi.pi_data, len);
489         return 0;
490
491  error:
492         if (fd >= 0)
493                 close(fd);
494         return -1;
495 }
496
497 /* Write PCI config space. */
498 int rte_pci_write_config(const struct rte_pci_device *dev,
499                 const void *buf, size_t len, off_t offset)
500 {
501         int fd = -1;
502
503         struct pci_io pi = {
504                 .pi_sel = {
505                         .pc_domain = dev->addr.domain,
506                         .pc_bus = dev->addr.bus,
507                         .pc_dev = dev->addr.devid,
508                         .pc_func = dev->addr.function,
509                 },
510                 .pi_reg = offset,
511                 .pi_data = *(const uint32_t *)buf,
512                 .pi_width = len,
513         };
514
515         if (len == 3 || len > sizeof(pi.pi_data)) {
516                 RTE_LOG(ERR, EAL, "%s(): invalid pci read length\n", __func__);
517                 goto error;
518         }
519
520         memcpy(&pi.pi_data, buf, len);
521
522         fd = open("/dev/pci", O_RDWR);
523         if (fd < 0) {
524                 RTE_LOG(ERR, EAL, "%s(): error opening /dev/pci\n", __func__);
525                 goto error;
526         }
527
528         if (ioctl(fd, PCIOCWRITE, &pi) < 0)
529                 goto error;
530
531         close(fd);
532         return 0;
533
534  error:
535         if (fd >= 0)
536                 close(fd);
537         return -1;
538 }
539
540 int
541 rte_pci_ioport_map(struct rte_pci_device *dev, int bar,
542                 struct rte_pci_ioport *p)
543 {
544         int ret;
545
546         switch (dev->kdrv) {
547 #if defined(RTE_ARCH_X86)
548         case RTE_KDRV_NIC_UIO:
549                 if ((uintptr_t) dev->mem_resource[bar].addr <= UINT16_MAX) {
550                         p->base = (uintptr_t)dev->mem_resource[bar].addr;
551                         ret = 0;
552                 } else
553                         ret = -1;
554                 break;
555 #endif
556         default:
557                 ret = -1;
558                 break;
559         }
560
561         if (!ret)
562                 p->dev = dev;
563
564         return ret;
565 }
566
567 static void
568 pci_uio_ioport_read(struct rte_pci_ioport *p,
569                 void *data, size_t len, off_t offset)
570 {
571 #if defined(RTE_ARCH_X86)
572         uint8_t *d;
573         int size;
574         unsigned short reg = p->base + offset;
575
576         for (d = data; len > 0; d += size, reg += size, len -= size) {
577                 if (len >= 4) {
578                         size = 4;
579                         *(uint32_t *)d = inl(reg);
580                 } else if (len >= 2) {
581                         size = 2;
582                         *(uint16_t *)d = inw(reg);
583                 } else {
584                         size = 1;
585                         *d = inb(reg);
586                 }
587         }
588 #else
589         RTE_SET_USED(p);
590         RTE_SET_USED(data);
591         RTE_SET_USED(len);
592         RTE_SET_USED(offset);
593 #endif
594 }
595
596 void
597 rte_pci_ioport_read(struct rte_pci_ioport *p,
598                 void *data, size_t len, off_t offset)
599 {
600         switch (p->dev->kdrv) {
601         case RTE_KDRV_NIC_UIO:
602                 pci_uio_ioport_read(p, data, len, offset);
603                 break;
604         default:
605                 break;
606         }
607 }
608
609 static void
610 pci_uio_ioport_write(struct rte_pci_ioport *p,
611                 const void *data, size_t len, off_t offset)
612 {
613 #if defined(RTE_ARCH_X86)
614         const uint8_t *s;
615         int size;
616         unsigned short reg = p->base + offset;
617
618         for (s = data; len > 0; s += size, reg += size, len -= size) {
619                 if (len >= 4) {
620                         size = 4;
621                         outl(reg, *(const uint32_t *)s);
622                 } else if (len >= 2) {
623                         size = 2;
624                         outw(reg, *(const uint16_t *)s);
625                 } else {
626                         size = 1;
627                         outb(reg, *s);
628                 }
629         }
630 #else
631         RTE_SET_USED(p);
632         RTE_SET_USED(data);
633         RTE_SET_USED(len);
634         RTE_SET_USED(offset);
635 #endif
636 }
637
638 void
639 rte_pci_ioport_write(struct rte_pci_ioport *p,
640                 const void *data, size_t len, off_t offset)
641 {
642         switch (p->dev->kdrv) {
643         case RTE_KDRV_NIC_UIO:
644                 pci_uio_ioport_write(p, data, len, offset);
645                 break;
646         default:
647                 break;
648         }
649 }
650
651 int
652 rte_pci_ioport_unmap(struct rte_pci_ioport *p)
653 {
654         int ret;
655
656         switch (p->dev->kdrv) {
657 #if defined(RTE_ARCH_X86)
658         case RTE_KDRV_NIC_UIO:
659                 ret = 0;
660                 break;
661 #endif
662         default:
663                 ret = -1;
664                 break;
665         }
666
667         return ret;
668 }