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

sdk/osal/ohos/condv.c

@@ -0,0 +1,105 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/string.h"
+#include "osal/semaphore.h"
+#include "osal/mutex.h"
+#include "osal/condv.h"
+
+
+#define CONDV_MAGIC (0x3a8d7c1d)
+
+int32 os_condv_init(os_condv_t *cond)
+{
+    UINT32 hdl = 0;
+    ASSERT(cond);
+
+    if(cond->magic == CONDV_MAGIC){
+        os_printf(KERN_WARNING"condv repeat initialization ????\r\n");
+    }
+
+    if (LOS_OK == LOS_SemCreate(0, &hdl)) {
+        cond->sema = (void *)(hdl + 1);
+        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 hdl  = (UINT32)cond->sema;
+    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++) {
+                LOS_SemPost(hdl - 1);
+            }
+        }
+        wait = atomic_read(&cond->waitings);
+    }
+
+    return RET_OK;
+}
+
+int32 os_condv_signal(os_condv_t *cond)
+{
+    ASSERT(cond && cond->magic == CONDV_MAGIC);
+    UINT32 hdl  = (UINT32)cond->sema;
+    uint32 wait = atomic_read(&cond->waitings);
+    while (wait > 0) {
+        if (wait == atomic_cmpxchg(&cond->waitings, wait, wait - 1)) {
+            LOS_SemPost(hdl - 1);
+            break;
+        }
+        wait = atomic_read(&cond->waitings);
+    }
+    return RET_OK;
+}
+
+int32 os_condv_del(os_condv_t *cond)
+{
+    ASSERT(cond && cond->magic == CONDV_MAGIC);
+    UINT32 hdl  = (UINT32)cond->sema;
+    LOS_SemDelete(hdl - 1);
+    cond->sema = NULL;
+    cond->magic = 0;
+    return RET_OK;
+}
+
+int32 os_condv_wait(os_condv_t *cond, os_mutex_t *mutex, uint32 tmo_ms)
+{
+    ASSERT(cond && cond->magic == CONDV_MAGIC);
+    int32 ret;
+    UINT32 hdl  = (UINT32)cond->sema;
+
+    atomic_inc(&cond->waitings);
+    os_mutex_unlock(mutex);
+    ret = LOS_SemPend(hdl - 1, LOS_MS2Tick(tmo_ms));
+    os_mutex_lock(mutex, osWaitForever);
+    atomic_dec(&cond->waitings);
+    return ret ? -ETIMEDOUT : RET_OK;
+}
+
+#endif
+

sdk/osal/ohos/event.c

@@ -0,0 +1,162 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+#include "osal/string.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+
+#define EVENT_MAGIC (0xa67b3cd4)
+
+int32 os_event_init(os_event_t *evt)
+{
+    UINT32 ret;
+    PEVENT_CB_S pstEventCB;
+
+    if(evt->magic == EVENT_MAGIC){
+        os_printf(KERN_WARNING"event repeat initialization ????\r\n");
+    }
+
+    pstEventCB = (PEVENT_CB_S)os_malloc(sizeof(EVENT_CB_S));
+    if (pstEventCB == NULL) {
+        return RET_ERR;
+    }
+
+    ret = LOS_EventInit(pstEventCB);
+    if (ret == LOS_OK) {
+        evt->hdl = pstEventCB;
+        evt->magic = EVENT_MAGIC;
+        return RET_OK;
+    } else {
+        os_free(pstEventCB);
+        return RET_ERR;
+    }
+}
+
+int32 os_event_del(os_event_t *evt)
+{
+    ASSERT(evt && evt->magic == EVENT_MAGIC);
+    int32 ret = LOS_EventDestroy((PEVENT_CB_S)evt->hdl);
+    os_free(evt->hdl);
+    evt->hdl = NULL;
+    evt->magic = 0;
+    return ret;
+}
+
+int32 os_event_set(os_event_t *evt, uint32 flags, uint32 *rflags)
+{
+    PEVENT_CB_S pstEventCB = (PEVENT_CB_S)evt->hdl;
+    UINT32 ret;
+
+    ASSERT(evt && evt->magic == EVENT_MAGIC);
+    if (pstEventCB == NULL) {
+        return -EINVAL;
+    }
+
+    ret = LOS_EventWrite(pstEventCB, (UINT32)flags);
+    if (ret == LOS_OK) {
+        *rflags = pstEventCB->uwEventID;
+        return ret;
+    } else {
+        return RET_ERR;
+    }
+}
+
+int32 os_event_clear(os_event_t *evt, uint32 flags, uint32 *rflags)
+{
+    PEVENT_CB_S pstEventCB = (PEVENT_CB_S)evt->hdl;
+    UINT32 intSave;
+    UINT32 ret;
+
+    if (pstEventCB == NULL) {
+        return RET_ERR;
+    }
+
+    intSave = LOS_IntLock();
+    *rflags = pstEventCB->uwEventID;
+    ret = LOS_EventClear(pstEventCB, ~flags);
+    LOS_IntRestore(intSave);
+    return ret;
+}
+
+int32 os_event_get(os_event_t *evt, uint32 *rflags)
+{
+    PEVENT_CB_S pstEventCB = (PEVENT_CB_S)evt->hdl;
+    UINT32 intSave;
+
+    if (pstEventCB == NULL) {
+        return RET_ERR;
+    }
+
+    intSave = LOS_IntLock();
+    *rflags = pstEventCB->uwEventID;
+    LOS_IntRestore(intSave);
+
+    return 0;
+}
+
+int32 os_event_wait(os_event_t *evt, uint32 flags, uint32 *rflags, uint32 mode, int32 timeout)
+{
+    PEVENT_CB_S pstEventCB = (PEVENT_CB_S)evt->hdl;
+    UINT32 imode = 0;
+    UINT32 ret;
+
+    if (pstEventCB == NULL) {
+        return RET_ERR;
+    }
+
+    if (OS_INT_ACTIVE && (timeout != 0)) {
+        return RET_ERR;
+    }
+
+    if (mode & OS_EVENT_WMODE_OR) {
+        imode |= LOS_WAITMODE_OR;
+    }
+
+    if (mode & OS_EVENT_WMODE_AND) {
+        imode |= LOS_WAITMODE_AND;
+    }
+
+    if (mode & OS_EVENT_WMODE_CLEAR) {
+        imode &= ~LOS_WAITMODE_CLR;
+    } else {
+        imode |= LOS_WAITMODE_CLR;
+    }
+
+    ret = LOS_EventRead(pstEventCB, (UINT32)flags, imode, (UINT32)timeout);
+    switch (ret) {
+        case LOS_ERRNO_EVENT_PTR_NULL:
+        case LOS_ERRNO_EVENT_EVENTMASK_INVALID:
+        case LOS_ERRNO_EVENT_FLAGS_INVALID:
+        case LOS_ERRNO_EVENT_SETBIT_INVALID:
+            return RET_ERR;
+
+        case LOS_ERRNO_EVENT_READ_IN_INTERRUPT:
+        case LOS_ERRNO_EVENT_READ_IN_LOCK:
+            return RET_ERR;
+
+        case LOS_ERRNO_EVENT_READ_TIMEOUT:
+            return -ETIMEDOUT;
+
+        default:
+            *rflags = (uint32_t)ret;
+            return RET_OK;
+    }
+}
+
+#endif
+

sdk/osal/ohos/malloc.c

@@ -0,0 +1,44 @@
+#include "basic_include.h"
+#include "los_config.h"
+#include "los_compiler.h"
+
+#ifdef OHOS
+
+UINT8 *m_aucSysMem0 = NULL;
+
+VOID *LOS_MemAlloc(VOID *pool, UINT32 size)
+{
+    void *caller = RETURN_ADDR();
+#if defined(PSRAM_HEAP) && defined(PSRAM_TASK_STACK)
+    return sysheap_alloc(&psram_heap, size, caller, 0);
+#else
+    return sysheap_alloc(&sram_heap, size, caller, 0);
+#endif
+}
+
+UINT32 LOS_MemFree(VOID *pool, VOID *ptr)
+{
+#if defined(PSRAM_HEAP) && defined(PSRAM_TASK_STACK)
+    os_free_psram(ptr);
+#else
+    os_free(ptr);
+#endif
+	return RET_OK;
+}
+
+VOID *LOS_MemAllocAlign(VOID *pool, UINT32 size, UINT32 boundary)
+{
+    void *ptr = LOS_MemAlloc(NULL, size + boundary);
+    if(ptr){
+        ptr = (void *)ALIGN((uint32)ptr, boundary);
+    }
+    return ptr;
+}
+
+UINT32 LOS_MemIntegrityCheck(const VOID *pool)
+{
+    return 0;
+}
+
+#endif
+

sdk/osal/ohos/msgqueue.c

@@ -0,0 +1,97 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/string.h"
+#include "osal/msgqueue.h"
+
+#define MSGQ_MAGIC (0x4a8b1c9d)
+
+int32 os_msgq_init(os_msgqueue_t *msgq, int32 size)
+{
+    UINT32 hdl = 0;
+
+    if(msgq->magic == MSGQ_MAGIC){
+        os_printf(KERN_WARNING"msgq repeat initialization ????\r\n");
+    }
+    
+    if (LOS_OK == LOS_QueueCreate("msgq", size, &hdl, 0, sizeof(uint32))) {
+        msgq->hdl = (void *)(hdl + 1);
+        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;
+    UINT32 hdl = (UINT32)msgq->hdl;
+    ASSERT(msgq->hdl);
+    LOS_QueueRead(hdl - 1, &val, sizeof(uint32), LOS_MS2Tick(tmo_ms));
+    return val;
+}
+
+uint32 os_msgq_get2(struct os_msgqueue *msgq, int32 tmo_ms, int32 *err)
+{
+    UINT32 ret;
+    UINT32 val = 0;
+    UINT32 hdl = (UINT32)msgq->hdl;
+    ASSERT(msgq->hdl);
+    ret = LOS_QueueRead(hdl - 1, &val, sizeof(uint32), LOS_MS2Tick(tmo_ms));
+    if(err) *err = ret;
+    return val;
+}
+
+int32 os_msgq_put(os_msgqueue_t *msgq, uint32 data, int32 tmo_ms)
+{
+    UINT32 hdl = (UINT32)msgq->hdl;
+    ASSERT(msgq->hdl);
+    return LOS_QueueWrite(hdl - 1, (void *)data, sizeof(uint32), LOS_MS2Tick(tmo_ms));
+}
+
+int32 os_msgq_put_head(os_msgqueue_t *msgq, uint32 data, int32 tmo_ms)
+{
+    UINT32 hdl = (UINT32)msgq->hdl;
+    ASSERT(msgq->hdl);
+    return LOS_QueueWriteHead(hdl - 1, (void *)data, sizeof(uint32), LOS_MS2Tick(tmo_ms));
+}
+
+int32 os_msgq_del(os_msgqueue_t *msgq)
+{
+    ASSERT(msgq->hdl);
+    UINT32 hdl = (UINT32)msgq->hdl;
+    ASSERT(msgq->hdl);
+    LOS_QueueDelete(hdl - 1);
+    msgq->hdl = NULL;
+    msgq->magic = 0;
+    return RET_OK;
+}
+
+int32 os_msgq_cnt(os_msgqueue_t *msgq)
+{
+    QUEUE_INFO_S queueInfo;
+    UINT32 hdl = (UINT32)msgq->hdl;
+    ASSERT(msgq->hdl);
+    memset(&queueInfo, 0, sizeof(queueInfo));
+    LOS_QueueInfoGet(hdl - 1, &queueInfo);
+    return queueInfo.readableCnt;
+}
+
+#endif
+

sdk/osal/ohos/mutex.c

@@ -0,0 +1,67 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/string.h"
+#include "osal/mutex.h"
+
+#define MUTEX_MAGIC (0xa8b4c2d5)
+
+int32 os_mutex_init(os_mutex_t *mutex)
+{
+    UINT32 hdl = 0;
+    
+    if(mutex->magic == MUTEX_MAGIC){
+        os_printf(KERN_WARNING"mutex repeat initialization ????\r\n");
+    }
+
+    if (LOS_OK == LOS_MuxCreate(&hdl)) {
+        mutex->hdl = (void *)(hdl+1);
+        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);
+    UINT32 hdl = (UINT32)mutex->hdl;
+    return LOS_MuxPend(hdl - 1, LOS_MS2Tick(tmo), (uint32_t)RETURN_ADDR());
+}
+
+int32 os_mutex_unlock(os_mutex_t *mutex)
+{
+    ASSERT(mutex && mutex->hdl);
+    UINT32 hdl = (UINT32)mutex->hdl;
+    return LOS_MuxPost(hdl - 1);
+}
+
+int32 os_mutex_del(os_mutex_t *mutex)
+{
+    ASSERT(mutex && mutex->hdl);
+    int32 ret = 0;
+    UINT32 hdl = (UINT32)mutex->hdl;
+    ret = LOS_MuxDelete(hdl - 1);
+    mutex->hdl = NULL;
+    mutex->magic = 0;
+    return ret;
+}
+
+#endif
+

sdk/osal/ohos/semaphore.c

@@ -0,0 +1,92 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/string.h"
+#include "osal/semaphore.h"
+
+#define SEMA_MAGIC (0x3a8d7c1d)
+
+int32 os_sema_init(os_semaphore_t *sem, int32 val)
+{
+    UINT32 hdl = 0;
+    ASSERT(sem);
+
+    if(sem->magic == SEMA_MAGIC){
+        os_printf(KERN_WARNING"sem repeat initialization ????\r\n");
+    }
+
+    if (LOS_OK == LOS_SemCreate(val, &hdl)) {
+        sem->hdl = (void *)(hdl + 1);
+        sem->magic = SEMA_MAGIC;
+    } else {
+        os_printf(KERN_ERR"os_sema_init fail\r\n");
+    }
+    return (sem->hdl ? RET_OK : RET_ERR);
+}
+
+int32 os_sema_down(os_semaphore_t *sem, int32 tmo_ms)
+{
+    ASSERT(sem && sem->hdl);
+    INT32  ret = 0;
+    UINT32 hdl = (UINT32)sem->hdl;
+    ret = LOS_SemPend((hdl - 1), LOS_MS2Tick(tmo_ms));
+    return (ret == LOS_OK) ? 1 : 0;
+}
+
+int32 os_sema_up(os_semaphore_t *sem)
+{
+    ASSERT(sem && sem->hdl);
+    UINT32 hdl = (UINT32)sem->hdl;
+    return LOS_SemPost(hdl - 1);
+}
+
+int32 os_sema_del(os_semaphore_t *sem)
+{
+    ASSERT(sem && sem->hdl);
+    UINT32 hdl = (UINT32)sem->hdl;
+    UINT32 ret = LOS_SemDelete(hdl - 1);
+    sem->hdl = NULL;
+    sem->magic = 0;
+    return ret;
+}
+
+int32 os_sema_count(os_semaphore_t *sem)
+{
+    INT32 val = 0;
+    if (sem && sem->hdl) {
+        UINT32 hdl = (UINT32)sem->hdl;
+        LOS_SemGetValue(hdl - 1, &val);
+    }
+    return val > 0 ? val : 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/ohos/sleep.c

@@ -0,0 +1,34 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/sleep.h"
+
+void os_sleep(int32 sec)
+{
+    LOS_TaskDelay(LOS_MS2Tick(sec*1000));
+}
+
+void os_sleep_ms(int32 msec)
+{
+    LOS_TaskDelay(LOS_MS2Tick(msec));
+}
+
+#endif
+

sdk/osal/ohos/task.c

@@ -0,0 +1,454 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/string.h"
+#include "osal/task.h"
+#include "los_cpup.h"
+
+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)
+{
+    UINT32 tsk_hdl = (UINT32)hdl;
+    if(tsk_hdl > 0){
+        return LOS_TaskPriGet(tsk_hdl - 1);
+    }else{
+        return 0;
+    }
+}
+
+int32 os_task_stacksize(os_task_t *task)
+{
+    //ASSERT(task);
+    return task->stack_size;
+}
+int32 os_task_stacksize2(void *hdl)
+{
+    UINT32 tsk_hdl = (UINT32)hdl;
+    if(tsk_hdl > 0){
+        LosTaskCB *taskCB = OS_TCB_FROM_TID(tsk_hdl - 1);
+        return taskCB->stackSize;
+    }else{
+        return 0;
+    }    
+}
+
+int32 _os_task_set_priority(os_task_t *task, uint32 prio)
+{
+    int32 pri      = 12;
+    uint8 priority = prio&0xff;
+
+    //ASSERT(task);
+    //ASSERT(!task->hdl);
+    if (priority < OS_TASK_PRIORITY_LOW) {
+        pri = 31;
+    } else if (priority < OS_TASK_PRIORITY_BELOW_NORMAL) {
+        pri = 24 + (priority - OS_TASK_PRIORITY_LOW);
+        if (pri > 30) { pri = 30; }
+    } else if (priority >= OS_TASK_PRIORITY_BELOW_NORMAL && priority < OS_TASK_PRIORITY_NORMAL) {
+        pri = 18 + (priority - OS_TASK_PRIORITY_BELOW_NORMAL);
+        if (pri > 24) { pri = 24; }
+    } else if (priority >= OS_TASK_PRIORITY_NORMAL && priority < OS_TASK_PRIORITY_ABOVE_NORMAL) {
+        pri = 12 + (priority - OS_TASK_PRIORITY_NORMAL);
+        if (pri > 18) { pri = 18; }
+    } else if (priority >= OS_TASK_PRIORITY_ABOVE_NORMAL && priority < OS_TASK_PRIORITY_HIGH) {
+        pri = 6 + (priority - OS_TASK_PRIORITY_ABOVE_NORMAL);
+        if (pri > 12) { pri = 12; }
+    } else if (priority >= OS_TASK_PRIORITY_HIGH && priority < OS_TASK_PRIORITY_REALTIME) {
+        pri = 2 + (priority - OS_TASK_PRIORITY_HIGH);
+        if (pri > 6) { pri = 6; }
+    } else if (priority >= OS_TASK_PRIORITY_REALTIME && priority < OS_TASK_PRIORITY_ISR) {
+        pri = 1;
+    } else {
+        pri = 0;
+    }
+
+    if (task) {
+        task->priority = pri;
+        task->lprun    = (prio & OS_TASK_FLAGS_LPRUN) ? 1 : 0;
+        if (task->hdl) {
+            LOS_TaskPriSet((UINT32)task->hdl - 1, task->priority);
+            LOS_Task_LpowerRun((UINT32)task->hdl - 1, 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)
+{
+    UINT32 hdl = 0;
+    TSK_INIT_PARAM_S stTskInitParam;
+    os_memset(&stTskInitParam, 0, sizeof(stTskInitParam));
+    stTskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)os_task_entry;
+    stTskInitParam.uwArg = (UINT32)task;
+    stTskInitParam.uwStackSize = task->stack_size;
+    stTskInitParam.pcName = (char *)task->name;
+    stTskInitParam.uwResved = LOS_TASK_ATTR_JOINABLE;
+    stTskInitParam.usTaskPrio = task->priority;
+    if (LOS_OK == LOS_TaskCreate(&hdl, &stTskInitParam)) {
+        LOS_Task_LpowerRun(hdl, task->lprun);
+        task->hdl = (void *)(hdl + 1);
+        return RET_OK;
+    }
+    return RET_ERR;
+}
+
+int32 os_task_stop(os_task_t *task)
+{
+    //ASSERT(0);
+    return RET_OK;
+}
+
+int32 os_task_del(os_task_t *task)
+{
+    UINT32 hdl = (UINT32)task->hdl;
+    task->hdl = NULL;
+    if(hdl > 0){
+        return LOS_TaskDelete(hdl - 1);
+    }else{
+        return -EINVAL;
+    }
+}
+
+int32 os_task_runtime(struct os_task_info *tsk_times, int32 count)
+{
+#if (LOSCFG_BASE_CORE_CPUP == 1)
+    int32 i = 0;
+    int32 j = 0;
+    LosTaskCB *taskCB;
+    CPUP_INFO_S info[LOSCFG_BASE_CORE_TSK_LIMIT + 1];
+    os_memset(info, 0, sizeof(info));
+    LOS_AllTaskCpuUsage(info, CPUP_IN_10S);
+    for (i = 0; i < count && i < LOSCFG_BASE_CORE_TSK_LIMIT + 1; i++) {
+        if (info[i].usStatus && i != g_idleTaskID) {
+            taskCB = OS_TCB_FROM_TID(i);
+            tsk_times[j].id    = i;
+            tsk_times[j].name  = (const char *)taskCB->taskName;
+            tsk_times[j].prio  = taskCB->priority;
+            tsk_times[j].arg   = i+1;
+            tsk_times[j].stack = taskCB->stackSize / 4;
+            tsk_times[j].time  = info[i].uwUsage / LOS_CPUP_PRECISION_MULT;
+            tsk_times[j].status = (const char *)OsConvertTskStatus(g_taskCBArray[i].taskStatus);
+            j++;
+        }
+    }
+    return j;
+#else
+    return 0;
+#endif
+}
+
+void os_task_print(void)
+{
+#if (LOSCFG_BASE_CORE_CPUP == 1)
+    int32 i = 0;
+    LosTaskCB *taskCB;
+    CPUP_INFO_S info[LOSCFG_BASE_CORE_TSK_LIMIT + 1];
+    os_memset(info, 0, sizeof(info));
+    LOS_AllTaskCpuUsage(info, CPUP_IN_10S);
+    for (i = 0; i < LOSCFG_BASE_CORE_TSK_LIMIT + 1; i++) {
+        if (info[i].usStatus) {
+            taskCB = OS_TCB_FROM_TID(i);
+            printf("\0011Task %s %s ticks:%d stack:%d prio:%d, arg:0x%x\r\n", taskCB->taskName, 
+                    (const char *)OsConvertTskStatus(info[i].usStatus),
+                    info[i].uwUsage / LOS_CPUP_PRECISION_MULT,
+                    taskCB->stackSize / 4, taskCB->priority, taskCB->arg);
+        }
+    }
+#endif
+}
+
+int32 os_task_count(void)
+{
+#if (LOSCFG_BASE_CORE_CPUP == 1)
+    int32 i = 0;
+    int32 j = 0;
+    CPUP_INFO_S info[LOSCFG_BASE_CORE_TSK_LIMIT + 1];
+    os_memset(info, 0, sizeof(info));
+    LOS_AllTaskCpuUsage(info, CPUP_IN_10S);
+    for (i = 0; i < LOSCFG_BASE_CORE_TSK_LIMIT + 1; i++) {
+        if (info[i].usStatus) {
+            j++;
+        }
+    }
+    return j;
+#else
+    return 0;
+#endif
+}
+
+void *os_task_current(void)
+{
+    return (void *)(g_losTask.runTask->taskID + 1);
+}
+
+int32 os_task_suspend(os_task_t *task)
+{
+    UINT32 hdl = (UINT32)task->hdl;
+    if(hdl > 0){
+        return LOS_TaskSuspend(hdl - 1);
+    }else{
+        return -EINVAL;
+    }
+}
+
+int32 os_task_resume(os_task_t *task)
+{
+    UINT32 hdl = (UINT32)task->hdl;
+
+    if(hdl > 0){
+        return LOS_TaskResume(hdl - 1);
+    }else{
+        return -EINVAL;
+    }
+}
+
+UINT8 os_task_state_convert(UINT16 taskStatus)
+{
+    if (taskStatus & OS_TASK_STATUS_RUNNING) {
+        return 1;
+    } else if (taskStatus & OS_TASK_STATUS_READY) {
+        return 1; //READY
+    } else if (taskStatus & OS_TASK_STATUS_EXIT) {
+        return 7; //delete
+    } else if (taskStatus & OS_TASK_STATUS_SUSPEND) {
+        return 3; //suspend
+    } else if (taskStatus & OS_TASK_STATUS_DELAY) {
+        return 5; //sleep
+    } else if (taskStatus & OS_TASK_STATUS_PEND) {
+        if (taskStatus & OS_TASK_STATUS_PEND_TIME) {
+            return 6; //
+        }
+        return 2; //pend
+    }
+
+    return 0;
+}
+
+void os_task_dump(void *hdl, void *stack)
+{
+    UINT32 i = 0;
+    UINT32 *p;
+    UINT32 *addr = 0;
+    LosTaskCB *task;
+    UINT32 taskID = (UINT32)hdl;
+    UINT32 *sp = (uint32_t *)__get_SP();
+
+    if(hdl == NULL){
+        return;
+    }
+
+    taskID = taskID - 1;
+    task = OS_TCB_FROM_TID(taskID);
+    p = (stack ? stack : task->stackPointer);
+__lable:
+    printf("\0011Task:%s\r\n", task->taskName);
+    printf("\0011    task_state: %d\r\n", os_task_state_convert(task->taskStatus));
+    printf("\0011    stack_size: %d\r\n", task->stackSize);
+    printf("\0011    task_stack: 0x%08x,0x%08x,0x%08x\r\n", (uint32_t)task->topOfStack, (uint32_t)p, (uint32_t)(task->topOfStack + task->stackSize));
+    if(task == g_losTask.runTask){
+        printf("\0011    task_lr   : %p\r\n", __builtin_return_address(0));
+        printf("\0011    task_pc   : %p\r\n", &&__lable);
+        p = sp;
+    }
+
+    printf("\0011    stack dump:\r\n    ");
+    for(addr=p; (UINT32)addr<task->topOfStack+task->stackSize; addr++){
+        printf("\00110x%08x,", *addr);
+        if(++i == 4){ 
+            printf("\0011\r\n    ");
+            i = 0;
+        }
+    }
+    printf("\0011\r\n");
+}
+
+int32 os_task_yield(void)
+{
+    return LOS_TaskYield();
+}
+
+int32 os_sched_disable(void)
+{
+    LOS_TaskLock();
+    return 0;
+}
+
+int32 os_sched_enbale(void)
+{
+    LOS_TaskUnlock();
+    return 0;
+}
+
+void *os_task_data(void *hdl)
+{
+    LosTaskCB *task;
+    UINT32 taskID = (UINT32)hdl;
+    if(taskID > 0){
+        task = OS_TCB_FROM_TID(taskID-1);
+        return (void *)task->arg;
+    }else{
+        return NULL;
+    }
+}
+
+void *os_task_create(const char *name, os_task_func_t func, void *args, uint32 prio, uint32 time, void *stack, uint32 stack_size)
+{
+    UINT32 hdl = 0;
+    TSK_INIT_PARAM_S stTskInitParam;
+    os_memset(&stTskInitParam, 0, sizeof(stTskInitParam));
+    stTskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)func;
+    stTskInitParam.uwArg = (UINT32)args;
+    stTskInitParam.uwStackSize = stack_size;
+    stTskInitParam.pcName = (char *)name;
+    stTskInitParam.uwResved = LOS_TASK_ATTR_JOINABLE;
+    stTskInitParam.usTaskPrio = os_task_set_priority(NULL, prio);
+    if (LOS_OK == LOS_TaskCreate(&hdl, &stTskInitParam)) {
+        if(prio & OS_TASK_FLAGS_LPRUN){
+            LOS_Task_LpowerRun(hdl, 1);
+        }
+        hdl++;
+    }
+    return (void *)hdl;
+}
+
+int32 os_task_destroy(void *hdl)
+{
+    UINT32 tsk_hdl = (UINT32)hdl;
+    if(tsk_hdl > 0){
+        return LOS_TaskDelete(tsk_hdl - 1);
+    }else{
+        return -EINVAL;
+    }
+}
+
+void os_lpower_mode(uint8 enable)
+{
+    UINT32       intSave;
+    UINT32       loopNum;
+    LosTaskCB    *taskCB = (LosTaskCB *)NULL;
+    intSave = LOS_IntLock();
+    for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) {
+        taskCB = (((LosTaskCB *)g_taskCBArray) + loopNum);
+        if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
+            continue;
+        }
+        if(loopNum != g_idleTaskID && !taskCB->lpRun){
+            if(enable){
+                LOS_TaskSuspend(loopNum);
+            }else{
+                LOS_TaskResume(loopNum);
+            }
+        }
+    }
+    LOS_IntRestore(intSave);
+}
+
+
+int32 os_task_suspend2(void *task_hdl)
+{
+	UINT32 hdl = (UINT32)task_hdl;
+    if(hdl > 0){
+        return LOS_TaskSuspend(hdl - 1);
+    }else{
+        return -EINVAL;
+    }
+}
+
+int32 os_task_resume2(void *task_hdl)
+{
+	UINT32 hdl = (UINT32)task_hdl;
+    if(hdl > 0){
+        return LOS_TaskResume(hdl - 1);
+    }else{
+        return -EINVAL;
+    }
+}
+
+int32 os_blklist_init(os_blklist_t *blkobj)
+{
+    blkobj->hdl = LOS_Blklist_New();
+    return  blkobj->hdl ? RET_OK : RET_ERR;
+}
+
+void os_blklist_del(os_blklist_t *blkobj)
+{
+    if(blkobj->hdl){
+        LOS_Blklist_Delete(blkobj->hdl);
+    }
+}
+
+void os_blklist_suspend(os_blklist_t *blkobj, void *hdl)
+{
+    UINT32 task_hdl = (UINT32)hdl;
+    if(blkobj->hdl && task_hdl > 0){
+        LOS_Blklist_Suspend(blkobj->hdl, task_hdl-1);
+    }
+}
+
+void os_blklist_resume(os_blklist_t *blkobj)
+{
+    if(blkobj->hdl){
+        LOS_Blklist_Resume(blkobj->hdl);
+    }
+}
+
+#endif
+

sdk/osal/ohos/time.c

@@ -0,0 +1,327 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/event.h"
+#include "osal/irq.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/sleep.h"
+#include <sys/time.h>
+
+static uint64 sys_time_base_ns = 0;
+static uint64 sys_time_real_ns = 0;
+
+uint64 os_jiffies(void)
+{
+    return LOS_TickCountGet();
+}
+
+uint32 os_seconds(void)
+{
+    return LOS_CurrNanosec()/1000000000;
+}
+
+uint64 os_mseconds(void)
+{
+    return LOS_CurrNanosec()/1000000;
+}
+
+uint64 os_useconds(void)
+{
+    return LOS_CurrNanosec()/1000;
+}
+
+void os_systime(struct timespec *tm)
+{
+    uint64 diff_ns = LOS_CurrNanosec() - 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 = LOS_CurrNanosec() - 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 = LOS_CurrNanosec();
+    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 = LOS_CurrNanosec() - 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   = LOS_CurrNanosec();
+        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 LOS_Tick2MS(jiff);
+}
+
+uint64 os_msecs_to_jiffies(uint64 msec)
+{
+    return LOS_MS2Tick(msec);
+}
+
+#endif
+

sdk/osal/ohos/timer.c

@@ -0,0 +1,150 @@
+#include "typesdef.h"
+#include "errno.h"
+#include "list.h"
+#include "osal/string.h"
+#include "osal/event.h"
+
+#ifdef OHOS
+#include "los_event.h"
+#include "los_membox.h"
+#include "los_memory.h"
+#include "los_interrupt.h"
+#include "los_mux.h"
+#include "los_queue.h"
+#include "los_sem.h"
+#include "los_swtmr.h"
+#include "los_task.h"
+#include "los_timer.h"
+#include "los_debug.h"
+#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
+#include "los_arch.h"
+#endif
+#include "osal/timer.h"
+
+#define TIMER_MAGIC (0x6a7b3c4d)
+
+static void _os_timer_cb(void *args)
+{
+    uint64 t1, t2, t3;
+    os_timer_t *timer = (os_timer_t *)args;
+    timer->trigger_cnt++;
+    t1 = os_jiffies();
+    timer->cb(timer->data);
+    t2 = os_jiffies();
+    t3 = t2 - t1;
+    timer->total_time += t3;
+    if (t3 > timer->max_time) {
+        timer->max_time = t3;
+    }
+
+    if (timer->mode == OS_TIMER_MODE_ONCE) {
+        timer->hdl = NULL;
+    }
+}
+
+static int32 _os_timer_create(os_timer_t *timer, int32 interval)
+{
+    int32 ret;
+    UINT32 hdl = 0;
+#if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
+    ret = LOS_SwtmrCreate(interval, timer->mode, (SWTMR_PROC_FUNC)_os_timer_cb, &hdl, (UINT32)timer, 1, 0);
+#else
+    ret = LOS_SwtmrCreate(interval, timer->mode, (SWTMR_PROC_FUNC)_os_timer_cb, &hdl, (UINT32)timer);
+#endif
+    if (ret == LOS_OK) {
+        timer->hdl = (void *)(hdl + 1);
+        timer->magic = TIMER_MAGIC;
+    }
+    return ret;
+}
+
+int os_timer_init(os_timer_t *timer, os_timer_func_t func, enum OS_TIMER_MODE mode, void *arg)
+{
+    int32 ret = RET_OK;
+
+    if(timer->magic == TIMER_MAGIC){
+        os_printf(KERN_WARNING"timer repeat initialization ????\r\n");
+    }
+    
+    memset(timer, 0, sizeof(os_timer_t));
+    timer->cb   = func;
+    timer->data = arg;
+    timer->mode = mode;
+    if (mode == OS_TIMER_MODE_PERIODIC) {
+        ret = _os_timer_create(timer, 1);
+    }
+    return ret;
+}
+
+int os_timer_start(os_timer_t *timer, unsigned long expires)
+{
+    int ret = RET_ERR;
+    UINT32 intSave;
+    UINT32 hdl;
+    SWTMR_CTRL_S *swtmr = NULL;
+
+    intSave = LOS_IntLock();
+    switch (timer->mode) {
+        case OS_TIMER_MODE_ONCE:
+            if (timer->hdl) os_timer_del(timer);
+            ret = _os_timer_create(timer, LOS_MS2Tick(expires));
+            break;
+        case OS_TIMER_MODE_PERIODIC:
+            if (timer->hdl) {
+                hdl = (UINT32)timer->hdl;
+                swtmr = OS_SWT_FROM_SID(hdl - 1);
+                swtmr->uwInterval = LOS_MS2Tick(expires);
+                if (swtmr->uwInterval == 0) {
+                    swtmr->uwInterval = 1;
+                }
+                ret = RET_OK;
+            }
+            break;
+        default:
+            break;
+    }
+
+    if (ret == LOS_OK) {
+        hdl = (UINT32)timer->hdl;
+        ret = LOS_SwtmrStart(hdl - 1);
+    }
+    LOS_IntRestore(intSave);
+    return ret;
+}
+
+int os_timer_stop(os_timer_t *timer)
+{
+    int ret = 0;
+    UINT32 hdl = (UINT32)timer->hdl;
+    //ASSERT(timer->hdl);
+    if (timer->hdl) {
+        ret = LOS_SwtmrStop(hdl - 1);
+    }
+    return 0;
+}
+
+int os_timer_del(os_timer_t *timer)
+{
+    int ret = 0;
+    UINT32 hdl = (UINT32)timer->hdl;
+    //ASSERT(timer->hdl);
+    if (timer->hdl) {
+        ret = LOS_SwtmrDelete(hdl - 1);
+        timer->hdl = 0;
+        timer->magic = 0;
+    }
+    return 0;
+}
+
+int os_timer_stat(os_timer_t *timer)
+{
+    uint32 ticks = 0;
+    UINT32 hdl = (UINT32)timer->hdl;
+    if (timer->hdl) {
+        return LOS_SwtmrTimeGet(hdl - 1, &ticks);
+    }
+    return ticks ? 1 : 0;
+}
+
+#endif
+