/*
|
* Licensed to the Apache Software Foundation (ASF) under one
|
* or more contributor license agreements. See the NOTICE file
|
* distributed with this work for additional information
|
* regarding copyright ownership. The ASF licenses this file
|
* to you under the Apache License, Version 2.0 (the
|
* "License"); you may not use this file except in compliance
|
* with the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing,
|
* software distributed under the License is distributed on an
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
* KIND, either express or implied. See the License for the
|
* specific language governing permissions and limitations
|
* under the License.
|
*/
|
|
#define _GNU_SOURCE
|
#include <pthread.h>
|
#include <syscfg/syscfg.h>
|
#include <os/os_task.h>
|
#include <hal/hal_os_tick.h>
|
#include <irq_ctrl.h>
|
|
static pthread_mutex_t bsim_ctx_sw_mutex = PTHREAD_MUTEX_INITIALIZER;
|
static int bsim_pend_sv;
|
|
struct task_info {
|
pthread_t tid;
|
pthread_cond_t cond;
|
void *arg;
|
};
|
|
static void *
|
task_wrapper(void *arg)
|
{
|
struct os_task *me = arg;
|
struct task_info *ti = me->t_arg;
|
|
pthread_mutex_lock(&bsim_ctx_sw_mutex);
|
if (g_current_task != me) {
|
pthread_cond_wait(&ti->cond, &bsim_ctx_sw_mutex);
|
assert(g_current_task == me);
|
}
|
|
me->t_func(ti->arg);
|
|
assert(0);
|
}
|
|
os_stack_t *
|
os_arch_task_stack_init(struct os_task *t, os_stack_t *stack_top, int size)
|
{
|
struct task_info *ti;
|
int err;
|
|
ti = calloc(1, sizeof(*ti));
|
|
pthread_cond_init(&ti->cond, NULL);
|
ti->arg = t->t_arg;
|
t->t_arg = ti;
|
|
err = pthread_create(&ti->tid, NULL, task_wrapper, t);
|
assert(err == 0);
|
|
pthread_setname_np(ti->tid, t->t_name);
|
|
return stack_top;
|
}
|
|
os_error_t
|
os_arch_os_start(void)
|
{
|
struct os_task *next_t;
|
struct task_info *ti;
|
|
os_tick_init(OS_TICKS_PER_SEC, 7);
|
|
next_t = os_sched_next_task();
|
assert(next_t);
|
os_sched_set_current_task(next_t);
|
|
g_os_started = 1;
|
|
ti = next_t->t_arg;
|
pthread_cond_signal(&ti->cond);
|
|
return 0;
|
}
|
|
os_error_t
|
os_arch_os_init(void)
|
{
|
STAILQ_INIT(&g_os_task_list);
|
TAILQ_INIT(&g_os_run_list);
|
TAILQ_INIT(&g_os_sleep_list);
|
|
os_init_idle_task();
|
|
return OS_OK;
|
}
|
|
void
|
os_arch_ctx_sw(struct os_task *next_t)
|
{
|
os_sched_ctx_sw_hook(next_t);
|
bsim_pend_sv = 1;
|
}
|
|
static void
|
do_ctx_sw(void)
|
{
|
struct os_task *next_t;
|
struct os_task *me;
|
struct task_info *ti, *next_ti;
|
|
next_t = os_sched_next_task();
|
assert(next_t);
|
|
bsim_pend_sv = 0;
|
|
assert(g_current_task);
|
me = g_current_task;
|
ti = me->t_arg;
|
|
if (me == next_t) {
|
return;
|
}
|
|
g_current_task = next_t;
|
next_ti = g_current_task->t_arg;
|
|
pthread_cond_signal(&next_ti->cond);
|
pthread_cond_wait(&ti->cond, &bsim_ctx_sw_mutex);
|
assert(g_current_task == me);
|
}
|
|
os_sr_t
|
os_arch_save_sr(void)
|
{
|
return hw_irq_ctrl_change_lock(1);
|
}
|
|
void
|
os_arch_restore_sr(os_sr_t osr)
|
{
|
hw_irq_ctrl_change_lock(osr);
|
|
if (!osr && bsim_pend_sv) {
|
do_ctx_sw();
|
}
|
}
|
|
int
|
os_arch_in_critical(void)
|
{
|
return hw_irq_ctrl_get_current_lock();
|
}
|
|
void
|
__assert_func(const char *file, int line, const char *func, const char *e)
|
{
|
#if MYNEWT_VAL(OS_ASSERT_CB)
|
os_assert_cb();
|
#endif
|
_Exit(1);
|
}
|
