usbdev.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2018 Koen Zandberg <koen@bergzand.net>
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
 
#include "assert.h"
#include "periph_conf.h"
#include "usb.h"
#include "usb/usbopt.h"
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct usbdev usbdev_t;

typedef struct usbdev_ep usbdev_ep_t;

#ifndef USBDEV_CPU_DMA_REQUIREMENTS
#define USBDEV_CPU_DMA_REQUIREMENTS
#endif

#define usbdev_ep_buf_t USBDEV_CPU_DMA_REQUIREMENTS uint8_t

#ifndef USBDEV_CPU_SET_ADDR_AFTER_STATUS
#define USBDEV_CPU_SET_ADDR_AFTER_STATUS    1
#endif

#ifndef USBDEV_NUM_ENDPOINTS
#define USBDEV_NUM_ENDPOINTS       8
#endif

typedef enum {
    USBDEV_EVENT_ESR = 1,

    USBDEV_EVENT_HOST_CONNECT,

    USBDEV_EVENT_HOST_DISCONNECT,

    USBDEV_EVENT_RESET,

    USBDEV_EVENT_SOF,

    USBDEV_EVENT_SUSPEND,

    USBDEV_EVENT_RESUME,

    USBDEV_EVENT_TR_COMPLETE,

    USBDEV_EVENT_TR_STALL,
 
    /* expand list if required */
} usbdev_event_t;

typedef void (*usbdev_event_cb_t)(usbdev_t *usbdev, usbdev_event_t event);

typedef void (*usbdev_ep_event_cb_t)(usbdev_ep_t *ep,
                                     usbdev_event_t event);

struct usbdev {
    const struct usbdev_driver *driver; 
    usbdev_event_cb_t cb;               
    usbdev_ep_event_cb_t epcb;          
    void *context;                      
};

struct usbdev_ep {
    usbdev_t *dev;      
    size_t len;         
    usb_ep_dir_t dir;   
    usb_ep_type_t type; 
    uint8_t num;        
};

typedef struct usbdev_driver {

    void (*init)(usbdev_t *usbdev);

    usbdev_ep_t *(*new_ep)(usbdev_t *dev, usb_ep_type_t type, usb_ep_dir_t dir, size_t size);

    int (*get)(usbdev_t *usbdev, usbopt_t opt,
               void *value, size_t max_len);

    int (*set)(usbdev_t *usbdev, usbopt_t opt,
               const void *value, size_t value_len);

    void (*esr)(usbdev_t *dev);

    void (*ep0_stall)(usbdev_t *usbdev);

    void (*ep_init)(usbdev_ep_t *ep);

    void (*ep_stall)(usbdev_ep_t *ep, bool enable);

    int (*ep_get)(usbdev_ep_t *ep, usbopt_ep_t opt,
               void *value, size_t max_len);

    int (*ep_set)(usbdev_ep_t *ep, usbopt_ep_t opt,
               const void *value, size_t value_len);

    void (*ep_esr)(usbdev_ep_t *ep);

    int (*xmit)(usbdev_ep_t *ep, uint8_t *buf, size_t len);
} usbdev_driver_t;

void usbdev_init_lowlevel(void);

usbdev_t *usbdev_get_ctx(unsigned num);

static inline void usbdev_init(usbdev_t *dev)
{
    assert(dev);
    dev->driver->init(dev);
}

static inline usbdev_ep_t * usbdev_new_ep(usbdev_t *dev, usb_ep_type_t type,
                                          usb_ep_dir_t dir, size_t size)
{
    assert(dev);
    return dev->driver->new_ep(dev, type, dir, size);
}

static inline int usbdev_get(usbdev_t *dev, usbopt_t opt,
                             void *value, size_t max_len)
{
    assert(dev);
    return dev->driver->get(dev, opt, value, max_len);
}

static inline int usbdev_set(usbdev_t *dev, usbopt_t opt,
                             const void *value, size_t value_len)
{
    assert(dev);
    return dev->driver->set(dev, opt, value, value_len);
}

static inline void usbdev_esr(usbdev_t *dev)
{
    assert(dev);
    dev->driver->esr(dev);
}

static inline void usbdev_ep0_stall(usbdev_t *dev)
{
    assert(dev);
    dev->driver->ep0_stall(dev);
}

static inline void usbdev_ep_init(usbdev_ep_t *ep)
{
    assert(ep);
    assert(ep->dev);
    ep->dev->driver->ep_init(ep);
}

static inline void usbdev_ep_stall(usbdev_ep_t *ep, bool enable)
{
    assert(ep);
    assert(ep->dev);
    ep->dev->driver->ep_stall(ep, enable);
}

static inline int usbdev_ep_get(usbdev_ep_t *ep, usbopt_ep_t opt,
                                void *value, size_t max_len)
{
    assert(ep);
    assert(ep->dev);
    return ep->dev->driver->ep_get(ep, opt, value, max_len);
}

static inline int usbdev_ep_set(usbdev_ep_t *ep, usbopt_ep_t opt,
                                const void *value, size_t value_len)
{
    assert(ep);
    assert(ep->dev);
    return ep->dev->driver->ep_set(ep, opt, value, value_len);
}

static inline void usbdev_ep_esr(usbdev_ep_t *ep)
{
    assert(ep);
    assert(ep->dev);
    ep->dev->driver->ep_esr(ep);
}

static inline int usbdev_ep_xmit(usbdev_ep_t *ep, uint8_t *buf, size_t len)
{
    assert(ep);
    assert(ep->dev);
    return ep->dev->driver->xmit(ep, buf, len);
}
 
#ifdef __cplusplus
}
#endif