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/msi.h>
13 #include <linux/of.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 #define NO_IOMMU 1
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 struct fwnode_handle *fwnode = &iommu_spec->np->fwnode;
27 int ret;
28
29 ops = iommu_ops_from_fwnode(fwnode);
30 if ((ops && !ops->of_xlate) ||
31 !of_device_is_available(iommu_spec->np))
32 return NO_IOMMU;
33
34 ret = iommu_fwspec_init(dev, &iommu_spec->np->fwnode, ops);
35 if (ret)
36 return ret;
37 /*
38 * The otherwise-empty fwspec handily serves to indicate the specific
39 * IOMMU device we're waiting for, which will be useful if we ever get
40 * a proper probe-ordering dependency mechanism in future.
41 */
42 if (!ops)
43 return driver_deferred_probe_check_state(dev);
44
45 if (!try_module_get(ops->owner))
46 return -ENODEV;
47
48 ret = ops->of_xlate(dev, iommu_spec);
49 module_put(ops->owner);
50 return ret;
51 }
52
of_iommu_configure_dev_id(struct device_node * master_np,struct device * dev,const u32 * id)53 static int of_iommu_configure_dev_id(struct device_node *master_np,
54 struct device *dev,
55 const u32 *id)
56 {
57 struct of_phandle_args iommu_spec = { .args_count = 1 };
58 int err;
59
60 err = of_map_id(master_np, *id, "iommu-map",
61 "iommu-map-mask", &iommu_spec.np,
62 iommu_spec.args);
63 if (err)
64 return err == -ENODEV ? NO_IOMMU : err;
65
66 err = of_iommu_xlate(dev, &iommu_spec);
67 of_node_put(iommu_spec.np);
68 return err;
69 }
70
of_iommu_configure_dev(struct device_node * master_np,struct device * dev)71 static int of_iommu_configure_dev(struct device_node *master_np,
72 struct device *dev)
73 {
74 struct of_phandle_args iommu_spec;
75 int err = NO_IOMMU, idx = 0;
76
77 while (!of_parse_phandle_with_args(master_np, "iommus",
78 "#iommu-cells",
79 idx, &iommu_spec)) {
80 err = of_iommu_xlate(dev, &iommu_spec);
81 of_node_put(iommu_spec.np);
82 idx++;
83 if (err)
84 break;
85 }
86
87 return err;
88 }
89
90 struct of_pci_iommu_alias_info {
91 struct device *dev;
92 struct device_node *np;
93 };
94
of_pci_iommu_init(struct pci_dev * pdev,u16 alias,void * data)95 static int of_pci_iommu_init(struct pci_dev *pdev, u16 alias, void *data)
96 {
97 struct of_pci_iommu_alias_info *info = data;
98 u32 input_id = alias;
99
100 return of_iommu_configure_dev_id(info->np, info->dev, &input_id);
101 }
102
of_iommu_configure_device(struct device_node * master_np,struct device * dev,const u32 * id)103 static int of_iommu_configure_device(struct device_node *master_np,
104 struct device *dev, const u32 *id)
105 {
106 return (id) ? of_iommu_configure_dev_id(master_np, dev, id) :
107 of_iommu_configure_dev(master_np, dev);
108 }
109
of_iommu_configure(struct device * dev,struct device_node * master_np,const u32 * id)110 const struct iommu_ops *of_iommu_configure(struct device *dev,
111 struct device_node *master_np,
112 const u32 *id)
113 {
114 const struct iommu_ops *ops = NULL;
115 struct iommu_fwspec *fwspec;
116 int err = NO_IOMMU;
117
118 if (!master_np)
119 return NULL;
120
121 /* Serialise to make dev->iommu stable under our potential fwspec */
122 mutex_lock(&iommu_probe_device_lock);
123 fwspec = dev_iommu_fwspec_get(dev);
124 if (fwspec) {
125 if (fwspec->ops) {
126 mutex_unlock(&iommu_probe_device_lock);
127 return fwspec->ops;
128 }
129 /* In the deferred case, start again from scratch */
130 iommu_fwspec_free(dev);
131 }
132
133 /*
134 * We don't currently walk up the tree looking for a parent IOMMU.
135 * See the `Notes:' section of
136 * Documentation/devicetree/bindings/iommu/iommu.txt
137 */
138 if (dev_is_pci(dev)) {
139 struct of_pci_iommu_alias_info info = {
140 .dev = dev,
141 .np = master_np,
142 };
143
144 pci_request_acs();
145 err = pci_for_each_dma_alias(to_pci_dev(dev),
146 of_pci_iommu_init, &info);
147 } else {
148 err = of_iommu_configure_device(master_np, dev, id);
149 }
150
151 /*
152 * Two success conditions can be represented by non-negative err here:
153 * >0 : there is no IOMMU, or one was unavailable for non-fatal reasons
154 * 0 : we found an IOMMU, and dev->fwspec is initialised appropriately
155 * <0 : any actual error
156 */
157 if (!err) {
158 /* The fwspec pointer changed, read it again */
159 fwspec = dev_iommu_fwspec_get(dev);
160 ops = fwspec->ops;
161 }
162 mutex_unlock(&iommu_probe_device_lock);
163
164 /*
165 * If we have reason to believe the IOMMU driver missed the initial
166 * probe for dev, replay it to get things in order.
167 */
168 if (!err && dev->bus && !device_iommu_mapped(dev))
169 err = iommu_probe_device(dev);
170
171 /* Ignore all other errors apart from EPROBE_DEFER */
172 if (err == -EPROBE_DEFER) {
173 ops = ERR_PTR(err);
174 } else if (err < 0) {
175 dev_dbg(dev, "Adding to IOMMU failed: %d\n", err);
176 ops = NULL;
177 }
178
179 return ops;
180 }
181