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 if (!IS_ENABLED(CONFIG_DMA_RESTRICTED_POOL
))
65 count
= of_property_count_elems_of_size(of_node
, "memory-region",
68 * If dev->of_node doesn't exist or doesn't contain memory-region, try
69 * the OF node having DMA configuration.
73 count
= of_property_count_elems_of_size(
74 of_node
, "memory-region", sizeof(u32
));
77 for (i
= 0; i
< count
; i
++) {
78 node
= of_parse_phandle(of_node
, "memory-region", i
);
80 * There might be multiple memory regions, but only one
81 * restricted-dma-pool region is allowed.
83 if (of_device_is_compatible(node
, "restricted-dma-pool") &&
84 of_device_is_available(node
))
89 * Attempt to initialize a restricted-dma-pool region if one was found.
90 * Note that count can hold a negative error code.
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");
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
104 * Try to get devices's DMA configuration from DT and update it
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.
111 int of_dma_configure_id(struct device
*dev
, struct device_node
*np
,
112 bool force_dma
, const u32
*id
)
114 const struct iommu_ops
*iommu
;
115 const struct bus_dma_region
*map
= NULL
;
117 u64 mask
, end
, size
= 0;
121 ret
= of_dma_get_range(np
, &map
);
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.
129 return ret
== -ENODEV
? 0 : ret
;
131 const struct bus_dma_region
*r
= map
;
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
;
142 size
= dma_end
- dma_start
;
145 * Add a work around to treat the size as mask + 1 in case
146 * it is defined in DT as a mask.
149 dev_warn(dev
, "Invalid size 0x%llx for dma-range(s)\n",
155 dev_err(dev
, "Adjusted size 0x%llx invalid\n", size
);
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.
167 if (!dev
->dma_mask
) {
168 dev_warn(dev
, "DMA mask not set\n");
169 dev
->dma_mask
= &dev
->coherent_dma_mask
;
172 if (!size
&& dev
->coherent_dma_mask
)
173 size
= max(dev
->coherent_dma_mask
, dev
->coherent_dma_mask
+ 1);
178 * Limit coherent and dma mask based on size and default mask
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 */
187 dev
->bus_dma_limit
= end
;
188 dev
->dma_range_map
= map
;
191 coherent
= of_dma_is_coherent(np
);
192 dev_dbg(dev
, "device is%sdma coherent\n",
193 coherent
? " " : " not ");
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 */
199 dev
->dma_range_map
= NULL
;
201 return -EPROBE_DEFER
;
204 dev_dbg(dev
, "device is%sbehind an iommu\n",
205 iommu
? " " : " not ");
207 arch_setup_dma_ops(dev
, dma_start
, size
, iommu
, coherent
);
210 of_dma_set_restricted_buffer(dev
, np
);
214 EXPORT_SYMBOL_GPL(of_dma_configure_id
);
216 int of_device_register(struct platform_device
*pdev
)
218 device_initialize(&pdev
->dev
);
219 return of_device_add(pdev
);
221 EXPORT_SYMBOL(of_device_register
);
223 void of_device_unregister(struct platform_device
*ofdev
)
225 device_unregister(&ofdev
->dev
);
227 EXPORT_SYMBOL(of_device_unregister
);
229 const void *of_device_get_match_data(const struct device
*dev
)
231 const struct of_device_id
*match
;
233 match
= of_match_device(dev
->driver
->of_match_table
, dev
);
239 EXPORT_SYMBOL(of_device_get_match_data
);
241 static ssize_t
of_device_get_modalias(struct device
*dev
, char *str
, ssize_t len
)
249 if ((!dev
) || (!dev
->of_node
))
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
));
261 of_property_for_each_string(dev
->of_node
, "compatible", p
, compat
) {
262 csize
= strlen(compat
) + 1;
267 csize
= snprintf(str
, len
, "C%s", compat
);
280 int of_device_request_module(struct device
*dev
)
286 size
= of_device_get_modalias(dev
, NULL
, 0);
290 str
= kmalloc(size
+ 1, GFP_KERNEL
);
294 of_device_get_modalias(dev
, str
, size
);
296 ret
= request_module(str
);
301 EXPORT_SYMBOL_GPL(of_device_request_module
);
304 * of_device_modalias - Fill buffer with newline terminated modalias string
305 * @dev: Calling device
306 * @str: Modalias string
309 ssize_t
of_device_modalias(struct device
*dev
, char *str
, ssize_t len
)
311 ssize_t sl
= of_device_get_modalias(dev
, str
, len
- 2);
321 EXPORT_SYMBOL_GPL(of_device_modalias
);
324 * of_device_uevent - Display OF related uevent information
325 * @dev: Device to apply DMA configuration
326 * @env: Kernel object's userspace event reference
328 void of_device_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
330 const char *compat
, *type
;
331 struct alias_prop
*app
;
335 if ((!dev
) || (!dev
->of_node
))
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
);
342 add_uevent_var(env
, "OF_TYPE=%s", type
);
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
);
351 add_uevent_var(env
, "OF_COMPATIBLE_N=%d", seen
);
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
,
362 mutex_unlock(&of_mutex
);
365 int of_device_uevent_modalias(struct device
*dev
, struct kobj_uevent_env
*env
)
369 if ((!dev
) || (!dev
->of_node
))
372 /* Devicetree modalias is tricky, we add it in 2 steps */
373 if (add_uevent_var(env
, "MODALIAS="))
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
))
384 EXPORT_SYMBOL_GPL(of_device_uevent_modalias
);