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
174
175
176
177
178
179
180
181
|
/***************************************************************************
* Copyright (c) 2024 Microsoft Corporation
* Copyright (c) 2026-present Eclipse ThreadX contributors
*
* This program and the accompanying materials are made available under the
* terms of the MIT License which is available at
* https://opensource.org/licenses/MIT.
*
* SPDX-License-Identifier: MIT
**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** USBX Component */
/** */
/** Device HID Class */
/** */
/**************************************************************************/
/**************************************************************************/
#define UX_SOURCE_CODE
/* Include necessary system files. */
#include "ux_api.h"
#include "ux_device_class_hid.h"
#include "ux_device_stack.h"
#if defined(UX_DEVICE_CLASS_HID_INTERRUPT_OUT_SUPPORT) && !defined(UX_DEVICE_STANDALONE)
/**************************************************************************/
/* */
/* FUNCTION RELEASE */
/* */
/* _ux_device_class_hid_receiver_thread PORTABLE C */
/* 6.3.0 */
/* AUTHOR */
/* */
/* Chaoqiong Xiao, Microsoft Corporation */
/* */
/* DESCRIPTION */
/* */
/* This function is the thread of the hid interrupt OUT endpoint */
/* */
/* INPUT */
/* */
/* hid_instance Address of hid class */
/* container */
/* */
/* OUTPUT */
/* */
/* None */
/* */
/* CALLS */
/* */
/* _ux_utility_event_flags_get Get event flags */
/* _ux_device_stack_transfer_request Request transfer */
/* _ux_utility_memory_copy Copy memory */
/* _ux_utility_thread_suspend Suspend thread */
/* */
/* CALLED BY */
/* */
/* ThreadX */
/* */
/**************************************************************************/
VOID _ux_device_class_hid_receiver_thread(ULONG hid_instance)
{
UX_SLAVE_CLASS_HID *hid;
UX_SLAVE_DEVICE *device;
UX_DEVICE_CLASS_HID_RECEIVER *receiver;
UX_DEVICE_CLASS_HID_RECEIVED_EVENT *pos;
UCHAR *next_pos;
UX_SLAVE_TRANSFER *transfer;
UINT status;
UCHAR *buffer;
ULONG temp;
/* Cast properly the hid instance. */
UX_THREAD_EXTENSION_PTR_GET(hid, UX_SLAVE_CLASS_HID, hid_instance)
/* Get the pointer to the device. */
device = &_ux_system_slave -> ux_system_slave_device;
/* Get receiver instance. */
receiver = hid -> ux_device_class_hid_receiver;
/* This thread runs forever but can be suspended or resumed. */
while(1)
{
/* Check device state. */
if (device -> ux_slave_device_state != UX_DEVICE_CONFIGURED)
{
/* We need to suspend ourselves. We will be resumed by the device enumeration module. */
_ux_utility_thread_suspend(&receiver -> ux_device_class_hid_receiver_thread);
continue;
}
/* Protect read. */
_ux_device_mutex_on(&hid -> ux_device_class_hid_read_mutex);
/* Check if there is buffer available. */
pos = receiver -> ux_device_class_hid_receiver_event_save_pos;
if (pos -> ux_device_class_hid_received_event_length != 0)
{
/* Wait before check again. */
status = _ux_utility_event_flags_get(
&hid -> ux_device_class_hid_event_flags_group,
UX_DEVICE_CLASS_HID_RECEIVER_RESTART,
UX_OR_CLEAR, &temp, 100);
if (status != UX_SUCCESS)
{
/* Keep checking before a good state. */
_ux_device_mutex_off(&hid -> ux_device_class_hid_read_mutex);
continue;
}
}
/* Event buffer available, issue request to get data. */
transfer = &hid -> ux_device_class_hid_read_endpoint -> ux_slave_endpoint_transfer_request;
#if (UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1) && defined(UX_DEVICE_CLASS_HID_ZERO_COPY)
/* Directly use event buffer for transfer. */
buffer = pos -> ux_device_class_hid_received_event_data;
transfer -> ux_slave_transfer_request_data_pointer = buffer;
#endif
/* Issue the transfer request. */
status = _ux_device_stack_transfer_request(transfer,
receiver -> ux_device_class_hid_receiver_event_buffer_size,
receiver -> ux_device_class_hid_receiver_event_buffer_size);
/* Check status and ignore ZLPs. */
if ((status != UX_SUCCESS) ||
(transfer -> ux_slave_transfer_request_actual_length == 0))
{
_ux_device_mutex_off(&hid -> ux_device_class_hid_read_mutex);
continue;
}
#if (UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1) && defined(UX_DEVICE_CLASS_HID_ZERO_COPY)
/* Save received event length. */
temp = transfer -> ux_slave_transfer_request_actual_length;
#else
/* Save received event data and length. */
buffer = (UCHAR *)&pos -> ux_device_class_hid_received_event_data;
temp = transfer -> ux_slave_transfer_request_actual_length;
_ux_utility_memory_copy(buffer,
transfer -> ux_slave_transfer_request_data_pointer,
temp); /* Use case of memcpy is verified. */
#endif
/* Unprotect read. */
_ux_device_mutex_off(&hid -> ux_device_class_hid_read_mutex);
/* Advance the save position. */
next_pos = (UCHAR *)pos + UX_DEVICE_CLASS_HID_RECEIVED_QUEUE_ITEM_SIZE(receiver);
if (next_pos >= (UCHAR *)receiver -> ux_device_class_hid_receiver_events_end)
next_pos = (UCHAR *)receiver -> ux_device_class_hid_receiver_events;
receiver -> ux_device_class_hid_receiver_event_save_pos = (UX_DEVICE_CLASS_HID_RECEIVED_EVENT *)next_pos;
/* Save received data length (it's valid now). */
pos -> ux_device_class_hid_received_event_length = temp;
/* Notify application that a event is received. */
if (receiver -> ux_device_class_hid_receiver_event_callback)
receiver -> ux_device_class_hid_receiver_event_callback(hid);
}
}
#endif /* UX_DEVICE_CLASS_HID_INTERRUPT_OUT_SUPPORT && !UX_DEVICE_STANDALONE */
|
