Subversion Repositories freemyipod

#ifndef __PROTOCOL_USB_USB_H__
#define __PROTOCOL_USB_USB_H__

#include "../global.h"

#ifndef IN_APPLICATION_CODE
#if   USB_ENDPOINTS & 0b00000000000000000000000000000010
#define USBDEBUG_ENDPOINT_OUT 1
#elif USB_ENDPOINTS & 0b00000000000000000000000000000100
#define USBDEBUG_ENDPOINT_OUT 2
#elif USB_ENDPOINTS & 0b00000000000000000000000000001000
#define USBDEBUG_ENDPOINT_OUT 3
#elif USB_ENDPOINTS & 0b00000000000000000000000000010000
#define USBDEBUG_ENDPOINT_OUT 4
#elif USB_ENDPOINTS & 0b00000000000000000000000000100000
#define USBDEBUG_ENDPOINT_OUT 5
#elif USB_ENDPOINTS & 0b00000000000000000000000001000000
#define USBDEBUG_ENDPOINT_OUT 6
#elif USB_ENDPOINTS & 0b00000000000000000000000010000000
#define USBDEBUG_ENDPOINT_OUT 7
#elif USB_ENDPOINTS & 0b00000000000000000000000100000000
#define USBDEBUG_ENDPOINT_OUT 8
#elif USB_ENDPOINTS & 0b00000000000000000000001000000000
#define USBDEBUG_ENDPOINT_OUT 9
#elif USB_ENDPOINTS & 0b00000000000000000000010000000000
#define USBDEBUG_ENDPOINT_OUT 10
#elif USB_ENDPOINTS & 0b00000000000000000000100000000000
#define USBDEBUG_ENDPOINT_OUT 11
#elif USB_ENDPOINTS & 0b00000000000000000001000000000000
#define USBDEBUG_ENDPOINT_OUT 12
#elif USB_ENDPOINTS & 0b00000000000000000010000000000000
#define USBDEBUG_ENDPOINT_OUT 13
#elif USB_ENDPOINTS & 0b00000000000000000100000000000000
#define USBDEBUG_ENDPOINT_OUT 14
#elif USB_ENDPOINTS & 0b00000000000000001000000000000000
#define USBDEBUG_ENDPOINT_OUT 15
#else
#error USBDEBUG: No OUT endpoints available!
#endif
#if   USB_ENDPOINTS & 0b00000000000000100000000000000000
#define USBDEBUG_ENDPOINT_IN 1
#elif USB_ENDPOINTS & 0b00000000000001000000000000000000
#define USBDEBUG_ENDPOINT_IN 2
#elif USB_ENDPOINTS & 0b00000000000010000000000000000000
#define USBDEBUG_ENDPOINT_IN 3
#elif USB_ENDPOINTS & 0b00000000000100000000000000000000
#define USBDEBUG_ENDPOINT_IN 4
#elif USB_ENDPOINTS & 0b00000000001000000000000000000000
#define USBDEBUG_ENDPOINT_IN 5
#elif USB_ENDPOINTS & 0b00000000010000000000000000000000
#define USBDEBUG_ENDPOINT_IN 6
#elif USB_ENDPOINTS & 0b00000000100000000000000000000000
#define USBDEBUG_ENDPOINT_IN 7
#elif USB_ENDPOINTS & 0b00000001000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 8
#elif USB_ENDPOINTS & 0b00000010000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 9
#elif USB_ENDPOINTS & 0b00000100000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 10
#elif USB_ENDPOINTS & 0b00001000000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 11
#elif USB_ENDPOINTS & 0b00010000000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 12
#elif USB_ENDPOINTS & 0b00100000000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 13
#elif USB_ENDPOINTS & 0b01000000000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 14
#elif USB_ENDPOINTS & 0b10000000000000000000000000000000
#define USBDEBUG_ENDPOINT_IN 15
#else
#error USBDEBUG: No IN endpoints available!
#endif
#endif

struct usb_instance;

union __attribute__((packed,aligned(4))) usb_ep0_buffer
{
    struct __attribute__((packed,aligned(4)))
    {
        struct __attribute__((packed))
        {
            enum
            {
                USB_SETUP_BMREQUESTTYPE_RECIPIENT_DEVICE = 0,
                USB_SETUP_BMREQUESTTYPE_RECIPIENT_INTERFACE = 1,
                USB_SETUP_BMREQUESTTYPE_RECIPIENT_ENDPOINT = 2,
                USB_SETUP_BMREQUESTTYPE_RECIPIENT_OTHER = 3,
            } recipient : 5;
            enum
            {
                USB_SETUP_BMREQUESTTYPE_TYPE_STANDARD = 0,
                USB_SETUP_BMREQUESTTYPE_TYPE_CLASS = 1,
                USB_SETUP_BMREQUESTTYPE_TYPE_VENDOR = 2,
            } type : 2;
            enum
            {
                USB_SETUP_BMREQUESTTYPE_DIRECTION_OUT = 0,
                USB_SETUP_BMREQUESTTYPE_DIRECTION_IN = 1,
            } direction : 1;
        } bmRequestType;
        union
        {
            enum __attribute__((packed))
            {
                USB_SETUP_BREQUEST_GET_STATUS = 0,
                USB_SETUP_BREQUEST_CLEAR_FEATURE = 1,
                USB_SETUP_BREQUEST_SET_FEATURE = 3,
                USB_SETUP_BREQUEST_SET_ADDRESS = 5,
                USB_SETUP_BREQUEST_GET_DESCRIPTOR = 6,
                USB_SETUP_BREQUEST_SET_DESCRIPTOR = 7,
                USB_SETUP_BREQUEST_GET_CONFIGURATION = 8,
                USB_SETUP_BREQUEST_SET_CONFIGURATION = 9,
                USB_SETUP_BREQUEST_GET_INTERFACE = 10,
                USB_SETUP_BREQUEST_SET_INTERFACE = 11,
                USB_SETUP_BREQUEST_SYNCH_FRAME = 12,
            } req;
            uint8_t raw;
        } bRequest;
        uint16_t wValue;
        uint16_t wIndex;
        uint16_t wLength;
    } setup;
    uint8_t raw[64];
};

enum __attribute__((packed)) usb_descriptor_type
{
    USB_DESCRIPTOR_TYPE_DEVICE = 1,
    USB_DESCRIPTOR_TYPE_CONFIGURATION = 2,
    USB_DESCRIPTOR_TYPE_STRING = 3,
    USB_DESCRIPTOR_TYPE_INTERFACE = 4,
    USB_DESCRIPTOR_TYPE_ENDPOINT = 5,
    USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER = 6,
    USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIG = 7,
    USB_DESCRIPTOR_TYPE_INTERFACE_POWER = 8,
    USB_DESCRIPTOR_TYPE_OTG = 9,
    USB_DESCRIPTOR_TYPE_DEBUG = 10,
    USB_DESCRIPTOR_TYPE_INTERFACE_ASSOCIATION = 11,
};

enum usb_endpoint_direction
{
    USB_ENDPOINT_DIRECTION_OUT = 0,
    USB_ENDPOINT_DIRECTION_IN = 1,
};

union __attribute__((packed)) usb_endpoint_number
{
    struct __attribute__((packed))
    {
        int number : 4;
        int reserved: 3;
        enum usb_endpoint_direction direction : 1;
    };
    uint8_t byte;
};

enum usb_endpoint_type
{
    USB_ENDPOINT_TYPE_CONTROL = 0,
    USB_ENDPOINT_TYPE_ISOCHRONOUS = 1,
    USB_ENDPOINT_TYPE_BULK = 2,
    USB_ENDPOINT_TYPE_INTERRUPT = 3,
};

struct __attribute__((packed)) usb_devicedescriptor
{
    uint8_t bLength;
    enum usb_descriptor_type bDescriptorType;
    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;
};

struct __attribute__((packed)) usb_configurationdescriptor
{
    uint8_t bLength;
    enum usb_descriptor_type bDescriptorType;
    uint16_t wTotalLength;
    uint8_t bNumInterfaces;
    uint8_t bConfigurationValue;
    uint8_t iConfiguration;
    struct __attribute__((packed))
    {
        unsigned int reserved : 5;
        unsigned int remotewakeup : 1;
        unsigned int selfpowered : 1;
        unsigned int buspowered : 1;
    } bmAttributes;
    uint8_t bMaxPower;
};

struct __attribute__((packed)) usb_interfacedescriptor
{
    uint8_t bLength;
    enum usb_descriptor_type bDescriptorType;
    uint8_t bInterfaceNumber;
    uint8_t bAlternateSetting;
    uint8_t bNumEndpoints;
    uint8_t bInterfaceClass;
    uint8_t bInterfaceSubClass;
    uint8_t bInterfaceProtocol;
    uint8_t iInterface;
};

struct __attribute__((packed)) usb_endpointdescriptor
{
    uint8_t bLength;
    enum usb_descriptor_type bDescriptorType;
    union usb_endpoint_number bEndpointAddress;
    struct __attribute__((packed))
    {
        enum
        {
            USB_ENDPOINT_ATTRIBUTE_TYPE_CONTROL = 0,
            USB_ENDPOINT_ATTRIBUTE_TYPE_ISOCHRONOUS = 1,
            USB_ENDPOINT_ATTRIBUTE_TYPE_BULK = 2,
            USB_ENDPOINT_ATTRIBUTE_TYPE_INTERRUPT = 3,
        } type : 2;
        enum
        {
            USB_ENDPOINT_ATTRIBUTE_SYNCTYPE_NOSYNC = 0,
            USB_ENDPOINT_ATTRIBUTE_SYNCTYPE_ASYNC = 1,
            USB_ENDPOINT_ATTRIBUTE_SYNCTYPE_ADAPTIVE = 2,
            USB_ENDPOINT_ATTRIBUTE_SYNCTYPE_SYNC = 3,
        } synctype : 2;
        enum
        {
            USB_ENDPOINT_ATTRIBUTE_USAGE_DATA = 0,
            USB_ENDPOINT_ATTRIBUTE_USAGE_FEEDBACK = 1,
            USB_ENDPOINT_ATTRIBUTE_USAGE_EXPLICIT = 2,
        } usage : 2;
        unsigned int reserved : 2;
    } bmAttributes;
    uint16_t wMaxPacketSize;
    uint8_t bInterval;
};

struct __attribute__((packed)) usb_stringdescriptor
{
    uint8_t bLength;
    enum usb_descriptor_type bDescriptorType;
    uint16_t wString[];
};

struct __attribute__((packed,aligned(4))) usb_endpoint
{
    union usb_endpoint_number number;
    uint8_t reserved1;
    uint8_t reserved2;
    uint8_t reserved3;
    int (*ctrl_request)(const struct usb_instance* data, int interface, int endpoint, union usb_ep0_buffer* request, const void** response);
    void (*xfer_complete)(const struct usb_instance* data, int interface, int endpoint, int bytesleft);
    union __attribute__((packed))
    {
        void (*setup_received)(const struct usb_instance* data, int interface, int endpoint);
        void (*timeout)(const struct usb_instance* data, int interface, int endpoint, int bytesleft);
    };
};

struct __attribute__((packed,aligned(4))) usb_altsetting
{
    void (*set_altsetting)(const struct usb_instance* data, int interface, int altsetting);
    void (*unset_altsetting)(const struct usb_instance* data, int interface, int altsetting);
    uint8_t reserved1;
    uint8_t reserved2;
    uint8_t reserved3;
    uint8_t endpoint_count;
    const struct usb_endpoint* endpoints[];
};

struct __attribute__((packed,aligned(4))) usb_interface
{
    void (*bus_reset)(const struct usb_instance* data, int configuration, int interface, int highspeed);
    int (*ctrl_request)(const struct usb_instance* data, int interface, union usb_ep0_buffer* request, const void** response);
    uint8_t reserved1;
    uint8_t reserved2;
    uint8_t reserved3;
    uint8_t altsetting_count;
    const struct usb_altsetting* altsettings[];
};

struct __attribute__((packed,aligned(4))) usb_configuration
{
    const struct usb_configurationdescriptor* descriptor;
    void (*set_configuration)(const struct usb_instance* data, int configuration);
    void (*unset_configuration)(const struct usb_instance* data, int configuration);
    uint8_t reserved1;
    uint8_t reserved2;
    uint8_t reserved3;
    uint8_t interface_count;
    const struct usb_interface* interfaces[];
};

struct __attribute__((packed,aligned(4))) usb_state
{
    bool (*ep0_rx_callback)(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft);
    bool (*ep0_tx_callback)(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft);
    const void* ep0_tx_ptr;
    uint16_t ep0_tx_len;
    uint8_t current_address;
    uint8_t current_configuration;
    uint8_t interface_altsetting[];
};

struct __attribute__((packed,aligned(4))) usb_driver
{
    void (*init)(const struct usb_instance* data);
    void (*exit)(const struct usb_instance* data);
    void (*ep0_start_rx)(const struct usb_instance* data, bool non_setup, int len);
    void (*ep0_start_tx)(const struct usb_instance* data, const void* buf, int len);
    void (*start_rx)(const struct usb_instance* data, union usb_endpoint_number ep, void* buf, int size);
    void (*start_tx)(const struct usb_instance* data, union usb_endpoint_number ep, const void* buf, int size);
    int (*get_stall)(const struct usb_instance* data, union usb_endpoint_number ep);
    void (*set_stall)(const struct usb_instance* data, union usb_endpoint_number ep, bool stall);
    void (*set_address)(const struct usb_instance* data, uint8_t address);
    void (*configure_ep)(const struct usb_instance* data, union usb_endpoint_number ep, enum usb_endpoint_type type, int maxpacket);
    void (*unconfigure_ep)(const struct usb_instance* data, union usb_endpoint_number ep);
    int (*get_max_transfer_size)(const struct usb_instance* data, union usb_endpoint_number ep);
};

struct __attribute__((packed,aligned(4))) usb_instance
{
    const struct usb_driver* driver;
    const void* driver_config;
    void* driver_state;
    struct usb_state* state;
    union usb_ep0_buffer* buffer;
    void (*bus_reset)(const struct usb_instance* data, int highspeed);
    int (*ctrl_request)(const struct usb_instance* data, union usb_ep0_buffer* request, const void** response);
    int (*ep0_setup_hook)(const struct usb_instance* data, union usb_ep0_buffer* buf);
    uint8_t configuration_count;
    uint8_t stringdescriptor_count;
    uint8_t reserved1;
    uint8_t reserved2;
    const struct usb_devicedescriptor* devicedescriptor;
    const struct usb_stringdescriptor** stringdescriptors;
    const struct usb_configuration* configurations[];
};

extern void usb_init(const struct usb_instance* data);
extern void usb_exit(const struct usb_instance* data);
extern void usb_handle_bus_reset(const struct usb_instance* data, int highspeed);
extern void usb_handle_timeout(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft);
extern void usb_handle_xfer_complete(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft);
extern void usb_handle_setup_received(const struct usb_instance* data, union usb_endpoint_number epnum);
extern void usb_ep0_start_rx(const struct usb_instance* data, bool non_setup, int len, bool (*callback)(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft));
extern void usb_ep0_start_tx(const struct usb_instance* data, const void* buf, int len, bool (*callback)(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft));
extern void usb_start_rx(const struct usb_instance* data, union usb_endpoint_number ep, void* buf, int size);
extern void usb_start_tx(const struct usb_instance* data, union usb_endpoint_number ep, const void* buf, int size);
extern void usb_set_stall(const struct usb_instance* data, union usb_endpoint_number ep, bool stall);
extern void usb_configure_ep(const struct usb_instance* data, union usb_endpoint_number ep, enum usb_endpoint_type type, int maxpacket);
extern void usb_unconfigure_ep(const struct usb_instance* data, union usb_endpoint_number ep);
extern int usb_get_max_transfer_size(const struct usb_instance* data, union usb_endpoint_number ep);
extern bool usb_ep0_tx_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft);
extern bool usb_ep0_short_tx_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft);
extern bool usb_ep0_ack_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft);


#endif