drivers/acpi/arm64/iort.c

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