4
0
mirror of https://github.com/RT-Thread/rt-thread.git synced 2025-02-01 07:40:23 +08:00

220 lines
5.5 KiB
C
Raw Normal View History

/*
* Copyright (c) 2006-2022, RT-Thread Development Team
2013-06-24 17:06:09 +08:00
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2006-03-23 Bernard the first version
* 2010-11-10 Bernard add cleanup callback function in thread exit.
* 2012-12-29 Bernard fix compiling warning.
* 2013-12-21 Grissiom let rt_thread_idle_excute loop until there is no
* dead thread.
* 2016-08-09 ArdaFu add method to get the handler of the idle thread.
* 2018-02-07 Bernard lock scheduler to protect tid->cleanup.
* 2018-07-14 armink add idle hook list
2018-11-22 14:40:43 +08:00
* 2018-11-22 Jesven add per cpu idle task
* combine the code of primary and secondary cpu
* 2021-11-15 THEWON Remove duplicate work between idle and _thread_exit
* 2023-09-15 xqyjlj perf rt_hw_interrupt_disable/enable
* 2023-11-07 xqyjlj fix thread exit
* 2023-12-10 xqyjlj add _hook_spinlock
*/
#include <rthw.h>
#include <rtthread.h>
2018-08-30 20:27:45 +08:00
#ifdef RT_USING_MODULE
#include <dlmodule.h>
2021-06-09 19:50:03 +08:00
#endif /* RT_USING_MODULE */
2018-08-30 20:27:45 +08:00
2021-06-09 19:50:03 +08:00
#ifdef RT_USING_HOOK
2017-05-16 10:02:19 +08:00
#ifndef RT_USING_IDLE_HOOK
#define RT_USING_IDLE_HOOK
2021-06-09 19:50:03 +08:00
#endif /* RT_USING_IDLE_HOOK */
#endif /* RT_USING_HOOK */
2017-05-16 10:02:19 +08:00
#ifndef IDLE_THREAD_STACK_SIZE
2017-05-16 10:02:19 +08:00
#if defined (RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP)
#define IDLE_THREAD_STACK_SIZE 256
#else
#define IDLE_THREAD_STACK_SIZE 128
2021-06-09 19:50:03 +08:00
#endif /* (RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP) */
#endif /* IDLE_THREAD_STACK_SIZE */
2018-11-22 14:40:43 +08:00
#define _CPUS_NR RT_CPUS_NR
static struct rt_thread idle_thread[_CPUS_NR];
rt_align(RT_ALIGN_SIZE)
static rt_uint8_t idle_thread_stack[_CPUS_NR][IDLE_THREAD_STACK_SIZE];
2018-11-22 22:06:02 +08:00
#ifdef RT_USING_IDLE_HOOK
#ifndef RT_IDLE_HOOK_LIST_SIZE
#define RT_IDLE_HOOK_LIST_SIZE 4
2021-06-09 19:50:03 +08:00
#endif /* RT_IDLE_HOOK_LIST_SIZE */
2018-11-22 22:06:02 +08:00
static void (*idle_hook_list[RT_IDLE_HOOK_LIST_SIZE])(void);
static struct rt_spinlock _hook_spinlock;
/**
* @brief This function sets a hook function to idle thread loop. When the system performs
* idle loop, this hook function should be invoked.
*
* @param hook the specified hook function.
*
* @return RT_EOK: set OK.
* -RT_EFULL: hook list is full.
2018-07-12 18:37:51 +08:00
*
* @note the hook function must be simple and never be blocked or suspend.
*/
2018-07-12 18:37:51 +08:00
rt_err_t rt_thread_idle_sethook(void (*hook)(void))
{
2018-07-12 18:37:51 +08:00
rt_size_t i;
rt_err_t ret = -RT_EFULL;
rt_base_t level;
level = rt_spin_lock_irqsave(&_hook_spinlock);
2018-07-12 18:37:51 +08:00
for (i = 0; i < RT_IDLE_HOOK_LIST_SIZE; i++)
2018-07-12 18:37:51 +08:00
{
if (idle_hook_list[i] == RT_NULL)
{
idle_hook_list[i] = hook;
ret = RT_EOK;
break;
2018-07-12 18:37:51 +08:00
}
}
rt_spin_unlock_irqrestore(&_hook_spinlock, level);
return ret;
}
2018-07-12 18:37:51 +08:00
/**
* @brief delete the idle hook on hook list.
2018-07-12 18:37:51 +08:00
*
* @param hook the specified hook function.
2018-07-12 18:37:51 +08:00
*
* @return RT_EOK: delete OK.
* -RT_ENOSYS: hook was not found.
2018-07-12 18:37:51 +08:00
*/
rt_err_t rt_thread_idle_delhook(void (*hook)(void))
{
rt_size_t i;
rt_err_t ret = -RT_ENOSYS;
rt_base_t level;
level = rt_spin_lock_irqsave(&_hook_spinlock);
2018-07-12 18:37:51 +08:00
for (i = 0; i < RT_IDLE_HOOK_LIST_SIZE; i++)
2018-07-12 18:37:51 +08:00
{
if (idle_hook_list[i] == hook)
{
idle_hook_list[i] = RT_NULL;
ret = RT_EOK;
break;
2018-07-12 18:37:51 +08:00
}
}
rt_spin_unlock_irqrestore(&_hook_spinlock, level);
return ret;
2018-07-12 18:37:51 +08:00
}
2021-06-09 19:50:03 +08:00
#endif /* RT_USING_IDLE_HOOK */
static void idle_thread_entry(void *parameter)
{
RT_UNUSED(parameter);
2018-11-22 14:40:43 +08:00
#ifdef RT_USING_SMP
if (rt_cpu_get_id() != 0)
2018-11-22 14:40:43 +08:00
{
while (1)
{
rt_hw_secondary_cpu_idle_exec();
}
}
2021-06-09 19:50:03 +08:00
#endif /* RT_USING_SMP */
2018-07-12 18:37:51 +08:00
while (1)
{
#ifdef RT_USING_IDLE_HOOK
2018-11-22 14:40:43 +08:00
rt_size_t i;
void (*idle_hook)(void);
2018-11-22 14:40:43 +08:00
for (i = 0; i < RT_IDLE_HOOK_LIST_SIZE; i++)
2017-05-22 23:53:55 +08:00
{
idle_hook = idle_hook_list[i];
if (idle_hook != RT_NULL)
2018-07-12 18:37:51 +08:00
{
idle_hook();
2018-07-12 18:37:51 +08:00
}
2017-05-22 23:53:55 +08:00
}
2021-06-09 19:50:03 +08:00
#endif /* RT_USING_IDLE_HOOK */
2017-05-22 23:53:55 +08:00
#if !defined(RT_USING_SMP) && !defined(RT_USING_SMART)
rt_defunct_execute();
#endif
2021-03-08 11:25:38 +08:00
#ifdef RT_USING_PM
2022-01-17 18:58:18 -05:00
void rt_system_power_manager(void);
rt_system_power_manager();
2021-06-09 19:50:03 +08:00
#endif /* RT_USING_PM */
}
}
/**
* @brief This function will initialize idle thread, then start it.
*
* @note this function must be invoked when system init.
*/
void rt_thread_idle_init(void)
{
rt_ubase_t i;
#if RT_NAME_MAX > 0
char idle_thread_name[RT_NAME_MAX];
#endif /* RT_NAME_MAX > 0 */
2018-11-22 14:40:43 +08:00
2024-08-30 21:11:47 +08:00
#ifdef RT_USING_IDLE_HOOK
2024-08-30 11:03:55 +08:00
rt_spin_lock_init(&_hook_spinlock);
2024-08-30 21:11:47 +08:00
#endif
2024-08-30 11:03:55 +08:00
2018-11-22 14:40:43 +08:00
for (i = 0; i < _CPUS_NR; i++)
{
#if RT_NAME_MAX > 0
rt_snprintf(idle_thread_name, RT_NAME_MAX, "tidle%d", i);
#endif /* RT_NAME_MAX > 0 */
rt_thread_init(&idle_thread[i],
#if RT_NAME_MAX > 0
idle_thread_name,
#else
"tidle",
#endif /* RT_NAME_MAX > 0 */
idle_thread_entry,
2018-11-22 14:40:43 +08:00
RT_NULL,
&idle_thread_stack[i][0],
sizeof(idle_thread_stack[i]),
2018-11-22 14:40:43 +08:00
RT_THREAD_PRIORITY_MAX - 1,
32);
#ifdef RT_USING_SMP
rt_thread_control(&idle_thread[i], RT_THREAD_CTRL_BIND_CPU, (void*)i);
#endif /* RT_USING_SMP */
2023-10-17 13:07:59 +08:00
/* update */
2023-10-17 13:07:59 +08:00
rt_cpu_index(i)->idle_thread = &idle_thread[i];
2018-11-22 14:40:43 +08:00
/* startup */
rt_thread_startup(&idle_thread[i]);
2018-11-22 14:40:43 +08:00
}
}
/**
* @brief This function will get the handler of the idle thread.
*/
rt_thread_t rt_thread_idle_gethandler(void)
{
int id = rt_cpu_get_id();
2018-11-22 14:40:43 +08:00
return (rt_thread_t)(&idle_thread[id]);
}