1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * OF helpers for IOMMU
4 *
5 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
6 */
7
8 #include <linux/export.h>
9 #include <linux/iommu.h>
10 #include <linux/limits.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/of_address.h>
14 #include <linux/of_iommu.h>
15 #include <linux/of_pci.h>
16 #include <linux/pci.h>
17 #include <linux/slab.h>
18 #include <linux/fsl/mc.h>
19
20 #include "iommu-priv.h"
21
of_iommu_xlate(struct device * dev,struct of_phandle_args * iommu_spec)22 static int of_iommu_xlate(struct device *dev,
23 struct of_phandle_args *iommu_spec)
24 {
25 const struct iommu_ops *ops;
26 int ret;
27
28 if (!of_device_is_available(iommu_spec->np))
29 return -ENODEV;
30
31 ret = iommu_fwspec_init(dev, of_fwnode_handle(iommu_spec->np));
32 if (ret == -EPROBE_DEFER)
33 return driver_deferred_probe_check_state(dev);
34 if (ret)
35 return ret;
36
37 ops = iommu_ops_from_fwnode(&iommu_spec->np->fwnode);
38 if (!ops->of_xlate || !try_module_get(ops->owner))
39 return -ENODEV;
40
41 ret = ops->of_xlate(dev, iommu_spec);
42 module_put(ops->owner);
43 return ret;
44 }
45
of_iommu_configure_dev_id(struct device_node * master_np,struct device * dev,const u32 * id)46 static int of_iommu_configure_dev_id(struct device_node *master_np,
47 struct device *dev,
48 const u32 *id)
49 {
50 struct of_phandle_args iommu_spec = { .args_count = 1 };
51 int err;
52
53 err = of_map_id(master_np, *id, "iommu-map",
54 "iommu-map-mask", &iommu_spec.np,
55 iommu_spec.args);
56 if (err)
57 return err;
58
59 err = of_iommu_xlate(dev, &iommu_spec);
60 of_node_put(iommu_spec.np);
61 return err;
62 }
63
of_iommu_configure_dev(struct device_node * master_np,struct device * dev)64 static int of_iommu_configure_dev(struct device_node *master_np,
65 struct device *dev)
66 {
67 struct of_phandle_args iommu_spec;
68 int err = -ENODEV, idx = 0;
69
70 while (!of_parse_phandle_with_args(master_np, "iommus",
71 "#iommu-cells",
72 idx, &iommu_spec)) {
73 err = of_iommu_xlate(dev, &iommu_spec);
74 of_node_put(iommu_spec.np);
75 idx++;
76 if (err)
77 break;
78 }
79
80 return err;
81 }
82
83 struct of_pci_iommu_alias_info {
84 struct device *dev;
85 struct device_node *np;
86 };
87
of_pci_iommu_init(struct pci_dev * pdev,u16 alias,void * data)88 static int of_pci_iommu_init(struct pci_dev *pdev, u16 alias, void *data)
89 {
90 struct of_pci_iommu_alias_info *info = data;
91 u32 input_id = alias;
92
93 return of_iommu_configure_dev_id(info->np, info->dev, &input_id);
94 }
95
of_iommu_configure_device(struct device_node * master_np,struct device * dev,const u32 * id)96 static int of_iommu_configure_device(struct device_node *master_np,
97 struct device *dev, const u32 *id)
98 {
99 return (id) ? of_iommu_configure_dev_id(master_np, dev, id) :
100 of_iommu_configure_dev(master_np, dev);
101 }
102
of_pci_check_device_ats(struct device * dev,struct device_node * np)103 static void of_pci_check_device_ats(struct device *dev, struct device_node *np)
104 {
105 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev);
106
107 if (fwspec && of_property_read_bool(np, "ats-supported"))
108 fwspec->flags |= IOMMU_FWSPEC_PCI_RC_ATS;
109 }
110
111 /*
112 * Returns:
113 * 0 on success, an iommu was configured
114 * -ENODEV if the device does not have any IOMMU
115 * -EPROBEDEFER if probing should be tried again
116 * -errno fatal errors
117 */
of_iommu_configure(struct device * dev,struct device_node * master_np,const u32 * id)118 int of_iommu_configure(struct device *dev, struct device_node *master_np,
119 const u32 *id)
120 {
121 bool dev_iommu_present;
122 int err;
123
124 if (!master_np)
125 return -ENODEV;
126
127 /* Serialise to make dev->iommu stable under our potential fwspec */
128 mutex_lock(&iommu_probe_device_lock);
129 if (dev_iommu_fwspec_get(dev)) {
130 mutex_unlock(&iommu_probe_device_lock);
131 return 0;
132 }
133 dev_iommu_present = dev->iommu;
134
135 /*
136 * We don't currently walk up the tree looking for a parent IOMMU.
137 * See the `Notes:' section of
138 * Documentation/devicetree/bindings/iommu/iommu.txt
139 */
140 if (dev_is_pci(dev)) {
141 struct of_pci_iommu_alias_info info = {
142 .dev = dev,
143 .np = master_np,
144 };
145
146 pci_request_acs();
147 err = pci_for_each_dma_alias(to_pci_dev(dev),
148 of_pci_iommu_init, &info);
149 of_pci_check_device_ats(dev, master_np);
150 } else {
151 err = of_iommu_configure_device(master_np, dev, id);
152 }
153
154 if (err && dev_iommu_present)
155 iommu_fwspec_free(dev);
156 else if (err && dev->iommu)
157 dev_iommu_free(dev);
158 mutex_unlock(&iommu_probe_device_lock);
159
160 if (!err && dev->bus)
161 err = iommu_probe_device(dev);
162
163 if (err && err != -EPROBE_DEFER)
164 dev_dbg(dev, "Adding to IOMMU failed: %d\n", err);
165
166 return err;
167 }
168
169 static enum iommu_resv_type __maybe_unused
iommu_resv_region_get_type(struct device * dev,struct resource * phys,phys_addr_t start,size_t length)170 iommu_resv_region_get_type(struct device *dev,
171 struct resource *phys,
172 phys_addr_t start, size_t length)
173 {
174 phys_addr_t end = start + length - 1;
175
176 /*
177 * IOMMU regions without an associated physical region cannot be
178 * mapped and are simply reservations.
179 */
180 if (phys->start >= phys->end)
181 return IOMMU_RESV_RESERVED;
182
183 /* may be IOMMU_RESV_DIRECT_RELAXABLE for certain cases */
184 if (start == phys->start && end == phys->end)
185 return IOMMU_RESV_DIRECT;
186
187 dev_warn(dev, "treating non-direct mapping [%pr] -> [%pap-%pap] as reservation\n", phys,
188 &start, &end);
189 return IOMMU_RESV_RESERVED;
190 }
191
192 /**
193 * of_iommu_get_resv_regions - reserved region driver helper for device tree
194 * @dev: device for which to get reserved regions
195 * @list: reserved region list
196 *
197 * IOMMU drivers can use this to implement their .get_resv_regions() callback
198 * for memory regions attached to a device tree node. See the reserved-memory
199 * device tree bindings on how to use these:
200 *
201 * Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt
202 */
of_iommu_get_resv_regions(struct device * dev,struct list_head * list)203 void of_iommu_get_resv_regions(struct device *dev, struct list_head *list)
204 {
205 #if IS_ENABLED(CONFIG_OF_ADDRESS)
206 struct of_phandle_iterator it;
207 int err;
208
209 of_for_each_phandle(&it, err, dev->of_node, "memory-region", NULL, 0) {
210 const __be32 *maps, *end;
211 struct resource phys;
212 int size;
213
214 memset(&phys, 0, sizeof(phys));
215
216 /*
217 * The "reg" property is optional and can be omitted by reserved-memory regions
218 * that represent reservations in the IOVA space, which are regions that should
219 * not be mapped.
220 */
221 if (of_property_present(it.node, "reg")) {
222 err = of_address_to_resource(it.node, 0, &phys);
223 if (err < 0) {
224 dev_err(dev, "failed to parse memory region %pOF: %d\n",
225 it.node, err);
226 continue;
227 }
228 }
229
230 maps = of_get_property(it.node, "iommu-addresses", &size);
231 if (!maps)
232 continue;
233
234 end = maps + size / sizeof(__be32);
235
236 while (maps < end) {
237 struct device_node *np;
238 u32 phandle;
239
240 phandle = be32_to_cpup(maps++);
241 np = of_find_node_by_phandle(phandle);
242
243 if (np == dev->of_node) {
244 int prot = IOMMU_READ | IOMMU_WRITE;
245 struct iommu_resv_region *region;
246 enum iommu_resv_type type;
247 phys_addr_t iova;
248 size_t length;
249
250 if (of_dma_is_coherent(dev->of_node))
251 prot |= IOMMU_CACHE;
252
253 maps = of_translate_dma_region(np, maps, &iova, &length);
254 if (length == 0) {
255 dev_warn(dev, "Cannot reserve IOVA region of 0 size\n");
256 continue;
257 }
258 type = iommu_resv_region_get_type(dev, &phys, iova, length);
259
260 region = iommu_alloc_resv_region(iova, length, prot, type,
261 GFP_KERNEL);
262 if (region)
263 list_add_tail(®ion->list, list);
264 }
265 }
266 }
267 #endif
268 }
269 EXPORT_SYMBOL(of_iommu_get_resv_regions);
270