lib/librte_pci/rte_pci.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation.
   3  * Copyright 2013-2014 6WIND S.A.
   4  */
   5
   6 #include <string.h>
   7 #include <inttypes.h>
   8 #include <stdint.h>
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <sys/queue.h>
  12 #include <sys/mman.h>
  13
  14 #include <rte_errno.h>
  15 #include <rte_interrupts.h>
  16 #include <rte_log.h>
  17 #include <rte_bus.h>
  18 #include <rte_per_lcore.h>
  19 #include <rte_memory.h>
  20 #include <rte_eal.h>
  21 #include <rte_string_fns.h>
  22 #include <rte_common.h>
  23
  24 #include "rte_pci.h"
  25
  26 static inline const char *
  27 get_u8_pciaddr_field(const char *in, void *_u8, char dlm)
  28 {
  29         unsigned long val;
  30         uint8_t *u8 = _u8;
  31         char *end;
  32
  33         errno = 0;
  34         val = strtoul(in, &end, 16);
  35         if (errno != 0 || end[0] != dlm || val > UINT8_MAX) {
  36                 errno = errno ? errno : EINVAL;
  37                 return NULL;
  38         }
  39         *u8 = (uint8_t)val;
  40         return end + 1;
  41 }
  42
  43 static int
  44 pci_bdf_parse(const char *input, struct rte_pci_addr *dev_addr)
  45 {
  46         const char *in = input;
  47
  48         dev_addr->domain = 0;
  49         in = get_u8_pciaddr_field(in, &dev_addr->bus, ':');
  50         if (in == NULL)
  51                 return -EINVAL;
  52         in = get_u8_pciaddr_field(in, &dev_addr->devid, '.');
  53         if (in == NULL)
  54                 return -EINVAL;
  55         in = get_u8_pciaddr_field(in, &dev_addr->function, '\0');
  56         if (in == NULL)
  57                 return -EINVAL;
  58         return 0;
  59 }
  60
  61 static int
  62 pci_dbdf_parse(const char *input, struct rte_pci_addr *dev_addr)
  63 {
  64         const char *in = input;
  65         unsigned long val;
  66         char *end;
  67
  68         errno = 0;
  69         val = strtoul(in, &end, 16);
  70         if (errno != 0 || end[0] != ':' || val > UINT16_MAX)
  71                 return -EINVAL;
  72         dev_addr->domain = (uint16_t)val;
  73         in = end + 1;
  74         in = get_u8_pciaddr_field(in, &dev_addr->bus, ':');
  75         if (in == NULL)
  76                 return -EINVAL;
  77         in = get_u8_pciaddr_field(in, &dev_addr->devid, '.');
  78         if (in == NULL)
  79                 return -EINVAL;
  80         in = get_u8_pciaddr_field(in, &dev_addr->function, '\0');
  81         if (in == NULL)
  82                 return -EINVAL;
  83         return 0;
  84 }
  85
  86 int
  87 eal_parse_pci_BDF(const char *input, struct rte_pci_addr *dev_addr)
  88 {
  89         return pci_bdf_parse(input, dev_addr);
  90 }
  91
  92 int
  93 eal_parse_pci_DomBDF(const char *input, struct rte_pci_addr *dev_addr)
  94 {
  95         return pci_dbdf_parse(input, dev_addr);
  96 }
  97
  98 void
  99 rte_pci_device_name(const struct rte_pci_addr *addr,
 100                 char *output, size_t size)
 101 {
 102         RTE_VERIFY(size >= PCI_PRI_STR_SIZE);
 103         RTE_VERIFY(snprintf(output, size, PCI_PRI_FMT,
 104                             addr->domain, addr->bus,
 105                             addr->devid, addr->function) >= 0);
 106 }
 107
 108 int
 109 rte_eal_compare_pci_addr(const struct rte_pci_addr *addr,
 110                          const struct rte_pci_addr *addr2)
 111 {
 112         return rte_pci_addr_cmp(addr, addr2);
 113 }
 114
 115 int
 116 rte_pci_addr_cmp(const struct rte_pci_addr *addr,
 117              const struct rte_pci_addr *addr2)
 118 {
 119         uint64_t dev_addr, dev_addr2;
 120
 121         if ((addr == NULL) || (addr2 == NULL))
 122                 return -1;
 123
 124         dev_addr = ((uint64_t)addr->domain << 24) |
 125                 (addr->bus << 16) | (addr->devid << 8) | addr->function;
 126         dev_addr2 = ((uint64_t)addr2->domain << 24) |
 127                 (addr2->bus << 16) | (addr2->devid << 8) | addr2->function;
 128
 129         if (dev_addr > dev_addr2)
 130                 return 1;
 131         else if (dev_addr < dev_addr2)
 132                 return -1;
 133         else
 134                 return 0;
 135 }
 136
 137 int
 138 rte_pci_addr_parse(const char *str, struct rte_pci_addr *addr)
 139 {
 140         if (pci_bdf_parse(str, addr) == 0 ||
 141             pci_dbdf_parse(str, addr) == 0)
 142                 return 0;
 143         return -1;
 144 }
 145
 146
 147 /* map a particular resource from a file */
 148 void *
 149 pci_map_resource(void *requested_addr, int fd, off_t offset, size_t size,
 150                  int additional_flags)
 151 {
 152         void *mapaddr;
 153
 154         /* Map the PCI memory resource of device */
 155         mapaddr = mmap(requested_addr, size, PROT_READ | PROT_WRITE,
 156                         MAP_SHARED | additional_flags, fd, offset);
 157         if (mapaddr == MAP_FAILED) {
 158                 RTE_LOG(ERR, EAL,
 159                         "%s(): cannot mmap(%d, %p, 0x%zx, 0x%llx): %s (%p)\n",
 160                         __func__, fd, requested_addr, size,
 161                         (unsigned long long)offset,
 162                         strerror(errno), mapaddr);
 163         } else
 164                 RTE_LOG(DEBUG, EAL, "  PCI memory mapped at %p\n", mapaddr);
 165
 166         return mapaddr;
 167 }
 168
 169 /* unmap a particular resource */
 170 void
 171 pci_unmap_resource(void *requested_addr, size_t size)
 172 {
 173         if (requested_addr == NULL)
 174                 return;
 175
 176         /* Unmap the PCI memory resource of device */
 177         if (munmap(requested_addr, size)) {
 178                 RTE_LOG(ERR, EAL, "%s(): cannot munmap(%p, %#zx): %s\n",
 179                         __func__, requested_addr, size,
 180                         strerror(errno));
 181         } else
 182                 RTE_LOG(DEBUG, EAL, "  PCI memory unmapped at %p\n",
 183                                 requested_addr);
 184 }