usbdev.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Koen Zandberg <koen@bergzand.net>
 *
 * This file is subject to the terms and conditions of the GNU Lesser General
 * Public License v2.1. See the file LICENSE in the top level directory for
 * more details.
 */
 
#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