2 * OMAP powerdomain control
4 * Copyright (C) 2007-2008 Texas Instruments, Inc.
5 * Copyright (C) 2007-2008 Nokia Corporation
7 * Written by Paul Walmsley
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 #ifdef CONFIG_OMAP_DEBUG_POWERDOMAIN
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/delay.h>
21 #include <linux/spinlock.h>
22 #include <linux/list.h>
23 #include <linux/errno.h>
24 #include <linux/err.h>
27 #include <asm/atomic.h>
30 #include "cm-regbits-34xx.h"
32 #include "prm-regbits-34xx.h"
35 #include <mach/powerdomain.h>
36 #include <mach/clockdomain.h>
45 /* pwrdm_list contains all registered struct powerdomains */
46 static LIST_HEAD(pwrdm_list
);
49 * pwrdm_rwlock protects pwrdm_list add and del ops - also reused to
50 * protect pwrdm_clkdms[] during clkdm add/del ops
52 static DEFINE_RWLOCK(pwrdm_rwlock
);
55 /* Private functions */
57 static u32
prm_read_mod_bits_shift(s16 domain
, s16 idx
, u32 mask
)
61 v
= prm_read_mod_reg(domain
, idx
);
68 static struct powerdomain
*_pwrdm_lookup(const char *name
)
70 struct powerdomain
*pwrdm
, *temp_pwrdm
;
74 list_for_each_entry(temp_pwrdm
, &pwrdm_list
, node
) {
75 if (!strcmp(name
, temp_pwrdm
->name
)) {
84 /* _pwrdm_deps_lookup - look up the specified powerdomain in a pwrdm list */
85 static struct powerdomain
*_pwrdm_deps_lookup(struct powerdomain
*pwrdm
,
86 struct pwrdm_dep
*deps
)
90 if (!pwrdm
|| !deps
|| !omap_chip_is(pwrdm
->omap_chip
))
91 return ERR_PTR(-EINVAL
);
93 for (pd
= deps
; pd
; pd
++) {
95 if (!omap_chip_is(pd
->omap_chip
))
98 if (!pd
->pwrdm
&& pd
->pwrdm_name
)
99 pd
->pwrdm
= pwrdm_lookup(pd
->pwrdm_name
);
101 if (pd
->pwrdm
== pwrdm
)
107 return ERR_PTR(-ENOENT
);
112 static int _pwrdm_state_switch(struct powerdomain
*pwrdm
, int flag
)
121 state
= pwrdm_read_pwrst(pwrdm
);
124 case PWRDM_STATE_NOW
:
127 case PWRDM_STATE_PREV
:
128 prev
= pwrdm_read_prev_pwrst(pwrdm
);
129 if (pwrdm
->state
!= prev
)
130 pwrdm
->state_counter
[prev
]++;
137 pwrdm
->state_counter
[state
]++;
139 pm_dbg_update_time(pwrdm
, prev
);
141 pwrdm
->state
= state
;
146 static int _pwrdm_pre_transition_cb(struct powerdomain
*pwrdm
, void *unused
)
148 pwrdm_clear_all_prev_pwrst(pwrdm
);
149 _pwrdm_state_switch(pwrdm
, PWRDM_STATE_NOW
);
153 static int _pwrdm_post_transition_cb(struct powerdomain
*pwrdm
, void *unused
)
155 _pwrdm_state_switch(pwrdm
, PWRDM_STATE_PREV
);
159 static __init
void _pwrdm_setup(struct powerdomain
*pwrdm
)
163 for (i
= 0; i
< 4; i
++)
164 pwrdm
->state_counter
[i
] = 0;
166 pwrdm_wait_transition(pwrdm
);
167 pwrdm
->state
= pwrdm_read_pwrst(pwrdm
);
168 pwrdm
->state_counter
[pwrdm
->state
] = 1;
172 /* Public functions */
175 * pwrdm_init - set up the powerdomain layer
177 * Loop through the list of powerdomains, registering all that are
178 * available on the current CPU. If pwrdm_list is supplied and not
179 * null, all of the referenced powerdomains will be registered. No
182 void pwrdm_init(struct powerdomain
**pwrdm_list
)
184 struct powerdomain
**p
= NULL
;
187 for (p
= pwrdm_list
; *p
; p
++) {
195 * pwrdm_register - register a powerdomain
196 * @pwrdm: struct powerdomain * to register
198 * Adds a powerdomain to the internal powerdomain list. Returns
199 * -EINVAL if given a null pointer, -EEXIST if a powerdomain is
200 * already registered by the provided name, or 0 upon success.
202 int pwrdm_register(struct powerdomain
*pwrdm
)
210 if (!omap_chip_is(pwrdm
->omap_chip
))
213 write_lock_irqsave(&pwrdm_rwlock
, flags
);
214 if (_pwrdm_lookup(pwrdm
->name
)) {
219 list_add(&pwrdm
->node
, &pwrdm_list
);
221 pr_debug("powerdomain: registered %s\n", pwrdm
->name
);
225 write_unlock_irqrestore(&pwrdm_rwlock
, flags
);
231 * pwrdm_unregister - unregister a powerdomain
232 * @pwrdm: struct powerdomain * to unregister
234 * Removes a powerdomain from the internal powerdomain list. Returns
235 * -EINVAL if pwrdm argument is NULL.
237 int pwrdm_unregister(struct powerdomain
*pwrdm
)
244 write_lock_irqsave(&pwrdm_rwlock
, flags
);
245 list_del(&pwrdm
->node
);
246 write_unlock_irqrestore(&pwrdm_rwlock
, flags
);
248 pr_debug("powerdomain: unregistered %s\n", pwrdm
->name
);
254 * pwrdm_lookup - look up a powerdomain by name, return a pointer
255 * @name: name of powerdomain
257 * Find a registered powerdomain by its name. Returns a pointer to the
258 * struct powerdomain if found, or NULL otherwise.
260 struct powerdomain
*pwrdm_lookup(const char *name
)
262 struct powerdomain
*pwrdm
;
268 read_lock_irqsave(&pwrdm_rwlock
, flags
);
269 pwrdm
= _pwrdm_lookup(name
);
270 read_unlock_irqrestore(&pwrdm_rwlock
, flags
);
276 * pwrdm_for_each - call function on each registered clockdomain
277 * @fn: callback function *
279 * Call the supplied function for each registered powerdomain. The
280 * callback function can return anything but 0 to bail out early from
281 * the iterator. The callback function is called with the pwrdm_rwlock
282 * held for reading, so no powerdomain structure manipulation
283 * functions should be called from the callback, although hardware
284 * powerdomain control functions are fine. Returns the last return
285 * value of the callback function, which should be 0 for success or
286 * anything else to indicate failure; or -EINVAL if the function
289 int pwrdm_for_each(int (*fn
)(struct powerdomain
*pwrdm
, void *user
),
292 struct powerdomain
*temp_pwrdm
;
299 read_lock_irqsave(&pwrdm_rwlock
, flags
);
300 list_for_each_entry(temp_pwrdm
, &pwrdm_list
, node
) {
301 ret
= (*fn
)(temp_pwrdm
, user
);
305 read_unlock_irqrestore(&pwrdm_rwlock
, flags
);
311 * pwrdm_add_clkdm - add a clockdomain to a powerdomain
312 * @pwrdm: struct powerdomain * to add the clockdomain to
313 * @clkdm: struct clockdomain * to associate with a powerdomain
315 * Associate the clockdomain 'clkdm' with a powerdomain 'pwrdm'. This
316 * enables the use of pwrdm_for_each_clkdm(). Returns -EINVAL if
317 * presented with invalid pointers; -ENOMEM if memory could not be allocated;
320 int pwrdm_add_clkdm(struct powerdomain
*pwrdm
, struct clockdomain
*clkdm
)
326 if (!pwrdm
|| !clkdm
)
329 pr_debug("powerdomain: associating clockdomain %s with powerdomain "
330 "%s\n", clkdm
->name
, pwrdm
->name
);
332 write_lock_irqsave(&pwrdm_rwlock
, flags
);
334 for (i
= 0; i
< PWRDM_MAX_CLKDMS
; i
++) {
335 if (!pwrdm
->pwrdm_clkdms
[i
])
338 if (pwrdm
->pwrdm_clkdms
[i
] == clkdm
) {
345 if (i
== PWRDM_MAX_CLKDMS
) {
346 pr_debug("powerdomain: increase PWRDM_MAX_CLKDMS for "
347 "pwrdm %s clkdm %s\n", pwrdm
->name
, clkdm
->name
);
353 pwrdm
->pwrdm_clkdms
[i
] = clkdm
;
358 write_unlock_irqrestore(&pwrdm_rwlock
, flags
);
364 * pwrdm_del_clkdm - remove a clockdomain from a powerdomain
365 * @pwrdm: struct powerdomain * to add the clockdomain to
366 * @clkdm: struct clockdomain * to associate with a powerdomain
368 * Dissociate the clockdomain 'clkdm' from the powerdomain
369 * 'pwrdm'. Returns -EINVAL if presented with invalid pointers;
370 * -ENOENT if the clkdm was not associated with the powerdomain, or 0
373 int pwrdm_del_clkdm(struct powerdomain
*pwrdm
, struct clockdomain
*clkdm
)
379 if (!pwrdm
|| !clkdm
)
382 pr_debug("powerdomain: dissociating clockdomain %s from powerdomain "
383 "%s\n", clkdm
->name
, pwrdm
->name
);
385 write_lock_irqsave(&pwrdm_rwlock
, flags
);
387 for (i
= 0; i
< PWRDM_MAX_CLKDMS
; i
++)
388 if (pwrdm
->pwrdm_clkdms
[i
] == clkdm
)
391 if (i
== PWRDM_MAX_CLKDMS
) {
392 pr_debug("powerdomain: clkdm %s not associated with pwrdm "
393 "%s ?!\n", clkdm
->name
, pwrdm
->name
);
398 pwrdm
->pwrdm_clkdms
[i
] = NULL
;
403 write_unlock_irqrestore(&pwrdm_rwlock
, flags
);
409 * pwrdm_for_each_clkdm - call function on each clkdm in a pwrdm
410 * @pwrdm: struct powerdomain * to iterate over
411 * @fn: callback function *
413 * Call the supplied function for each clockdomain in the powerdomain
414 * 'pwrdm'. The callback function can return anything but 0 to bail
415 * out early from the iterator. The callback function is called with
416 * the pwrdm_rwlock held for reading, so no powerdomain structure
417 * manipulation functions should be called from the callback, although
418 * hardware powerdomain control functions are fine. Returns -EINVAL
419 * if presented with invalid pointers; or passes along the last return
420 * value of the callback function, which should be 0 for success or
421 * anything else to indicate failure.
423 int pwrdm_for_each_clkdm(struct powerdomain
*pwrdm
,
424 int (*fn
)(struct powerdomain
*pwrdm
,
425 struct clockdomain
*clkdm
))
434 read_lock_irqsave(&pwrdm_rwlock
, flags
);
436 for (i
= 0; i
< PWRDM_MAX_CLKDMS
&& !ret
; i
++)
437 ret
= (*fn
)(pwrdm
, pwrdm
->pwrdm_clkdms
[i
]);
439 read_unlock_irqrestore(&pwrdm_rwlock
, flags
);
446 * pwrdm_add_wkdep - add a wakeup dependency from pwrdm2 to pwrdm1
447 * @pwrdm1: wake this struct powerdomain * up (dependent)
448 * @pwrdm2: when this struct powerdomain * wakes up (source)
450 * When the powerdomain represented by pwrdm2 wakes up (due to an
451 * interrupt), wake up pwrdm1. Implemented in hardware on the OMAP,
452 * this feature is designed to reduce wakeup latency of the dependent
453 * powerdomain. Returns -EINVAL if presented with invalid powerdomain
454 * pointers, -ENOENT if pwrdm2 cannot wake up pwrdm1 in hardware, or
457 int pwrdm_add_wkdep(struct powerdomain
*pwrdm1
, struct powerdomain
*pwrdm2
)
459 struct powerdomain
*p
;
464 p
= _pwrdm_deps_lookup(pwrdm2
, pwrdm1
->wkdep_srcs
);
466 pr_debug("powerdomain: hardware cannot set/clear wake up of "
467 "%s when %s wakes up\n", pwrdm1
->name
, pwrdm2
->name
);
471 pr_debug("powerdomain: hardware will wake up %s when %s wakes up\n",
472 pwrdm1
->name
, pwrdm2
->name
);
474 prm_set_mod_reg_bits((1 << pwrdm2
->dep_bit
),
475 pwrdm1
->prcm_offs
, PM_WKDEP
);
481 * pwrdm_del_wkdep - remove a wakeup dependency from pwrdm2 to pwrdm1
482 * @pwrdm1: wake this struct powerdomain * up (dependent)
483 * @pwrdm2: when this struct powerdomain * wakes up (source)
485 * Remove a wakeup dependency that causes pwrdm1 to wake up when pwrdm2
486 * wakes up. Returns -EINVAL if presented with invalid powerdomain
487 * pointers, -ENOENT if pwrdm2 cannot wake up pwrdm1 in hardware, or
490 int pwrdm_del_wkdep(struct powerdomain
*pwrdm1
, struct powerdomain
*pwrdm2
)
492 struct powerdomain
*p
;
497 p
= _pwrdm_deps_lookup(pwrdm2
, pwrdm1
->wkdep_srcs
);
499 pr_debug("powerdomain: hardware cannot set/clear wake up of "
500 "%s when %s wakes up\n", pwrdm1
->name
, pwrdm2
->name
);
504 pr_debug("powerdomain: hardware will no longer wake up %s after %s "
505 "wakes up\n", pwrdm1
->name
, pwrdm2
->name
);
507 prm_clear_mod_reg_bits((1 << pwrdm2
->dep_bit
),
508 pwrdm1
->prcm_offs
, PM_WKDEP
);
514 * pwrdm_read_wkdep - read wakeup dependency state from pwrdm2 to pwrdm1
515 * @pwrdm1: wake this struct powerdomain * up (dependent)
516 * @pwrdm2: when this struct powerdomain * wakes up (source)
518 * Return 1 if a hardware wakeup dependency exists wherein pwrdm1 will be
519 * awoken when pwrdm2 wakes up; 0 if dependency is not set; -EINVAL
520 * if either powerdomain pointer is invalid; or -ENOENT if the hardware
523 * REVISIT: Currently this function only represents software-controllable
524 * wakeup dependencies. Wakeup dependencies fixed in hardware are not
527 int pwrdm_read_wkdep(struct powerdomain
*pwrdm1
, struct powerdomain
*pwrdm2
)
529 struct powerdomain
*p
;
534 p
= _pwrdm_deps_lookup(pwrdm2
, pwrdm1
->wkdep_srcs
);
536 pr_debug("powerdomain: hardware cannot set/clear wake up of "
537 "%s when %s wakes up\n", pwrdm1
->name
, pwrdm2
->name
);
541 return prm_read_mod_bits_shift(pwrdm1
->prcm_offs
, PM_WKDEP
,
542 (1 << pwrdm2
->dep_bit
));
546 * pwrdm_add_sleepdep - add a sleep dependency from pwrdm2 to pwrdm1
547 * @pwrdm1: prevent this struct powerdomain * from sleeping (dependent)
548 * @pwrdm2: when this struct powerdomain * is active (source)
550 * Prevent pwrdm1 from automatically going inactive (and then to
551 * retention or off) if pwrdm2 is still active. Returns -EINVAL if
552 * presented with invalid powerdomain pointers or called on a machine
553 * that does not support software-configurable hardware sleep dependencies,
554 * -ENOENT if the specified dependency cannot be set in hardware, or
557 int pwrdm_add_sleepdep(struct powerdomain
*pwrdm1
, struct powerdomain
*pwrdm2
)
559 struct powerdomain
*p
;
564 if (!cpu_is_omap34xx())
567 p
= _pwrdm_deps_lookup(pwrdm2
, pwrdm1
->sleepdep_srcs
);
569 pr_debug("powerdomain: hardware cannot set/clear sleep "
570 "dependency affecting %s from %s\n", pwrdm1
->name
,
575 pr_debug("powerdomain: will prevent %s from sleeping if %s is active\n",
576 pwrdm1
->name
, pwrdm2
->name
);
578 cm_set_mod_reg_bits((1 << pwrdm2
->dep_bit
),
579 pwrdm1
->prcm_offs
, OMAP3430_CM_SLEEPDEP
);
585 * pwrdm_del_sleepdep - remove a sleep dependency from pwrdm2 to pwrdm1
586 * @pwrdm1: prevent this struct powerdomain * from sleeping (dependent)
587 * @pwrdm2: when this struct powerdomain * is active (source)
589 * Allow pwrdm1 to automatically go inactive (and then to retention or
590 * off), independent of the activity state of pwrdm2. Returns -EINVAL
591 * if presented with invalid powerdomain pointers or called on a machine
592 * that does not support software-configurable hardware sleep dependencies,
593 * -ENOENT if the specified dependency cannot be cleared in hardware, or
596 int pwrdm_del_sleepdep(struct powerdomain
*pwrdm1
, struct powerdomain
*pwrdm2
)
598 struct powerdomain
*p
;
603 if (!cpu_is_omap34xx())
606 p
= _pwrdm_deps_lookup(pwrdm2
, pwrdm1
->sleepdep_srcs
);
608 pr_debug("powerdomain: hardware cannot set/clear sleep "
609 "dependency affecting %s from %s\n", pwrdm1
->name
,
614 pr_debug("powerdomain: will no longer prevent %s from sleeping if "
615 "%s is active\n", pwrdm1
->name
, pwrdm2
->name
);
617 cm_clear_mod_reg_bits((1 << pwrdm2
->dep_bit
),
618 pwrdm1
->prcm_offs
, OMAP3430_CM_SLEEPDEP
);
624 * pwrdm_read_sleepdep - read sleep dependency state from pwrdm2 to pwrdm1
625 * @pwrdm1: prevent this struct powerdomain * from sleeping (dependent)
626 * @pwrdm2: when this struct powerdomain * is active (source)
628 * Return 1 if a hardware sleep dependency exists wherein pwrdm1 will
629 * not be allowed to automatically go inactive if pwrdm2 is active;
630 * 0 if pwrdm1's automatic power state inactivity transition is independent
631 * of pwrdm2's; -EINVAL if either powerdomain pointer is invalid or called
632 * on a machine that does not support software-configurable hardware sleep
633 * dependencies; or -ENOENT if the hardware is incapable.
635 * REVISIT: Currently this function only represents software-controllable
636 * sleep dependencies. Sleep dependencies fixed in hardware are not
639 int pwrdm_read_sleepdep(struct powerdomain
*pwrdm1
, struct powerdomain
*pwrdm2
)
641 struct powerdomain
*p
;
646 if (!cpu_is_omap34xx())
649 p
= _pwrdm_deps_lookup(pwrdm2
, pwrdm1
->sleepdep_srcs
);
651 pr_debug("powerdomain: hardware cannot set/clear sleep "
652 "dependency affecting %s from %s\n", pwrdm1
->name
,
657 return prm_read_mod_bits_shift(pwrdm1
->prcm_offs
, OMAP3430_CM_SLEEPDEP
,
658 (1 << pwrdm2
->dep_bit
));
662 * pwrdm_get_mem_bank_count - get number of memory banks in this powerdomain
663 * @pwrdm: struct powerdomain *
665 * Return the number of controllable memory banks in powerdomain pwrdm,
666 * starting with 1. Returns -EINVAL if the powerdomain pointer is null.
668 int pwrdm_get_mem_bank_count(struct powerdomain
*pwrdm
)
677 * pwrdm_set_next_pwrst - set next powerdomain power state
678 * @pwrdm: struct powerdomain * to set
679 * @pwrst: one of the PWRDM_POWER_* macros
681 * Set the powerdomain pwrdm's next power state to pwrst. The powerdomain
682 * may not enter this state immediately if the preconditions for this state
683 * have not been satisfied. Returns -EINVAL if the powerdomain pointer is
684 * null or if the power state is invalid for the powerdomin, or returns 0
687 int pwrdm_set_next_pwrst(struct powerdomain
*pwrdm
, u8 pwrst
)
692 if (!(pwrdm
->pwrsts
& (1 << pwrst
)))
695 pr_debug("powerdomain: setting next powerstate for %s to %0x\n",
698 prm_rmw_mod_reg_bits(OMAP_POWERSTATE_MASK
,
699 (pwrst
<< OMAP_POWERSTATE_SHIFT
),
700 pwrdm
->prcm_offs
, PM_PWSTCTRL
);
706 * pwrdm_read_next_pwrst - get next powerdomain power state
707 * @pwrdm: struct powerdomain * to get power state
709 * Return the powerdomain pwrdm's next power state. Returns -EINVAL
710 * if the powerdomain pointer is null or returns the next power state
713 int pwrdm_read_next_pwrst(struct powerdomain
*pwrdm
)
718 return prm_read_mod_bits_shift(pwrdm
->prcm_offs
, PM_PWSTCTRL
,
719 OMAP_POWERSTATE_MASK
);
723 * pwrdm_read_pwrst - get current powerdomain power state
724 * @pwrdm: struct powerdomain * to get power state
726 * Return the powerdomain pwrdm's current power state. Returns -EINVAL
727 * if the powerdomain pointer is null or returns the current power state
730 int pwrdm_read_pwrst(struct powerdomain
*pwrdm
)
735 return prm_read_mod_bits_shift(pwrdm
->prcm_offs
, PM_PWSTST
,
736 OMAP_POWERSTATEST_MASK
);
740 * pwrdm_read_prev_pwrst - get previous powerdomain power state
741 * @pwrdm: struct powerdomain * to get previous power state
743 * Return the powerdomain pwrdm's previous power state. Returns -EINVAL
744 * if the powerdomain pointer is null or returns the previous power state
747 int pwrdm_read_prev_pwrst(struct powerdomain
*pwrdm
)
752 return prm_read_mod_bits_shift(pwrdm
->prcm_offs
, OMAP3430_PM_PREPWSTST
,
753 OMAP3430_LASTPOWERSTATEENTERED_MASK
);
757 * pwrdm_set_logic_retst - set powerdomain logic power state upon retention
758 * @pwrdm: struct powerdomain * to set
759 * @pwrst: one of the PWRDM_POWER_* macros
761 * Set the next power state that the logic portion of the powerdomain
762 * pwrdm will enter when the powerdomain enters retention. This will
763 * be either RETENTION or OFF, if supported. Returns -EINVAL if the
764 * powerdomain pointer is null or the target power state is not not
765 * supported, or returns 0 upon success.
767 int pwrdm_set_logic_retst(struct powerdomain
*pwrdm
, u8 pwrst
)
772 if (!(pwrdm
->pwrsts_logic_ret
& (1 << pwrst
)))
775 pr_debug("powerdomain: setting next logic powerstate for %s to %0x\n",
779 * The register bit names below may not correspond to the
780 * actual names of the bits in each powerdomain's register,
781 * but the type of value returned is the same for each
784 prm_rmw_mod_reg_bits(OMAP3430_LOGICL1CACHERETSTATE
,
785 (pwrst
<< __ffs(OMAP3430_LOGICL1CACHERETSTATE
)),
786 pwrdm
->prcm_offs
, PM_PWSTCTRL
);
792 * pwrdm_set_mem_onst - set memory power state while powerdomain ON
793 * @pwrdm: struct powerdomain * to set
794 * @bank: memory bank number to set (0-3)
795 * @pwrst: one of the PWRDM_POWER_* macros
797 * Set the next power state that memory bank x of the powerdomain
798 * pwrdm will enter when the powerdomain enters the ON state. Bank
799 * will be a number from 0 to 3, and represents different types of
800 * memory, depending on the powerdomain. Returns -EINVAL if the
801 * powerdomain pointer is null or the target power state is not not
802 * supported for this memory bank, -EEXIST if the target memory bank
803 * does not exist or is not controllable, or returns 0 upon success.
805 int pwrdm_set_mem_onst(struct powerdomain
*pwrdm
, u8 bank
, u8 pwrst
)
812 if (pwrdm
->banks
< (bank
+ 1))
815 if (!(pwrdm
->pwrsts_mem_on
[bank
] & (1 << pwrst
)))
818 pr_debug("powerdomain: setting next memory powerstate for domain %s "
819 "bank %0x while pwrdm-ON to %0x\n", pwrdm
->name
, bank
, pwrst
);
822 * The register bit names below may not correspond to the
823 * actual names of the bits in each powerdomain's register,
824 * but the type of value returned is the same for each
829 m
= OMAP3430_SHAREDL1CACHEFLATONSTATE_MASK
;
832 m
= OMAP3430_L1FLATMEMONSTATE_MASK
;
835 m
= OMAP3430_SHAREDL2CACHEFLATONSTATE_MASK
;
838 m
= OMAP3430_L2FLATMEMONSTATE_MASK
;
841 WARN_ON(1); /* should never happen */
845 prm_rmw_mod_reg_bits(m
, (pwrst
<< __ffs(m
)),
846 pwrdm
->prcm_offs
, PM_PWSTCTRL
);
852 * pwrdm_set_mem_retst - set memory power state while powerdomain in RET
853 * @pwrdm: struct powerdomain * to set
854 * @bank: memory bank number to set (0-3)
855 * @pwrst: one of the PWRDM_POWER_* macros
857 * Set the next power state that memory bank x of the powerdomain
858 * pwrdm will enter when the powerdomain enters the RETENTION state.
859 * Bank will be a number from 0 to 3, and represents different types
860 * of memory, depending on the powerdomain. pwrst will be either
861 * RETENTION or OFF, if supported. Returns -EINVAL if the powerdomain
862 * pointer is null or the target power state is not not supported for
863 * this memory bank, -EEXIST if the target memory bank does not exist
864 * or is not controllable, or returns 0 upon success.
866 int pwrdm_set_mem_retst(struct powerdomain
*pwrdm
, u8 bank
, u8 pwrst
)
873 if (pwrdm
->banks
< (bank
+ 1))
876 if (!(pwrdm
->pwrsts_mem_ret
[bank
] & (1 << pwrst
)))
879 pr_debug("powerdomain: setting next memory powerstate for domain %s "
880 "bank %0x while pwrdm-RET to %0x\n", pwrdm
->name
, bank
, pwrst
);
883 * The register bit names below may not correspond to the
884 * actual names of the bits in each powerdomain's register,
885 * but the type of value returned is the same for each
890 m
= OMAP3430_SHAREDL1CACHEFLATRETSTATE
;
893 m
= OMAP3430_L1FLATMEMRETSTATE
;
896 m
= OMAP3430_SHAREDL2CACHEFLATRETSTATE
;
899 m
= OMAP3430_L2FLATMEMRETSTATE
;
902 WARN_ON(1); /* should never happen */
906 prm_rmw_mod_reg_bits(m
, (pwrst
<< __ffs(m
)), pwrdm
->prcm_offs
,
913 * pwrdm_read_logic_pwrst - get current powerdomain logic retention power state
914 * @pwrdm: struct powerdomain * to get current logic retention power state
916 * Return the current power state that the logic portion of
917 * powerdomain pwrdm will enter
918 * Returns -EINVAL if the powerdomain pointer is null or returns the
919 * current logic retention power state upon success.
921 int pwrdm_read_logic_pwrst(struct powerdomain
*pwrdm
)
926 return prm_read_mod_bits_shift(pwrdm
->prcm_offs
, PM_PWSTST
,
927 OMAP3430_LOGICSTATEST
);
931 * pwrdm_read_prev_logic_pwrst - get previous powerdomain logic power state
932 * @pwrdm: struct powerdomain * to get previous logic power state
934 * Return the powerdomain pwrdm's logic power state. Returns -EINVAL
935 * if the powerdomain pointer is null or returns the previous logic
936 * power state upon success.
938 int pwrdm_read_prev_logic_pwrst(struct powerdomain
*pwrdm
)
944 * The register bit names below may not correspond to the
945 * actual names of the bits in each powerdomain's register,
946 * but the type of value returned is the same for each
949 return prm_read_mod_bits_shift(pwrdm
->prcm_offs
, OMAP3430_PM_PREPWSTST
,
950 OMAP3430_LASTLOGICSTATEENTERED
);
954 * pwrdm_read_mem_pwrst - get current memory bank power state
955 * @pwrdm: struct powerdomain * to get current memory bank power state
956 * @bank: memory bank number (0-3)
958 * Return the powerdomain pwrdm's current memory power state for bank
959 * x. Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
960 * the target memory bank does not exist or is not controllable, or
961 * returns the current memory power state upon success.
963 int pwrdm_read_mem_pwrst(struct powerdomain
*pwrdm
, u8 bank
)
970 if (pwrdm
->banks
< (bank
+ 1))
974 * The register bit names below may not correspond to the
975 * actual names of the bits in each powerdomain's register,
976 * but the type of value returned is the same for each
981 m
= OMAP3430_SHAREDL1CACHEFLATSTATEST_MASK
;
984 m
= OMAP3430_L1FLATMEMSTATEST_MASK
;
987 m
= OMAP3430_SHAREDL2CACHEFLATSTATEST_MASK
;
990 m
= OMAP3430_L2FLATMEMSTATEST_MASK
;
993 WARN_ON(1); /* should never happen */
997 return prm_read_mod_bits_shift(pwrdm
->prcm_offs
, PM_PWSTST
, m
);
1001 * pwrdm_read_prev_mem_pwrst - get previous memory bank power state
1002 * @pwrdm: struct powerdomain * to get previous memory bank power state
1003 * @bank: memory bank number (0-3)
1005 * Return the powerdomain pwrdm's previous memory power state for bank
1006 * x. Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
1007 * the target memory bank does not exist or is not controllable, or
1008 * returns the previous memory power state upon success.
1010 int pwrdm_read_prev_mem_pwrst(struct powerdomain
*pwrdm
, u8 bank
)
1017 if (pwrdm
->banks
< (bank
+ 1))
1021 * The register bit names below may not correspond to the
1022 * actual names of the bits in each powerdomain's register,
1023 * but the type of value returned is the same for each
1028 m
= OMAP3430_LASTMEM1STATEENTERED_MASK
;
1031 m
= OMAP3430_LASTMEM2STATEENTERED_MASK
;
1034 m
= OMAP3430_LASTSHAREDL2CACHEFLATSTATEENTERED_MASK
;
1037 m
= OMAP3430_LASTL2FLATMEMSTATEENTERED_MASK
;
1040 WARN_ON(1); /* should never happen */
1044 return prm_read_mod_bits_shift(pwrdm
->prcm_offs
,
1045 OMAP3430_PM_PREPWSTST
, m
);
1049 * pwrdm_clear_all_prev_pwrst - clear previous powerstate register for a pwrdm
1050 * @pwrdm: struct powerdomain * to clear
1052 * Clear the powerdomain's previous power state register. Clears the
1053 * entire register, including logic and memory bank previous power states.
1054 * Returns -EINVAL if the powerdomain pointer is null, or returns 0 upon
1057 int pwrdm_clear_all_prev_pwrst(struct powerdomain
*pwrdm
)
1063 * XXX should get the powerdomain's current state here;
1064 * warn & fail if it is not ON.
1067 pr_debug("powerdomain: clearing previous power state reg for %s\n",
1070 prm_write_mod_reg(0, pwrdm
->prcm_offs
, OMAP3430_PM_PREPWSTST
);
1076 * pwrdm_enable_hdwr_sar - enable automatic hardware SAR for a pwrdm
1077 * @pwrdm: struct powerdomain *
1079 * Enable automatic context save-and-restore upon power state change
1080 * for some devices in a powerdomain. Warning: this only affects a
1081 * subset of devices in a powerdomain; check the TRM closely. Returns
1082 * -EINVAL if the powerdomain pointer is null or if the powerdomain
1083 * does not support automatic save-and-restore, or returns 0 upon
1086 int pwrdm_enable_hdwr_sar(struct powerdomain
*pwrdm
)
1091 if (!(pwrdm
->flags
& PWRDM_HAS_HDWR_SAR
))
1094 pr_debug("powerdomain: %s: setting SAVEANDRESTORE bit\n",
1097 prm_rmw_mod_reg_bits(0, 1 << OMAP3430ES2_SAVEANDRESTORE_SHIFT
,
1098 pwrdm
->prcm_offs
, PM_PWSTCTRL
);
1104 * pwrdm_disable_hdwr_sar - disable automatic hardware SAR for a pwrdm
1105 * @pwrdm: struct powerdomain *
1107 * Disable automatic context save-and-restore upon power state change
1108 * for some devices in a powerdomain. Warning: this only affects a
1109 * subset of devices in a powerdomain; check the TRM closely. Returns
1110 * -EINVAL if the powerdomain pointer is null or if the powerdomain
1111 * does not support automatic save-and-restore, or returns 0 upon
1114 int pwrdm_disable_hdwr_sar(struct powerdomain
*pwrdm
)
1119 if (!(pwrdm
->flags
& PWRDM_HAS_HDWR_SAR
))
1122 pr_debug("powerdomain: %s: clearing SAVEANDRESTORE bit\n",
1125 prm_rmw_mod_reg_bits(1 << OMAP3430ES2_SAVEANDRESTORE_SHIFT
, 0,
1126 pwrdm
->prcm_offs
, PM_PWSTCTRL
);
1132 * pwrdm_has_hdwr_sar - test whether powerdomain supports hardware SAR
1133 * @pwrdm: struct powerdomain *
1135 * Returns 1 if powerdomain 'pwrdm' supports hardware save-and-restore
1136 * for some devices, or 0 if it does not.
1138 bool pwrdm_has_hdwr_sar(struct powerdomain
*pwrdm
)
1140 return (pwrdm
&& pwrdm
->flags
& PWRDM_HAS_HDWR_SAR
) ? 1 : 0;
1144 * pwrdm_wait_transition - wait for powerdomain power transition to finish
1145 * @pwrdm: struct powerdomain * to wait for
1147 * If the powerdomain pwrdm is in the process of a state transition,
1148 * spin until it completes the power transition, or until an iteration
1149 * bailout value is reached. Returns -EINVAL if the powerdomain
1150 * pointer is null, -EAGAIN if the bailout value was reached, or
1151 * returns 0 upon success.
1153 int pwrdm_wait_transition(struct powerdomain
*pwrdm
)
1161 * REVISIT: pwrdm_wait_transition() may be better implemented
1162 * via a callback and a periodic timer check -- how long do we expect
1163 * powerdomain transitions to take?
1166 /* XXX Is this udelay() value meaningful? */
1167 while ((prm_read_mod_reg(pwrdm
->prcm_offs
, PM_PWSTST
) &
1168 OMAP_INTRANSITION
) &&
1169 (c
++ < PWRDM_TRANSITION_BAILOUT
))
1172 if (c
> PWRDM_TRANSITION_BAILOUT
) {
1173 printk(KERN_ERR
"powerdomain: waited too long for "
1174 "powerdomain %s to complete transition\n", pwrdm
->name
);
1178 pr_debug("powerdomain: completed transition in %d loops\n", c
);
1183 int pwrdm_state_switch(struct powerdomain
*pwrdm
)
1185 return _pwrdm_state_switch(pwrdm
, PWRDM_STATE_NOW
);
1188 int pwrdm_clkdm_state_switch(struct clockdomain
*clkdm
)
1190 if (clkdm
!= NULL
&& clkdm
->pwrdm
.ptr
!= NULL
) {
1191 pwrdm_wait_transition(clkdm
->pwrdm
.ptr
);
1192 return pwrdm_state_switch(clkdm
->pwrdm
.ptr
);
1197 int pwrdm_clk_state_switch(struct clk
*clk
)
1199 if (clk
!= NULL
&& clk
->clkdm
!= NULL
)
1200 return pwrdm_clkdm_state_switch(clk
->clkdm
);
1204 int pwrdm_pre_transition(void)
1206 pwrdm_for_each(_pwrdm_pre_transition_cb
, NULL
);
1210 int pwrdm_post_transition(void)
1212 pwrdm_for_each(_pwrdm_post_transition_cb
, NULL
);