653 lines
29 KiB
C++
653 lines
29 KiB
C++
/***********************************************************************
|
||
* $Id:: mw_usbd.h 197 2011-06-12 20:22:41Z usb06052 $
|
||
*
|
||
* Project: USB device ROM Stack
|
||
*
|
||
* Description:
|
||
* USB Definitions.
|
||
*
|
||
***********************************************************************
|
||
* Copyright(C) 2011, NXP Semiconductor
|
||
* All rights reserved.
|
||
*
|
||
* Software that is described herein is for illustrative purposes only
|
||
* which provides customers with programming information regarding the
|
||
* products. This software is supplied "AS IS" without any warranties.
|
||
* NXP Semiconductors assumes no responsibility or liability for the
|
||
* use of the software, conveys no license or title under any patent,
|
||
* copyright, or mask work right to the product. NXP Semiconductors
|
||
* reserves the right to make changes in the software without
|
||
* notification. NXP Semiconductors also make no representation or
|
||
* warranty that such application will be suitable for the specified
|
||
* use without further testing or modification.
|
||
**********************************************************************/
|
||
|
||
#ifndef __USB_H__
|
||
#define __USB_H__
|
||
|
||
/** \file
|
||
* \brief Common definitions and declarations for the USB stack.
|
||
*
|
||
* Common definitions and declarations for the USB stack.
|
||
* \addtogroup USBD_Core
|
||
* @{
|
||
*/
|
||
|
||
#include <stdint.h>
|
||
|
||
#if defined(__GNUC__)
|
||
/* As per http://gcc.gnu.org/onlinedocs/gcc/Attribute-Syntax.html#Attribute-Syntax,
|
||
6.29 Attributes Syntax
|
||
"An attribute specifier list may appear as part of a struct, union or
|
||
enum specifier. It may go either immediately after the struct, union
|
||
or enum keyword, or after the closing brace. The former syntax is
|
||
preferred. Where attribute specifiers follow the closing brace, they
|
||
are considered to relate to the structure, union or enumerated type
|
||
defined, not to any enclosing declaration the type specifier appears
|
||
in, and the type defined is not complete until after the attribute
|
||
specifiers."
|
||
So use POST_PACK immediately after struct keyword
|
||
*/
|
||
#define PRE_PACK
|
||
#define POST_PACK __attribute__((__packed__))
|
||
#define ALIGNED(n) __attribute__((aligned (n)))
|
||
#elif defined(__arm)
|
||
#define PRE_PACK __packed
|
||
#define POST_PACK
|
||
#define ALIGNED(n) __align(n)
|
||
#endif
|
||
|
||
/** Structure to pack lower and upper byte to form 16 bit word. */
|
||
PRE_PACK struct POST_PACK _WB_T
|
||
{
|
||
uint8_t L; /**< lower byte */
|
||
uint8_t H; /**< upper byte */
|
||
};
|
||
/** Structure to pack lower and upper byte to form 16 bit word.*/
|
||
typedef struct _WB_T WB_T;
|
||
|
||
/** Union of \ref _WB_T struct and 16 bit word.*/
|
||
PRE_PACK union POST_PACK __WORD_BYTE
|
||
{
|
||
uint16_t W; /**< data member to do 16 bit access */
|
||
WB_T WB; /**< data member to do 8 bit access */
|
||
} ;
|
||
/** Union of \ref _WB_T struct and 16 bit word.*/
|
||
typedef union __WORD_BYTE WORD_BYTE;
|
||
|
||
/** bmRequestType.Dir defines
|
||
* @{
|
||
*/
|
||
/** Request from host to device */
|
||
#define REQUEST_HOST_TO_DEVICE 0
|
||
/** Request from device to host */
|
||
#define REQUEST_DEVICE_TO_HOST 1
|
||
/** @} */
|
||
|
||
/** bmRequestType.Type defines
|
||
* @{
|
||
*/
|
||
/** Standard Request */
|
||
#define REQUEST_STANDARD 0
|
||
/** Class Request */
|
||
#define REQUEST_CLASS 1
|
||
/** Vendor Request */
|
||
#define REQUEST_VENDOR 2
|
||
/** Reserved Request */
|
||
#define REQUEST_RESERVED 3
|
||
/** @} */
|
||
|
||
/** bmRequestType.Recipient defines
|
||
* @{
|
||
*/
|
||
/** Request to device */
|
||
#define REQUEST_TO_DEVICE 0
|
||
/** Request to interface */
|
||
#define REQUEST_TO_INTERFACE 1
|
||
/** Request to endpoint */
|
||
#define REQUEST_TO_ENDPOINT 2
|
||
/** Request to other */
|
||
#define REQUEST_TO_OTHER 3
|
||
/** @} */
|
||
|
||
/** Structure to define 8 bit USB request.*/
|
||
PRE_PACK struct POST_PACK _BM_T
|
||
{
|
||
uint8_t Recipient : 5; /**< Recipeint type. */
|
||
uint8_t Type : 2; /**< Request type. */
|
||
uint8_t Dir : 1; /**< Directtion type. */
|
||
};
|
||
/** Structure to define 8 bit USB request.*/
|
||
typedef struct _BM_T BM_T;
|
||
|
||
/** Union of \ref _BM_T struct and 8 bit byte.*/
|
||
PRE_PACK union POST_PACK _REQUEST_TYPE
|
||
{
|
||
uint8_t B; /**< byte wide access memeber */
|
||
BM_T BM; /**< bitfield structure access memeber */
|
||
} ;
|
||
/** Union of \ref _BM_T struct and 8 bit byte.*/
|
||
typedef union _REQUEST_TYPE REQUEST_TYPE;
|
||
|
||
/** USB Standard Request Codes
|
||
* @{
|
||
*/
|
||
/** GET_STATUS request */
|
||
#define USB_REQUEST_GET_STATUS 0
|
||
/** CLEAR_FEATURE request */
|
||
#define USB_REQUEST_CLEAR_FEATURE 1
|
||
/** SET_FEATURE request */
|
||
#define USB_REQUEST_SET_FEATURE 3
|
||
/** SET_ADDRESS request */
|
||
#define USB_REQUEST_SET_ADDRESS 5
|
||
/** GET_DESCRIPTOR request */
|
||
#define USB_REQUEST_GET_DESCRIPTOR 6
|
||
/** SET_DESCRIPTOR request */
|
||
#define USB_REQUEST_SET_DESCRIPTOR 7
|
||
/** GET_CONFIGURATION request */
|
||
#define USB_REQUEST_GET_CONFIGURATION 8
|
||
/** SET_CONFIGURATION request */
|
||
#define USB_REQUEST_SET_CONFIGURATION 9
|
||
/** GET_INTERFACE request */
|
||
#define USB_REQUEST_GET_INTERFACE 10
|
||
/** SET_INTERFACE request */
|
||
#define USB_REQUEST_SET_INTERFACE 11
|
||
/** SYNC_FRAME request */
|
||
#define USB_REQUEST_SYNC_FRAME 12
|
||
/** @} */
|
||
|
||
/** USB GET_STATUS Bit Values
|
||
* @{
|
||
*/
|
||
/** SELF_POWERED status*/
|
||
#define USB_GETSTATUS_SELF_POWERED 0x01
|
||
/** REMOTE_WAKEUP capable status*/
|
||
#define USB_GETSTATUS_REMOTE_WAKEUP 0x02
|
||
/** ENDPOINT_STALL status*/
|
||
#define USB_GETSTATUS_ENDPOINT_STALL 0x01
|
||
/** @} */
|
||
|
||
/** USB Standard Feature selectors
|
||
* @{
|
||
*/
|
||
/** ENDPOINT_STALL feature*/
|
||
#define USB_FEATURE_ENDPOINT_STALL 0
|
||
/** REMOTE_WAKEUP feature*/
|
||
#define USB_FEATURE_REMOTE_WAKEUP 1
|
||
/** TEST_MODE feature*/
|
||
#define USB_FEATURE_TEST_MODE 2
|
||
/** @} */
|
||
|
||
/** USB Default Control Pipe Setup Packet*/
|
||
PRE_PACK struct POST_PACK _USB_SETUP_PACKET
|
||
{
|
||
REQUEST_TYPE bmRequestType; /**< This bitmapped field identifies the characteristics
|
||
of the specific request. \sa _BM_T.
|
||
*/
|
||
uint8_t bRequest; /**< This field specifies the particular request. The
|
||
Type bits in the bmRequestType field modify the meaning
|
||
of this field. \sa USBD_REQUEST.
|
||
*/
|
||
WORD_BYTE wValue; /**< Used to pass a parameter to the device, specific
|
||
to the request.
|
||
*/
|
||
WORD_BYTE wIndex; /**< Used to pass a parameter to the device, specific
|
||
to the request. The wIndex field is often used in
|
||
requests to specify an endpoint or an interface.
|
||
*/
|
||
uint16_t wLength; /**< This field specifies the length of the data
|
||
transferred during the second phase of the control
|
||
transfer.
|
||
*/
|
||
} ;
|
||
/** USB Default Control Pipe Setup Packet*/
|
||
typedef struct _USB_SETUP_PACKET USB_SETUP_PACKET;
|
||
|
||
|
||
/** USB Descriptor Types
|
||
* @{
|
||
*/
|
||
/** Device descriptor type */
|
||
#define USB_DEVICE_DESCRIPTOR_TYPE 1
|
||
/** Configuration descriptor type */
|
||
#define USB_CONFIGURATION_DESCRIPTOR_TYPE 2
|
||
/** String descriptor type */
|
||
#define USB_STRING_DESCRIPTOR_TYPE 3
|
||
/** Interface descriptor type */
|
||
#define USB_INTERFACE_DESCRIPTOR_TYPE 4
|
||
/** Endpoint descriptor type */
|
||
#define USB_ENDPOINT_DESCRIPTOR_TYPE 5
|
||
/** Device qualifier descriptor type */
|
||
#define USB_DEVICE_QUALIFIER_DESCRIPTOR_TYPE 6
|
||
/** Other speed configuration descriptor type */
|
||
#define USB_OTHER_SPEED_CONFIG_DESCRIPTOR_TYPE 7
|
||
/** Interface power descriptor type */
|
||
#define USB_INTERFACE_POWER_DESCRIPTOR_TYPE 8
|
||
/** OTG descriptor type */
|
||
#define USB_OTG_DESCRIPTOR_TYPE 9
|
||
/** Debug descriptor type */
|
||
#define USB_DEBUG_DESCRIPTOR_TYPE 10
|
||
/** Interface association descriptor type */
|
||
#define USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE 11
|
||
/** @} */
|
||
|
||
/** USB Device Classes
|
||
* @{
|
||
*/
|
||
/** Reserved device class */
|
||
#define USB_DEVICE_CLASS_RESERVED 0x00
|
||
/** Audio device class */
|
||
#define USB_DEVICE_CLASS_AUDIO 0x01
|
||
/** Communications device class */
|
||
#define USB_DEVICE_CLASS_COMMUNICATIONS 0x02
|
||
/** Human interface device class */
|
||
#define USB_DEVICE_CLASS_HUMAN_INTERFACE 0x03
|
||
/** monitor device class */
|
||
#define USB_DEVICE_CLASS_MONITOR 0x04
|
||
/** physical interface device class */
|
||
#define USB_DEVICE_CLASS_PHYSICAL_INTERFACE 0x05
|
||
/** power device class */
|
||
#define USB_DEVICE_CLASS_POWER 0x06
|
||
/** Printer device class */
|
||
#define USB_DEVICE_CLASS_PRINTER 0x07
|
||
/** Storage device class */
|
||
#define USB_DEVICE_CLASS_STORAGE 0x08
|
||
/** Hub device class */
|
||
#define USB_DEVICE_CLASS_HUB 0x09
|
||
/** miscellaneous device class */
|
||
#define USB_DEVICE_CLASS_MISCELLANEOUS 0xEF
|
||
/** Application device class */
|
||
#define USB_DEVICE_CLASS_APP 0xFE
|
||
/** Vendor specific device class */
|
||
#define USB_DEVICE_CLASS_VENDOR_SPECIFIC 0xFF
|
||
/** @} */
|
||
|
||
/** bmAttributes in Configuration Descriptor
|
||
* @{
|
||
*/
|
||
/** Power field mask */
|
||
#define USB_CONFIG_POWERED_MASK 0x40
|
||
/** Bus powered */
|
||
#define USB_CONFIG_BUS_POWERED 0x80
|
||
/** Self powered */
|
||
#define USB_CONFIG_SELF_POWERED 0xC0
|
||
/** remote wakeup */
|
||
#define USB_CONFIG_REMOTE_WAKEUP 0x20
|
||
/** @} */
|
||
|
||
/** bMaxPower in Configuration Descriptor */
|
||
#define USB_CONFIG_POWER_MA(mA) ((mA)/2)
|
||
|
||
/** bEndpointAddress in Endpoint Descriptor
|
||
* @{
|
||
*/
|
||
/** Endopint address mask */
|
||
#define USB_ENDPOINT_DIRECTION_MASK 0x80
|
||
/** Macro to convert OUT endopint number to endpoint address value. */
|
||
#define USB_ENDPOINT_OUT(addr) ((addr) | 0x00)
|
||
/** Macro to convert IN endopint number to endpoint address value. */
|
||
#define USB_ENDPOINT_IN(addr) ((addr) | 0x80)
|
||
/** @} */
|
||
|
||
/** bmAttributes in Endpoint Descriptor
|
||
* @{
|
||
*/
|
||
/** Endopint type mask */
|
||
#define USB_ENDPOINT_TYPE_MASK 0x03
|
||
/** Control Endopint type */
|
||
#define USB_ENDPOINT_TYPE_CONTROL 0x00
|
||
/** isochronous Endopint type */
|
||
#define USB_ENDPOINT_TYPE_ISOCHRONOUS 0x01
|
||
/** bulk Endopint type */
|
||
#define USB_ENDPOINT_TYPE_BULK 0x02
|
||
/** interrupt Endopint type */
|
||
#define USB_ENDPOINT_TYPE_INTERRUPT 0x03
|
||
/** Endopint sync type mask */
|
||
#define USB_ENDPOINT_SYNC_MASK 0x0C
|
||
/** no synchronization Endopint */
|
||
#define USB_ENDPOINT_SYNC_NO_SYNCHRONIZATION 0x00
|
||
/** Asynchronous sync Endopint */
|
||
#define USB_ENDPOINT_SYNC_ASYNCHRONOUS 0x04
|
||
/** Adaptive sync Endopint */
|
||
#define USB_ENDPOINT_SYNC_ADAPTIVE 0x08
|
||
/** Synchronous sync Endopint */
|
||
#define USB_ENDPOINT_SYNC_SYNCHRONOUS 0x0C
|
||
/** Endopint usage type mask */
|
||
#define USB_ENDPOINT_USAGE_MASK 0x30
|
||
/** Endopint data usage type */
|
||
#define USB_ENDPOINT_USAGE_DATA 0x00
|
||
/** Endopint feedback usage type */
|
||
#define USB_ENDPOINT_USAGE_FEEDBACK 0x10
|
||
/** Endopint implicit feedback usage type */
|
||
#define USB_ENDPOINT_USAGE_IMPLICIT_FEEDBACK 0x20
|
||
/** Endopint reserved usage type */
|
||
#define USB_ENDPOINT_USAGE_RESERVED 0x30
|
||
/** @} */
|
||
|
||
/** Control endopint EP0's maximum packet size in high-speed mode.*/
|
||
#define USB_ENDPOINT_0_HS_MAXP 64
|
||
/** Control endopint EP0's maximum packet size in low-speed mode.*/
|
||
#define USB_ENDPOINT_0_LS_MAXP 8
|
||
/** Bulk endopint's maximum packet size in high-speed mode.*/
|
||
#define USB_ENDPOINT_BULK_HS_MAXP 512
|
||
|
||
/** USB Standard Device Descriptor */
|
||
PRE_PACK struct POST_PACK _USB_DEVICE_DESCRIPTOR
|
||
{
|
||
uint8_t bLength; /**< Size of this descriptor in bytes. */
|
||
uint8_t bDescriptorType; /**< DEVICE Descriptor Type. */
|
||
uint16_t bcdUSB; /**< BUSB Specification Release Number in
|
||
Binary-Coded Decimal (i.e., 2.10 is 210H).
|
||
This field identifies the release of the USB
|
||
Specification with which the device and its
|
||
descriptors are compliant.
|
||
*/
|
||
uint8_t bDeviceClass; /**< Class code (assigned by the USB-IF).
|
||
If this field is reset to zero, each interface
|
||
within a configuration specifies its own
|
||
class information and the various
|
||
interfaces operate independently.\n
|
||
If this field is set to a value between 1 and
|
||
FEH, the device supports different class
|
||
specifications on different interfaces and
|
||
the interfaces may not operate
|
||
independently. This value identifies the
|
||
class definition used for the aggregate
|
||
interfaces. \n
|
||
If this field is set to FFH, the device class
|
||
is vendor-specific.
|
||
*/
|
||
uint8_t bDeviceSubClass; /**< Subclass code (assigned by the USB-IF).
|
||
These codes are qualified by the value of
|
||
the bDeviceClass field. \n
|
||
If the bDeviceClass field is reset to zero,
|
||
this field must also be reset to zero. \n
|
||
If the bDeviceClass field is not set to FFH,
|
||
all values are reserved for assignment by
|
||
the USB-IF.
|
||
*/
|
||
uint8_t bDeviceProtocol; /**< Protocol code (assigned by the USB-IF).
|
||
These codes are qualified by the value of
|
||
the bDeviceClass and the
|
||
bDeviceSubClass fields. If a device
|
||
supports class-specific protocols on a
|
||
device basis as opposed to an interface
|
||
basis, this code identifies the protocols
|
||
that the device uses as defined by the
|
||
specification of the device class. \n
|
||
If this field is reset to zero, the device
|
||
does not use class-specific protocols on a
|
||
device basis. However, it may use classspecific
|
||
protocols on an interface basis. \n
|
||
If this field is set to FFH, the device uses a
|
||
vendor-specific protocol on a device basis.
|
||
*/
|
||
uint8_t bMaxPacketSize0; /**< Maximum packet size for endpoint zero
|
||
(only 8, 16, 32, or 64 are valid). For HS devices
|
||
is fixed to 64.
|
||
*/
|
||
|
||
uint16_t idVendor; /**< Vendor ID (assigned by the USB-IF). */
|
||
uint16_t idProduct; /**< Product ID (assigned by the manufacturer). */
|
||
uint16_t bcdDevice; /**< Device release number in binary-coded decimal. */
|
||
uint8_t iManufacturer; /**< Index of string descriptor describing manufacturer. */
|
||
uint8_t iProduct; /**< Index of string descriptor describing product. */
|
||
uint8_t iSerialNumber; /**< Index of string descriptor describing the device<63>s
|
||
serial number.
|
||
*/
|
||
uint8_t bNumConfigurations; /**< Number of possible configurations. */
|
||
} ;
|
||
/** USB Standard Device Descriptor */
|
||
typedef struct _USB_DEVICE_DESCRIPTOR USB_DEVICE_DESCRIPTOR;
|
||
|
||
/** USB 2.0 Device Qualifier Descriptor */
|
||
PRE_PACK struct POST_PACK _USB_DEVICE_QUALIFIER_DESCRIPTOR
|
||
{
|
||
uint8_t bLength; /**< Size of descriptor */
|
||
uint8_t bDescriptorType; /**< Device Qualifier Type */
|
||
uint16_t bcdUSB; /**< USB specification version number (e.g., 0200H for V2.00) */
|
||
uint8_t bDeviceClass; /**< Class Code */
|
||
uint8_t bDeviceSubClass; /**< SubClass Code */
|
||
uint8_t bDeviceProtocol; /**< Protocol Code */
|
||
uint8_t bMaxPacketSize0; /**< Maximum packet size for other speed */
|
||
uint8_t bNumConfigurations; /**< Number of Other-speed Configurations */
|
||
uint8_t bReserved; /**< Reserved for future use, must be zero */
|
||
} ;
|
||
/** USB 2.0 Device Qualifier Descriptor */
|
||
typedef struct _USB_DEVICE_QUALIFIER_DESCRIPTOR USB_DEVICE_QUALIFIER_DESCRIPTOR;
|
||
|
||
/** USB Standard Configuration Descriptor */
|
||
PRE_PACK struct POST_PACK _USB_CONFIGURATION_DESCRIPTOR
|
||
{
|
||
uint8_t bLength; /**< Size of this descriptor in bytes */
|
||
uint8_t bDescriptorType; /**< CONFIGURATION Descriptor Type*/
|
||
uint16_t wTotalLength; /**< Total length of data returned for this
|
||
configuration. Includes the combined length
|
||
of all descriptors (configuration, interface,
|
||
endpoint, and class- or vendor-specific)
|
||
returned for this configuration.*/
|
||
uint8_t bNumInterfaces; /**< Number of interfaces supported by this configuration*/
|
||
uint8_t bConfigurationValue; /**< Value to use as an argument to the
|
||
SetConfiguration() request to select this
|
||
configuration. */
|
||
uint8_t iConfiguration; /**< Index of string descriptor describing this
|
||
configuration*/
|
||
uint8_t bmAttributes; /**< Configuration characteristics \n
|
||
D7: Reserved (set to one)\n
|
||
D6: Self-powered \n
|
||
D5: Remote Wakeup \n
|
||
D4...0: Reserved (reset to zero) \n
|
||
D7 is reserved and must be set to one for
|
||
historical reasons. \n
|
||
A device configuration that uses power from
|
||
the bus and a local source reports a non-zero
|
||
value in bMaxPower to indicate the amount of
|
||
bus power required and sets D6. The actual
|
||
power source at runtime may be determined
|
||
using the GetStatus(DEVICE) request (see
|
||
USB 2.0 spec Section 9.4.5). \n
|
||
If a device configuration supports remote
|
||
wakeup, D5 is set to one.*/
|
||
uint8_t bMaxPower; /**< Maximum power consumption of the USB
|
||
device from the bus in this specific
|
||
configuration when the device is fully
|
||
operational. Expressed in 2 mA units
|
||
(i.e., 50 = 100 mA). \n
|
||
Note: A device configuration reports whether
|
||
the configuration is bus-powered or selfpowered.
|
||
Device status reports whether the
|
||
device is currently self-powered. If a device is
|
||
disconnected from its external power source, it
|
||
updates device status to indicate that it is no
|
||
longer self-powered. \n
|
||
A device may not increase its power draw
|
||
from the bus, when it loses its external power
|
||
source, beyond the amount reported by its
|
||
configuration. \n
|
||
If a device can continue to operate when
|
||
disconnected from its external power source, it
|
||
continues to do so. If the device cannot
|
||
continue to operate, it fails operations it can
|
||
no longer support. The USB System Software
|
||
may determine the cause of the failure by
|
||
checking the status and noting the loss of the
|
||
device<63>s power source.*/
|
||
} ;
|
||
/** USB Standard Configuration Descriptor */
|
||
typedef struct _USB_CONFIGURATION_DESCRIPTOR USB_CONFIGURATION_DESCRIPTOR;
|
||
|
||
/** USB Standard Interface Descriptor */
|
||
PRE_PACK struct POST_PACK _USB_INTERFACE_DESCRIPTOR
|
||
{
|
||
uint8_t bLength; /**< Size of this descriptor in bytes*/
|
||
uint8_t bDescriptorType; /**< INTERFACE Descriptor Type*/
|
||
uint8_t bInterfaceNumber; /**< Number of this interface. Zero-based
|
||
value identifying the index in the array of
|
||
concurrent interfaces supported by this
|
||
configuration.*/
|
||
uint8_t bAlternateSetting; /**< Value used to select this alternate setting
|
||
for the interface identified in the prior field*/
|
||
uint8_t bNumEndpoints; /**< Number of endpoints used by this
|
||
interface (excluding endpoint zero). If this
|
||
value is zero, this interface only uses the
|
||
Default Control Pipe.*/
|
||
uint8_t bInterfaceClass; /**< Class code (assigned by the USB-IF). \n
|
||
A value of zero is reserved for future
|
||
standardization. \n
|
||
If this field is set to FFH, the interface
|
||
class is vendor-specific. \n
|
||
All other values are reserved for
|
||
assignment by the USB-IF.*/
|
||
uint8_t bInterfaceSubClass; /**< Subclass code (assigned by the USB-IF). \n
|
||
These codes are qualified by the value of
|
||
the bInterfaceClass field. \n
|
||
If the bInterfaceClass field is reset to zero,
|
||
this field must also be reset to zero. \n
|
||
If the bInterfaceClass field is not set to
|
||
FFH, all values are reserved for
|
||
assignment by the USB-IF.*/
|
||
uint8_t bInterfaceProtocol; /**< Protocol code (assigned by the USB). \n
|
||
These codes are qualified by the value of
|
||
the bInterfaceClass and the
|
||
bInterfaceSubClass fields. If an interface
|
||
supports class-specific requests, this code
|
||
identifies the protocols that the device
|
||
uses as defined by the specification of the
|
||
device class. \n
|
||
If this field is reset to zero, the device
|
||
does not use a class-specific protocol on
|
||
this interface. \n
|
||
If this field is set to FFH, the device uses
|
||
a vendor-specific protocol for this
|
||
interface.*/
|
||
uint8_t iInterface; /**< Index of string descriptor describing this interface*/
|
||
} ;
|
||
/** USB Standard Interface Descriptor */
|
||
typedef struct _USB_INTERFACE_DESCRIPTOR USB_INTERFACE_DESCRIPTOR;
|
||
|
||
/** USB Standard Endpoint Descriptor */
|
||
PRE_PACK struct POST_PACK _USB_ENDPOINT_DESCRIPTOR
|
||
{
|
||
uint8_t bLength; /**< Size of this descriptor in bytes*/
|
||
uint8_t bDescriptorType; /**< ENDPOINT Descriptor Type*/
|
||
uint8_t bEndpointAddress; /**< The address of the endpoint on the USB device
|
||
described by this descriptor. The address is
|
||
encoded as follows: \n
|
||
Bit 3...0: The endpoint number \n
|
||
Bit 6...4: Reserved, reset to zero \n
|
||
Bit 7: Direction, ignored for control endpoints
|
||
0 = OUT endpoint
|
||
1 = IN endpoint. \n \sa USBD_ENDPOINT_ADR_Type*/
|
||
uint8_t bmAttributes; /**< This field describes the endpoint<6E>s attributes when it is
|
||
configured using the bConfigurationValue. \n
|
||
Bits 1..0: Transfer Type
|
||
\li 00 = Control
|
||
\li 01 = Isochronous
|
||
\li 10 = Bulk
|
||
\li 11 = Interrupt \n
|
||
If not an isochronous endpoint, bits 5..2 are reserved
|
||
and must be set to zero. If isochronous, they are
|
||
defined as follows: \n
|
||
Bits 3..2: Synchronization Type
|
||
\li 00 = No Synchronization
|
||
\li 01 = Asynchronous
|
||
\li 10 = Adaptive
|
||
\li 11 = Synchronous \n
|
||
Bits 5..4: Usage Type
|
||
\li 00 = Data endpoint
|
||
\li 01 = Feedback endpoint
|
||
\li 10 = Implicit feedback Data endpoint
|
||
\li 11 = Reserved \n
|
||
Refer to Chapter 5 of USB 2.0 specification for more information. \n
|
||
All other bits are reserved and must be reset to zero.
|
||
Reserved bits must be ignored by the host.
|
||
\n \sa USBD_EP_ATTR_Type*/
|
||
uint16_t wMaxPacketSize; /**< Maximum packet size this endpoint is capable of
|
||
sending or receiving when this configuration is
|
||
selected. \n
|
||
For isochronous endpoints, this value is used to
|
||
reserve the bus time in the schedule, required for the
|
||
per-(micro)frame data payloads. The pipe may, on an
|
||
ongoing basis, actually use less bandwidth than that
|
||
reserved. The device reports, if necessary, the actual
|
||
bandwidth used via its normal, non-USB defined
|
||
mechanisms. \n
|
||
For all endpoints, bits 10..0 specify the maximum
|
||
packet size (in bytes). \n
|
||
For high-speed isochronous and interrupt endpoints: \n
|
||
Bits 12..11 specify the number of additional transaction
|
||
opportunities per microframe: \n
|
||
\li 00 = None (1 transaction per microframe)
|
||
\li 01 = 1 additional (2 per microframe)
|
||
\li 10 = 2 additional (3 per microframe)
|
||
\li 11 = Reserved \n
|
||
Bits 15..13 are reserved and must be set to zero.*/
|
||
uint8_t bInterval; /**< Interval for polling endpoint for data transfers.
|
||
Expressed in frames or microframes depending on the
|
||
device operating speed (i.e., either 1 millisecond or
|
||
125 <20>s units).
|
||
\li For full-/high-speed isochronous endpoints, this value
|
||
must be in the range from 1 to 16. The bInterval value
|
||
is used as the exponent for a \f$ 2^(bInterval-1) \f$ value; e.g., a
|
||
bInterval of 4 means a period of 8 (\f$ 2^(4-1) \f$).
|
||
\li For full-/low-speed interrupt endpoints, the value of
|
||
this field may be from 1 to 255.
|
||
\li For high-speed interrupt endpoints, the bInterval value
|
||
is used as the exponent for a \f$ 2^(bInterval-1) \f$ value; e.g., a
|
||
bInterval of 4 means a period of 8 (\f$ 2^(4-1) \f$) . This value
|
||
must be from 1 to 16.
|
||
\li For high-speed bulk/control OUT endpoints, the
|
||
bInterval must specify the maximum NAK rate of the
|
||
endpoint. A value of 0 indicates the endpoint never
|
||
NAKs. Other values indicate at most 1 NAK each
|
||
bInterval number of microframes. This value must be
|
||
in the range from 0 to 255. \n
|
||
Refer to Chapter 5 of USB 2.0 specification for more information.
|
||
*/
|
||
} ;
|
||
/** USB Standard Endpoint Descriptor */
|
||
typedef struct _USB_ENDPOINT_DESCRIPTOR USB_ENDPOINT_DESCRIPTOR;
|
||
|
||
/** USB String Descriptor */
|
||
PRE_PACK struct POST_PACK _USB_STRING_DESCRIPTOR
|
||
{
|
||
uint8_t bLength; /**< Size of this descriptor in bytes*/
|
||
uint8_t bDescriptorType; /**< STRING Descriptor Type*/
|
||
uint16_t bString/*[]*/; /**< UNICODE encoded string */
|
||
} ;
|
||
/** USB String Descriptor */
|
||
typedef struct _USB_STRING_DESCRIPTOR USB_STRING_DESCRIPTOR;
|
||
|
||
/** USB Common Descriptor */
|
||
PRE_PACK struct POST_PACK _USB_COMMON_DESCRIPTOR
|
||
{
|
||
uint8_t bLength; /**< Size of this descriptor in bytes*/
|
||
uint8_t bDescriptorType; /**< Descriptor Type*/
|
||
} ;
|
||
/** USB Common Descriptor */
|
||
typedef struct _USB_COMMON_DESCRIPTOR USB_COMMON_DESCRIPTOR;
|
||
|
||
/** USB Other Speed Configuration */
|
||
PRE_PACK struct POST_PACK _USB_OTHER_SPEED_CONFIGURATION
|
||
{
|
||
uint8_t bLength; /**< Size of descriptor*/
|
||
uint8_t bDescriptorType; /**< Other_speed_Configuration Type*/
|
||
uint16_t wTotalLength; /**< Total length of data returned*/
|
||
uint8_t bNumInterfaces; /**< Number of interfaces supported by this speed configuration*/
|
||
uint8_t bConfigurationValue; /**< Value to use to select configuration*/
|
||
uint8_t IConfiguration; /**< Index of string descriptor*/
|
||
uint8_t bmAttributes; /**< Same as Configuration descriptor*/
|
||
uint8_t bMaxPower; /**< Same as Configuration descriptor*/
|
||
} ;
|
||
/** USB Other Speed Configuration */
|
||
typedef struct _USB_OTHER_SPEED_CONFIGURATION USB_OTHER_SPEED_CONFIGURATION;
|
||
|
||
/** \ingroup USBD_Core
|
||
* USB device stack/module handle.
|
||
*/
|
||
typedef void* USBD_HANDLE_T;
|
||
|
||
/** @}*/
|
||
|
||
#endif /* __USB_H__ */
|