1 /*
2 * OF helpers for IOMMU
3 *
4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
5 *
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.
9 *
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
13 * more details.
14 *
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.
18 */
19
20 #include <linux/export.h>
21 #include <linux/iommu.h>
22 #include <linux/limits.h>
23 #include <linux/of.h>
24 #include <linux/of_iommu.h>
25 #include <linux/slab.h>
26
27 static const struct of_device_id __iommu_of_table_sentinel
28 __used __section(__iommu_of_table_end);
29
30 /**
31 * of_get_dma_window - Parse *dma-window property and returns 0 if found.
32 *
33 * @dn: device node
34 * @prefix: prefix for property name if any
35 * @index: index to start to parse
36 * @busno: Returns busno if supported. Otherwise pass NULL
37 * @addr: Returns address that DMA starts
38 * @size: Returns the range that DMA can handle
39 *
40 * This supports different formats flexibly. "prefix" can be
41 * configured if any. "busno" and "index" are optionally
42 * specified. Set 0(or NULL) if not used.
43 */
of_get_dma_window(struct device_node * dn,const char * prefix,int index,unsigned long * busno,dma_addr_t * addr,size_t * size)44 int of_get_dma_window(struct device_node *dn, const char *prefix, int index,
45 unsigned long *busno, dma_addr_t *addr, size_t *size)
46 {
47 const __be32 *dma_window, *end;
48 int bytes, cur_index = 0;
49 char propname[NAME_MAX], addrname[NAME_MAX], sizename[NAME_MAX];
50
51 if (!dn || !addr || !size)
52 return -EINVAL;
53
54 if (!prefix)
55 prefix = "";
56
57 snprintf(propname, sizeof(propname), "%sdma-window", prefix);
58 snprintf(addrname, sizeof(addrname), "%s#dma-address-cells", prefix);
59 snprintf(sizename, sizeof(sizename), "%s#dma-size-cells", prefix);
60
61 dma_window = of_get_property(dn, propname, &bytes);
62 if (!dma_window)
63 return -ENODEV;
64 end = dma_window + bytes / sizeof(*dma_window);
65
66 while (dma_window < end) {
67 u32 cells;
68 const void *prop;
69
70 /* busno is one cell if supported */
71 if (busno)
72 *busno = be32_to_cpup(dma_window++);
73
74 prop = of_get_property(dn, addrname, NULL);
75 if (!prop)
76 prop = of_get_property(dn, "#address-cells", NULL);
77
78 cells = prop ? be32_to_cpup(prop) : of_n_addr_cells(dn);
79 if (!cells)
80 return -EINVAL;
81 *addr = of_read_number(dma_window, cells);
82 dma_window += cells;
83
84 prop = of_get_property(dn, sizename, NULL);
85 cells = prop ? be32_to_cpup(prop) : of_n_size_cells(dn);
86 if (!cells)
87 return -EINVAL;
88 *size = of_read_number(dma_window, cells);
89 dma_window += cells;
90
91 if (cur_index++ == index)
92 break;
93 }
94 return 0;
95 }
96 EXPORT_SYMBOL_GPL(of_get_dma_window);
97
98 struct of_iommu_node {
99 struct list_head list;
100 struct device_node *np;
101 struct iommu_ops *ops;
102 };
103 static LIST_HEAD(of_iommu_list);
104 static DEFINE_SPINLOCK(of_iommu_lock);
105
of_iommu_set_ops(struct device_node * np,struct iommu_ops * ops)106 void of_iommu_set_ops(struct device_node *np, struct iommu_ops *ops)
107 {
108 struct of_iommu_node *iommu = kzalloc(sizeof(*iommu), GFP_KERNEL);
109
110 if (WARN_ON(!iommu))
111 return;
112
113 INIT_LIST_HEAD(&iommu->list);
114 iommu->np = np;
115 iommu->ops = ops;
116 spin_lock(&of_iommu_lock);
117 list_add_tail(&iommu->list, &of_iommu_list);
118 spin_unlock(&of_iommu_lock);
119 }
120
of_iommu_get_ops(struct device_node * np)121 struct iommu_ops *of_iommu_get_ops(struct device_node *np)
122 {
123 struct of_iommu_node *node;
124 struct iommu_ops *ops = NULL;
125
126 spin_lock(&of_iommu_lock);
127 list_for_each_entry(node, &of_iommu_list, list)
128 if (node->np == np) {
129 ops = node->ops;
130 break;
131 }
132 spin_unlock(&of_iommu_lock);
133 return ops;
134 }
135
of_iommu_configure(struct device * dev,struct device_node * master_np)136 struct iommu_ops *of_iommu_configure(struct device *dev,
137 struct device_node *master_np)
138 {
139 struct of_phandle_args iommu_spec;
140 struct device_node *np;
141 struct iommu_ops *ops = NULL;
142 int idx = 0;
143
144 /*
145 * We can't do much for PCI devices without knowing how
146 * device IDs are wired up from the PCI bus to the IOMMU.
147 */
148 if (dev_is_pci(dev))
149 return NULL;
150
151 /*
152 * We don't currently walk up the tree looking for a parent IOMMU.
153 * See the `Notes:' section of
154 * Documentation/devicetree/bindings/iommu/iommu.txt
155 */
156 while (!of_parse_phandle_with_args(master_np, "iommus",
157 "#iommu-cells", idx,
158 &iommu_spec)) {
159 np = iommu_spec.np;
160 ops = of_iommu_get_ops(np);
161
162 if (!ops || !ops->of_xlate || ops->of_xlate(dev, &iommu_spec))
163 goto err_put_node;
164
165 of_node_put(np);
166 idx++;
167 }
168
169 return ops;
170
171 err_put_node:
172 of_node_put(np);
173 return NULL;
174 }
175
of_iommu_init(void)176 void __init of_iommu_init(void)
177 {
178 struct device_node *np;
179 const struct of_device_id *match, *matches = &__iommu_of_table;
180
181 for_each_matching_node_and_match(np, matches, &match) {
182 const of_iommu_init_fn init_fn = match->data;
183
184 if (init_fn(np))
185 pr_err("Failed to initialise IOMMU %s\n",
186 of_node_full_name(np));
187 }
188 }
189