usbh.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright Nordic Semiconductor ASA
 * SPDX-FileCopyrightText: Copyright 2025 NXP
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_USBH_H_
#define ZEPHYR_INCLUDE_USBH_H_
 
#include <stdint.h>
#include <zephyr/device.h>
#include <zephyr/net_buf.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/dlist.h>
#include <zephyr/sys/bitarray.h>
#include <zephyr/drivers/usb/uhc.h>
#include <zephyr/sys/iterable_sections.h>
 
#ifdef __cplusplus
extern "C" {
#endif


struct usbh_status {
        unsigned int initialized : 1;
        unsigned int enabled : 1;
};

struct usbh_context {
        const char *name;
        struct k_mutex mutex;
        const struct device *dev;
        struct usbh_status status;
        sys_dlist_t udevs;
        struct usb_device *root;
        struct sys_bitarray *addr_ba;
};
 
#define USBH_CONTROLLER_DEFINE(device_name, uhc_dev)                    \
        SYS_BITARRAY_DEFINE_STATIC(ba_##device_name, 128);              \
        static STRUCT_SECTION_ITERABLE(usbh_context, device_name) = {   \
                .name = STRINGIFY(device_name),                         \
                .mutex = Z_MUTEX_INITIALIZER(device_name.mutex),        \
                .dev = uhc_dev,                                         \
                .addr_ba = &ba_##device_name,                           \
        }
 
struct usbh_class_data;

struct usbh_class_filter {
        uint16_t vid;
        uint16_t pid;
        uint8_t class;
        uint8_t sub;
        uint8_t proto;
        uint8_t flags;
};

struct usbh_class_api {
        int (*init)(struct usbh_class_data *const c_data,
                    struct usbh_context *const uhs_ctx);
        int (*completion_cb)(struct usbh_class_data *const c_data,
                             struct uhc_transfer *const xfer);
        int (*probe)(struct usbh_class_data *const c_data,
                     struct usb_device *const udev,
                     const uint8_t iface);
        int (*removed)(struct usbh_class_data *const c_data);
        int (*suspended)(struct usbh_class_data *const c_data);
        int (*resumed)(struct usbh_class_data *const c_data);
};

struct usbh_class_data {
        const char *name;
        struct usbh_context *uhs_ctx;
        struct usb_device *udev;
        uint8_t iface;
        struct usbh_class_api *api;
        void *priv;
};

enum usbh_class_state {
        USBH_CLASS_STATE_IDLE,
        USBH_CLASS_STATE_BOUND,
        USBH_CLASS_STATE_ERROR,
};
/* @endcond */

struct usbh_class_node {
        struct usbh_class_data *const c_data;
        const struct usbh_class_filter *filters;
        enum usbh_class_state state;
};
/* @endcond */

#define USBH_DEFINE_CLASS(class_name, class_api, class_priv, filt)              \
        static struct usbh_class_data UTIL_CAT(class_data_, class_name) = {     \
                .name = STRINGIFY(class_name),                                  \
                .api = class_api,                                               \
                .priv = class_priv,                                             \
        };                                                                      \
        static STRUCT_SECTION_ITERABLE(usbh_class_node, class_name) = {         \
                .c_data = &UTIL_CAT(class_data_, class_name),                   \
                .filters = filt,                                                \
        };

int usbh_init(struct usbh_context *uhs_ctx);

int usbh_enable(struct usbh_context *uhs_ctx);

int usbh_disable(struct usbh_context *uhs_ctx);

int usbh_shutdown(struct usbh_context *const uhs_ctx);

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_USBH_H_ */