2 * Copyright (C) 2016, Semihalf
3 * Author: Tomasz Nowicki <tn@semihalf.com>
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * This file implements early detection/parsing of I/O mapping
15 * reported to OS through firmware via I/O Remapping Table (IORT)
16 * IORT document number: ARM DEN 0049A
19 #define pr_fmt(fmt) "ACPI: IORT: " fmt
21 #include <linux/acpi_iort.h>
22 #include <linux/iommu.h>
23 #include <linux/kernel.h>
24 #include <linux/list.h>
25 #include <linux/pci.h>
26 #include <linux/platform_device.h>
27 #include <linux/slab.h>
29 #define IORT_TYPE_MASK(type) (1 << (type))
30 #define IORT_MSI_TYPE (1 << ACPI_IORT_NODE_ITS_GROUP)
31 #define IORT_IOMMU_TYPE ((1 << ACPI_IORT_NODE_SMMU) | \
32 (1 << ACPI_IORT_NODE_SMMU_V3))
34 struct iort_its_msi_chip
{
35 struct list_head list
;
36 struct fwnode_handle
*fw_node
;
41 struct list_head list
;
42 struct acpi_iort_node
*iort_node
;
43 struct fwnode_handle
*fwnode
;
45 static LIST_HEAD(iort_fwnode_list
);
46 static DEFINE_SPINLOCK(iort_fwnode_lock
);
49 * iort_set_fwnode() - Create iort_fwnode and use it to register
50 * iommu data in the iort_fwnode_list
52 * @node: IORT table node associated with the IOMMU
53 * @fwnode: fwnode associated with the IORT node
55 * Returns: 0 on success
58 static inline int iort_set_fwnode(struct acpi_iort_node
*iort_node
,
59 struct fwnode_handle
*fwnode
)
61 struct iort_fwnode
*np
;
63 np
= kzalloc(sizeof(struct iort_fwnode
), GFP_ATOMIC
);
68 INIT_LIST_HEAD(&np
->list
);
69 np
->iort_node
= iort_node
;
72 spin_lock(&iort_fwnode_lock
);
73 list_add_tail(&np
->list
, &iort_fwnode_list
);
74 spin_unlock(&iort_fwnode_lock
);
80 * iort_get_fwnode() - Retrieve fwnode associated with an IORT node
82 * @node: IORT table node to be looked-up
84 * Returns: fwnode_handle pointer on success, NULL on failure
87 struct fwnode_handle
*iort_get_fwnode(struct acpi_iort_node
*node
)
89 struct iort_fwnode
*curr
;
90 struct fwnode_handle
*fwnode
= NULL
;
92 spin_lock(&iort_fwnode_lock
);
93 list_for_each_entry(curr
, &iort_fwnode_list
, list
) {
94 if (curr
->iort_node
== node
) {
95 fwnode
= curr
->fwnode
;
99 spin_unlock(&iort_fwnode_lock
);
105 * iort_delete_fwnode() - Delete fwnode associated with an IORT node
107 * @node: IORT table node associated with fwnode to delete
109 static inline void iort_delete_fwnode(struct acpi_iort_node
*node
)
111 struct iort_fwnode
*curr
, *tmp
;
113 spin_lock(&iort_fwnode_lock
);
114 list_for_each_entry_safe(curr
, tmp
, &iort_fwnode_list
, list
) {
115 if (curr
->iort_node
== node
) {
116 list_del(&curr
->list
);
121 spin_unlock(&iort_fwnode_lock
);
124 typedef acpi_status (*iort_find_node_callback
)
125 (struct acpi_iort_node
*node
, void *context
);
127 /* Root pointer to the mapped IORT table */
128 static struct acpi_table_header
*iort_table
;
130 static LIST_HEAD(iort_msi_chip_list
);
131 static DEFINE_SPINLOCK(iort_msi_chip_lock
);
134 * iort_register_domain_token() - register domain token and related ITS ID
135 * to the list from where we can get it back later on.
137 * @fw_node: Domain token.
139 * Returns: 0 on success, -ENOMEM if no memory when allocating list element
141 int iort_register_domain_token(int trans_id
, struct fwnode_handle
*fw_node
)
143 struct iort_its_msi_chip
*its_msi_chip
;
145 its_msi_chip
= kzalloc(sizeof(*its_msi_chip
), GFP_KERNEL
);
149 its_msi_chip
->fw_node
= fw_node
;
150 its_msi_chip
->translation_id
= trans_id
;
152 spin_lock(&iort_msi_chip_lock
);
153 list_add(&its_msi_chip
->list
, &iort_msi_chip_list
);
154 spin_unlock(&iort_msi_chip_lock
);
160 * iort_deregister_domain_token() - Deregister domain token based on ITS ID
165 void iort_deregister_domain_token(int trans_id
)
167 struct iort_its_msi_chip
*its_msi_chip
, *t
;
169 spin_lock(&iort_msi_chip_lock
);
170 list_for_each_entry_safe(its_msi_chip
, t
, &iort_msi_chip_list
, list
) {
171 if (its_msi_chip
->translation_id
== trans_id
) {
172 list_del(&its_msi_chip
->list
);
177 spin_unlock(&iort_msi_chip_lock
);
181 * iort_find_domain_token() - Find domain token based on given ITS ID
184 * Returns: domain token when find on the list, NULL otherwise
186 struct fwnode_handle
*iort_find_domain_token(int trans_id
)
188 struct fwnode_handle
*fw_node
= NULL
;
189 struct iort_its_msi_chip
*its_msi_chip
;
191 spin_lock(&iort_msi_chip_lock
);
192 list_for_each_entry(its_msi_chip
, &iort_msi_chip_list
, list
) {
193 if (its_msi_chip
->translation_id
== trans_id
) {
194 fw_node
= its_msi_chip
->fw_node
;
198 spin_unlock(&iort_msi_chip_lock
);
203 static struct acpi_iort_node
*iort_scan_node(enum acpi_iort_node_type type
,
204 iort_find_node_callback callback
,
207 struct acpi_iort_node
*iort_node
, *iort_end
;
208 struct acpi_table_iort
*iort
;
214 /* Get the first IORT node */
215 iort
= (struct acpi_table_iort
*)iort_table
;
216 iort_node
= ACPI_ADD_PTR(struct acpi_iort_node
, iort
,
218 iort_end
= ACPI_ADD_PTR(struct acpi_iort_node
, iort_table
,
221 for (i
= 0; i
< iort
->node_count
; i
++) {
222 if (WARN_TAINT(iort_node
>= iort_end
, TAINT_FIRMWARE_WORKAROUND
,
223 "IORT node pointer overflows, bad table!\n"))
226 if (iort_node
->type
== type
&&
227 ACPI_SUCCESS(callback(iort_node
, context
)))
230 iort_node
= ACPI_ADD_PTR(struct acpi_iort_node
, iort_node
,
238 iort_match_type_callback(struct acpi_iort_node
*node
, void *context
)
243 bool iort_node_match(u8 type
)
245 struct acpi_iort_node
*node
;
247 node
= iort_scan_node(type
, iort_match_type_callback
, NULL
);
252 static acpi_status
iort_match_node_callback(struct acpi_iort_node
*node
,
255 struct device
*dev
= context
;
256 acpi_status status
= AE_NOT_FOUND
;
258 if (node
->type
== ACPI_IORT_NODE_NAMED_COMPONENT
) {
259 struct acpi_buffer buf
= { ACPI_ALLOCATE_BUFFER
, NULL
};
260 struct acpi_device
*adev
= to_acpi_device_node(dev
->fwnode
);
261 struct acpi_iort_named_component
*ncomp
;
266 status
= acpi_get_name(adev
->handle
, ACPI_FULL_PATHNAME
, &buf
);
267 if (ACPI_FAILURE(status
)) {
268 dev_warn(dev
, "Can't get device full path name\n");
272 ncomp
= (struct acpi_iort_named_component
*)node
->node_data
;
273 status
= !strcmp(ncomp
->device_name
, buf
.pointer
) ?
274 AE_OK
: AE_NOT_FOUND
;
275 acpi_os_free(buf
.pointer
);
276 } else if (node
->type
== ACPI_IORT_NODE_PCI_ROOT_COMPLEX
) {
277 struct acpi_iort_root_complex
*pci_rc
;
280 bus
= to_pci_bus(dev
);
281 pci_rc
= (struct acpi_iort_root_complex
*)node
->node_data
;
284 * It is assumed that PCI segment numbers maps one-to-one
285 * with root complexes. Each segment number can represent only
288 status
= pci_rc
->pci_segment_number
== pci_domain_nr(bus
) ?
289 AE_OK
: AE_NOT_FOUND
;
295 static int iort_id_map(struct acpi_iort_id_mapping
*map
, u8 type
, u32 rid_in
,
298 /* Single mapping does not care for input id */
299 if (map
->flags
& ACPI_IORT_ID_SINGLE_MAPPING
) {
300 if (type
== ACPI_IORT_NODE_NAMED_COMPONENT
||
301 type
== ACPI_IORT_NODE_PCI_ROOT_COMPLEX
) {
302 *rid_out
= map
->output_base
;
306 pr_warn(FW_BUG
"[map %p] SINGLE MAPPING flag not allowed for node type %d, skipping ID map\n",
311 if (rid_in
< map
->input_base
||
312 (rid_in
>= map
->input_base
+ map
->id_count
))
315 *rid_out
= map
->output_base
+ (rid_in
- map
->input_base
);
320 struct acpi_iort_node
*iort_node_get_id(struct acpi_iort_node
*node
,
321 u32
*id_out
, int index
)
323 struct acpi_iort_node
*parent
;
324 struct acpi_iort_id_mapping
*map
;
326 if (!node
->mapping_offset
|| !node
->mapping_count
||
327 index
>= node
->mapping_count
)
330 map
= ACPI_ADD_PTR(struct acpi_iort_id_mapping
, node
,
331 node
->mapping_offset
+ index
* sizeof(*map
));
334 if (!map
->output_reference
) {
335 pr_err(FW_BUG
"[node %p type %d] ID map has NULL parent reference\n",
340 parent
= ACPI_ADD_PTR(struct acpi_iort_node
, iort_table
,
341 map
->output_reference
);
343 if (map
->flags
& ACPI_IORT_ID_SINGLE_MAPPING
) {
344 if (node
->type
== ACPI_IORT_NODE_NAMED_COMPONENT
||
345 node
->type
== ACPI_IORT_NODE_PCI_ROOT_COMPLEX
) {
346 *id_out
= map
->output_base
;
354 static struct acpi_iort_node
*iort_node_map_id(struct acpi_iort_node
*node
,
355 u32 id_in
, u32
*id_out
,
360 /* Parse the ID mapping tree to find specified node type */
362 struct acpi_iort_id_mapping
*map
;
365 if (IORT_TYPE_MASK(node
->type
) & type_mask
) {
371 if (!node
->mapping_offset
|| !node
->mapping_count
)
374 map
= ACPI_ADD_PTR(struct acpi_iort_id_mapping
, node
,
375 node
->mapping_offset
);
378 if (!map
->output_reference
) {
379 pr_err(FW_BUG
"[node %p type %d] ID map has NULL parent reference\n",
384 /* Do the ID translation */
385 for (i
= 0; i
< node
->mapping_count
; i
++, map
++) {
386 if (!iort_id_map(map
, node
->type
, id
, &id
))
390 if (i
== node
->mapping_count
)
393 node
= ACPI_ADD_PTR(struct acpi_iort_node
, iort_table
,
394 map
->output_reference
);
398 /* Map input ID to output ID unchanged on mapping failure */
406 struct acpi_iort_node
*iort_node_map_platform_id(struct acpi_iort_node
*node
,
407 u32
*id_out
, u8 type_mask
,
410 struct acpi_iort_node
*parent
;
413 /* step 1: retrieve the initial dev id */
414 parent
= iort_node_get_id(node
, &id
, index
);
419 * optional step 2: map the initial dev id if its parent is not
420 * the target type we want, map it again for the use cases such
421 * as NC (named component) -> SMMU -> ITS. If the type is matched,
422 * return the initial dev id and its parent pointer directly.
424 if (!(IORT_TYPE_MASK(parent
->type
) & type_mask
))
425 parent
= iort_node_map_id(parent
, id
, id_out
, type_mask
);
433 static struct acpi_iort_node
*iort_find_dev_node(struct device
*dev
)
435 struct pci_bus
*pbus
;
437 if (!dev_is_pci(dev
))
438 return iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT
,
439 iort_match_node_callback
, dev
);
441 /* Find a PCI root bus */
442 pbus
= to_pci_dev(dev
)->bus
;
443 while (!pci_is_root_bus(pbus
))
446 return iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX
,
447 iort_match_node_callback
, &pbus
->dev
);
451 * iort_msi_map_rid() - Map a MSI requester ID for a device
452 * @dev: The device for which the mapping is to be done.
453 * @req_id: The device requester ID.
455 * Returns: mapped MSI RID on success, input requester ID otherwise
457 u32
iort_msi_map_rid(struct device
*dev
, u32 req_id
)
459 struct acpi_iort_node
*node
;
462 node
= iort_find_dev_node(dev
);
466 iort_node_map_id(node
, req_id
, &dev_id
, IORT_MSI_TYPE
);
471 * iort_pmsi_get_dev_id() - Get the device id for a device
472 * @dev: The device for which the mapping is to be done.
473 * @dev_id: The device ID found.
475 * Returns: 0 for successful find a dev id, -ENODEV on error
477 int iort_pmsi_get_dev_id(struct device
*dev
, u32
*dev_id
)
480 struct acpi_iort_node
*node
;
482 node
= iort_find_dev_node(dev
);
486 for (i
= 0; i
< node
->mapping_count
; i
++) {
487 if (iort_node_map_platform_id(node
, dev_id
, IORT_MSI_TYPE
, i
))
495 * iort_dev_find_its_id() - Find the ITS identifier for a device
497 * @req_id: Device's requester ID
498 * @idx: Index of the ITS identifier list.
499 * @its_id: ITS identifier.
501 * Returns: 0 on success, appropriate error value otherwise
503 static int iort_dev_find_its_id(struct device
*dev
, u32 req_id
,
504 unsigned int idx
, int *its_id
)
506 struct acpi_iort_its_group
*its
;
507 struct acpi_iort_node
*node
;
509 node
= iort_find_dev_node(dev
);
513 node
= iort_node_map_id(node
, req_id
, NULL
, IORT_MSI_TYPE
);
517 /* Move to ITS specific data */
518 its
= (struct acpi_iort_its_group
*)node
->node_data
;
519 if (idx
> its
->its_count
) {
520 dev_err(dev
, "requested ITS ID index [%d] is greater than available [%d]\n",
521 idx
, its
->its_count
);
525 *its_id
= its
->identifiers
[idx
];
530 * iort_get_device_domain() - Find MSI domain related to a device
532 * @req_id: Requester ID for the device.
534 * Returns: the MSI domain for this device, NULL otherwise
536 struct irq_domain
*iort_get_device_domain(struct device
*dev
, u32 req_id
)
538 struct fwnode_handle
*handle
;
541 if (iort_dev_find_its_id(dev
, req_id
, 0, &its_id
))
544 handle
= iort_find_domain_token(its_id
);
548 return irq_find_matching_fwnode(handle
, DOMAIN_BUS_PCI_MSI
);
551 static int __get_pci_rid(struct pci_dev
*pdev
, u16 alias
, void *data
)
559 static int arm_smmu_iort_xlate(struct device
*dev
, u32 streamid
,
560 struct fwnode_handle
*fwnode
,
561 const struct iommu_ops
*ops
)
563 int ret
= iommu_fwspec_init(dev
, fwnode
, ops
);
566 ret
= iommu_fwspec_add_ids(dev
, &streamid
, 1);
571 static const struct iommu_ops
*iort_iommu_xlate(struct device
*dev
,
572 struct acpi_iort_node
*node
,
575 const struct iommu_ops
*ops
= NULL
;
577 struct fwnode_handle
*iort_fwnode
;
580 iort_fwnode
= iort_get_fwnode(node
);
584 ops
= iommu_get_instance(iort_fwnode
);
588 ret
= arm_smmu_iort_xlate(dev
, streamid
, iort_fwnode
, ops
);
591 return ret
? NULL
: ops
;
595 * iort_set_dma_mask - Set-up dma mask for a device.
597 * @dev: device to configure
599 void iort_set_dma_mask(struct device
*dev
)
602 * Set default coherent_dma_mask to 32 bit. Drivers are expected to
603 * setup the correct supported mask.
605 if (!dev
->coherent_dma_mask
)
606 dev
->coherent_dma_mask
= DMA_BIT_MASK(32);
609 * Set it to coherent_dma_mask by default if the architecture
610 * code has not set it.
613 dev
->dma_mask
= &dev
->coherent_dma_mask
;
617 * iort_iommu_configure - Set-up IOMMU configuration for a device.
619 * @dev: device to configure
621 * Returns: iommu_ops pointer on configuration success
622 * NULL on configuration failure
624 const struct iommu_ops
*iort_iommu_configure(struct device
*dev
)
626 struct acpi_iort_node
*node
, *parent
;
627 const struct iommu_ops
*ops
= NULL
;
630 if (dev_is_pci(dev
)) {
631 struct pci_bus
*bus
= to_pci_dev(dev
)->bus
;
634 pci_for_each_dma_alias(to_pci_dev(dev
), __get_pci_rid
,
637 node
= iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX
,
638 iort_match_node_callback
, &bus
->dev
);
642 parent
= iort_node_map_id(node
, rid
, &streamid
,
645 ops
= iort_iommu_xlate(dev
, parent
, streamid
);
650 node
= iort_scan_node(ACPI_IORT_NODE_NAMED_COMPONENT
,
651 iort_match_node_callback
, dev
);
655 parent
= iort_node_map_platform_id(node
, &streamid
,
656 IORT_IOMMU_TYPE
, i
++);
659 ops
= iort_iommu_xlate(dev
, parent
, streamid
);
661 parent
= iort_node_map_platform_id(node
, &streamid
,
670 static void __init
acpi_iort_register_irq(int hwirq
, const char *name
,
672 struct resource
*res
)
674 int irq
= acpi_register_gsi(NULL
, hwirq
, trigger
,
678 pr_err("could not register gsi hwirq %d name [%s]\n", hwirq
,
685 res
->flags
= IORESOURCE_IRQ
;
689 static int __init
arm_smmu_v3_count_resources(struct acpi_iort_node
*node
)
691 struct acpi_iort_smmu_v3
*smmu
;
692 /* Always present mem resource */
695 /* Retrieve SMMUv3 specific data */
696 smmu
= (struct acpi_iort_smmu_v3
*)node
->node_data
;
698 if (smmu
->event_gsiv
)
713 static void __init
arm_smmu_v3_init_resources(struct resource
*res
,
714 struct acpi_iort_node
*node
)
716 struct acpi_iort_smmu_v3
*smmu
;
719 /* Retrieve SMMUv3 specific data */
720 smmu
= (struct acpi_iort_smmu_v3
*)node
->node_data
;
722 res
[num_res
].start
= smmu
->base_address
;
723 res
[num_res
].end
= smmu
->base_address
+ SZ_128K
- 1;
724 res
[num_res
].flags
= IORESOURCE_MEM
;
728 if (smmu
->event_gsiv
)
729 acpi_iort_register_irq(smmu
->event_gsiv
, "eventq",
734 acpi_iort_register_irq(smmu
->pri_gsiv
, "priq",
739 acpi_iort_register_irq(smmu
->gerr_gsiv
, "gerror",
744 acpi_iort_register_irq(smmu
->sync_gsiv
, "cmdq-sync",
749 static bool __init
arm_smmu_v3_is_coherent(struct acpi_iort_node
*node
)
751 struct acpi_iort_smmu_v3
*smmu
;
753 /* Retrieve SMMUv3 specific data */
754 smmu
= (struct acpi_iort_smmu_v3
*)node
->node_data
;
756 return smmu
->flags
& ACPI_IORT_SMMU_V3_COHACC_OVERRIDE
;
759 static int __init
arm_smmu_count_resources(struct acpi_iort_node
*node
)
761 struct acpi_iort_smmu
*smmu
;
763 /* Retrieve SMMU specific data */
764 smmu
= (struct acpi_iort_smmu
*)node
->node_data
;
767 * Only consider the global fault interrupt and ignore the
768 * configuration access interrupt.
770 * MMIO address and global fault interrupt resources are always
771 * present so add them to the context interrupt count as a static
774 return smmu
->context_interrupt_count
+ 2;
777 static void __init
arm_smmu_init_resources(struct resource
*res
,
778 struct acpi_iort_node
*node
)
780 struct acpi_iort_smmu
*smmu
;
781 int i
, hw_irq
, trigger
, num_res
= 0;
782 u64
*ctx_irq
, *glb_irq
;
784 /* Retrieve SMMU specific data */
785 smmu
= (struct acpi_iort_smmu
*)node
->node_data
;
787 res
[num_res
].start
= smmu
->base_address
;
788 res
[num_res
].end
= smmu
->base_address
+ smmu
->span
- 1;
789 res
[num_res
].flags
= IORESOURCE_MEM
;
792 glb_irq
= ACPI_ADD_PTR(u64
, node
, smmu
->global_interrupt_offset
);
794 hw_irq
= IORT_IRQ_MASK(glb_irq
[0]);
795 trigger
= IORT_IRQ_TRIGGER_MASK(glb_irq
[0]);
797 acpi_iort_register_irq(hw_irq
, "arm-smmu-global", trigger
,
801 ctx_irq
= ACPI_ADD_PTR(u64
, node
, smmu
->context_interrupt_offset
);
802 for (i
= 0; i
< smmu
->context_interrupt_count
; i
++) {
803 hw_irq
= IORT_IRQ_MASK(ctx_irq
[i
]);
804 trigger
= IORT_IRQ_TRIGGER_MASK(ctx_irq
[i
]);
806 acpi_iort_register_irq(hw_irq
, "arm-smmu-context", trigger
,
811 static bool __init
arm_smmu_is_coherent(struct acpi_iort_node
*node
)
813 struct acpi_iort_smmu
*smmu
;
815 /* Retrieve SMMU specific data */
816 smmu
= (struct acpi_iort_smmu
*)node
->node_data
;
818 return smmu
->flags
& ACPI_IORT_SMMU_COHERENT_WALK
;
821 struct iort_iommu_config
{
823 int (*iommu_init
)(struct acpi_iort_node
*node
);
824 bool (*iommu_is_coherent
)(struct acpi_iort_node
*node
);
825 int (*iommu_count_resources
)(struct acpi_iort_node
*node
);
826 void (*iommu_init_resources
)(struct resource
*res
,
827 struct acpi_iort_node
*node
);
830 static const struct iort_iommu_config iort_arm_smmu_v3_cfg __initconst
= {
831 .name
= "arm-smmu-v3",
832 .iommu_is_coherent
= arm_smmu_v3_is_coherent
,
833 .iommu_count_resources
= arm_smmu_v3_count_resources
,
834 .iommu_init_resources
= arm_smmu_v3_init_resources
837 static const struct iort_iommu_config iort_arm_smmu_cfg __initconst
= {
839 .iommu_is_coherent
= arm_smmu_is_coherent
,
840 .iommu_count_resources
= arm_smmu_count_resources
,
841 .iommu_init_resources
= arm_smmu_init_resources
845 const struct iort_iommu_config
*iort_get_iommu_cfg(struct acpi_iort_node
*node
)
847 switch (node
->type
) {
848 case ACPI_IORT_NODE_SMMU_V3
:
849 return &iort_arm_smmu_v3_cfg
;
850 case ACPI_IORT_NODE_SMMU
:
851 return &iort_arm_smmu_cfg
;
858 * iort_add_smmu_platform_device() - Allocate a platform device for SMMU
859 * @node: Pointer to SMMU ACPI IORT node
861 * Returns: 0 on success, <0 failure
863 static int __init
iort_add_smmu_platform_device(struct acpi_iort_node
*node
)
865 struct fwnode_handle
*fwnode
;
866 struct platform_device
*pdev
;
868 enum dev_dma_attr attr
;
870 const struct iort_iommu_config
*ops
= iort_get_iommu_cfg(node
);
875 pdev
= platform_device_alloc(ops
->name
, PLATFORM_DEVID_AUTO
);
877 return PTR_ERR(pdev
);
879 count
= ops
->iommu_count_resources(node
);
881 r
= kcalloc(count
, sizeof(*r
), GFP_KERNEL
);
887 ops
->iommu_init_resources(r
, node
);
889 ret
= platform_device_add_resources(pdev
, r
, count
);
891 * Resources are duplicated in platform_device_add_resources,
892 * free their allocated memory
900 * Add a copy of IORT node pointer to platform_data to
901 * be used to retrieve IORT data information.
903 ret
= platform_device_add_data(pdev
, &node
, sizeof(node
));
908 * We expect the dma masks to be equivalent for
911 pdev
->dev
.dma_mask
= &pdev
->dev
.coherent_dma_mask
;
913 fwnode
= iort_get_fwnode(node
);
920 pdev
->dev
.fwnode
= fwnode
;
922 attr
= ops
->iommu_is_coherent(node
) ?
923 DEV_DMA_COHERENT
: DEV_DMA_NON_COHERENT
;
925 /* Configure DMA for the page table walker */
926 acpi_dma_configure(&pdev
->dev
, attr
);
928 ret
= platform_device_add(pdev
);
930 goto dma_deconfigure
;
935 acpi_dma_deconfigure(&pdev
->dev
);
937 platform_device_put(pdev
);
942 static void __init
iort_init_platform_devices(void)
944 struct acpi_iort_node
*iort_node
, *iort_end
;
945 struct acpi_table_iort
*iort
;
946 struct fwnode_handle
*fwnode
;
950 * iort_table and iort both point to the start of IORT table, but
951 * have different struct types
953 iort
= (struct acpi_table_iort
*)iort_table
;
955 /* Get the first IORT node */
956 iort_node
= ACPI_ADD_PTR(struct acpi_iort_node
, iort
,
958 iort_end
= ACPI_ADD_PTR(struct acpi_iort_node
, iort
,
961 for (i
= 0; i
< iort
->node_count
; i
++) {
962 if (iort_node
>= iort_end
) {
963 pr_err("iort node pointer overflows, bad table\n");
967 if ((iort_node
->type
== ACPI_IORT_NODE_SMMU
) ||
968 (iort_node
->type
== ACPI_IORT_NODE_SMMU_V3
)) {
970 fwnode
= acpi_alloc_fwnode_static();
974 iort_set_fwnode(iort_node
, fwnode
);
976 ret
= iort_add_smmu_platform_device(iort_node
);
978 iort_delete_fwnode(iort_node
);
979 acpi_free_fwnode_static(fwnode
);
984 iort_node
= ACPI_ADD_PTR(struct acpi_iort_node
, iort_node
,
989 void __init
acpi_iort_init(void)
993 status
= acpi_get_table(ACPI_SIG_IORT
, 0, &iort_table
);
994 if (ACPI_FAILURE(status
)) {
995 if (status
!= AE_NOT_FOUND
) {
996 const char *msg
= acpi_format_exception(status
);
998 pr_err("Failed to get table, %s\n", msg
);
1004 iort_init_platform_devices();
1006 acpi_probe_device_table(iort
);