*/
if (ao_cur_task->wchan == NULL)
ao_task_to_run_queue(ao_cur_task);
- ao_cur_task = NULL;
for (;;) {
ao_arch_memory_barrier();
if (!ao_list_is_empty(&run_queue))
void
ao_wakeup(__xdata void *wchan) __reentrant
{
+ ao_validate_cur_stack();
#if HAS_TASK_QUEUE
struct ao_task *sleep, *next;
struct ao_list *sleep_queue;
}
ao_arch_irqrestore(flags);
#else
+ {
uint8_t i;
for (i = 0; i < ao_num_tasks; i++)
if (ao_tasks[i]->wchan == wchan)
ao_tasks[i]->wchan = NULL;
+ }
#endif
ao_check_stack();
}
-static void
-ao_alarm(uint16_t delay)
+uint8_t
+ao_sleep_for(__xdata void *wchan, uint16_t timeout)
{
+ uint8_t ret;
+ if (timeout) {
#if HAS_TASK_QUEUE
- uint32_t flags;
- /* Make sure we sleep *at least* delay ticks, which means adding
- * one to account for the fact that we may be close to the next tick
- */
- flags = ao_arch_irqsave();
+ uint32_t flags;
+ /* Make sure we sleep *at least* delay ticks, which means adding
+ * one to account for the fact that we may be close to the next tick
+ */
+ flags = ao_arch_irqsave();
#endif
- if (!(ao_cur_task->alarm = ao_time() + delay + 1))
- ao_cur_task->alarm = 1;
+ if (!(ao_cur_task->alarm = ao_time() + timeout + 1))
+ ao_cur_task->alarm = 1;
#if HAS_TASK_QUEUE
- ao_task_to_alarm_queue(ao_cur_task);
- ao_arch_irqrestore(flags);
+ ao_task_to_alarm_queue(ao_cur_task);
+ ao_arch_irqrestore(flags);
#endif
-}
-
-static void
-ao_clear_alarm(void)
-{
+ }
+ ret = ao_sleep(wchan);
+ if (timeout) {
#if HAS_TASK_QUEUE
- uint32_t flags;
+ uint32_t flags;
- flags = ao_arch_irqsave();
+ flags = ao_arch_irqsave();
#endif
- ao_cur_task->alarm = 0;
+ ao_cur_task->alarm = 0;
#if HAS_TASK_QUEUE
- ao_task_from_alarm_queue(ao_cur_task);
- ao_arch_irqrestore(flags);
+ ao_task_from_alarm_queue(ao_cur_task);
+ ao_arch_irqrestore(flags);
#endif
-}
-
-uint8_t
-ao_sleep_for(__xdata void *wchan, uint16_t timeout)
-{
- uint8_t ret;
- if (timeout)
- ao_alarm(timeout);
- ret = ao_sleep(wchan);
- if (timeout)
- ao_clear_alarm();
+ }
return ret;
}