4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20 #include <linux/export.h>
21 #include <linux/iommu.h>
22 #include <linux/limits.h>
24 #include <linux/of_iommu.h>
25 #include <linux/of_pci.h>
26 #include <linux/slab.h>
30 static const struct of_device_id __iommu_of_table_sentinel
31 __used
__section(__iommu_of_table_end
);
34 * of_get_dma_window - Parse *dma-window property and returns 0 if found.
37 * @prefix: prefix for property name if any
38 * @index: index to start to parse
39 * @busno: Returns busno if supported. Otherwise pass NULL
40 * @addr: Returns address that DMA starts
41 * @size: Returns the range that DMA can handle
43 * This supports different formats flexibly. "prefix" can be
44 * configured if any. "busno" and "index" are optionally
45 * specified. Set 0(or NULL) if not used.
47 int of_get_dma_window(struct device_node
*dn
, const char *prefix
, int index
,
48 unsigned long *busno
, dma_addr_t
*addr
, size_t *size
)
50 const __be32
*dma_window
, *end
;
51 int bytes
, cur_index
= 0;
52 char propname
[NAME_MAX
], addrname
[NAME_MAX
], sizename
[NAME_MAX
];
54 if (!dn
|| !addr
|| !size
)
60 snprintf(propname
, sizeof(propname
), "%sdma-window", prefix
);
61 snprintf(addrname
, sizeof(addrname
), "%s#dma-address-cells", prefix
);
62 snprintf(sizename
, sizeof(sizename
), "%s#dma-size-cells", prefix
);
64 dma_window
= of_get_property(dn
, propname
, &bytes
);
67 end
= dma_window
+ bytes
/ sizeof(*dma_window
);
69 while (dma_window
< end
) {
73 /* busno is one cell if supported */
75 *busno
= be32_to_cpup(dma_window
++);
77 prop
= of_get_property(dn
, addrname
, NULL
);
79 prop
= of_get_property(dn
, "#address-cells", NULL
);
81 cells
= prop
? be32_to_cpup(prop
) : of_n_addr_cells(dn
);
84 *addr
= of_read_number(dma_window
, cells
);
87 prop
= of_get_property(dn
, sizename
, NULL
);
88 cells
= prop
? be32_to_cpup(prop
) : of_n_size_cells(dn
);
91 *size
= of_read_number(dma_window
, cells
);
94 if (cur_index
++ == index
)
99 EXPORT_SYMBOL_GPL(of_get_dma_window
);
101 static bool of_iommu_driver_present(struct device_node
*np
)
104 * If the IOMMU still isn't ready by the time we reach init, assume
105 * it never will be. We don't want to defer indefinitely, nor attempt
106 * to dereference __iommu_of_table after it's been freed.
108 if (system_state
>= SYSTEM_RUNNING
)
111 return of_match_node(&__iommu_of_table
, np
);
114 static int of_iommu_xlate(struct device
*dev
,
115 struct of_phandle_args
*iommu_spec
)
117 const struct iommu_ops
*ops
;
118 struct fwnode_handle
*fwnode
= &iommu_spec
->np
->fwnode
;
121 ops
= iommu_ops_from_fwnode(fwnode
);
122 if ((ops
&& !ops
->of_xlate
) ||
123 !of_device_is_available(iommu_spec
->np
) ||
124 (!ops
&& !of_iommu_driver_present(iommu_spec
->np
)))
127 err
= iommu_fwspec_init(dev
, &iommu_spec
->np
->fwnode
, ops
);
131 * The otherwise-empty fwspec handily serves to indicate the specific
132 * IOMMU device we're waiting for, which will be useful if we ever get
133 * a proper probe-ordering dependency mechanism in future.
136 return -EPROBE_DEFER
;
138 return ops
->of_xlate(dev
, iommu_spec
);
141 struct of_pci_iommu_alias_info
{
143 struct device_node
*np
;
146 static int of_pci_iommu_init(struct pci_dev
*pdev
, u16 alias
, void *data
)
148 struct of_pci_iommu_alias_info
*info
= data
;
149 struct of_phandle_args iommu_spec
= { .args_count
= 1 };
152 err
= of_pci_map_rid(info
->np
, alias
, "iommu-map",
153 "iommu-map-mask", &iommu_spec
.np
,
156 return err
== -ENODEV
? NO_IOMMU
: err
;
158 err
= of_iommu_xlate(info
->dev
, &iommu_spec
);
159 of_node_put(iommu_spec
.np
);
163 const struct iommu_ops
*of_iommu_configure(struct device
*dev
,
164 struct device_node
*master_np
)
166 const struct iommu_ops
*ops
= NULL
;
167 struct iommu_fwspec
*fwspec
= dev
->iommu_fwspec
;
177 /* In the deferred case, start again from scratch */
178 iommu_fwspec_free(dev
);
182 * We don't currently walk up the tree looking for a parent IOMMU.
183 * See the `Notes:' section of
184 * Documentation/devicetree/bindings/iommu/iommu.txt
186 if (dev_is_pci(dev
)) {
187 struct of_pci_iommu_alias_info info
= {
192 err
= pci_for_each_dma_alias(to_pci_dev(dev
),
193 of_pci_iommu_init
, &info
);
195 struct of_phandle_args iommu_spec
;
198 while (!of_parse_phandle_with_args(master_np
, "iommus",
201 err
= of_iommu_xlate(dev
, &iommu_spec
);
202 of_node_put(iommu_spec
.np
);
210 * Two success conditions can be represented by non-negative err here:
211 * >0 : there is no IOMMU, or one was unavailable for non-fatal reasons
212 * 0 : we found an IOMMU, and dev->fwspec is initialised appropriately
213 * <0 : any actual error
216 ops
= dev
->iommu_fwspec
->ops
;
218 * If we have reason to believe the IOMMU driver missed the initial
219 * add_device callback for dev, replay it to get things in order.
221 if (ops
&& ops
->add_device
&& dev
->bus
&& !dev
->iommu_group
)
222 err
= ops
->add_device(dev
);
224 /* Ignore all other errors apart from EPROBE_DEFER */
225 if (err
== -EPROBE_DEFER
) {
227 } else if (err
< 0) {
228 dev_dbg(dev
, "Adding to IOMMU failed: %d\n", err
);