blob: 5b69742691074819a07b9f9eac29bab016906369 [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 *
20 * In the medium- to long-term, this code should either be
21 * a) implemented via arch-specific pointers in platform_data
22 * or
23 * b) implemented as a proper omap_bus/omap_device in Linux, no more
24 * platform_data func pointers
25 *
26 *
27 * Guidelines for usage by driver authors:
28 *
29 * 1. These functions are intended to be used by device drivers via
30 * function pointers in struct platform_data. As an example,
31 * omap_device_enable() should be passed to the driver as
32 *
33 * struct foo_driver_platform_data {
34 * ...
35 * int (*device_enable)(struct platform_device *pdev);
36 * ...
37 * }
38 *
39 * Note that the generic "device_enable" name is used, rather than
40 * "omap_device_enable". This is so other architectures can pass in their
41 * own enable/disable functions here.
42 *
43 * This should be populated during device setup:
44 *
45 * ...
46 * pdata->device_enable = omap_device_enable;
47 * ...
48 *
49 * 2. Drivers should first check to ensure the function pointer is not null
50 * before calling it, as in:
51 *
52 * if (pdata->device_enable)
53 * pdata->device_enable(pdev);
54 *
55 * This allows other architectures that don't use similar device_enable()/
56 * device_shutdown() functions to execute normally.
57 *
58 * ...
59 *
60 * Suggested usage by device drivers:
61 *
62 * During device initialization:
63 * device_enable()
64 *
65 * During device idle:
66 * (save remaining device context if necessary)
67 * device_idle();
68 *
69 * During device resume:
70 * device_enable();
71 * (restore context if necessary)
72 *
73 * During device shutdown:
74 * device_shutdown()
75 * (device must be reinitialized at this point to use it again)
76 *
77 */
78#undef DEBUG
79
80#include <linux/kernel.h>
Axel Lin55581412011-11-07 12:27:10 -080081#include <linux/export.h>
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030082#include <linux/platform_device.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090083#include <linux/slab.h>
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030084#include <linux/err.h>
85#include <linux/io.h>
Partha Basak4ef7aca2010-09-21 19:23:04 +020086#include <linux/clk.h>
Rajendra Nayakda0653f2011-02-25 15:40:21 -070087#include <linux/clkdev.h>
Kevin Hilman345f79b2011-05-31 16:08:09 -070088#include <linux/pm_runtime.h>
Benoit Coussondc2d07e2011-08-10 13:32:08 +020089#include <linux/of.h>
90#include <linux/notifier.h>
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030091
Tony Lindgrence491cf2009-10-20 09:40:47 -070092#include <plat/omap_device.h>
93#include <plat/omap_hwmod.h>
Rajendra Nayakda0653f2011-02-25 15:40:21 -070094#include <plat/clock.h>
Paul Walmsleyb04b65a2009-09-03 20:14:05 +030095
96/* These parameters are passed to _omap_device_{de,}activate() */
97#define USE_WAKEUP_LAT 0
98#define IGNORE_WAKEUP_LAT 1
99
Kevin Hilmanbfae4f82011-07-21 14:47:53 -0700100static int omap_early_device_register(struct platform_device *pdev);
Kevin Hilmana2a28ad2011-07-21 14:14:35 -0700101
Benoit Coussonb7b5bc92011-08-09 16:54:19 +0200102static struct omap_device_pm_latency omap_default_latency[] = {
103 {
104 .deactivate_func = omap_device_idle_hwmods,
105 .activate_func = omap_device_enable_hwmods,
106 .flags = OMAP_DEVICE_LATENCY_AUTO_ADJUST,
107 }
108};
109
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300110/* Private functions */
111
112/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300113 * _omap_device_activate - increase device readiness
114 * @od: struct omap_device *
115 * @ignore_lat: increase to latency target (0) or full readiness (1)?
116 *
117 * Increase readiness of omap_device @od (thus decreasing device
118 * wakeup latency, but consuming more power). If @ignore_lat is
119 * IGNORE_WAKEUP_LAT, make the omap_device fully active. Otherwise,
120 * if @ignore_lat is USE_WAKEUP_LAT, and the device's maximum wakeup
121 * latency is greater than the requested maximum wakeup latency, step
122 * backwards in the omap_device_pm_latency table to ensure the
123 * device's maximum wakeup latency is less than or equal to the
124 * requested maximum wakeup latency. Returns 0.
125 */
126static int _omap_device_activate(struct omap_device *od, u8 ignore_lat)
127{
Tony Lindgrenf0594292009-10-19 15:25:24 -0700128 struct timespec a, b, c;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300129
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700130 dev_dbg(&od->pdev->dev, "omap_device: activating\n");
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300131
132 while (od->pm_lat_level > 0) {
133 struct omap_device_pm_latency *odpl;
Tony Lindgrenf0594292009-10-19 15:25:24 -0700134 unsigned long long act_lat = 0;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300135
136 od->pm_lat_level--;
137
138 odpl = od->pm_lats + od->pm_lat_level;
139
140 if (!ignore_lat &&
141 (od->dev_wakeup_lat <= od->_dev_wakeup_lat_limit))
142 break;
143
Kevin Hilmand2292662009-12-08 16:34:23 -0700144 read_persistent_clock(&a);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300145
146 /* XXX check return code */
147 odpl->activate_func(od);
148
Kevin Hilmand2292662009-12-08 16:34:23 -0700149 read_persistent_clock(&b);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300150
Tony Lindgrenf0594292009-10-19 15:25:24 -0700151 c = timespec_sub(b, a);
Kevin Hilman0d93d8b2009-12-08 16:34:26 -0700152 act_lat = timespec_to_ns(&c);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300153
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700154 dev_dbg(&od->pdev->dev,
Paul Walmsley7852ec02012-07-26 00:54:26 -0600155 "omap_device: pm_lat %d: activate: elapsed time %llu nsec\n",
156 od->pm_lat_level, act_lat);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300157
Kevin Hilman9799aca2010-01-26 20:13:02 -0700158 if (act_lat > odpl->activate_lat) {
159 odpl->activate_lat_worst = act_lat;
160 if (odpl->flags & OMAP_DEVICE_LATENCY_AUTO_ADJUST) {
161 odpl->activate_lat = act_lat;
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700162 dev_dbg(&od->pdev->dev,
Paul Walmsley7852ec02012-07-26 00:54:26 -0600163 "new worst case activate latency %d: %llu\n",
Grazvydas Ignotas47c3e5d2011-07-25 16:18:24 +0300164 od->pm_lat_level, act_lat);
Kevin Hilman9799aca2010-01-26 20:13:02 -0700165 } else
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700166 dev_warn(&od->pdev->dev,
Paul Walmsley7852ec02012-07-26 00:54:26 -0600167 "activate latency %d higher than expected. (%llu > %d)\n",
Kevin Hilman49882c92011-07-21 09:58:36 -0700168 od->pm_lat_level, act_lat,
169 odpl->activate_lat);
Kevin Hilman9799aca2010-01-26 20:13:02 -0700170 }
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300171
172 od->dev_wakeup_lat -= odpl->activate_lat;
173 }
174
175 return 0;
176}
177
178/**
179 * _omap_device_deactivate - decrease device readiness
180 * @od: struct omap_device *
181 * @ignore_lat: decrease to latency target (0) or full inactivity (1)?
182 *
183 * Decrease readiness of omap_device @od (thus increasing device
184 * wakeup latency, but conserving power). If @ignore_lat is
185 * IGNORE_WAKEUP_LAT, make the omap_device fully inactive. Otherwise,
186 * if @ignore_lat is USE_WAKEUP_LAT, and the device's maximum wakeup
187 * latency is less than the requested maximum wakeup latency, step
188 * forwards in the omap_device_pm_latency table to ensure the device's
189 * maximum wakeup latency is less than or equal to the requested
190 * maximum wakeup latency. Returns 0.
191 */
192static int _omap_device_deactivate(struct omap_device *od, u8 ignore_lat)
193{
Tony Lindgrenf0594292009-10-19 15:25:24 -0700194 struct timespec a, b, c;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300195
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700196 dev_dbg(&od->pdev->dev, "omap_device: deactivating\n");
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300197
198 while (od->pm_lat_level < od->pm_lats_cnt) {
199 struct omap_device_pm_latency *odpl;
Tony Lindgrenf0594292009-10-19 15:25:24 -0700200 unsigned long long deact_lat = 0;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300201
202 odpl = od->pm_lats + od->pm_lat_level;
203
204 if (!ignore_lat &&
205 ((od->dev_wakeup_lat + odpl->activate_lat) >
206 od->_dev_wakeup_lat_limit))
207 break;
208
Kevin Hilmand2292662009-12-08 16:34:23 -0700209 read_persistent_clock(&a);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300210
211 /* XXX check return code */
212 odpl->deactivate_func(od);
213
Kevin Hilmand2292662009-12-08 16:34:23 -0700214 read_persistent_clock(&b);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300215
Tony Lindgrenf0594292009-10-19 15:25:24 -0700216 c = timespec_sub(b, a);
Kevin Hilman0d93d8b2009-12-08 16:34:26 -0700217 deact_lat = timespec_to_ns(&c);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300218
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700219 dev_dbg(&od->pdev->dev,
Paul Walmsley7852ec02012-07-26 00:54:26 -0600220 "omap_device: pm_lat %d: deactivate: elapsed time %llu nsec\n",
221 od->pm_lat_level, deact_lat);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300222
Kevin Hilman9799aca2010-01-26 20:13:02 -0700223 if (deact_lat > odpl->deactivate_lat) {
224 odpl->deactivate_lat_worst = deact_lat;
225 if (odpl->flags & OMAP_DEVICE_LATENCY_AUTO_ADJUST) {
226 odpl->deactivate_lat = deact_lat;
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700227 dev_dbg(&od->pdev->dev,
Paul Walmsley7852ec02012-07-26 00:54:26 -0600228 "new worst case deactivate latency %d: %llu\n",
Grazvydas Ignotas47c3e5d2011-07-25 16:18:24 +0300229 od->pm_lat_level, deact_lat);
Kevin Hilman9799aca2010-01-26 20:13:02 -0700230 } else
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700231 dev_warn(&od->pdev->dev,
Paul Walmsley7852ec02012-07-26 00:54:26 -0600232 "deactivate latency %d higher than expected. (%llu > %d)\n",
Kevin Hilman49882c92011-07-21 09:58:36 -0700233 od->pm_lat_level, deact_lat,
234 odpl->deactivate_lat);
Kevin Hilman9799aca2010-01-26 20:13:02 -0700235 }
236
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300237 od->dev_wakeup_lat += odpl->activate_lat;
238
239 od->pm_lat_level++;
240 }
241
242 return 0;
243}
244
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600245static void _add_clkdev(struct omap_device *od, const char *clk_alias,
246 const char *clk_name)
247{
248 struct clk *r;
249 struct clk_lookup *l;
250
251 if (!clk_alias || !clk_name)
252 return;
253
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700254 dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name);
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600255
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700256 r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias);
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600257 if (!IS_ERR(r)) {
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700258 dev_warn(&od->pdev->dev,
Kevin Hilman49882c92011-07-21 09:58:36 -0700259 "alias %s already exists\n", clk_alias);
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600260 clk_put(r);
261 return;
262 }
263
Rajendra Nayak6ea74cb2012-09-22 02:24:16 -0600264 r = clk_get(NULL, clk_name);
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600265 if (IS_ERR(r)) {
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700266 dev_err(&od->pdev->dev,
Rajendra Nayak6ea74cb2012-09-22 02:24:16 -0600267 "clk_get for %s failed\n", clk_name);
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600268 return;
269 }
270
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700271 l = clkdev_alloc(r, clk_alias, dev_name(&od->pdev->dev));
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600272 if (!l) {
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700273 dev_err(&od->pdev->dev,
Kevin Hilman49882c92011-07-21 09:58:36 -0700274 "clkdev_alloc for %s failed\n", clk_alias);
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600275 return;
276 }
277
278 clkdev_add(l);
279}
280
Partha Basak4ef7aca2010-09-21 19:23:04 +0200281/**
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600282 * _add_hwmod_clocks_clkdev - Add clkdev entry for hwmod optional clocks
283 * and main clock
Partha Basak4ef7aca2010-09-21 19:23:04 +0200284 * @od: struct omap_device *od
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600285 * @oh: struct omap_hwmod *oh
Partha Basak4ef7aca2010-09-21 19:23:04 +0200286 *
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600287 * For the main clock and every optional clock present per hwmod per
288 * omap_device, this function adds an entry in the clkdev table of the
289 * form <dev-id=dev_name, con-id=role> if it does not exist already.
Partha Basak4ef7aca2010-09-21 19:23:04 +0200290 *
291 * The function is called from inside omap_device_build_ss(), after
292 * omap_device_register.
293 *
294 * This allows drivers to get a pointer to its optional clocks based on its role
295 * by calling clk_get(<dev*>, <role>).
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600296 * In the case of the main clock, a "fck" alias is used.
Partha Basak4ef7aca2010-09-21 19:23:04 +0200297 *
298 * No return value.
299 */
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600300static void _add_hwmod_clocks_clkdev(struct omap_device *od,
301 struct omap_hwmod *oh)
Partha Basak4ef7aca2010-09-21 19:23:04 +0200302{
303 int i;
304
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600305 _add_clkdev(od, "fck", oh->main_clk);
Partha Basak4ef7aca2010-09-21 19:23:04 +0200306
Benoit Coussonbf1e0772011-07-10 05:54:12 -0600307 for (i = 0; i < oh->opt_clks_cnt; i++)
308 _add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk);
Partha Basak4ef7aca2010-09-21 19:23:04 +0200309}
310
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300311
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200312/**
313 * omap_device_build_from_dt - build an omap_device with multiple hwmods
314 * @pdev_name: name of the platform_device driver to use
315 * @pdev_id: this platform_device's connection ID
316 * @oh: ptr to the single omap_hwmod that backs this omap_device
317 * @pdata: platform_data ptr to associate with the platform_device
318 * @pdata_len: amount of memory pointed to by @pdata
319 * @pm_lats: pointer to a omap_device_pm_latency array for this device
320 * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
321 * @is_early_device: should the device be registered as an early device or not
322 *
323 * Function for building an omap_device already registered from device-tree
324 *
325 * Returns 0 or PTR_ERR() on error.
326 */
327static int omap_device_build_from_dt(struct platform_device *pdev)
328{
329 struct omap_hwmod **hwmods;
330 struct omap_device *od;
331 struct omap_hwmod *oh;
332 struct device_node *node = pdev->dev.of_node;
333 const char *oh_name;
334 int oh_cnt, i, ret = 0;
335
336 oh_cnt = of_property_count_strings(node, "ti,hwmods");
337 if (!oh_cnt || IS_ERR_VALUE(oh_cnt)) {
Benoit Cousson5dc06b72012-01-20 18:14:00 +0100338 dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n");
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200339 return -ENODEV;
340 }
341
342 hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
343 if (!hwmods) {
344 ret = -ENOMEM;
345 goto odbfd_exit;
346 }
347
348 for (i = 0; i < oh_cnt; i++) {
349 of_property_read_string_index(node, "ti,hwmods", i, &oh_name);
350 oh = omap_hwmod_lookup(oh_name);
351 if (!oh) {
352 dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n",
353 oh_name);
354 ret = -EINVAL;
355 goto odbfd_exit1;
356 }
357 hwmods[i] = oh;
358 }
359
360 od = omap_device_alloc(pdev, hwmods, oh_cnt, NULL, 0);
361 if (!od) {
362 dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n",
363 oh_name);
364 ret = PTR_ERR(od);
365 goto odbfd_exit1;
366 }
367
368 if (of_get_property(node, "ti,no_idle_on_suspend", NULL))
369 omap_device_disable_idle_on_suspend(pdev);
370
371 pdev->dev.pm_domain = &omap_device_pm_domain;
372
373odbfd_exit1:
374 kfree(hwmods);
375odbfd_exit:
376 return ret;
377}
378
379static int _omap_device_notifier_call(struct notifier_block *nb,
380 unsigned long event, void *dev)
381{
382 struct platform_device *pdev = to_platform_device(dev);
383
384 switch (event) {
385 case BUS_NOTIFY_ADD_DEVICE:
386 if (pdev->dev.of_node)
387 omap_device_build_from_dt(pdev);
388 break;
389
390 case BUS_NOTIFY_DEL_DEVICE:
391 if (pdev->archdata.od)
392 omap_device_delete(pdev->archdata.od);
393 break;
394 }
395
396 return NOTIFY_DONE;
397}
398
399
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300400/* Public functions for use by core code */
401
402/**
Kevin Hilmanc80705a2010-12-21 21:31:55 -0700403 * omap_device_get_context_loss_count - get lost context count
404 * @od: struct omap_device *
405 *
406 * Using the primary hwmod, query the context loss count for this
407 * device.
408 *
409 * Callers should consider context for this device lost any time this
410 * function returns a value different than the value the caller got
411 * the last time it called this function.
412 *
413 * If any hwmods exist for the omap_device assoiated with @pdev,
414 * return the context loss counter for that hwmod, otherwise return
415 * zero.
416 */
Tomi Valkeinenfc013872011-06-09 16:56:23 +0300417int omap_device_get_context_loss_count(struct platform_device *pdev)
Kevin Hilmanc80705a2010-12-21 21:31:55 -0700418{
419 struct omap_device *od;
420 u32 ret = 0;
421
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600422 od = to_omap_device(pdev);
Kevin Hilmanc80705a2010-12-21 21:31:55 -0700423
424 if (od->hwmods_cnt)
425 ret = omap_hwmod_get_context_loss_count(od->hwmods[0]);
426
427 return ret;
428}
429
430/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300431 * omap_device_count_resources - count number of struct resource entries needed
432 * @od: struct omap_device *
433 *
434 * Count the number of struct resource entries needed for this
435 * omap_device @od. Used by omap_device_build_ss() to determine how
436 * much memory to allocate before calling
437 * omap_device_fill_resources(). Returns the count.
438 */
Kevin Hilmana2a28ad2011-07-21 14:14:35 -0700439static int omap_device_count_resources(struct omap_device *od)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300440{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300441 int c = 0;
442 int i;
443
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -0600444 for (i = 0; i < od->hwmods_cnt; i++)
445 c += omap_hwmod_count_resources(od->hwmods[i]);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300446
Paul Walmsley7852ec02012-07-26 00:54:26 -0600447 pr_debug("omap_device: %s: counted %d total resources across %d hwmods\n",
448 od->pdev->name, c, od->hwmods_cnt);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300449
450 return c;
451}
452
453/**
454 * omap_device_fill_resources - fill in array of struct resource
455 * @od: struct omap_device *
456 * @res: pointer to an array of struct resource to be filled in
457 *
458 * Populate one or more empty struct resource pointed to by @res with
459 * the resource data for this omap_device @od. Used by
460 * omap_device_build_ss() after calling omap_device_count_resources().
461 * Ideally this function would not be needed at all. If omap_device
462 * replaces platform_device, then we can specify our own
463 * get_resource()/ get_irq()/etc functions that use the underlying
464 * omap_hwmod information. Or if platform_device is extended to use
465 * subarchitecture-specific function pointers, the various
466 * platform_device functions can simply call omap_device internal
467 * functions to get device resources. Hacking around the existing
468 * platform_device code wastes memory. Returns 0.
469 */
Kevin Hilmana2a28ad2011-07-21 14:14:35 -0700470static int omap_device_fill_resources(struct omap_device *od,
471 struct resource *res)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300472{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300473 int i, r;
474
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -0600475 for (i = 0; i < od->hwmods_cnt; i++) {
476 r = omap_hwmod_fill_resources(od->hwmods[i], res);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300477 res += r;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300478 }
479
480 return 0;
481}
482
483/**
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200484 * omap_device_alloc - allocate an omap_device
485 * @pdev: platform_device that will be included in this omap_device
486 * @oh: ptr to the single omap_hwmod that backs this omap_device
487 * @pdata: platform_data ptr to associate with the platform_device
488 * @pdata_len: amount of memory pointed to by @pdata
489 * @pm_lats: pointer to a omap_device_pm_latency array for this device
490 * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
491 *
492 * Convenience function for allocating an omap_device structure and filling
493 * hwmods, resources and pm_latency attributes.
494 *
495 * Returns an struct omap_device pointer or ERR_PTR() on error;
496 */
Ohad Ben-Cohen993e4fb2012-02-20 09:43:29 -0800497struct omap_device *omap_device_alloc(struct platform_device *pdev,
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200498 struct omap_hwmod **ohs, int oh_cnt,
499 struct omap_device_pm_latency *pm_lats,
500 int pm_lats_cnt)
501{
502 int ret = -ENOMEM;
503 struct omap_device *od;
504 struct resource *res = NULL;
505 int i, res_count;
506 struct omap_hwmod **hwmods;
507
508 od = kzalloc(sizeof(struct omap_device), GFP_KERNEL);
509 if (!od) {
510 ret = -ENOMEM;
511 goto oda_exit1;
512 }
513 od->hwmods_cnt = oh_cnt;
514
515 hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
516 if (!hwmods)
517 goto oda_exit2;
518
519 od->hwmods = hwmods;
520 od->pdev = pdev;
521
522 /*
523 * HACK: Ideally the resources from DT should match, and hwmod
524 * should just add the missing ones. Since the name is not
525 * properly populated by DT, stick to hwmod resources only.
526 */
527 if (pdev->num_resources && pdev->resource)
528 dev_warn(&pdev->dev, "%s(): resources already allocated %d\n",
529 __func__, pdev->num_resources);
530
531 res_count = omap_device_count_resources(od);
532 if (res_count > 0) {
533 dev_dbg(&pdev->dev, "%s(): resources allocated from hwmod %d\n",
534 __func__, res_count);
535 res = kzalloc(sizeof(struct resource) * res_count, GFP_KERNEL);
536 if (!res)
537 goto oda_exit3;
538
539 omap_device_fill_resources(od, res);
540
541 ret = platform_device_add_resources(pdev, res, res_count);
542 kfree(res);
543
544 if (ret)
545 goto oda_exit3;
546 }
547
548 if (!pm_lats) {
549 pm_lats = omap_default_latency;
550 pm_lats_cnt = ARRAY_SIZE(omap_default_latency);
551 }
552
553 od->pm_lats_cnt = pm_lats_cnt;
554 od->pm_lats = kmemdup(pm_lats,
555 sizeof(struct omap_device_pm_latency) * pm_lats_cnt,
556 GFP_KERNEL);
557 if (!od->pm_lats)
558 goto oda_exit3;
559
560 pdev->archdata.od = od;
561
562 for (i = 0; i < oh_cnt; i++) {
563 hwmods[i]->od = od;
564 _add_hwmod_clocks_clkdev(od, hwmods[i]);
565 }
566
567 return od;
568
569oda_exit3:
570 kfree(hwmods);
571oda_exit2:
572 kfree(od);
573oda_exit1:
574 dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret);
575
576 return ERR_PTR(ret);
577}
578
Ohad Ben-Cohen993e4fb2012-02-20 09:43:29 -0800579void omap_device_delete(struct omap_device *od)
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200580{
Benoit Coussondc2d07e2011-08-10 13:32:08 +0200581 if (!od)
582 return;
583
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200584 od->pdev->archdata.od = NULL;
585 kfree(od->pm_lats);
586 kfree(od->hwmods);
587 kfree(od);
588}
589
590/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300591 * omap_device_build - build and register an omap_device with one omap_hwmod
592 * @pdev_name: name of the platform_device driver to use
593 * @pdev_id: this platform_device's connection ID
594 * @oh: ptr to the single omap_hwmod that backs this omap_device
595 * @pdata: platform_data ptr to associate with the platform_device
596 * @pdata_len: amount of memory pointed to by @pdata
597 * @pm_lats: pointer to a omap_device_pm_latency array for this device
598 * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700599 * @is_early_device: should the device be registered as an early device or not
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300600 *
601 * Convenience function for building and registering a single
602 * omap_device record, which in turn builds and registers a
603 * platform_device record. See omap_device_build_ss() for more
604 * information. Returns ERR_PTR(-EINVAL) if @oh is NULL; otherwise,
605 * passes along the return value of omap_device_build_ss().
606 */
Kevin Hilman9cf793f2012-02-20 09:43:30 -0800607struct platform_device __init *omap_device_build(const char *pdev_name, int pdev_id,
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300608 struct omap_hwmod *oh, void *pdata,
609 int pdata_len,
610 struct omap_device_pm_latency *pm_lats,
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700611 int pm_lats_cnt, int is_early_device)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300612{
613 struct omap_hwmod *ohs[] = { oh };
614
615 if (!oh)
616 return ERR_PTR(-EINVAL);
617
618 return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata,
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700619 pdata_len, pm_lats, pm_lats_cnt,
620 is_early_device);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300621}
622
623/**
624 * omap_device_build_ss - build and register an omap_device with multiple hwmods
625 * @pdev_name: name of the platform_device driver to use
626 * @pdev_id: this platform_device's connection ID
627 * @oh: ptr to the single omap_hwmod that backs this omap_device
628 * @pdata: platform_data ptr to associate with the platform_device
629 * @pdata_len: amount of memory pointed to by @pdata
630 * @pm_lats: pointer to a omap_device_pm_latency array for this device
631 * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700632 * @is_early_device: should the device be registered as an early device or not
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300633 *
634 * Convenience function for building and registering an omap_device
635 * subsystem record. Subsystem records consist of multiple
636 * omap_hwmods. This function in turn builds and registers a
637 * platform_device record. Returns an ERR_PTR() on error, or passes
638 * along the return value of omap_device_register().
639 */
Kevin Hilman9cf793f2012-02-20 09:43:30 -0800640struct platform_device __init *omap_device_build_ss(const char *pdev_name, int pdev_id,
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300641 struct omap_hwmod **ohs, int oh_cnt,
642 void *pdata, int pdata_len,
643 struct omap_device_pm_latency *pm_lats,
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700644 int pm_lats_cnt, int is_early_device)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300645{
646 int ret = -ENOMEM;
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700647 struct platform_device *pdev;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300648 struct omap_device *od;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300649
650 if (!ohs || oh_cnt == 0 || !pdev_name)
651 return ERR_PTR(-EINVAL);
652
653 if (!pdata && pdata_len > 0)
654 return ERR_PTR(-EINVAL);
655
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700656 pdev = platform_device_alloc(pdev_name, pdev_id);
657 if (!pdev) {
658 ret = -ENOMEM;
659 goto odbs_exit;
660 }
661
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200662 /* Set the dev_name early to allow dev_xxx in omap_device_alloc */
663 if (pdev->id != -1)
664 dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
665 else
666 dev_set_name(&pdev->dev, "%s", pdev->name);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300667
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200668 od = omap_device_alloc(pdev, ohs, oh_cnt, pm_lats, pm_lats_cnt);
669 if (!od)
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700670 goto odbs_exit1;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300671
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700672 ret = platform_device_add_data(pdev, pdata, pdata_len);
Artem Bityutskiy49b368a2010-07-12 13:38:07 +0000673 if (ret)
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200674 goto odbs_exit2;
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700675
676 if (is_early_device)
677 ret = omap_early_device_register(pdev);
678 else
679 ret = omap_device_register(pdev);
680 if (ret)
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200681 goto odbs_exit2;
Kevin Hilman06563582010-07-26 16:34:30 -0600682
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700683 return pdev;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300684
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700685odbs_exit2:
Benoit Coussona4f6cdb2011-08-09 16:47:01 +0200686 omap_device_delete(od);
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700687odbs_exit1:
688 platform_device_put(pdev);
689odbs_exit:
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300690
691 pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret);
692
693 return ERR_PTR(ret);
694}
695
696/**
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700697 * omap_early_device_register - register an omap_device as an early platform
698 * device.
699 * @od: struct omap_device * to register
700 *
701 * Register the omap_device structure. This currently just calls
702 * platform_early_add_device() on the underlying platform_device.
703 * Returns 0 by default.
704 */
Kevin Hilman9cf793f2012-02-20 09:43:30 -0800705static int __init omap_early_device_register(struct platform_device *pdev)
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700706{
707 struct platform_device *devices[1];
708
Kevin Hilmanbfae4f82011-07-21 14:47:53 -0700709 devices[0] = pdev;
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700710 early_platform_add_devices(devices, 1);
711 return 0;
712}
713
Kevin Hilman256a5432011-07-12 22:48:03 +0200714#ifdef CONFIG_PM_RUNTIME
Kevin Hilman638080c2011-04-29 00:36:42 +0200715static int _od_runtime_suspend(struct device *dev)
716{
717 struct platform_device *pdev = to_platform_device(dev);
Kevin Hilman345f79b2011-05-31 16:08:09 -0700718 int ret;
Kevin Hilman638080c2011-04-29 00:36:42 +0200719
Kevin Hilman345f79b2011-05-31 16:08:09 -0700720 ret = pm_generic_runtime_suspend(dev);
721
722 if (!ret)
723 omap_device_idle(pdev);
724
725 return ret;
726}
727
728static int _od_runtime_idle(struct device *dev)
729{
730 return pm_generic_runtime_idle(dev);
Kevin Hilman638080c2011-04-29 00:36:42 +0200731}
732
733static int _od_runtime_resume(struct device *dev)
734{
735 struct platform_device *pdev = to_platform_device(dev);
736
Kevin Hilman345f79b2011-05-31 16:08:09 -0700737 omap_device_enable(pdev);
738
739 return pm_generic_runtime_resume(dev);
Kevin Hilman638080c2011-04-29 00:36:42 +0200740}
Kevin Hilman256a5432011-07-12 22:48:03 +0200741#endif
Kevin Hilman638080c2011-04-29 00:36:42 +0200742
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200743#ifdef CONFIG_SUSPEND
744static int _od_suspend_noirq(struct device *dev)
745{
746 struct platform_device *pdev = to_platform_device(dev);
747 struct omap_device *od = to_omap_device(pdev);
748 int ret;
749
750 ret = pm_generic_suspend_noirq(dev);
751
752 if (!ret && !pm_runtime_status_suspended(dev)) {
753 if (pm_generic_runtime_suspend(dev) == 0) {
Paul Walmsleyb7c39a32012-03-03 13:15:33 -0700754 if (!(od->flags & OMAP_DEVICE_NO_IDLE_ON_SUSPEND))
755 omap_device_idle(pdev);
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200756 od->flags |= OMAP_DEVICE_SUSPENDED;
757 }
758 }
759
760 return ret;
761}
762
763static int _od_resume_noirq(struct device *dev)
764{
765 struct platform_device *pdev = to_platform_device(dev);
766 struct omap_device *od = to_omap_device(pdev);
767
768 if ((od->flags & OMAP_DEVICE_SUSPENDED) &&
769 !pm_runtime_status_suspended(dev)) {
770 od->flags &= ~OMAP_DEVICE_SUSPENDED;
Paul Walmsleyb7c39a32012-03-03 13:15:33 -0700771 if (!(od->flags & OMAP_DEVICE_NO_IDLE_ON_SUSPEND))
772 omap_device_enable(pdev);
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200773 pm_generic_runtime_resume(dev);
774 }
775
776 return pm_generic_resume_noirq(dev);
777}
Kevin Hilman126caf12011-09-01 10:59:36 -0700778#else
779#define _od_suspend_noirq NULL
780#define _od_resume_noirq NULL
Kevin Hilmanc03f0072011-07-12 22:48:19 +0200781#endif
782
Kevin Hilman3ec2dec2012-02-15 11:47:45 -0800783struct dev_pm_domain omap_device_pm_domain = {
Kevin Hilman638080c2011-04-29 00:36:42 +0200784 .ops = {
Kevin Hilman256a5432011-07-12 22:48:03 +0200785 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume,
786 _od_runtime_idle)
Kevin Hilman638080c2011-04-29 00:36:42 +0200787 USE_PLATFORM_PM_SLEEP_OPS
Kevin Hilmanff353362011-08-25 15:31:14 +0200788 .suspend_noirq = _od_suspend_noirq,
789 .resume_noirq = _od_resume_noirq,
Kevin Hilman638080c2011-04-29 00:36:42 +0200790 }
791};
792
Thara Gopinathc23a97d2010-02-24 12:05:58 -0700793/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300794 * omap_device_register - register an omap_device with one omap_hwmod
795 * @od: struct omap_device * to register
796 *
797 * Register the omap_device structure. This currently just calls
798 * platform_device_register() on the underlying platform_device.
799 * Returns the return value of platform_device_register().
800 */
Ohad Ben-Cohen993e4fb2012-02-20 09:43:29 -0800801int omap_device_register(struct platform_device *pdev)
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300802{
Kevin Hilmanbfae4f82011-07-21 14:47:53 -0700803 pr_debug("omap_device: %s: registering\n", pdev->name);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300804
Kevin Hilmanbfae4f82011-07-21 14:47:53 -0700805 pdev->dev.pm_domain = &omap_device_pm_domain;
Kevin Hilmand66b3fe2011-07-21 13:58:51 -0700806 return platform_device_add(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300807}
808
809
810/* Public functions for use by device drivers through struct platform_data */
811
812/**
813 * omap_device_enable - fully activate an omap_device
814 * @od: struct omap_device * to activate
815 *
816 * Do whatever is necessary for the hwmods underlying omap_device @od
817 * to be accessible and ready to operate. This generally involves
818 * enabling clocks, setting SYSCONFIG registers; and in the future may
819 * involve remuxing pins. Device drivers should call this function
820 * (through platform_data function pointers) where they would normally
821 * enable clocks, etc. Returns -EINVAL if called when the omap_device
822 * is already enabled, or passes along the return value of
823 * _omap_device_activate().
824 */
825int omap_device_enable(struct platform_device *pdev)
826{
827 int ret;
828 struct omap_device *od;
829
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600830 od = to_omap_device(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300831
832 if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
Kevin Hilman49882c92011-07-21 09:58:36 -0700833 dev_warn(&pdev->dev,
834 "omap_device: %s() called from invalid state %d\n",
835 __func__, od->_state);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300836 return -EINVAL;
837 }
838
839 /* Enable everything if we're enabling this device from scratch */
840 if (od->_state == OMAP_DEVICE_STATE_UNKNOWN)
841 od->pm_lat_level = od->pm_lats_cnt;
842
843 ret = _omap_device_activate(od, IGNORE_WAKEUP_LAT);
844
845 od->dev_wakeup_lat = 0;
Kevin Hilman5f1b6ef2009-12-08 16:34:22 -0700846 od->_dev_wakeup_lat_limit = UINT_MAX;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300847 od->_state = OMAP_DEVICE_STATE_ENABLED;
848
849 return ret;
850}
851
852/**
853 * omap_device_idle - idle an omap_device
854 * @od: struct omap_device * to idle
855 *
856 * Idle omap_device @od by calling as many .deactivate_func() entries
857 * in the omap_device's pm_lats table as is possible without exceeding
858 * the device's maximum wakeup latency limit, pm_lat_limit. Device
859 * drivers should call this function (through platform_data function
860 * pointers) where they would normally disable clocks after operations
861 * complete, etc.. Returns -EINVAL if the omap_device is not
862 * currently enabled, or passes along the return value of
863 * _omap_device_deactivate().
864 */
865int omap_device_idle(struct platform_device *pdev)
866{
867 int ret;
868 struct omap_device *od;
869
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600870 od = to_omap_device(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300871
872 if (od->_state != OMAP_DEVICE_STATE_ENABLED) {
Kevin Hilman49882c92011-07-21 09:58:36 -0700873 dev_warn(&pdev->dev,
874 "omap_device: %s() called from invalid state %d\n",
875 __func__, od->_state);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300876 return -EINVAL;
877 }
878
879 ret = _omap_device_deactivate(od, USE_WAKEUP_LAT);
880
881 od->_state = OMAP_DEVICE_STATE_IDLE;
882
883 return ret;
884}
885
886/**
887 * omap_device_shutdown - shut down an omap_device
888 * @od: struct omap_device * to shut down
889 *
890 * Shut down omap_device @od by calling all .deactivate_func() entries
891 * in the omap_device's pm_lats table and then shutting down all of
892 * the underlying omap_hwmods. Used when a device is being "removed"
893 * or a device driver is being unloaded. Returns -EINVAL if the
894 * omap_device is not currently enabled or idle, or passes along the
895 * return value of _omap_device_deactivate().
896 */
897int omap_device_shutdown(struct platform_device *pdev)
898{
899 int ret, i;
900 struct omap_device *od;
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300901
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600902 od = to_omap_device(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300903
904 if (od->_state != OMAP_DEVICE_STATE_ENABLED &&
905 od->_state != OMAP_DEVICE_STATE_IDLE) {
Kevin Hilman49882c92011-07-21 09:58:36 -0700906 dev_warn(&pdev->dev,
907 "omap_device: %s() called from invalid state %d\n",
908 __func__, od->_state);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300909 return -EINVAL;
910 }
911
912 ret = _omap_device_deactivate(od, IGNORE_WAKEUP_LAT);
913
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -0600914 for (i = 0; i < od->hwmods_cnt; i++)
915 omap_hwmod_shutdown(od->hwmods[i]);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300916
917 od->_state = OMAP_DEVICE_STATE_SHUTDOWN;
918
919 return ret;
920}
921
922/**
Omar Ramirez Luna8bb9fde2012-09-23 17:28:18 -0600923 * omap_device_assert_hardreset - set a device's hardreset line
924 * @pdev: struct platform_device * to reset
925 * @name: const char * name of the reset line
926 *
927 * Set the hardreset line identified by @name on the IP blocks
928 * associated with the hwmods backing the platform_device @pdev. All
929 * of the hwmods associated with @pdev must have the same hardreset
930 * line linked to them for this to work. Passes along the return value
931 * of omap_hwmod_assert_hardreset() in the event of any failure, or
932 * returns 0 upon success.
933 */
934int omap_device_assert_hardreset(struct platform_device *pdev, const char *name)
935{
936 struct omap_device *od = to_omap_device(pdev);
937 int ret = 0;
938 int i;
939
940 for (i = 0; i < od->hwmods_cnt; i++) {
941 ret = omap_hwmod_assert_hardreset(od->hwmods[i], name);
942 if (ret)
943 break;
944 }
945
946 return ret;
947}
948
949/**
950 * omap_device_deassert_hardreset - release a device's hardreset line
951 * @pdev: struct platform_device * to reset
952 * @name: const char * name of the reset line
953 *
954 * Release the hardreset line identified by @name on the IP blocks
955 * associated with the hwmods backing the platform_device @pdev. All
956 * of the hwmods associated with @pdev must have the same hardreset
957 * line linked to them for this to work. Passes along the return
958 * value of omap_hwmod_deassert_hardreset() in the event of any
959 * failure, or returns 0 upon success.
960 */
961int omap_device_deassert_hardreset(struct platform_device *pdev,
962 const char *name)
963{
964 struct omap_device *od = to_omap_device(pdev);
965 int ret = 0;
966 int i;
967
968 for (i = 0; i < od->hwmods_cnt; i++) {
969 ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name);
970 if (ret)
971 break;
972 }
973
974 return ret;
975}
976
977/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +0300978 * omap_device_align_pm_lat - activate/deactivate device to match wakeup lat lim
979 * @od: struct omap_device *
980 *
981 * When a device's maximum wakeup latency limit changes, call some of
982 * the .activate_func or .deactivate_func function pointers in the
983 * omap_device's pm_lats array to ensure that the device's maximum
984 * wakeup latency is less than or equal to the new latency limit.
985 * Intended to be called by OMAP PM code whenever a device's maximum
986 * wakeup latency limit changes (e.g., via
987 * omap_pm_set_dev_wakeup_lat()). Returns 0 if nothing needs to be
988 * done (e.g., if the omap_device is not currently idle, or if the
989 * wakeup latency is already current with the new limit) or passes
990 * along the return value of _omap_device_deactivate() or
991 * _omap_device_activate().
992 */
993int omap_device_align_pm_lat(struct platform_device *pdev,
994 u32 new_wakeup_lat_limit)
995{
996 int ret = -EINVAL;
997 struct omap_device *od;
998
Kevin Hilman8f0d69d2011-07-09 19:15:20 -0600999 od = to_omap_device(pdev);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001000
1001 if (new_wakeup_lat_limit == od->dev_wakeup_lat)
1002 return 0;
1003
1004 od->_dev_wakeup_lat_limit = new_wakeup_lat_limit;
1005
1006 if (od->_state != OMAP_DEVICE_STATE_IDLE)
1007 return 0;
1008 else if (new_wakeup_lat_limit > od->dev_wakeup_lat)
1009 ret = _omap_device_deactivate(od, USE_WAKEUP_LAT);
1010 else if (new_wakeup_lat_limit < od->dev_wakeup_lat)
1011 ret = _omap_device_activate(od, USE_WAKEUP_LAT);
1012
1013 return ret;
1014}
1015
1016/**
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001017 * omap_device_get_pwrdm - return the powerdomain * associated with @od
1018 * @od: struct omap_device *
1019 *
1020 * Return the powerdomain associated with the first underlying
1021 * omap_hwmod for this omap_device. Intended for use by core OMAP PM
1022 * code. Returns NULL on error or a struct powerdomain * upon
1023 * success.
1024 */
1025struct powerdomain *omap_device_get_pwrdm(struct omap_device *od)
1026{
1027 /*
1028 * XXX Assumes that all omap_hwmod powerdomains are identical.
1029 * This may not necessarily be true. There should be a sanity
1030 * check in here to WARN() if any difference appears.
1031 */
1032 if (!od->hwmods_cnt)
1033 return NULL;
1034
1035 return omap_hwmod_get_pwrdm(od->hwmods[0]);
1036}
1037
Paul Walmsleydb2a60b2010-07-26 16:34:33 -06001038/**
1039 * omap_device_get_mpu_rt_va - return the MPU's virtual addr for the hwmod base
1040 * @od: struct omap_device *
1041 *
1042 * Return the MPU's virtual address for the base of the hwmod, from
1043 * the ioremap() that the hwmod code does. Only valid if there is one
1044 * hwmod associated with this device. Returns NULL if there are zero
1045 * or more than one hwmods associated with this omap_device;
1046 * otherwise, passes along the return value from
1047 * omap_hwmod_get_mpu_rt_va().
1048 */
1049void __iomem *omap_device_get_rt_va(struct omap_device *od)
1050{
1051 if (od->hwmods_cnt != 1)
1052 return NULL;
1053
1054 return omap_hwmod_get_mpu_rt_va(od->hwmods[0]);
1055}
1056
Nishanth Menon1f8a7d52011-07-27 15:02:32 -05001057/**
1058 * omap_device_get_by_hwmod_name() - convert a hwmod name to
1059 * device pointer.
1060 * @oh_name: name of the hwmod device
1061 *
1062 * Returns back a struct device * pointer associated with a hwmod
1063 * device represented by a hwmod_name
1064 */
1065struct device *omap_device_get_by_hwmod_name(const char *oh_name)
1066{
1067 struct omap_hwmod *oh;
1068
1069 if (!oh_name) {
1070 WARN(1, "%s: no hwmod name!\n", __func__);
1071 return ERR_PTR(-EINVAL);
1072 }
1073
1074 oh = omap_hwmod_lookup(oh_name);
1075 if (IS_ERR_OR_NULL(oh)) {
1076 WARN(1, "%s: no hwmod for %s\n", __func__,
1077 oh_name);
1078 return ERR_PTR(oh ? PTR_ERR(oh) : -ENODEV);
1079 }
1080 if (IS_ERR_OR_NULL(oh->od)) {
1081 WARN(1, "%s: no omap_device for %s\n", __func__,
1082 oh_name);
1083 return ERR_PTR(oh->od ? PTR_ERR(oh->od) : -ENODEV);
1084 }
1085
1086 if (IS_ERR_OR_NULL(oh->od->pdev))
1087 return ERR_PTR(oh->od->pdev ? PTR_ERR(oh->od->pdev) : -ENODEV);
1088
1089 return &oh->od->pdev->dev;
1090}
1091EXPORT_SYMBOL(omap_device_get_by_hwmod_name);
1092
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001093/*
1094 * Public functions intended for use in omap_device_pm_latency
1095 * .activate_func and .deactivate_func function pointers
1096 */
1097
1098/**
1099 * omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods
1100 * @od: struct omap_device *od
1101 *
1102 * Enable all underlying hwmods. Returns 0.
1103 */
1104int omap_device_enable_hwmods(struct omap_device *od)
1105{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001106 int i;
1107
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -06001108 for (i = 0; i < od->hwmods_cnt; i++)
1109 omap_hwmod_enable(od->hwmods[i]);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001110
1111 /* XXX pass along return value here? */
1112 return 0;
1113}
1114
1115/**
1116 * omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods
1117 * @od: struct omap_device *od
1118 *
1119 * Idle all underlying hwmods. Returns 0.
1120 */
1121int omap_device_idle_hwmods(struct omap_device *od)
1122{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001123 int i;
1124
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -06001125 for (i = 0; i < od->hwmods_cnt; i++)
1126 omap_hwmod_idle(od->hwmods[i]);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001127
1128 /* XXX pass along return value here? */
1129 return 0;
1130}
1131
1132/**
1133 * omap_device_disable_clocks - disable all main and interface clocks
1134 * @od: struct omap_device *od
1135 *
1136 * Disable the main functional clock and interface clock for all of the
1137 * omap_hwmods associated with the omap_device. Returns 0.
1138 */
1139int omap_device_disable_clocks(struct omap_device *od)
1140{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001141 int i;
1142
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -06001143 for (i = 0; i < od->hwmods_cnt; i++)
1144 omap_hwmod_disable_clocks(od->hwmods[i]);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001145
1146 /* XXX pass along return value here? */
1147 return 0;
1148}
1149
1150/**
1151 * omap_device_enable_clocks - enable all main and interface clocks
1152 * @od: struct omap_device *od
1153 *
1154 * Enable the main functional clock and interface clock for all of the
1155 * omap_hwmods associated with the omap_device. Returns 0.
1156 */
1157int omap_device_enable_clocks(struct omap_device *od)
1158{
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001159 int i;
1160
Kishon Vijay Abraham If39f4892010-09-24 10:23:18 -06001161 for (i = 0; i < od->hwmods_cnt; i++)
1162 omap_hwmod_enable_clocks(od->hwmods[i]);
Paul Walmsleyb04b65a2009-09-03 20:14:05 +03001163
1164 /* XXX pass along return value here? */
1165 return 0;
1166}
Kevin Hilman0d5e8252010-08-23 08:10:55 -07001167
Benoit Coussondc2d07e2011-08-10 13:32:08 +02001168static struct notifier_block platform_nb = {
1169 .notifier_call = _omap_device_notifier_call,
1170};
1171
Kevin Hilman0d5e8252010-08-23 08:10:55 -07001172static int __init omap_device_init(void)
1173{
Benoit Coussondc2d07e2011-08-10 13:32:08 +02001174 bus_register_notifier(&platform_bus_type, &platform_nb);
Kevin Hilman3ec2dec2012-02-15 11:47:45 -08001175 return 0;
Kevin Hilman0d5e8252010-08-23 08:10:55 -07001176}
1177core_initcall(omap_device_init);