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