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/drivers/usb/usb_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 high_bandwidth : 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);
        void (*lock)(const struct device *dev);
        void (*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;
        const void *event_ctx;
        atomic_t status;
        void *priv;
        uint8_t setup[8];
        bool setup_pending;
        bool setup_valid;
};


static inline bool udc_is_initialized(const struct device *dev)
{
        struct udc_data *data = (struct udc_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 = (struct udc_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 = (struct udc_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, const void *const event_ctx);

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 = (struct udc_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 = (const struct udc_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 = (const struct udc_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 = (const struct udc_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_purge_queues(const struct device *dev);

bool udc_ep_queue_is_empty(const struct device *dev, const uint8_t ep);

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);

struct net_buf *udc_ctrl_setup_alloc(const struct device *dev);

struct net_buf *udc_ctrl_data_alloc(const struct device *dev,
                                    const uint8_t ep,
                                    const size_t size);

struct net_buf *udc_ctrl_status_alloc(const struct device *dev,
                                      const uint8_t ep);

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);
}
 

static inline const void *udc_get_event_ctx(const struct device *dev)
{
        struct udc_data *data = (struct udc_data *)dev->data;
 
        return data->event_ctx;
}

static inline uint16_t udc_mps_ep_size(const struct udc_ep_config *const cfg)
{
        return USB_MPS_EP_SIZE(cfg->mps);
}

 
#endif /* ZEPHYR_INCLUDE_UDC_H */