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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/*
* Copyright (c) 2022, sakumisu
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "usb_osal.h"
#include "usb_errno.h"
#include <rtthread.h>
#include <rthw.h>
#ifndef RT_USING_TIMER_SOFT
#error must enable RT_USING_TIMER_SOFT to support timer callback in thread
#endif
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)
{
rt_thread_t htask;
htask = rt_thread_create(name, entry, args, stack_size, prio, 10);
rt_thread_startup(htask);
return (usb_osal_thread_t)htask;
}
void usb_osal_thread_delete(usb_osal_thread_t thread)
{
if (thread == NULL) {
return;
}
rt_thread_delete(thread);
}
usb_osal_sem_t usb_osal_sem_create(uint32_t initial_count)
{
return (usb_osal_sem_t)rt_sem_create("usbh_sem", initial_count, RT_IPC_FLAG_FIFO);
}
void usb_osal_sem_delete(usb_osal_sem_t sem)
{
rt_sem_delete((rt_sem_t)sem);
}
int usb_osal_sem_take(usb_osal_sem_t sem, uint32_t timeout)
{
int ret = 0;
rt_err_t result = RT_EOK;
if (timeout == USB_OSAL_WAITING_FOREVER) {
result = rt_sem_take((rt_sem_t)sem, RT_WAITING_FOREVER);
} else {
result = rt_sem_take((rt_sem_t)sem, rt_tick_from_millisecond(timeout));
}
if (result == -RT_ETIMEOUT) {
ret = -USB_ERR_TIMEOUT;
} else if (result == -RT_ERROR) {
ret = -USB_ERR_INVAL;
} else {
ret = 0;
}
return (int)ret;
}
int usb_osal_sem_give(usb_osal_sem_t sem)
{
return (int)rt_sem_release((rt_sem_t)sem);
}
void usb_osal_sem_reset(usb_osal_sem_t sem)
{
rt_sem_control((rt_sem_t)sem, RT_IPC_CMD_RESET, (void *)0);
}
usb_osal_mutex_t usb_osal_mutex_create(void)
{
return (usb_osal_mutex_t)rt_mutex_create("usbh_mutex", RT_IPC_FLAG_FIFO);
}
void usb_osal_mutex_delete(usb_osal_mutex_t mutex)
{
rt_mutex_delete((rt_mutex_t)mutex);
}
int usb_osal_mutex_take(usb_osal_mutex_t mutex)
{
return (int)rt_mutex_take((rt_mutex_t)mutex, RT_WAITING_FOREVER);
}
int usb_osal_mutex_give(usb_osal_mutex_t mutex)
{
return (int)rt_mutex_release((rt_mutex_t)mutex);
}
usb_osal_mq_t usb_osal_mq_create(uint32_t max_msgs)
{
return (usb_osal_mq_t)rt_mq_create("usbh_mq", sizeof(uintptr_t), max_msgs, RT_IPC_FLAG_FIFO);
}
void usb_osal_mq_delete(usb_osal_mq_t mq)
{
rt_mq_delete((rt_mq_t)mq);
}
int usb_osal_mq_send(usb_osal_mq_t mq, uintptr_t addr)
{
return rt_mq_send((rt_mq_t)mq, &addr, sizeof(uintptr_t));
}
int usb_osal_mq_recv(usb_osal_mq_t mq, uintptr_t *addr, uint32_t timeout)
{
int ret = 0;
rt_err_t result = RT_EOK;
if (timeout == USB_OSAL_WAITING_FOREVER) {
result = rt_mq_recv((rt_mq_t)mq, addr, sizeof(uintptr_t), RT_WAITING_FOREVER);
} else {
result = rt_mq_recv((rt_mq_t)mq, addr, sizeof(uintptr_t), rt_tick_from_millisecond(timeout));
}
if (result == -RT_ETIMEOUT) {
ret = -USB_ERR_TIMEOUT;
} else if (result == -RT_ERROR) {
ret = -USB_ERR_INVAL;
} else {
ret = 0;
}
return (int)ret;
}
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;
timer = rt_malloc(sizeof(struct usb_osal_timer));
memset(timer, 0, sizeof(struct usb_osal_timer));
timer->timer = (void *)rt_timer_create("usb_tim", handler, argument, timeout_ms, is_period ? (RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER) : (RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER));
if (timer->timer == NULL) {
return NULL;
}
return timer;
}
void usb_osal_timer_delete(struct usb_osal_timer *timer)
{
rt_timer_stop(timer->timer);
rt_timer_delete(timer->timer);
rt_free(timer);
}
void usb_osal_timer_start(struct usb_osal_timer *timer)
{
rt_timer_start(timer->timer);
}
void usb_osal_timer_stop(struct usb_osal_timer *timer)
{
rt_timer_stop(timer->timer);
}
size_t usb_osal_enter_critical_section(void)
{
return rt_hw_interrupt_disable();
}
void usb_osal_leave_critical_section(size_t flag)
{
rt_hw_interrupt_enable(flag);
}
void usb_osal_msleep(uint32_t delay)
{
rt_thread_mdelay(delay);
}
|
