1 /*
2 * Copyright (c) 2022 Nordic Semiconductor ASA
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <zephyr/ztest.h>
8 #include <zephyr/drivers/usb/udc.h>
9 #include <zephyr/sys/byteorder.h>
10 #include <zephyr/usb/usb_ch9.h>
11
12 #include <zephyr/logging/log.h>
13 LOG_MODULE_REGISTER(udc_test, LOG_LEVEL_INF);
14
15 /*
16 * Simple test for API rules, allocation, queue, and dequeu
17 * of the endpoint requests. USB device controller should not be
18 * connected to the host as this state is not covered by this test.
19 */
20
21 #define BULK_OUT_EP_ADDR 0x01U
22 #define BULK_IN_EP_ADDR 0x81U
23 #define FALSE_EP_ADDR 0x0FU
24
25 K_MSGQ_DEFINE(test_msgq, sizeof(struct udc_event), 8, sizeof(uint32_t));
26 static K_KERNEL_STACK_DEFINE(test_udc_stack, 512);
27 static struct k_thread test_udc_thread_data;
28 static K_SEM_DEFINE(ep_queue_sem, 0, 1);
29 static uint8_t last_used_ep;
30 static uint8_t test_event_ctx;
31
test_udc_event_handler(const struct device * dev,const struct udc_event * const event)32 static int test_udc_event_handler(const struct device *dev,
33 const struct udc_event *const event)
34 {
35 return k_msgq_put(&test_msgq, event, K_NO_WAIT);
36 }
37
event_ep_request(const struct device * dev,struct udc_event event)38 static void event_ep_request(const struct device *dev, struct udc_event event)
39 {
40 struct udc_buf_info *bi;
41 int err;
42
43 bi = udc_get_buf_info(event.buf);
44
45 err = udc_ep_buf_free(dev, event.buf);
46 zassert_ok(err, "Failed to free request buffer");
47
48 if (bi->err == -ECONNABORTED && bi->ep == last_used_ep) {
49 k_sem_give(&ep_queue_sem);
50 }
51 }
52
test_udc_thread(void * p1,void * p2,void * p3)53 static void test_udc_thread(void *p1, void *p2, void *p3)
54 {
55 ARG_UNUSED(p2);
56 ARG_UNUSED(p3);
57
58 const struct device *dev = p1;
59 struct udc_event event;
60
61 while (true) {
62 k_msgq_get(&test_msgq, &event, K_FOREVER);
63
64 zassert_equal(udc_get_event_ctx(event.dev), &test_event_ctx,
65 "Wrong pointer to higher layer context");
66
67 switch (event.type) {
68 case UDC_EVT_VBUS_REMOVED:
69 LOG_DBG("VBUS remove event");
70 break;
71 case UDC_EVT_VBUS_READY:
72 LOG_DBG("VBUS detected event");
73 break;
74 case UDC_EVT_SUSPEND:
75 LOG_DBG("Suspend event");
76 break;
77 case UDC_EVT_RESUME:
78 LOG_DBG("Resume event");
79 break;
80 case UDC_EVT_RESET:
81 LOG_DBG("Reset event");
82 break;
83 case UDC_EVT_SOF:
84 LOG_DBG("SoF event");
85 break;
86 case UDC_EVT_EP_REQUEST:
87 event_ep_request(dev, event);
88 break;
89 case UDC_EVT_ERROR:
90 LOG_DBG("Error event");
91 break;
92 default:
93 break;
94 };
95 }
96 }
97
test_udc_ep_try_config(const struct device * dev,struct usb_ep_descriptor * ed)98 static void test_udc_ep_try_config(const struct device *dev,
99 struct usb_ep_descriptor *ed)
100 {
101 uint16_t mps = sys_le16_to_cpu(ed->wMaxPacketSize);
102 int err;
103
104 err = udc_ep_try_config(dev, ed->bEndpointAddress,
105 ed->bmAttributes, &mps,
106 ed->bInterval);
107 zassert_equal(err, 0, "Failed to test endpoint configuration");
108
109 if (ed->bmAttributes == USB_EP_TYPE_CONTROL ||
110 ed->bmAttributes == USB_EP_TYPE_ISO) {
111 /*
112 * Skip subsequent test since udc_ep_try_config() does not
113 * update mps argument for control and iso endpoints.
114 */
115 return;
116 }
117
118 mps = 0;
119 err = udc_ep_try_config(dev, ed->bEndpointAddress,
120 ed->bmAttributes, &mps,
121 ed->bInterval);
122 zassert_equal(err, 0, "Failed to test endpoint configuration");
123 zassert_not_equal(mps, 0, "Failed to test endpoint configuration");
124 }
125
test_udc_ep_enable(const struct device * dev,struct usb_ep_descriptor * ed)126 static void test_udc_ep_enable(const struct device *dev,
127 struct usb_ep_descriptor *ed)
128 {
129 uint8_t ctrl_ep = USB_EP_DIR_IS_IN(ed->bEndpointAddress) ?
130 USB_CONTROL_EP_IN : USB_CONTROL_EP_OUT;
131 /* Possible return values 0, -EINVAL, -ENODEV, -EALREADY, -EPERM. */
132 int err1, err2, err3;
133
134 err1 = udc_ep_enable(dev, ed->bEndpointAddress, ed->bmAttributes,
135 sys_le16_to_cpu(ed->wMaxPacketSize),
136 ed->bInterval);
137 err2 = udc_ep_enable(dev, ed->bEndpointAddress, ed->bmAttributes,
138 sys_le16_to_cpu(ed->wMaxPacketSize),
139 ed->bInterval);
140 err3 = udc_ep_enable(dev, ctrl_ep, ed->bmAttributes,
141 sys_le16_to_cpu(ed->wMaxPacketSize),
142 ed->bInterval);
143
144 if (!udc_is_initialized(dev) && !udc_is_enabled(dev)) {
145 zassert_equal(err1, -EPERM, "Not failed to enable endpoint");
146 zassert_equal(err2, -EPERM, "Not failed to enable endpoint");
147 zassert_equal(err3, -EINVAL, "Not failed to enable endpoint");
148 } else if (udc_is_initialized(dev) && !udc_is_enabled(dev)) {
149 zassert_equal(err1, -EPERM, "Not failed to enable endpoint");
150 zassert_equal(err2, -EPERM, "Not failed to enable endpoint");
151 zassert_equal(err3, -EINVAL, "Not failed to enable endpoint");
152 } else {
153 zassert_equal(err1, 0, "Failed to enable endpoint");
154 zassert_equal(err2, -EALREADY, "Not failed to enable endpoint");
155 zassert_equal(err3, -EINVAL, "Not failed to enable endpoint");
156 }
157 }
158
test_udc_ep_disable(const struct device * dev,struct usb_ep_descriptor * ed)159 static void test_udc_ep_disable(const struct device *dev,
160 struct usb_ep_descriptor *ed)
161 {
162 uint8_t ctrl_ep = USB_EP_DIR_IS_IN(ed->bEndpointAddress) ?
163 USB_CONTROL_EP_IN : USB_CONTROL_EP_OUT;
164 /* Possible return values 0, -EINVAL, -ENODEV, -EALREADY, -EPERM. */
165 int err1, err2, err3;
166
167 err1 = udc_ep_disable(dev, ed->bEndpointAddress);
168 err2 = udc_ep_disable(dev, ed->bEndpointAddress);
169 err3 = udc_ep_disable(dev, ctrl_ep);
170
171 if (!udc_is_initialized(dev) && !udc_is_enabled(dev)) {
172 zassert_equal(err1, -EPERM, "Not failed to disable endpoint");
173 zassert_equal(err2, -EPERM, "Not failed to disable endpoint");
174 zassert_equal(err3, -EINVAL, "Not failed to disable endpoint");
175 } else if (udc_is_initialized(dev) && !udc_is_enabled(dev)) {
176 zassert_equal(err1, -EALREADY, "Failed to disable endpoint");
177 zassert_equal(err2, -EALREADY, "Not failed to disable endpoint");
178 zassert_equal(err3, -EINVAL, "Not failed to disable endpoint");
179 } else {
180 zassert_equal(err1, 0, "Failed to disable endpoint");
181 zassert_equal(err2, -EALREADY, "Not failed to disable endpoint");
182 zassert_equal(err3, -EINVAL, "Not failed to disable endpoint");
183 }
184 }
185
test_udc_ep_buf_alloc(const struct device * dev,struct usb_ep_descriptor * ed)186 static struct net_buf *test_udc_ep_buf_alloc(const struct device *dev,
187 struct usb_ep_descriptor *ed)
188 {
189 struct net_buf *buf;
190
191 buf = udc_ep_buf_alloc(dev, ed->bEndpointAddress,
192 USB_MPS_TO_TPL(sys_le16_to_cpu(ed->wMaxPacketSize)));
193
194 zassert_not_null(buf, "Failed to allocate request");
195
196 return buf;
197 }
198
test_udc_ep_buf_free(const struct device * dev,struct net_buf * buf)199 static void test_udc_ep_buf_free(const struct device *dev,
200 struct net_buf *buf)
201 {
202 int err;
203
204 if (buf == NULL) {
205 return;
206 }
207
208 err = udc_ep_buf_free(dev, buf);
209 zassert_ok(err, "Failed to free request");
210 }
211
test_udc_ep_halt(const struct device * dev,struct usb_ep_descriptor * ed)212 static void test_udc_ep_halt(const struct device *dev,
213 struct usb_ep_descriptor *ed)
214 {
215 /* Possible return values 0, -ENODEV, -ENOTSUP, -EPERM. */
216 int err1, err2;
217
218 err1 = udc_ep_set_halt(dev, ed->bEndpointAddress);
219 err2 = udc_ep_set_halt(dev, FALSE_EP_ADDR);
220
221 if (udc_is_enabled(dev)) {
222 if (ed->bmAttributes == USB_EP_TYPE_ISO) {
223 zassert_equal(err1, -ENOTSUP, "Not failed to set halt");
224 } else {
225 zassert_equal(err1, 0, "Failed to set halt");
226 }
227
228 zassert_equal(err2, -ENODEV, "Not failed to set halt");
229 } else {
230 zassert_equal(err1, -EPERM, "Not failed to set halt");
231 zassert_equal(err2, -EPERM, "Not failed to set halt");
232 }
233
234 err1 = udc_ep_clear_halt(dev, ed->bEndpointAddress);
235 err2 = udc_ep_clear_halt(dev, FALSE_EP_ADDR);
236
237 if (udc_is_enabled(dev)) {
238 if (ed->bmAttributes == USB_EP_TYPE_ISO) {
239 zassert_equal(err1, -ENOTSUP, "Not failed to clear halt");
240 } else {
241 zassert_equal(err1, 0, "Failed to clear halt ");
242 }
243
244 zassert_equal(err2, -ENODEV, "Not failed to clear halt");
245 } else {
246 zassert_equal(err1, -EPERM, "Not failed to clear halt");
247 zassert_equal(err2, -EPERM, "Not failed to clear halt");
248 }
249 }
250
test_udc_ep_enqueue(const struct device * dev,struct net_buf * buf)251 static void test_udc_ep_enqueue(const struct device *dev,
252 struct net_buf *buf)
253 {
254 /* Possible return values 0, -EPERM, -ENODEV, -EACCES(TBD), -EBUSY (TBD) */
255 int err1, err2 = 0;
256 struct net_buf *false_buf = NULL;
257
258 err1 = udc_ep_enqueue(dev, buf);
259 if (udc_is_enabled(dev)) {
260 false_buf = udc_ep_buf_alloc(dev, FALSE_EP_ADDR, 64);
261 zassert_not_null(false_buf, "Failed to allocate request");
262 err2 = udc_ep_enqueue(dev, false_buf);
263 }
264
265 if (udc_is_enabled(dev)) {
266 zassert_equal(err1, 0, "Failed to queue request");
267 zassert_equal(err2, -ENODEV, "Not failed to queue request");
268 } else {
269 zassert_equal(err1, -EPERM, "Not failed to queue request");
270 }
271
272 test_udc_ep_buf_free(dev, false_buf);
273 }
274
test_udc_ep_dequeue(const struct device * dev,struct usb_ep_descriptor * ed)275 static void test_udc_ep_dequeue(const struct device *dev,
276 struct usb_ep_descriptor *ed)
277 {
278 /* Possible return values 0, -EPERM, -ENODEV, -EACCES(TBD) */
279 int err;
280
281 err = udc_ep_dequeue(dev, ed->bEndpointAddress);
282
283 if (!udc_is_initialized(dev)) {
284 zassert_equal(err, -EPERM, "Not failed to dequeue");
285 } else {
286 zassert_equal(err, 0, "Failed to dequeue");
287 }
288 }
289
test_udc_wakeup(const struct device * dev)290 static void test_udc_wakeup(const struct device *dev)
291 {
292 int err;
293
294 err = udc_host_wakeup(dev);
295
296 if (!udc_is_enabled(dev)) {
297 zassert_equal(err, -EPERM, "Not failed to request host wakeup");
298 }
299 }
300
test_udc_set_address(const struct device * dev,uint8_t addr)301 static void test_udc_set_address(const struct device *dev, uint8_t addr)
302 {
303 int err;
304
305 err = udc_set_address(dev, addr);
306
307 if (!udc_is_enabled(dev)) {
308 zassert_equal(err, -EPERM, "Not failed to set address");
309 }
310 }
311
test_udc_ep_api(const struct device * dev,struct usb_ep_descriptor * ed)312 static void test_udc_ep_api(const struct device *dev,
313 struct usb_ep_descriptor *ed)
314 {
315 const int num_of_iterations = 10;
316 struct net_buf *buf;
317 int err;
318
319 last_used_ep = ed->bEndpointAddress;
320
321 for (int i = 0; i < num_of_iterations; i++) {
322 err = udc_ep_enable(dev, ed->bEndpointAddress, ed->bmAttributes,
323 sys_le16_to_cpu(ed->wMaxPacketSize),
324 ed->bInterval);
325 zassert_ok(err, "Failed to enable endpoint");
326
327 /* It needs a little reserve for memory management overhead. */
328 for (int n = 0; n < (CONFIG_UDC_BUF_COUNT - 4); n++) {
329 buf = udc_ep_buf_alloc(dev, ed->bEndpointAddress,
330 USB_MPS_TO_TPL(sys_le16_to_cpu(ed->wMaxPacketSize)));
331 zassert_not_null(buf,
332 "Failed to allocate request (%d) for 0x%02x",
333 n, ed->bEndpointAddress);
334
335 udc_ep_buf_set_zlp(buf);
336 err = udc_ep_enqueue(dev, buf);
337 zassert_ok(err, "Failed to queue request");
338 k_yield();
339 }
340
341 err = udc_ep_disable(dev, ed->bEndpointAddress);
342 zassert_ok(err, "Failed to disable endpoint");
343
344 err = udc_ep_dequeue(dev, ed->bEndpointAddress);
345 zassert_ok(err, "Failed to dequeue endpoint");
346
347 err = k_sem_take(&ep_queue_sem, K_MSEC(100));
348 zassert_ok(err, "Timeout to dequeue endpoint %x %d", last_used_ep, err);
349 }
350 }
351
test_udc_ep_mps(uint8_t type)352 static void test_udc_ep_mps(uint8_t type)
353 {
354 uint16_t mps[] = {8, 16, 32, 64, 512, 1024};
355 struct usb_ep_descriptor ed = {
356 .bLength = sizeof(struct usb_ep_descriptor),
357 .bDescriptorType = USB_DESC_ENDPOINT,
358 .bEndpointAddress = 0x01,
359 .bmAttributes = type,
360 .wMaxPacketSize = sys_cpu_to_le16(0),
361 .bInterval = 0,
362 };
363 const struct device *dev;
364 uint16_t supported = 0;
365 int err;
366
367 dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
368 zassert_true(device_is_ready(dev), "UDC device not ready");
369
370 err = udc_init(dev, test_udc_event_handler, &test_event_ctx);
371 zassert_ok(err, "Failed to initialize UDC driver");
372
373 err = udc_enable(dev);
374 zassert_ok(err, "Failed to enable UDC driver");
375
376 if (type == USB_EP_TYPE_INTERRUPT) {
377 ed.bInterval = 1;
378 }
379
380 for (uint8_t i = 1; i < 16U; i++) {
381 err = udc_ep_try_config(dev, i,
382 ed.bmAttributes, &supported,
383 ed.bInterval);
384 if (!err) {
385 ed.bEndpointAddress = i;
386 break;
387 }
388 }
389
390 zassert_ok(err, "Failed to determine MPS");
391
392 for (int i = 0; i < ARRAY_SIZE(mps); i++) {
393 if (mps[i] > supported) {
394 continue;
395 }
396
397 ed.wMaxPacketSize = sys_cpu_to_le16(mps[i]);
398 test_udc_ep_api(dev, &ed);
399
400 ed.bEndpointAddress |= USB_EP_DIR_IN;
401 test_udc_ep_api(dev, &ed);
402 }
403
404 err = udc_disable(dev);
405 zassert_ok(err, "Failed to disable UDC driver");
406
407 err = udc_shutdown(dev);
408 zassert_ok(err, "Failed to shoot-down UDC driver");
409 }
410
test_udc_device_get(void)411 static void *test_udc_device_get(void)
412 {
413 struct udc_device_caps caps;
414 const struct device *dev;
415
416 dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
417 zassert_true(device_is_ready(dev), "UDC device not ready");
418
419 caps = udc_caps(dev);
420 LOG_INF("UDC device HS: %u", caps.hs);
421
422 k_thread_create(&test_udc_thread_data, test_udc_stack,
423 K_KERNEL_STACK_SIZEOF(test_udc_stack),
424 test_udc_thread,
425 (void *)dev, NULL, NULL,
426 K_PRIO_COOP(9), 0, K_NO_WAIT);
427
428 k_thread_name_set(&test_udc_thread_data, "test-udc");
429
430 return (void *)dev;
431 }
432
433 static struct usb_ep_descriptor ed_ctrl_out = {
434 .bLength = sizeof(struct usb_ep_descriptor),
435 .bDescriptorType = USB_DESC_ENDPOINT,
436 .bEndpointAddress = USB_CONTROL_EP_OUT,
437 .bmAttributes = USB_EP_TYPE_CONTROL,
438 .wMaxPacketSize = sys_cpu_to_le16(64),
439 .bInterval = 0,
440 };
441
442 static struct usb_ep_descriptor ed_ctrl_in = {
443 .bLength = sizeof(struct usb_ep_descriptor),
444 .bDescriptorType = USB_DESC_ENDPOINT,
445 .bEndpointAddress = USB_CONTROL_EP_IN,
446 .bmAttributes = USB_EP_TYPE_CONTROL,
447 .wMaxPacketSize = sys_cpu_to_le16(64),
448 .bInterval = 0,
449 };
450
451 static struct usb_ep_descriptor ed_bulk_out = {
452 .bLength = sizeof(struct usb_ep_descriptor),
453 .bDescriptorType = USB_DESC_ENDPOINT,
454 .bEndpointAddress = BULK_OUT_EP_ADDR,
455 .bmAttributes = USB_EP_TYPE_BULK,
456 .wMaxPacketSize = sys_cpu_to_le16(64),
457 .bInterval = 0,
458 };
459
460 static struct usb_ep_descriptor ed_bulk_in = {
461 .bLength = sizeof(struct usb_ep_descriptor),
462 .bDescriptorType = USB_DESC_ENDPOINT,
463 .bEndpointAddress = BULK_IN_EP_ADDR,
464 .bmAttributes = USB_EP_TYPE_BULK,
465 .wMaxPacketSize = sys_cpu_to_le16(64),
466 .bInterval = 0,
467 };
468
ZTEST(udc_driver_test,test_udc_not_initialized)469 ZTEST(udc_driver_test, test_udc_not_initialized)
470 {
471 const struct device *dev;
472 struct net_buf *buf;
473 int err;
474
475 dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
476 zassert_true(device_is_ready(dev), "UDC device not ready");
477
478 err = udc_init(dev, NULL, NULL);
479 zassert_equal(err, -EINVAL, "Not failed to initialize UDC");
480
481 err = udc_shutdown(dev);
482 zassert_equal(err, -EALREADY, "Not failed to shutdown UDC");
483
484 err = udc_enable(dev);
485 zassert_equal(err, -EPERM, "Not failed to enable UDC driver");
486
487 test_udc_set_address(dev, 0);
488 test_udc_set_address(dev, 1);
489 test_udc_wakeup(dev);
490
491 test_udc_ep_try_config(dev, &ed_ctrl_out);
492 test_udc_ep_try_config(dev, &ed_ctrl_in);
493 test_udc_ep_try_config(dev, &ed_bulk_out);
494 test_udc_ep_try_config(dev, &ed_bulk_in);
495
496 buf = test_udc_ep_buf_alloc(dev, &ed_bulk_out);
497 test_udc_ep_enable(dev, &ed_bulk_out);
498 test_udc_ep_enqueue(dev, buf);
499 test_udc_ep_halt(dev, &ed_bulk_out);
500 test_udc_ep_disable(dev, &ed_bulk_out);
501 test_udc_ep_dequeue(dev, &ed_bulk_out);
502 test_udc_ep_buf_free(dev, buf);
503
504 err = udc_disable(dev);
505 zassert_equal(err, -EALREADY, "Not failed to disable UDC driver");
506 }
507
ZTEST(udc_driver_test,test_udc_initialized)508 ZTEST(udc_driver_test, test_udc_initialized)
509 {
510 const struct device *dev;
511 struct net_buf *buf;
512 int err;
513
514 dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
515 zassert_true(device_is_ready(dev), "UDC device not ready");
516
517 err = udc_init(dev, test_udc_event_handler, &test_event_ctx);
518 zassert_ok(err, "Failed to initialize UDC driver");
519
520 test_udc_set_address(dev, 0);
521 test_udc_set_address(dev, 1);
522 test_udc_wakeup(dev);
523
524 test_udc_ep_try_config(dev, &ed_ctrl_out);
525 test_udc_ep_try_config(dev, &ed_ctrl_in);
526 test_udc_ep_try_config(dev, &ed_bulk_out);
527 test_udc_ep_try_config(dev, &ed_bulk_in);
528
529 buf = test_udc_ep_buf_alloc(dev, &ed_bulk_out);
530 test_udc_ep_enable(dev, &ed_bulk_out);
531 test_udc_ep_enqueue(dev, buf);
532 test_udc_ep_halt(dev, &ed_bulk_out);
533 test_udc_ep_disable(dev, &ed_bulk_out);
534 test_udc_ep_dequeue(dev, &ed_bulk_out);
535 test_udc_ep_buf_free(dev, buf);
536
537 err = udc_shutdown(dev);
538 zassert_ok(err, "Failed to shootdown UDC driver");
539 }
540
ZTEST(udc_driver_test,test_udc_enabled)541 ZTEST(udc_driver_test, test_udc_enabled)
542 {
543 const struct device *dev;
544 struct net_buf *buf;
545 int err;
546
547 dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
548 zassert_true(device_is_ready(dev), "UDC device not ready");
549
550 err = udc_init(dev, test_udc_event_handler, &test_event_ctx);
551 zassert_ok(err, "Failed to initialize UDC driver");
552
553 err = udc_enable(dev);
554 zassert_ok(err, "Failed to enable UDC driver");
555
556 err = udc_enable(dev);
557 zassert_equal(err, -EALREADY, "Not failed to enable UDC driver");
558
559 err = udc_disable(dev);
560 zassert_ok(err, "Failed to disable UDC driver");
561
562 err = udc_enable(dev);
563 zassert_ok(err, "Failed to enable UDC driver");
564
565 test_udc_set_address(dev, 0);
566 test_udc_set_address(dev, 1);
567
568 test_udc_ep_try_config(dev, &ed_ctrl_out);
569 test_udc_ep_try_config(dev, &ed_ctrl_in);
570 test_udc_ep_try_config(dev, &ed_bulk_out);
571 test_udc_ep_try_config(dev, &ed_bulk_in);
572
573 buf = test_udc_ep_buf_alloc(dev, &ed_bulk_out);
574 test_udc_ep_enable(dev, &ed_bulk_out);
575 test_udc_ep_enqueue(dev, buf);
576 test_udc_ep_halt(dev, &ed_bulk_out);
577 test_udc_ep_disable(dev, &ed_bulk_out);
578 test_udc_ep_dequeue(dev, &ed_bulk_out);
579
580 err = udc_shutdown(dev);
581 zassert_equal(err, -EBUSY, "Not failed to shoot-down UDC driver");
582
583 err = udc_disable(dev);
584 zassert_ok(err, "Failed to disable UDC driver");
585
586 err = udc_shutdown(dev);
587 zassert_ok(err, "Failed to shoot-down UDC driver");
588 }
589
ZTEST(udc_driver_test,test_udc_ep_buf)590 ZTEST(udc_driver_test, test_udc_ep_buf)
591 {
592 test_udc_ep_mps(USB_EP_TYPE_BULK);
593 }
594
ZTEST(udc_driver_test,test_udc_ep_int)595 ZTEST(udc_driver_test, test_udc_ep_int)
596 {
597 test_udc_ep_mps(USB_EP_TYPE_INTERRUPT);
598 }
599
ZTEST(udc_driver_test,test_udc_ep_iso)600 ZTEST(udc_driver_test, test_udc_ep_iso)
601 {
602 test_udc_ep_mps(USB_EP_TYPE_ISO);
603 }
604
605 ZTEST_SUITE(udc_driver_test, NULL, test_udc_device_get, NULL, NULL, NULL);
606
