V1.0.6

kernel/common/include/osal/aic_osal.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, ArtInChip Technology Co., Ltd
+ * Copyright (c) 2022-2024, ArtInChip Technology Co., Ltd
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -14,6 +14,9 @@
 #include <rtconfig.h>
 #include <aic_common.h>
 
+/* aicos_memcpy */
+extern void *aicos_memcpy(void *, const void *, size_t);
+
 /* Common malloc align */
 typedef void *(*aicos_malloc1_t)(size_t);
 typedef void (*aicos_free1_t)(void *);
@@ -34,6 +37,7 @@ typedef void *aicos_sem_t;
 typedef void *aicos_mutex_t;
 typedef void *aicos_event_t;
 typedef void *aicos_queue_t;
+typedef void *aicos_wqueue_t;
 
 #if defined(KERNEL_RTTHREAD)
 #include "aic_osal_rtthread.h"
@@ -91,6 +95,14 @@ static inline int aicos_queue_send(aicos_queue_t queue, void const *buff) {retur
 static inline int aicos_queue_receive(aicos_queue_t queue, void *buff, uint32_t msec) {return -1;}
 static inline int aicos_queue_empty(aicos_queue_t queue) {return false;}
 
+//--------------------------------------------------------------------+
+// Wait Queue API
+//--------------------------------------------------------------------+
+static inline aicos_wqueue_t aicos_wqueue_create(aicos_wqueue_t queue) {return NULL;}
+static inline void aicos_wqueue_delete(aicos_wqueue_t queue) {}
+static inline int aicos_wqueue_wakeup(aicos_wqueue_t queue) {return -1;}
+static inline int aicos_wqueue_wait(aicos_wqueue_t queue, uint32_t msec) {return -1;}
+
 //--------------------------------------------------------------------+
 // Critical API
 //--------------------------------------------------------------------+

kernel/common/include/osal/aic_osal_baremetal.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, ArtInChip Technology Co., Ltd
+ * Copyright (c) 2022-2024, ArtInChip Technology Co., Ltd
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -41,6 +41,26 @@ static inline void aicos_free_align(uint32_t mem_type, void *mem)
     aic_tlsf_free_align(mem_type, mem);
 }
 
+static inline void *aicos_memdup(unsigned int mem_type, void *src, size_t size)
+{
+    void *p;
+
+    p = aic_tlsf_malloc(mem_type, size);
+    if (p)
+        memcpy(p, src, size);
+    return p;
+}
+
+static inline void *aicos_memdup_align(unsigned int mem_type, void *src, size_t size, size_t align)
+{
+    void *p;
+
+    p = aic_tlsf_malloc_align(mem_type, size, align);
+    if (p)
+        memcpy(p, src, size);
+    return p;
+}
+
 //--------------------------------------------------------------------+
 // Timeout Define
 //--------------------------------------------------------------------+
@@ -337,6 +357,39 @@ static inline int aicos_queue_empty(aicos_queue_t queue)
     return !RB_DATA_COUNT(q->wr_idx, q->rd_idx, q->depth);
 }
 
+//--------------------------------------------------------------------+
+// Wait Queue API
+//--------------------------------------------------------------------+
+
+static inline aicos_wqueue_t aicos_wqueue_create(void)
+{
+    aicos_event_t event = aicos_event_create();
+
+    return (aicos_wqueue_t)event;
+}
+
+static inline void aicos_wqueue_delete(aicos_wqueue_t wqueue)
+{
+    aicos_event_t event = (aicos_event_t)wqueue;
+
+    aicos_event_delete(event);
+}
+
+static inline void aicos_wqueue_wakeup(aicos_wqueue_t wqueue)
+{
+    aicos_event_t event = (aicos_event_t)wqueue;
+    uint32_t recved;
+
+    aicos_event_recv(event, 0x1, &recved, 100);
+}
+
+static inline int aicos_wqueue_wait(aicos_wqueue_t wqueue, uint32_t msec)
+{
+    aicos_event_t event = (aicos_event_t)wqueue;
+
+    return aicos_event_send(event, 0x1);
+}
+
 //--------------------------------------------------------------------+
 // Critical API
 //--------------------------------------------------------------------+

kernel/common/include/osal/aic_osal_freertos.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, ArtInChip Technology Co., Ltd
+ * Copyright (c) 2022-2024, ArtInChip Technology Co., Ltd
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -11,6 +11,7 @@
  extern "C" {
 #endif
 
+#include <string.h>
 #include <FreeRTOS.h>
 #include <semphr.h>
 #include <timers.h>
@@ -264,6 +265,39 @@ static inline int aicos_queue_empty(aicos_queue_t queue)
     return uxQueueMessagesWaiting((QueueHandle_t)queue) == 0;
 }
 
+//--------------------------------------------------------------------+
+// Wait Queue API
+//--------------------------------------------------------------------+
+
+static inline aicos_wqueue_t aicos_wqueue_create(void)
+{
+    aicos_event_t event = aicos_event_create();
+
+    return (aicos_wqueue_t)event;
+}
+
+static inline void aicos_wqueue_delete(aicos_wqueue_t wqueue)
+{
+    aicos_event_t event = (aicos_event_t)wqueue;
+
+    aicos_event_delete(event);
+}
+
+static inline void aicos_wqueue_wakeup(aicos_wqueue_t wqueue)
+{
+    aicos_event_t event = (aicos_event_t)wqueue;
+    uint32_t recved;
+
+    aicos_event_recv(event, 0x1, &recved, 100);
+}
+
+static inline int aicos_wqueue_wait(aicos_wqueue_t wqueue, uint32_t msec)
+{
+    aicos_event_t event = (aicos_event_t)wqueue;
+
+    return aicos_event_send(event, 0x1);
+}
+
 //--------------------------------------------------------------------+
 // Critical API
 //--------------------------------------------------------------------+
@@ -324,6 +358,33 @@ static inline void aicos_free_align(uint32_t mem_type, void *mem)
         aic_tlsf_free_align(mem_type, mem);
 }
 
+static inline void *aicos_memdup(unsigned int mem_type, void *src, size_t size)
+{
+    void *p;
+
+    if (mem_type == MEM_DEFAULT)
+        p = pvPortMalloc(size);
+    else
+        p = aic_tlsf_malloc(mem_type, size);
+
+    if (p)
+        memcpy(p, src, size);
+    return p;
+}
+static inline void *aicos_memdup_align(unsigned int mem_type, void *src, size_t size, size_t align)
+{
+    void *p;
+
+    if (mem_type == MEM_DEFAULT)
+        p = _aicos_malloc_align_(size, align, 0xFFFF, (void *)pvPortMalloc);
+    else
+        p = aic_tlsf_malloc_align(mem_type, size, align);
+
+    if (p)
+        memcpy(p, src, size);
+    return p;
+}
+
 #ifdef __cplusplus
  }
 #endif

kernel/common/include/osal/aic_osal_rtthread.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, ArtInChip Technology Co., Ltd
+ * Copyright (c) 2022-2024, ArtInChip Technology Co., Ltd
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -11,15 +11,18 @@
  extern "C" {
 #endif
 
+#include <string.h>
 #include <rtthread.h>
 #include <rthw.h>
+#include <rtdevice.h>
 #include <aic_errno.h>
 
 //--------------------------------------------------------------------+
 // Timeout Define
 //--------------------------------------------------------------------+
 
-#define AICOS_WAIT_FOREVER RT_WAITING_FOREVER
+#define AICOS_WAIT_FOREVER  RT_WAITING_FOREVER
+#define AICOS_CMD_RESET     RT_IPC_CMD_RESET
 
 //--------------------------------------------------------------------+
 // Thread API
@@ -87,6 +90,15 @@ static inline int aicos_sem_give(aicos_sem_t sem)
     return (int)rt_sem_release((rt_sem_t)sem);
 }
 
+static inline int aicos_sem_reset(aicos_sem_t sem, unsigned long val)
+{
+    int ret = 0;
+
+    ret = rt_sem_control((rt_sem_t)sem, AICOS_CMD_RESET, (void *)val);
+
+    return (int)ret;
+}
+
 //--------------------------------------------------------------------+
 // Mutex API (priority inheritance)
 //--------------------------------------------------------------------+
@@ -199,6 +211,58 @@ static inline int aicos_queue_empty(aicos_queue_t queue)
     return (qhdl->entry) == 0;
 }
 
+//--------------------------------------------------------------------+
+// Wait Queue API
+//--------------------------------------------------------------------+
+
+static inline aicos_wqueue_t aicos_wqueue_create(void)
+{
+    rt_wqueue_t *wqueue = rt_malloc(sizeof(*wqueue));
+
+    if (!wqueue)
+        return NULL;
+
+    rt_wqueue_init(wqueue);
+    return (aicos_wqueue_t)wqueue;
+}
+
+static inline void aicos_wqueue_delete(aicos_wqueue_t wqueue)
+{
+    rt_wqueue_t *queue = (rt_wqueue_t *)wqueue;
+    rt_list_t *queue_list;
+    struct rt_list_node *node;
+    struct rt_wqueue_node *entry;
+
+    queue_list = &(queue->waiting_list);
+
+    if (!(rt_list_isempty(queue_list)))
+    {
+        for (node = queue_list->next; node != queue_list;)
+        {
+            entry = rt_list_entry(node, struct rt_wqueue_node, list);
+
+            node = node->next;
+            rt_wqueue_remove(entry);
+        }
+    }
+
+    rt_free(wqueue);
+}
+
+static inline void aicos_wqueue_wakeup(aicos_wqueue_t wqueue)
+{
+    rt_wqueue_t *wq = (rt_wqueue_t *)wqueue;
+
+    rt_wqueue_wakeup_all(wq, NULL);
+}
+
+static inline int aicos_wqueue_wait(aicos_wqueue_t wqueue, uint32_t msec)
+{
+    rt_wqueue_t *wq = (rt_wqueue_t *)wqueue;
+
+    return rt_wqueue_wait(wq, 0, msec);
+}
+
 //--------------------------------------------------------------------+
 // Critical API
 //--------------------------------------------------------------------+
@@ -230,10 +294,14 @@ void aic_memheap_free(int type, void *rmem);
 
 static inline void *aicos_malloc(unsigned int mem_type, size_t size)
 {
+    void *p;
+
     if (mem_type == MEM_DEFAULT)
-        return rt_malloc(size);
+        p = rt_malloc(size);
     else
-        return aic_memheap_malloc(mem_type, size);
+        p = aic_memheap_malloc(mem_type, size);
+
+    return p;
 }
 
 static inline void aicos_free(unsigned int mem_type, void *mem)
@@ -246,10 +314,14 @@ static inline void aicos_free(unsigned int mem_type, void *mem)
 
 static inline void *aicos_malloc_align(uint32_t mem_type, size_t size, size_t align)
 {
+    void *p;
+
     if (mem_type == MEM_DEFAULT)
-        return rt_malloc_align(size, align);
+        p = rt_malloc_align(size, align);
     else
-        return _aicos_malloc_align_(size, align, mem_type, (void *)aic_memheap_malloc);
+        p = _aicos_malloc_align_(size, align, mem_type, (void *)aic_memheap_malloc);
+
+    return p;
 }
 
 static inline void aicos_free_align(uint32_t mem_type, void *mem)
@@ -260,6 +332,34 @@ static inline void aicos_free_align(uint32_t mem_type, void *mem)
         _aicos_free_align_(mem, mem_type, (void *)aic_memheap_free);
 }
 
+static inline void *aicos_memdup(unsigned int mem_type, void *src, size_t size)
+{
+    void *p;
+
+    if (mem_type == MEM_DEFAULT)
+        p = rt_malloc(size);
+    else
+        p = aic_memheap_malloc(mem_type, size);
+
+    if (p)
+        memcpy(p, src, size);
+    return p;
+}
+
+static inline void *aicos_memdup_align(unsigned int mem_type, void *src, size_t size, size_t align)
+{
+    void *p;
+
+    if (mem_type == MEM_DEFAULT)
+        p = rt_malloc_align(size, align);
+    else
+        p = _aicos_malloc_align_(size, align, mem_type, (void *)aic_memheap_malloc);
+
+    if (p)
+        memcpy(p, src, size);
+    return p;
+}
+
 #ifdef __cplusplus
  }
 #endif