]> git.karo-electronics.de Git - karo-tx-linux.git/blob - arch/arm/mach-omap2/clockdomain.c
Merge branch 'for-john' of git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211
[karo-tx-linux.git] / arch / arm / mach-omap2 / clockdomain.c
1 /*
2  * OMAP2/3/4 clockdomain framework functions
3  *
4  * Copyright (C) 2008-2011 Texas Instruments, Inc.
5  * Copyright (C) 2008-2011 Nokia Corporation
6  *
7  * Written by Paul Walmsley and Jouni Högander
8  * Added OMAP4 specific support by Abhijit Pagare <abhijitpagare@ti.com>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  */
14 #undef DEBUG
15
16 #include <linux/kernel.h>
17 #include <linux/device.h>
18 #include <linux/list.h>
19 #include <linux/errno.h>
20 #include <linux/string.h>
21 #include <linux/delay.h>
22 #include <linux/clk.h>
23 #include <linux/limits.h>
24 #include <linux/err.h>
25 #include <linux/clk-provider.h>
26
27 #include <linux/io.h>
28
29 #include <linux/bitops.h>
30
31 #include "soc.h"
32 #include "clock.h"
33 #include "clockdomain.h"
34
35 /* clkdm_list contains all registered struct clockdomains */
36 static LIST_HEAD(clkdm_list);
37
38 /* array of clockdomain deps to be added/removed when clkdm in hwsup mode */
39 static struct clkdm_autodep *autodeps;
40
41 static struct clkdm_ops *arch_clkdm;
42
43 /* Private functions */
44
45 static struct clockdomain *_clkdm_lookup(const char *name)
46 {
47         struct clockdomain *clkdm, *temp_clkdm;
48
49         if (!name)
50                 return NULL;
51
52         clkdm = NULL;
53
54         list_for_each_entry(temp_clkdm, &clkdm_list, node) {
55                 if (!strcmp(name, temp_clkdm->name)) {
56                         clkdm = temp_clkdm;
57                         break;
58                 }
59         }
60
61         return clkdm;
62 }
63
64 /**
65  * _clkdm_register - register a clockdomain
66  * @clkdm: struct clockdomain * to register
67  *
68  * Adds a clockdomain to the internal clockdomain list.
69  * Returns -EINVAL if given a null pointer, -EEXIST if a clockdomain is
70  * already registered by the provided name, or 0 upon success.
71  */
72 static int _clkdm_register(struct clockdomain *clkdm)
73 {
74         struct powerdomain *pwrdm;
75
76         if (!clkdm || !clkdm->name)
77                 return -EINVAL;
78
79         pwrdm = pwrdm_lookup(clkdm->pwrdm.name);
80         if (!pwrdm) {
81                 pr_err("clockdomain: %s: powerdomain %s does not exist\n",
82                         clkdm->name, clkdm->pwrdm.name);
83                 return -EINVAL;
84         }
85         clkdm->pwrdm.ptr = pwrdm;
86
87         /* Verify that the clockdomain is not already registered */
88         if (_clkdm_lookup(clkdm->name))
89                 return -EEXIST;
90
91         list_add(&clkdm->node, &clkdm_list);
92
93         pwrdm_add_clkdm(pwrdm, clkdm);
94
95         pr_debug("clockdomain: registered %s\n", clkdm->name);
96
97         return 0;
98 }
99
100 /* _clkdm_deps_lookup - look up the specified clockdomain in a clkdm list */
101 static struct clkdm_dep *_clkdm_deps_lookup(struct clockdomain *clkdm,
102                                             struct clkdm_dep *deps)
103 {
104         struct clkdm_dep *cd;
105
106         if (!clkdm || !deps)
107                 return ERR_PTR(-EINVAL);
108
109         for (cd = deps; cd->clkdm_name; cd++) {
110                 if (!cd->clkdm && cd->clkdm_name)
111                         cd->clkdm = _clkdm_lookup(cd->clkdm_name);
112
113                 if (cd->clkdm == clkdm)
114                         break;
115         }
116
117         if (!cd->clkdm_name)
118                 return ERR_PTR(-ENOENT);
119
120         return cd;
121 }
122
123 /**
124  * _autodep_lookup - resolve autodep clkdm names to clkdm pointers; store
125  * @autodep: struct clkdm_autodep * to resolve
126  *
127  * Resolve autodep clockdomain names to clockdomain pointers via
128  * clkdm_lookup() and store the pointers in the autodep structure.  An
129  * "autodep" is a clockdomain sleep/wakeup dependency that is
130  * automatically added and removed whenever clocks in the associated
131  * clockdomain are enabled or disabled (respectively) when the
132  * clockdomain is in hardware-supervised mode.  Meant to be called
133  * once at clockdomain layer initialization, since these should remain
134  * fixed for a particular architecture.  No return value.
135  *
136  * XXX autodeps are deprecated and should be removed at the earliest
137  * opportunity
138  */
139 static void _autodep_lookup(struct clkdm_autodep *autodep)
140 {
141         struct clockdomain *clkdm;
142
143         if (!autodep)
144                 return;
145
146         clkdm = clkdm_lookup(autodep->clkdm.name);
147         if (!clkdm) {
148                 pr_err("clockdomain: autodeps: clockdomain %s does not exist\n",
149                          autodep->clkdm.name);
150                 clkdm = ERR_PTR(-ENOENT);
151         }
152         autodep->clkdm.ptr = clkdm;
153 }
154
155 /**
156  * _resolve_clkdm_deps() - resolve clkdm_names in @clkdm_deps to clkdms
157  * @clkdm: clockdomain that we are resolving dependencies for
158  * @clkdm_deps: ptr to array of struct clkdm_deps to resolve
159  *
160  * Iterates through @clkdm_deps, looking up the struct clockdomain named by
161  * clkdm_name and storing the clockdomain pointer in the struct clkdm_dep.
162  * No return value.
163  */
164 static void _resolve_clkdm_deps(struct clockdomain *clkdm,
165                                 struct clkdm_dep *clkdm_deps)
166 {
167         struct clkdm_dep *cd;
168
169         for (cd = clkdm_deps; cd && cd->clkdm_name; cd++) {
170                 if (cd->clkdm)
171                         continue;
172                 cd->clkdm = _clkdm_lookup(cd->clkdm_name);
173
174                 WARN(!cd->clkdm, "clockdomain: %s: could not find clkdm %s while resolving dependencies - should never happen",
175                      clkdm->name, cd->clkdm_name);
176         }
177 }
178
179 /**
180  * _clkdm_add_wkdep - add a wakeup dependency from clkdm2 to clkdm1 (lockless)
181  * @clkdm1: wake this struct clockdomain * up (dependent)
182  * @clkdm2: when this struct clockdomain * wakes up (source)
183  *
184  * When the clockdomain represented by @clkdm2 wakes up, wake up
185  * @clkdm1. Implemented in hardware on the OMAP, this feature is
186  * designed to reduce wakeup latency of the dependent clockdomain @clkdm1.
187  * Returns -EINVAL if presented with invalid clockdomain pointers,
188  * -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or 0 upon
189  * success.
190  */
191 static int _clkdm_add_wkdep(struct clockdomain *clkdm1,
192                             struct clockdomain *clkdm2)
193 {
194         struct clkdm_dep *cd;
195         int ret = 0;
196
197         if (!clkdm1 || !clkdm2)
198                 return -EINVAL;
199
200         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
201         if (IS_ERR(cd))
202                 ret = PTR_ERR(cd);
203
204         if (!arch_clkdm || !arch_clkdm->clkdm_add_wkdep)
205                 ret = -EINVAL;
206
207         if (ret) {
208                 pr_debug("clockdomain: hardware cannot set/clear wake up of %s when %s wakes up\n",
209                          clkdm1->name, clkdm2->name);
210                 return ret;
211         }
212
213         cd->wkdep_usecount++;
214         if (cd->wkdep_usecount == 1) {
215                 pr_debug("clockdomain: hardware will wake up %s when %s wakes up\n",
216                          clkdm1->name, clkdm2->name);
217
218                 ret = arch_clkdm->clkdm_add_wkdep(clkdm1, clkdm2);
219         }
220
221         return ret;
222 }
223
224 /**
225  * _clkdm_del_wkdep - remove a wakeup dep from clkdm2 to clkdm1 (lockless)
226  * @clkdm1: wake this struct clockdomain * up (dependent)
227  * @clkdm2: when this struct clockdomain * wakes up (source)
228  *
229  * Remove a wakeup dependency causing @clkdm1 to wake up when @clkdm2
230  * wakes up.  Returns -EINVAL if presented with invalid clockdomain
231  * pointers, -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or
232  * 0 upon success.
233  */
234 static int _clkdm_del_wkdep(struct clockdomain *clkdm1,
235                             struct clockdomain *clkdm2)
236 {
237         struct clkdm_dep *cd;
238         int ret = 0;
239
240         if (!clkdm1 || !clkdm2)
241                 return -EINVAL;
242
243         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
244         if (IS_ERR(cd))
245                 ret = PTR_ERR(cd);
246
247         if (!arch_clkdm || !arch_clkdm->clkdm_del_wkdep)
248                 ret = -EINVAL;
249
250         if (ret) {
251                 pr_debug("clockdomain: hardware cannot set/clear wake up of %s when %s wakes up\n",
252                          clkdm1->name, clkdm2->name);
253                 return ret;
254         }
255
256         cd->wkdep_usecount--;
257         if (cd->wkdep_usecount == 0) {
258                 pr_debug("clockdomain: hardware will no longer wake up %s after %s wakes up\n",
259                          clkdm1->name, clkdm2->name);
260
261                 ret = arch_clkdm->clkdm_del_wkdep(clkdm1, clkdm2);
262         }
263
264         return ret;
265 }
266
267 /**
268  * _clkdm_add_sleepdep - add a sleep dependency from clkdm2 to clkdm1 (lockless)
269  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
270  * @clkdm2: when this struct clockdomain * is active (source)
271  *
272  * Prevent @clkdm1 from automatically going inactive (and then to
273  * retention or off) if @clkdm2 is active.  Returns -EINVAL if
274  * presented with invalid clockdomain pointers or called on a machine
275  * that does not support software-configurable hardware sleep
276  * dependencies, -ENOENT if the specified dependency cannot be set in
277  * hardware, or 0 upon success.
278  */
279 static int _clkdm_add_sleepdep(struct clockdomain *clkdm1,
280                                struct clockdomain *clkdm2)
281 {
282         struct clkdm_dep *cd;
283         int ret = 0;
284
285         if (!clkdm1 || !clkdm2)
286                 return -EINVAL;
287
288         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
289         if (IS_ERR(cd))
290                 ret = PTR_ERR(cd);
291
292         if (!arch_clkdm || !arch_clkdm->clkdm_add_sleepdep)
293                 ret = -EINVAL;
294
295         if (ret) {
296                 pr_debug("clockdomain: hardware cannot set/clear sleep dependency affecting %s from %s\n",
297                          clkdm1->name, clkdm2->name);
298                 return ret;
299         }
300
301         cd->sleepdep_usecount++;
302         if (cd->sleepdep_usecount == 1) {
303                 pr_debug("clockdomain: will prevent %s from sleeping if %s is active\n",
304                          clkdm1->name, clkdm2->name);
305
306                 ret = arch_clkdm->clkdm_add_sleepdep(clkdm1, clkdm2);
307         }
308
309         return ret;
310 }
311
312 /**
313  * _clkdm_del_sleepdep - remove a sleep dep from clkdm2 to clkdm1 (lockless)
314  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
315  * @clkdm2: when this struct clockdomain * is active (source)
316  *
317  * Allow @clkdm1 to automatically go inactive (and then to retention or
318  * off), independent of the activity state of @clkdm2.  Returns -EINVAL
319  * if presented with invalid clockdomain pointers or called on a machine
320  * that does not support software-configurable hardware sleep dependencies,
321  * -ENOENT if the specified dependency cannot be cleared in hardware, or
322  * 0 upon success.
323  */
324 static int _clkdm_del_sleepdep(struct clockdomain *clkdm1,
325                                struct clockdomain *clkdm2)
326 {
327         struct clkdm_dep *cd;
328         int ret = 0;
329
330         if (!clkdm1 || !clkdm2)
331                 return -EINVAL;
332
333         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
334         if (IS_ERR(cd))
335                 ret = PTR_ERR(cd);
336
337         if (!arch_clkdm || !arch_clkdm->clkdm_del_sleepdep)
338                 ret = -EINVAL;
339
340         if (ret) {
341                 pr_debug("clockdomain: hardware cannot set/clear sleep dependency affecting %s from %s\n",
342                          clkdm1->name, clkdm2->name);
343                 return ret;
344         }
345
346         cd->sleepdep_usecount--;
347         if (cd->sleepdep_usecount == 0) {
348                 pr_debug("clockdomain: will no longer prevent %s from sleeping if %s is active\n",
349                          clkdm1->name, clkdm2->name);
350
351                 ret = arch_clkdm->clkdm_del_sleepdep(clkdm1, clkdm2);
352         }
353
354         return ret;
355 }
356
357 /* Public functions */
358
359 /**
360  * clkdm_register_platform_funcs - register clockdomain implementation fns
361  * @co: func pointers for arch specific implementations
362  *
363  * Register the list of function pointers used to implement the
364  * clockdomain functions on different OMAP SoCs.  Should be called
365  * before any other clkdm_register*() function.  Returns -EINVAL if
366  * @co is null, -EEXIST if platform functions have already been
367  * registered, or 0 upon success.
368  */
369 int clkdm_register_platform_funcs(struct clkdm_ops *co)
370 {
371         if (!co)
372                 return -EINVAL;
373
374         if (arch_clkdm)
375                 return -EEXIST;
376
377         arch_clkdm = co;
378
379         return 0;
380 };
381
382 /**
383  * clkdm_register_clkdms - register SoC clockdomains
384  * @cs: pointer to an array of struct clockdomain to register
385  *
386  * Register the clockdomains available on a particular OMAP SoC.  Must
387  * be called after clkdm_register_platform_funcs().  May be called
388  * multiple times.  Returns -EACCES if called before
389  * clkdm_register_platform_funcs(); -EINVAL if the argument @cs is
390  * null; or 0 upon success.
391  */
392 int clkdm_register_clkdms(struct clockdomain **cs)
393 {
394         struct clockdomain **c = NULL;
395
396         if (!arch_clkdm)
397                 return -EACCES;
398
399         if (!cs)
400                 return -EINVAL;
401
402         for (c = cs; *c; c++)
403                 _clkdm_register(*c);
404
405         return 0;
406 }
407
408 /**
409  * clkdm_register_autodeps - register autodeps (if required)
410  * @ia: pointer to a static array of struct clkdm_autodep to register
411  *
412  * Register clockdomain "automatic dependencies."  These are
413  * clockdomain wakeup and sleep dependencies that are automatically
414  * added whenever the first clock inside a clockdomain is enabled, and
415  * removed whenever the last clock inside a clockdomain is disabled.
416  * These are currently only used on OMAP3 devices, and are deprecated,
417  * since they waste energy.  However, until the OMAP2/3 IP block
418  * enable/disable sequence can be converted to match the OMAP4
419  * sequence, they are needed.
420  *
421  * Must be called only after all of the SoC clockdomains are
422  * registered, since the function will resolve autodep clockdomain
423  * names into clockdomain pointers.
424  *
425  * The struct clkdm_autodep @ia array must be static, as this function
426  * does not copy the array elements.
427  *
428  * Returns -EACCES if called before any clockdomains have been
429  * registered, -EINVAL if called with a null @ia argument, -EEXIST if
430  * autodeps have already been registered, or 0 upon success.
431  */
432 int clkdm_register_autodeps(struct clkdm_autodep *ia)
433 {
434         struct clkdm_autodep *a = NULL;
435
436         if (list_empty(&clkdm_list))
437                 return -EACCES;
438
439         if (!ia)
440                 return -EINVAL;
441
442         if (autodeps)
443                 return -EEXIST;
444
445         autodeps = ia;
446         for (a = autodeps; a->clkdm.ptr; a++)
447                 _autodep_lookup(a);
448
449         return 0;
450 }
451
452 /**
453  * clkdm_complete_init - set up the clockdomain layer
454  *
455  * Put all clockdomains into software-supervised mode; PM code should
456  * later enable hardware-supervised mode as appropriate.  Must be
457  * called after clkdm_register_clkdms().  Returns -EACCES if called
458  * before clkdm_register_clkdms(), or 0 upon success.
459  */
460 int clkdm_complete_init(void)
461 {
462         struct clockdomain *clkdm;
463
464         if (list_empty(&clkdm_list))
465                 return -EACCES;
466
467         list_for_each_entry(clkdm, &clkdm_list, node) {
468                 if (clkdm->flags & CLKDM_CAN_FORCE_WAKEUP)
469                         clkdm_wakeup(clkdm);
470                 else if (clkdm->flags & CLKDM_CAN_DISABLE_AUTO)
471                         clkdm_deny_idle(clkdm);
472
473                 _resolve_clkdm_deps(clkdm, clkdm->wkdep_srcs);
474                 clkdm_clear_all_wkdeps(clkdm);
475
476                 _resolve_clkdm_deps(clkdm, clkdm->sleepdep_srcs);
477                 clkdm_clear_all_sleepdeps(clkdm);
478         }
479
480         return 0;
481 }
482
483 /**
484  * clkdm_lookup - look up a clockdomain by name, return a pointer
485  * @name: name of clockdomain
486  *
487  * Find a registered clockdomain by its name @name.  Returns a pointer
488  * to the struct clockdomain if found, or NULL otherwise.
489  */
490 struct clockdomain *clkdm_lookup(const char *name)
491 {
492         struct clockdomain *clkdm, *temp_clkdm;
493
494         if (!name)
495                 return NULL;
496
497         clkdm = NULL;
498
499         list_for_each_entry(temp_clkdm, &clkdm_list, node) {
500                 if (!strcmp(name, temp_clkdm->name)) {
501                         clkdm = temp_clkdm;
502                         break;
503                 }
504         }
505
506         return clkdm;
507 }
508
509 /**
510  * clkdm_for_each - call function on each registered clockdomain
511  * @fn: callback function *
512  *
513  * Call the supplied function @fn for each registered clockdomain.
514  * The callback function @fn can return anything but 0 to bail
515  * out early from the iterator.  The callback function is called with
516  * the clkdm_mutex held, so no clockdomain structure manipulation
517  * functions should be called from the callback, although hardware
518  * clockdomain control functions are fine.  Returns the last return
519  * value of the callback function, which should be 0 for success or
520  * anything else to indicate failure; or -EINVAL if the function pointer
521  * is null.
522  */
523 int clkdm_for_each(int (*fn)(struct clockdomain *clkdm, void *user),
524                         void *user)
525 {
526         struct clockdomain *clkdm;
527         int ret = 0;
528
529         if (!fn)
530                 return -EINVAL;
531
532         list_for_each_entry(clkdm, &clkdm_list, node) {
533                 ret = (*fn)(clkdm, user);
534                 if (ret)
535                         break;
536         }
537
538         return ret;
539 }
540
541
542 /**
543  * clkdm_get_pwrdm - return a ptr to the pwrdm that this clkdm resides in
544  * @clkdm: struct clockdomain *
545  *
546  * Return a pointer to the struct powerdomain that the specified clockdomain
547  * @clkdm exists in, or returns NULL if @clkdm is NULL.
548  */
549 struct powerdomain *clkdm_get_pwrdm(struct clockdomain *clkdm)
550 {
551         if (!clkdm)
552                 return NULL;
553
554         return clkdm->pwrdm.ptr;
555 }
556
557
558 /* Hardware clockdomain control */
559
560 /**
561  * clkdm_add_wkdep - add a wakeup dependency from clkdm2 to clkdm1
562  * @clkdm1: wake this struct clockdomain * up (dependent)
563  * @clkdm2: when this struct clockdomain * wakes up (source)
564  *
565  * When the clockdomain represented by @clkdm2 wakes up, wake up
566  * @clkdm1. Implemented in hardware on the OMAP, this feature is
567  * designed to reduce wakeup latency of the dependent clockdomain @clkdm1.
568  * Returns -EINVAL if presented with invalid clockdomain pointers,
569  * -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or 0 upon
570  * success.
571  */
572 int clkdm_add_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
573 {
574         struct clkdm_dep *cd;
575         int ret;
576
577         if (!clkdm1 || !clkdm2)
578                 return -EINVAL;
579
580         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
581         if (IS_ERR(cd))
582                 return PTR_ERR(cd);
583
584         pwrdm_lock(cd->clkdm->pwrdm.ptr);
585         ret = _clkdm_add_wkdep(clkdm1, clkdm2);
586         pwrdm_unlock(cd->clkdm->pwrdm.ptr);
587
588         return ret;
589 }
590
591 /**
592  * clkdm_del_wkdep - remove a wakeup dependency from clkdm2 to clkdm1
593  * @clkdm1: wake this struct clockdomain * up (dependent)
594  * @clkdm2: when this struct clockdomain * wakes up (source)
595  *
596  * Remove a wakeup dependency causing @clkdm1 to wake up when @clkdm2
597  * wakes up.  Returns -EINVAL if presented with invalid clockdomain
598  * pointers, -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or
599  * 0 upon success.
600  */
601 int clkdm_del_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
602 {
603         struct clkdm_dep *cd;
604         int ret;
605
606         if (!clkdm1 || !clkdm2)
607                 return -EINVAL;
608
609         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
610         if (IS_ERR(cd))
611                 return PTR_ERR(cd);
612
613         pwrdm_lock(cd->clkdm->pwrdm.ptr);
614         ret = _clkdm_del_wkdep(clkdm1, clkdm2);
615         pwrdm_unlock(cd->clkdm->pwrdm.ptr);
616
617         return ret;
618 }
619
620 /**
621  * clkdm_read_wkdep - read wakeup dependency state from clkdm2 to clkdm1
622  * @clkdm1: wake this struct clockdomain * up (dependent)
623  * @clkdm2: when this struct clockdomain * wakes up (source)
624  *
625  * Return 1 if a hardware wakeup dependency exists wherein @clkdm1 will be
626  * awoken when @clkdm2 wakes up; 0 if dependency is not set; -EINVAL
627  * if either clockdomain pointer is invalid; or -ENOENT if the hardware
628  * is incapable.
629  *
630  * REVISIT: Currently this function only represents software-controllable
631  * wakeup dependencies.  Wakeup dependencies fixed in hardware are not
632  * yet handled here.
633  */
634 int clkdm_read_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
635 {
636         struct clkdm_dep *cd;
637         int ret = 0;
638
639         if (!clkdm1 || !clkdm2)
640                 return -EINVAL;
641
642         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
643         if (IS_ERR(cd))
644                 ret = PTR_ERR(cd);
645
646         if (!arch_clkdm || !arch_clkdm->clkdm_read_wkdep)
647                 ret = -EINVAL;
648
649         if (ret) {
650                 pr_debug("clockdomain: hardware cannot set/clear wake up of %s when %s wakes up\n",
651                          clkdm1->name, clkdm2->name);
652                 return ret;
653         }
654
655         /* XXX It's faster to return the wkdep_usecount */
656         return arch_clkdm->clkdm_read_wkdep(clkdm1, clkdm2);
657 }
658
659 /**
660  * clkdm_clear_all_wkdeps - remove all wakeup dependencies from target clkdm
661  * @clkdm: struct clockdomain * to remove all wakeup dependencies from
662  *
663  * Remove all inter-clockdomain wakeup dependencies that could cause
664  * @clkdm to wake.  Intended to be used during boot to initialize the
665  * PRCM to a known state, after all clockdomains are put into swsup idle
666  * and woken up.  Returns -EINVAL if @clkdm pointer is invalid, or
667  * 0 upon success.
668  */
669 int clkdm_clear_all_wkdeps(struct clockdomain *clkdm)
670 {
671         if (!clkdm)
672                 return -EINVAL;
673
674         if (!arch_clkdm || !arch_clkdm->clkdm_clear_all_wkdeps)
675                 return -EINVAL;
676
677         return arch_clkdm->clkdm_clear_all_wkdeps(clkdm);
678 }
679
680 /**
681  * clkdm_add_sleepdep - add a sleep dependency from clkdm2 to clkdm1
682  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
683  * @clkdm2: when this struct clockdomain * is active (source)
684  *
685  * Prevent @clkdm1 from automatically going inactive (and then to
686  * retention or off) if @clkdm2 is active.  Returns -EINVAL if
687  * presented with invalid clockdomain pointers or called on a machine
688  * that does not support software-configurable hardware sleep
689  * dependencies, -ENOENT if the specified dependency cannot be set in
690  * hardware, or 0 upon success.
691  */
692 int clkdm_add_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
693 {
694         struct clkdm_dep *cd;
695         int ret;
696
697         if (!clkdm1 || !clkdm2)
698                 return -EINVAL;
699
700         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
701         if (IS_ERR(cd))
702                 return PTR_ERR(cd);
703
704         pwrdm_lock(cd->clkdm->pwrdm.ptr);
705         ret = _clkdm_add_sleepdep(clkdm1, clkdm2);
706         pwrdm_unlock(cd->clkdm->pwrdm.ptr);
707
708         return ret;
709 }
710
711 /**
712  * clkdm_del_sleepdep - remove a sleep dependency from clkdm2 to clkdm1
713  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
714  * @clkdm2: when this struct clockdomain * is active (source)
715  *
716  * Allow @clkdm1 to automatically go inactive (and then to retention or
717  * off), independent of the activity state of @clkdm2.  Returns -EINVAL
718  * if presented with invalid clockdomain pointers or called on a machine
719  * that does not support software-configurable hardware sleep dependencies,
720  * -ENOENT if the specified dependency cannot be cleared in hardware, or
721  * 0 upon success.
722  */
723 int clkdm_del_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
724 {
725         struct clkdm_dep *cd;
726         int ret;
727
728         if (!clkdm1 || !clkdm2)
729                 return -EINVAL;
730
731         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
732         if (IS_ERR(cd))
733                 return PTR_ERR(cd);
734
735         pwrdm_lock(cd->clkdm->pwrdm.ptr);
736         ret = _clkdm_del_sleepdep(clkdm1, clkdm2);
737         pwrdm_unlock(cd->clkdm->pwrdm.ptr);
738
739         return ret;
740 }
741
742 /**
743  * clkdm_read_sleepdep - read sleep dependency state from clkdm2 to clkdm1
744  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
745  * @clkdm2: when this struct clockdomain * is active (source)
746  *
747  * Return 1 if a hardware sleep dependency exists wherein @clkdm1 will
748  * not be allowed to automatically go inactive if @clkdm2 is active;
749  * 0 if @clkdm1's automatic power state inactivity transition is independent
750  * of @clkdm2's; -EINVAL if either clockdomain pointer is invalid or called
751  * on a machine that does not support software-configurable hardware sleep
752  * dependencies; or -ENOENT if the hardware is incapable.
753  *
754  * REVISIT: Currently this function only represents software-controllable
755  * sleep dependencies.  Sleep dependencies fixed in hardware are not
756  * yet handled here.
757  */
758 int clkdm_read_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
759 {
760         struct clkdm_dep *cd;
761         int ret = 0;
762
763         if (!clkdm1 || !clkdm2)
764                 return -EINVAL;
765
766         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
767         if (IS_ERR(cd))
768                 ret = PTR_ERR(cd);
769
770         if (!arch_clkdm || !arch_clkdm->clkdm_read_sleepdep)
771                 ret = -EINVAL;
772
773         if (ret) {
774                 pr_debug("clockdomain: hardware cannot set/clear sleep dependency affecting %s from %s\n",
775                          clkdm1->name, clkdm2->name);
776                 return ret;
777         }
778
779         /* XXX It's faster to return the sleepdep_usecount */
780         return arch_clkdm->clkdm_read_sleepdep(clkdm1, clkdm2);
781 }
782
783 /**
784  * clkdm_clear_all_sleepdeps - remove all sleep dependencies from target clkdm
785  * @clkdm: struct clockdomain * to remove all sleep dependencies from
786  *
787  * Remove all inter-clockdomain sleep dependencies that could prevent
788  * @clkdm from idling.  Intended to be used during boot to initialize the
789  * PRCM to a known state, after all clockdomains are put into swsup idle
790  * and woken up.  Returns -EINVAL if @clkdm pointer is invalid, or
791  * 0 upon success.
792  */
793 int clkdm_clear_all_sleepdeps(struct clockdomain *clkdm)
794 {
795         if (!clkdm)
796                 return -EINVAL;
797
798         if (!arch_clkdm || !arch_clkdm->clkdm_clear_all_sleepdeps)
799                 return -EINVAL;
800
801         return arch_clkdm->clkdm_clear_all_sleepdeps(clkdm);
802 }
803
804 /**
805  * clkdm_sleep_nolock - force clockdomain sleep transition (lockless)
806  * @clkdm: struct clockdomain *
807  *
808  * Instruct the CM to force a sleep transition on the specified
809  * clockdomain @clkdm.  Only for use by the powerdomain code.  Returns
810  * -EINVAL if @clkdm is NULL or if clockdomain does not support
811  * software-initiated sleep; 0 upon success.
812  */
813 int clkdm_sleep_nolock(struct clockdomain *clkdm)
814 {
815         int ret;
816
817         if (!clkdm)
818                 return -EINVAL;
819
820         if (!(clkdm->flags & CLKDM_CAN_FORCE_SLEEP)) {
821                 pr_debug("clockdomain: %s does not support forcing sleep via software\n",
822                          clkdm->name);
823                 return -EINVAL;
824         }
825
826         if (!arch_clkdm || !arch_clkdm->clkdm_sleep)
827                 return -EINVAL;
828
829         pr_debug("clockdomain: forcing sleep on %s\n", clkdm->name);
830
831         clkdm->_flags &= ~_CLKDM_FLAG_HWSUP_ENABLED;
832         ret = arch_clkdm->clkdm_sleep(clkdm);
833         ret |= pwrdm_state_switch_nolock(clkdm->pwrdm.ptr);
834
835         return ret;
836 }
837
838 /**
839  * clkdm_sleep - force clockdomain sleep transition
840  * @clkdm: struct clockdomain *
841  *
842  * Instruct the CM to force a sleep transition on the specified
843  * clockdomain @clkdm.  Returns -EINVAL if @clkdm is NULL or if
844  * clockdomain does not support software-initiated sleep; 0 upon
845  * success.
846  */
847 int clkdm_sleep(struct clockdomain *clkdm)
848 {
849         int ret;
850
851         pwrdm_lock(clkdm->pwrdm.ptr);
852         ret = clkdm_sleep_nolock(clkdm);
853         pwrdm_unlock(clkdm->pwrdm.ptr);
854
855         return ret;
856 }
857
858 /**
859  * clkdm_wakeup_nolock - force clockdomain wakeup transition (lockless)
860  * @clkdm: struct clockdomain *
861  *
862  * Instruct the CM to force a wakeup transition on the specified
863  * clockdomain @clkdm.  Only for use by the powerdomain code.  Returns
864  * -EINVAL if @clkdm is NULL or if the clockdomain does not support
865  * software-controlled wakeup; 0 upon success.
866  */
867 int clkdm_wakeup_nolock(struct clockdomain *clkdm)
868 {
869         int ret;
870
871         if (!clkdm)
872                 return -EINVAL;
873
874         if (!(clkdm->flags & CLKDM_CAN_FORCE_WAKEUP)) {
875                 pr_debug("clockdomain: %s does not support forcing wakeup via software\n",
876                          clkdm->name);
877                 return -EINVAL;
878         }
879
880         if (!arch_clkdm || !arch_clkdm->clkdm_wakeup)
881                 return -EINVAL;
882
883         pr_debug("clockdomain: forcing wakeup on %s\n", clkdm->name);
884
885         clkdm->_flags &= ~_CLKDM_FLAG_HWSUP_ENABLED;
886         ret = arch_clkdm->clkdm_wakeup(clkdm);
887         ret |= pwrdm_state_switch_nolock(clkdm->pwrdm.ptr);
888
889         return ret;
890 }
891
892 /**
893  * clkdm_wakeup - force clockdomain wakeup transition
894  * @clkdm: struct clockdomain *
895  *
896  * Instruct the CM to force a wakeup transition on the specified
897  * clockdomain @clkdm.  Returns -EINVAL if @clkdm is NULL or if the
898  * clockdomain does not support software-controlled wakeup; 0 upon
899  * success.
900  */
901 int clkdm_wakeup(struct clockdomain *clkdm)
902 {
903         int ret;
904
905         pwrdm_lock(clkdm->pwrdm.ptr);
906         ret = clkdm_wakeup_nolock(clkdm);
907         pwrdm_unlock(clkdm->pwrdm.ptr);
908
909         return ret;
910 }
911
912 /**
913  * clkdm_allow_idle_nolock - enable hwsup idle transitions for clkdm
914  * @clkdm: struct clockdomain *
915  *
916  * Allow the hardware to automatically switch the clockdomain @clkdm
917  * into active or idle states, as needed by downstream clocks.  If the
918  * clockdomain has any downstream clocks enabled in the clock
919  * framework, wkdep/sleepdep autodependencies are added; this is so
920  * device drivers can read and write to the device.  Only for use by
921  * the powerdomain code.  No return value.
922  */
923 void clkdm_allow_idle_nolock(struct clockdomain *clkdm)
924 {
925         if (!clkdm)
926                 return;
927
928         if (!(clkdm->flags & CLKDM_CAN_ENABLE_AUTO)) {
929                 pr_debug("clock: %s: automatic idle transitions cannot be enabled\n",
930                          clkdm->name);
931                 return;
932         }
933
934         if (!arch_clkdm || !arch_clkdm->clkdm_allow_idle)
935                 return;
936
937         pr_debug("clockdomain: enabling automatic idle transitions for %s\n",
938                  clkdm->name);
939
940         clkdm->_flags |= _CLKDM_FLAG_HWSUP_ENABLED;
941         arch_clkdm->clkdm_allow_idle(clkdm);
942         pwrdm_state_switch_nolock(clkdm->pwrdm.ptr);
943 }
944
945 /**
946  * clkdm_allow_idle - enable hwsup idle transitions for clkdm
947  * @clkdm: struct clockdomain *
948  *
949  * Allow the hardware to automatically switch the clockdomain @clkdm into
950  * active or idle states, as needed by downstream clocks.  If the
951  * clockdomain has any downstream clocks enabled in the clock
952  * framework, wkdep/sleepdep autodependencies are added; this is so
953  * device drivers can read and write to the device.  No return value.
954  */
955 void clkdm_allow_idle(struct clockdomain *clkdm)
956 {
957         pwrdm_lock(clkdm->pwrdm.ptr);
958         clkdm_allow_idle_nolock(clkdm);
959         pwrdm_unlock(clkdm->pwrdm.ptr);
960 }
961
962 /**
963  * clkdm_deny_idle - disable hwsup idle transitions for clkdm
964  * @clkdm: struct clockdomain *
965  *
966  * Prevent the hardware from automatically switching the clockdomain
967  * @clkdm into inactive or idle states.  If the clockdomain has
968  * downstream clocks enabled in the clock framework, wkdep/sleepdep
969  * autodependencies are removed.  Only for use by the powerdomain
970  * code.  No return value.
971  */
972 void clkdm_deny_idle_nolock(struct clockdomain *clkdm)
973 {
974         if (!clkdm)
975                 return;
976
977         if (!(clkdm->flags & CLKDM_CAN_DISABLE_AUTO)) {
978                 pr_debug("clockdomain: %s: automatic idle transitions cannot be disabled\n",
979                          clkdm->name);
980                 return;
981         }
982
983         if (!arch_clkdm || !arch_clkdm->clkdm_deny_idle)
984                 return;
985
986         pr_debug("clockdomain: disabling automatic idle transitions for %s\n",
987                  clkdm->name);
988
989         clkdm->_flags &= ~_CLKDM_FLAG_HWSUP_ENABLED;
990         arch_clkdm->clkdm_deny_idle(clkdm);
991         pwrdm_state_switch_nolock(clkdm->pwrdm.ptr);
992 }
993
994 /**
995  * clkdm_deny_idle - disable hwsup idle transitions for clkdm
996  * @clkdm: struct clockdomain *
997  *
998  * Prevent the hardware from automatically switching the clockdomain
999  * @clkdm into inactive or idle states.  If the clockdomain has
1000  * downstream clocks enabled in the clock framework, wkdep/sleepdep
1001  * autodependencies are removed.  No return value.
1002  */
1003 void clkdm_deny_idle(struct clockdomain *clkdm)
1004 {
1005         pwrdm_lock(clkdm->pwrdm.ptr);
1006         clkdm_deny_idle_nolock(clkdm);
1007         pwrdm_unlock(clkdm->pwrdm.ptr);
1008 }
1009
1010 /**
1011  * clkdm_in_hwsup - is clockdomain @clkdm have hardware-supervised idle enabled?
1012  * @clkdm: struct clockdomain *
1013  *
1014  * Returns true if clockdomain @clkdm currently has
1015  * hardware-supervised idle enabled, or false if it does not or if
1016  * @clkdm is NULL.  It is only valid to call this function after
1017  * clkdm_init() has been called.  This function does not actually read
1018  * bits from the hardware; it instead tests an in-memory flag that is
1019  * changed whenever the clockdomain code changes the auto-idle mode.
1020  */
1021 bool clkdm_in_hwsup(struct clockdomain *clkdm)
1022 {
1023         bool ret;
1024
1025         if (!clkdm)
1026                 return false;
1027
1028         ret = (clkdm->_flags & _CLKDM_FLAG_HWSUP_ENABLED) ? true : false;
1029
1030         return ret;
1031 }
1032
1033 /**
1034  * clkdm_missing_idle_reporting - can @clkdm enter autoidle even if in use?
1035  * @clkdm: struct clockdomain *
1036  *
1037  * Returns true if clockdomain @clkdm has the
1038  * CLKDM_MISSING_IDLE_REPORTING flag set, or false if not or @clkdm is
1039  * null.  More information is available in the documentation for the
1040  * CLKDM_MISSING_IDLE_REPORTING macro.
1041  */
1042 bool clkdm_missing_idle_reporting(struct clockdomain *clkdm)
1043 {
1044         if (!clkdm)
1045                 return false;
1046
1047         return (clkdm->flags & CLKDM_MISSING_IDLE_REPORTING) ? true : false;
1048 }
1049
1050 /* Public autodep handling functions (deprecated) */
1051
1052 /**
1053  * clkdm_add_autodeps - add auto sleepdeps/wkdeps to clkdm upon clock enable
1054  * @clkdm: struct clockdomain *
1055  *
1056  * Add the "autodep" sleep & wakeup dependencies to clockdomain 'clkdm'
1057  * in hardware-supervised mode.  Meant to be called from clock framework
1058  * when a clock inside clockdomain 'clkdm' is enabled.  No return value.
1059  *
1060  * XXX autodeps are deprecated and should be removed at the earliest
1061  * opportunity
1062  */
1063 void clkdm_add_autodeps(struct clockdomain *clkdm)
1064 {
1065         struct clkdm_autodep *autodep;
1066
1067         if (!autodeps || clkdm->flags & CLKDM_NO_AUTODEPS)
1068                 return;
1069
1070         for (autodep = autodeps; autodep->clkdm.ptr; autodep++) {
1071                 if (IS_ERR(autodep->clkdm.ptr))
1072                         continue;
1073
1074                 pr_debug("clockdomain: %s: adding %s sleepdep/wkdep\n",
1075                          clkdm->name, autodep->clkdm.ptr->name);
1076
1077                 _clkdm_add_sleepdep(clkdm, autodep->clkdm.ptr);
1078                 _clkdm_add_wkdep(clkdm, autodep->clkdm.ptr);
1079         }
1080 }
1081
1082 /**
1083  * clkdm_del_autodeps - remove auto sleepdeps/wkdeps from clkdm
1084  * @clkdm: struct clockdomain *
1085  *
1086  * Remove the "autodep" sleep & wakeup dependencies from clockdomain 'clkdm'
1087  * in hardware-supervised mode.  Meant to be called from clock framework
1088  * when a clock inside clockdomain 'clkdm' is disabled.  No return value.
1089  *
1090  * XXX autodeps are deprecated and should be removed at the earliest
1091  * opportunity
1092  */
1093 void clkdm_del_autodeps(struct clockdomain *clkdm)
1094 {
1095         struct clkdm_autodep *autodep;
1096
1097         if (!autodeps || clkdm->flags & CLKDM_NO_AUTODEPS)
1098                 return;
1099
1100         for (autodep = autodeps; autodep->clkdm.ptr; autodep++) {
1101                 if (IS_ERR(autodep->clkdm.ptr))
1102                         continue;
1103
1104                 pr_debug("clockdomain: %s: removing %s sleepdep/wkdep\n",
1105                          clkdm->name, autodep->clkdm.ptr->name);
1106
1107                 _clkdm_del_sleepdep(clkdm, autodep->clkdm.ptr);
1108                 _clkdm_del_wkdep(clkdm, autodep->clkdm.ptr);
1109         }
1110 }
1111
1112 /* Clockdomain-to-clock/hwmod framework interface code */
1113
1114 static int _clkdm_clk_hwmod_enable(struct clockdomain *clkdm)
1115 {
1116         if (!clkdm || !arch_clkdm || !arch_clkdm->clkdm_clk_enable)
1117                 return -EINVAL;
1118
1119         pwrdm_lock(clkdm->pwrdm.ptr);
1120
1121         /*
1122          * For arch's with no autodeps, clkcm_clk_enable
1123          * should be called for every clock instance or hwmod that is
1124          * enabled, so the clkdm can be force woken up.
1125          */
1126         clkdm->usecount++;
1127         if (clkdm->usecount > 1 && autodeps) {
1128                 pwrdm_unlock(clkdm->pwrdm.ptr);
1129                 return 0;
1130         }
1131
1132         arch_clkdm->clkdm_clk_enable(clkdm);
1133         pwrdm_state_switch_nolock(clkdm->pwrdm.ptr);
1134         pwrdm_unlock(clkdm->pwrdm.ptr);
1135
1136         pr_debug("clockdomain: %s: enabled\n", clkdm->name);
1137
1138         return 0;
1139 }
1140
1141 /**
1142  * clkdm_clk_enable - add an enabled downstream clock to this clkdm
1143  * @clkdm: struct clockdomain *
1144  * @clk: struct clk * of the enabled downstream clock
1145  *
1146  * Increment the usecount of the clockdomain @clkdm and ensure that it
1147  * is awake before @clk is enabled.  Intended to be called by
1148  * clk_enable() code.  If the clockdomain is in software-supervised
1149  * idle mode, force the clockdomain to wake.  If the clockdomain is in
1150  * hardware-supervised idle mode, add clkdm-pwrdm autodependencies, to
1151  * ensure that devices in the clockdomain can be read from/written to
1152  * by on-chip processors.  Returns -EINVAL if passed null pointers;
1153  * returns 0 upon success or if the clockdomain is in hwsup idle mode.
1154  */
1155 int clkdm_clk_enable(struct clockdomain *clkdm, struct clk *clk)
1156 {
1157         /*
1158          * XXX Rewrite this code to maintain a list of enabled
1159          * downstream clocks for debugging purposes?
1160          */
1161
1162         if (!clk)
1163                 return -EINVAL;
1164
1165         return _clkdm_clk_hwmod_enable(clkdm);
1166 }
1167
1168 /**
1169  * clkdm_clk_disable - remove an enabled downstream clock from this clkdm
1170  * @clkdm: struct clockdomain *
1171  * @clk: struct clk * of the disabled downstream clock
1172  *
1173  * Decrement the usecount of this clockdomain @clkdm when @clk is
1174  * disabled.  Intended to be called by clk_disable() code.  If the
1175  * clockdomain usecount goes to 0, put the clockdomain to sleep
1176  * (software-supervised mode) or remove the clkdm autodependencies
1177  * (hardware-supervised mode).  Returns -EINVAL if passed null
1178  * pointers; -ERANGE if the @clkdm usecount underflows; or returns 0
1179  * upon success or if the clockdomain is in hwsup idle mode.
1180  */
1181 int clkdm_clk_disable(struct clockdomain *clkdm, struct clk *clk)
1182 {
1183         if (!clkdm || !clk || !arch_clkdm || !arch_clkdm->clkdm_clk_disable)
1184                 return -EINVAL;
1185
1186         pwrdm_lock(clkdm->pwrdm.ptr);
1187
1188         /* corner case: disabling unused clocks */
1189         if ((__clk_get_enable_count(clk) == 0) && clkdm->usecount == 0)
1190                 goto ccd_exit;
1191
1192         if (clkdm->usecount == 0) {
1193                 pwrdm_unlock(clkdm->pwrdm.ptr);
1194                 WARN_ON(1); /* underflow */
1195                 return -ERANGE;
1196         }
1197
1198         clkdm->usecount--;
1199         if (clkdm->usecount > 0) {
1200                 pwrdm_unlock(clkdm->pwrdm.ptr);
1201                 return 0;
1202         }
1203
1204         arch_clkdm->clkdm_clk_disable(clkdm);
1205         pwrdm_state_switch_nolock(clkdm->pwrdm.ptr);
1206
1207         pr_debug("clockdomain: %s: disabled\n", clkdm->name);
1208
1209 ccd_exit:
1210         pwrdm_unlock(clkdm->pwrdm.ptr);
1211
1212         return 0;
1213 }
1214
1215 /**
1216  * clkdm_hwmod_enable - add an enabled downstream hwmod to this clkdm
1217  * @clkdm: struct clockdomain *
1218  * @oh: struct omap_hwmod * of the enabled downstream hwmod
1219  *
1220  * Increment the usecount of the clockdomain @clkdm and ensure that it
1221  * is awake before @oh is enabled. Intended to be called by
1222  * module_enable() code.
1223  * If the clockdomain is in software-supervised idle mode, force the
1224  * clockdomain to wake.  If the clockdomain is in hardware-supervised idle
1225  * mode, add clkdm-pwrdm autodependencies, to ensure that devices in the
1226  * clockdomain can be read from/written to by on-chip processors.
1227  * Returns -EINVAL if passed null pointers;
1228  * returns 0 upon success or if the clockdomain is in hwsup idle mode.
1229  */
1230 int clkdm_hwmod_enable(struct clockdomain *clkdm, struct omap_hwmod *oh)
1231 {
1232         /* The clkdm attribute does not exist yet prior OMAP4 */
1233         if (cpu_is_omap24xx() || cpu_is_omap34xx())
1234                 return 0;
1235
1236         /*
1237          * XXX Rewrite this code to maintain a list of enabled
1238          * downstream hwmods for debugging purposes?
1239          */
1240
1241         if (!oh)
1242                 return -EINVAL;
1243
1244         return _clkdm_clk_hwmod_enable(clkdm);
1245 }
1246
1247 /**
1248  * clkdm_hwmod_disable - remove an enabled downstream hwmod from this clkdm
1249  * @clkdm: struct clockdomain *
1250  * @oh: struct omap_hwmod * of the disabled downstream hwmod
1251  *
1252  * Decrement the usecount of this clockdomain @clkdm when @oh is
1253  * disabled. Intended to be called by module_disable() code.
1254  * If the clockdomain usecount goes to 0, put the clockdomain to sleep
1255  * (software-supervised mode) or remove the clkdm autodependencies
1256  * (hardware-supervised mode).
1257  * Returns -EINVAL if passed null pointers; -ERANGE if the @clkdm usecount
1258  * underflows; or returns 0 upon success or if the clockdomain is in hwsup
1259  * idle mode.
1260  */
1261 int clkdm_hwmod_disable(struct clockdomain *clkdm, struct omap_hwmod *oh)
1262 {
1263         /* The clkdm attribute does not exist yet prior OMAP4 */
1264         if (cpu_is_omap24xx() || cpu_is_omap34xx())
1265                 return 0;
1266
1267         /*
1268          * XXX Rewrite this code to maintain a list of enabled
1269          * downstream hwmods for debugging purposes?
1270          */
1271
1272         if (!clkdm || !oh || !arch_clkdm || !arch_clkdm->clkdm_clk_disable)
1273                 return -EINVAL;
1274
1275         pwrdm_lock(clkdm->pwrdm.ptr);
1276
1277         if (clkdm->usecount == 0) {
1278                 pwrdm_unlock(clkdm->pwrdm.ptr);
1279                 WARN_ON(1); /* underflow */
1280                 return -ERANGE;
1281         }
1282
1283         clkdm->usecount--;
1284         if (clkdm->usecount > 0) {
1285                 pwrdm_unlock(clkdm->pwrdm.ptr);
1286                 return 0;
1287         }
1288
1289         arch_clkdm->clkdm_clk_disable(clkdm);
1290         pwrdm_state_switch_nolock(clkdm->pwrdm.ptr);
1291         pwrdm_unlock(clkdm->pwrdm.ptr);
1292
1293         pr_debug("clockdomain: %s: disabled\n", clkdm->name);
1294
1295         return 0;
1296 }
1297