sergiotarxz/nuttx
sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

pm: add pm_domain_lock/unlock support

Browse Source 
Signed-off-by: ligd <liguiding1@xiaomi.com>
This commit is contained in:
ligd 2022-12-30 13:42:31 +08:00 committed by Xiang Xiao
parent d2ef505684
commit 38c6f20d17
8 changed files with 82 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
drivers/power/pm/activity_governor.c
View File

@ -235,7 +235,7 @@ static void governor_activity(int domain, int count)
{ {
/* Add the activity count to the accumulated counts. */ /* Add the activity count to the accumulated counts. */
flags = pm_lock(domain); flags = pm_domain_lock(domain);
accum = (uint32_t)pdomstate->accum + count; accum = (uint32_t)pdomstate->accum + count;
/* Make sure that we do not overflow the underlying representation */ /* Make sure that we do not overflow the underlying representation */
@ -275,7 +275,7 @@ static void governor_activity(int domain, int count)
governor_update(domain, tmp); governor_update(domain, tmp);
} }
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
} }
} }
@ -476,7 +476,7 @@ static enum pm_state_e governor_checkstate(int domain)
* logic in governor_activity(). * logic in governor_activity().
*/ */
flags = pm_lock(domain); flags = pm_domain_lock(domain);
/* Check the elapsed time. In periods of low activity, time slicing is /* Check the elapsed time. In periods of low activity, time slicing is
* controlled by IDLE loop polling; in periods of higher activity, time * controlled by IDLE loop polling; in periods of higher activity, time
@ -515,7 +515,7 @@ static enum pm_state_e governor_checkstate(int domain)
} }
} }
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
return pdomstate->recommended; return pdomstate->recommended;
} }

8
drivers/power/pm/greedy_governor.c
View File

@ -119,7 +119,7 @@ static enum pm_state_e greedy_governor_checkstate(int domain)
* invoked, which modifies the stay count which we are about to read * invoked, which modifies the stay count which we are about to read
*/ */
flags = pm_lock(domain); flags = pm_domain_lock(domain);
if (!WDOG_ISACTIVE(&pdomstate->wdog)) if (!WDOG_ISACTIVE(&pdomstate->wdog))
{ {
@ -131,7 +131,7 @@ static enum pm_state_e greedy_governor_checkstate(int domain)
} }
} }
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
/* Return the found state */ /* Return the found state */
@ -159,7 +159,7 @@ static void greedy_governor_activity(int domain, int count)
pdomstate = &g_pm_greedy_governor.domain_states[domain]; pdomstate = &g_pm_greedy_governor.domain_states[domain];
count = count ? count : 1; count = count ? count : 1;
flags = pm_lock(domain); flags = pm_domain_lock(domain);
if (TICK2SEC(wd_gettime(&pdomstate->wdog)) < count) if (TICK2SEC(wd_gettime(&pdomstate->wdog)) < count)
{ {
@ -167,7 +167,7 @@ static void greedy_governor_activity(int domain, int count)
greedy_governor_timer_cb, (wdparm_t)domain); greedy_governor_timer_cb, (wdparm_t)domain);
} }
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
} }
/**************************************************************************** /****************************************************************************

46
drivers/power/pm/pm.h
View File

@ -133,11 +133,14 @@ EXTERN struct pm_global_s g_pmglobals;
* Lock the power management operation. * Lock the power management operation.
* *
* Input Parameters: * Input Parameters:
* domain - The PM domain to lock * lock - The lock subjuct
*
* Returned Value:
* Return current state
* *
****************************************************************************/ ****************************************************************************/
irqstate_t pm_lock(int domain); irqstate_t pm_lock(FAR rmutex_t *lock);
/**************************************************************************** /****************************************************************************
* Name: pm_unlock * Name: pm_unlock
@ -146,11 +149,46 @@ irqstate_t pm_lock(int domain);
* Unlock the power management operation. * Unlock the power management operation.
* *
* Input Parameters: * Input Parameters:
* domain - The PM domain to unlock * lock - The lock subjuct
*
* Returned Value:
* None
* *
****************************************************************************/ ****************************************************************************/
void pm_unlock(int domain, irqstate_t flags); void pm_unlock(FAR rmutex_t *lock, irqstate_t flags);
/****************************************************************************
* Name: pm_domain_lock
*
* Description:
* Lock the power management operation.
*
* Input Parameters:
* domain - The PM domain to lock
*
* Returned Value:
* Return current state
*
****************************************************************************/
irqstate_t pm_domain_lock(int domain);
/****************************************************************************
* Name: pm_domain_unlock
*
* Description:
* Unlock the power management operation.
*
* Input Parameters:
* domain - The PM domain to unlock
*
* Returned Value:
* None
*
****************************************************************************/
void pm_domain_unlock(int domain, irqstate_t flags);
/**************************************************************************** /****************************************************************************
* Name: pm_wakelock_global_init * Name: pm_wakelock_global_init

16
drivers/power/pm/pm_activity.c
View File

@ -305,7 +305,7 @@ void pm_wakelock_uninit(FAR struct pm_wakelock_s *wakelock)
dq = &pdom->wakelock[wakelock->state]; dq = &pdom->wakelock[wakelock->state];
wdog = &wakelock->wdog; wdog = &wakelock->wdog;
flags = pm_lock(domain); flags = pm_domain_lock(domain);
if (wakelock->count > 0) if (wakelock->count > 0)
{ {
@ -316,7 +316,7 @@ void pm_wakelock_uninit(FAR struct pm_wakelock_s *wakelock)
wd_cancel(wdog); wd_cancel(wdog);
pm_wakelock_stats_rm(wakelock); pm_wakelock_stats_rm(wakelock);
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
} }
/**************************************************************************** /****************************************************************************
@ -353,7 +353,7 @@ void pm_wakelock_stay(FAR struct pm_wakelock_s *wakelock)
pdom = &g_pmglobals.domain[domain]; pdom = &g_pmglobals.domain[domain];
dq = &pdom->wakelock[wakelock->state]; dq = &pdom->wakelock[wakelock->state];
flags = pm_lock(domain); flags = pm_domain_lock(domain);
DEBUGASSERT(wakelock->count < UINT32_MAX); DEBUGASSERT(wakelock->count < UINT32_MAX);
if (wakelock->count++ == 0) if (wakelock->count++ == 0)
@ -362,7 +362,7 @@ void pm_wakelock_stay(FAR struct pm_wakelock_s *wakelock)
pm_wakelock_stats(wakelock, true); pm_wakelock_stats(wakelock, true);
} }
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
pm_auto_updatestate(domain); pm_auto_updatestate(domain);
} }
@ -400,7 +400,7 @@ void pm_wakelock_relax(FAR struct pm_wakelock_s *wakelock)
pdom = &g_pmglobals.domain[domain]; pdom = &g_pmglobals.domain[domain];
dq = &pdom->wakelock[wakelock->state]; dq = &pdom->wakelock[wakelock->state];
flags = pm_lock(domain); flags = pm_domain_lock(domain);
DEBUGASSERT(wakelock->count > 0); DEBUGASSERT(wakelock->count > 0);
if (--wakelock->count == 0) if (--wakelock->count == 0)
@ -409,7 +409,7 @@ void pm_wakelock_relax(FAR struct pm_wakelock_s *wakelock)
pm_wakelock_stats(wakelock, false); pm_wakelock_stats(wakelock, false);
} }
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
pm_auto_updatestate(domain); pm_auto_updatestate(domain);
} }
@ -452,7 +452,7 @@ void pm_wakelock_staytimeout(FAR struct pm_wakelock_s *wakelock, int ms)
dq = &pdom->wakelock[wakelock->state]; dq = &pdom->wakelock[wakelock->state];
wdog = &wakelock->wdog; wdog = &wakelock->wdog;
flags = pm_lock(domain); flags = pm_domain_lock(domain);
if (!WDOG_ISACTIVE(wdog)) if (!WDOG_ISACTIVE(wdog))
{ {
@ -469,7 +469,7 @@ void pm_wakelock_staytimeout(FAR struct pm_wakelock_s *wakelock, int ms)
wd_start(wdog, MSEC2TICK(ms), pm_waklock_cb, (wdparm_t)wakelock); wd_start(wdog, MSEC2TICK(ms), pm_waklock_cb, (wdparm_t)wakelock);
} }
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
pm_auto_updatestate(domain); pm_auto_updatestate(domain);
} }

8
drivers/power/pm/pm_autoupdate.c
View File

@ -44,12 +44,12 @@ static void pm_auto_updatestate_cb(FAR void *arg)
enum pm_state_e newstate; enum pm_state_e newstate;
irqstate_t flags; irqstate_t flags;
flags = pm_lock(domain); flags = pm_domain_lock(domain);
newstate = pm_checkstate(domain); newstate = pm_checkstate(domain);
pm_changestate(domain, newstate); pm_changestate(domain, newstate);
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
} }
/**************************************************************************** /****************************************************************************
@ -114,9 +114,9 @@ void pm_auto_update(int domain, bool auto_update)
DEBUGASSERT(domain >= 0 && domain < CONFIG_PM_NDOMAINS); DEBUGASSERT(domain >= 0 && domain < CONFIG_PM_NDOMAINS);
pdom = &g_pmglobals.domain[domain]; pdom = &g_pmglobals.domain[domain];
flags = pm_lock(domain); flags = pm_domain_lock(domain);
pdom->auto_update = auto_update; pdom->auto_update = auto_update;
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
} }
#endif /* CONFIG_PM */ #endif /* CONFIG_PM */

4
drivers/power/pm/pm_changestate.c
View File

@ -242,7 +242,7 @@ int pm_changestate(int domain, enum pm_state_e newstate)
* re-enabled. * re-enabled.
*/ */
flags = pm_lock(domain); flags = pm_domain_lock(domain);
if (newstate != PM_RESTORE) if (newstate != PM_RESTORE)
{ {
@ -286,7 +286,7 @@ int pm_changestate(int domain, enum pm_state_e newstate)
/* Restore the interrupt state */ /* Restore the interrupt state */
pm_unlock(domain, flags); pm_domain_unlock(domain, flags);
return ret; return ret;
} }

40
drivers/power/pm/pm_lock.c
View File

@ -37,46 +37,34 @@
* Public Functions * Public Functions
****************************************************************************/ ****************************************************************************/
/**************************************************************************** irqstate_t pm_lock(FAR rmutex_t *lock)
* Name: pm_lock
*
* Description:
* Lock the power management operation.
*
* Input Parameters:
* domain - The PM domain to lock
*
****************************************************************************/
irqstate_t pm_lock(int domain)
{ {
if (!up_interrupt_context() && !sched_idletask()) if (!up_interrupt_context() && !sched_idletask())
{ {
nxrmutex_lock(&g_pmglobals.domain[domain].lock); nxrmutex_lock(lock);
} }
return enter_critical_section(); return enter_critical_section();
} }
/**************************************************************************** void pm_unlock(FAR rmutex_t *lock, irqstate_t flags)
* Name: pm_unlock
*
* Description:
* Unlock the power management operation.
*
* Input Parameters:
* domain - The PM domain to unlock
*
****************************************************************************/
void pm_unlock(int domain, irqstate_t flags)
{ {
leave_critical_section(flags); leave_critical_section(flags);
if (!up_interrupt_context() && !sched_idletask()) if (!up_interrupt_context() && !sched_idletask())
{ {
nxrmutex_unlock(&g_pmglobals.domain[domain].lock); nxrmutex_unlock(lock);
} }
} }
irqstate_t pm_domain_lock(int domain)
{
return pm_lock(&g_pmglobals.domain[domain].lock);
}
void pm_domain_unlock(int domain, irqstate_t flags)
{
pm_unlock(&g_pmglobals.domain[domain].lock, flags);
}
#endif /* CONFIG_PM */ #endif /* CONFIG_PM */

8
drivers/power/pm/pm_procfs.c
View File

@ -268,7 +268,7 @@ static ssize_t pm_read_state(FAR struct file *filep, FAR char *buffer,
totalsize += copysize; totalsize += copysize;
flags = pm_lock(pmfile->domain); flags = pm_domain_lock(pmfile->domain);
for (state = 0; state < PM_COUNT; state++) for (state = 0; state < PM_COUNT; state++)
{ {
@ -300,7 +300,7 @@ static ssize_t pm_read_state(FAR struct file *filep, FAR char *buffer,
totalsize += copysize; totalsize += copysize;
} }
pm_unlock(pmfile->domain, flags); pm_domain_unlock(pmfile->domain, flags);
filep->f_pos += totalsize; filep->f_pos += totalsize;
return totalsize; return totalsize;
@ -340,7 +340,7 @@ static ssize_t pm_read_wakelock(FAR struct file *filep, FAR char *buffer,
totalsize += copysize; totalsize += copysize;
flags = pm_lock(pmfile->domain); flags = pm_domain_lock(pmfile->domain);
entry = dq_peek(&dom->wakelockall); entry = dq_peek(&dom->wakelockall);
for (; entry && totalsize < buflen; entry = dq_next(entry)) for (; entry && totalsize < buflen; entry = dq_next(entry))
@ -374,7 +374,7 @@ static ssize_t pm_read_wakelock(FAR struct file *filep, FAR char *buffer,
totalsize += copysize; totalsize += copysize;
} }
pm_unlock(pmfile->domain, flags); pm_domain_unlock(pmfile->domain, flags);
filep->f_pos += totalsize; filep->f_pos += totalsize;
return totalsize; return totalsize;