Initial commit: TXW82x FPV v2.7.0.7-42229 SDK + project sources

sdk/osal/csky/condv.c

@@ -0,0 +1,84 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/string.h"
+#include "osal/semaphore.h"
+#include "osal/mutex.h"
+#include "osal/condv.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+#include <k_api.h>
+
+#define CONDV_MAGIC (0x3a8d7c1d)
+
+int32 os_condv_init(os_condv_t *cond)
+{
+    if(cond->magic == CONDV_MAGIC){
+        os_printf(KERN_WARNING"condv repeat initialization ????\r\n");
+    }
+
+    cond->sema = csi_kernel_sem_new(65535, 0);
+    if (cond->sema) {
+        cond->magic = CONDV_MAGIC;
+        atomic_set(&cond->waitings, 0);
+    }
+    return (cond->sema ? RET_OK : RET_ERR);
+}
+
+int32 os_condv_broadcast(os_condv_t *cond)
+{
+    uint32 i;
+    uint32 wait = atomic_read(&cond->waitings);
+
+    ASSERT(cond && cond->magic == CONDV_MAGIC);
+    while (wait > 0) {
+        if (wait == atomic_cmpxchg(&cond->waitings, wait, 0)) {
+            for (i = 0; i < wait; i++) {
+                csi_kernel_sem_post(cond->sema);
+            }
+        }
+        wait = atomic_read(&cond->waitings);
+    }
+
+    return RET_OK;
+}
+
+int32 os_condv_signal(os_condv_t *cond)
+{
+    uint32 wait = atomic_read(&cond->waitings);
+    ASSERT(cond && cond->magic == CONDV_MAGIC);
+    while (wait > 0) {
+        if (wait == atomic_cmpxchg(&cond->waitings, wait, wait - 1)) {
+            csi_kernel_sem_post(cond->sema);
+            break;
+        }
+        wait = atomic_read(&cond->waitings);
+    }
+	return RET_OK;
+}
+
+int32 os_condv_del(os_condv_t *cond)
+{
+    ASSERT(cond && cond->magic == CONDV_MAGIC);
+    csi_kernel_sem_del(cond->sema);
+    cond->sema = NULL;
+    cond->magic = 0;
+    return RET_OK;
+}
+
+int32 os_condv_wait(os_condv_t *cond, os_mutex_t *mutex, uint32 tmo_ms)
+{
+    int32 ret;
+    ASSERT(cond && cond->magic == CONDV_MAGIC);
+    atomic_inc(&cond->waitings);
+    os_mutex_unlock(mutex);
+    ret = csi_kernel_sem_wait(cond->sema, tmo_ms);
+    //os_printf(KERN_NOTICE"condv 0x%x waitings:%d, tmo_ms:%d, ret:%d\r\n", cond, atomic_read(&cond->waitings), tmo_ms, ret);
+    os_mutex_lock(mutex, osWaitForever);
+    atomic_dec(&cond->waitings);
+    return ret ? -ETIMEDOUT : RET_OK;
+}
+
+#endif
+

sdk/osal/csky/event.c

@@ -0,0 +1,72 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/string.h"
+#include "osal/event.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+
+#define EVENT_MAGIC (0xa67b3cd4)
+
+int32 os_event_init(os_event_t *evt)
+{
+    if(evt->magic == EVENT_MAGIC){
+        os_printf(KERN_WARNING"event repeat initialization ????\r\n");
+    }
+
+    evt->hdl = csi_kernel_event_new();
+    ASSERT(evt->hdl);
+    if (evt->hdl) { 
+        evt->magic = EVENT_MAGIC; 
+    }
+    return (evt->hdl ? RET_OK : RET_ERR);
+}
+
+int32 os_event_del(os_event_t *evt)
+{
+    ASSERT(evt && evt->magic == EVENT_MAGIC);
+    int32 ret = csi_kernel_event_del(evt->hdl);
+    evt->hdl = NULL;
+    evt->magic = 0;
+    return ret;
+}
+
+int32 os_event_set(os_event_t *evt, uint32 flags, uint32 *rflags)
+{
+    uint32 _rflags;
+    ASSERT(evt && evt->magic == EVENT_MAGIC);
+    if(rflags == NULL) rflags = &_rflags;
+    return csi_kernel_event_set(evt->hdl, flags, (uint32_t *)rflags);
+}
+
+int32 os_event_clear(os_event_t *evt, uint32 flags, uint32 *rflags)
+{
+    uint32 _rflags;
+    ASSERT(evt && evt->magic == EVENT_MAGIC);
+    if(rflags == NULL) rflags = &_rflags;
+    return csi_kernel_event_clear(evt->hdl, flags, (uint32_t *)rflags);
+}
+
+int32 os_event_get(os_event_t *evt, uint32 *rflags)
+{
+    ASSERT(evt && evt->magic == EVENT_MAGIC);
+    return csi_kernel_event_get(evt->hdl, (uint32_t *)rflags);
+}
+
+int32 os_event_wait(os_event_t *evt, uint32 flags, uint32 *rflags, uint32 mode, int32 timeout)
+{
+    uint32 _rflags;
+    k_event_opt_t options = KEVENT_OPT_SET_ALL;
+    uint8_t clr_on_exit   = (mode & OS_EVENT_WMODE_CLEAR) ? 1 : 0;
+
+    ASSERT(evt && evt->magic == EVENT_MAGIC);
+    if (mode & OS_EVENT_WMODE_OR) {
+        options = KEVENT_OPT_SET_ANY;
+    }
+    if(rflags == NULL) rflags = &_rflags;
+    return csi_kernel_event_wait(evt->hdl, flags, options, clr_on_exit, (uint32_t *)rflags, timeout);
+}
+
+#endif
+

sdk/osal/csky/msgqueue.c

@@ -0,0 +1,65 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/string.h"
+#include "osal/msgqueue.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+
+#define MSGQ_MAGIC (0x4a8b1c9d)
+
+int32 os_msgq_init(os_msgqueue_t *msgq, int32 size)
+{
+    if(msgq->magic == MSGQ_MAGIC){
+        os_printf(KERN_WARNING"msgq repeat initialization ????\r\n");
+    }
+
+    msgq->hdl = csi_kernel_msgq_new(size, sizeof(uint32));
+    if(msgq->hdl) msgq->magic = MSGQ_MAGIC;
+    return (msgq->hdl ? RET_OK : RET_ERR);
+}
+
+uint32 os_msgq_get(os_msgqueue_t *msgq, int32 tmo_ms)
+{
+    uint32 val = 0;
+    ASSERT(msgq->hdl);
+    csi_kernel_msgq_get(msgq->hdl, &val, csi_kernel_ms2tick(tmo_ms));
+    return val;
+}
+
+uint32 os_msgq_get2(struct os_msgqueue *msgq, int32 tmo_ms, int32 *err)
+{
+    uint32 val = 0;
+    k_status_t ret = csi_kernel_msgq_get(msgq->hdl, &val, csi_kernel_ms2tick(tmo_ms));
+    if(err) *err = ret;
+    return val;
+}
+
+int32 os_msgq_put(os_msgqueue_t *msgq, uint32 data, int32 tmo_ms)
+{
+    ASSERT(msgq->hdl);
+    return csi_kernel_msgq_put(msgq->hdl, &data, 0, csi_kernel_ms2tick(tmo_ms));
+}
+
+int32 os_msgq_put_head(os_msgqueue_t *msgq, uint32 data, int32 tmo_ms)
+{
+    ASSERT(msgq->hdl);
+    return csi_kernel_msgq_put(msgq->hdl, &data, 0, csi_kernel_ms2tick(tmo_ms));
+}
+
+int32 os_msgq_del(os_msgqueue_t *msgq)
+{
+    ASSERT(msgq->hdl);
+    csi_kernel_msgq_del(msgq->hdl);
+    msgq->hdl = NULL;
+    msgq->magic = 0;
+    return RET_OK;
+}
+
+int32 os_msgq_cnt(os_msgqueue_t *msgq)
+{
+    return csi_kernel_msgq_get_count(msgq->hdl);
+}
+
+#endif

sdk/osal/csky/mutex.c

@@ -0,0 +1,52 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/string.h"
+#include "osal/mutex.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+
+#define MUTEX_MAGIC (0xa8b4c2d5)
+
+int32 os_mutex_init(os_mutex_t *mutex)
+{
+    if(mutex->magic == MUTEX_MAGIC){
+        os_printf(KERN_WARNING"mutex repeat initialization ????\r\n");
+    }
+
+    mutex->hdl = csi_kernel_mutex_new();
+    if(mutex->hdl) mutex->magic = MUTEX_MAGIC;
+    return (mutex->hdl ? RET_OK : RET_ERR);
+}
+
+int32 os_mutex_lock(os_mutex_t *mutex, int32 tmo)
+{
+    ASSERT(mutex && mutex->hdl);
+    return csi_kernel_mutex_lock(mutex->hdl, csi_kernel_ms2tick(tmo), (uint32_t)RETURN_ADDR());
+}
+
+int32 os_mutex_unlock(os_mutex_t *mutex)
+{
+    ASSERT(mutex && mutex->hdl);
+    return csi_kernel_mutex_unlock(mutex->hdl);
+}
+
+int32 os_mutex_del(os_mutex_t *mutex)
+{
+    int32 ret = 0;
+    ASSERT(mutex && mutex->hdl);
+    ret = csi_kernel_mutex_del(mutex->hdl);
+    mutex->hdl = NULL;
+    mutex->magic = 0;
+    return ret;
+}
+
+void *os_mutex_owner(os_mutex_t *mutex)
+{
+    ASSERT(mutex && mutex->hdl);
+    return csi_kernel_mutex_get_owner(mutex->hdl);
+}
+
+#endif
+

sdk/osal/csky/semaphore.c

@@ -0,0 +1,64 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/string.h"
+#include "osal/semaphore.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+#include <k_api.h>
+
+#define SEMA_MAGIC (0x3a8d7c1d)
+
+int32 os_sema_init(os_semaphore_t *sem, int32 val)
+{
+    if (sem->magic == SEMA_MAGIC) {
+        os_printf(KERN_WARNING"sem repeat initialization ????\r\n");
+    }
+
+    sem->hdl = csi_kernel_sem_new(65535, val);
+    if (sem->hdl) { sem->magic = SEMA_MAGIC; }
+    return (sem->hdl ? RET_OK : RET_ERR);
+}
+
+int32 os_sema_down(os_semaphore_t *sem, int32 tmo_ms)
+{
+    int32  ret = 0;
+    ASSERT(sem && sem->hdl);
+    ret = csi_kernel_sem_wait(sem->hdl, csi_kernel_ms2tick(tmo_ms));
+    return (ret == RHINO_SUCCESS) ? 1 : 0;
+}
+
+int32 os_sema_up(os_semaphore_t *sem)
+{
+    ASSERT(sem && sem->hdl);
+    return csi_kernel_sem_post(sem->hdl);
+}
+
+int32 os_sema_del(os_semaphore_t *sem)
+{
+    ASSERT(sem && sem->hdl);
+    int32 ret = csi_kernel_sem_del(sem->hdl);
+    sem->hdl = NULL;
+    sem->magic = 0;
+    return ret;
+}
+
+int32 os_sema_count(os_semaphore_t *sem)
+{
+    return (sem && sem->hdl) ? csi_kernel_sem_get_count(sem->hdl) : 0;
+}
+
+void os_sema_eat(os_semaphore_t *sem)
+{
+    int32 ret = 0;
+    while (os_sema_count(sem) > 0) {
+        ret = os_sema_down(sem, 0);
+        if (!ret) {
+            break;
+        }
+    }
+}
+
+#endif
+

sdk/osal/csky/sleep.c

@@ -0,0 +1,22 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/sleep.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+#include <k_api.h>
+#include <sys/time.h>
+
+void os_sleep(int32 sec)
+{
+    csi_kernel_delay(csi_kernel_ms2tick(sec * 1000));
+}
+
+void os_sleep_ms(int32 msec)
+{
+    csi_kernel_delay_ms(msec);
+}
+
+#endif
+

sdk/osal/csky/task.c

@@ -0,0 +1,270 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/string.h"
+#include "osal/task.h"
+
+#ifdef CSKY_OS
+#include <csi_kernel.h>
+#include <k_api.h>
+
+extern uint32_t csi_kernel_task_runtime(struct os_task_info *tsk_rumtime, int count);
+extern void csi_kernel_task_dump(k_task_handle_t task_handle, void *stack);
+extern void csi_kernel_task_print(void);
+extern int csi_kernel_task_count(void);
+
+static void os_task_entry(void *args)
+{
+    os_task_t *task = (os_task_t *)args;
+    task->func((void *)task->args);
+}
+
+int32 os_task_init(const uint8 *name, os_task_t *task, os_task_func_t func, uint32 data)
+{
+    //ASSERT(task);
+    os_memset(task, 0, sizeof(os_task_t));
+    task->args = data;
+    task->func = func;
+    task->name = (const char *)name;
+    return RET_OK;
+}
+
+int32 os_task_priority(os_task_t *task)
+{
+    //ASSERT(task);
+    return task->priority;
+}
+int32 os_task_priority2(void *hdl)
+{
+    return csi_kernel_task_get_prio(hdl);
+}
+
+int32 os_task_stacksize(os_task_t *task)
+{
+    //ASSERT(task);
+    return task->stack_size;
+}
+int32 os_task_stacksize2(void *hdl)
+{
+    return csi_kernel_task_get_stack_size(hdl);
+}
+
+int32 _os_task_set_priority(os_task_t *task, uint32 prio)
+{
+    int32 pri = KPRIO_NORMAL;
+    uint8 priority  = prio & 0xff;
+
+    //ASSERT(task);
+    //ASSERT(!task->hdl);
+    if (priority < OS_TASK_PRIORITY_LOW) {
+        pri = KPRIO_LOW0;
+    } else if (priority < OS_TASK_PRIORITY_BELOW_NORMAL) {
+        pri = KPRIO_LOW0 + (priority - OS_TASK_PRIORITY_LOW);
+        if (pri > KPRIO_LOW7) { pri = KPRIO_LOW7; }
+    } else if (priority >= OS_TASK_PRIORITY_BELOW_NORMAL && priority < OS_TASK_PRIORITY_NORMAL) {
+        pri = KPRIO_NORMAL_BELOW0 + (priority - OS_TASK_PRIORITY_BELOW_NORMAL);
+        if (pri > KPRIO_NORMAL_BELOW7) { pri = KPRIO_NORMAL_BELOW7; }
+    } else if (priority >= OS_TASK_PRIORITY_NORMAL && priority < OS_TASK_PRIORITY_ABOVE_NORMAL) {
+        pri = KPRIO_NORMAL + (priority - OS_TASK_PRIORITY_NORMAL);
+        if (pri > KPRIO_NORMAL7) { pri = KPRIO_NORMAL7; }
+    } else if (priority >= OS_TASK_PRIORITY_ABOVE_NORMAL && priority < OS_TASK_PRIORITY_HIGH) {
+        pri = KPRIO_NORMAL_ABOVE0 + (priority - OS_TASK_PRIORITY_ABOVE_NORMAL);
+        if (pri > KPRIO_NORMAL_ABOVE7) { pri = KPRIO_NORMAL_ABOVE7; }
+    } else if (priority >= OS_TASK_PRIORITY_HIGH && priority < OS_TASK_PRIORITY_REALTIME) {
+        pri = KPRIO_HIGH0 + (priority - OS_TASK_PRIORITY_HIGH);
+        if (pri > KPRIO_HIGH7) { pri = KPRIO_HIGH7; }
+    } else if (priority >= OS_TASK_PRIORITY_REALTIME && priority < OS_TASK_PRIORITY_ISR) {
+        pri = KPRIO_REALTIME0 + (priority - OS_TASK_PRIORITY_REALTIME);
+        if (pri > KPRIO_REALTIME7) { pri = KPRIO_REALTIME7; }
+    } else {
+        pri = KPRIO_ISR;
+    }
+
+    if (task) {
+        task->priority = pri;
+        task->lprun    = (prio & OS_TASK_FLAGS_LPRUN) ? 1 : 0;
+        if (task->hdl) {
+            csi_kernel_task_set_prio(task->hdl, task->priority);
+            csi_kernel_task_set_lprun(task->hdl, task->lprun);
+        }
+    }
+    return pri;
+}
+
+int32 os_task_set_priority(os_task_t *task, uint32 pri)
+{
+    uint8 priority = pri & 0xff;
+    if (priority >= OS_TASK_PRIORITY_HIGH) {
+        priority = OS_TASK_PRIORITY_HIGH - 1;
+        pri &= 0xffffff00;
+        pri |= priority;
+        os_printf("INVALID PRIORITY\r\n");
+    }
+    return _os_task_set_priority(task, pri);
+}
+
+int32 os_task_set_stack(os_task_t *task, void *stack, int32 stack_size)
+{
+    //ASSERT(task);
+    //ASSERT(!task->hdl);
+    task->stack = stack;
+    task->stack_size = stack_size;
+    return RET_OK;
+}
+
+int32 os_task_run(os_task_t *task)
+{
+    //ASSERT(task);
+    int32 ret = csi_kernel_task_new(os_task_entry, task->name,
+                                    (void *)task, task->priority, 0, task->stack,
+                                    task->stack_size, &task->hdl);
+    if(ret == RET_OK){
+        csi_kernel_task_set_lprun(task->hdl, task->lprun);
+    }
+    //ASSERT(!ret);
+    return ret;
+}
+
+int32 os_task_stop(os_task_t *task)
+{
+    //ASSERT(0);
+    csi_kernel_task_terminate(task->hdl);
+    return RET_OK;
+}
+
+int32 os_task_del(os_task_t *task)
+{
+    int32 ret = 0;
+    //ASSERT(task);
+    ASSERT(task->hdl);
+    void *hdl = task->hdl;
+    task->hdl = NULL;
+    ret = csi_kernel_task_del(hdl);
+
+    return ret;
+}
+
+int32 os_task_runtime(struct os_task_info *tsk_times, int32 count)
+{
+    return csi_kernel_task_runtime(tsk_times, count);
+}
+
+void os_task_print(void)
+{
+    csi_kernel_task_print();
+}
+
+int32 os_task_count(void)
+{
+    return csi_kernel_task_count();
+}
+
+void *os_task_current(void)
+{
+    return csi_kernel_task_get_cur();
+}
+
+int32 os_task_suspend(os_task_t *task)
+{
+    return csi_kernel_task_suspend(task->hdl);
+}
+
+int32 os_task_resume(os_task_t *task)
+{
+    return csi_kernel_task_resume(task->hdl);
+}
+
+void os_task_dump(void *hdl, void *stack)
+{
+    csi_kernel_task_dump(hdl, stack);
+}
+
+int32 os_task_yield(void)
+{
+    return csi_kernel_task_yield();
+}
+
+int32 os_sched_disable(void)
+{
+    krhino_sched_disable();
+    return 0;
+}
+
+int32 os_sched_enbale(void)
+{
+    krhino_sched_enable();
+    return 0;
+}
+
+os_task_t *os_task_hdl2tsk(void *hdl)
+{
+    ktask_t *task = (ktask_t *)hdl;
+    return (task && task->arg) ? ((os_task_t *)task->arg) : NULL;
+}
+
+void *os_task_data(void *hdl)
+{
+    ktask_t *task = (ktask_t *)hdl;
+    return task->arg;
+}
+
+void *os_task_create(const char *name, os_task_func_t func, void *args, uint32 prio, uint32 time, void *stack, uint32 stack_size)
+{
+    k_task_handle_t hdl = NULL;
+    uint32 priority = os_task_set_priority(NULL, prio);
+    int32 ret = csi_kernel_task_new(func, name, args, priority, time, stack, stack_size, &hdl);
+    if(ret == RET_OK){
+        if(prio & OS_TASK_FLAGS_LPRUN){
+            csi_kernel_task_set_lprun(hdl, 1);
+        }
+    }
+    ASSERT(!ret);
+    return hdl;
+}
+
+int32 os_task_destroy(void *hdl)
+{
+    return csi_kernel_task_del(hdl);
+}
+
+int32 os_task_suspend2(void *hdl)
+{
+    return csi_kernel_task_suspend((k_task_handle_t)hdl);
+}
+
+int32 os_task_resume2(void  *hdl)
+{
+    return csi_kernel_task_resume((k_task_handle_t)hdl);
+}
+
+int32 os_blklist_init(os_blklist_t *blkobj)
+{
+	void *csi_kernel_blklist_new();
+    blkobj->hdl = csi_kernel_blklist_new();
+    return  blkobj->hdl ? RET_OK : RET_ERR;
+}
+
+void os_blklist_del(os_blklist_t *blkobj)
+{
+	void csi_kernel_blklist_del(void *hdl);
+    csi_kernel_blklist_del(blkobj->hdl);
+}
+
+void os_blklist_suspend(os_blklist_t *blkobj, void *task_hdl)
+{
+	void csi_kernel_blklist_suspend(void *hdl, k_task_handle_t task_hdl);
+    csi_kernel_blklist_suspend(blkobj->hdl, task_hdl);
+}
+
+void os_blklist_resume(os_blklist_t *blkobj)
+{
+	void csi_kernel_blklist_wakeup(void *hdl);
+    csi_kernel_blklist_wakeup(blkobj->hdl);
+}
+
+void os_lpower_mode(uint8 enable)
+{
+    csi_kernel_lpower_mode(enable);
+}
+
+#endif

sdk/osal/csky/time.c

@@ -0,0 +1,323 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/sleep.h"
+#include "osal/irq.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+#include <k_api.h>
+#include <sys/time.h>
+
+#define OS_MS_PERIOD_TICK (1000/OS_SYSTICK_HZ)
+
+extern uint32_t g_cpuloading;
+extern uint64_t g_sys_tick_count;
+static uint64 sys_time_base_ns = 0;
+static uint64 sys_time_real_ns = 0;
+
+uint64 os_jiffies(void)
+{
+    return (g_sys_tick_count);
+}
+
+uint32 os_cpuloading(void)
+{
+    return g_cpuloading;
+}
+
+uint32 os_seconds(void)
+{
+    return krhino_curr_nanosec()/1000000000;
+}
+
+uint64 os_mseconds(void)
+{
+    return krhino_curr_nanosec()/1000000;
+}
+
+uint64 os_useconds(void)
+{
+    return krhino_curr_nanosec()/1000;
+}
+
+void os_systime(struct timespec *tm)
+{
+    uint64 diff_ns = krhino_curr_nanosec() - sys_time_base_ns;
+    tm->tv_sec  = (sys_time_real_ns + diff_ns) / NANOSECONDS_PER_SECOND;
+    tm->tv_nsec = (sys_time_real_ns + diff_ns) % NANOSECONDS_PER_SECOND;
+}
+
+#ifdef __NEWLIB__
+int gettimeofday(struct timeval *ptimeval, void *ptimezone)
+#else
+int gettimeofday(struct timeval *ptimeval, struct timezone *ptimezone)
+#endif
+{
+    uint64 diff_ns = krhino_curr_nanosec() - sys_time_base_ns;
+    ptimeval->tv_sec  = (sys_time_real_ns + diff_ns) / NANOSECONDS_PER_SECOND;
+    ptimeval->tv_usec = ((sys_time_real_ns + diff_ns) % NANOSECONDS_PER_SECOND) / 1000;
+    //加时区
+    //ptimeval->tv_sec += (8*3600); //东八区
+    return 0;
+}
+
+int settimeofday(const struct timeval *tv, const struct timezone *tz)
+{
+    uint32 f = disable_irq();
+    sys_time_base_ns = krhino_curr_nanosec();
+    sys_time_real_ns = (uint64)tv->tv_sec * NANOSECONDS_PER_SECOND + (uint64)tv->tv_usec * 1000UL;
+    enable_irq(f);
+    return 0;
+}
+
+time_t time(time_t *t)
+{
+    time_t v;
+    uint64 diff_ns = krhino_curr_nanosec() - sys_time_base_ns;
+    v = (sys_time_real_ns + diff_ns) / NANOSECONDS_PER_SECOND;
+    if (t) *t = v;
+    return v;
+}
+
+int clock_gettime(uint32 clk_id, struct timespec *tp)
+{
+    if(tp){
+        uint64 ns   = krhino_curr_nanosec();
+        tp->tv_sec  = ns / NANOSECONDS_PER_SECOND;
+        tp->tv_nsec = ns % NANOSECONDS_PER_SECOND;
+    }
+    return 0;
+}
+
+int32 timespec_validate(const struct timespec *time)
+{
+    int32 ret = 0;
+
+    if (time != NULL) {
+        /* Verify 0 <= tv_nsec < 1000000000. */
+        if ((time->tv_nsec >= 0) && (time->tv_nsec < NANOSECONDS_PER_SECOND)) {
+            ret = 1;
+        }
+    }
+
+    return ret;
+}
+
+int32 timespec_cmp(const struct timespec *x, const struct timespec *y)
+{
+    int32 ret = 0;
+
+    /* Check parameters */
+    if ((x == NULL) && (y == NULL)) {
+        ret = 0;
+    } else if (y == NULL) {
+        ret = 1;
+    } else if (x == NULL) {
+        ret = -1;
+    } else if (x->tv_sec > y->tv_sec) {
+        ret = 1;
+    } else if (x->tv_sec < y->tv_sec) {
+        ret = -1;
+    } else {
+        /* seconds are equal compare nano seconds */
+        if (x->tv_nsec > y->tv_nsec) {
+            ret = 1;
+        } else if (x->tv_nsec < y->tv_nsec) {
+            ret = -1;
+        } else {
+            ret = 0;
+        }
+    }
+
+    return ret;
+}
+
+
+int32 timespec_to_ticks(const struct timespec *time, uint64 *result)
+{
+    int32 ret = 0;
+    uint64 llTotalTicks = 0;
+    long lNanoseconds = 0;
+
+    /* Check parameters. */
+    if ((time == NULL) || (result == NULL)) {
+        ret = -EINVAL;
+    } else if ((ret == 0) && (timespec_validate(time) == FALSE)) {
+        ret = -EINVAL;
+    } else {
+        /* Convert timespec.tv_sec to ticks. */
+        llTotalTicks = (uint64) OS_SYSTICK_HZ * (time->tv_sec);
+
+        /* Convert timespec.tv_nsec to ticks. This value does not have to be checked
+         * for overflow because a valid timespec has 0 <= tv_nsec < 1000000000 and
+         * NANOSECONDS_PER_TICK > 1. */
+        lNanoseconds = time->tv_nsec / (long) NANOSECONDS_PER_TICK +                    /* Whole nanoseconds. */
+                       (long)(time->tv_nsec % (long) NANOSECONDS_PER_TICK != 0);        /* Add 1 to round up if needed. */
+
+        /* Add the nanoseconds to the total ticks. */
+        llTotalTicks += (uint64) lNanoseconds;
+
+        /* Write result. */
+        *result = (uint64) llTotalTicks;
+    }
+
+    return ret;
+}
+
+void nanosec_to_timespec(int64 llSource, struct timespec *time)
+{
+    long lCarrySec = 0;
+
+    /* Convert to timespec. */
+    time->tv_sec = (time_t)(llSource / NANOSECONDS_PER_SECOND);
+    time->tv_nsec = (long)(llSource % NANOSECONDS_PER_SECOND);
+
+    /* Subtract from tv_sec if tv_nsec < 0. */
+    if (time->tv_nsec < 0L) {
+        /* Compute the number of seconds to carry. */
+        lCarrySec = (time->tv_nsec / (long) NANOSECONDS_PER_SECOND) + 1L;
+
+        time->tv_sec -= (time_t)(lCarrySec);
+        time->tv_nsec += lCarrySec * (long) NANOSECONDS_PER_SECOND;
+    }
+}
+
+int32 timespec_add(const struct timespec *x, const struct timespec *y, struct timespec *result)
+{
+    int64 llPartialSec = 0;
+    int32 ret = 0;
+
+    /* Check parameters. */
+    if ((result == NULL) || (x == NULL) || (y == NULL)) {
+        return -1;
+    }
+
+    /* Perform addition. */
+    result->tv_nsec = x->tv_nsec + y->tv_nsec;
+
+    /* check for overflow in case nsec value was invalid */
+    if (result->tv_nsec < 0) {
+        ret = 1;
+    } else {
+        llPartialSec = (result->tv_nsec) / NANOSECONDS_PER_SECOND;
+        result->tv_nsec = (result->tv_nsec) % NANOSECONDS_PER_SECOND;
+        result->tv_sec = x->tv_sec + y->tv_sec + llPartialSec;
+
+        /* check for overflow */
+        if (result->tv_sec < 0) {
+            ret = 1;
+        }
+    }
+
+    return ret;
+}
+
+int32 timespec_add_nanosec(const struct timespec *x, int64 llNanoseconds, struct timespec *result)
+{
+    int64 llTotalNSec = 0;
+    int32 ret = 0;
+
+    /* Check parameters. */
+    if ((result == NULL) || (x == NULL)) {
+        return -1;
+    }
+
+    /* add nano seconds */
+    llTotalNSec = x->tv_nsec + llNanoseconds;
+
+    /* check for nano seconds overflow */
+    if (llTotalNSec < 0) {
+        ret = 1;
+    } else {
+        result->tv_nsec = llTotalNSec % NANOSECONDS_PER_SECOND;
+        result->tv_sec = x->tv_sec + (llTotalNSec / NANOSECONDS_PER_SECOND);
+
+        /* check for seconds overflow */
+        if (result->tv_sec < 0) {
+            ret = 1;
+        }
+    }
+
+    return ret;
+}
+
+int32 timespec_sub(const struct timespec *x, const struct timespec *y, struct timespec *result)
+{
+    int32 cmp_ret = 0;
+    int32 ret = 0;
+
+    /* Check parameters. */
+    if ((result == NULL) || (x == NULL) || (y == NULL)) {
+        return -1;
+    }
+
+    cmp_ret = timespec_cmp(x, y);
+
+    /* if x < y then result would be negative, return 1 */
+    if (cmp_ret == -1) {
+        ret = 1;
+    } else if (cmp_ret == 0) {
+        /* if times are the same return zero */
+        result->tv_sec = 0;
+        result->tv_nsec = 0;
+    } else {
+        /* If x > y Perform subtraction. */
+        result->tv_sec = x->tv_sec - y->tv_sec;
+        result->tv_nsec = x->tv_nsec - y->tv_nsec;
+
+        /* check if nano seconds value needs to borrow */
+        if (result->tv_nsec < 0) {
+            /* Based on comparison, tv_sec > 0 */
+            result->tv_sec--;
+            result->tv_nsec += (long) NANOSECONDS_PER_SECOND;
+        }
+
+        /* if nano second is negative after borrow, it is an overflow error */
+        if (result->tv_nsec < 0) {
+            ret = -1;
+        }
+    }
+
+    return ret;
+}
+
+int32 timespec_detal_ticks(const struct timespec *abstime, const struct timespec *curtime, uint64 *result)
+{
+    int32 ret = 0;
+    struct timespec diff = { 0 };
+
+    if(abstime == NULL || curtime == NULL || result == NULL){
+        return -EINVAL;
+    }
+
+    ret = timespec_sub(abstime, curtime, &diff);
+
+    if (ret == 1) {
+        /* abstime was in the past. */
+        ret = -ETIMEDOUT;
+    } else if (ret == -1) {
+        /* error */
+        ret = -EINVAL;
+    }
+
+    /* Convert the time difference to ticks. */
+    if (ret == 0) {
+        ret = timespec_to_ticks(&diff, result);
+    }
+
+    return ret;
+}
+
+uint64 os_jiffies_to_msecs(uint64 jiff)
+{
+    return ((jiff)*OS_MS_PERIOD_TICK);
+}
+
+uint64 os_msecs_to_jiffies(uint64 msec)
+{
+    return ((msec)/OS_MS_PERIOD_TICK);
+}
+
+#endif
+

sdk/osal/csky/timer.c

@@ -0,0 +1,84 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/timer.h"
+#include "osal/string.h"
+
+#ifdef CSKY_OS
+#include "csi_kernel.h"
+
+#define TIMER_MAGIC (0x6a7b3c4d)
+
+static void _os_timer_cb(void *args)
+{
+    uint32 t1, t2, t3;
+    os_timer_t *timer = (os_timer_t *)args;
+    timer->trigger_cnt++;
+    t1 = 0;
+    timer->cb(timer->data);
+    t2 = 0;
+    t3 = t2 - t1;
+    timer->total_time += t3;
+    if (t3 > timer->max_time) {
+        timer->max_time = t3;
+    }
+}
+int os_timer_init(os_timer_t *timer, os_timer_func_t func,
+                  enum OS_TIMER_MODE mode, void *arg)
+{
+    ASSERT(timer && func);
+    if(timer->magic == TIMER_MAGIC){
+        os_printf(KERN_WARNING"timer repeat initialization ????\r\n");
+    }
+
+    timer->cb   = func;
+    timer->data = arg;
+    timer->total_time = 0;
+    timer->max_time = 0;
+    timer->trigger_cnt = 0;
+    timer->hdl = csi_kernel_timer_new(_os_timer_cb, mode, timer);
+    if(timer->hdl) timer->magic = TIMER_MAGIC;
+    return timer->hdl ? 0 : -1;
+}
+
+int os_timer_start(os_timer_t *timer, unsigned long expires)
+{
+    //ASSERT(timer->hdl);
+    if (timer->hdl) {
+        return csi_kernel_timer_start(timer->hdl, csi_kernel_ms2tick(expires));
+    }
+    return 0;
+}
+
+int os_timer_stop(os_timer_t *timer)
+{
+    int ret = 0;
+    //ASSERT(timer->hdl);
+    if (timer->hdl) {
+        ret = csi_kernel_timer_stop(timer->hdl);
+    }
+    return 0;
+}
+
+int os_timer_del(os_timer_t *timer)
+{
+    int ret = 0;
+    //ASSERT(timer->hdl);
+    if (timer->hdl) {
+        ret = csi_kernel_timer_del(timer->hdl);
+        timer->hdl = 0;
+        timer->magic = 0;
+    }
+    return 0;
+}
+
+int os_timer_stat(os_timer_t *timer)
+{
+    if (timer->hdl) {
+        return csi_kernel_timer_get_stat(timer->hdl);
+    }
+    return 0;
+}
+
+#endif
+