include/usb/usb_protocol.h

Go to the documentation of this file.

#ifndef USB_PROTOCOL_H_INCLUDED
#define USB_PROTOCOL_H_INCLUDED

#include <types.h>

enum usb_device_state {
        USB_STATE_ATTACHED = 0,
        USB_STATE_POWERED,
        USB_STATE_DEFAULT,
        USB_STATE_ADDRESS,
        USB_STATE_CONFIGURED,
        USB_STATE_SUSPENDED = 0x80,
        USB_STATE_POWERED_SUSPENDED = USB_STATE_POWERED | USB_STATE_SUSPENDED,
        USB_STATE_DEFAULT_SUSPENDED = USB_STATE_DEFAULT | USB_STATE_SUSPENDED,
        USB_STATE_ADDRESS_SUSPENDED = USB_STATE_ADDRESS | USB_STATE_SUSPENDED,
        USB_STATE_CONFIGURED_SUSPENDED = (USB_STATE_CONFIGURED
                                          | USB_STATE_SUSPENDED),
};

enum usb_device_speed {
        USB_SPEED_UNKNOWN = 0,  
        USB_SPEED_LOW,          
        USB_SPEED_FULL,         
        USB_SPEED_HIGH,         
};

enum usb_reqtype {
        USB_REQTYPE_STANDARD    = 0, 
        USB_REQTYPE_CLASS       = 1, 
        USB_REQTYPE_VENDOR      = 2, 
};

#define USB_REQTYPE_STANDARD_MASK       (USB_REQTYPE_STANDARD << 5)
#define USB_REQTYPE_CLASS_MASK          (USB_REQTYPE_CLASS << 5)
#define USB_REQTYPE_VENDOR_MASK         (USB_REQTYPE_VENDOR << 5)

enum usb_recipient {
        USB_RECIP_DEVICE        = 0,
        USB_RECIP_INTERFACE     = 1,
        USB_RECIP_ENDPOINT      = 2,
        USB_RECIP_OTHER         = 3,
};

#define USB_RECIP_DEVICE_MASK           (USB_RECIP_DEVICE << 0)
#define USB_RECIP_INTERFACE_MASK        (USB_RECIP_INTERFACE << 0)
#define USB_RECIP_ENDPOINT_MASK         (USB_RECIP_ENDPOINT << 0)
#define USB_RECIP_OTHER_MASK            (USB_RECIP_OTHER << 0)

enum usb_reqid {
        USB_REQ_GET_STATUS              =  0,
        USB_REQ_CLEAR_FEATURE           =  1,
        USB_REQ_SET_FEATURE             =  3,
        USB_REQ_SET_ADDRESS             =  5,
        USB_REQ_GET_DESCRIPTOR          =  6,
        USB_REQ_SET_DESCRIPTOR          =  7,
        USB_REQ_GET_CONFIGURATION       =  8,
        USB_REQ_SET_CONFIGURATION       =  9,
        USB_REQ_GET_INTERFACE           = 10,
        USB_REQ_SET_INTERFACE           = 11,
        USB_REQ_SYNCH_FRAME             = 12,
};

enum usb_device_feature {
        USB_DEV_STATUS_SELF_POWERED     = 0, 
        USB_DEV_FEATURE_REMOTE_WAKEUP   = 1, 
        USB_DEV_FEATURE_TEST_MODE       = 2, 
};

enum usb_endpoint_feature {
        USB_EP_FEATURE_HALT             = 0,
};

enum usb_test_mode_selector {
        USB_TEST_J                      = 0x01,
        USB_TEST_K                      = 0x02,
        USB_TEST_SE0_NAK                = 0x03,
        USB_TEST_PACKET                 = 0x04,
        USB_TEST_FORCE_ENABLE           = 0x05,
};

enum usb_descriptor_type {
        USB_DT_DEVICE                   = 1,
        USB_DT_CONFIGURATION            = 2,
        USB_DT_STRING                   = 3,
        USB_DT_INTERFACE                = 4,
        USB_DT_ENDPOINT                 = 5,
        USB_DT_DEVICE_QUALIFIER         = 6,
        USB_DT_OTHER_SPEED_CONFIGURATION = 7,
        USB_DT_INTERFACE_POWER          = 8,
};

enum usb_ep_xfer_type {
        USB_EP_XFER_CONTROL             = 0x00,
        USB_EP_XFER_ISOCHRONOUS         = 0x01,
        USB_EP_XFER_BULK                = 0x02,
        USB_EP_XFER_INTERRUPT           = 0x03,
};

enum usb_langid {
        USB_LANGID_EN_US                = 0x0406, 
};

#define USB_EP_ADDR_MASK                0x0f

#define USB_DIR_IN                      0x80

#define USB_DIR_OUT                     0x00

#define USB_MAX_DESC_LEN                255

/*
 * 2-byte alignment is OK for setup requests and device (qualifier)
 * descriptors.
 */
COMPILER_PACK_SET(2);

struct usb_setup_req {
        uint8_t bmRequestType;
        uint8_t bRequest;
        le16_t wValue;
        le16_t wIndex;
        le16_t wLength;
};

#define usb_setup_is_in(req)            (!!((req)->bmRequestType & USB_DIR_IN))

#define usb_setup_is_out(req)           (!((req)->bmRequestType & USB_DIR_IN))

#define usb_setup_type(req)             (((req)->bmRequestType >> 5) & 3)

#define usb_setup_recipient(req)        ((req)->bmRequestType & 0x1f)

struct usb_device_descriptor {
        uint8_t bLength;
        uint8_t bDescriptorType;
        le16_t bcdUSB;
        uint8_t bDeviceClass;
        uint8_t bDeviceSubClass;
        uint8_t bDeviceProtocol;
        uint8_t bMaxPacketSize0;
        le16_t idVendor;
        le16_t idProduct;
        le16_t bcdDevice;
        uint8_t iManufacturer;
        uint8_t iProduct;
        uint8_t iSerialNumber;
        uint8_t bNumConfigurations;
};

struct usb_device_qualifier_descriptor {
        uint8_t bLength;
        uint8_t bDescriptorType;
        le16_t bcdUSB;
        uint8_t bDeviceClass;
        uint8_t bDeviceSubClass;
        uint8_t bDeviceProtocol;
        uint8_t bMaxPacketSize0;
        uint8_t bNumConfigurations;
        uint8_t bReserved;
};

/* Configuration and associated descriptors must be packed tightly */
COMPILER_PACK_SET(1);

struct usb_configuration_descriptor {
        uint8_t bLength;
        uint8_t bDescriptorType;
        le16_t wTotalLength;
        uint8_t bNumInterfaces;
        uint8_t bConfigurationValue;
        uint8_t iConfiguration;
        uint8_t bmAttributes;
        uint8_t bMaxPower;
};

#define USB_CONFIG_ATTR_MUST_SET        (1U << 7) //!< Must always be set
#define USB_CONFIG_ATTR_SELF_POWERED    (1U << 6) //!< Self-powered
#define USB_CONFIG_ATTR_REMOTE_WAKEUP   (1U << 5) //!< Supports remote wakeup
#define USB_CONFIG_MAX_POWER(ma)        (((ma) + 1) / 2) //!< Max power in mA

struct usb_interface_descriptor {
        uint8_t bLength;
        uint8_t bDescriptorType;
        uint8_t bInterfaceNumber;
        uint8_t bAlternateSetting;
        uint8_t bNumEndpoints;
        uint8_t bInterfaceClass;
        uint8_t bInterfaceSubClass;
        uint8_t bInterfaceProtocol;
        uint8_t iInterface;
};

struct usb_endpoint_descriptor {
        uint8_t bLength;
        uint8_t bDescriptorType;
        uint8_t bEndpointAddress;
        uint8_t bmAttributes;
        le16_t wMaxPacketSize;
        uint8_t bInterval;
};

#define usb_ep_index(desc)      ((desc)->bEndpointAddress & USB_EP_ADDR_MASK)

#define usb_ep_is_in(desc)      (!!((desc)->bEndpointAddress & USB_DIR_IN))

#define usb_ep_is_out(desc)     (!((desc)->bEndpointAddress & USB_DIR_IN))

#define usb_ep_xfer(desc)       ((desc)->bmAttributes & 0x03)

/* String descriptors may be 2-byte aligned */
COMPILER_PACK_SET(2);

struct usb_string_descriptor {
        uint8_t bLength;
        uint8_t bDescriptorType;
        le16_t  bString[0];
};

COMPILER_PACK_RESET();


#endif /* USB_PROTOCOL_H_INCLUDED */

---