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