drivers/bus/pci/linux/pci_uio.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <unistd.h>
   7 #include <fcntl.h>
   8 #include <dirent.h>
   9 #include <inttypes.h>
  10 #include <sys/stat.h>
  11 #include <sys/mman.h>
  12 #include <sys/sysmacros.h>
  13 #include <linux/pci_regs.h>
  14
  15 #if defined(RTE_ARCH_X86)
  16 #include <sys/io.h>
  17 #endif
  18
  19 #include <rte_string_fns.h>
  20 #include <rte_log.h>
  21 #include <rte_pci.h>
  22 #include <rte_bus_pci.h>
  23 #include <rte_common.h>
  24 #include <rte_malloc.h>
  25
  26 #include "eal_filesystem.h"
  27 #include "pci_init.h"
  28 #include "private.h"
  29
  30 void *pci_map_addr = NULL;
  31
  32 #define OFF_MAX              ((uint64_t)(off_t)-1)
  33
  34 int
  35 pci_uio_read_config(const struct rte_intr_handle *intr_handle,
  36                     void *buf, size_t len, off_t offset)
  37 {
  38         int uio_cfg_fd = rte_intr_dev_fd_get(intr_handle);
  39
  40         return pread(uio_cfg_fd, buf, len, offset);
  41 }
  42
  43 int
  44 pci_uio_write_config(const struct rte_intr_handle *intr_handle,
  45                      const void *buf, size_t len, off_t offset)
  46 {
  47         int uio_cfg_fd = rte_intr_dev_fd_get(intr_handle);
  48
  49         return pwrite(uio_cfg_fd, buf, len, offset);
  50 }
  51
  52 static int
  53 pci_uio_set_bus_master(int dev_fd)
  54 {
  55         uint16_t reg;
  56         int ret;
  57
  58         ret = pread(dev_fd, &reg, sizeof(reg), PCI_COMMAND);
  59         if (ret != sizeof(reg)) {
  60                 RTE_LOG(ERR, EAL,
  61                         "Cannot read command from PCI config space!\n");
  62                 return -1;
  63         }
  64
  65         /* return if bus mastering is already on */
  66         if (reg & PCI_COMMAND_MASTER)
  67                 return 0;
  68
  69         reg |= PCI_COMMAND_MASTER;
  70
  71         ret = pwrite(dev_fd, &reg, sizeof(reg), PCI_COMMAND);
  72         if (ret != sizeof(reg)) {
  73                 RTE_LOG(ERR, EAL,
  74                         "Cannot write command to PCI config space!\n");
  75                 return -1;
  76         }
  77
  78         return 0;
  79 }
  80
  81 static int
  82 pci_mknod_uio_dev(const char *sysfs_uio_path, unsigned uio_num)
  83 {
  84         FILE *f;
  85         char filename[PATH_MAX];
  86         int ret;
  87         unsigned major, minor;
  88         dev_t dev;
  89
  90         /* get the name of the sysfs file that contains the major and minor
  91          * of the uio device and read its content */
  92         snprintf(filename, sizeof(filename), "%s/dev", sysfs_uio_path);
  93
  94         f = fopen(filename, "r");
  95         if (f == NULL) {
  96                 RTE_LOG(ERR, EAL, "%s(): cannot open sysfs to get major:minor\n",
  97                         __func__);
  98                 return -1;
  99         }
 100
 101         ret = fscanf(f, "%u:%u", &major, &minor);
 102         if (ret != 2) {
 103                 RTE_LOG(ERR, EAL, "%s(): cannot parse sysfs to get major:minor\n",
 104                         __func__);
 105                 fclose(f);
 106                 return -1;
 107         }
 108         fclose(f);
 109
 110         /* create the char device "mknod /dev/uioX c major minor" */
 111         snprintf(filename, sizeof(filename), "/dev/uio%u", uio_num);
 112         dev = makedev(major, minor);
 113         ret = mknod(filename, S_IFCHR | S_IRUSR | S_IWUSR, dev);
 114         if (ret != 0) {
 115                 RTE_LOG(ERR, EAL, "%s(): mknod() failed %s\n",
 116                         __func__, strerror(errno));
 117                 return -1;
 118         }
 119
 120         return ret;
 121 }
 122
 123 /*
 124  * Return the uioX char device used for a pci device. On success, return
 125  * the UIO number and fill dstbuf string with the path of the device in
 126  * sysfs. On error, return a negative value. In this case dstbuf is
 127  * invalid.
 128  */
 129 static int
 130 pci_get_uio_dev(struct rte_pci_device *dev, char *dstbuf,
 131                            unsigned int buflen, int create)
 132 {
 133         struct rte_pci_addr *loc = &dev->addr;
 134         int uio_num = -1;
 135         struct dirent *e;
 136         DIR *dir;
 137         char dirname[PATH_MAX];
 138
 139         /* depending on kernel version, uio can be located in uio/uioX
 140          * or uio:uioX */
 141
 142         snprintf(dirname, sizeof(dirname),
 143                         "%s/" PCI_PRI_FMT "/uio", rte_pci_get_sysfs_path(),
 144                         loc->domain, loc->bus, loc->devid, loc->function);
 145
 146         dir = opendir(dirname);
 147         if (dir == NULL) {
 148                 /* retry with the parent directory */
 149                 snprintf(dirname, sizeof(dirname),
 150                                 "%s/" PCI_PRI_FMT, rte_pci_get_sysfs_path(),
 151                                 loc->domain, loc->bus, loc->devid, loc->function);
 152                 dir = opendir(dirname);
 153
 154                 if (dir == NULL) {
 155                         RTE_LOG(ERR, EAL, "Cannot opendir %s\n", dirname);
 156                         return -1;
 157                 }
 158         }
 159
 160         /* take the first file starting with "uio" */
 161         while ((e = readdir(dir)) != NULL) {
 162                 /* format could be uio%d ...*/
 163                 int shortprefix_len = sizeof("uio") - 1;
 164                 /* ... or uio:uio%d */
 165                 int longprefix_len = sizeof("uio:uio") - 1;
 166                 char *endptr;
 167
 168                 if (strncmp(e->d_name, "uio", 3) != 0)
 169                         continue;
 170
 171                 /* first try uio%d */
 172                 errno = 0;
 173                 uio_num = strtoull(e->d_name + shortprefix_len, &endptr, 10);
 174                 if (errno == 0 && endptr != (e->d_name + shortprefix_len)) {
 175                         snprintf(dstbuf, buflen, "%s/uio%u", dirname, uio_num);
 176                         break;
 177                 }
 178
 179                 /* then try uio:uio%d */
 180                 errno = 0;
 181                 uio_num = strtoull(e->d_name + longprefix_len, &endptr, 10);
 182                 if (errno == 0 && endptr != (e->d_name + longprefix_len)) {
 183                         snprintf(dstbuf, buflen, "%s/uio:uio%u", dirname, uio_num);
 184                         break;
 185                 }
 186         }
 187         closedir(dir);
 188
 189         /* No uio resource found */
 190         if (e == NULL)
 191                 return -1;
 192
 193         /* create uio device if we've been asked to */
 194         if (rte_eal_create_uio_dev() && create &&
 195                         pci_mknod_uio_dev(dstbuf, uio_num) < 0)
 196                 RTE_LOG(WARNING, EAL, "Cannot create /dev/uio%u\n", uio_num);
 197
 198         return uio_num;
 199 }
 200
 201 void
 202 pci_uio_free_resource(struct rte_pci_device *dev,
 203                 struct mapped_pci_resource *uio_res)
 204 {
 205         int uio_cfg_fd = rte_intr_dev_fd_get(dev->intr_handle);
 206
 207         rte_free(uio_res);
 208
 209         if (uio_cfg_fd >= 0) {
 210                 close(uio_cfg_fd);
 211                 rte_intr_dev_fd_set(dev->intr_handle, -1);
 212         }
 213
 214         if (rte_intr_fd_get(dev->intr_handle) >= 0) {
 215                 close(rte_intr_fd_get(dev->intr_handle));
 216                 rte_intr_fd_set(dev->intr_handle, -1);
 217                 rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_UNKNOWN);
 218         }
 219 }
 220
 221 int
 222 pci_uio_alloc_resource(struct rte_pci_device *dev,
 223                 struct mapped_pci_resource **uio_res)
 224 {
 225         char dirname[PATH_MAX];
 226         char cfgname[PATH_MAX];
 227         char devname[PATH_MAX]; /* contains the /dev/uioX */
 228         int uio_num, fd, uio_cfg_fd;
 229         struct rte_pci_addr *loc;
 230
 231         loc = &dev->addr;
 232
 233         /* find uio resource */
 234         uio_num = pci_get_uio_dev(dev, dirname, sizeof(dirname), 1);
 235         if (uio_num < 0) {
 236                 RTE_LOG(WARNING, EAL, "  "PCI_PRI_FMT" not managed by UIO driver, "
 237                                 "skipping\n", loc->domain, loc->bus, loc->devid, loc->function);
 238                 return 1;
 239         }
 240         snprintf(devname, sizeof(devname), "/dev/uio%u", uio_num);
 241
 242         /* save fd if in primary process */
 243         fd = open(devname, O_RDWR);
 244         if (fd < 0) {
 245                 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
 246                         devname, strerror(errno));
 247                 goto error;
 248         }
 249
 250         if (rte_intr_fd_set(dev->intr_handle, fd))
 251                 goto error;
 252
 253         snprintf(cfgname, sizeof(cfgname),
 254                         "/sys/class/uio/uio%u/device/config", uio_num);
 255
 256         uio_cfg_fd = open(cfgname, O_RDWR);
 257         if (uio_cfg_fd < 0) {
 258                 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
 259                         cfgname, strerror(errno));
 260                 goto error;
 261         }
 262
 263         if (rte_intr_dev_fd_set(dev->intr_handle, uio_cfg_fd))
 264                 goto error;
 265
 266         if (dev->kdrv == RTE_PCI_KDRV_IGB_UIO) {
 267                 if (rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_UIO))
 268                         goto error;
 269         } else {
 270                 if (rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_UIO_INTX))
 271                         goto error;
 272
 273                 /* set bus master that is not done by uio_pci_generic */
 274                 if (pci_uio_set_bus_master(uio_cfg_fd)) {
 275                         RTE_LOG(ERR, EAL, "Cannot set up bus mastering!\n");
 276                         goto error;
 277                 }
 278         }
 279
 280         /* allocate the mapping details for secondary processes*/
 281         *uio_res = rte_zmalloc("UIO_RES", sizeof(**uio_res), 0);
 282         if (*uio_res == NULL) {
 283                 RTE_LOG(ERR, EAL,
 284                         "%s(): cannot store uio mmap details\n", __func__);
 285                 goto error;
 286         }
 287
 288         strlcpy((*uio_res)->path, devname, sizeof((*uio_res)->path));
 289         memcpy(&(*uio_res)->pci_addr, &dev->addr, sizeof((*uio_res)->pci_addr));
 290
 291         return 0;
 292
 293 error:
 294         pci_uio_free_resource(dev, *uio_res);
 295         return -1;
 296 }
 297
 298 int
 299 pci_uio_map_resource_by_index(struct rte_pci_device *dev, int res_idx,
 300                 struct mapped_pci_resource *uio_res, int map_idx)
 301 {
 302         int fd = -1;
 303         char devname[PATH_MAX];
 304         void *mapaddr;
 305         struct rte_pci_addr *loc;
 306         struct pci_map *maps;
 307         int wc_activate = 0;
 308
 309         if (dev->driver != NULL)
 310                 wc_activate = dev->driver->drv_flags & RTE_PCI_DRV_WC_ACTIVATE;
 311
 312         loc = &dev->addr;
 313         maps = uio_res->maps;
 314
 315         /* allocate memory to keep path */
 316         maps[map_idx].path = rte_malloc(NULL, sizeof(devname), 0);
 317         if (maps[map_idx].path == NULL) {
 318                 RTE_LOG(ERR, EAL, "Cannot allocate memory for path: %s\n",
 319                                 strerror(errno));
 320                 return -1;
 321         }
 322
 323         /*
 324          * open resource file, to mmap it
 325          */
 326         if (wc_activate) {
 327                 /* update devname for mmap  */
 328                 snprintf(devname, sizeof(devname),
 329                         "%s/" PCI_PRI_FMT "/resource%d_wc",
 330                         rte_pci_get_sysfs_path(),
 331                         loc->domain, loc->bus, loc->devid,
 332                         loc->function, res_idx);
 333
 334                 fd = open(devname, O_RDWR);
 335                 if (fd < 0 && errno != ENOENT) {
 336                         RTE_LOG(INFO, EAL, "%s cannot be mapped. "
 337                                 "Fall-back to non prefetchable mode.\n",
 338                                 devname);
 339                 }
 340         }
 341
 342         if (!wc_activate || fd < 0) {
 343                 snprintf(devname, sizeof(devname),
 344                         "%s/" PCI_PRI_FMT "/resource%d",
 345                         rte_pci_get_sysfs_path(),
 346                         loc->domain, loc->bus, loc->devid,
 347                         loc->function, res_idx);
 348
 349                 /* then try to map resource file */
 350                 fd = open(devname, O_RDWR);
 351                 if (fd < 0) {
 352                         RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
 353                                 devname, strerror(errno));
 354                         goto error;
 355                 }
 356         }
 357
 358         /* try mapping somewhere close to the end of hugepages */
 359         if (pci_map_addr == NULL)
 360                 pci_map_addr = pci_find_max_end_va();
 361
 362         mapaddr = pci_map_resource(pci_map_addr, fd, 0,
 363                         (size_t)dev->mem_resource[res_idx].len, 0);
 364         close(fd);
 365         if (mapaddr == NULL)
 366                 goto error;
 367
 368         pci_map_addr = RTE_PTR_ADD(mapaddr,
 369                         (size_t)dev->mem_resource[res_idx].len);
 370
 371         pci_map_addr = RTE_PTR_ALIGN(pci_map_addr, sysconf(_SC_PAGE_SIZE));
 372
 373         maps[map_idx].phaddr = dev->mem_resource[res_idx].phys_addr;
 374         maps[map_idx].size = dev->mem_resource[res_idx].len;
 375         maps[map_idx].addr = mapaddr;
 376         maps[map_idx].offset = 0;
 377         strcpy(maps[map_idx].path, devname);
 378         dev->mem_resource[res_idx].addr = mapaddr;
 379
 380         return 0;
 381
 382 error:
 383         rte_free(maps[map_idx].path);
 384         return -1;
 385 }
 386
 387 #define PIO_MAX 0x10000
 388
 389 #if defined(RTE_ARCH_X86)
 390 int
 391 pci_uio_ioport_map(struct rte_pci_device *dev, int bar,
 392                    struct rte_pci_ioport *p)
 393 {
 394         FILE *f = NULL;
 395         char dirname[PATH_MAX];
 396         char filename[PATH_MAX];
 397         char buf[BUFSIZ];
 398         uint64_t phys_addr, end_addr, flags;
 399         unsigned long base;
 400         int i, fd;
 401
 402         /* open and read addresses of the corresponding resource in sysfs */
 403         snprintf(filename, sizeof(filename), "%s/" PCI_PRI_FMT "/resource",
 404                 rte_pci_get_sysfs_path(), dev->addr.domain, dev->addr.bus,
 405                 dev->addr.devid, dev->addr.function);
 406         f = fopen(filename, "r");
 407         if (f == NULL) {
 408                 RTE_LOG(ERR, EAL, "%s(): Cannot open sysfs resource: %s\n",
 409                         __func__, strerror(errno));
 410                 return -1;
 411         }
 412
 413         for (i = 0; i < bar + 1; i++) {
 414                 if (fgets(buf, sizeof(buf), f) == NULL) {
 415                         RTE_LOG(ERR, EAL, "%s(): Cannot read sysfs resource\n", __func__);
 416                         goto error;
 417                 }
 418         }
 419         if (pci_parse_one_sysfs_resource(buf, sizeof(buf), &phys_addr,
 420                 &end_addr, &flags) < 0)
 421                 goto error;
 422
 423         if (flags & IORESOURCE_IO) {
 424                 if (rte_eal_iopl_init()) {
 425                         RTE_LOG(ERR, EAL, "%s(): insufficient ioport permissions for PCI device %s\n",
 426                                 __func__, dev->name);
 427                         goto error;
 428                 }
 429
 430                 base = (unsigned long)phys_addr;
 431                 if (base > PIO_MAX) {
 432                         RTE_LOG(ERR, EAL, "%s(): %08lx too large PIO resource\n", __func__, base);
 433                         goto error;
 434                 }
 435
 436                 RTE_LOG(DEBUG, EAL, "%s(): PIO BAR %08lx detected\n", __func__, base);
 437         } else if (flags & IORESOURCE_MEM) {
 438                 base = (unsigned long)dev->mem_resource[bar].addr;
 439                 RTE_LOG(DEBUG, EAL, "%s(): MMIO BAR %08lx detected\n", __func__, base);
 440         } else {
 441                 RTE_LOG(ERR, EAL, "%s(): unknown BAR type\n", __func__);
 442                 goto error;
 443         }
 444
 445         /* FIXME only for primary process ? */
 446         if (rte_intr_type_get(dev->intr_handle) ==
 447                                         RTE_INTR_HANDLE_UNKNOWN) {
 448                 int uio_num = pci_get_uio_dev(dev, dirname, sizeof(dirname), 0);
 449                 if (uio_num < 0) {
 450                         RTE_LOG(ERR, EAL, "cannot open %s: %s\n",
 451                                 dirname, strerror(errno));
 452                         goto error;
 453                 }
 454
 455                 snprintf(filename, sizeof(filename), "/dev/uio%u", uio_num);
 456                 fd = open(filename, O_RDWR);
 457                 if (fd < 0) {
 458                         RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
 459                                 filename, strerror(errno));
 460                         goto error;
 461                 }
 462                 if (rte_intr_fd_set(dev->intr_handle, fd))
 463                         goto error;
 464
 465                 if (rte_intr_type_set(dev->intr_handle, RTE_INTR_HANDLE_UIO))
 466                         goto error;
 467         }
 468
 469         RTE_LOG(DEBUG, EAL, "PCI Port IO found start=0x%lx\n", base);
 470
 471         p->base = base;
 472         p->len = 0;
 473         fclose(f);
 474         return 0;
 475 error:
 476         if (f)
 477                 fclose(f);
 478         return -1;
 479 }
 480 #else
 481 int
 482 pci_uio_ioport_map(struct rte_pci_device *dev, int bar,
 483                    struct rte_pci_ioport *p)
 484 {
 485         FILE *f;
 486         char buf[BUFSIZ];
 487         char filename[PATH_MAX];
 488         uint64_t phys_addr, end_addr, flags;
 489         int fd, i;
 490         void *addr;
 491
 492         /* open and read addresses of the corresponding resource in sysfs */
 493         snprintf(filename, sizeof(filename), "%s/" PCI_PRI_FMT "/resource",
 494                 rte_pci_get_sysfs_path(), dev->addr.domain, dev->addr.bus,
 495                 dev->addr.devid, dev->addr.function);
 496         f = fopen(filename, "r");
 497         if (f == NULL) {
 498                 RTE_LOG(ERR, EAL, "Cannot open sysfs resource: %s\n",
 499                         strerror(errno));
 500                 return -1;
 501         }
 502         for (i = 0; i < bar + 1; i++) {
 503                 if (fgets(buf, sizeof(buf), f) == NULL) {
 504                         RTE_LOG(ERR, EAL, "Cannot read sysfs resource\n");
 505                         goto error;
 506                 }
 507         }
 508         if (pci_parse_one_sysfs_resource(buf, sizeof(buf), &phys_addr,
 509                         &end_addr, &flags) < 0)
 510                 goto error;
 511         if ((flags & IORESOURCE_IO) == 0) {
 512                 RTE_LOG(ERR, EAL, "BAR %d is not an IO resource\n", bar);
 513                 goto error;
 514         }
 515         snprintf(filename, sizeof(filename), "%s/" PCI_PRI_FMT "/resource%d",
 516                 rte_pci_get_sysfs_path(), dev->addr.domain, dev->addr.bus,
 517                 dev->addr.devid, dev->addr.function, bar);
 518
 519         /* mmap the pci resource */
 520         fd = open(filename, O_RDWR);
 521         if (fd < 0) {
 522                 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n", filename,
 523                         strerror(errno));
 524                 goto error;
 525         }
 526         addr = mmap(NULL, end_addr + 1, PROT_READ | PROT_WRITE,
 527                 MAP_SHARED, fd, 0);
 528         close(fd);
 529         if (addr == MAP_FAILED) {
 530                 RTE_LOG(ERR, EAL, "Cannot mmap IO port resource: %s\n",
 531                         strerror(errno));
 532                 goto error;
 533         }
 534
 535         /* strangely, the base address is mmap addr + phys_addr */
 536         p->base = (uintptr_t)addr + phys_addr;
 537         p->len = end_addr + 1;
 538         RTE_LOG(DEBUG, EAL, "PCI Port IO found start=0x%"PRIx64"\n", p->base);
 539         fclose(f);
 540
 541         return 0;
 542
 543 error:
 544         fclose(f);
 545         return -1;
 546 }
 547 #endif
 548
 549 #if defined(RTE_ARCH_X86)
 550
 551 static inline uint8_t ioread8(void *addr)
 552 {
 553         uint8_t val;
 554
 555         val = (uint64_t)(uintptr_t)addr >= PIO_MAX ?
 556                 *(volatile uint8_t *)addr :
 557 #ifdef __GLIBC__
 558                 inb_p((unsigned long)addr);
 559 #else
 560                 inb((unsigned long)addr);
 561 #endif
 562
 563         return val;
 564 }
 565
 566 static inline uint16_t ioread16(void *addr)
 567 {
 568         uint16_t val;
 569
 570         val = (uint64_t)(uintptr_t)addr >= PIO_MAX ?
 571                 *(volatile uint16_t *)addr :
 572 #ifdef __GLIBC__
 573                 inw_p((unsigned long)addr);
 574 #else
 575                 inw((unsigned long)addr);
 576 #endif
 577
 578         return val;
 579 }
 580
 581 static inline uint32_t ioread32(void *addr)
 582 {
 583         uint32_t val;
 584
 585         val = (uint64_t)(uintptr_t)addr >= PIO_MAX ?
 586                 *(volatile uint32_t *)addr :
 587 #ifdef __GLIBC__
 588                 inl_p((unsigned long)addr);
 589 #else
 590                 inl((unsigned long)addr);
 591 #endif
 592
 593         return val;
 594 }
 595
 596 static inline void iowrite8(uint8_t val, void *addr)
 597 {
 598         (uint64_t)(uintptr_t)addr >= PIO_MAX ?
 599                 *(volatile uint8_t *)addr = val :
 600 #ifdef __GLIBC__
 601                 outb_p(val, (unsigned long)addr);
 602 #else
 603                 outb(val, (unsigned long)addr);
 604 #endif
 605 }
 606
 607 static inline void iowrite16(uint16_t val, void *addr)
 608 {
 609         (uint64_t)(uintptr_t)addr >= PIO_MAX ?
 610                 *(volatile uint16_t *)addr = val :
 611 #ifdef __GLIBC__
 612                 outw_p(val, (unsigned long)addr);
 613 #else
 614                 outw(val, (unsigned long)addr);
 615 #endif
 616 }
 617
 618 static inline void iowrite32(uint32_t val, void *addr)
 619 {
 620         (uint64_t)(uintptr_t)addr >= PIO_MAX ?
 621                 *(volatile uint32_t *)addr = val :
 622 #ifdef __GLIBC__
 623                 outl_p(val, (unsigned long)addr);
 624 #else
 625                 outl(val, (unsigned long)addr);
 626 #endif
 627 }
 628
 629 #else /* !RTE_ARCH_X86 */
 630
 631 static inline uint8_t ioread8(void *addr)
 632 {
 633         return *(volatile uint8_t *)addr;
 634 }
 635
 636 static inline uint16_t ioread16(void *addr)
 637 {
 638         return *(volatile uint16_t *)addr;
 639 }
 640
 641 static inline uint32_t ioread32(void *addr)
 642 {
 643         return *(volatile uint32_t *)addr;
 644 }
 645
 646 static inline void iowrite8(uint8_t val, void *addr)
 647 {
 648         *(volatile uint8_t *)addr = val;
 649 }
 650
 651 static inline void iowrite16(uint16_t val, void *addr)
 652 {
 653         *(volatile uint16_t *)addr = val;
 654 }
 655
 656 static inline void iowrite32(uint32_t val, void *addr)
 657 {
 658         *(volatile uint32_t *)addr = val;
 659 }
 660
 661 #endif /* !RTE_ARCH_X86 */
 662
 663 void
 664 pci_uio_ioport_read(struct rte_pci_ioport *p,
 665                     void *data, size_t len, off_t offset)
 666 {
 667         uint8_t *d;
 668         int size;
 669         uintptr_t reg = p->base + offset;
 670
 671         for (d = data; len > 0; d += size, reg += size, len -= size) {
 672                 if (len >= 4) {
 673                         size = 4;
 674                         *(uint32_t *)d = ioread32((void *)reg);
 675                 } else if (len >= 2) {
 676                         size = 2;
 677                         *(uint16_t *)d = ioread16((void *)reg);
 678                 } else {
 679                         size = 1;
 680                         *d = ioread8((void *)reg);
 681                 }
 682         }
 683 }
 684
 685 void
 686 pci_uio_ioport_write(struct rte_pci_ioport *p,
 687                      const void *data, size_t len, off_t offset)
 688 {
 689         const uint8_t *s;
 690         int size;
 691         uintptr_t reg = p->base + offset;
 692
 693         for (s = data; len > 0; s += size, reg += size, len -= size) {
 694                 if (len >= 4) {
 695                         size = 4;
 696                         iowrite32(*(const uint32_t *)s, (void *)reg);
 697                 } else if (len >= 2) {
 698                         size = 2;
 699                         iowrite16(*(const uint16_t *)s, (void *)reg);
 700                 } else {
 701                         size = 1;
 702                         iowrite8(*s, (void *)reg);
 703                 }
 704         }
 705 }
 706
 707 int
 708 pci_uio_ioport_unmap(struct rte_pci_ioport *p)
 709 {
 710 #if defined(RTE_ARCH_X86)
 711         RTE_SET_USED(p);
 712         /* FIXME close intr fd ? */
 713         return 0;
 714 #else
 715         return munmap((void *)(uintptr_t)p->base, p->len);
 716 #endif
 717 }