1#include <linux/string.h>
2#include <linux/kernel.h>
3#include <linux/of.h>
4#include <linux/of_device.h>
5#include <linux/of_address.h>
6#include <linux/of_iommu.h>
7#include <linux/dma-mapping.h>
8#include <linux/init.h>
9#include <linux/module.h>
10#include <linux/mod_devicetable.h>
11#include <linux/slab.h>
12
13#include <asm/errno.h>
14#include "of_private.h"
15
16/**
17 * of_match_device - Tell if a struct device matches an of_device_id list
18 * @ids: array of of device match structures to search in
19 * @dev: the of device structure to match against
20 *
21 * Used by a driver to check whether an platform_device present in the
22 * system is in its list of supported devices.
23 */
24const struct of_device_id *of_match_device(const struct of_device_id *matches,
25					   const struct device *dev)
26{
27	if ((!matches) || (!dev->of_node))
28		return NULL;
29	return of_match_node(matches, dev->of_node);
30}
31EXPORT_SYMBOL(of_match_device);
32
33struct platform_device *of_dev_get(struct platform_device *dev)
34{
35	struct device *tmp;
36
37	if (!dev)
38		return NULL;
39	tmp = get_device(&dev->dev);
40	if (tmp)
41		return to_platform_device(tmp);
42	else
43		return NULL;
44}
45EXPORT_SYMBOL(of_dev_get);
46
47void of_dev_put(struct platform_device *dev)
48{
49	if (dev)
50		put_device(&dev->dev);
51}
52EXPORT_SYMBOL(of_dev_put);
53
54int of_device_add(struct platform_device *ofdev)
55{
56	BUG_ON(ofdev->dev.of_node == NULL);
57
58	/* name and id have to be set so that the platform bus doesn't get
59	 * confused on matching */
60	ofdev->name = dev_name(&ofdev->dev);
61	ofdev->id = -1;
62
63	/* device_add will assume that this device is on the same node as
64	 * the parent. If there is no parent defined, set the node
65	 * explicitly */
66	if (!ofdev->dev.parent)
67		set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));
68
69	return device_add(&ofdev->dev);
70}
71
72/**
73 * of_dma_configure - Setup DMA configuration
74 * @dev:	Device to apply DMA configuration
75 * @np:		Pointer to OF node having DMA configuration
76 *
77 * Try to get devices's DMA configuration from DT and update it
78 * accordingly.
79 *
80 * If platform code needs to use its own special DMA configuration, it
81 * can use a platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE events
82 * to fix up DMA configuration.
83 */
84void of_dma_configure(struct device *dev, struct device_node *np)
85{
86	u64 dma_addr, paddr, size;
87	int ret;
88	bool coherent;
89	unsigned long offset;
90	struct iommu_ops *iommu;
91
92	/*
93	 * Set default coherent_dma_mask to 32 bit.  Drivers are expected to
94	 * setup the correct supported mask.
95	 */
96	if (!dev->coherent_dma_mask)
97		dev->coherent_dma_mask = DMA_BIT_MASK(32);
98
99	/*
100	 * Set it to coherent_dma_mask by default if the architecture
101	 * code has not set it.
102	 */
103	if (!dev->dma_mask)
104		dev->dma_mask = &dev->coherent_dma_mask;
105
106	ret = of_dma_get_range(np, &dma_addr, &paddr, &size);
107	if (ret < 0) {
108		dma_addr = offset = 0;
109		size = dev->coherent_dma_mask + 1;
110	} else {
111		offset = PFN_DOWN(paddr - dma_addr);
112
113		/*
114		 * Add a work around to treat the size as mask + 1 in case
115		 * it is defined in DT as a mask.
116		 */
117		if (size & 1) {
118			dev_warn(dev, "Invalid size 0x%llx for dma-range\n",
119				 size);
120			size = size + 1;
121		}
122
123		if (!size) {
124			dev_err(dev, "Adjusted size 0x%llx invalid\n", size);
125			return;
126		}
127		dev_dbg(dev, "dma_pfn_offset(%#08lx)\n", offset);
128	}
129
130	dev->dma_pfn_offset = offset;
131
132	/*
133	 * Limit coherent and dma mask based on size and default mask
134	 * set by the driver.
135	 */
136	dev->coherent_dma_mask = min(dev->coherent_dma_mask,
137				     DMA_BIT_MASK(ilog2(dma_addr + size)));
138	*dev->dma_mask = min((*dev->dma_mask),
139			     DMA_BIT_MASK(ilog2(dma_addr + size)));
140
141	coherent = of_dma_is_coherent(np);
142	dev_dbg(dev, "device is%sdma coherent\n",
143		coherent ? " " : " not ");
144
145	iommu = of_iommu_configure(dev, np);
146	dev_dbg(dev, "device is%sbehind an iommu\n",
147		iommu ? " " : " not ");
148
149	arch_setup_dma_ops(dev, dma_addr, size, iommu, coherent);
150}
151EXPORT_SYMBOL_GPL(of_dma_configure);
152
153int of_device_register(struct platform_device *pdev)
154{
155	device_initialize(&pdev->dev);
156	return of_device_add(pdev);
157}
158EXPORT_SYMBOL(of_device_register);
159
160void of_device_unregister(struct platform_device *ofdev)
161{
162	device_unregister(&ofdev->dev);
163}
164EXPORT_SYMBOL(of_device_unregister);
165
166ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len)
167{
168	const char *compat;
169	int cplen, i;
170	ssize_t tsize, csize, repend;
171
172	if ((!dev) || (!dev->of_node))
173		return -ENODEV;
174
175	/* Name & Type */
176	csize = snprintf(str, len, "of:N%sT%s", dev->of_node->name,
177			 dev->of_node->type);
178
179	/* Get compatible property if any */
180	compat = of_get_property(dev->of_node, "compatible", &cplen);
181	if (!compat)
182		return csize;
183
184	/* Find true end (we tolerate multiple \0 at the end */
185	for (i = (cplen - 1); i >= 0 && !compat[i]; i--)
186		cplen--;
187	if (!cplen)
188		return csize;
189	cplen++;
190
191	/* Check space (need cplen+1 chars including final \0) */
192	tsize = csize + cplen;
193	repend = tsize;
194
195	if (csize >= len)		/* @ the limit, all is already filled */
196		return tsize;
197
198	if (tsize >= len) {		/* limit compat list */
199		cplen = len - csize - 1;
200		repend = len;
201	}
202
203	/* Copy and do char replacement */
204	memcpy(&str[csize + 1], compat, cplen);
205	for (i = csize; i < repend; i++) {
206		char c = str[i];
207		if (c == '\0')
208			str[i] = 'C';
209		else if (c == ' ')
210			str[i] = '_';
211	}
212
213	return tsize;
214}
215
216/**
217 * of_device_uevent - Display OF related uevent information
218 */
219void of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
220{
221	const char *compat;
222	struct alias_prop *app;
223	int seen = 0, cplen, sl;
224
225	if ((!dev) || (!dev->of_node))
226		return;
227
228	add_uevent_var(env, "OF_NAME=%s", dev->of_node->name);
229	add_uevent_var(env, "OF_FULLNAME=%s", dev->of_node->full_name);
230	if (dev->of_node->type && strcmp("<NULL>", dev->of_node->type) != 0)
231		add_uevent_var(env, "OF_TYPE=%s", dev->of_node->type);
232
233	/* Since the compatible field can contain pretty much anything
234	 * it's not really legal to split it out with commas. We split it
235	 * up using a number of environment variables instead. */
236	compat = of_get_property(dev->of_node, "compatible", &cplen);
237	while (compat && *compat && cplen > 0) {
238		add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat);
239		sl = strlen(compat) + 1;
240		compat += sl;
241		cplen -= sl;
242		seen++;
243	}
244	add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen);
245
246	seen = 0;
247	mutex_lock(&of_mutex);
248	list_for_each_entry(app, &aliases_lookup, link) {
249		if (dev->of_node == app->np) {
250			add_uevent_var(env, "OF_ALIAS_%d=%s", seen,
251				       app->alias);
252			seen++;
253		}
254	}
255	mutex_unlock(&of_mutex);
256}
257
258int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
259{
260	int sl;
261
262	if ((!dev) || (!dev->of_node))
263		return -ENODEV;
264
265	/* Devicetree modalias is tricky, we add it in 2 steps */
266	if (add_uevent_var(env, "MODALIAS="))
267		return -ENOMEM;
268
269	sl = of_device_get_modalias(dev, &env->buf[env->buflen-1],
270				    sizeof(env->buf) - env->buflen);
271	if (sl >= (sizeof(env->buf) - env->buflen))
272		return -ENOMEM;
273	env->buflen += sl;
274
275	return 0;
276}
277