usb_desc.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef  __USB_DESC_H
#define  __USB_DESC_H
#include <predef.h>
#include <stdint.h>
#include <basictypes.h>
#include <usb_langid.h>
 
enum class eDesc_t : uint8_t {
    eDesc_Dev           = 0x01, // Device Descriptor
    eDesc_Cfg           = 0x02, // Configuration Descriptor
    eDesc_Str           = 0x03, // String Descriptor
    eDesc_Intf          = 0x04, // Interface Descriptor
    eDesc_EndPt         = 0x05, // Endpoint Descriptor
    eDesc_DevQual       = 0x06, // Device Qualifier Descriptor
    eDesc_Other_Spd_Cfg = 0x07, // Other Speed Configuration Descriptor
    eDesc_IntfPwr       = 0x08, // Interface Power Descriptor
    eDesc_OTG           = 0x09, // On-the-go Descriptor
    eDesc_Debug         = 0x0A, // Debug Descriptor
    eDesc_IntfAssoc     = 0x0B, // Interface Association Descriptor
    eDesc_CS_Intf       = 0x24, // CDC Function Interface Descriptor
    eDesc_CS_EndPt      = 0x25, // CDC Function Endpoint Descriptor
};
 
enum class eDevClassID_t : uint8_t {
    eClassID_UseIntf    = 0x00, // Only allowed for Device descriptor
    eClassID_CDC        = 0x02, // Communication Device Class
    eClassID_HUB        = 0x09, // USB Hub Device
    eClassID_BillBoard  = 0x11, // Billboard Device
    eClassID_Diagnostic = 0xDC, // Diagnostic (Debug) Device
    eClassID_Misc       = 0xEF, // Miscellaneous Device
    eClassID_Vendor     = 0xFF  // Vendor Defined
};
 
 
enum class eClassID_t : uint8_t {
    eClassID_Audio       = 0x01, // Audio Device
    eClassID_CDC         = 0x02, // Communication Device Class
    eClassID_HID         = 0x03, // Human Interface Device
    eClassID_Physical    = 0x05, // Physical Device
    eClassID_StillImage  = 0x06, // Still Imaging Device
    eClassID_LPT         = 0x07, // Printer Device
    eClassID_MSD         = 0x08, // Mass Storage Device
    eClassID_HUB         = 0x09, // USB Hub Device
    eClassID_CDC_Data    = 0x0A, // Communication Device Class, Data Interface
    eClassID_SmartCard   = 0x0B, // Smart Card Device
    eClassID_ContentSec  = 0x0C, // Content Security
    eClassID_Video       = 0x0D, // Video Device
    eClassID_Health      = 0x0F, // Personal Healthcare Device
    eClassID_AVD         = 0x10, // Audio/Visual Device
    eClassID_BillBoard   = 0x11, // Billboard Device
    eClassID_USBC_Bridge = 0x12, // USB-C Bridge Device
    eClassID_Diagnostic  = 0xDC, // Diagnostic (Debug) Device
    eClassID_Wireless    = 0xE0, // Wireless Controller
    eClassID_Misc        = 0xEF, // Miscellaneous Device
    eClassID_APP         = 0xFE, // Application Specific
    eClassID_Vendor      = 0xFF  // Vendor Defined
};
 
enum class eSubClass_CDC_t : uint8_t {
    eSubClass_CDC_DLC    = 0x01, // Direct Line Control Model [USBPSTN1.2]
    eSubClass_CDC_ACM    = 0x02, // Abstract Control Model [USBPSTN1.2]
    eSubClass_CDC_PSTN   = 0x03, // Telephone Control Model [USBPSTN1.2]
    eSubClass_CDC_MC     = 0x04, // Multi-Channel Control Model [USBISDN1.2]
    eSubClass_CDC_CAPI   = 0x05, // CAPI Control Model [USBISDN1.2]
    eSubClass_CDC_Eth    = 0x06, // Ethernet Networking Control Model [USBECM1.2]
    eSubClass_CDC_ATM    = 0x07, // ATM Networking Control Model [USBATM1.2]
    eSubClass_CDC_WHS    = 0x08, // Wireless Handset Control Model [USBWMC1.1]
    eSubClass_CDC_Mgmnt  = 0x09, // Device Management [USBWMC1.1]
    eSubClass_CDC_MobDLC = 0x0A, // Mobile Direct Line Model [USBWMC1.1]
    eSubClass_CDC_OBEX   = 0x0B, // OBEX [USBWMC1.1]
    eSubClass_CDC_EthEmu = 0x0C, // Ethernet Emulation Model [USBEEM1.0]
    eSubClass_CDC_NetCtl = 0x0D, // Network Control Model [USBNCM1.0]
};
 
enum class eProto_CDC_t : uint8_t {
    eProto_CDC_None     = 0x00, // No class specific protocol required
    eProto_CDC_V250     = 0x01, // ITU-T V.250 AT Commands: V.250 etc
    eProto_CDC_PCCA     = 0x02, // PCCA-101 AT Commands defined by PCCA-101
    eProto_CDC_PCCA_ANX = 0x03, // PCCA-101 AT Commands defined by PCCA-101 & Annex O
    eProto_CDC_GSM      = 0x04, // GSM 7.07 AT Commands defined by GSM 07.07
    eProto_CDC_3G       = 0x05, // 3GPP 27.07 AT Commands defined by 3GPP 27.007
    eProto_CDC_CDMA     = 0x06, // C-S0017-0 AT Commands defined by TIA for CDMA
    eProto_CDC_EthEm    = 0x07, // USB EEM Ethernet Emulation Model
    eProto_CDC_Ext      = 0xFE, // External Protocol: Commands defined by
                                //   Command Set Functional Descriptor
    eProto_CDC_Vendor   = 0xFF, // USB Specification Vendor-specific
};
 
enum class eProto_CDCData_t : uint8_t {
    eProto_CDCData_None        = 0x00,  // No class specific protocol required
    eProto_CDCDATA_NetBlock    = 0x01,  // Network Transfer Block   [USBNCM1.0]
    eProto_CDCDATA_ISDN_BRI    = 0x30,  // Physical interface protocol for ISDN BRI [I.430]
    eProto_CDCDATA_HDLC        = 0x31,  // HDLC     [ISO/IEC 3309-1993]
    eProto_CDCDATA_TRN         = 0x32,  // Transparent
    eProto_CDCDATA_Q921_Mgmnt  = 0x50,  // Management protocol for Q.921 data link protocol [Q.921M]
    eProto_CDCDATA_Q921_Data   = 0x51,  // Data link protocol for Q.931  [Q.921]
    eProto_CDCDATA_Q921_Mplx   = 0x52,  // TEI-multiplexor for Q.921 data link protocol  [Q921TM]
    eProto_CDCDATA_V42_Cmprss  = 0x90,  // Data compression procedures  [V.42bis]
    eProto_CDCDATA_EU_ISDN_Ctl = 0x91,  // Euro-ISDN protocol control  [Q.931/Euro- ISDN]
    eProto_CDCDATA_V24_ISDN    = 0x92,  // V.24 rate adaptation to ISDN  [V.120]
    eProto_CDCDATA_CAPI_Cmd    = 0x93,  // CAPI Commands  [CAPI2.0]
    eProto_CDCDATA_Host_Cfg    = 0xFD,  // Host based driver. See note in [CDC120-20101103]
    eProto_CDCDATA_Ext         = 0xFE,  // External Protocol: Protocol(s) are described
                                        //     by Protocol Unit Functional Descriptors
    eProto_CDCDATA_Vendor      = 0xFF,  // USB Specification Vendor-specific
};
 
enum class eSubClass_HID_t : uint8_t {
    eSubClass_HID_None = 0x00,
    eSubClass_HID_Boot = 0x01, // Supports a BIOS Boot interface
};
 
enum class eProto_HID_t : uint8_t {
    eProto_HID_None     = 0x00,
    eProto_HID_Keyboard = 0x01, // Keyboard device
    eProto_HID_Mouse    = 0x02,    // Mouse device
};
 
enum class eSubClass_AVD_t : uint8_t {
    eSubClass_AVD_Ctl = 0x01, // AVControl Interface
    eSubClass_AVD_Video = 0x02, // AVData Video Streaming Interface
    eSubClass_AVD_Audio = 0x03, // AVData Audio Streaming Interface
};
 
enum class eProtoHub_t : uint8_t {
    eProtoHub_FS = 0x00, // Full Speed Hub
    eProtoHub_TT = 0x01, // High Speed Hub w/ Single Transaction Translator
    eProtoHub_MutiTT = 0x02, // High Speed Hub w/ Multiple Transaction Translators
};
 
enum class eCfgAttr_t : uint8_t {
    eCfgAttr_RemoteWkup = 0x20, // Supports Remote Wakeup
    eCfgAttr_SelfPwr    = 0x40, // Device is Self Powered
};
 
enum class eEndPt_t : uint8_t {
    eEndPt_Ctl  = 0x00, // Control Endpoint
    eEndPt_Iso  = 0x01, // Isochronous Endpoint
    eEndPt_Bulk = 0x02, // Bulk Transfer Endpoint
    eEndPt_IRQ  = 0x03, // Interrupt Endpoint
 
    eEndPt_INVALID = 0xFF // Invalid enpoint/not configured
};
 
enum class eIsoSync_t : uint8_t {
    eIsoSync_None  = 0x00, // No synchronization
    eIsoSync_Async = 0x01, // Fully Asynchronous
    eIsoSync_Adapt = 0x02, // Adaptive Synchronization
    eIsoSync_Synch = 0x03, // Fully Synchronous
};
 
enum class eIsoUsage_t : uint8_t {
    eIsoUsage_Data     = 0x00, // Data endpoint
    eIsoUsage_Feedback = 0x01, // Feedback endpoint
    eIsoUsage_Implicit = 0x02, // Implicit Feedback endpoint
};
 
/**** USB Descriptor Structs ****/
 
struct usb_desc_t {
    uint8_t   bLength;         // Size of descriptor in bytes
    uint8_t   bDescriptorType; // Type: <descriptor>
    uint8_t   pData[];         // Remainder of the descriptor
};
 
struct usb_desc_str_zero_t {
    uint8_t   bLength;         // Size of descriptor in bytes
    uint8_t   bDescriptorType; // Type: STRING descriptor, equals eDesc_Str
    eLangID_t wLangID[];       // Language codes supported by this device
} __attribute__((packed));
 
struct usb_desc_str_t {
    uint8_t  bLength;          // Size of descriptor in bytes
    uint8_t  bDescriptorType;  // Type: STRING descriptor, equals eDesc_Str
    char16_t bString[];        // UNICODE (UTF-16) encoded string, !!!NOT NULL TERMINATED!!!
} __attribute__((packed));
 
/* USB Device Endpoint Descriptor */
struct usb_endpt_t {
    uint8_t    bLength;          // Size of descriptor in bytes
    uint8_t    bDescriptorType;  // Type: CONFIGURATION descriptor, equals eDesc_Cfg
    uint8_t    bEndpointAddress; // The addr of the endpt on the Dev described by this descriptor
                                 //   Bit 3..0: Endpt Number
                                 //   Bit 6..4: RESERVED
                                 //   Bit 7:    Direction, 0 = OUT endpt, 1 = IN endpt
    uint8_t    bmAttributes;     // Endpoint transfer attributes
    leuint16_t wMaxPacketSize;   // Maximum packet size for this enpoint in this configuration
                                 //   Bit 10..0: Max packet size in bytes
                                 //   HS ISO/IRQ:
                                 //       Bit 12..11: number of additional transaction opportunities
                                 //                   per micro-frame
                                 //                   0x0 = None (1 txn/microframe)
                                 //                   0x1 = 1 (2 txn/microframe)
                                 //                   0x2 = 2 (3 txn/microframe)
                                 //                   0x3 = RESERVED
    uint8_t    bInterval;  //Interval for polling transfers. Units: Frame or Micro-frame count
                           //  depending on device speed
                           // Valid ranges:
                           // FS/HS ISO: 1-16, bInterval is exponent in count (2^(bInterval-1)),
                           //                  i.e. bInterval of 4 means period of 8
                           // FS/LS IRQ: 1-255, bInterval is raw period
                           // HS Bulk/Ctl: 0-255, NAK rate. 0 = never NAKs,
                           //              otherwise at most 1 NAK per bInterval microframes
 
    const void    *pExtra;   // Pointer to extra data
    uint16_t extraLen; // Size of extra data
} __attribute__((packed));
#define USB_DESC_ENDPT_SIZE (7)
 
/* USB Interface Association Descriptor */
/* Allows interfaces to be grouped by function */
struct usb_intf_assoc_t {
    uint8_t    bLength;             // Size of descriptor in bytes
    uint8_t    bDescriptorType;     // Type: CONFIGURATION descriptor, equals eDesc_Cfg
    uint8_t    bFirstInterface;     // Intf number of the First interface associated with this function
    uint8_t    bInterfaceCount;     // Number of contiguous interfaces associated with this function
    uint8_t    bFunctionClass;      // Class code for this function
    uint8_t    bFunctionSubClass;   // Subclass code for this function
    uint8_t    bFunctionProtocol;   // Protocol code for this function
    uint8_t    iFunction;           // Index of the String Descriptor describing this function
} __attribute__((packed));
#define USB_DESC_INTF_ASSOC_SIZE (8)
 
/* USB Interface Descriptor */
/* A collections of endpoints used for a function */
struct usb_intf_t {
    uint8_t    bLength;            // Size of descriptor in bytes
    uint8_t    bDescriptorType;    // Type: INTERFACE descriptor, equals eDesc_Intf
    uint8_t    bInterfaceNumber;   // Zero-based index for this interface in this configuration
    uint8_t    bAlternateSetting;  // Value used to select this alternate setting
    uint8_t    bNumEndpoints;      // Number of endpoints used by this interface (excluding EP 0)
    uint8_t    bInterfaceClass;    // Interface Class Code
    uint8_t    bInterfaceSubClass; // Interface SubClass Code
    uint8_t    bInterfaceProtocol; // Interface Protocol Code
    uint8_t    iInterface;         // Index of String Descriptor describing this Interface
 
    const usb_intf_t  *pAltSetting;      // Pointer to the next alternate setting for this interface
    const usb_intf_assoc_t *pIntfAssoc;  // Pointer to Interface Association, if first in Assoc
    const usb_endpt_t *endpt;            // Pointer to array of endpoints
    const void        *pExtra;           // Pointer to extra data
    uint16_t     extraLen;         // Size of extra data
} __attribute__((packed));
#define USB_DESC_INTF_SIZE (9)
 
/* USB Configuration Descriptor */
/* Logical configuration of the device as a whole */
struct usb_cfg_t {
    uint8_t    bLength;             // Size of descriptor in bytes
    uint8_t    bDescriptorType;     // Type: CONFIGURATION descriptor, equals eDesc_Cfg
    leuint16_t wTotalLength;        // Total Length returned for this config:
                                    //    Includes combined length of *all* descriptors
                                    //    (cfg, intf, ep, and class- or vendor-specific)
    uint8_t    bNumInterfaces;      // Number of interfaces supported by this configuration
    uint8_t    bConfigurationValue; // Argument to SetConfiguration to select this config
    uint8_t    iConfiguration;      // Index of the String Descriptor describing this config
    uint8_t    bmAttributes;        // Configuration Characteristics
    uint8_t    bMaxPower;           // Maximum power consumption from the bus in this configuration
                                    //    Units: 2mA, (i.e. 50 == 100mA)
    const usb_intf_t *intf;    // Pointer to array of interfaces
    uint16_t    intfLen; // length of 'intf' array
} __attribute__((packed));
#define USB_DESC_CFG_SIZE (9)
 
/* USB Other Speed Configuration Descriptor */
/* Only relevant if the HighSpeed device has Device Qualifier */
struct usb_other_spd_t {
    uint8_t  bLength;             // Size of descriptor in bytes
    uint8_t  bDescriptorType;     // Type: Other_speed_configuration descriptor, equals eDesc_Other_Spd_Cfg
    leuint16_t wTotalLength;      // Total Length returned for this config
                                  //    Includes combined length of *all* descriptors
                                  //    (cfg, intf, ep, and class- or vendor-specific)
    uint8_t  bNumInterfaces;      // Number of interfaces supported by this configuration
    uint8_t  bConfigurationValue; // Argument to SetConfiguration to select this config
    uint8_t  iConfiguration;      // Index of the String Descriptor describing this config
    uint8_t  bmAttributes;        // Configuration Characteristics
    uint8_t  bMaxPower;           // Maximum power consumption from the bus in this configuration
                                  //    Units: 2mA, (i.e. 50 == 100mA)
    const usb_intf_t *intf;  // Pointer to array of interfaces
    void    *pExtra;   // Pointer to extra data
    leuint16_t extraLen; // Size of extra data
} __attribute__((packed));
#define USB_DESC_OTHER_SPD_SIZE (9)
 
/* USB Device Qualifier Descriptor */
/* Per USB 2.0 Specification:
 * The device_qualifier descriptor describes information about a high-speed
 *  capable device that would change if the device were operating at the other
 *  speed. For example, if the device is currently operating at full-speed,
 *  the device_qualifier returns information about how it would operate at
 *  high-speed and vice-versa.
 */
struct usb_dev_qual_t {
    uint8_t      bLength;            // Size of descriptor in bytes
    uint8_t      bDescriptorType;    // Type: DEVICE QUALIFIER descriptor, equals eDesc_DevQual
    leuint16_t   bcdUSB;             // Binary-Coded Decimal USB Specification device is compliant to (2.10 is 0x210)
    uint8_t      bDeviceClass;       // Class code for this device
    uint8_t      bDeviceSubClass;    // Subclass code for tihs device
    uint8_t      bDeviceProtocol;    // Protocol code for this device
    uint8_t      bMaxPacketSize0;    // Maximum packet size for EP 0
    uint8_t      bNumConfigurations; // Number of possible Configurations
    uint8_t      bReserved;          // Reserved for Future Use, must be Zero
} __attribute__((packed));
#define USB_DESC_DEV_QUALIFIER_SIZE (10)
 
/* USB Device Descriptor */
/* Overall description of the USB device */
struct usb_dev_t {
    uint8_t      bLength;            // Size of descriptor in bytes
    uint8_t      bDescriptorType;    // Type: DEVICE descriptor, equals eDesc_Dev
    leuint16_t   bcdUSB;             // Binary-Coded Decimal USB Specification device is compliant to (2.10 is 0x210)
    uint8_t      bDeviceClass;       // Class code for this device
    uint8_t      bDeviceSubClass;    // Subclass code for tihs device
    uint8_t      bDeviceProtocol;    // Protocol code for this device
    uint8_t      bMaxPacketSize0;    // Maximum packet size for EP 0
    leuint16_t   idVendor;           // Vendor ID (assigned by USB-IF)
    leuint16_t   idProduct;          // Product ID (assigned by the manufacturer)
    leuint16_t   bcdDevice;          // Device Release number, BCD
    uint8_t      iManufacture;       // Index of string descriptor describing: Manufacturer
    uint8_t      iProduct;           // Index of string descriptor describing: Prouduct
    uint8_t      iSerialNumber;      // Index of string descriptor describing: Serial Number
    uint8_t      bNumConfigurations; // Number of possible Configurations
} __attribute__((packed));
#define USB_DESC_DEVICE_SIZE (18)
 
 
#endif   /* ----- #ifndef __USB_DESC_H  ----- */