update: remove ununsed osal
Signed-off-by: sakumisu <1203593632@qq.com>
This commit is contained in:
sakumisu
@@ -1,165 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2022, sakumisu
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#ifdef __rtems__
|
||||
|
||||
#include "usb_osal.h"
|
||||
#include "usb_errno.h"
|
||||
#include <rtems.h>
|
||||
|
||||
#define SYS_USB_MBOX_SIZE (sizeof(void *))
|
||||
|
||||
usb_osal_thread_t usb_osal_thread_create(const char *name, uint32_t stack_size, uint32_t prio, usb_thread_entry_t entry, void *args)
|
||||
{
|
||||
rtems_id id = 0;
|
||||
rtems_status_code res;
|
||||
|
||||
res = rtems_task_create(
|
||||
rtems_build_name(name[0], name[1], name[2], name[3]),
|
||||
prio,
|
||||
stack_size,
|
||||
RTEMS_PREEMPT,
|
||||
0,
|
||||
&id);
|
||||
|
||||
if (res != RTEMS_SUCCESSFUL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
res = rtems_task_start(id, (rtems_task_entry)entry, (rtems_task_argument)args);
|
||||
|
||||
if (res != RTEMS_SUCCESSFUL) {
|
||||
rtems_task_delete(id);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (usb_osal_thread_t)id;
|
||||
}
|
||||
|
||||
void usb_osal_thread_delete(usb_osal_thread_t thread)
|
||||
{
|
||||
rtems_task_delete(thread);
|
||||
}
|
||||
|
||||
usb_osal_sem_t usb_osal_sem_create(uint32_t initial_count)
|
||||
{
|
||||
rtems_id semaphore = 0;
|
||||
rtems_status_code ret = rtems_semaphore_create(
|
||||
rtems_build_name('U', 'S', 'B', 's'),
|
||||
initial_count,
|
||||
RTEMS_COUNTING_SEMAPHORE,
|
||||
0,
|
||||
&semaphore);
|
||||
|
||||
return semaphore;
|
||||
}
|
||||
|
||||
void usb_osal_sem_delete(usb_osal_sem_t sem)
|
||||
{
|
||||
rtems_semaphore_delete(sem);
|
||||
}
|
||||
|
||||
int usb_osal_sem_take(usb_osal_sem_t sem, uint32_t timeout)
|
||||
{
|
||||
rtems_status_code status;
|
||||
status = rtems_semaphore_obtain(sem, RTEMS_WAIT, timeout);
|
||||
return status == RTEMS_SUCCESSFUL ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
int usb_osal_sem_give(usb_osal_sem_t sem)
|
||||
{
|
||||
rtems_status_code status = rtems_semaphore_release(sem);
|
||||
|
||||
return (status == RTEMS_SUCCESSFUL) ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
usb_osal_mutex_t usb_osal_mutex_create(void)
|
||||
{
|
||||
rtems_id mutex;
|
||||
rtems_status_code ret = rtems_semaphore_create(
|
||||
rtems_build_name('U', 'S', 'B', 'm'),
|
||||
1,
|
||||
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_LOCAL,
|
||||
0,
|
||||
&mutex);
|
||||
|
||||
return mutex;
|
||||
}
|
||||
|
||||
void usb_osal_mutex_delete(usb_osal_mutex_t mutex)
|
||||
{
|
||||
rtems_semaphore_delete(mutex);
|
||||
}
|
||||
|
||||
int usb_osal_mutex_take(usb_osal_mutex_t mutex)
|
||||
{
|
||||
return (rtems_semaphore_obtain(mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT) == RTEMS_SUCCESSFUL) ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
int usb_osal_mutex_give(usb_osal_mutex_t mutex)
|
||||
{
|
||||
return (rtems_semaphore_release(mutex) == RTEMS_SUCCESSFUL) ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
usb_osal_mq_t usb_osal_mq_create(uint32_t max_msgs)
|
||||
{
|
||||
rtems_status_code ret;
|
||||
rtems_id mailbox = 0;
|
||||
ret = rtems_message_queue_create(
|
||||
rtems_build_name('U', 'S', 'B', 'q'),
|
||||
max_msgs,
|
||||
SYS_USB_MBOX_SIZE,
|
||||
RTEMS_DEFAULT_ATTRIBUTES,
|
||||
&mailbox);
|
||||
return mailbox;
|
||||
}
|
||||
|
||||
int usb_osal_mq_send(usb_osal_mq_t mq, uintptr_t addr)
|
||||
{
|
||||
rtems_status_code ret;
|
||||
ret = rtems_message_queue_send(mq, &addr, SYS_USB_MBOX_SIZE);
|
||||
return (ret == RTEMS_SUCCESSFUL) ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
int usb_osal_mq_recv(usb_osal_mq_t mq, uintptr_t *addr, uint32_t timeout)
|
||||
{
|
||||
size_t size;
|
||||
rtems_status_code sc;
|
||||
sc = rtems_message_queue_receive(
|
||||
mq,
|
||||
addr,
|
||||
&size,
|
||||
RTEMS_WAIT,
|
||||
timeout);
|
||||
return (sc == RTEMS_SUCCESSFUL) ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
uint32_t usb_osal_enter_critical_section(void)
|
||||
{
|
||||
rtems_interrupt_level pval;
|
||||
|
||||
#if RTEMS_SMP
|
||||
rtems_recursive_mutex_lock(&sys_arch_lock);
|
||||
#else
|
||||
rtems_interrupt_disable(pval);
|
||||
#endif
|
||||
return pval;
|
||||
}
|
||||
|
||||
void usb_osal_leave_critical_section(size_t flag)
|
||||
{
|
||||
#if RTEMS_SMP
|
||||
rtems_recursive_mutex_unlock(&sys_arch_lock);
|
||||
#else
|
||||
rtems_interrupt_enable(flag);
|
||||
#endif
|
||||
}
|
||||
|
||||
void usb_osal_msleep(uint32_t delay)
|
||||
{
|
||||
rtems_task_wake_after(RTEMS_MILLISECONDS_TO_TICKS(delay));
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,425 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2025, sakumisu
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include "usb_config.h"
|
||||
#include "usb_util.h"
|
||||
#include "usb_osal.h"
|
||||
#include "usb_errno.h"
|
||||
#include "usb_log.h"
|
||||
/*
|
||||
*********************************************************************************************************
|
||||
* STANDARD LIBRARIES
|
||||
*********************************************************************************************************
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
#include <math.h>
|
||||
|
||||
/*
|
||||
*********************************************************************************************************
|
||||
* OS
|
||||
*********************************************************************************************************
|
||||
*/
|
||||
|
||||
#include <os.h>
|
||||
|
||||
/*
|
||||
*********************************************************************************************************
|
||||
* LIBRARIES
|
||||
*********************************************************************************************************
|
||||
*/
|
||||
|
||||
#include <cpu.h>
|
||||
#include <lib_def.h>
|
||||
#include <lib_ascii.h>
|
||||
#include <lib_math.h>
|
||||
#include <lib_mem.h>
|
||||
#include <lib_str.h>
|
||||
|
||||
/*
|
||||
*********************************************************************************************************
|
||||
* APP / BSP
|
||||
*********************************************************************************************************
|
||||
*/
|
||||
|
||||
#include <app_cfg.h>
|
||||
|
||||
usb_osal_thread_t usb_osal_thread_create(const char *name, uint32_t stack_size, uint32_t prio, usb_thread_entry_t entry, void *args)
|
||||
{
|
||||
OS_ERR err;
|
||||
OS_TCB *tcb;
|
||||
|
||||
tcb = (OS_TCB *)usb_osal_malloc(USB_ALIGN_UP(sizeof(OS_TCB), 4) + stack_size);
|
||||
if (tcb == NULL) {
|
||||
USB_LOG_ERR("Create thread %s failed\r\n", name);
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
|
||||
memset(tcb, 0, USB_ALIGN_UP(sizeof(OS_TCB), 4) + stack_size);
|
||||
OSTaskCreate((OS_TCB *)tcb,
|
||||
(CPU_CHAR *)name,
|
||||
(OS_TASK_PTR)entry,
|
||||
(void *)args,
|
||||
(OS_PRIO)prio,
|
||||
(CPU_STK *)((uint8_t *)tcb + USB_ALIGN_UP(sizeof(OS_TCB), 4)),
|
||||
(CPU_STK_SIZE)(stack_size / 4) / 10,
|
||||
(CPU_STK_SIZE)(stack_size / 4),
|
||||
(OS_MSG_QTY)0,
|
||||
(OS_TICK)0,
|
||||
(void *)0,
|
||||
(OS_OPT)OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
|
||||
(OS_ERR *)&err);
|
||||
|
||||
return (usb_osal_thread_t)tcb;
|
||||
}
|
||||
|
||||
void usb_osal_thread_delete(usb_osal_thread_t thread)
|
||||
{
|
||||
OS_ERR err;
|
||||
OS_TCB *tcb;
|
||||
CPU_SR_ALLOC();
|
||||
|
||||
CPU_CRITICAL_ENTER();
|
||||
if (thread == NULL) {
|
||||
tcb = OSTCBCurPtr;
|
||||
} else {
|
||||
tcb = (OS_TCB *)thread;
|
||||
}
|
||||
|
||||
OSTaskDel(tcb, &err);
|
||||
usb_osal_free(tcb);
|
||||
CPU_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void usb_osal_thread_schedule_other(void)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
OS_TCB *current_tcb = OSTCBCurPtr;
|
||||
|
||||
const OS_PRIO old_priority = OSPrioCur;
|
||||
|
||||
OSTaskChangePrio(current_tcb, OS_CFG_PRIO_MAX - 1, &err);
|
||||
|
||||
OSSchedRoundRobinYield(&err);
|
||||
|
||||
OSTaskChangePrio(current_tcb, old_priority, &err);
|
||||
}
|
||||
|
||||
usb_osal_sem_t usb_osal_sem_create(uint32_t initial_count)
|
||||
{
|
||||
OS_ERR err;
|
||||
OS_SEM *sem;
|
||||
|
||||
sem = (OS_SEM *)usb_osal_malloc(sizeof(OS_SEM));
|
||||
if (sem == NULL) {
|
||||
USB_LOG_ERR("Create semaphore failed\r\n");
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
|
||||
memset(sem, 0, sizeof(OS_SEM));
|
||||
OSSemCreate(sem, "usbh_sem", initial_count, &err);
|
||||
|
||||
return sem;
|
||||
}
|
||||
|
||||
void usb_osal_sem_delete(usb_osal_sem_t sem)
|
||||
{
|
||||
OS_ERR err;
|
||||
CPU_SR_ALLOC();
|
||||
|
||||
CPU_CRITICAL_ENTER();
|
||||
OSSemDel((OS_SEM *)sem, OS_OPT_DEL_ALWAYS, &err);
|
||||
usb_osal_free(sem);
|
||||
CPU_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
int usb_osal_sem_take(usb_osal_sem_t sem, uint32_t timeout)
|
||||
{
|
||||
OS_ERR err;
|
||||
CPU_TS ts;
|
||||
|
||||
if (timeout == USB_OSAL_WAITING_FOREVER) {
|
||||
OSSemPend((OS_SEM *)sem, 0, OS_OPT_PEND_BLOCKING, &ts, &err);
|
||||
} else {
|
||||
if (timeout == 0) {
|
||||
OSSemPend((OS_SEM *)sem, 0, OS_OPT_PEND_NON_BLOCKING, &ts, &err);
|
||||
} else {
|
||||
OSSemPend((OS_SEM *)sem, timeout, OS_OPT_PEND_BLOCKING, &ts, &err);
|
||||
}
|
||||
}
|
||||
|
||||
if (err == OS_ERR_TIMEOUT) {
|
||||
return -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
if (err != OS_ERR_NONE) {
|
||||
return -USB_ERR_INVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int usb_osal_sem_give(usb_osal_sem_t sem)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
return (OSSemPost((OS_SEM *)sem, OS_OPT_POST_1, &err) == OS_ERR_NONE) ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
void usb_osal_sem_reset(usb_osal_sem_t sem)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
OSSemSet((OS_SEM *)sem, 0, &err);
|
||||
}
|
||||
|
||||
usb_osal_mutex_t usb_osal_mutex_create(void)
|
||||
{
|
||||
OS_ERR err;
|
||||
OS_MUTEX *mutex;
|
||||
|
||||
mutex = (OS_MUTEX *)usb_osal_malloc(sizeof(OS_MUTEX));
|
||||
if (mutex == NULL) {
|
||||
USB_LOG_ERR("Create mutex failed\r\n");
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
|
||||
memset(mutex, 0, sizeof(OS_MUTEX));
|
||||
OSMutexCreate(mutex, "usbh_mutex", &err);
|
||||
|
||||
return mutex;
|
||||
}
|
||||
|
||||
void usb_osal_mutex_delete(usb_osal_mutex_t mutex)
|
||||
{
|
||||
OS_ERR err;
|
||||
CPU_SR_ALLOC();
|
||||
|
||||
CPU_CRITICAL_ENTER();
|
||||
OSMutexDel((OS_MUTEX *)mutex, OS_OPT_DEL_ALWAYS, &err);
|
||||
usb_osal_free(mutex);
|
||||
CPU_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
int usb_osal_mutex_take(usb_osal_mutex_t mutex)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
CPU_TS ts;
|
||||
|
||||
OSMutexPend((OS_MUTEX *)mutex, 0, OS_OPT_PEND_BLOCKING, &ts, &err);
|
||||
|
||||
if (err == OS_ERR_TIMEOUT) {
|
||||
return -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
if (err != OS_ERR_NONE) {
|
||||
return -USB_ERR_INVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int usb_osal_mutex_give(usb_osal_mutex_t mutex)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
OSMutexPost((OS_MUTEX *)mutex, OS_OPT_POST_NONE, &err);
|
||||
|
||||
return (err == OS_ERR_NONE) ? 0 : -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
usb_osal_mq_t usb_osal_mq_create(uint32_t max_msgs)
|
||||
{
|
||||
OS_ERR err;
|
||||
OS_Q *mq;
|
||||
|
||||
mq = (OS_Q *)usb_osal_malloc(sizeof(OS_Q));
|
||||
if (mq == NULL) {
|
||||
USB_LOG_ERR("Create message queue failed\r\n");
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
|
||||
memset(mq, 0, sizeof(OS_Q));
|
||||
OSQCreate((OS_Q *)mq, "usbh_mq", (OS_MSG_QTY)max_msgs, &err);
|
||||
|
||||
return mq;
|
||||
}
|
||||
|
||||
void usb_osal_mq_delete(usb_osal_mq_t mq)
|
||||
{
|
||||
OS_ERR err;
|
||||
CPU_SR_ALLOC();
|
||||
|
||||
CPU_CRITICAL_ENTER();
|
||||
OSQFlush((OS_Q *)mq, &err);
|
||||
OSQDel((OS_Q *)mq, OS_OPT_DEL_ALWAYS, &err);
|
||||
usb_osal_free(mq);
|
||||
CPU_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
int usb_osal_mq_send(usb_osal_mq_t mq, uintptr_t addr)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
OSQPost((OS_Q *)mq, &addr, sizeof(uintptr_t), OS_OPT_POST_FIFO, &err);
|
||||
|
||||
if (err == OS_ERR_TIMEOUT) {
|
||||
return -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
if (err != OS_ERR_NONE) {
|
||||
return -USB_ERR_INVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int usb_osal_mq_recv(usb_osal_mq_t mq, uintptr_t *addr, uint32_t timeout)
|
||||
{
|
||||
OS_ERR err;
|
||||
void *msg = NULL;
|
||||
OS_MSG_SIZE msg_size;
|
||||
|
||||
if (timeout == USB_OSAL_WAITING_FOREVER) {
|
||||
msg = OSQPend((OS_Q *)mq, 0, OS_OPT_PEND_BLOCKING, &msg_size, NULL, &err);
|
||||
} else {
|
||||
if (timeout == 0) {
|
||||
msg = OSQPend((OS_Q *)mq, 0, OS_OPT_PEND_NON_BLOCKING, &msg_size, NULL, &err);
|
||||
} else {
|
||||
msg = OSQPend((OS_Q *)mq, timeout, OS_OPT_PEND_BLOCKING, &msg_size, NULL, &err);
|
||||
}
|
||||
}
|
||||
|
||||
if (err == OS_ERR_TIMEOUT) {
|
||||
return -USB_ERR_TIMEOUT;
|
||||
}
|
||||
|
||||
if (err != OS_ERR_NONE) {
|
||||
return -USB_ERR_INVAL;
|
||||
}
|
||||
|
||||
*addr = *(uintptr_t *)msg;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __usb_timeout(void *p_tmr, void *p_arg)
|
||||
{
|
||||
struct usb_osal_timer *timer = (struct usb_osal_timer *)p_arg;
|
||||
|
||||
timer->handler(timer->argument);
|
||||
}
|
||||
|
||||
struct usb_osal_timer *usb_osal_timer_create(const char *name, uint32_t timeout_ms, usb_timer_handler_t handler, void *argument, bool is_period)
|
||||
{
|
||||
struct usb_osal_timer *timer;
|
||||
OS_ERR err;
|
||||
OS_TMR *tmr;
|
||||
(void)name;
|
||||
|
||||
timer = (struct usb_osal_timer *)usb_osal_malloc(sizeof(struct usb_osal_timer));
|
||||
if (timer == NULL) {
|
||||
USB_LOG_ERR("Create timer %s failed\r\n", name);
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
|
||||
memset(timer, 0, sizeof(struct usb_osal_timer));
|
||||
tmr = (OS_TMR *)usb_osal_malloc(sizeof(OS_TMR));
|
||||
if (tmr == NULL) {
|
||||
USB_LOG_ERR("Create timer %s failed\r\n", name);
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
|
||||
memset(tmr, 0, sizeof(OS_TMR));
|
||||
|
||||
timer->timeout_ms = timeout_ms;
|
||||
timer->handler = handler;
|
||||
timer->argument = argument;
|
||||
timer->is_period = is_period;
|
||||
timer->timer = tmr;
|
||||
|
||||
OSTmrCreate((OS_TMR *)tmr,
|
||||
(CPU_CHAR *)name,
|
||||
(OS_TICK)is_period ? 0 : timeout_ms,
|
||||
(OS_TICK)is_period ? timeout_ms : 0,
|
||||
(OS_OPT)is_period ? OS_OPT_TMR_PERIODIC : OS_OPT_TMR_ONE_SHOT,
|
||||
(OS_TMR_CALLBACK_PTR)__usb_timeout,
|
||||
(void *)timer,
|
||||
(OS_ERR *)&err);
|
||||
|
||||
return timer;
|
||||
}
|
||||
|
||||
void usb_osal_timer_delete(struct usb_osal_timer *timer)
|
||||
{
|
||||
OS_ERR err;
|
||||
CPU_SR_ALLOC();
|
||||
|
||||
CPU_CRITICAL_ENTER();
|
||||
OSTmrStop((OS_TMR *)timer->timer, OS_OPT_TMR_NONE, NULL, &err);
|
||||
OSTmrDel((OS_TMR *)timer->timer, &err);
|
||||
usb_osal_free(timer->timer);
|
||||
usb_osal_free(timer);
|
||||
CPU_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void usb_osal_timer_start(struct usb_osal_timer *timer)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
OSTmrStart((OS_TMR *)timer->timer, &err);
|
||||
}
|
||||
|
||||
void usb_osal_timer_stop(struct usb_osal_timer *timer)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
OSTmrStop((OS_TMR *)timer->timer, OS_OPT_TMR_NONE, NULL, &err);
|
||||
}
|
||||
|
||||
size_t usb_osal_enter_critical_section(void)
|
||||
{
|
||||
return CPU_SR_Save();
|
||||
}
|
||||
|
||||
void usb_osal_leave_critical_section(size_t flag)
|
||||
{
|
||||
CPU_SR_Restore(flag);
|
||||
}
|
||||
|
||||
void usb_osal_msleep(uint32_t delay)
|
||||
{
|
||||
OS_ERR err;
|
||||
|
||||
OSTimeDlyHMSM(0, 0, 0, delay, OS_OPT_TIME_HMSM_NON_STRICT, &err);
|
||||
}
|
||||
|
||||
void *usb_osal_malloc(size_t size)
|
||||
{
|
||||
void *buf = malloc(size);
|
||||
if (!buf) {
|
||||
USB_LOG_ERR("usb_osal_malloc failed\r\n");
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
void usb_osal_free(void *ptr)
|
||||
{
|
||||
free(ptr);
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2022, sakumisu
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
#include "usb_osal.h"
|
||||
#include "usb_errno.h"
|
||||
#include <aos/kernel.h>
|
||||
#include <csi_core.h>
|
||||
|
||||
usb_osal_thread_t usb_osal_thread_create(const char *name, uint32_t stack_size, uint32_t prio, usb_thread_entry_t entry, void *args)
|
||||
{
|
||||
aos_task_t task_handle = NULL;
|
||||
|
||||
aos_task_new_ext(&task_handle, name, entry, args, stack_size, prio + AOS_DEFAULT_APP_PRI - 4);
|
||||
|
||||
return task_handle;
|
||||
}
|
||||
|
||||
void usb_osal_thread_delete(usb_osal_thread_t thread)
|
||||
{
|
||||
aos_task_exit(0);
|
||||
}
|
||||
|
||||
usb_osal_sem_t usb_osal_sem_create(uint32_t initial_count)
|
||||
{
|
||||
aos_sem_t sem = NULL;
|
||||
|
||||
aos_sem_new(&sem, initial_count);
|
||||
|
||||
return sem;
|
||||
}
|
||||
|
||||
void usb_osal_sem_delete(usb_osal_sem_t sem)
|
||||
{
|
||||
aos_sem_free((aos_sem_t *)&sem);
|
||||
}
|
||||
|
||||
int usb_osal_sem_take(usb_osal_sem_t sem, uint32_t timeout)
|
||||
{
|
||||
if (timeout == USB_OSAL_WAITING_FOREVER) {
|
||||
return aos_sem_wait((aos_sem_t *)&sem, AOS_WAIT_FOREVER);
|
||||
} else {
|
||||
return aos_sem_wait((aos_sem_t *)&sem, timeout);
|
||||
}
|
||||
}
|
||||
|
||||
int usb_osal_sem_give(usb_osal_sem_t sem)
|
||||
{
|
||||
aos_sem_signal((aos_sem_t *)&sem);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void usb_osal_sem_reset(usb_osal_sem_t sem)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
usb_osal_mutex_t usb_osal_mutex_create(void)
|
||||
{
|
||||
aos_mutex_t mutex = NULL;
|
||||
|
||||
aos_mutex_new(&mutex);
|
||||
|
||||
return (usb_osal_mutex_t)mutex;
|
||||
}
|
||||
|
||||
void usb_osal_mutex_delete(usb_osal_mutex_t mutex)
|
||||
{
|
||||
aos_mutex_free(((aos_mutex_t *)&mutex));
|
||||
}
|
||||
|
||||
int usb_osal_mutex_take(usb_osal_mutex_t mutex)
|
||||
{
|
||||
return aos_mutex_lock(((aos_mutex_t *)&mutex), AOS_WAIT_FOREVER);
|
||||
}
|
||||
|
||||
int usb_osal_mutex_give(usb_osal_mutex_t mutex)
|
||||
{
|
||||
return aos_mutex_unlock(((aos_mutex_t *)&mutex));
|
||||
}
|
||||
|
||||
usb_osal_mq_t usb_osal_mq_create(uint32_t max_msgs)
|
||||
{
|
||||
aos_queue_t queue = NULL;
|
||||
|
||||
aos_queue_create(&queue, sizeof(uintptr_t), max_msgs, 0);
|
||||
|
||||
return (usb_osal_mq_t)queue;
|
||||
}
|
||||
|
||||
void usb_osal_mq_delete(usb_osal_mq_t mq)
|
||||
{
|
||||
aos_queue_free((aos_queue_t)mq);
|
||||
}
|
||||
|
||||
int usb_osal_mq_send(usb_osal_mq_t mq, uintptr_t addr)
|
||||
{
|
||||
return aos_queue_send((aos_queue_t *)&mq, &addr, sizeof(uintptr_t));
|
||||
}
|
||||
|
||||
int usb_osal_mq_recv(usb_osal_mq_t mq, uintptr_t *addr, uint32_t timeout)
|
||||
{
|
||||
size_t recv_size;
|
||||
if (timeout == USB_OSAL_WAITING_FOREVER) {
|
||||
return aos_queue_recv((aos_queue_t *)&mq, AOS_WAIT_FOREVER, addr, &recv_size);
|
||||
} else {
|
||||
return aos_queue_recv((aos_queue_t *)&mq, timeout, addr, &recv_size);
|
||||
}
|
||||
}
|
||||
|
||||
size_t usb_osal_enter_critical_section(void)
|
||||
{
|
||||
return csi_irq_save();
|
||||
}
|
||||
|
||||
void usb_osal_leave_critical_section(size_t flag)
|
||||
{
|
||||
csi_irq_restore(flag);
|
||||
}
|
||||
|
||||
void usb_osal_msleep(uint32_t delay)
|
||||
{
|
||||
aos_msleep(delay);
|
||||
}
|
||||
|
||||
void *usb_osal_malloc(size_t size)
|
||||
{
|
||||
return aos_malloc(size);
|
||||
}
|
||||
|
||||
void usb_osal_free(void *ptr)
|
||||
{
|
||||
aos_free(ptr);
|
||||
}
|
||||
Reference in New Issue
Block a user