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. */
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
accum = (uint32_t)pdomstate->accum + count;
/* 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);
}
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().
*/
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
/* Check the elapsed time. In periods of low activity, time slicing is
* 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;
}

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
*/
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
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 */
@ -159,7 +159,7 @@ static void greedy_governor_activity(int domain, int count)
pdomstate = &g_pm_greedy_governor.domain_states[domain];
count = count ? count : 1;
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
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);
}
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.
*
* 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
@ -146,11 +149,46 @@ irqstate_t pm_lock(int domain);
* Unlock the power management operation.
*
* 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

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];
wdog = &wakelock->wdog;
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
if (wakelock->count > 0)
{
@ -316,7 +316,7 @@ void pm_wakelock_uninit(FAR struct pm_wakelock_s *wakelock)
wd_cancel(wdog);
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];
dq = &pdom->wakelock[wakelock->state];
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
DEBUGASSERT(wakelock->count < UINT32_MAX);
if (wakelock->count++ == 0)
@ -362,7 +362,7 @@ void pm_wakelock_stay(FAR struct pm_wakelock_s *wakelock)
pm_wakelock_stats(wakelock, true);
}
pm_unlock(domain, flags);
pm_domain_unlock(domain, flags);
pm_auto_updatestate(domain);
}
@ -400,7 +400,7 @@ void pm_wakelock_relax(FAR struct pm_wakelock_s *wakelock)
pdom = &g_pmglobals.domain[domain];
dq = &pdom->wakelock[wakelock->state];
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
DEBUGASSERT(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_unlock(domain, flags);
pm_domain_unlock(domain, flags);
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];
wdog = &wakelock->wdog;
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
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);
}
pm_unlock(domain, flags);
pm_domain_unlock(domain, flags);
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;
irqstate_t flags;
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
newstate = pm_checkstate(domain);
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);
pdom = &g_pmglobals.domain[domain];
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
pdom->auto_update = auto_update;
pm_unlock(domain, flags);
pm_domain_unlock(domain, flags);
}
#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.
*/
flags = pm_lock(domain);
flags = pm_domain_lock(domain);
if (newstate != PM_RESTORE)
{
@ -286,7 +286,7 @@ int pm_changestate(int domain, enum pm_state_e newstate)
/* Restore the interrupt state */
pm_unlock(domain, flags);
pm_domain_unlock(domain, flags);
return ret;
}

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

@ -37,46 +37,34 @@
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: pm_lock
*
* Description:
* Lock the power management operation.
*
* Input Parameters:
* domain - The PM domain to lock
*
****************************************************************************/
irqstate_t pm_lock(int domain)
irqstate_t pm_lock(FAR rmutex_t *lock)
{
if (!up_interrupt_context() && !sched_idletask())
{
nxrmutex_lock(&g_pmglobals.domain[domain].lock);
nxrmutex_lock(lock);
}
return enter_critical_section();
}
/****************************************************************************
* 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)
void pm_unlock(FAR rmutex_t *lock, irqstate_t flags)
{
leave_critical_section(flags);
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 */

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;
flags = pm_lock(pmfile->domain);
flags = pm_domain_lock(pmfile->domain);
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;
}
pm_unlock(pmfile->domain, flags);
pm_domain_unlock(pmfile->domain, flags);
filep->f_pos += totalsize;
return totalsize;
@ -340,7 +340,7 @@ static ssize_t pm_read_wakelock(FAR struct file *filep, FAR char *buffer,
totalsize += copysize;
flags = pm_lock(pmfile->domain);
flags = pm_domain_lock(pmfile->domain);
entry = dq_peek(&dom->wakelockall);
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;
}
pm_unlock(pmfile->domain, flags);
pm_domain_unlock(pmfile->domain, flags);
filep->f_pos += totalsize;
return totalsize;