1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/*
* Copyright (c) 2022, sakumisu
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "usb_osal.h"
#include "usb_errno.h"
#include <FreeRTOS.h>
#include "semphr.h"
#include "timers.h"
#include "event_groups.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)
{
TaskHandle_t htask = NULL;
stack_size /= sizeof(StackType_t);
xTaskCreate(entry, name, stack_size, args, configMAX_PRIORITIES - 1 - prio, &htask);
return (usb_osal_thread_t)htask;
}
void usb_osal_thread_delete(usb_osal_thread_t thread)
{
vTaskDelete(thread);
}
usb_osal_sem_t usb_osal_sem_create(uint32_t initial_count)
{
return (usb_osal_sem_t)xSemaphoreCreateCounting(1, initial_count);
}
void usb_osal_sem_delete(usb_osal_sem_t sem)
{
vSemaphoreDelete((SemaphoreHandle_t)sem);
}
int usb_osal_sem_take(usb_osal_sem_t sem, uint32_t timeout)
{
if (timeout == USB_OSAL_WAITING_FOREVER) {
return (xSemaphoreTake((SemaphoreHandle_t)sem, portMAX_DELAY) == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
} else {
return (xSemaphoreTake((SemaphoreHandle_t)sem, pdMS_TO_TICKS(timeout)) == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
}
}
int usb_osal_sem_give(usb_osal_sem_t sem)
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
int ret;
if (xPortIsInsideInterrupt()) {
ret = xSemaphoreGiveFromISR((SemaphoreHandle_t)sem, &xHigherPriorityTaskWoken);
if (ret == pdPASS) {
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
} else {
ret = xSemaphoreGive((SemaphoreHandle_t)sem);
}
return (ret == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
}
void usb_osal_sem_reset(usb_osal_sem_t sem)
{
xQueueReset((QueueHandle_t)sem);
}
usb_osal_mutex_t usb_osal_mutex_create(void)
{
return (usb_osal_mutex_t)xSemaphoreCreateMutex();
}
void usb_osal_mutex_delete(usb_osal_mutex_t mutex)
{
vSemaphoreDelete((SemaphoreHandle_t)mutex);
}
int usb_osal_mutex_take(usb_osal_mutex_t mutex)
{
return (xSemaphoreTake((SemaphoreHandle_t)mutex, portMAX_DELAY) == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
}
int usb_osal_mutex_give(usb_osal_mutex_t mutex)
{
return (xSemaphoreGive((SemaphoreHandle_t)mutex) == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
}
usb_osal_mq_t usb_osal_mq_create(uint32_t max_msgs)
{
return (usb_osal_mq_t)xQueueCreate(max_msgs, sizeof(uintptr_t));
}
void usb_osal_mq_delete(usb_osal_mq_t mq)
{
vQueueDelete((QueueHandle_t)mq);
}
int usb_osal_mq_send(usb_osal_mq_t mq, uintptr_t addr)
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
int ret;
ret = xQueueSendFromISR((usb_osal_mq_t)mq, &addr, &xHigherPriorityTaskWoken);
if (ret == pdPASS) {
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
return (ret == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
}
int usb_osal_mq_recv(usb_osal_mq_t mq, uintptr_t *addr, uint32_t timeout)
{
if (timeout == USB_OSAL_WAITING_FOREVER) {
return (xQueueReceive((usb_osal_mq_t)mq, addr, portMAX_DELAY) == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
} else {
return (xQueueReceive((usb_osal_mq_t)mq, addr, pdMS_TO_TICKS(timeout)) == pdPASS) ? 0 : -USB_ERR_TIMEOUT;
}
}
size_t usb_osal_enter_critical_section(void)
{
taskDISABLE_INTERRUPTS();
return 1;
}
void usb_osal_leave_critical_section(size_t flag)
{
taskENABLE_INTERRUPTS();
}
void usb_osal_msleep(uint32_t delay)
{
vTaskDelay(pdMS_TO_TICKS(delay));
}
|
