PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

support stm8

Browse Source 
1. see: TencentOS-tiny\board\STM8L052R8T6\IAR\hello_world
2. compile/debug/run with IAR for STM8
This commit is contained in:
daishengdong
2020-02-15 16:39:00 +08:00
parent 59e403891a
commit 405e5d970a
169 changed files with 49472 additions and 550 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
kernel/core/include/tos_compiler.h
View File

@@ -21,8 +21,8 @@
// function with __API__ prefix, api for user
#define __API__
// function with __KERNEL__ prefix, only for kernel
#define __KERNEL__
// function with __KNL__ prefix, only for kernel
#define __KNL__
// function with __HOOK__ prefix, should be implemented by user
#define __HOOK__
@@ -80,6 +80,7 @@
#define __NO_RETURN__ __attribute__((__noreturn__))
#define __NAKED__ __attribute__((naked))
#define __WEAK__ __attribute__((weak))
/*------------------ ICC Compiler ----------------------*/
#elif defined(__ICCARM__) || defined(__ICC430__) // __IAR_SYSTEMS_ICC__
@@ -102,6 +103,27 @@
#define __NAKED__
#define __WEAK__ __weak
/*------------------ ICC Compiler for STM8 ----------------------*/
#elif defined(__IAR_SYSTEMS_ICC__)
#define __ASM__ __asm
#define __VOLATILE__ volatile
#define __INLINE__ inline
#define __STATIC__ static
#define __STATIC_INLINE__ static inline
#define likely(x) (x)
#define unlikely(x) (x)
#define __UNUSED__
#define __USED__
#define __PACKED__
#define __ALIGNED__(x)
#define __PURE__
#define __CONST__
#define __NO_RETURN__
#define __NAKED__
#define __WEAK__ __weak
/*------------------ GNU Compiler ----------------------*/
#elif defined(__GNUC__)

2
kernel/core/include/tos_config_check.h
View File

@@ -70,7 +70,7 @@
#error "UNDECLARED config, TOS_CFG_CPU_HRTIMER_EN should be declared in 'port.h'"
#elif (TOS_CFG_CPU_HRTIMER_EN > 0u) && !defined(TOS_CFG_CPU_HRTIMER_SIZE)
#error "UNDECLARED config, TOS_CFG_CPU_HRTIMER_SIZE should be declared in 'port.h'"
#elif ((TOS_CFG_CPU_HRTIMER_SIZE != CPU_WORD_SIZE_08) && \
#elif (TOS_CFG_CPU_HRTIMER_EN > 0u) && ((TOS_CFG_CPU_HRTIMER_SIZE != CPU_WORD_SIZE_08) && \
(TOS_CFG_CPU_HRTIMER_SIZE != CPU_WORD_SIZE_16) && \
(TOS_CFG_CPU_HRTIMER_SIZE != CPU_WORD_SIZE_32) && \
(TOS_CFG_CPU_HRTIMER_SIZE != CPU_WORD_SIZE_64))

4
kernel/core/include/tos_k.h
View File

@@ -56,8 +56,12 @@
#include <tos_mmheap.h>
#include <tos_tick.h>
#include <tos_sched.h>
#if TOS_CFG_PWR_MGR_EN > 0u
#include <tos_pm.h>
#if TOS_CFG_TICKLESS_EN > 0u
#include <tos_tickless.h>
#endif
#endif
#include <tos_global.h>
#endif /* _TOS_K_H_ */

5
kernel/core/include/tos_ktypes.h
View File

@@ -36,7 +36,12 @@ typedef uint32_t k_time_t;
typedef uint32_t k_timeslice_t;
typedef uint32_t k_cycle_t;
#if TOS_CFG_CPU_DATA_SIZE == CPU_WORD_SIZE_08
typedef uint32_t k_tick_t;
#else
typedef uint64_t k_tick_t;
#endif
#define K_TRUE (1u)
#define K_FALSE (0u)

4
kernel/core/include/tos_mmheap.h
View File

@@ -256,9 +256,9 @@ __API__ k_err_t tos_mmheap_pool_check(void *pool_start, k_mmheap_info_t *info);
*/
__API__ k_err_t tos_mmheap_check(k_mmheap_info_t *info);
__KERNEL__ k_err_t mmheap_init(void);
__KNL__ k_err_t mmheap_init(void);
__KERNEL__ k_err_t mmheap_init_with_pool(void *pool_start, size_t pool_size);
__KNL__ k_err_t mmheap_init_with_pool(void *pool_start, size_t pool_size);
#endif

2
kernel/core/include/tos_mutex.h
View File

@@ -110,7 +110,7 @@ __API__ k_err_t tos_mutex_pend(k_mutex_t *mutex);
*/
__API__ k_err_t tos_mutex_post(k_mutex_t *mutex);
__KERNEL__ void mutex_release(k_mutex_t *mutex);
__KNL__ void mutex_release(k_mutex_t *mutex);
#endif

26
kernel/core/include/tos_pend.h
View File

@@ -41,31 +41,31 @@ typedef struct pend_object_st {
k_list_t list;
} pend_obj_t;
__KERNEL__ void pend_object_init(pend_obj_t *object);
__KNL__ void pend_object_init(pend_obj_t *object);
__KERNEL__ void pend_object_deinit(pend_obj_t *object);
__KNL__ void pend_object_deinit(pend_obj_t *object);
__KERNEL__ int pend_is_nopending(pend_obj_t *object);
__KNL__ int pend_is_nopending(pend_obj_t *object);
__KERNEL__ k_prio_t pend_highest_pending_prio_get(pend_obj_t *object);
__KNL__ k_prio_t pend_highest_pending_prio_get(pend_obj_t *object);
__KERNEL__ k_task_t *pend_highest_pending_task_get(pend_obj_t *object);
__KNL__ k_task_t *pend_highest_pending_task_get(pend_obj_t *object);
__KERNEL__ void pend_list_remove(k_task_t *task);
__KNL__ void pend_list_remove(k_task_t *task);
__KERNEL__ void pend_list_adjust(k_task_t *task);
__KNL__ void pend_list_adjust(k_task_t *task);
__KERNEL__ k_err_t pend_state2errno(pend_state_t state);
__KNL__ k_err_t pend_state2errno(pend_state_t state);
__KERNEL__ void pend_task_wakeup(k_task_t *task, pend_state_t state);
__KNL__ void pend_task_wakeup(k_task_t *task, pend_state_t state);
__KERNEL__ void pend_task_block(k_task_t *task, pend_obj_t *object, k_tick_t timeout);
__KNL__ void pend_task_block(k_task_t *task, pend_obj_t *object, k_tick_t timeout);
__KERNEL__ void pend_wakeup_one(pend_obj_t *object, pend_state_t state);
__KNL__ void pend_wakeup_one(pend_obj_t *object, pend_state_t state);
__KERNEL__ void pend_wakeup_all(pend_obj_t *object, pend_state_t state);
__KNL__ void pend_wakeup_all(pend_obj_t *object, pend_state_t state);
__KERNEL__ void pend_wakeup(pend_obj_t *object, pend_state_t state, opt_post_t opt);
__KNL__ void pend_wakeup(pend_obj_t *object, pend_state_t state, opt_post_t opt);
#endif /* _TOS_PEND_H_ */

2
kernel/core/include/tos_robin.h
View File

@@ -46,7 +46,7 @@ __API__ void tos_robin_timeslice_set(k_task_t *task, k_timeslice_t timeslice)
*/
__API__ void tos_robin_default_timeslice_config(k_timeslice_t default_timeslice);
__KERNEL__ void robin_sched(k_prio_t prio);
__KNL__ void robin_sched(k_prio_t prio);
#endif

18
kernel/core/include/tos_sched.h
View File

@@ -30,23 +30,23 @@ typedef struct readyqueue_st {
k_prio_t highest_prio;
} readyqueue_t;
__KERNEL__ void readyqueue_init(void);
__KNL__ void readyqueue_init(void);
__KERNEL__ int readyqueue_is_prio_onlyone(k_prio_t prio);
__KNL__ int readyqueue_is_prio_onlyone(k_prio_t prio);
__KERNEL__ k_task_t *readyqueue_first_task_get(k_prio_t prio);
__KNL__ k_task_t *readyqueue_first_task_get(k_prio_t prio);
__KERNEL__ k_task_t *readyqueue_highest_ready_task_get(void);
__KNL__ k_task_t *readyqueue_highest_ready_task_get(void);
__KERNEL__ void readyqueue_add_head(k_task_t *task);
__KNL__ void readyqueue_add_head(k_task_t *task);
__KERNEL__ void readyqueue_add_tail(k_task_t *task);
__KNL__ void readyqueue_add_tail(k_task_t *task);
__KERNEL__ void readyqueue_add(k_task_t *task);
__KNL__ void readyqueue_add(k_task_t *task);
__KERNEL__ void readyqueue_remove(k_task_t *task);
__KNL__ void readyqueue_remove(k_task_t *task);
__KERNEL__ void readyqueue_move_head_to_tail(k_prio_t prio);
__KNL__ void readyqueue_move_head_to_tail(k_prio_t prio);
#endif /* _TOS_SCHED_H_ */

30
kernel/core/include/tos_sys.h
View File

@@ -160,29 +160,29 @@ __API__ k_err_t tos_knl_sched_lock(void);
__API__ k_err_t tos_knl_sched_unlock(void);
#if TOS_CFG_TICKLESS_EN > 0u
__KERNEL__ k_tick_t knl_next_expires_get(void);
__KNL__ k_tick_t knl_next_expires_get(void);
#endif
__KERNEL__ void knl_sched(void);
__KERNEL__ int knl_is_sched_locked(void);
__KERNEL__ int knl_is_inirq(void);
__KERNEL__ int knl_is_idle(k_task_t *task);
__KERNEL__ int knl_is_self(k_task_t *task);
__KERNEL__ k_err_t knl_idle_init(void);
__KNL__ void knl_sched(void);
__KNL__ int knl_is_sched_locked(void);
__KNL__ int knl_is_inirq(void);
__KNL__ int knl_is_idle(k_task_t *task);
__KNL__ int knl_is_self(k_task_t *task);
__KNL__ k_err_t knl_idle_init(void);
#if TOS_CFG_OBJECT_VERIFY_EN > 0u
__KERNEL__ __STATIC_INLINE__ int knl_object_verify(knl_obj_t *knl_obj, knl_obj_type_t type)
__KNL__ __STATIC_INLINE__ int knl_object_verify(knl_obj_t *knl_obj, knl_obj_type_t type)
{
return knl_obj->type == type;
}
__KERNEL__ __STATIC_INLINE__ void knl_object_init(knl_obj_t *knl_obj, knl_obj_type_t type)
__KNL__ __STATIC_INLINE__ void knl_object_init(knl_obj_t *knl_obj, knl_obj_type_t type)
{
knl_obj->type = type;
}
__KERNEL__ __STATIC_INLINE__ void knl_object_deinit(knl_obj_t *knl_obj)
__KNL__ __STATIC_INLINE__ void knl_object_deinit(knl_obj_t *knl_obj)
{
knl_obj->type = KNL_OBJ_TYPE_NONE;
}
@@ -191,27 +191,27 @@ __KERNEL__ __STATIC_INLINE__ void knl_object_deinit(knl_obj_t *knl_obj)
#if TOS_CFG_MMHEAP_EN > 0u
__KERNEL__ __STATIC_INLINE__ void knl_object_alloc_reset(knl_obj_t *knl_obj)
__KNL__ __STATIC_INLINE__ void knl_object_alloc_reset(knl_obj_t *knl_obj)
{
knl_obj->alloc_type = KNL_OBJ_ALLOC_TYPE_NONE;
}
__KERNEL__ __STATIC_INLINE__ void knl_object_alloc_set_dynamic(knl_obj_t *knl_obj)
__KNL__ __STATIC_INLINE__ void knl_object_alloc_set_dynamic(knl_obj_t *knl_obj)
{
knl_obj->alloc_type = KNL_OBJ_ALLOC_TYPE_DYNAMIC;
}
__KERNEL__ __STATIC_INLINE__ void knl_object_alloc_set_static(knl_obj_t *knl_obj)
__KNL__ __STATIC_INLINE__ void knl_object_alloc_set_static(knl_obj_t *knl_obj)
{
knl_obj->alloc_type = KNL_OBJ_ALLOC_TYPE_STATIC;
}
__KERNEL__ __STATIC_INLINE__ int knl_object_alloc_is_dynamic(knl_obj_t *knl_obj)
__KNL__ __STATIC_INLINE__ int knl_object_alloc_is_dynamic(knl_obj_t *knl_obj)
{
return knl_obj->alloc_type == KNL_OBJ_ALLOC_TYPE_DYNAMIC;
}
__KERNEL__ __STATIC_INLINE__ int knl_object_alloc_is_static(knl_obj_t *knl_obj)
__KNL__ __STATIC_INLINE__ int knl_object_alloc_is_static(knl_obj_t *knl_obj)
{
return knl_obj->alloc_type == KNL_OBJ_ALLOC_TYPE_STATIC;
}

26
kernel/core/include/tos_task.h
View File

@@ -337,64 +337,64 @@ __API__ void tos_task_walkthru(k_task_walker_t walker);
*/
__DEBUG__ void tos_task_info_display(void);
__KERNEL__ void task_free_all(void);
__KNL__ void task_free_all(void);
__KERNEL__ __STATIC_INLINE__ int task_state_is_ready(k_task_t *task)
__KNL__ __STATIC_INLINE__ int task_state_is_ready(k_task_t *task)
{
return task->state == K_TASK_STATE_READY;
}
__KERNEL__ __STATIC_INLINE__ int task_state_is_sleeping(k_task_t *task)
__KNL__ __STATIC_INLINE__ int task_state_is_sleeping(k_task_t *task)
{
return task->state & K_TASK_STATE_SLEEP;
}
__KERNEL__ __STATIC_INLINE__ int task_state_is_pending(k_task_t *task)
__KNL__ __STATIC_INLINE__ int task_state_is_pending(k_task_t *task)
{
return task->state & K_TASK_STATE_PEND;
}
__KERNEL__ __STATIC_INLINE__ int task_state_is_suspended(k_task_t *task)
__KNL__ __STATIC_INLINE__ int task_state_is_suspended(k_task_t *task)
{
return task->state & K_TASK_STATE_SUSPENDED;
}
__KERNEL__ __STATIC_INLINE__ void task_state_reset_pending(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_reset_pending(k_task_t *task)
{
task->state &= ~K_TASK_STATE_PEND;
}
__KERNEL__ __STATIC_INLINE__ void task_state_reset_sleeping(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_reset_sleeping(k_task_t *task)
{
task->state &= ~K_TASK_STATE_SLEEP;
}
__KERNEL__ __STATIC_INLINE__ void task_state_reset_suspended(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_reset_suspended(k_task_t *task)
{
task->state &= ~K_TASK_STATE_SUSPENDED;
}
__KERNEL__ __STATIC_INLINE__ void task_state_set_suspended(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_set_suspended(k_task_t *task)
{
task->state |= K_TASK_STATE_SUSPENDED;
}
__KERNEL__ __STATIC_INLINE__ void task_state_set_pend(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_set_pend(k_task_t *task)
{
task->state |= K_TASK_STATE_PEND;
}
__KERNEL__ __STATIC_INLINE__ void task_state_set_ready(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_set_ready(k_task_t *task)
{
task->state = K_TASK_STATE_READY;
}
__KERNEL__ __STATIC_INLINE__ void task_state_set_deleted(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_set_deleted(k_task_t *task)
{
task->state = K_TASK_STATE_DELETED;
}
__KERNEL__ __STATIC_INLINE__ void task_state_set_sleeping(k_task_t *task)
__KNL__ __STATIC_INLINE__ void task_state_set_sleeping(k_task_t *task)
{
task->state |= K_TASK_STATE_SLEEP;
}

10
kernel/core/include/tos_tick.h
View File

@@ -28,16 +28,16 @@
*
* @return None
*/
__API__ void tos_tick_handler(void);
__API__ void tos_tick_handler(void);
__KERNEL__ void tick_update(k_tick_t tick);
__KNL__ void tick_update(k_tick_t tick);
__KERNEL__ void tick_list_add(k_task_t *task, k_tick_t timeout);
__KNL__ void tick_list_add(k_task_t *task, k_tick_t timeout);
__KERNEL__ void tick_list_remove(k_task_t *task);
__KNL__ void tick_list_remove(k_task_t *task);
#if TOS_CFG_TICKLESS_EN > 0u
__KERNEL__ k_tick_t tick_next_expires_get(void);
__KNL__ k_tick_t tick_next_expires_get(void);
#endif
#endif /* _TOS_TICK_H_ */

6
kernel/core/include/tos_timer.h
View File

@@ -175,13 +175,13 @@ __API__ k_err_t tos_timer_period_change(k_timer_t *tmr, k_tick_t period);
*
* @return None
*/
__KERNEL__ void timer_update(void);
__KNL__ void timer_update(void);
#endif
__KERNEL__ k_err_t timer_init(void);
__KNL__ k_err_t timer_init(void);
__KERNEL__ k_tick_t timer_next_expires_get(void);
__KNL__ k_tick_t timer_next_expires_get(void);
#endif

4
kernel/core/tos_mmheap.c
View File

@@ -572,13 +572,13 @@ __STATIC__ void mmheap_ctl_init(void)
}
}
__KERNEL__ k_err_t mmheap_init(void)
__KNL__ k_err_t mmheap_init(void)
{
mmheap_ctl_init();
return K_ERR_NONE;
}
__KERNEL__ k_err_t mmheap_init_with_pool(void *pool_start, size_t pool_size)
__KNL__ k_err_t mmheap_init_with_pool(void *pool_start, size_t pool_size)
{
mmheap_ctl_init();

2
kernel/core/tos_mutex.c
View File

@@ -61,7 +61,7 @@ __STATIC_INLINE__ void mutex_new_owner_mark(k_mutex_t *mutex, k_task_t *task)
}
}
__KERNEL__ void mutex_release(k_mutex_t *mutex)
__KNL__ void mutex_release(k_mutex_t *mutex)
{
mutex_old_owner_release(mutex);
pend_wakeup_all(&mutex->pend_obj, PEND_STATE_OWNER_DIE);

26
kernel/core/tos_pend.c
View File

@@ -36,7 +36,7 @@ __STATIC__ void pend_list_add(k_task_t *task, pend_obj_t *pend_obj)
task_state_set_pend(task);
}
__KERNEL__ k_prio_t pend_highest_pending_prio_get(pend_obj_t *object)
__KNL__ k_prio_t pend_highest_pending_prio_get(pend_obj_t *object)
{
k_task_t *task;
@@ -45,12 +45,12 @@ __KERNEL__ k_prio_t pend_highest_pending_prio_get(pend_obj_t *object)
return task ? task->prio : K_TASK_PRIO_INVALID;
}
__KERNEL__ k_task_t *pend_highest_pending_task_get(pend_obj_t *object)
__KNL__ k_task_t *pend_highest_pending_task_get(pend_obj_t *object)
{
return TOS_LIST_FIRST_ENTRY(&object->list, k_task_t, pend_list);
}
__KERNEL__ void pend_list_remove(k_task_t *task)
__KNL__ void pend_list_remove(k_task_t *task)
{
tos_list_del(&task->pend_list);
@@ -58,22 +58,22 @@ __KERNEL__ void pend_list_remove(k_task_t *task)
task_state_reset_pending(task);
}
__KERNEL__ void pend_object_init(pend_obj_t *object)
__KNL__ void pend_object_init(pend_obj_t *object)
{
tos_list_init(&object->list);
}
__KERNEL__ void pend_object_deinit(pend_obj_t *object)
__KNL__ void pend_object_deinit(pend_obj_t *object)
{
tos_list_init(&object->list);
}
__KERNEL__ int pend_is_nopending(pend_obj_t *object)
__KNL__ int pend_is_nopending(pend_obj_t *object)
{
return tos_list_empty(&object->list);
}
__KERNEL__ void pend_list_adjust(k_task_t *task)
__KNL__ void pend_list_adjust(k_task_t *task)
{
// we may be the boss, so re-enter the pend list
tos_list_del(&task->pend_list);
@@ -81,7 +81,7 @@ __KERNEL__ void pend_list_adjust(k_task_t *task)
pend_list_add(task, task->pending_obj);
}
__KERNEL__ k_err_t pend_state2errno(pend_state_t state)
__KNL__ k_err_t pend_state2errno(pend_state_t state)
{
if (state == PEND_STATE_POST) {
return K_ERR_NONE;
@@ -96,7 +96,7 @@ __KERNEL__ k_err_t pend_state2errno(pend_state_t state)
}
}
__KERNEL__ void pend_task_wakeup(k_task_t *task, pend_state_t state)
__KNL__ void pend_task_wakeup(k_task_t *task, pend_state_t state)
{
if (task_state_is_pending(task)) {
// mark why we wakeup
@@ -115,7 +115,7 @@ __KERNEL__ void pend_task_wakeup(k_task_t *task, pend_state_t state)
readyqueue_add(task);
}
__KERNEL__ void pend_task_block(k_task_t *task, pend_obj_t *object, k_tick_t timeout)
__KNL__ void pend_task_block(k_task_t *task, pend_obj_t *object, k_tick_t timeout)
{
readyqueue_remove(task);
@@ -127,12 +127,12 @@ __KERNEL__ void pend_task_block(k_task_t *task, pend_obj_t *object, k_tick_t tim
}
}
__KERNEL__ void pend_wakeup_one(pend_obj_t *object, pend_state_t state)
__KNL__ void pend_wakeup_one(pend_obj_t *object, pend_state_t state)
{
pend_task_wakeup(TOS_LIST_FIRST_ENTRY(&object->list, k_task_t, pend_list), state);
}
__KERNEL__ void pend_wakeup_all(pend_obj_t *object, pend_state_t state)
__KNL__ void pend_wakeup_all(pend_obj_t *object, pend_state_t state)
{
k_task_t *task, *tmp;
@@ -141,7 +141,7 @@ __KERNEL__ void pend_wakeup_all(pend_obj_t *object, pend_state_t state)
}
}
__KERNEL__ void pend_wakeup(pend_obj_t *object, pend_state_t state, opt_post_t opt)
__KNL__ void pend_wakeup(pend_obj_t *object, pend_state_t state, opt_post_t opt)
{
if (opt == OPT_POST_ONE) {
pend_wakeup_one(object, state);

2
kernel/core/tos_robin.c
View File

@@ -56,7 +56,7 @@ __API__ void tos_robin_timeslice_set(k_task_t *task, k_timeslice_t timeslice)
TOS_CPU_INT_ENABLE();
}
__KERNEL__ void robin_sched(k_prio_t prio)
__KNL__ void robin_sched(k_prio_t prio)
{
TOS_CPU_CPSR_ALLOC();
k_task_t *task;

18
kernel/core/tos_sched.c
View File

@@ -55,7 +55,7 @@ __STATIC_INLINE__ void readyqueue_prio_mark(k_prio_t prio)
/**
* when this function involved, must be at least one task in the task list of the certain priority
*/
__KERNEL__ int readyqueue_is_prio_onlyone(k_prio_t prio)
__KNL__ int readyqueue_is_prio_onlyone(k_prio_t prio)
{
k_list_t *task_list;
k_task_t *task;
@@ -65,7 +65,7 @@ __KERNEL__ int readyqueue_is_prio_onlyone(k_prio_t prio)
return task->pend_list.next == task_list;
}
__KERNEL__ k_task_t *readyqueue_first_task_get(k_prio_t prio)
__KNL__ k_task_t *readyqueue_first_task_get(k_prio_t prio)
{
k_list_t *task_list;
@@ -73,7 +73,7 @@ __KERNEL__ k_task_t *readyqueue_first_task_get(k_prio_t prio)
return TOS_LIST_FIRST_ENTRY_OR_NULL(task_list, k_task_t, pend_list);
}
__KERNEL__ k_task_t *readyqueue_highest_ready_task_get(void)
__KNL__ k_task_t *readyqueue_highest_ready_task_get(void)
{
k_list_t *task_list;
@@ -81,7 +81,7 @@ __KERNEL__ k_task_t *readyqueue_highest_ready_task_get(void)
return TOS_LIST_FIRST_ENTRY(task_list, k_task_t, pend_list);
}
__KERNEL__ void readyqueue_init(void)
__KNL__ void readyqueue_init(void)
{
uint8_t i;
@@ -96,7 +96,7 @@ __KERNEL__ void readyqueue_init(void)
}
}
__KERNEL__ void readyqueue_add_head(k_task_t *task)
__KNL__ void readyqueue_add_head(k_task_t *task)
{
k_prio_t task_prio;
k_list_t *task_list;
@@ -111,7 +111,7 @@ __KERNEL__ void readyqueue_add_head(k_task_t *task)
tos_list_add(&task->pend_list, task_list);
}
__KERNEL__ void readyqueue_add_tail(k_task_t *task)
__KNL__ void readyqueue_add_tail(k_task_t *task)
{
k_prio_t task_prio;
k_list_t *task_list;
@@ -126,7 +126,7 @@ __KERNEL__ void readyqueue_add_tail(k_task_t *task)
tos_list_add_tail(&task->pend_list, task_list);
}
__KERNEL__ void readyqueue_add(k_task_t *task)
__KNL__ void readyqueue_add(k_task_t *task)
{
if (task->prio == k_curr_task->prio) {
readyqueue_add_tail(task);
@@ -135,7 +135,7 @@ __KERNEL__ void readyqueue_add(k_task_t *task)
}
}
__KERNEL__ void readyqueue_remove(k_task_t *task)
__KNL__ void readyqueue_remove(k_task_t *task)
{
k_prio_t task_prio;
k_list_t *task_list;
@@ -154,7 +154,7 @@ __KERNEL__ void readyqueue_remove(k_task_t *task)
}
}
__KERNEL__ void readyqueue_move_head_to_tail(k_prio_t prio)
__KNL__ void readyqueue_move_head_to_tail(k_prio_t prio)
{
k_list_t *task_list;

14
kernel/core/tos_sys.c
View File

@@ -177,7 +177,7 @@ __API__ int tos_knl_is_running(void)
*
* @return The remian ticks of the first oncoming task to be scheduled.
*/
__KERNEL__ k_tick_t knl_next_expires_get(void)
__KNL__ k_tick_t knl_next_expires_get(void)
{
k_tick_t tick_next_expires;
#if TOS_CFG_TIMER_EN > 0u
@@ -199,7 +199,7 @@ __KERNEL__ k_tick_t knl_next_expires_get(void)
#endif
__KERNEL__ void knl_sched(void)
__KNL__ void knl_sched(void)
{
TOS_CPU_CPSR_ALLOC();
@@ -226,22 +226,22 @@ __KERNEL__ void knl_sched(void)
TOS_CPU_INT_ENABLE();
}
__KERNEL__ int knl_is_sched_locked(void)
__KNL__ int knl_is_sched_locked(void)
{
return k_sched_lock_nest_cnt > 0u;
}
__KERNEL__ int knl_is_inirq(void)
__KNL__ int knl_is_inirq(void)
{
return k_irq_nest_cnt > 0u;
}
__KERNEL__ int knl_is_idle(k_task_t *task)
__KNL__ int knl_is_idle(k_task_t *task)
{
return task == &k_idle_task;
}
__KERNEL__ int knl_is_self(k_task_t *task)
__KNL__ int knl_is_self(k_task_t *task)
{
return task == k_curr_task;
}
@@ -261,7 +261,7 @@ __STATIC__ void knl_idle_entry(void *arg)
}
}
__KERNEL__ k_err_t knl_idle_init(void)
__KNL__ k_err_t knl_idle_init(void)
{
return tos_task_create(&k_idle_task, "idle",
knl_idle_entry, K_NULL,

2
kernel/core/tos_task.c
View File

@@ -215,7 +215,7 @@ __STATIC__ void task_free(k_task_t *task)
tos_mmheap_free(task);
}
__KERNEL__ void task_free_all(void)
__KNL__ void task_free_all(void)
{
TOS_CPU_CPSR_ALLOC();
k_task_t *task, *tmp;

8
kernel/core/tos_tick.c
View File

@@ -69,19 +69,19 @@ __STATIC__ void tick_task_takeoff(k_task_t *task)
TOS_CPU_INT_ENABLE();
}
__KERNEL__ void tick_list_add(k_task_t *task, k_tick_t timeout)
__KNL__ void tick_list_add(k_task_t *task, k_tick_t timeout)
{
tick_task_place(task, timeout);
task_state_set_sleeping(task);
}
__KERNEL__ void tick_list_remove(k_task_t *task)
__KNL__ void tick_list_remove(k_task_t *task)
{
tick_task_takeoff(task);
task_state_reset_sleeping(task);
}
__KERNEL__ void tick_update(k_tick_t tick)
__KNL__ void tick_update(k_tick_t tick)
{
TOS_CPU_CPSR_ALLOC();
k_task_t *first, *task, *tmp;
@@ -115,7 +115,7 @@ __KERNEL__ void tick_update(k_tick_t tick)
TOS_CPU_INT_ENABLE();
}
__KERNEL__ k_tick_t tick_next_expires_get(void)
__KNL__ k_tick_t tick_next_expires_get(void)
{
TOS_CPU_CPSR_ALLOC();
k_tick_t next_expires;

6
kernel/core/tos_timer.c
View File

@@ -253,7 +253,7 @@ __API__ k_err_t tos_timer_period_change(k_timer_t *tmr, k_tick_t period)
return timer_change(tmr, period, TIMER_CHANGE_TYPE_PERIOD);
}
__KERNEL__ k_tick_t timer_next_expires_get(void)
__KNL__ k_tick_t timer_next_expires_get(void)
{
TOS_CPU_CPSR_ALLOC();
k_tick_t next_expires;
@@ -274,7 +274,7 @@ __KERNEL__ k_tick_t timer_next_expires_get(void)
#if TOS_CFG_TIMER_AS_PROC > 0u
__KERNEL__ void timer_update(void)
__KNL__ void timer_update(void)
{
k_timer_t *tmr, *tmp;
@@ -347,7 +347,7 @@ __STATIC__ void timer_task_entry(void *arg)
#endif
__KERNEL__ k_err_t timer_init(void)
__KNL__ k_err_t timer_init(void)
{
#if TOS_CFG_TIMER_AS_PROC > 0u
return K_ERR_NONE;

4
kernel/evtdrv/include/tos_evtdrv_event.h
View File

@@ -68,9 +68,9 @@ __API__ evtdrv_err_t tos_evtdrv_event_set(evtdrv_task_id_t task_id, evtdrv_event
*/
__API__ evtdrv_err_t tos_evtdrv_event_reset(evtdrv_task_id_t task_id, evtdrv_event_flag_t event_flags);
__KERNEL__ evtdrv_err_t evtdrv_event_init(void);
__KNL__ evtdrv_err_t evtdrv_event_init(void);
__KERNEL__ evtdrv_event_flag_t evtdrv_event_fetch(evtdrv_task_id_t *task_id);
__KNL__ evtdrv_event_flag_t evtdrv_event_fetch(evtdrv_task_id_t *task_id);
__STATIC_INLINE__ evtdrv_bool_t evtdrv_event_is_usr(evtdrv_event_flag_t event_flag)
{

2
kernel/evtdrv/include/tos_evtdrv_msg.h
View File

@@ -78,7 +78,7 @@ __API__ evtdrv_err_t tos_evtdrv_msg_send(evtdrv_task_id_t dst_task_id, evtdrv_ms
__API__ evtdrv_msg_body_t tos_evtdrv_msg_recv(void);
__KERNEL__ void evtdrv_msg_init(void);
__KNL__ void evtdrv_msg_init(void);
#endif /* TOS_CFG_EVENT_DRIVEN_EN */

6
kernel/evtdrv/include/tos_evtdrv_task.h
View File

@@ -36,11 +36,11 @@ typedef evtdrv_event_flag_t (*evtdrv_task_entry_t)(evtdrv_event_flag_t event_fla
*/
__API__ evtdrv_task_id_t tos_evtdrv_task_self(void);
__KERNEL__ evtdrv_bool_t evtdrv_task_id_is_invalid(evtdrv_task_id_t task_id);
__KNL__ evtdrv_bool_t evtdrv_task_id_is_invalid(evtdrv_task_id_t task_id);
__KERNEL__ evtdrv_bool_t evtdrv_task_is_self(evtdrv_task_id_t task_id);
__KNL__ evtdrv_bool_t evtdrv_task_is_self(evtdrv_task_id_t task_id);
__KERNEL__ void evtdrv_task_init(void);
__KNL__ void evtdrv_task_init(void);
#endif /* TOS_CFG_EVENT_DRIVEN_EN */

2
kernel/evtdrv/include/tos_evtdrv_timer.h
View File

@@ -93,7 +93,7 @@ __API__ evtdrv_err_t tos_evtdrv_timer_start(evtdrv_timer_t *tmr, evtdrv_tick_t t
*/
__API__ evtdrv_err_t tos_evtdrv_timer_stop(evtdrv_timer_t *tmr);
__KERNEL__ void evtdrv_timer_update(void);
__KNL__ void evtdrv_timer_update(void);
#endif /* _TOS_EVTDRV_TIMER_H_ */

4
kernel/evtdrv/tos_evtdrv_event.c
View File

@@ -88,7 +88,7 @@ __API__ evtdrv_err_t tos_evtdrv_event_reset(evtdrv_task_id_t task_id, evtdrv_eve
return EVTDRV_ERR_NONE;
}
__KERNEL__ evtdrv_err_t evtdrv_event_init(void)
__KNL__ evtdrv_err_t evtdrv_event_init(void)
{
evtdrv_task_id_t i;
evtdrv_event_t *event;
@@ -106,7 +106,7 @@ __KERNEL__ evtdrv_err_t evtdrv_event_init(void)
return EVTDRV_ERR_NONE;
}
__KERNEL__ evtdrv_event_flag_t evtdrv_event_fetch(evtdrv_task_id_t *task_id)
__KNL__ evtdrv_event_flag_t evtdrv_event_fetch(evtdrv_task_id_t *task_id)
{
evtdrv_task_id_t i;
evtdrv_event_t *event;

2
kernel/evtdrv/tos_evtdrv_msg.c
View File

@@ -112,7 +112,7 @@ __API__ evtdrv_msg_body_t tos_evtdrv_msg_recv(void)
return K_NULL;
}
__KERNEL__ void evtdrv_msg_init(void)
__KNL__ void evtdrv_msg_init(void)
{
tos_list_init(&evtdrv_msg_list);
}

6
kernel/evtdrv/tos_evtdrv_task.c
View File

@@ -24,17 +24,17 @@ __API__ evtdrv_task_id_t tos_evtdrv_task_self(void)
return evtdrv_curr_task;
}
__KERNEL__ evtdrv_bool_t evtdrv_task_id_is_invalid(evtdrv_task_id_t task_id)
__KNL__ evtdrv_bool_t evtdrv_task_id_is_invalid(evtdrv_task_id_t task_id)
{
return task_id >= evtdrv_task_table_size;
}
__KERNEL__ evtdrv_bool_t evtdrv_task_is_self(evtdrv_task_id_t task_id)
__KNL__ evtdrv_bool_t evtdrv_task_is_self(evtdrv_task_id_t task_id)
{
return task_id == evtdrv_curr_task;
}
__KERNEL__ void evtdrv_task_init(void)
__KNL__ void evtdrv_task_init(void)
{
evtdrv_task_id_t i;

2
kernel/evtdrv/tos_evtdrv_timer.c
View File

@@ -95,7 +95,7 @@ __API__ evtdrv_err_t tos_evtdrv_timer_stop(evtdrv_timer_t *tmr)
return EVTDRV_ERR_NONE;
}
__KERNEL__ void evtdrv_timer_update(void)
__KNL__ void evtdrv_timer_update(void)
{
TOS_CPU_CPSR_ALLOC();
evtdrv_timer_t *tmr, *tmp;

18
kernel/pm/include/tos_pm.h
View File

@@ -78,23 +78,23 @@ __API__ k_err_t tos_pm_cpu_lpwr_mode_set(k_cpu_lpwr_mode_t cpu_lpwr_mode);
__API__ k_err_t tos_pm_device_register(k_pm_device_t *device);
__KERNEL__ void pm_init(void);
__KNL__ void pm_init(void);
__KERNEL__ void pm_cpu_lpwr_mode_enter(k_cpu_lpwr_mode_t lpwr_mode);
__KNL__ void pm_cpu_lpwr_mode_enter(k_cpu_lpwr_mode_t lpwr_mode);
__KERNEL__ k_cpu_lpwr_mode_t pm_cpu_lpwr_mode_get(void);
__KNL__ k_cpu_lpwr_mode_t pm_cpu_lpwr_mode_get(void);
__KERNEL__ void pm_idle_pwr_mgr_mode_set(idle_pwrmgr_mode_t idle_pwrmgr_mode);
__KNL__ void pm_idle_pwr_mgr_mode_set(idle_pwrmgr_mode_t idle_pwrmgr_mode);
__KERNEL__ int pm_idle_pwr_mgr_mode_is_sleep(void);
__KNL__ int pm_idle_pwr_mgr_mode_is_sleep(void);
__KERNEL__ int pm_idle_pwr_mgr_mode_is_tickless(void);
__KNL__ int pm_idle_pwr_mgr_mode_is_tickless(void);
__KERNEL__ void pm_power_manager(void);
__KNL__ void pm_power_manager(void);
__KERNEL__ int pm_device_suspend(void);
__KNL__ int pm_device_suspend(void);
__KERNEL__ int pm_device_resume(void);
__KNL__ int pm_device_resume(void);
#endif /* TOS_CFG_PWR_MGR_EN */

6
kernel/pm/include/tos_tickless.h
View File

@@ -33,11 +33,11 @@ __API__ k_err_t tos_tickless_wkup_alarm_init(k_cpu_lpwr_mode_t mode);
__HOOK__ int tos_bsp_tickless_setup(void);
__KERNEL__ int tickless_wkup_alarm_is_installed(k_cpu_lpwr_mode_t mode);
__KNL__ int tickless_wkup_alarm_is_installed(k_cpu_lpwr_mode_t mode);
__KERNEL__ void tickless_init(void);
__KNL__ void tickless_init(void);
__KERNEL__ void tickless_proc(void);
__KNL__ void tickless_proc(void);
#endif /* TOS_CFG_TICKLESS_EN */

18
kernel/pm/tos_pm.c
View File

@@ -64,7 +64,7 @@ __API__ k_err_t tos_pm_device_register(k_pm_device_t *device)
return K_ERR_NONE;
}
__KERNEL__ void pm_init(void)
__KNL__ void pm_init(void)
{
memset(&k_pm_device_ctl, 0, sizeof(k_pm_device_ctl));
k_pm_device_ctl.count = 0u;
@@ -85,7 +85,7 @@ __STATIC_INLINE__ void pm_cpu_standby_mode_enter(void)
cpu_standby_mode_enter();
}
__KERNEL__ void pm_cpu_lpwr_mode_enter(k_cpu_lpwr_mode_t lpwr_mode)
__KNL__ void pm_cpu_lpwr_mode_enter(k_cpu_lpwr_mode_t lpwr_mode)
{
if (TOS_LOW_POWER_MODE_SLEEP == lpwr_mode) {
pm_cpu_sleep_mode_enter();
@@ -100,27 +100,27 @@ __KERNEL__ void pm_cpu_lpwr_mode_enter(k_cpu_lpwr_mode_t lpwr_mode)
}
}
__KERNEL__ k_cpu_lpwr_mode_t pm_cpu_lpwr_mode_get(void)
__KNL__ k_cpu_lpwr_mode_t pm_cpu_lpwr_mode_get(void)
{
return k_cpu_lpwr_mode;
}
__KERNEL__ void pm_idle_pwr_mgr_mode_set(idle_pwrmgr_mode_t idle_pwrmgr_mode)
__KNL__ void pm_idle_pwr_mgr_mode_set(idle_pwrmgr_mode_t idle_pwrmgr_mode)
{
k_idle_pwr_mgr_mode = idle_pwrmgr_mode;
}
__KERNEL__ int pm_idle_pwr_mgr_mode_is_sleep(void)
__KNL__ int pm_idle_pwr_mgr_mode_is_sleep(void)
{
return k_idle_pwr_mgr_mode == IDLE_POWER_MANAGER_MODE_SLEEP;
}
__KERNEL__ int pm_idle_pwr_mgr_mode_is_tickless(void)
__KNL__ int pm_idle_pwr_mgr_mode_is_tickless(void)
{
return k_idle_pwr_mgr_mode == IDLE_POWER_MANAGER_MODE_TICKLESS;
}
__KERNEL__ void pm_power_manager(void)
__KNL__ void pm_power_manager(void)
{
if (pm_idle_pwr_mgr_mode_is_sleep()) {
pm_cpu_sleep_mode_enter();
@@ -133,7 +133,7 @@ __KERNEL__ void pm_power_manager(void)
#endif
}
__KERNEL__ int pm_device_suspend(void)
__KNL__ int pm_device_suspend(void)
{
uint8_t i = 0;
@@ -145,7 +145,7 @@ __KERNEL__ int pm_device_suspend(void)
return 0;
}
__KERNEL__ int pm_device_resume(void)
__KNL__ int pm_device_resume(void)
{
uint8_t i = 0;

6
kernel/pm/tos_tickless.c
View File

@@ -40,7 +40,7 @@ __API__ k_err_t tos_tickless_wkup_alarm_init(k_cpu_lpwr_mode_t mode)
return K_ERR_NONE;
}
__KERNEL__ int tickless_wkup_alarm_is_installed(k_cpu_lpwr_mode_t mode)
__KNL__ int tickless_wkup_alarm_is_installed(k_cpu_lpwr_mode_t mode)
{
return k_tickless_wkup_alarm[mode] != K_NULL;
}
@@ -134,7 +134,7 @@ __STATIC__ void tickless_leave(k_time_t time_sleep_ms)
tickless_systick_fix(tick_sleep);
}
__KERNEL__ void tickless_proc(void)
__KNL__ void tickless_proc(void)
{
k_time_t time_sleep;
k_cpu_lpwr_mode_t lpwr_mode;
@@ -150,7 +150,7 @@ __KERNEL__ void tickless_proc(void)
tickless_leave(time_sleep);
}
__KERNEL__ void tickless_init(void)
__KNL__ void tickless_init(void)
{
pm_idle_pwr_mgr_mode_set(IDLE_POWER_MANAGER_MODE_TICKLESS);