udc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2022 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_UDC_H
#define ZEPHYR_INCLUDE_UDC_H
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/net/buf.h>
#include <zephyr/sys/atomic.h>
#include <zephyr/usb/usb_ch9.h>
 
enum udc_mps0 {
 UDC_MPS0_8,
 UDC_MPS0_16,
 UDC_MPS0_32,
 UDC_MPS0_64,
};
 
struct udc_device_caps {
 uint32_t hs : 1;
 uint32_t rwup : 1;
 uint32_t out_ack : 1;
 uint32_t addr_before_status : 1;
 uint32_t can_detect_vbus : 1;
 enum udc_mps0 mps0 : 2;
};
 
enum udc_bus_speed {
 UDC_BUS_UNKNOWN,
 UDC_BUS_SPEED_FS,
 UDC_BUS_SPEED_HS,
 UDC_BUS_SPEED_SS,
};
 
struct udc_ep_caps {
 uint32_t mps : 16;
 uint32_t control : 1;
 uint32_t interrupt : 1;
 uint32_t bulk : 1;
 uint32_t iso : 1;
 uint32_t in : 1;
 uint32_t out : 1;
};
 
struct udc_ep_stat {
 uint32_t enabled : 1;
 uint32_t halted : 1;
 uint32_t data1 : 1;
 uint32_t odd : 1;
 uint32_t busy : 1;
};
 
struct udc_ep_config {
 struct k_fifo fifo;
 struct udc_ep_caps caps;
 struct udc_ep_stat stat;
 uint8_t addr;
 uint8_t attributes;
 uint16_t mps;
 uint8_t interval;
};
 
 
enum udc_event_type {
 UDC_EVT_VBUS_READY,
 UDC_EVT_VBUS_REMOVED,
 UDC_EVT_RESUME,
 UDC_EVT_SUSPEND,
 UDC_EVT_RESET,
 UDC_EVT_SOF,
 UDC_EVT_EP_REQUEST,
 UDC_EVT_ERROR,
};
 
struct udc_event {
 enum udc_event_type type;
 union {
 uint32_t value;
 int status;
 struct net_buf *buf;
 };
 const struct device *dev;
};
 
struct udc_buf_info {
 uint8_t ep;
 unsigned int setup : 1;
 unsigned int data : 1;
 unsigned int status : 1;
 unsigned int zlp : 1;
 unsigned int claimed : 1;
 unsigned int queued : 1;
 void *owner;
 int err;
} __packed;
 
typedef int (*udc_event_cb_t)(const struct device *dev,
 const struct udc_event *const event);
 
struct udc_api {
 enum udc_bus_speed (*device_speed)(const struct device *dev);
 int (*ep_enqueue)(const struct device *dev,
 struct udc_ep_config *const cfg,
 struct net_buf *const buf);
 int (*ep_dequeue)(const struct device *dev,
 struct udc_ep_config *const cfg);
 int (*ep_set_halt)(const struct device *dev,
 struct udc_ep_config *const cfg);
 int (*ep_clear_halt)(const struct device *dev,
 struct udc_ep_config *const cfg);
 int (*ep_try_config)(const struct device *dev,
 struct udc_ep_config *const cfg);
 int (*ep_enable)(const struct device *dev,
 struct udc_ep_config *const cfg);
 int (*ep_disable)(const struct device *dev,
 struct udc_ep_config *const cfg);
 int (*host_wakeup)(const struct device *dev);
 int (*set_address)(const struct device *dev,
 const uint8_t addr);
 int (*test_mode)(const struct device *dev,
 const uint8_t mode, const bool dryrun);
 int (*enable)(const struct device *dev);
 int (*disable)(const struct device *dev);
 int (*init)(const struct device *dev);
 int (*shutdown)(const struct device *dev);
 int (*lock)(const struct device *dev);
 int (*unlock)(const struct device *dev);
};
 
#define UDC_STATUS_INITIALIZED 0
#define UDC_STATUS_ENABLED 1
#define UDC_STATUS_SUSPENDED 2
 
struct udc_data {
 struct udc_ep_config *ep_lut[32];
 struct udc_device_caps caps;
 struct k_mutex mutex;
 udc_event_cb_t event_cb;
 atomic_t status;
 int stage;
 struct net_buf *setup;
 void *priv;
};
 
static inline bool udc_is_initialized(const struct device *dev)
{
 struct udc_data *data = dev->data;
 
 return atomic_test_bit(&data->status, UDC_STATUS_INITIALIZED);
}
 
static inline bool udc_is_enabled(const struct device *dev)
{
 struct udc_data *data = dev->data;
 
 return atomic_test_bit(&data->status, UDC_STATUS_ENABLED);
}
 
static inline bool udc_is_suspended(const struct device *dev)
{
 struct udc_data *data = dev->data;
 
 return atomic_test_bit(&data->status, UDC_STATUS_SUSPENDED);
}
 
int udc_init(const struct device *dev, udc_event_cb_t event_cb);
 
int udc_enable(const struct device *dev);
 
int udc_disable(const struct device *dev);
 
int udc_shutdown(const struct device *dev);
 
static inline struct udc_device_caps udc_caps(const struct device *dev)
{
 struct udc_data *data = dev->data;
 
 return data->caps;
}
 
enum udc_bus_speed udc_device_speed(const struct device *dev);
 
static inline int udc_set_address(const struct device *dev, const uint8_t addr)
{
 const struct udc_api *api = dev->api;
 int ret;
 
 if (!udc_is_enabled(dev)) {
 return -EPERM;
 }
 
 api->lock(dev);
 ret = api->set_address(dev, addr);
 api->unlock(dev);
 
 return ret;
}
 
static inline int udc_test_mode(const struct device *dev,
 const uint8_t mode, const bool dryrun)
{
 const struct udc_api *api = dev->api;
 int ret;
 
 if (!udc_is_enabled(dev)) {
 return -EPERM;
 }
 
 if (api->test_mode != NULL) {
 api->lock(dev);
 ret = api->test_mode(dev, mode, dryrun);
 api->unlock(dev);
 } else {
 ret = -ENOTSUP;
 }
 
 return ret;
}
 
static inline int udc_host_wakeup(const struct device *dev)
{
 const struct udc_api *api = dev->api;
 int ret;
 
 if (!udc_is_enabled(dev)) {
 return -EPERM;
 }
 
 api->lock(dev);
 ret = api->host_wakeup(dev);
 api->unlock(dev);
 
 return ret;
}
 
int udc_ep_try_config(const struct device *dev,
 const uint8_t ep,
 const uint8_t attributes,
 uint16_t *const mps,
 const uint8_t interval);
 
int udc_ep_enable(const struct device *dev,
 const uint8_t ep,
 const uint8_t attributes,
 const uint16_t mps,
 const uint8_t interval);
 
int udc_ep_disable(const struct device *dev, const uint8_t ep);
 
int udc_ep_set_halt(const struct device *dev, const uint8_t ep);
 
int udc_ep_clear_halt(const struct device *dev, const uint8_t ep);
 
int udc_ep_enqueue(const struct device *dev, struct net_buf *const buf);
 
int udc_ep_dequeue(const struct device *dev, const uint8_t ep);
 
struct net_buf *udc_ep_buf_alloc(const struct device *dev,
 const uint8_t ep,
 const size_t size);
 
int udc_ep_buf_free(const struct device *dev, struct net_buf *const buf);
 
static inline void udc_ep_buf_set_zlp(struct net_buf *const buf)
{
 struct udc_buf_info *bi;
 
 __ASSERT_NO_MSG(buf);
 bi = (struct udc_buf_info *)net_buf_user_data(buf);
 if (USB_EP_DIR_IS_IN(bi->ep)) {
 bi->zlp = 1;
 }
}
 
static inline struct udc_buf_info *udc_get_buf_info(const struct net_buf *const buf)
{
 __ASSERT_NO_MSG(buf);
 return (struct udc_buf_info *)net_buf_user_data(buf);
}
 
#endif /* ZEPHYR_INCLUDE_UDC_H */