usb.h

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0+ */
 
#ifndef __USB_H__
#define __USB_H__
 
#include "reg/reg-usb.h"
 
/*
 * Descriptor types
 */
#define USB_DT_DEVICE 0x01
#define USB_DT_CONFIG 0x02
#define USB_DT_STRING 0x03
#define USB_DT_INTERFACE 0x04
#define USB_DT_ENDPOINT 0x05
#define USB_DT_DEVICE_QUALIFIER 0x06
 
#define USB_DT_HID (USB_TYPE_CLASS | 0x01)
#define USB_DT_REPORT (USB_TYPE_CLASS | 0x02)
#define USB_DT_PHYSICAL (USB_TYPE_CLASS | 0x03)
#define USB_DT_HUB (USB_TYPE_CLASS | 0x09)
 
/*
 * Descriptor sizes per descriptor type
 */
#define USB_DT_DEVICE_SIZE 18
#define USB_DT_CONFIG_SIZE 9
#define USB_DT_INTERFACE_SIZE 9
#define USB_DT_ENDPOINT_SIZE 7
#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
#define USB_DT_HUB_NONVAR_SIZE 7
#define USB_DT_HID_SIZE 9
 
enum usb_device_speed {
    USB_SPEED_LOW,
    USB_SPEED_FULL, /* usb 1.1 */
    USB_SPEED_HIGH, /* usb 2.0 */
    USB_SPEED_RESERVED
};
 
/*
 * standard usb descriptor structures
 */
struct usb_endpoint_descriptor {
    uint8_t bLength;
    uint8_t bDescriptorType; /* 0x5 */
    uint8_t bEndpointAddress;
    uint8_t bmAttributes;
    uint16_t wMaxPacketSize;
    uint8_t bInterval;
} __attribute__((packed));
 
struct usb_interface_descriptor {
    uint8_t bLength;
    uint8_t bDescriptorType; /* 0x04 */
    uint8_t bInterfaceNumber;
    uint8_t bAlternateSetting;
    uint8_t bNumEndpoints;
    uint8_t bInterfaceClass;
    uint8_t bInterfaceSubClass;
    uint8_t bInterfaceProtocol;
    uint8_t iInterface;
} __attribute__((packed));
 
struct usb_configuration_descriptor {
    uint8_t bLength;
    uint8_t bDescriptorType; /* 0x2 */
    uint16_t wTotalLength;
    uint8_t bNumInterfaces;
    uint8_t bConfigurationValue;
    uint8_t iConfiguration;
    uint8_t bmAttributes;
    uint8_t bMaxPower;
} __attribute__((packed));
 
struct usb_device_descriptor {
    uint8_t bLength;
    uint8_t bDescriptorType; /* 0x01 */
    uint16_t bcdUSB;
    uint8_t bDeviceClass;
    uint8_t bDeviceSubClass;
    uint8_t bDeviceProtocol;
    uint8_t bMaxPacketSize0;
    uint16_t idVendor;
    uint16_t idProduct;
    uint16_t bcdDevice;
    uint8_t iManufacturer;
    uint8_t iProduct;
    uint8_t iSerialNumber;
    uint8_t bNumConfigurations;
} __attribute__((packed));
 
struct usb_qualifier_descriptor {
    uint8_t bLength;
    uint8_t bDescriptorType;
 
    uint16_t bcdUSB;
    uint8_t bDeviceClass;
    uint8_t bDeviceSubClass;
    uint8_t bDeviceProtocol;
    uint8_t bMaxPacketSize0;
    uint8_t bNumConfigurations;
    uint8_t breserved;
} __attribute__((packed));
 
struct usb_string_descriptor {
    uint8_t bLength;
    uint8_t bDescriptorType; /* 0x03 */
    uint16_t wData[0];
} __attribute__((packed));
 
struct usb_generic_descriptor {
    uint8_t bLength;
    uint8_t bDescriptorType;
    uint8_t bDescriptorSubtype;
} __attribute__((packed));
 
struct usb_device_request {
    uint8_t request_type;
    uint8_t request;
    uint16_t value;
    uint16_t index;
    uint16_t length;
} __attribute__((packed));
 
typedef struct sunxi_udc {
    uint64_t usbc_hd;
    uint32_t address;     /* device address, allocated by the host */
    uint32_t speed;       /* flag: is it high speed? */
    uint32_t bulk_ep_max; /* maximum packet size for bulk endpoints */
    uint32_t fifo_size;   /* size of the FIFO */
    uint32_t bulk_in_addr;
    uint32_t bulk_out_addr;
    uint32_t dma_send_channal;
    uint32_t dma_recv_channal;
    struct usb_device_request standard_reg;
} sunxi_udc_t;
 
typedef struct sunxi_ubuf {
    uint8_t *rx_base_buffer;    /* base address for bulk transfer */
    uint8_t *rx_req_buffer;     /* buffer for the request phase of bulk transfer */
    uint32_t rx_req_length;     /* length of data in the request phase of bulk transfer */
    uint32_t rx_ready_for_data; /* flag indicating completion of data reception */
    uint32_t request_size;      /* size of the data to be sent */
} sunxi_ubuf_t;
 
typedef struct sunxi_usb_setup_req_s {
    int (*state_init)(void);
    int (*state_exit)(void);
    void (*state_reset)(void);
    int (*standard_req_op)(uint32_t cmd, struct usb_device_request *req, uint8_t *buffer);
    int (*nonstandard_req_op)(uint32_t cmd, struct usb_device_request *req, uint8_t *buffer, uint32_t data_status);
    int (*state_loop)(void *sunxi_udc);
    void (*dma_rx_isr)(void *p_arg);
    void (*dma_tx_isr)(void *p_arg);
} sunxi_usb_setup_req_t;
 
#define SUNXI_USB_DEVICE_DETECT (1)
#define SUNXI_USB_DEVICE_MASS (2)
 
#define sunxi_usb_module_init(name, state_init, state_exit, state_reset, standard_req_op, nonstandard_req_op, state_loop, dma_rx_isr, dma_tx_isr) \
    sunxi_usb_setup_req_t setup_req_##name = {state_init, state_exit, state_reset, standard_req_op, nonstandard_req_op, state_loop, dma_rx_isr, dma_tx_isr};
 
#define sunxi_usb_module_reg(name) sunxi_udev_active = &setup_req_##name
 
#define sunxi_usb_module_ext(name) extern sunxi_usb_setup_req_t setup_req_##name
 
/* export usb module */
sunxi_usb_module_ext(SUNXI_USB_DEVICE_DETECT);
sunxi_usb_module_ext(SUNXI_USB_DEVICE_MASS);
 
/* USB IO Wrzpper */
#define usb_get_bit8(bp, reg) (read8(reg) & (1 << (bp)))
#define usb_get_bit16(bp, reg) (read16(reg) & (1 << (bp)))
#define usb_get_bit32(bp, reg) (read32(reg) & (1 << (bp)))
 
#define usb_set_bit8(bp, reg) (write8((reg), (read8(reg) | (1 << (bp)))))
#define usb_set_bit16(bp, reg) (write16((reg), (read16(reg) | (1 << (bp)))))
#define usb_set_bit32(bp, reg) (write32((reg), (read32(reg) | (1 << (bp)))))
 
#define usb_clear_bit8(bp, reg) (write8((reg), (read8(reg) & (~(1 << (bp))))))
#define usb_clear_bit16(bp, reg) (write16((reg), (read16(reg) & (~(1 << (bp))))))
#define usb_clear_bit32(bp, reg) (write32((reg), (read32(reg) & (~(1 << (bp))))))
 
/* Error Codes */
#define SUNXI_USB_REQ_SUCCESSED (0)
#define SUNXI_USB_REQ_DEVICE_NOT_SUPPORTED (-1)
#define SUNXI_USB_REQ_UNKNOWN_COMMAND (-2)
#define SUNXI_USB_REQ_UNMATCHED_COMMAND (-3)
#define SUNXI_USB_REQ_DATA_HUNGRY (-4)
#define SUNXI_USB_REQ_OP_ERR (-5)
 
void sunxi_usb_attach_module(uint32_t device_type);
 
int sunxi_usb_init();
 
void sunxi_usb_dump(uint32_t usbc_base, uint32_t ep_index);
 
void sunxi_usb_ep_reset();
 
void sunxi_usb_irq();
 
void sunxi_usb_attach();
 
int sunxi_usb_extern_loop();
 
void sunxi_usb_bulk_ep_reset();
 
int sunxi_usb_start_recv_by_dma(void *mem_base, uint32_t length);
 
void sunxi_usb_send_setup(uint32_t length, void *buffer);
 
int sunxi_usb_set_address(uint32_t address);
 
int sunxi_usb_send_data(void *buffer, uint32_t buffer_size);
 
int sunxi_usb_get_ep_max(void);
 
int sunxi_usb_get_ep_in_type(void);
 
int sunxi_usb_get_ep_out_type(void);
 
#endif// __USB_H__