1 /* This test is designed to test the ux_device_stack_class_unregister. */
2
3 #include <stdio.h>
4 #include "tx_api.h"
5 #include "ux_api.h"
6 #include "ux_system.h"
7 #include "ux_utility.h"
8
9 #include "ux_host_stack.h"
10 #include "ux_device_stack.h"
11
12 #include "ux_device_class_cdc_acm.h"
13 #include "ux_host_class_cdc_acm.h"
14
15 #include "ux_host_class_dpump.h"
16 #include "ux_device_class_dpump.h"
17
18 #include "ux_host_class_hid.h"
19 #include "ux_device_class_hid.h"
20
21 #include "ux_host_class_storage.h"
22 #include "ux_device_class_storage.h"
23
24 #include "ux_test_dcd_sim_slave.h"
25 #include "ux_test_hcd_sim_host.h"
26 #include "ux_test_utility_sim.h"
27
28
29 /* Define USBX test constants. */
30
31 #define UX_TEST_STACK_SIZE 4096
32 #define UX_TEST_BUFFER_SIZE 2048
33 #define UX_TEST_RUN 1
34 #define UX_TEST_MEMORY_SIZE (64*1024)
35
36 /* HID mouse related descriptors */
37
38 static UCHAR hid_mouse_report[] = {
39
40 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
41 0x09, 0x02, // USAGE (Mouse)
42 0xa1, 0x01, // COLLECTION (Application)
43 0x09, 0x01, // USAGE (Pointer)
44 0xa1, 0x00, // COLLECTION (Physical)
45 0x05, 0x09, // USAGE_PAGE (Button)
46 0x19, 0x01, // USAGE_MINIMUM (Button 1)
47 0x29, 0x03, // USAGE_MAXIMUM (Button 3)
48 0x15, 0x00, // LOGICAL_MINIMUM (0)
49 0x25, 0x01, // LOGICAL_MAXIMUM (1)
50 0x95, 0x03, // REPORT_COUNT (3)
51 0x75, 0x01, // REPORT_SIZE (1)
52 0x81, 0x02, // INPUT (Data,Var,Abs)
53 0x95, 0x01, // REPORT_COUNT (1)
54 0x75, 0x05, // REPORT_SIZE (5)
55 0x81, 0x03, // INPUT (Cnst,Var,Abs)
56 0x05, 0x01, // USAGE_PAGE (Generic Desktop)
57 0x09, 0x30, // USAGE (X)
58 0x09, 0x31, // USAGE (Y)
59 0x15, 0x81, // LOGICAL_MINIMUM (-127)
60 0x25, 0x7f, // LOGICAL_MAXIMUM (127)
61 0x75, 0x08, // REPORT_SIZE (8)
62 0x95, 0x02, // REPORT_COUNT (2)
63 0x81, 0x06, // INPUT (Data,Var,Rel)
64 0x09, 0x38, // USAGE (Mouse Wheel)
65 0x15, 0x81, // LOGICAL_MINIMUM (-127)
66 0x25, 0x7f, // LOGICAL_MAXIMUM (127)
67 0x75, 0x08, // REPORT_SIZE (8)
68 0x95, 0x01, // REPORT_COUNT (1)
69 0x81, 0x06, // INPUT (Data,Var,Rel)
70 0xc0, // END_COLLECTION
71 0xc0 // END_COLLECTION
72 };
73 #define HID_MOUSE_REPORT_LENGTH (sizeof(hid_mouse_report)/sizeof(hid_mouse_report[0]))
74
75 #define LSB(x) (x & 0x00ff)
76 #define MSB(x) ((x & 0xff00) >> 8)
77
78 /* Configuration descriptor 9 bytes */
79 #define CFG_DESC(wTotalLength, bNumInterfaces, bConfigurationValue)\
80 /* Configuration 1 descriptor 9 bytes */\
81 0x09, 0x02, LSB(wTotalLength), MSB(wTotalLength),\
82 (bNumInterfaces), (bConfigurationValue), 0x00,\
83 0x20, 0x00,
84 #define CFG_DESC_LEN 9
85
86 /* DPUMP interface descriptors 9+7+7=23 bytes. */
87 #define DPUMP_IFC_DESC_ALL(ifc, bulk_in_epa, bulk_out_epa) \
88 /* Interface descriptor */\
89 0x09, 0x04, (ifc), 0x00, 0x02, 0x99, 0x99, 0x99, 0x00,\
90 /* Endpoint descriptor (Bulk Out) */\
91 0x07, 0x05, (bulk_out_epa), 0x02, 0x40, 0x00, 0x00,\
92 /* Endpoint descriptor (Bulk In) */\
93 0x07, 0x05, (bulk_in_epa), 0x02, 0x40, 0x00, 0x00,
94 #define DPUMP_IFC_DESC_ALL_LEN 23
95
96 /* HID Mouse interface descriptors 9+9=18 bytes */
97 #define HID_MOUSE_IFC0_DESC_ALL(ifc) \
98 /* Interface descriptor */\
99 0x09, 0x04, (ifc), 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,\
100 /* HID descriptor */\
101 0x09, 0x21, 0x10, 0x01, 0x21, 0x01, 0x22, LSB(HID_MOUSE_REPORT_LENGTH),\
102 MSB(HID_MOUSE_REPORT_LENGTH),
103 #define HID_MOUSE_IFC0_DESC_ALL_LEN 18
104
105 /* HID Mouse interface descriptors 9+9+7=25 bytes */
106 #define HID_MOUSE_IFC1_DESC_ALL(ifc, interrupt_epa) \
107 /* Interface descriptor */\
108 0x09, 0x04, (ifc), 0x01, 0x01, 0x03, 0x00, 0x00, 0x00,\
109 /* HID descriptor */\
110 0x09, 0x21, 0x10, 0x01, 0x21, 0x01, 0x22, LSB(HID_MOUSE_REPORT_LENGTH),\
111 MSB(HID_MOUSE_REPORT_LENGTH),\
112 /* Endpoint descriptor (Interrupt) */\
113 0x07, 0x05, (interrupt_epa), 0x03, 0x08, 0x00, 0x08,
114 #define HID_MOUSE_IFC1_DESC_ALL_LEN 25
115
116 /* CDC-ACM interfaces descriptors 8 +9+5+4+5+5+7 +9+7+7=66 bytes */
117 #define CDC_ACM_IFCES_DESC_ALL(ifc, interrupt_epa, bulk_in_epa, bulk_out_epa) \
118 /* Interface association descriptor. 8 bytes. */\
119 0x08, 0x0b, (ifc), 0x02, 0x02, 0x02, 0x00, 0x00,\
120 /* Communication Class Interface Descriptor Requirement. 9 bytes. */\
121 0x09, 0x04, (ifc), 0x00, 0x01, 0x02, 0x02, 0x01, 0x00,\
122 /* Header Functional Descriptor 5 bytes */\
123 0x05, 0x24, 0x00, 0x10, 0x01,\
124 /* ACM Functional Descriptor 4 bytes */\
125 0x04, 0x24, 0x02, 0x0f,\
126 /* Union Functional Descriptor 5 bytes */\
127 0x05, 0x24, 0x06,\
128 (ifc), /* Master interface */\
129 (ifc+1), /* Slave interface */\
130 /* Call Management Functional Descriptor 5 bytes */\
131 0x05, 0x24, 0x01, 0x03,\
132 (ifc+1), /* Data interface */\
133 /* Interrupt endpoint descriptor 7 bytes */\
134 0x07, 0x05, (interrupt_epa), 0x03, 0x08, 0x00, 15,\
135 /* Data Class Interface Descriptor Requirement 9 bytes */\
136 0x09, 0x04, (ifc+1), 0x00, 0x02, 0x0A, 0x00, 0x00, 0x00,\
137 /* Endpoint descriptor 7 bytes */\
138 0x07, 0x05, (bulk_out_epa), 0x02, 0x40, 0x00, 0x00,\
139 /* Endpoint descriptor 7 bytes */\
140 0x07, 0x05, (bulk_in_epa), 0x02, 0x40, 0x00, 0x00,
141 #define CDC_ACM_IFCES_DESC_ALL_LEN 66
142
143 /* Define the counters used in the test application... */
144
145 static ULONG thread_0_counter;
146 static ULONG thread_1_counter;
147 static ULONG error_counter;
148
149 static UCHAR expect_errors = UX_FALSE;
150
151
152 /* Define USBX test global variables. */
153
154 static UX_HOST_CLASS *class_driver;
155 static UX_HOST_CLASS_DPUMP *dpump;
156 static UX_SLAVE_CLASS_DPUMP *dpump_slave = UX_NULL;
157
158
159 static UCHAR device_framework_full_speed[] = {
160
161 /* Device descriptor 18 bytes */
162 0x12, 0x01, 0x10, 0x01, 0x00, 0x00, 0x00, 0x08,
163 0xec, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
164 0x00, 0x01,
165
166 /* Configuration descriptor 9 bytes */
167 CFG_DESC(CFG_DESC_LEN + DPUMP_IFC_DESC_ALL_LEN + HID_MOUSE_IFC0_DESC_ALL_LEN + HID_MOUSE_IFC1_DESC_ALL_LEN + CDC_ACM_IFCES_DESC_ALL_LEN, 2, 1)
168 /* DPUMP 9+9+7 =25 */
169 DPUMP_IFC_DESC_ALL(0, 0x81, 0x02)
170 /* HID 9+9 + 9+9+7=43 */
171 HID_MOUSE_IFC0_DESC_ALL(1)
172 HID_MOUSE_IFC1_DESC_ALL(1, 0x83)
173 /* CDC-ACM */
174 CDC_ACM_IFCES_DESC_ALL(2, 0x86, 0x85, 0x04)
175 };
176 #define DEVICE_FRAMEWORK_LENGTH_FULL_SPEED sizeof(device_framework_full_speed)
177
178 static UCHAR device_framework_high_speed[] = {
179
180 /* Device descriptor */
181 0x12, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40,
182 0x0a, 0x07, 0x25, 0x40, 0x01, 0x00, 0x01, 0x02,
183 0x03, 0x01,
184
185 /* Device qualifier descriptor */
186 0x0a, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40,
187 0x01, 0x00,
188
189 /* Configuration descriptor 9 bytes */
190 CFG_DESC(CFG_DESC_LEN + DPUMP_IFC_DESC_ALL_LEN + HID_MOUSE_IFC0_DESC_ALL_LEN + HID_MOUSE_IFC1_DESC_ALL_LEN + CDC_ACM_IFCES_DESC_ALL_LEN, 2, 1)
191 /* DPUMP 9+9+7 =25 */
192 DPUMP_IFC_DESC_ALL(0, 0x81, 0x02)
193 /* HID 9+9 + 9+9+7=43 */
194 HID_MOUSE_IFC0_DESC_ALL(1)
195 HID_MOUSE_IFC1_DESC_ALL(1, 0x83)
196 /* CDC-ACM */
197 CDC_ACM_IFCES_DESC_ALL(2, 0x86, 0x85, 0x04)
198 };
199 #define DEVICE_FRAMEWORK_LENGTH_HIGH_SPEED sizeof(device_framework_high_speed)
200
201 /* String Device Framework :
202 Byte 0 and 1 : Word containing the language ID : 0x0904 for US
203 Byte 2 : Byte containing the index of the descriptor
204 Byte 3 : Byte containing the length of the descriptor string
205 */
206
207 static UCHAR string_framework[] = {
208
209 /* Manufacturer string descriptor : Index 1 */
210 0x09, 0x04, 0x01, 0x0c,
211 0x45, 0x78, 0x70, 0x72,0x65, 0x73, 0x20, 0x4c,
212 0x6f, 0x67, 0x69, 0x63,
213
214 /* Product string descriptor : Index 2 */
215 0x09, 0x04, 0x02, 0x0c,
216 0x44, 0x61, 0x74, 0x61, 0x50, 0x75, 0x6d, 0x70,
217 0x44, 0x65, 0x6d, 0x6f,
218
219 /* Serial Number string descriptor : Index 3 */
220 0x09, 0x04, 0x03, 0x04,
221 0x30, 0x30, 0x30, 0x31
222 };
223 #define STRING_FRAMEWORK_LENGTH sizeof(string_framework)
224
225 /* Multiple languages are supported on the device, to add
226 a language besides English, the unicode language code must
227 be appended to the language_id_framework array and the length
228 adjusted accordingly. */
229 static UCHAR language_id_framework[] = {
230
231 /* English. */
232 0x09, 0x04
233 };
234 #define LANGUAGE_ID_FRAMEWORK_LENGTH sizeof(language_id_framework)
235
236 /* Simulation actions. */
237
238 static UX_TEST_SIM_ENTRY_ACTION dcd_endpoint_create_fail[] = {
239 /* function, request to match,
240 port action, port status,
241 request action, request EP, request data, request actual length, request status,
242 status, additional callback,
243 no_return */
244 { UX_DCD_CREATE_ENDPOINT, NULL,
245 UX_FALSE, 0,
246 0 , 0, UX_NULL, 0, 0,
247 UX_ERROR , UX_NULL},
248 { 0 }
249 };
250
251
252 /* Define prototypes for external Host Controller's (HCDs), classes and clients. */
253
254 static VOID ux_test_instance_activate(VOID *dpump_instance);
255 static VOID ux_test_instance_deactivate(VOID *dpump_instance);
256
257 UINT _ux_host_class_dpump_entry(UX_HOST_CLASS_COMMAND *command);
258 UINT ux_hcd_sim_initialize(UX_HCD *hcd);
259 UINT _ux_host_class_dpump_write(UX_HOST_CLASS_DPUMP *dpump, UCHAR * data_pointer,
260 ULONG requested_length, ULONG *actual_length);
261 UINT _ux_host_class_dpump_read (UX_HOST_CLASS_DPUMP *dpump, UCHAR *data_pointer,
262 ULONG requested_length, ULONG *actual_length);
263
264 static TX_THREAD ux_test_thread_simulation_0;
265 static TX_THREAD ux_test_thread_simulation_1;
266 static void ux_test_thread_simulation_0_entry(ULONG);
267 static void ux_test_thread_simulation_1_entry(ULONG);
268
269
270 /* Define the ISR dispatch. */
271
272 extern VOID (*test_isr_dispatch)(void);
273
274
275 /* Prototype for test control return. */
276
277 void test_control_return(UINT status);
278
279
280 /* Define the ISR dispatch routine. */
281
test_isr(void)282 static void test_isr(void)
283 {
284
285 /* For further expansion of interrupt-level testing. */
286 }
287
288
error_callback(UINT system_level,UINT system_context,UINT error_code)289 static VOID error_callback(UINT system_level, UINT system_context, UINT error_code)
290 {
291 if (!expect_errors)
292 {
293 if (error_code != UX_DEVICE_HANDLE_UNKNOWN)
294 {
295 /* Failed test. */
296 printf("Error on line %d, system_level: %d, system_context: %d, error code: %d\n", __LINE__, system_level, system_context, error_code);
297 test_control_return(1);
298 }
299 }
300 }
301
test_ux_device_class_hid_entry(UX_SLAVE_CLASS_COMMAND * command)302 static UINT test_ux_device_class_hid_entry(UX_SLAVE_CLASS_COMMAND *command)
303 {
304 return UX_SUCCESS;
305 // return _ux_device_class_hid_entry(command);
306 }
307
308 /* Define what the initial system looks like. */
309
310 #ifdef CTEST
test_application_define(void * first_unused_memory)311 void test_application_define(void *first_unused_memory)
312 #else
313 void usbx_ux_device_stack_class_unregister_test_application_define(void *first_unused_memory)
314 #endif
315 {
316
317 UINT status;
318 CHAR *stack_pointer;
319 CHAR *memory_pointer;
320 UX_SLAVE_CLASS_DPUMP_PARAMETER parameter;
321 UX_SLAVE_CLASS_HID_PARAMETER hid_parameter;
322
323 /* Inform user. */
324 printf("Running ux_device_stack_class_unregister Test....................... ");
325 stepinfo("\n");
326
327 /* Initialize the free memory pointer. */
328 stack_pointer = (CHAR *) first_unused_memory;
329 memory_pointer = stack_pointer + (UX_TEST_STACK_SIZE * 2);
330
331 /* Initialize USBX Memory. */
332 status = ux_system_initialize(memory_pointer, UX_TEST_MEMORY_SIZE, UX_NULL, 0);
333
334 /* Check for error. */
335 if (status != UX_SUCCESS)
336 {
337
338 printf("ERROR #%d\n", __LINE__);
339 test_control_return(1);
340 }
341
342 /* Register the error callback. */
343 _ux_utility_error_callback_register(error_callback);
344
345 /* The code below is required for installing the host portion of USBX. */
346 status = ux_host_stack_initialize(UX_NULL);
347
348 /* Check for error. */
349 if (status != UX_SUCCESS)
350 {
351
352 printf("ERROR #%d\n", __LINE__);
353 test_control_return(1);
354 }
355
356 /* Register all the host class drivers for this USBX implementation. */
357 status = ux_host_stack_class_register(_ux_system_host_class_dpump_name, ux_host_class_dpump_entry);
358
359 /* Check for error. */
360 if (status != UX_SUCCESS)
361 {
362
363 printf("ERROR #%d\n", __LINE__);
364 test_control_return(1);
365 }
366
367 /* The code below is required for installing the device portion of USBX */
368 status = ux_device_stack_initialize(device_framework_high_speed, DEVICE_FRAMEWORK_LENGTH_HIGH_SPEED,
369 device_framework_full_speed, DEVICE_FRAMEWORK_LENGTH_FULL_SPEED,
370 string_framework, STRING_FRAMEWORK_LENGTH,
371 language_id_framework, LANGUAGE_ID_FRAMEWORK_LENGTH, UX_NULL);
372
373 /* Check for error. */
374 if (status != UX_SUCCESS)
375 {
376
377 printf("ERROR #%d\n", __LINE__);
378 test_control_return(1);
379 }
380
381 /* Set the parameters for callback when insertion/extraction of a Data Pump device. */
382 parameter.ux_slave_class_dpump_instance_activate = ux_test_instance_activate;
383 parameter.ux_slave_class_dpump_instance_deactivate = ux_test_instance_deactivate;
384
385 /* Initialize the device dpump class. The class is connected with interface 0 */
386 status = ux_device_stack_class_register(_ux_system_slave_class_dpump_name, _ux_device_class_dpump_entry,
387 1, 0, ¶meter);
388
389 /* Initialize the hid class parameters. */
390 hid_parameter.ux_device_class_hid_parameter_report_address = hid_mouse_report;
391 hid_parameter.ux_device_class_hid_parameter_report_length = HID_MOUSE_REPORT_LENGTH;
392 hid_parameter.ux_device_class_hid_parameter_callback = UX_NULL;
393 hid_parameter.ux_slave_class_hid_instance_activate = UX_NULL;
394
395 status |= ux_device_stack_class_register(_ux_system_slave_class_hid_name, test_ux_device_class_hid_entry,
396 1, 1, ¶meter);
397 #if UX_MAX_SLAVE_CLASS_DRIVER > 1
398 /* Check for error. */
399 if (status != UX_SUCCESS)
400 {
401
402 printf("ERROR #%d\n", __LINE__);
403 test_control_return(1);
404 }
405 #endif
406 /* Initialize the simulated device controller. */
407 status = _ux_test_dcd_sim_slave_initialize();
408
409 /* Check for error. */
410 if (status != UX_SUCCESS)
411 {
412
413 printf("ERROR #%d\n", __LINE__);
414 test_control_return(1);
415 }
416
417 /* Register all the USB host controllers available in this system */
418 status = ux_host_stack_hcd_register(_ux_system_host_hcd_simulator_name, _ux_test_hcd_sim_host_initialize,0,0);
419
420 /* Check for error. */
421 if (status != UX_SUCCESS)
422 {
423
424 printf("ERROR #%d\n", __LINE__);
425 test_control_return(1);
426 }
427
428 /* Create the main host simulation thread. */
429 status = tx_thread_create(&ux_test_thread_simulation_0, "test host simulation", ux_test_thread_simulation_0_entry, 0,
430 stack_pointer, UX_TEST_STACK_SIZE,
431 20, 20, 1, TX_AUTO_START);
432
433 /* Check for error. */
434 if (status != TX_SUCCESS)
435 {
436
437 printf("ERROR #%d\n", __LINE__);
438 test_control_return(1);
439 }
440 }
441
442
ux_test_thread_simulation_0_entry(ULONG arg)443 static void ux_test_thread_simulation_0_entry(ULONG arg)
444 {
445
446 UINT status;
447 UCHAR invalid_class_name[UX_MAX_CLASS_NAME_LENGTH+2];
448
449 /* Inform user. */
450 stepinfo(">>>>>>>>> ENUM check\n");
451
452 ux_test_dcd_sim_slave_connect(UX_HIGH_SPEED_DEVICE);
453 ux_test_hcd_sim_host_connect(UX_HIGH_SPEED_DEVICE);
454
455 /* Enumeration check. */
456 if (dpump_slave == UX_NULL)
457 {
458
459 printf("ERROR #%d: Enum fail\n", __LINE__);
460 test_control_return(1);
461 }
462
463 stepinfo(">>>>>>>>> Disconnect\n");
464 ux_test_dcd_sim_slave_disconnect();
465 ux_test_hcd_sim_host_disconnect();
466
467 /* Expect errors so skip them in error handler. */
468 expect_errors = UX_TRUE;
469
470 #if !defined(UX_NAME_REFERENCED_BY_POINTER)
471 stepinfo(">>>>>>>>> _ux_device_stack_class_unregister - error if class_name exceed UX_MAX_CLASS_NAME_LENGTH\n");
472 _ux_utility_memory_set(invalid_class_name, 'a', sizeof(invalid_class_name));
473 _ux_utility_memory_copy(invalid_class_name, _ux_system_slave_class_dpump_name, 20);
474 status = _ux_device_stack_class_unregister(invalid_class_name, _ux_device_class_dpump_entry);
475 if (status != UX_ERROR)
476 {
477 printf("ERROR %d: expect error %d\n", __LINE__, UX_ERROR);
478 error_counter ++;
479 }
480 #endif
481
482 /* Break on errors. */
483 expect_errors = UX_TRUE;
484
485 /* Sleep for a tick to make sure everything is complete. */
486 tx_thread_sleep(1);
487
488 /* Check for errors from other threads. */
489 if (error_counter)
490 {
491
492 /* Test error. */
493 printf("ERROR #%d\n", __LINE__);
494 test_control_return(1);
495 }
496 else
497 {
498
499 /* Successful test. */
500 printf("SUCCESS!\n");
501 test_control_return(0);
502 }
503 }
504
ux_test_instance_activate(VOID * dpump_instance)505 static VOID ux_test_instance_activate(VOID *dpump_instance)
506 {
507
508 /* Save the DPUMP instance. */
509 dpump_slave = (UX_SLAVE_CLASS_DPUMP *) dpump_instance;
510 }
511
ux_test_instance_deactivate(VOID * dpump_instance)512 static VOID ux_test_instance_deactivate(VOID *dpump_instance)
513 {
514
515 /* Reset the DPUMP instance. */
516 dpump_slave = UX_NULL;
517 }
518
519
