1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/string.h>
3 #include <linux/kernel.h>
4 #include <linux/of.h>
5 #include <linux/of_device.h>
6 #include <linux/of_address.h>
7 #include <linux/of_iommu.h>
8 #include <linux/of_reserved_mem.h>
9 #include <linux/dma-direct.h> /* for bus_dma_region */
10 #include <linux/dma-map-ops.h>
11 #include <linux/init.h>
12 #include <linux/module.h>
13 #include <linux/mod_devicetable.h>
14 #include <linux/slab.h>
15 #include <linux/platform_device.h>
16 
17 #include <asm/errno.h>
18 #include "of_private.h"
19 
20 /**
21  * of_match_device - Tell if a struct device matches an of_device_id list
22  * @matches: array of of device match structures to search in
23  * @dev: the of device structure to match against
24  *
25  * Used by a driver to check whether an platform_device present in the
26  * system is in its list of supported devices.
27  */
of_match_device(const struct of_device_id * matches,const struct device * dev)28 const struct of_device_id *of_match_device(const struct of_device_id *matches,
29 					   const struct device *dev)
30 {
31 	if ((!matches) || (!dev->of_node))
32 		return NULL;
33 	return of_match_node(matches, dev->of_node);
34 }
35 EXPORT_SYMBOL(of_match_device);
36 
of_device_add(struct platform_device * ofdev)37 int of_device_add(struct platform_device *ofdev)
38 {
39 	BUG_ON(ofdev->dev.of_node == NULL);
40 
41 	/* name and id have to be set so that the platform bus doesn't get
42 	 * confused on matching */
43 	ofdev->name = dev_name(&ofdev->dev);
44 	ofdev->id = PLATFORM_DEVID_NONE;
45 
46 	/*
47 	 * If this device has not binding numa node in devicetree, that is
48 	 * of_node_to_nid returns NUMA_NO_NODE. device_add will assume that this
49 	 * device is on the same node as the parent.
50 	 */
51 	set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));
52 
53 	return device_add(&ofdev->dev);
54 }
55 
56 static void
of_dma_set_restricted_buffer(struct device * dev,struct device_node * np)57 of_dma_set_restricted_buffer(struct device *dev, struct device_node *np)
58 {
59 	struct device_node *node, *of_node = dev->of_node;
60 	int count, i;
61 
62 	if (!IS_ENABLED(CONFIG_DMA_RESTRICTED_POOL))
63 		return;
64 
65 	count = of_property_count_elems_of_size(of_node, "memory-region",
66 						sizeof(u32));
67 	/*
68 	 * If dev->of_node doesn't exist or doesn't contain memory-region, try
69 	 * the OF node having DMA configuration.
70 	 */
71 	if (count <= 0) {
72 		of_node = np;
73 		count = of_property_count_elems_of_size(
74 			of_node, "memory-region", sizeof(u32));
75 	}
76 
77 	for (i = 0; i < count; i++) {
78 		node = of_parse_phandle(of_node, "memory-region", i);
79 		/*
80 		 * There might be multiple memory regions, but only one
81 		 * restricted-dma-pool region is allowed.
82 		 */
83 		if (of_device_is_compatible(node, "restricted-dma-pool") &&
84 		    of_device_is_available(node))
85 			break;
86 	}
87 
88 	/*
89 	 * Attempt to initialize a restricted-dma-pool region if one was found.
90 	 * Note that count can hold a negative error code.
91 	 */
92 	if (i < count && of_reserved_mem_device_init_by_idx(dev, of_node, i))
93 		dev_warn(dev, "failed to initialise \"restricted-dma-pool\" memory node\n");
94 }
95 
96 /**
97  * of_dma_configure_id - Setup DMA configuration
98  * @dev:	Device to apply DMA configuration
99  * @np:		Pointer to OF node having DMA configuration
100  * @force_dma:  Whether device is to be set up by of_dma_configure() even if
101  *		DMA capability is not explicitly described by firmware.
102  * @id:		Optional const pointer value input id
103  *
104  * Try to get devices's DMA configuration from DT and update it
105  * accordingly.
106  *
107  * If platform code needs to use its own special DMA configuration, it
108  * can use a platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE events
109  * to fix up DMA configuration.
110  */
of_dma_configure_id(struct device * dev,struct device_node * np,bool force_dma,const u32 * id)111 int of_dma_configure_id(struct device *dev, struct device_node *np,
112 			bool force_dma, const u32 *id)
113 {
114 	const struct iommu_ops *iommu;
115 	const struct bus_dma_region *map = NULL;
116 	u64 dma_start = 0;
117 	u64 mask, end, size = 0;
118 	bool coherent;
119 	int ret;
120 
121 	ret = of_dma_get_range(np, &map);
122 	if (ret < 0) {
123 		/*
124 		 * For legacy reasons, we have to assume some devices need
125 		 * DMA configuration regardless of whether "dma-ranges" is
126 		 * correctly specified or not.
127 		 */
128 		if (!force_dma)
129 			return ret == -ENODEV ? 0 : ret;
130 	} else {
131 		const struct bus_dma_region *r = map;
132 		u64 dma_end = 0;
133 
134 		/* Determine the overall bounds of all DMA regions */
135 		for (dma_start = ~0; r->size; r++) {
136 			/* Take lower and upper limits */
137 			if (r->dma_start < dma_start)
138 				dma_start = r->dma_start;
139 			if (r->dma_start + r->size > dma_end)
140 				dma_end = r->dma_start + r->size;
141 		}
142 		size = dma_end - dma_start;
143 
144 		/*
145 		 * Add a work around to treat the size as mask + 1 in case
146 		 * it is defined in DT as a mask.
147 		 */
148 		if (size & 1) {
149 			dev_warn(dev, "Invalid size 0x%llx for dma-range(s)\n",
150 				 size);
151 			size = size + 1;
152 		}
153 
154 		if (!size) {
155 			dev_err(dev, "Adjusted size 0x%llx invalid\n", size);
156 			kfree(map);
157 			return -EINVAL;
158 		}
159 	}
160 
161 	/*
162 	 * If @dev is expected to be DMA-capable then the bus code that created
163 	 * it should have initialised its dma_mask pointer by this point. For
164 	 * now, we'll continue the legacy behaviour of coercing it to the
165 	 * coherent mask if not, but we'll no longer do so quietly.
166 	 */
167 	if (!dev->dma_mask) {
168 		dev_warn(dev, "DMA mask not set\n");
169 		dev->dma_mask = &dev->coherent_dma_mask;
170 	}
171 
172 	if (!size && dev->coherent_dma_mask)
173 		size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);
174 	else if (!size)
175 		size = 1ULL << 32;
176 
177 	/*
178 	 * Limit coherent and dma mask based on size and default mask
179 	 * set by the driver.
180 	 */
181 	end = dma_start + size - 1;
182 	mask = DMA_BIT_MASK(ilog2(end) + 1);
183 	dev->coherent_dma_mask &= mask;
184 	*dev->dma_mask &= mask;
185 	/* ...but only set bus limit and range map if we found valid dma-ranges earlier */
186 	if (!ret) {
187 		dev->bus_dma_limit = end;
188 		dev->dma_range_map = map;
189 	}
190 
191 	coherent = of_dma_is_coherent(np);
192 	dev_dbg(dev, "device is%sdma coherent\n",
193 		coherent ? " " : " not ");
194 
195 	iommu = of_iommu_configure(dev, np, id);
196 	if (PTR_ERR(iommu) == -EPROBE_DEFER) {
197 		/* Don't touch range map if it wasn't set from a valid dma-ranges */
198 		if (!ret)
199 			dev->dma_range_map = NULL;
200 		kfree(map);
201 		return -EPROBE_DEFER;
202 	}
203 
204 	dev_dbg(dev, "device is%sbehind an iommu\n",
205 		iommu ? " " : " not ");
206 
207 	arch_setup_dma_ops(dev, dma_start, size, iommu, coherent);
208 
209 	if (!iommu)
210 		of_dma_set_restricted_buffer(dev, np);
211 
212 	return 0;
213 }
214 EXPORT_SYMBOL_GPL(of_dma_configure_id);
215 
of_device_register(struct platform_device * pdev)216 int of_device_register(struct platform_device *pdev)
217 {
218 	device_initialize(&pdev->dev);
219 	return of_device_add(pdev);
220 }
221 EXPORT_SYMBOL(of_device_register);
222 
of_device_unregister(struct platform_device * ofdev)223 void of_device_unregister(struct platform_device *ofdev)
224 {
225 	device_unregister(&ofdev->dev);
226 }
227 EXPORT_SYMBOL(of_device_unregister);
228 
of_device_get_match_data(const struct device * dev)229 const void *of_device_get_match_data(const struct device *dev)
230 {
231 	const struct of_device_id *match;
232 
233 	match = of_match_device(dev->driver->of_match_table, dev);
234 	if (!match)
235 		return NULL;
236 
237 	return match->data;
238 }
239 EXPORT_SYMBOL(of_device_get_match_data);
240 
of_device_get_modalias(struct device * dev,char * str,ssize_t len)241 static ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len)
242 {
243 	const char *compat;
244 	char *c;
245 	struct property *p;
246 	ssize_t csize;
247 	ssize_t tsize;
248 
249 	if ((!dev) || (!dev->of_node))
250 		return -ENODEV;
251 
252 	/* Name & Type */
253 	/* %p eats all alphanum characters, so %c must be used here */
254 	csize = snprintf(str, len, "of:N%pOFn%c%s", dev->of_node, 'T',
255 			 of_node_get_device_type(dev->of_node));
256 	tsize = csize;
257 	len -= csize;
258 	if (str)
259 		str += csize;
260 
261 	of_property_for_each_string(dev->of_node, "compatible", p, compat) {
262 		csize = strlen(compat) + 1;
263 		tsize += csize;
264 		if (csize > len)
265 			continue;
266 
267 		csize = snprintf(str, len, "C%s", compat);
268 		for (c = str; c; ) {
269 			c = strchr(c, ' ');
270 			if (c)
271 				*c++ = '_';
272 		}
273 		len -= csize;
274 		str += csize;
275 	}
276 
277 	return tsize;
278 }
279 
of_device_request_module(struct device * dev)280 int of_device_request_module(struct device *dev)
281 {
282 	char *str;
283 	ssize_t size;
284 	int ret;
285 
286 	size = of_device_get_modalias(dev, NULL, 0);
287 	if (size < 0)
288 		return size;
289 
290 	str = kmalloc(size + 1, GFP_KERNEL);
291 	if (!str)
292 		return -ENOMEM;
293 
294 	of_device_get_modalias(dev, str, size);
295 	str[size] = '\0';
296 	ret = request_module(str);
297 	kfree(str);
298 
299 	return ret;
300 }
301 EXPORT_SYMBOL_GPL(of_device_request_module);
302 
303 /**
304  * of_device_modalias - Fill buffer with newline terminated modalias string
305  * @dev:	Calling device
306  * @str:	Modalias string
307  * @len:	Size of @str
308  */
of_device_modalias(struct device * dev,char * str,ssize_t len)309 ssize_t of_device_modalias(struct device *dev, char *str, ssize_t len)
310 {
311 	ssize_t sl = of_device_get_modalias(dev, str, len - 2);
312 	if (sl < 0)
313 		return sl;
314 	if (sl > len - 2)
315 		return -ENOMEM;
316 
317 	str[sl++] = '\n';
318 	str[sl] = 0;
319 	return sl;
320 }
321 EXPORT_SYMBOL_GPL(of_device_modalias);
322 
323 /**
324  * of_device_uevent - Display OF related uevent information
325  * @dev:	Device to apply DMA configuration
326  * @env:	Kernel object's userspace event reference
327  */
of_device_uevent(struct device * dev,struct kobj_uevent_env * env)328 void of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
329 {
330 	const char *compat, *type;
331 	struct alias_prop *app;
332 	struct property *p;
333 	int seen = 0;
334 
335 	if ((!dev) || (!dev->of_node))
336 		return;
337 
338 	add_uevent_var(env, "OF_NAME=%pOFn", dev->of_node);
339 	add_uevent_var(env, "OF_FULLNAME=%pOF", dev->of_node);
340 	type = of_node_get_device_type(dev->of_node);
341 	if (type)
342 		add_uevent_var(env, "OF_TYPE=%s", type);
343 
344 	/* Since the compatible field can contain pretty much anything
345 	 * it's not really legal to split it out with commas. We split it
346 	 * up using a number of environment variables instead. */
347 	of_property_for_each_string(dev->of_node, "compatible", p, compat) {
348 		add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat);
349 		seen++;
350 	}
351 	add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen);
352 
353 	seen = 0;
354 	mutex_lock(&of_mutex);
355 	list_for_each_entry(app, &aliases_lookup, link) {
356 		if (dev->of_node == app->np) {
357 			add_uevent_var(env, "OF_ALIAS_%d=%s", seen,
358 				       app->alias);
359 			seen++;
360 		}
361 	}
362 	mutex_unlock(&of_mutex);
363 }
364 
of_device_uevent_modalias(struct device * dev,struct kobj_uevent_env * env)365 int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
366 {
367 	int sl;
368 
369 	if ((!dev) || (!dev->of_node))
370 		return -ENODEV;
371 
372 	/* Devicetree modalias is tricky, we add it in 2 steps */
373 	if (add_uevent_var(env, "MODALIAS="))
374 		return -ENOMEM;
375 
376 	sl = of_device_get_modalias(dev, &env->buf[env->buflen-1],
377 				    sizeof(env->buf) - env->buflen);
378 	if (sl >= (sizeof(env->buf) - env->buflen))
379 		return -ENOMEM;
380 	env->buflen += sl;
381 
382 	return 0;
383 }
384 EXPORT_SYMBOL_GPL(of_device_uevent_modalias);
385