blob: 33d85511d7904e17a5c5ea10132474ce62da7dcc [file] [log] [blame]
Rob Herringaf6074f2017-12-27 12:55:14 -06001// SPDX-License-Identifier: GPL-2.0
Stephen Rothwellf85ff302007-05-01 16:40:36 +10002#include <linux/string.h>
3#include <linux/kernel.h>
4#include <linux/of.h>
Stephen Rothwellf898f8d2007-05-01 16:49:51 +10005#include <linux/of_device.h>
Murali Karicheri1f5c69a2015-03-03 12:52:09 -05006#include <linux/of_address.h>
7#include <linux/of_iommu.h>
8#include <linux/dma-mapping.h>
Stephen Rothwellf85ff302007-05-01 16:40:36 +10009#include <linux/init.h>
10#include <linux/module.h>
11#include <linux/mod_devicetable.h>
12#include <linux/slab.h>
Robin Murphy72328882017-08-31 11:32:54 +010013#include <linux/platform_device.h>
Stephen Rothwellf85ff302007-05-01 16:40:36 +100014
15#include <asm/errno.h>
Stepan Moskovchenkoced4eec2012-12-06 14:55:41 -080016#include "of_private.h"
Stephen Rothwellf85ff302007-05-01 16:40:36 +100017
18/**
Grant Likely44504b22010-04-13 16:13:22 -070019 * of_match_device - Tell if a struct device matches an of_device_id list
Stephen Rothwellf85ff302007-05-01 16:40:36 +100020 * @ids: array of of device match structures to search in
21 * @dev: the of device structure to match against
22 *
Grant Likely2dc11582010-08-06 09:25:50 -060023 * Used by a driver to check whether an platform_device present in the
Stephen Rothwellf85ff302007-05-01 16:40:36 +100024 * system is in its list of supported devices.
25 */
26const struct of_device_id *of_match_device(const struct of_device_id *matches,
Grant Likely44504b22010-04-13 16:13:22 -070027 const struct device *dev)
Stephen Rothwellf85ff302007-05-01 16:40:36 +100028{
Grant Likely8cec0e72010-06-08 07:48:17 -060029 if ((!matches) || (!dev->of_node))
Stephen Rothwellf85ff302007-05-01 16:40:36 +100030 return NULL;
Grant Likely44504b22010-04-13 16:13:22 -070031 return of_match_node(matches, dev->of_node);
Stephen Rothwellf85ff302007-05-01 16:40:36 +100032}
33EXPORT_SYMBOL(of_match_device);
34
Grant Likely94a0cb12010-07-22 13:59:23 -060035struct platform_device *of_dev_get(struct platform_device *dev)
Stephen Rothwellf85ff302007-05-01 16:40:36 +100036{
37 struct device *tmp;
38
39 if (!dev)
40 return NULL;
41 tmp = get_device(&dev->dev);
42 if (tmp)
Grant Likely94a0cb12010-07-22 13:59:23 -060043 return to_platform_device(tmp);
Stephen Rothwellf85ff302007-05-01 16:40:36 +100044 else
45 return NULL;
46}
47EXPORT_SYMBOL(of_dev_get);
48
Grant Likely94a0cb12010-07-22 13:59:23 -060049void of_dev_put(struct platform_device *dev)
Stephen Rothwellf85ff302007-05-01 16:40:36 +100050{
51 if (dev)
52 put_device(&dev->dev);
53}
54EXPORT_SYMBOL(of_dev_put);
55
Grant Likely7096d042010-10-20 11:45:13 -060056int of_device_add(struct platform_device *ofdev)
Stephen Rothwellf85ff302007-05-01 16:40:36 +100057{
Grant Likely61c7a082010-04-13 16:12:29 -070058 BUG_ON(ofdev->dev.of_node == NULL);
Jeremy Kerr6098e2e2008-10-26 21:51:25 +000059
Grant Likelyeca39302010-06-08 07:48:21 -060060 /* name and id have to be set so that the platform bus doesn't get
61 * confused on matching */
62 ofdev->name = dev_name(&ofdev->dev);
Andy Shevchenko6d7e3bf82017-08-25 18:33:13 +030063 ofdev->id = PLATFORM_DEVID_NONE;
Grant Likelyeca39302010-06-08 07:48:21 -060064
Zhen Lei56f2de82015-08-25 12:08:22 +080065 /*
66 * If this device has not binding numa node in devicetree, that is
67 * of_node_to_nid returns NUMA_NO_NODE. device_add will assume that this
68 * device is on the same node as the parent.
69 */
70 set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));
Jeremy Kerr6098e2e2008-10-26 21:51:25 +000071
72 return device_add(&ofdev->dev);
Stephen Rothwellf85ff302007-05-01 16:40:36 +100073}
Grant Likely7096d042010-10-20 11:45:13 -060074
Murali Karicheri1f5c69a2015-03-03 12:52:09 -050075/**
76 * of_dma_configure - Setup DMA configuration
77 * @dev: Device to apply DMA configuration
78 * @np: Pointer to OF node having DMA configuration
Christoph Hellwig3d6ce862018-05-03 16:25:08 +020079 * @force_dma: Whether device is to be set up by of_dma_configure() even if
80 * DMA capability is not explicitly described by firmware.
Murali Karicheri1f5c69a2015-03-03 12:52:09 -050081 *
82 * Try to get devices's DMA configuration from DT and update it
83 * accordingly.
84 *
85 * If platform code needs to use its own special DMA configuration, it
86 * can use a platform bus notifier and handle BUS_NOTIFY_ADD_DEVICE events
87 * to fix up DMA configuration.
88 */
Christoph Hellwig3d6ce862018-05-03 16:25:08 +020089int of_dma_configure(struct device *dev, struct device_node *np, bool force_dma)
Murali Karicheri1f5c69a2015-03-03 12:52:09 -050090{
Robin Murphy72328882017-08-31 11:32:54 +010091 u64 dma_addr, paddr, size = 0;
Murali Karicheri1f5c69a2015-03-03 12:52:09 -050092 int ret;
93 bool coherent;
94 unsigned long offset;
Robin Murphy53c92d72016-04-07 18:42:05 +010095 const struct iommu_ops *iommu;
Robin Murphyee7b1f32017-08-11 17:29:56 +010096 u64 mask;
Murali Karicheri1f5c69a2015-03-03 12:52:09 -050097
Murali Karicheri1f5c69a2015-03-03 12:52:09 -050098 ret = of_dma_get_range(np, &dma_addr, &paddr, &size);
99 if (ret < 0) {
Robin Murphy72328882017-08-31 11:32:54 +0100100 /*
101 * For legacy reasons, we have to assume some devices need
102 * DMA configuration regardless of whether "dma-ranges" is
103 * correctly specified or not.
104 */
Christoph Hellwig3d6ce862018-05-03 16:25:08 +0200105 if (!force_dma)
Robin Murphy72328882017-08-31 11:32:54 +0100106 return ret == -ENODEV ? 0 : ret;
107
Murali Karicheri1f5c69a2015-03-03 12:52:09 -0500108 dma_addr = offset = 0;
Murali Karicheri1f5c69a2015-03-03 12:52:09 -0500109 } else {
110 offset = PFN_DOWN(paddr - dma_addr);
Murali Karicheri0c79c812015-03-03 12:52:10 -0500111
112 /*
113 * Add a work around to treat the size as mask + 1 in case
114 * it is defined in DT as a mask.
115 */
116 if (size & 1) {
117 dev_warn(dev, "Invalid size 0x%llx for dma-range\n",
118 size);
119 size = size + 1;
120 }
121
122 if (!size) {
123 dev_err(dev, "Adjusted size 0x%llx invalid\n", size);
Laurent Pinchart7b07cbe2017-04-10 16:51:02 +0530124 return -EINVAL;
Murali Karicheri0c79c812015-03-03 12:52:10 -0500125 }
Murali Karicheri1f5c69a2015-03-03 12:52:09 -0500126 dev_dbg(dev, "dma_pfn_offset(%#08lx)\n", offset);
127 }
128
Robin Murphy72328882017-08-31 11:32:54 +0100129 /*
130 * Set default coherent_dma_mask to 32 bit. Drivers are expected to
131 * setup the correct supported mask.
132 */
133 if (!dev->coherent_dma_mask)
134 dev->coherent_dma_mask = DMA_BIT_MASK(32);
135 /*
136 * Set it to coherent_dma_mask by default if the architecture
137 * code has not set it.
138 */
139 if (!dev->dma_mask)
140 dev->dma_mask = &dev->coherent_dma_mask;
141
142 if (!size)
143 size = max(dev->coherent_dma_mask, dev->coherent_dma_mask + 1);
144
Murali Karicheri1f5c69a2015-03-03 12:52:09 -0500145 dev->dma_pfn_offset = offset;
146
Murali Karicheri9a6d7292015-03-03 14:44:57 -0600147 /*
148 * Limit coherent and dma mask based on size and default mask
149 * set by the driver.
150 */
Robin Murphyee7b1f32017-08-11 17:29:56 +0100151 mask = DMA_BIT_MASK(ilog2(dma_addr + size - 1) + 1);
152 dev->coherent_dma_mask &= mask;
153 *dev->dma_mask &= mask;
Murali Karicheri9a6d7292015-03-03 14:44:57 -0600154
Murali Karicheri1f5c69a2015-03-03 12:52:09 -0500155 coherent = of_dma_is_coherent(np);
156 dev_dbg(dev, "device is%sdma coherent\n",
157 coherent ? " " : " not ");
158
159 iommu = of_iommu_configure(dev, np);
Sricharan Ra37b19a2017-05-27 19:17:41 +0530160 if (IS_ERR(iommu) && PTR_ERR(iommu) == -EPROBE_DEFER)
161 return -EPROBE_DEFER;
Laurent Pinchart7b07cbe2017-04-10 16:51:02 +0530162
Murali Karicheri1f5c69a2015-03-03 12:52:09 -0500163 dev_dbg(dev, "device is%sbehind an iommu\n",
164 iommu ? " " : " not ");
165
166 arch_setup_dma_ops(dev, dma_addr, size, iommu, coherent);
Laurent Pinchart7b07cbe2017-04-10 16:51:02 +0530167
168 return 0;
Murali Karicheri1f5c69a2015-03-03 12:52:09 -0500169}
170EXPORT_SYMBOL_GPL(of_dma_configure);
171
Laurent Pinchart3f186672017-04-10 16:50:58 +0530172/**
173 * of_dma_deconfigure - Clean up DMA configuration
174 * @dev: Device for which to clean up DMA configuration
175 *
176 * Clean up all configuration performed by of_dma_configure_ops() and free all
177 * resources that have been allocated.
178 */
179void of_dma_deconfigure(struct device *dev)
180{
181 arch_teardown_dma_ops(dev);
182}
183
Grant Likely7096d042010-10-20 11:45:13 -0600184int of_device_register(struct platform_device *pdev)
185{
186 device_initialize(&pdev->dev);
187 return of_device_add(pdev);
188}
Stephen Rothwellf85ff302007-05-01 16:40:36 +1000189EXPORT_SYMBOL(of_device_register);
190
Grant Likely94a0cb12010-07-22 13:59:23 -0600191void of_device_unregister(struct platform_device *ofdev)
Stephen Rothwellf85ff302007-05-01 16:40:36 +1000192{
Stephen Rothwellf85ff302007-05-01 16:40:36 +1000193 device_unregister(&ofdev->dev);
194}
195EXPORT_SYMBOL(of_device_unregister);
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000196
Joachim Eastwood3386e0f2015-05-06 20:09:09 +0200197const void *of_device_get_match_data(const struct device *dev)
198{
199 const struct of_device_id *match;
200
201 match = of_match_device(dev->driver->of_match_table, dev);
202 if (!match)
203 return NULL;
204
205 return match->data;
206}
207EXPORT_SYMBOL(of_device_get_match_data);
208
Rob Herring0634c292017-03-22 09:16:27 -0500209static ssize_t of_device_get_modalias(struct device *dev, char *str, ssize_t len)
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000210{
211 const char *compat;
Rob Herringbc575062017-07-21 15:45:32 -0500212 char *c;
213 struct property *p;
214 ssize_t csize;
Bjorn Andersson8c2a75e2017-08-23 18:03:52 -0700215 ssize_t tsize;
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000216
Zhang Ruib9f73062014-01-14 16:46:38 +0800217 if ((!dev) || (!dev->of_node))
218 return -ENODEV;
219
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000220 /* Name & Type */
Grant Likely34a1c1e2010-06-08 07:48:13 -0600221 csize = snprintf(str, len, "of:N%sT%s", dev->of_node->name,
222 dev->of_node->type);
Bjorn Andersson8c2a75e2017-08-23 18:03:52 -0700223 tsize = csize;
Rob Herringbc575062017-07-21 15:45:32 -0500224 len -= csize;
Bjorn Andersson8c2a75e2017-08-23 18:03:52 -0700225 if (str)
226 str += csize;
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000227
Rob Herringbc575062017-07-21 15:45:32 -0500228 of_property_for_each_string(dev->of_node, "compatible", p, compat) {
Bjorn Andersson8c2a75e2017-08-23 18:03:52 -0700229 csize = strlen(compat) + 1;
230 tsize += csize;
231 if (csize > len)
232 continue;
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000233
Rob Herringbc575062017-07-21 15:45:32 -0500234 csize = snprintf(str, len, "C%s", compat);
235 for (c = str; c; ) {
236 c = strchr(c, ' ');
237 if (c)
238 *c++ = '_';
239 }
240 len -= csize;
241 str += csize;
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000242 }
243
Bjorn Andersson8c2a75e2017-08-23 18:03:52 -0700244 return tsize;
Stephen Rothwell09e67ca2008-05-16 11:57:45 +1000245}
Grant Likelydd27dcd2010-06-08 07:48:12 -0600246
Stephen Boyd9c829c02016-12-28 14:56:47 -0800247int of_device_request_module(struct device *dev)
248{
249 char *str;
250 ssize_t size;
251 int ret;
252
253 size = of_device_get_modalias(dev, NULL, 0);
254 if (size < 0)
255 return size;
256
257 str = kmalloc(size + 1, GFP_KERNEL);
258 if (!str)
259 return -ENOMEM;
260
261 of_device_get_modalias(dev, str, size);
262 str[size] = '\0';
263 ret = request_module(str);
264 kfree(str);
265
266 return ret;
267}
268EXPORT_SYMBOL_GPL(of_device_request_module);
269
Grant Likelydd27dcd2010-06-08 07:48:12 -0600270/**
Rob Herring0634c292017-03-22 09:16:27 -0500271 * of_device_modalias - Fill buffer with newline terminated modalias string
272 */
273ssize_t of_device_modalias(struct device *dev, char *str, ssize_t len)
274{
275 ssize_t sl = of_device_get_modalias(dev, str, len - 2);
276 if (sl < 0)
277 return sl;
Bjorn Andersson08ab58d2017-08-23 18:04:04 -0700278 if (sl > len - 2)
279 return -ENOMEM;
Rob Herring0634c292017-03-22 09:16:27 -0500280
281 str[sl++] = '\n';
282 str[sl] = 0;
283 return sl;
284}
285EXPORT_SYMBOL_GPL(of_device_modalias);
286
287/**
Grant Likelydd27dcd2010-06-08 07:48:12 -0600288 * of_device_uevent - Display OF related uevent information
289 */
Grant Likely07d57a32012-02-01 11:22:22 -0700290void of_device_uevent(struct device *dev, struct kobj_uevent_env *env)
Grant Likelydd27dcd2010-06-08 07:48:12 -0600291{
292 const char *compat;
Stepan Moskovchenkoced4eec2012-12-06 14:55:41 -0800293 struct alias_prop *app;
Rob Herringbc575062017-07-21 15:45:32 -0500294 struct property *p;
295 int seen = 0;
Grant Likelydd27dcd2010-06-08 07:48:12 -0600296
297 if ((!dev) || (!dev->of_node))
Grant Likely07d57a32012-02-01 11:22:22 -0700298 return;
Grant Likelydd27dcd2010-06-08 07:48:12 -0600299
Grant Likely07d57a32012-02-01 11:22:22 -0700300 add_uevent_var(env, "OF_NAME=%s", dev->of_node->name);
Rob Herring0d638a02017-06-01 15:50:55 -0500301 add_uevent_var(env, "OF_FULLNAME=%pOF", dev->of_node);
Grant Likely07d57a32012-02-01 11:22:22 -0700302 if (dev->of_node->type && strcmp("<NULL>", dev->of_node->type) != 0)
303 add_uevent_var(env, "OF_TYPE=%s", dev->of_node->type);
Grant Likelydd27dcd2010-06-08 07:48:12 -0600304
305 /* Since the compatible field can contain pretty much anything
306 * it's not really legal to split it out with commas. We split it
307 * up using a number of environment variables instead. */
Rob Herringbc575062017-07-21 15:45:32 -0500308 of_property_for_each_string(dev->of_node, "compatible", p, compat) {
Grant Likely07d57a32012-02-01 11:22:22 -0700309 add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat);
Grant Likelydd27dcd2010-06-08 07:48:12 -0600310 seen++;
311 }
Grant Likely07d57a32012-02-01 11:22:22 -0700312 add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen);
Stepan Moskovchenkoced4eec2012-12-06 14:55:41 -0800313
314 seen = 0;
Pantelis Antoniouc05aba22014-07-04 19:58:03 +0300315 mutex_lock(&of_mutex);
Stepan Moskovchenkoced4eec2012-12-06 14:55:41 -0800316 list_for_each_entry(app, &aliases_lookup, link) {
317 if (dev->of_node == app->np) {
318 add_uevent_var(env, "OF_ALIAS_%d=%s", seen,
319 app->alias);
320 seen++;
321 }
322 }
Pantelis Antoniouc05aba22014-07-04 19:58:03 +0300323 mutex_unlock(&of_mutex);
Grant Likely07d57a32012-02-01 11:22:22 -0700324}
Grant Likelydd27dcd2010-06-08 07:48:12 -0600325
Grant Likely07d57a32012-02-01 11:22:22 -0700326int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
327{
328 int sl;
Grant Likelydd27dcd2010-06-08 07:48:12 -0600329
Grant Likely07d57a32012-02-01 11:22:22 -0700330 if ((!dev) || (!dev->of_node))
331 return -ENODEV;
332
333 /* Devicetree modalias is tricky, we add it in 2 steps */
Grant Likelydd27dcd2010-06-08 07:48:12 -0600334 if (add_uevent_var(env, "MODALIAS="))
335 return -ENOMEM;
336
Grant Likely34a1c1e2010-06-08 07:48:13 -0600337 sl = of_device_get_modalias(dev, &env->buf[env->buflen-1],
Grant Likelydd27dcd2010-06-08 07:48:12 -0600338 sizeof(env->buf) - env->buflen);
339 if (sl >= (sizeof(env->buf) - env->buflen))
340 return -ENOMEM;
341 env->buflen += sl;
342
343 return 0;
344}
Stephen Boyd7a3b7cd2016-12-28 14:56:48 -0800345EXPORT_SYMBOL_GPL(of_device_uevent_modalias);