zouhaitao/TAIXIN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
TAIXIN/csky/csi_kernel/rhino/adapter/csi_rhino.c

1575 lines
34 KiB
C
Raw Permalink Blame History

/*
* Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved.
*
* Licensed 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.
*/
/******************************************************************************
* @file csi_rhino.c
* @brief the adapter file for the rhino
* @version V1.0
* @date 20. July 2016
******************************************************************************/
#include <csi_kernel.h>
#include <k_api.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <csi_config.h>
#include <soc.h>
extern uint32_t dump_mmleak(void);
extern void krhino_task_dump(ktask_t *task, void* stack);
#define AUTORUN 1
#define TMR_ONE_SHOT_DLY 10
#define TMR_PERIODIC_PERIOD 10
#define RHINO_OS_MS_PERIOD_TICK (1000 / RHINO_CONFIG_TICKS_PER_SECOND)
__init k_status_t csi_kernel_init(void)
{
kstat_t ret = krhino_init();
#ifdef CONFIG_KERNEL_PWR_MGMT
extern void cpu_pwrmgmt_init(void);
cpu_pwrmgmt_init();
#endif
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
__init k_status_t csi_kernel_start(void)
{
kstat_t ret = krhino_start();
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
k_sched_stat_t csi_kernel_get_stat(void)
{
kstat_t get = g_sys_stat;
if (get == RHINO_STOPPED) {
return KSCHED_ST_INACTIVE;
} else if (get == RHINO_RUNNING) {
return KSCHED_ST_RUNNING;
}
return KSCHED_ST_ERROR;
}
int32_t csi_kernel_sched_lock(void)
{
return -EOPNOTSUPP;
}
int32_t csi_kernel_sched_unlock(void)
{
return -EOPNOTSUPP;
}
int32_t csi_kernel_sched_restore_lock(int32_t lock)
{
return -EOPNOTSUPP;
}
uint32_t csi_kernel_sched_suspend(void)
{
if (g_sys_stat != RHINO_RUNNING) {
return 0;
}
krhino_sched_disable();
return 0;
}
void csi_kernel_sched_resume(uint32_t sleep_ticks)
{
if (g_sys_stat != RHINO_RUNNING) {
return;
}
krhino_sched_enable();
}
k_status_t csi_kernel_task_new(k_task_entry_t task, const char *name, void *arg,
k_priority_t prio, uint32_t time_quanta,
void *stack, uint32_t stack_size, k_task_handle_t *task_handle)
{
if ((task_handle == NULL) || (stack_size % 4 != 0) || ((stack_size == 0) && (stack == NULL)) || prio <= KPRIO_IDLE || prio > KPRIO_REALTIME7) {
return -EINVAL;
}
k_status_t rc = -1;
#if (RHINO_CONFIG_KOBJ_DYN_ALLOC > 0)
uint8_t prio_trans = RHINO_CONFIG_USER_PRI_MAX - prio;
csi_kernel_sched_suspend();
kstat_t ret;
if (name) {
ret = krhino_task_dyn_create((ktask_t **)task_handle, name, arg, prio_trans, time_quanta, stack, stack_size / 4, task, AUTORUN);
} else {
ret = krhino_task_dyn_create((ktask_t **)task_handle, "user_task", arg, prio_trans, time_quanta, stack, stack_size / 4, task, AUTORUN);
}
if (ret == RHINO_SUCCESS) {
csi_kernel_sched_resume(0);
return 0;
} else {
csi_kernel_sched_resume(0);
return -EPERM;
}
#endif
return rc;
}
k_status_t csi_kernel_task_del(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return -EINVAL;
}
k_status_t rc = -1;
#if (RHINO_CONFIG_KOBJ_DYN_ALLOC > 0)
kstat_t ret = krhino_task_dyn_del(task_handle);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
#else
kstat_t ret = krhino_task_del(task_handle);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
#endif
return rc;
}
k_task_handle_t csi_kernel_task_get_cur(void)
{
ktask_t *ret;
ret = g_active_task[cpu_cur_get()];
return (k_task_handle_t)ret;
}
k_task_stat_t csi_kernel_task_get_stat(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return KTASK_ST_ERROR;
}
if (csi_kernel_task_get_cur() == task_handle) {
return KTASK_ST_RUNNING;
}
task_stat_t get;
ktask_t *handle = (ktask_t *)task_handle;
get = handle->task_state;
switch (get) {
case K_PEND:
case K_SUSPENDED:
case K_PEND_SUSPENDED:
case K_SLEEP:
case K_SLEEP_SUSPENDED:
return KTASK_ST_BLOCKED;
break;
case K_DELETED:
return KTASK_ST_TERMINATED;
break;
case K_RDY:
return KTASK_ST_READY;
break;
default:
return KTASK_ST_ERROR;
}
}
k_status_t csi_kernel_task_set_prio(k_task_handle_t task_handle, k_priority_t priority)
{
if (task_handle == NULL || priority <= KPRIO_IDLE || priority > KPRIO_REALTIME7) {
return -EINVAL;
}
uint8_t prio = RHINO_CONFIG_USER_PRI_MAX - priority;
uint8_t old;
kstat_t ret = krhino_task_pri_change(task_handle, prio, &old);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_task_set_lprun(k_task_handle_t task_handle, uint8_t run)
{
if (task_handle == NULL) {
return -EINVAL;
}
krhino_task_set_lprun(task_handle, run);
return 0;
}
void csi_kernel_lpower_mode(uint8_t enable)
{
krhino_lpower_mode(enable);
}
k_priority_t csi_kernel_task_get_prio(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return KPRIO_ERROR;
}
ktask_t *handle = (ktask_t *)task_handle;
uint8_t ret = handle->prio;
if (ret <= RHINO_CONFIG_USER_PRI_MAX) {
ret = RHINO_CONFIG_USER_PRI_MAX - ret;
} else {
ret = RHINO_CONFIG_PRI_MAX - ret;
}
return ret;
}
const char *csi_kernel_task_get_name(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return NULL;
}
ktask_t *handle = (ktask_t *)task_handle;
return handle->task_name;
}
k_status_t csi_kernel_task_suspend(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_task_suspend(task_handle);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_task_resume(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_task_resume(task_handle);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
void csi_kernel_task_dump(k_task_handle_t task_handle, void* stack)
{
krhino_task_dump(task_handle, stack);
}
k_status_t csi_kernel_task_terminate(k_task_handle_t task_handle)
{
return csi_kernel_task_del(task_handle);
}
void csi_kernel_task_exit(void)
{
csi_kernel_task_del(csi_kernel_task_get_cur());
}
k_status_t csi_kernel_task_yield(void)
{
kstat_t ret = krhino_task_yield();
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
uint32_t csi_kernel_task_get_count(void)
{
#if (RHINO_CONFIG_SYSTEM_STATS > 0)
klist_t *taskhead;
klist_t *taskend;
klist_t *tmp;
taskhead = &g_kobj_list.task_head;
taskend = taskhead;
uint32_t ret = 0;
for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next) {
ret ++;
}
return ret;
#else
return 0;
#endif
}
uint32_t csi_kernel_task_get_stack_size(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return 0;
}
ktask_t *handle = (ktask_t *)task_handle;
return 4 * handle->stack_size;
}
uint32_t csi_kernel_task_get_stack_space(k_task_handle_t task_handle)
{
if (task_handle == NULL) {
return 0;
}
uint32_t stack_free;
kstat_t ret = krhino_task_stack_min_free(task_handle, &stack_free);
if (ret == RHINO_SUCCESS) {
return 4 * stack_free;
} else {
return 0;
}
}
uint32_t csi_kernel_task_list(k_task_handle_t *task_array, uint32_t array_items)
{
if (task_array == NULL || array_items == 0) {
return 0;
}
uint32_t real_tsk_num = 0;
#if (RHINO_CONFIG_SYSTEM_STATS > 0)
klist_t *taskhead;
klist_t *taskend;
klist_t *tmp;
ktask_t *task;
k_task_handle_t *tk_tmp = task_array;
taskhead = &g_kobj_list.task_head;
taskend = taskhead;
#ifdef CONFIG_BACKTRACE
uint32_t task_free;
size_t irq_flags;
#endif
#ifdef CONFIG_STACK_GUARD
int stack_flags;
#endif
for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next) {
real_tsk_num ++;
task = krhino_list_entry(tmp, ktask_t, task_stats_item);
#ifdef CONFIG_BACKTRACE
krhino_task_stack_min_free(task, &task_free);
printf("\n%s:\n\t state %d, pri %d, stack: total %d, free %d\n",
task->task_name, task->task_state, task->prio, 4 * task->stack_size, 4 * task_free);
#endif
}
if (array_items < real_tsk_num) {
real_tsk_num = array_items;
}
for (tmp = taskhead->next; tmp != taskend && real_tsk_num >= 1; tmp = tmp->next) {
task = krhino_list_entry(tmp, ktask_t, task_stats_item);
*tk_tmp = task;
tk_tmp ++;
}
#ifdef CONFIG_BACKTRACE
irq_flags = cpu_intrpt_save();
#ifdef CONFIG_STACK_GUARD
extern int stack_guard_save(void);
stack_flags = stack_guard_save();
#endif
for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next) {
task = krhino_list_entry(tmp, ktask_t, task_stats_item);
krhino_task_stack_min_free(task, &task_free);
printf("\n%s:\n", task->task_name);
extern int csky_task_backtrace(void *stack, char *buf, int len);
csky_task_backtrace(task->task_stack, NULL, 0);
}
#ifdef CONFIG_STACK_GUARD
extern void stack_guard_restore(int value);
stack_guard_restore(stack_flags);
#endif
cpu_intrpt_restore(irq_flags);
#endif /* CONFIG_BACKTRACE */
#endif /* RHINO_CONFIG_SYSTEM_STATS */
return real_tsk_num;
}
k_status_t csi_kernel_intrpt_enter(void)
{
kstat_t ret = krhino_intrpt_enter();
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
return 0;
}
k_status_t csi_kernel_intrpt_exit(void)
{
krhino_intrpt_exit();
return 0;
}
k_status_t csi_kernel_delay(uint32_t ticks)
{
kstat_t ret = krhino_task_sleep(ticks);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_delay_until(uint64_t ticks)
{
return -EOPNOTSUPP;
}
uint64_t csi_kernel_tick2ms(uint32_t ticks)
{
return ((uint64_t)ticks * RHINO_OS_MS_PERIOD_TICK);
}
uint64_t csi_kernel_ms2tick(uint32_t ms)
{
if (ms < RHINO_OS_MS_PERIOD_TICK) {
return 0;
}
return (((uint64_t)ms) / RHINO_OS_MS_PERIOD_TICK);
}
k_status_t csi_kernel_delay_ms(uint32_t ms)
{
uint32_t ms_get = ms;
if ((ms < RHINO_OS_MS_PERIOD_TICK) && (ms != 0)) {
ms_get = RHINO_OS_MS_PERIOD_TICK;
}
uint64_t ticks = csi_kernel_ms2tick(ms_get);
kstat_t ret = krhino_task_sleep(ticks);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
uint64_t csi_kernel_get_ticks(void)
{
return (uint64_t)krhino_sys_tick_get();
}
uint64_t csi_kernel_suspend_tick(void)
{
// return next_task_wake_tick_get();
return 0;
}
void csi_kernel_update_tick(uint32_t ms)
{
extern uint64_t g_sys_tick_count;
uint32_t ticks = ms * RHINO_CONFIG_TICKS_PER_SECOND / 1000;
CPSR_ALLOC();
RHINO_CPU_INTRPT_DISABLE();
g_sys_tick_count += ticks;
RHINO_CPU_INTRPT_ENABLE();
}
uint32_t csi_kernel_get_tick_freq(void)
{
return RHINO_CONFIG_TICKS_PER_SECOND;
}
uint32_t csi_kernel_get_systimer_freq(void)
{
return 0;//drv_get_sys_freq();
}
typedef struct tmr_ad {
k_timer_cb_t func;
ktimer_t tmr;
} tmr_ad_t;
typedef struct tmr_arg {
void *arg;
tmr_ad_t *tmr_above;
} tmr_arg_t;
static void tmr_adapt_cb(void *timer, void *arg)
{
ktimer_t *get = (ktimer_t *)timer;
tmr_arg_t *arg_above = (tmr_arg_t *)(get->timer_cb_arg);
tmr_ad_t *tmr_above = (tmr_ad_t *)arg_above->tmr_above;
tmr_above->func(arg_above->arg);
return;
}
k_timer_handle_t csi_kernel_timer_new(k_timer_cb_t func, k_timer_type_t type, void *arg)
{
if (type < 0 || type > 3 || func == NULL) {
return NULL;
}
tick_t first = TMR_ONE_SHOT_DLY;
tick_t round;
if (type == KTIMER_TYPE_ONCE) {
round = 0;
} else {
round = TMR_PERIODIC_PERIOD;
}
tmr_ad_t *handle_ad = (tmr_ad_t *)krhino_mm_alloc(sizeof(tmr_ad_t), __builtin_return_address(0));
if (handle_ad == NULL) {
return NULL;
}
tmr_arg_t *get_arg = (tmr_arg_t *)krhino_mm_alloc(sizeof(tmr_arg_t), __builtin_return_address(0));
if (get_arg == NULL) {
krhino_mm_free((void *)handle_ad);
return NULL;
}
get_arg->arg = arg;
kstat_t ret = krhino_timer_create(&(handle_ad->tmr), "UserTmr", (timer_cb_t)tmr_adapt_cb, first, round, get_arg, 0);
if (ret == RHINO_SUCCESS) {
handle_ad->func = func;
get_arg->tmr_above = handle_ad;
return handle_ad;
} else {
krhino_mm_free((void *)handle_ad);
krhino_mm_free((void *)get_arg);
return NULL;
}
}
k_status_t csi_kernel_timer_del(k_timer_handle_t timer_handle)
{
if (timer_handle == NULL) {
return -EINVAL;
}
tmr_ad_t *handle_ad = (tmr_ad_t *)timer_handle;
kstat_t ret = krhino_timer_del(&(handle_ad->tmr));
if (ret == RHINO_SUCCESS) {
krhino_mm_free(((ktimer_t *)(&(handle_ad->tmr)))->timer_cb_arg);
krhino_mm_free(timer_handle);
return 0;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_timer_start(k_timer_handle_t timer_handle, uint32_t ticks)
{
if (timer_handle == NULL || ticks == 0) {
return -EINVAL;
}
tick_t round;
tmr_ad_t *handle_ad = (tmr_ad_t *)timer_handle;
ktimer_t *handle = (ktimer_t *)(&(handle_ad->tmr));
round = handle->round_ticks;
tick_t tr;
tick_t tf = ticks;
if (round != 0) {
tr = ticks;
} else {
tr = 0;
}
kstat_t ret1 = krhino_timer_change(handle, tf, tr);
if (ret1 == RHINO_SUCCESS) {
kstat_t ret2 = krhino_timer_start(handle);
if (ret2 == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
} else {
return -EPERM;
}
}
k_status_t csi_kernel_timer_stop(k_timer_handle_t timer_handle)
{
if (timer_handle == NULL) {
return -EINVAL;
}
tmr_ad_t *handle_ad = (tmr_ad_t *)timer_handle;
ktimer_t *handle = (ktimer_t *)(&(handle_ad->tmr));
kstat_t ret = krhino_timer_stop(handle);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
k_timer_stat_t csi_kernel_timer_get_stat(k_timer_handle_t timer_handle)
{
if (timer_handle == NULL) {
return KTIMER_ST_INACTIVE;
}
tmr_ad_t *handle_ad = (tmr_ad_t *)timer_handle;
ktimer_t *handle = (ktimer_t *)(&(handle_ad->tmr));
k_timer_state_t get = handle->timer_state;
if (get == TIMER_DEACTIVE) {
return KTIMER_ST_INACTIVE;
} else {
return KTIMER_ST_ACTIVE;
}
}
k_event_handle_t csi_kernel_event_new(void)
{
#if (RHINO_CONFIG_EVENT_FLAG > 0)
kevent_t *handle = (kevent_t *)krhino_mm_alloc(sizeof(kevent_t), __builtin_return_address(0));
if (handle == NULL) {
return NULL;
}
kstat_t ret = krhino_event_create(handle, "UserEvent", 0);
if (ret == RHINO_SUCCESS) {
return handle;
} else {
return NULL;
}
#else
return NULL;
#endif
}
k_status_t csi_kernel_event_del(k_event_handle_t ev_handle)
{
#if (RHINO_CONFIG_EVENT_FLAG > 0)
if (ev_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_event_del(ev_handle);
if (ret == RHINO_SUCCESS) {
krhino_mm_free(ev_handle);
return 0;
} else {
return -EPERM;
}
#else
return -EOPNOTSUPP;
#endif
}
k_status_t csi_kernel_event_set(k_event_handle_t ev_handle, uint32_t flags, uint32_t *ret_flags)
{
#if (RHINO_CONFIG_EVENT_FLAG > 0)
if (ev_handle == NULL || ret_flags == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_event_set(ev_handle, flags, RHINO_OR);
if (ret == RHINO_SUCCESS) {
kevent_t *handle = (kevent_t *)ev_handle;
*ret_flags = handle->flags;
return 0;
} else {
return -EPERM;
}
#else
return -EOPNOTSUPP;
#endif
}
k_status_t csi_kernel_event_clear(k_event_handle_t ev_handle, uint32_t flags, uint32_t *ret_flags)
{
#if (RHINO_CONFIG_EVENT_FLAG > 0)
if (ev_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_event_set(ev_handle, ~flags, RHINO_AND);
if (ret == RHINO_SUCCESS) {
kevent_t *handle = (kevent_t *)ev_handle;
if(ret_flags) *ret_flags = handle->flags;
return 0;
} else {
return -EPERM;
}
#else
return -EOPNOTSUPP;
#endif
}
k_status_t csi_kernel_event_get(k_event_handle_t ev_handle, uint32_t *ret_flags)
{
#if (RHINO_CONFIG_EVENT_FLAG > 0)
if (ev_handle == NULL || ret_flags == NULL) {
return -EINVAL;
}
kevent_t *handle = (kevent_t *)ev_handle;
*ret_flags = handle->flags;
return 0;
#else
return -EOPNOTSUPP;
#endif
}
k_status_t csi_kernel_event_wait(k_event_handle_t ev_handle, uint32_t flags,
k_event_opt_t options, uint8_t clr_on_exit,
uint32_t *actl_flags, int32_t timeout)
{
#if (RHINO_CONFIG_EVENT_FLAG > 0)
if (ev_handle == NULL || actl_flags == NULL
|| ((clr_on_exit != 0) && (clr_on_exit != 1))) {
return -EINVAL;
}
if (options == KEVENT_OPT_CLR_ANY || options == KEVENT_OPT_CLR_ALL) {
return -EOPNOTSUPP;
}
uint8_t opt = 0;
if (options == KEVENT_OPT_SET_ANY) {
if (clr_on_exit == 1) {
opt = RHINO_OR_CLEAR;
} else {
opt = RHINO_OR;
}
} else if (options == KEVENT_OPT_SET_ALL) {
if (clr_on_exit == 1) {
opt = RHINO_AND_CLEAR;
} else {
opt = RHINO_AND;
}
}
tick_t t;
if (timeout < 0) {
t = RHINO_WAIT_FOREVER;
} else {
t = timeout;
}
kstat_t ret = krhino_event_get(ev_handle, flags, opt, actl_flags, t);
if (ret == RHINO_SUCCESS) {
return 0;
} else if (ret == RHINO_BLK_TIMEOUT) {
return -ETIMEDOUT;
} else {
return -EPERM;
}
#else
return -EOPNOTSUPP;
#endif
}
k_mutex_handle_t csi_kernel_mutex_new(void)
{
kmutex_t *handle = (kmutex_t *)krhino_mm_alloc(sizeof(kmutex_t), __builtin_return_address(0));
if (handle == NULL) {
return NULL;
}
kstat_t ret = krhino_mutex_create(handle, "UserMutex");
if (ret == RHINO_SUCCESS) {
return handle;
} else {
return NULL;
}
}
k_status_t csi_kernel_mutex_del(k_mutex_handle_t mutex_handle)
{
if (mutex_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_mutex_del(mutex_handle);
if (ret == RHINO_SUCCESS) {
krhino_mm_free(mutex_handle);
return 0;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_mutex_lock(k_mutex_handle_t mutex_handle, int32_t timeout, uint32_t lr)
{
if (mutex_handle == NULL) {
return -EINVAL;
}
tick_t t;
if (timeout < 0) {
t = RHINO_WAIT_FOREVER;
} else {
t = timeout;
}
kstat_t ret = krhino_mutex_lock(mutex_handle, t, lr);
if (ret == RHINO_SUCCESS || ret == RHINO_MUTEX_OWNER_NESTED) {
return 0;
} else if (ret == RHINO_BLK_TIMEOUT) {
return -ETIMEDOUT;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_mutex_unlock(k_mutex_handle_t mutex_handle)
{
if (mutex_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_mutex_unlock(mutex_handle);
if (ret == RHINO_SUCCESS || ret == RHINO_MUTEX_OWNER_NESTED) {
return 0;
} else {
return -EPERM;
}
}
k_task_handle_t csi_kernel_mutex_get_owner(k_mutex_handle_t mutex_handle)
{
if (mutex_handle == NULL) {
return NULL;
}
kmutex_t *handle = (kmutex_t *)mutex_handle;
return handle->mutex_task;
}
k_sem_handle_t csi_kernel_sem_new(int32_t max_count, int32_t initial_count)
{
if (max_count <= 0 || initial_count < 0) {
return NULL;
}
if (max_count < initial_count) {
return NULL;
}
ksem_t *handle = (ksem_t *)krhino_mm_alloc(sizeof(ksem_t), __builtin_return_address(0));
if (handle == NULL) {
return NULL;
}
kstat_t ret = krhino_sem_create(handle, "UserSem", initial_count);
if (ret == RHINO_SUCCESS) {
return handle;
} else {
return NULL;
}
}
k_status_t csi_kernel_sem_del(k_sem_handle_t sem_handle)
{
if (sem_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_sem_del(sem_handle);
if (ret == RHINO_SUCCESS) {
krhino_mm_free(sem_handle);
return 0;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_sem_wait(k_sem_handle_t sem_handle, int32_t timeout)
{
if (sem_handle == NULL) {
return -EINVAL;
}
tick_t t;
if (timeout < 0) {
t = RHINO_WAIT_FOREVER;
} else {
t = timeout;
}
kstat_t ret = krhino_sem_take(sem_handle, t);
if (ret == RHINO_SUCCESS) {
return 0;
} else if (ret == RHINO_BLK_TIMEOUT) {
return -ETIMEDOUT;
} else {
return -EPERM;
}
}
k_status_t csi_kernel_sem_post(k_sem_handle_t sem_handle)
{
if (sem_handle == NULL) {
return -EINVAL;
}
kstat_t ret = krhino_sem_give(sem_handle);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
int32_t csi_kernel_sem_get_count(k_sem_handle_t sem_handle)
{
if (sem_handle == NULL) {
return -EINVAL;
}
sem_count_t cnt;
kstat_t ret = krhino_sem_count_get(sem_handle, &cnt);
if (ret == RHINO_SUCCESS) {
return (int32_t)cnt;
} else {
return -EPERM;
}
}
#if 0
k_mpool_handle_t csi_kernel_mpool_new(void *p_addr, int32_t block_count, int32_t block_size)
{
if (p_addr == NULL || block_count < 0 || block_size <= 0 || (block_size % 4 != 0)) {
return NULL;
}
#if (RHINO_CONFIG_MM_BLK > 0)
mblk_pool_t *handle = (mblk_pool_t *)krhino_mm_alloc(sizeof(mblk_pool_t), __builtin_return_address(0));
if (handle == NULL) {
return NULL;
}
kstat_t ret = krhino_mblk_pool_init(handle, "UserMp", p_addr, block_size, block_count * block_size);
if (ret == RHINO_SUCCESS) {
return handle;
} else {
return NULL;
}
#else
return NULL;
#endif
}
k_status_t csi_kernel_mpool_del(k_mpool_handle_t mp_handle)
{
if (mp_handle == NULL) {
return -EINVAL;
}
memset(mp_handle, 0, sizeof(mblk_pool_t));
krhino_mm_free(mp_handle);
return 0;
}
void *csi_kernel_mpool_alloc(k_mpool_handle_t mp_handle, int32_t timeout)
{
if (mp_handle == NULL) {
return NULL;
}
#if (RHINO_CONFIG_MM_BLK > 0)
uint32_t g_csi_rhino_blk = 0;
kstat_t ret = krhino_mblk_alloc(mp_handle, (void **)&g_csi_rhino_blk);
if (ret == RHINO_SUCCESS) {
return (void *)g_csi_rhino_blk;
} else {
return NULL;
}
#else
return NULL;
#endif
}
k_status_t csi_kernel_mpool_free(k_mpool_handle_t mp_handle, void *block)
{
if (mp_handle == NULL || block == NULL) {
return -EINVAL;
}
#if (RHINO_CONFIG_MM_BLK > 0)
kstat_t ret = krhino_mblk_free(mp_handle, block);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
#else
return -EPERM;
#endif
}
int32_t csi_kernel_mpool_get_count(k_mpool_handle_t mp_handle)
{
if (mp_handle == NULL) {
return 0;
}
mblk_pool_t *handle = (mblk_pool_t *)mp_handle;
int32_t used = handle->blk_whole - handle->blk_avail;
return used;
}
uint32_t csi_kernel_mpool_get_capacity(k_mpool_handle_t mp_handle)
{
if (mp_handle == NULL) {
return 0;
}
mblk_pool_t *handle = (mblk_pool_t *)mp_handle;
return handle->blk_whole;
}
uint32_t csi_kernel_mpool_get_block_size(k_mpool_handle_t mp_handle)
{
if (mp_handle == NULL) {
return 0;
}
mblk_pool_t *handle = (mblk_pool_t *)mp_handle;
return handle->blk_size;
}
#endif
typedef struct mq_adapter {
kbuf_queue_t *buf_q;
int32_t msg_size;
int32_t msg_count;
} mq_adapter_t;
k_msgq_handle_t csi_kernel_msgq_new(int32_t msg_count, int32_t msg_size)
{
if (msg_count <= 0 || msg_size <= 0) {
return NULL;
}
#if (RHINO_CONFIG_KOBJ_DYN_ALLOC > 0)
mq_adapter_t *handle = (mq_adapter_t *)krhino_mm_alloc(sizeof(mq_adapter_t), __builtin_return_address(0));
if (handle == NULL) {
return NULL;
}
kstat_t ret = krhino_buf_queue_dyn_create(&(handle->buf_q), "UserMsgQ", msg_size * (msg_count + 1), msg_size);
if (ret == RHINO_SUCCESS) {
handle->msg_count = msg_count;
handle->msg_size = msg_size;
return (k_msgq_handle_t)handle;
} else {
krhino_mm_free(handle);
return NULL;
}
#else
return NULL;
#endif
}
k_status_t csi_kernel_msgq_del(k_msgq_handle_t mq_handle)
{
if (!mq_handle) {
return -EINVAL;
}
#if (RHINO_CONFIG_KOBJ_DYN_ALLOC > 0)
mq_adapter_t *handle = (mq_adapter_t *)mq_handle;
kstat_t ret = krhino_buf_queue_dyn_del(handle->buf_q);
if (ret == RHINO_SUCCESS) {
krhino_mm_free(mq_handle);
return 0;
} else {
return -EPERM;
}
#else
return -EPERM;
#endif
}
k_status_t csi_kernel_msgq_put(k_msgq_handle_t mq_handle, const void *msg_ptr, uint8_t front_or_back, int32_t timeout)
{
k_status_t retval = -EPERM;
if ((!mq_handle) || (msg_ptr == NULL) || ((front_or_back != 0) && (front_or_back != 1))) {
return -EINVAL;
}
mq_adapter_t *handle = (mq_adapter_t *)mq_handle;
if (front_or_back == 0) {
kstat_t ret = krhino_buf_queue_send(handle->buf_q, (void *)msg_ptr, handle->msg_size, timeout);
if (ret == RHINO_SUCCESS) {
retval = 0 ;
} else {
retval = -EPERM;
}
} else if (front_or_back == 1) {
kstat_t ret = krhino_buf_queue_send(handle->buf_q, (void *)msg_ptr, handle->msg_size, timeout);
if (ret == RHINO_SUCCESS) {
retval = 0;
} else {
retval = -EPERM;
}
}
return retval;
}
k_status_t csi_kernel_msgq_get(k_msgq_handle_t mq_handle, void *msg_ptr, int32_t timeout)
{
if (mq_handle == NULL || msg_ptr == NULL) {
return -EINVAL;
}
tick_t t;
if (timeout < 0) {
t = RHINO_WAIT_FOREVER;
} else {
t = timeout;
}
mq_adapter_t *handle = (mq_adapter_t *)mq_handle;
uint32_t size;
kstat_t ret = krhino_buf_queue_recv(handle->buf_q, t, msg_ptr, &size);
if (ret == RHINO_SUCCESS) {
return 0;
} else if (ret == RHINO_BLK_TIMEOUT) {
return -ETIMEDOUT;
} else {
return -EPERM;
}
}
int32_t csi_kernel_msgq_get_count(k_msgq_handle_t mq_handle)
{
if (mq_handle == NULL) {
return -EINVAL;
}
mq_adapter_t *handle = (mq_adapter_t *)mq_handle;
kbuf_queue_info_t info;
kstat_t ret = krhino_buf_queue_info_get(handle->buf_q, &info);
if (ret == RHINO_SUCCESS) {
int32_t cnt = info.cur_num;
return cnt;
} else {
return -EPERM;
}
}
uint32_t csi_kernel_msgq_get_capacity(k_msgq_handle_t mq_handle)
{
if (mq_handle == NULL) {
return 0;
}
mq_adapter_t *handle = (mq_adapter_t *)mq_handle;
return handle->msg_count;
}
uint32_t csi_kernel_msgq_get_msg_size(k_msgq_handle_t mq_handle)
{
if (mq_handle == NULL) {
return 0;
}
mq_adapter_t *handle = (mq_adapter_t *)mq_handle;
return handle->buf_q->max_msg_size;
}
k_status_t csi_kernel_msgq_flush(k_msgq_handle_t mq_handle)
{
if (mq_handle == NULL) {
return -EINVAL;
}
mq_adapter_t *handle = (mq_adapter_t *)mq_handle;
kstat_t ret = krhino_buf_queue_flush(handle->buf_q);
if (ret == RHINO_SUCCESS) {
return 0;
} else {
return -EPERM;
}
}
#if 0
void *csi_kernel_malloc(int32_t size, void *caller)
{
void *ret;
if (size < 1) {
return NULL;
}
csi_kernel_sched_suspend();
ret = krhino_mm_alloc(size, caller);
csi_kernel_sched_resume(0);
return ret;
}
void csi_kernel_free(void *ptr, void *caller)
{
csi_kernel_sched_suspend();
krhino_mm_free(ptr);
csi_kernel_sched_resume(0);
}
void *csi_kernel_realloc(void *ptr, int32_t size, void *caller)
{
void *new_ptr;
new_ptr = krhino_mm_realloc(ptr, size, caller);
return new_ptr;
}
#endif
#if 0
k_status_t csi_kernel_get_mminfo(int32_t *total, int32_t *used, int32_t *free, int32_t *peak)
{
*total = g_kmm_head->used_size + g_kmm_head->free_size;
*used = g_kmm_head->used_size;
*free = g_kmm_head->free_size;
*peak = g_kmm_head->maxused_size;
return 0;
}
k_status_t csi_kernel_mm_dump(void)
{
#if (RHINO_CONFIG_MM_DEBUG > 0u)
dumpsys_mm_info_func(NULL, 0);
#endif
return 0;
}
#endif
const char *csi_kernel_task_status_text(int state)
{
switch(state){
case K_SEED:
return "Seed";
case K_RDY:
return "Ready";
case K_PEND:
return "Pend";
case K_SUSPENDED:
return "Suspended";
case K_PEND_SUSPENDED:
return "Pend_Suspended";
case K_SLEEP:
return "Sleep";
case K_SLEEP_SUSPENDED:
return "Sleep_Suspended";
case K_DELETED:
return "Deleted";
default:
return "Unused";
}
}
struct os_task_info {
uint32_t id;
const char *name;
const char *status;
uint32_t time;
uint32_t stack;
uint32_t prio;
uint32_t arg;
};
uint32_t csi_kernel_task_runtime(struct os_task_info *tsk_rumtime, int count)
{
#if (RHINO_CONFIG_SYSTEM_STATS > 0)
uint32_t ret = 0;
klist_t *taskhead;
klist_t *taskend;
klist_t *tmp;
ktask_t *task;
taskhead = &g_kobj_list.task_head;
taskend = taskhead;
for (tmp = taskhead->next; tmp != taskend && ret < count; tmp = tmp->next) {
task = krhino_list_entry(tmp, ktask_t, task_stats_item);
if(task == &g_idle_task[cpu_cur_get()]) //忽略idle task
continue;
tsk_rumtime[ret].id = ret;
tsk_rumtime[ret].name = task->task_name;
tsk_rumtime[ret].time = task->runtime;
tsk_rumtime[ret].stack = task->stack_size;
tsk_rumtime[ret].prio = task->prio;
tsk_rumtime[ret].arg = (uint32_t)task;
tsk_rumtime[ret].status = csi_kernel_task_status_text(task->task_state);
task->runtime = 0;
ret ++;
}
return ret;
#else
return 0;
#endif
}
void csi_kernel_task_print(void)
{
#if (RHINO_CONFIG_SYSTEM_STATS > 0)
klist_t *taskhead;
klist_t *taskend;
klist_t *tmp;
ktask_t *task;
taskhead = &g_kobj_list.task_head;
taskend = taskhead;
for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next) {
task = krhino_list_entry(tmp, ktask_t, task_stats_item);
printf("\0011Task %s %s, ticks:%d stack:%d prio:%d arg:%p\r\n", task->task_name,
csi_kernel_task_status_text(task->task_state),
task->runtime, task->stack_size, task->prio, task);
task->runtime = 0;
}
#endif
}
int csi_kernel_task_count(void)
{
int count = 0;
#if (RHINO_CONFIG_SYSTEM_STATS > 0)
klist_t *taskhead;
klist_t *taskend;
klist_t *tmp;
taskhead = &g_kobj_list.task_head;
taskend = taskhead;
for (tmp = taskhead->next; tmp != taskend; tmp = tmp->next) {
count++;
}
#endif
return count;
}
void csi_kernel_blklist_suspend(void *hdl, k_task_handle_t task_hdl)
{
CPSR_ALLOC();
ktask_t *task = (ktask_t *)task_hdl;
blk_obj_t *obj = (blk_obj_t *)hdl;
if (obj) {
krhino_check_fatal_call(__FUNCTION__);
if (task == NULL) {
task = g_active_task[cpu_cur_get()];
}
printf("task %s suspend!\r\n", task->task_name);
RHINO_CRITICAL_ENTER();
if (obj->obj_type != RHINO_BLKLIST_OBJ_TYPE) {
RHINO_CRITICAL_EXIT();
return;
}
pend_to_blk_obj(obj, task, RHINO_WAIT_FOREVER, psr);
RHINO_CRITICAL_EXIT_SCHED();
/* task has been wakeup !!!*/
RHINO_CPU_INTRPT_DISABLE();
/* so the task is waked up, need know which reason cause wake up */
pend_state_end_proc(task);
RHINO_CPU_INTRPT_ENABLE();
printf("task %s wakeup ...\r\n", task->task_name);
}
}
void csi_kernel_blklist_wakeup(void *hdl)
{
CPSR_ALLOC();
klist_t *iter;
klist_t *event_head;
klist_t *iter_temp;
ktask_t *task;
blk_obj_t *obj = (blk_obj_t *)hdl;
if (obj) {
/* this is only needed when system zero interrupt feature is enabled */
#if (RHINO_CONFIG_INTRPT_GUARD > 0)
soc_intrpt_guard();
#endif
RHINO_CRITICAL_ENTER();
if (obj->obj_type != RHINO_BLKLIST_OBJ_TYPE) {
RHINO_CRITICAL_EXIT();
return;
}
event_head = &obj->blk_list;
iter = event_head->next;
/* if list is not empty */
while (iter != event_head) {
task = krhino_list_entry(iter, ktask_t, task_list);
iter_temp = iter->next;
pend_task_wakeup(task);
iter = iter_temp;
}
RHINO_CRITICAL_EXIT_SCHED();
}
}
void *csi_kernel_blklist_new()
{
blk_obj_t *obj = malloc(sizeof(blk_obj_t));
if (obj) {
memset(obj, 0, sizeof(blk_obj_t));
klist_init(&obj->blk_list);
obj->blk_policy = BLK_POLICY_PRI;
obj->name = "blklist";
obj->obj_type = RHINO_BLKLIST_OBJ_TYPE;
}
return obj;
}
void csi_kernel_blklist_del(void *hdl)
{
blk_obj_t *obj = (blk_obj_t *)hdl;
if (obj && obj->obj_type == RHINO_BLKLIST_OBJ_TYPE) {
csi_kernel_blklist_wakeup(hdl);
obj->obj_type = RHINO_OBJ_TYPE_NONE;
free(obj);
}
}
Reference in New Issue View Git Blame Copy Permalink