X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fkernel%2Fao_task.c;h=38aefbec1ea3d91bd3bf2d4a4e0bc5664f8b5d95;hb=a6baf04bae3fe6a6b3da2f456419732ffeb4d056;hp=e8a092aaf660fcf6bbec48706e14d2f7936e297b;hpb=1085ec5d57e0ed5d132f2bbdac1a0b6a32c0ab4a;p=fw%2Faltos diff --git a/src/kernel/ao_task.c b/src/kernel/ao_task.c index e8a092aa..38aefbec 100644 --- a/src/kernel/ao_task.c +++ b/src/kernel/ao_task.c @@ -24,17 +24,18 @@ #if HAS_STACK_GUARD #include #endif +#include #define DEBUG 0 #define AO_NO_TASK_INDEX 0xff -__xdata struct ao_task * __xdata ao_tasks[AO_NUM_TASKS]; -__data uint8_t ao_num_tasks; -__xdata struct ao_task *__data ao_cur_task; +struct ao_task * ao_tasks[AO_NUM_TASKS]; +uint8_t ao_num_tasks; +struct ao_task *ao_cur_task; #if !HAS_TASK_QUEUE -static __data uint8_t ao_cur_task_index; +static uint8_t ao_cur_task_index; #endif #ifdef ao_arch_task_globals @@ -67,7 +68,7 @@ static inline void ao_check_stack(void) { static struct ao_list run_queue; static struct ao_list alarm_queue; -static struct ao_list sleep_queue[SLEEP_HASH_SIZE]; +static struct ao_list ao_sleep_queue[SLEEP_HASH_SIZE]; static void ao_task_to_run_queue(struct ao_task *task) @@ -80,7 +81,7 @@ ao_task_to_run_queue(struct ao_task *task) static struct ao_list * ao_task_sleep_queue(void *wchan) { - return &sleep_queue[(uintptr_t) wchan % SLEEP_HASH_SIZE]; + return &ao_sleep_queue[(uintptr_t) wchan % SLEEP_HASH_SIZE]; } static void @@ -125,7 +126,7 @@ ao_task_validate_alarm_queue(void) #define ao_task_validate_alarm_queue() #endif -uint16_t ao_task_alarm_tick; +AO_TICK_TYPE ao_task_alarm_tick; static void ao_task_to_alarm_queue(struct ao_task *task) @@ -173,7 +174,7 @@ ao_task_exit_queue(struct ao_task *task) } void -ao_task_check_alarm(uint16_t tick) +ao_task_check_alarm(AO_TICK_TYPE tick) { struct ao_task *alarm, *next; @@ -195,7 +196,7 @@ ao_task_init(void) ao_list_init(&alarm_queue); ao_task_alarm_tick = 0; for (i = 0; i < SLEEP_HASH_SIZE; i++) - ao_list_init(&sleep_queue[i]); + ao_list_init(&ao_sleep_queue[i]); } #if DEBUG @@ -289,8 +290,23 @@ ao_task_validate(void) #endif /* HAS_TASK_QUEUE */ +static inline void * +ao_stack_top(struct ao_task *task) +{ + uint8_t *top = &task->stack8[AO_STACK_SIZE]; + + /* Subtract off the TLS space, but keep the resulting + * stack 8-byte aligned + */ +#if USE_TLS + return top - ((_tls_size() + 7) & ~3); +#else + return top; +#endif +} + void -ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name) __reentrant +ao_add_task(struct ao_task * task, void (*task_func)(void), const char *name) { uint8_t task_id; uint8_t t; @@ -310,7 +326,11 @@ ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *nam * Construct a stack frame so that it will 'return' * to the start of the task */ - ao_arch_init_stack(task, start); + uint32_t *sp = ao_stack_top(task); +#if USE_TLS + _init_tls(sp); +#endif + ao_arch_init_stack(task, sp, task_func); ao_arch_critical( #if HAS_TASK_QUEUE ao_task_init_queue(task); @@ -321,7 +341,7 @@ ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *nam ); } -__data uint8_t ao_task_minimize_latency; +uint8_t ao_task_minimize_latency; /* Task switching function. This must not use any stack variables */ void @@ -339,8 +359,8 @@ ao_yield(void) ao_arch_naked_define else { #if HAS_SAMPLE_PROFILE - uint16_t tick = ao_sample_profile_timer_value(); - uint16_t run = tick - ao_cur_task->start; + AO_TICK_TYPE tick = ao_sample_profile_timer_value(); + AO_TICK_TYPE run = tick - ao_cur_task->start; if (run > ao_cur_task->max_run) ao_cur_task->max_run = run; ++ao_cur_task->yields; @@ -373,12 +393,16 @@ ao_yield(void) ao_arch_naked_define if (!ao_list_is_empty(&run_queue)) break; /* Wait for interrupts when there's nothing ready */ - ao_arch_wait_interrupt(); + if (ao_task_minimize_latency) { + ao_arch_release_interrupts(); + ao_arch_block_interrupts(); + } else + ao_arch_wait_interrupt(); } ao_cur_task = ao_list_first_entry(&run_queue, struct ao_task, queue); #else { - __pdata uint8_t ao_last_task_index = ao_cur_task_index; + uint8_t ao_last_task_index = ao_cur_task_index; for (;;) { ++ao_cur_task_index; if (ao_cur_task_index == ao_num_tasks) @@ -409,12 +433,15 @@ ao_yield(void) ao_arch_naked_define #endif #if AO_CHECK_STACK in_yield = 0; +#endif +#if USE_TLS + _set_tls(ao_stack_top(ao_cur_task)); #endif ao_arch_restore_stack(); } uint8_t -ao_sleep(__xdata void *wchan) +ao_sleep(void *wchan) { #if HAS_TASK_QUEUE uint32_t flags; @@ -435,7 +462,7 @@ ao_sleep(__xdata void *wchan) } void -ao_wakeup(__xdata void *wchan) __reentrant +ao_wakeup(void *wchan) { ao_validate_cur_stack(); #if HAS_TASK_QUEUE @@ -466,7 +493,7 @@ ao_wakeup(__xdata void *wchan) __reentrant } uint8_t -ao_sleep_for(__xdata void *wchan, uint16_t timeout) +ao_sleep_for(void *wchan, AO_TICK_TYPE timeout) { uint8_t ret; if (timeout) { @@ -500,10 +527,10 @@ ao_sleep_for(__xdata void *wchan, uint16_t timeout) return ret; } -static __xdata uint8_t ao_forever; +static uint8_t ao_forever; void -ao_delay(uint16_t ticks) +ao_delay(AO_TICK_TYPE ticks) { if (!ticks) ticks = 1; @@ -537,8 +564,8 @@ void ao_task_info(void) { uint8_t i; - __xdata struct ao_task *task; - uint16_t now = ao_time(); + struct ao_task *task; + AO_TICK_TYPE now = ao_time(); for (i = 0; i < ao_num_tasks; i++) { task = ao_tasks[i]; @@ -565,4 +592,5 @@ ao_start_scheduler(void) ao_arch_start_scheduler(); #endif ao_yield(); + __builtin_unreachable(); }