uhc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_UHC_H
#define ZEPHYR_INCLUDE_UHC_H
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/net_buf.h>
#include <zephyr/drivers/usb/usb_buf.h>
#include <zephyr/usb/usb_ch9.h>
#include <zephyr/sys/dlist.h>
#include <zephyr/sys/ref.h>


enum usb_device_state {
        USB_STATE_NOTCONNECTED,
        USB_STATE_DEFAULT,
        USB_STATE_ADDRESSED,
        USB_STATE_CONFIGURED,
};

enum usb_device_speed {
        USB_SPEED_UNKNOWN,
        USB_SPEED_SPEED_LS,
        USB_SPEED_SPEED_FS,
        USB_SPEED_SPEED_HS,
        USB_SPEED_SPEED_SS,
};
 
#define UHC_INTERFACES_MAX 32
 
struct usb_host_interface {
        struct usb_desc_header *dhp;
        struct usb_association_descriptor *iad;
        uint8_t alternate;
};
 
struct usb_host_ep {
        struct usb_ep_descriptor *desc;
};

struct usb_device {
        sys_dnode_t node;
        void *ctx;
        struct k_mutex mutex;
        struct usb_device_descriptor dev_desc;
        enum usb_device_state state;
        enum usb_device_speed speed;
        uint8_t actual_cfg;
        uint8_t addr;
        void *cfg_desc;
        struct usb_host_interface ifaces[UHC_INTERFACES_MAX + 1];
        struct usb_host_ep ep_out[16];
        struct usb_host_ep ep_in[16];
        struct usb_device *hub;
        uint16_t tt;
        uint8_t hub_port;
        uint8_t level;
};

enum uhc_control_stage {
        UHC_CONTROL_STAGE_SETUP = 0,
        UHC_CONTROL_STAGE_DATA,
        UHC_CONTROL_STAGE_STATUS,
};

struct uhc_transfer {
        sys_dnode_t node;
        struct sys_ref ref;
        __aligned(USB_BUF_ALIGN) uint8_t setup_pkt[USB_BUF_ROUND_UP(8)];
        struct net_buf *buf;
        uint8_t ep;
        uint8_t type;
        uint16_t mps;
        uint16_t interval;
        uint16_t start_frame;
        unsigned int queued : 1;
        unsigned int stage : 2;
        unsigned int no_status : 1;
        struct usb_device *udev;
        void *cb;
        void *priv;
        int err;
};

enum uhc_event_type {
        UHC_EVT_DEV_CONNECTED_LS,
        UHC_EVT_DEV_CONNECTED_FS,
        UHC_EVT_DEV_CONNECTED_HS,
        UHC_EVT_DEV_REMOVED,
        UHC_EVT_RESETED,
        UHC_EVT_SUSPENDED,
        UHC_EVT_RESUMED,
        UHC_EVT_RWUP,
        UHC_EVT_EP_REQUEST,
        UHC_EVT_ERROR,
};

struct uhc_event {
        sys_snode_t node;
        enum uhc_event_type type;
        union {
                int status;
                struct uhc_transfer *xfer;
        };
        const struct device *dev;
};

typedef int (*uhc_event_cb_t)(const struct device *dev,
                              const struct uhc_event *const event);

struct uhc_device_caps {
        uint32_t hs : 1;
};

#define UHC_STATUS_INITIALIZED          0
#define UHC_STATUS_ENABLED              1

struct uhc_data {
        struct uhc_device_caps caps;
        struct k_mutex mutex;
        sys_dlist_t ctrl_xfers;
        sys_dlist_t bulk_xfers;
        uhc_event_cb_t event_cb;
        const void *event_ctx;
        atomic_t status;
        void *priv;
};

static inline bool uhc_is_initialized(const struct device *dev)
{
        struct uhc_data *data = dev->data;
 
        return atomic_test_bit(&data->status, UHC_STATUS_INITIALIZED);
}

static inline bool uhc_is_enabled(const struct device *dev)
{
        struct uhc_data *data = dev->data;
 
        return atomic_test_bit(&data->status, UHC_STATUS_ENABLED);
}

__subsystem struct uhc_driver_api {
        int (*lock)(const struct device *dev);
        int (*unlock)(const struct device *dev);
 
        int (*init)(const struct device *dev);
        int (*enable)(const struct device *dev);
        int (*disable)(const struct device *dev);
        int (*shutdown)(const struct device *dev);
 
        int (*bus_reset)(const struct device *dev);
        int (*sof_enable)(const struct device *dev);
        int (*bus_suspend)(const struct device *dev);
        int (*bus_resume)(const struct device *dev);
 
        int (*ep_enqueue)(const struct device *dev,
                          struct uhc_transfer *const xfer);
        int (*ep_dequeue)(const struct device *dev,
                          struct uhc_transfer *const xfer);
};

static inline int uhc_bus_reset(const struct device *dev)
{
        const struct uhc_driver_api *api = DEVICE_API_GET(uhc, dev);
        int ret;
 
        api->lock(dev);
        ret = api->bus_reset(dev);
        api->unlock(dev);
 
        return ret;
}

static inline int uhc_sof_enable(const struct device *dev)
{
        const struct uhc_driver_api *api = DEVICE_API_GET(uhc, dev);
        int ret;
 
        api->lock(dev);
        ret = api->sof_enable(dev);
        api->unlock(dev);
 
        return ret;
}

static inline int uhc_bus_suspend(const struct device *dev)
{
        const struct uhc_driver_api *api = DEVICE_API_GET(uhc, dev);
        int ret;
 
        api->lock(dev);
        ret = api->bus_suspend(dev);
        api->unlock(dev);
 
        return ret;
}

static inline int uhc_bus_resume(const struct device *dev)
{
        const struct uhc_driver_api *api = DEVICE_API_GET(uhc, dev);
        int ret;
 
        api->lock(dev);
        ret = api->bus_resume(dev);
        api->unlock(dev);
 
        return ret;
}

struct uhc_transfer *uhc_xfer_alloc(const struct device *dev,
                                    const uint8_t ep,
                                    struct usb_device *const udev,
                                    void *const cb,
                                    void *const cb_priv);

struct uhc_transfer *uhc_xfer_alloc_with_buf(const struct device *dev,
                                             const uint8_t ep,
                                             struct usb_device *const udev,
                                             void *const cb,
                                             void *const cb_priv,
                                             size_t size);

void uhc_xfer_ref(struct uhc_transfer *const xfer);

bool uhc_xfer_unref(struct uhc_transfer *const xfer);

int uhc_xfer_free(const struct device *dev,
                  struct uhc_transfer *const xfer);

int uhc_xfer_buf_add(const struct device *dev,
                     struct uhc_transfer *const xfer,
                     struct net_buf *buf);
struct net_buf *uhc_xfer_buf_alloc(const struct device *dev,
                                   const size_t size);

void uhc_xfer_buf_free(const struct device *dev, struct net_buf *const buf);

int uhc_ep_enqueue(const struct device *dev, struct uhc_transfer *const xfer);

int uhc_ep_dequeue(const struct device *dev, struct uhc_transfer *const xfer);

int uhc_init(const struct device *dev,
             uhc_event_cb_t event_cb, const void *const event_ctx);

int uhc_enable(const struct device *dev);

int uhc_disable(const struct device *dev);

int uhc_shutdown(const struct device *dev);

static inline struct uhc_device_caps uhc_caps(const struct device *dev)
{
        struct uhc_data *data = dev->data;
 
        return data->caps;
}

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

 
#endif /* ZEPHYR_INCLUDE_UHC_H */