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.
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/delay.h>
19 #include <linux/spinlock.h>
20 #include <linux/list.h>
21 #include <linux/errno.h>
22 #include <linux/err.h>
25 #include <asm/atomic.h>
28 #include "cm-regbits-34xx.h"
30 #include "prm-regbits-34xx.h"
33 #include <plat/powerdomain.h>
34 #include <plat/clockdomain.h>
43 /* pwrdm_list contains all registered struct powerdomains */
44 static LIST_HEAD(pwrdm_list);
47 * pwrdm_rwlock protects pwrdm_list add and del ops - also reused to
48 * protect pwrdm_clkdms[] during clkdm add/del ops
50 static DEFINE_RWLOCK(pwrdm_rwlock);
53 /* Private functions */
55 static u32 prm_read_mod_bits_shift(s16 domain, s16 idx, u32 mask)
59 v = prm_read_mod_reg(domain, idx);
66 static struct powerdomain *_pwrdm_lookup(const char *name)
68 struct powerdomain *pwrdm, *temp_pwrdm;
72 list_for_each_entry(temp_pwrdm, &pwrdm_list, node) {
73 if (!strcmp(name, temp_pwrdm->name)) {
82 /* _pwrdm_deps_lookup - look up the specified powerdomain in a pwrdm list */
83 static struct powerdomain *_pwrdm_deps_lookup(struct powerdomain *pwrdm,
84 struct pwrdm_dep *deps)
88 if (!pwrdm || !deps || !omap_chip_is(pwrdm->omap_chip))
89 return ERR_PTR(-EINVAL);
91 for (pd = deps; pd->pwrdm_name; pd++) {
93 if (!omap_chip_is(pd->omap_chip))
96 if (!pd->pwrdm && pd->pwrdm_name)
97 pd->pwrdm = pwrdm_lookup(pd->pwrdm_name);
99 if (pd->pwrdm == pwrdm)
105 return ERR_PTR(-ENOENT);
110 static int _pwrdm_state_switch(struct powerdomain *pwrdm, int flag)
119 state = pwrdm_read_pwrst(pwrdm);
122 case PWRDM_STATE_NOW:
125 case PWRDM_STATE_PREV:
126 prev = pwrdm_read_prev_pwrst(pwrdm);
127 if (pwrdm->state != prev)
128 pwrdm->state_counter[prev]++;
135 pwrdm->state_counter[state]++;
137 pm_dbg_update_time(pwrdm, prev);
139 pwrdm->state = state;
144 static int _pwrdm_pre_transition_cb(struct powerdomain *pwrdm, void *unused)
146 pwrdm_clear_all_prev_pwrst(pwrdm);
147 _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
151 static int _pwrdm_post_transition_cb(struct powerdomain *pwrdm, void *unused)
153 _pwrdm_state_switch(pwrdm, PWRDM_STATE_PREV);
157 static __init void _pwrdm_setup(struct powerdomain *pwrdm)
161 for (i = 0; i < PWRDM_MAX_PWRSTS; i++)
162 pwrdm->state_counter[i] = 0;
164 pwrdm_wait_transition(pwrdm);
165 pwrdm->state = pwrdm_read_pwrst(pwrdm);
166 pwrdm->state_counter[pwrdm->state] = 1;
170 /* Public functions */
173 * pwrdm_init - set up the powerdomain layer
175 * Loop through the list of powerdomains, registering all that are
176 * available on the current CPU. If pwrdm_list is supplied and not
177 * null, all of the referenced powerdomains will be registered. No
180 void pwrdm_init(struct powerdomain **pwrdm_list)
182 struct powerdomain **p = NULL;
185 for (p = pwrdm_list; *p; p++) {
193 * pwrdm_register - register a powerdomain
194 * @pwrdm: struct powerdomain * to register
196 * Adds a powerdomain to the internal powerdomain list. Returns
197 * -EINVAL if given a null pointer, -EEXIST if a powerdomain is
198 * already registered by the provided name, or 0 upon success.
200 int pwrdm_register(struct powerdomain *pwrdm)
208 if (!omap_chip_is(pwrdm->omap_chip))
211 write_lock_irqsave(&pwrdm_rwlock, flags);
212 if (_pwrdm_lookup(pwrdm->name)) {
217 list_add(&pwrdm->node, &pwrdm_list);
219 pr_debug("powerdomain: registered %s\n", pwrdm->name);
223 write_unlock_irqrestore(&pwrdm_rwlock, flags);
229 * pwrdm_unregister - unregister a powerdomain
230 * @pwrdm: struct powerdomain * to unregister
232 * Removes a powerdomain from the internal powerdomain list. Returns
233 * -EINVAL if pwrdm argument is NULL.
235 int pwrdm_unregister(struct powerdomain *pwrdm)
242 write_lock_irqsave(&pwrdm_rwlock, flags);
243 list_del(&pwrdm->node);
244 write_unlock_irqrestore(&pwrdm_rwlock, flags);
246 pr_debug("powerdomain: unregistered %s\n", pwrdm->name);
252 * pwrdm_lookup - look up a powerdomain by name, return a pointer
253 * @name: name of powerdomain
255 * Find a registered powerdomain by its name. Returns a pointer to the
256 * struct powerdomain if found, or NULL otherwise.
258 struct powerdomain *pwrdm_lookup(const char *name)
260 struct powerdomain *pwrdm;
266 read_lock_irqsave(&pwrdm_rwlock, flags);
267 pwrdm = _pwrdm_lookup(name);
268 read_unlock_irqrestore(&pwrdm_rwlock, flags);
274 * pwrdm_for_each_nolock - call function on each registered clockdomain
275 * @fn: callback function *
277 * Call the supplied function for each registered powerdomain. The
278 * callback function can return anything but 0 to bail out early from
279 * the iterator. Returns the last return value of the callback function, which
280 * should be 0 for success or anything else to indicate failure; or -EINVAL if
281 * the function pointer is null.
283 int pwrdm_for_each_nolock(int (*fn)(struct powerdomain *pwrdm, void *user),
286 struct powerdomain *temp_pwrdm;
292 list_for_each_entry(temp_pwrdm, &pwrdm_list, node) {
293 ret = (*fn)(temp_pwrdm, user);
302 * pwrdm_for_each - call function on each registered clockdomain
303 * @fn: callback function *
305 * This function is the same as 'pwrdm_for_each_nolock()', but keeps the
306 * &pwrdm_rwlock locked for reading, so no powerdomain structure manipulation
307 * functions should be called from the callback, although hardware powerdomain
308 * control functions are fine.
310 int pwrdm_for_each(int (*fn)(struct powerdomain *pwrdm, void *user),
316 read_lock_irqsave(&pwrdm_rwlock, flags);
317 ret = pwrdm_for_each_nolock(fn, user);
318 read_unlock_irqrestore(&pwrdm_rwlock, flags);
324 * pwrdm_add_clkdm - add a clockdomain to a powerdomain
325 * @pwrdm: struct powerdomain * to add the clockdomain to
326 * @clkdm: struct clockdomain * to associate with a powerdomain
328 * Associate the clockdomain 'clkdm' with a powerdomain 'pwrdm'. This
329 * enables the use of pwrdm_for_each_clkdm(). Returns -EINVAL if
330 * presented with invalid pointers; -ENOMEM if memory could not be allocated;
333 int pwrdm_add_clkdm(struct powerdomain *pwrdm, struct clockdomain *clkdm)
339 if (!pwrdm || !clkdm)
342 pr_debug("powerdomain: associating clockdomain %s with powerdomain "
343 "%s\n", clkdm->name, pwrdm->name);
345 write_lock_irqsave(&pwrdm_rwlock, flags);
347 for (i = 0; i < PWRDM_MAX_CLKDMS; i++) {
348 if (!pwrdm->pwrdm_clkdms[i])
351 if (pwrdm->pwrdm_clkdms[i] == clkdm) {
358 if (i == PWRDM_MAX_CLKDMS) {
359 pr_debug("powerdomain: increase PWRDM_MAX_CLKDMS for "
360 "pwrdm %s clkdm %s\n", pwrdm->name, clkdm->name);
366 pwrdm->pwrdm_clkdms[i] = clkdm;
371 write_unlock_irqrestore(&pwrdm_rwlock, flags);
377 * pwrdm_del_clkdm - remove a clockdomain from a powerdomain
378 * @pwrdm: struct powerdomain * to add the clockdomain to
379 * @clkdm: struct clockdomain * to associate with a powerdomain
381 * Dissociate the clockdomain 'clkdm' from the powerdomain
382 * 'pwrdm'. Returns -EINVAL if presented with invalid pointers;
383 * -ENOENT if the clkdm was not associated with the powerdomain, or 0
386 int pwrdm_del_clkdm(struct powerdomain *pwrdm, struct clockdomain *clkdm)
392 if (!pwrdm || !clkdm)
395 pr_debug("powerdomain: dissociating clockdomain %s from powerdomain "
396 "%s\n", clkdm->name, pwrdm->name);
398 write_lock_irqsave(&pwrdm_rwlock, flags);
400 for (i = 0; i < PWRDM_MAX_CLKDMS; i++)
401 if (pwrdm->pwrdm_clkdms[i] == clkdm)
404 if (i == PWRDM_MAX_CLKDMS) {
405 pr_debug("powerdomain: clkdm %s not associated with pwrdm "
406 "%s ?!\n", clkdm->name, pwrdm->name);
411 pwrdm->pwrdm_clkdms[i] = NULL;
416 write_unlock_irqrestore(&pwrdm_rwlock, flags);
422 * pwrdm_for_each_clkdm - call function on each clkdm in a pwrdm
423 * @pwrdm: struct powerdomain * to iterate over
424 * @fn: callback function *
426 * Call the supplied function for each clockdomain in the powerdomain
427 * 'pwrdm'. The callback function can return anything but 0 to bail
428 * out early from the iterator. The callback function is called with
429 * the pwrdm_rwlock held for reading, so no powerdomain structure
430 * manipulation functions should be called from the callback, although
431 * hardware powerdomain control functions are fine. Returns -EINVAL
432 * if presented with invalid pointers; or passes along the last return
433 * value of the callback function, which should be 0 for success or
434 * anything else to indicate failure.
436 int pwrdm_for_each_clkdm(struct powerdomain *pwrdm,
437 int (*fn)(struct powerdomain *pwrdm,
438 struct clockdomain *clkdm))
447 read_lock_irqsave(&pwrdm_rwlock, flags);
449 for (i = 0; i < PWRDM_MAX_CLKDMS && !ret; i++)
450 ret = (*fn)(pwrdm, pwrdm->pwrdm_clkdms[i]);
452 read_unlock_irqrestore(&pwrdm_rwlock, flags);
459 * pwrdm_add_wkdep - add a wakeup dependency from pwrdm2 to pwrdm1
460 * @pwrdm1: wake this struct powerdomain * up (dependent)
461 * @pwrdm2: when this struct powerdomain * wakes up (source)
463 * When the powerdomain represented by pwrdm2 wakes up (due to an
464 * interrupt), wake up pwrdm1. Implemented in hardware on the OMAP,
465 * this feature is designed to reduce wakeup latency of the dependent
466 * powerdomain. Returns -EINVAL if presented with invalid powerdomain
467 * pointers, -ENOENT if pwrdm2 cannot wake up pwrdm1 in hardware, or
470 int pwrdm_add_wkdep(struct powerdomain *pwrdm1, struct powerdomain *pwrdm2)
472 struct powerdomain *p;
477 p = _pwrdm_deps_lookup(pwrdm2, pwrdm1->wkdep_srcs);
479 pr_debug("powerdomain: hardware cannot set/clear wake up of "
480 "%s when %s wakes up\n", pwrdm1->name, pwrdm2->name);
484 pr_debug("powerdomain: hardware will wake up %s when %s wakes up\n",
485 pwrdm1->name, pwrdm2->name);
487 prm_set_mod_reg_bits((1 << pwrdm2->dep_bit),
488 pwrdm1->prcm_offs, PM_WKDEP);
494 * pwrdm_del_wkdep - remove a wakeup dependency from pwrdm2 to pwrdm1
495 * @pwrdm1: wake this struct powerdomain * up (dependent)
496 * @pwrdm2: when this struct powerdomain * wakes up (source)
498 * Remove a wakeup dependency that causes pwrdm1 to wake up when pwrdm2
499 * wakes up. Returns -EINVAL if presented with invalid powerdomain
500 * pointers, -ENOENT if pwrdm2 cannot wake up pwrdm1 in hardware, or
503 int pwrdm_del_wkdep(struct powerdomain *pwrdm1, struct powerdomain *pwrdm2)
505 struct powerdomain *p;
510 p = _pwrdm_deps_lookup(pwrdm2, pwrdm1->wkdep_srcs);
512 pr_debug("powerdomain: hardware cannot set/clear wake up of "
513 "%s when %s wakes up\n", pwrdm1->name, pwrdm2->name);
517 pr_debug("powerdomain: hardware will no longer wake up %s after %s "
518 "wakes up\n", pwrdm1->name, pwrdm2->name);
520 prm_clear_mod_reg_bits((1 << pwrdm2->dep_bit),
521 pwrdm1->prcm_offs, PM_WKDEP);
527 * pwrdm_read_wkdep - read wakeup dependency state from pwrdm2 to pwrdm1
528 * @pwrdm1: wake this struct powerdomain * up (dependent)
529 * @pwrdm2: when this struct powerdomain * wakes up (source)
531 * Return 1 if a hardware wakeup dependency exists wherein pwrdm1 will be
532 * awoken when pwrdm2 wakes up; 0 if dependency is not set; -EINVAL
533 * if either powerdomain pointer is invalid; or -ENOENT if the hardware
536 * REVISIT: Currently this function only represents software-controllable
537 * wakeup dependencies. Wakeup dependencies fixed in hardware are not
540 int pwrdm_read_wkdep(struct powerdomain *pwrdm1, struct powerdomain *pwrdm2)
542 struct powerdomain *p;
547 p = _pwrdm_deps_lookup(pwrdm2, pwrdm1->wkdep_srcs);
549 pr_debug("powerdomain: hardware cannot set/clear wake up of "
550 "%s when %s wakes up\n", pwrdm1->name, pwrdm2->name);
554 return prm_read_mod_bits_shift(pwrdm1->prcm_offs, PM_WKDEP,
555 (1 << pwrdm2->dep_bit));
559 * pwrdm_add_sleepdep - add a sleep dependency from pwrdm2 to pwrdm1
560 * @pwrdm1: prevent this struct powerdomain * from sleeping (dependent)
561 * @pwrdm2: when this struct powerdomain * is active (source)
563 * Prevent pwrdm1 from automatically going inactive (and then to
564 * retention or off) if pwrdm2 is still active. Returns -EINVAL if
565 * presented with invalid powerdomain pointers or called on a machine
566 * that does not support software-configurable hardware sleep dependencies,
567 * -ENOENT if the specified dependency cannot be set in hardware, or
570 int pwrdm_add_sleepdep(struct powerdomain *pwrdm1, struct powerdomain *pwrdm2)
572 struct powerdomain *p;
574 if (!cpu_is_omap34xx())
580 p = _pwrdm_deps_lookup(pwrdm2, pwrdm1->sleepdep_srcs);
582 pr_debug("powerdomain: hardware cannot set/clear sleep "
583 "dependency affecting %s from %s\n", pwrdm1->name,
588 pr_debug("powerdomain: will prevent %s from sleeping if %s is active\n",
589 pwrdm1->name, pwrdm2->name);
591 cm_set_mod_reg_bits((1 << pwrdm2->dep_bit),
592 pwrdm1->prcm_offs, OMAP3430_CM_SLEEPDEP);
598 * pwrdm_del_sleepdep - remove a sleep dependency from pwrdm2 to pwrdm1
599 * @pwrdm1: prevent this struct powerdomain * from sleeping (dependent)
600 * @pwrdm2: when this struct powerdomain * is active (source)
602 * Allow pwrdm1 to automatically go inactive (and then to retention or
603 * off), independent of the activity state of pwrdm2. Returns -EINVAL
604 * if presented with invalid powerdomain pointers or called on a machine
605 * that does not support software-configurable hardware sleep dependencies,
606 * -ENOENT if the specified dependency cannot be cleared in hardware, or
609 int pwrdm_del_sleepdep(struct powerdomain *pwrdm1, struct powerdomain *pwrdm2)
611 struct powerdomain *p;
613 if (!cpu_is_omap34xx())
619 p = _pwrdm_deps_lookup(pwrdm2, pwrdm1->sleepdep_srcs);
621 pr_debug("powerdomain: hardware cannot set/clear sleep "
622 "dependency affecting %s from %s\n", pwrdm1->name,
627 pr_debug("powerdomain: will no longer prevent %s from sleeping if "
628 "%s is active\n", pwrdm1->name, pwrdm2->name);
630 cm_clear_mod_reg_bits((1 << pwrdm2->dep_bit),
631 pwrdm1->prcm_offs, OMAP3430_CM_SLEEPDEP);
637 * pwrdm_read_sleepdep - read sleep dependency state from pwrdm2 to pwrdm1
638 * @pwrdm1: prevent this struct powerdomain * from sleeping (dependent)
639 * @pwrdm2: when this struct powerdomain * is active (source)
641 * Return 1 if a hardware sleep dependency exists wherein pwrdm1 will
642 * not be allowed to automatically go inactive if pwrdm2 is active;
643 * 0 if pwrdm1's automatic power state inactivity transition is independent
644 * of pwrdm2's; -EINVAL if either powerdomain pointer is invalid or called
645 * on a machine that does not support software-configurable hardware sleep
646 * dependencies; or -ENOENT if the hardware is incapable.
648 * REVISIT: Currently this function only represents software-controllable
649 * sleep dependencies. Sleep dependencies fixed in hardware are not
652 int pwrdm_read_sleepdep(struct powerdomain *pwrdm1, struct powerdomain *pwrdm2)
654 struct powerdomain *p;
656 if (!cpu_is_omap34xx())
662 p = _pwrdm_deps_lookup(pwrdm2, pwrdm1->sleepdep_srcs);
664 pr_debug("powerdomain: hardware cannot set/clear sleep "
665 "dependency affecting %s from %s\n", pwrdm1->name,
670 return prm_read_mod_bits_shift(pwrdm1->prcm_offs, OMAP3430_CM_SLEEPDEP,
671 (1 << pwrdm2->dep_bit));
675 * pwrdm_get_mem_bank_count - get number of memory banks in this powerdomain
676 * @pwrdm: struct powerdomain *
678 * Return the number of controllable memory banks in powerdomain pwrdm,
679 * starting with 1. Returns -EINVAL if the powerdomain pointer is null.
681 int pwrdm_get_mem_bank_count(struct powerdomain *pwrdm)
690 * pwrdm_set_next_pwrst - set next powerdomain power state
691 * @pwrdm: struct powerdomain * to set
692 * @pwrst: one of the PWRDM_POWER_* macros
694 * Set the powerdomain pwrdm's next power state to pwrst. The powerdomain
695 * may not enter this state immediately if the preconditions for this state
696 * have not been satisfied. Returns -EINVAL if the powerdomain pointer is
697 * null or if the power state is invalid for the powerdomin, or returns 0
700 int pwrdm_set_next_pwrst(struct powerdomain *pwrdm, u8 pwrst)
705 if (!(pwrdm->pwrsts & (1 << pwrst)))
708 pr_debug("powerdomain: setting next powerstate for %s to %0x\n",
711 prm_rmw_mod_reg_bits(OMAP_POWERSTATE_MASK,
712 (pwrst << OMAP_POWERSTATE_SHIFT),
713 pwrdm->prcm_offs, PM_PWSTCTRL);
719 * pwrdm_read_next_pwrst - get next powerdomain power state
720 * @pwrdm: struct powerdomain * to get power state
722 * Return the powerdomain pwrdm's next power state. Returns -EINVAL
723 * if the powerdomain pointer is null or returns the next power state
726 int pwrdm_read_next_pwrst(struct powerdomain *pwrdm)
731 return prm_read_mod_bits_shift(pwrdm->prcm_offs, PM_PWSTCTRL,
732 OMAP_POWERSTATE_MASK);
736 * pwrdm_read_pwrst - get current powerdomain power state
737 * @pwrdm: struct powerdomain * to get power state
739 * Return the powerdomain pwrdm's current power state. Returns -EINVAL
740 * if the powerdomain pointer is null or returns the current power state
743 int pwrdm_read_pwrst(struct powerdomain *pwrdm)
748 return prm_read_mod_bits_shift(pwrdm->prcm_offs, PM_PWSTST,
749 OMAP_POWERSTATEST_MASK);
753 * pwrdm_read_prev_pwrst - get previous powerdomain power state
754 * @pwrdm: struct powerdomain * to get previous power state
756 * Return the powerdomain pwrdm's previous power state. Returns -EINVAL
757 * if the powerdomain pointer is null or returns the previous power state
760 int pwrdm_read_prev_pwrst(struct powerdomain *pwrdm)
765 return prm_read_mod_bits_shift(pwrdm->prcm_offs, OMAP3430_PM_PREPWSTST,
766 OMAP3430_LASTPOWERSTATEENTERED_MASK);
770 * pwrdm_set_logic_retst - set powerdomain logic power state upon retention
771 * @pwrdm: struct powerdomain * to set
772 * @pwrst: one of the PWRDM_POWER_* macros
774 * Set the next power state that the logic portion of the powerdomain
775 * pwrdm will enter when the powerdomain enters retention. This will
776 * be either RETENTION or OFF, if supported. Returns -EINVAL if the
777 * powerdomain pointer is null or the target power state is not not
778 * supported, or returns 0 upon success.
780 int pwrdm_set_logic_retst(struct powerdomain *pwrdm, u8 pwrst)
785 if (!(pwrdm->pwrsts_logic_ret & (1 << pwrst)))
788 pr_debug("powerdomain: setting next logic powerstate for %s to %0x\n",
792 * The register bit names below may not correspond to the
793 * actual names of the bits in each powerdomain's register,
794 * but the type of value returned is the same for each
797 prm_rmw_mod_reg_bits(OMAP3430_LOGICL1CACHERETSTATE,
798 (pwrst << __ffs(OMAP3430_LOGICL1CACHERETSTATE)),
799 pwrdm->prcm_offs, PM_PWSTCTRL);
805 * pwrdm_set_mem_onst - set memory power state while powerdomain ON
806 * @pwrdm: struct powerdomain * to set
807 * @bank: memory bank number to set (0-3)
808 * @pwrst: one of the PWRDM_POWER_* macros
810 * Set the next power state that memory bank x of the powerdomain
811 * pwrdm will enter when the powerdomain enters the ON state. Bank
812 * will be a number from 0 to 3, and represents different types of
813 * memory, depending on the powerdomain. Returns -EINVAL if the
814 * powerdomain pointer is null or the target power state is not not
815 * supported for this memory bank, -EEXIST if the target memory bank
816 * does not exist or is not controllable, or returns 0 upon success.
818 int pwrdm_set_mem_onst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
825 if (pwrdm->banks < (bank + 1))
828 if (!(pwrdm->pwrsts_mem_on[bank] & (1 << pwrst)))
831 pr_debug("powerdomain: setting next memory powerstate for domain %s "
832 "bank %0x while pwrdm-ON to %0x\n", pwrdm->name, bank, pwrst);
835 * The register bit names below may not correspond to the
836 * actual names of the bits in each powerdomain's register,
837 * but the type of value returned is the same for each
842 m = OMAP3430_SHAREDL1CACHEFLATONSTATE_MASK;
845 m = OMAP3430_L1FLATMEMONSTATE_MASK;
848 m = OMAP3430_SHAREDL2CACHEFLATONSTATE_MASK;
851 m = OMAP3430_L2FLATMEMONSTATE_MASK;
854 WARN_ON(1); /* should never happen */
858 prm_rmw_mod_reg_bits(m, (pwrst << __ffs(m)),
859 pwrdm->prcm_offs, PM_PWSTCTRL);
865 * pwrdm_set_mem_retst - set memory power state while powerdomain in RET
866 * @pwrdm: struct powerdomain * to set
867 * @bank: memory bank number to set (0-3)
868 * @pwrst: one of the PWRDM_POWER_* macros
870 * Set the next power state that memory bank x of the powerdomain
871 * pwrdm will enter when the powerdomain enters the RETENTION state.
872 * Bank will be a number from 0 to 3, and represents different types
873 * of memory, depending on the powerdomain. pwrst will be either
874 * RETENTION or OFF, if supported. Returns -EINVAL if the powerdomain
875 * pointer is null or the target power state is not not supported for
876 * this memory bank, -EEXIST if the target memory bank does not exist
877 * or is not controllable, or returns 0 upon success.
879 int pwrdm_set_mem_retst(struct powerdomain *pwrdm, u8 bank, u8 pwrst)
886 if (pwrdm->banks < (bank + 1))
889 if (!(pwrdm->pwrsts_mem_ret[bank] & (1 << pwrst)))
892 pr_debug("powerdomain: setting next memory powerstate for domain %s "
893 "bank %0x while pwrdm-RET to %0x\n", pwrdm->name, bank, pwrst);
896 * The register bit names below may not correspond to the
897 * actual names of the bits in each powerdomain's register,
898 * but the type of value returned is the same for each
903 m = OMAP3430_SHAREDL1CACHEFLATRETSTATE;
906 m = OMAP3430_L1FLATMEMRETSTATE;
909 m = OMAP3430_SHAREDL2CACHEFLATRETSTATE;
912 m = OMAP3430_L2FLATMEMRETSTATE;
915 WARN_ON(1); /* should never happen */
919 prm_rmw_mod_reg_bits(m, (pwrst << __ffs(m)), pwrdm->prcm_offs,
926 * pwrdm_read_logic_pwrst - get current powerdomain logic retention power state
927 * @pwrdm: struct powerdomain * to get current logic retention power state
929 * Return the current power state that the logic portion of
930 * powerdomain pwrdm will enter
931 * Returns -EINVAL if the powerdomain pointer is null or returns the
932 * current logic retention power state upon success.
934 int pwrdm_read_logic_pwrst(struct powerdomain *pwrdm)
939 return prm_read_mod_bits_shift(pwrdm->prcm_offs, PM_PWSTST,
940 OMAP3430_LOGICSTATEST);
944 * pwrdm_read_prev_logic_pwrst - get previous powerdomain logic power state
945 * @pwrdm: struct powerdomain * to get previous logic power state
947 * Return the powerdomain pwrdm's logic power state. Returns -EINVAL
948 * if the powerdomain pointer is null or returns the previous logic
949 * power state upon success.
951 int pwrdm_read_prev_logic_pwrst(struct powerdomain *pwrdm)
957 * The register bit names below may not correspond to the
958 * actual names of the bits in each powerdomain's register,
959 * but the type of value returned is the same for each
962 return prm_read_mod_bits_shift(pwrdm->prcm_offs, OMAP3430_PM_PREPWSTST,
963 OMAP3430_LASTLOGICSTATEENTERED);
967 * pwrdm_read_mem_pwrst - get current memory bank power state
968 * @pwrdm: struct powerdomain * to get current memory bank power state
969 * @bank: memory bank number (0-3)
971 * Return the powerdomain pwrdm's current memory power state for bank
972 * x. Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
973 * the target memory bank does not exist or is not controllable, or
974 * returns the current memory power state upon success.
976 int pwrdm_read_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
983 if (pwrdm->banks < (bank + 1))
986 if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
990 * The register bit names below may not correspond to the
991 * actual names of the bits in each powerdomain's register,
992 * but the type of value returned is the same for each
997 m = OMAP3430_SHAREDL1CACHEFLATSTATEST_MASK;
1000 m = OMAP3430_L1FLATMEMSTATEST_MASK;
1003 m = OMAP3430_SHAREDL2CACHEFLATSTATEST_MASK;
1006 m = OMAP3430_L2FLATMEMSTATEST_MASK;
1009 WARN_ON(1); /* should never happen */
1013 return prm_read_mod_bits_shift(pwrdm->prcm_offs, PM_PWSTST, m);
1017 * pwrdm_read_prev_mem_pwrst - get previous memory bank power state
1018 * @pwrdm: struct powerdomain * to get previous memory bank power state
1019 * @bank: memory bank number (0-3)
1021 * Return the powerdomain pwrdm's previous memory power state for bank
1022 * x. Returns -EINVAL if the powerdomain pointer is null, -EEXIST if
1023 * the target memory bank does not exist or is not controllable, or
1024 * returns the previous memory power state upon success.
1026 int pwrdm_read_prev_mem_pwrst(struct powerdomain *pwrdm, u8 bank)
1033 if (pwrdm->banks < (bank + 1))
1036 if (pwrdm->flags & PWRDM_HAS_MPU_QUIRK)
1040 * The register bit names below may not correspond to the
1041 * actual names of the bits in each powerdomain's register,
1042 * but the type of value returned is the same for each
1047 m = OMAP3430_LASTMEM1STATEENTERED_MASK;
1050 m = OMAP3430_LASTMEM2STATEENTERED_MASK;
1053 m = OMAP3430_LASTSHAREDL2CACHEFLATSTATEENTERED_MASK;
1056 m = OMAP3430_LASTL2FLATMEMSTATEENTERED_MASK;
1059 WARN_ON(1); /* should never happen */
1063 return prm_read_mod_bits_shift(pwrdm->prcm_offs,
1064 OMAP3430_PM_PREPWSTST, m);
1068 * pwrdm_clear_all_prev_pwrst - clear previous powerstate register for a pwrdm
1069 * @pwrdm: struct powerdomain * to clear
1071 * Clear the powerdomain's previous power state register. Clears the
1072 * entire register, including logic and memory bank previous power states.
1073 * Returns -EINVAL if the powerdomain pointer is null, or returns 0 upon
1076 int pwrdm_clear_all_prev_pwrst(struct powerdomain *pwrdm)
1082 * XXX should get the powerdomain's current state here;
1083 * warn & fail if it is not ON.
1086 pr_debug("powerdomain: clearing previous power state reg for %s\n",
1089 prm_write_mod_reg(0, pwrdm->prcm_offs, OMAP3430_PM_PREPWSTST);
1095 * pwrdm_enable_hdwr_sar - enable automatic hardware SAR for a pwrdm
1096 * @pwrdm: struct powerdomain *
1098 * Enable automatic context save-and-restore upon power state change
1099 * for some devices in a powerdomain. Warning: this only affects a
1100 * subset of devices in a powerdomain; check the TRM closely. Returns
1101 * -EINVAL if the powerdomain pointer is null or if the powerdomain
1102 * does not support automatic save-and-restore, or returns 0 upon
1105 int pwrdm_enable_hdwr_sar(struct powerdomain *pwrdm)
1110 if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
1113 pr_debug("powerdomain: %s: setting SAVEANDRESTORE bit\n",
1116 prm_rmw_mod_reg_bits(0, 1 << OMAP3430ES2_SAVEANDRESTORE_SHIFT,
1117 pwrdm->prcm_offs, PM_PWSTCTRL);
1123 * pwrdm_disable_hdwr_sar - disable automatic hardware SAR for a pwrdm
1124 * @pwrdm: struct powerdomain *
1126 * Disable automatic context save-and-restore upon power state change
1127 * for some devices in a powerdomain. Warning: this only affects a
1128 * subset of devices in a powerdomain; check the TRM closely. Returns
1129 * -EINVAL if the powerdomain pointer is null or if the powerdomain
1130 * does not support automatic save-and-restore, or returns 0 upon
1133 int pwrdm_disable_hdwr_sar(struct powerdomain *pwrdm)
1138 if (!(pwrdm->flags & PWRDM_HAS_HDWR_SAR))
1141 pr_debug("powerdomain: %s: clearing SAVEANDRESTORE bit\n",
1144 prm_rmw_mod_reg_bits(1 << OMAP3430ES2_SAVEANDRESTORE_SHIFT, 0,
1145 pwrdm->prcm_offs, PM_PWSTCTRL);
1151 * pwrdm_has_hdwr_sar - test whether powerdomain supports hardware SAR
1152 * @pwrdm: struct powerdomain *
1154 * Returns 1 if powerdomain 'pwrdm' supports hardware save-and-restore
1155 * for some devices, or 0 if it does not.
1157 bool pwrdm_has_hdwr_sar(struct powerdomain *pwrdm)
1159 return (pwrdm && pwrdm->flags & PWRDM_HAS_HDWR_SAR) ? 1 : 0;
1163 * pwrdm_wait_transition - wait for powerdomain power transition to finish
1164 * @pwrdm: struct powerdomain * to wait for
1166 * If the powerdomain pwrdm is in the process of a state transition,
1167 * spin until it completes the power transition, or until an iteration
1168 * bailout value is reached. Returns -EINVAL if the powerdomain
1169 * pointer is null, -EAGAIN if the bailout value was reached, or
1170 * returns 0 upon success.
1172 int pwrdm_wait_transition(struct powerdomain *pwrdm)
1180 * REVISIT: pwrdm_wait_transition() may be better implemented
1181 * via a callback and a periodic timer check -- how long do we expect
1182 * powerdomain transitions to take?
1185 /* XXX Is this udelay() value meaningful? */
1186 while ((prm_read_mod_reg(pwrdm->prcm_offs, PM_PWSTST) &
1187 OMAP_INTRANSITION) &&
1188 (c++ < PWRDM_TRANSITION_BAILOUT))
1191 if (c > PWRDM_TRANSITION_BAILOUT) {
1192 printk(KERN_ERR "powerdomain: waited too long for "
1193 "powerdomain %s to complete transition\n", pwrdm->name);
1197 pr_debug("powerdomain: completed transition in %d loops\n", c);
1202 int pwrdm_state_switch(struct powerdomain *pwrdm)
1204 return _pwrdm_state_switch(pwrdm, PWRDM_STATE_NOW);
1207 int pwrdm_clkdm_state_switch(struct clockdomain *clkdm)
1209 if (clkdm != NULL && clkdm->pwrdm.ptr != NULL) {
1210 pwrdm_wait_transition(clkdm->pwrdm.ptr);
1211 return pwrdm_state_switch(clkdm->pwrdm.ptr);
1216 int pwrdm_clk_state_switch(struct clk *clk)
1218 if (clk != NULL && clk->clkdm != NULL)
1219 return pwrdm_clkdm_state_switch(clk->clkdm);
1223 int pwrdm_pre_transition(void)
1225 pwrdm_for_each(_pwrdm_pre_transition_cb, NULL);
1229 int pwrdm_post_transition(void)
1231 pwrdm_for_each(_pwrdm_post_transition_cb, NULL);