blob: 0437537751bc0c593dbe3554e216727b845f3a78 [file] [log] [blame]
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001/*
2 * omap_device implementation
3 *
Paul Walmsley887adea2010-07-26 16:34:33 -06004 * Copyright (C) 2009-2010 Nokia Corporation
Paul Walmsley4788da22010-05-18 20:24:05 -06005 * Paul Walmsley, Kevin Hilman
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03006 *
7 * Developed in collaboration with (alphabetical order): Benoit
Paul Walmsley4788da22010-05-18 20:24:05 -06008 * Cousson, Thara Gopinath, Tony Lindgren, Rajendra Nayak, Vikram
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03009 * Pandita, Sakari Poussa, Anand Sawant, Santosh Shilimkar, Richard
10 * Woodruff
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
15 *
16 * This code provides a consistent interface for OMAP device drivers
17 * to control power management and interconnect properties of their
18 * devices.
19 *
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -070020 * In the medium- to long-term, this code should be implemented as a
21 * proper omap_bus/omap_device in Linux, no more platform_data func
22 * pointers
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030023 *
24 *
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030025 */
26#undef DEBUG
27
28#include <linux/kernel.h>
29#include <linux/platform_device.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030031#include <linux/err.h>
32#include <linux/io.h>
Partha Basak4ef7aca2010-09-21 19:23:04 +020033#include <linux/clk.h>
Rajendra Nayakda0653f2011-02-25 15:40:21 -070034#include <linux/clkdev.h>
Tomeu Vizoso989561d2016-01-07 16:46:13 +010035#include <linux/pm_domain.h>
Kevin Hilman345f79b2011-05-31 16:08:09 -070036#include <linux/pm_runtime.h>
Benoit Coussondc2d07e2011-08-10 13:32:08 +020037#include <linux/of.h>
38#include <linux/notifier.h>
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030039
Tony Lindgrendad12d12013-12-06 10:52:58 -080040#include "common.h"
Tony Lindgrenb76c8b12013-01-11 11:24:18 -080041#include "soc.h"
Tony Lindgren25c7d492012-10-02 17:25:48 -070042#include "omap_device.h"
Tony Lindgren2a296c82012-10-02 17:41:35 -070043#include "omap_hwmod.h"
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030044
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030045/* Private functions */
46
Benoit Coussonbf1e0772011-07-10 05:54:12 -060047static void _add_clkdev(struct omap_device *od, const char *clk_alias,
48 const char *clk_name)
49{
50 struct clk *r;
Russell King1ca90bd2015-03-02 15:46:03 +000051 int rc;
Benoit Coussonbf1e0772011-07-10 05:54:12 -060052
53 if (!clk_alias || !clk_name)
54 return;
55
Kevin Hilmand66b3fe2011-07-21 13:58:51 -070056 dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name);
Benoit Coussonbf1e0772011-07-10 05:54:12 -060057
Kevin Hilmand66b3fe2011-07-21 13:58:51 -070058 r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias);
Benoit Coussonbf1e0772011-07-10 05:54:12 -060059 if (!IS_ERR(r)) {
Markus Pargmann9a02ae42014-08-25 16:15:34 -070060 dev_dbg(&od->pdev->dev,
Kevin Hilman49882c92011-07-21 09:58:36 -070061 "alias %s already exists\n", clk_alias);
Benoit Coussonbf1e0772011-07-10 05:54:12 -060062 clk_put(r);
63 return;
64 }
65
Russell King1ca90bd2015-03-02 15:46:03 +000066 rc = clk_add_alias(clk_alias, dev_name(&od->pdev->dev), clk_name, NULL);
67 if (rc) {
68 if (rc == -ENODEV || rc == -ENOMEM)
69 dev_err(&od->pdev->dev,
70 "clkdev_alloc for %s failed\n", clk_alias);
71 else
72 dev_err(&od->pdev->dev,
73 "clk_get for %s failed\n", clk_name);
Benoit Coussonbf1e0772011-07-10 05:54:12 -060074 }
Benoit Coussonbf1e0772011-07-10 05:54:12 -060075}
76
Partha Basak4ef7aca2010-09-21 19:23:04 +020077/**
Benoit Coussonbf1e0772011-07-10 05:54:12 -060078 * _add_hwmod_clocks_clkdev - Add clkdev entry for hwmod optional clocks
79 * and main clock
Partha Basak4ef7aca2010-09-21 19:23:04 +020080 * @od: struct omap_device *od
Benoit Coussonbf1e0772011-07-10 05:54:12 -060081 * @oh: struct omap_hwmod *oh
Partha Basak4ef7aca2010-09-21 19:23:04 +020082 *
Benoit Coussonbf1e0772011-07-10 05:54:12 -060083 * For the main clock and every optional clock present per hwmod per
84 * omap_device, this function adds an entry in the clkdev table of the
85 * form <dev-id=dev_name, con-id=role> if it does not exist already.
Partha Basak4ef7aca2010-09-21 19:23:04 +020086 *
87 * The function is called from inside omap_device_build_ss(), after
88 * omap_device_register.
89 *
90 * This allows drivers to get a pointer to its optional clocks based on its role
91 * by calling clk_get(<dev*>, <role>).
Benoit Coussonbf1e0772011-07-10 05:54:12 -060092 * In the case of the main clock, a "fck" alias is used.
Partha Basak4ef7aca2010-09-21 19:23:04 +020093 *
94 * No return value.
95 */
Benoit Coussonbf1e0772011-07-10 05:54:12 -060096static void _add_hwmod_clocks_clkdev(struct omap_device *od,
97 struct omap_hwmod *oh)
Partha Basak4ef7aca2010-09-21 19:23:04 +020098{
99 int i;
100
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600101 _add_clkdev(od, "fck", oh->main_clk);
Partha Basak4ef7aca2010-09-21 19:23:04 +0200102
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600103 for (i = 0; i < oh->opt_clks_cnt; i++)
104 _add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk);
Partha Basak4ef7aca2010-09-21 19:23:04 +0200105}
106
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300107
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200108/**
109 * omap_device_build_from_dt - build an omap_device with multiple hwmods
110 * @pdev_name: name of the platform_device driver to use
111 * @pdev_id: this platform_device's connection ID
112 * @oh: ptr to the single omap_hwmod that backs this omap_device
113 * @pdata: platform_data ptr to associate with the platform_device
114 * @pdata_len: amount of memory pointed to by @pdata
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200115 *
116 * Function for building an omap_device already registered from device-tree
117 *
118 * Returns 0 or PTR_ERR() on error.
119 */
120static int omap_device_build_from_dt(struct platform_device *pdev)
121{
122 struct omap_hwmod **hwmods;
123 struct omap_device *od;
124 struct omap_hwmod *oh;
125 struct device_node *node = pdev->dev.of_node;
126 const char *oh_name;
127 int oh_cnt, i, ret = 0;
Rajendra Nayak72680322013-07-28 23:01:51 -0600128 bool device_active = false;
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200129
130 oh_cnt = of_property_count_strings(node, "ti,hwmods");
Russell Kingc48cd652013-03-13 20:44:21 +0000131 if (oh_cnt <= 0) {
Benoit Cousson5dc06b72012-01-20 18:14:00 +0100132 dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n");
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200133 return -ENODEV;
134 }
135
136 hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
137 if (!hwmods) {
138 ret = -ENOMEM;
139 goto odbfd_exit;
140 }
141
142 for (i = 0; i < oh_cnt; i++) {
143 of_property_read_string_index(node, "ti,hwmods", i, &oh_name);
144 oh = omap_hwmod_lookup(oh_name);
145 if (!oh) {
146 dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n",
147 oh_name);
148 ret = -EINVAL;
149 goto odbfd_exit1;
150 }
151 hwmods[i] = oh;
Rajendra Nayak72680322013-07-28 23:01:51 -0600152 if (oh->flags & HWMOD_INIT_NO_IDLE)
153 device_active = true;
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200154 }
155
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700156 od = omap_device_alloc(pdev, hwmods, oh_cnt);
Wei Yongjun4cf9cf82013-09-18 12:01:58 -0700157 if (IS_ERR(od)) {
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200158 dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n",
159 oh_name);
160 ret = PTR_ERR(od);
161 goto odbfd_exit1;
162 }
163
Peter Ujfalusi3956a1a2012-08-23 16:54:09 +0300164 /* Fix up missing resource names */
165 for (i = 0; i < pdev->num_resources; i++) {
166 struct resource *r = &pdev->resource[i];
167
168 if (r->name == NULL)
169 r->name = dev_name(&pdev->dev);
170 }
171
Tomeu Vizoso989561d2016-01-07 16:46:13 +0100172 dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain);
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200173
Rajendra Nayak72680322013-07-28 23:01:51 -0600174 if (device_active) {
175 omap_device_enable(pdev);
176 pm_runtime_set_active(&pdev->dev);
177 }
178
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200179odbfd_exit1:
180 kfree(hwmods);
181odbfd_exit:
Nishanth Menonf5c33b02013-12-03 19:39:13 -0600182 /* if data/we are at fault.. load up a fail handler */
183 if (ret)
Tomeu Vizoso989561d2016-01-07 16:46:13 +0100184 dev_pm_domain_set(&pdev->dev, &omap_device_fail_pm_domain);
Nishanth Menonf5c33b02013-12-03 19:39:13 -0600185
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200186 return ret;
187}
188
189static int _omap_device_notifier_call(struct notifier_block *nb,
190 unsigned long event, void *dev)
191{
192 struct platform_device *pdev = to_platform_device(dev);
Kevin Hilmane7533452012-07-10 11:13:16 -0700193 struct omap_device *od;
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200194
195 switch (event) {
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200196 case BUS_NOTIFY_DEL_DEVICE:
197 if (pdev->archdata.od)
198 omap_device_delete(pdev->archdata.od);
199 break;
Kevin Hilmane7533452012-07-10 11:13:16 -0700200 case BUS_NOTIFY_ADD_DEVICE:
201 if (pdev->dev.of_node)
202 omap_device_build_from_dt(pdev);
Tony Lindgrendad12d12013-12-06 10:52:58 -0800203 omap_auxdata_legacy_init(dev);
Kevin Hilmane7533452012-07-10 11:13:16 -0700204 /* fall through */
205 default:
206 od = to_omap_device(pdev);
207 if (od)
208 od->_driver_status = event;
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200209 }
210
211 return NOTIFY_DONE;
212}
213
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700214/**
215 * _omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods
216 * @od: struct omap_device *od
217 *
218 * Enable all underlying hwmods. Returns 0.
219 */
220static int _omap_device_enable_hwmods(struct omap_device *od)
221{
Pali Rohár6da23352015-02-26 14:49:51 +0100222 int ret = 0;
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700223 int i;
224
225 for (i = 0; i < od->hwmods_cnt; i++)
Pali Rohár6da23352015-02-26 14:49:51 +0100226 ret |= omap_hwmod_enable(od->hwmods[i]);
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700227
Pali Rohár6da23352015-02-26 14:49:51 +0100228 return ret;
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700229}
230
231/**
232 * _omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods
233 * @od: struct omap_device *od
234 *
235 * Idle all underlying hwmods. Returns 0.
236 */
237static int _omap_device_idle_hwmods(struct omap_device *od)
238{
Pali Rohár6da23352015-02-26 14:49:51 +0100239 int ret = 0;
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700240 int i;
241
242 for (i = 0; i < od->hwmods_cnt; i++)
Pali Rohár6da23352015-02-26 14:49:51 +0100243 ret |= omap_hwmod_idle(od->hwmods[i]);
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700244
Pali Rohár6da23352015-02-26 14:49:51 +0100245 return ret;
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700246}
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200247
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300248/* Public functions for use by core code */
249
250/**
Kevin Hilmanc80705a2010-12-21 21:31:55 -0700251 * omap_device_get_context_loss_count - get lost context count
252 * @od: struct omap_device *
253 *
254 * Using the primary hwmod, query the context loss count for this
255 * device.
256 *
257 * Callers should consider context for this device lost any time this
258 * function returns a value different than the value the caller got
259 * the last time it called this function.
260 *
261 * If any hwmods exist for the omap_device assoiated with @pdev,
262 * return the context loss counter for that hwmod, otherwise return
263 * zero.
264 */
Tomi Valkeinenfc013872011-06-09 16:56:23 +0300265int omap_device_get_context_loss_count(struct platform_device *pdev)
Kevin Hilmanc80705a2010-12-21 21:31:55 -0700266{
267 struct omap_device *od;
268 u32 ret = 0;
269
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600270 od = to_omap_device(pdev);
Kevin Hilmanc80705a2010-12-21 21:31:55 -0700271
272 if (od->hwmods_cnt)
273 ret = omap_hwmod_get_context_loss_count(od->hwmods[0]);
274
275 return ret;
276}
277
278/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300279 * omap_device_count_resources - count number of struct resource entries needed
280 * @od: struct omap_device *
Peter Ujfalusidad41912012-11-21 16:15:17 -0700281 * @flags: Type of resources to include when counting (IRQ/DMA/MEM)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300282 *
283 * Count the number of struct resource entries needed for this
284 * omap_device @od. Used by omap_device_build_ss() to determine how
285 * much memory to allocate before calling
286 * omap_device_fill_resources(). Returns the count.
287 */
Peter Ujfalusidad41912012-11-21 16:15:17 -0700288static int omap_device_count_resources(struct omap_device *od,
289 unsigned long flags)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300290{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300291 int c = 0;
292 int i;
293
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -0600294 for (i = 0; i < od->hwmods_cnt; i++)
Peter Ujfalusidad41912012-11-21 16:15:17 -0700295 c += omap_hwmod_count_resources(od->hwmods[i], flags);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300296
Paul Walmsley7852ec02012-07-26 00:54:26 -0600297 pr_debug("omap_device: %s: counted %d total resources across %d hwmods\n",
298 od->pdev->name, c, od->hwmods_cnt);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300299
300 return c;
301}
302
303/**
304 * omap_device_fill_resources - fill in array of struct resource
305 * @od: struct omap_device *
306 * @res: pointer to an array of struct resource to be filled in
307 *
308 * Populate one or more empty struct resource pointed to by @res with
309 * the resource data for this omap_device @od. Used by
310 * omap_device_build_ss() after calling omap_device_count_resources().
311 * Ideally this function would not be needed at all. If omap_device
312 * replaces platform_device, then we can specify our own
313 * get_resource()/ get_irq()/etc functions that use the underlying
314 * omap_hwmod information. Or if platform_device is extended to use
315 * subarchitecture-specific function pointers, the various
316 * platform_device functions can simply call omap_device internal
317 * functions to get device resources. Hacking around the existing
318 * platform_device code wastes memory. Returns 0.
319 */
Kevin Hilmana2a28ad2011-07-21 14:14:35 -0700320static int omap_device_fill_resources(struct omap_device *od,
321 struct resource *res)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300322{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300323 int i, r;
324
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -0600325 for (i = 0; i < od->hwmods_cnt; i++) {
326 r = omap_hwmod_fill_resources(od->hwmods[i], res);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300327 res += r;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300328 }
329
330 return 0;
331}
332
333/**
Vaibhav Hiremathb82b04e2012-08-29 15:18:11 +0530334 * _od_fill_dma_resources - fill in array of struct resource with dma resources
335 * @od: struct omap_device *
336 * @res: pointer to an array of struct resource to be filled in
337 *
338 * Populate one or more empty struct resource pointed to by @res with
339 * the dma resource data for this omap_device @od. Used by
340 * omap_device_alloc() after calling omap_device_count_resources().
341 *
342 * Ideally this function would not be needed at all. If we have
343 * mechanism to get dma resources from DT.
344 *
345 * Returns 0.
346 */
347static int _od_fill_dma_resources(struct omap_device *od,
348 struct resource *res)
349{
350 int i, r;
351
352 for (i = 0; i < od->hwmods_cnt; i++) {
353 r = omap_hwmod_fill_dma_resources(od->hwmods[i], res);
354 res += r;
355 }
356
357 return 0;
358}
359
360/**
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200361 * omap_device_alloc - allocate an omap_device
362 * @pdev: platform_device that will be included in this omap_device
363 * @oh: ptr to the single omap_hwmod that backs this omap_device
364 * @pdata: platform_data ptr to associate with the platform_device
365 * @pdata_len: amount of memory pointed to by @pdata
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200366 *
367 * Convenience function for allocating an omap_device structure and filling
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700368 * hwmods, and resources.
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200369 *
370 * Returns an struct omap_device pointer or ERR_PTR() on error;
371 */
Ohad Ben-Cohen993e4fb2012-02-20 09:43:29 -0800372struct omap_device *omap_device_alloc(struct platform_device *pdev,
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700373 struct omap_hwmod **ohs, int oh_cnt)
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200374{
375 int ret = -ENOMEM;
376 struct omap_device *od;
377 struct resource *res = NULL;
378 int i, res_count;
379 struct omap_hwmod **hwmods;
380
381 od = kzalloc(sizeof(struct omap_device), GFP_KERNEL);
382 if (!od) {
383 ret = -ENOMEM;
384 goto oda_exit1;
385 }
386 od->hwmods_cnt = oh_cnt;
387
388 hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
389 if (!hwmods)
390 goto oda_exit2;
391
392 od->hwmods = hwmods;
393 od->pdev = pdev;
394
Vaibhav Hiremathb82b04e2012-08-29 15:18:11 +0530395 /*
Peter Ujfalusic567b052012-11-21 16:15:18 -0700396 * Non-DT Boot:
397 * Here, pdev->num_resources = 0, and we should get all the
398 * resources from hwmod.
399 *
Vaibhav Hiremathb82b04e2012-08-29 15:18:11 +0530400 * DT Boot:
401 * OF framework will construct the resource structure (currently
402 * does for MEM & IRQ resource) and we should respect/use these
403 * resources, killing hwmod dependency.
404 * If pdev->num_resources > 0, we assume that MEM & IRQ resources
405 * have been allocated by OF layer already (through DTB).
Peter Ujfalusic567b052012-11-21 16:15:18 -0700406 * As preparation for the future we examine the OF provided resources
407 * to see if we have DMA resources provided already. In this case
408 * there is no need to update the resources for the device, we use the
409 * OF provided ones.
Vaibhav Hiremathb82b04e2012-08-29 15:18:11 +0530410 *
411 * TODO: Once DMA resource is available from OF layer, we should
412 * kill filling any resources from hwmod.
413 */
Peter Ujfalusic567b052012-11-21 16:15:18 -0700414 if (!pdev->num_resources) {
415 /* Count all resources for the device */
416 res_count = omap_device_count_resources(od, IORESOURCE_IRQ |
417 IORESOURCE_DMA |
418 IORESOURCE_MEM);
419 } else {
420 /* Take a look if we already have DMA resource via DT */
421 for (i = 0; i < pdev->num_resources; i++) {
422 struct resource *r = &pdev->resource[i];
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200423
Peter Ujfalusic567b052012-11-21 16:15:18 -0700424 /* We have it, no need to touch the resources */
425 if (r->flags == IORESOURCE_DMA)
426 goto have_everything;
Vaibhav Hiremathb82b04e2012-08-29 15:18:11 +0530427 }
Peter Ujfalusic567b052012-11-21 16:15:18 -0700428 /* Count only DMA resources for the device */
429 res_count = omap_device_count_resources(od, IORESOURCE_DMA);
430 /* The device has no DMA resource, no need for update */
431 if (!res_count)
432 goto have_everything;
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200433
Peter Ujfalusic567b052012-11-21 16:15:18 -0700434 res_count += pdev->num_resources;
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200435 }
436
Peter Ujfalusic567b052012-11-21 16:15:18 -0700437 /* Allocate resources memory to account for new resources */
438 res = kzalloc(sizeof(struct resource) * res_count, GFP_KERNEL);
439 if (!res)
440 goto oda_exit3;
441
442 if (!pdev->num_resources) {
443 dev_dbg(&pdev->dev, "%s: using %d resources from hwmod\n",
444 __func__, res_count);
445 omap_device_fill_resources(od, res);
446 } else {
447 dev_dbg(&pdev->dev,
448 "%s: appending %d DMA resources from hwmod\n",
449 __func__, res_count - pdev->num_resources);
450 memcpy(res, pdev->resource,
451 sizeof(struct resource) * pdev->num_resources);
452 _od_fill_dma_resources(od, &res[pdev->num_resources]);
453 }
454
455 ret = platform_device_add_resources(pdev, res, res_count);
456 kfree(res);
457
458 if (ret)
459 goto oda_exit3;
460
461have_everything:
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200462 pdev->archdata.od = od;
463
464 for (i = 0; i < oh_cnt; i++) {
465 hwmods[i]->od = od;
466 _add_hwmod_clocks_clkdev(od, hwmods[i]);
467 }
468
469 return od;
470
471oda_exit3:
472 kfree(hwmods);
473oda_exit2:
474 kfree(od);
475oda_exit1:
476 dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret);
477
478 return ERR_PTR(ret);
479}
480
Ohad Ben-Cohen993e4fb2012-02-20 09:43:29 -0800481void omap_device_delete(struct omap_device *od)
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200482{
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200483 if (!od)
484 return;
485
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200486 od->pdev->archdata.od = NULL;
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200487 kfree(od->hwmods);
488 kfree(od);
489}
490
491/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300492 * omap_device_build - build and register an omap_device with one omap_hwmod
493 * @pdev_name: name of the platform_device driver to use
494 * @pdev_id: this platform_device's connection ID
495 * @oh: ptr to the single omap_hwmod that backs this omap_device
496 * @pdata: platform_data ptr to associate with the platform_device
497 * @pdata_len: amount of memory pointed to by @pdata
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300498 *
499 * Convenience function for building and registering a single
500 * omap_device record, which in turn builds and registers a
501 * platform_device record. See omap_device_build_ss() for more
502 * information. Returns ERR_PTR(-EINVAL) if @oh is NULL; otherwise,
503 * passes along the return value of omap_device_build_ss().
504 */
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700505struct platform_device __init *omap_device_build(const char *pdev_name,
506 int pdev_id,
507 struct omap_hwmod *oh,
508 void *pdata, int pdata_len)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300509{
510 struct omap_hwmod *ohs[] = { oh };
511
512 if (!oh)
513 return ERR_PTR(-EINVAL);
514
515 return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata,
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700516 pdata_len);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300517}
518
519/**
520 * omap_device_build_ss - build and register an omap_device with multiple hwmods
521 * @pdev_name: name of the platform_device driver to use
522 * @pdev_id: this platform_device's connection ID
523 * @oh: ptr to the single omap_hwmod that backs this omap_device
524 * @pdata: platform_data ptr to associate with the platform_device
525 * @pdata_len: amount of memory pointed to by @pdata
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300526 *
527 * Convenience function for building and registering an omap_device
528 * subsystem record. Subsystem records consist of multiple
529 * omap_hwmods. This function in turn builds and registers a
530 * platform_device record. Returns an ERR_PTR() on error, or passes
531 * along the return value of omap_device_register().
532 */
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700533struct platform_device __init *omap_device_build_ss(const char *pdev_name,
534 int pdev_id,
535 struct omap_hwmod **ohs,
536 int oh_cnt, void *pdata,
537 int pdata_len)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300538{
539 int ret = -ENOMEM;
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700540 struct platform_device *pdev;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300541 struct omap_device *od;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300542
543 if (!ohs || oh_cnt == 0 || !pdev_name)
544 return ERR_PTR(-EINVAL);
545
546 if (!pdata && pdata_len > 0)
547 return ERR_PTR(-EINVAL);
548
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700549 pdev = platform_device_alloc(pdev_name, pdev_id);
550 if (!pdev) {
551 ret = -ENOMEM;
552 goto odbs_exit;
553 }
554
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200555 /* Set the dev_name early to allow dev_xxx in omap_device_alloc */
556 if (pdev->id != -1)
557 dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
558 else
559 dev_set_name(&pdev->dev, "%s", pdev->name);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300560
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700561 od = omap_device_alloc(pdev, ohs, oh_cnt);
Wei Yongjuna87e6622012-09-21 14:32:04 +0800562 if (IS_ERR(od))
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700563 goto odbs_exit1;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300564
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700565 ret = platform_device_add_data(pdev, pdata, pdata_len);
Artem Bityutskiy49b368a2010-07-12 13:38:07 +0000566 if (ret)
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200567 goto odbs_exit2;
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700568
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700569 ret = omap_device_register(pdev);
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700570 if (ret)
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200571 goto odbs_exit2;
Kevin Hilman06563582010-07-26 16:34:30 -0600572
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700573 return pdev;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300574
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700575odbs_exit2:
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200576 omap_device_delete(od);
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700577odbs_exit1:
578 platform_device_put(pdev);
579odbs_exit:
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300580
581 pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret);
582
583 return ERR_PTR(ret);
584}
585
Rafael J. Wysockibf7c5442014-12-13 00:42:49 +0100586#ifdef CONFIG_PM
Kevin Hilman638080c2011-04-29 00:36:42 +0200587static int _od_runtime_suspend(struct device *dev)
588{
589 struct platform_device *pdev = to_platform_device(dev);
Kevin Hilman345f79b2011-05-31 16:08:09 -0700590 int ret;
Kevin Hilman638080c2011-04-29 00:36:42 +0200591
Kevin Hilman345f79b2011-05-31 16:08:09 -0700592 ret = pm_generic_runtime_suspend(dev);
Pali Rohár6da23352015-02-26 14:49:51 +0100593 if (ret)
594 return ret;
Kevin Hilman345f79b2011-05-31 16:08:09 -0700595
Pali Rohár6da23352015-02-26 14:49:51 +0100596 return omap_device_idle(pdev);
Kevin Hilman345f79b2011-05-31 16:08:09 -0700597}
598
Kevin Hilman638080c2011-04-29 00:36:42 +0200599static int _od_runtime_resume(struct device *dev)
600{
601 struct platform_device *pdev = to_platform_device(dev);
Pali Rohár6da23352015-02-26 14:49:51 +0100602 int ret;
Kevin Hilman638080c2011-04-29 00:36:42 +0200603
Pali Rohár6da23352015-02-26 14:49:51 +0100604 ret = omap_device_enable(pdev);
605 if (ret)
606 return ret;
Kevin Hilman345f79b2011-05-31 16:08:09 -0700607
608 return pm_generic_runtime_resume(dev);
Kevin Hilman638080c2011-04-29 00:36:42 +0200609}
Nishanth Menonf5c33b02013-12-03 19:39:13 -0600610
611static int _od_fail_runtime_suspend(struct device *dev)
612{
613 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__);
614 return -ENODEV;
615}
616
617static int _od_fail_runtime_resume(struct device *dev)
618{
619 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__);
620 return -ENODEV;
621}
622
Kevin Hilman256a5432011-07-12 22:48:03 +0200623#endif
Kevin Hilman638080c2011-04-29 00:36:42 +0200624
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200625#ifdef CONFIG_SUSPEND
626static int _od_suspend_noirq(struct device *dev)
627{
628 struct platform_device *pdev = to_platform_device(dev);
629 struct omap_device *od = to_omap_device(pdev);
630 int ret;
631
Kevin Hilman72bb6f92012-07-10 15:29:04 -0700632 /* Don't attempt late suspend on a driver that is not bound */
633 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER)
634 return 0;
635
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200636 ret = pm_generic_suspend_noirq(dev);
637
638 if (!ret && !pm_runtime_status_suspended(dev)) {
639 if (pm_generic_runtime_suspend(dev) == 0) {
Nishanth Menon3522bf72013-11-14 11:05:16 -0600640 pm_runtime_set_suspended(dev);
Sourav Poddar4b7ec5a2013-04-27 01:55:34 +0530641 omap_device_idle(pdev);
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200642 od->flags |= OMAP_DEVICE_SUSPENDED;
643 }
644 }
645
646 return ret;
647}
648
649static int _od_resume_noirq(struct device *dev)
650{
651 struct platform_device *pdev = to_platform_device(dev);
652 struct omap_device *od = to_omap_device(pdev);
653
Nishanth Menon3522bf72013-11-14 11:05:16 -0600654 if (od->flags & OMAP_DEVICE_SUSPENDED) {
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200655 od->flags &= ~OMAP_DEVICE_SUSPENDED;
Sourav Poddar4b7ec5a2013-04-27 01:55:34 +0530656 omap_device_enable(pdev);
Nishanth Menon3522bf72013-11-14 11:05:16 -0600657 /*
658 * XXX: we run before core runtime pm has resumed itself. At
659 * this point in time, we just restore the runtime pm state and
660 * considering symmetric operations in resume, we donot expect
661 * to fail. If we failed, something changed in core runtime_pm
662 * framework OR some device driver messed things up, hence, WARN
663 */
664 WARN(pm_runtime_set_active(dev),
665 "Could not set %s runtime state active\n", dev_name(dev));
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200666 pm_generic_runtime_resume(dev);
667 }
668
669 return pm_generic_resume_noirq(dev);
670}
Kevin Hilman126caf12011-09-01 10:59:36 -0700671#else
672#define _od_suspend_noirq NULL
673#define _od_resume_noirq NULL
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200674#endif
675
Nishanth Menonf5c33b02013-12-03 19:39:13 -0600676struct dev_pm_domain omap_device_fail_pm_domain = {
677 .ops = {
678 SET_RUNTIME_PM_OPS(_od_fail_runtime_suspend,
679 _od_fail_runtime_resume, NULL)
680 }
681};
682
Kevin Hilman3ec2dec2012-02-15 11:47:45 -0800683struct dev_pm_domain omap_device_pm_domain = {
Kevin Hilman638080c2011-04-29 00:36:42 +0200684 .ops = {
Kevin Hilman256a5432011-07-12 22:48:03 +0200685 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume,
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +0200686 NULL)
Kevin Hilman638080c2011-04-29 00:36:42 +0200687 USE_PLATFORM_PM_SLEEP_OPS
Grygorii Strashkoc381f222015-04-27 21:24:32 +0300688 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq,
689 _od_resume_noirq)
Kevin Hilman638080c2011-04-29 00:36:42 +0200690 }
691};
692
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700693/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300694 * omap_device_register - register an omap_device with one omap_hwmod
695 * @od: struct omap_device * to register
696 *
697 * Register the omap_device structure. This currently just calls
698 * platform_device_register() on the underlying platform_device.
699 * Returns the return value of platform_device_register().
700 */
Ohad Ben-Cohen993e4fb2012-02-20 09:43:29 -0800701int omap_device_register(struct platform_device *pdev)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300702{
Kevin Hilmanbfae4f82011-07-21 14:47:53 -0700703 pr_debug("omap_device: %s: registering\n", pdev->name);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300704
Tomeu Vizoso989561d2016-01-07 16:46:13 +0100705 dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain);
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700706 return platform_device_add(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300707}
708
709
710/* Public functions for use by device drivers through struct platform_data */
711
712/**
713 * omap_device_enable - fully activate an omap_device
714 * @od: struct omap_device * to activate
715 *
716 * Do whatever is necessary for the hwmods underlying omap_device @od
717 * to be accessible and ready to operate. This generally involves
718 * enabling clocks, setting SYSCONFIG registers; and in the future may
719 * involve remuxing pins. Device drivers should call this function
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700720 * indirectly via pm_runtime_get*(). Returns -EINVAL if called when
721 * the omap_device is already enabled, or passes along the return
722 * value of _omap_device_enable_hwmods().
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300723 */
724int omap_device_enable(struct platform_device *pdev)
725{
726 int ret;
727 struct omap_device *od;
728
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600729 od = to_omap_device(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300730
731 if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
Kevin Hilman49882c92011-07-21 09:58:36 -0700732 dev_warn(&pdev->dev,
733 "omap_device: %s() called from invalid state %d\n",
734 __func__, od->_state);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300735 return -EINVAL;
736 }
737
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700738 ret = _omap_device_enable_hwmods(od);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300739
Pali Rohár6da23352015-02-26 14:49:51 +0100740 if (ret == 0)
741 od->_state = OMAP_DEVICE_STATE_ENABLED;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300742
743 return ret;
744}
745
746/**
747 * omap_device_idle - idle an omap_device
748 * @od: struct omap_device * to idle
749 *
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700750 * Idle omap_device @od. Device drivers call this function indirectly
751 * via pm_runtime_put*(). Returns -EINVAL if the omap_device is not
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300752 * currently enabled, or passes along the return value of
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700753 * _omap_device_idle_hwmods().
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300754 */
755int omap_device_idle(struct platform_device *pdev)
756{
757 int ret;
758 struct omap_device *od;
759
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600760 od = to_omap_device(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300761
762 if (od->_state != OMAP_DEVICE_STATE_ENABLED) {
Kevin Hilman49882c92011-07-21 09:58:36 -0700763 dev_warn(&pdev->dev,
764 "omap_device: %s() called from invalid state %d\n",
765 __func__, od->_state);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300766 return -EINVAL;
767 }
768
Paul Walmsleyc1d1cd52013-01-26 00:48:53 -0700769 ret = _omap_device_idle_hwmods(od);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300770
Pali Rohár6da23352015-02-26 14:49:51 +0100771 if (ret == 0)
772 od->_state = OMAP_DEVICE_STATE_IDLE;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300773
774 return ret;
775}
776
777/**
Omar Ramirez Luna8bb9fde2012-09-23 17:28:18 -0600778 * omap_device_assert_hardreset - set a device's hardreset line
779 * @pdev: struct platform_device * to reset
780 * @name: const char * name of the reset line
781 *
782 * Set the hardreset line identified by @name on the IP blocks
783 * associated with the hwmods backing the platform_device @pdev. All
784 * of the hwmods associated with @pdev must have the same hardreset
785 * line linked to them for this to work. Passes along the return value
786 * of omap_hwmod_assert_hardreset() in the event of any failure, or
787 * returns 0 upon success.
788 */
789int omap_device_assert_hardreset(struct platform_device *pdev, const char *name)
790{
791 struct omap_device *od = to_omap_device(pdev);
792 int ret = 0;
793 int i;
794
795 for (i = 0; i < od->hwmods_cnt; i++) {
796 ret = omap_hwmod_assert_hardreset(od->hwmods[i], name);
797 if (ret)
798 break;
799 }
800
801 return ret;
802}
803
804/**
805 * omap_device_deassert_hardreset - release a device's hardreset line
806 * @pdev: struct platform_device * to reset
807 * @name: const char * name of the reset line
808 *
809 * Release the hardreset line identified by @name on the IP blocks
810 * associated with the hwmods backing the platform_device @pdev. All
811 * of the hwmods associated with @pdev must have the same hardreset
812 * line linked to them for this to work. Passes along the return
813 * value of omap_hwmod_deassert_hardreset() in the event of any
814 * failure, or returns 0 upon success.
815 */
816int omap_device_deassert_hardreset(struct platform_device *pdev,
817 const char *name)
818{
819 struct omap_device *od = to_omap_device(pdev);
820 int ret = 0;
821 int i;
822
823 for (i = 0; i < od->hwmods_cnt; i++) {
824 ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name);
825 if (ret)
826 break;
827 }
828
829 return ret;
830}
831
832/**
Nishanth Menon1f8a7d52011-07-27 15:02:32 -0500833 * omap_device_get_by_hwmod_name() - convert a hwmod name to
834 * device pointer.
835 * @oh_name: name of the hwmod device
836 *
837 * Returns back a struct device * pointer associated with a hwmod
838 * device represented by a hwmod_name
839 */
840struct device *omap_device_get_by_hwmod_name(const char *oh_name)
841{
842 struct omap_hwmod *oh;
843
844 if (!oh_name) {
845 WARN(1, "%s: no hwmod name!\n", __func__);
846 return ERR_PTR(-EINVAL);
847 }
848
849 oh = omap_hwmod_lookup(oh_name);
Russell King857835c2013-02-24 10:56:59 +0000850 if (!oh) {
Nishanth Menon1f8a7d52011-07-27 15:02:32 -0500851 WARN(1, "%s: no hwmod for %s\n", __func__,
852 oh_name);
Russell King857835c2013-02-24 10:56:59 +0000853 return ERR_PTR(-ENODEV);
Nishanth Menon1f8a7d52011-07-27 15:02:32 -0500854 }
Russell King857835c2013-02-24 10:56:59 +0000855 if (!oh->od) {
Nishanth Menon1f8a7d52011-07-27 15:02:32 -0500856 WARN(1, "%s: no omap_device for %s\n", __func__,
857 oh_name);
Russell King857835c2013-02-24 10:56:59 +0000858 return ERR_PTR(-ENODEV);
Nishanth Menon1f8a7d52011-07-27 15:02:32 -0500859 }
860
Nishanth Menon1f8a7d52011-07-27 15:02:32 -0500861 return &oh->od->pdev->dev;
862}
Kevin Hilman0d5e8252010-08-23 08:10:55 -0700863
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200864static struct notifier_block platform_nb = {
865 .notifier_call = _omap_device_notifier_call,
866};
867
Kevin Hilman0d5e8252010-08-23 08:10:55 -0700868static int __init omap_device_init(void)
869{
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200870 bus_register_notifier(&platform_bus_type, &platform_nb);
Kevin Hilman3ec2dec2012-02-15 11:47:45 -0800871 return 0;
Kevin Hilman0d5e8252010-08-23 08:10:55 -0700872}
Tony Lindgren8dd5ea72015-12-03 11:38:09 -0800873omap_postcore_initcall(omap_device_init);
Kevin Hilman9634c8d2012-07-10 15:06:11 -0700874
875/**
876 * omap_device_late_idle - idle devices without drivers
877 * @dev: struct device * associated with omap_device
878 * @data: unused
879 *
880 * Check the driver bound status of this device, and idle it
881 * if there is no driver attached.
882 */
883static int __init omap_device_late_idle(struct device *dev, void *data)
884{
885 struct platform_device *pdev = to_platform_device(dev);
886 struct omap_device *od = to_omap_device(pdev);
Rajendra Nayakf66e3292013-07-28 23:01:50 -0600887 int i;
Kevin Hilman9634c8d2012-07-10 15:06:11 -0700888
889 if (!od)
890 return 0;
891
892 /*
893 * If omap_device state is enabled, but has no driver bound,
894 * idle it.
895 */
Rajendra Nayakf66e3292013-07-28 23:01:50 -0600896
897 /*
898 * Some devices (like memory controllers) are always kept
899 * enabled, and should not be idled even with no drivers.
900 */
901 for (i = 0; i < od->hwmods_cnt; i++)
902 if (od->hwmods[i]->flags & HWMOD_INIT_NO_IDLE)
903 return 0;
904
Grygorii Strashkofe8291e2015-09-01 13:59:24 -0700905 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER &&
906 od->_driver_status != BUS_NOTIFY_BIND_DRIVER) {
Kevin Hilman9634c8d2012-07-10 15:06:11 -0700907 if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
908 dev_warn(dev, "%s: enabled but no driver. Idling\n",
909 __func__);
910 omap_device_idle(pdev);
911 }
912 }
913
914 return 0;
915}
916
917static int __init omap_device_late_init(void)
918{
919 bus_for_each_dev(&platform_bus_type, NULL, NULL, omap_device_late_idle);
Tony Lindgren4b91f7f2014-10-27 13:05:54 -0700920
921 WARN(!of_have_populated_dt(),
922 "legacy booting deprecated, please update to boot with .dts\n");
923
Kevin Hilman9634c8d2012-07-10 15:06:11 -0700924 return 0;
925}
Kevin Hilmane7e17c52013-05-08 16:48:01 -0700926omap_late_initcall_sync(omap_device_late_init);