1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2017 6WIND S.A. 3 */ 4 5 #ifndef _PCI_PRIVATE_H_ 6 #define _PCI_PRIVATE_H_ 7 8 #include <stdbool.h> 9 #include <stdio.h> 10 11 #include <rte_bus_pci.h> 12 #include <rte_os_shim.h> 13 #include <rte_pci.h> 14 15 extern struct rte_pci_bus rte_pci_bus; 16 17 struct rte_pci_driver; 18 struct rte_pci_device; 19 20 /** 21 * Scan the content of the PCI bus, and the devices in the devices 22 * list 23 * 24 * @return 25 * 0 on success, negative on error 26 */ 27 int rte_pci_scan(void); 28 29 /** 30 * Find the name of a PCI device. 31 */ 32 void 33 pci_name_set(struct rte_pci_device *dev); 34 35 /** 36 * Validate whether a device with given PCI address should be ignored or not. 37 * 38 * @param pci_addr 39 * PCI address of device to be validated 40 * @return 41 * true: if device is to be ignored, 42 * false: if device is to be scanned, 43 */ 44 bool rte_pci_ignore_device(const struct rte_pci_addr *pci_addr); 45 46 /** 47 * Add a PCI device to the PCI Bus (append to PCI Device list). This function 48 * also updates the bus references of the PCI Device (and the generic device 49 * object embedded within. 50 * 51 * @param pci_dev 52 * PCI device to add 53 * @return void 54 */ 55 void rte_pci_add_device(struct rte_pci_device *pci_dev); 56 57 /** 58 * Insert a PCI device in the PCI Bus at a particular location in the device 59 * list. It also updates the PCI Bus reference of the new devices to be 60 * inserted. 61 * 62 * @param exist_pci_dev 63 * Existing PCI device in PCI Bus 64 * @param new_pci_dev 65 * PCI device to be added before exist_pci_dev 66 * @return void 67 */ 68 void rte_pci_insert_device(struct rte_pci_device *exist_pci_dev, 69 struct rte_pci_device *new_pci_dev); 70 71 /** 72 * A structure describing a PCI mapping. 73 */ 74 struct pci_map { 75 void *addr; 76 char *path; 77 uint64_t offset; 78 uint64_t size; 79 uint64_t phaddr; 80 }; 81 82 struct pci_msix_table { 83 int bar_index; 84 uint32_t offset; 85 uint32_t size; 86 }; 87 88 /** 89 * A structure describing a mapped PCI resource. 90 * For multi-process we need to reproduce all PCI mappings in secondary 91 * processes, so save them in a tailq. 92 */ 93 struct mapped_pci_resource { 94 TAILQ_ENTRY(mapped_pci_resource) next; 95 96 struct rte_pci_addr pci_addr; 97 char path[PATH_MAX]; 98 int nb_maps; 99 struct pci_map maps[PCI_MAX_RESOURCE]; 100 struct pci_msix_table msix_table; 101 }; 102 103 /** mapped pci device list */ 104 TAILQ_HEAD(mapped_pci_res_list, mapped_pci_resource); 105 106 /** 107 * Map a particular resource from a file. 108 * 109 * @param requested_addr 110 * The starting address for the new mapping range. 111 * @param fd 112 * The file descriptor. 113 * @param offset 114 * The offset for the mapping range. 115 * @param size 116 * The size for the mapping range. 117 * @param additional_flags 118 * The additional rte_mem_map() flags for the mapping range. 119 * @return 120 * - On success, the function returns a pointer to the mapped area. 121 * - On error, NULL is returned. 122 */ 123 void *pci_map_resource(void *requested_addr, int fd, off_t offset, 124 size_t size, int additional_flags); 125 126 /** 127 * Unmap a particular resource. 128 * 129 * @param requested_addr 130 * The address for the unmapping range. 131 * @param size 132 * The size for the unmapping range. 133 */ 134 void pci_unmap_resource(void *requested_addr, size_t size); 135 136 /** 137 * Map the PCI resource of a PCI device in virtual memory 138 * 139 * This function is private to EAL. 140 * 141 * @return 142 * 0 on success, negative on error 143 */ 144 int pci_uio_map_resource(struct rte_pci_device *dev); 145 146 /** 147 * Unmap the PCI resource of a PCI device 148 * 149 * This function is private to EAL. 150 */ 151 void pci_uio_unmap_resource(struct rte_pci_device *dev); 152 153 /** 154 * Allocate uio resource for PCI device 155 * 156 * This function is private to EAL. 157 * 158 * @param dev 159 * PCI device to allocate uio resource 160 * @param uio_res 161 * Pointer to uio resource. 162 * If the function returns 0, the pointer will be filled. 163 * @return 164 * 0 on success, negative on error 165 */ 166 int pci_uio_alloc_resource(struct rte_pci_device *dev, 167 struct mapped_pci_resource **uio_res); 168 169 /** 170 * Free uio resource for PCI device 171 * 172 * This function is private to EAL. 173 * 174 * @param dev 175 * PCI device to free uio resource 176 * @param uio_res 177 * Pointer to uio resource. 178 */ 179 void pci_uio_free_resource(struct rte_pci_device *dev, 180 struct mapped_pci_resource *uio_res); 181 182 /** 183 * Remap the PCI resource of a PCI device in anonymous virtual memory. 184 * 185 * @param dev 186 * Point to the struct rte pci device. 187 * @return 188 * - On success, zero. 189 * - On failure, a negative value. 190 */ 191 int 192 pci_uio_remap_resource(struct rte_pci_device *dev); 193 194 /** 195 * Map device memory to uio resource 196 * 197 * This function is private to EAL. 198 * 199 * @param dev 200 * PCI device that has memory information. 201 * @param res_idx 202 * Memory resource index of the PCI device. 203 * @param uio_res 204 * uio resource that will keep mapping information. 205 * @param map_idx 206 * Mapping information index of the uio resource. 207 * @return 208 * 0 on success, negative on error 209 */ 210 int pci_uio_map_resource_by_index(struct rte_pci_device *dev, int res_idx, 211 struct mapped_pci_resource *uio_res, int map_idx); 212 213 /* 214 * Match the PCI Driver and Device using the ID Table 215 * 216 * @param pci_drv 217 * PCI driver from which ID table would be extracted 218 * @param pci_dev 219 * PCI device to match against the driver 220 * @return 221 * 1 for successful match 222 * 0 for unsuccessful match 223 */ 224 int 225 rte_pci_match(const struct rte_pci_driver *pci_drv, 226 const struct rte_pci_device *pci_dev); 227 228 /** 229 * OS specific callbacks for rte_pci_get_iommu_class 230 * 231 */ 232 bool 233 pci_device_iommu_support_va(const struct rte_pci_device *dev); 234 235 enum rte_iova_mode 236 pci_device_iova_mode(const struct rte_pci_driver *pci_drv, 237 const struct rte_pci_device *pci_dev); 238 239 /** 240 * Get iommu class of PCI devices on the bus. 241 * And return their preferred iova mapping mode. 242 * 243 * @return 244 * - enum rte_iova_mode. 245 */ 246 enum rte_iova_mode 247 rte_pci_get_iommu_class(void); 248 249 /* 250 * Iterate over internal devices, 251 * matching any device against the provided 252 * string. 253 * 254 * @param start 255 * Iteration starting point. 256 * 257 * @param str 258 * Device string to match against. 259 * 260 * @param it 261 * (unused) iterator structure. 262 * 263 * @return 264 * A pointer to the next matching device if any. 265 * NULL otherwise. 266 */ 267 void * 268 rte_pci_dev_iterate(const void *start, 269 const char *str, 270 const struct rte_dev_iterator *it); 271 272 /* 273 * Parse device arguments and update name. 274 * 275 * @param da 276 * device arguments to parse. 277 * 278 * @return 279 * 0 on success. 280 * -EINVAL: kvargs string is invalid and cannot be parsed. 281 * -ENODEV: no key matching a device ID is found in the kv list. 282 */ 283 int 284 rte_pci_devargs_parse(struct rte_devargs *da); 285 286 #endif /* _PCI_PRIVATE_H_ */ 287