1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/string.h>
3 #include <linux/kernel.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>
17 #include <asm/errno.h>
18 #include "of_private.h"
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
25 * Used by a driver to check whether an platform_device present in the
26 * system is in its list of supported devices.
28 const struct of_device_id *of_match_device(const struct of_device_id *matches,
29 const struct device *dev)
31 if ((!matches) || (!dev->of_node))
33 return of_match_node(matches, dev->of_node);
35 EXPORT_SYMBOL(of_match_device);
37 int of_device_add(struct platform_device *ofdev)
39 BUG_ON(ofdev->dev.of_node == NULL);
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;
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.
51 set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));
53 return device_add(&ofdev->dev);
57 of_dma_set_restricted_buffer(struct device *dev, struct device_node *np)
59 struct device_node *node, *of_node = dev->of_node;
62 count = of_property_count_elems_of_size(of_node, "memory-region",
65 * If dev->of_node doesn't exist or doesn't contain memory-region, try
66 * the OF node having DMA configuration.
70 count = of_property_count_elems_of_size(
71 of_node, "memory-region", sizeof(u32));
74 for (i = 0; i < count; i++) {
75 node = of_parse_phandle(of_node, "memory-region", i);
77 * There might be multiple memory regions, but only one
78 * restricted-dma-pool region is allowed.
80 if (of_device_is_compatible(node, "restricted-dma-pool") &&
81 of_device_is_available(node))
82 return of_reserved_mem_device_init_by_idx(dev, of_node,
90 * of_dma_configure_id - Setup DMA configuration
91 * @dev: Device to apply DMA configuration
92 * @np: Pointer to OF node having DMA configuration
93 * @force_dma: Whether device is to be set up by of_dma_configure() even if
94 * DMA capability is not explicitly described by firmware.
95 * @id: Optional const pointer value input id
97 * Try to get devices's DMA configuration from DT and update it
100 * If platform code needs to use its own special DMA configuration, it
101 * can use a platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE events
102 * to fix up DMA configuration.
104 int of_dma_configure_id(struct device *dev, struct device_node *np,
105 bool force_dma, const u32 *id)
107 const struct iommu_ops *iommu;
108 const struct bus_dma_region *map = NULL;
110 u64 mask, end, size = 0;
114 ret = of_dma_get_range(np, &map);
117 * For legacy reasons, we have to assume some devices need
118 * DMA configuration regardless of whether "dma-ranges" is
119 * correctly specified or not.
122 return ret == -ENODEV ? 0 : ret;
124 const struct bus_dma_region *r = map;
127 /* Determine the overall bounds of all DMA regions */
128 for (dma_start = ~0; r->size; r++) {
129 /* Take lower and upper limits */
130 if (r->dma_start < dma_start)
131 dma_start = r->dma_start;
132 if (r->dma_start + r->size > dma_end)
133 dma_end = r->dma_start + r->size;
135 size = dma_end - dma_start;
138 * Add a work around to treat the size as mask + 1 in case
139 * it is defined in DT as a mask.
142 dev_warn(dev, "Invalid size 0x%llx for dma-range(s)\n",
148 dev_err(dev, "Adjusted size 0x%llx invalid\n", size);
155 * If @dev is expected to be DMA-capable then the bus code that created
156 * it should have initialised its dma_mask pointer by this point. For
157 * now, we'll continue the legacy behaviour of coercing it to the
158 * coherent mask if not, but we'll no longer do so quietly.
160 if (!dev->dma_mask) {
161 dev_warn(dev, "DMA mask not set\n");
162 dev->dma_mask = &dev->coherent_dma_mask;
165 if (!size && dev->coherent_dma_mask)
166 size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);
171 * Limit coherent and dma mask based on size and default mask
174 end = dma_start + size - 1;
175 mask = DMA_BIT_MASK(ilog2(end) + 1);
176 dev->coherent_dma_mask &= mask;
177 *dev->dma_mask &= mask;
178 /* ...but only set bus limit and range map if we found valid dma-ranges earlier */
180 dev->bus_dma_limit = end;
181 dev->dma_range_map = map;
184 coherent = of_dma_is_coherent(np);
185 dev_dbg(dev, "device is%sdma coherent\n",
186 coherent ? " " : " not ");
188 iommu = of_iommu_configure(dev, np, id);
189 if (PTR_ERR(iommu) == -EPROBE_DEFER) {
190 /* Don't touch range map if it wasn't set from a valid dma-ranges */
192 dev->dma_range_map = NULL;
194 return -EPROBE_DEFER;
197 dev_dbg(dev, "device is%sbehind an iommu\n",
198 iommu ? " " : " not ");
200 arch_setup_dma_ops(dev, dma_start, size, iommu, coherent);
203 return of_dma_set_restricted_buffer(dev, np);
207 EXPORT_SYMBOL_GPL(of_dma_configure_id);
209 int of_device_register(struct platform_device *pdev)
211 device_initialize(&pdev->dev);
212 return of_device_add(pdev);
214 EXPORT_SYMBOL(of_device_register);
216 void of_device_unregister(struct platform_device *ofdev)
218 device_unregister(&ofdev->dev);
220 EXPORT_SYMBOL(of_device_unregister);
222 const void *of_device_get_match_data(const struct device *dev)
224 const struct of_device_id *match;
226 match = of_match_device(dev->driver->of_match_table, dev);
232 EXPORT_SYMBOL(of_device_get_match_data);
234 static ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len)
242 if ((!dev) || (!dev->of_node))
246 /* %p eats all alphanum characters, so %c must be used here */
247 csize = snprintf(str, len, "of:N%pOFn%c%s", dev->of_node, 'T',
248 of_node_get_device_type(dev->of_node));
254 of_property_for_each_string(dev->of_node, "compatible", p, compat) {
255 csize = strlen(compat) + 1;
260 csize = snprintf(str, len, "C%s", compat);
273 int of_device_request_module(struct device *dev)
279 size = of_device_get_modalias(dev, NULL, 0);
283 str = kmalloc(size + 1, GFP_KERNEL);
287 of_device_get_modalias(dev, str, size);
289 ret = request_module(str);
294 EXPORT_SYMBOL_GPL(of_device_request_module);
297 * of_device_modalias - Fill buffer with newline terminated modalias string
298 * @dev: Calling device
299 * @str: Modalias string
302 ssize_t of_device_modalias(struct device *dev, char *str, ssize_t len)
304 ssize_t sl = of_device_get_modalias(dev, str, len - 2);
314 EXPORT_SYMBOL_GPL(of_device_modalias);
317 * of_device_uevent - Display OF related uevent information
318 * @dev: Device to apply DMA configuration
319 * @env: Kernel object's userspace event reference
321 void of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
323 const char *compat, *type;
324 struct alias_prop *app;
328 if ((!dev) || (!dev->of_node))
331 add_uevent_var(env, "OF_NAME=%pOFn", dev->of_node);
332 add_uevent_var(env, "OF_FULLNAME=%pOF", dev->of_node);
333 type = of_node_get_device_type(dev->of_node);
335 add_uevent_var(env, "OF_TYPE=%s", type);
337 /* Since the compatible field can contain pretty much anything
338 * it's not really legal to split it out with commas. We split it
339 * up using a number of environment variables instead. */
340 of_property_for_each_string(dev->of_node, "compatible", p, compat) {
341 add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat);
344 add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen);
347 mutex_lock(&of_mutex);
348 list_for_each_entry(app, &aliases_lookup, link) {
349 if (dev->of_node == app->np) {
350 add_uevent_var(env, "OF_ALIAS_%d=%s", seen,
355 mutex_unlock(&of_mutex);
358 int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
362 if ((!dev) || (!dev->of_node))
365 /* Devicetree modalias is tricky, we add it in 2 steps */
366 if (add_uevent_var(env, "MODALIAS="))
369 sl = of_device_get_modalias(dev, &env->buf[env->buflen-1],
370 sizeof(env->buf) - env->buflen);
371 if (sl >= (sizeof(env->buf) - env->buflen))
377 EXPORT_SYMBOL_GPL(of_device_uevent_modalias);