libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #4097 from zhangsz0516/zhangsz_1127 

[update][PM]更新RT-Thread PM2.0框架
This commit is contained in:
Bernard Xiong 2020-12-31 08:33:27 +08:00 committed by GitHub
parent a207f22150 5b4845089a
commit 5fd6aec3d1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 374 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
components/drivers/include/drivers/pm.h
View File

@ -8,6 +8,8 @@
* 2012-06-02 Bernard the first version
* 2018-08-02 Tanek split run and sleep modes, support custom mode
* 2019-04-28 Zero-Free improve PM mode and device ops interface
* 2020-11-23 zhangsz update pm mode select
* 2020-11-27 zhangsz update pm 2.0
*/
#ifndef __PM_H__
@ -45,7 +47,8 @@ enum
RT_PM_FREQUENCY_PENDING = 0x01,
};
#define RT_PM_DEFAULT_SLEEP_MODE PM_SLEEP_MODE_IDLE
#define RT_PM_DEFAULT_SLEEP_MODE PM_SLEEP_MODE_NONE
#define RT_PM_DEFAULT_DEEPSLEEP_MODE PM_SLEEP_MODE_DEEP
#define RT_PM_DEFAULT_RUN_MODE PM_RUN_MODE_NORMAL_SPEED
/* The name of all modes used in the msh command "pm_dump" */
@ -67,6 +70,33 @@ enum
"Low Mode", \
}
/**
* Modules used for
* pm_module_request(PM_BOARD_ID, PM_SLEEP_MODE_IDLE)
* pm_module_release(PM_BOARD_ID, PM_SLEEP_MODE_IDLE)
* pm_module_release_all(PM_BOARD_ID, PM_SLEEP_MODE_IDLE)
*/
enum pm_module_id {
PM_NONE_ID = 0,
PM_POWER_ID,
PM_BOARD_ID,
PM_BSP_ID,
PM_MAIN_ID,
PM_PMS_ID,
PM_PMC_ID,
PM_TASK_ID,
PM_SPI_ID,
PM_I2C_ID,
PM_UART_ID,
PM_CAN_ID,
PM_ETH_ID,
PM_SENSOR_ID,
PM_LCD_ID,
PM_KEY_ID,
PM_TP_ID,
PM_MODULE_MAX_ID, /* enum must! */
};
#else /* PM_HAS_CUSTOM_CONFIG */
#include <pm_cfg.h>
@ -106,6 +136,14 @@ struct rt_device_pm
const struct rt_device_pm_ops *ops;
};
struct rt_pm_module
{
rt_uint8_t req_status;
rt_bool_t busy_flag;
rt_uint32_t timeout;
rt_uint32_t start_time;
};
/**
* power management
*/
@ -118,6 +156,9 @@ struct rt_pm
rt_uint8_t sleep_mode; /* current sleep mode */
rt_uint8_t run_mode; /* current running mode */
/* modules request status*/
struct rt_pm_module module_status[PM_MODULE_MAX_ID];
/* the list of device, which has PM feature */
rt_uint8_t device_pm_number;
struct rt_device_pm *device_pm;
@ -143,6 +184,7 @@ struct rt_pm_notify
void rt_pm_request(rt_uint8_t sleep_mode);
void rt_pm_release(rt_uint8_t sleep_mode);
void rt_pm_release_all(rt_uint8_t sleep_mode);
int rt_pm_run_enter(rt_uint8_t run_mode);
void rt_pm_device_register(struct rt_device *device, const struct rt_device_pm_ops *ops);
@ -154,5 +196,11 @@ void rt_pm_default_set(rt_uint8_t sleep_mode);
void rt_system_pm_init(const struct rt_pm_ops *ops,
rt_uint8_t timer_mask,
void *user_data);
void rt_pm_module_request(uint8_t module_id, rt_uint8_t sleep_mode);
void rt_pm_module_release(uint8_t module_id, rt_uint8_t sleep_mode);
void rt_pm_module_release_all(uint8_t module_id, rt_uint8_t sleep_mode);
void rt_pm_module_delay_sleep(rt_uint8_t module_id, rt_tick_t timeout);
rt_uint32_t rt_pm_module_get_status(void);
rt_uint8_t rt_pm_get_sleep_mode(void);
#endif /* __PM_H__ */

344
components/drivers/pm/pm.c
View File

@ -9,6 +9,7 @@
* 2018-08-02 Tanek split run and sleep modes, support custom mode
* 2019-04-28 Zero-Free improve PM mode and device ops interface
* 2020-11-23 zhangsz update pm mode select
* 2020-11-27 zhangsz update pm 2.0
*/
#include <rthw.h>
@ -18,7 +19,13 @@
#ifdef RT_USING_PM
static struct rt_pm _pm;
/* default mode : system power on */
static rt_uint8_t _pm_default_sleep = RT_PM_DEFAULT_SLEEP_MODE;
/* default deepsleep mode : tick-less mode */
static rt_uint8_t _pm_default_deepsleep = RT_PM_DEFAULT_DEEPSLEEP_MODE;
static struct rt_pm_notify _pm_notify;
static rt_uint8_t _pm_init_flag = 0;
@ -112,7 +119,7 @@ static rt_uint8_t _pm_select_sleep_mode(struct rt_pm *pm)
int index;
rt_uint8_t mode;
mode = _pm_default_sleep;
mode = _pm_default_deepsleep;
for (index = PM_SLEEP_MODE_NONE; index < PM_SLEEP_MODE_MAX; index ++)
{
if (pm->modes[index])
@ -126,42 +133,102 @@ static rt_uint8_t _pm_select_sleep_mode(struct rt_pm *pm)
return mode;
}
/**
* pm module request delay sleep.
*/
void rt_pm_module_delay_sleep(rt_uint8_t module_id, rt_tick_t timeout)
{
rt_base_t level;
struct rt_pm *pm;
if (_pm_init_flag == 0)
return;
if (module_id > (PM_MODULE_MAX_ID - 1))
return;
level = rt_hw_interrupt_disable();
pm = &_pm;
pm->module_status[module_id].busy_flag = RT_TRUE;
pm->module_status[module_id].timeout = timeout;
pm->module_status[module_id].start_time = rt_tick_get();
rt_hw_interrupt_enable(level);
}
/**
* This function check if all modules in idle status.
*/
static rt_bool_t _pm_device_check_idle(void)
{
struct rt_pm *pm;
if (_pm_init_flag == 0)
return RT_TRUE;
pm = &_pm;
for (int i = 0; i < PM_MODULE_MAX_ID; i++)
{
if (pm->module_status[i].busy_flag == RT_TRUE)
{
if (rt_tick_get() - pm->module_status[i].start_time > pm->module_status[i].timeout)
{
pm->module_status[i].busy_flag = RT_FALSE;
pm->module_status[i].timeout = 0x00;
}
}
if (pm->module_status[i].busy_flag == RT_TRUE)
{
return RT_FALSE;
}
}
return RT_TRUE;
}
/**
* This function changes the power sleep mode base on the result of selection
*/
static void _pm_change_sleep_mode(struct rt_pm *pm, rt_uint8_t mode)
static void _pm_change_sleep_mode(struct rt_pm *pm)
{
rt_tick_t timeout_tick, delta_tick;
rt_base_t level;
int ret = RT_EOK;
if (mode == PM_SLEEP_MODE_NONE)
level = rt_pm_enter_critical(pm->sleep_mode);
/* module busy request */
if (_pm_device_check_idle() == RT_FALSE)
{
pm->sleep_mode = mode;
pm->ops->sleep(pm, PM_SLEEP_MODE_NONE);
rt_pm_exit_critical(level, pm->sleep_mode);
return;
}
if (_pm.sleep_mode == PM_SLEEP_MODE_NONE)
{
pm->ops->sleep(pm, PM_SLEEP_MODE_NONE);
rt_pm_exit_critical(level, pm->sleep_mode);
}
else
{
level = rt_pm_enter_critical(mode);
/* Notify app will enter sleep mode */
if (_pm_notify.notify)
_pm_notify.notify(RT_PM_ENTER_SLEEP, mode, _pm_notify.data);
_pm_notify.notify(RT_PM_ENTER_SLEEP, pm->sleep_mode, _pm_notify.data);
/* Suspend all peripheral device */
ret = _pm_device_suspend(mode);
ret = _pm_device_suspend(pm->sleep_mode);
if (ret != RT_EOK)
{
_pm_device_resume(mode);
_pm_device_resume(pm->sleep_mode);
if (_pm_notify.notify)
_pm_notify.notify(RT_PM_EXIT_SLEEP, mode, _pm_notify.data);
rt_pm_exit_critical(level, mode);
_pm_notify.notify(RT_PM_EXIT_SLEEP, pm->sleep_mode, _pm_notify.data);
rt_pm_exit_critical(level, pm->sleep_mode);
return;
}
/* Tickless*/
if (pm->timer_mask & (0x01 << mode))
if (pm->timer_mask & (0x01 << pm->sleep_mode))
{
timeout_tick = rt_timer_next_timeout_tick();
if (timeout_tick == RT_TICK_MAX)
@ -176,7 +243,7 @@ static void _pm_change_sleep_mode(struct rt_pm *pm, rt_uint8_t mode)
timeout_tick = timeout_tick - rt_tick_get();
if (timeout_tick < RT_PM_TICKLESS_THRESH)
{
mode = PM_SLEEP_MODE_IDLE;
pm->sleep_mode = PM_SLEEP_MODE_IDLE;
}
else
{
@ -186,17 +253,16 @@ static void _pm_change_sleep_mode(struct rt_pm *pm, rt_uint8_t mode)
}
/* enter lower power state */
pm->ops->sleep(pm, mode);
pm->ops->sleep(pm, pm->sleep_mode);
/* wake up from lower power state*/
if (pm->timer_mask & (0x01 << mode))
if (pm->timer_mask & (0x01 << pm->sleep_mode))
{
delta_tick = pm->ops->timer_get_tick(pm);
pm->ops->timer_stop(pm);
if (delta_tick)
{
rt_tick_set(rt_tick_get() + delta_tick);
rt_timer_check();
}
}
@ -204,9 +270,17 @@ static void _pm_change_sleep_mode(struct rt_pm *pm, rt_uint8_t mode)
_pm_device_resume(pm->sleep_mode);
if (_pm_notify.notify)
_pm_notify.notify(RT_PM_EXIT_SLEEP, mode, _pm_notify.data);
_pm_notify.notify(RT_PM_EXIT_SLEEP, pm->sleep_mode, _pm_notify.data);
rt_pm_exit_critical(level, mode);
rt_pm_exit_critical(level, pm->sleep_mode);
if (pm->timer_mask & (0x01 << pm->sleep_mode))
{
if (delta_tick)
{
rt_timer_check();
}
}
}
}
@ -222,7 +296,7 @@ void rt_system_power_manager(void)
_pm_frequency_scaling(&_pm);
/* Low Power Mode Processing */
_pm_change_sleep_mode(&_pm, _pm.sleep_mode);
_pm_change_sleep_mode(&_pm);
}
/**
@ -276,6 +350,120 @@ void rt_pm_release(rt_uint8_t mode)
rt_hw_interrupt_enable(level);
}
/**
* Upper application or device driver releases all the stall
* of corresponding power mode.
*
* @param parameter the parameter of run mode or sleep mode
*
*/
void rt_pm_release_all(rt_uint8_t mode)
{
rt_ubase_t level;
struct rt_pm *pm;
if (_pm_init_flag == 0)
return;
if (mode > (PM_SLEEP_MODE_MAX - 1))
return;
level = rt_hw_interrupt_disable();
pm = &_pm;
pm->modes[mode] = 0;
_pm_select_sleep_mode(pm);
rt_hw_interrupt_enable(level);
}
/**
* Upper application or device driver requests the system
* stall in corresponding power mode.
*
* @param module_id the application or device module id
* @param mode the system power sleep mode
*/
void rt_pm_module_request(uint8_t module_id, rt_uint8_t mode)
{
rt_base_t level;
struct rt_pm *pm;
if (_pm_init_flag == 0)
return;
if (mode > (PM_SLEEP_MODE_MAX - 1))
return;
if (module_id > (PM_MODULE_MAX_ID - 1))
return;
level = rt_hw_interrupt_disable();
pm = &_pm;
pm->module_status[module_id].req_status = 0x01;
if (pm->modes[mode] < 255)
pm->modes[mode] ++;
_pm_select_sleep_mode(pm);
rt_hw_interrupt_enable(level);
}
/**
* Upper application or device driver releases the stall
* of corresponding power mode.
*
* @param module_id the application or device module id
* @param mode the system power sleep mode
*
*/
void rt_pm_module_release(uint8_t module_id, rt_uint8_t mode)
{
rt_ubase_t level;
struct rt_pm *pm;
if (_pm_init_flag == 0)
return;
if (mode > (PM_SLEEP_MODE_MAX - 1))
return;
if (module_id > (PM_MODULE_MAX_ID - 1))
return;
level = rt_hw_interrupt_disable();
pm = &_pm;
if (pm->modes[mode] > 0)
pm->modes[mode] --;
if (pm->modes[mode] == 0)
pm->module_status[module_id].req_status = 0x00;
_pm_select_sleep_mode(pm);
rt_hw_interrupt_enable(level);
}
/**
* Upper application or device driver releases all the stall
* of corresponding power mode.
*
* @param module_id the application or device module id
* @param mode the system power sleep mode
*
*/
void rt_pm_module_release_all(uint8_t module_id, rt_uint8_t mode)
{
rt_ubase_t level;
struct rt_pm *pm;
if (_pm_init_flag == 0)
return;
if (mode > (PM_SLEEP_MODE_MAX - 1))
return;
level = rt_hw_interrupt_disable();
pm = &_pm;
pm->modes[mode] = 0;
pm->module_status[module_id].req_status = 0x00;
_pm_select_sleep_mode(pm);
rt_hw_interrupt_enable(level);
}
/**
* Register a device with PM feature
*
@ -508,6 +696,10 @@ void rt_system_pm_init(const struct rt_pm_ops *ops,
rt_memset(pm->modes, 0, sizeof(pm->modes));
pm->sleep_mode = _pm_default_sleep;
/* when system power on, set default sleep modes */
pm->modes[pm->sleep_mode] = 1;
pm->module_status[PM_POWER_ID].req_status = 1;
pm->run_mode = RT_PM_DEFAULT_RUN_MODE;
pm->timer_mask = timer_mask;
@ -541,6 +733,18 @@ static void rt_pm_release_mode(int argc, char **argv)
}
MSH_CMD_EXPORT_ALIAS(rt_pm_release_mode, pm_release, release power management mode);
static void rt_pm_release_mode_all(int argc, char **argv)
{
int mode = 0;
if (argc >= 2)
{
mode = atoi(argv[1]);
}
rt_pm_release_all(mode);
}
MSH_CMD_EXPORT_ALIAS(rt_pm_release_mode_all, pm_release_all, release power management mode count);
static void rt_pm_request_mode(int argc, char **argv)
{
int mode = 0;
@ -553,6 +757,66 @@ static void rt_pm_request_mode(int argc, char **argv)
}
MSH_CMD_EXPORT_ALIAS(rt_pm_request_mode, pm_request, request power management mode);
static void rt_module_release_mode(int argc, char **argv)
{
int module = 0;
int mode = 0;
if (argc >= 3)
{
module = atoi(argv[1]);
mode = atoi(argv[2]);
}
rt_pm_module_release(module, mode);
}
MSH_CMD_EXPORT_ALIAS(rt_module_release_mode, pm_module_release, release module power mode);
static void rt_module_release_mode_all(int argc, char **argv)
{
int module = 0;
int mode = 0;
if (argc >= 3)
{
module = atoi(argv[1]);
mode = atoi(argv[2]);
}
rt_pm_module_release_all(module, mode);
}
MSH_CMD_EXPORT_ALIAS(rt_module_release_mode_all, pm_module_release_all, release power management mode count);
static void rt_module_request_mode(int argc, char **argv)
{
int module = 0;
int mode = 0;
if (argc >= 3)
{
module = atoi(argv[1]);
mode = atoi(argv[2]);
}
rt_pm_module_request(module, mode);
}
MSH_CMD_EXPORT_ALIAS(rt_module_request_mode, pm_module_request, request power management mode);
static void rt_module_delay_sleep(int argc, char **argv)
{
int module = 0;
unsigned int timeout = 0;
if (argc >= 3)
{
module = atoi(argv[1]);
timeout = atoi(argv[2]);
}
rt_pm_module_delay_sleep(module, timeout);
}
MSH_CMD_EXPORT_ALIAS(rt_module_delay_sleep, pm_module_delay, module request delay sleep);
static void rt_pm_run_mode_switch(int argc, char **argv)
{
int mode = 0;
@ -565,6 +829,32 @@ static void rt_pm_run_mode_switch(int argc, char **argv)
}
MSH_CMD_EXPORT_ALIAS(rt_pm_run_mode_switch, pm_run, switch power management run mode);
rt_uint32_t rt_pm_module_get_status(void)
{
rt_uint8_t index = 0;
struct rt_pm *pm;
rt_uint32_t req_status = 0x00;
pm = &_pm;
for (index = 0; index < 32; index ++)
{
if (pm->module_status[index].req_status == 0x01)
req_status |= 1<<index;
if (index >= PM_MODULE_MAX_ID)
break;
}
return req_status;
}
rt_uint8_t rt_pm_get_sleep_mode(void)
{
struct rt_pm *pm;
pm = &_pm;
return pm->sleep_mode;
}
static void rt_pm_dump_status(void)
{
rt_uint32_t index;
@ -586,6 +876,22 @@ static void rt_pm_dump_status(void)
rt_kprintf("pm current sleep mode: %s\n", _pm_sleep_str[pm->sleep_mode]);
rt_kprintf("pm current run mode: %s\n", _pm_run_str[pm->run_mode]);
rt_kprintf("\n");
rt_kprintf("| module | busy | start time | timeout |\n");
rt_kprintf("+--------+------+------------+-----------+\n");
for (index = 0; index < PM_MODULE_MAX_ID; index ++)
{
if ((pm->module_status[index].busy_flag == RT_TRUE) ||
(pm->module_status[index].req_status != 0x00))
{
rt_kprintf("| %04d | %d | 0x%08x | 0x%08x |\n",
index, pm->module_status[index].busy_flag,
pm->module_status[index].start_time,
pm->module_status[index].timeout);
}
}
rt_kprintf("+--------+------+------------+-----------+\n");
}
FINSH_FUNCTION_EXPORT_ALIAS(rt_pm_dump_status, pm_dump, dump power management status);
MSH_CMD_EXPORT_ALIAS(rt_pm_dump_status, pm_dump, dump power management status);