1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Virtual I/O topology 4 * 5 * The Virtual I/O Translation Table (VIOT) describes the topology of 6 * para-virtual IOMMUs and the endpoints they manage. The OS uses it to 7 * initialize devices in the right order, preventing endpoints from issuing DMA 8 * before their IOMMU is ready. 9 * 10 * When binding a driver to a device, before calling the device driver's probe() 11 * method, the driver infrastructure calls dma_configure(). At that point the 12 * VIOT driver looks for an IOMMU associated to the device in the VIOT table. 13 * If an IOMMU exists and has been initialized, the VIOT driver initializes the 14 * device's IOMMU fwspec, allowing the DMA infrastructure to invoke the IOMMU 15 * ops when the device driver configures DMA mappings. If an IOMMU exists and 16 * hasn't yet been initialized, VIOT returns -EPROBE_DEFER to postpone probing 17 * the device until the IOMMU is available. 18 */ 19 #define pr_fmt(fmt) "ACPI: VIOT: " fmt 20 21 #include <linux/acpi_viot.h> 22 #include <linux/dma-iommu.h> 23 #include <linux/fwnode.h> 24 #include <linux/iommu.h> 25 #include <linux/list.h> 26 #include <linux/pci.h> 27 #include <linux/platform_device.h> 28 29 struct viot_iommu { 30 /* Node offset within the table */ 31 unsigned int offset; 32 struct fwnode_handle *fwnode; 33 struct list_head list; 34 }; 35 36 struct viot_endpoint { 37 union { 38 /* PCI range */ 39 struct { 40 u16 segment_start; 41 u16 segment_end; 42 u16 bdf_start; 43 u16 bdf_end; 44 }; 45 /* MMIO */ 46 u64 address; 47 }; 48 u32 endpoint_id; 49 struct viot_iommu *viommu; 50 struct list_head list; 51 }; 52 53 static struct acpi_table_viot *viot; 54 static LIST_HEAD(viot_iommus); 55 static LIST_HEAD(viot_pci_ranges); 56 static LIST_HEAD(viot_mmio_endpoints); 57 58 static int __init viot_check_bounds(const struct acpi_viot_header *hdr) 59 { 60 struct acpi_viot_header *start, *end, *hdr_end; 61 62 start = ACPI_ADD_PTR(struct acpi_viot_header, viot, 63 max_t(size_t, sizeof(*viot), viot->node_offset)); 64 end = ACPI_ADD_PTR(struct acpi_viot_header, viot, viot->header.length); 65 hdr_end = ACPI_ADD_PTR(struct acpi_viot_header, hdr, sizeof(*hdr)); 66 67 if (hdr < start || hdr_end > end) { 68 pr_err(FW_BUG "Node pointer overflows\n"); 69 return -EOVERFLOW; 70 } 71 if (hdr->length < sizeof(*hdr)) { 72 pr_err(FW_BUG "Empty node\n"); 73 return -EINVAL; 74 } 75 return 0; 76 } 77 78 static int __init viot_get_pci_iommu_fwnode(struct viot_iommu *viommu, 79 u16 segment, u16 bdf) 80 { 81 struct pci_dev *pdev; 82 struct fwnode_handle *fwnode; 83 84 pdev = pci_get_domain_bus_and_slot(segment, PCI_BUS_NUM(bdf), 85 bdf & 0xff); 86 if (!pdev) { 87 pr_err("Could not find PCI IOMMU\n"); 88 return -ENODEV; 89 } 90 91 fwnode = pdev->dev.fwnode; 92 if (!fwnode) { 93 /* 94 * PCI devices aren't necessarily described by ACPI. Create a 95 * fwnode so the IOMMU subsystem can identify this device. 96 */ 97 fwnode = acpi_alloc_fwnode_static(); 98 if (!fwnode) { 99 pci_dev_put(pdev); 100 return -ENOMEM; 101 } 102 set_primary_fwnode(&pdev->dev, fwnode); 103 } 104 viommu->fwnode = pdev->dev.fwnode; 105 pci_dev_put(pdev); 106 return 0; 107 } 108 109 static int __init viot_get_mmio_iommu_fwnode(struct viot_iommu *viommu, 110 u64 address) 111 { 112 struct acpi_device *adev; 113 struct resource res = { 114 .start = address, 115 .end = address, 116 .flags = IORESOURCE_MEM, 117 }; 118 119 adev = acpi_resource_consumer(&res); 120 if (!adev) { 121 pr_err("Could not find MMIO IOMMU\n"); 122 return -EINVAL; 123 } 124 viommu->fwnode = &adev->fwnode; 125 return 0; 126 } 127 128 static struct viot_iommu * __init viot_get_iommu(unsigned int offset) 129 { 130 int ret; 131 struct viot_iommu *viommu; 132 struct acpi_viot_header *hdr = ACPI_ADD_PTR(struct acpi_viot_header, 133 viot, offset); 134 union { 135 struct acpi_viot_virtio_iommu_pci pci; 136 struct acpi_viot_virtio_iommu_mmio mmio; 137 } *node = (void *)hdr; 138 139 list_for_each_entry(viommu, &viot_iommus, list) 140 if (viommu->offset == offset) 141 return viommu; 142 143 if (viot_check_bounds(hdr)) 144 return NULL; 145 146 viommu = kzalloc(sizeof(*viommu), GFP_KERNEL); 147 if (!viommu) 148 return NULL; 149 150 viommu->offset = offset; 151 switch (hdr->type) { 152 case ACPI_VIOT_NODE_VIRTIO_IOMMU_PCI: 153 if (hdr->length < sizeof(node->pci)) 154 goto err_free; 155 156 ret = viot_get_pci_iommu_fwnode(viommu, node->pci.segment, 157 node->pci.bdf); 158 break; 159 case ACPI_VIOT_NODE_VIRTIO_IOMMU_MMIO: 160 if (hdr->length < sizeof(node->mmio)) 161 goto err_free; 162 163 ret = viot_get_mmio_iommu_fwnode(viommu, 164 node->mmio.base_address); 165 break; 166 default: 167 ret = -EINVAL; 168 } 169 if (ret) 170 goto err_free; 171 172 list_add(&viommu->list, &viot_iommus); 173 return viommu; 174 175 err_free: 176 kfree(viommu); 177 return NULL; 178 } 179 180 static int __init viot_parse_node(const struct acpi_viot_header *hdr) 181 { 182 int ret = -EINVAL; 183 struct list_head *list; 184 struct viot_endpoint *ep; 185 union { 186 struct acpi_viot_mmio mmio; 187 struct acpi_viot_pci_range pci; 188 } *node = (void *)hdr; 189 190 if (viot_check_bounds(hdr)) 191 return -EINVAL; 192 193 if (hdr->type == ACPI_VIOT_NODE_VIRTIO_IOMMU_PCI || 194 hdr->type == ACPI_VIOT_NODE_VIRTIO_IOMMU_MMIO) 195 return 0; 196 197 ep = kzalloc(sizeof(*ep), GFP_KERNEL); 198 if (!ep) 199 return -ENOMEM; 200 201 switch (hdr->type) { 202 case ACPI_VIOT_NODE_PCI_RANGE: 203 if (hdr->length < sizeof(node->pci)) { 204 pr_err(FW_BUG "Invalid PCI node size\n"); 205 goto err_free; 206 } 207 208 ep->segment_start = node->pci.segment_start; 209 ep->segment_end = node->pci.segment_end; 210 ep->bdf_start = node->pci.bdf_start; 211 ep->bdf_end = node->pci.bdf_end; 212 ep->endpoint_id = node->pci.endpoint_start; 213 ep->viommu = viot_get_iommu(node->pci.output_node); 214 list = &viot_pci_ranges; 215 break; 216 case ACPI_VIOT_NODE_MMIO: 217 if (hdr->length < sizeof(node->mmio)) { 218 pr_err(FW_BUG "Invalid MMIO node size\n"); 219 goto err_free; 220 } 221 222 ep->address = node->mmio.base_address; 223 ep->endpoint_id = node->mmio.endpoint; 224 ep->viommu = viot_get_iommu(node->mmio.output_node); 225 list = &viot_mmio_endpoints; 226 break; 227 default: 228 pr_warn("Unsupported node %x\n", hdr->type); 229 ret = 0; 230 goto err_free; 231 } 232 233 if (!ep->viommu) { 234 pr_warn("No IOMMU node found\n"); 235 /* 236 * A future version of the table may use the node for other 237 * purposes. Keep parsing. 238 */ 239 ret = 0; 240 goto err_free; 241 } 242 243 list_add(&ep->list, list); 244 return 0; 245 246 err_free: 247 kfree(ep); 248 return ret; 249 } 250 251 /** 252 * acpi_viot_init - Parse the VIOT table 253 * 254 * Parse the VIOT table, prepare the list of endpoints to be used during DMA 255 * setup of devices. 256 */ 257 void __init acpi_viot_init(void) 258 { 259 int i; 260 acpi_status status; 261 struct acpi_table_header *hdr; 262 struct acpi_viot_header *node; 263 264 status = acpi_get_table(ACPI_SIG_VIOT, 0, &hdr); 265 if (ACPI_FAILURE(status)) { 266 if (status != AE_NOT_FOUND) { 267 const char *msg = acpi_format_exception(status); 268 269 pr_err("Failed to get table, %s\n", msg); 270 } 271 return; 272 } 273 274 viot = (void *)hdr; 275 276 node = ACPI_ADD_PTR(struct acpi_viot_header, viot, viot->node_offset); 277 for (i = 0; i < viot->node_count; i++) { 278 if (viot_parse_node(node)) 279 return; 280 281 node = ACPI_ADD_PTR(struct acpi_viot_header, node, 282 node->length); 283 } 284 285 acpi_put_table(hdr); 286 } 287 288 static int viot_dev_iommu_init(struct device *dev, struct viot_iommu *viommu, 289 u32 epid) 290 { 291 const struct iommu_ops *ops; 292 293 if (!viommu) 294 return -ENODEV; 295 296 /* We're not translating ourself */ 297 if (viommu->fwnode == dev->fwnode) 298 return -EINVAL; 299 300 ops = iommu_ops_from_fwnode(viommu->fwnode); 301 if (!ops) 302 return IS_ENABLED(CONFIG_VIRTIO_IOMMU) ? 303 -EPROBE_DEFER : -ENODEV; 304 305 return acpi_iommu_fwspec_init(dev, epid, viommu->fwnode, ops); 306 } 307 308 static int viot_pci_dev_iommu_init(struct pci_dev *pdev, u16 dev_id, void *data) 309 { 310 u32 epid; 311 struct viot_endpoint *ep; 312 u32 domain_nr = pci_domain_nr(pdev->bus); 313 314 list_for_each_entry(ep, &viot_pci_ranges, list) { 315 if (domain_nr >= ep->segment_start && 316 domain_nr <= ep->segment_end && 317 dev_id >= ep->bdf_start && 318 dev_id <= ep->bdf_end) { 319 epid = ((domain_nr - ep->segment_start) << 16) + 320 dev_id - ep->bdf_start + ep->endpoint_id; 321 322 /* 323 * If we found a PCI range managed by the viommu, we're 324 * the one that has to request ACS. 325 */ 326 pci_request_acs(); 327 328 return viot_dev_iommu_init(&pdev->dev, ep->viommu, 329 epid); 330 } 331 } 332 return -ENODEV; 333 } 334 335 static int viot_mmio_dev_iommu_init(struct platform_device *pdev) 336 { 337 struct resource *mem; 338 struct viot_endpoint *ep; 339 340 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); 341 if (!mem) 342 return -ENODEV; 343 344 list_for_each_entry(ep, &viot_mmio_endpoints, list) { 345 if (ep->address == mem->start) 346 return viot_dev_iommu_init(&pdev->dev, ep->viommu, 347 ep->endpoint_id); 348 } 349 return -ENODEV; 350 } 351 352 /** 353 * viot_iommu_configure - Setup IOMMU ops for an endpoint described by VIOT 354 * @dev: the endpoint 355 * 356 * Return: 0 on success, <0 on failure 357 */ 358 int viot_iommu_configure(struct device *dev) 359 { 360 if (dev_is_pci(dev)) 361 return pci_for_each_dma_alias(to_pci_dev(dev), 362 viot_pci_dev_iommu_init, NULL); 363 else if (dev_is_platform(dev)) 364 return viot_mmio_dev_iommu_init(to_platform_device(dev)); 365 return -ENODEV; 366 } 367