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->pwrdm_name; 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);