1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2016, Semihalf 4 * Author: Tomasz Nowicki <tn@semihalf.com> 5 * 6 * This file implements early detection/parsing of I/O mapping 7 * reported to OS through firmware via I/O Remapping Table (IORT) 8 * IORT document number: ARM DEN 0049A 9 */ 10 11 #define pr_fmt(fmt) "ACPI: IORT: " fmt 12 13 #include <linux/acpi_iort.h> 14 #include <linux/bitfield.h> 15 #include <linux/iommu.h> 16 #include <linux/kernel.h> 17 #include <linux/list.h> 18 #include <linux/pci.h> 19 #include <linux/platform_device.h> 20 #include <linux/slab.h> 21 #include <linux/dma-map-ops.h> 22 23 #define IORT_TYPE_MASK(type) (1 << (type)) 24 #define IORT_MSI_TYPE (1 << ACPI_IORT_NODE_ITS_GROUP) 25 #define IORT_IOMMU_TYPE ((1 << ACPI_IORT_NODE_SMMU) | \ 26 (1 << ACPI_IORT_NODE_SMMU_V3)) 27 28 struct iort_its_msi_chip { 29 struct list_head list; 30 struct fwnode_handle *fw_node; 31 phys_addr_t base_addr; 32 u32 translation_id; 33 }; 34 35 struct iort_fwnode { 36 struct list_head list; 37 struct acpi_iort_node *iort_node; 38 struct fwnode_handle *fwnode; 39 }; 40 static LIST_HEAD(iort_fwnode_list); 41 static DEFINE_SPINLOCK(iort_fwnode_lock); 42 43 /** 44 * iort_set_fwnode() - Create iort_fwnode and use it to register 45 * iommu data in the iort_fwnode_list 46 * 47 * @iort_node: IORT table node associated with the IOMMU 48 * @fwnode: fwnode associated with the IORT node 49 * 50 * Returns: 0 on success 51 * <0 on failure 52 */ 53 static inline int iort_set_fwnode(struct acpi_iort_node *iort_node, 54 struct fwnode_handle *fwnode) 55 { 56 struct iort_fwnode *np; 57 58 np = kzalloc(sizeof(struct iort_fwnode), GFP_ATOMIC); 59 60 if (WARN_ON(!np)) 61 return -ENOMEM; 62 63 INIT_LIST_HEAD(&np->list); 64 np->iort_node = iort_node; 65 np->fwnode = fwnode; 66 67 spin_lock(&iort_fwnode_lock); 68 list_add_tail(&np->list, &iort_fwnode_list); 69 spin_unlock(&iort_fwnode_lock); 70 71 return 0; 72 } 73 74 /** 75 * iort_get_fwnode() - Retrieve fwnode associated with an IORT node 76 * 77 * @node: IORT table node to be looked-up 78 * 79 * Returns: fwnode_handle pointer on success, NULL on failure 80 */ 81 static inline struct fwnode_handle *iort_get_fwnode( 82 struct acpi_iort_node *node) 83 { 84 struct iort_fwnode *curr; 85 struct fwnode_handle *fwnode = NULL; 86 87 spin_lock(&iort_fwnode_lock); 88 list_for_each_entry(curr, &iort_fwnode_list, list) { 89 if (curr->iort_node == node) { 90 fwnode = curr->fwnode; 91 break; 92 } 93 } 94 spin_unlock(&iort_fwnode_lock); 95 96 return fwnode; 97 } 98 99 /** 100 * iort_delete_fwnode() - Delete fwnode associated with an IORT node 101 * 102 * @node: IORT table node associated with fwnode to delete 103 */ 104 static inline void iort_delete_fwnode(struct acpi_iort_node *node) 105 { 106 struct iort_fwnode *curr, *tmp; 107 108 spin_lock(&iort_fwnode_lock); 109 list_for_each_entry_safe(curr, tmp, &iort_fwnode_list, list) { 110 if (curr->iort_node == node) { 111 list_del(&curr->list); 112 kfree(curr); 113 break; 114 } 115 } 116 spin_unlock(&iort_fwnode_lock); 117 } 118 119 /** 120 * iort_get_iort_node() - Retrieve iort_node associated with an fwnode 121 * 122 * @fwnode: fwnode associated with device to be looked-up 123 * 124 * Returns: iort_node pointer on success, NULL on failure 125 */ 126 static inline struct acpi_iort_node *iort_get_iort_node( 127 struct fwnode_handle *fwnode) 128 { 129 struct iort_fwnode *curr; 130 struct acpi_iort_node *iort_node = NULL; 131 132 spin_lock(&iort_fwnode_lock); 133 list_for_each_entry(curr, &iort_fwnode_list, list) { 134 if (curr->fwnode == fwnode) { 135 iort_node = curr->iort_node; 136 break; 137 } 138 } 139 spin_unlock(&iort_fwnode_lock); 140 141 return iort_node; 142 } 143 144 typedef acpi_status (*iort_find_node_callback) 145 (struct acpi_iort_node *node, void *context); 146 147 /* Root pointer to the mapped IORT table */ 148 static struct acpi_table_header *iort_table; 149 150 static LIST_HEAD(iort_msi_chip_list); 151 static DEFINE_SPINLOCK(iort_msi_chip_lock); 152 153 /** 154 * iort_register_domain_token() - register domain token along with related 155 * ITS ID and base address to the list from where we can get it back later on. 156 * @trans_id: ITS ID. 157 * @base: ITS base address. 158 * @fw_node: Domain token. 159 * 160 * Returns: 0 on success, -ENOMEM if no memory when allocating list element 161 */ 162 int iort_register_domain_token(int trans_id, phys_addr_t base, 163 struct fwnode_handle *fw_node) 164 { 165 struct iort_its_msi_chip *its_msi_chip; 166 167 its_msi_chip = kzalloc(sizeof(*its_msi_chip), GFP_KERNEL); 168 if (!its_msi_chip) 169 return -ENOMEM; 170 171 its_msi_chip->fw_node = fw_node; 172 its_msi_chip->translation_id = trans_id; 173 its_msi_chip->base_addr = base; 174 175 spin_lock(&iort_msi_chip_lock); 176 list_add(&its_msi_chip->list, &iort_msi_chip_list); 177 spin_unlock(&iort_msi_chip_lock); 178 179 return 0; 180 } 181 182 /** 183 * iort_deregister_domain_token() - Deregister domain token based on ITS ID 184 * @trans_id: ITS ID. 185 * 186 * Returns: none. 187 */ 188 void iort_deregister_domain_token(int trans_id) 189 { 190 struct iort_its_msi_chip *its_msi_chip, *t; 191 192 spin_lock(&iort_msi_chip_lock); 193 list_for_each_entry_safe(its_msi_chip, t, &iort_msi_chip_list, list) { 194 if (its_msi_chip->translation_id == trans_id) { 195 list_del(&its_msi_chip->list); 196 kfree(its_msi_chip); 197 break; 198 } 199 } 200 spin_unlock(&iort_msi_chip_lock); 201 } 202 203 /** 204 * iort_find_domain_token() - Find domain token based on given ITS ID 205 * @trans_id: ITS ID. 206 * 207 * Returns: domain token when find on the list, NULL otherwise 208 */ 209 struct fwnode_handle *iort_find_domain_token(int trans_id) 210 { 211 struct fwnode_handle *fw_node = NULL; 212 struct iort_its_msi_chip *its_msi_chip; 213 214 spin_lock(&iort_msi_chip_lock); 215 list_for_each_entry(its_msi_chip, &iort_msi_chip_list, list) { 216 if (its_msi_chip->translation_id == trans_id) { 217 fw_node = its_msi_chip->fw_node; 218 break; 219 } 220 } 221 spin_unlock(&iort_msi_chip_lock); 222 223 return fw_node; 224 } 225 226 static struct acpi_iort_node *iort_scan_node(enum acpi_iort_node_type type, 227 iort_find_node_callback callback, 228 void *context) 229 { 230 struct acpi_iort_node *iort_node, *iort_end; 231 struct acpi_table_iort *iort; 232 int i; 233 234 if (!iort_table) 235 return NULL; 236 237 /* Get the first IORT node */ 238 iort = (struct acpi_table_iort *)iort_table; 239 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort, 240 iort->node_offset); 241 iort_end = ACPI_ADD_PTR(struct acpi_iort_node, iort_table, 242 iort_table->length); 243 244 for (i = 0; i < iort->node_count; i++) { 245 if (WARN_TAINT(iort_node >= iort_end, TAINT_FIRMWARE_WORKAROUND, 246 "IORT node pointer overflows, bad table!\n")) 247 return NULL; 248 249 if (iort_node->type == type && 250 ACPI_SUCCESS(callback(iort_node, context))) 251 return iort_node; 252 253 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort_node, 254 iort_node->length); 255 } 256 257 return NULL; 258 } 259 260 static acpi_status iort_match_node_callback(struct acpi_iort_node *node, 261 void *context) 262 { 263 struct device *dev = context; 264 acpi_status status = AE_NOT_FOUND; 265 266 if (node->type == ACPI_IORT_NODE_NAMED_COMPONENT) { 267 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL }; 268 struct acpi_device *adev; 269 struct acpi_iort_named_component *ncomp; 270 struct device *nc_dev = dev; 271 272 /* 273 * Walk the device tree to find a device with an 274 * ACPI companion; there is no point in scanning 275 * IORT for a device matching a named component if 276 * the device does not have an ACPI companion to 277 * start with. 278 */ 279 do { 280 adev = ACPI_COMPANION(nc_dev); 281 if (adev) 282 break; 283 284 nc_dev = nc_dev->parent; 285 } while (nc_dev); 286 287 if (!adev) 288 goto out; 289 290 status = acpi_get_name(adev->handle, ACPI_FULL_PATHNAME, &buf); 291 if (ACPI_FAILURE(status)) { 292 dev_warn(nc_dev, "Can't get device full path name\n"); 293 goto out; 294 } 295 296 ncomp = (struct acpi_iort_named_component *)node->node_data; 297 status = !strcmp(ncomp->device_name, buf.pointer) ? 298 AE_OK : AE_NOT_FOUND; 299 acpi_os_free(buf.pointer); 300 } else if (node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) { 301 struct acpi_iort_root_complex *pci_rc; 302 struct pci_bus *bus; 303 304 bus = to_pci_bus(dev); 305 pci_rc = (struct acpi_iort_root_complex *)node->node_data; 306 307 /* 308 * It is assumed that PCI segment numbers maps one-to-one 309 * with root complexes. Each segment number can represent only 310 * one root complex. 311 */ 312 status = pci_rc->pci_segment_number == pci_domain_nr(bus) ? 313 AE_OK : AE_NOT_FOUND; 314 } 315 out: 316 return status; 317 } 318 319 static int iort_id_map(struct acpi_iort_id_mapping *map, u8 type, u32 rid_in, 320 u32 *rid_out, bool check_overlap) 321 { 322 /* Single mapping does not care for input id */ 323 if (map->flags & ACPI_IORT_ID_SINGLE_MAPPING) { 324 if (type == ACPI_IORT_NODE_NAMED_COMPONENT || 325 type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) { 326 *rid_out = map->output_base; 327 return 0; 328 } 329 330 pr_warn(FW_BUG "[map %p] SINGLE MAPPING flag not allowed for node type %d, skipping ID map\n", 331 map, type); 332 return -ENXIO; 333 } 334 335 if (rid_in < map->input_base || 336 (rid_in > map->input_base + map->id_count)) 337 return -ENXIO; 338 339 if (check_overlap) { 340 /* 341 * We already found a mapping for this input ID at the end of 342 * another region. If it coincides with the start of this 343 * region, we assume the prior match was due to the off-by-1 344 * issue mentioned below, and allow it to be superseded. 345 * Otherwise, things are *really* broken, and we just disregard 346 * duplicate matches entirely to retain compatibility. 347 */ 348 pr_err(FW_BUG "[map %p] conflicting mapping for input ID 0x%x\n", 349 map, rid_in); 350 if (rid_in != map->input_base) 351 return -ENXIO; 352 353 pr_err(FW_BUG "applying workaround.\n"); 354 } 355 356 *rid_out = map->output_base + (rid_in - map->input_base); 357 358 /* 359 * Due to confusion regarding the meaning of the id_count field (which 360 * carries the number of IDs *minus 1*), we may have to disregard this 361 * match if it is at the end of the range, and overlaps with the start 362 * of another one. 363 */ 364 if (map->id_count > 0 && rid_in == map->input_base + map->id_count) 365 return -EAGAIN; 366 return 0; 367 } 368 369 static struct acpi_iort_node *iort_node_get_id(struct acpi_iort_node *node, 370 u32 *id_out, int index) 371 { 372 struct acpi_iort_node *parent; 373 struct acpi_iort_id_mapping *map; 374 375 if (!node->mapping_offset || !node->mapping_count || 376 index >= node->mapping_count) 377 return NULL; 378 379 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node, 380 node->mapping_offset + index * sizeof(*map)); 381 382 /* Firmware bug! */ 383 if (!map->output_reference) { 384 pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n", 385 node, node->type); 386 return NULL; 387 } 388 389 parent = ACPI_ADD_PTR(struct acpi_iort_node, iort_table, 390 map->output_reference); 391 392 if (map->flags & ACPI_IORT_ID_SINGLE_MAPPING) { 393 if (node->type == ACPI_IORT_NODE_NAMED_COMPONENT || 394 node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX || 395 node->type == ACPI_IORT_NODE_SMMU_V3 || 396 node->type == ACPI_IORT_NODE_PMCG) { 397 *id_out = map->output_base; 398 return parent; 399 } 400 } 401 402 return NULL; 403 } 404 405 static int iort_get_id_mapping_index(struct acpi_iort_node *node) 406 { 407 struct acpi_iort_smmu_v3 *smmu; 408 struct acpi_iort_pmcg *pmcg; 409 410 switch (node->type) { 411 case ACPI_IORT_NODE_SMMU_V3: 412 /* 413 * SMMUv3 dev ID mapping index was introduced in revision 1 414 * table, not available in revision 0 415 */ 416 if (node->revision < 1) 417 return -EINVAL; 418 419 smmu = (struct acpi_iort_smmu_v3 *)node->node_data; 420 /* 421 * ID mapping index is only ignored if all interrupts are 422 * GSIV based 423 */ 424 if (smmu->event_gsiv && smmu->pri_gsiv && smmu->gerr_gsiv 425 && smmu->sync_gsiv) 426 return -EINVAL; 427 428 if (smmu->id_mapping_index >= node->mapping_count) { 429 pr_err(FW_BUG "[node %p type %d] ID mapping index overflows valid mappings\n", 430 node, node->type); 431 return -EINVAL; 432 } 433 434 return smmu->id_mapping_index; 435 case ACPI_IORT_NODE_PMCG: 436 pmcg = (struct acpi_iort_pmcg *)node->node_data; 437 if (pmcg->overflow_gsiv || node->mapping_count == 0) 438 return -EINVAL; 439 440 return 0; 441 default: 442 return -EINVAL; 443 } 444 } 445 446 static struct acpi_iort_node *iort_node_map_id(struct acpi_iort_node *node, 447 u32 id_in, u32 *id_out, 448 u8 type_mask) 449 { 450 u32 id = id_in; 451 452 /* Parse the ID mapping tree to find specified node type */ 453 while (node) { 454 struct acpi_iort_id_mapping *map; 455 int i, index, rc = 0; 456 u32 out_ref = 0, map_id = id; 457 458 if (IORT_TYPE_MASK(node->type) & type_mask) { 459 if (id_out) 460 *id_out = id; 461 return node; 462 } 463 464 if (!node->mapping_offset || !node->mapping_count) 465 goto fail_map; 466 467 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node, 468 node->mapping_offset); 469 470 /* Firmware bug! */ 471 if (!map->output_reference) { 472 pr_err(FW_BUG "[node %p type %d] ID map has NULL parent reference\n", 473 node, node->type); 474 goto fail_map; 475 } 476 477 /* 478 * Get the special ID mapping index (if any) and skip its 479 * associated ID map to prevent erroneous multi-stage 480 * IORT ID translations. 481 */ 482 index = iort_get_id_mapping_index(node); 483 484 /* Do the ID translation */ 485 for (i = 0; i < node->mapping_count; i++, map++) { 486 /* if it is special mapping index, skip it */ 487 if (i == index) 488 continue; 489 490 rc = iort_id_map(map, node->type, map_id, &id, out_ref); 491 if (!rc) 492 break; 493 if (rc == -EAGAIN) 494 out_ref = map->output_reference; 495 } 496 497 if (i == node->mapping_count && !out_ref) 498 goto fail_map; 499 500 node = ACPI_ADD_PTR(struct acpi_iort_node, iort_table, 501 rc ? out_ref : map->output_reference); 502 } 503 504 fail_map: 505 /* Map input ID to output ID unchanged on mapping failure */ 506 if (id_out) 507 *id_out = id_in; 508 509 return NULL; 510 } 511 512 static struct acpi_iort_node *iort_node_map_platform_id( 513 struct acpi_iort_node *node, u32 *id_out, u8 type_mask, 514 int index) 515 { 516 struct acpi_iort_node *parent; 517 u32 id; 518 519 /* step 1: retrieve the initial dev id */ 520 parent = iort_node_get_id(node, &id, index); 521 if (!parent) 522 return NULL; 523 524 /* 525 * optional step 2: map the initial dev id if its parent is not 526 * the target type we want, map it again for the use cases such 527 * as NC (named component) -> SMMU -> ITS. If the type is matched, 528 * return the initial dev id and its parent pointer directly. 529 */ 530 if (!(IORT_TYPE_MASK(parent->type) & type_mask)) 531 parent = iort_node_map_id(parent, id, id_out, type_mask); 532 else 533 if (id_out) 534 *id_out = id; 535 536 return parent; 537 } 538 539 static struct acpi_iort_node *iort_find_dev_node(struct device *dev) 540 { 541 struct pci_bus *pbus; 542 543 if (!dev_is_pci(dev)) { 544 struct acpi_iort_node *node; 545 /* 546 * scan iort_fwnode_list to see if it's an iort platform 547 * device (such as SMMU, PMCG),its iort node already cached 548 * and associated with fwnode when iort platform devices 549 * were initialized. 550 */ 551 node = iort_get_iort_node(dev->fwnode); 552 if (node) 553 return node; 554 /* 555 * if not, then it should be a platform device defined in 556 * DSDT/SSDT (with Named Component node in IORT) 557 */ 558 return iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT, 559 iort_match_node_callback, dev); 560 } 561 562 pbus = to_pci_dev(dev)->bus; 563 564 return iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX, 565 iort_match_node_callback, &pbus->dev); 566 } 567 568 /** 569 * iort_msi_map_id() - Map a MSI input ID for a device 570 * @dev: The device for which the mapping is to be done. 571 * @input_id: The device input ID. 572 * 573 * Returns: mapped MSI ID on success, input ID otherwise 574 */ 575 u32 iort_msi_map_id(struct device *dev, u32 input_id) 576 { 577 struct acpi_iort_node *node; 578 u32 dev_id; 579 580 node = iort_find_dev_node(dev); 581 if (!node) 582 return input_id; 583 584 iort_node_map_id(node, input_id, &dev_id, IORT_MSI_TYPE); 585 return dev_id; 586 } 587 588 /** 589 * iort_pmsi_get_dev_id() - Get the device id for a device 590 * @dev: The device for which the mapping is to be done. 591 * @dev_id: The device ID found. 592 * 593 * Returns: 0 for successful find a dev id, -ENODEV on error 594 */ 595 int iort_pmsi_get_dev_id(struct device *dev, u32 *dev_id) 596 { 597 int i, index; 598 struct acpi_iort_node *node; 599 600 node = iort_find_dev_node(dev); 601 if (!node) 602 return -ENODEV; 603 604 index = iort_get_id_mapping_index(node); 605 /* if there is a valid index, go get the dev_id directly */ 606 if (index >= 0) { 607 if (iort_node_get_id(node, dev_id, index)) 608 return 0; 609 } else { 610 for (i = 0; i < node->mapping_count; i++) { 611 if (iort_node_map_platform_id(node, dev_id, 612 IORT_MSI_TYPE, i)) 613 return 0; 614 } 615 } 616 617 return -ENODEV; 618 } 619 620 static int __maybe_unused iort_find_its_base(u32 its_id, phys_addr_t *base) 621 { 622 struct iort_its_msi_chip *its_msi_chip; 623 int ret = -ENODEV; 624 625 spin_lock(&iort_msi_chip_lock); 626 list_for_each_entry(its_msi_chip, &iort_msi_chip_list, list) { 627 if (its_msi_chip->translation_id == its_id) { 628 *base = its_msi_chip->base_addr; 629 ret = 0; 630 break; 631 } 632 } 633 spin_unlock(&iort_msi_chip_lock); 634 635 return ret; 636 } 637 638 /** 639 * iort_dev_find_its_id() - Find the ITS identifier for a device 640 * @dev: The device. 641 * @id: Device's ID 642 * @idx: Index of the ITS identifier list. 643 * @its_id: ITS identifier. 644 * 645 * Returns: 0 on success, appropriate error value otherwise 646 */ 647 static int iort_dev_find_its_id(struct device *dev, u32 id, 648 unsigned int idx, int *its_id) 649 { 650 struct acpi_iort_its_group *its; 651 struct acpi_iort_node *node; 652 653 node = iort_find_dev_node(dev); 654 if (!node) 655 return -ENXIO; 656 657 node = iort_node_map_id(node, id, NULL, IORT_MSI_TYPE); 658 if (!node) 659 return -ENXIO; 660 661 /* Move to ITS specific data */ 662 its = (struct acpi_iort_its_group *)node->node_data; 663 if (idx >= its->its_count) { 664 dev_err(dev, "requested ITS ID index [%d] overruns ITS entries [%d]\n", 665 idx, its->its_count); 666 return -ENXIO; 667 } 668 669 *its_id = its->identifiers[idx]; 670 return 0; 671 } 672 673 /** 674 * iort_get_device_domain() - Find MSI domain related to a device 675 * @dev: The device. 676 * @id: Requester ID for the device. 677 * @bus_token: irq domain bus token. 678 * 679 * Returns: the MSI domain for this device, NULL otherwise 680 */ 681 struct irq_domain *iort_get_device_domain(struct device *dev, u32 id, 682 enum irq_domain_bus_token bus_token) 683 { 684 struct fwnode_handle *handle; 685 int its_id; 686 687 if (iort_dev_find_its_id(dev, id, 0, &its_id)) 688 return NULL; 689 690 handle = iort_find_domain_token(its_id); 691 if (!handle) 692 return NULL; 693 694 return irq_find_matching_fwnode(handle, bus_token); 695 } 696 697 static void iort_set_device_domain(struct device *dev, 698 struct acpi_iort_node *node) 699 { 700 struct acpi_iort_its_group *its; 701 struct acpi_iort_node *msi_parent; 702 struct acpi_iort_id_mapping *map; 703 struct fwnode_handle *iort_fwnode; 704 struct irq_domain *domain; 705 int index; 706 707 index = iort_get_id_mapping_index(node); 708 if (index < 0) 709 return; 710 711 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, node, 712 node->mapping_offset + index * sizeof(*map)); 713 714 /* Firmware bug! */ 715 if (!map->output_reference || 716 !(map->flags & ACPI_IORT_ID_SINGLE_MAPPING)) { 717 pr_err(FW_BUG "[node %p type %d] Invalid MSI mapping\n", 718 node, node->type); 719 return; 720 } 721 722 msi_parent = ACPI_ADD_PTR(struct acpi_iort_node, iort_table, 723 map->output_reference); 724 725 if (!msi_parent || msi_parent->type != ACPI_IORT_NODE_ITS_GROUP) 726 return; 727 728 /* Move to ITS specific data */ 729 its = (struct acpi_iort_its_group *)msi_parent->node_data; 730 731 iort_fwnode = iort_find_domain_token(its->identifiers[0]); 732 if (!iort_fwnode) 733 return; 734 735 domain = irq_find_matching_fwnode(iort_fwnode, DOMAIN_BUS_PLATFORM_MSI); 736 if (domain) 737 dev_set_msi_domain(dev, domain); 738 } 739 740 /** 741 * iort_get_platform_device_domain() - Find MSI domain related to a 742 * platform device 743 * @dev: the dev pointer associated with the platform device 744 * 745 * Returns: the MSI domain for this device, NULL otherwise 746 */ 747 static struct irq_domain *iort_get_platform_device_domain(struct device *dev) 748 { 749 struct acpi_iort_node *node, *msi_parent = NULL; 750 struct fwnode_handle *iort_fwnode; 751 struct acpi_iort_its_group *its; 752 int i; 753 754 /* find its associated iort node */ 755 node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT, 756 iort_match_node_callback, dev); 757 if (!node) 758 return NULL; 759 760 /* then find its msi parent node */ 761 for (i = 0; i < node->mapping_count; i++) { 762 msi_parent = iort_node_map_platform_id(node, NULL, 763 IORT_MSI_TYPE, i); 764 if (msi_parent) 765 break; 766 } 767 768 if (!msi_parent) 769 return NULL; 770 771 /* Move to ITS specific data */ 772 its = (struct acpi_iort_its_group *)msi_parent->node_data; 773 774 iort_fwnode = iort_find_domain_token(its->identifiers[0]); 775 if (!iort_fwnode) 776 return NULL; 777 778 return irq_find_matching_fwnode(iort_fwnode, DOMAIN_BUS_PLATFORM_MSI); 779 } 780 781 void acpi_configure_pmsi_domain(struct device *dev) 782 { 783 struct irq_domain *msi_domain; 784 785 msi_domain = iort_get_platform_device_domain(dev); 786 if (msi_domain) 787 dev_set_msi_domain(dev, msi_domain); 788 } 789 790 #ifdef CONFIG_IOMMU_API 791 static struct acpi_iort_node *iort_get_msi_resv_iommu(struct device *dev) 792 { 793 struct acpi_iort_node *iommu; 794 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev); 795 796 iommu = iort_get_iort_node(fwspec->iommu_fwnode); 797 798 if (iommu && (iommu->type == ACPI_IORT_NODE_SMMU_V3)) { 799 struct acpi_iort_smmu_v3 *smmu; 800 801 smmu = (struct acpi_iort_smmu_v3 *)iommu->node_data; 802 if (smmu->model == ACPI_IORT_SMMU_V3_HISILICON_HI161X) 803 return iommu; 804 } 805 806 return NULL; 807 } 808 809 static inline const struct iommu_ops *iort_fwspec_iommu_ops(struct device *dev) 810 { 811 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev); 812 813 return (fwspec && fwspec->ops) ? fwspec->ops : NULL; 814 } 815 816 static inline int iort_add_device_replay(struct device *dev) 817 { 818 int err = 0; 819 820 if (dev->bus && !device_iommu_mapped(dev)) 821 err = iommu_probe_device(dev); 822 823 return err; 824 } 825 826 /** 827 * iort_iommu_msi_get_resv_regions - Reserved region driver helper 828 * @dev: Device from iommu_get_resv_regions() 829 * @head: Reserved region list from iommu_get_resv_regions() 830 * 831 * Returns: Number of msi reserved regions on success (0 if platform 832 * doesn't require the reservation or no associated msi regions), 833 * appropriate error value otherwise. The ITS interrupt translation 834 * spaces (ITS_base + SZ_64K, SZ_64K) associated with the device 835 * are the msi reserved regions. 836 */ 837 int iort_iommu_msi_get_resv_regions(struct device *dev, struct list_head *head) 838 { 839 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev); 840 struct acpi_iort_its_group *its; 841 struct acpi_iort_node *iommu_node, *its_node = NULL; 842 int i, resv = 0; 843 844 iommu_node = iort_get_msi_resv_iommu(dev); 845 if (!iommu_node) 846 return 0; 847 848 /* 849 * Current logic to reserve ITS regions relies on HW topologies 850 * where a given PCI or named component maps its IDs to only one 851 * ITS group; if a PCI or named component can map its IDs to 852 * different ITS groups through IORT mappings this function has 853 * to be reworked to ensure we reserve regions for all ITS groups 854 * a given PCI or named component may map IDs to. 855 */ 856 857 for (i = 0; i < fwspec->num_ids; i++) { 858 its_node = iort_node_map_id(iommu_node, 859 fwspec->ids[i], 860 NULL, IORT_MSI_TYPE); 861 if (its_node) 862 break; 863 } 864 865 if (!its_node) 866 return 0; 867 868 /* Move to ITS specific data */ 869 its = (struct acpi_iort_its_group *)its_node->node_data; 870 871 for (i = 0; i < its->its_count; i++) { 872 phys_addr_t base; 873 874 if (!iort_find_its_base(its->identifiers[i], &base)) { 875 int prot = IOMMU_WRITE | IOMMU_NOEXEC | IOMMU_MMIO; 876 struct iommu_resv_region *region; 877 878 region = iommu_alloc_resv_region(base + SZ_64K, SZ_64K, 879 prot, IOMMU_RESV_MSI); 880 if (region) { 881 list_add_tail(®ion->list, head); 882 resv++; 883 } 884 } 885 } 886 887 return (resv == its->its_count) ? resv : -ENODEV; 888 } 889 890 static inline bool iort_iommu_driver_enabled(u8 type) 891 { 892 switch (type) { 893 case ACPI_IORT_NODE_SMMU_V3: 894 return IS_ENABLED(CONFIG_ARM_SMMU_V3); 895 case ACPI_IORT_NODE_SMMU: 896 return IS_ENABLED(CONFIG_ARM_SMMU); 897 default: 898 pr_warn("IORT node type %u does not describe an SMMU\n", type); 899 return false; 900 } 901 } 902 903 static int arm_smmu_iort_xlate(struct device *dev, u32 streamid, 904 struct fwnode_handle *fwnode, 905 const struct iommu_ops *ops) 906 { 907 int ret = iommu_fwspec_init(dev, fwnode, ops); 908 909 if (!ret) 910 ret = iommu_fwspec_add_ids(dev, &streamid, 1); 911 912 return ret; 913 } 914 915 static bool iort_pci_rc_supports_ats(struct acpi_iort_node *node) 916 { 917 struct acpi_iort_root_complex *pci_rc; 918 919 pci_rc = (struct acpi_iort_root_complex *)node->node_data; 920 return pci_rc->ats_attribute & ACPI_IORT_ATS_SUPPORTED; 921 } 922 923 static int iort_iommu_xlate(struct device *dev, struct acpi_iort_node *node, 924 u32 streamid) 925 { 926 const struct iommu_ops *ops; 927 struct fwnode_handle *iort_fwnode; 928 929 if (!node) 930 return -ENODEV; 931 932 iort_fwnode = iort_get_fwnode(node); 933 if (!iort_fwnode) 934 return -ENODEV; 935 936 /* 937 * If the ops look-up fails, this means that either 938 * the SMMU drivers have not been probed yet or that 939 * the SMMU drivers are not built in the kernel; 940 * Depending on whether the SMMU drivers are built-in 941 * in the kernel or not, defer the IOMMU configuration 942 * or just abort it. 943 */ 944 ops = iommu_ops_from_fwnode(iort_fwnode); 945 if (!ops) 946 return iort_iommu_driver_enabled(node->type) ? 947 -EPROBE_DEFER : -ENODEV; 948 949 return arm_smmu_iort_xlate(dev, streamid, iort_fwnode, ops); 950 } 951 952 struct iort_pci_alias_info { 953 struct device *dev; 954 struct acpi_iort_node *node; 955 }; 956 957 static int iort_pci_iommu_init(struct pci_dev *pdev, u16 alias, void *data) 958 { 959 struct iort_pci_alias_info *info = data; 960 struct acpi_iort_node *parent; 961 u32 streamid; 962 963 parent = iort_node_map_id(info->node, alias, &streamid, 964 IORT_IOMMU_TYPE); 965 return iort_iommu_xlate(info->dev, parent, streamid); 966 } 967 968 static void iort_named_component_init(struct device *dev, 969 struct acpi_iort_node *node) 970 { 971 struct acpi_iort_named_component *nc; 972 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev); 973 974 if (!fwspec) 975 return; 976 977 nc = (struct acpi_iort_named_component *)node->node_data; 978 fwspec->num_pasid_bits = FIELD_GET(ACPI_IORT_NC_PASID_BITS, 979 nc->node_flags); 980 } 981 982 static int iort_nc_iommu_map(struct device *dev, struct acpi_iort_node *node) 983 { 984 struct acpi_iort_node *parent; 985 int err = -ENODEV, i = 0; 986 u32 streamid = 0; 987 988 do { 989 990 parent = iort_node_map_platform_id(node, &streamid, 991 IORT_IOMMU_TYPE, 992 i++); 993 994 if (parent) 995 err = iort_iommu_xlate(dev, parent, streamid); 996 } while (parent && !err); 997 998 return err; 999 } 1000 1001 static int iort_nc_iommu_map_id(struct device *dev, 1002 struct acpi_iort_node *node, 1003 const u32 *in_id) 1004 { 1005 struct acpi_iort_node *parent; 1006 u32 streamid; 1007 1008 parent = iort_node_map_id(node, *in_id, &streamid, IORT_IOMMU_TYPE); 1009 if (parent) 1010 return iort_iommu_xlate(dev, parent, streamid); 1011 1012 return -ENODEV; 1013 } 1014 1015 1016 /** 1017 * iort_iommu_configure_id - Set-up IOMMU configuration for a device. 1018 * 1019 * @dev: device to configure 1020 * @id_in: optional input id const value pointer 1021 * 1022 * Returns: iommu_ops pointer on configuration success 1023 * NULL on configuration failure 1024 */ 1025 const struct iommu_ops *iort_iommu_configure_id(struct device *dev, 1026 const u32 *id_in) 1027 { 1028 struct acpi_iort_node *node; 1029 const struct iommu_ops *ops; 1030 int err = -ENODEV; 1031 1032 /* 1033 * If we already translated the fwspec there 1034 * is nothing left to do, return the iommu_ops. 1035 */ 1036 ops = iort_fwspec_iommu_ops(dev); 1037 if (ops) 1038 return ops; 1039 1040 if (dev_is_pci(dev)) { 1041 struct iommu_fwspec *fwspec; 1042 struct pci_bus *bus = to_pci_dev(dev)->bus; 1043 struct iort_pci_alias_info info = { .dev = dev }; 1044 1045 node = iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX, 1046 iort_match_node_callback, &bus->dev); 1047 if (!node) 1048 return NULL; 1049 1050 info.node = node; 1051 err = pci_for_each_dma_alias(to_pci_dev(dev), 1052 iort_pci_iommu_init, &info); 1053 1054 fwspec = dev_iommu_fwspec_get(dev); 1055 if (fwspec && iort_pci_rc_supports_ats(node)) 1056 fwspec->flags |= IOMMU_FWSPEC_PCI_RC_ATS; 1057 } else { 1058 node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT, 1059 iort_match_node_callback, dev); 1060 if (!node) 1061 return NULL; 1062 1063 err = id_in ? iort_nc_iommu_map_id(dev, node, id_in) : 1064 iort_nc_iommu_map(dev, node); 1065 1066 if (!err) 1067 iort_named_component_init(dev, node); 1068 } 1069 1070 /* 1071 * If we have reason to believe the IOMMU driver missed the initial 1072 * add_device callback for dev, replay it to get things in order. 1073 */ 1074 if (!err) { 1075 ops = iort_fwspec_iommu_ops(dev); 1076 err = iort_add_device_replay(dev); 1077 } 1078 1079 /* Ignore all other errors apart from EPROBE_DEFER */ 1080 if (err == -EPROBE_DEFER) { 1081 ops = ERR_PTR(err); 1082 } else if (err) { 1083 dev_dbg(dev, "Adding to IOMMU failed: %d\n", err); 1084 ops = NULL; 1085 } 1086 1087 return ops; 1088 } 1089 1090 #else 1091 int iort_iommu_msi_get_resv_regions(struct device *dev, struct list_head *head) 1092 { return 0; } 1093 const struct iommu_ops *iort_iommu_configure_id(struct device *dev, 1094 const u32 *input_id) 1095 { return NULL; } 1096 #endif 1097 1098 static int nc_dma_get_range(struct device *dev, u64 *size) 1099 { 1100 struct acpi_iort_node *node; 1101 struct acpi_iort_named_component *ncomp; 1102 1103 node = iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT, 1104 iort_match_node_callback, dev); 1105 if (!node) 1106 return -ENODEV; 1107 1108 ncomp = (struct acpi_iort_named_component *)node->node_data; 1109 1110 *size = ncomp->memory_address_limit >= 64 ? U64_MAX : 1111 1ULL<<ncomp->memory_address_limit; 1112 1113 return 0; 1114 } 1115 1116 static int rc_dma_get_range(struct device *dev, u64 *size) 1117 { 1118 struct acpi_iort_node *node; 1119 struct acpi_iort_root_complex *rc; 1120 struct pci_bus *pbus = to_pci_dev(dev)->bus; 1121 1122 node = iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX, 1123 iort_match_node_callback, &pbus->dev); 1124 if (!node || node->revision < 1) 1125 return -ENODEV; 1126 1127 rc = (struct acpi_iort_root_complex *)node->node_data; 1128 1129 *size = rc->memory_address_limit >= 64 ? U64_MAX : 1130 1ULL<<rc->memory_address_limit; 1131 1132 return 0; 1133 } 1134 1135 /** 1136 * iort_dma_setup() - Set-up device DMA parameters. 1137 * 1138 * @dev: device to configure 1139 * @dma_addr: device DMA address result pointer 1140 * @dma_size: DMA range size result pointer 1141 */ 1142 void iort_dma_setup(struct device *dev, u64 *dma_addr, u64 *dma_size) 1143 { 1144 u64 end, mask, dmaaddr = 0, size = 0, offset = 0; 1145 int ret; 1146 1147 /* 1148 * If @dev is expected to be DMA-capable then the bus code that created 1149 * it should have initialised its dma_mask pointer by this point. For 1150 * now, we'll continue the legacy behaviour of coercing it to the 1151 * coherent mask if not, but we'll no longer do so quietly. 1152 */ 1153 if (!dev->dma_mask) { 1154 dev_warn(dev, "DMA mask not set\n"); 1155 dev->dma_mask = &dev->coherent_dma_mask; 1156 } 1157 1158 if (dev->coherent_dma_mask) 1159 size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1); 1160 else 1161 size = 1ULL << 32; 1162 1163 ret = acpi_dma_get_range(dev, &dmaaddr, &offset, &size); 1164 if (ret == -ENODEV) 1165 ret = dev_is_pci(dev) ? rc_dma_get_range(dev, &size) 1166 : nc_dma_get_range(dev, &size); 1167 1168 if (!ret) { 1169 /* 1170 * Limit coherent and dma mask based on size retrieved from 1171 * firmware. 1172 */ 1173 end = dmaaddr + size - 1; 1174 mask = DMA_BIT_MASK(ilog2(end) + 1); 1175 dev->bus_dma_limit = end; 1176 dev->coherent_dma_mask = mask; 1177 *dev->dma_mask = mask; 1178 } 1179 1180 *dma_addr = dmaaddr; 1181 *dma_size = size; 1182 1183 ret = dma_direct_set_offset(dev, dmaaddr + offset, dmaaddr, size); 1184 1185 dev_dbg(dev, "dma_offset(%#08llx)%s\n", offset, ret ? " failed!" : ""); 1186 } 1187 1188 static void __init acpi_iort_register_irq(int hwirq, const char *name, 1189 int trigger, 1190 struct resource *res) 1191 { 1192 int irq = acpi_register_gsi(NULL, hwirq, trigger, 1193 ACPI_ACTIVE_HIGH); 1194 1195 if (irq <= 0) { 1196 pr_err("could not register gsi hwirq %d name [%s]\n", hwirq, 1197 name); 1198 return; 1199 } 1200 1201 res->start = irq; 1202 res->end = irq; 1203 res->flags = IORESOURCE_IRQ; 1204 res->name = name; 1205 } 1206 1207 static int __init arm_smmu_v3_count_resources(struct acpi_iort_node *node) 1208 { 1209 struct acpi_iort_smmu_v3 *smmu; 1210 /* Always present mem resource */ 1211 int num_res = 1; 1212 1213 /* Retrieve SMMUv3 specific data */ 1214 smmu = (struct acpi_iort_smmu_v3 *)node->node_data; 1215 1216 if (smmu->event_gsiv) 1217 num_res++; 1218 1219 if (smmu->pri_gsiv) 1220 num_res++; 1221 1222 if (smmu->gerr_gsiv) 1223 num_res++; 1224 1225 if (smmu->sync_gsiv) 1226 num_res++; 1227 1228 return num_res; 1229 } 1230 1231 static bool arm_smmu_v3_is_combined_irq(struct acpi_iort_smmu_v3 *smmu) 1232 { 1233 /* 1234 * Cavium ThunderX2 implementation doesn't not support unique 1235 * irq line. Use single irq line for all the SMMUv3 interrupts. 1236 */ 1237 if (smmu->model != ACPI_IORT_SMMU_V3_CAVIUM_CN99XX) 1238 return false; 1239 1240 /* 1241 * ThunderX2 doesn't support MSIs from the SMMU, so we're checking 1242 * SPI numbers here. 1243 */ 1244 return smmu->event_gsiv == smmu->pri_gsiv && 1245 smmu->event_gsiv == smmu->gerr_gsiv && 1246 smmu->event_gsiv == smmu->sync_gsiv; 1247 } 1248 1249 static unsigned long arm_smmu_v3_resource_size(struct acpi_iort_smmu_v3 *smmu) 1250 { 1251 /* 1252 * Override the size, for Cavium ThunderX2 implementation 1253 * which doesn't support the page 1 SMMU register space. 1254 */ 1255 if (smmu->model == ACPI_IORT_SMMU_V3_CAVIUM_CN99XX) 1256 return SZ_64K; 1257 1258 return SZ_128K; 1259 } 1260 1261 static void __init arm_smmu_v3_init_resources(struct resource *res, 1262 struct acpi_iort_node *node) 1263 { 1264 struct acpi_iort_smmu_v3 *smmu; 1265 int num_res = 0; 1266 1267 /* Retrieve SMMUv3 specific data */ 1268 smmu = (struct acpi_iort_smmu_v3 *)node->node_data; 1269 1270 res[num_res].start = smmu->base_address; 1271 res[num_res].end = smmu->base_address + 1272 arm_smmu_v3_resource_size(smmu) - 1; 1273 res[num_res].flags = IORESOURCE_MEM; 1274 1275 num_res++; 1276 if (arm_smmu_v3_is_combined_irq(smmu)) { 1277 if (smmu->event_gsiv) 1278 acpi_iort_register_irq(smmu->event_gsiv, "combined", 1279 ACPI_EDGE_SENSITIVE, 1280 &res[num_res++]); 1281 } else { 1282 1283 if (smmu->event_gsiv) 1284 acpi_iort_register_irq(smmu->event_gsiv, "eventq", 1285 ACPI_EDGE_SENSITIVE, 1286 &res[num_res++]); 1287 1288 if (smmu->pri_gsiv) 1289 acpi_iort_register_irq(smmu->pri_gsiv, "priq", 1290 ACPI_EDGE_SENSITIVE, 1291 &res[num_res++]); 1292 1293 if (smmu->gerr_gsiv) 1294 acpi_iort_register_irq(smmu->gerr_gsiv, "gerror", 1295 ACPI_EDGE_SENSITIVE, 1296 &res[num_res++]); 1297 1298 if (smmu->sync_gsiv) 1299 acpi_iort_register_irq(smmu->sync_gsiv, "cmdq-sync", 1300 ACPI_EDGE_SENSITIVE, 1301 &res[num_res++]); 1302 } 1303 } 1304 1305 static void __init arm_smmu_v3_dma_configure(struct device *dev, 1306 struct acpi_iort_node *node) 1307 { 1308 struct acpi_iort_smmu_v3 *smmu; 1309 enum dev_dma_attr attr; 1310 1311 /* Retrieve SMMUv3 specific data */ 1312 smmu = (struct acpi_iort_smmu_v3 *)node->node_data; 1313 1314 attr = (smmu->flags & ACPI_IORT_SMMU_V3_COHACC_OVERRIDE) ? 1315 DEV_DMA_COHERENT : DEV_DMA_NON_COHERENT; 1316 1317 /* We expect the dma masks to be equivalent for all SMMUv3 set-ups */ 1318 dev->dma_mask = &dev->coherent_dma_mask; 1319 1320 /* Configure DMA for the page table walker */ 1321 acpi_dma_configure(dev, attr); 1322 } 1323 1324 #if defined(CONFIG_ACPI_NUMA) 1325 /* 1326 * set numa proximity domain for smmuv3 device 1327 */ 1328 static int __init arm_smmu_v3_set_proximity(struct device *dev, 1329 struct acpi_iort_node *node) 1330 { 1331 struct acpi_iort_smmu_v3 *smmu; 1332 1333 smmu = (struct acpi_iort_smmu_v3 *)node->node_data; 1334 if (smmu->flags & ACPI_IORT_SMMU_V3_PXM_VALID) { 1335 int dev_node = pxm_to_node(smmu->pxm); 1336 1337 if (dev_node != NUMA_NO_NODE && !node_online(dev_node)) 1338 return -EINVAL; 1339 1340 set_dev_node(dev, dev_node); 1341 pr_info("SMMU-v3[%llx] Mapped to Proximity domain %d\n", 1342 smmu->base_address, 1343 smmu->pxm); 1344 } 1345 return 0; 1346 } 1347 #else 1348 #define arm_smmu_v3_set_proximity NULL 1349 #endif 1350 1351 static int __init arm_smmu_count_resources(struct acpi_iort_node *node) 1352 { 1353 struct acpi_iort_smmu *smmu; 1354 1355 /* Retrieve SMMU specific data */ 1356 smmu = (struct acpi_iort_smmu *)node->node_data; 1357 1358 /* 1359 * Only consider the global fault interrupt and ignore the 1360 * configuration access interrupt. 1361 * 1362 * MMIO address and global fault interrupt resources are always 1363 * present so add them to the context interrupt count as a static 1364 * value. 1365 */ 1366 return smmu->context_interrupt_count + 2; 1367 } 1368 1369 static void __init arm_smmu_init_resources(struct resource *res, 1370 struct acpi_iort_node *node) 1371 { 1372 struct acpi_iort_smmu *smmu; 1373 int i, hw_irq, trigger, num_res = 0; 1374 u64 *ctx_irq, *glb_irq; 1375 1376 /* Retrieve SMMU specific data */ 1377 smmu = (struct acpi_iort_smmu *)node->node_data; 1378 1379 res[num_res].start = smmu->base_address; 1380 res[num_res].end = smmu->base_address + smmu->span - 1; 1381 res[num_res].flags = IORESOURCE_MEM; 1382 num_res++; 1383 1384 glb_irq = ACPI_ADD_PTR(u64, node, smmu->global_interrupt_offset); 1385 /* Global IRQs */ 1386 hw_irq = IORT_IRQ_MASK(glb_irq[0]); 1387 trigger = IORT_IRQ_TRIGGER_MASK(glb_irq[0]); 1388 1389 acpi_iort_register_irq(hw_irq, "arm-smmu-global", trigger, 1390 &res[num_res++]); 1391 1392 /* Context IRQs */ 1393 ctx_irq = ACPI_ADD_PTR(u64, node, smmu->context_interrupt_offset); 1394 for (i = 0; i < smmu->context_interrupt_count; i++) { 1395 hw_irq = IORT_IRQ_MASK(ctx_irq[i]); 1396 trigger = IORT_IRQ_TRIGGER_MASK(ctx_irq[i]); 1397 1398 acpi_iort_register_irq(hw_irq, "arm-smmu-context", trigger, 1399 &res[num_res++]); 1400 } 1401 } 1402 1403 static void __init arm_smmu_dma_configure(struct device *dev, 1404 struct acpi_iort_node *node) 1405 { 1406 struct acpi_iort_smmu *smmu; 1407 enum dev_dma_attr attr; 1408 1409 /* Retrieve SMMU specific data */ 1410 smmu = (struct acpi_iort_smmu *)node->node_data; 1411 1412 attr = (smmu->flags & ACPI_IORT_SMMU_COHERENT_WALK) ? 1413 DEV_DMA_COHERENT : DEV_DMA_NON_COHERENT; 1414 1415 /* We expect the dma masks to be equivalent for SMMU set-ups */ 1416 dev->dma_mask = &dev->coherent_dma_mask; 1417 1418 /* Configure DMA for the page table walker */ 1419 acpi_dma_configure(dev, attr); 1420 } 1421 1422 static int __init arm_smmu_v3_pmcg_count_resources(struct acpi_iort_node *node) 1423 { 1424 struct acpi_iort_pmcg *pmcg; 1425 1426 /* Retrieve PMCG specific data */ 1427 pmcg = (struct acpi_iort_pmcg *)node->node_data; 1428 1429 /* 1430 * There are always 2 memory resources. 1431 * If the overflow_gsiv is present then add that for a total of 3. 1432 */ 1433 return pmcg->overflow_gsiv ? 3 : 2; 1434 } 1435 1436 static void __init arm_smmu_v3_pmcg_init_resources(struct resource *res, 1437 struct acpi_iort_node *node) 1438 { 1439 struct acpi_iort_pmcg *pmcg; 1440 1441 /* Retrieve PMCG specific data */ 1442 pmcg = (struct acpi_iort_pmcg *)node->node_data; 1443 1444 res[0].start = pmcg->page0_base_address; 1445 res[0].end = pmcg->page0_base_address + SZ_4K - 1; 1446 res[0].flags = IORESOURCE_MEM; 1447 res[1].start = pmcg->page1_base_address; 1448 res[1].end = pmcg->page1_base_address + SZ_4K - 1; 1449 res[1].flags = IORESOURCE_MEM; 1450 1451 if (pmcg->overflow_gsiv) 1452 acpi_iort_register_irq(pmcg->overflow_gsiv, "overflow", 1453 ACPI_EDGE_SENSITIVE, &res[2]); 1454 } 1455 1456 static struct acpi_platform_list pmcg_plat_info[] __initdata = { 1457 /* HiSilicon Hip08 Platform */ 1458 {"HISI ", "HIP08 ", 0, ACPI_SIG_IORT, greater_than_or_equal, 1459 "Erratum #162001800", IORT_SMMU_V3_PMCG_HISI_HIP08}, 1460 { } 1461 }; 1462 1463 static int __init arm_smmu_v3_pmcg_add_platdata(struct platform_device *pdev) 1464 { 1465 u32 model; 1466 int idx; 1467 1468 idx = acpi_match_platform_list(pmcg_plat_info); 1469 if (idx >= 0) 1470 model = pmcg_plat_info[idx].data; 1471 else 1472 model = IORT_SMMU_V3_PMCG_GENERIC; 1473 1474 return platform_device_add_data(pdev, &model, sizeof(model)); 1475 } 1476 1477 struct iort_dev_config { 1478 const char *name; 1479 int (*dev_init)(struct acpi_iort_node *node); 1480 void (*dev_dma_configure)(struct device *dev, 1481 struct acpi_iort_node *node); 1482 int (*dev_count_resources)(struct acpi_iort_node *node); 1483 void (*dev_init_resources)(struct resource *res, 1484 struct acpi_iort_node *node); 1485 int (*dev_set_proximity)(struct device *dev, 1486 struct acpi_iort_node *node); 1487 int (*dev_add_platdata)(struct platform_device *pdev); 1488 }; 1489 1490 static const struct iort_dev_config iort_arm_smmu_v3_cfg __initconst = { 1491 .name = "arm-smmu-v3", 1492 .dev_dma_configure = arm_smmu_v3_dma_configure, 1493 .dev_count_resources = arm_smmu_v3_count_resources, 1494 .dev_init_resources = arm_smmu_v3_init_resources, 1495 .dev_set_proximity = arm_smmu_v3_set_proximity, 1496 }; 1497 1498 static const struct iort_dev_config iort_arm_smmu_cfg __initconst = { 1499 .name = "arm-smmu", 1500 .dev_dma_configure = arm_smmu_dma_configure, 1501 .dev_count_resources = arm_smmu_count_resources, 1502 .dev_init_resources = arm_smmu_init_resources, 1503 }; 1504 1505 static const struct iort_dev_config iort_arm_smmu_v3_pmcg_cfg __initconst = { 1506 .name = "arm-smmu-v3-pmcg", 1507 .dev_count_resources = arm_smmu_v3_pmcg_count_resources, 1508 .dev_init_resources = arm_smmu_v3_pmcg_init_resources, 1509 .dev_add_platdata = arm_smmu_v3_pmcg_add_platdata, 1510 }; 1511 1512 static __init const struct iort_dev_config *iort_get_dev_cfg( 1513 struct acpi_iort_node *node) 1514 { 1515 switch (node->type) { 1516 case ACPI_IORT_NODE_SMMU_V3: 1517 return &iort_arm_smmu_v3_cfg; 1518 case ACPI_IORT_NODE_SMMU: 1519 return &iort_arm_smmu_cfg; 1520 case ACPI_IORT_NODE_PMCG: 1521 return &iort_arm_smmu_v3_pmcg_cfg; 1522 default: 1523 return NULL; 1524 } 1525 } 1526 1527 /** 1528 * iort_add_platform_device() - Allocate a platform device for IORT node 1529 * @node: Pointer to device ACPI IORT node 1530 * @ops: Pointer to IORT device config struct 1531 * 1532 * Returns: 0 on success, <0 failure 1533 */ 1534 static int __init iort_add_platform_device(struct acpi_iort_node *node, 1535 const struct iort_dev_config *ops) 1536 { 1537 struct fwnode_handle *fwnode; 1538 struct platform_device *pdev; 1539 struct resource *r; 1540 int ret, count; 1541 1542 pdev = platform_device_alloc(ops->name, PLATFORM_DEVID_AUTO); 1543 if (!pdev) 1544 return -ENOMEM; 1545 1546 if (ops->dev_set_proximity) { 1547 ret = ops->dev_set_proximity(&pdev->dev, node); 1548 if (ret) 1549 goto dev_put; 1550 } 1551 1552 count = ops->dev_count_resources(node); 1553 1554 r = kcalloc(count, sizeof(*r), GFP_KERNEL); 1555 if (!r) { 1556 ret = -ENOMEM; 1557 goto dev_put; 1558 } 1559 1560 ops->dev_init_resources(r, node); 1561 1562 ret = platform_device_add_resources(pdev, r, count); 1563 /* 1564 * Resources are duplicated in platform_device_add_resources, 1565 * free their allocated memory 1566 */ 1567 kfree(r); 1568 1569 if (ret) 1570 goto dev_put; 1571 1572 /* 1573 * Platform devices based on PMCG nodes uses platform_data to 1574 * pass the hardware model info to the driver. For others, add 1575 * a copy of IORT node pointer to platform_data to be used to 1576 * retrieve IORT data information. 1577 */ 1578 if (ops->dev_add_platdata) 1579 ret = ops->dev_add_platdata(pdev); 1580 else 1581 ret = platform_device_add_data(pdev, &node, sizeof(node)); 1582 1583 if (ret) 1584 goto dev_put; 1585 1586 fwnode = iort_get_fwnode(node); 1587 1588 if (!fwnode) { 1589 ret = -ENODEV; 1590 goto dev_put; 1591 } 1592 1593 pdev->dev.fwnode = fwnode; 1594 1595 if (ops->dev_dma_configure) 1596 ops->dev_dma_configure(&pdev->dev, node); 1597 1598 iort_set_device_domain(&pdev->dev, node); 1599 1600 ret = platform_device_add(pdev); 1601 if (ret) 1602 goto dma_deconfigure; 1603 1604 return 0; 1605 1606 dma_deconfigure: 1607 arch_teardown_dma_ops(&pdev->dev); 1608 dev_put: 1609 platform_device_put(pdev); 1610 1611 return ret; 1612 } 1613 1614 #ifdef CONFIG_PCI 1615 static void __init iort_enable_acs(struct acpi_iort_node *iort_node) 1616 { 1617 static bool acs_enabled __initdata; 1618 1619 if (acs_enabled) 1620 return; 1621 1622 if (iort_node->type == ACPI_IORT_NODE_PCI_ROOT_COMPLEX) { 1623 struct acpi_iort_node *parent; 1624 struct acpi_iort_id_mapping *map; 1625 int i; 1626 1627 map = ACPI_ADD_PTR(struct acpi_iort_id_mapping, iort_node, 1628 iort_node->mapping_offset); 1629 1630 for (i = 0; i < iort_node->mapping_count; i++, map++) { 1631 if (!map->output_reference) 1632 continue; 1633 1634 parent = ACPI_ADD_PTR(struct acpi_iort_node, 1635 iort_table, map->output_reference); 1636 /* 1637 * If we detect a RC->SMMU mapping, make sure 1638 * we enable ACS on the system. 1639 */ 1640 if ((parent->type == ACPI_IORT_NODE_SMMU) || 1641 (parent->type == ACPI_IORT_NODE_SMMU_V3)) { 1642 pci_request_acs(); 1643 acs_enabled = true; 1644 return; 1645 } 1646 } 1647 } 1648 } 1649 #else 1650 static inline void iort_enable_acs(struct acpi_iort_node *iort_node) { } 1651 #endif 1652 1653 static void __init iort_init_platform_devices(void) 1654 { 1655 struct acpi_iort_node *iort_node, *iort_end; 1656 struct acpi_table_iort *iort; 1657 struct fwnode_handle *fwnode; 1658 int i, ret; 1659 const struct iort_dev_config *ops; 1660 1661 /* 1662 * iort_table and iort both point to the start of IORT table, but 1663 * have different struct types 1664 */ 1665 iort = (struct acpi_table_iort *)iort_table; 1666 1667 /* Get the first IORT node */ 1668 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort, 1669 iort->node_offset); 1670 iort_end = ACPI_ADD_PTR(struct acpi_iort_node, iort, 1671 iort_table->length); 1672 1673 for (i = 0; i < iort->node_count; i++) { 1674 if (iort_node >= iort_end) { 1675 pr_err("iort node pointer overflows, bad table\n"); 1676 return; 1677 } 1678 1679 iort_enable_acs(iort_node); 1680 1681 ops = iort_get_dev_cfg(iort_node); 1682 if (ops) { 1683 fwnode = acpi_alloc_fwnode_static(); 1684 if (!fwnode) 1685 return; 1686 1687 iort_set_fwnode(iort_node, fwnode); 1688 1689 ret = iort_add_platform_device(iort_node, ops); 1690 if (ret) { 1691 iort_delete_fwnode(iort_node); 1692 acpi_free_fwnode_static(fwnode); 1693 return; 1694 } 1695 } 1696 1697 iort_node = ACPI_ADD_PTR(struct acpi_iort_node, iort_node, 1698 iort_node->length); 1699 } 1700 } 1701 1702 void __init acpi_iort_init(void) 1703 { 1704 acpi_status status; 1705 1706 /* iort_table will be used at runtime after the iort init, 1707 * so we don't need to call acpi_put_table() to release 1708 * the IORT table mapping. 1709 */ 1710 status = acpi_get_table(ACPI_SIG_IORT, 0, &iort_table); 1711 if (ACPI_FAILURE(status)) { 1712 if (status != AE_NOT_FOUND) { 1713 const char *msg = acpi_format_exception(status); 1714 1715 pr_err("Failed to get table, %s\n", msg); 1716 } 1717 1718 return; 1719 } 1720 1721 iort_init_platform_devices(); 1722 } 1723