Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/async_tx
[linux-2.6.git] / arch / arm / mach-omap2 / clockdomain.c
1 /*
2  * OMAP2/3/4 clockdomain framework functions
3  *
4  * Copyright (C) 2008-2010 Texas Instruments, Inc.
5  * Copyright (C) 2008-2010 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/module.h>
17 #include <linux/kernel.h>
18 #include <linux/device.h>
19 #include <linux/list.h>
20 #include <linux/errno.h>
21 #include <linux/delay.h>
22 #include <linux/clk.h>
23 #include <linux/limits.h>
24 #include <linux/err.h>
25
26 #include <linux/io.h>
27
28 #include <linux/bitops.h>
29
30 #include "prm.h"
31 #include "prm-regbits-24xx.h"
32 #include "cm.h"
33
34 #include <plat/clock.h>
35 #include <plat/powerdomain.h>
36 #include <plat/clockdomain.h>
37 #include <plat/prcm.h>
38
39 /* clkdm_list contains all registered struct clockdomains */
40 static LIST_HEAD(clkdm_list);
41
42 /* array of clockdomain deps to be added/removed when clkdm in hwsup mode */
43 static struct clkdm_autodep *autodeps;
44
45
46 /* Private functions */
47
48 static struct clockdomain *_clkdm_lookup(const char *name)
49 {
50         struct clockdomain *clkdm, *temp_clkdm;
51
52         if (!name)
53                 return NULL;
54
55         clkdm = NULL;
56
57         list_for_each_entry(temp_clkdm, &clkdm_list, node) {
58                 if (!strcmp(name, temp_clkdm->name)) {
59                         clkdm = temp_clkdm;
60                         break;
61                 }
62         }
63
64         return clkdm;
65 }
66
67 /**
68  * _clkdm_register - register a clockdomain
69  * @clkdm: struct clockdomain * to register
70  *
71  * Adds a clockdomain to the internal clockdomain list.
72  * Returns -EINVAL if given a null pointer, -EEXIST if a clockdomain is
73  * already registered by the provided name, or 0 upon success.
74  */
75 static int _clkdm_register(struct clockdomain *clkdm)
76 {
77         struct powerdomain *pwrdm;
78
79         if (!clkdm || !clkdm->name)
80                 return -EINVAL;
81
82         if (!omap_chip_is(clkdm->omap_chip))
83                 return -EINVAL;
84
85         pwrdm = pwrdm_lookup(clkdm->pwrdm.name);
86         if (!pwrdm) {
87                 pr_err("clockdomain: %s: powerdomain %s does not exist\n",
88                         clkdm->name, clkdm->pwrdm.name);
89                 return -EINVAL;
90         }
91         clkdm->pwrdm.ptr = pwrdm;
92
93         /* Verify that the clockdomain is not already registered */
94         if (_clkdm_lookup(clkdm->name))
95                 return -EEXIST;
96
97         list_add(&clkdm->node, &clkdm_list);
98
99         pwrdm_add_clkdm(pwrdm, clkdm);
100
101         pr_debug("clockdomain: registered %s\n", clkdm->name);
102
103         return 0;
104 }
105
106 /* _clkdm_deps_lookup - look up the specified clockdomain in a clkdm list */
107 static struct clkdm_dep *_clkdm_deps_lookup(struct clockdomain *clkdm,
108                                             struct clkdm_dep *deps)
109 {
110         struct clkdm_dep *cd;
111
112         if (!clkdm || !deps || !omap_chip_is(clkdm->omap_chip))
113                 return ERR_PTR(-EINVAL);
114
115         for (cd = deps; cd->clkdm_name; cd++) {
116                 if (!omap_chip_is(cd->omap_chip))
117                         continue;
118
119                 if (!cd->clkdm && cd->clkdm_name)
120                         cd->clkdm = _clkdm_lookup(cd->clkdm_name);
121
122                 if (cd->clkdm == clkdm)
123                         break;
124         }
125
126         if (!cd->clkdm_name)
127                 return ERR_PTR(-ENOENT);
128
129         return cd;
130 }
131
132 /*
133  * _autodep_lookup - resolve autodep clkdm names to clkdm pointers; store
134  * @autodep: struct clkdm_autodep * to resolve
135  *
136  * Resolve autodep clockdomain names to clockdomain pointers via
137  * clkdm_lookup() and store the pointers in the autodep structure.  An
138  * "autodep" is a clockdomain sleep/wakeup dependency that is
139  * automatically added and removed whenever clocks in the associated
140  * clockdomain are enabled or disabled (respectively) when the
141  * clockdomain is in hardware-supervised mode.  Meant to be called
142  * once at clockdomain layer initialization, since these should remain
143  * fixed for a particular architecture.  No return value.
144  */
145 static void _autodep_lookup(struct clkdm_autodep *autodep)
146 {
147         struct clockdomain *clkdm;
148
149         if (!autodep)
150                 return;
151
152         if (!omap_chip_is(autodep->omap_chip))
153                 return;
154
155         clkdm = clkdm_lookup(autodep->clkdm.name);
156         if (!clkdm) {
157                 pr_err("clockdomain: autodeps: clockdomain %s does not exist\n",
158                          autodep->clkdm.name);
159                 clkdm = ERR_PTR(-ENOENT);
160         }
161         autodep->clkdm.ptr = clkdm;
162 }
163
164 /*
165  * _clkdm_add_autodeps - add auto sleepdeps/wkdeps to clkdm upon clock enable
166  * @clkdm: struct clockdomain *
167  *
168  * Add the "autodep" sleep & wakeup dependencies to clockdomain 'clkdm'
169  * in hardware-supervised mode.  Meant to be called from clock framework
170  * when a clock inside clockdomain 'clkdm' is enabled.  No return value.
171  */
172 static void _clkdm_add_autodeps(struct clockdomain *clkdm)
173 {
174         struct clkdm_autodep *autodep;
175
176         if (!autodeps)
177                 return;
178
179         for (autodep = autodeps; autodep->clkdm.ptr; autodep++) {
180                 if (IS_ERR(autodep->clkdm.ptr))
181                         continue;
182
183                 if (!omap_chip_is(autodep->omap_chip))
184                         continue;
185
186                 pr_debug("clockdomain: adding %s sleepdep/wkdep for "
187                          "clkdm %s\n", autodep->clkdm.ptr->name,
188                          clkdm->name);
189
190                 clkdm_add_sleepdep(clkdm, autodep->clkdm.ptr);
191                 clkdm_add_wkdep(clkdm, autodep->clkdm.ptr);
192         }
193 }
194
195 /*
196  * _clkdm_add_autodeps - remove auto sleepdeps/wkdeps from clkdm
197  * @clkdm: struct clockdomain *
198  *
199  * Remove the "autodep" sleep & wakeup dependencies from clockdomain 'clkdm'
200  * in hardware-supervised mode.  Meant to be called from clock framework
201  * when a clock inside clockdomain 'clkdm' is disabled.  No return value.
202  */
203 static void _clkdm_del_autodeps(struct clockdomain *clkdm)
204 {
205         struct clkdm_autodep *autodep;
206
207         if (!autodeps)
208                 return;
209
210         for (autodep = autodeps; autodep->clkdm.ptr; autodep++) {
211                 if (IS_ERR(autodep->clkdm.ptr))
212                         continue;
213
214                 if (!omap_chip_is(autodep->omap_chip))
215                         continue;
216
217                 pr_debug("clockdomain: removing %s sleepdep/wkdep for "
218                          "clkdm %s\n", autodep->clkdm.ptr->name,
219                          clkdm->name);
220
221                 clkdm_del_sleepdep(clkdm, autodep->clkdm.ptr);
222                 clkdm_del_wkdep(clkdm, autodep->clkdm.ptr);
223         }
224 }
225
226 /*
227  * _omap2_clkdm_set_hwsup - set the hwsup idle transition bit
228  * @clkdm: struct clockdomain *
229  * @enable: int 0 to disable, 1 to enable
230  *
231  * Internal helper for actually switching the bit that controls hwsup
232  * idle transitions for clkdm.
233  */
234 static void _omap2_clkdm_set_hwsup(struct clockdomain *clkdm, int enable)
235 {
236         u32 bits, v;
237
238         if (cpu_is_omap24xx()) {
239                 if (enable)
240                         bits = OMAP24XX_CLKSTCTRL_ENABLE_AUTO;
241                 else
242                         bits = OMAP24XX_CLKSTCTRL_DISABLE_AUTO;
243         } else if (cpu_is_omap34xx() || cpu_is_omap44xx()) {
244                 if (enable)
245                         bits = OMAP34XX_CLKSTCTRL_ENABLE_AUTO;
246                 else
247                         bits = OMAP34XX_CLKSTCTRL_DISABLE_AUTO;
248         } else {
249                 BUG();
250         }
251
252         bits = bits << __ffs(clkdm->clktrctrl_mask);
253
254         v = __raw_readl(clkdm->clkstctrl_reg);
255         v &= ~(clkdm->clktrctrl_mask);
256         v |= bits;
257         __raw_writel(v, clkdm->clkstctrl_reg);
258
259 }
260
261 /* Public functions */
262
263 /**
264  * clkdm_init - set up the clockdomain layer
265  * @clkdms: optional pointer to an array of clockdomains to register
266  * @init_autodeps: optional pointer to an array of autodeps to register
267  *
268  * Set up internal state.  If a pointer to an array of clockdomains
269  * @clkdms was supplied, loop through the list of clockdomains,
270  * register all that are available on the current platform. Similarly,
271  * if a pointer to an array of clockdomain autodependencies
272  * @init_autodeps was provided, register those.  No return value.
273  */
274 void clkdm_init(struct clockdomain **clkdms,
275                 struct clkdm_autodep *init_autodeps)
276 {
277         struct clockdomain **c = NULL;
278         struct clockdomain *clkdm;
279         struct clkdm_autodep *autodep = NULL;
280
281         if (clkdms)
282                 for (c = clkdms; *c; c++)
283                         _clkdm_register(*c);
284
285         autodeps = init_autodeps;
286         if (autodeps)
287                 for (autodep = autodeps; autodep->clkdm.ptr; autodep++)
288                         _autodep_lookup(autodep);
289
290         /*
291          * Put all clockdomains into software-supervised mode; PM code
292          * should later enable hardware-supervised mode as appropriate
293          */
294         list_for_each_entry(clkdm, &clkdm_list, node) {
295                 if (clkdm->flags & CLKDM_CAN_FORCE_WAKEUP)
296                         omap2_clkdm_wakeup(clkdm);
297                 else if (clkdm->flags & CLKDM_CAN_DISABLE_AUTO)
298                         omap2_clkdm_deny_idle(clkdm);
299
300                 clkdm_clear_all_wkdeps(clkdm);
301                 clkdm_clear_all_sleepdeps(clkdm);
302         }
303 }
304
305 /**
306  * clkdm_lookup - look up a clockdomain by name, return a pointer
307  * @name: name of clockdomain
308  *
309  * Find a registered clockdomain by its name @name.  Returns a pointer
310  * to the struct clockdomain if found, or NULL otherwise.
311  */
312 struct clockdomain *clkdm_lookup(const char *name)
313 {
314         struct clockdomain *clkdm, *temp_clkdm;
315
316         if (!name)
317                 return NULL;
318
319         clkdm = NULL;
320
321         list_for_each_entry(temp_clkdm, &clkdm_list, node) {
322                 if (!strcmp(name, temp_clkdm->name)) {
323                         clkdm = temp_clkdm;
324                         break;
325                 }
326         }
327
328         return clkdm;
329 }
330
331 /**
332  * clkdm_for_each - call function on each registered clockdomain
333  * @fn: callback function *
334  *
335  * Call the supplied function @fn for each registered clockdomain.
336  * The callback function @fn can return anything but 0 to bail
337  * out early from the iterator.  The callback function is called with
338  * the clkdm_mutex held, so no clockdomain structure manipulation
339  * functions should be called from the callback, although hardware
340  * clockdomain control functions are fine.  Returns the last return
341  * value of the callback function, which should be 0 for success or
342  * anything else to indicate failure; or -EINVAL if the function pointer
343  * is null.
344  */
345 int clkdm_for_each(int (*fn)(struct clockdomain *clkdm, void *user),
346                         void *user)
347 {
348         struct clockdomain *clkdm;
349         int ret = 0;
350
351         if (!fn)
352                 return -EINVAL;
353
354         list_for_each_entry(clkdm, &clkdm_list, node) {
355                 ret = (*fn)(clkdm, user);
356                 if (ret)
357                         break;
358         }
359
360         return ret;
361 }
362
363
364 /**
365  * clkdm_get_pwrdm - return a ptr to the pwrdm that this clkdm resides in
366  * @clkdm: struct clockdomain *
367  *
368  * Return a pointer to the struct powerdomain that the specified clockdomain
369  * @clkdm exists in, or returns NULL if @clkdm is NULL.
370  */
371 struct powerdomain *clkdm_get_pwrdm(struct clockdomain *clkdm)
372 {
373         if (!clkdm)
374                 return NULL;
375
376         return clkdm->pwrdm.ptr;
377 }
378
379
380 /* Hardware clockdomain control */
381
382 /**
383  * clkdm_add_wkdep - add a wakeup dependency from clkdm2 to clkdm1
384  * @clkdm1: wake this struct clockdomain * up (dependent)
385  * @clkdm2: when this struct clockdomain * wakes up (source)
386  *
387  * When the clockdomain represented by @clkdm2 wakes up, wake up
388  * @clkdm1. Implemented in hardware on the OMAP, this feature is
389  * designed to reduce wakeup latency of the dependent clockdomain @clkdm1.
390  * Returns -EINVAL if presented with invalid clockdomain pointers,
391  * -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or 0 upon
392  * success.
393  */
394 int clkdm_add_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
395 {
396         struct clkdm_dep *cd;
397
398         if (!clkdm1 || !clkdm2)
399                 return -EINVAL;
400
401         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
402         if (IS_ERR(cd)) {
403                 pr_debug("clockdomain: hardware cannot set/clear wake up of "
404                          "%s when %s wakes up\n", clkdm1->name, clkdm2->name);
405                 return PTR_ERR(cd);
406         }
407
408         if (atomic_inc_return(&cd->wkdep_usecount) == 1) {
409                 pr_debug("clockdomain: hardware will wake up %s when %s wakes "
410                          "up\n", clkdm1->name, clkdm2->name);
411
412                 prm_set_mod_reg_bits((1 << clkdm2->dep_bit),
413                                      clkdm1->pwrdm.ptr->prcm_offs, PM_WKDEP);
414         }
415
416         return 0;
417 }
418
419 /**
420  * clkdm_del_wkdep - remove a wakeup dependency from clkdm2 to clkdm1
421  * @clkdm1: wake this struct clockdomain * up (dependent)
422  * @clkdm2: when this struct clockdomain * wakes up (source)
423  *
424  * Remove a wakeup dependency causing @clkdm1 to wake up when @clkdm2
425  * wakes up.  Returns -EINVAL if presented with invalid clockdomain
426  * pointers, -ENOENT if @clkdm2 cannot wake up clkdm1 in hardware, or
427  * 0 upon success.
428  */
429 int clkdm_del_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
430 {
431         struct clkdm_dep *cd;
432
433         if (!clkdm1 || !clkdm2)
434                 return -EINVAL;
435
436         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
437         if (IS_ERR(cd)) {
438                 pr_debug("clockdomain: hardware cannot set/clear wake up of "
439                          "%s when %s wakes up\n", clkdm1->name, clkdm2->name);
440                 return PTR_ERR(cd);
441         }
442
443         if (atomic_dec_return(&cd->wkdep_usecount) == 0) {
444                 pr_debug("clockdomain: hardware will no longer wake up %s "
445                          "after %s wakes up\n", clkdm1->name, clkdm2->name);
446
447                 prm_clear_mod_reg_bits((1 << clkdm2->dep_bit),
448                                        clkdm1->pwrdm.ptr->prcm_offs, PM_WKDEP);
449         }
450
451         return 0;
452 }
453
454 /**
455  * clkdm_read_wkdep - read wakeup dependency state from clkdm2 to clkdm1
456  * @clkdm1: wake this struct clockdomain * up (dependent)
457  * @clkdm2: when this struct clockdomain * wakes up (source)
458  *
459  * Return 1 if a hardware wakeup dependency exists wherein @clkdm1 will be
460  * awoken when @clkdm2 wakes up; 0 if dependency is not set; -EINVAL
461  * if either clockdomain pointer is invalid; or -ENOENT if the hardware
462  * is incapable.
463  *
464  * REVISIT: Currently this function only represents software-controllable
465  * wakeup dependencies.  Wakeup dependencies fixed in hardware are not
466  * yet handled here.
467  */
468 int clkdm_read_wkdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
469 {
470         struct clkdm_dep *cd;
471
472         if (!clkdm1 || !clkdm2)
473                 return -EINVAL;
474
475         cd = _clkdm_deps_lookup(clkdm2, clkdm1->wkdep_srcs);
476         if (IS_ERR(cd)) {
477                 pr_debug("clockdomain: hardware cannot set/clear wake up of "
478                          "%s when %s wakes up\n", clkdm1->name, clkdm2->name);
479                 return PTR_ERR(cd);
480         }
481
482         /* XXX It's faster to return the atomic wkdep_usecount */
483         return prm_read_mod_bits_shift(clkdm1->pwrdm.ptr->prcm_offs, PM_WKDEP,
484                                        (1 << clkdm2->dep_bit));
485 }
486
487 /**
488  * clkdm_clear_all_wkdeps - remove all wakeup dependencies from target clkdm
489  * @clkdm: struct clockdomain * to remove all wakeup dependencies from
490  *
491  * Remove all inter-clockdomain wakeup dependencies that could cause
492  * @clkdm to wake.  Intended to be used during boot to initialize the
493  * PRCM to a known state, after all clockdomains are put into swsup idle
494  * and woken up.  Returns -EINVAL if @clkdm pointer is invalid, or
495  * 0 upon success.
496  */
497 int clkdm_clear_all_wkdeps(struct clockdomain *clkdm)
498 {
499         struct clkdm_dep *cd;
500         u32 mask = 0;
501
502         if (!clkdm)
503                 return -EINVAL;
504
505         for (cd = clkdm->wkdep_srcs; cd && cd->clkdm_name; cd++) {
506                 if (!omap_chip_is(cd->omap_chip))
507                         continue;
508
509                 if (!cd->clkdm && cd->clkdm_name)
510                         cd->clkdm = _clkdm_lookup(cd->clkdm_name);
511
512                 /* PRM accesses are slow, so minimize them */
513                 mask |= 1 << cd->clkdm->dep_bit;
514                 atomic_set(&cd->wkdep_usecount, 0);
515         }
516
517         prm_clear_mod_reg_bits(mask, clkdm->pwrdm.ptr->prcm_offs, PM_WKDEP);
518
519         return 0;
520 }
521
522 /**
523  * clkdm_add_sleepdep - add a sleep dependency from clkdm2 to clkdm1
524  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
525  * @clkdm2: when this struct clockdomain * is active (source)
526  *
527  * Prevent @clkdm1 from automatically going inactive (and then to
528  * retention or off) if @clkdm2 is active.  Returns -EINVAL if
529  * presented with invalid clockdomain pointers or called on a machine
530  * that does not support software-configurable hardware sleep
531  * dependencies, -ENOENT if the specified dependency cannot be set in
532  * hardware, or 0 upon success.
533  */
534 int clkdm_add_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
535 {
536         struct clkdm_dep *cd;
537
538         if (!cpu_is_omap34xx())
539                 return -EINVAL;
540
541         if (!clkdm1 || !clkdm2)
542                 return -EINVAL;
543
544         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
545         if (IS_ERR(cd)) {
546                 pr_debug("clockdomain: hardware cannot set/clear sleep "
547                          "dependency affecting %s from %s\n", clkdm1->name,
548                          clkdm2->name);
549                 return PTR_ERR(cd);
550         }
551
552         if (atomic_inc_return(&cd->sleepdep_usecount) == 1) {
553                 pr_debug("clockdomain: will prevent %s from sleeping if %s "
554                          "is active\n", clkdm1->name, clkdm2->name);
555
556                 cm_set_mod_reg_bits((1 << clkdm2->dep_bit),
557                                     clkdm1->pwrdm.ptr->prcm_offs,
558                                     OMAP3430_CM_SLEEPDEP);
559         }
560
561         return 0;
562 }
563
564 /**
565  * clkdm_del_sleepdep - remove a sleep dependency from clkdm2 to clkdm1
566  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
567  * @clkdm2: when this struct clockdomain * is active (source)
568  *
569  * Allow @clkdm1 to automatically go inactive (and then to retention or
570  * off), independent of the activity state of @clkdm2.  Returns -EINVAL
571  * if presented with invalid clockdomain pointers or called on a machine
572  * that does not support software-configurable hardware sleep dependencies,
573  * -ENOENT if the specified dependency cannot be cleared in hardware, or
574  * 0 upon success.
575  */
576 int clkdm_del_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
577 {
578         struct clkdm_dep *cd;
579
580         if (!cpu_is_omap34xx())
581                 return -EINVAL;
582
583         if (!clkdm1 || !clkdm2)
584                 return -EINVAL;
585
586         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
587         if (IS_ERR(cd)) {
588                 pr_debug("clockdomain: hardware cannot set/clear sleep "
589                          "dependency affecting %s from %s\n", clkdm1->name,
590                          clkdm2->name);
591                 return PTR_ERR(cd);
592         }
593
594         if (atomic_dec_return(&cd->sleepdep_usecount) == 0) {
595                 pr_debug("clockdomain: will no longer prevent %s from "
596                          "sleeping if %s is active\n", clkdm1->name,
597                          clkdm2->name);
598
599                 cm_clear_mod_reg_bits((1 << clkdm2->dep_bit),
600                                       clkdm1->pwrdm.ptr->prcm_offs,
601                                       OMAP3430_CM_SLEEPDEP);
602         }
603
604         return 0;
605 }
606
607 /**
608  * clkdm_read_sleepdep - read sleep dependency state from clkdm2 to clkdm1
609  * @clkdm1: prevent this struct clockdomain * from sleeping (dependent)
610  * @clkdm2: when this struct clockdomain * is active (source)
611  *
612  * Return 1 if a hardware sleep dependency exists wherein @clkdm1 will
613  * not be allowed to automatically go inactive if @clkdm2 is active;
614  * 0 if @clkdm1's automatic power state inactivity transition is independent
615  * of @clkdm2's; -EINVAL if either clockdomain pointer is invalid or called
616  * on a machine that does not support software-configurable hardware sleep
617  * dependencies; or -ENOENT if the hardware is incapable.
618  *
619  * REVISIT: Currently this function only represents software-controllable
620  * sleep dependencies.  Sleep dependencies fixed in hardware are not
621  * yet handled here.
622  */
623 int clkdm_read_sleepdep(struct clockdomain *clkdm1, struct clockdomain *clkdm2)
624 {
625         struct clkdm_dep *cd;
626
627         if (!cpu_is_omap34xx())
628                 return -EINVAL;
629
630         if (!clkdm1 || !clkdm2)
631                 return -EINVAL;
632
633         cd = _clkdm_deps_lookup(clkdm2, clkdm1->sleepdep_srcs);
634         if (IS_ERR(cd)) {
635                 pr_debug("clockdomain: hardware cannot set/clear sleep "
636                          "dependency affecting %s from %s\n", clkdm1->name,
637                          clkdm2->name);
638                 return PTR_ERR(cd);
639         }
640
641         /* XXX It's faster to return the atomic sleepdep_usecount */
642         return prm_read_mod_bits_shift(clkdm1->pwrdm.ptr->prcm_offs,
643                                        OMAP3430_CM_SLEEPDEP,
644                                        (1 << clkdm2->dep_bit));
645 }
646
647 /**
648  * clkdm_clear_all_sleepdeps - remove all sleep dependencies from target clkdm
649  * @clkdm: struct clockdomain * to remove all sleep dependencies from
650  *
651  * Remove all inter-clockdomain sleep dependencies that could prevent
652  * @clkdm from idling.  Intended to be used during boot to initialize the
653  * PRCM to a known state, after all clockdomains are put into swsup idle
654  * and woken up.  Returns -EINVAL if @clkdm pointer is invalid, or
655  * 0 upon success.
656  */
657 int clkdm_clear_all_sleepdeps(struct clockdomain *clkdm)
658 {
659         struct clkdm_dep *cd;
660         u32 mask = 0;
661
662         if (!cpu_is_omap34xx())
663                 return -EINVAL;
664
665         if (!clkdm)
666                 return -EINVAL;
667
668         for (cd = clkdm->sleepdep_srcs; cd && cd->clkdm_name; cd++) {
669                 if (!omap_chip_is(cd->omap_chip))
670                         continue;
671
672                 if (!cd->clkdm && cd->clkdm_name)
673                         cd->clkdm = _clkdm_lookup(cd->clkdm_name);
674
675                 /* PRM accesses are slow, so minimize them */
676                 mask |= 1 << cd->clkdm->dep_bit;
677                 atomic_set(&cd->sleepdep_usecount, 0);
678         }
679
680         prm_clear_mod_reg_bits(mask, clkdm->pwrdm.ptr->prcm_offs,
681                                OMAP3430_CM_SLEEPDEP);
682
683         return 0;
684 }
685
686 /**
687  * omap2_clkdm_clktrctrl_read - read the clkdm's current state transition mode
688  * @clkdm: struct clkdm * of a clockdomain
689  *
690  * Return the clockdomain @clkdm current state transition mode from the
691  * corresponding domain CM_CLKSTCTRL register.  Returns -EINVAL if @clkdm
692  * is NULL or the current mode upon success.
693  */
694 static int omap2_clkdm_clktrctrl_read(struct clockdomain *clkdm)
695 {
696         u32 v;
697
698         if (!clkdm)
699                 return -EINVAL;
700
701         v = __raw_readl(clkdm->clkstctrl_reg);
702         v &= clkdm->clktrctrl_mask;
703         v >>= __ffs(clkdm->clktrctrl_mask);
704
705         return v;
706 }
707
708 /**
709  * omap2_clkdm_sleep - force clockdomain sleep transition
710  * @clkdm: struct clockdomain *
711  *
712  * Instruct the CM to force a sleep transition on the specified
713  * clockdomain @clkdm.  Returns -EINVAL if @clkdm is NULL or if
714  * clockdomain does not support software-initiated sleep; 0 upon
715  * success.
716  */
717 int omap2_clkdm_sleep(struct clockdomain *clkdm)
718 {
719         if (!clkdm)
720                 return -EINVAL;
721
722         if (!(clkdm->flags & CLKDM_CAN_FORCE_SLEEP)) {
723                 pr_debug("clockdomain: %s does not support forcing "
724                          "sleep via software\n", clkdm->name);
725                 return -EINVAL;
726         }
727
728         pr_debug("clockdomain: forcing sleep on %s\n", clkdm->name);
729
730         if (cpu_is_omap24xx()) {
731
732                 cm_set_mod_reg_bits(OMAP24XX_FORCESTATE_MASK,
733                             clkdm->pwrdm.ptr->prcm_offs, OMAP2_PM_PWSTCTRL);
734
735         } else if (cpu_is_omap34xx() || cpu_is_omap44xx()) {
736
737                 u32 bits = (OMAP34XX_CLKSTCTRL_FORCE_SLEEP <<
738                          __ffs(clkdm->clktrctrl_mask));
739
740                 u32 v = __raw_readl(clkdm->clkstctrl_reg);
741                 v &= ~(clkdm->clktrctrl_mask);
742                 v |= bits;
743                 __raw_writel(v, clkdm->clkstctrl_reg);
744
745         } else {
746                 BUG();
747         };
748
749         return 0;
750 }
751
752 /**
753  * omap2_clkdm_wakeup - force clockdomain wakeup transition
754  * @clkdm: struct clockdomain *
755  *
756  * Instruct the CM to force a wakeup transition on the specified
757  * clockdomain @clkdm.  Returns -EINVAL if @clkdm is NULL or if the
758  * clockdomain does not support software-controlled wakeup; 0 upon
759  * success.
760  */
761 int omap2_clkdm_wakeup(struct clockdomain *clkdm)
762 {
763         if (!clkdm)
764                 return -EINVAL;
765
766         if (!(clkdm->flags & CLKDM_CAN_FORCE_WAKEUP)) {
767                 pr_debug("clockdomain: %s does not support forcing "
768                          "wakeup via software\n", clkdm->name);
769                 return -EINVAL;
770         }
771
772         pr_debug("clockdomain: forcing wakeup on %s\n", clkdm->name);
773
774         if (cpu_is_omap24xx()) {
775
776                 cm_clear_mod_reg_bits(OMAP24XX_FORCESTATE_MASK,
777                               clkdm->pwrdm.ptr->prcm_offs, OMAP2_PM_PWSTCTRL);
778
779         } else if (cpu_is_omap34xx() || cpu_is_omap44xx()) {
780
781                 u32 bits = (OMAP34XX_CLKSTCTRL_FORCE_WAKEUP <<
782                          __ffs(clkdm->clktrctrl_mask));
783
784                 u32 v = __raw_readl(clkdm->clkstctrl_reg);
785                 v &= ~(clkdm->clktrctrl_mask);
786                 v |= bits;
787                 __raw_writel(v, clkdm->clkstctrl_reg);
788
789         } else {
790                 BUG();
791         };
792
793         return 0;
794 }
795
796 /**
797  * omap2_clkdm_allow_idle - enable hwsup idle transitions for clkdm
798  * @clkdm: struct clockdomain *
799  *
800  * Allow the hardware to automatically switch the clockdomain @clkdm into
801  * active or idle states, as needed by downstream clocks.  If the
802  * clockdomain has any downstream clocks enabled in the clock
803  * framework, wkdep/sleepdep autodependencies are added; this is so
804  * device drivers can read and write to the device.  No return value.
805  */
806 void omap2_clkdm_allow_idle(struct clockdomain *clkdm)
807 {
808         if (!clkdm)
809                 return;
810
811         if (!(clkdm->flags & CLKDM_CAN_ENABLE_AUTO)) {
812                 pr_debug("clock: automatic idle transitions cannot be enabled "
813                          "on clockdomain %s\n", clkdm->name);
814                 return;
815         }
816
817         pr_debug("clockdomain: enabling automatic idle transitions for %s\n",
818                  clkdm->name);
819
820         /*
821          * XXX This should be removed once TI adds wakeup/sleep
822          * dependency code and data for OMAP4.
823          */
824         if (cpu_is_omap44xx()) {
825                 WARN_ONCE(1, "clockdomain: OMAP4 wakeup/sleep dependency "
826                           "support is not yet implemented\n");
827         } else {
828                 if (atomic_read(&clkdm->usecount) > 0)
829                         _clkdm_add_autodeps(clkdm);
830         }
831
832         _omap2_clkdm_set_hwsup(clkdm, 1);
833
834         pwrdm_clkdm_state_switch(clkdm);
835 }
836
837 /**
838  * omap2_clkdm_deny_idle - disable hwsup idle transitions for clkdm
839  * @clkdm: struct clockdomain *
840  *
841  * Prevent the hardware from automatically switching the clockdomain
842  * @clkdm into inactive or idle states.  If the clockdomain has
843  * downstream clocks enabled in the clock framework, wkdep/sleepdep
844  * autodependencies are removed.  No return value.
845  */
846 void omap2_clkdm_deny_idle(struct clockdomain *clkdm)
847 {
848         if (!clkdm)
849                 return;
850
851         if (!(clkdm->flags & CLKDM_CAN_DISABLE_AUTO)) {
852                 pr_debug("clockdomain: automatic idle transitions cannot be "
853                          "disabled on %s\n", clkdm->name);
854                 return;
855         }
856
857         pr_debug("clockdomain: disabling automatic idle transitions for %s\n",
858                  clkdm->name);
859
860         _omap2_clkdm_set_hwsup(clkdm, 0);
861
862         /*
863          * XXX This should be removed once TI adds wakeup/sleep
864          * dependency code and data for OMAP4.
865          */
866         if (cpu_is_omap44xx()) {
867                 WARN_ONCE(1, "clockdomain: OMAP4 wakeup/sleep dependency "
868                           "support is not yet implemented\n");
869         } else {
870                 if (atomic_read(&clkdm->usecount) > 0)
871                         _clkdm_del_autodeps(clkdm);
872         }
873 }
874
875
876 /* Clockdomain-to-clock framework interface code */
877
878 /**
879  * omap2_clkdm_clk_enable - add an enabled downstream clock to this clkdm
880  * @clkdm: struct clockdomain *
881  * @clk: struct clk * of the enabled downstream clock
882  *
883  * Increment the usecount of the clockdomain @clkdm and ensure that it
884  * is awake before @clk is enabled.  Intended to be called by
885  * clk_enable() code.  If the clockdomain is in software-supervised
886  * idle mode, force the clockdomain to wake.  If the clockdomain is in
887  * hardware-supervised idle mode, add clkdm-pwrdm autodependencies, to
888  * ensure that devices in the clockdomain can be read from/written to
889  * by on-chip processors.  Returns -EINVAL if passed null pointers;
890  * returns 0 upon success or if the clockdomain is in hwsup idle mode.
891  */
892 int omap2_clkdm_clk_enable(struct clockdomain *clkdm, struct clk *clk)
893 {
894         int v;
895
896         /*
897          * XXX Rewrite this code to maintain a list of enabled
898          * downstream clocks for debugging purposes?
899          */
900
901         if (!clkdm || !clk)
902                 return -EINVAL;
903
904         if (atomic_inc_return(&clkdm->usecount) > 1)
905                 return 0;
906
907         /* Clockdomain now has one enabled downstream clock */
908
909         pr_debug("clockdomain: clkdm %s: clk %s now enabled\n", clkdm->name,
910                  clk->name);
911
912         if (!clkdm->clkstctrl_reg)
913                 return 0;
914
915         v = omap2_clkdm_clktrctrl_read(clkdm);
916
917         if ((cpu_is_omap34xx() && v == OMAP34XX_CLKSTCTRL_ENABLE_AUTO) ||
918             (cpu_is_omap24xx() && v == OMAP24XX_CLKSTCTRL_ENABLE_AUTO)) {
919                 /* Disable HW transitions when we are changing deps */
920                 _omap2_clkdm_set_hwsup(clkdm, 0);
921                 _clkdm_add_autodeps(clkdm);
922                 _omap2_clkdm_set_hwsup(clkdm, 1);
923         } else {
924                 omap2_clkdm_wakeup(clkdm);
925         }
926
927         pwrdm_wait_transition(clkdm->pwrdm.ptr);
928         pwrdm_clkdm_state_switch(clkdm);
929
930         return 0;
931 }
932
933 /**
934  * omap2_clkdm_clk_disable - remove an enabled downstream clock from this clkdm
935  * @clkdm: struct clockdomain *
936  * @clk: struct clk * of the disabled downstream clock
937  *
938  * Decrement the usecount of this clockdomain @clkdm when @clk is
939  * disabled.  Intended to be called by clk_disable() code.  If the
940  * clockdomain usecount goes to 0, put the clockdomain to sleep
941  * (software-supervised mode) or remove the clkdm autodependencies
942  * (hardware-supervised mode).  Returns -EINVAL if passed null
943  * pointers; -ERANGE if the @clkdm usecount underflows and debugging
944  * is enabled; or returns 0 upon success or if the clockdomain is in
945  * hwsup idle mode.
946  */
947 int omap2_clkdm_clk_disable(struct clockdomain *clkdm, struct clk *clk)
948 {
949         int v;
950
951         /*
952          * XXX Rewrite this code to maintain a list of enabled
953          * downstream clocks for debugging purposes?
954          */
955
956         if (!clkdm || !clk)
957                 return -EINVAL;
958
959 #ifdef DEBUG
960         if (atomic_read(&clkdm->usecount) == 0) {
961                 WARN_ON(1); /* underflow */
962                 return -ERANGE;
963         }
964 #endif
965
966         if (atomic_dec_return(&clkdm->usecount) > 0)
967                 return 0;
968
969         /* All downstream clocks of this clockdomain are now disabled */
970
971         pr_debug("clockdomain: clkdm %s: clk %s now disabled\n", clkdm->name,
972                  clk->name);
973
974         if (!clkdm->clkstctrl_reg)
975                 return 0;
976
977         v = omap2_clkdm_clktrctrl_read(clkdm);
978
979         if ((cpu_is_omap34xx() && v == OMAP34XX_CLKSTCTRL_ENABLE_AUTO) ||
980             (cpu_is_omap24xx() && v == OMAP24XX_CLKSTCTRL_ENABLE_AUTO)) {
981                 /* Disable HW transitions when we are changing deps */
982                 _omap2_clkdm_set_hwsup(clkdm, 0);
983                 _clkdm_del_autodeps(clkdm);
984                 _omap2_clkdm_set_hwsup(clkdm, 1);
985         } else {
986                 omap2_clkdm_sleep(clkdm);
987         }
988
989         pwrdm_clkdm_state_switch(clkdm);
990
991         return 0;
992 }
993