michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: drivers: add simple UDC driver test

Browse source 
Simple test for API rules, allocation, queue, and dequeu
of the endpoint requests. USB device controller should not be
connected to the host as this state is not covered by this test.

Signed-off-by: Johann Fischer <johann.fischer@nordicsemi.no>
This commit is contained in:
Johann Fischer 2021-09-07 18:15:51 +02:00 • committed by Carles Cufí
commit db1fb82c18
5 changed files with 624 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
MAINTAINERS.yml
View file

@ -2151,6 +2151,7 @@ USB:
- samples/subsys/usb/
- subsys/usb/
- tests/subsys/usb/
- tests/drivers/udc/
labels:
- "area: USB"

11
tests/drivers/udc/CMakeLists.txt Normal file
View file

@ -0,0 +1,11 @@
# Copyright (c) 2021 Nordic Semiconductor ASA
# SPDX-License-Identifier: Apache-2.0
cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(test_udc_driver)
target_sources(app PRIVATE
src/main.c
)

11
tests/drivers/udc/prj.conf Normal file
View file

@ -0,0 +1,11 @@
# Copyright (c) 2021 Nordic Semiconductor ASA
# SPDX-License-Identifier: Apache-2.0
CONFIG_LOG=y
CONFIG_ZTEST=y
CONFIG_ZTEST_NEW_API=y
CONFIG_UDC_DRIVER=y
CONFIG_UDC_BUF_COUNT=32
CONFIG_UDC_BUF_POOL_SIZE=8192
CONFIG_UDC_DRIVER_LOG_LEVEL_INF=y

597
tests/drivers/udc/src/main.c Normal file
View file

@ -0,0 +1,597 @@
/*
* Copyright (c) 2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/ztest.h>
#include <zephyr/drivers/usb/udc.h>
#include <zephyr/usb/usb_ch9.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(udc_test, LOG_LEVEL_INF);
/*
* Simple test for API rules, allocation, queue, and dequeu
* of the endpoint requests. USB device controller should not be
* connected to the host as this state is not covered by this test.
*/
#define FALSE_EP_ADDR 0x0FU
K_MSGQ_DEFINE(test_msgq, sizeof(struct udc_event), 8, sizeof(uint32_t));
static K_KERNEL_STACK_DEFINE(test_udc_stack, 512);
static struct k_thread test_udc_thread_data;
static K_SEM_DEFINE(ep_queue_sem, 0, 1);
static uint8_t last_used_ep;
static int test_udc_event_handler(const struct device *dev,
const struct udc_event *const event)
{
return k_msgq_put(&test_msgq, event, K_NO_WAIT);
}
static void event_ep_request(const struct device *dev, struct udc_event event)
{
struct udc_buf_info *bi;
int err;
bi = udc_get_buf_info(event.buf);
err = udc_ep_buf_free(dev, event.buf);
zassert_ok(err, "Failed to free request buffer");
if (event.status == -ECONNABORTED && bi->ep == last_used_ep) {
k_sem_give(&ep_queue_sem);
}
}
static void test_udc_thread(const struct device *dev)
{
struct udc_event event;
while (true) {
k_msgq_get(&test_msgq, &event, K_FOREVER);
switch (event.type) {
case UDC_EVT_VBUS_REMOVED:
LOG_DBG("VBUS remove event");
break;
case UDC_EVT_VBUS_READY:
LOG_DBG("VBUS detected event");
break;
case UDC_EVT_SUSPEND:
LOG_DBG("Suspend event");
break;
case UDC_EVT_RESUME:
LOG_DBG("Resume event");
break;
case UDC_EVT_RESET:
LOG_DBG("Reset event");
break;
case UDC_EVT_SOF:
LOG_DBG("SoF event");
break;
case UDC_EVT_EP_REQUEST:
event_ep_request(dev, event);
break;
case UDC_EVT_ERROR:
LOG_DBG("Error event");
break;
default:
break;
};
}
}
static void test_udc_ep_try_config(const struct device *dev,
struct usb_ep_descriptor *ed)
{
uint16_t mps = ed->wMaxPacketSize;
int err;
err = udc_ep_try_config(dev, ed->bEndpointAddress,
ed->bmAttributes, &mps,
ed->bInterval);
zassert_equal(err, 0, "Failed to test endpoint configuration");
mps = 0;
err = udc_ep_try_config(dev, ed->bEndpointAddress,
ed->bmAttributes, &mps,
ed->bInterval);
zassert_equal(err, 0, "Failed to test endpoint configuration");
zassert_not_equal(mps, 0, "Failed to test endpoint configuration");
}
static void test_udc_ep_enable(const struct device *dev,
struct usb_ep_descriptor *ed)
{
uint8_t ctrl_ep = USB_EP_DIR_IS_IN(ed->bEndpointAddress) ?
USB_CONTROL_EP_IN : USB_CONTROL_EP_OUT;
/* Possible return values 0, -EINVAL, -ENODEV, -EALREADY, -EPERM. */
int err1, err2, err3, err4;
err1 = udc_ep_enable(dev, ed->bEndpointAddress, ed->bmAttributes,
ed->wMaxPacketSize, ed->bInterval);
err2 = udc_ep_enable(dev, ed->bEndpointAddress, ed->bmAttributes,
ed->wMaxPacketSize, ed->bInterval);
err3 = udc_ep_enable(dev, FALSE_EP_ADDR, ed->bmAttributes,
ed->wMaxPacketSize, ed->bInterval);
err4 = udc_ep_enable(dev, ctrl_ep, ed->bmAttributes,
ed->wMaxPacketSize, ed->bInterval);
if (!udc_is_initialized(dev) && !udc_is_enabled(dev)) {
zassert_equal(err1, -EPERM, "Not failed to enable endpoint");
zassert_equal(err2, -EPERM, "Not failed to enable endpoint");
zassert_equal(err3, -EPERM, "Not failed to enable endpoint");
zassert_equal(err4, -EINVAL, "Not failed to enable endpoint");
} else if (udc_is_initialized(dev) && !udc_is_enabled(dev)) {
zassert_equal(err1, -EPERM, "Not failed to enable endpoint");
zassert_equal(err2, -EPERM, "Not failed to enable endpoint");
zassert_equal(err3, -EPERM, "Not failed to enable endpoint");
zassert_equal(err4, -EINVAL, "Not failed to enable endpoint");
} else {
zassert_equal(err1, 0, "Failed to enable endpoint");
zassert_equal(err2, -EALREADY, "Not failed to enable endpoint");
zassert_equal(err3, -ENODEV, "Not failed to enable endpoint");
zassert_equal(err4, -EINVAL, "Not failed to enable endpoint");
}
}
static void test_udc_ep_disable(const struct device *dev,
struct usb_ep_descriptor *ed)
{
uint8_t ctrl_ep = USB_EP_DIR_IS_IN(ed->bEndpointAddress) ?
USB_CONTROL_EP_IN : USB_CONTROL_EP_OUT;
/* Possible return values 0, -EINVAL, -ENODEV, -EALREADY, -EPERM. */
int err1, err2, err3, err4;
err1 = udc_ep_disable(dev, ed->bEndpointAddress);
err2 = udc_ep_disable(dev, ed->bEndpointAddress);
err3 = udc_ep_disable(dev, FALSE_EP_ADDR);
err4 = udc_ep_disable(dev, ctrl_ep);
if (!udc_is_initialized(dev) && !udc_is_enabled(dev)) {
zassert_equal(err1, -EPERM, "Not failed to disable endpoint");
zassert_equal(err2, -EPERM, "Not failed to disable endpoint");
zassert_equal(err3, -EPERM, "Not failed to disable endpoint");
zassert_equal(err4, -EINVAL, "Not failed to disable endpoint");
} else if (udc_is_initialized(dev) && !udc_is_enabled(dev)) {
zassert_equal(err1, -EALREADY, "Failed to disable endpoint");
zassert_equal(err2, -EALREADY, "Not failed to disable endpoint");
zassert_equal(err3, -ENODEV, "Not failed to disable endpoint");
zassert_equal(err4, -EINVAL, "Not failed to disable endpoint");
} else {
zassert_equal(err1, 0, "Failed to disable endpoint");
zassert_equal(err2, -EALREADY, "Not failed to disable endpoint");
zassert_equal(err3, -ENODEV, "Not failed to disable endpoint");
zassert_equal(err4, -EINVAL, "Not failed to disable endpoint");
}
}
static struct net_buf *test_udc_ep_buf_alloc(const struct device *dev,
struct usb_ep_descriptor *ed)
{
struct net_buf *buf;
buf = udc_ep_buf_alloc(dev, ed->bEndpointAddress,
ed->wMaxPacketSize);
zassert_not_null(buf, "Failed to allocate request");
return buf;
}
static void test_udc_ep_buf_free(const struct device *dev,
struct net_buf *buf)
{
int err;
if (buf == NULL) {
return;
}
err = udc_ep_buf_free(dev, buf);
zassert_ok(err, "Failed to free request");
}
static void test_udc_ep_halt(const struct device *dev,
struct usb_ep_descriptor *ed)
{
/* Possible return values 0, -ENODEV, -ENOTSUP, -EPERM. */
int err1, err2, err3;
err1 = udc_ep_set_halt(dev, ed->bEndpointAddress);
err2 = udc_ep_set_halt(dev, FALSE_EP_ADDR);
err3 = udc_ep_set_halt(dev, USB_CONTROL_EP_OUT);
if (udc_is_enabled(dev)) {
if (ed->bmAttributes == USB_EP_TYPE_ISO) {
zassert_equal(err1, -ENOTSUP, "Not failed to set halt");
} else {
zassert_equal(err1, 0, "Failed to set halt");
}
zassert_equal(err2, -ENODEV, "Not failed to set halt");
zassert_equal(err3, 0, "Failed to set halt");
} else {
zassert_equal(err1, -EPERM, "Not failed to set halt");
zassert_equal(err2, -EPERM, "Not failed to set halt");
zassert_equal(err3, -EPERM, "Not failed to set halt");
}
err1 = udc_ep_clear_halt(dev, ed->bEndpointAddress);
err2 = udc_ep_clear_halt(dev, FALSE_EP_ADDR);
err3 = udc_ep_clear_halt(dev, USB_CONTROL_EP_OUT);
if (udc_is_enabled(dev)) {
if (ed->bmAttributes == USB_EP_TYPE_ISO) {
zassert_equal(err1, -ENOTSUP, "Not failed to clear halt");
} else {
zassert_equal(err1, 0, "Failed to clear halt ");
}
zassert_equal(err2, -ENODEV, "Not failed to clear halt");
zassert_equal(err3, 0, "Failed to clear halt");
} else {
zassert_equal(err1, -EPERM, "Not failed to clear halt");
zassert_equal(err2, -EPERM, "Not failed to clear halt");
zassert_equal(err3, -EPERM, "Not failed to clear halt");
}
}
static void test_udc_ep_enqueue(const struct device *dev,
struct net_buf *buf)
{
/* Possible return values 0, -EPERM, -ENODEV, -EACCES(TBD), -EBUSY (TBD) */
int err1, err2 = 0;
struct net_buf *false_buf = NULL;
err1 = udc_ep_enqueue(dev, buf);
if (udc_is_enabled(dev)) {
false_buf = udc_ep_buf_alloc(dev, FALSE_EP_ADDR, 64);
zassert_not_null(false_buf, "Failed to allocate request");
err2 = udc_ep_enqueue(dev, false_buf);
}
if (udc_is_enabled(dev)) {
zassert_equal(err1, 0, "Failed to queue request");
zassert_equal(err2, -ENODEV, "Not failed to queue request");
} else {
zassert_equal(err1, -EPERM, "Not failed to queue request");
}
test_udc_ep_buf_free(dev, false_buf);
}
static void test_udc_ep_dequeue(const struct device *dev,
struct usb_ep_descriptor *ed)
{
/* Possible return values 0, -EPERM, -ENODEV, -EACCES(TBD) */
int err1, err2;
err1 = udc_ep_dequeue(dev, ed->bEndpointAddress);
err2 = udc_ep_dequeue(dev, FALSE_EP_ADDR);
if (!udc_is_initialized(dev)) {
zassert_equal(err1, -EPERM, "Not failed to dequeue");
zassert_equal(err2, -EPERM, "Not failed to dequeue");
} else {
zassert_equal(err1, 0, "Failed to dequeue");
zassert_equal(err2, -ENODEV, "Not failed to dequeue");
}
}
static void test_udc_wakeup(const struct device *dev)
{
int err;
err = udc_host_wakeup(dev);
if (!udc_is_enabled(dev)) {
zassert_equal(err, -EPERM, "Not failed to request host wakeup");
}
}
static void test_udc_set_address(const struct device *dev, uint8_t addr)
{
int err;
err = udc_set_address(dev, addr);
if (!udc_is_enabled(dev)) {
zassert_equal(err, -EPERM, "Not failed to set address");
}
}
static void test_udc_ep_api(const struct device *dev,
struct usb_ep_descriptor *ed)
{
const int num_of_iterations = 10;
struct net_buf *buf;
int err;
last_used_ep = ed->bEndpointAddress;
for (int i = 0; i < num_of_iterations; i++) {
err = udc_ep_enable(dev, ed->bEndpointAddress, ed->bmAttributes,
ed->wMaxPacketSize, ed->bInterval);
zassert_ok(err, "Failed to enable endpoint");
/* It needs a little reserve for memory management overhead. */
for (int n = 0; n < (CONFIG_UDC_BUF_COUNT - 2); n++) {
buf = udc_ep_buf_alloc(dev, ed->bEndpointAddress,
ed->wMaxPacketSize);
zassert_not_null(buf,
"Failed to allocate request (%d) for 0x%02x",
n, ed->bEndpointAddress);
udc_ep_buf_set_zlp(buf);
err = udc_ep_enqueue(dev, buf);
zassert_ok(err, "Failed to queue request");
}
err = udc_ep_disable(dev, ed->bEndpointAddress);
zassert_ok(err, "Failed to disable endpoint");
err = udc_ep_dequeue(dev, ed->bEndpointAddress);
zassert_ok(err, "Failed to dequeue endpoint");
err = k_sem_take(&ep_queue_sem, K_MSEC(100));
zassert_ok(err, "Timeout to dequeue endpoint %d", err);
}
}
static void test_udc_ep_mps(uint8_t type)
{
uint16_t mps[] = {8, 16, 32, 64, 512, 1024};
struct usb_ep_descriptor ed = {
.bLength = sizeof(struct usb_ep_descriptor),
.bDescriptorType = USB_DESC_ENDPOINT,
.bEndpointAddress = 0x01,
.bmAttributes = type,
.wMaxPacketSize = 0,
.bInterval = 0,
};
const struct device *dev;
uint16_t supported;
int err;
dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
zassert_true(device_is_ready(dev), "UDC device not ready");
err = udc_init(dev, test_udc_event_handler);
zassert_ok(err, "Failed to initialize UDC driver");
err = udc_enable(dev);
zassert_ok(err, "Failed to enable UDC driver");
if (type == USB_EP_TYPE_INTERRUPT) {
ed.bInterval = 1;
}
for (uint8_t i = 1; i < 16U; i++) {
err = udc_ep_try_config(dev, i,
ed.bmAttributes, &supported,
ed.bInterval);
if (!err) {
ed.bEndpointAddress = i;
break;
}
}
zassert_ok(err, "Failed to determine MPS");
for (int i = 0; i < ARRAY_SIZE(mps); i++) {
if (mps[i] > supported) {
continue;
}
ed.wMaxPacketSize = mps[i];
test_udc_ep_api(dev, &ed);
ed.bEndpointAddress |= USB_EP_DIR_IN;
test_udc_ep_api(dev, &ed);
}
err = udc_disable(dev);
zassert_ok(err, "Failed to disable UDC driver");
err = udc_shutdown(dev);
zassert_ok(err, "Failed to shoot-down UDC driver");
}
ZTEST(udc_driver_test, test_udc_device_get)
{
struct udc_device_caps caps;
const struct device *dev;
dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
zassert_true(device_is_ready(dev), "UDC device not ready");
caps = udc_caps(dev);
LOG_INF("UDC device HS: %u", caps.hs);
k_thread_create(&test_udc_thread_data, test_udc_stack,
K_KERNEL_STACK_SIZEOF(test_udc_stack),
(k_thread_entry_t)test_udc_thread,
(void *)dev, NULL, NULL,
K_PRIO_COOP(9), 0, K_NO_WAIT);
k_thread_name_set(&test_udc_thread_data, "test-udc");
}
static struct usb_ep_descriptor ed_ctrl_out = {
.bLength = sizeof(struct usb_ep_descriptor),
.bDescriptorType = USB_DESC_ENDPOINT,
.bEndpointAddress = USB_CONTROL_EP_OUT,
.bmAttributes = USB_EP_TYPE_CONTROL,
.wMaxPacketSize = 64,
.bInterval = 0,
};
static struct usb_ep_descriptor ed_ctrl_in = {
.bLength = sizeof(struct usb_ep_descriptor),
.bDescriptorType = USB_DESC_ENDPOINT,
.bEndpointAddress = USB_CONTROL_EP_IN,
.bmAttributes = USB_EP_TYPE_CONTROL,
.wMaxPacketSize = 64,
.bInterval = 0,
};
static struct usb_ep_descriptor ed_bulk_out = {
.bLength = sizeof(struct usb_ep_descriptor),
.bDescriptorType = USB_DESC_ENDPOINT,
.bEndpointAddress = 0x01,
.bmAttributes = USB_EP_TYPE_BULK,
.wMaxPacketSize = 64,
.bInterval = 0,
};
static struct usb_ep_descriptor ed_bulk_in = {
.bLength = sizeof(struct usb_ep_descriptor),
.bDescriptorType = USB_DESC_ENDPOINT,
.bEndpointAddress = 0x81,
.bmAttributes = USB_EP_TYPE_BULK,
.wMaxPacketSize = 64,
.bInterval = 0,
};
ZTEST(udc_driver_test, test_udc_not_initialized)
{
const struct device *dev;
struct net_buf *buf;
int err;
dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
zassert_true(device_is_ready(dev), "UDC device not ready");
err = udc_init(dev, NULL);
zassert_equal(err, -EINVAL, "Not failed to initialize UDC");
err = udc_shutdown(dev);
zassert_equal(err, -EALREADY, "Not failed to shutdown UDC");
err = udc_enable(dev);
zassert_equal(err, -EPERM, "Not failed to enable UDC driver");
test_udc_set_address(dev, 0);
test_udc_set_address(dev, 1);
test_udc_wakeup(dev);
test_udc_ep_try_config(dev, &ed_ctrl_out);
test_udc_ep_try_config(dev, &ed_ctrl_in);
test_udc_ep_try_config(dev, &ed_bulk_out);
test_udc_ep_try_config(dev, &ed_bulk_in);
buf = test_udc_ep_buf_alloc(dev, &ed_bulk_out);
test_udc_ep_enable(dev, &ed_bulk_out);
test_udc_ep_enqueue(dev, buf);
test_udc_ep_halt(dev, &ed_bulk_out);
test_udc_ep_disable(dev, &ed_bulk_out);
test_udc_ep_dequeue(dev, &ed_bulk_out);
test_udc_ep_buf_free(dev, buf);
err = udc_disable(dev);
zassert_equal(err, -EALREADY, "Not failed to disable UDC driver");
}
ZTEST(udc_driver_test, test_udc_initialized)
{
const struct device *dev;
struct net_buf *buf;
int err;
dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
zassert_true(device_is_ready(dev), "UDC device not ready");
err = udc_init(dev, test_udc_event_handler);
zassert_ok(err, "Failed to initialize UDC driver");
test_udc_set_address(dev, 0);
test_udc_set_address(dev, 1);
test_udc_wakeup(dev);
test_udc_ep_try_config(dev, &ed_ctrl_out);
test_udc_ep_try_config(dev, &ed_ctrl_in);
test_udc_ep_try_config(dev, &ed_bulk_out);
test_udc_ep_try_config(dev, &ed_bulk_in);
buf = test_udc_ep_buf_alloc(dev, &ed_bulk_out);
test_udc_ep_enable(dev, &ed_bulk_out);
test_udc_ep_enqueue(dev, buf);
test_udc_ep_halt(dev, &ed_bulk_out);
test_udc_ep_disable(dev, &ed_bulk_out);
test_udc_ep_dequeue(dev, &ed_bulk_out);
test_udc_ep_buf_free(dev, buf);
err = udc_shutdown(dev);
zassert_ok(err, "Failed to shootdown UDC driver");
}
ZTEST(udc_driver_test, test_udc_enabled)
{
const struct device *dev;
struct net_buf *buf;
int err;
dev = DEVICE_DT_GET(DT_NODELABEL(zephyr_udc0));
zassert_true(device_is_ready(dev), "UDC device not ready");
err = udc_init(dev, test_udc_event_handler);
zassert_ok(err, "Failed to initialize UDC driver");
err = udc_enable(dev);
zassert_ok(err, "Failed to enable UDC driver");
err = udc_enable(dev);
zassert_equal(err, -EALREADY, "Not failed to enable UDC driver");
err = udc_disable(dev);
zassert_ok(err, "Failed to disable UDC driver");
err = udc_enable(dev);
zassert_ok(err, "Failed to enable UDC driver");
test_udc_set_address(dev, 0);
test_udc_set_address(dev, 1);
test_udc_ep_try_config(dev, &ed_ctrl_out);
test_udc_ep_try_config(dev, &ed_ctrl_in);
test_udc_ep_try_config(dev, &ed_bulk_out);
test_udc_ep_try_config(dev, &ed_bulk_in);
buf = test_udc_ep_buf_alloc(dev, &ed_bulk_out);
test_udc_ep_enable(dev, &ed_bulk_out);
test_udc_ep_enqueue(dev, buf);
test_udc_ep_halt(dev, &ed_bulk_out);
test_udc_ep_disable(dev, &ed_bulk_out);
test_udc_ep_dequeue(dev, &ed_bulk_out);
test_udc_ep_buf_free(dev, buf);
err = udc_shutdown(dev);
zassert_equal(err, -EBUSY, "Not failed to shoot-down UDC driver");
err = udc_disable(dev);
zassert_ok(err, "Failed to disable UDC driver");
err = udc_shutdown(dev);
zassert_ok(err, "Failed to shoot-down UDC driver");
}
ZTEST(udc_driver_test, test_udc_ep_buf)
{
test_udc_ep_mps(USB_EP_TYPE_BULK);
}
ZTEST(udc_driver_test, test_udc_ep_int)
{
test_udc_ep_mps(USB_EP_TYPE_INTERRUPT);
}
ZTEST(udc_driver_test, test_udc_ep_iso)
{
test_udc_ep_mps(USB_EP_TYPE_ISO);
}
ZTEST_SUITE(udc_driver_test, NULL, NULL, NULL, NULL, NULL);

4
tests/drivers/udc/testcase.yaml Normal file
View file

@ -0,0 +1,4 @@
tests:
drivers.udc:
tags: usb drivers
platform_allow: nrf52840dk_nrf52840