1 /***************************************************************************
2  * Copyright (c) 2024 Microsoft Corporation
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the MIT License which is available at
6  * https://opensource.org/licenses/MIT.
7  *
8  * SPDX-License-Identifier: MIT
9  **************************************************************************/
10 
11 
12 /**************************************************************************/
13 /**************************************************************************/
14 /**                                                                       */
15 /** USBX Component                                                        */
16 /**                                                                       */
17 /**   HID Class                                                           */
18 /**                                                                       */
19 /**************************************************************************/
20 /**************************************************************************/
21 
22 
23 /**************************************************************************/
24 /*                                                                        */
25 /*  COMPONENT DEFINITION                                   RELEASE        */
26 /*                                                                        */
27 /*    ux_device_class_hid.h                               PORTABLE C      */
28 /*                                                           6.3.0        */
29 /*  AUTHOR                                                                */
30 /*                                                                        */
31 /*    Chaoqiong Xiao, Microsoft Corporation                               */
32 /*                                                                        */
33 /*  DESCRIPTION                                                           */
34 /*                                                                        */
35 /*    This file contains all the header and extern functions used by the  */
36 /*    USBX HID class.                                                     */
37 /*                                                                        */
38 /*  RELEASE HISTORY                                                       */
39 /*                                                                        */
40 /*    DATE              NAME                      DESCRIPTION             */
41 /*                                                                        */
42 /*  05-19-2020     Chaoqiong Xiao           Initial Version 6.0           */
43 /*  09-30-2020     Chaoqiong Xiao           Modified comment(s),          */
44 /*                                            used UX prefix to refer to  */
45 /*                                            TX symbols instead of using */
46 /*                                            them directly,              */
47 /*                                            resulting in version 6.1    */
48 /*  12-31-2020     Chaoqiong Xiao           Modified comment(s),          */
49 /*                                            added Get/Set Protocol      */
50 /*                                            request support,            */
51 /*                                            resulting in version 6.1.3  */
52 /*  08-02-2021     Chaoqiong Xiao           Modified comment(s),          */
53 /*                                            added extern "C" keyword    */
54 /*                                            for compatibility with C++, */
55 /*                                            resulting in version 6.1.8  */
56 /*  01-31-2022     Chaoqiong Xiao           Modified comment(s),          */
57 /*                                            added standalone support,   */
58 /*                                            added interrupt OUT support,*/
59 /*                                            resulting in version 6.1.10 */
60 /*  04-25-2022     Chaoqiong Xiao           Modified comment(s),          */
61 /*                                            added receiver callback,    */
62 /*                                            resulting in version 6.1.11 */
63 /*  07-29-2022     Chaoqiong Xiao           Modified comment(s),          */
64 /*                                            added standalone int out,   */
65 /*                                            resulting in version 6.1.12 */
66 /*  10-31-2023     Chaoqiong Xiao           Modified comment(s),          */
67 /*                                            added zero copy support,    */
68 /*                                            added a new mode to manage  */
69 /*                                            endpoint buffer in classes, */
70 /*                                            moved build option check,   */
71 /*                                            resulting in version 6.3.0  */
72 /*                                                                        */
73 /**************************************************************************/
74 
75 #ifndef UX_DEVICE_CLASS_HID_H
76 #define UX_DEVICE_CLASS_HID_H
77 
78 /* Determine if a C++ compiler is being used.  If so, ensure that standard
79    C is used to process the API information.  */
80 
81 #ifdef   __cplusplus
82 
83 /* Yes, C++ compiler is present.  Use standard C.  */
84 extern   "C" {
85 
86 #endif
87 
88 /* Device HID Compile Options.  */
89 
90 /* If defined, interrupt OUT transfer is supported.  */
91 /* #define UX_DEVICE_CLASS_HID_INTERRUPT_OUT_SUPPORT  */
92 
93 
94 /* Internal option: enable the basic USBX error checking. This define is typically used
95    while debugging application.  */
96 #if defined(UX_ENABLE_ERROR_CHECKING) && !defined(UX_DEVICE_CLASS_HID_ENABLE_ERROR_CHECKING)
97 #define UX_DEVICE_CLASS_HID_ENABLE_ERROR_CHECKING
98 #endif
99 
100 
101 /* Use UX general thread stack size for receiver thread.  */
102 #define UX_DEVICE_CLASS_HID_RECEIVER_THREAD_STACK_SIZE              UX_THREAD_STACK_SIZE
103 
104 /* Use UX general thread stack size for HID class thread.  */
105 #define UX_DEVICE_CLASS_HID_THREAD_STACK_SIZE                       UX_THREAD_STACK_SIZE
106 
107 /* Interrupt out endpoint buffer size, must be larger than endpoint, and aligned in 4-bytes.  */
108 #define UX_DEVICE_CLASS_HID_INTERRUPTIN_BUFFER_SIZE                 UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH
109 
110 /* Interrupt in endpoint buffer size, must be larger than endpoint, and aligned in 4-bytes.  */
111 #ifdef UX_DEVICE_CLASS_HID_INTERRUPT_OUT_SUPPORT
112 #define UX_DEVICE_CLASS_HID_INTERRUPTOUT_BUFFER_SIZE                8
113 #else
114 #define UX_DEVICE_CLASS_HID_INTERRUPTOUT_BUFFER_SIZE                0
115 #endif
116 
117 /* Option: defined, it enables zero copy support (works if HID owns endpoint buffer).  */
118 /* #define UX_DEVICE_CLASS_HID_ZERO_COPY  */
119 
120 /* Option: defined, it enables initialize parameters to set event queue size and event max length.
121     If disabled, the default value is UX_DEVICE_CLASS_HID_MAX_EVENTS_QUEUE for queue size
122      and UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH for event max length.
123     If enabled, the parameter _event_max_number (2~UX_DEVICE_CLASS_HID_MAX_EVENTS_QUEUE) sets
124      the queue size and _event_max_length (max UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH) sets
125      event max length. If parameters are not valid, maximum values are used.
126     It's enabled automatically if HID owns endpoint buffer and zero copy is enabled.
127  */
128 #ifndef UX_DEVICE_CLASS_HID_FLEXIBLE_EVENTS_QUEUE
129 #if (UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1) && defined(UX_DEVICE_CLASS_HID_ZERO_COPY)
130 #define UX_DEVICE_CLASS_HID_FLEXIBLE_EVENTS_QUEUE
131 #endif
132 #endif
133 
134 /* Internal: check if class own endpoint buffer  */
135 #if (UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1)
136 #define UX_DEVICE_CLASS_HID_OWN_ENDPOINT_BUFFER
137 #endif
138 
139 
140 /* Define HID Class constants.  */
141 
142 #define UX_DEVICE_CLASS_HID_CLASS                                   0x03
143 #define UX_DEVICE_CLASS_HID_SUBCLASS                                0X00
144 #define UX_DEVICE_CLASS_HID_PROTOCOL                                0X00
145 
146 /* Define HID Class commands.  */
147 
148 #define UX_DEVICE_CLASS_HID_COMMAND_GET_REPORT                      0x01
149 #define UX_DEVICE_CLASS_HID_COMMAND_GET_IDLE                        0x02
150 #define UX_DEVICE_CLASS_HID_COMMAND_GET_PROTOCOL                    0x03
151 #define UX_DEVICE_CLASS_HID_COMMAND_SET_REPORT                      0x09
152 #define UX_DEVICE_CLASS_HID_COMMAND_SET_IDLE                        0x0A
153 #define UX_DEVICE_CLASS_HID_COMMAND_SET_PROTOCOL                    0x0B
154 
155 /* Define HID Class Descriptor types.  */
156 
157 #define UX_DEVICE_CLASS_HID_DESCRIPTOR_HID                          0x21
158 #define UX_DEVICE_CLASS_HID_DESCRIPTOR_REPORT                       0x22
159 #define UX_DEVICE_CLASS_HID_DESCRIPTOR_PHYSICAL                     0x23
160 
161 /* Define HID Report Types.  */
162 
163 #define UX_DEVICE_CLASS_HID_REPORT_TYPE_INPUT                       0x1
164 #define UX_DEVICE_CLASS_HID_REPORT_TYPE_OUTPUT                      0x2
165 #define UX_DEVICE_CLASS_HID_REPORT_TYPE_FEATURE                     0x3
166 
167 /* Define HID Protocols.  */
168 
169 #define UX_DEVICE_CLASS_HID_PROTOCOL_BOOT                           0
170 #define UX_DEVICE_CLASS_HID_PROTOCOL_REPORT                         1
171 
172 /* Define HID standalone read/receiver states.  */
173 
174 #define UX_DEVICE_CLASS_HID_READ_START                              (UX_STATE_STEP + 1)
175 #define UX_DEVICE_CLASS_HID_READ_WAIT                               (UX_STATE_STEP + 2)
176 
177 #define UX_DEVICE_CLASS_HID_RECEIVER_START                          (UX_STATE_STEP + 3)
178 #define UX_DEVICE_CLASS_HID_RECEIVER_WAIT                           (UX_STATE_STEP + 4)
179 #define UX_DEVICE_CLASS_HID_RECEIVER_ERROR                          (UX_STATE_STEP + 5)
180 
181 
182 /* Define HID event info structure.  */
183 
184 #ifndef UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH
185 #define UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH                     32
186 #endif
187 
188 /* Ensure the event buffer can fit inside the control endpoint's data buffer.  */
189 #if UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH > UX_SLAVE_REQUEST_CONTROL_MAX_LENGTH
190 /* #error "Error: the event buffer cannot fit inside the control endpoint's data buffer. Reduce UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH such that it is less than or equal to UX_SLAVE_REQUEST_CONTROL_MAX_LENGTH." */
191 /* Build option checked runtime by UX_ASSERT  */
192 #endif
193 
194 /* Ensure the event buffer can fit inside the interrupt endpoint's data buffer.  */
195 #if UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH > UX_SLAVE_REQUEST_DATA_MAX_LENGTH
196 /* #error "Error: the event buffer cannot fit inside the interrupt endpoint's data buffer. Reduce UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH such that it is less than or equal to UX_SLAVE_REQUEST_DATA_MAX_LENGTH." */
197 /* Build option checked runtime by UX_ASSERT  */
198 #endif
199 
200 #ifndef UX_DEVICE_CLASS_HID_MAX_EVENTS_QUEUE
201 #define UX_DEVICE_CLASS_HID_MAX_EVENTS_QUEUE                        16
202 #endif
203 
204 #define UX_DEVICE_CLASS_HID_NEW_EVENT                               1u
205 #define UX_DEVICE_CLASS_HID_NEW_IDLE_RATE                           2u
206 #define UX_DEVICE_CLASS_HID_EVENTS_MASK                             3u /* Mask _NEW_EVENT and _NEW_IDLE_RATE  */
207 
208 #define UX_DEVICE_CLASS_HID_RECEIVER_RESTART                        4u
209 
210 #define UX_DEVICE_CLASS_HID_EVENTS_ALL_MASK                         7u /* Mask all event flags.  */
211 
212 typedef struct UX_SLAVE_CLASS_HID_EVENT_STRUCT
213 {
214     ULONG                   ux_device_class_hid_event_report_id;
215     ULONG                   ux_device_class_hid_event_report_type;
216     ULONG                   ux_device_class_hid_event_length;
217     UCHAR                   ux_device_class_hid_event_buffer[UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH];
218 
219 } UX_SLAVE_CLASS_HID_EVENT;
220 
221 /* Internal (transmit) event header.   */
222 typedef struct UX_DEVICE_CLASS_HID_EVENT_STRUCT
223 {
224     ULONG                   ux_device_class_hid_event_report_id;
225     ULONG                   ux_device_class_hid_event_report_type;
226     ULONG                   ux_device_class_hid_event_length;
227     UCHAR                   *ux_device_class_hid_event_buffer;
228 } UX_DEVICE_CLASS_HID_EVENT;
229 
230 #if defined(UX_DEVICE_CLASS_HID_FLEXIBLE_EVENTS_QUEUE)
231 #define UX_DEVICE_CLASS_HID_EVENT_BUFFER(e)     ((e)->ux_device_class_hid_event_buffer)
232 #else
233 #define UX_DEVICE_CLASS_HID_EVENT_BUFFER(e)     (((UX_SLAVE_CLASS_HID_EVENT*)e)->ux_device_class_hid_event_buffer)
234 #endif
235 
236 
237 /* Define HID structure.  */
238 
239 typedef struct UX_SLAVE_CLASS_HID_STRUCT
240 {
241 
242     UX_SLAVE_INTERFACE              *ux_slave_class_hid_interface;
243     UX_SLAVE_ENDPOINT               *ux_device_class_hid_interrupt_endpoint;
244 
245 #if defined(UX_DEVICE_CLASS_HID_OWN_ENDPOINT_BUFFER)
246     UCHAR                           *ux_device_class_hid_endpoint_buffer;
247 #endif
248 
249     UINT                            ux_device_class_hid_state;
250     UINT                            (*ux_device_class_hid_callback)(struct UX_SLAVE_CLASS_HID_STRUCT *hid, UX_SLAVE_CLASS_HID_EVENT *);
251     UINT                            (*ux_device_class_hid_get_callback)(struct UX_SLAVE_CLASS_HID_STRUCT *hid, UX_SLAVE_CLASS_HID_EVENT *);
252     VOID                            (*ux_slave_class_hid_instance_activate)(VOID *);
253     VOID                            (*ux_slave_class_hid_instance_deactivate)(VOID *);
254     UCHAR                           *ux_device_class_hid_report_address;
255     ULONG                           ux_device_class_hid_report_id;
256     ULONG                           ux_device_class_hid_report_length;
257 #if !defined(UX_DEVICE_STANDALONE)
258     UX_EVENT_FLAGS_GROUP            ux_device_class_hid_event_flags_group;
259 #else
260     UINT                            ux_device_class_hid_event_state;
261     ULONG                           ux_device_class_hid_event_wait_start;
262     UX_DEVICE_CLASS_HID_EVENT       ux_device_class_hid_event;
263 #endif
264     ULONG                           ux_device_class_hid_event_idle_rate;
265     ULONG                           ux_device_class_hid_event_wait_timeout;
266     ULONG                           ux_device_class_hid_protocol;
267     UX_DEVICE_CLASS_HID_EVENT       *ux_device_class_hid_event_array;
268     UX_DEVICE_CLASS_HID_EVENT       *ux_device_class_hid_event_array_head;
269     UX_DEVICE_CLASS_HID_EVENT       *ux_device_class_hid_event_array_tail;
270     UX_DEVICE_CLASS_HID_EVENT       *ux_device_class_hid_event_array_end;
271 #if defined(UX_DEVICE_CLASS_HID_FLEXIBLE_EVENTS_QUEUE)
272     ULONG                           ux_device_class_hid_event_max_length;
273 #endif
274 
275 #if defined(UX_DEVICE_CLASS_HID_INTERRUPT_OUT_SUPPORT)
276     UX_SLAVE_ENDPOINT               *ux_device_class_hid_read_endpoint;
277     struct UX_DEVICE_CLASS_HID_RECEIVER_STRUCT
278                                     *ux_device_class_hid_receiver;
279 #if !defined(UX_DEVICE_STANDALONE)
280     UX_MUTEX                        ux_device_class_hid_read_mutex;
281 #else
282 
283     UCHAR                           *ux_device_class_hid_read_buffer;
284     ULONG                           ux_device_class_hid_read_requested_length;
285     ULONG                           ux_device_class_hid_read_actual_length;
286     ULONG                           ux_device_class_hid_read_transfer_length;
287 
288     UINT                            ux_device_class_hid_read_state;
289     UINT                            ux_device_class_hid_read_status;
290 #endif
291 #endif
292 
293 } UX_SLAVE_CLASS_HID;
294 
295 /* Define HID endpoint buffer settings (when HID owns buffer).  */
296 #define UX_DEVICE_CLASS_HID_ENDPOINT_BUFFER_SIZE_CALC_OVERFLOW                  \
297     (UX_OVERFLOW_CHECK_ADD_ULONG(UX_DEVICE_CLASS_HID_INTERRUPTIN_BUFFER_SIZE,   \
298                                  UX_DEVICE_CLASS_HID_INTERRUPTOUT_BUFFER_SIZE))
299 #define UX_DEVICE_CLASS_HID_ENDPOINT_BUFFER_SIZE        (UX_DEVICE_CLASS_HID_INTERRUPTOUT_BUFFER_SIZE + UX_DEVICE_CLASS_HID_INTERRUPTIN_BUFFER_SIZE)
300 #define UX_DEVICE_CLASS_HID_INTERRUPTOUT_BUFFER(hid)    ((hid)->ux_device_class_hid_endpoint_buffer)
301 #define UX_DEVICE_CLASS_HID_INTERRUPTIN_BUFFER(hid)     (UX_DEVICE_CLASS_HID_INTERRUPTOUT_BUFFER(hid) + UX_DEVICE_CLASS_HID_INTERRUPTOUT_BUFFER_SIZE)
302 
303 #ifdef UX_DEVICE_CLASS_HID_FLEXIBLE_EVENTS_QUEUE
304 #define UX_DEVICE_CLASS_HID_EVENT_MAX_LENGTH(hid)       ((hid)->ux_device_class_hid_event_max_length)
305 #if (UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1) && defined(UX_DEVICE_CLASS_HID_ZERO_COPY)
306 #define UX_DEVICE_CLASS_HID_EVENT_QUEUE_ITEM_SIZE(hid)  sizeof(UX_DEVICE_CLASS_HID_EVENT)
307 #else
308 #define UX_DEVICE_CLASS_HID_EVENT_QUEUE_ITEM_SIZE(hid)  (sizeof(UX_DEVICE_CLASS_HID_EVENT) - 4 + UX_DEVICE_CLASS_HID_EVENT_MAX_LENGTH(hid))
309 #endif
310 #else
311 #define UX_DEVICE_CLASS_HID_EVENT_MAX_LENGTH(hid)       UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH
312 #define UX_DEVICE_CLASS_HID_EVENT_QUEUE_ITEM_SIZE(hid)  sizeof(UX_SLAVE_CLASS_HID_EVENT)
313 #endif
314 
315 
316 /* HID interrupt OUT support extensions.  */
317 
318 typedef struct UX_DEVICE_CLASS_HID_RECEIVED_EVENT_STRUCT
319 {
320     ULONG                   ux_device_class_hid_received_event_length;
321     UCHAR                   *ux_device_class_hid_received_event_data;
322 } UX_DEVICE_CLASS_HID_RECEIVED_EVENT;
323 
324 typedef struct UX_DEVICE_CLASS_HID_RECEIVER_STRUCT
325 {
326 
327     VOID                    (*ux_device_class_hid_receiver_uninitialize)(struct UX_DEVICE_CLASS_HID_RECEIVER_STRUCT *receiver);
328     VOID                    (*ux_device_class_hid_receiver_event_callback)(struct UX_SLAVE_CLASS_HID_STRUCT *hid);
329 
330     ULONG                   ux_device_class_hid_receiver_event_buffer_size;
331     UX_DEVICE_CLASS_HID_RECEIVED_EVENT
332                             *ux_device_class_hid_receiver_events;
333     UX_DEVICE_CLASS_HID_RECEIVED_EVENT
334                             *ux_device_class_hid_receiver_events_end;
335     UX_DEVICE_CLASS_HID_RECEIVED_EVENT
336                             *ux_device_class_hid_receiver_event_read_pos;
337     UX_DEVICE_CLASS_HID_RECEIVED_EVENT
338                             *ux_device_class_hid_receiver_event_save_pos;
339 
340 #if !defined(UX_DEVICE_STANDALONE)
341     UX_THREAD               ux_device_class_hid_receiver_thread;
342 #else
343     UINT                    (*ux_device_class_hid_receiver_tasks_run)(struct UX_SLAVE_CLASS_HID_STRUCT *hid);
344 #endif
345 } UX_DEVICE_CLASS_HID_RECEIVER;
346 
347 #if (UX_DEVICE_ENDPOINT_BUFFER_OWNER == 1) && defined(UX_DEVICE_CLASS_HID_ZERO_COPY)
348 #define UX_DEVICE_CLASS_HID_RECEIVED_QUEUE_ITEM_BUFFER(i)   ((i) -> ux_device_class_hid_received_event_data)
349 #define UX_DEVICE_CLASS_HID_RECEIVED_QUEUE_ITEM_SIZE(r)     sizeof(UX_DEVICE_CLASS_HID_RECEIVED_EVENT)
350 #else
351 #define UX_DEVICE_CLASS_HID_RECEIVED_QUEUE_ITEM_BUFFER(i)   ((UCHAR*)&(i) -> ux_device_class_hid_received_event_data)
352 #define UX_DEVICE_CLASS_HID_RECEIVED_QUEUE_ITEM_SIZE(r)     ((r) -> ux_device_class_hid_receiver_event_buffer_size + sizeof(ULONG))
353 #endif
354 
355 
356 /* Define HID initialization command structure.  */
357 
358 typedef struct UX_SLAVE_CLASS_HID_PARAMETER_STRUCT
359 {
360 
361     VOID                    (*ux_slave_class_hid_instance_activate)(VOID *);
362     VOID                    (*ux_slave_class_hid_instance_deactivate)(VOID *);
363     UCHAR                   *ux_device_class_hid_parameter_report_address;
364     ULONG                   ux_device_class_hid_parameter_report_id;
365     ULONG                   ux_device_class_hid_parameter_report_length;
366     UINT                    (*ux_device_class_hid_parameter_callback)(struct UX_SLAVE_CLASS_HID_STRUCT *hid, UX_SLAVE_CLASS_HID_EVENT *);
367     UINT                    (*ux_device_class_hid_parameter_get_callback)(struct UX_SLAVE_CLASS_HID_STRUCT *hid, UX_SLAVE_CLASS_HID_EVENT *);
368 #if defined(UX_DEVICE_CLASS_HID_FLEXIBLE_EVENTS_QUEUE)
369     ULONG                   ux_device_class_hid_parameter_event_max_number;
370     ULONG                   ux_device_class_hid_parameter_event_max_length;
371 #endif
372 #if defined(UX_DEVICE_CLASS_HID_INTERRUPT_OUT_SUPPORT)
373     UINT                    (*ux_device_class_hid_parameter_receiver_initialize)(UX_SLAVE_CLASS_HID *hid, struct UX_SLAVE_CLASS_HID_PARAMETER_STRUCT *parameter, UX_DEVICE_CLASS_HID_RECEIVER **receiver);
374     ULONG                   ux_device_class_hid_parameter_receiver_event_max_number;
375     ULONG                   ux_device_class_hid_parameter_receiver_event_max_length;
376     VOID                    (*ux_device_class_hid_parameter_receiver_event_callback)(struct UX_SLAVE_CLASS_HID_STRUCT *hid);
377 #endif
378 
379 } UX_SLAVE_CLASS_HID_PARAMETER;
380 
381 #ifdef UX_DEVICE_CLASS_HID_FLEXIBLE_EVENTS_QUEUE
382 #define UX_DEVICE_CLASS_HID_PARAM_EVENT_QUEUE_SIZE(p)       ((p)->ux_device_class_hid_parameter_event_max_number)
383 #define UX_DEVICE_CLASS_HID_PARAM_EVENT_MAX_LENGTH(p)       ((p)->ux_device_class_hid_parameter_event_max_length)
384 #else
385 #define UX_DEVICE_CLASS_HID_PARAM_EVENT_QUEUE_SIZE(p)       UX_DEVICE_CLASS_HID_MAX_EVENTS_QUEUE
386 #define UX_DEVICE_CLASS_HID_PARAM_EVENT_MAX_LENGTH(p)       UX_DEVICE_CLASS_HID_EVENT_BUFFER_LENGTH
387 #endif
388 
389 
390 /* Define HID Class function prototypes.  */
391 UINT  _ux_device_class_hid_descriptor_send(UX_SLAVE_CLASS_HID *hid, ULONG descriptor_type,
392                                             ULONG request_index, ULONG host_length);
393 UINT  _ux_device_class_hid_activate(UX_SLAVE_CLASS_COMMAND *command);
394 UINT  _ux_device_class_hid_deactivate(UX_SLAVE_CLASS_COMMAND *command);
395 UINT  _ux_device_class_hid_control_request(UX_SLAVE_CLASS_COMMAND *command);
396 UINT  _ux_device_class_hid_entry(UX_SLAVE_CLASS_COMMAND *command);
397 VOID  _ux_device_class_hid_interrupt_thread(ULONG hid_class);
398 UINT  _ux_device_class_hid_initialize(UX_SLAVE_CLASS_COMMAND *command);
399 UINT  _ux_device_class_hid_uninitialize(UX_SLAVE_CLASS_COMMAND *command);
400 UINT  _ux_device_class_hid_event_set(UX_SLAVE_CLASS_HID *hid,
401                                       UX_SLAVE_CLASS_HID_EVENT *hid_event);
402 UINT  _ux_device_class_hid_event_check(UX_SLAVE_CLASS_HID *hid,
403                                        UX_DEVICE_CLASS_HID_EVENT **hid_event);
404 VOID  _ux_device_class_hid_event_free(UX_SLAVE_CLASS_HID *hid);
405 UINT  _ux_device_class_hid_event_get(UX_SLAVE_CLASS_HID *hid,
406                                       UX_SLAVE_CLASS_HID_EVENT *hid_event);
407 UINT  _ux_device_class_hid_report_set(UX_SLAVE_CLASS_HID *hid, ULONG descriptor_type,
408                                             ULONG request_index, ULONG host_length);
409 UINT  _ux_device_class_hid_report_get(UX_SLAVE_CLASS_HID *hid, ULONG descriptor_type,
410                                             ULONG request_index, ULONG host_length);
411 
412 UINT  _ux_device_class_hid_tasks_run(VOID *class_instance);
413 
414 UINT  _ux_device_class_hid_read(UX_SLAVE_CLASS_HID *hid,
415                                 UCHAR *buffer, ULONG requested_length,
416                                 ULONG *actual_length);
417 
418 VOID  _ux_device_class_hid_receiver_thread(ULONG hid_class);
419 UINT  _ux_device_class_hid_receiver_initialize(UX_SLAVE_CLASS_HID *hid,
420                                     UX_SLAVE_CLASS_HID_PARAMETER *parameter,
421                                     UX_DEVICE_CLASS_HID_RECEIVER **receiver);
422 VOID  _ux_device_class_hid_receiver_uninitialize(UX_DEVICE_CLASS_HID_RECEIVER *receiver);
423 UINT  _ux_device_class_hid_receiver_event_get(UX_SLAVE_CLASS_HID *hid,
424                                 UX_DEVICE_CLASS_HID_RECEIVED_EVENT *event);
425 UINT  _ux_device_class_hid_receiver_event_free(UX_SLAVE_CLASS_HID *hid);
426 
427 UINT  _ux_device_class_hid_read_run(UX_SLAVE_CLASS_HID *hid,
428                                 UCHAR *buffer, ULONG requested_length,
429                                 ULONG *actual_length);
430 UINT  _ux_device_class_hid_receiver_tasks_run(UX_SLAVE_CLASS_HID *hid);
431 
432 
433 UINT  _uxe_device_class_hid_initialize(UX_SLAVE_CLASS_COMMAND *command);
434 UINT  _uxe_device_class_hid_event_set(UX_SLAVE_CLASS_HID *hid,
435                                       UX_SLAVE_CLASS_HID_EVENT *hid_event);
436 UINT  _uxe_device_class_hid_event_get(UX_SLAVE_CLASS_HID *hid,
437                                       UX_SLAVE_CLASS_HID_EVENT *hid_event);
438 UINT  _uxe_device_class_hid_read(UX_SLAVE_CLASS_HID *hid,
439                                 UCHAR *buffer, ULONG requested_length,
440                                 ULONG *actual_length);
441 UINT  _uxe_device_class_hid_read_run(UX_SLAVE_CLASS_HID *hid,
442                                 UCHAR *buffer, ULONG requested_length,
443                                 ULONG *actual_length);
444 UINT  _uxe_device_class_hid_receiver_initialize(UX_SLAVE_CLASS_HID *hid,
445                                     UX_SLAVE_CLASS_HID_PARAMETER *parameter,
446                                     UX_DEVICE_CLASS_HID_RECEIVER **receiver);
447 UINT  _uxe_device_class_hid_receiver_event_get(UX_SLAVE_CLASS_HID *hid,
448                                 UX_DEVICE_CLASS_HID_RECEIVED_EVENT *event);
449 UINT  _uxe_device_class_hid_receiver_event_free(UX_SLAVE_CLASS_HID *hid);
450 
451 
452 /* Define Device HID Class API prototypes.  */
453 
454 #if defined(UX_DEVICE_CLASS_HID_ENABLE_ERROR_CHECKING)
455 
456 #define ux_device_class_hid_entry               _ux_device_class_hid_entry
457 #define ux_device_class_hid_event_set           _uxe_device_class_hid_event_set
458 #define ux_device_class_hid_event_get           _uxe_device_class_hid_event_get
459 #define ux_device_class_hid_report_set          _ux_device_class_hid_report_set
460 #define ux_device_class_hid_report_get          _ux_device_class_hid_report_get
461 
462 #define ux_device_class_hid_protocol_get(hid)   (((hid) == UX_NULL) ? UX_ERROR : (hid) -> ux_device_class_hid_protocol)
463 
464 #define ux_device_class_hid_read                _uxe_device_class_hid_read
465 #define ux_device_class_hid_read_run            _uxe_device_class_hid_read_run
466 
467 #define ux_device_class_hid_receiver_initialize _ux_device_class_hid_receiver_initialize
468 #define ux_device_class_hid_receiver_event_get  _uxe_device_class_hid_receiver_event_get
469 #define ux_device_class_hid_receiver_event_free _uxe_device_class_hid_receiver_event_free
470 
471 #else
472 
473 #define ux_device_class_hid_entry        _ux_device_class_hid_entry
474 #define ux_device_class_hid_event_set    _ux_device_class_hid_event_set
475 #define ux_device_class_hid_event_get    _ux_device_class_hid_event_get
476 #define ux_device_class_hid_report_set   _ux_device_class_hid_report_set
477 #define ux_device_class_hid_report_get   _ux_device_class_hid_report_get
478 
479 #define ux_device_class_hid_protocol_get(hid)   ((hid) -> ux_device_class_hid_protocol)
480 
481 #define ux_device_class_hid_read                _ux_device_class_hid_read
482 #define ux_device_class_hid_read_run            _ux_device_class_hid_read_run
483 
484 #define ux_device_class_hid_receiver_initialize _ux_device_class_hid_receiver_initialize
485 #define ux_device_class_hid_receiver_event_get  _ux_device_class_hid_receiver_event_get
486 #define ux_device_class_hid_receiver_event_free _ux_device_class_hid_receiver_event_free
487 
488 #endif
489 
490 /* Determine if a C++ compiler is being used.  If so, complete the standard
491    C conditional started above.  */
492 #ifdef __cplusplus
493 }
494 #endif
495 
496 #endif
497