New USB device stack core API. More...

Data Structures
struct	usbd_desc_node
	Descriptor node. More...

struct	usbd_config_node
	Device configuration node. More...

struct	usbd_ch9_data
	USB device support middle layer runtime data. More...

struct	usbd_status
	USB device support status. More...

struct	usbd_contex
	USB device support runtime context. More...

struct	usbd_cctx_vendor_req
	Vendor Requests Table. More...

struct	usbd_class_api
	USB device support class instance API. More...

struct	usbd_class_data
	USB device support class data. More...

Macros
#define	USB_BSTRING_LENGTH(s) (sizeof(s) * 2 - 2)

#define	USB_STRING_DESCRIPTOR_LENGTH(s) (sizeof(s) * 2)

#define	USBD_NUMOF_INTERFACES_MAX 16U

#define	USBD_CCTX_REGISTERED 0
	USB Class instance registered flag.

#define	USBD_DEVICE_DEFINE(device_name, uhc_dev, vid, pid)

#define	USBD_CONFIGURATION_DEFINE(name, attrib, power)

#define	USBD_DESC_LANG_DEFINE(name)
	Create a string descriptor node and language string descriptor.

#define	USBD_DESC_STRING_DEFINE(d_name, d_string, d_utype)

#define	USBD_DESC_MANUFACTURER_DEFINE(d_name, d_string) USBD_DESC_STRING_DEFINE(d_name, d_string, USBD_DUT_STRING_MANUFACTURER)
	Create a string descriptor node and manufacturer string descriptor.

#define	USBD_DESC_PRODUCT_DEFINE(d_name, d_string) USBD_DESC_STRING_DEFINE(d_name, d_string, USBD_DUT_STRING_PRODUCT)
	Create a string descriptor node and product string descriptor.

#define	USBD_DESC_SERIAL_NUMBER_DEFINE(d_name, d_string) USBD_DESC_STRING_DEFINE(d_name, d_string, USBD_DUT_STRING_SERIAL_NUMBER)
	Create a string descriptor node and serial number string descriptor.

#define	USBD_DEFINE_CLASS(class_name, class_api, class_priv, class_v_reqs)

#define	VENDOR_REQ_DEFINE(_reqs, _len)
	Helper to declare request table of usbd_cctx_vendor_req.

#define	USBD_VENDOR_REQ(_reqs...)
	Helper to declare supported vendor requests.

Enumerations
enum	usbd_desc_usage_type { USBD_DUT_STRING_LANG , USBD_DUT_STRING_MANUFACTURER , USBD_DUT_STRING_PRODUCT , USBD_DUT_STRING_SERIAL_NUMBER , USBD_DUT_STRING_INTERFACE }

enum	usbd_ch9_state { USBD_STATE_DEFAULT = 0 , USBD_STATE_ADDRESS , USBD_STATE_CONFIGURED }
	USB device support middle layer runtime state. More...

enum	usbd_speed { USBD_SPEED_FS , USBD_SPEED_HS , USBD_SPEED_SS }
	USB device speed. More...

Functions
static struct usbd_contex *	usbd_class_get_ctx (const struct usbd_class_data *const c_data)
	Get the USB device runtime context under which the class is registered.

static void *	usbd_class_get_private (const struct usbd_class_data *const c_data)
	Get class implementation private data.

int	usbd_add_descriptor (struct usbd_contex uds_ctx, struct usbd_desc_node dn)
	Add common USB descriptor.

int	usbd_add_configuration (struct usbd_contex uds_ctx, const enum usbd_speed speed, struct usbd_config_node cd)
	Add a USB device configuration.

int	usbd_register_class (struct usbd_contex uds_ctx, const char name, const enum usbd_speed speed, uint8_t cfg)
	Register an USB class instance.

int	usbd_unregister_class (struct usbd_contex uds_ctx, const char name, const enum usbd_speed speed, uint8_t cfg)
	Unregister an USB class instance.

int	usbd_msg_register_cb (struct usbd_contex *const uds_ctx, const usbd_msg_cb_t cb)
	Register USB notification message callback.

int	usbd_init (struct usbd_contex *uds_ctx)
	Initialize USB device.

int	usbd_enable (struct usbd_contex *uds_ctx)
	Enable the USB device support and registered class instances.

int	usbd_disable (struct usbd_contex *uds_ctx)
	Disable the USB device support.

int	usbd_shutdown (struct usbd_contex *const uds_ctx)
	Shutdown the USB device support.

int	usbd_ep_set_halt (struct usbd_contex *uds_ctx, uint8_t ep)
	Halt endpoint.

int	usbd_ep_clear_halt (struct usbd_contex *uds_ctx, uint8_t ep)
	Clear endpoint halt.

bool	usbd_ep_is_halted (struct usbd_contex *uds_ctx, uint8_t ep)
	Checks whether the endpoint is halted.

struct net_buf *	usbd_ep_ctrl_buf_alloc (struct usbd_contex *const uds_ctx, const uint8_t ep, const size_t size)
	Allocate buffer for USB device control request.

struct net_buf *	usbd_ep_buf_alloc (const struct usbd_class_data *const c_data, const uint8_t ep, const size_t size)
	Allocate buffer for USB device request.

int	usbd_ep_ctrl_enqueue (struct usbd_contex const uds_ctx, struct net_buf const buf)
	Queue USB device control request.

int	usbd_ep_enqueue (const struct usbd_class_data const c_data, struct net_buf const buf)
	Queue USB device request.

int	usbd_ep_dequeue (struct usbd_contex *uds_ctx, const uint8_t ep)
	Remove all USB device controller requests from endpoint queue.

int	usbd_ep_buf_free (struct usbd_contex uds_ctx, struct net_buf buf)
	Free USB device request buffer.

bool	usbd_is_suspended (struct usbd_contex *uds_ctx)
	Checks whether the USB device controller is suspended.

int	usbd_wakeup_request (struct usbd_contex *uds_ctx)
	Initiate the USB remote wakeup (TBD)

enum usbd_speed	usbd_bus_speed (const struct usbd_contex *const uds_ctx)
	Get actual device speed.

enum usbd_speed	usbd_caps_speed (const struct usbd_contex *const uds_ctx)
	Get highest speed supported by the controller.

int	usbd_device_set_bcd (struct usbd_contex *const uds_ctx, const enum usbd_speed speed, const uint16_t bcd)
	Set USB device descriptor value bcdUSB.

int	usbd_device_set_vid (struct usbd_contex *const uds_ctx, const uint16_t vid)
	Set USB device descriptor value idVendor.

int	usbd_device_set_pid (struct usbd_contex *const uds_ctx, const uint16_t pid)
	Set USB device descriptor value idProduct.

int	usbd_device_set_code_triple (struct usbd_contex *const uds_ctx, const enum usbd_speed speed, const uint8_t base_class, const uint8_t subclass, const uint8_t protocol)
	Set USB device descriptor code triple Base Class, SubClass, and Protocol.

int	usbd_config_attrib_rwup (struct usbd_contex *const uds_ctx, const enum usbd_speed speed, const uint8_t cfg, const bool enable)
	Setup USB device configuration attribute Remote Wakeup.

int	usbd_config_attrib_self (struct usbd_contex *const uds_ctx, const enum usbd_speed speed, const uint8_t cfg, const bool enable)
	Setup USB device configuration attribute Self-powered.

int	usbd_config_maxpower (struct usbd_contex *const uds_ctx, const enum usbd_speed speed, const uint8_t cfg, const uint8_t power)
	Setup USB device configuration power consumption.

Detailed Description

New USB device stack core API.

Macro Definition Documentation

◆ USB_BSTRING_LENGTH

#define USB_BSTRING_LENGTH ( s ) (sizeof(s) * 2 - 2)

#include <zephyr/usb/usbd.h>

◆ USB_STRING_DESCRIPTOR_LENGTH

#define USB_STRING_DESCRIPTOR_LENGTH ( s ) (sizeof(s) * 2)

#include <zephyr/usb/usbd.h>

◆ USBD_CCTX_REGISTERED

#define USBD_CCTX_REGISTERED 0

#include <zephyr/usb/usbd.h>

USB Class instance registered flag.

◆ USBD_CONFIGURATION_DEFINE

#define USBD_CONFIGURATION_DEFINE	(	name,
		attrib,
		power
	)

#include <zephyr/usb/usbd.h>

Value:

        static struct usb_cfg_descriptor                                \
        cfg_desc_##name = {                                             \
                .bLength = sizeof(struct usb_cfg_descriptor),           \
                .bDescriptorType = USB_DESC_CONFIGURATION,              \
                .wTotalLength = 0,                                      \
                .bNumInterfaces = 0,                                    \
                .bConfigurationValue = 1,                               \
                .iConfiguration = 0,                                    \
                .bmAttributes = USB_SCD_RESERVED | (attrib),            \
                .bMaxPower = (power),                                   \
        };                                                              \
        BUILD_ASSERT((power) < 256, "Too much power");                  \
        static struct usbd_config_node name = {                         \
                .desc = &cfg_desc_##name,                               \
        }

◆ USBD_DEFINE_CLASS

#define USBD_DEFINE_CLASS	(	class_name,
		class_api,
		class_priv,
		class_v_reqs
	)

#include <zephyr/usb/usbd.h>

Value:

        static struct usbd_class_data class_name = {                            \
                .name = STRINGIFY(class_name),                                  \
                .api = class_api,                                               \
                .v_reqs = class_v_reqs,                                         \
                .priv = class_priv,                                             \
        };                                                                      \
        static STRUCT_SECTION_ITERABLE_ALTERNATE(                               \
                usbd_class_fs, usbd_class_node, class_name##_fs) = {            \
                .c_data = &class_name,                                          \
        };                                                                      \
        static STRUCT_SECTION_ITERABLE_ALTERNATE(                               \
                usbd_class_hs, usbd_class_node, class_name##_hs) = {            \
                .c_data = &class_name,                                          \
        }

◆ USBD_DESC_LANG_DEFINE

#define USBD_DESC_LANG_DEFINE ( name )

#include <zephyr/usb/usbd.h>

Value:

        static struct usb_string_descriptor                             \
        string_desc_##name = {                                          \
                .bLength = sizeof(struct usb_string_descriptor),        \
                .bDescriptorType = USB_DESC_STRING,                     \
                .bString = sys_cpu_to_le16(0x0409),                     \
        };                                                              \
        static struct usbd_desc_node name = {                           \
                .idx = 0,                                               \
                .utype = USBD_DUT_STRING_LANG,                          \
                .desc = &string_desc_##name,                            \
        }

Create a string descriptor node and language string descriptor.

This macro defines a descriptor node and a string descriptor that, when added to the device context, is automatically used as the language string descriptor zero. Both descriptor node and descriptor are defined with static-storage-class specifier. Default and currently only supported language ID is 0x0409 English (United States). If string descriptors are used, it is necessary to add this descriptor as the first one to the USB device context.

Parameters

name	Language string descriptor node identifier.

◆ USBD_DESC_MANUFACTURER_DEFINE

#define USBD_DESC_MANUFACTURER_DEFINE	(	d_name,
		d_string
	)	USBD_DESC_STRING_DEFINE(d_name, d_string, USBD_DUT_STRING_MANUFACTURER)

#include <zephyr/usb/usbd.h>

Create a string descriptor node and manufacturer string descriptor.

This macro defines a descriptor node and a string descriptor that, when added to the device context, is automatically used as the manufacturer string descriptor. Both descriptor node and descriptor are defined with static-storage-class specifier.

Parameters

d_name	String descriptor node identifier.
d_string	ASCII7 encoded manufacturer string literal

◆ USBD_DESC_PRODUCT_DEFINE

#define USBD_DESC_PRODUCT_DEFINE	(	d_name,
		d_string
	)	USBD_DESC_STRING_DEFINE(d_name, d_string, USBD_DUT_STRING_PRODUCT)

#include <zephyr/usb/usbd.h>

Create a string descriptor node and product string descriptor.

This macro defines a descriptor node and a string descriptor that, when added to the device context, is automatically used as the product string descriptor. Both descriptor node and descriptor are defined with static-storage-class specifier.

Parameters

d_name	String descriptor node identifier.
d_string	ASCII7 encoded product string literal

◆ USBD_DESC_SERIAL_NUMBER_DEFINE

#define USBD_DESC_SERIAL_NUMBER_DEFINE	(	d_name,
		d_string
	)	USBD_DESC_STRING_DEFINE(d_name, d_string, USBD_DUT_STRING_SERIAL_NUMBER)

#include <zephyr/usb/usbd.h>

Create a string descriptor node and serial number string descriptor.

This macro defines a descriptor node and a string descriptor that, when added to the device context, is automatically used as the serial number string descriptor. The string literal parameter is used as a placeholder, the unique number is obtained from hwinfo. Both descriptor node and descriptor are defined with static-storage-class specifier.

Parameters

d_name	String descriptor node identifier.
d_string	ASCII7 encoded serial number string literal placeholder

◆ USBD_DESC_STRING_DEFINE

#define USBD_DESC_STRING_DEFINE	(	d_name,
		d_string,
		d_utype
	)

#include <zephyr/usb/usbd.h>

Value:

        struct usb_string_descriptor_##d_name {                         \
                uint8_t bLength;                                        \
                uint8_t bDescriptorType;                                \
                uint8_t bString[USB_BSTRING_LENGTH(d_string)];          \
        } __packed;                                                     \
        static struct usb_string_descriptor_##d_name                    \
        string_desc_##d_name = {                                        \
                .bLength = USB_STRING_DESCRIPTOR_LENGTH(d_string),      \
                .bDescriptorType = USB_DESC_STRING,                     \
                .bString = d_string,                                    \
        };                                                              \
        static struct usbd_desc_node d_name = {                         \
                .utype = d_utype,                                       \
                .desc = &string_desc_##d_name,                          \
        }

◆ USBD_DEVICE_DEFINE

#define USBD_DEVICE_DEFINE	(	device_name,
		uhc_dev,
		vid,
		pid
	)

#include <zephyr/usb/usbd.h>

Value:

        static struct usb_device_descriptor                             \
        fs_desc_##device_name = {                                       \
                .bLength = sizeof(struct usb_device_descriptor),        \
                .bDescriptorType = USB_DESC_DEVICE,                     \
                .bcdUSB = sys_cpu_to_le16(USB_SRN_2_0),                 \
                .bDeviceClass = USB_BCC_MISCELLANEOUS,                  \
                .bDeviceSubClass = 2,                                   \
                .bDeviceProtocol = 1,                                   \
                .bMaxPacketSize0 = USB_CONTROL_EP_MPS,                  \
                .idVendor = vid,                                        \
                .idProduct = pid,                                       \
                .bcdDevice = sys_cpu_to_le16(USB_BCD_DRN),              \
                .iManufacturer = 0,                                     \
                .iProduct = 0,                                          \
                .iSerialNumber = 0,                                     \
                .bNumConfigurations = 0,                                \
        };                                                              \
        static struct usb_device_descriptor                             \
        hs_desc_##device_name = {                                       \
                .bLength = sizeof(struct usb_device_descriptor),        \
                .bDescriptorType = USB_DESC_DEVICE,                     \
                .bcdUSB = sys_cpu_to_le16(USB_SRN_2_0),                 \
                .bDeviceClass = USB_BCC_MISCELLANEOUS,                  \
                .bDeviceSubClass = 2,                                   \
                .bDeviceProtocol = 1,                                   \
                .bMaxPacketSize0 = 64,                                  \
                .idVendor = vid,                                        \
                .idProduct = pid,                                       \
                .bcdDevice = sys_cpu_to_le16(USB_BCD_DRN),              \
                .iManufacturer = 0,                                     \
                .iProduct = 0,                                          \
                .iSerialNumber = 0,                                     \
                .bNumConfigurations = 0,                                \
        };                                                              \
        static STRUCT_SECTION_ITERABLE(usbd_contex, device_name) = {    \
                .name = STRINGIFY(device_name),                         \
                .dev = uhc_dev,                                         \
                .fs_desc = &fs_desc_##device_name,                      \
                .hs_desc = &hs_desc_##device_name,                      \
        }

◆ USBD_NUMOF_INTERFACES_MAX

#define USBD_NUMOF_INTERFACES_MAX 16U

#include <zephyr/usb/usbd.h>

◆ USBD_VENDOR_REQ

#define USBD_VENDOR_REQ ( _reqs... )

#include <zephyr/usb/usbd.h>

Value:

VENDOR_REQ_DEFINE(((uint8_t []) { _reqs }), \

sizeof((uint8_t []) { _reqs }))

VENDOR_REQ_DEFINE

#define VENDOR_REQ_DEFINE(_reqs, _len)

Helper to declare request table of usbd_cctx_vendor_req.

Definition: usbd.h:511

Helper to declare supported vendor requests.

Parameters

_reqs Variable number of vendor requests

◆ VENDOR_REQ_DEFINE

#define VENDOR_REQ_DEFINE	(	_reqs,
		_len
	)

#include <zephyr/usb/usbd.h>

Value:

        { \
                .reqs = (const uint8_t *)(_reqs), \
                .len = (_len), \
        }

Helper to declare request table of usbd_cctx_vendor_req.

Parameters

_reqs	Pointer to the vendor request field
_len	Number of supported vendor requests

Enumeration Type Documentation

◆ usbd_ch9_state

enum usbd_ch9_state

#include <zephyr/usb/usbd.h>

USB device support middle layer runtime state.

Part of USB device states without suspended and powered states, as it is better to track them separately.

Enumerator
USBD_STATE_DEFAULT
USBD_STATE_ADDRESS
USBD_STATE_CONFIGURED

◆ usbd_desc_usage_type

enum usbd_desc_usage_type

#include <zephyr/usb/usbd.h>

Enumerator
USBD_DUT_STRING_LANG
USBD_DUT_STRING_MANUFACTURER
USBD_DUT_STRING_PRODUCT
USBD_DUT_STRING_SERIAL_NUMBER
USBD_DUT_STRING_INTERFACE

◆ usbd_speed

enum usbd_speed

#include <zephyr/usb/usbd.h>

USB device speed.

Enumerator
USBD_SPEED_FS	Device supports or is connected to a full speed bus.
USBD_SPEED_HS	Device supports or is connected to a high speed bus
USBD_SPEED_SS	Device supports or is connected to a super speed bus.

Function Documentation

◆ usbd_add_configuration()

int usbd_add_configuration	(	struct usbd_contex *	uds_ctx,
		const enum usbd_speed	speed,
		struct usbd_config_node *	cd
	)

#include <zephyr/usb/usbd.h>

Add a USB device configuration.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	speed	Speed at which this configuration operates
[in]	cd	Pointer to USB configuration node

Returns: 0 on success, other values on fail.

◆ usbd_add_descriptor()

int usbd_add_descriptor	(	struct usbd_contex *	uds_ctx,
		struct usbd_desc_node *	dn
	)

#include <zephyr/usb/usbd.h>

Add common USB descriptor.

Add common descriptor like string or bos.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	dn	Pointer to USB descriptor node

Returns: 0 on success, other values on fail.

◆ usbd_bus_speed()

enum usbd_speed usbd_bus_speed ( const struct usbd_contex *const uds_ctx )

#include <zephyr/usb/usbd.h>

Get actual device speed.

Parameters

[in] uds_ctx Pointer to a device context

Returns: Actual device speed

◆ usbd_caps_speed()

enum usbd_speed usbd_caps_speed ( const struct usbd_contex *const uds_ctx )

#include <zephyr/usb/usbd.h>

Get highest speed supported by the controller.

Parameters

[in] uds_ctx Pointer to a device context

Returns: Highest supported speed

◆ usbd_class_get_ctx()

static struct usbd_contex * usbd_class_get_ctx ( const struct usbd_class_data *const c_data )

inlinestatic

#include <zephyr/usb/usbd.h>

Get the USB device runtime context under which the class is registered.

The class implementation must use this function and not access the members of the struct directly.

Parameters

[in] c_data Pointer to USB device class data

Returns: Pointer to USB device runtime context

◆ usbd_class_get_private()

static void * usbd_class_get_private ( const struct usbd_class_data *const c_data )

inlinestatic

#include <zephyr/usb/usbd.h>

Get class implementation private data.

The class implementation must use this function and not access the members of the struct directly.

Parameters

[in] c_data Pointer to USB device class data

Returns: Pointer to class implementation private data

◆ usbd_config_attrib_rwup()

int usbd_config_attrib_rwup	(	struct usbd_contex *const	uds_ctx,
		const enum usbd_speed	speed,
		const uint8_t	cfg,
		const bool	enable
	)

#include <zephyr/usb/usbd.h>

Setup USB device configuration attribute Remote Wakeup.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	speed	Configuration speed
[in]	cfg	Configuration number
[in]	enable	Sets attribute if true, clears it otherwise

Returns: 0 on success, other values on fail.

◆ usbd_config_attrib_self()

int usbd_config_attrib_self	(	struct usbd_contex *const	uds_ctx,
		const enum usbd_speed	speed,
		const uint8_t	cfg,
		const bool	enable
	)

#include <zephyr/usb/usbd.h>

Setup USB device configuration attribute Self-powered.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	speed	Configuration speed
[in]	cfg	Configuration number
[in]	enable	Sets attribute if true, clears it otherwise

Returns: 0 on success, other values on fail.

◆ usbd_config_maxpower()

int usbd_config_maxpower	(	struct usbd_contex *const	uds_ctx,
		const enum usbd_speed	speed,
		const uint8_t	cfg,
		const uint8_t	power
	)

#include <zephyr/usb/usbd.h>

Setup USB device configuration power consumption.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	speed	Configuration speed
[in]	cfg	Configuration number
[in]	power	Maximum power consumption value (bMaxPower)

Returns: 0 on success, other values on fail.

◆ usbd_device_set_bcd()

int usbd_device_set_bcd	(	struct usbd_contex *const	uds_ctx,
		const enum usbd_speed	speed,
		const uint16_t	bcd
	)

#include <zephyr/usb/usbd.h>

Set USB device descriptor value bcdUSB.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	speed	Speed for which the bcdUSB should be set
[in]	bcd	bcdUSB value

Returns: 0 on success, other values on fail.

◆ usbd_device_set_code_triple()

int usbd_device_set_code_triple	(	struct usbd_contex *const	uds_ctx,
		const enum usbd_speed	speed,
		const uint8_t	base_class,
		const uint8_t	subclass,
		const uint8_t	protocol
	)

#include <zephyr/usb/usbd.h>

Set USB device descriptor code triple Base Class, SubClass, and Protocol.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	speed	Speed for which the code triple should be set
[in]	base_class	bDeviceClass value
[in]	subclass	bDeviceSubClass value
[in]	protocol	bDeviceProtocol value

Returns: 0 on success, other values on fail.

◆ usbd_device_set_pid()

int usbd_device_set_pid	(	struct usbd_contex *const	uds_ctx,
		const uint16_t	pid
	)

#include <zephyr/usb/usbd.h>

Set USB device descriptor value idProduct.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	pid	idProduct value

Returns: 0 on success, other values on fail.

◆ usbd_device_set_vid()

int usbd_device_set_vid	(	struct usbd_contex *const	uds_ctx,
		const uint16_t	vid
	)

#include <zephyr/usb/usbd.h>

Set USB device descriptor value idVendor.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	vid	idVendor value

Returns: 0 on success, other values on fail.

◆ usbd_disable()

int usbd_disable ( struct usbd_contex * uds_ctx )

#include <zephyr/usb/usbd.h>

Disable the USB device support.

This function disables the USB device support.

Parameters

[in] uds_ctx Pointer to USB device support context

Returns: 0 on success, other values on fail.

◆ usbd_enable()

int usbd_enable ( struct usbd_contex * uds_ctx )

#include <zephyr/usb/usbd.h>

Enable the USB device support and registered class instances.

This function enables the USB device support.

Parameters

[in] uds_ctx Pointer to USB device support context

Returns: 0 on success, other values on fail.

◆ usbd_ep_buf_alloc()

struct net_buf * usbd_ep_buf_alloc	(	const struct usbd_class_data *const	c_data,
		const uint8_t	ep,
		const size_t	size
	)

#include <zephyr/usb/usbd.h>

Allocate buffer for USB device request.

Allocate a new buffer from controller's driver buffer pool.

Parameters

[in]	c_data	Pointer to USB device class data
[in]	ep	Endpoint address
[in]	size	Size of the request buffer

Returns: pointer to allocated request or NULL on error.

◆ usbd_ep_buf_free()

int usbd_ep_buf_free	(	struct usbd_contex *	uds_ctx,
		struct net_buf *	buf
	)

#include <zephyr/usb/usbd.h>

Free USB device request buffer.

Put the buffer back into the request buffer pool.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	buf	Pointer to UDC request buffer

Returns: 0 on success, all other values should be treated as error.

◆ usbd_ep_clear_halt()

int usbd_ep_clear_halt	(	struct usbd_contex *	uds_ctx,
		uint8_t	ep
	)

#include <zephyr/usb/usbd.h>

Clear endpoint halt.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	ep	Endpoint address

Returns: 0 on success, or error from udc_ep_clear_halt()

◆ usbd_ep_ctrl_buf_alloc()

struct net_buf * usbd_ep_ctrl_buf_alloc	(	struct usbd_contex *const	uds_ctx,
		const uint8_t	ep,
		const size_t	size
	)

#include <zephyr/usb/usbd.h>

Allocate buffer for USB device control request.

Allocate a new buffer from controller's driver buffer pool.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	ep	Endpoint address
[in]	size	Size of the request buffer

Returns: pointer to allocated request or NULL on error.

◆ usbd_ep_ctrl_enqueue()

int usbd_ep_ctrl_enqueue	(	struct usbd_contex *const	uds_ctx,
		struct net_buf *const	buf
	)

#include <zephyr/usb/usbd.h>

Queue USB device control request.

Add control request to the queue.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	buf	Pointer to UDC request buffer

Returns: 0 on success, all other values should be treated as error.

◆ usbd_ep_dequeue()

int usbd_ep_dequeue	(	struct usbd_contex *	uds_ctx,
		const uint8_t	ep
	)

#include <zephyr/usb/usbd.h>

Remove all USB device controller requests from endpoint queue.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	ep	Endpoint address

Returns: 0 on success, or error from udc_ep_dequeue()

◆ usbd_ep_enqueue()

int usbd_ep_enqueue	(	const struct usbd_class_data *const	c_data,
		struct net_buf *const	buf
	)

#include <zephyr/usb/usbd.h>

Queue USB device request.

Add request to the queue.

Parameters

[in]	c_data	Pointer to USB device class data
[in]	buf	Pointer to UDC request buffer

Returns: 0 on success, or error from udc_ep_enqueue()

◆ usbd_ep_is_halted()

bool usbd_ep_is_halted	(	struct usbd_contex *	uds_ctx,
		uint8_t	ep
	)

#include <zephyr/usb/usbd.h>

Checks whether the endpoint is halted.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	ep	Endpoint address

Returns: true if endpoint is halted, false otherwise

◆ usbd_ep_set_halt()

int usbd_ep_set_halt	(	struct usbd_contex *	uds_ctx,
		uint8_t	ep
	)

#include <zephyr/usb/usbd.h>

Halt endpoint.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	ep	Endpoint address

Returns: 0 on success, or error from udc_ep_set_halt()

◆ usbd_init()

int usbd_init ( struct usbd_contex * uds_ctx )

#include <zephyr/usb/usbd.h>

Initialize USB device.

Initialize USB device descriptors and configuration, initialize USB device controller. Class instances should be registered before they are involved. However, the stack should also initialize without registered instances, even if the host would complain about missing interfaces.

Parameters

[in] uds_ctx Pointer to USB device support context

Returns: 0 on success, other values on fail.

◆ usbd_is_suspended()

bool usbd_is_suspended ( struct usbd_contex * uds_ctx )

#include <zephyr/usb/usbd.h>

Checks whether the USB device controller is suspended.

Parameters

[in] uds_ctx Pointer to USB device support context

Returns: true if endpoint is halted, false otherwise

◆ usbd_msg_register_cb()

int usbd_msg_register_cb	(	struct usbd_contex *const	uds_ctx,
		const usbd_msg_cb_t	cb
	)

#include <zephyr/usb/usbd.h>

Register USB notification message callback.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	cb	Pointer to message callback function

Returns: 0 on success, other values on fail.

◆ usbd_register_class()

int usbd_register_class	(	struct usbd_contex *	uds_ctx,
		const char *	name,
		const enum usbd_speed	speed,
		uint8_t	cfg
	)

#include <zephyr/usb/usbd.h>

Register an USB class instance.

An USB class implementation can have one or more instances. To identify the instances we use device drivers API. Device names have a prefix derived from the name of the class, for example CDC_ACM for CDC ACM class instance, and can also be easily identified in the shell. Class instance can only be registered when the USB device stack is disabled. Registered instances are initialized at initialization of the USB device stack, and the interface descriptors of each instance are adapted to the whole context.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	name	Class instance name
[in]	speed	Configuration speed
[in]	cfg	Configuration value (similar to bConfigurationValue)

Returns: 0 on success, other values on fail.

◆ usbd_shutdown()

int usbd_shutdown ( struct usbd_contex *const uds_ctx )

#include <zephyr/usb/usbd.h>

Shutdown the USB device support.

This function completely disables the USB device support.

Parameters

[in] uds_ctx Pointer to USB device support context

Returns: 0 on success, other values on fail.

◆ usbd_unregister_class()

int usbd_unregister_class	(	struct usbd_contex *	uds_ctx,
		const char *	name,
		const enum usbd_speed	speed,
		uint8_t	cfg
	)

#include <zephyr/usb/usbd.h>

Unregister an USB class instance.

USB class instance will be removed and will not appear on the next start of the stack. Instance can only be unregistered when the USB device stack is disabled.

Parameters

[in]	uds_ctx	Pointer to USB device support context
[in]	name	Class instance name
[in]	speed	Configuration speed
[in]	cfg	Configuration value (similar to bConfigurationValue)

Returns: 0 on success, other values on fail.

◆ usbd_wakeup_request()

int usbd_wakeup_request ( struct usbd_contex * uds_ctx )

#include <zephyr/usb/usbd.h>

Initiate the USB remote wakeup (TBD)

Returns: 0 on success, other values on fail.

Data Structures

Macros

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ USB_BSTRING_LENGTH

◆ USB_STRING_DESCRIPTOR_LENGTH

◆ USBD_CCTX_REGISTERED

◆ USBD_CONFIGURATION_DEFINE

◆ USBD_DEFINE_CLASS

◆ USBD_DESC_LANG_DEFINE

◆ USBD_DESC_MANUFACTURER_DEFINE

◆ USBD_DESC_PRODUCT_DEFINE

◆ USBD_DESC_SERIAL_NUMBER_DEFINE

◆ USBD_DESC_STRING_DEFINE

◆ USBD_DEVICE_DEFINE

◆ USBD_NUMOF_INTERFACES_MAX

◆ USBD_VENDOR_REQ

◆ VENDOR_REQ_DEFINE

Enumeration Type Documentation

◆ usbd_ch9_state

◆ usbd_desc_usage_type

◆ usbd_speed

Function Documentation

◆ usbd_add_configuration()

◆ usbd_add_descriptor()

◆ usbd_bus_speed()

◆ usbd_caps_speed()

◆ usbd_class_get_ctx()

◆ usbd_class_get_private()

◆ usbd_config_attrib_rwup()

◆ usbd_config_attrib_self()

◆ usbd_config_maxpower()

◆ usbd_device_set_bcd()

◆ usbd_device_set_code_triple()

◆ usbd_device_set_pid()

◆ usbd_device_set_vid()

◆ usbd_disable()

◆ usbd_enable()

◆ usbd_ep_buf_alloc()

◆ usbd_ep_buf_free()

◆ usbd_ep_clear_halt()

◆ usbd_ep_ctrl_buf_alloc()

◆ usbd_ep_ctrl_enqueue()

◆ usbd_ep_dequeue()

◆ usbd_ep_enqueue()

◆ usbd_ep_is_halted()

◆ usbd_ep_set_halt()

◆ usbd_init()

◆ usbd_is_suspended()

◆ usbd_msg_register_cb()

◆ usbd_register_class()

◆ usbd_shutdown()

◆ usbd_unregister_class()

◆ usbd_wakeup_request()