Merge branch 'master' into fork/HiFiPhile/xfer_close

49 files changed, 8027 insertions, 5169 deletions

diff --git a/src/class/audio/audio.h b/src/class/audio/audio.h
index 0d1acadcc..cff38cc22 100644
--- a/src/class/audio/audio.h
+++ b/src/class/audio/audio.h
@@ -30,8 +30,8 @@
  *            Currently only MIDI subclass is supported
  *  @{ */
 
-#ifndef _TUSB_AUDIO_H__
-#define _TUSB_AUDIO_H__
+#ifndef TUSB_AUDIO_H__
+#define TUSB_AUDIO_H__
 
 #include "common/tusb_common.h"
 
@@ -39,917 +39,1255 @@
 extern "C" {
 #endif
 
-/// Audio Device Class Codes
+//--------------------------------------------------------------------+
+// GENERIC AUDIO CLASS CODES (COMMON TO UAC1 AND UAC2)
+//--------------------------------------------------------------------+
 
 /// A.2 - Audio Function Subclass Codes
-typedef enum
-{
+typedef enum {
   AUDIO_FUNCTION_SUBCLASS_UNDEFINED = 0x00,
 } audio_function_subclass_type_t;
 
 /// A.3 - Audio Function Protocol Codes
-typedef enum
-{
-  AUDIO_FUNC_PROTOCOL_CODE_UNDEF       = 0x00,
-  AUDIO_FUNC_PROTOCOL_CODE_V2          = 0x20, ///< Version 2.0
+typedef enum {
+  AUDIO_FUNC_PROTOCOL_CODE_UNDEF = 0x00,
+  AUDIO_FUNC_PROTOCOL_CODE_V1 = 0x00,///< Version 1.0 - same as undefined for backward compatibility
+  AUDIO_FUNC_PROTOCOL_CODE_V2 = 0x20,///< Version 2.0
 } audio_function_protocol_code_t;
 
 /// A.5 - Audio Interface Subclass Codes
-typedef enum
-{
+typedef enum {
   AUDIO_SUBCLASS_UNDEFINED = 0x00,
-  AUDIO_SUBCLASS_CONTROL         , ///< Audio Control
-  AUDIO_SUBCLASS_STREAMING       , ///< Audio Streaming
-  AUDIO_SUBCLASS_MIDI_STREAMING  , ///< MIDI Streaming
+  AUDIO_SUBCLASS_CONTROL,       ///< Audio Control
+  AUDIO_SUBCLASS_STREAMING,     ///< Audio Streaming
+  AUDIO_SUBCLASS_MIDI_STREAMING,///< MIDI Streaming
 } audio_subclass_type_t;
 
 /// A.6 - Audio Interface Protocol Codes
-typedef enum
-{
-  AUDIO_INT_PROTOCOL_CODE_UNDEF       = 0x00,
-  AUDIO_INT_PROTOCOL_CODE_V2          = 0x20, ///< Version 2.0
+typedef enum {
+  AUDIO_INT_PROTOCOL_CODE_UNDEF = 0x00,
+  AUDIO_INT_PROTOCOL_CODE_V1 = 0x00,///< Version 1.0 - same as undefined for backward compatibility
+  AUDIO_INT_PROTOCOL_CODE_V2 = 0x20,///< Version 2.0
 } audio_interface_protocol_code_t;
 
+/// Terminal Types
+
+/// 2.1 - Audio Class-Terminal Types
+typedef enum {
+  AUDIO_TERM_TYPE_USB_UNDEFINED = 0x0100,
+  AUDIO_TERM_TYPE_USB_STREAMING = 0x0101,
+  AUDIO_TERM_TYPE_USB_VENDOR_SPEC = 0x01FF,
+} audio_terminal_type_t;
+
+/// 2.2 - Audio Class-Input Terminal Types
+typedef enum {
+  AUDIO_TERM_TYPE_IN_UNDEFINED = 0x0200,
+  AUDIO_TERM_TYPE_IN_GENERIC_MIC = 0x0201,
+  AUDIO_TERM_TYPE_IN_DESKTOP_MIC = 0x0202,
+  AUDIO_TERM_TYPE_IN_PERSONAL_MIC = 0x0203,
+  AUDIO_TERM_TYPE_IN_OMNI_MIC = 0x0204,
+  AUDIO_TERM_TYPE_IN_ARRAY_MIC = 0x0205,
+  AUDIO_TERM_TYPE_IN_PROC_ARRAY_MIC = 0x0206,
+} audio_terminal_input_type_t;
+
+/// 2.3 - Audio Class-Output Terminal Types
+typedef enum {
+  AUDIO_TERM_TYPE_OUT_UNDEFINED = 0x0300,
+  AUDIO_TERM_TYPE_OUT_GENERIC_SPEAKER = 0x0301,
+  AUDIO_TERM_TYPE_OUT_HEADPHONES = 0x0302,
+  AUDIO_TERM_TYPE_OUT_HEAD_MNT_DISP_AUIDO = 0x0303,
+  AUDIO_TERM_TYPE_OUT_DESKTOP_SPEAKER = 0x0304,
+  AUDIO_TERM_TYPE_OUT_ROOM_SPEAKER = 0x0305,
+  AUDIO_TERM_TYPE_OUT_COMMUNICATION_SPEAKER = 0x0306,
+  AUDIO_TERM_TYPE_OUT_LOW_FRQ_EFFECTS_SPEAKER = 0x0307,
+} audio_terminal_output_type_t;
+
+/// Rest is yet to be implemented
+
+//--------------------------------------------------------------------+
+// USB AUDIO CLASS 1.0 (UAC1) DEFINITIONS
+//--------------------------------------------------------------------+
+
+/// A.5 - Audio Class-Specific AC Interface Descriptor Subtypes UAC1
+typedef enum {
+  AUDIO10_CS_AC_INTERFACE_AC_DESCRIPTOR_UNDEF = 0x00,
+  AUDIO10_CS_AC_INTERFACE_HEADER = 0x01,
+  AUDIO10_CS_AC_INTERFACE_INPUT_TERMINAL = 0x02,
+  AUDIO10_CS_AC_INTERFACE_OUTPUT_TERMINAL = 0x03,
+  AUDIO10_CS_AC_INTERFACE_MIXER_UNIT = 0x04,
+  AUDIO10_CS_AC_INTERFACE_SELECTOR_UNIT = 0x05,
+  AUDIO10_CS_AC_INTERFACE_FEATURE_UNIT = 0x06,
+  AUDIO10_CS_AC_INTERFACE_PROCESSING_UNIT = 0x07,
+  AUDIO10_CS_AC_INTERFACE_EXTENSION_UNIT = 0x08,
+} audio10_cs_ac_interface_subtype_t;
+
+/// A.6 - Audio Class-Specific AS Interface Descriptor Subtypes UAC1
+typedef enum {
+  AUDIO10_CS_AS_INTERFACE_AS_DESCRIPTOR_UNDEF = 0x00,
+  AUDIO10_CS_AS_INTERFACE_AS_GENERAL = 0x01,
+  AUDIO10_CS_AS_INTERFACE_FORMAT_TYPE = 0x02,
+} audio10_cs_as_interface_subtype_t;
+
+/// A.8 - Audio Class-Specific EP Descriptor Subtypes UAC1
+typedef enum {
+  AUDIO10_CS_EP_SUBTYPE_UNDEF = 0x00,
+  AUDIO10_CS_EP_SUBTYPE_GENERAL = 0x01,
+} audio10_cs_ep_subtype_t;
+
+/// A.9 - Audio Class-Specific Request Codes UAC1
+typedef enum {
+  AUDIO10_CS_REQ_UNDEF = 0x00,
+  AUDIO10_CS_REQ_SET_CUR = 0x01,
+  AUDIO10_CS_REQ_GET_CUR = 0x81,
+  AUDIO10_CS_REQ_SET_MIN = 0x02,
+  AUDIO10_CS_REQ_GET_MIN = 0x82,
+  AUDIO10_CS_REQ_SET_MAX = 0x03,
+  AUDIO10_CS_REQ_GET_MAX = 0x83,
+  AUDIO10_CS_REQ_SET_RES = 0x04,
+  AUDIO10_CS_REQ_GET_RES = 0x84,
+  AUDIO10_CS_REQ_SET_MEM = 0x05,
+  AUDIO10_CS_REQ_GET_MEM = 0x85,
+  AUDIO10_CS_REQ_GET_STAT = 0xFF,
+} audio10_cs_req_t;
+
+/// A.10.1 - Terminal Control Selectors UAC1
+typedef enum {
+  AUDIO10_TE_CTRL_UNDEF = 0x00,
+  AUDIO10_TE_CTRL_COPY_PROTECT = 0x01,
+} audio10_terminal_control_selector_t;
+
+/// A.10.2 - Feature Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_FU_CTRL_UNDEF = 0x00,
+  AUDIO10_FU_CTRL_MUTE = 0x01,
+  AUDIO10_FU_CTRL_VOLUME = 0x02,
+  AUDIO10_FU_CTRL_BASS = 0x03,
+  AUDIO10_FU_CTRL_MID = 0x04,
+  AUDIO10_FU_CTRL_TREBLE = 0x05,
+  AUDIO10_FU_CTRL_GRAPHIC_EQUALIZER = 0x06,
+  AUDIO10_FU_CTRL_AGC = 0x07,
+  AUDIO10_FU_CTRL_DELAY = 0x08,
+  AUDIO10_FU_CTRL_BASS_BOOST = 0x09,
+  AUDIO10_FU_CTRL_LOUDNESS = 0x0A,
+} audio10_feature_unit_control_selector_t;
+
+/// A.10.3.1 - Up/Down-mix Processing Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_UD_CTRL_UNDEF = 0x00,
+  AUDIO10_UD_CTRL_ENABLE = 0x01,
+  AUDIO10_UD_CTRL_MODE_SELECT = 0x02,
+} audio10_up_down_mix_control_selector_t;
+
+/// A.10.3.2 - Dolby Prologic Processing Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_DP_CTRL_UNDEF = 0x00,
+  AUDIO10_DP_CTRL_ENABLE = 0x01,
+  AUDIO10_DP_CTRL_MODE_SELECT = 0x02,
+} audio10_dolby_prologic_control_selector_t;
+
+/// A.10.3.3 - 3D Stereo Extender Processing Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_3D_CTRL_UNDEF = 0x00,
+  AUDIO10_3D_CTRL_ENABLE = 0x01,
+  AUDIO10_3D_CTRL_SPACIOUSNESS = 0x02,
+} audio10_3d_stereo_extender_control_selector_t;
+
+/// A.10.3.4 - Reverberation Processing Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_RV_CTRL_UNDEF = 0x00,
+  AUDIO10_RV_CTRL_ENABLE = 0x01,
+  AUDIO10_RV_CTRL_REVERB_LEVEL = 0x02,
+  AUDIO10_RV_CTRL_REVERB_TIME = 0x03,
+  AUDIO10_RV_CTRL_REVERB_FEEDBACK = 0x04,
+} audio10_reverberation_control_selector_t;
+
+/// A.10.3.5 - Chorus Processing Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_CH_CTRL_UNDEF = 0x00,
+  AUDIO10_CH_CTRL_ENABLE = 0x01,
+  AUDIO10_CH_CTRL_CHORUS_LEVEL = 0x02,
+  AUDIO10_CH_CTRL_CHORUS_RATE = 0x03,
+  AUDIO10_CH_CTRL_CHORUS_DEPTH = 0x04,
+} audio10_chorus_control_selector_t;
+
+/// A.10.3.6 - Dynamic Range Compressor Processing Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_DR_CTRL_UNDEF = 0x00,
+  AUDIO10_DR_CTRL_ENABLE = 0x01,
+  AUDIO10_DR_CTRL_COMPRESSION_RATE = 0x02,
+  AUDIO10_DR_CTRL_MAXAMPL = 0x03,
+  AUDIO10_DR_CTRL_THRESHOLD = 0x04,
+  AUDIO10_DR_CTRL_ATTACK_TIME = 0x05,
+  AUDIO10_DR_CTRL_RELEASE_TIME = 0x06,
+} audio10_dynamic_range_compression_control_selector_t;
+
+/// A.10.4 - Extension Unit Control Selectors UAC1
+typedef enum {
+  AUDIO10_XU_CTRL_UNDEF = 0x00,
+  AUDIO10_XU_CTRL_ENABLE = 0x01,
+} audio10_extension_unit_control_selector_t;
+
+/// A.10.5 - Endpoint Control Selectors UAC1
+typedef enum {
+  AUDIO10_EP_CTRL_UNDEF = 0x00,
+  AUDIO10_EP_CTRL_SAMPLING_FREQ = 0x01,
+  AUDIO10_EP_CTRL_PITCH = 0x02,
+} audio10_ep_control_selector_t;
+
+/// Audio Class-Specific AS Isochronous Data EP Attributes UAC1
+typedef enum {
+  AUDIO10_CS_AS_ISO_DATA_EP_ATT_MAX_PACKETS_ONLY = 0x80,
+  AUDIO10_CS_AS_ISO_DATA_EP_ATT_NON_MAX_PACKETS_OK = 0x00,
+  AUDIO10_CS_AS_ISO_DATA_EP_ATT_SAMPLING_FRQ = 0x01,
+  AUDIO10_CS_AS_ISO_DATA_EP_ATT_PITCH = 0x02,
+} audio10_cs_as_iso_data_ep_attribute_t;
+
+/// Audio Class-Specific AS Isochronous Data EP Lock Delay Units UAC1
+typedef enum {
+  AUDIO10_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_UNDEFINED = 0x00,
+  AUDIO10_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_MILLISEC = 0x01,
+  AUDIO10_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_PCM_SAMPLES = 0x02,
+} audio10_cs_as_iso_data_ep_lock_delay_unit_t;
+
+/// Audio Class-Feature Unit Controls UAC1
+typedef enum {
+  AUDIO10_FU_CONTROL_BM_MUTE = 1 << 0,
+  AUDIO10_FU_CONTROL_BM_VOLUME = 1 << 1,
+  AUDIO10_FU_CONTROL_BM_BASS = 1 << 2,
+  AUDIO10_FU_CONTROL_BM_MID = 1 << 3,
+  AUDIO10_FU_CONTROL_BM_TREBLE = 1 << 4,
+  AUDIO10_FU_CONTROL_BM_GRAPHIC_EQUALIZER = 1 << 5,
+  AUDIO10_FU_CONTROL_BM_AGC = 1 << 6,
+  AUDIO10_FU_CONTROL_BM_DELAY = 1 << 7,
+  AUDIO10_FU_CONTROL_BM_BASS_BOOST = 1 << 8,
+  AUDIO10_FU_CONTROL_BM_LOUDNESS = 1 << 9,
+} audio10_feature_unit_control_bitmap_t;
+
+/// A.1 - Audio Class-Format Type Codes UAC1
+typedef enum {
+  AUDIO10_FORMAT_TYPE_UNDEFINED = 0x00,
+  AUDIO10_FORMAT_TYPE_I = 0x01,
+  AUDIO10_FORMAT_TYPE_II = 0x02,
+  AUDIO10_FORMAT_TYPE_III = 0x03,
+} audio10_format_type_t;
+
+// A.1.1 - Audio Class-Audio Data Format Type I UAC1
+typedef enum {
+  AUDIO10_DATA_FORMAT_TYPE_I_PCM = 0x0001,
+  AUDIO10_DATA_FORMAT_TYPE_I_PCM8 = 0x0002,
+  AUDIO10_DATA_FORMAT_TYPE_I_IEEE_FLOAT = 0x0003,
+  AUDIO10_DATA_FORMAT_TYPE_I_ALAW = 0x0004,
+  AUDIO10_DATA_FORMAT_TYPE_I_MULAW = 0x0005,
+} audio10_data_format_type_I_t;
+
+// A.1.2 - Audio Class-Audio Data Format Type II UAC1
+typedef enum {
+  AUDIO10_DATA_FORMAT_TYPE_II_MPEG = 0x1001,
+  AUDIO10_DATA_FORMAT_TYPE_II_AC3 = 0x1002,
+} audio10_data_format_type_II_t;
+
+// A.1.3 - Audio Class-Audio Data Format Type III UAC1
+typedef enum {
+  AUDIO10_DATA_FORMAT_TYPE_III_IEC1937_AC3_1 = 0x2001,
+  AUDIO10_DATA_FORMAT_TYPE_III_IEC1937_MPEG1_L1_1 = 0x2002,
+  AUDIO10_DATA_FORMAT_TYPE_III_IEC1937_MPEG1_L23_1 = 0x2003,
+  AUDIO10_DATA_FORMAT_TYPE_III_IEC1937_MPEG2_EXT_1 = 0x2004,
+  AUDIO10_DATA_FORMAT_TYPE_III_IEC1937_MPEG2_L1_LS_1 = 0x2005,
+  AUDIO10_DATA_FORMAT_TYPE_III_IEC1937_MPEG2_L23_LS_1 = 0x2006,
+} audio10_data_format_type_III_t;
+
+/// Audio Class-Audio Channel Configuration UAC1 (Table A-7)
+typedef enum {
+  AUDIO10_CHANNEL_CONFIG_NON_PREDEFINED = 0x0000,
+  AUDIO10_CHANNEL_CONFIG_LEFT_FRONT = 0x0001,
+  AUDIO10_CHANNEL_CONFIG_RIGHT_FRONT = 0x0002,
+  AUDIO10_CHANNEL_CONFIG_CENTER_FRONT = 0x0004,
+  AUDIO10_CHANNEL_CONFIG_LOW_FRQ_EFFECTS = 0x0008,
+  AUDIO10_CHANNEL_CONFIG_LEFT_SURROUND = 0x0010,
+  AUDIO10_CHANNEL_CONFIG_RIGHT_SURROUND = 0x0020,
+  AUDIO10_CHANNEL_CONFIG_LEFT_OF_CENTER = 0x0040,
+  AUDIO10_CHANNEL_CONFIG_RIGHT_OF_CENTER = 0x0080,
+  AUDIO10_CHANNEL_CONFIG_SURROUND = 0x0100,
+  AUDIO10_CHANNEL_CONFIG_SIDE_LEFT = 0x0200,
+  AUDIO10_CHANNEL_CONFIG_SIDE_RIGHT = 0x0400,
+  AUDIO10_CHANNEL_CONFIG_TOP = 0x0800,
+} audio10_channel_config_t;
+
+
+//--------------------------------------------------------------------+
+// USB AUDIO CLASS 1.0 (UAC1) DESCRIPTORS
+//--------------------------------------------------------------------+
+
+/// AUDIO Class-Specific AC Interface Header Descriptor UAC1 (4.3.2)
+#define audio10_desc_cs_ac_interface_n_t(numInterfaces)                                                                                          \
+  struct TU_ATTR_PACKED {                                                                                                                        \
+    uint8_t bLength;                      /* Size of this descriptor in bytes: 8+n. */                                                           \
+    uint8_t bDescriptorType;              /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                                  \
+    uint8_t bDescriptorSubType;           /* Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_HEADER. */                                       \
+    uint16_t bcdADC;                      /* Audio Device Class Specification Release Number in Binary-Coded Decimal. Value: 0x0100 for UAC1. */ \
+    uint16_t wTotalLength;                /* Total number of bytes returned for the class-specific AudioControl interface descriptor. */         \
+    uint8_t bInCollection;                /* The number of AudioStreaming and MIDIStreaming interfaces in the Audio Interface Collection. */     \
+    uint8_t baInterfaceNr[numInterfaces]; /* Interface number of the AudioStreaming or MIDIStreaming interface in the Collection. */             \
+  }
+
+/// AUDIO Input Terminal Descriptor UAC1 (4.3.2.1)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor in bytes: 12.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_INPUT_TERMINAL.
+  uint8_t bTerminalID;       ///< Constant uniquely identifying the Terminal within the audio function.
+  uint16_t wTerminalType;    ///< Constant characterizing the type of Terminal.
+  uint8_t bAssocTerminal;    ///< ID of the Output Terminal to which this Input Terminal is associated.
+  uint8_t bNrChannels;       ///< Number of logical output channels in the Terminal's output audio channel cluster.
+  uint16_t wChannelConfig;   ///< Describes the spatial location of the logical channels.
+  uint8_t iChannelNames;     ///< Index of a string descriptor, describing the name of the first logical channel.
+  uint8_t iTerminal;         ///< Index of a string descriptor, describing the Input Terminal.
+} audio10_desc_input_terminal_t;
+
+/// AUDIO Output Terminal Descriptor UAC1 (4.3.2.2)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor in bytes: 9.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_OUTPUT_TERMINAL.
+  uint8_t bTerminalID;       ///< Constant uniquely identifying the Terminal within the audio function.
+  uint16_t wTerminalType;    ///< Constant characterizing the type of Terminal.
+  uint8_t bAssocTerminal;    ///< Constant, identifying the Input Terminal to which this Output Terminal is associated.
+  uint8_t bSourceID;         ///< ID of the Unit or Terminal to which this Terminal is connected.
+  uint8_t iTerminal;         ///< Index of a string descriptor, describing the Output Terminal.
+} audio10_desc_output_terminal_t;
+
+/// AUDIO Mixer Unit Descriptor UAC1 (4.3.2.3)
+#define audio10_desc_mixer_unit_n_t(numInputPins, numControlBytes)                                                                 \
+  struct TU_ATTR_PACKED {                                                                                                          \
+    uint8_t bLength;                     /* Size of this descriptor in bytes: 10+p+n. */                                           \
+    uint8_t bDescriptorType;             /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                     \
+    uint8_t bDescriptorSubType;          /* Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_MIXER_UNIT. */                      \
+    uint8_t bUnitID;                     /* Constant uniquely identifying the Unit within the audio function. */                   \
+    uint8_t bNrInPins;                   /* Number of Input Pins of this Unit: p. */                                               \
+    uint8_t baSourceID[numInputPins];    /* ID of the Unit or Terminal to which Input Pins of this Mixer Unit are connected. */    \
+    uint8_t bNrChannels;                 /* Number of logical output channels in the Mixer Unit's output audio channel cluster. */ \
+    uint16_t wChannelConfig;             /* Describes the spatial location of the logical channels. */                             \
+    uint8_t iChannelNames;               /* Index of a string descriptor, describing the name of the first logical channel. */     \
+    uint8_t bmControls[numControlBytes]; /* Mixer Unit Controls bitmap. */                                                         \
+    uint8_t iMixer;                      /* Index of a string descriptor, describing the Mixer Unit. */                            \
+  }
+
+/// AUDIO Selector Unit Descriptor UAC1 (4.3.2.4)
+#define audio10_desc_selector_unit_n_t(numInputPins)                                                                            \
+  struct TU_ATTR_PACKED {                                                                                                       \
+    uint8_t bLength;                  /* Size of this descriptor in bytes: 6+p. */                                              \
+    uint8_t bDescriptorType;          /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                     \
+    uint8_t bDescriptorSubType;       /* Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_SELECTOR_UNIT. */                   \
+    uint8_t bUnitID;                  /* Constant uniquely identifying the Unit within the audio function. */                   \
+    uint8_t bNrInPins;                /* Number of Input Pins of this Unit: p. */                                               \
+    uint8_t baSourceID[numInputPins]; /* ID of the Unit or Terminal to which Input Pins of this Selector Unit are connected. */ \
+    uint8_t iSelector;                /* Index of a string descriptor, describing the Selector Unit. */                         \
+  }
+
+/// AUDIO Feature Unit Descriptor UAC1 (4.3.2.5)
+#define audio10_desc_feature_unit_n_t(numChannels, controlSize)                                                                     \
+  struct TU_ATTR_PACKED {                                                                                                           \
+    uint8_t bLength;                                      /* Size of this descriptor in bytes: 7+(ch+1)*n. */                       \
+    uint8_t bDescriptorType;                              /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                     \
+    uint8_t bDescriptorSubType;                           /* Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_FEATURE_UNIT. */    \
+    uint8_t bUnitID;                                      /* Constant uniquely identifying the Unit within the audio function. */   \
+    uint8_t bSourceID;                                    /* ID of the Unit or Terminal to which this Feature Unit is connected. */ \
+    uint8_t bControlSize;                                 /* Size in bytes of an element of the bmaControls() array. */             \
+    uint8_t bmaControls[(numChannels + 1) * controlSize]; /* Control bitmaps for master + logical channels. */                      \
+    uint8_t iFeature;                                     /* Index of a string descriptor, describing this Feature Unit. */         \
+  }
+
+/// AUDIO Processing Unit Descriptor UAC1 (4.3.2.6)
+#define audio10_desc_processing_unit_n_t(numInputPins, numControlBytes)                                                                 \
+  struct TU_ATTR_PACKED {                                                                                                               \
+    uint8_t bLength;                     /* Size of this descriptor in bytes: 13+p+n. */                                                \
+    uint8_t bDescriptorType;             /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                          \
+    uint8_t bDescriptorSubType;          /* Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_PROCESSING_UNIT. */                      \
+    uint8_t bUnitID;                     /* Constant uniquely identifying the Unit within the audio function. */                        \
+    uint16_t wProcessType;               /* Constant identifying the type of processing this Unit is performing. */                     \
+    uint8_t bNrInPins;                   /* Number of Input Pins of this Unit: p. */                                                    \
+    uint8_t baSourceID[numInputPins];    /* ID of the Unit or Terminal to which Input Pins of this Processing Unit are connected. */    \
+    uint8_t bNrChannels;                 /* Number of logical output channels in the Processing Unit's output audio channel cluster. */ \
+    uint16_t wChannelConfig;             /* Describes the spatial location of the logical channels. */                                  \
+    uint8_t iChannelNames;               /* Index of a string descriptor, describing the name of the first logical channel. */          \
+    uint8_t bControlSize;                /* Size in bytes of the bmControls field. */                                                   \
+    uint8_t bmControls[numControlBytes]; /* Processing Unit Controls bitmap. */                                                         \
+    uint8_t iProcessing;                 /* Index of a string descriptor, describing the Processing Unit. */                            \
+  }
+
+/// AUDIO Extension Unit Descriptor UAC1 (4.3.2.7)
+#define audio10_desc_extension_unit_n_t(numInputPins, numControlBytes)                                                                 \
+  struct TU_ATTR_PACKED {                                                                                                              \
+    uint8_t bLength;                     /* Size of this descriptor in bytes: 13+p+n. */                                               \
+    uint8_t bDescriptorType;             /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                         \
+    uint8_t bDescriptorSubType;          /* Descriptor SubType. Value: AUDIO10_CS_AC_INTERFACE_EXTENSION_UNIT. */                      \
+    uint8_t bUnitID;                     /* Constant uniquely identifying the Unit within the audio function. */                       \
+    uint16_t wExtensionCode;             /* Vendor-specific code identifying the Extension Unit. */                                    \
+    uint8_t bNrInPins;                   /* Number of Input Pins of this Unit: p. */                                                   \
+    uint8_t baSourceID[numInputPins];    /* ID of the Unit or Terminal to which Input Pins of this Extension Unit are connected. */    \
+    uint8_t bNrChannels;                 /* Number of logical output channels in the Extension Unit's output audio channel cluster. */ \
+    uint16_t wChannelConfig;             /* Describes the spatial location of the logical channels. */                                 \
+    uint8_t iChannelNames;               /* Index of a string descriptor, describing the name of the first logical channel. */         \
+    uint8_t bControlSize;                /* Size in bytes of the bmControls field. */                                                  \
+    uint8_t bmControls[numControlBytes]; /* Extension Unit Controls bitmap. */                                                         \
+    uint8_t iExtension;                  /* Index of a string descriptor, describing the Extension Unit. */                            \
+  }
+
+/// AUDIO Class-Specific AS Interface Descriptor UAC1 (4.5.2)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor in bytes: 7.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO10_CS_AS_INTERFACE_AS_GENERAL.
+  uint8_t bTerminalLink;     ///< The Terminal ID of the Terminal to which the endpoint of this interface is connected.
+  uint8_t bDelay;            ///< Expressed in number of frames.
+  uint16_t wFormatTag;       ///< The Audio Data Format that has to be used to communicate with this interface.
+} audio10_desc_cs_as_interface_t;
+
+/// AUDIO Type I Format Type Descriptor UAC1 (2.2.5)
+#define audio10_desc_type_I_format_n_t(numSamFreq)                                                                            \
+  struct TU_ATTR_PACKED {                                                                                                     \
+    uint8_t bLength;                  /* Size of this descriptor in bytes: 8+(ns*3). */                                       \
+    uint8_t bDescriptorType;          /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                   \
+    uint8_t bDescriptorSubType;       /* Descriptor SubType. Value: AUDIO10_CS_AS_INTERFACE_FORMAT_TYPE. */                   \
+    uint8_t bFormatType;              /* Constant identifying the Format Type the AudioStreaming interface is using. */       \
+    uint8_t bNrChannels;              /* Indicates the number of physical channels in the audio data stream. */               \
+    uint8_t bSubFrameSize;            /* The number of bytes occupied by one audio subframe. */                               \
+    uint8_t bBitResolution;           /* The number of effectively used bits from the available bits in an audio subframe. */ \
+    uint8_t bSamFreqType;             /* Indicates how the sampling frequency can be programmed. */                           \
+    uint8_t tSamFreq[numSamFreq * 3]; /* Sampling frequency or lower/upper bounds in Hz for the sampling frequency range. */  \
+  }
+
+/// AUDIO Type II Format Type Descriptor UAC1 (2.3.5)
+#define audio10_desc_type_II_format_n_t(numSamFreq)                                                                          \
+  struct TU_ATTR_PACKED {                                                                                                    \
+    uint8_t bLength;                  /* Size of this descriptor in bytes: 9+(ns*3). */                                      \
+    uint8_t bDescriptorType;          /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                  \
+    uint8_t bDescriptorSubType;       /* Descriptor SubType. Value: AUDIO10_CS_AS_INTERFACE_FORMAT_TYPE. */                  \
+    uint8_t bFormatType;              /* Constant identifying the Format Type the AudioStreaming interface is using. */      \
+    uint16_t wMaxBitRate;             /* Indicates the maximum number of bits per second this interface can handle. */       \
+    uint16_t wSamplesPerFrame;        /* Indicates the number of PCM audio samples contained in one encoded audio frame. */  \
+    uint8_t bSamFreqType;             /* Indicates how the sampling frequency can be programmed. */                          \
+    uint8_t tSamFreq[numSamFreq * 3]; /* Sampling frequency or lower/upper bounds in Hz for the sampling frequency range. */ \
+  }
+
+/// AUDIO Type III Format Type Descriptor UAC1 (2.4.5)
+#define audio10_desc_type_III_format_n_t(numSamFreq)                                                                          \
+  struct TU_ATTR_PACKED {                                                                                                     \
+    uint8_t bLength;                  /* Size of this descriptor in bytes: 8+(ns*3). */                                       \
+    uint8_t bDescriptorType;          /* Descriptor Type. Value: TUSB_DESC_CS_INTERFACE. */                                   \
+    uint8_t bDescriptorSubType;       /* Descriptor SubType. Value: AUDIO10_CS_AS_INTERFACE_FORMAT_TYPE. */                   \
+    uint8_t bFormatType;              /* Constant identifying the Format Type the AudioStreaming interface is using. */       \
+    uint8_t bNrChannels;              /* Indicates the number of physical channels in the audio data stream. */               \
+    uint8_t bSubFrameSize;            /* The number of bytes occupied by one audio subframe. */                               \
+    uint8_t bBitResolution;           /* The number of effectively used bits from the available bits in an audio subframe. */ \
+    uint8_t bSamFreqType;             /* Indicates how the sampling frequency can be programmed. */                           \
+    uint8_t tSamFreq[numSamFreq * 3]; /* Sampling frequency or lower/upper bounds in Hz for the sampling frequency range. */  \
+  }
+
+/// Standard AS Isochronous Audio Data Endpoint Descriptor UAC1 (4.6.1.1)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;         ///< Size of this descriptor in bytes: 9.
+  uint8_t bDescriptorType; ///< Descriptor Type. Value: TUSB_DESC_ENDPOINT.
+  uint8_t bEndpointAddress;///< The address of the endpoint on the USB device described by this descriptor.
+  struct TU_ATTR_PACKED {
+    uint8_t xfer  : 2;        // Control, ISO, Bulk, Interrupt
+    uint8_t sync  : 2;        // None, Asynchronous, Adaptive, Synchronous
+    uint8_t usage : 2;        // Data, Feedback, Implicit feedback
+    uint8_t       : 2;
+  } bmAttributes;
+  uint16_t wMaxPacketSize; ///< Maximum packet size this endpoint is capable of sending or receiving when this configuration is selected.
+  uint8_t bInterval;       ///< Interval for polling endpoint for data transfers.
+  uint8_t bRefresh;        ///< The rate at which the endpoint is refreshed.
+  uint8_t bSynchAddress;   ///< The address of the endpoint used to send synchronization information for the data endpoint.
+} audio10_desc_as_iso_data_ep_t;
+
+/// AUDIO Class-Specific AS Isochronous Audio Data Endpoint Descriptor UAC1 (4.6.1.2)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor in bytes: 7.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_ENDPOINT.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO10_CS_EP_SUBTYPE_GENERAL.
+  uint8_t bmAttributes;      ///< Bit 0: Sampling Frequency, Bit 1: Pitch, Bit 7: MaxPacketsOnly.
+  uint8_t bLockDelayUnits;   ///< Indicates the units used for the wLockDelay field.
+  uint16_t wLockDelay;       ///< Indicates the time it takes this endpoint to reliably lock its internal clock recovery circuitry.
+} audio10_desc_cs_as_iso_data_ep_t;
+
+/// AUDIO Interrupt Data Message Format UAC1 (3.7.1.2)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bStatusType;///< Indicates the type of status information being reported.
+  uint8_t bOriginator;///< Indicates the entity that originated this status information.
+} audio10_interrupt_data_t;
+
+//--------------------------------------------------------------------+
+// USB AUDIO CLASS 2.0 (UAC2) DEFINITIONS
+//--------------------------------------------------------------------+
+
 /// A.7 - Audio Function Category Codes
-typedef enum
-{
-  AUDIO_FUNC_UNDEF              = 0x00,
-  AUDIO_FUNC_DESKTOP_SPEAKER    = 0x01,
-  AUDIO_FUNC_HOME_THEATER       = 0x02,
-  AUDIO_FUNC_MICROPHONE         = 0x03,
-  AUDIO_FUNC_HEADSET            = 0x04,
-  AUDIO_FUNC_TELEPHONE          = 0x05,
-  AUDIO_FUNC_CONVERTER          = 0x06,
-  AUDIO_FUNC_SOUND_RECODER      = 0x07,
-  AUDIO_FUNC_IO_BOX             = 0x08,
-  AUDIO_FUNC_MUSICAL_INSTRUMENT = 0x09,
-  AUDIO_FUNC_PRO_AUDIO          = 0x0A,
-  AUDIO_FUNC_AUDIO_VIDEO        = 0x0B,
-  AUDIO_FUNC_CONTROL_PANEL      = 0x0C,
-  AUDIO_FUNC_OTHER              = 0xFF,
-} audio_function_code_t;
+typedef enum {
+  AUDIO20_FUNC_UNDEF = 0x00,
+  AUDIO20_FUNC_DESKTOP_SPEAKER = 0x01,
+  AUDIO20_FUNC_HOME_THEATER = 0x02,
+  AUDIO20_FUNC_MICROPHONE = 0x03,
+  AUDIO20_FUNC_HEADSET = 0x04,
+  AUDIO20_FUNC_TELEPHONE = 0x05,
+  AUDIO20_FUNC_CONVERTER = 0x06,
+  AUDIO20_FUNC_SOUND_RECODER = 0x07,
+  AUDIO20_FUNC_IO_BOX = 0x08,
+  AUDIO20_FUNC_MUSICAL_INSTRUMENT = 0x09,
+  AUDIO20_FUNC_PRO_AUDIO = 0x0A,
+  AUDIO20_FUNC_AUDIO_VIDEO = 0x0B,
+  AUDIO20_FUNC_CONTROL_PANEL = 0x0C,
+  AUDIO20_FUNC_OTHER = 0xFF,
+} audio20_function_code_t;
 
 /// A.9 - Audio Class-Specific AC Interface Descriptor Subtypes UAC2
-typedef enum
-{
-  AUDIO_CS_AC_INTERFACE_AC_DESCRIPTOR_UNDEF   = 0x00,
-  AUDIO_CS_AC_INTERFACE_HEADER                = 0x01,
-  AUDIO_CS_AC_INTERFACE_INPUT_TERMINAL        = 0x02,
-  AUDIO_CS_AC_INTERFACE_OUTPUT_TERMINAL       = 0x03,
-  AUDIO_CS_AC_INTERFACE_MIXER_UNIT            = 0x04,
-  AUDIO_CS_AC_INTERFACE_SELECTOR_UNIT         = 0x05,
-  AUDIO_CS_AC_INTERFACE_FEATURE_UNIT          = 0x06,
-  AUDIO_CS_AC_INTERFACE_EFFECT_UNIT           = 0x07,
-  AUDIO_CS_AC_INTERFACE_PROCESSING_UNIT       = 0x08,
-  AUDIO_CS_AC_INTERFACE_EXTENSION_UNIT        = 0x09,
-  AUDIO_CS_AC_INTERFACE_CLOCK_SOURCE          = 0x0A,
-  AUDIO_CS_AC_INTERFACE_CLOCK_SELECTOR        = 0x0B,
-  AUDIO_CS_AC_INTERFACE_CLOCK_MULTIPLIER      = 0x0C,
-  AUDIO_CS_AC_INTERFACE_SAMPLE_RATE_CONVERTER = 0x0D,
-} audio_cs_ac_interface_subtype_t;
+typedef enum {
+  AUDIO20_CS_AC_INTERFACE_AC_DESCRIPTOR_UNDEF = 0x00,
+  AUDIO20_CS_AC_INTERFACE_HEADER = 0x01,
+  AUDIO20_CS_AC_INTERFACE_INPUT_TERMINAL = 0x02,
+  AUDIO20_CS_AC_INTERFACE_OUTPUT_TERMINAL = 0x03,
+  AUDIO20_CS_AC_INTERFACE_MIXER_UNIT = 0x04,
+  AUDIO20_CS_AC_INTERFACE_SELECTOR_UNIT = 0x05,
+  AUDIO20_CS_AC_INTERFACE_FEATURE_UNIT = 0x06,
+  AUDIO20_CS_AC_INTERFACE_EFFECT_UNIT = 0x07,
+  AUDIO20_CS_AC_INTERFACE_PROCESSING_UNIT = 0x08,
+  AUDIO20_CS_AC_INTERFACE_EXTENSION_UNIT = 0x09,
+  AUDIO20_CS_AC_INTERFACE_CLOCK_SOURCE = 0x0A,
+  AUDIO20_CS_AC_INTERFACE_CLOCK_SELECTOR = 0x0B,
+  AUDIO20_CS_AC_INTERFACE_CLOCK_MULTIPLIER = 0x0C,
+  AUDIO20_CS_AC_INTERFACE_SAMPLE_RATE_CONVERTER = 0x0D,
+} audio20_cs_ac_interface_subtype_t;
 
 /// A.10 - Audio Class-Specific AS Interface Descriptor Subtypes UAC2
-typedef enum
-{
-  AUDIO_CS_AS_INTERFACE_AS_DESCRIPTOR_UNDEF   = 0x00,
-  AUDIO_CS_AS_INTERFACE_AS_GENERAL            = 0x01,
-  AUDIO_CS_AS_INTERFACE_FORMAT_TYPE           = 0x02,
-  AUDIO_CS_AS_INTERFACE_ENCODER               = 0x03,
-  AUDIO_CS_AS_INTERFACE_DECODER               = 0x04,
-} audio_cs_as_interface_subtype_t;
+typedef enum {
+  AUDIO20_CS_AS_INTERFACE_AS_DESCRIPTOR_UNDEF = 0x00,
+  AUDIO20_CS_AS_INTERFACE_AS_GENERAL = 0x01,
+  AUDIO20_CS_AS_INTERFACE_FORMAT_TYPE = 0x02,
+  AUDIO20_CS_AS_INTERFACE_ENCODER = 0x03,
+  AUDIO20_CS_AS_INTERFACE_DECODER = 0x04,
+} audio20_cs_as_interface_subtype_t;
 
 /// A.11 - Effect Unit Effect Types
-typedef enum
-{
-  AUDIO_EFFECT_TYPE_UNDEF                     = 0x00,
-  AUDIO_EFFECT_TYPE_PARAM_EQ_SECTION          = 0x01,
-  AUDIO_EFFECT_TYPE_REVERBERATION             = 0x02,
-  AUDIO_EFFECT_TYPE_MOD_DELAY                 = 0x03,
-  AUDIO_EFFECT_TYPE_DYN_RANGE_COMP            = 0x04,
-} audio_effect_unit_effect_type_t;
+typedef enum {
+  AUDIO20_EFFECT_TYPE_UNDEF = 0x00,
+  AUDIO20_EFFECT_TYPE_PARAM_EQ_SECTION = 0x01,
+  AUDIO20_EFFECT_TYPE_REVERBERATION = 0x02,
+  AUDIO20_EFFECT_TYPE_MOD_DELAY = 0x03,
+  AUDIO20_EFFECT_TYPE_DYN_RANGE_COMP = 0x04,
+} audio20_effect_unit_effect_type_t;
 
 /// A.12 - Processing Unit Process Types
-typedef enum
-{
-  AUDIO_PROCESS_TYPE_UNDEF                    = 0x00,
-  AUDIO_PROCESS_TYPE_UP_DOWN_MIX              = 0x01,
-  AUDIO_PROCESS_TYPE_DOLBY_PROLOGIC           = 0x02,
-  AUDIO_PROCESS_TYPE_STEREO_EXTENDER          = 0x03,
-} audio_processing_unit_process_type_t;
+typedef enum {
+  AUDIO20_PROCESS_TYPE_UNDEF = 0x00,
+  AUDIO20_PROCESS_TYPE_UP_DOWN_MIX = 0x01,
+  AUDIO20_PROCESS_TYPE_DOLBY_PROLOGIC = 0x02,
+  AUDIO20_PROCESS_TYPE_STEREO_EXTENDER = 0x03,
+} audio20_processing_unit_process_type_t;
 
 /// A.13 - Audio Class-Specific EP Descriptor Subtypes UAC2
-typedef enum
-{
-  AUDIO_CS_EP_SUBTYPE_UNDEF                   = 0x00,
-  AUDIO_CS_EP_SUBTYPE_GENERAL                 = 0x01,
-} audio_cs_ep_subtype_t;
+typedef enum {
+  AUDIO20_CS_EP_SUBTYPE_UNDEF = 0x00,
+  AUDIO20_CS_EP_SUBTYPE_GENERAL = 0x01,
+} audio20_cs_ep_subtype_t;
 
-/// A.14 - Audio Class-Specific Request Codes
-typedef enum
-{
-  AUDIO_CS_REQ_UNDEF                          = 0x00,
-  AUDIO_CS_REQ_CUR                            = 0x01,
-  AUDIO_CS_REQ_RANGE                          = 0x02,
-  AUDIO_CS_REQ_MEM                            = 0x03,
-} audio_cs_req_t;
+/// A.14 - Audio Class-Specific Request Codes UAC2
+typedef enum {
+  AUDIO20_CS_REQ_UNDEF = 0x00,
+  AUDIO20_CS_REQ_CUR = 0x01,
+  AUDIO20_CS_REQ_RANGE = 0x02,
+  AUDIO20_CS_REQ_MEM = 0x03,
+} audio20_cs_req_t;
 
-/// A.17 - Control Selector Codes
+/// A.17 - Control Selector Codes UAC2
 
 /// A.17.1 - Clock Source Control Selectors
-typedef enum
-{
-  AUDIO_CS_CTRL_UNDEF                         = 0x00,
-  AUDIO_CS_CTRL_SAM_FREQ                      = 0x01,
-  AUDIO_CS_CTRL_CLK_VALID                     = 0x02,
-} audio_clock_src_control_selector_t;
+typedef enum {
+  AUDIO20_CS_CTRL_UNDEF = 0x00,
+  AUDIO20_CS_CTRL_SAM_FREQ = 0x01,
+  AUDIO20_CS_CTRL_CLK_VALID = 0x02,
+} audio20_clock_src_control_selector_t;
 
 /// A.17.2 - Clock Selector Control Selectors
-typedef enum
-{
-  AUDIO_CX_CTRL_UNDEF                         = 0x00,
-  AUDIO_CX_CTRL_CONTROL                       = 0x01,
-} audio_clock_sel_control_selector_t;
+typedef enum {
+  AUDIO20_CX_CTRL_UNDEF = 0x00,
+  AUDIO20_CX_CTRL_CONTROL = 0x01,
+} audio20_clock_sel_control_selector_t;
 
 /// A.17.3 - Clock Multiplier Control Selectors
-typedef enum
-{
-  AUDIO_CM_CTRL_UNDEF                         = 0x00,
-  AUDIO_CM_CTRL_NUMERATOR_CONTROL             = 0x01,
-  AUDIO_CM_CTRL_DENOMINATOR_CONTROL           = 0x02,
-} audio_clock_mul_control_selector_t;
+typedef enum {
+  AUDIO20_CM_CTRL_UNDEF = 0x00,
+  AUDIO20_CM_CTRL_NUMERATOR_CONTROL = 0x01,
+  AUDIO20_CM_CTRL_DENOMINATOR_CONTROL = 0x02,
+} audio20_clock_mul_control_selector_t;
 
-/// A.17.4 - Terminal Control Selectors
-typedef enum
-{
-  AUDIO_TE_CTRL_UNDEF                         = 0x00,
-  AUDIO_TE_CTRL_COPY_PROTECT                  = 0x01,
-  AUDIO_TE_CTRL_CONNECTOR                     = 0x02,
-  AUDIO_TE_CTRL_OVERLOAD                      = 0x03,
-  AUDIO_TE_CTRL_CLUSTER                       = 0x04,
-  AUDIO_TE_CTRL_UNDERFLOW                     = 0x05,
-  AUDIO_TE_CTRL_OVERFLOW                      = 0x06,
-  AUDIO_TE_CTRL_LATENCY                       = 0x07,
-} audio_terminal_control_selector_t;
+/// A.17.4 - Terminal Control Selectors UAC2
+typedef enum {
+  AUDIO20_TE_CTRL_UNDEF = 0x00,
+  AUDIO20_TE_CTRL_COPY_PROTECT = 0x01,
+  AUDIO20_TE_CTRL_CONNECTOR = 0x02,
+  AUDIO20_TE_CTRL_OVERLOAD = 0x03,
+  AUDIO20_TE_CTRL_CLUSTER = 0x04,
+  AUDIO20_TE_CTRL_UNDERFLOW = 0x05,
+  AUDIO20_TE_CTRL_OVERFLOW = 0x06,
+  AUDIO20_TE_CTRL_LATENCY = 0x07,
+} audio20_terminal_control_selector_t;
 
 /// A.17.5 - Mixer Control Selectors
-typedef enum
-{
-  AUDIO_MU_CTRL_UNDEF                         = 0x00,
-  AUDIO_MU_CTRL_MIXER                         = 0x01,
-  AUDIO_MU_CTRL_CLUSTER                       = 0x02,
-  AUDIO_MU_CTRL_UNDERFLOW                     = 0x03,
-  AUDIO_MU_CTRL_OVERFLOW                      = 0x04,
-  AUDIO_MU_CTRL_LATENCY                       = 0x05,
-} audio_mixer_control_selector_t;
+typedef enum {
+  AUDIO20_MU_CTRL_UNDEF = 0x00,
+  AUDIO20_MU_CTRL_MIXER = 0x01,
+  AUDIO20_MU_CTRL_CLUSTER = 0x02,
+  AUDIO20_MU_CTRL_UNDERFLOW = 0x03,
+  AUDIO20_MU_CTRL_OVERFLOW = 0x04,
+  AUDIO20_MU_CTRL_LATENCY = 0x05,
+} audio20_mixer_control_selector_t;
 
 /// A.17.6 - Selector Control Selectors
-typedef enum
-{
-  AUDIO_SU_CTRL_UNDEF                         = 0x00,
-  AUDIO_SU_CTRL_SELECTOR                      = 0x01,
-  AUDIO_SU_CTRL_LATENCY                       = 0x02,
-} audio_sel_control_selector_t;
+typedef enum {
+  AUDIO20_SU_CTRL_UNDEF = 0x00,
+  AUDIO20_SU_CTRL_SELECTOR = 0x01,
+  AUDIO20_SU_CTRL_LATENCY = 0x02,
+} audio20_sel_control_selector_t;
 
-/// A.17.7 - Feature Unit Control Selectors
-typedef enum
-{
-  AUDIO_FU_CTRL_UNDEF                         = 0x00,
-  AUDIO_FU_CTRL_MUTE                          = 0x01,
-  AUDIO_FU_CTRL_VOLUME                        = 0x02,
-  AUDIO_FU_CTRL_BASS                          = 0x03,
-  AUDIO_FU_CTRL_MID                           = 0x04,
-  AUDIO_FU_CTRL_TREBLE                        = 0x05,
-  AUDIO_FU_CTRL_GRAPHIC_EQUALIZER             = 0x06,
-  AUDIO_FU_CTRL_AGC                           = 0x07,
-  AUDIO_FU_CTRL_DELAY                         = 0x08,
-  AUDIO_FU_CTRL_BASS_BOOST                    = 0x09,
-  AUDIO_FU_CTRL_LOUDNESS                      = 0x0A,
-  AUDIO_FU_CTRL_INPUT_GAIN                    = 0x0B,
-  AUDIO_FU_CTRL_GAIN_PAD                      = 0x0C,
-  AUDIO_FU_CTRL_INVERTER                      = 0x0D,
-  AUDIO_FU_CTRL_UNDERFLOW                     = 0x0E,
-  AUDIO_FU_CTRL_OVERVLOW                      = 0x0F,
-  AUDIO_FU_CTRL_LATENCY                       = 0x10,
-} audio_feature_unit_control_selector_t;
+/// A.17.7 - Feature Unit Control Selectors UAC2
+typedef enum {
+  AUDIO20_FU_CTRL_UNDEF = 0x00,
+  AUDIO20_FU_CTRL_MUTE = 0x01,
+  AUDIO20_FU_CTRL_VOLUME = 0x02,
+  AUDIO20_FU_CTRL_BASS = 0x03,
+  AUDIO20_FU_CTRL_MID = 0x04,
+  AUDIO20_FU_CTRL_TREBLE = 0x05,
+  AUDIO20_FU_CTRL_GRAPHIC_EQUALIZER = 0x06,
+  AUDIO20_FU_CTRL_AGC = 0x07,
+  AUDIO20_FU_CTRL_DELAY = 0x08,
+  AUDIO20_FU_CTRL_BASS_BOOST = 0x09,
+  AUDIO20_FU_CTRL_LOUDNESS = 0x0A,
+  AUDIO20_FU_CTRL_INPUT_GAIN = 0x0B,
+  AUDIO20_FU_CTRL_GAIN_PAD = 0x0C,
+  AUDIO20_FU_CTRL_INVERTER = 0x0D,
+  AUDIO20_FU_CTRL_UNDERFLOW = 0x0E,
+  AUDIO20_FU_CTRL_OVERVLOW = 0x0F,
+  AUDIO20_FU_CTRL_LATENCY = 0x10,
+} audio20_feature_unit_control_selector_t;
 
 /// A.17.8 Effect Unit Control Selectors
 
 /// A.17.8.1 Parametric Equalizer Section Effect Unit Control Selectors
-typedef enum
-{
-  AUDIO_PE_CTRL_UNDEF                         = 0x00,
-  AUDIO_PE_CTRL_ENABLE                        = 0x01,
-  AUDIO_PE_CTRL_CENTERFREQ                    = 0x02,
-  AUDIO_PE_CTRL_QFACTOR                       = 0x03,
-  AUDIO_PE_CTRL_GAIN                          = 0x04,
-  AUDIO_PE_CTRL_UNDERFLOW                     = 0x05,
-  AUDIO_PE_CTRL_OVERFLOW                      = 0x06,
-  AUDIO_PE_CTRL_LATENCY                       = 0x07,
-} audio_parametric_equalizer_control_selector_t;
+typedef enum {
+  AUDIO20_PE_CTRL_UNDEF = 0x00,
+  AUDIO20_PE_CTRL_ENABLE = 0x01,
+  AUDIO20_PE_CTRL_CENTERFREQ = 0x02,
+  AUDIO20_PE_CTRL_QFACTOR = 0x03,
+  AUDIO20_PE_CTRL_GAIN = 0x04,
+  AUDIO20_PE_CTRL_UNDERFLOW = 0x05,
+  AUDIO20_PE_CTRL_OVERFLOW = 0x06,
+  AUDIO20_PE_CTRL_LATENCY = 0x07,
+} audio20_parametric_equalizer_control_selector_t;
 
 /// A.17.8.2 Reverberation Effect Unit Control Selectors
-typedef enum
-{
-  AUDIO_RV_CTRL_UNDEF                         = 0x00,
-  AUDIO_RV_CTRL_ENABLE                        = 0x01,
-  AUDIO_RV_CTRL_TYPE                          = 0x02,
-  AUDIO_RV_CTRL_LEVEL                         = 0x03,
-  AUDIO_RV_CTRL_TIME                          = 0x04,
-  AUDIO_RV_CTRL_FEEDBACK                      = 0x05,
-  AUDIO_RV_CTRL_PREDELAY                      = 0x06,
-  AUDIO_RV_CTRL_DENSITY                       = 0x07,
-  AUDIO_RV_CTRL_HIFREQ_ROLLOFF                = 0x08,
-  AUDIO_RV_CTRL_UNDERFLOW                     = 0x09,
-  AUDIO_RV_CTRL_OVERFLOW                      = 0x0A,
-  AUDIO_RV_CTRL_LATENCY                       = 0x0B,
-} audio_reverberation_effect_control_selector_t;
+typedef enum {
+  AUDIO20_RV_CTRL_UNDEF = 0x00,
+  AUDIO20_RV_CTRL_ENABLE = 0x01,
+  AUDIO20_RV_CTRL_TYPE = 0x02,
+  AUDIO20_RV_CTRL_LEVEL = 0x03,
+  AUDIO20_RV_CTRL_TIME = 0x04,
+  AUDIO20_RV_CTRL_FEEDBACK = 0x05,
+  AUDIO20_RV_CTRL_PREDELAY = 0x06,
+  AUDIO20_RV_CTRL_DENSITY = 0x07,
+  AUDIO20_RV_CTRL_HIFREQ_ROLLOFF = 0x08,
+  AUDIO20_RV_CTRL_UNDERFLOW = 0x09,
+  AUDIO20_RV_CTRL_OVERFLOW = 0x0A,
+  AUDIO20_RV_CTRL_LATENCY = 0x0B,
+} audio20_reverberation_effect_control_selector_t;
 
 /// A.17.8.3 Modulation Delay Effect Unit Control Selectors
-typedef enum
-{
-  AUDIO_MD_CTRL_UNDEF                         = 0x00,
-  AUDIO_MD_CTRL_ENABLE                        = 0x01,
-  AUDIO_MD_CTRL_BALANCE                       = 0x02,
-  AUDIO_MD_CTRL_RATE                          = 0x03,
-  AUDIO_MD_CTRL_DEPTH                         = 0x04,
-  AUDIO_MD_CTRL_TIME                          = 0x05,
-  AUDIO_MD_CTRL_FEEDBACK                      = 0x06,
-  AUDIO_MD_CTRL_UNDERFLOW                     = 0x07,
-  AUDIO_MD_CTRL_OVERFLOW                      = 0x08,
-  AUDIO_MD_CTRL_LATENCY                       = 0x09,
-} audio_modulation_delay_control_selector_t;
+typedef enum {
+  AUDIO20_MD_CTRL_UNDEF = 0x00,
+  AUDIO20_MD_CTRL_ENABLE = 0x01,
+  AUDIO20_MD_CTRL_BALANCE = 0x02,
+  AUDIO20_MD_CTRL_RATE = 0x03,
+  AUDIO20_MD_CTRL_DEPTH = 0x04,
+  AUDIO20_MD_CTRL_TIME = 0x05,
+  AUDIO20_MD_CTRL_FEEDBACK = 0x06,
+  AUDIO20_MD_CTRL_UNDERFLOW = 0x07,
+  AUDIO20_MD_CTRL_OVERFLOW = 0x08,
+  AUDIO20_MD_CTRL_LATENCY = 0x09,
+} audio20_modulation_delay_control_selector_t;
 
 /// A.17.8.4 Dynamic Range Compressor Effect Unit Control Selectors
-typedef enum
-{
-  AUDIO_DR_CTRL_UNDEF                         = 0x00,
-  AUDIO_DR_CTRL_ENABLE                        = 0x01,
-  AUDIO_DR_CTRL_COMPRESSION_RATE              = 0x02,
-  AUDIO_DR_CTRL_MAXAMPL                       = 0x03,
-  AUDIO_DR_CTRL_THRESHOLD                     = 0x04,
-  AUDIO_DR_CTRL_ATTACK_TIME                   = 0x05,
-  AUDIO_DR_CTRL_RELEASE_TIME                  = 0x06,
-  AUDIO_DR_CTRL_UNDERFLOW                     = 0x07,
-  AUDIO_DR_CTRL_OVERFLOW                      = 0x08,
-  AUDIO_DR_CTRL_LATENCY                       = 0x09,
-} audio_dynamic_range_compression_control_selector_t;
+typedef enum {
+  AUDIO20_DR_CTRL_UNDEF = 0x00,
+  AUDIO20_DR_CTRL_ENABLE = 0x01,
+  AUDIO20_DR_CTRL_COMPRESSION_RATE = 0x02,
+  AUDIO20_DR_CTRL_MAXAMPL = 0x03,
+  AUDIO20_DR_CTRL_THRESHOLD = 0x04,
+  AUDIO20_DR_CTRL_ATTACK_TIME = 0x05,
+  AUDIO20_DR_CTRL_RELEASE_TIME = 0x06,
+  AUDIO20_DR_CTRL_UNDERFLOW = 0x07,
+  AUDIO20_DR_CTRL_OVERFLOW = 0x08,
+  AUDIO20_DR_CTRL_LATENCY = 0x09,
+} audio20_dynamic_range_compression_control_selector_t;
 
 /// A.17.9 Processing Unit Control Selectors
 
 /// A.17.9.1 Up/Down-mix Processing Unit Control Selectors
-typedef enum
-{
-  AUDIO_UD_CTRL_UNDEF                         = 0x00,
-  AUDIO_UD_CTRL_ENABLE                        = 0x01,
-  AUDIO_UD_CTRL_MODE_SELECT                   = 0x02,
-  AUDIO_UD_CTRL_CLUSTER                       = 0x03,
-  AUDIO_UD_CTRL_UNDERFLOW                     = 0x04,
-  AUDIO_UD_CTRL_OVERFLOW                      = 0x05,
-  AUDIO_UD_CTRL_LATENCY                       = 0x06,
-} audio_up_down_mix_control_selector_t;
+typedef enum {
+  AUDIO20_UD_CTRL_UNDEF = 0x00,
+  AUDIO20_UD_CTRL_ENABLE = 0x01,
+  AUDIO20_UD_CTRL_MODE_SELECT = 0x02,
+  AUDIO20_UD_CTRL_CLUSTER = 0x03,
+  AUDIO20_UD_CTRL_UNDERFLOW = 0x04,
+  AUDIO20_UD_CTRL_OVERFLOW = 0x05,
+  AUDIO20_UD_CTRL_LATENCY = 0x06,
+} audio20_up_down_mix_control_selector_t;
 
 /// A.17.9.2 Dolby Prologic ™ Processing Unit Control Selectors
-typedef enum
-{
-  AUDIO_DP_CTRL_UNDEF                         = 0x00,
-  AUDIO_DP_CTRL_ENABLE                        = 0x01,
-  AUDIO_DP_CTRL_MODE_SELECT                   = 0x02,
-  AUDIO_DP_CTRL_CLUSTER                       = 0x03,
-  AUDIO_DP_CTRL_UNDERFLOW                     = 0x04,
-  AUDIO_DP_CTRL_OVERFLOW                      = 0x05,
-  AUDIO_DP_CTRL_LATENCY                       = 0x06,
-} audio_dolby_prologic_control_selector_t;
+typedef enum {
+  AUDIO20_DP_CTRL_UNDEF = 0x00,
+  AUDIO20_DP_CTRL_ENABLE = 0x01,
+  AUDIO20_DP_CTRL_MODE_SELECT = 0x02,
+  AUDIO20_DP_CTRL_CLUSTER = 0x03,
+  AUDIO20_DP_CTRL_UNDERFLOW = 0x04,
+  AUDIO20_DP_CTRL_OVERFLOW = 0x05,
+  AUDIO20_DP_CTRL_LATENCY = 0x06,
+} audio20_dolby_prologic_control_selector_t;
 
 /// A.17.9.3 Stereo Extender Processing Unit Control Selectors
-typedef enum
-{
-  AUDIO_ST_EXT_CTRL_UNDEF                     = 0x00,
-  AUDIO_ST_EXT_CTRL_ENABLE                    = 0x01,
-  AUDIO_ST_EXT_CTRL_WIDTH                     = 0x02,
-  AUDIO_ST_EXT_CTRL_UNDERFLOW                 = 0x03,
-  AUDIO_ST_EXT_CTRL_OVERFLOW                  = 0x04,
-  AUDIO_ST_EXT_CTRL_LATENCY                   = 0x05,
-} audio_stereo_extender_control_selector_t;
+typedef enum {
+  AUDIO20_ST_EXT_CTRL_UNDEF = 0x00,
+  AUDIO20_ST_EXT_CTRL_ENABLE = 0x01,
+  AUDIO20_ST_EXT_CTRL_WIDTH = 0x02,
+  AUDIO20_ST_EXT_CTRL_UNDERFLOW = 0x03,
+  AUDIO20_ST_EXT_CTRL_OVERFLOW = 0x04,
+  AUDIO20_ST_EXT_CTRL_LATENCY = 0x05,
+} audio20_stereo_extender_control_selector_t;
 
 /// A.17.10 Extension Unit Control Selectors
-typedef enum
-{
-  AUDIO_XU_CTRL_UNDEF                         = 0x00,
-  AUDIO_XU_CTRL_ENABLE                        = 0x01,
-  AUDIO_XU_CTRL_CLUSTER                       = 0x02,
-  AUDIO_XU_CTRL_UNDERFLOW                     = 0x03,
-  AUDIO_XU_CTRL_OVERFLOW                      = 0x04,
-  AUDIO_XU_CTRL_LATENCY                       = 0x05,
-} audio_extension_unit_control_selector_t;
+typedef enum {
+  AUDIO20_XU_CTRL_UNDEF = 0x00,
+  AUDIO20_XU_CTRL_ENABLE = 0x01,
+  AUDIO20_XU_CTRL_CLUSTER = 0x02,
+  AUDIO20_XU_CTRL_UNDERFLOW = 0x03,
+  AUDIO20_XU_CTRL_OVERFLOW = 0x04,
+  AUDIO20_XU_CTRL_LATENCY = 0x05,
+} audio20_extension_unit_control_selector_t;
 
 /// A.17.11 AudioStreaming Interface Control Selectors
-typedef enum
-{
-  AUDIO_AS_CTRL_UNDEF                         = 0x00,
-  AUDIO_AS_CTRL_ACT_ALT_SETTING               = 0x01,
-  AUDIO_AS_CTRL_VAL_ALT_SETTINGS              = 0x02,
-  AUDIO_AS_CTRL_AUDIO_DATA_FORMAT             = 0x03,
-} audio_audiostreaming_interface_control_selector_t;
+typedef enum {
+  AUDIO20_AS_CTRL_UNDEF = 0x00,
+  AUDIO20_AS_CTRL_ACT_ALT_SETTING = 0x01,
+  AUDIO20_AS_CTRL_VAL_ALT_SETTINGS = 0x02,
+  AUDIO20_AS_CTRL_AUDIO_DATA_FORMAT = 0x03,
+} audio20_audiostreaming_interface_control_selector_t;
 
 /// A.17.12 Encoder Control Selectors
-typedef enum
-{
-  AUDIO_EN_CTRL_UNDEF                         = 0x00,
-  AUDIO_EN_CTRL_BIT_RATE                      = 0x01,
-  AUDIO_EN_CTRL_QUALITY                       = 0x02,
-  AUDIO_EN_CTRL_VBR                           = 0x03,
-  AUDIO_EN_CTRL_TYPE                          = 0x04,
-  AUDIO_EN_CTRL_UNDERFLOW                     = 0x05,
-  AUDIO_EN_CTRL_OVERFLOW                      = 0x06,
-  AUDIO_EN_CTRL_ENCODER_ERROR                 = 0x07,
-  AUDIO_EN_CTRL_PARAM1                        = 0x08,
-  AUDIO_EN_CTRL_PARAM2                        = 0x09,
-  AUDIO_EN_CTRL_PARAM3                        = 0x0A,
-  AUDIO_EN_CTRL_PARAM4                        = 0x0B,
-  AUDIO_EN_CTRL_PARAM5                        = 0x0C,
-  AUDIO_EN_CTRL_PARAM6                        = 0x0D,
-  AUDIO_EN_CTRL_PARAM7                        = 0x0E,
-  AUDIO_EN_CTRL_PARAM8                        = 0x0F,
-} audio_encoder_control_selector_t;
+typedef enum {
+  AUDIO20_EN_CTRL_UNDEF = 0x00,
+  AUDIO20_EN_CTRL_BIT_RATE = 0x01,
+  AUDIO20_EN_CTRL_QUALITY = 0x02,
+  AUDIO20_EN_CTRL_VBR = 0x03,
+  AUDIO20_EN_CTRL_TYPE = 0x04,
+  AUDIO20_EN_CTRL_UNDERFLOW = 0x05,
+  AUDIO20_EN_CTRL_OVERFLOW = 0x06,
+  AUDIO20_EN_CTRL_ENCODER_ERROR = 0x07,
+  AUDIO20_EN_CTRL_PARAM1 = 0x08,
+  AUDIO20_EN_CTRL_PARAM2 = 0x09,
+  AUDIO20_EN_CTRL_PARAM3 = 0x0A,
+  AUDIO20_EN_CTRL_PARAM4 = 0x0B,
+  AUDIO20_EN_CTRL_PARAM5 = 0x0C,
+  AUDIO20_EN_CTRL_PARAM6 = 0x0D,
+  AUDIO20_EN_CTRL_PARAM7 = 0x0E,
+  AUDIO20_EN_CTRL_PARAM8 = 0x0F,
+} audio20_encoder_control_selector_t;
 
 /// A.17.13 Decoder Control Selectors
 
 /// A.17.13.1 MPEG Decoder Control Selectors
-typedef enum
-{
-  AUDIO_MPD_CTRL_UNDEF                        = 0x00,
-  AUDIO_MPD_CTRL_DUAL_CHANNEL                 = 0x01,
-  AUDIO_MPD_CTRL_SECOND_STEREO                = 0x02,
-  AUDIO_MPD_CTRL_MULTILINGUAL                 = 0x03,
-  AUDIO_MPD_CTRL_DYN_RANGE                    = 0x04,
-  AUDIO_MPD_CTRL_SCALING                      = 0x05,
-  AUDIO_MPD_CTRL_HILO_SCALING                 = 0x06,
-  AUDIO_MPD_CTRL_UNDERFLOW                    = 0x07,
-  AUDIO_MPD_CTRL_OVERFLOW                     = 0x08,
-  AUDIO_MPD_CTRL_DECODER_ERROR                = 0x09,
-} audio_MPEG_decoder_control_selector_t;
+typedef enum {
+  AUDIO20_MPD_CTRL_UNDEF = 0x00,
+  AUDIO20_MPD_CTRL_DUAL_CHANNEL = 0x01,
+  AUDIO20_MPD_CTRL_SECOND_STEREO = 0x02,
+  AUDIO20_MPD_CTRL_MULTILINGUAL = 0x03,
+  AUDIO20_MPD_CTRL_DYN_RANGE = 0x04,
+  AUDIO20_MPD_CTRL_SCALING = 0x05,
+  AUDIO20_MPD_CTRL_HILO_SCALING = 0x06,
+  AUDIO20_MPD_CTRL_UNDERFLOW = 0x07,
+  AUDIO20_MPD_CTRL_OVERFLOW = 0x08,
+  AUDIO20_MPD_CTRL_DECODER_ERROR = 0x09,
+} audio20_MPEG_decoder_control_selector_t;
 
 /// A.17.13.2 AC-3 Decoder Control Selectors
-typedef enum
-{
-  AUDIO_AD_CTRL_UNDEF                         = 0x00,
-  AUDIO_AD_CTRL_MODE                          = 0x01,
-  AUDIO_AD_CTRL_DYN_RANGE                     = 0x02,
-  AUDIO_AD_CTRL_SCALING                       = 0x03,
-  AUDIO_AD_CTRL_HILO_SCALING                  = 0x04,
-  AUDIO_AD_CTRL_UNDERFLOW                     = 0x05,
-  AUDIO_AD_CTRL_OVERFLOW                      = 0x06,
-  AUDIO_AD_CTRL_DECODER_ERROR                 = 0x07,
-} audio_AC3_decoder_control_selector_t;
+typedef enum {
+  AUDIO20_AD_CTRL_UNDEF = 0x00,
+  AUDIO20_AD_CTRL_MODE = 0x01,
+  AUDIO20_AD_CTRL_DYN_RANGE = 0x02,
+  AUDIO20_AD_CTRL_SCALING = 0x03,
+  AUDIO20_AD_CTRL_HILO_SCALING = 0x04,
+  AUDIO20_AD_CTRL_UNDERFLOW = 0x05,
+  AUDIO20_AD_CTRL_OVERFLOW = 0x06,
+  AUDIO20_AD_CTRL_DECODER_ERROR = 0x07,
+} audio20_AC3_decoder_control_selector_t;
 
 /// A.17.13.3 WMA Decoder Control Selectors
-typedef enum
-{
-  AUDIO_WD_CTRL_UNDEF                         = 0x00,
-  AUDIO_WD_CTRL_UNDERFLOW                     = 0x01,
-  AUDIO_WD_CTRL_OVERFLOW                      = 0x02,
-  AUDIO_WD_CTRL_DECODER_ERROR                 = 0x03,
-} audio_WMA_decoder_control_selector_t;
+typedef enum {
+  AUDIO20_WD_CTRL_UNDEF = 0x00,
+  AUDIO20_WD_CTRL_UNDERFLOW = 0x01,
+  AUDIO20_WD_CTRL_OVERFLOW = 0x02,
+  AUDIO20_WD_CTRL_DECODER_ERROR = 0x03,
+} audio20_WMA_decoder_control_selector_t;
 
 /// A.17.13.4 DTS Decoder Control Selectors
-typedef enum
-{
-  AUDIO_DD_CTRL_UNDEF                         = 0x00,
-  AUDIO_DD_CTRL_UNDERFLOW                     = 0x01,
-  AUDIO_DD_CTRL_OVERFLOW                      = 0x02,
-  AUDIO_DD_CTRL_DECODER_ERROR                 = 0x03,
-} audio_DTS_decoder_control_selector_t;
+typedef enum {
+  AUDIO20_DD_CTRL_UNDEF = 0x00,
+  AUDIO20_DD_CTRL_UNDERFLOW = 0x01,
+  AUDIO20_DD_CTRL_OVERFLOW = 0x02,
+  AUDIO20_DD_CTRL_DECODER_ERROR = 0x03,
+} audio20_DTS_decoder_control_selector_t;
 
 /// A.17.14 Endpoint Control Selectors
-typedef enum
-{
-  AUDIO_EP_CTRL_UNDEF                         = 0x00,
-  AUDIO_EP_CTRL_PITCH                         = 0x01,
-  AUDIO_EP_CTRL_DATA_OVERRUN                  = 0x02,
-  AUDIO_EP_CTRL_DATA_UNDERRUN                 = 0x03,
-} audio_EP_control_selector_t;
-
-/// Terminal Types
-
-/// 2.1 - Audio Class-Terminal Types UAC2
-typedef enum
-{
-  AUDIO_TERM_TYPE_USB_UNDEFINED       = 0x0100,
-  AUDIO_TERM_TYPE_USB_STREAMING       = 0x0101,
-  AUDIO_TERM_TYPE_USB_VENDOR_SPEC     = 0x01FF,
-} audio_terminal_type_t;
-
-/// 2.2 - Audio Class-Input Terminal Types UAC2
-typedef enum
-{
-  AUDIO_TERM_TYPE_IN_UNDEFINED        = 0x0200,
-  AUDIO_TERM_TYPE_IN_GENERIC_MIC      = 0x0201,
-  AUDIO_TERM_TYPE_IN_DESKTOP_MIC      = 0x0202,
-  AUDIO_TERM_TYPE_IN_PERSONAL_MIC     = 0x0203,
-  AUDIO_TERM_TYPE_IN_OMNI_MIC         = 0x0204,
-  AUDIO_TERM_TYPE_IN_ARRAY_MIC        = 0x0205,
-  AUDIO_TERM_TYPE_IN_PROC_ARRAY_MIC   = 0x0206,
-} audio_terminal_input_type_t;
-
-/// 2.3 - Audio Class-Output Terminal Types UAC2
-typedef enum
-{
-  AUDIO_TERM_TYPE_OUT_UNDEFINED               = 0x0300,
-  AUDIO_TERM_TYPE_OUT_GENERIC_SPEAKER         = 0x0301,
-  AUDIO_TERM_TYPE_OUT_HEADPHONES              = 0x0302,
-  AUDIO_TERM_TYPE_OUT_HEAD_MNT_DISP_AUIDO     = 0x0303,
-  AUDIO_TERM_TYPE_OUT_DESKTOP_SPEAKER         = 0x0304,
-  AUDIO_TERM_TYPE_OUT_ROOM_SPEAKER            = 0x0305,
-  AUDIO_TERM_TYPE_OUT_COMMUNICATION_SPEAKER   = 0x0306,
-  AUDIO_TERM_TYPE_OUT_LOW_FRQ_EFFECTS_SPEAKER = 0x0307,
-} audio_terminal_output_type_t;
-
-/// Rest is yet to be implemented
+typedef enum {
+  AUDIO20_EP_CTRL_UNDEF = 0x00,
+  AUDIO20_EP_CTRL_PITCH = 0x01,
+  AUDIO20_EP_CTRL_DATA_OVERRUN = 0x02,
+  AUDIO20_EP_CTRL_DATA_UNDERRUN = 0x03,
+} audio20_EP_control_selector_t;
 
 /// Additional Audio Device Class Codes - Source: Audio Data Formats
 
 /// A.1 - Audio Class-Format Type Codes UAC2
-typedef enum
-{
-  AUDIO_FORMAT_TYPE_UNDEFINED     = 0x00,
-  AUDIO_FORMAT_TYPE_I             = 0x01,
-  AUDIO_FORMAT_TYPE_II            = 0x02,
-  AUDIO_FORMAT_TYPE_III           = 0x03,
-  AUDIO_FORMAT_TYPE_IV            = 0x04,
-  AUDIO_EXT_FORMAT_TYPE_I         = 0x81,
-  AUDIO_EXT_FORMAT_TYPE_II        = 0x82,
-  AUDIO_EXT_FORMAT_TYPE_III       = 0x83,
-} audio_format_type_t;
+typedef enum {
+  AUDIO20_FORMAT_TYPE_UNDEFINED = 0x00,
+  AUDIO20_FORMAT_TYPE_I = 0x01,
+  AUDIO20_FORMAT_TYPE_II = 0x02,
+  AUDIO20_FORMAT_TYPE_III = 0x03,
+  AUDIO20_FORMAT_TYPE_IV = 0x04,
+  AUDIO20_EXT_FORMAT_TYPE_I = 0x81,
+  AUDIO20_EXT_FORMAT_TYPE_II = 0x82,
+  AUDIO20_EXT_FORMAT_TYPE_III = 0x83,
+} audio20_format_type_t;
 
 // A.2.1 - Audio Class-Audio Data Format Type I UAC2
-typedef enum
-{
-  AUDIO_DATA_FORMAT_TYPE_I_PCM            = (uint32_t) (1 << 0),
-  AUDIO_DATA_FORMAT_TYPE_I_PCM8           = (uint32_t) (1 << 1),
-  AUDIO_DATA_FORMAT_TYPE_I_IEEE_FLOAT     = (uint32_t) (1 << 2),
-  AUDIO_DATA_FORMAT_TYPE_I_ALAW           = (uint32_t) (1 << 3),
-  AUDIO_DATA_FORMAT_TYPE_I_MULAW          = (uint32_t) (1 << 4),
-  AUDIO_DATA_FORMAT_TYPE_I_RAW_DATA       = 0x80000000u,
-} audio_data_format_type_I_t;
+typedef enum {
+  AUDIO20_DATA_FORMAT_TYPE_I_PCM = 1 << 0,
+  AUDIO20_DATA_FORMAT_TYPE_I_PCM8 = 1 << 1,
+  AUDIO20_DATA_FORMAT_TYPE_I_IEEE_FLOAT = 1 << 2,
+  AUDIO20_DATA_FORMAT_TYPE_I_ALAW = 1 << 3,
+  AUDIO20_DATA_FORMAT_TYPE_I_MULAW = 1 << 4,
+  AUDIO20_DATA_FORMAT_TYPE_I_RAW_DATA = 0x80000000u,
+} audio20_data_format_type_I_t;
+
+/// Audio Class-Audio Channel Configuration UAC2 (Table A-11)
+typedef enum {
+  AUDIO20_CHANNEL_CONFIG_NON_PREDEFINED = 0x00000000,
+  AUDIO20_CHANNEL_CONFIG_FRONT_LEFT = 0x00000001,
+  AUDIO20_CHANNEL_CONFIG_FRONT_RIGHT = 0x00000002,
+  AUDIO20_CHANNEL_CONFIG_FRONT_CENTER = 0x00000004,
+  AUDIO20_CHANNEL_CONFIG_LOW_FRQ_EFFECTS = 0x00000008,
+  AUDIO20_CHANNEL_CONFIG_BACK_LEFT = 0x00000010,
+  AUDIO20_CHANNEL_CONFIG_BACK_RIGHT = 0x00000020,
+  AUDIO20_CHANNEL_CONFIG_FRONT_LEFT_OF_CENTER = 0x00000040,
+  AUDIO20_CHANNEL_CONFIG_FRONT_RIGHT_OF_CENTER = 0x00000080,
+  AUDIO20_CHANNEL_CONFIG_BACK_CENTER = 0x00000100,
+  AUDIO20_CHANNEL_CONFIG_SIDE_LEFT = 0x00000200,
+  AUDIO20_CHANNEL_CONFIG_SIDE_RIGHT = 0x00000400,
+  AUDIO20_CHANNEL_CONFIG_TOP_CENTER = 0x00000800,
+  AUDIO20_CHANNEL_CONFIG_TOP_FRONT_LEFT = 0x00001000,
+  AUDIO20_CHANNEL_CONFIG_TOP_FRONT_CENTER = 0x00002000,
+  AUDIO20_CHANNEL_CONFIG_TOP_FRONT_RIGHT = 0x00004000,
+  AUDIO20_CHANNEL_CONFIG_TOP_BACK_LEFT = 0x00008000,
+  AUDIO20_CHANNEL_CONFIG_TOP_BACK_CENTER = 0x00010000,
+  AUDIO20_CHANNEL_CONFIG_TOP_BACK_RIGHT = 0x00020000,
+  AUDIO20_CHANNEL_CONFIG_TOP_FRONT_LEFT_OF_CENTER = 0x00040000,
+  AUDIO20_CHANNEL_CONFIG_TOP_FRONT_RIGHT_OF_CENTER = 0x00080000,
+  AUDIO20_CHANNEL_CONFIG_LEFT_LOW_FRQ_EFFECTS = 0x00100000,
+  AUDIO20_CHANNEL_CONFIG_RIGHT_LOW_FRQ_EFFECTS = 0x00200000,
+  AUDIO20_CHANNEL_CONFIG_TOP_SIDE_LEFT = 0x00400000,
+  AUDIO20_CHANNEL_CONFIG_TOP_SIDE_RIGHT = 0x00800000,
+  AUDIO20_CHANNEL_CONFIG_BOTTOM_CENTER = 0x01000000,
+  AUDIO20_CHANNEL_CONFIG_BACK_LEFT_OF_CENTER = 0x02000000,
+  AUDIO20_CHANNEL_CONFIG_BACK_RIGHT_OF_CENTER = 0x04000000,
+  AUDIO20_CHANNEL_CONFIG_RAW_DATA = 0x80000000u,
+} audio20_channel_config_t;
 
 /// All remaining definitions are taken from the descriptor descriptions in the UAC2 main specification
 
 /// Audio Class-Control Values UAC2
-typedef enum
-{
-  AUDIO_CTRL_NONE     = 0x00,         ///< No Host access
-  AUDIO_CTRL_R        = 0x01,         ///< Host read access only
-  AUDIO_CTRL_RW       = 0x03,         ///< Host read write access
-} audio_control_t;
+typedef enum {
+  AUDIO20_CTRL_NONE = 0x00,///< No Host access
+  AUDIO20_CTRL_R = 0x01,   ///< Host read access only
+  AUDIO20_CTRL_RW = 0x03,  ///< Host read write access
+} audio20_control_t;
 
 /// Audio Class-Specific AC Interface Descriptor Controls UAC2
-typedef enum
-{
-  AUDIO_CS_AS_INTERFACE_CTRL_LATENCY_POS  = 0,
-} audio_cs_ac_interface_control_pos_t;
+typedef enum {
+  AUDIO20_CS_AS_INTERFACE_CTRL_LATENCY_POS = 0,
+} audio20_cs_ac_interface_control_pos_t;
 
 /// Audio Class-Specific AS Interface Descriptor Controls UAC2
-typedef enum
-{
-  AUDIO_CS_AS_INTERFACE_CTRL_ACTIVE_ALT_SET_POS   = 0,
-  AUDIO_CS_AS_INTERFACE_CTRL_VALID_ALT_SET_POS    = 2,
-} audio_cs_as_interface_control_pos_t;
+typedef enum {
+  AUDIO20_CS_AS_INTERFACE_CTRL_ACTIVE_ALT_SET_POS = 0,
+  AUDIO20_CS_AS_INTERFACE_CTRL_VALID_ALT_SET_POS = 2,
+} audio20_cs_as_interface_control_pos_t;
 
 /// Audio Class-Specific AS Isochronous Data EP Attributes UAC2
-typedef enum
-{
-  AUDIO_CS_AS_ISO_DATA_EP_ATT_MAX_PACKETS_ONLY    = 0x80,
-  AUDIO_CS_AS_ISO_DATA_EP_ATT_NON_MAX_PACKETS_OK  = 0x00,
-} audio_cs_as_iso_data_ep_attribute_t;
+typedef enum {
+  AUDIO20_CS_AS_ISO_DATA_EP_ATT_MAX_PACKETS_ONLY = 0x80,
+  AUDIO20_CS_AS_ISO_DATA_EP_ATT_NON_MAX_PACKETS_OK = 0x00,
+} audio20_cs_as_iso_data_ep_attribute_t;
 
 /// Audio Class-Specific AS Isochronous Data EP Controls UAC2
-typedef enum
-{
-  AUDIO_CS_AS_ISO_DATA_EP_CTRL_PITCH_POS          = 0,
-  AUDIO_CS_AS_ISO_DATA_EP_CTRL_DATA_OVERRUN_POS   = 2,
-  AUDIO_CS_AS_ISO_DATA_EP_CTRL_DATA_UNDERRUN_POS  = 4,
-} audio_cs_as_iso_data_ep_control_pos_t;
+typedef enum {
+  AUDIO20_CS_AS_ISO_DATA_EP_CTRL_PITCH_POS = 0,
+  AUDIO20_CS_AS_ISO_DATA_EP_CTRL_DATA_OVERRUN_POS = 2,
+  AUDIO20_CS_AS_ISO_DATA_EP_CTRL_DATA_UNDERRUN_POS = 4,
+} audio20_cs_as_iso_data_ep_control_pos_t;
 
 /// Audio Class-Specific AS Isochronous Data EP Lock Delay Units UAC2
-typedef enum
-{
-  AUDIO_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_UNDEFINED       = 0x00,
-  AUDIO_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_MILLISEC        = 0x01,
-  AUDIO_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_PCM_SAMPLES     = 0x02,
-} audio_cs_as_iso_data_ep_lock_delay_unit_t;
+typedef enum {
+  AUDIO20_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_UNDEFINED = 0x00,
+  AUDIO20_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_MILLISEC = 0x01,
+  AUDIO20_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_PCM_SAMPLES = 0x02,
+} audio20_cs_as_iso_data_ep_lock_delay_unit_t;
 
 /// Audio Class-Clock Source Attributes UAC2
-typedef enum
-{
-  AUDIO_CLOCK_SOURCE_ATT_EXT_CLK      = 0x00,
-  AUDIO_CLOCK_SOURCE_ATT_INT_FIX_CLK  = 0x01,
-  AUDIO_CLOCK_SOURCE_ATT_INT_VAR_CLK  = 0x02,
-  AUDIO_CLOCK_SOURCE_ATT_INT_PRO_CLK  = 0x03,
-  AUDIO_CLOCK_SOURCE_ATT_CLK_SYC_SOF  = 0x04,
-} audio_clock_source_attribute_t;
+typedef enum {
+  AUDIO20_CLOCK_SOURCE_ATT_EXT_CLK = 0x00,
+  AUDIO20_CLOCK_SOURCE_ATT_INT_FIX_CLK = 0x01,
+  AUDIO20_CLOCK_SOURCE_ATT_INT_VAR_CLK = 0x02,
+  AUDIO20_CLOCK_SOURCE_ATT_INT_PRO_CLK = 0x03,
+  AUDIO20_CLOCK_SOURCE_ATT_CLK_SYC_SOF = 0x04,
+} audio20_clock_source_attribute_t;
 
 /// Audio Class-Clock Source Controls UAC2
-typedef enum
-{
-  AUDIO_CLOCK_SOURCE_CTRL_CLK_FRQ_POS     = 0,
-  AUDIO_CLOCK_SOURCE_CTRL_CLK_VAL_POS     = 2,
-} audio_clock_source_control_pos_t;
+typedef enum {
+  AUDIO20_CLOCK_SOURCE_CTRL_CLK_FRQ_POS = 0,
+  AUDIO20_CLOCK_SOURCE_CTRL_CLK_VAL_POS = 2,
+} audio20_clock_source_control_pos_t;
 
 /// Audio Class-Clock Selector Controls UAC2
-typedef enum
-{
-  AUDIO_CLOCK_SELECTOR_CTRL_POS   = 0,
-} audio_clock_selector_control_pos_t;
+typedef enum {
+  AUDIO20_CLOCK_SELECTOR_CTRL_POS = 0,
+} audio20_clock_selector_control_pos_t;
 
 /// Audio Class-Clock Multiplier Controls UAC2
-typedef enum
-{
-  AUDIO_CLOCK_MULTIPLIER_CTRL_NUMERATOR_POS       = 0,
-  AUDIO_CLOCK_MULTIPLIER_CTRL_DENOMINATOR_POS     = 2,
-} audio_clock_multiplier_control_pos_t;
+typedef enum {
+  AUDIO20_CLOCK_MULTIPLIER_CTRL_NUMERATOR_POS = 0,
+  AUDIO20_CLOCK_MULTIPLIER_CTRL_DENOMINATOR_POS = 2,
+} audio20_clock_multiplier_control_pos_t;
 
 /// Audio Class-Input Terminal Controls UAC2
-typedef enum
-{
-  AUDIO_IN_TERM_CTRL_CPY_PROT_POS     = 0,
-  AUDIO_IN_TERM_CTRL_CONNECTOR_POS    = 2,
-  AUDIO_IN_TERM_CTRL_OVERLOAD_POS     = 4,
-  AUDIO_IN_TERM_CTRL_CLUSTER_POS      = 6,
-  AUDIO_IN_TERM_CTRL_UNDERFLOW_POS    = 8,
-  AUDIO_IN_TERM_CTRL_OVERFLOW_POS     = 10,
-} audio_terminal_input_control_pos_t;
+typedef enum {
+  AUDIO20_IN_TERM_CTRL_CPY_PROT_POS = 0,
+  AUDIO20_IN_TERM_CTRL_CONNECTOR_POS = 2,
+  AUDIO20_IN_TERM_CTRL_OVERLOAD_POS = 4,
+  AUDIO20_IN_TERM_CTRL_CLUSTER_POS = 6,
+  AUDIO20_IN_TERM_CTRL_UNDERFLOW_POS = 8,
+  AUDIO20_IN_TERM_CTRL_OVERFLOW_POS = 10,
+} audio20_terminal_input_control_pos_t;
 
 /// Audio Class-Output Terminal Controls UAC2
-typedef enum
-{
-  AUDIO_OUT_TERM_CTRL_CPY_PROT_POS    = 0,
-  AUDIO_OUT_TERM_CTRL_CONNECTOR_POS   = 2,
-  AUDIO_OUT_TERM_CTRL_OVERLOAD_POS    = 4,
-  AUDIO_OUT_TERM_CTRL_UNDERFLOW_POS   = 6,
-  AUDIO_OUT_TERM_CTRL_OVERFLOW_POS    = 8,
-} audio_terminal_output_control_pos_t;
+typedef enum {
+  AUDIO20_OUT_TERM_CTRL_CPY_PROT_POS = 0,
+  AUDIO20_OUT_TERM_CTRL_CONNECTOR_POS = 2,
+  AUDIO20_OUT_TERM_CTRL_OVERLOAD_POS = 4,
+  AUDIO20_OUT_TERM_CTRL_UNDERFLOW_POS = 6,
+  AUDIO20_OUT_TERM_CTRL_OVERFLOW_POS = 8,
+} audio20_terminal_output_control_pos_t;
 
 /// Audio Class-Feature Unit Controls UAC2
-typedef enum
-{
-  AUDIO_FEATURE_UNIT_CTRL_MUTE_POS            = 0,
-  AUDIO_FEATURE_UNIT_CTRL_VOLUME_POS          = 2,
-  AUDIO_FEATURE_UNIT_CTRL_BASS_POS            = 4,
-  AUDIO_FEATURE_UNIT_CTRL_MID_POS             = 6,
-  AUDIO_FEATURE_UNIT_CTRL_TREBLE_POS          = 8,
-  AUDIO_FEATURE_UNIT_CTRL_GRAPHIC_EQU_POS     = 10,
-  AUDIO_FEATURE_UNIT_CTRL_AGC_POS             = 12,
-  AUDIO_FEATURE_UNIT_CTRL_DELAY_POS           = 14,
-  AUDIO_FEATURE_UNIT_CTRL_BASS_BOOST_POS      = 16,
-  AUDIO_FEATURE_UNIT_CTRL_LOUDNESS_POS        = 18,
-  AUDIO_FEATURE_UNIT_CTRL_INPUT_GAIN_POS      = 20,
-  AUDIO_FEATURE_UNIT_CTRL_INPUT_GAIN_PAD_POS  = 22,
-  AUDIO_FEATURE_UNIT_CTRL_PHASE_INV_POS       = 24,
-  AUDIO_FEATURE_UNIT_CTRL_UNDERFLOW_POS       = 26,
-  AUDIO_FEATURE_UNIT_CTRL_OVERFLOW_POS        = 28,
-} audio_feature_unit_control_pos_t;
+typedef enum {
+  AUDIO20_FEATURE_UNIT_CTRL_MUTE_POS = 0,
+  AUDIO20_FEATURE_UNIT_CTRL_VOLUME_POS = 2,
+  AUDIO20_FEATURE_UNIT_CTRL_BASS_POS = 4,
+  AUDIO20_FEATURE_UNIT_CTRL_MID_POS = 6,
+  AUDIO20_FEATURE_UNIT_CTRL_TREBLE_POS = 8,
+  AUDIO20_FEATURE_UNIT_CTRL_GRAPHIC_EQU_POS = 10,
+  AUDIO20_FEATURE_UNIT_CTRL_AGC_POS = 12,
+  AUDIO20_FEATURE_UNIT_CTRL_DELAY_POS = 14,
+  AUDIO20_FEATURE_UNIT_CTRL_BASS_BOOST_POS = 16,
+  AUDIO20_FEATURE_UNIT_CTRL_LOUDNESS_POS = 18,
+  AUDIO20_FEATURE_UNIT_CTRL_INPUT_GAIN_POS = 20,
+  AUDIO20_FEATURE_UNIT_CTRL_INPUT_GAIN_PAD_POS = 22,
+  AUDIO20_FEATURE_UNIT_CTRL_PHASE_INV_POS = 24,
+  AUDIO20_FEATURE_UNIT_CTRL_UNDERFLOW_POS = 26,
+  AUDIO20_FEATURE_UNIT_CTRL_OVERFLOW_POS = 28,
+} audio20_feature_unit_control_pos_t;
 
-/// Audio Class-Audio Channel Configuration UAC2
-typedef enum
-{
-  AUDIO_CHANNEL_CONFIG_NON_PREDEFINED             = 0x00000000,
-  AUDIO_CHANNEL_CONFIG_FRONT_LEFT                 = 0x00000001,
-  AUDIO_CHANNEL_CONFIG_FRONT_RIGHT                = 0x00000002,
-  AUDIO_CHANNEL_CONFIG_FRONT_CENTER               = 0x00000004,
-  AUDIO_CHANNEL_CONFIG_LOW_FRQ_EFFECTS            = 0x00000008,
-  AUDIO_CHANNEL_CONFIG_BACK_LEFT                  = 0x00000010,
-  AUDIO_CHANNEL_CONFIG_BACK_RIGHT                 = 0x00000020,
-  AUDIO_CHANNEL_CONFIG_FRONT_LEFT_OF_CENTER       = 0x00000040,
-  AUDIO_CHANNEL_CONFIG_FRONT_RIGHT_OF_CENTER      = 0x00000080,
-  AUDIO_CHANNEL_CONFIG_BACK_CENTER                = 0x00000100,
-  AUDIO_CHANNEL_CONFIG_SIDE_LEFT                  = 0x00000200,
-  AUDIO_CHANNEL_CONFIG_SIDE_RIGHT                 = 0x00000400,
-  AUDIO_CHANNEL_CONFIG_TOP_CENTER                 = 0x00000800,
-  AUDIO_CHANNEL_CONFIG_TOP_FRONT_LEFT             = 0x00001000,
-  AUDIO_CHANNEL_CONFIG_TOP_FRONT_CENTER           = 0x00002000,
-  AUDIO_CHANNEL_CONFIG_TOP_FRONT_RIGHT            = 0x00004000,
-  AUDIO_CHANNEL_CONFIG_TOP_BACK_LEFT              = 0x00008000,
-  AUDIO_CHANNEL_CONFIG_TOP_BACK_CENTER            = 0x00010000,
-  AUDIO_CHANNEL_CONFIG_TOP_BACK_RIGHT             = 0x00020000,
-  AUDIO_CHANNEL_CONFIG_TOP_FRONT_LEFT_OF_CENTER   = 0x00040000,
-  AUDIO_CHANNEL_CONFIG_TOP_FRONT_RIGHT_OF_CENTER  = 0x00080000,
-  AUDIO_CHANNEL_CONFIG_LEFT_LOW_FRQ_EFFECTS       = 0x00100000,
-  AUDIO_CHANNEL_CONFIG_RIGHT_LOW_FRQ_EFFECTS      = 0x00200000,
-  AUDIO_CHANNEL_CONFIG_TOP_SIDE_LEFT              = 0x00400000,
-  AUDIO_CHANNEL_CONFIG_TOP_SIDE_RIGHT             = 0x00800000,
-  AUDIO_CHANNEL_CONFIG_BOTTOM_CENTER              = 0x01000000,
-  AUDIO_CHANNEL_CONFIG_BACK_LEFT_OF_CENTER        = 0x02000000,
-  AUDIO_CHANNEL_CONFIG_BACK_RIGHT_OF_CENTER       = 0x04000000,
-  AUDIO_CHANNEL_CONFIG_RAW_DATA                   = 0x80000000u,
-} audio_channel_config_t;
+//--------------------------------------------------------------------+
+// USB AUDIO CLASS 2.0 (UAC2) DESCRIPTORS
+//--------------------------------------------------------------------+
 
-/// AUDIO Channel Cluster Descriptor (4.1)
+/// AUDIO Channel Cluster Descriptor UAC2 (4.1)
 typedef struct TU_ATTR_PACKED {
-  uint8_t                 bNrChannels;        ///< Number of channels currently connected.
-  audio_channel_config_t  bmChannelConfig;    ///< Bitmap according to 'audio_channel_config_t' with a 1 set if channel is connected and 0 else. In case channels are non-predefined ignore them here (see UAC2 specification 4.1 Audio Channel Cluster Descriptor.
-  uint8_t                 iChannelNames;      ///< Index of a string descriptor, describing the name of the first inserted channel with a non-predefined spatial location.
-} audio_desc_channel_cluster_t;
+  uint8_t bNrChannels;                     ///< Number of channels currently connected.
+  uint32_t bmChannelConfig;///< Bitmap according to 'audio20_channel_config_t' with a 1 set if channel is connected and 0 else. In case channels are non-predefined ignore them here (see UAC2 specification 4.1 Audio Channel Cluster Descriptor.
+  uint8_t iChannelNames;                   ///< Index of a string descriptor, describing the name of the first inserted channel with a non-predefined spatial location.
+} audio20_desc_channel_cluster_t;
 
-/// AUDIO Class-Specific AC Interface Header Descriptor (4.7.2)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor in bytes: 9.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_HEADER.
-  uint16_t bcdADC            ; ///< Audio Device Class Specification Release Number in Binary-Coded Decimal. Value: U16_TO_U8S_LE(0x0200).
-  uint8_t bCategory          ; ///< Constant, indicating the primary use of this audio function, as intended by the manufacturer. See: audio_function_t.
-  uint16_t wTotalLength      ; ///< Total number of bytes returned for the class-specific AudioControl interface descriptor. Includes the combined length of this descriptor header and all Clock Source, Unit and Terminal descriptors.
-  uint8_t bmControls         ; ///< See: audio_cs_ac_interface_control_pos_t.
-} audio_desc_cs_ac_interface_t;
-TU_VERIFY_STATIC(sizeof(audio_desc_cs_ac_interface_t) == 9, "size is not correct");
+/// AUDIO Class-Specific AC Interface Header Descriptor UAC2 (4.7.2)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor in bytes: 9.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AC_INTERFACE_HEADER.
+  uint16_t bcdADC;           ///< Audio Device Class Specification Release Number in Binary-Coded Decimal. Value: U16_TO_U8S_LE(0x0200).
+  uint8_t bCategory;         ///< Constant, indicating the primary use of this audio function, as intended by the manufacturer. See: audio20_function_code_t.
+  uint16_t wTotalLength;     ///< Total number of bytes returned for the class-specific AudioControl interface descriptor. Includes the combined length of this descriptor header and all Clock Source, Unit and Terminal descriptors.
+  uint8_t bmControls;        ///< See: audio20_cs_ac_interface_control_pos_t.
+} audio20_desc_cs_ac_interface_t;
+TU_VERIFY_STATIC(sizeof(audio20_desc_cs_ac_interface_t) == 9, "size is not correct");
 
-/// AUDIO Clock Source Descriptor (4.7.2.1)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor in bytes: 8.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_CLOCK_SOURCE.
-  uint8_t bClockID           ; ///< Constant uniquely identifying the Clock Source Entity within the audio function. This value is used in all requests to address this Entity.
-  uint8_t bmAttributes       ; ///< See: audio_clock_source_attribute_t.
-  uint8_t bmControls         ; ///< See: audio_clock_source_control_pos_t.
-  uint8_t bAssocTerminal     ; ///< Terminal ID of the Terminal that is associated with this Clock Source.
-  uint8_t iClockSource       ; ///< Index of a string descriptor, describing the Clock Source Entity.
-} audio_desc_clock_source_t;
+/// AUDIO Clock Source Descriptor UAC2 (4.7.2.1)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor in bytes: 8.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AC_INTERFACE_CLOCK_SOURCE.
+  uint8_t bClockID;          ///< Constant uniquely identifying the Clock Source Entity within the audio function. This value is used in all requests to address this Entity.
+  uint8_t bmAttributes;      ///< See: audio20_clock_source_attribute_t.
+  uint8_t bmControls;        ///< See: audio20_clock_source_control_pos_t.
+  uint8_t bAssocTerminal;    ///< Terminal ID of the Terminal that is associated with this Clock Source.
+  uint8_t iClockSource;      ///< Index of a string descriptor, describing the Clock Source Entity.
+} audio20_desc_clock_source_t;
 
-/// AUDIO Clock Selector Descriptor (4.7.2.2) for ONE pin
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 7+p.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_CLOCK_SELECTOR.
-  uint8_t bClockID           ; ///< Constant uniquely identifying the Clock Selector Entity within the audio function. This value is used in all requests to address this Entity.
-  uint8_t bNrInPins          ; ///< Number of Input Pins of this Unit: p = 1 thus bNrInPins = 1.
-  uint8_t baCSourceID        ; ///< ID of the Clock Entity to which the first Clock Input Pin of this Clock Selector Entity is connected..
-  uint8_t bmControls         ; ///< See: audio_clock_selector_control_pos_t.
-  uint8_t iClockSource       ; ///< Index of a string descriptor, describing the Clock Selector Entity.
-} audio_desc_clock_selector_t;
+/// AUDIO Clock Selector Descriptor UAC2 (4.7.2.2) for ONE pin
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 7+p.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AC_INTERFACE_CLOCK_SELECTOR.
+  uint8_t bClockID;          ///< Constant uniquely identifying the Clock Selector Entity within the audio function. This value is used in all requests to address this Entity.
+  uint8_t bNrInPins;         ///< Number of Input Pins of this Unit: p = 1 thus bNrInPins = 1.
+  uint8_t baCSourceID;       ///< ID of the Clock Entity to which the first Clock Input Pin of this Clock Selector Entity is connected..
+  uint8_t bmControls;        ///< See: audio20_clock_selector_control_pos_t.
+  uint8_t iClockSource;      ///< Index of a string descriptor, describing the Clock Selector Entity.
+} audio20_desc_clock_selector_t;
 
 /// AUDIO Clock Selector Descriptor (4.7.2.2) for multiple pins
-#define audio_desc_clock_selector_n_t(source_num) \
-    struct TU_ATTR_PACKED {       \
-  uint8_t bLength               ; \
-  uint8_t bDescriptorType       ; \
-  uint8_t bDescriptorSubType    ; \
-  uint8_t bClockID              ; \
-  uint8_t bNrInPins             ; \
-  struct TU_ATTR_PACKED {         \
-    uint8_t baSourceID          ; \
-  } sourceID[source_num]        ; \
-  uint8_t bmControls            ; \
-  uint8_t iClockSource          ; \
-}
+#define audio20_desc_clock_selector_n_t(source_num) \
+  struct TU_ATTR_PACKED {                           \
+    uint8_t bLength;                                \
+    uint8_t bDescriptorType;                        \
+    uint8_t bDescriptorSubType;                     \
+    uint8_t bClockID;                               \
+    uint8_t bNrInPins;                              \
+    struct TU_ATTR_PACKED {                         \
+      uint8_t baSourceID;                           \
+    } sourceID[source_num];                         \
+    uint8_t bmControls;                             \
+    uint8_t iClockSource;                           \
+  }
 
-/// AUDIO Clock Multiplier Descriptor (4.7.2.3)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 7.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_CLOCK_MULTIPLIER.
-  uint8_t bClockID           ; ///< Constant uniquely identifying the Clock Multiplier Entity within the audio function. This value is used in all requests to address this Entity.
-  uint8_t bCSourceID         ; ///< ID of the Clock Entity to which the last Clock Input Pin of this Clock Selector Entity is connected.
-  uint8_t bmControls         ; ///< See: audio_clock_multiplier_control_pos_t.
-  uint8_t iClockSource       ; ///< Index of a string descriptor, describing the Clock Multiplier Entity.
-} audio_desc_clock_multiplier_t;
+/// AUDIO Clock Multiplier Descriptor UAC2 (4.7.2.3)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 7.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AC_INTERFACE_CLOCK_MULTIPLIER.
+  uint8_t bClockID;          ///< Constant uniquely identifying the Clock Multiplier Entity within the audio function. This value is used in all requests to address this Entity.
+  uint8_t bCSourceID;        ///< ID of the Clock Entity to which the last Clock Input Pin of this Clock Selector Entity is connected.
+  uint8_t bmControls;        ///< See: audio20_clock_multiplier_control_pos_t.
+  uint8_t iClockSource;      ///< Index of a string descriptor, describing the Clock Multiplier Entity.
+} audio20_desc_clock_multiplier_t;
 
 /// AUDIO Input Terminal Descriptor(4.7.2.4)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 17.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_INPUT_TERMINAL.
-  uint8_t bTerminalID        ; ///< Constant uniquely identifying the Terminal within the audio function. This value is used in all requests to address this terminal.
-  uint16_t wTerminalType     ; ///< Constant characterizing the type of Terminal. See: audio_terminal_type_t for USB streaming and audio_terminal_input_type_t for other input types.
-  uint8_t bAssocTerminal     ; ///< ID of the Output Terminal to which this Input Terminal is associated.
-  uint8_t bCSourceID         ; ///< ID of the Clock Entity to which this Input Terminal is connected.
-  uint8_t bNrChannels        ; ///< Number of logical output channels in the Terminal’s output audio channel cluster.
-  uint32_t bmChannelConfig   ; ///< Describes the spatial location of the logical channels. See:audio_channel_config_t.
-  uint8_t iChannelNames      ; ///< Index of a string descriptor, describing the name of the first logical channel.
-  uint16_t bmControls        ; ///< See: audio_terminal_input_control_pos_t.
-  uint8_t iTerminal          ; ///< Index of a string descriptor, describing the Input Terminal.
-} audio_desc_input_terminal_t;
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 17.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_INPUT_TERMINAL.
+  uint8_t bTerminalID;       ///< Constant uniquely identifying the Terminal within the audio function. This value is used in all requests to address this terminal.
+  uint16_t wTerminalType;    ///< Constant characterizing the type of Terminal. See: audio_terminal_type_t for USB streaming and audio_terminal_input_type_t for other input types.
+  uint8_t bAssocTerminal;    ///< ID of the Output Terminal to which this Input Terminal is associated.
+  uint8_t bCSourceID;        ///< ID of the Clock Entity to which this Input Terminal is connected.
+  uint8_t bNrChannels;       ///< Number of logical output channels in the Terminal’s output audio channel cluster.
+  uint32_t bmChannelConfig;  ///< Describes the spatial location of the logical channels. See:audio20_channel_config_t.
+  uint8_t iChannelNames;     ///< Index of a string descriptor, describing the name of the first logical channel.
+  uint16_t bmControls;       ///< See: audio_terminal_input_control_pos_t.
+  uint8_t iTerminal;         ///< Index of a string descriptor, describing the Input Terminal.
+} audio20_desc_input_terminal_t;
 
-/// AUDIO Output Terminal Descriptor(4.7.2.5)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 12.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_OUTPUT_TERMINAL.
-  uint8_t bTerminalID        ; ///< Constant uniquely identifying the Terminal within the audio function. This value is used in all requests to address this Terminal.
-  uint16_t wTerminalType     ; ///< Constant characterizing the type of Terminal. See: audio_terminal_type_t for USB streaming and audio_terminal_output_type_t for other output types.
-  uint8_t bAssocTerminal     ; ///< Constant, identifying the Input Terminal to which this Output Terminal is associated.
-  uint8_t bSourceID          ; ///< ID of the Unit or Terminal to which this Terminal is connected.
-  uint8_t bCSourceID         ; ///< ID of the Clock Entity to which this Output Terminal is connected.
-  uint16_t bmControls        ; ///< See: audio_terminal_output_type_t.
-  uint8_t iTerminal          ; ///< Index of a string descriptor, describing the Output Terminal.
-} audio_desc_output_terminal_t;
+/// AUDIO Output Terminal Descriptor UAC2 (4.7.2.5)
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 12.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AC_INTERFACE_OUTPUT_TERMINAL.
+  uint8_t bTerminalID;       ///< Constant uniquely identifying the Terminal within the audio function. This value is used in all requests to address this Terminal.
+  uint16_t wTerminalType;    ///< Constant characterizing the type of Terminal. See: audio20_terminal_type_t for USB streaming and audio20_terminal_output_type_t for other output types.
+  uint8_t bAssocTerminal;    ///< Constant, identifying the Input Terminal to which this Output Terminal is associated.
+  uint8_t bSourceID;         ///< ID of the Unit or Terminal to which this Terminal is connected.
+  uint8_t bCSourceID;        ///< ID of the Clock Entity to which this Output Terminal is connected.
+  uint16_t bmControls;       ///< See: audio20_terminal_output_control_pos_t.
+  uint8_t iTerminal;         ///< Index of a string descriptor, describing the Output Terminal.
+} audio20_desc_output_terminal_t;
 
-/// AUDIO Feature Unit Descriptor(4.7.2.8) for ONE channel
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 14.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AC_INTERFACE_FEATURE_UNIT.
-  uint8_t bUnitID            ; ///< Constant uniquely identifying the Unit within the audio function. This value is used in all requests to address this Unit.
-  uint8_t bSourceID          ; ///< ID of the Unit or Terminal to which this Feature Unit is connected.
+/// AUDIO Feature Unit Descriptor UAC2 (4.7.2.8) for ONE channel
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 14.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AC_INTERFACE_FEATURE_UNIT.
+  uint8_t bUnitID;           ///< Constant uniquely identifying the Unit within the audio function. This value is used in all requests to address this Unit.
+  uint8_t bSourceID;         ///< ID of the Unit or Terminal to which this Feature Unit is connected.
   struct TU_ATTR_PACKED {
-    uint32_t bmaControls     ; ///< See: audio_feature_unit_control_pos_t. Controls0 is master channel 0 (always present) and Controls1 is logical channel 1.
-  } controls[2]              ;
-  uint8_t iTerminal          ; ///< Index of a string descriptor, describing this Feature Unit.
-} audio_desc_feature_unit_t;
+    uint32_t bmaControls;///< See: audio20_feature_unit_control_pos_t. Controls0 is master channel 0 (always present) and Controls1 is logical channel 1.
+  } controls[2];
+  uint8_t iTerminal;///< Index of a string descriptor, describing this Feature Unit.
+} audio20_desc_feature_unit_t;
 
 /// AUDIO Feature Unit Descriptor(4.7.2.8) for multiple channels
-#define audio_desc_feature_unit_n_t(ch_num)\
-    struct TU_ATTR_PACKED {         \
-  uint8_t bLength               ; /* 6+(ch_num+1)*4 */\
-    uint8_t bDescriptorType     ; \
-    uint8_t bDescriptorSubType  ; \
-    uint8_t bUnitID             ; \
-    uint8_t bSourceID           ; \
-    struct TU_ATTR_PACKED {       \
-      uint32_t bmaControls      ; \
-    } controls[ch_num+1]        ; \
-    uint8_t iTerminal           ; \
-}
+#define audio20_desc_feature_unit_n_t(ch_num) \
+  struct TU_ATTR_PACKED {                     \
+    uint8_t bLength; /* 6+(ch_num+1)*4 */     \
+    uint8_t bDescriptorType;                  \
+    uint8_t bDescriptorSubType;               \
+    uint8_t bUnitID;                          \
+    uint8_t bSourceID;                        \
+    struct TU_ATTR_PACKED {                   \
+      uint32_t bmaControls;                   \
+    } controls[ch_num + 1];                   \
+    uint8_t iTerminal;                        \
+  }
 
 /// AUDIO Class-Specific AS Interface Descriptor(4.9.2)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 16.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AS_INTERFACE_AS_GENERAL.
-  uint8_t bTerminalLink      ; ///< The Terminal ID of the Terminal to which this interface is connected.
-  uint8_t bmControls         ; ///< See: audio_cs_as_interface_control_pos_t.
-  uint8_t bFormatType        ; ///< Constant identifying the Format Type the AudioStreaming interface is using. See: audio_format_type_t.
-  uint32_t bmFormats         ; ///< The Audio Data Format(s) that can be used to communicate with this interface.See: audio_data_format_type_I_t.
-  uint8_t bNrChannels        ; ///< Number of physical channels in the AS Interface audio channel cluster.
-  uint32_t bmChannelConfig   ; ///< Describes the spatial location of the physical channels. See: audio_channel_config_t.
-  uint8_t iChannelNames      ; ///< Index of a string descriptor, describing the name of the first physical channel.
-} audio_desc_cs_as_interface_t;
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 16.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AS_INTERFACE_AS_GENERAL.
+  uint8_t bTerminalLink;     ///< The Terminal ID of the Terminal to which this interface is connected.
+  uint8_t bmControls;        ///< See: audio20_cs_as_interface_control_pos_t.
+  uint8_t bFormatType;       ///< Constant identifying the Format Type the AudioStreaming interface is using. See: audio20_format_type_t.
+  uint32_t bmFormats;        ///< The Audio Data Format(s) that can be used to communicate with this interface.See: audio20_data_format_type_I_t.
+  uint8_t bNrChannels;       ///< Number of physical channels in the AS Interface audio channel cluster.
+  uint32_t bmChannelConfig;  ///< Describes the spatial location of the physical channels. See: audio20_channel_config_t.
+  uint8_t iChannelNames;     ///< Index of a string descriptor, describing the name of the first physical channel.
+} audio20_desc_cs_as_interface_t;
 
 /// AUDIO Type I Format Type Descriptor(2.3.1.6 - Audio Formats)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 6.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_AS_INTERFACE_FORMAT_TYPE.
-  uint8_t bFormatType        ; ///< Constant identifying the Format Type the AudioStreaming interface is using. Value: AUDIO_FORMAT_TYPE_I.
-  uint8_t bSubslotSize       ; ///< The number of bytes occupied by one audio subslot. Can be 1, 2, 3 or 4.
-  uint8_t bBitResolution     ; ///< The number of effectively used bits from the available bits in an audio subslot.
-} audio_desc_type_I_format_t;
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 6.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_INTERFACE.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_AS_INTERFACE_FORMAT_TYPE.
+  uint8_t bFormatType;       ///< Constant identifying the Format Type the AudioStreaming interface is using. Value: AUDIO20_FORMAT_TYPE_I.
+  uint8_t bSubslotSize;      ///< The number of bytes occupied by one audio subslot. Can be 1, 2, 3 or 4.
+  uint8_t bBitResolution;    ///< The number of effectively used bits from the available bits in an audio subslot.
+} audio20_desc_type_I_format_t;
 
 /// AUDIO Class-Specific AS Isochronous Audio Data Endpoint Descriptor(4.10.1.2)
-typedef struct TU_ATTR_PACKED
-{
-  uint8_t bLength            ; ///< Size of this descriptor, in bytes: 8.
-  uint8_t bDescriptorType    ; ///< Descriptor Type. Value: TUSB_DESC_CS_ENDPOINT.
-  uint8_t bDescriptorSubType ; ///< Descriptor SubType. Value: AUDIO_CS_EP_SUBTYPE_GENERAL.
-  uint8_t bmAttributes       ; ///< See: audio_cs_as_iso_data_ep_attribute_t.
-  uint8_t bmControls         ; ///< See: audio_cs_as_iso_data_ep_control_pos_t.
-  uint8_t bLockDelayUnits    ; ///< Indicates the units used for the wLockDelay field. See: audio_cs_as_iso_data_ep_lock_delay_unit_t.
-  uint16_t wLockDelay        ; ///< Indicates the time it takes this endpoint to reliably lock its internal clock recovery circuitry. Units used depend on the value of the bLockDelayUnits field.
-} audio_desc_cs_as_iso_data_ep_t;
+typedef struct TU_ATTR_PACKED {
+  uint8_t bLength;           ///< Size of this descriptor, in bytes: 8.
+  uint8_t bDescriptorType;   ///< Descriptor Type. Value: TUSB_DESC_CS_ENDPOINT.
+  uint8_t bDescriptorSubType;///< Descriptor SubType. Value: AUDIO20_CS_EP_SUBTYPE_GENERAL.
+  uint8_t bmAttributes;      ///< See: audio20_cs_as_iso_data_ep_attribute_t.
+  uint8_t bmControls;        ///< See: audio20_cs_as_iso_data_ep_control_pos_t.
+  uint8_t bLockDelayUnits;   ///< Indicates the units used for the wLockDelay field. See: audio20_cs_as_iso_data_ep_lock_delay_unit_t.
+  uint16_t wLockDelay;       ///< Indicates the time it takes this endpoint to reliably lock its internal clock recovery circuitry. Units used depend on the value of the bLockDelayUnits field.
+} audio20_desc_cs_as_iso_data_ep_t;
 
 // 5.2.2 Control Request Layout
-typedef struct TU_ATTR_PACKED
-{
-    union
-    {
-        struct TU_ATTR_PACKED
-        {
-            uint8_t recipient :  5; ///< Recipient type tusb_request_recipient_t.
-            uint8_t type      :  2; ///< Request type tusb_request_type_t.
-            uint8_t direction :  1; ///< Direction type. tusb_dir_t
-        } bmRequestType_bit;
+typedef struct TU_ATTR_PACKED {
+  union {
+    struct TU_ATTR_PACKED {
+      uint8_t recipient : 5;///< Recipient type tusb_request_recipient_t.
+      uint8_t type : 2;     ///< Request type tusb_request_type_t.
+      uint8_t direction : 1;///< Direction type. tusb_dir_t
+    } bmRequestType_bit;
 
-        uint8_t bmRequestType;
-    };
+    uint8_t bmRequestType;
+  };
 
-    uint8_t bRequest;  ///< Request type audio_cs_req_t
-    uint8_t bChannelNumber;
-    uint8_t bControlSelector;
-    union
-    {
-        uint8_t bInterface;
-        uint8_t bEndpoint;
-    };
-    uint8_t bEntityID;
-    uint16_t wLength;
-} audio_control_request_t;
+  uint8_t bRequest;///< Request type audio_cs_req_t
+  uint8_t bChannelNumber;
+  uint8_t bControlSelector;
+  union {
+    uint8_t bInterface;
+    uint8_t bEndpoint;
+  };
+  uint8_t bEntityID;
+  uint16_t wLength;
+} audio20_control_request_t;
 
 //// 5.2.3 Control Request Parameter Block Layout
 
 // 5.2.3.1 1-byte Control CUR Parameter Block
-typedef struct TU_ATTR_PACKED
-{
-  int8_t bCur               ;   ///< The setting for the CUR attribute of the addressed Control
-} audio_control_cur_1_t;
+typedef struct TU_ATTR_PACKED {
+  int8_t bCur;///< The setting for the CUR attribute of the addressed Control
+} audio20_control_cur_1_t;
 
 // 5.2.3.2 2-byte Control CUR Parameter Block
-typedef struct TU_ATTR_PACKED
-{
-  int16_t bCur              ;   ///< The setting for the CUR attribute of the addressed Control
-} audio_control_cur_2_t;
-
-// 5.2.3.3 4-byte Control CUR Parameter Block
-typedef struct TU_ATTR_PACKED
-{
-  int32_t bCur              ;   ///< The setting for the CUR attribute of the addressed Control
-} audio_control_cur_4_t;
-
-// Use the following ONLY for RECEIVED data - compiler does not know how many subranges are defined! Use the one below for predefined lengths - or if you know what you are doing do what you like
-// 5.2.3.1 1-byte Control RANGE Parameter Block
 typedef struct TU_ATTR_PACKED {
-  uint16_t wNumSubRanges;
-  struct TU_ATTR_PACKED {
-    int8_t bMin             ; /*The setting for the MIN attribute of the nth subrange of the addressed Control*/
-    int8_t bMax             ; /*The setting for the MAX attribute of the nth subrange of the addressed Control*/
-    uint8_t bRes            ; /*The setting for the RES attribute of the nth subrange of the addressed Control*/
-  } subrange[]              ;
-} audio_control_range_1_t;
+  int16_t bCur;///< The setting for the CUR attribute of the addressed Control
+} audio20_control_cur_2_t;
 
-// 5.2.3.2 2-byte Control RANGE Parameter Block
+// 5.2.3.3 4-byte Control CUR Parameter Block
 typedef struct TU_ATTR_PACKED {
-  uint16_t wNumSubRanges;
-  struct TU_ATTR_PACKED {
-    int16_t bMin            ; /*The setting for the MIN attribute of the nth subrange of the addressed Control*/
-    int16_t bMax            ; /*The setting for the MAX attribute of the nth subrange of the addressed Control*/
-    uint16_t bRes           ; /*The setting for the RES attribute of the nth subrange of the addressed Control*/
-  } subrange[]              ;
-} audio_control_range_2_t;
+  int32_t bCur;///< The setting for the CUR attribute of the addressed Control
+} audio20_control_cur_4_t;
 
-// 5.2.3.3 4-byte Control RANGE Parameter Block
-typedef struct TU_ATTR_PACKED {
-  uint16_t wNumSubRanges;
-  struct TU_ATTR_PACKED {
-    int32_t bMin            ; /*The setting for the MIN attribute of the nth subrange of the addressed Control*/
-    int32_t bMax            ; /*The setting for the MAX attribute of the nth subrange of the addressed Control*/
-    uint32_t bRes           ; /*The setting for the RES attribute of the nth subrange of the addressed Control*/
-  } subrange[]              ;
-} audio_control_range_4_t;
+// Use the following ONLY for RECEIVED data - compiler does not know how many subranges are defined! Use the #define macros below for predefined lengths.
 
 // 5.2.3.1 1-byte Control RANGE Parameter Block
-#define audio_control_range_1_n_t(numSubRanges) \
-    struct TU_ATTR_PACKED {                     \
-  uint16_t wNumSubRanges;                       \
-  struct TU_ATTR_PACKED {                       \
-      int8_t bMin               ; /*The setting for the MIN attribute of the nth subrange of the addressed Control*/\
-    int8_t bMax                 ; /*The setting for the MAX attribute of the nth subrange of the addressed Control*/\
-    uint8_t bRes                ; /*The setting for the RES attribute of the nth subrange of the addressed Control*/\
-    } subrange[numSubRanges]    ;               \
-}
+#define audio20_control_range_1_n_t(numSubRanges)                                                      \
+  struct TU_ATTR_PACKED {                                                                              \
+    uint16_t wNumSubRanges;                                                                            \
+    struct TU_ATTR_PACKED {                                                                            \
+      int8_t bMin;  /*The setting for the MIN attribute of the nth subrange of the addressed Control*/ \
+      int8_t bMax;  /*The setting for the MAX attribute of the nth subrange of the addressed Control*/ \
+      uint8_t bRes; /*The setting for the RES attribute of the nth subrange of the addressed Control*/ \
+    } subrange[numSubRanges];                                                                          \
+  }
 
 /// 5.2.3.2 2-byte Control RANGE Parameter Block
-#define audio_control_range_2_n_t(numSubRanges) \
-    struct TU_ATTR_PACKED {                     \
-  uint16_t wNumSubRanges;                       \
-  struct TU_ATTR_PACKED {                       \
-      int16_t bMin          ; /*The setting for the MIN attribute of the nth subrange of the addressed Control*/\
-    int16_t bMax            ; /*The setting for the MAX attribute of the nth subrange of the addressed Control*/\
-    uint16_t bRes           ; /*The setting for the RES attribute of the nth subrange of the addressed Control*/\
-    } subrange[numSubRanges];                   \
-}
+#define audio20_control_range_2_n_t(numSubRanges)                                                       \
+  struct TU_ATTR_PACKED {                                                                               \
+    uint16_t wNumSubRanges;                                                                             \
+    struct TU_ATTR_PACKED {                                                                             \
+      int16_t bMin;  /*The setting for the MIN attribute of the nth subrange of the addressed Control*/ \
+      int16_t bMax;  /*The setting for the MAX attribute of the nth subrange of the addressed Control*/ \
+      uint16_t bRes; /*The setting for the RES attribute of the nth subrange of the addressed Control*/ \
+    } subrange[numSubRanges];                                                                           \
+  }
 
 // 5.2.3.3 4-byte Control RANGE Parameter Block
-#define audio_control_range_4_n_t(numSubRanges) \
-    struct TU_ATTR_PACKED {                     \
-  uint16_t wNumSubRanges;                       \
-  struct TU_ATTR_PACKED {                       \
-      int32_t bMin          ; /*The setting for the MIN attribute of the nth subrange of the addressed Control*/\
-    int32_t bMax            ; /*The setting for the MAX attribute of the nth subrange of the addressed Control*/\
-    uint32_t bRes           ; /*The setting for the RES attribute of the nth subrange of the addressed Control*/\
-    } subrange[numSubRanges];                   \
-}
+#define audio20_control_range_4_n_t(numSubRanges)                                                       \
+  struct TU_ATTR_PACKED {                                                                               \
+    uint16_t wNumSubRanges;                                                                             \
+    struct TU_ATTR_PACKED {                                                                             \
+      int32_t bMin;  /*The setting for the MIN attribute of the nth subrange of the addressed Control*/ \
+      int32_t bMax;  /*The setting for the MAX attribute of the nth subrange of the addressed Control*/ \
+      uint32_t bRes; /*The setting for the RES attribute of the nth subrange of the addressed Control*/ \
+    } subrange[numSubRanges];                                                                           \
+  }
 
 // 6.1 Interrupt Data Message Format
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t bInfo;
   uint8_t bAttribute;
-  union
-  {
+  union {
     uint16_t wValue;
-    struct
-    {
+    struct {
       uint8_t wValue_cn_or_mcn;
       uint8_t wValue_cs;
     };
   };
-  union
-  {
+  union {
     uint16_t wIndex;
-    struct
-    {
+    struct {
       uint8_t wIndex_ep_or_int;
       uint8_t wIndex_entity_id;
     };
   };
+} audio20_interrupt_data_t;
+
+//--------------------------------------------------------------------+
+// APPLICATION HELPER DEFINITIONS
+//--------------------------------------------------------------------+
+
+// Combined Interrupt Data Message Format for both UAC1 and UAC2
+typedef union {
+  audio10_interrupt_data_t v1;
+  audio20_interrupt_data_t v2;
 } audio_interrupt_data_t;
 
+// MIDI1.0 use the same CS AC Interface Descriptor as UAC1
+typedef audio10_desc_cs_ac_interface_n_t(1) midi10_desc_cs_ac_interface_t;
+
+// UAC1.0 AC Interface Descriptor with 1 interface, used to read fields other than baInterfaceNr
+typedef audio10_desc_cs_ac_interface_n_t(1) audio10_desc_cs_ac_interface_1_t;
+
 /** @} */
 
 #ifdef __cplusplus
diff --git a/src/class/audio/audio_device.c b/src/class/audio/audio_device.c
index 7a6fd453f..4a8a60192 100644
--- a/src/class/audio/audio_device.c
+++ b/src/class/audio/audio_device.c
@@ -79,10 +79,9 @@
 // Linear buffer in case target MCU is not capable of handling a ring buffer FIFO e.g. no hardware buffer
 // is available or driver is would need to be changed dramatically
 
-// Only STM32 and dcd_transdimension use non-linear buffer for now
-// dwc2 except esp32sx (since it may use dcd_esp32sx)
+// Only STM32 and ChipIdea HS use non-linear buffer for now
 // Ring buffer is incompatible with dcache, since neither address nor size is aligned to cache line
-#if (defined(TUP_USBIP_DWC2) && !TU_CHECK_MCU(OPT_MCU_ESP32S2, OPT_MCU_ESP32S3)) || \
+#if defined(TUP_USBIP_DWC2) || \
     defined(TUP_USBIP_FSDEV) ||                                                     \
     CFG_TUSB_MCU == OPT_MCU_RX63X ||                                                \
     CFG_TUSB_MCU == OPT_MCU_RX65X ||                                                \
@@ -108,19 +107,19 @@
 #endif
 
 // Put swap buffer in USB section only if necessary
-#if USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_ENCODING
+#if USE_LINEAR_BUFFER
   #define IN_SW_BUF_MEM_ATTR TU_ATTR_ALIGNED(4)
 #else
   #define IN_SW_BUF_MEM_ATTR CFG_TUD_MEM_SECTION CFG_TUD_MEM_ALIGN
 #endif
-#if USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_DECODING
+#if USE_LINEAR_BUFFER
   #define OUT_SW_BUF_MEM_ATTR TU_ATTR_ALIGNED(4)
 #else
   #define OUT_SW_BUF_MEM_ATTR CFG_TUD_MEM_SECTION CFG_TUD_MEM_ALIGN
 #endif
 
-// EP IN software buffers and mutexes
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
+// EP IN software buffers
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
 tu_static IN_SW_BUF_MEM_ATTR struct {
   #if CFG_TUD_AUDIO_FUNC_1_EP_IN_SW_BUF_SZ > 0
   TUD_EPBUF_DEF(buf_1, CFG_TUD_AUDIO_FUNC_1_EP_IN_SW_BUF_SZ);
@@ -132,24 +131,11 @@ tu_static IN_SW_BUF_MEM_ATTR struct {
   TUD_EPBUF_DEF(buf_3, CFG_TUD_AUDIO_FUNC_3_EP_IN_SW_BUF_SZ);
   #endif
 } ep_in_sw_buf;
-
-  #if CFG_FIFO_MUTEX
-    #if CFG_TUD_AUDIO_FUNC_1_EP_IN_SW_BUF_SZ > 0
-    tu_static osal_mutex_def_t ep_in_ff_mutex_wr_1;
-    #endif
-    #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_EP_IN_SW_BUF_SZ > 0
-    tu_static osal_mutex_def_t ep_in_ff_mutex_wr_2;
-    #endif
-    #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_EP_IN_SW_BUF_SZ > 0
-    tu_static osal_mutex_def_t ep_in_ff_mutex_wr_3;
-    #endif
-  #endif
-#endif// CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
+#endif// CFG_TUD_AUDIO_ENABLE_EP_IN
 
 // Linear buffer TX in case:
 // - target MCU is not capable of handling a ring buffer FIFO e.g. no hardware buffer is available or driver is would need to be changed dramatically OR
-// - the software encoding is used - in this case the linear buffers serve as a target memory where logical channels are encoded into
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && (USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_ENCODING)
+#if CFG_TUD_AUDIO_ENABLE_EP_IN && USE_LINEAR_BUFFER
 tu_static CFG_TUD_MEM_SECTION struct {
   #if CFG_TUD_AUDIO_FUNC_1_EP_IN_SZ_MAX > 0
   TUD_EPBUF_DEF(buf_1, CFG_TUD_AUDIO_FUNC_1_EP_IN_SZ_MAX);
@@ -161,10 +147,10 @@ tu_static CFG_TUD_MEM_SECTION struct {
   TUD_EPBUF_DEF(buf_3, CFG_TUD_AUDIO_FUNC_3_EP_IN_SZ_MAX);
   #endif
 } lin_buf_in;
-#endif// CFG_TUD_AUDIO_ENABLE_EP_IN && (USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_DECODING)
+#endif// CFG_TUD_AUDIO_ENABLE_EP_IN && USE_LINEAR_BUFFER
 
-// EP OUT software buffers and mutexes
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+// EP OUT software buffers
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
 tu_static OUT_SW_BUF_MEM_ATTR struct {
   #if CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ > 0
   TUD_EPBUF_DEF(buf_1, CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ);
@@ -176,24 +162,11 @@ tu_static OUT_SW_BUF_MEM_ATTR struct {
   TUD_EPBUF_DEF(buf_3, CFG_TUD_AUDIO_FUNC_3_EP_OUT_SW_BUF_SZ);
   #endif
 } ep_out_sw_buf;
-
-  #if CFG_FIFO_MUTEX
-    #if CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ > 0
-    tu_static osal_mutex_def_t ep_out_ff_mutex_rd_1;
-    #endif
-    #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_EP_OUT_SW_BUF_SZ > 0
-    tu_static osal_mutex_def_t ep_out_ff_mutex_rd_2;
-    #endif
-    #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_EP_OUT_SW_BUF_SZ > 0
-    tu_static osal_mutex_def_t ep_out_ff_mutex_rd_3;
-    #endif
-  #endif
-#endif// CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+#endif// CFG_TUD_AUDIO_ENABLE_EP_OUT
 
 // Linear buffer RX in case:
 // - target MCU is not capable of handling a ring buffer FIFO e.g. no hardware buffer is available or driver is would need to be changed dramatically OR
-// - the software encoding is used - in this case the linear buffers serve as a target memory where logical channels are encoded into
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && (USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_DECODING)
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT && USE_LINEAR_BUFFER
 tu_static CFG_TUD_MEM_SECTION struct {
   #if CFG_TUD_AUDIO_FUNC_1_EP_OUT_SZ_MAX > 0
   TUD_EPBUF_DEF(buf_1, CFG_TUD_AUDIO_FUNC_1_EP_OUT_SZ_MAX);
@@ -205,82 +178,10 @@ tu_static CFG_TUD_MEM_SECTION struct {
   TUD_EPBUF_DEF(buf_3, CFG_TUD_AUDIO_FUNC_3_EP_OUT_SZ_MAX);
   #endif
 } lin_buf_out;
-#endif// CFG_TUD_AUDIO_ENABLE_EP_OUT && (USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_DECODING)
+#endif// CFG_TUD_AUDIO_ENABLE_EP_OUT && USE_LINEAR_BUFFER
 
-// Control buffers
-tu_static CFG_TUD_MEM_SECTION struct {
-  TUD_EPBUF_DEF(buf1, CFG_TUD_AUDIO_FUNC_1_CTRL_BUF_SZ);
-  #if CFG_TUD_AUDIO > 1
-  TUD_EPBUF_DEF(buf2, CFG_TUD_AUDIO_FUNC_2_CTRL_BUF_SZ);
-  #endif
-  #if CFG_TUD_AUDIO > 2
-  TUD_EPBUF_DEF(buf3, CFG_TUD_AUDIO_FUNC_3_CTRL_BUF_SZ);
-  #endif
-} ctrl_buf;
-
-// Active alternate setting of interfaces
-tu_static uint8_t alt_setting_1[CFG_TUD_AUDIO_FUNC_1_N_AS_INT];
-
-#if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_N_AS_INT > 0
-tu_static uint8_t alt_setting_2[CFG_TUD_AUDIO_FUNC_2_N_AS_INT];
-#endif
-
-#if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_N_AS_INT > 0
-tu_static uint8_t alt_setting_3[CFG_TUD_AUDIO_FUNC_3_N_AS_INT];
-#endif
-
-// Software encoding/decoding support FIFOs
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-  #if CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ > 0
-    tu_static TU_ATTR_ALIGNED(4) uint8_t tx_supp_ff_buf_1[CFG_TUD_AUDIO_FUNC_1_N_TX_SUPP_SW_FIFO][CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ];
-    tu_static tu_fifo_t tx_supp_ff_1[CFG_TUD_AUDIO_FUNC_1_N_TX_SUPP_SW_FIFO];
-    #if CFG_FIFO_MUTEX
-    tu_static osal_mutex_def_t tx_supp_ff_mutex_wr_1[CFG_TUD_AUDIO_FUNC_1_N_TX_SUPP_SW_FIFO];// No need for read mutex as only USB driver reads from FIFO
-    #endif
-  #endif
-
-  #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ > 0
-    tu_static TU_ATTR_ALIGNED(4) uint8_t tx_supp_ff_buf_2[CFG_TUD_AUDIO_FUNC_2_N_TX_SUPP_SW_FIFO][CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ];
-    tu_static tu_fifo_t tx_supp_ff_2[CFG_TUD_AUDIO_FUNC_2_N_TX_SUPP_SW_FIFO];
-    #if CFG_FIFO_MUTEX
-    tu_static osal_mutex_def_t tx_supp_ff_mutex_wr_2[CFG_TUD_AUDIO_FUNC_2_N_TX_SUPP_SW_FIFO];// No need for read mutex as only USB driver reads from FIFO
-    #endif
-  #endif
-
-  #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ > 0
-    tu_static TU_ATTR_ALIGNED(4) uint8_t tx_supp_ff_buf_3[CFG_TUD_AUDIO_FUNC_3_N_TX_SUPP_SW_FIFO][CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ];
-    tu_static tu_fifo_t tx_supp_ff_3[CFG_TUD_AUDIO_FUNC_3_N_TX_SUPP_SW_FIFO];
-    #if CFG_FIFO_MUTEX
-    tu_static osal_mutex_def_t tx_supp_ff_mutex_wr_3[CFG_TUD_AUDIO_FUNC_3_N_TX_SUPP_SW_FIFO];// No need for read mutex as only USB driver reads from FIFO
-    #endif
-  #endif
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-  #if CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ > 0
-    tu_static TU_ATTR_ALIGNED(4) uint8_t rx_supp_ff_buf_1[CFG_TUD_AUDIO_FUNC_1_N_RX_SUPP_SW_FIFO][CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ];
-    tu_static tu_fifo_t rx_supp_ff_1[CFG_TUD_AUDIO_FUNC_1_N_RX_SUPP_SW_FIFO];
-    #if CFG_FIFO_MUTEX
-    tu_static osal_mutex_def_t rx_supp_ff_mutex_rd_1[CFG_TUD_AUDIO_FUNC_1_N_RX_SUPP_SW_FIFO];// No need for write mutex as only USB driver writes into FIFO
-    #endif
-  #endif
-
-  #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ > 0
-    tu_static TU_ATTR_ALIGNED(4) uint8_t rx_supp_ff_buf_2[CFG_TUD_AUDIO_FUNC_2_N_RX_SUPP_SW_FIFO][CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ];
-    tu_static tu_fifo_t rx_supp_ff_2[CFG_TUD_AUDIO_FUNC_2_N_RX_SUPP_SW_FIFO];
-    #if CFG_FIFO_MUTEX
-    tu_static osal_mutex_def_t rx_supp_ff_mutex_rd_2[CFG_TUD_AUDIO_FUNC_2_N_RX_SUPP_SW_FIFO];// No need for write mutex as only USB driver writes into FIFO
-    #endif
-  #endif
-
-  #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ > 0
-    tu_static TU_ATTR_ALIGNED(4) uint8_t rx_supp_ff_buf_3[CFG_TUD_AUDIO_FUNC_3_N_RX_SUPP_SW_FIFO][CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ];
-    tu_static tu_fifo_t rx_supp_ff_3[CFG_TUD_AUDIO_FUNC_3_N_RX_SUPP_SW_FIFO];
-    #if CFG_FIFO_MUTEX
-    tu_static osal_mutex_def_t rx_supp_ff_mutex_rd_3[CFG_TUD_AUDIO_FUNC_3_N_RX_SUPP_SW_FIFO];// No need for write mutex as only USB driver writes into FIFO
-    #endif
-  #endif
-#endif
+// Control buffer
+CFG_TUD_MEM_ALIGN uint8_t ctrl_buf[CFG_TUD_AUDIO_CTRL_BUF_SZ];
 
 // Aligned buffer for feedback EP
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
@@ -308,18 +209,22 @@ typedef struct
 {
   uint8_t rhport;
   uint8_t const *p_desc;// Pointer pointing to Standard AC Interface Descriptor(4.7.1) - Audio Control descriptor defining audio function
+  uint8_t const *p_desc_as;// Pointer pointing to 1st Standard AS Interface Descriptor(4.9.1) - Audio Streaming descriptor defining audio function
+  uint16_t desc_length;// Length of audio function descriptor
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
   uint8_t ep_in;            // TX audio data EP.
   uint16_t ep_in_sz;        // Current size of TX EP
   uint8_t ep_in_as_intf_num;// Corresponding Standard AS Interface Descriptor (4.9.1) belonging to output terminal to which this EP belongs - 0 is invalid (this fits to UAC2 specification since AS interfaces can not have interface number equal to zero)
-#endif
+  uint8_t ep_in_alt;        // Current alternate setting of TX EP
+  uint16_t ep_in_fifo_threshold;// Target size for the EP IN FIFO.
+  #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
   uint8_t ep_out;            // Incoming (into uC) audio data EP.
   uint16_t ep_out_sz;        // Current size of RX EP
   uint8_t ep_out_as_intf_num;// Corresponding Standard AS Interface Descriptor (4.9.1) belonging to input terminal to which this EP belongs - 0 is invalid (this fits to UAC2 specification since AS interfaces can not have interface number equal to zero)
-
+  uint8_t ep_out_alt;        // Current alternate setting of RX EP
   #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
   uint8_t ep_fb;// Feedback EP.
   #endif
@@ -332,8 +237,6 @@ typedef struct
 
   bool mounted;// Device opened
 
-  uint16_t desc_length;// Length of audio function descriptor
-
 #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
   struct {
     uint32_t value;    // Feedback value for asynchronous mode (in 16.16 format).
@@ -342,7 +245,6 @@ typedef struct
 
     uint8_t frame_shift;// bInterval-1 in unit of frame (FS), micro-frame (HS)
     uint8_t compute_method;
-    bool format_correction;
     union {
       uint8_t power_of_2;// pre-computed power of 2 shift
       float float_const; // pre-computed float constant
@@ -363,82 +265,34 @@ typedef struct
   } feedback;
 #endif// CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
 
-// Decoding parameters - parameters are set when alternate AS interface is set by host
-// Coding is currently only supported for EP. Software coding corresponding to AS interfaces without EPs are not supported currently.
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-  audio_format_type_t format_type_rx;
-  uint8_t n_channels_rx;
-
-  #if CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-  audio_data_format_type_I_t format_type_I_rx;
-  uint8_t n_bytes_per_sample_rx;
-  uint8_t n_ff_used_rx;
-  #endif
-#endif
-
 #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
   uint32_t sample_rate_tx;
   uint16_t packet_sz_tx[3];
   uint8_t bclock_id_tx;
   uint8_t interval_tx;
-#endif
-
-// Encoding parameters - parameters are set when alternate AS interface is set by host
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && (CFG_TUD_AUDIO_ENABLE_ENCODING || CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL)
-  audio_format_type_t format_type_tx;
+  uint8_t format_type_tx;
   uint8_t n_channels_tx;
   uint8_t n_bytes_per_sample_tx;
-
-  #if CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-  audio_data_format_type_I_t format_type_I_tx;
-  uint8_t n_ff_used_tx;
-  #endif
 #endif
 
   /*------------- From this point, data is not cleared by bus reset -------------*/
 
-  // Buffer for control requests
-  uint8_t *ctrl_buf;
-  uint8_t ctrl_buf_sz;
-
-  // Current active alternate settings
-  uint8_t *alt_setting;// We need to save the current alternate setting this way, because it is possible that there are AS interfaces which do not have an EP!
-
 // EP Transfer buffers and FIFOs
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
   tu_fifo_t ep_out_ff;
 #endif
 
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
   tu_fifo_t ep_in_ff;
 #endif
 
-// Support FIFOs for software encoding and decoding
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-  tu_fifo_t *rx_supp_ff;
-  uint8_t n_rx_supp_ff;
-  uint16_t rx_supp_ff_sz_max;
-  #if CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-  uint8_t n_channels_per_ff_rx;
-  #endif
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-  tu_fifo_t *tx_supp_ff;
-  uint8_t n_tx_supp_ff;
-  uint16_t tx_supp_ff_sz_max;
-  #if CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-  uint8_t n_channels_per_ff_tx;
-  #endif
-#endif
-
-// Linear buffer in case target MCU is not capable of handling a ring buffer FIFO e.g. no hardware buffer is available or driver is would need to be changed dramatically OR the support FIFOs are used
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && (USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_DECODING)
+// Linear buffer in case target MCU is not capable of handling a ring buffer FIFO e.g. no hardware buffer is available or driver is would need to be changed dramatically
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT && USE_LINEAR_BUFFER
   uint8_t *lin_buf_out;
   #define USE_LINEAR_BUFFER_RX 1
 #endif
 
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && (USE_LINEAR_BUFFER || CFG_TUD_AUDIO_ENABLE_ENCODING)
+#if CFG_TUD_AUDIO_ENABLE_EP_IN && USE_LINEAR_BUFFER
   uint8_t *lin_buf_in;
   #define USE_LINEAR_BUFFER_TX 1
 #endif
@@ -456,42 +310,30 @@ typedef struct
   #define USE_LINEAR_BUFFER_RX 0
 #endif
 
-#define ITF_MEM_RESET_SIZE offsetof(audiod_function_t, ctrl_buf)
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
+#define ITF_MEM_RESET_SIZE offsetof(audiod_function_t, ep_out_ff)
+#else
+#define ITF_MEM_RESET_SIZE offsetof(audiod_function_t, ep_in_ff)
+#endif
 
 //--------------------------------------------------------------------+
 // WEAK FUNCTION STUBS
 //--------------------------------------------------------------------+
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
-TU_ATTR_WEAK bool tud_audio_tx_done_pre_load_cb(uint8_t rhport, uint8_t func_id, uint8_t ep_in, uint8_t cur_alt_setting) {
+TU_ATTR_WEAK bool tud_audio_tx_done_isr(uint8_t rhport, uint16_t n_bytes_sent, uint8_t func_id, uint8_t ep_in, uint8_t cur_alt_setting) {
   (void) rhport;
+  (void) n_bytes_sent;
   (void) func_id;
   (void) ep_in;
   (void) cur_alt_setting;
   return true;
 }
 
-TU_ATTR_WEAK bool tud_audio_tx_done_post_load_cb(uint8_t rhport, uint16_t n_bytes_copied, uint8_t func_id, uint8_t ep_in, uint8_t cur_alt_setting) {
-  (void) rhport;
-  (void) n_bytes_copied;
-  (void) func_id;
-  (void) ep_in;
-  (void) cur_alt_setting;
-  return true;
-}
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-TU_ATTR_WEAK bool tud_audio_rx_done_pre_read_cb(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out, uint8_t cur_alt_setting) {
-  (void) rhport;
-  (void) n_bytes_received;
-  (void) func_id;
-  (void) ep_out;
-  (void) cur_alt_setting;
-  return true;
-}
-
-TU_ATTR_WEAK bool tud_audio_rx_done_post_read_cb(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out, uint8_t cur_alt_setting) {
+TU_ATTR_WEAK bool tud_audio_rx_done_isr(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out, uint8_t cur_alt_setting) {
   (void) rhport;
   (void) n_bytes_received;
   (void) func_id;
@@ -502,21 +344,12 @@ TU_ATTR_WEAK bool tud_audio_rx_done_post_read_cb(uint8_t rhport, uint16_t n_byte
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-TU_ATTR_WEAK void tud_audio_fb_done_cb(uint8_t func_id) {
-  (void) func_id;
-}
-
 TU_ATTR_WEAK void tud_audio_feedback_params_cb(uint8_t func_id, uint8_t alt_itf, audio_feedback_params_t *feedback_param) {
   (void) func_id;
   (void) alt_itf;
   feedback_param->method = AUDIO_FEEDBACK_METHOD_DISABLED;
 }
 
-TU_ATTR_WEAK bool tud_audio_feedback_format_correction_cb(uint8_t func_id) {
-  (void) func_id;
-  return CFG_TUD_AUDIO_ENABLE_FEEDBACK_FORMAT_CORRECTION;
-}
-
 TU_ATTR_WEAK TU_ATTR_FAST_FUNC void tud_audio_feedback_interval_isr(uint8_t func_id, uint32_t frame_number, uint8_t interval_shift) {
   (void) func_id;
   (void) frame_number;
@@ -538,7 +371,7 @@ TU_ATTR_WEAK bool tud_audio_set_itf_cb(uint8_t rhport, tusb_control_request_t co
 }
 
 // Invoked when audio set interface request received which closes an EP
-TU_ATTR_WEAK bool tud_audio_set_itf_close_EP_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
+TU_ATTR_WEAK bool tud_audio_set_itf_close_ep_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
   (void) rhport;
   (void) p_request;
   return true;
@@ -601,42 +434,29 @@ TU_ATTR_WEAK bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_reque
 tu_static CFG_TUD_MEM_SECTION audiod_function_t _audiod_fct[CFG_TUD_AUDIO];
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-static bool audiod_rx_done_cb(uint8_t rhport, audiod_function_t *audio, uint16_t n_bytes_received);
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_DECODING && CFG_TUD_AUDIO_ENABLE_EP_OUT
-static bool audiod_decode_type_I_pcm(uint8_t rhport, audiod_function_t *audio, uint16_t n_bytes_received);
+static bool audiod_rx_xfer_isr(uint8_t rhport, audiod_function_t* audio, uint16_t n_bytes_received);
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
-static bool audiod_tx_done_cb(uint8_t rhport, audiod_function_t *audio);
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_ENCODING && CFG_TUD_AUDIO_ENABLE_EP_IN
-static uint16_t audiod_encode_type_I_pcm(uint8_t rhport, audiod_function_t *audio);
+static bool audiod_tx_xfer_isr(uint8_t rhport, audiod_function_t* audio, uint16_t n_bytes_sent);
 #endif
 
 static bool audiod_get_interface(uint8_t rhport, tusb_control_request_t const *p_request);
 static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p_request);
 
-static bool audiod_get_AS_interface_index_global(uint8_t itf, uint8_t *func_id, uint8_t *idxItf, uint8_t const **pp_desc_int);
-static bool audiod_get_AS_interface_index(uint8_t itf, audiod_function_t *audio, uint8_t *idxItf, uint8_t const **pp_desc_int);
 static bool audiod_verify_entity_exists(uint8_t itf, uint8_t entityID, uint8_t *func_id);
 static bool audiod_verify_itf_exists(uint8_t itf, uint8_t *func_id);
 static bool audiod_verify_ep_exists(uint8_t ep, uint8_t *func_id);
-static uint8_t audiod_get_audio_fct_idx(audiod_function_t *audio);
-
-#if (CFG_TUD_AUDIO_ENABLE_EP_IN && (CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL || CFG_TUD_AUDIO_ENABLE_ENCODING)) || (CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING)
-static void audiod_parse_for_AS_params(audiod_function_t *audio, uint8_t const *p_desc, uint8_t const *p_desc_end, uint8_t const as_itf);
-#endif
+static inline uint8_t audiod_get_audio_fct_idx(audiod_function_t *audio);
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
+static void audiod_parse_flow_control_params(audiod_function_t *audio, uint8_t const *p_desc);
 static bool audiod_calc_tx_packet_sz(audiod_function_t *audio);
-static uint16_t audiod_tx_packet_size(const uint16_t *norminal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t max_size);
+static uint16_t audiod_tx_packet_size(const uint16_t *nominal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t fifo_threshold, uint16_t max_size);
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-static bool audiod_set_fb_params_freq(audiod_function_t *audio, uint32_t sample_freq, uint32_t mclk_freq);
+static bool audiod_fb_params_prepare(uint8_t func_id, uint8_t alt);
 static void audiod_fb_fifo_count_update(audiod_function_t *audio, uint16_t lvl_new);
 #endif
 
@@ -651,7 +471,7 @@ bool tud_audio_n_mounted(uint8_t func_id) {
 // READ API
 //--------------------------------------------------------------------+
 
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
 
 uint16_t tud_audio_n_available(uint8_t func_id) {
   TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL);
@@ -669,275 +489,108 @@ bool tud_audio_n_clear_ep_out_ff(uint8_t func_id) {
 }
 
 tu_fifo_t *tud_audio_n_get_ep_out_ff(uint8_t func_id) {
-  if (func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL) return &_audiod_fct[func_id].ep_out_ff;
+  if (func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL) {
+    return &_audiod_fct[func_id].ep_out_ff;
+  }
   return NULL;
 }
 
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_DECODING && CFG_TUD_AUDIO_ENABLE_EP_OUT
-// Delete all content in the support RX FIFOs
-bool tud_audio_n_clear_rx_support_ff(uint8_t func_id, uint8_t ff_idx) {
-  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL && ff_idx < _audiod_fct[func_id].n_rx_supp_ff);
-  return tu_fifo_clear(&_audiod_fct[func_id].rx_supp_ff[ff_idx]);
-}
-
-uint16_t tud_audio_n_available_support_ff(uint8_t func_id, uint8_t ff_idx) {
-  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL && ff_idx < _audiod_fct[func_id].n_rx_supp_ff);
-  return tu_fifo_count(&_audiod_fct[func_id].rx_supp_ff[ff_idx]);
-}
-
-uint16_t tud_audio_n_read_support_ff(uint8_t func_id, uint8_t ff_idx, void *buffer, uint16_t bufsize) {
-  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL && ff_idx < _audiod_fct[func_id].n_rx_supp_ff);
-  return tu_fifo_read_n(&_audiod_fct[func_id].rx_supp_ff[ff_idx], buffer, bufsize);
-}
-
-tu_fifo_t *tud_audio_n_get_rx_support_ff(uint8_t func_id, uint8_t ff_idx) {
-  if (func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL && ff_idx < _audiod_fct[func_id].n_rx_supp_ff) return &_audiod_fct[func_id].rx_supp_ff[ff_idx];
-  return NULL;
-}
-#endif
-
-// This function is called once an audio packet is received by the USB and is responsible for putting data from USB memory into EP_OUT_FIFO (or support FIFOs + decoding of received stream into audio channels).
-// If you prefer your own (more efficient) implementation suiting your purpose set CFG_TUD_AUDIO_ENABLE_DECODING = 0.
-
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT
-
-static bool audiod_rx_done_cb(uint8_t rhport, audiod_function_t *audio, uint16_t n_bytes_received) {
-  uint8_t idxItf = 0;
-  uint8_t const *dummy2;
-  uint8_t idx_audio_fct = 0;
-
-  idx_audio_fct = audiod_get_audio_fct_idx(audio);
-  TU_VERIFY(audiod_get_AS_interface_index(audio->ep_out_as_intf_num, audio, &idxItf, &dummy2));
-
-  // Call a weak callback here - a possibility for user to get informed an audio packet was received and data gets now loaded into EP FIFO (or decoded into support RX software FIFO)
-  TU_VERIFY(tud_audio_rx_done_pre_read_cb(rhport, n_bytes_received, idx_audio_fct, audio->ep_out, audio->alt_setting[idxItf]));
-
-  #if CFG_TUD_AUDIO_ENABLE_DECODING
-
-  switch (audio->format_type_rx) {
-    case AUDIO_FORMAT_TYPE_UNDEFINED:
-      // INDIVIDUAL DECODING PROCEDURE REQUIRED HERE!
-      TU_LOG2("  Desired CFG_TUD_AUDIO_FORMAT encoding not implemented!\r\n");
-      TU_BREAKPOINT();
-      break;
-
-    case AUDIO_FORMAT_TYPE_I:
-
-      switch (audio->format_type_I_rx) {
-        case AUDIO_DATA_FORMAT_TYPE_I_PCM:
-          TU_VERIFY(audiod_decode_type_I_pcm(rhport, audio, n_bytes_received));
-          break;
-
-        default:
-          // DESIRED CFG_TUD_AUDIO_FORMAT_TYPE_I_RX NOT IMPLEMENTED!
-          TU_LOG2("  Desired CFG_TUD_AUDIO_FORMAT_TYPE_I_RX encoding not implemented!\r\n");
-          TU_BREAKPOINT();
-          break;
-      }
-      break;
-
-    default:
-      // Desired CFG_TUD_AUDIO_FORMAT_TYPE_RX not implemented!
-      TU_LOG2("  Desired CFG_TUD_AUDIO_FORMAT_TYPE_RX not implemented!\r\n");
-      TU_BREAKPOINT();
-      break;
-  }
-
-  // Prepare for next transmission
-  TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_out, audio->lin_buf_out, audio->ep_out_sz), false);
-
-  #else
+static bool audiod_rx_xfer_isr(uint8_t rhport, audiod_function_t* audio, uint16_t n_bytes_received) {
+  uint8_t idx_audio_fct = audiod_get_audio_fct_idx(audio);
 
-    #if USE_LINEAR_BUFFER_RX
+  #if USE_LINEAR_BUFFER_RX
   // Data currently is in linear buffer, copy into EP OUT FIFO
-  TU_VERIFY(tu_fifo_write_n(&audio->ep_out_ff, audio->lin_buf_out, n_bytes_received));
+  TU_VERIFY(0 < tu_fifo_write_n(&audio->ep_out_ff, audio->lin_buf_out, n_bytes_received));
 
   // Schedule for next receive
   TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_out, audio->lin_buf_out, audio->ep_out_sz), false);
-    #else
+  #else
   // Data is already placed in EP FIFO, schedule for next receive
   TU_VERIFY(usbd_edpt_xfer_fifo(rhport, audio->ep_out, &audio->ep_out_ff, audio->ep_out_sz), false);
-    #endif
+  #endif
 
-    #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
+  #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
   if (audio->feedback.compute_method == AUDIO_FEEDBACK_METHOD_FIFO_COUNT) {
     audiod_fb_fifo_count_update(audio, tu_fifo_count(&audio->ep_out_ff));
   }
-    #endif
-
   #endif
 
-  // Call a weak callback here - a possibility for user to get informed decoding was completed
-  TU_VERIFY(tud_audio_rx_done_post_read_cb(rhport, n_bytes_received, idx_audio_fct, audio->ep_out, audio->alt_setting[idxItf]));
+  // Call a weak callback here - a possibility for user to get informed an audio packet was received and data gets now loaded into EP FIFO
+  TU_VERIFY(tud_audio_rx_done_isr(rhport, n_bytes_received, idx_audio_fct, audio->ep_out, audio->ep_out_alt));
 
   return true;
 }
 
 #endif//CFG_TUD_AUDIO_ENABLE_EP_OUT
 
-// The following functions are used in case CFG_TUD_AUDIO_ENABLE_DECODING != 0
-#if CFG_TUD_AUDIO_ENABLE_DECODING && CFG_TUD_AUDIO_ENABLE_EP_OUT
-
-// Decoding according to 2.3.1.5 Audio Streams
-
-// Helper function
-static inline void *audiod_interleaved_copy_bytes_fast_decode(uint16_t const nBytesPerSample, void *dst, const void *dst_end, void *src, uint8_t const n_ff_used) {
-  // Due to one FIFO contains 2 channels, data always aligned to (nBytesPerSample * 2)
-  uint16_t *dst16 = dst;
-  uint16_t *src16 = src;
-  const uint16_t *dst_end16 = dst_end;
-  uint32_t *dst32 = dst;
-  uint32_t *src32 = src;
-  const uint32_t *dst_end32 = dst_end;
-
-  if (nBytesPerSample == 1) {
-    while (dst16 < dst_end16) {
-      *dst16++ = *src16++;
-      src16 += n_ff_used - 1;
-    }
-    return src16;
-  } else if (nBytesPerSample == 2) {
-    while (dst32 < dst_end32) {
-      *dst32++ = *src32++;
-      src32 += n_ff_used - 1;
-    }
-    return src32;
-  } else if (nBytesPerSample == 3) {
-    while (dst16 < dst_end16) {
-      *dst16++ = *src16++;
-      *dst16++ = *src16++;
-      *dst16++ = *src16++;
-      src16 += 3 * (n_ff_used - 1);
-    }
-    return src16;
-  } else// nBytesPerSample == 4
-  {
-    while (dst32 < dst_end32) {
-      *dst32++ = *src32++;
-      *dst32++ = *src32++;
-      src32 += 2 * (n_ff_used - 1);
-    }
-    return src32;
-  }
-}
-
-static bool audiod_decode_type_I_pcm(uint8_t rhport, audiod_function_t *audio, uint16_t n_bytes_received) {
-  (void) rhport;
-
-  // Determine amount of samples
-  uint8_t const n_ff_used = audio->n_ff_used_rx;
-  uint16_t const nBytesPerFFToRead = n_bytes_received / n_ff_used;
-  uint8_t cnt_ff;
-
-  // Decode
-  uint8_t *src;
-  uint8_t *dst_end;
-
-  tu_fifo_buffer_info_t info;
-
-  for (cnt_ff = 0; cnt_ff < n_ff_used; cnt_ff++) {
-    tu_fifo_get_write_info(&audio->rx_supp_ff[cnt_ff], &info);
-
-    if (info.len_lin != 0) {
-      info.len_lin = tu_min16(nBytesPerFFToRead, info.len_lin);
-      src = &audio->lin_buf_out[cnt_ff * audio->n_channels_per_ff_rx * audio->n_bytes_per_sample_rx];
-      dst_end = info.ptr_lin + info.len_lin;
-      src = audiod_interleaved_copy_bytes_fast_decode(audio->n_bytes_per_sample_rx, info.ptr_lin, dst_end, src, n_ff_used);
-
-      // Handle wrapped part of FIFO
-      info.len_wrap = tu_min16(nBytesPerFFToRead - info.len_lin, info.len_wrap);
-      if (info.len_wrap != 0) {
-        dst_end = info.ptr_wrap + info.len_wrap;
-        audiod_interleaved_copy_bytes_fast_decode(audio->n_bytes_per_sample_rx, info.ptr_wrap, dst_end, src, n_ff_used);
-      }
-      tu_fifo_advance_write_pointer(&audio->rx_supp_ff[cnt_ff], info.len_lin + info.len_wrap);
-    }
-  }
-
-  // Number of bytes should be a multiple of CFG_TUD_AUDIO_N_BYTES_PER_SAMPLE_RX * CFG_TUD_AUDIO_N_CHANNELS_RX but checking makes no sense - no way to correct it
-  // TU_VERIFY(cnt != n_bytes);
-
-  #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-  if (audio->feedback.compute_method == AUDIO_FEEDBACK_METHOD_FIFO_COUNT) {
-    audiod_fb_fifo_count_update(audio, tu_fifo_count(&audio->rx_supp_ff[0]));
-  }
-  #endif
-
-  return true;
-}
-#endif//CFG_TUD_AUDIO_ENABLE_DECODING
-
 //--------------------------------------------------------------------+
 // WRITE API
 //--------------------------------------------------------------------+
 
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
 
-/**
- * \brief           Write data to EP in buffer
- *
- *  Write data to buffer. If it is full, new data can be inserted once a transmit was scheduled. See audiod_tx_done_cb().
- *  If TX FIFOs are used, this function is not available in order to not let the user mess up the encoding process.
- *
- * \param[in]       func_id: Index of audio function interface
- * \param[in]       data: Pointer to data array to be copied from
- * \param[in]       len: # of array elements to copy
- * \return          Number of bytes actually written
- */
 uint16_t tud_audio_n_write(uint8_t func_id, const void *data, uint16_t len) {
   TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL);
   return tu_fifo_write_n(&_audiod_fct[func_id].ep_in_ff, data, len);
 }
 
-bool tud_audio_n_clear_ep_in_ff(uint8_t func_id)// Delete all content in the EP IN FIFO
-{
+bool tud_audio_n_clear_ep_in_ff(uint8_t func_id) {
   TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL);
   return tu_fifo_clear(&_audiod_fct[func_id].ep_in_ff);
 }
 
 tu_fifo_t *tud_audio_n_get_ep_in_ff(uint8_t func_id) {
-  if (func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL) return &_audiod_fct[func_id].ep_in_ff;
+  if (func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL) {
+    return &_audiod_fct[func_id].ep_in_ff;
+  }
   return NULL;
 }
 
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_ENCODING && CFG_TUD_AUDIO_ENABLE_EP_IN
-
-uint16_t tud_audio_n_flush_tx_support_ff(uint8_t func_id)// Force all content in the support TX FIFOs to be written into linear buffer and schedule a transmit
-{
-  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL);
-  audiod_function_t *audio = &_audiod_fct[func_id];
+uint16_t tud_audio_n_get_ep_in_fifo_threshold(uint8_t func_id) {
+  if (func_id < CFG_TUD_AUDIO) return _audiod_fct[func_id].ep_in_fifo_threshold;
+  return 0;
+}
 
-  uint16_t n_bytes_copied = tu_fifo_count(&audio->tx_supp_ff[0]);
+void tud_audio_n_set_ep_in_fifo_threshold(uint8_t func_id, uint16_t threshold) {
+  if (func_id < CFG_TUD_AUDIO && threshold < _audiod_fct[func_id].ep_in_ff.depth) {
+    _audiod_fct[func_id].ep_in_fifo_threshold = threshold;
+  }
+}
 
-  TU_VERIFY(audiod_tx_done_cb(audio->rhport, audio));
+static bool audiod_tx_xfer_isr(uint8_t rhport, audiod_function_t * audio, uint16_t n_bytes_sent) {
+  uint8_t idx_audio_fct = audiod_get_audio_fct_idx(audio);
 
-  n_bytes_copied -= tu_fifo_count(&audio->tx_supp_ff[0]);
-  n_bytes_copied = n_bytes_copied * audio->tx_supp_ff[0].item_size;
+  // Only send something if current alternate interface is not 0 as in this case nothing is to be sent due to UAC2 specifications
+  if (audio->ep_in_alt == 0) { return false; }
 
-  return n_bytes_copied;
-}
+  // Send everything in ISO EP FIFO
+  uint16_t n_bytes_tx;
 
-bool tud_audio_n_clear_tx_support_ff(uint8_t func_id, uint8_t ff_idx) {
-  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL && ff_idx < _audiod_fct[func_id].n_tx_supp_ff);
-  return tu_fifo_clear(&_audiod_fct[func_id].tx_supp_ff[ff_idx]);
-}
+  #if CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
+  // packet_sz_tx is based on total packet size, here we want size for each support buffer.
+  n_bytes_tx = audiod_tx_packet_size(audio->packet_sz_tx, tu_fifo_count(&audio->ep_in_ff), audio->ep_in_ff.depth, audio->ep_in_fifo_threshold, audio->ep_in_sz);
+  #else
+  n_bytes_tx = tu_min16(tu_fifo_count(&audio->ep_in_ff), audio->ep_in_sz);// Limit up to max packet size, more can not be done for ISO
+  #endif
+  #if USE_LINEAR_BUFFER_TX
+  tu_fifo_read_n(&audio->ep_in_ff, audio->lin_buf_in, n_bytes_tx);
+  TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_in, audio->lin_buf_in, n_bytes_tx));
+  #else
+  // Send everything in ISO EP FIFO
+  TU_VERIFY(usbd_edpt_xfer_fifo(rhport, audio->ep_in, &audio->ep_in_ff, n_bytes_tx));
+  #endif
 
-uint16_t tud_audio_n_write_support_ff(uint8_t func_id, uint8_t ff_idx, const void *data, uint16_t len) {
-  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL && ff_idx < _audiod_fct[func_id].n_tx_supp_ff);
-  return tu_fifo_write_n(&_audiod_fct[func_id].tx_supp_ff[ff_idx], data, len);
-}
+  // Call a weak callback here - a possibility for user to get informed former TX was completed and data gets now loaded into EP in buffer
+  TU_VERIFY(tud_audio_tx_done_isr(rhport, n_bytes_sent, idx_audio_fct, audio->ep_in, audio->ep_in_alt));
 
-tu_fifo_t *tud_audio_n_get_tx_support_ff(uint8_t func_id, uint8_t ff_idx) {
-  if (func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL && ff_idx < _audiod_fct[func_id].n_tx_supp_ff) return &_audiod_fct[func_id].tx_supp_ff[ff_idx];
-  return NULL;
+  return true;
 }
 
 #endif
 
+//--------------------------------------------------------------------+
+// OTHER API
+//--------------------------------------------------------------------+
 
 #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
 // If no interrupt transmit is pending bytes get written into buffer and a transmit is scheduled - once transmit completed tud_audio_int_done_cb() is called in inform user
@@ -949,10 +602,15 @@ bool tud_audio_int_n_write(uint8_t func_id, const audio_interrupt_data_t *data)
   // We write directly into the EP's buffer - abort if previous transfer not complete
   TU_VERIFY(usbd_edpt_claim(_audiod_fct[func_id].rhport, _audiod_fct[func_id].ep_int));
 
+  uint8_t size = tud_audio_n_version(func_id) == 2 ? sizeof(audio20_interrupt_data_t) : sizeof(audio10_interrupt_data_t);
+
+  // INT EP buffer must be large enough
+  TU_ASSERT(size <= sizeof(int_ep_buf[func_id].buf));
+
   // Check length
-  if (tu_memcpy_s(int_ep_buf[func_id].buf, sizeof(int_ep_buf[func_id].buf), data, sizeof(audio_interrupt_data_t)) == 0) {
+  if (tu_memcpy_s(int_ep_buf[func_id].buf, sizeof(int_ep_buf[func_id].buf), data, size) == 0) {
     // Schedule transmit
-    TU_ASSERT(usbd_edpt_xfer(_audiod_fct[func_id].rhport, _audiod_fct[func_id].ep_int, int_ep_buf[func_id].buf, sizeof(int_ep_buf[func_id].buf)), 0);
+    TU_ASSERT(usbd_edpt_xfer(_audiod_fct[func_id].rhport, _audiod_fct[func_id].ep_int, int_ep_buf[func_id].buf, size), 0);
   } else {
     // Release endpoint since we don't make any transfer
     usbd_edpt_release(_audiod_fct[func_id].rhport, _audiod_fct[func_id].ep_int);
@@ -962,254 +620,87 @@ bool tud_audio_int_n_write(uint8_t func_id, const audio_interrupt_data_t *data)
 }
 #endif
 
-// This function is called once a transmit of an audio packet was successfully completed. Here, we encode samples and place it in IN EP's buffer for next transmission.
-// If you prefer your own (more efficient) implementation suiting your purpose set CFG_TUD_AUDIO_ENABLE_ENCODING = 0 and use tud_audio_n_write.
-
-// n_bytes_copied - Informs caller how many bytes were loaded. In case n_bytes_copied = 0, a ZLP is scheduled to inform host no data is available for current frame.
-#if CFG_TUD_AUDIO_ENABLE_EP_IN
-static bool audiod_tx_done_cb(uint8_t rhport, audiod_function_t *audio) {
-  uint8_t idxItf;
-  uint8_t const *dummy2;
-
-  uint8_t idx_audio_fct = audiod_get_audio_fct_idx(audio);
-  TU_VERIFY(audiod_get_AS_interface_index(audio->ep_in_as_intf_num, audio, &idxItf, &dummy2));
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
+// This function is called once a transmit of a feedback packet was successfully completed. Here, we get the next feedback value to be sent
+static inline bool audiod_fb_send(uint8_t func_id) {
+  audiod_function_t *audio = &_audiod_fct[func_id];
+  uint8_t uac_version = tud_audio_n_version(func_id);
+  // Format the feedback value
+  if (uac_version == 1) {
+    uint8_t *fb = (uint8_t *) audio->fb_buf;
 
-  // Only send something if current alternate interface is not 0 as in this case nothing is to be sent due to UAC2 specifications
-  if (audio->alt_setting[idxItf] == 0) return false;
+    // For FS format is 10.14
+    *(fb++) = (audio->feedback.value >> 2) & 0xFF;
+    *(fb++) = (audio->feedback.value >> 10) & 0xFF;
+    *(fb++) = (audio->feedback.value >> 18) & 0xFF;
+    *fb = 0;
+  } else {
+    *audio->fb_buf = audio->feedback.value;
+  }
 
-  // Call a weak callback here - a possibility for user to get informed former TX was completed and data gets now loaded into EP in buffer (in case FIFOs are used) or
-  // if no FIFOs are used the user may use this call back to load its data into the EP IN buffer by use of tud_audio_n_write_ep_in_buffer().
-  TU_VERIFY(tud_audio_tx_done_pre_load_cb(rhport, idx_audio_fct, audio->ep_in, audio->alt_setting[idxItf]));
+  return usbd_edpt_xfer(audio->rhport, audio->ep_fb, (uint8_t *) audio->fb_buf, uac_version == 1 ? 3 : 4);
+}
 
-  // Send everything in ISO EP FIFO
-  uint16_t n_bytes_tx;
+uint32_t tud_audio_feedback_update(uint8_t func_id, uint32_t cycles) {
+  audiod_function_t *audio = &_audiod_fct[func_id];
+  uint32_t feedback;
 
-  // If support FIFOs are used, encode and schedule transmit
-  #if CFG_TUD_AUDIO_ENABLE_ENCODING && CFG_TUD_AUDIO_ENABLE_EP_IN
-  switch (audio->format_type_tx) {
-    case AUDIO_FORMAT_TYPE_UNDEFINED:
-      // INDIVIDUAL ENCODING PROCEDURE REQUIRED HERE!
-      TU_LOG2("  Desired CFG_TUD_AUDIO_FORMAT encoding not implemented!\r\n");
-      TU_BREAKPOINT();
-      n_bytes_tx = 0;
+  switch (audio->feedback.compute_method) {
+    case AUDIO_FEEDBACK_METHOD_FREQUENCY_POWER_OF_2:
+      feedback = (cycles << audio->feedback.compute.power_of_2);
       break;
 
-    case AUDIO_FORMAT_TYPE_I:
-
-      switch (audio->format_type_I_tx) {
-        case AUDIO_DATA_FORMAT_TYPE_I_PCM:
-
-          n_bytes_tx = audiod_encode_type_I_pcm(rhport, audio);
-          break;
-
-        default:
-          // YOUR ENCODING IS REQUIRED HERE!
-          TU_LOG2("  Desired CFG_TUD_AUDIO_FORMAT_TYPE_I_TX encoding not implemented!\r\n");
-          TU_BREAKPOINT();
-          n_bytes_tx = 0;
-          break;
-      }
+    case AUDIO_FEEDBACK_METHOD_FREQUENCY_FLOAT:
+      feedback = (uint32_t) ((float) cycles * audio->feedback.compute.float_const);
       break;
 
+    case AUDIO_FEEDBACK_METHOD_FREQUENCY_FIXED: {
+      uint64_t fb64 = (((uint64_t) cycles) * audio->feedback.compute.fixed.sample_freq) << (16 - (audio->feedback.frame_shift - 1));
+      feedback = (uint32_t) (fb64 / audio->feedback.compute.fixed.mclk_freq);
+    } break;
+
     default:
-      // Desired CFG_TUD_AUDIO_FORMAT_TYPE_TX not implemented!
-      TU_LOG2("  Desired CFG_TUD_AUDIO_FORMAT_TYPE_TX not implemented!\r\n");
-      TU_BREAKPOINT();
-      n_bytes_tx = 0;
-      break;
+      return 0;
   }
 
-  TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_in, audio->lin_buf_in, n_bytes_tx));
-
-  #else
-    // No support FIFOs, if no linear buffer required schedule transmit, else put data into linear buffer and schedule
-    #if CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
-  // packet_sz_tx is based on total packet size, here we want size for each support buffer.
-  n_bytes_tx = audiod_tx_packet_size(audio->packet_sz_tx, tu_fifo_count(&audio->ep_in_ff), audio->ep_in_ff.depth, audio->ep_in_sz);
-    #else
-  n_bytes_tx = tu_min16(tu_fifo_count(&audio->ep_in_ff), audio->ep_in_sz);// Limit up to max packet size, more can not be done for ISO
-    #endif
-    #if USE_LINEAR_BUFFER_TX
-  tu_fifo_read_n(&audio->ep_in_ff, audio->lin_buf_in, n_bytes_tx);
-  TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_in, audio->lin_buf_in, n_bytes_tx));
-    #else
-  // Send everything in ISO EP FIFO
-  TU_VERIFY(usbd_edpt_xfer_fifo(rhport, audio->ep_in, &audio->ep_in_ff, n_bytes_tx));
-    #endif
-
-  #endif
-
-  // Call a weak callback here - a possibility for user to get informed former TX was completed and how many bytes were loaded for the next frame
-  TU_VERIFY(tud_audio_tx_done_post_load_cb(rhport, n_bytes_tx, idx_audio_fct, audio->ep_in, audio->alt_setting[idxItf]));
-
-  return true;
-}
-
-#endif//CFG_TUD_AUDIO_ENABLE_EP_IN
-
-#if CFG_TUD_AUDIO_ENABLE_ENCODING && CFG_TUD_AUDIO_ENABLE_EP_IN
-// Take samples from the support buffer and encode them into the IN EP software FIFO
-// Returns number of bytes written into linear buffer
-
-/* 2.3.1.7.1 PCM Format
-The PCM (Pulse Coded Modulation) format is the most commonly used audio format to represent audio
-data streams. The audio data is not compressed and uses a signed two’s-complement fixed point format. It
-is left-justified (the sign bit is the Msb) and data is padded with trailing zeros to fill the remaining unused
-bits of the subslot. The binary point is located to the right of the sign bit so that all values lie within the
-range [-1, +1)
- */
-
-/*
- * This function encodes channels saved within the support FIFOs into one stream by interleaving the PCM samples
- * in the support FIFOs according to 2.3.1.5 Audio Streams. It does not control justification (left or right) and
- * does not change the number of bytes per sample.
- * */
-
-// Helper function
-static inline void *audiod_interleaved_copy_bytes_fast_encode(uint16_t const nBytesPerSample, void *src, const void *src_end, void *dst, uint8_t const n_ff_used) {
-  // Due to one FIFO contains 2 channels, data always aligned to (nBytesPerSample * 2)
-  uint16_t *dst16 = dst;
-  uint16_t *src16 = src;
-  const uint16_t *src_end16 = src_end;
-  uint32_t *dst32 = dst;
-  uint32_t *src32 = src;
-  const uint32_t *src_end32 = src_end;
-
-  if (nBytesPerSample == 1) {
-    while (src16 < src_end16) {
-      *dst16++ = *src16++;
-      dst16 += n_ff_used - 1;
-    }
-    return dst16;
-  } else if (nBytesPerSample == 2) {
-    while (src32 < src_end32) {
-      *dst32++ = *src32++;
-      dst32 += n_ff_used - 1;
-    }
-    return dst32;
-  } else if (nBytesPerSample == 3) {
-    while (src16 < src_end16) {
-      *dst16++ = *src16++;
-      *dst16++ = *src16++;
-      *dst16++ = *src16++;
-      dst16 += 3 * (n_ff_used - 1);
-    }
-    return dst16;
-  } else// nBytesPerSample == 4
-  {
-    while (src32 < src_end32) {
-      *dst32++ = *src32++;
-      *dst32++ = *src32++;
-      dst32 += 2 * (n_ff_used - 1);
-    }
-    return dst32;
+  // For Windows: https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/usb-2-0-audio-drivers
+  // The size of isochronous packets created by the device must be within the limits specified in FMT-2.0 section 2.3.1.1.
+  // This means that the deviation of actual packet size from nominal size must not exceed +/- one audio slot
+  // (audio slot = channel count samples).
+  if (feedback > audio->feedback.max_value) {
+    feedback = audio->feedback.max_value;
   }
-}
-
-static uint16_t audiod_encode_type_I_pcm(uint8_t rhport, audiod_function_t *audio) {
-  // This function relies on the fact that the length of the support FIFOs was configured to be a multiple of the active sample size in bytes s.t. no sample is split within a wrap
-  // This is ensured within set_interface, where the FIFOs are reconfigured according to this size
-
-  // We encode directly into IN EP's linear buffer - abort if previous transfer not complete
-  TU_VERIFY(!usbd_edpt_busy(rhport, audio->ep_in));
-
-  // Determine amount of samples
-  uint8_t const n_ff_used = audio->n_ff_used_tx;
-  uint16_t nBytesPerFFToSend = tu_fifo_count(&audio->tx_supp_ff[0]);
-  uint8_t cnt_ff;
-
-  for (cnt_ff = 1; cnt_ff < n_ff_used; cnt_ff++) {
-    uint16_t const count = tu_fifo_count(&audio->tx_supp_ff[cnt_ff]);
-    if (count < nBytesPerFFToSend) {
-      nBytesPerFFToSend = count;
-    }
+  if (feedback < audio->feedback.min_value) {
+    feedback = audio->feedback.min_value;
   }
 
-  #if CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
-  const uint16_t norm_packet_sz_tx[3] = {audio->packet_sz_tx[0] / n_ff_used,
-                                         audio->packet_sz_tx[1] / n_ff_used,
-                                         audio->packet_sz_tx[2] / n_ff_used};
-  // packet_sz_tx is based on total packet size, here we want size for each support buffer.
-  nBytesPerFFToSend = audiod_tx_packet_size(norm_packet_sz_tx, nBytesPerFFToSend, audio->tx_supp_ff[0].depth, audio->ep_in_sz / n_ff_used);
-  // Check if there is enough data
-  if (nBytesPerFFToSend == 0) return 0;
-  #else
-  // Check if there is enough data
-  if (nBytesPerFFToSend == 0) return 0;
-  // Limit to maximum sample number - THIS IS A POSSIBLE ERROR SOURCE IF TOO MANY SAMPLE WOULD NEED TO BE SENT BUT CAN NOT!
-  nBytesPerFFToSend = tu_min16(nBytesPerFFToSend, audio->ep_in_sz / n_ff_used);
-  // Round to full number of samples (flooring)
-  uint16_t const nSlotSize = audio->n_channels_per_ff_tx * audio->n_bytes_per_sample_tx;
-  nBytesPerFFToSend = (nBytesPerFFToSend / nSlotSize) * nSlotSize;
-  #endif
-
-  // Encode
-  uint8_t *dst;
-  uint8_t *src_end;
-
-  tu_fifo_buffer_info_t info;
-
-  for (cnt_ff = 0; cnt_ff < n_ff_used; cnt_ff++) {
-    dst = &audio->lin_buf_in[cnt_ff * audio->n_channels_per_ff_tx * audio->n_bytes_per_sample_tx];
-
-    tu_fifo_get_read_info(&audio->tx_supp_ff[cnt_ff], &info);
-
-    if (info.len_lin != 0) {
-      info.len_lin = tu_min16(nBytesPerFFToSend, info.len_lin);// Limit up to desired length
-      src_end = (uint8_t *) info.ptr_lin + info.len_lin;
-      dst = audiod_interleaved_copy_bytes_fast_encode(audio->n_bytes_per_sample_tx, info.ptr_lin, src_end, dst, n_ff_used);
+  tud_audio_n_fb_set(func_id, feedback);
 
-      // Limit up to desired length
-      info.len_wrap = tu_min16(nBytesPerFFToSend - info.len_lin, info.len_wrap);
+  return feedback;
+}
 
-      // Handle wrapped part of FIFO
-      if (info.len_wrap != 0) {
-        src_end = (uint8_t *) info.ptr_wrap + info.len_wrap;
-        audiod_interleaved_copy_bytes_fast_encode(audio->n_bytes_per_sample_tx, info.ptr_wrap, src_end, dst, n_ff_used);
-      }
+bool tud_audio_n_fb_set(uint8_t func_id, uint32_t feedback) {
+  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL);
 
-      tu_fifo_advance_read_pointer(&audio->tx_supp_ff[cnt_ff], info.len_lin + info.len_wrap);
-    }
-  }
+  _audiod_fct[func_id].feedback.value = feedback;
 
-  return nBytesPerFFToSend * n_ff_used;
+  return true;
 }
-#endif//CFG_TUD_AUDIO_ENABLE_ENCODING
+#endif
 
-// This function is called once a transmit of a feedback packet was successfully completed. Here, we get the next feedback value to be sent
+uint8_t tud_audio_n_version(uint8_t func_id) {
+  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL);
 
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-static inline bool audiod_fb_send(audiod_function_t *audio) {
-  bool apply_correction = (TUSB_SPEED_FULL == tud_speed_get()) && audio->feedback.format_correction;
-  // Format the feedback value
-  if (apply_correction) {
-    uint8_t *fb = (uint8_t *) audio->fb_buf;
+  uint8_t bIntfProtocol = ((tusb_desc_interface_t const *)_audiod_fct[func_id].p_desc)->bInterfaceProtocol;
 
-    // For FS format is 10.14
-    *(fb++) = (audio->feedback.value >> 2) & 0xFF;
-    *(fb++) = (audio->feedback.value >> 10) & 0xFF;
-    *(fb++) = (audio->feedback.value >> 18) & 0xFF;
-    *fb = 0;
+  if (bIntfProtocol == AUDIO_INT_PROTOCOL_CODE_V1) {
+    return 1;
+  } else if (bIntfProtocol == AUDIO_INT_PROTOCOL_CODE_V2) {
+    return 2;
   } else {
-    *audio->fb_buf = audio->feedback.value;
+    return 0; // Unknown version
   }
-
-  // About feedback format on FS
-  //
-  // 3 variables: Format | packetSize | sendSize | Working OS:
-  //              16.16    4            4          Linux, Windows
-  //              16.16    4            3          Linux
-  //              16.16    3            4          Linux
-  //              16.16    3            3          Linux
-  //              10.14    4            4          Linux
-  //              10.14    4            3          Linux
-  //              10.14    3            4          Linux, OSX
-  //              10.14    3            3          Linux, OSX
-  //
-  // We send 3 bytes since sending packet larger than wMaxPacketSize is pretty ugly
-  return usbd_edpt_xfer(audio->rhport, audio->ep_fb, (uint8_t *) audio->fb_buf, apply_correction ? 3 : 4);
 }
-#endif
 
 //--------------------------------------------------------------------+
 // USBD Driver API
@@ -1220,75 +711,26 @@ void audiod_init(void) {
   for (uint8_t i = 0; i < CFG_TUD_AUDIO; i++) {
     audiod_function_t *audio = &_audiod_fct[i];
 
-    // Initialize control buffers
-    switch (i) {
-      case 0:
-        audio->ctrl_buf = ctrl_buf.buf1;
-        audio->ctrl_buf_sz = CFG_TUD_AUDIO_FUNC_1_CTRL_BUF_SZ;
-        break;
-#if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_CTRL_BUF_SZ > 0
-      case 1:
-        audio->ctrl_buf = ctrl_buf.buf2;
-        audio->ctrl_buf_sz = CFG_TUD_AUDIO_FUNC_2_CTRL_BUF_SZ;
-        break;
-#endif
-#if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_CTRL_BUF_SZ > 0
-      case 2:
-        audio->ctrl_buf = ctrl_buf.buf3;
-        audio->ctrl_buf_sz = CFG_TUD_AUDIO_FUNC_3_CTRL_BUF_SZ;
-        break;
-#endif
-    }
-
-    // Initialize active alternate interface buffers
-    switch (i) {
-#if CFG_TUD_AUDIO_FUNC_1_N_AS_INT > 0
-      case 0:
-        audio->alt_setting = alt_setting_1;
-        break;
-#endif
-#if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_N_AS_INT > 0
-      case 1:
-        audio->alt_setting = alt_setting_2;
-        break;
-#endif
-#if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_N_AS_INT > 0
-      case 2:
-        audio->alt_setting = alt_setting_3;
-        break;
-#endif
-    }
-
       // Initialize IN EP FIFO if required
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
-
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
     switch (i) {
   #if CFG_TUD_AUDIO_FUNC_1_EP_IN_SW_BUF_SZ > 0
       case 0:
         tu_fifo_config(&audio->ep_in_ff, ep_in_sw_buf.buf_1, CFG_TUD_AUDIO_FUNC_1_EP_IN_SW_BUF_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-        tu_fifo_config_mutex(&audio->ep_in_ff, osal_mutex_create(&ep_in_ff_mutex_wr_1), NULL);
-    #endif
         break;
   #endif
   #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_EP_IN_SW_BUF_SZ > 0
       case 1:
         tu_fifo_config(&audio->ep_in_ff, ep_in_sw_buf.buf_2, CFG_TUD_AUDIO_FUNC_2_EP_IN_SW_BUF_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-        tu_fifo_config_mutex(&audio->ep_in_ff, osal_mutex_create(&ep_in_ff_mutex_wr_2), NULL);
-    #endif
         break;
   #endif
   #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_EP_IN_SW_BUF_SZ > 0
       case 2:
         tu_fifo_config(&audio->ep_in_ff, ep_in_sw_buf.buf_3, CFG_TUD_AUDIO_FUNC_3_EP_IN_SW_BUF_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-        tu_fifo_config_mutex(&audio->ep_in_ff, osal_mutex_create(&ep_in_ff_mutex_wr_3), NULL);
-    #endif
         break;
   #endif
     }
-#endif// CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
+#endif// CFG_TUD_AUDIO_ENABLE_EP_IN
 
       // Initialize linear buffers
 #if USE_LINEAR_BUFFER_TX
@@ -1312,35 +754,26 @@ void audiod_init(void) {
 #endif// USE_LINEAR_BUFFER_TX
 
       // Initialize OUT EP FIFO if required
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
 
     switch (i) {
   #if CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ > 0
       case 0:
         tu_fifo_config(&audio->ep_out_ff, ep_out_sw_buf.buf_1, CFG_TUD_AUDIO_FUNC_1_EP_OUT_SW_BUF_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-        tu_fifo_config_mutex(&audio->ep_out_ff, NULL, osal_mutex_create(&ep_out_ff_mutex_rd_1));
-    #endif
         break;
   #endif
   #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_EP_OUT_SW_BUF_SZ > 0
       case 1:
         tu_fifo_config(&audio->ep_out_ff, ep_out_sw_buf.buf_2, CFG_TUD_AUDIO_FUNC_2_EP_OUT_SW_BUF_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-        tu_fifo_config_mutex(&audio->ep_out_ff, NULL, osal_mutex_create(&ep_out_ff_mutex_rd_2));
-    #endif
         break;
   #endif
   #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_EP_OUT_SW_BUF_SZ > 0
       case 2:
         tu_fifo_config(&audio->ep_out_ff, ep_out_sw_buf.buf_3, CFG_TUD_AUDIO_FUNC_3_EP_OUT_SW_BUF_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-        tu_fifo_config_mutex(&audio->ep_out_ff, NULL, osal_mutex_create(&ep_out_ff_mutex_rd_3));
-    #endif
         break;
   #endif
     }
-#endif// CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+#endif// CFG_TUD_AUDIO_ENABLE_EP_OUT
 
       // Initialize linear buffers
 #if USE_LINEAR_BUFFER_RX
@@ -1382,150 +815,6 @@ void audiod_init(void) {
   #endif
     }
 #endif// CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-
-      // Initialize TX support FIFOs if required
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-
-    switch (i) {
-  #if CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ > 0
-      case 0:
-        audio->tx_supp_ff = tx_supp_ff_1;
-        audio->n_tx_supp_ff = CFG_TUD_AUDIO_FUNC_1_N_TX_SUPP_SW_FIFO;
-        audio->tx_supp_ff_sz_max = CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ;
-        for (uint8_t cnt = 0; cnt < CFG_TUD_AUDIO_FUNC_1_N_TX_SUPP_SW_FIFO; cnt++) {
-          tu_fifo_config(&tx_supp_ff_1[cnt], tx_supp_ff_buf_1[cnt], CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-          tu_fifo_config_mutex(&tx_supp_ff_1[cnt], osal_mutex_create(&tx_supp_ff_mutex_wr_1[cnt]), NULL);
-    #endif
-        }
-
-        break;
-  #endif// CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ > 0
-
-  #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ > 0
-      case 1:
-        audio->tx_supp_ff = tx_supp_ff_2;
-        audio->n_tx_supp_ff = CFG_TUD_AUDIO_FUNC_2_N_TX_SUPP_SW_FIFO;
-        audio->tx_supp_ff_sz_max = CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ;
-        for (uint8_t cnt = 0; cnt < CFG_TUD_AUDIO_FUNC_2_N_TX_SUPP_SW_FIFO; cnt++) {
-          tu_fifo_config(&tx_supp_ff_2[cnt], tx_supp_ff_buf_2[cnt], CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-          tu_fifo_config_mutex(&tx_supp_ff_2[cnt], osal_mutex_create(&tx_supp_ff_mutex_wr_2[cnt]), NULL);
-    #endif
-        }
-
-        break;
-  #endif// CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ > 0
-
-  #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ > 0
-      case 2:
-        audio->tx_supp_ff = tx_supp_ff_3;
-        audio->n_tx_supp_ff = CFG_TUD_AUDIO_FUNC_3_N_TX_SUPP_SW_FIFO;
-        audio->tx_supp_ff_sz_max = CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ;
-        for (uint8_t cnt = 0; cnt < CFG_TUD_AUDIO_FUNC_3_N_TX_SUPP_SW_FIFO; cnt++) {
-          tu_fifo_config(&tx_supp_ff_3[cnt], tx_supp_ff_buf_3[cnt], CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-          tu_fifo_config_mutex(&tx_supp_ff_3[cnt], osal_mutex_create(&tx_supp_ff_mutex_wr_3[cnt]), NULL);
-    #endif
-        }
-
-        break;
-  #endif// CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ > 0
-    }
-#endif// CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-
-      // Set encoding parameters for Type_I formats
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-    switch (i) {
-  #if CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ > 0
-      case 0:
-        audio->n_channels_per_ff_tx = CFG_TUD_AUDIO_FUNC_1_CHANNEL_PER_FIFO_TX;
-        break;
-  #endif
-  #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ > 0
-      case 1:
-        audio->n_channels_per_ff_tx = CFG_TUD_AUDIO_FUNC_2_CHANNEL_PER_FIFO_TX;
-        break;
-  #endif
-  #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ > 0
-      case 2:
-        audio->n_channels_per_ff_tx = CFG_TUD_AUDIO_FUNC_3_CHANNEL_PER_FIFO_TX;
-        break;
-  #endif
-    }
-#endif// CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-
-      // Initialize RX support FIFOs if required
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-
-    switch (i) {
-  #if CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ > 0
-      case 0:
-        audio->rx_supp_ff = rx_supp_ff_1;
-        audio->n_rx_supp_ff = CFG_TUD_AUDIO_FUNC_1_N_RX_SUPP_SW_FIFO;
-        audio->rx_supp_ff_sz_max = CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ;
-        for (uint8_t cnt = 0; cnt < CFG_TUD_AUDIO_FUNC_1_N_RX_SUPP_SW_FIFO; cnt++) {
-          tu_fifo_config(&rx_supp_ff_1[cnt], rx_supp_ff_buf_1[cnt], CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-          tu_fifo_config_mutex(&rx_supp_ff_1[cnt], osal_mutex_create(&rx_supp_ff_mutex_rd_1[cnt]), NULL);
-    #endif
-        }
-
-        break;
-  #endif// CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ > 0
-
-  #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ > 0
-      case 1:
-        audio->rx_supp_ff = rx_supp_ff_2;
-        audio->n_rx_supp_ff = CFG_TUD_AUDIO_FUNC_2_N_RX_SUPP_SW_FIFO;
-        audio->rx_supp_ff_sz_max = CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ;
-        for (uint8_t cnt = 0; cnt < CFG_TUD_AUDIO_FUNC_2_N_RX_SUPP_SW_FIFO; cnt++) {
-          tu_fifo_config(&rx_supp_ff_2[cnt], rx_supp_ff_buf_2[cnt], CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-          tu_fifo_config_mutex(&rx_supp_ff_2[cnt], osal_mutex_create(&rx_supp_ff_mutex_rd_2[cnt]), NULL);
-    #endif
-        }
-
-        break;
-  #endif// CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ > 0
-
-  #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ > 0
-      case 2:
-        audio->rx_supp_ff = rx_supp_ff_3;
-        audio->n_rx_supp_ff = CFG_TUD_AUDIO_FUNC_3_N_RX_SUPP_SW_FIFO;
-        audio->rx_supp_ff_sz_max = CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ;
-        for (uint8_t cnt = 0; cnt < CFG_TUD_AUDIO_FUNC_3_N_RX_SUPP_SW_FIFO; cnt++) {
-          tu_fifo_config(&rx_supp_ff_3[cnt], rx_supp_ff_buf_3[cnt], CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ, 1, true);
-    #if CFG_FIFO_MUTEX
-          tu_fifo_config_mutex(&rx_supp_ff_3[cnt], osal_mutex_create(&rx_supp_ff_mutex_rd_3[cnt]), NULL);
-    #endif
-        }
-
-        break;
-  #endif// CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ > 0
-    }
-#endif// CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-
-      // Set encoding parameters for Type_I formats
-#if CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-    switch (i) {
-  #if CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ > 0
-      case 0:
-        audio->n_channels_per_ff_rx = CFG_TUD_AUDIO_FUNC_1_CHANNEL_PER_FIFO_RX;
-        break;
-  #endif
-  #if CFG_TUD_AUDIO > 1 && CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ > 0
-      case 1:
-        audio->n_channels_per_ff_rx = CFG_TUD_AUDIO_FUNC_2_CHANNEL_PER_FIFO_RX;
-        break;
-  #endif
-  #if CFG_TUD_AUDIO > 2 && CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ > 0
-      case 2:
-        audio->n_channels_per_ff_rx = CFG_TUD_AUDIO_FUNC_3_CHANNEL_PER_FIFO_RX;
-        break;
-  #endif
-    }
-#endif// CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
   }
 }
 
@@ -1540,25 +829,13 @@ void audiod_reset(uint8_t rhport) {
     audiod_function_t *audio = &_audiod_fct[i];
     tu_memclr(audio, ITF_MEM_RESET_SIZE);
 
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
     tu_fifo_clear(&audio->ep_in_ff);
 #endif
 
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
     tu_fifo_clear(&audio->ep_out_ff);
 #endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-    for (uint8_t cnt = 0; cnt < audio->n_tx_supp_ff; cnt++) {
-      tu_fifo_clear(&audio->tx_supp_ff[cnt]);
-    }
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-    for (uint8_t cnt = 0; cnt < audio->n_rx_supp_ff; cnt++) {
-      tu_fifo_clear(&audio->rx_supp_ff[cnt]);
-    }
-#endif
   }
 }
 
@@ -1569,7 +846,8 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
             AUDIO_SUBCLASS_CONTROL == itf_desc->bInterfaceSubClass);
 
   // Verify version is correct - this check can be omitted
-  TU_VERIFY(itf_desc->bInterfaceProtocol == AUDIO_INT_PROTOCOL_CODE_V2);
+  TU_VERIFY(itf_desc->bInterfaceProtocol == AUDIO_INT_PROTOCOL_CODE_V1 ||
+            itf_desc->bInterfaceProtocol == AUDIO_INT_PROTOCOL_CODE_V2);
 
   // Verify interrupt control EP is enabled if demanded by descriptor
   TU_ASSERT(itf_desc->bNumEndpoints <= 1);// 0 or 1 EPs are allowed
@@ -1587,21 +865,32 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
       _audiod_fct[i].p_desc = (uint8_t const *) itf_desc;// Save pointer to AC descriptor which is by specification always the first one
       _audiod_fct[i].rhport = rhport;
 
-      // Setup descriptor lengths
-      switch (i) {
-        case 0:
-          _audiod_fct[i].desc_length = CFG_TUD_AUDIO_FUNC_1_DESC_LEN;
-          break;
-#if CFG_TUD_AUDIO > 1
-        case 1:
-          _audiod_fct[i].desc_length = CFG_TUD_AUDIO_FUNC_2_DESC_LEN;
-          break;
-#endif
-#if CFG_TUD_AUDIO > 2
-        case 2:
-          _audiod_fct[i].desc_length = CFG_TUD_AUDIO_FUNC_3_DESC_LEN;
-          break;
-#endif
+      // Calculate descriptor length
+      {
+        uint8_t const *p_desc = (uint8_t const *) itf_desc;
+        uint8_t const *p_desc_end = p_desc + max_len;
+        uint16_t total_len = sizeof(tusb_desc_interface_t);
+        // Skip Standard AC interface descriptor
+        p_desc = tu_desc_next(p_desc);
+        while (p_desc_end - p_desc > 0) {
+          // Stop if:
+          // - Non audio streaming interface descriptor found
+          // - IAD found
+          if ((tu_desc_type(p_desc) == TUSB_DESC_INTERFACE &&
+              !(((tusb_desc_interface_t const *) p_desc)->bInterfaceClass == TUSB_CLASS_AUDIO && ((tusb_desc_interface_t const *) p_desc)->bInterfaceSubClass == AUDIO_SUBCLASS_STREAMING))
+              || tu_desc_type(p_desc) == TUSB_DESC_INTERFACE_ASSOCIATION) {
+            break;
+          } else if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE && ((tusb_desc_interface_t const *) p_desc)->bInterfaceSubClass == AUDIO_SUBCLASS_STREAMING) {
+            if (_audiod_fct[i].p_desc_as == NULL) {
+              _audiod_fct[i].p_desc_as = p_desc;
+            }
+          } else {
+            // nothing to do
+          }
+          total_len += p_desc[0];
+          p_desc = tu_desc_next(p_desc);
+        }
+        _audiod_fct[i].desc_length = total_len;
       }
 
 #ifdef TUP_DCD_EDPT_ISO_ALLOC
@@ -1620,52 +909,67 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
         uint8_t ep_fb = 0;
   #endif
         uint8_t const *p_desc = _audiod_fct[i].p_desc;
-        uint8_t const *p_desc_end = p_desc + _audiod_fct[i].desc_length - TUD_AUDIO_DESC_IAD_LEN;
+        uint8_t const *p_desc_end = p_desc + _audiod_fct[i].desc_length;
         // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
         while (p_desc_end - p_desc > 0) {
           if (tu_desc_type(p_desc) == TUSB_DESC_ENDPOINT) {
+            // Unified UAC1/UAC2 endpoint processing
             tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) p_desc;
-            if (desc_ep->bmAttributes.xfer == TUSB_XFER_ISOCHRONOUS) {
-  #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-              // Explicit feedback EP
-              if (desc_ep->bmAttributes.usage == 1) {
-                ep_fb = desc_ep->bEndpointAddress;
-              }
-  #endif
-              // Data EP
-              if (desc_ep->bmAttributes.usage == 0) {
-                if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
-  #if CFG_TUD_AUDIO_ENABLE_EP_IN
-                  ep_in = desc_ep->bEndpointAddress;
-                  ep_in_size = TU_MAX(tu_edpt_packet_size(desc_ep), ep_in_size);
-  #endif
-                } else {
-  #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-                  ep_out = desc_ep->bEndpointAddress;
-                  ep_out_size = TU_MAX(tu_edpt_packet_size(desc_ep), ep_out_size);
-  #endif
-                }
-              }
+            bool is_feedback_ep = false;
+            bool is_data_ep = false;
+
+            if (tud_audio_n_version(i) == 1) {
+              // UAC1: Use bRefresh field to distinguish endpoint types
+              audio10_desc_as_iso_data_ep_t const *desc_ep_uac1 = (audio10_desc_as_iso_data_ep_t const *) p_desc;
+              is_data_ep = (desc_ep_uac1->bmAttributes.sync != TUSB_ISO_EP_ATT_NO_SYNC);
+              is_feedback_ep = (desc_ep_uac1->bmAttributes.sync == TUSB_ISO_EP_ATT_NO_SYNC);
+            } else {
+              // UAC2: Use bmAttributes.usage to distinguish endpoint types
+              is_data_ep = (desc_ep->bmAttributes.usage == 0 || desc_ep->bmAttributes.usage == 2);
+              is_feedback_ep = (desc_ep->bmAttributes.usage == 1);
             }
+
+    #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
+            // Explicit feedback EP
+            if (is_feedback_ep) {
+              ep_fb = desc_ep->bEndpointAddress;
+            }
+    #else
+            (void) is_feedback_ep;
+    #endif
+    #if CFG_TUD_AUDIO_ENABLE_EP_IN
+            // Data or data with implicit feedback IN EP
+            if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN && is_data_ep) {
+              ep_in = desc_ep->bEndpointAddress;
+              ep_in_size = TU_MAX(tu_edpt_packet_size(desc_ep), ep_in_size);
+            }
+    #endif
+    #if CFG_TUD_AUDIO_ENABLE_EP_OUT
+            // Data OUT EP
+            if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_OUT && is_data_ep) {
+              ep_out = desc_ep->bEndpointAddress;
+              ep_out_size = TU_MAX(tu_edpt_packet_size(desc_ep), ep_out_size);
+            }
+    #endif
           }
 
           p_desc = tu_desc_next(p_desc);
         }
 
   #if CFG_TUD_AUDIO_ENABLE_EP_IN
-        if (ep_in) {
+        if (ep_in != 0) {
           usbd_edpt_iso_alloc(rhport, ep_in, ep_in_size);
         }
   #endif
 
   #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-        if (ep_out) {
+        if (ep_out != 0) {
           usbd_edpt_iso_alloc(rhport, ep_out, ep_out_size);
         }
   #endif
 
   #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-        if (ep_fb) {
+        if (ep_fb != 0) {
           usbd_edpt_iso_alloc(rhport, ep_fb, 4);
         }
   #endif
@@ -1675,22 +979,27 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
 #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
       {
         uint8_t const *p_desc = _audiod_fct[i].p_desc;
-        uint8_t const *p_desc_end = p_desc + _audiod_fct[i].desc_length - TUD_AUDIO_DESC_IAD_LEN;
+        uint8_t const *p_desc_end = p_desc + _audiod_fct[i].desc_length;
         // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
         while (p_desc_end - p_desc > 0) {
           if (tu_desc_type(p_desc) == TUSB_DESC_ENDPOINT) {
             tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) p_desc;
             if (desc_ep->bmAttributes.xfer == TUSB_XFER_ISOCHRONOUS) {
-              if (desc_ep->bmAttributes.usage == 0) {
-                if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
-                  _audiod_fct[i].interval_tx = desc_ep->bInterval;
-                }
+              // For data or data with implicit feedback IN EP
+              // For UAC1 this is always the case since there is no usage field
+              if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN
+                  && (desc_ep->bmAttributes.usage == 0 || desc_ep->bmAttributes.usage == 2)) {
+                _audiod_fct[i].interval_tx = desc_ep->bInterval;
               }
             }
-          } else if (tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE && tu_desc_subtype(p_desc) == AUDIO_CS_AC_INTERFACE_OUTPUT_TERMINAL) {
+          } else if (tud_audio_n_version(i) == 2 &&
+              tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE && tu_desc_subtype(p_desc) == AUDIO20_CS_AC_INTERFACE_OUTPUT_TERMINAL) {
+              // For UAC2 only, UAC1 doesn't have a clock source
             if (tu_unaligned_read16(p_desc + 4) == AUDIO_TERM_TYPE_USB_STREAMING) {
               _audiod_fct[i].bclock_id_tx = p_desc[8];
             }
+          } else {
+            // nothing to do
           }
           p_desc = tu_desc_next(p_desc);
         }
@@ -1700,7 +1009,7 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
 #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
       {
         uint8_t const *p_desc = _audiod_fct[i].p_desc;
-        uint8_t const *p_desc_end = p_desc + _audiod_fct[i].desc_length - TUD_AUDIO_DESC_IAD_LEN;
+        uint8_t const *p_desc_end = p_desc + _audiod_fct[i].desc_length;
         // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
         while (p_desc_end - p_desc > 0) {
           // For each endpoint
@@ -1728,7 +1037,7 @@ uint16_t audiod_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint
   TU_ASSERT(i < CFG_TUD_AUDIO);
 
   // This is all we need so far - the EPs are setup by a later set_interface request (as per UAC2 specification)
-  uint16_t drv_len = _audiod_fct[i].desc_length - TUD_AUDIO_DESC_IAD_LEN;// - TUD_AUDIO_DESC_IAD_LEN since tinyUSB already handles the IAD descriptor
+  uint16_t drv_len = _audiod_fct[i].desc_length;
 
   return drv_len;
 }
@@ -1737,13 +1046,25 @@ static bool audiod_get_interface(uint8_t rhport, tusb_control_request_t const *p
   uint8_t const itf = tu_u16_low(p_request->wIndex);
 
   // Find index of audio streaming interface
-  uint8_t func_id, idxItf;
-  uint8_t const *dummy;
+  uint8_t func_id;
+  TU_VERIFY(audiod_verify_itf_exists(itf, &func_id));
 
-  TU_VERIFY(audiod_get_AS_interface_index_global(itf, &func_id, &idxItf, &dummy));
-  TU_VERIFY(tud_control_xfer(rhport, p_request, &_audiod_fct[func_id].alt_setting[idxItf], 1));
+  // Default to 0 if interface not yet activated
+  uint8_t alt = 0;
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
+  if (_audiod_fct[func_id].ep_in_as_intf_num == itf) {
+    alt = _audiod_fct[func_id].ep_in_alt;
+  }
+#endif
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
+  if (_audiod_fct[func_id].ep_out_as_intf_num == itf) {
+    alt = _audiod_fct[func_id].ep_out_alt;
+  }
+#endif
+
+  TU_VERIFY(tud_control_xfer(rhport, p_request, &alt, 1));
 
-  TU_LOG2("  Get itf: %u - current alt: %u\r\n", itf, _audiod_fct[func_id].alt_setting[idxItf]);
+  TU_LOG2("  Get itf: %u - current alt: %u\r\n", itf, alt);
 
   return true;
 }
@@ -1768,9 +1089,8 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
   TU_LOG2("  Set itf: %u - alt: %u\r\n", itf, alt);
 
   // Find index of audio streaming interface and index of interface
-  uint8_t func_id, idxItf;
-  uint8_t const *p_desc;
-  TU_VERIFY(audiod_get_AS_interface_index_global(itf, &func_id, &idxItf, &p_desc));
+  uint8_t func_id;
+  TU_VERIFY(audiod_verify_itf_exists(itf, &func_id));
 
   audiod_function_t *audio = &_audiod_fct[func_id];
 
@@ -1778,21 +1098,16 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
   if (audio->ep_in_as_intf_num == itf) {
     audio->ep_in_as_intf_num = 0;
+    audio->ep_in_alt = 0;
   #ifndef TUP_DCD_EDPT_ISO_ALLOC
     usbd_edpt_close(rhport, audio->ep_in);
   #endif
 
     // Clear FIFOs, since data is no longer valid
-  #if !CFG_TUD_AUDIO_ENABLE_ENCODING
     tu_fifo_clear(&audio->ep_in_ff);
-  #else
-    for (uint8_t cnt = 0; cnt < audio->n_tx_supp_ff; cnt++) {
-      tu_fifo_clear(&audio->tx_supp_ff[cnt]);
-    }
-  #endif
 
     // Invoke callback - can be used to stop data sampling
-    TU_VERIFY(tud_audio_set_itf_close_EP_cb(rhport, p_request));
+    TU_VERIFY(tud_audio_set_itf_close_ep_cb(rhport, p_request));
 
     audio->ep_in = 0;// Necessary?
 
@@ -1807,21 +1122,16 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
   if (audio->ep_out_as_intf_num == itf) {
     audio->ep_out_as_intf_num = 0;
+    audio->ep_out_alt = 0;
   #ifndef TUP_DCD_EDPT_ISO_ALLOC
     usbd_edpt_close(rhport, audio->ep_out);
   #endif
 
     // Clear FIFOs, since data is no longer valid
-  #if !CFG_TUD_AUDIO_ENABLE_DECODING
     tu_fifo_clear(&audio->ep_out_ff);
-  #else
-    for (uint8_t cnt = 0; cnt < audio->n_rx_supp_ff; cnt++) {
-      tu_fifo_clear(&audio->rx_supp_ff[cnt]);
-    }
-  #endif
 
     // Invoke callback - can be used to stop data sampling
-    TU_VERIFY(tud_audio_set_itf_close_EP_cb(rhport, p_request));
+    TU_VERIFY(tud_audio_set_itf_close_ep_cb(rhport, p_request));
 
     audio->ep_out = 0;// Necessary?
 
@@ -1836,19 +1146,18 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
   }
 #endif// CFG_TUD_AUDIO_ENABLE_EP_OUT
 
-  // Save current alternative interface setting
-  audio->alt_setting[idxItf] = alt;
-
   // Open new EP if necessary - EPs are only to be closed or opened for AS interfaces - Look for AS interface with correct alternate interface
+
+  uint8_t const *p_desc = audio->p_desc_as;
   // Get pointer at end
-  uint8_t const *p_desc_end = audio->p_desc + audio->desc_length - TUD_AUDIO_DESC_IAD_LEN;
+  uint8_t const *p_desc_end = audio->p_desc + audio->desc_length;
 
   // p_desc starts at required interface with alternate setting zero
   // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
   while (p_desc_end - p_desc > 0) {
     // Find correct interface
     if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE && ((tusb_desc_interface_t const *) p_desc)->bInterfaceNumber == itf && ((tusb_desc_interface_t const *) p_desc)->bAlternateSetting == alt) {
-#if (CFG_TUD_AUDIO_ENABLE_EP_IN && (CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL || CFG_TUD_AUDIO_ENABLE_ENCODING)) || (CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING)
+#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
       uint8_t const *p_desc_parse_for_params = p_desc;
 #endif
       // From this point forward follow the EP descriptors associated to the current alternate setting interface - Open EPs if necessary
@@ -1864,61 +1173,58 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
 #endif
           uint8_t const ep_addr = desc_ep->bEndpointAddress;
 
+          bool is_feedback_ep = false;
+          bool is_data_ep = false;
+
+          if (tud_audio_n_version(func_id) == 1) {
+            // UAC1: Use bRefresh field to distinguish endpoint types
+            audio10_desc_as_iso_data_ep_t const *desc_ep_uac1 = (audio10_desc_as_iso_data_ep_t const *) p_desc;
+            is_data_ep = (desc_ep_uac1->bmAttributes.sync != TUSB_ISO_EP_ATT_NO_SYNC);
+            is_feedback_ep = (desc_ep_uac1->bmAttributes.sync == TUSB_ISO_EP_ATT_NO_SYNC);
+          } else {
+            // UAC2: Use bmAttributes.usage to distinguish endpoint types
+            is_data_ep = (desc_ep->bmAttributes.usage == 0 || desc_ep->bmAttributes.usage == 2);
+            is_feedback_ep = (desc_ep->bmAttributes.usage == 1);
+          }
+
           //TODO: We need to set EP non busy since this is not taken care of right now in ep_close() - THIS IS A WORKAROUND!
           usbd_edpt_clear_stall(rhport, ep_addr);
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
-          if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN && desc_ep->bmAttributes.usage == 0x00)// Check if usage is data EP
+          // For data or data with implicit feedback IN EP
+          if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN && is_data_ep)
           {
             // Save address
             audio->ep_in = ep_addr;
             audio->ep_in_as_intf_num = itf;
+            audio->ep_in_alt = alt;
             audio->ep_in_sz = tu_edpt_packet_size(desc_ep);
+            // Set the default EP IN FIFO threshold to half fifo depth.
+            audio->ep_in_fifo_threshold = audio->ep_in_ff.depth / 2;
 
-            // If software encoding is enabled, parse for the corresponding parameters - doing this here means only AS interfaces with EPs get scanned for parameters
-  #if CFG_TUD_AUDIO_ENABLE_ENCODING || CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
-            audiod_parse_for_AS_params(audio, p_desc_parse_for_params, p_desc_end, itf);
-
-              // Reconfigure size of support FIFOs - this is necessary to avoid samples to get split in case of a wrap
-    #if CFG_TUD_AUDIO_ENABLE_ENCODING && CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-            const uint16_t active_fifo_depth = (uint16_t) ((audio->tx_supp_ff_sz_max / (audio->n_channels_per_ff_tx * audio->n_bytes_per_sample_tx)) * (audio->n_channels_per_ff_tx * audio->n_bytes_per_sample_tx));
-            for (uint8_t cnt = 0; cnt < audio->n_tx_supp_ff; cnt++) {
-              tu_fifo_config(&audio->tx_supp_ff[cnt], audio->tx_supp_ff[cnt].buffer, active_fifo_depth, 1, true);
-            }
-            audio->n_ff_used_tx = audio->n_channels_tx / audio->n_channels_per_ff_tx;
-            TU_ASSERT(audio->n_ff_used_tx <= audio->n_tx_supp_ff);
-    #endif
+            // If flow control is enabled, parse for the corresponding parameters - doing this here means only AS interfaces with EPs get scanned for parameters
+  #if  CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
+            audiod_parse_flow_control_params(audio, p_desc_parse_for_params);
+  #endif
+            // Schedule first transmit if alternate interface is not zero, as sample data is available a ZLP is loaded
+  #if USE_LINEAR_BUFFER_TX
+            TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_in, audio->lin_buf_in, 0));
+  #else
+            // Send everything in ISO EP FIFO
+            TU_VERIFY(usbd_edpt_xfer_fifo(rhport, audio->ep_in, &audio->ep_in_ff, 0));
   #endif
-
-            // Schedule first transmit if alternate interface is not zero i.e. streaming is disabled - in case no sample data is available a ZLP is loaded
-            // It is necessary to trigger this here since the refill is done with an RX FIFO empty interrupt which can only trigger if something was in there
-            TU_VERIFY(audiod_tx_done_cb(rhport, &_audiod_fct[func_id]));
           }
 #endif// CFG_TUD_AUDIO_ENABLE_EP_IN
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-
-          if (tu_edpt_dir(ep_addr) == TUSB_DIR_OUT)// Checking usage not necessary
-          {
+          // Checking usage not necessary
+          if (tu_edpt_dir(ep_addr) == TUSB_DIR_OUT && is_data_ep) {
             // Save address
             audio->ep_out = ep_addr;
             audio->ep_out_as_intf_num = itf;
+            audio->ep_out_alt = alt;
             audio->ep_out_sz = tu_edpt_packet_size(desc_ep);
 
-  #if CFG_TUD_AUDIO_ENABLE_DECODING
-            audiod_parse_for_AS_params(audio, p_desc_parse_for_params, p_desc_end, itf);
-
-              // Reconfigure size of support FIFOs - this is necessary to avoid samples to get split in case of a wrap
-    #if CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-            const uint16_t active_fifo_depth = (audio->rx_supp_ff_sz_max / audio->n_bytes_per_sample_rx) * audio->n_bytes_per_sample_rx;
-            for (uint8_t cnt = 0; cnt < audio->n_rx_supp_ff; cnt++) {
-              tu_fifo_config(&audio->rx_supp_ff[cnt], audio->rx_supp_ff[cnt].buffer, active_fifo_depth, 1, true);
-            }
-            audio->n_ff_used_rx = audio->n_channels_rx / audio->n_channels_per_ff_rx;
-            TU_ASSERT(audio->n_ff_used_rx <= audio->n_rx_supp_ff);
-    #endif
-  #endif
-
             // Prepare for incoming data
   #if USE_LINEAR_BUFFER_RX
             TU_VERIFY(usbd_edpt_xfer(rhport, audio->ep_out, audio->lin_buf_out, audio->ep_out_sz), false);
@@ -1928,12 +1234,18 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
           }
 
   #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-          if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN && desc_ep->bmAttributes.usage == 1)// Check if usage is explicit data feedback
-          {
+          // Check if usage is explicit data feedback
+          if (is_feedback_ep) {
             audio->ep_fb = ep_addr;
             audio->feedback.frame_shift = desc_ep->bInterval - 1;
+            // Schedule first feedback transmit
+            audiod_fb_send(func_id);
           }
+  #else
+          (void) is_feedback_ep;
   #endif
+#else
+        (void) is_feedback_ep;
 #endif// CFG_TUD_AUDIO_ENABLE_EP_OUT
 
           foundEPs += 1;
@@ -1947,55 +1259,8 @@ static bool audiod_set_interface(uint8_t rhport, tusb_control_request_t const *p
       TU_VERIFY(tud_audio_set_itf_cb(rhport, p_request));
 
 #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-      // Prepare feedback computation if endpoint is available
-      if (audio->ep_fb != 0) {
-        audio_feedback_params_t fb_param;
-
-        tud_audio_feedback_params_cb(func_id, alt, &fb_param);
-        audio->feedback.compute_method = fb_param.method;
-
-        if (TUSB_SPEED_FULL == tud_speed_get())
-          audio->feedback.format_correction = tud_audio_feedback_format_correction_cb(func_id);
-
-        // Minimal/Maximum value in 16.16 format for full speed (1ms per frame) or high speed (125 us per frame)
-        uint32_t const frame_div = (TUSB_SPEED_FULL == tud_speed_get()) ? 1000 : 8000;
-        audio->feedback.min_value = ((fb_param.sample_freq - 1) / frame_div) << 16;
-        audio->feedback.max_value = (fb_param.sample_freq / frame_div + 1) << 16;
-
-        switch (fb_param.method) {
-          case AUDIO_FEEDBACK_METHOD_FREQUENCY_FIXED:
-          case AUDIO_FEEDBACK_METHOD_FREQUENCY_FLOAT:
-          case AUDIO_FEEDBACK_METHOD_FREQUENCY_POWER_OF_2:
-            audiod_set_fb_params_freq(audio, fb_param.sample_freq, fb_param.frequency.mclk_freq);
-            break;
-
-          case AUDIO_FEEDBACK_METHOD_FIFO_COUNT: {
-            // Initialize the threshold level to half filled
-            uint16_t fifo_lvl_thr;
-  #if CFG_TUD_AUDIO_ENABLE_DECODING
-            fifo_lvl_thr = tu_fifo_depth(&audio->rx_supp_ff[0]) / 2;
-  #else
-            fifo_lvl_thr = tu_fifo_depth(&audio->ep_out_ff) / 2;
-  #endif
-            audio->feedback.compute.fifo_count.fifo_lvl_thr = fifo_lvl_thr;
-            audio->feedback.compute.fifo_count.fifo_lvl_avg = ((uint32_t) fifo_lvl_thr) << 16;
-            // Avoid 64bit division
-            uint32_t nominal = ((fb_param.sample_freq / 100) << 16) / (frame_div / 100);
-            audio->feedback.compute.fifo_count.nom_value = nominal;
-            audio->feedback.compute.fifo_count.rate_const[0] = (uint16_t) ((audio->feedback.max_value - nominal) / fifo_lvl_thr);
-            audio->feedback.compute.fifo_count.rate_const[1] = (uint16_t) ((nominal - audio->feedback.min_value) / fifo_lvl_thr);
-            // On HS feedback is more sensitive since packet size can vary every MSOF, could cause instability
-            if (tud_speed_get() == TUSB_SPEED_HIGH) {
-              audio->feedback.compute.fifo_count.rate_const[0] /= 8;
-              audio->feedback.compute.fifo_count.rate_const[1] /= 8;
-            }
-          } break;
-
-          // nothing to do
-          default:
-            break;
-        }
-      }
+      // Prepare feedback computation parameters
+      TU_VERIFY(audiod_fb_params_prepare(func_id, alt));
 #endif// CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
 
       // We are done - abort loop
@@ -2047,20 +1312,23 @@ static bool audiod_control_complete(uint8_t rhport, tusb_control_request_t const
           TU_VERIFY(audiod_verify_entity_exists(itf, entityID, &func_id));
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
-          uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
-          if (_audiod_fct[func_id].bclock_id_tx == entityID && ctrlSel == AUDIO_CS_CTRL_SAM_FREQ && p_request->bRequest == AUDIO_CS_REQ_CUR) {
-            _audiod_fct[func_id].sample_rate_tx = tu_unaligned_read32(_audiod_fct[func_id].ctrl_buf);
+          if (tud_audio_n_version(func_id) == 2) {
+            uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+            if (_audiod_fct[func_id].bclock_id_tx == entityID && ctrlSel == AUDIO20_CS_CTRL_SAM_FREQ && p_request->bRequest == AUDIO20_CS_REQ_CUR) {
+              _audiod_fct[func_id].sample_rate_tx = tu_unaligned_read32(ctrl_buf);
+              audiod_calc_tx_packet_sz(&_audiod_fct[func_id]);
+            }
           }
 #endif
 
           // Invoke callback
-          return tud_audio_set_req_entity_cb(rhport, p_request, _audiod_fct[func_id].ctrl_buf);
+          return tud_audio_set_req_entity_cb(rhport, p_request, ctrl_buf);
         } else {
           // Find index of audio driver structure and verify interface really exists
           TU_VERIFY(audiod_verify_itf_exists(itf, &func_id));
 
           // Invoke callback
-          return tud_audio_set_req_itf_cb(rhport, p_request, _audiod_fct[func_id].ctrl_buf);
+          return tud_audio_set_req_itf_cb(rhport, p_request, ctrl_buf);
         }
       } break;
 
@@ -2070,8 +1338,32 @@ static bool audiod_control_complete(uint8_t rhport, tusb_control_request_t const
         // Check if entity is present and get corresponding driver index
         TU_VERIFY(audiod_verify_ep_exists(ep, &func_id));
 
-        // Invoke callback
-        return tud_audio_set_req_ep_cb(rhport, p_request, _audiod_fct[func_id].ctrl_buf);
+#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
+          if (tud_audio_n_version(func_id) == 1) {
+            if (_audiod_fct[func_id].ep_in == ep) {
+              uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+              if (ctrlSel == AUDIO10_EP_CTRL_SAMPLING_FREQ && p_request->bRequest == AUDIO10_CS_REQ_SET_CUR) {
+                _audiod_fct[func_id].sample_rate_tx = tu_unaligned_read32(ctrl_buf) & 0x00FFFFFF;
+                audiod_calc_tx_packet_sz(&_audiod_fct[func_id]);
+              }
+            }
+          }
+#endif
+
+          // Invoke callback
+          bool ret = tud_audio_set_req_ep_cb(rhport, p_request, ctrl_buf);
+
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
+          if (ret && tud_audio_n_version(func_id) == 1) {
+            if (_audiod_fct[func_id].ep_out == ep) {
+              uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+              if (ctrlSel == AUDIO10_EP_CTRL_SAMPLING_FREQ && p_request->bRequest == AUDIO10_CS_REQ_SET_CUR) {
+                audiod_fb_params_prepare(func_id, _audiod_fct[func_id].ep_out_alt);
+              }
+            }
+          }
+#endif
+        return ret;
       } break;
       // Unknown/Unsupported recipient
       default:
@@ -2156,7 +1448,7 @@ static bool audiod_control_request(uint8_t rhport, tusb_control_request_t const
     }
 
     // If we end here, the received request is a set request - we schedule a receive for the data stage and return true here. We handle the rest later in audiod_control_complete() once the data stage was finished
-    TU_VERIFY(tud_control_xfer(rhport, p_request, _audiod_fct[func_id].ctrl_buf, _audiod_fct[func_id].ctrl_buf_sz));
+    TU_VERIFY(tud_control_xfer(rhport, p_request, ctrl_buf, sizeof(ctrl_buf)));
     return true;
   }
 
@@ -2170,6 +1462,8 @@ bool audiod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_
     return audiod_control_request(rhport, request);
   } else if (stage == CONTROL_STAGE_DATA) {
     return audiod_control_complete(rhport, request);
+  } else {
+    // nothing to do
   }
 
   return true;
@@ -2179,12 +1473,11 @@ bool audiod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
   (void) result;
   (void) xferred_bytes;
 
+  #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
   // Search for interface belonging to given end point address and proceed as required
   for (uint8_t func_id = 0; func_id < CFG_TUD_AUDIO; func_id++) {
     audiod_function_t *audio = &_audiod_fct[func_id];
 
-#if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
-
     // Data transmission of control interrupt finished
     if (audio->ep_int == ep_addr) {
       // According to USB2 specification, maximum payload of interrupt EP is 8 bytes on low speed, 64 bytes on full speed, and 1024 bytes on high speed (but only if an alternate interface other than 0 is used - see specification p. 49)
@@ -2198,12 +1491,28 @@ bool audiod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
       return true;
     }
 
-#endif
+  }
+  #else
+  (void) rhport;
+  (void) ep_addr;
+  #endif
+
+  return false;
+}
+
+bool audiod_xfer_isr(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
+  (void) result;
+  (void) xferred_bytes;
+
+  // Search for interface belonging to given end point address and proceed as required
+  for (uint8_t func_id = 0; func_id < CFG_TUD_AUDIO; func_id++)
+  {
+    audiod_function_t* audio = &_audiod_fct[func_id];
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
 
     // Data transmission of audio packet finished
-    if (audio->ep_in == ep_addr && audio->alt_setting != 0) {
+    if (audio->ep_in == ep_addr) {
       // USB 2.0, section 5.6.4, third paragraph, states "An isochronous endpoint must specify its required bus access period. However, an isochronous endpoint must be prepared to handle poll rates faster than the one specified."
       // That paragraph goes on to say "An isochronous IN endpoint must return a zero-length packet whenever data is requested at a faster interval than the specified interval and data is not available."
       // This can only be solved reliably if we load a ZLP after every IN transmission since we can not say if the host requests samples earlier than we declared! Once all samples are collected we overwrite the loaded ZLP.
@@ -2213,32 +1522,24 @@ bool audiod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
       // This is the only place where we can fill something into the EPs buffer!
 
       // Load new data
-      TU_VERIFY(audiod_tx_done_cb(rhport, audio));
-
-      // Transmission of ZLP is done by audiod_tx_done_cb()
+      audiod_tx_xfer_isr(rhport, audio, (uint16_t) xferred_bytes);
       return true;
     }
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-
     // New audio packet received
     if (audio->ep_out == ep_addr) {
-      TU_VERIFY(audiod_rx_done_cb(rhport, audio, (uint16_t) xferred_bytes));
+      audiod_rx_xfer_isr(rhport, audio, (uint16_t) xferred_bytes);
       return true;
     }
-
-
   #if CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
     // Transmission of feedback EP finished
     if (audio->ep_fb == ep_addr) {
-      tud_audio_fb_done_cb(func_id);
-
       // Schedule a transmit with the new value if EP is not busy
-      if (usbd_edpt_claim(rhport, audio->ep_fb)) {
-        // Schedule next transmission - value is changed bytud_audio_n_fb_set() in the meantime or the old value gets sent
-        return audiod_fb_send(audio);
-      }
+      // Schedule next transmission - value is changed bytud_audio_n_fb_set() in the meantime or the old value gets sent
+      audiod_fb_send(func_id);
+      return true;
     }
   #endif
 #endif
@@ -2249,30 +1550,72 @@ bool audiod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
 
-static bool audiod_set_fb_params_freq(audiod_function_t *audio, uint32_t sample_freq, uint32_t mclk_freq) {
-  // Check if frame interval is within sane limits
-  // The interval value n_frames was taken from the descriptors within audiod_set_interface()
+static bool audiod_fb_params_prepare(uint8_t func_id, uint8_t alt) {
+  audiod_function_t *audio = &_audiod_fct[func_id];
 
-  // n_frames_min is ceil(2^10 * f_s / f_m) for full speed and ceil(2^13 * f_s / f_m) for high speed
-  // this lower limit ensures the measures feedback value has sufficient precision
-  uint32_t const k = (TUSB_SPEED_FULL == tud_speed_get()) ? 10 : 13;
-  uint32_t const n_frame = (1UL << audio->feedback.frame_shift);
+  // Prepare feedback computation if endpoint is available
+  if (audio->ep_fb != 0) {
+    audio_feedback_params_t fb_param = {0};
 
-  if ((((1UL << k) * sample_freq / mclk_freq) + 1) > n_frame) {
-    TU_LOG1("  UAC2 feedback interval too small\r\n");
-    TU_BREAKPOINT();
-    return false;
-  }
+    tud_audio_feedback_params_cb(func_id, alt, &fb_param);
+    audio->feedback.compute_method = fb_param.method;
 
-  // Check if parameters really allow for a power of two division
-  if ((mclk_freq % sample_freq) == 0 && tu_is_power_of_two(mclk_freq / sample_freq)) {
-    audio->feedback.compute_method = AUDIO_FEEDBACK_METHOD_FREQUENCY_POWER_OF_2;
-    audio->feedback.compute.power_of_2 = (uint8_t) (16 - (audio->feedback.frame_shift - 1) - tu_log2(mclk_freq / sample_freq));
-  } else if (audio->feedback.compute_method == AUDIO_FEEDBACK_METHOD_FREQUENCY_FLOAT) {
-    audio->feedback.compute.float_const = (float) sample_freq / (float) mclk_freq * (1UL << (16 - (audio->feedback.frame_shift - 1)));
-  } else {
-    audio->feedback.compute.fixed.sample_freq = sample_freq;
-    audio->feedback.compute.fixed.mclk_freq = mclk_freq;
+    // Minimal/Maximum value in 16.16 format for full speed (1ms per frame) or high speed (125 us per frame)
+    uint32_t const frame_div = (TUSB_SPEED_FULL == tud_speed_get()) ? 1000 : 8000;
+    audio->feedback.min_value = ((fb_param.sample_freq - 1) / frame_div) << 16;
+    audio->feedback.max_value = (fb_param.sample_freq / frame_div + 1) << 16;
+
+    switch (fb_param.method) {
+      case AUDIO_FEEDBACK_METHOD_FREQUENCY_FIXED:
+      case AUDIO_FEEDBACK_METHOD_FREQUENCY_FLOAT:
+      case AUDIO_FEEDBACK_METHOD_FREQUENCY_POWER_OF_2: {
+        // Check if frame interval is within sane limits
+        // The interval value n_frames was taken from the descriptors within audiod_set_interface()
+
+        // n_frames_min is ceil(2^10 * f_s / f_m) for full speed and ceil(2^13 * f_s / f_m) for high speed
+        // this lower limit ensures the measures feedback value has sufficient precision
+        uint32_t const k = (TUSB_SPEED_FULL == tud_speed_get()) ? 10 : 13;
+        uint32_t const n_frame = (1UL << audio->feedback.frame_shift);
+
+        if ((((1UL << k) * fb_param.sample_freq / fb_param.frequency.mclk_freq) + 1) > n_frame) {
+          TU_LOG1("  UAC2 feedback interval too small\r\n");
+          TU_BREAKPOINT();
+          return false;
+        }
+
+        // Check if parameters really allow for a power of two division
+        if ((fb_param.frequency.mclk_freq % fb_param.sample_freq) == 0 && tu_is_power_of_two(fb_param.frequency.mclk_freq / fb_param.sample_freq)) {
+          audio->feedback.compute_method = AUDIO_FEEDBACK_METHOD_FREQUENCY_POWER_OF_2;
+          audio->feedback.compute.power_of_2 = (uint8_t) (16 - (audio->feedback.frame_shift - 1) - tu_log2(fb_param.frequency.mclk_freq / fb_param.sample_freq));
+        } else if (audio->feedback.compute_method == AUDIO_FEEDBACK_METHOD_FREQUENCY_FLOAT) {
+          audio->feedback.compute.float_const = (float) fb_param.sample_freq / (float) fb_param.frequency.mclk_freq * (1UL << (16 - (audio->feedback.frame_shift - 1)));
+        } else {
+          audio->feedback.compute.fixed.sample_freq = fb_param.sample_freq;
+          audio->feedback.compute.fixed.mclk_freq = fb_param.frequency.mclk_freq;
+        }
+      } break;
+
+      case AUDIO_FEEDBACK_METHOD_FIFO_COUNT: {
+        // Determine FIFO threshold
+        uint16_t fifo_threshold = fb_param.fifo_count.fifo_threshold ? fb_param.fifo_count.fifo_threshold : tu_fifo_depth(&audio->ep_out_ff) / 2;
+        audio->feedback.compute.fifo_count.fifo_lvl_thr = fifo_threshold;
+        audio->feedback.compute.fifo_count.fifo_lvl_avg = ((uint32_t) fifo_threshold) << 16;
+        // Avoid 64bit division
+        uint32_t nominal = ((fb_param.sample_freq / 100) << 16) / (frame_div / 100);
+        audio->feedback.compute.fifo_count.nom_value = nominal;
+        audio->feedback.compute.fifo_count.rate_const[0] = (uint16_t) ((audio->feedback.max_value - nominal) / fifo_threshold);
+        audio->feedback.compute.fifo_count.rate_const[1] = (uint16_t) ((nominal - audio->feedback.min_value) / fifo_threshold);
+        // On HS feedback is more sensitive since packet size can vary every MSOF, could cause instability
+        if (tud_speed_get() == TUSB_SPEED_HIGH) {
+          audio->feedback.compute.fifo_count.rate_const[0] /= 8;
+          audio->feedback.compute.fifo_count.rate_const[1] /= 8;
+        }
+      } break;
+
+      // nothing to do
+      default:
+        break;
+    }
   }
 
   return true;
@@ -2296,62 +1639,15 @@ static void audiod_fb_fifo_count_update(audiod_function_t *audio, uint16_t lvl_n
     feedback = audio->feedback.compute.fifo_count.nom_value - (ff_lvl - ff_thr) * rate[1];
   }
 
-  if (feedback > audio->feedback.max_value) feedback = audio->feedback.max_value;
-  if (feedback < audio->feedback.min_value) feedback = audio->feedback.min_value;
-  audio->feedback.value = feedback;
-
-  // Schedule a transmit with the new value if EP is not busy - this triggers repetitive scheduling of the feedback value
-  if (usbd_edpt_claim(audio->rhport, audio->ep_fb)) {
-    audiod_fb_send(audio);
+  if (feedback > audio->feedback.max_value) {
+    feedback = audio->feedback.max_value;
   }
-}
-
-uint32_t tud_audio_feedback_update(uint8_t func_id, uint32_t cycles) {
-  audiod_function_t *audio = &_audiod_fct[func_id];
-  uint32_t feedback;
-
-  switch (audio->feedback.compute_method) {
-    case AUDIO_FEEDBACK_METHOD_FREQUENCY_POWER_OF_2:
-      feedback = (cycles << audio->feedback.compute.power_of_2);
-      break;
-
-    case AUDIO_FEEDBACK_METHOD_FREQUENCY_FLOAT:
-      feedback = (uint32_t) ((float) cycles * audio->feedback.compute.float_const);
-      break;
-
-    case AUDIO_FEEDBACK_METHOD_FREQUENCY_FIXED: {
-      uint64_t fb64 = (((uint64_t) cycles) * audio->feedback.compute.fixed.sample_freq) << (16 - (audio->feedback.frame_shift - 1));
-      feedback = (uint32_t) (fb64 / audio->feedback.compute.fixed.mclk_freq);
-    } break;
-
-    default:
-      return 0;
+  if (feedback < audio->feedback.min_value) {
+    feedback = audio->feedback.min_value;
   }
-
-  // For Windows: https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/usb-2-0-audio-drivers
-  // The size of isochronous packets created by the device must be within the limits specified in FMT-2.0 section 2.3.1.1.
-  // This means that the deviation of actual packet size from nominal size must not exceed +/- one audio slot
-  // (audio slot = channel count samples).
-  if (feedback > audio->feedback.max_value) feedback = audio->feedback.max_value;
-  if (feedback < audio->feedback.min_value) feedback = audio->feedback.min_value;
-
-  tud_audio_n_fb_set(func_id, feedback);
-
-  return feedback;
+  audio->feedback.value = feedback;
 }
 
-bool tud_audio_n_fb_set(uint8_t func_id, uint32_t feedback) {
-  TU_VERIFY(func_id < CFG_TUD_AUDIO && _audiod_fct[func_id].p_desc != NULL);
-
-  _audiod_fct[func_id].feedback.value = feedback;
-
-  // Schedule a transmit with the new value if EP is not busy - this triggers repetitive scheduling of the feedback value
-  if (usbd_edpt_claim(_audiod_fct[func_id].rhport, _audiod_fct[func_id].ep_fb)) {
-    return audiod_fb_send(&_audiod_fct[func_id]);
-  }
-
-  return true;
-}
 #endif
 
 TU_ATTR_FAST_FUNC void audiod_sof_isr(uint8_t rhport, uint32_t frame_count) {
@@ -2419,71 +1715,27 @@ bool tud_audio_buffer_and_schedule_control_xfer(uint8_t rhport, tusb_control_req
   }
 
   // Crop length
-  if (len > _audiod_fct[func_id].ctrl_buf_sz) len = _audiod_fct[func_id].ctrl_buf_sz;
+  if (len > sizeof(ctrl_buf)) len = sizeof(ctrl_buf);
 
   // Copy into buffer
-  TU_VERIFY(0 == tu_memcpy_s(_audiod_fct[func_id].ctrl_buf, _audiod_fct[func_id].ctrl_buf_sz, data, (size_t) len));
+  TU_VERIFY(0 == tu_memcpy_s(ctrl_buf, sizeof(ctrl_buf), data, (size_t) len));
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
-  // Find data for sampling_frequency_control
-  if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS && p_request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE) {
-    uint8_t entityID = TU_U16_HIGH(p_request->wIndex);
-    uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
-    if (_audiod_fct[func_id].bclock_id_tx == entityID && ctrlSel == AUDIO_CS_CTRL_SAM_FREQ && p_request->bRequest == AUDIO_CS_REQ_CUR) {
-      _audiod_fct[func_id].sample_rate_tx = tu_unaligned_read32(_audiod_fct[func_id].ctrl_buf);
+  if (tud_audio_n_version(func_id) == 2) {
+    // Find data for sampling_frequency_control
+    if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS && p_request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE) {
+      uint8_t entityID = TU_U16_HIGH(p_request->wIndex);
+      uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+      if (_audiod_fct[func_id].bclock_id_tx == entityID && ctrlSel == AUDIO20_CS_CTRL_SAM_FREQ && p_request->bRequest == AUDIO20_CS_REQ_CUR) {
+        _audiod_fct[func_id].sample_rate_tx = tu_unaligned_read32(ctrl_buf);
+        audiod_calc_tx_packet_sz(&_audiod_fct[func_id]);
+      }
     }
   }
 #endif
 
   // Schedule transmit
-  return tud_control_xfer(rhport, p_request, (void *) _audiod_fct[func_id].ctrl_buf, len);
-}
-
-// This helper function finds for a given audio function and AS interface number the index of the attached driver structure, the index of the interface in the audio function
-// (e.g. the std. AS interface with interface number 15 is the first AS interface for the given audio function and thus gets index zero), and
-// finally a pointer to the std. AS interface, where the pointer always points to the first alternate setting i.e. alternate interface zero.
-static bool audiod_get_AS_interface_index(uint8_t itf, audiod_function_t *audio, uint8_t *idxItf, uint8_t const **pp_desc_int) {
-  if (audio->p_desc) {
-    // Get pointer at end
-    uint8_t const *p_desc_end = audio->p_desc + audio->desc_length - TUD_AUDIO_DESC_IAD_LEN;
-
-    // Advance past AC descriptors
-    uint8_t const *p_desc = tu_desc_next(audio->p_desc);
-    p_desc += ((audio_desc_cs_ac_interface_t const *) p_desc)->wTotalLength;
-
-    uint8_t tmp = 0;
-    // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
-    while (p_desc_end - p_desc > 0) {
-      // We assume the number of alternate settings is increasing thus we return the index of alternate setting zero!
-      if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE && ((tusb_desc_interface_t const *) p_desc)->bAlternateSetting == 0) {
-        if (((tusb_desc_interface_t const *) p_desc)->bInterfaceNumber == itf) {
-          *idxItf = tmp;
-          *pp_desc_int = p_desc;
-          return true;
-        }
-        // Increase index, bytes read, and pointer
-        tmp++;
-      }
-      p_desc = tu_desc_next(p_desc);
-    }
-  }
-  return false;
-}
-
-// This helper function finds for a given AS interface number the index of the attached driver structure, the index of the interface in the audio function
-// (e.g. the std. AS interface with interface number 15 is the first AS interface for the given audio function and thus gets index zero), and
-// finally a pointer to the std. AS interface, where the pointer always points to the first alternate setting i.e. alternate interface zero.
-static bool audiod_get_AS_interface_index_global(uint8_t itf, uint8_t *func_id, uint8_t *idxItf, uint8_t const **pp_desc_int) {
-  // Loop over audio driver interfaces
-  uint8_t i;
-  for (i = 0; i < CFG_TUD_AUDIO; i++) {
-    if (audiod_get_AS_interface_index(itf, &_audiod_fct[i], idxItf, pp_desc_int)) {
-      *func_id = i;
-      return true;
-    }
-  }
-
-  return false;
+  return tud_control_xfer(rhport, p_request, ctrl_buf, len);
 }
 
 // Verify an entity with the given ID exists and returns also the corresponding driver index
@@ -2494,13 +1746,11 @@ static bool audiod_verify_entity_exists(uint8_t itf, uint8_t entityID, uint8_t *
     if (_audiod_fct[i].p_desc && ((tusb_desc_interface_t const *) _audiod_fct[i].p_desc)->bInterfaceNumber == itf) {
       // Get pointers after class specific AC descriptors and end of AC descriptors - entities are defined in between
       uint8_t const *p_desc = tu_desc_next(_audiod_fct[i].p_desc);// Points to CS AC descriptor
-      uint8_t const *p_desc_end = ((audio_desc_cs_ac_interface_t const *) p_desc)->wTotalLength + p_desc;
       p_desc = tu_desc_next(p_desc);// Get past CS AC descriptor
 
-      // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
-      while (p_desc_end - p_desc > 0) {
-        if (p_desc[3] == entityID)// Entity IDs are always at offset 3
-        {
+      while (_audiod_fct[i].p_desc_as - p_desc > 0) {
+        // Entity IDs are always at offset 3
+        if (p_desc[3] == entityID) {
           *func_id = i;
           return true;
         }
@@ -2514,13 +1764,13 @@ static bool audiod_verify_entity_exists(uint8_t itf, uint8_t entityID, uint8_t *
 static bool audiod_verify_itf_exists(uint8_t itf, uint8_t *func_id) {
   uint8_t i;
   for (i = 0; i < CFG_TUD_AUDIO; i++) {
-    if (_audiod_fct[i].p_desc) {
+    if (_audiod_fct[i].p_desc != NULL) {
       // Get pointer at beginning and end
       uint8_t const *p_desc = _audiod_fct[i].p_desc;
-      uint8_t const *p_desc_end = _audiod_fct[i].p_desc + _audiod_fct[i].desc_length - TUD_AUDIO_DESC_IAD_LEN;
+      uint8_t const *p_desc_end = _audiod_fct[i].p_desc + _audiod_fct[i].desc_length;
       // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
       while (p_desc_end - p_desc > 0) {
-        if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE && ((tusb_desc_interface_t const *) _audiod_fct[i].p_desc)->bInterfaceNumber == itf) {
+        if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE && ((tusb_desc_interface_t const *)p_desc)->bInterfaceNumber == itf) {
           *func_id = i;
           return true;
         }
@@ -2539,8 +1789,7 @@ static bool audiod_verify_ep_exists(uint8_t ep, uint8_t *func_id) {
       uint8_t const *p_desc_end = _audiod_fct[i].p_desc + _audiod_fct[i].desc_length;
 
       // Advance past AC descriptors - EP we look for are streaming EPs
-      uint8_t const *p_desc = tu_desc_next(_audiod_fct[i].p_desc);
-      p_desc += ((audio_desc_cs_ac_interface_t const *) p_desc)->wTotalLength;
+      uint8_t const *p_desc = _audiod_fct[i].p_desc_as;
 
       // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
       while (p_desc_end - p_desc > 0) {
@@ -2555,89 +1804,39 @@ static bool audiod_verify_ep_exists(uint8_t ep, uint8_t *func_id) {
   return false;
 }
 
-#if (CFG_TUD_AUDIO_ENABLE_EP_IN && (CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL || CFG_TUD_AUDIO_ENABLE_ENCODING)) || (CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING)
-// p_desc points to the AS interface of alternate setting zero
-// itf is the interface number of the corresponding interface - we check if the interface belongs to EP in or EP out to see if it is a TX or RX parameter
-// Currently, only AS interfaces with an EP (in or out) are supposed to be parsed for!
-static void audiod_parse_for_AS_params(audiod_function_t *audio, uint8_t const *p_desc, uint8_t const *p_desc_end, uint8_t const as_itf) {
-  #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_EP_OUT
-  if (as_itf != audio->ep_in_as_intf_num && as_itf != audio->ep_out_as_intf_num) return;// Abort, this interface has no EP, this driver does not support this currently
-  #endif
-  #if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_EP_OUT
-  if (as_itf != audio->ep_in_as_intf_num) return;
-  #endif
-  #if !CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_EP_OUT
-  if (as_itf != audio->ep_out_as_intf_num) return;
-  #endif
+#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
+static void audiod_parse_flow_control_params(audiod_function_t *audio, uint8_t const *p_desc) {
 
   p_desc = tu_desc_next(p_desc);// Exclude standard AS interface descriptor of current alternate interface descriptor
-  // Condition modified from p_desc < p_desc_end to prevent gcc>=12 strict-overflow warning
-  while (p_desc_end - p_desc > 0) {
-    // Abort if follow up descriptor is a new standard interface descriptor - indicates the last AS descriptor was already finished
-    if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE) break;
 
-    // Look for a Class-Specific AS Interface Descriptor(4.9.2) to verify format type and format and also to get number of physical channels
-    if (tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE && tu_desc_subtype(p_desc) == AUDIO_CS_AS_INTERFACE_AS_GENERAL) {
-  #if CFG_TUD_AUDIO_ENABLE_EP_IN
-      if (as_itf == audio->ep_in_as_intf_num) {
-        audio->n_channels_tx = ((audio_desc_cs_as_interface_t const *) p_desc)->bNrChannels;
-        audio->format_type_tx = (audio_format_type_t) (((audio_desc_cs_as_interface_t const *) p_desc)->bFormatType);
-
-    #if CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-        audio->format_type_I_tx = (audio_data_format_type_I_t) (((audio_desc_cs_as_interface_t const *) p_desc)->bmFormats);
-    #endif
-      }
-  #endif
-
-  #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-      if (as_itf == audio->ep_out_as_intf_num) {
-        audio->n_channels_rx = ((audio_desc_cs_as_interface_t const *) p_desc)->bNrChannels;
-        audio->format_type_rx = ((audio_desc_cs_as_interface_t const *) p_desc)->bFormatType;
-    #if CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-        audio->format_type_I_rx = ((audio_desc_cs_as_interface_t const *) p_desc)->bmFormats;
-    #endif
+  if (tud_audio_n_version(audiod_get_audio_fct_idx(audio)) == 1) {
+    p_desc = tu_desc_next(p_desc);// Exclude Class-Specific AS Interface Descriptor(4.5.2) to get to format type descriptor
+    if (tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE && tu_desc_subtype(p_desc) == AUDIO10_CS_AS_INTERFACE_FORMAT_TYPE) {
+      audio->format_type_tx = ((audio10_desc_type_I_format_n_t(1) const *) p_desc)->bFormatType;
+      if (audio->format_type_tx == AUDIO10_FORMAT_TYPE_I) {
+        audio->n_channels_tx = ((audio10_desc_type_I_format_n_t(1) const *) p_desc)->bNrChannels;
+        audio->n_bytes_per_sample_tx = ((audio10_desc_type_I_format_n_t(1) const *) p_desc)->bSubFrameSize;
+        // Save sample rate - needed when EP doesn't support setting sample rate
+        audio->sample_rate_tx = tu_unaligned_read32(((audio10_desc_type_I_format_n_t(1) const *) p_desc)->tSamFreq) & 0x00FFFFFF;
       }
-  #endif
     }
-
-    // Look for a Type I Format Type Descriptor(2.3.1.6 - Audio Formats)
-  #if CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING || CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL || CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-    if (tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE && tu_desc_subtype(p_desc) == AUDIO_CS_AS_INTERFACE_FORMAT_TYPE && ((audio_desc_type_I_format_t const *) p_desc)->bFormatType == AUDIO_FORMAT_TYPE_I) {
-    #if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_EP_OUT
-      if (as_itf != audio->ep_in_as_intf_num && as_itf != audio->ep_out_as_intf_num) break;// Abort loop, this interface has no EP, this driver does not support this currently
-    #endif
-    #if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_EP_OUT
-      if (as_itf != audio->ep_in_as_intf_num) break;
-    #endif
-    #if !CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_EP_OUT
-      if (as_itf != audio->ep_out_as_intf_num) break;
-    #endif
-
-    #if CFG_TUD_AUDIO_ENABLE_EP_IN
-      if (as_itf == audio->ep_in_as_intf_num) {
-        audio->n_bytes_per_sample_tx = ((audio_desc_type_I_format_t const *) p_desc)->bSubslotSize;
-      }
-    #endif
-
-    #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-      if (as_itf == audio->ep_out_as_intf_num) {
-        audio->n_bytes_per_sample_rx = ((audio_desc_type_I_format_t const *) p_desc)->bSubslotSize;
+  } else {
+    // Look for a Class-Specific AS Interface Descriptor(4.9.2) to verify format type and format and also to get number of physical channels
+    if (tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE && tu_desc_subtype(p_desc) == AUDIO20_CS_AS_INTERFACE_AS_GENERAL) {
+      audio->n_channels_tx = ((audio20_desc_cs_as_interface_t const *) p_desc)->bNrChannels;
+      audio->format_type_tx = ((audio20_desc_cs_as_interface_t const *) p_desc)->bFormatType;
+      // Look for a Type I Format Type Descriptor(2.3.1.6 - Audio Formats)
+      p_desc = tu_desc_next(p_desc);
+      if (tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE && tu_desc_subtype(p_desc) == AUDIO20_CS_AS_INTERFACE_FORMAT_TYPE && ((audio20_desc_type_I_format_t const *) p_desc)->bFormatType == AUDIO20_FORMAT_TYPE_I) {
+        audio->n_bytes_per_sample_tx = ((audio20_desc_type_I_format_t const *) p_desc)->bSubslotSize;
       }
-    #endif
     }
-  #endif
-
-    // Other format types are not supported yet
-
-    p_desc = tu_desc_next(p_desc);
   }
 }
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
 
 static bool audiod_calc_tx_packet_sz(audiod_function_t *audio) {
-  TU_VERIFY(audio->format_type_tx == AUDIO_FORMAT_TYPE_I);
+  // AUDIO20_FORMAT_TYPE_I = AUDIO10_FORMAT_TYPE_I
+  TU_VERIFY(audio->format_type_tx == AUDIO20_FORMAT_TYPE_I);
   TU_VERIFY(audio->n_channels_tx);
   TU_VERIFY(audio->n_bytes_per_sample_tx);
   TU_VERIFY(audio->interval_tx);
@@ -2672,22 +1871,22 @@ static bool audiod_calc_tx_packet_sz(audiod_function_t *audio) {
   return true;
 }
 
-static uint16_t audiod_tx_packet_size(const uint16_t *norminal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t max_depth) {
+static uint16_t audiod_tx_packet_size(const uint16_t *nominal_size, uint16_t data_count, uint16_t fifo_depth, uint16_t fifo_threshold, uint16_t max_depth) {
   // Flow control need a FIFO size of at least 4*Navg
-  if (norminal_size[1] && norminal_size[1] <= fifo_depth * 4) {
+  if (nominal_size[1] && nominal_size[1] <= fifo_depth * 4) {
     // Use blackout to prioritize normal size packet
     static int ctrl_blackout = 0;
     uint16_t packet_size;
-    uint16_t slot_size = norminal_size[2] - norminal_size[1];
-    if (data_count < norminal_size[0]) {
+    uint16_t slot_size = nominal_size[2] - nominal_size[1];
+    if (data_count < nominal_size[0]) {
       // If you get here frequently, then your I2S clock deviation is too big !
       packet_size = 0;
-    } else if (data_count < fifo_depth / 2 - slot_size && !ctrl_blackout) {
-      packet_size = norminal_size[0];
+    } else if (data_count < (fifo_threshold - slot_size) && !ctrl_blackout) {
+      packet_size = nominal_size[0];
       ctrl_blackout = 10;
-    } else if (data_count > fifo_depth / 2 + slot_size && !ctrl_blackout) {
-      packet_size = norminal_size[2];
-      if (norminal_size[0] == norminal_size[1]) {
+    } else if (data_count > (fifo_threshold + slot_size) && !ctrl_blackout) {
+      packet_size = nominal_size[2];
+      if (nominal_size[0] == nominal_size[1]) {
         // nav > INT(nav), eg. 44.1k, 88.2k
         ctrl_blackout = 0;
       } else {
@@ -2695,7 +1894,7 @@ static uint16_t audiod_tx_packet_size(const uint16_t *norminal_size, uint16_t da
         ctrl_blackout = 10;
       }
     } else {
-      packet_size = norminal_size[1];
+      packet_size = nominal_size[1];
       if (ctrl_blackout) {
         ctrl_blackout--;
       }
@@ -2710,11 +1909,8 @@ static uint16_t audiod_tx_packet_size(const uint16_t *norminal_size, uint16_t da
 #endif
 
 // No security checks here - internal function only which should always succeed
-static uint8_t audiod_get_audio_fct_idx(audiod_function_t *audio) {
-  for (uint8_t cnt = 0; cnt < CFG_TUD_AUDIO; cnt++) {
-    if (&_audiod_fct[cnt] == audio) return cnt;
-  }
-  return 0;
+static inline uint8_t audiod_get_audio_fct_idx(audiod_function_t *audio) {
+  return (uint8_t) (audio - _audiod_fct);
 }
 
 #endif // (CFG_TUD_ENABLED && CFG_TUD_AUDIO)
diff --git a/src/class/audio/audio_device.h b/src/class/audio/audio_device.h
index 0a7bff212..1e0c46915 100644
--- a/src/class/audio/audio_device.h
+++ b/src/class/audio/audio_device.h
@@ -26,8 +26,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_AUDIO_DEVICE_H_
-#define _TUSB_AUDIO_DEVICE_H_
+#ifndef TUSB_AUDIO_DEVICE_H_
+#define TUSB_AUDIO_DEVICE_H_
 
 #include "audio.h"
 
@@ -37,50 +37,10 @@
 
 // All sizes are in bytes!
 
-#ifndef CFG_TUD_AUDIO_FUNC_1_DESC_LEN
-#error You must tell the driver the length of the audio function descriptor including IAD descriptor
-#endif
-#if CFG_TUD_AUDIO > 1
-#ifndef CFG_TUD_AUDIO_FUNC_2_DESC_LEN
-#error You must tell the driver the length of the audio function descriptor including IAD descriptor
-#endif
-#endif
-#if CFG_TUD_AUDIO > 2
-#ifndef CFG_TUD_AUDIO_FUNC_3_DESC_LEN
-#error You must tell the driver the length of the audio function descriptor including IAD descriptor
-#endif
-#endif
-
-// Number of Standard AS Interface Descriptors (4.9.1) defined per audio function - this is required to be able to remember the current alternate settings of these interfaces
-#ifndef CFG_TUD_AUDIO_FUNC_1_N_AS_INT
-#error You must tell the driver the number of Standard AS Interface Descriptors you have defined in the audio function descriptor!
-#endif
-#if CFG_TUD_AUDIO > 1
-#ifndef CFG_TUD_AUDIO_FUNC_2_N_AS_INT
-#error You must tell the driver the number of Standard AS Interface Descriptors you have defined in the audio function descriptor!
-#endif
-#endif
-#if CFG_TUD_AUDIO > 2
-#ifndef CFG_TUD_AUDIO_FUNC_3_N_AS_INT
-#error You must tell the driver the number of Standard AS Interface Descriptors you have defined in the audio function descriptor!
-#endif
-#endif
-
-// Size of control buffer used to receive and send control messages via EP0 - has to be big enough to hold your biggest request structure e.g. range requests with multiple intervals defined or cluster descriptors
-#ifndef CFG_TUD_AUDIO_FUNC_1_CTRL_BUF_SZ
-#error You must define an audio class control request buffer size!
-#endif
-
-#if CFG_TUD_AUDIO > 1
-#ifndef CFG_TUD_AUDIO_FUNC_2_CTRL_BUF_SZ
-#error You must define an audio class control request buffer size!
-#endif
-#endif
-
-#if CFG_TUD_AUDIO > 2
-#ifndef CFG_TUD_AUDIO_FUNC_3_CTRL_BUF_SZ
-#error You must define an audio class control request buffer size!
-#endif
+// Size of control buffer used to receive and send control messages via EP0 - has to be big enough to hold your
+// biggest request structure e.g. range requests with multiple intervals defined or cluster descriptors
+#ifndef CFG_TUD_AUDIO_CTRL_BUF_SZ
+#define CFG_TUD_AUDIO_CTRL_BUF_SZ    64
 #endif
 
 // End point sizes IN BYTES - Limits: Full Speed <= 1023, High Speed <= 1024
@@ -182,7 +142,8 @@
 #endif
 #endif
 
-// (For TYPE-I format only) Flow control is necessary to allow IN ep send correct amount of data, unless it's a virtual device where data is perfectly synchronized to USB clock.
+// (For TYPE-I format only) Flow control is necessary to allow IN ep send correct amount of data, unless it's a
+// virtual device where data is perfectly synchronized to USB clock.
 #ifndef CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL
 #define CFG_TUD_AUDIO_EP_IN_FLOW_CONTROL  1
 #endif
@@ -192,12 +153,6 @@
 #define CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP                    0                             // Feedback - 0 or 1
 #endif
 
-// Enable/disable conversion from 16.16 to 10.14 format on full-speed devices. See tud_audio_n_fb_set().
-// Can be override by tud_audio_feedback_format_correction_cb()
-#ifndef CFG_TUD_AUDIO_ENABLE_FEEDBACK_FORMAT_CORRECTION
-#define CFG_TUD_AUDIO_ENABLE_FEEDBACK_FORMAT_CORRECTION     0                             // 0 or 1
-#endif
-
 // Enable/disable interrupt EP (required for notifying host of control changes)
 #ifndef CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
 #define CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP                   0                             // Feedback - 0 or 1
@@ -206,153 +161,6 @@
 // Audio control interrupt EP - 6 Bytes according to UAC 2 specification (p. 74)
 #define CFG_TUD_AUDIO_INTERRUPT_EP_SZ                       6
 
-// Use software encoding/decoding
-
-// The software coding feature of the driver is not mandatory. It is useful if, for instance, you have two I2S streams which need to be interleaved
-// into a single PCM stream as SAMPLE_1 | SAMPLE_2 | SAMPLE_3 | SAMPLE_4.
-//
-// Currently, only PCM type I encoding/decoding is supported!
-//
-// If the coding feature is to be used, support FIFOs need to be configured. Their sizes and numbers are defined below.
-
-// Encoding/decoding is done in software and thus time consuming. If you can encode/decode your stream more efficiently do not use the
-// support FIFOs but write/read directly into/from the EP_X_SW_BUFFER_FIFOs using
-// - tud_audio_n_write() or
-// - tud_audio_n_read().
-// To write/read to/from the support FIFOs use
-// - tud_audio_n_write_support_ff() or
-// - tud_audio_n_read_support_ff().
-//
-// The encoding/decoding format type done is defined below.
-//
-// The encoding/decoding starts when the private callback functions
-// - audio_tx_done_cb()
-// - audio_rx_done_cb()
-// are invoked. If support FIFOs are used, the corresponding encoding/decoding functions are called from there.
-// Once encoding/decoding is done the result is put directly into the EP_X_SW_BUFFER_FIFOs. You can use the public callback functions
-// - tud_audio_tx_done_pre_load_cb() or tud_audio_tx_done_post_load_cb()
-// - tud_audio_rx_done_pre_read_cb() or tud_audio_rx_done_post_read_cb()
-// if you want to get informed what happened.
-//
-// If you don't use the support FIFOs you may use the public callback functions
-// - tud_audio_tx_done_pre_load_cb() or tud_audio_tx_done_post_load_cb()
-// - tud_audio_rx_done_pre_read_cb() or tud_audio_rx_done_post_read_cb()
-// to write/read from/into the EP_X_SW_BUFFER_FIFOs at the right time.
-//
-// If you need a different encoding which is not support so far implement it in the
-// - audio_tx_done_cb()
-// - audio_rx_done_cb()
-// functions.
-
-// Enable encoding/decodings - for these to work, support FIFOs need to be setup in appropriate numbers and size
-// The actual coding parameters of active AS alternate interface is parsed from the descriptors
-
-// The item size of the FIFO is always fixed to one i.e. bytes! Furthermore, the actively used FIFO depth is reconfigured such that the depth is a multiple
-// of the current sample size in order to avoid samples to get split up in case of a wrap in the FIFO ring buffer (depth = (max_depth / sample_sz) * sample_sz)!
-// This is important to remind in case you use DMAs! If the sample sizes changes, the DMA MUST BE RECONFIGURED just like the FIFOs for a different depth!!!
-
-// For PCM encoding/decoding
-
-#ifndef CFG_TUD_AUDIO_ENABLE_ENCODING
-#define CFG_TUD_AUDIO_ENABLE_ENCODING                       0
-#endif
-
-#ifndef CFG_TUD_AUDIO_ENABLE_DECODING
-#define CFG_TUD_AUDIO_ENABLE_DECODING                       0
-#endif
-
-// This enabling allows to save the current coding parameters e.g. # of bytes per sample etc. - TYPE_I includes common PCM encoding
-#ifndef CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-#define CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING                0
-#endif
-
-#ifndef CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-#define CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING                0
-#endif
-
-// Type I Coding parameters not given within UAC2 descriptors
-// It would be possible to allow for a more flexible setting and not fix this parameter as done below. However, this is most often not needed and kept for later if really necessary. The more flexible setting could be implemented within set_interface(), however, how the values are saved per alternate setting is to be determined!
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING && CFG_TUD_AUDIO_ENABLE_TYPE_I_ENCODING
-#ifndef CFG_TUD_AUDIO_FUNC_1_CHANNEL_PER_FIFO_TX
-#error You must tell the driver the number of channels per FIFO for the interleaved encoding! E.g. for an I2S interface having two channels, CHANNEL_PER_FIFO = 2 as the I2S stream having two channels is usually saved within one FIFO
-#endif
-#if CFG_TUD_AUDIO > 1
-#ifndef CFG_TUD_AUDIO_FUNC_2_CHANNEL_PER_FIFO_TX
-#error You must tell the driver the number of channels per FIFO for the interleaved encoding! E.g. for an I2S interface having two channels, CHANNEL_PER_FIFO = 2 as the I2S stream having two channels is usually saved within one FIFO
-#endif
-#endif
-#if CFG_TUD_AUDIO > 2
-#ifndef CFG_TUD_AUDIO_FUNC_3_CHANNEL_PER_FIFO_TX
-#error You must tell the driver the number of channels per FIFO for the interleaved encoding! E.g. for an I2S interface having two channels, CHANNEL_PER_FIFO = 2 as the I2S stream having two channels is usually saved within one FIFO
-#endif
-#endif
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING && CFG_TUD_AUDIO_ENABLE_TYPE_I_DECODING
-#ifndef CFG_TUD_AUDIO_FUNC_1_CHANNEL_PER_FIFO_RX
-#error You must tell the driver the number of channels per FIFO for the interleaved encoding! E.g. for an I2S interface having two channels, CHANNEL_PER_FIFO = 2 as the I2S stream having two channels is usually saved within one FIFO
-#endif
-#if CFG_TUD_AUDIO > 1
-#ifndef CFG_TUD_AUDIO_FUNC_2_CHANNEL_PER_FIFO_RX
-#error You must tell the driver the number of channels per FIFO for the interleaved encoding! E.g. for an I2S interface having two channels, CHANNEL_PER_FIFO = 2 as the I2S stream having two channels is usually saved within one FIFO
-#endif
-#endif
-#if CFG_TUD_AUDIO > 2
-#ifndef CFG_TUD_AUDIO_FUNC_3_CHANNEL_PER_FIFO_RX
-#error You must tell the driver the number of channels per FIFO for the interleaved encoding! E.g. for an I2S interface having two channels, CHANNEL_PER_FIFO = 2 as the I2S stream having two channels is usually saved within one FIFO
-#endif
-#endif
-#endif
-
-// Remaining types not support so far
-
-// Number of support FIFOs to set up - multiple channels can be handled by one FIFO - very common is two channels per FIFO stemming from one I2S interface
-#ifndef CFG_TUD_AUDIO_FUNC_1_N_TX_SUPP_SW_FIFO
-#define CFG_TUD_AUDIO_FUNC_1_N_TX_SUPP_SW_FIFO              0
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_2_N_TX_SUPP_SW_FIFO
-#define CFG_TUD_AUDIO_FUNC_2_N_TX_SUPP_SW_FIFO              0
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_3_N_TX_SUPP_SW_FIFO
-#define CFG_TUD_AUDIO_FUNC_3_N_TX_SUPP_SW_FIFO              0
-#endif
-
-#ifndef CFG_TUD_AUDIO_FUNC_1_N_RX_SUPP_SW_FIFO
-#define CFG_TUD_AUDIO_FUNC_1_N_RX_SUPP_SW_FIFO              0
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_2_N_RX_SUPP_SW_FIFO
-#define CFG_TUD_AUDIO_FUNC_2_N_RX_SUPP_SW_FIFO              0
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_3_N_RX_SUPP_SW_FIFO
-#define CFG_TUD_AUDIO_FUNC_3_N_RX_SUPP_SW_FIFO              0
-#endif
-
-// Size of support FIFOs IN BYTES - if size > 0 there are as many FIFOs set up as CFG_TUD_AUDIO_FUNC_X_N_TX_SUPP_SW_FIFO and CFG_TUD_AUDIO_FUNC_X_N_RX_SUPP_SW_FIFO
-#ifndef CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ
-#define CFG_TUD_AUDIO_FUNC_1_TX_SUPP_SW_FIFO_SZ             0         // FIFO size - minimum size: ceil(f_s/1000) * max(# of TX channels) / (# of TX support FIFOs) * max(# of bytes per sample)
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ
-#define CFG_TUD_AUDIO_FUNC_2_TX_SUPP_SW_FIFO_SZ             0
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ
-#define CFG_TUD_AUDIO_FUNC_3_TX_SUPP_SW_FIFO_SZ             0
-#endif
-
-#ifndef CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ
-#define CFG_TUD_AUDIO_FUNC_1_RX_SUPP_SW_FIFO_SZ             0         // FIFO size - minimum size: ceil(f_s/1000) * max(# of RX channels) / (# of RX support FIFOs) * max(# of bytes per sample)
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ
-#define CFG_TUD_AUDIO_FUNC_2_RX_SUPP_SW_FIFO_SZ             0
-#endif
-#ifndef CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ
-#define CFG_TUD_AUDIO_FUNC_3_RX_SUPP_SW_FIFO_SZ             0
-#endif
-
-//static_assert(sizeof(tud_audio_desc_lengths) != CFG_TUD_AUDIO, "Supply audio function descriptor pack length!");
-
-// Supported types of this driver:
-// AUDIO_DATA_FORMAT_TYPE_I_PCM     -   Required definitions: CFG_TUD_AUDIO_N_CHANNELS and CFG_TUD_AUDIO_BYTES_PER_CHANNEL
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -366,75 +174,45 @@ extern "C" {
 // Application API (Multiple Interfaces)
 // CFG_TUD_AUDIO > 1
 //--------------------------------------------------------------------+
-bool     tud_audio_n_mounted    (uint8_t func_id);
+bool tud_audio_n_mounted(uint8_t func_id);
+uint8_t tud_audio_n_version(uint8_t func_id);
 
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
-uint16_t tud_audio_n_available                    (uint8_t func_id);
-uint16_t tud_audio_n_read                         (uint8_t func_id, void* buffer, uint16_t bufsize);
-bool     tud_audio_n_clear_ep_out_ff              (uint8_t func_id);                          // Delete all content in the EP OUT FIFO
-tu_fifo_t*   tud_audio_n_get_ep_out_ff            (uint8_t func_id);
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-bool     tud_audio_n_clear_rx_support_ff          (uint8_t func_id, uint8_t ff_idx);       // Delete all content in the support RX FIFOs
-uint16_t tud_audio_n_available_support_ff         (uint8_t func_id, uint8_t ff_idx);
-uint16_t tud_audio_n_read_support_ff              (uint8_t func_id, uint8_t ff_idx, void* buffer, uint16_t bufsize);
-tu_fifo_t* tud_audio_n_get_rx_support_ff          (uint8_t func_id, uint8_t ff_idx);
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
-uint16_t tud_audio_n_write                        (uint8_t func_id, const void * data, uint16_t len);
-bool     tud_audio_n_clear_ep_in_ff               (uint8_t func_id);                          // Delete all content in the EP IN FIFO
-tu_fifo_t*   tud_audio_n_get_ep_in_ff             (uint8_t func_id);
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
+uint16_t   tud_audio_n_available       (uint8_t func_id);
+uint16_t   tud_audio_n_read            (uint8_t func_id, void* buffer, uint16_t bufsize);
+bool       tud_audio_n_clear_ep_out_ff (uint8_t func_id);
+tu_fifo_t* tud_audio_n_get_ep_out_ff   (uint8_t func_id);
 #endif
 
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-uint16_t tud_audio_n_flush_tx_support_ff          (uint8_t func_id);      // Force all content in the support TX FIFOs to be written into EP SW FIFO
-bool     tud_audio_n_clear_tx_support_ff          (uint8_t func_id, uint8_t ff_idx);
-uint16_t tud_audio_n_write_support_ff             (uint8_t func_id, uint8_t ff_idx, const void * data, uint16_t len);
-tu_fifo_t* tud_audio_n_get_tx_support_ff          (uint8_t func_id, uint8_t ff_idx);
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
+uint16_t   tud_audio_n_write          (uint8_t func_id, const void * data, uint16_t len);
+bool       tud_audio_n_clear_ep_in_ff (uint8_t func_id);
+tu_fifo_t* tud_audio_n_get_ep_in_ff   (uint8_t func_id);
+uint16_t   tud_audio_n_get_ep_in_fifo_threshold(uint8_t func_id);
+void       tud_audio_n_set_ep_in_fifo_threshold(uint8_t func_id, uint16_t threshold);
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
 bool    tud_audio_int_n_write                     (uint8_t func_id, const audio_interrupt_data_t * data);
 #endif
 
-
 //--------------------------------------------------------------------+
 // Application API (Interface0)
 //--------------------------------------------------------------------+
-
 static inline bool         tud_audio_mounted                (void);
+static inline uint8_t      tud_audio_version                (void);
 
-// RX API
-
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
-static inline uint16_t     tud_audio_available              (void);
-static inline bool         tud_audio_clear_ep_out_ff        (void);                       // Delete all content in the EP OUT FIFO
-static inline uint16_t     tud_audio_read                   (void* buffer, uint16_t bufsize);
-static inline tu_fifo_t*   tud_audio_get_ep_out_ff          (void);
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-static inline bool     tud_audio_clear_rx_support_ff        (uint8_t ff_idx);
-static inline uint16_t tud_audio_available_support_ff       (uint8_t ff_idx);
-static inline uint16_t tud_audio_read_support_ff            (uint8_t ff_idx, void* buffer, uint16_t bufsize);
-static inline tu_fifo_t* tud_audio_get_rx_support_ff        (uint8_t ff_idx);
-#endif
-
-// TX API
-
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
-static inline uint16_t tud_audio_write                      (const void * data, uint16_t len);
-static inline bool 	   tud_audio_clear_ep_in_ff             (void);
-static inline tu_fifo_t* tud_audio_get_ep_in_ff             (void);
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
+static inline uint16_t   tud_audio_available       (void);
+static inline bool       tud_audio_clear_ep_out_ff (void);
+static inline uint16_t   tud_audio_read            (void* buffer, uint16_t bufsize);
+static inline tu_fifo_t* tud_audio_get_ep_out_ff   (void);
 #endif
 
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-static inline uint16_t tud_audio_flush_tx_support_ff        (void);
-static inline uint16_t tud_audio_clear_tx_support_ff        (uint8_t ff_idx);
-static inline uint16_t tud_audio_write_support_ff           (uint8_t ff_idx, const void * data, uint16_t len);
-static inline tu_fifo_t* tud_audio_get_tx_support_ff        (uint8_t ff_idx);
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
+static inline uint16_t   tud_audio_write          (const void * data, uint16_t len);
+static inline bool       tud_audio_clear_ep_in_ff (void);
+static inline tu_fifo_t* tud_audio_get_ep_in_ff   (void);
 #endif
 
 // INT CTR API
@@ -444,71 +222,91 @@ static inline bool tud_audio_int_write                      (const audio_interru
 #endif
 
 // Buffer control EP data and schedule a transmit
-// This function is intended to be used if you do not have a persistent buffer or memory location available (e.g. non-local variables) and need to answer onto a
-// get request. This function buffers your answer request frame into the control buffer of the corresponding audio driver and schedules a transmit for sending it.
-// Since transmission is triggered via interrupts, a persistent memory location is required onto which the buffer pointer in pointing. If you already have such
-// available you may directly use 'tud_control_xfer(...)'. In this case data does not need to be copied into an additional buffer and you save some time.
+// This function is intended to be used if you do not have a persistent buffer or memory location available
+// (e.g. non-local variables) and need to answer onto a get request. This function buffers your answer request
+// frame into the control buffer of the corresponding audio driver and schedules a transmit for sending it.
+// Since transmission is triggered via interrupts, a persistent memory location is required onto which the buffer
+// pointer in pointing. If you already have such available you may directly use 'tud_control_xfer(...)'. In this
+// case data does not need to be copied into an additional buffer and you save some time.
 // If the request's wLength is zero, a status packet is sent instead.
-bool tud_audio_buffer_and_schedule_control_xfer(uint8_t rhport, tusb_control_request_t const * p_request, void* data, uint16_t len);
+bool tud_audio_buffer_and_schedule_control_xfer(uint8_t rhport, tusb_control_request_t const * p_request,
+                                                 void* data, uint16_t len);
 
 //--------------------------------------------------------------------+
 // Application Callback API
 //--------------------------------------------------------------------+
 
 #if CFG_TUD_AUDIO_ENABLE_EP_IN
-bool tud_audio_tx_done_pre_load_cb(uint8_t rhport, uint8_t func_id, uint8_t ep_in, uint8_t cur_alt_setting);
-bool tud_audio_tx_done_post_load_cb(uint8_t rhport, uint16_t n_bytes_copied, uint8_t func_id, uint8_t ep_in, uint8_t cur_alt_setting);
+// Invoked in ISR context once an audio packet was sent successfully.
+// Normally this function is not needed, since the data transfer should be driven by audio clock (i.e. I2S clock),
+// call tud_audio_write() in I2S receive callback.
+bool tud_audio_tx_done_isr(uint8_t rhport, uint16_t n_bytes_sent, uint8_t func_id, uint8_t ep_in,
+                           uint8_t cur_alt_setting);
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT
-bool tud_audio_rx_done_pre_read_cb(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out, uint8_t cur_alt_setting);
-bool tud_audio_rx_done_post_read_cb(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out, uint8_t cur_alt_setting);
+// Invoked in ISR context once an audio packet was received successfully.
+// Normally this function is not needed, since the data transfer should be driven by audio clock (i.e. I2S clock),
+// call tud_audio_read() in I2S transmit callback.
+bool tud_audio_rx_done_isr(uint8_t rhport, uint16_t n_bytes_received, uint8_t func_id, uint8_t ep_out,
+                           uint8_t cur_alt_setting);
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-void tud_audio_fb_done_cb(uint8_t func_id);
-
 
 // Note about feedback calculation
 //
 // Option 1 - AUDIO_FEEDBACK_METHOD_FIFO_COUNT
 // Feedback value is calculated within the audio driver by regulating the FIFO level to half fill.
-// Advantage: No ISR interrupt is enabled, hence the CPU need not to handle an ISR every 1ms or 125us and thus less CPU load, well tested
-// (Windows, Linux, OSX) with a reliable result so far.
-// Disadvantage: A FIFO of minimal 4 frames is needed to compensate for jitter, an average delay of 2 frames is introduced.
+// Advantage: No SOF interrupt is enabled, hence the CPU need not to handle an ISR every 1ms or 125us and thus
+// less CPU load, well tested (Windows, Linux, OSX) with a reliable result so far.
+// Disadvantage: A FIFO of minimal 4 frames is needed to compensate for jitter, an average delay of 2 frames is
+// introduced.
 //
 // Option 2 - AUDIO_FEEDBACK_METHOD_FREQUENCY_FIXED / AUDIO_FEEDBACK_METHOD_FREQUENCY_FLOAT
-// Feedback value is calculated within the audio driver by use of SOF interrupt. The driver needs information about the master clock f_m from
-// which the audio sample frequency f_s is derived, f_s itself, and the cycle count of f_m at time of the SOF interrupt (e.g. by use of a hardware counter).
+// Feedback value is calculated within the audio driver by use of SOF interrupt. The driver needs information
+// about the master clock f_m from which the audio sample frequency f_s is derived, f_s itself, and the cycle
+// count of f_m at time of the SOF interrupt (e.g. by use of a hardware counter).
 // See tud_audio_set_fb_params() and tud_audio_feedback_update()
-// Advantage: Reduced jitter in the feedback value computation, hence, the receive FIFO can be smaller and thus a smaller delay is possible.
-// Disadvantage: higher CPU load due to SOF ISR handling every frame i.e. 1ms or 125us. (The most critical point is the reading of the cycle counter value of f_m.
-// It is read from within the SOF ISR - see: audiod_sof() -, hence, the ISR must has a high priority such that no software dependent "random" delay i.e. jitter is introduced).
-// Long-term drift could occur since error is accumulated.
+// Advantage: Reduced jitter in the feedback value computation, hence, the receive FIFO can be smaller and thus a
+// smaller delay is possible.
+// Disadvantage: higher CPU load due to SOF ISR handling every frame i.e. 1ms or 125us. (The most critical point
+// is the reading of the cycle counter value of f_m. It is read from within the SOF ISR - see: audiod_sof() -,
+// hence, the ISR must has a high priority such that no software dependent "random" delay i.e. jitter is
+// introduced). Long-term drift will cause the FIFO under/overflow, you still needs to correct it somehow.
 //
 // Option 3 - manual
-// Determined by the user itself and set by use of tud_audio_n_fb_set(). The feedback value may be determined e.g. from some fill status of some FIFO buffer.
-// Advantage: No ISR interrupt is enabled, hence the CPU need not to handle an ISR every 1ms or 125us and thus less CPU load.
-// Disadvantage: typically a larger FIFO is needed to compensate for jitter (e.g. 6 frames), i.e. a larger delay is introduced.
+// Determined by the user itself and set by use of tud_audio_n_fb_set(). The feedback value may be determined
+// e.g. from some fill status of some FIFO buffer.
+// Advantage: No ISR interrupt is enabled, hence the CPU need not to handle an ISR every 1ms or 125us and thus
+// less CPU load.
+// Disadvantage: typically a larger FIFO is needed to compensate for jitter (e.g. 6 frames), i.e. a larger delay
+// is introduced.
 
 
-// This function is used to provide data rate feedback from an asynchronous sink. Feedback value will be sent at FB endpoint interval till it's changed.
+// This function is used to provide data rate feedback from an asynchronous sink. Feedback value will be sent at
+// FB endpoint interval till it's changed.
 //
-// The feedback format is specified to be 16.16 for HS and 10.14 for FS devices (see Universal Serial Bus Specification Revision 2.0 5.12.4.2). By default,
-// the choice of format is left to the caller and feedback argument is sent as-is. If CFG_TUD_AUDIO_ENABLE_FEEDBACK_FORMAT_CORRECTION is set or tud_audio_feedback_format_correction_cb()
-// return true, then tinyusb expects 16.16 format and handles the conversion to 10.14 on FS.
+// The feedback format is specified to be 16.16 for HS and 10.14 for FS devices (see Universal Serial Bus
+// Specification Revision 2.0 5.12.4.2). For simplicity, this function always uses 16.16 format. For FS devices,
+// the driver will automatically convert the value to 10.14 format.
 //
-// Note that due to a bug in its USB Audio 2.0 driver, Windows currently requires 16.16 format for _all_ USB 2.0 devices. On Linux and it seems the
-// driver can work with either format.
+// Note that due to a bug in its USB Audio 2.0 driver, Windows currently requires 16.16 format for _all_ USB 2.0
+// devices. On Linux and it seems the driver can work with either format.
 //
-// Feedback value can be determined from within the SOF ISR of the audio driver. This should reduce jitter. If the feature is used, the user can not set the feedback value.
+// Feedback value can be determined from within the SOF ISR of the audio driver. This should reduce jitter. If the
+// feature is used, the user can not set the feedback value.
 //
 // Determine feedback value - The feedback method is described in 5.12.4.2 of the USB 2.0 spec
 // Boiled down, the feedback value Ff = n_samples / (micro)frame.
-// Since an accuracy of less than 1 Sample / second is desired, at least n_frames = ceil(2^K * f_s / f_m) frames need to be measured, where K = 10 for full speed and K = 13
-// for high speed, f_s is the sampling frequency e.g. 48 kHz and f_m is the cpu clock frequency e.g. 100 MHz (or any other master clock whose clock count is available and locked to f_s)
-// The update interval in the (4.10.2.1) Feedback Endpoint Descriptor must be less or equal to 2^(K - P), where P = min( ceil(log2(f_m / f_s)), K)
-// feedback = n_cycles / n_frames * f_s / f_m in 16.16 format, where n_cycles are the number of main clock cycles within fb_n_frames
+// Since an accuracy of less than 1 Sample / second is desired, at least n_frames = ceil(2^K * f_s / f_m) frames
+// need to be measured, where K = 10 for full speed and K = 13 for high speed, f_s is the sampling frequency
+// e.g. 48 kHz and f_m is the cpu clock frequency e.g. 100 MHz (or any other master clock whose clock count is
+// available and locked to f_s)
+// The update interval in the (4.10.2.1) Feedback Endpoint Descriptor must be less or equal to 2^(K - P), where
+// P = min( ceil(log2(f_m / f_s)), K)
+// feedback = n_cycles / n_frames * f_s / f_m in 16.16 format, where n_cycles are the number of main clock cycles
+// within fb_n_frames
 bool tud_audio_n_fb_set(uint8_t func_id, uint32_t feedback);
 
 // Update feedback value with passed MCLK cycles since last time this update function is called.
@@ -535,10 +333,12 @@ typedef struct {
   union {
     struct {
       uint32_t mclk_freq; // Main clock frequency in Hz i.e. master clock to which sample clock is based on
-    }frequency;
-
+    } frequency;
+    struct {
+      uint16_t fifo_threshold;  // Target FIFO threshold level, default to half FIFO if not set
+    } fifo_count;
   };
-}audio_feedback_params_t;
+} audio_feedback_params_t;
 
 // Invoked when needed to set feedback parameters
 void tud_audio_feedback_params_cb(uint8_t func_id, uint8_t alt_itf, audio_feedback_params_t* feedback_param);
@@ -548,13 +348,10 @@ void tud_audio_feedback_params_cb(uint8_t func_id, uint8_t alt_itf, audio_feedba
 // frame_number  : current SOF count
 // interval_shift: number of bit shift i.e log2(interval) from Feedback endpoint descriptor
 TU_ATTR_FAST_FUNC void tud_audio_feedback_interval_isr(uint8_t func_id, uint32_t frame_number, uint8_t interval_shift);
-
-// (Full-Speed only) Callback to set feedback format correction is applied or not,
-// default to CFG_TUD_AUDIO_ENABLE_FEEDBACK_FORMAT_CORRECTION if not implemented.
-bool tud_audio_feedback_format_correction_cb(uint8_t func_id);
 #endif // CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
 
 #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
+// Invoked when an interrupt notification transfer is complete
 void tud_audio_int_done_cb(uint8_t rhport);
 #endif
 
@@ -562,7 +359,10 @@ void tud_audio_int_done_cb(uint8_t rhport);
 bool tud_audio_set_itf_cb(uint8_t rhport, tusb_control_request_t const * p_request);
 
 // Invoked when audio set interface request received which closes an EP
-bool tud_audio_set_itf_close_EP_cb(uint8_t rhport, tusb_control_request_t const * p_request);
+bool tud_audio_set_itf_close_ep_cb(uint8_t rhport, tusb_control_request_t const * p_request);
+
+// backward compatible for typo
+#define tud_audio_set_itf_close_EP_cb   tud_audio_set_itf_close_ep_cb
 
 // Invoked when audio class specific set request received for an EP
 bool tud_audio_set_req_ep_cb(uint8_t rhport, tusb_control_request_t const * p_request, uint8_t *pBuff);
@@ -586,120 +386,70 @@ bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *
 // Inline Functions
 //--------------------------------------------------------------------+
 
-static inline bool tud_audio_mounted(void)
-{
+TU_ATTR_ALWAYS_INLINE static inline bool tud_audio_mounted(void) {
   return tud_audio_n_mounted(0);
 }
 
-// RX API
+TU_ATTR_ALWAYS_INLINE static inline uint8_t tud_audio_version(void) {
+  return tud_audio_n_version(0);
+}
 
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && !CFG_TUD_AUDIO_ENABLE_DECODING
+#if CFG_TUD_AUDIO_ENABLE_EP_OUT
 
-static inline uint16_t tud_audio_available(void)
-{
+TU_ATTR_ALWAYS_INLINE static inline uint16_t tud_audio_available(void) {
   return tud_audio_n_available(0);
 }
 
-static inline uint16_t tud_audio_read(void* buffer, uint16_t bufsize)
-{
+TU_ATTR_ALWAYS_INLINE static inline uint16_t tud_audio_read(void* buffer, uint16_t bufsize) {
   return tud_audio_n_read(0, buffer, bufsize);
 }
 
-static inline bool tud_audio_clear_ep_out_ff(void)
-{
+TU_ATTR_ALWAYS_INLINE static inline bool tud_audio_clear_ep_out_ff(void) {
   return tud_audio_n_clear_ep_out_ff(0);
 }
 
-static inline tu_fifo_t* tud_audio_get_ep_out_ff(void)
-{
+TU_ATTR_ALWAYS_INLINE static inline tu_fifo_t* tud_audio_get_ep_out_ff(void) {
   return tud_audio_n_get_ep_out_ff(0);
 }
 
 #endif
 
-#if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_DECODING
-
-static inline bool tud_audio_clear_rx_support_ff(uint8_t ff_idx)
-{
-  return tud_audio_n_clear_rx_support_ff(0, ff_idx);
-}
-
-static inline uint16_t tud_audio_available_support_ff(uint8_t ff_idx)
-{
-  return tud_audio_n_available_support_ff(0, ff_idx);
-}
-
-static inline uint16_t tud_audio_read_support_ff(uint8_t ff_idx, void* buffer, uint16_t bufsize)
-{
-  return tud_audio_n_read_support_ff(0, ff_idx, buffer, bufsize);
-}
-
-static inline tu_fifo_t* tud_audio_get_rx_support_ff(uint8_t ff_idx)
-{
-  return tud_audio_n_get_rx_support_ff(0, ff_idx);
-}
-
-#endif
-
-// TX API
-
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && !CFG_TUD_AUDIO_ENABLE_ENCODING
+#if CFG_TUD_AUDIO_ENABLE_EP_IN
 
-static inline uint16_t tud_audio_write(const void * data, uint16_t len)
-{
+TU_ATTR_ALWAYS_INLINE static inline uint16_t tud_audio_write(const void * data, uint16_t len) {
   return tud_audio_n_write(0, data, len);
 }
 
-static inline bool tud_audio_clear_ep_in_ff(void)
-{
+TU_ATTR_ALWAYS_INLINE static inline bool tud_audio_clear_ep_in_ff(void) {
   return tud_audio_n_clear_ep_in_ff(0);
 }
 
-static inline tu_fifo_t* tud_audio_get_ep_in_ff(void)
-{
+TU_ATTR_ALWAYS_INLINE static inline tu_fifo_t* tud_audio_get_ep_in_ff(void) {
   return tud_audio_n_get_ep_in_ff(0);
 }
 
-#endif
-
-#if CFG_TUD_AUDIO_ENABLE_EP_IN && CFG_TUD_AUDIO_ENABLE_ENCODING
-
-static inline uint16_t tud_audio_flush_tx_support_ff(void)
-{
-  return tud_audio_n_flush_tx_support_ff(0);
-}
-
-static inline uint16_t tud_audio_clear_tx_support_ff(uint8_t ff_idx)
-{
-  return tud_audio_n_clear_tx_support_ff(0, ff_idx);
-}
-
-static inline uint16_t tud_audio_write_support_ff(uint8_t ff_idx, const void * data, uint16_t len)
+TU_ATTR_ALWAYS_INLINE static inline uint16_t tud_audio_get_ep_in_fifo_threshold(void)
 {
-  return tud_audio_n_write_support_ff(0, ff_idx, data, len);
+  return tud_audio_n_get_ep_in_fifo_threshold(0);
 }
 
-static inline tu_fifo_t* tud_audio_get_tx_support_ff(uint8_t ff_idx)
+TU_ATTR_ALWAYS_INLINE static inline void tud_audio_set_ep_in_fifo_threshold(uint16_t threshold)
 {
-  return tud_audio_n_get_tx_support_ff(0, ff_idx);
+  tud_audio_n_set_ep_in_fifo_threshold(0, threshold);
 }
 
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_INTERRUPT_EP
-static inline bool tud_audio_int_write(const audio_interrupt_data_t * data)
-{
+TU_ATTR_ALWAYS_INLINE static inline bool tud_audio_int_write(const audio_interrupt_data_t * data) {
   return tud_audio_int_n_write(0, data);
 }
 #endif
 
 #if CFG_TUD_AUDIO_ENABLE_EP_OUT && CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP
-
-static inline bool tud_audio_fb_set(uint32_t feedback)
-{
+TU_ATTR_ALWAYS_INLINE static inline bool tud_audio_fb_set(uint32_t feedback) {
   return tud_audio_n_fb_set(0, feedback);
 }
-
 #endif
 
 //--------------------------------------------------------------------+
@@ -711,13 +461,14 @@ void     audiod_reset          (uint8_t rhport);
 uint16_t audiod_open           (uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
 bool     audiod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
 bool     audiod_xfer_cb        (uint8_t rhport, uint8_t edpt_addr, xfer_result_t result, uint32_t xferred_bytes);
+bool     audiod_xfer_isr       (uint8_t rhport, uint8_t edpt_addr, xfer_result_t result, uint32_t xferred_bytes);
 void     audiod_sof_isr        (uint8_t rhport, uint32_t frame_count);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* _TUSB_AUDIO_DEVICE_H_ */
+#endif /* TUSB_AUDIO_DEVICE_H_ */
 
 /** @} */
 /** @} */
diff --git a/src/class/bth/bth_device.c b/src/class/bth/bth_device.c
index 45cbf2d98..3f1529cb6 100755
--- a/src/class/bth/bth_device.c
+++ b/src/class/bth/bth_device.c
@@ -43,7 +43,7 @@ typedef struct {
   uint8_t ep_acl_in;
   uint16_t ep_acl_in_pkt_sz;
   uint8_t ep_acl_out;
-  uint8_t ep_voice[2];  // Not used yet
+  uint8_t ep_voice[2];// Not used yet
   uint8_t ep_voice_size[2][CFG_TUD_BTH_ISO_ALT_COUNT];
 
   // Previous amount of bytes sent when issuing ZLP
@@ -61,8 +61,7 @@ typedef struct {
 static btd_interface_t _btd_itf;
 CFG_TUD_MEM_SECTION static btd_epbuf_t _btd_epbuf;
 
-static bool bt_tx_data(uint8_t ep, void *data, uint16_t len)
-{
+static bool bt_tx_data(uint8_t ep, void *data, uint16_t len) {
   uint8_t const rhport = 0;
 
   // skip if previous transfer not complete
@@ -74,6 +73,27 @@ static bool bt_tx_data(uint8_t ep, void *data, uint16_t len)
 }
 
 //--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_bt_hci_cmd_cb(void *hci_cmd, size_t cmd_len) {
+  (void) hci_cmd;
+  (void) cmd_len;
+}
+
+TU_ATTR_WEAK void tud_bt_acl_data_received_cb(void *acl_data, uint16_t data_len) {
+  (void) acl_data;
+  (void) data_len;
+}
+
+TU_ATTR_WEAK void tud_bt_event_sent_cb(uint16_t sent_bytes) {
+  (void) sent_bytes;
+}
+
+TU_ATTR_WEAK void tud_bt_acl_data_sent_cb(uint16_t sent_bytes) {
+  (void) sent_bytes;
+}
+
+//--------------------------------------------------------------------+
 // READ API
 //--------------------------------------------------------------------+
 
@@ -82,13 +102,11 @@ static bool bt_tx_data(uint8_t ep, void *data, uint16_t len)
 // WRITE API
 //--------------------------------------------------------------------+
 
-bool tud_bt_event_send(void *event, uint16_t event_len)
-{
+bool tud_bt_event_send(void *event, uint16_t event_len) {
   return bt_tx_data(_btd_itf.ep_ev, event, event_len);
 }
 
-bool tud_bt_acl_data_send(void *event, uint16_t event_len)
-{
+bool tud_bt_acl_data_send(void *event, uint16_t event_len) {
   return bt_tx_data(_btd_itf.ep_acl_in, event, event_len);
 }
 
@@ -103,13 +121,11 @@ bool btd_deinit(void) {
   return true;
 }
 
-void btd_reset(uint8_t rhport)
-{
-  (void)rhport;
+void btd_reset(uint8_t rhport) {
+  (void) rhport;
 }
 
-uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_t max_len)
-{
+uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
   tusb_desc_endpoint_t const *desc_ep;
   uint16_t drv_len = 0;
   // Size of single alternative of ISO interface
@@ -118,8 +134,9 @@ uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_
   const uint16_t hci_itf_size = sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t);
   // Ensure this is BT Primary Controller
   TU_VERIFY(TUSB_CLASS_WIRELESS_CONTROLLER == itf_desc->bInterfaceClass &&
-            TUD_BT_APP_SUBCLASS == itf_desc->bInterfaceSubClass &&
-            TUD_BT_PROTOCOL_PRIMARY_CONTROLLER == itf_desc->bInterfaceProtocol, 0);
+                TUD_BT_APP_SUBCLASS == itf_desc->bInterfaceSubClass &&
+                TUD_BT_PROTOCOL_PRIMARY_CONTROLLER == itf_desc->bInterfaceProtocol,
+            0);
 
   TU_ASSERT(itf_desc->bNumEndpoints == 3 && max_len >= hci_itf_size);
 
@@ -131,10 +148,10 @@ uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_
   TU_ASSERT(usbd_edpt_open(rhport, desc_ep), 0);
   _btd_itf.ep_ev = desc_ep->bEndpointAddress;
 
-  desc_ep = (tusb_desc_endpoint_t const *)tu_desc_next(desc_ep);
+  desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(desc_ep);
 
   // Open endpoint pair
-  TU_ASSERT(usbd_open_edpt_pair(rhport, (uint8_t const *)desc_ep, 2,
+  TU_ASSERT(usbd_open_edpt_pair(rhport, (uint8_t const *) desc_ep, 2,
                                 TUSB_XFER_BULK, &_btd_itf.ep_acl_out,
                                 &_btd_itf.ep_acl_in),
             0);
@@ -146,10 +163,10 @@ uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_
       _btd_itf.ep_acl_in_pkt_sz = tu_edpt_packet_size(desc_ep_acl_in);
       break;
     }
-    desc_ep_acl_in = (tusb_desc_endpoint_t const *)tu_desc_next(desc_ep_acl_in);
+    desc_ep_acl_in = (tusb_desc_endpoint_t const *) tu_desc_next(desc_ep_acl_in);
   }
 
-  itf_desc = (tusb_desc_interface_t const *)tu_desc_next(tu_desc_next(desc_ep));
+  itf_desc = (tusb_desc_interface_t const *) tu_desc_next(tu_desc_next(desc_ep));
 
   // Prepare for incoming data from host
   TU_ASSERT(usbd_edpt_xfer(rhport, _btd_itf.ep_acl_out, _btd_epbuf.epout_buf, CFG_TUD_BTH_DATA_EPSIZE), 0);
@@ -158,13 +175,14 @@ uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_
 
   // Ensure this is still BT Primary Controller
   TU_ASSERT(TUSB_CLASS_WIRELESS_CONTROLLER == itf_desc->bInterfaceClass &&
-            TUD_BT_APP_SUBCLASS == itf_desc->bInterfaceSubClass &&
-            TUD_BT_PROTOCOL_PRIMARY_CONTROLLER == itf_desc->bInterfaceProtocol, 0);
+                TUD_BT_APP_SUBCLASS == itf_desc->bInterfaceSubClass &&
+                TUD_BT_PROTOCOL_PRIMARY_CONTROLLER == itf_desc->bInterfaceProtocol,
+            0);
   TU_ASSERT(itf_desc->bNumEndpoints == 2 && max_len >= iso_alt_itf_size + drv_len);
 
   uint8_t dir;
 
-  desc_ep = (tusb_desc_endpoint_t const *)tu_desc_next(itf_desc);
+  desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
   TU_ASSERT(itf_desc->bAlternateSetting < CFG_TUD_BTH_ISO_ALT_COUNT, 0);
   TU_ASSERT(desc_ep->bDescriptorType == TUSB_DESC_ENDPOINT, 0);
   dir = tu_edpt_dir(desc_ep->bEndpointAddress);
@@ -172,7 +190,7 @@ uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_
   // Store endpoint size for alternative
   _btd_itf.ep_voice_size[dir][itf_desc->bAlternateSetting] = (uint8_t) tu_edpt_packet_size(desc_ep);
 
-  desc_ep = (tusb_desc_endpoint_t const *)tu_desc_next(desc_ep);
+  desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(desc_ep);
   TU_ASSERT(desc_ep->bDescriptorType == TUSB_DESC_ENDPOINT, 0);
   dir = tu_edpt_dir(desc_ep->bEndpointAddress);
   _btd_itf.ep_voice[dir] = desc_ep->bEndpointAddress;
@@ -182,29 +200,30 @@ uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_
 
   for (int i = 1; i < CFG_TUD_BTH_ISO_ALT_COUNT && drv_len + iso_alt_itf_size <= max_len; ++i) {
     // Make sure rest of alternatives matches
-    itf_desc = (tusb_desc_interface_t const *)tu_desc_next(desc_ep);
+    itf_desc = (tusb_desc_interface_t const *) tu_desc_next(desc_ep);
     if (itf_desc->bDescriptorType != TUSB_DESC_INTERFACE ||
         TUSB_CLASS_WIRELESS_CONTROLLER != itf_desc->bInterfaceClass ||
         TUD_BT_APP_SUBCLASS != itf_desc->bInterfaceSubClass ||
-        TUD_BT_PROTOCOL_PRIMARY_CONTROLLER != itf_desc->bInterfaceProtocol)
-    {
+        TUD_BT_PROTOCOL_PRIMARY_CONTROLLER != itf_desc->bInterfaceProtocol) {
       // Not an Iso interface instance
       break;
     }
     TU_ASSERT(itf_desc->bAlternateSetting < CFG_TUD_BTH_ISO_ALT_COUNT, 0);
 
-    desc_ep = (tusb_desc_endpoint_t const *)tu_desc_next(itf_desc);
+    desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
     dir = tu_edpt_dir(desc_ep->bEndpointAddress);
     // Verify that alternative endpoint are same as first ones
     TU_ASSERT(desc_ep->bDescriptorType == TUSB_DESC_ENDPOINT &&
-              _btd_itf.ep_voice[dir] == desc_ep->bEndpointAddress, 0);
+                  _btd_itf.ep_voice[dir] == desc_ep->bEndpointAddress,
+              0);
     _btd_itf.ep_voice_size[dir][itf_desc->bAlternateSetting] = (uint8_t) tu_edpt_packet_size(desc_ep);
 
-    desc_ep = (tusb_desc_endpoint_t const *)tu_desc_next(desc_ep);
+    desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(desc_ep);
     dir = tu_edpt_dir(desc_ep->bEndpointAddress);
     // Verify that alternative endpoint are same as first ones
     TU_ASSERT(desc_ep->bDescriptorType == TUSB_DESC_ENDPOINT &&
-              _btd_itf.ep_voice[dir] == desc_ep->bEndpointAddress, 0);
+                  _btd_itf.ep_voice[dir] == desc_ep->bEndpointAddress,
+              0);
     _btd_itf.ep_voice_size[dir][itf_desc->bAlternateSetting] = (uint8_t) tu_edpt_packet_size(desc_ep);
     drv_len += iso_alt_itf_size;
   }
@@ -215,44 +234,32 @@ uint16_t btd_open(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_
 // Invoked when a control transfer occurred on an interface of this class
 // Driver response accordingly to the request and the transfer stage (setup/data/ack)
 // return false to stall control endpoint (e.g unsupported request)
-bool btd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const *request)
-{
-  (void)rhport;
+bool btd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const *request) {
+  (void) rhport;
 
-  if ( stage == CONTROL_STAGE_SETUP )
-  {
+  if (stage == CONTROL_STAGE_SETUP) {
     if (request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS &&
-        request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_DEVICE)
-    {
+        request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_DEVICE) {
       // HCI command packet addressing for single function Primary Controllers
       // also compatible with historical mode if enabled
       TU_VERIFY((request->bRequest == 0 && request->wValue == 0 && request->wIndex == 0) ||
                 (CFG_TUD_BTH_HISTORICAL_COMPATIBLE && request->bRequest == 0xe0));
-    }
-    else if (request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE)
-    {
-      if (request->bRequest == TUSB_REQ_SET_INTERFACE && _btd_itf.itf_num + 1 == request->wIndex)
-      {
+    } else if (request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_INTERFACE) {
+      if (request->bRequest == TUSB_REQ_SET_INTERFACE && _btd_itf.itf_num + 1 == request->wIndex) {
         // TODO: Set interface it would involve changing size of endpoint size
-      }
-      else
-      {
+      } else {
         // HCI command packet for Primary Controller function in a composite device
         TU_VERIFY(request->bRequest == 0 && request->wValue == 0 && request->wIndex == _btd_itf.itf_num);
       }
-    }
-    else return false;
+    } else
+      return false;
 
     return tud_control_xfer(rhport, request, &_btd_epbuf.hci_cmd, sizeof(bt_hci_cmd_t));
-  }
-  else if ( stage == CONTROL_STAGE_DATA )
-  {
+  } else if (stage == CONTROL_STAGE_DATA) {
     // Handle class request only
     TU_VERIFY(request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS);
 
-    if (tud_bt_hci_cmd_cb) {
-      tud_bt_hci_cmd_cb(&_btd_epbuf.hci_cmd, tu_min16(request->wLength, sizeof(bt_hci_cmd_t)));
-      }
+    tud_bt_hci_cmd_cb(&_btd_epbuf.hci_cmd, tu_min16(request->wLength, sizeof(bt_hci_cmd_t)));
   }
 
   return true;
@@ -261,19 +268,14 @@ bool btd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t c
 bool btd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result,
                  uint32_t xferred_bytes) {
   // received new data from host
-  if (ep_addr == _btd_itf.ep_acl_out)
-  {
-    if (tud_bt_acl_data_received_cb) tud_bt_acl_data_received_cb(_btd_epbuf.epout_buf, xferred_bytes);
+  if (ep_addr == _btd_itf.ep_acl_out) {
+    tud_bt_acl_data_received_cb(_btd_epbuf.epout_buf, xferred_bytes);
 
     // prepare for next data
     TU_ASSERT(usbd_edpt_xfer(rhport, _btd_itf.ep_acl_out, _btd_epbuf.epout_buf, CFG_TUD_BTH_DATA_EPSIZE));
-  }
-  else if (ep_addr == _btd_itf.ep_ev)
-  {
-    if (tud_bt_event_sent_cb) tud_bt_event_sent_cb((uint16_t)xferred_bytes);
-  }
-  else if (ep_addr == _btd_itf.ep_acl_in)
-  {
+  } else if (ep_addr == _btd_itf.ep_ev) {
+    tud_bt_event_sent_cb((uint16_t) xferred_bytes);
+  } else if (ep_addr == _btd_itf.ep_acl_in) {
     if ((result == XFER_RESULT_SUCCESS) && (xferred_bytes > 0) &&
         ((xferred_bytes & (_btd_itf.ep_acl_in_pkt_sz - 1)) == 0)) {
       // Save number of transferred bytes
@@ -281,12 +283,12 @@ bool btd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result,
 
       // Send zero-length packet
       tud_bt_acl_data_send(NULL, 0);
-    } else if (tud_bt_acl_data_sent_cb) {
+    } else {
       if (xferred_bytes == 0) {
         xferred_bytes = _btd_itf.prev_xferred_bytes;
         _btd_itf.prev_xferred_bytes = 0;
       }
-      tud_bt_acl_data_sent_cb((uint16_t)xferred_bytes);
+      tud_bt_acl_data_sent_cb((uint16_t) xferred_bytes);
     }
   }
 
diff --git a/src/class/bth/bth_device.h b/src/class/bth/bth_device.h
index 4f6350839..89a056dc8 100755
--- a/src/class/bth/bth_device.h
+++ b/src/class/bth/bth_device.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_BTH_DEVICE_H_
-#define _TUSB_BTH_DEVICE_H_
+#ifndef TUSB_BTH_DEVICE_H_
+#define TUSB_BTH_DEVICE_H_
 
 #include <common/tusb_common.h>
 #include <device/usbd.h>
@@ -67,23 +67,23 @@ typedef struct TU_ATTR_PACKED
 // Part E, 5.4.1.
 // Length of the command is from 3 bytes (2 bytes for OpCode,
 // 1 byte for parameter total length) to 258.
-TU_ATTR_WEAK void tud_bt_hci_cmd_cb(void *hci_cmd, size_t cmd_len);
+void tud_bt_hci_cmd_cb(void *hci_cmd, size_t cmd_len);
 
 // Invoked when ACL data was received over USB from Bluetooth host.
 // Detailed format is described in Bluetooth core specification Vol 2,
 // Part E, 5.4.2.
 // Length is from 4 bytes, (12 bits for Handle, 4 bits for flags
 // and 16 bits for data total length) to endpoint size.
-TU_ATTR_WEAK void tud_bt_acl_data_received_cb(void *acl_data, uint16_t data_len);
+void tud_bt_acl_data_received_cb(void *acl_data, uint16_t data_len);
 
 // Called when event sent with tud_bt_event_send() was delivered to BT stack.
 // Controller can release/reuse buffer with Event packet at this point.
-TU_ATTR_WEAK void tud_bt_event_sent_cb(uint16_t sent_bytes);
+void tud_bt_event_sent_cb(uint16_t sent_bytes);
 
 // Called when ACL data that was sent with tud_bt_acl_data_send()
 // was delivered to BT stack.
 // Controller can release/reuse buffer with ACL packet at this point.
-TU_ATTR_WEAK void tud_bt_acl_data_sent_cb(uint16_t sent_bytes);
+void tud_bt_acl_data_sent_cb(uint16_t sent_bytes);
 
 // Bluetooth controller calls this function when it wants to send even packet
 // as described in Bluetooth core specification Vol 2, Part E, 5.4.4.
@@ -114,4 +114,4 @@ bool     btd_xfer_cb         (uint8_t rhport, uint8_t edpt_addr, xfer_result_t r
  }
 #endif
 
-#endif /* _TUSB_BTH_DEVICE_H_ */
+#endif /* TUSB_BTH_DEVICE_H_ */
diff --git a/src/class/cdc/cdc.h b/src/class/cdc/cdc.h
index 5cbd658fe..679723ba6 100644
--- a/src/class/cdc/cdc.h
+++ b/src/class/cdc/cdc.h
@@ -29,8 +29,8 @@
  *            Currently only Abstract Control Model subclass is supported
  *  @{ */
 
-#ifndef _TUSB_CDC_H__
-#define _TUSB_CDC_H__
+#ifndef TUSB_CDC_H__
+#define TUSB_CDC_H__
 
 #include "common/tusb_common.h"
 
@@ -192,6 +192,11 @@ typedef enum {
   CDC_LINE_CODING_STOP_BITS_2   = 2, // 2   bits
 } cdc_line_coding_stopbits_t;
 
+#define CDC_LINE_CODING_STOP_BITS_TEXT(STOP_BITS) (          \
+  (STOP_BITS) == CDC_LINE_CODING_STOP_BITS_1   ? "1" :       \
+  (STOP_BITS) == CDC_LINE_CODING_STOP_BITS_1_5 ? "1.5" :     \
+  (STOP_BITS) == CDC_LINE_CODING_STOP_BITS_2   ? "2"   : "?" )
+
 // TODO Backward compatible for typos. Maybe removed in the future release
 #define CDC_LINE_CONDING_STOP_BITS_1   CDC_LINE_CODING_STOP_BITS_1
 #define CDC_LINE_CONDING_STOP_BITS_1_5 CDC_LINE_CODING_STOP_BITS_1_5
@@ -205,22 +210,31 @@ typedef enum {
   CDC_LINE_CODING_PARITY_SPACE = 4,
 } cdc_line_coding_parity_t;
 
+#define CDC_LINE_CODING_PARITY_CHAR(PARITY) (        \
+  (PARITY) == CDC_LINE_CODING_PARITY_NONE  ? 'N' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_ODD   ? 'O' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_EVEN  ? 'E' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_MARK  ? 'M' :     \
+  (PARITY) == CDC_LINE_CODING_PARITY_SPACE ? 'S' : '?' )
+
 //--------------------------------------------------------------------+
 // Management Element Notification (Notification Endpoint)
 //--------------------------------------------------------------------+
 
+#define CDC_REQ_TYPE_NOTIF 0xA1 ///< Direction IN; Type Class; Recipient Interface
+
 /// 6.3 Notification Codes
 typedef enum {
-  CDC_NOTIF_NETWORK_CONNECTION               = 0x00, ///< This notification allows the device to notify the host about network connection status.
-  CDC_NOTIF_RESPONSE_AVAILABLE               = 0x01, ///< This notification allows the device to notify the hostthat a response is available. This response can be retrieved with a subsequent \ref CDC_REQUEST_GET_ENCAPSULATED_RESPONSE request.
+  CDC_NOTIF_NETWORK_CONNECTION               = 0x00, // notify the host about network connection status.
+  CDC_NOTIF_RESPONSE_AVAILABLE               = 0x01, // notify the host that a response is available.
   CDC_NOTIF_AUX_JACK_HOOK_STATE              = 0x08,
   CDC_NOTIF_RING_DETECT                      = 0x09,
   CDC_NOTIF_SERIAL_STATE                     = 0x20,
   CDC_NOTIF_CALL_STATE_CHANGE                = 0x28,
   CDC_NOTIF_LINE_STATE_CHANGE                = 0x29,
-  CDC_NOTIF_CONNECTION_SPEED_CHANGE          = 0x2A, ///< This notification allows the device to inform the host-networking driver that a change in either the upstream or the downstream bit rate of the connection has occurred
+  CDC_NOTIF_CONNECTION_SPEED_CHANGE          = 0x2A, // notify the host-networking driver that a change in either the upstream or the downstream bit rate of the connection has occurred
   CDC_NOTIF_MDLM_SEMANTIC_MODEL_NOTIFICATION = 0x40,
-}cdc_notification_request_t;
+} cdc_notify_request_t;
 
 //--------------------------------------------------------------------+
 // Class Specific Functional Descriptor (Communication Interface)
@@ -231,8 +245,7 @@ TU_ATTR_PACKED_BEGIN
 TU_ATTR_BIT_FIELD_ORDER_BEGIN
 
 /// Header Functional Descriptor (Communication Interface)
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t bLength            ; ///< Size of this descriptor in bytes.
   uint8_t bDescriptorType    ; ///< Descriptor Type, must be Class-Specific
   uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUNC_DESC_
@@ -240,8 +253,7 @@ typedef struct TU_ATTR_PACKED
 }cdc_desc_func_header_t;
 
 /// Union Functional Descriptor (Communication Interface)
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t bLength                  ; ///< Size of this descriptor in bytes.
   uint8_t bDescriptorType          ; ///< Descriptor Type, must be Class-Specific
   uint8_t bDescriptorSubType       ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
@@ -259,14 +271,13 @@ typedef struct TU_ATTR_PACKED
 }
 
 /// Country Selection Functional Descriptor (Communication Interface)
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t bLength             ; ///< Size of this descriptor in bytes.
   uint8_t bDescriptorType     ; ///< Descriptor Type, must be Class-Specific
   uint8_t bDescriptorSubType  ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
   uint8_t iCountryCodeRelDate ; ///< Index of a string giving the release date for the implemented ISO 3166 Country Codes.
   uint16_t wCountryCode       ; ///< Country code in the format as defined in [ISO3166], release date as specified inoffset 3 for the first supported country.
-}cdc_desc_func_country_selection_t;
+} cdc_desc_func_country_selection_t;
 
 #define cdc_desc_func_country_selection_n_t(no_country) \
   struct TU_ATTR_PACKED {            \
@@ -283,8 +294,7 @@ typedef struct TU_ATTR_PACKED
 
 /// \brief Call Management Functional Descriptor
 /// \details This functional descriptor describes the processing of calls for the Communications Class interface.
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t bLength            ; ///< Size of this descriptor in bytes.
   uint8_t bDescriptorType    ; ///< Descriptor Type, must be Class-Specific
   uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
@@ -298,8 +308,7 @@ typedef struct TU_ATTR_PACKED
   uint8_t bDataInterface;
 }cdc_desc_func_call_management_t;
 
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t support_comm_request                    : 1; ///< Device supports the request combination of Set_Comm_Feature, Clear_Comm_Feature, and Get_Comm_Feature.
   uint8_t support_line_request                    : 1; ///< Device supports the request combination of Set_Line_Coding, Set_Control_Line_State, Get_Line_Coding, and the notification Serial_State.
   uint8_t support_send_break                      : 1; ///< Device supports the request Send_Break
@@ -311,8 +320,7 @@ TU_VERIFY_STATIC(sizeof(cdc_acm_capability_t) == 1, "mostly problem with compile
 
 /// Abstract Control Management Functional Descriptor
 /// This functional descriptor describes the commands supported by by the Communications Class interface with SubClass code of \ref CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t bLength                  ; ///< Size of this descriptor in bytes.
   uint8_t bDescriptorType          ; ///< Descriptor Type, must be Class-Specific
   uint8_t bDescriptorSubType       ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
@@ -321,8 +329,7 @@ typedef struct TU_ATTR_PACKED
 
 /// \brief Direct Line Management Functional Descriptor
 /// \details This functional descriptor describes the commands supported by the Communications Class interface with SubClass code of \ref CDC_FUNC_DESC_DIRECT_LINE_MANAGEMENT
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint8_t bLength            ; ///< Size of this descriptor in bytes.
   uint8_t bDescriptorType    ; ///< Descriptor Type, must be Class-Specific
   uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
@@ -384,16 +391,14 @@ typedef struct TU_ATTR_PACKED
 }cdc_desc_func_telephone_call_state_reporting_capabilities_t;
 
 // TODO remove
-static inline uint8_t cdc_functional_desc_typeof(uint8_t const * p_desc)
-{
+TU_ATTR_ALWAYS_INLINE static inline uint8_t cdc_functional_desc_typeof(uint8_t const * p_desc) {
   return p_desc[2];
 }
 
 //--------------------------------------------------------------------+
 // Requests
 //--------------------------------------------------------------------+
-typedef struct TU_ATTR_PACKED
-{
+typedef struct TU_ATTR_PACKED {
   uint32_t bit_rate;
   uint8_t  stop_bits; ///< 0: 1 stop bit - 1: 1.5 stop bits - 2: 2 stop bits
   uint8_t  parity;    ///< 0: None - 1: Odd - 2: Even - 3: Mark - 4: Space
@@ -402,15 +407,58 @@ typedef struct TU_ATTR_PACKED
 
 TU_VERIFY_STATIC(sizeof(cdc_line_coding_t) == 7, "size is not correct");
 
-typedef struct TU_ATTR_PACKED
-{
-  uint16_t dtr : 1;
-  uint16_t rts : 1;
-  uint16_t : 6;
-  uint16_t : 8;
+typedef union TU_ATTR_PACKED {
+  struct TU_ATTR_PACKED {
+    uint8_t dtr : 1;
+    uint8_t rts : 1;
+    uint8_t     : 6;
+  };
+  uint8_t value;
 } cdc_line_control_state_t;
 
-TU_VERIFY_STATIC(sizeof(cdc_line_control_state_t) == 2, "size is not correct");
+TU_VERIFY_STATIC(sizeof(cdc_line_control_state_t) == 1, "size is not correct");
+
+//--------------------------------------------------------------------+
+// Notifications
+//--------------------------------------------------------------------+
+// PSTN 1.2 section 6.5.4 table 31
+typedef union TU_ATTR_PACKED {
+  struct TU_ATTR_PACKED {
+    uint16_t bRxCarrier  : 1; // DCD
+    uint16_t bTxCarrier  : 1; // DSR
+    uint16_t bBreak      : 1; // Break Detected
+    uint16_t bRingSignal : 1;
+    uint16_t bFraming    : 1;
+    uint16_t bParity     : 1;
+    uint16_t bOverRun    : 1;
+    uint16_t             : 9;
+  };
+  struct TU_ATTR_PACKED {
+    uint16_t dcd : 1;
+    uint16_t dsr : 1;
+    uint16_t brk : 1;
+    uint16_t     :13;
+  };
+  uint16_t value;
+} cdc_notify_uart_state_t;
+
+TU_VERIFY_STATIC(sizeof(cdc_notify_uart_state_t) == 2, "size is not correct");
+
+// CDC 1.2 section 6.3.3 table 21
+typedef struct TU_ATTR_PACKED {
+  uint32_t upstream_bitrate;
+  uint32_t downstream_bitrate;
+} cdc_notify_conn_speed_change_t;
+
+typedef struct TU_ATTR_PACKED {
+  tusb_control_request_t request;
+  union {
+    cdc_notify_uart_state_t serial_state;
+    cdc_notify_conn_speed_change_t conn_speed_change;
+  };
+} cdc_notify_msg_t;
+
+TU_VERIFY_STATIC(sizeof(cdc_notify_msg_t) == 16, "size is not correct");
 
 TU_ATTR_PACKED_END  // End of all packed definitions
 TU_ATTR_BIT_FIELD_ORDER_END
diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index 4d19adeb4..babb89952 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -46,103 +46,165 @@
 #define BULK_PACKET_SIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
 
 typedef struct {
+  uint8_t rhport;
   uint8_t itf_num;
-  uint8_t ep_notif;
-  uint8_t ep_in;
-  uint8_t ep_out;
-
-  // Bit 0:  DTR (Data Terminal Ready), Bit 1: RTS (Request to Send)
-  uint8_t line_state;
+  uint8_t ep_notify;
+  uint8_t line_state; // Bit 0: DTR, Bit 1: RTS
 
   /*------------- From this point, data is not cleared by bus reset -------------*/
-  char wanted_char;
   TU_ATTR_ALIGNED(4) cdc_line_coding_t line_coding;
+  char wanted_char;
 
-  // FIFO
-  tu_fifo_t rx_ff;
-  tu_fifo_t tx_ff;
-
-  uint8_t rx_ff_buf[CFG_TUD_CDC_RX_BUFSIZE];
-  uint8_t tx_ff_buf[CFG_TUD_CDC_TX_BUFSIZE];
+  struct {
+    tu_edpt_stream_t tx;
+    tu_edpt_stream_t rx;
 
-  OSAL_MUTEX_DEF(rx_ff_mutex);
-  OSAL_MUTEX_DEF(tx_ff_mutex);
+    uint8_t tx_ff_buf[CFG_TUD_CDC_TX_BUFSIZE];
+    uint8_t rx_ff_buf[CFG_TUD_CDC_RX_BUFSIZE];
+  } stream;
 } cdcd_interface_t;
 
-#define ITF_MEM_RESET_SIZE   offsetof(cdcd_interface_t, wanted_char)
+#define ITF_MEM_RESET_SIZE offsetof(cdcd_interface_t, line_coding)
 
 typedef struct {
   TUD_EPBUF_DEF(epout, CFG_TUD_CDC_EP_BUFSIZE);
   TUD_EPBUF_DEF(epin, CFG_TUD_CDC_EP_BUFSIZE);
+
+  #if CFG_TUD_CDC_NOTIFY
+  TUD_EPBUF_TYPE_DEF(cdc_notify_msg_t, epnotify);
+  #endif
 } cdcd_epbuf_t;
 
 //--------------------------------------------------------------------+
-// INTERNAL OBJECT & FUNCTION DECLARATION
+// Weak stubs: invoked if no strong implementation is available
 //--------------------------------------------------------------------+
-static cdcd_interface_t _cdcd_itf[CFG_TUD_CDC];
-CFG_TUD_MEM_SECTION static cdcd_epbuf_t _cdcd_epbuf[CFG_TUD_CDC];
+TU_ATTR_WEAK void tud_cdc_rx_cb(uint8_t itf) {
+  (void)itf;
+}
 
-static tud_cdc_configure_t _cdcd_cfg = TUD_CDC_CONFIGURE_DEFAULT();
+TU_ATTR_WEAK void tud_cdc_rx_wanted_cb(uint8_t itf, char wanted_char) {
+  (void)itf;
+  (void)wanted_char;
+}
 
-static bool _prep_out_transaction(uint8_t itf) {
-  const uint8_t rhport = 0;
-  cdcd_interface_t* p_cdc = &_cdcd_itf[itf];
-  cdcd_epbuf_t* p_epbuf = &_cdcd_epbuf[itf];
+TU_ATTR_WEAK void tud_cdc_tx_complete_cb(uint8_t itf) {
+  (void)itf;
+}
 
-  // Skip if usb is not ready yet
-  TU_VERIFY(tud_ready() && p_cdc->ep_out);
+TU_ATTR_WEAK void tud_cdc_notify_complete_cb(uint8_t itf) {
+  (void)itf;
+}
 
-  uint16_t available = tu_fifo_remaining(&p_cdc->rx_ff);
+TU_ATTR_WEAK void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
+  (void)itf;
+  (void)dtr;
+  (void)rts;
+}
 
-  // Prepare for incoming data but only allow what we can store in the ring buffer.
-  // TODO Actually we can still carry out the transfer, keeping count of received bytes
-  // and slowly move it to the FIFO when read().
-  // This pre-check reduces endpoint claiming
-  TU_VERIFY(available >= CFG_TUD_CDC_EP_BUFSIZE);
+TU_ATTR_WEAK void tud_cdc_line_coding_cb(uint8_t itf, const cdc_line_coding_t *p_line_coding) {
+  (void)itf;
+  (void)p_line_coding;
+}
 
-  // claim endpoint
-  TU_VERIFY(usbd_edpt_claim(rhport, p_cdc->ep_out));
+TU_ATTR_WEAK void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms) {
+  (void)itf;
+  (void)duration_ms;
+}
 
-  // fifo can be changed before endpoint is claimed
-  available = tu_fifo_remaining(&p_cdc->rx_ff);
+//--------------------------------------------------------------------+
+// INTERNAL OBJECT & FUNCTION DECLARATION
+//--------------------------------------------------------------------+
+static cdcd_interface_t _cdcd_itf[CFG_TUD_CDC];
+CFG_TUD_MEM_SECTION static cdcd_epbuf_t _cdcd_epbuf[CFG_TUD_CDC];
+static tud_cdc_configure_t _cdcd_cfg = TUD_CDC_CONFIGURE_DEFAULT();
 
-  if (available >= CFG_TUD_CDC_EP_BUFSIZE) {
-    return usbd_edpt_xfer(rhport, p_cdc->ep_out, p_epbuf->epout, CFG_TUD_CDC_EP_BUFSIZE);
-  } else {
-    // Release endpoint since we don't make any transfer
-    usbd_edpt_release(rhport, p_cdc->ep_out);
-    return false;
+TU_ATTR_ALWAYS_INLINE static inline uint8_t find_cdc_itf(uint8_t ep_addr) {
+  for (uint8_t idx = 0; idx < CFG_TUD_CDC; idx++) {
+    const cdcd_interface_t *p_cdc = &_cdcd_itf[idx];
+    if (ep_addr == p_cdc->stream.rx.ep_addr || ep_addr == p_cdc->stream.tx.ep_addr ||
+        (ep_addr == p_cdc->ep_notify && ep_addr != 0)) {
+      return idx;
+    }
   }
+  return TUSB_INDEX_INVALID_8;
 }
 
 //--------------------------------------------------------------------+
 // APPLICATION API
 //--------------------------------------------------------------------+
-
 bool tud_cdc_configure(const tud_cdc_configure_t* driver_cfg) {
-  TU_VERIFY(driver_cfg);
+  TU_VERIFY(driver_cfg != NULL);
   _cdcd_cfg = *driver_cfg;
   return true;
 }
 
 bool tud_cdc_n_ready(uint8_t itf) {
-  return tud_ready() && _cdcd_itf[itf].ep_in != 0 && _cdcd_itf[itf].ep_out != 0;
+  TU_VERIFY(itf < CFG_TUD_CDC);
+  TU_VERIFY(tud_ready());
+  const cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
+
+  const bool in_opened  = tu_edpt_stream_is_opened(&p_cdc->stream.tx);
+  const bool out_opened = tu_edpt_stream_is_opened(&p_cdc->stream.rx);
+  return in_opened && out_opened;
 }
 
 bool tud_cdc_n_connected(uint8_t itf) {
+  TU_VERIFY(itf < CFG_TUD_CDC);
+  TU_VERIFY(tud_ready());
   // DTR (bit 0) active  is considered as connected
-  return tud_ready() && tu_bit_test(_cdcd_itf[itf].line_state, 0);
+  return tu_bit_test(_cdcd_itf[itf].line_state, 0);
 }
 
 uint8_t tud_cdc_n_get_line_state(uint8_t itf) {
+  TU_VERIFY(itf < CFG_TUD_CDC, 0);
   return _cdcd_itf[itf].line_state;
 }
 
-void tud_cdc_n_get_line_coding(uint8_t itf, cdc_line_coding_t* coding) {
+void tud_cdc_n_get_line_coding(uint8_t itf, cdc_line_coding_t *coding) {
+  TU_VERIFY(itf < CFG_TUD_CDC, );
   (*coding) = _cdcd_itf[itf].line_coding;
 }
 
+#if CFG_TUD_CDC_NOTIFY
+bool tud_cdc_n_notify_uart_state (uint8_t itf, const cdc_notify_uart_state_t *state) {
+  TU_VERIFY(itf < CFG_TUD_CDC);
+  cdcd_interface_t *p_cdc   = &_cdcd_itf[itf];
+  cdcd_epbuf_t     *p_epbuf = &_cdcd_epbuf[itf];
+  TU_VERIFY(tud_ready() && p_cdc->ep_notify != 0);
+  TU_VERIFY(usbd_edpt_claim(p_cdc->rhport, p_cdc->ep_notify));
+
+  cdc_notify_msg_t* notify_msg = &p_epbuf->epnotify;
+  notify_msg->request.bmRequestType = CDC_REQ_TYPE_NOTIF;
+  notify_msg->request.bRequest = CDC_NOTIF_SERIAL_STATE;
+  notify_msg->request.wValue = 0;
+  notify_msg->request.wIndex = p_cdc->itf_num;
+  notify_msg->request.wLength = sizeof(cdc_notify_uart_state_t);
+  notify_msg->serial_state = *state;
+
+  return usbd_edpt_xfer(p_cdc->rhport, p_cdc->ep_notify, (uint8_t *)notify_msg, 8 + sizeof(cdc_notify_uart_state_t));
+}
+
+bool tud_cdc_n_notify_conn_speed_change(uint8_t itf, const cdc_notify_conn_speed_change_t* conn_speed_change) {
+  TU_VERIFY(itf < CFG_TUD_CDC);
+  cdcd_interface_t *p_cdc   = &_cdcd_itf[itf];
+  cdcd_epbuf_t     *p_epbuf = &_cdcd_epbuf[itf];
+  TU_VERIFY(tud_ready() && p_cdc->ep_notify != 0);
+  TU_VERIFY(usbd_edpt_claim(p_cdc->rhport, p_cdc->ep_notify));
+
+  cdc_notify_msg_t* notify_msg = &p_epbuf->epnotify;
+  notify_msg->request.bmRequestType = CDC_REQ_TYPE_NOTIF;
+  notify_msg->request.bRequest = CDC_NOTIF_CONNECTION_SPEED_CHANGE;
+  notify_msg->request.wValue = 0;
+  notify_msg->request.wIndex = p_cdc->itf_num;
+  notify_msg->request.wLength = sizeof(cdc_notify_conn_speed_change_t);
+  notify_msg->conn_speed_change = *conn_speed_change;
+
+  return usbd_edpt_xfer(p_cdc->rhport, p_cdc->ep_notify, (uint8_t *)notify_msg, 8 + sizeof(cdc_notify_conn_speed_change_t));
+}
+#endif
+
 void tud_cdc_n_set_wanted_char(uint8_t itf, char wanted) {
+  TU_VERIFY(itf < CFG_TUD_CDC, );
   _cdcd_itf[itf].wanted_char = wanted;
 }
 
@@ -150,82 +212,53 @@ void tud_cdc_n_set_wanted_char(uint8_t itf, char wanted) {
 // READ API
 //--------------------------------------------------------------------+
 uint32_t tud_cdc_n_available(uint8_t itf) {
-  return tu_fifo_count(&_cdcd_itf[itf].rx_ff);
+  TU_VERIFY(itf < CFG_TUD_CDC, 0);
+  return tu_edpt_stream_read_available(&_cdcd_itf[itf].stream.rx);
 }
 
 uint32_t tud_cdc_n_read(uint8_t itf, void* buffer, uint32_t bufsize) {
-  cdcd_interface_t* p_cdc = &_cdcd_itf[itf];
-  uint32_t num_read = tu_fifo_read_n(&p_cdc->rx_ff, buffer, (uint16_t) TU_MIN(bufsize, UINT16_MAX));
-  _prep_out_transaction(itf);
-  return num_read;
+  TU_VERIFY(itf < CFG_TUD_CDC, 0);
+  cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
+  return tu_edpt_stream_read(p_cdc->rhport, &p_cdc->stream.rx, buffer, bufsize);
 }
 
-bool tud_cdc_n_peek(uint8_t itf, uint8_t* chr) {
-  return tu_fifo_peek(&_cdcd_itf[itf].rx_ff, chr);
+bool tud_cdc_n_peek(uint8_t itf, uint8_t *chr) {
+  TU_VERIFY(itf < CFG_TUD_CDC);
+  return tu_edpt_stream_peek(&_cdcd_itf[itf].stream.rx, chr);
 }
 
 void tud_cdc_n_read_flush(uint8_t itf) {
-  cdcd_interface_t* p_cdc = &_cdcd_itf[itf];
-  tu_fifo_clear(&p_cdc->rx_ff);
-  _prep_out_transaction(itf);
+  TU_VERIFY(itf < CFG_TUD_CDC, );
+  cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
+  tu_edpt_stream_clear(&p_cdc->stream.rx);
+  tu_edpt_stream_read_xfer(p_cdc->rhport, &p_cdc->stream.rx);
 }
 
 //--------------------------------------------------------------------+
 // WRITE API
 //--------------------------------------------------------------------+
 uint32_t tud_cdc_n_write(uint8_t itf, const void* buffer, uint32_t bufsize) {
-  cdcd_interface_t* p_cdc = &_cdcd_itf[itf];
-  uint16_t wr_count = tu_fifo_write_n(&p_cdc->tx_ff, buffer, (uint16_t) TU_MIN(bufsize, UINT16_MAX));
-
-  // flush if queue more than packet size
-  if (tu_fifo_count(&p_cdc->tx_ff) >= BULK_PACKET_SIZE
-      #if CFG_TUD_CDC_TX_BUFSIZE < BULK_PACKET_SIZE
-      || tu_fifo_full(&p_cdc->tx_ff) // check full if fifo size is less than packet size
-      #endif
-      ) {
-    tud_cdc_n_write_flush(itf);
-  }
-
-  return wr_count;
+  TU_VERIFY(itf < CFG_TUD_CDC, 0);
+  cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
+  return tu_edpt_stream_write(p_cdc->rhport, &p_cdc->stream.tx, buffer, bufsize);
 }
 
 uint32_t tud_cdc_n_write_flush(uint8_t itf) {
-  cdcd_interface_t* p_cdc = &_cdcd_itf[itf];
-  cdcd_epbuf_t* p_epbuf = &_cdcd_epbuf[itf];
-
-  // Skip if usb is not ready yet
-  TU_VERIFY(tud_ready(), 0);
-
-  // No data to send
-  if (!tu_fifo_count(&p_cdc->tx_ff)) {
-    return 0;
-  }
-
-  const uint8_t rhport = 0;
-
-  // Claim the endpoint
-  TU_VERIFY(usbd_edpt_claim(rhport, p_cdc->ep_in), 0);
-
-  // Pull data from FIFO
-  const uint16_t count = tu_fifo_read_n(&p_cdc->tx_ff, p_epbuf->epin, CFG_TUD_CDC_EP_BUFSIZE);
-
-  if (count) {
-    TU_ASSERT(usbd_edpt_xfer(rhport, p_cdc->ep_in, p_epbuf->epin, count), 0);
-    return count;
-  } else {
-    // Release endpoint since we don't make any transfer
-    // Note: data is dropped if terminal is not connected
-    usbd_edpt_release(rhport, p_cdc->ep_in);
-    return 0;
-  }
+  TU_VERIFY(itf < CFG_TUD_CDC, 0);
+  cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
+  return tu_edpt_stream_write_xfer(p_cdc->rhport, &p_cdc->stream.tx);
 }
 
 uint32_t tud_cdc_n_write_available(uint8_t itf) {
-  return tu_fifo_remaining(&_cdcd_itf[itf].tx_ff);
+  TU_VERIFY(itf < CFG_TUD_CDC, 0);
+  cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
+  return tu_edpt_stream_write_available(p_cdc->rhport, &p_cdc->stream.tx);
 }
 
 bool tud_cdc_n_write_clear(uint8_t itf) {
-  return tu_fifo_clear(&_cdcd_itf[itf].tx_ff);
+  TU_VERIFY(itf < CFG_TUD_CDC);
+  cdcd_interface_t *p_cdc = &_cdcd_itf[itf];
+  return tu_edpt_stream_clear(&p_cdc->stream.tx);
 }
 
 //--------------------------------------------------------------------+
@@ -234,7 +267,8 @@ bool tud_cdc_n_write_clear(uint8_t itf) {
 void cdcd_init(void) {
   tu_memclr(_cdcd_itf, sizeof(_cdcd_itf));
   for (uint8_t i = 0; i < CFG_TUD_CDC; i++) {
-    cdcd_interface_t* p_cdc = &_cdcd_itf[i];
+    cdcd_interface_t *p_cdc   = &_cdcd_itf[i];
+    cdcd_epbuf_t     *p_epbuf = &_cdcd_epbuf[i];
 
     p_cdc->wanted_char = (char) -1;
 
@@ -244,44 +278,23 @@ void cdcd_init(void) {
     p_cdc->line_coding.parity = 0;
     p_cdc->line_coding.data_bits = 8;
 
-    // Config RX fifo
-    tu_fifo_config(&p_cdc->rx_ff, p_cdc->rx_ff_buf, TU_ARRAY_SIZE(p_cdc->rx_ff_buf), 1, false);
+    tu_edpt_stream_init(&p_cdc->stream.rx, false, false, false, p_cdc->stream.rx_ff_buf, CFG_TUD_CDC_RX_BUFSIZE,
+                        p_epbuf->epout, CFG_TUD_CDC_EP_BUFSIZE);
 
     // TX fifo can be configured to change to overwritable if not connected (DTR bit not set). Without DTR we do not
     // know if data is actually polled by terminal. This way the most current data is prioritized.
     // Default: is overwritable
-    tu_fifo_config(&p_cdc->tx_ff, p_cdc->tx_ff_buf, TU_ARRAY_SIZE(p_cdc->tx_ff_buf), 1, _cdcd_cfg.tx_overwritabe_if_not_connected);
-
-    #if OSAL_MUTEX_REQUIRED
-    osal_mutex_t mutex_rd = osal_mutex_create(&p_cdc->rx_ff_mutex);
-    osal_mutex_t mutex_wr = osal_mutex_create(&p_cdc->tx_ff_mutex);
-    TU_ASSERT(mutex_rd != NULL && mutex_wr != NULL, );
-
-    tu_fifo_config_mutex(&p_cdc->rx_ff, NULL, mutex_rd);
-    tu_fifo_config_mutex(&p_cdc->tx_ff, mutex_wr, NULL);
-    #endif
+    tu_edpt_stream_init(&p_cdc->stream.tx, false, true, _cdcd_cfg.tx_overwritabe_if_not_connected,
+                        p_cdc->stream.tx_ff_buf, CFG_TUD_CDC_TX_BUFSIZE, p_epbuf->epin, CFG_TUD_CDC_EP_BUFSIZE);
   }
 }
 
 bool cdcd_deinit(void) {
-  #if OSAL_MUTEX_REQUIRED
-  for(uint8_t i=0; i<CFG_TUD_CDC; i++) {
+  for (uint8_t i = 0; i < CFG_TUD_CDC; i++) {
     cdcd_interface_t* p_cdc = &_cdcd_itf[i];
-    osal_mutex_t mutex_rd = p_cdc->rx_ff.mutex_rd;
-    osal_mutex_t mutex_wr = p_cdc->tx_ff.mutex_wr;
-
-    if (mutex_rd) {
-      osal_mutex_delete(mutex_rd);
-      tu_fifo_config_mutex(&p_cdc->rx_ff, NULL, NULL);
-    }
-
-    if (mutex_wr) {
-      osal_mutex_delete(mutex_wr);
-      tu_fifo_config_mutex(&p_cdc->tx_ff, NULL, NULL);
-    }
+    tu_edpt_stream_deinit(&p_cdc->stream.rx);
+    tu_edpt_stream_deinit(&p_cdc->stream.tx);
   }
-  #endif
-
   return true;
 }
 
@@ -290,74 +303,85 @@ void cdcd_reset(uint8_t rhport) {
 
   for (uint8_t i = 0; i < CFG_TUD_CDC; i++) {
     cdcd_interface_t* p_cdc = &_cdcd_itf[i];
-
     tu_memclr(p_cdc, ITF_MEM_RESET_SIZE);
-    if (!_cdcd_cfg.rx_persistent) {
-      tu_fifo_clear(&p_cdc->rx_ff);
-    }
-    if (!_cdcd_cfg.tx_persistent) {
-      tu_fifo_clear(&p_cdc->tx_ff);
-    }
-    tu_fifo_set_overwritable(&p_cdc->tx_ff, _cdcd_cfg.tx_overwritabe_if_not_connected);
+
+    tu_fifo_set_overwritable(&p_cdc->stream.tx.ff, _cdcd_cfg.tx_overwritabe_if_not_connected); // back to default
+    tu_edpt_stream_close(&p_cdc->stream.rx);
+    tu_edpt_stream_close(&p_cdc->stream.tx);
   }
 }
 
 uint16_t cdcd_open(uint8_t rhport, const tusb_desc_interface_t* itf_desc, uint16_t max_len) {
   // Only support ACM subclass
-  TU_VERIFY( TUSB_CLASS_CDC                           == itf_desc->bInterfaceClass &&
-             CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass, 0);
+  TU_VERIFY(TUSB_CLASS_CDC == itf_desc->bInterfaceClass &&
+              CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass,
+            0);
 
-  // Find available interface
-  cdcd_interface_t* p_cdc;
-  uint8_t cdc_id;
-  for (cdc_id = 0; cdc_id < CFG_TUD_CDC; cdc_id++) {
-    p_cdc = &_cdcd_itf[cdc_id];
-    if (p_cdc->ep_in == 0) {
-      break;
-    }
-  }
+  const uint8_t cdc_id = find_cdc_itf(0); // Find available interface
   TU_ASSERT(cdc_id < CFG_TUD_CDC, 0);
+  cdcd_interface_t *p_cdc = &_cdcd_itf[cdc_id];
 
   //------------- Control Interface -------------//
+  p_cdc->rhport = rhport;
   p_cdc->itf_num = itf_desc->bInterfaceNumber;
 
-  uint16_t drv_len = sizeof(tusb_desc_interface_t);
-  const uint8_t* p_desc = tu_desc_next(itf_desc);
+  const uint8_t *p_desc   = (const uint8_t *)itf_desc;
+  const uint8_t *desc_end = p_desc + max_len;
 
-  // Communication Functional Descriptors
-  while (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc) && drv_len <= max_len) {
-    drv_len += tu_desc_len(p_desc);
+  // Skip all class-specific descriptor
+  p_desc = tu_desc_next(itf_desc);
+  while (tu_desc_in_bounds(p_desc, desc_end) && TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc)) {
     p_desc = tu_desc_next(p_desc);
   }
 
+  // notification endpoint (optional)
   if (TUSB_DESC_ENDPOINT == tu_desc_type(p_desc)) {
-    // notification endpoint
     const tusb_desc_endpoint_t* desc_ep = (const tusb_desc_endpoint_t*) p_desc;
-
     TU_ASSERT(usbd_edpt_open(rhport, desc_ep), 0);
-    p_cdc->ep_notif = desc_ep->bEndpointAddress;
+    p_cdc->ep_notify = desc_ep->bEndpointAddress;
 
-    drv_len += tu_desc_len(p_desc);
     p_desc = tu_desc_next(p_desc);
   }
 
-  //------------- Data Interface (if any) -------------//
-  if ((TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
-      (TUSB_CLASS_CDC_DATA == ((const tusb_desc_interface_t*) p_desc)->bInterfaceClass)) {
-    // next to endpoint descriptor
-    drv_len += tu_desc_len(p_desc);
-    p_desc = tu_desc_next(p_desc);
+  //------------- Data Interface (optional) -------------//
+  if (TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) {
+    const tusb_desc_interface_t *data_itf_desc = (const tusb_desc_interface_t *)p_desc;
+    if (TUSB_CLASS_CDC_DATA == data_itf_desc->bInterfaceClass) {
+      for (uint8_t e = 0; e < data_itf_desc->bNumEndpoints; e++) {
+        if (!tu_desc_in_bounds(p_desc, desc_end)) {
+          break;
+        }
+        p_desc = tu_desc_next(p_desc);
 
-    // Open endpoint pair
-    TU_ASSERT(usbd_open_edpt_pair(rhport, p_desc, 2, TUSB_XFER_BULK, &p_cdc->ep_out, &p_cdc->ep_in), 0);
+        const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)p_desc;
+        TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType && TUSB_XFER_BULK == desc_ep->bmAttributes.xfer, 0);
 
-    drv_len += 2 * sizeof(tusb_desc_endpoint_t);
-  }
+        TU_ASSERT(usbd_edpt_open(rhport, desc_ep), 0);
+        if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
+          tu_edpt_stream_t *stream_tx = &p_cdc->stream.tx;
 
-  // Prepare for incoming data
-  _prep_out_transaction(cdc_id);
+          tu_edpt_stream_open(stream_tx, desc_ep);
+          if (_cdcd_cfg.tx_persistent) {
+            tu_edpt_stream_write_xfer(rhport, stream_tx); // flush pending data
+          } else {
+            tu_edpt_stream_clear(stream_tx);
+          }
+        } else {
+          tu_edpt_stream_t *stream_rx = &p_cdc->stream.rx;
+
+          tu_edpt_stream_open(stream_rx, desc_ep);
+          if (!_cdcd_cfg.rx_persistent) {
+            tu_edpt_stream_clear(stream_rx);
+          }
+          TU_ASSERT(tu_edpt_stream_read_xfer(rhport, stream_rx) > 0, 0); // prepare for incoming data
+        }
+      }
+
+      p_desc = tu_desc_next(p_desc);
+    }
+  }
 
-  return drv_len;
+  return (uint16_t)(p_desc - (const uint8_t *)itf_desc);
 }
 
 // Invoked when a control transfer occurred on an interface of this class
@@ -385,9 +409,9 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
         TU_LOG_DRV("  Set Line Coding\r\n");
         tud_control_xfer(rhport, request, &p_cdc->line_coding, sizeof(cdc_line_coding_t));
       } else if (stage == CONTROL_STAGE_ACK) {
-        if (tud_cdc_line_coding_cb) {
-          tud_cdc_line_coding_cb(itf, &p_cdc->line_coding);
-        }
+        tud_cdc_line_coding_cb(itf, &p_cdc->line_coding);
+      } else {
+        // nothing to do
       }
       break;
 
@@ -414,17 +438,15 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
 
         // If enabled: fifo overwriting is disabled if DTR bit is set and vice versa
         if (_cdcd_cfg.tx_overwritabe_if_not_connected) {
-          tu_fifo_set_overwritable(&p_cdc->tx_ff, !dtr);
+          tu_fifo_set_overwritable(&p_cdc->stream.tx.ff, !dtr);
         } else {
-          tu_fifo_set_overwritable(&p_cdc->tx_ff, false);
+          tu_fifo_set_overwritable(&p_cdc->stream.tx.ff, false);
         }
 
         TU_LOG_DRV("  Set Control Line State: DTR = %d, RTS = %d\r\n", dtr, rts);
-
-        // Invoke callback
-        if (tud_cdc_line_state_cb) {
-          tud_cdc_line_state_cb(itf, dtr, rts);
-        }
+        tud_cdc_line_state_cb(itf, dtr, rts); // invoke callback
+      } else {
+        // nothing to do
       }
       break;
 
@@ -433,9 +455,9 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
         tud_control_status(rhport, request);
       } else if (stage == CONTROL_STAGE_ACK) {
         TU_LOG_DRV("  Send Break\r\n");
-        if (tud_cdc_send_break_cb) {
-          tud_cdc_send_break_cb(itf, request->wValue);
-        }
+        tud_cdc_send_break_cb(itf, request->wValue);
+      } else {
+        // nothing to do
       }
       break;
 
@@ -447,64 +469,52 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_requ
 }
 
 bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
-  (void) result;
-
-  uint8_t itf;
-  cdcd_interface_t* p_cdc;
+  (void)result;
 
-  // Identify which interface to use
-  for (itf = 0; itf < CFG_TUD_CDC; itf++) {
-    p_cdc = &_cdcd_itf[itf];
-    if ((ep_addr == p_cdc->ep_out) || (ep_addr == p_cdc->ep_in)) {
-      break;
-    }
-  }
+  uint8_t itf = find_cdc_itf(ep_addr);
   TU_ASSERT(itf < CFG_TUD_CDC);
-  cdcd_epbuf_t* p_epbuf = &_cdcd_epbuf[itf];
+  cdcd_interface_t *p_cdc     = &_cdcd_itf[itf];
+  tu_edpt_stream_t *stream_rx = &p_cdc->stream.rx;
+  tu_edpt_stream_t *stream_tx = &p_cdc->stream.tx;
 
-  // Received new data
-  if (ep_addr == p_cdc->ep_out) {
-    tu_fifo_write_n(&p_cdc->rx_ff, p_epbuf->epout, (uint16_t) xferred_bytes);
+  // Received new data, move to fifo
+  if (ep_addr == stream_rx->ep_addr) {
+    tu_edpt_stream_read_xfer_complete(stream_rx, xferred_bytes);
 
-    // Check for wanted char and invoke callback if needed
-    if (tud_cdc_rx_wanted_cb && (((signed char) p_cdc->wanted_char) != -1)) {
+    // Check for wanted char and invoke wanted callback (multiple times if multiple wanted received)
+    if (((signed char)p_cdc->wanted_char) != -1) {
       for (uint32_t i = 0; i < xferred_bytes; i++) {
-        if ((p_cdc->wanted_char == p_epbuf->epout[i]) && !tu_fifo_empty(&p_cdc->rx_ff)) {
+        if ((p_cdc->wanted_char == (char)stream_rx->ep_buf[i]) && !tu_edpt_stream_empty(stream_rx)) {
           tud_cdc_rx_wanted_cb(itf, p_cdc->wanted_char);
         }
       }
     }
 
-    // invoke receive callback (if there is still data)
-    if (tud_cdc_rx_cb && !tu_fifo_empty(&p_cdc->rx_ff)) {
+    // invoke receive callback if there is still data
+    if (!tu_edpt_stream_empty(stream_rx)) {
       tud_cdc_rx_cb(itf);
     }
 
-    // prepare for OUT transaction
-    _prep_out_transaction(itf);
+    tu_edpt_stream_read_xfer(rhport, stream_rx); // prepare for more data
   }
 
   // Data sent to host, we continue to fetch from tx fifo to send.
   // Note: This will cause incorrect baudrate set in line coding.
   //       Though maybe the baudrate is not really important !!!
-  if (ep_addr == p_cdc->ep_in) {
+  if (ep_addr == stream_tx->ep_addr) {
     // invoke transmit callback to possibly refill tx fifo
-    if (tud_cdc_tx_complete_cb) {
-      tud_cdc_tx_complete_cb(itf);
-    }
+    tud_cdc_tx_complete_cb(itf);
 
-    if (0 == tud_cdc_n_write_flush(itf)) {
-      // If there is no data left, a ZLP should be sent if
-      // xferred_bytes is multiple of EP Packet size and not zero
-      if (!tu_fifo_count(&p_cdc->tx_ff) && xferred_bytes && (0 == (xferred_bytes & (BULK_PACKET_SIZE - 1)))) {
-        if (usbd_edpt_claim(rhport, p_cdc->ep_in)) {
-          TU_ASSERT(usbd_edpt_xfer(rhport, p_cdc->ep_in, NULL, 0));
-        }
-      }
+    if (0 == tu_edpt_stream_write_xfer(rhport, stream_tx)) {
+      // If there is no data left, a ZLP should be sent if needed
+      tu_edpt_stream_write_zlp_if_needed(rhport, stream_tx, xferred_bytes);
     }
   }
 
-  // nothing to do with notif endpoint for now
+  // Sent notification to host
+  if (ep_addr == p_cdc->ep_notify) {
+    tud_cdc_notify_complete_cb(itf);
+  }
 
   return true;
 }
diff --git a/src/class/cdc/cdc_device.h b/src/class/cdc/cdc_device.h
index b653ebd74..6f21af4f3 100644
--- a/src/class/cdc/cdc_device.h
+++ b/src/class/cdc/cdc_device.h
@@ -32,6 +32,10 @@
 //--------------------------------------------------------------------+
 // Class Driver Configuration
 //--------------------------------------------------------------------+
+#ifndef CFG_TUD_CDC_NOTIFY
+  #define CFG_TUD_CDC_NOTIFY    0
+#endif
+
 #if !defined(CFG_TUD_CDC_EP_BUFSIZE) && defined(CFG_TUD_CDC_EPSIZE)
   #warning CFG_TUD_CDC_EPSIZE is renamed to CFG_TUD_CDC_EP_BUFSIZE, please update to use the new name
   #define CFG_TUD_CDC_EP_BUFSIZE    CFG_TUD_CDC_EPSIZE
@@ -49,15 +53,16 @@
 // Driver Configuration
 //--------------------------------------------------------------------+
 typedef struct TU_ATTR_PACKED {
-  uint8_t rx_persistent : 1; // keep rx fifo data even with bus reset or disconnect
-  uint8_t tx_persistent : 1; // keep tx fifo data even with reset or disconnect
-  uint8_t tx_overwritabe_if_not_connected : 1; // if not connected, tx fifo can be overwritten
+  bool rx_persistent : 1; // keep rx fifo data even with bus reset or disconnect
+  bool tx_persistent : 1; // keep tx fifo data even with reset or disconnect
+  bool tx_overwritabe_if_not_connected : 1; // if not connected, tx fifo can be overwritten
 } tud_cdc_configure_t;
+TU_VERIFY_STATIC(sizeof(tud_cdc_configure_t) == 1, "size is not correct");
 
 #define TUD_CDC_CONFIGURE_DEFAULT() { \
-  .rx_persistent = 0, \
-  .tx_persistent = 0, \
-  .tx_overwritabe_if_not_connected = 1, \
+  .rx_persistent = false, \
+  .tx_persistent = false, \
+  .tx_overwritabe_if_not_connected = true, \
 }
 
 // Configure CDC driver behavior
@@ -126,6 +131,23 @@ uint32_t tud_cdc_n_write_available(uint8_t itf);
 // Clear the transmit FIFO
 bool tud_cdc_n_write_clear(uint8_t itf);
 
+
+#if CFG_TUD_CDC_NOTIFY
+// Send UART status notification: DCD, DSR etc ..
+bool tud_cdc_n_notify_uart_state(uint8_t itf, const cdc_notify_uart_state_t *state);
+
+// Send connection speed change notification
+bool tud_cdc_n_notify_conn_speed_change(uint8_t itf, const cdc_notify_conn_speed_change_t* conn_speed_change);
+
+TU_ATTR_ALWAYS_INLINE static inline bool tud_cdc_notify_uart_state(const cdc_notify_uart_state_t* state) {
+ return tud_cdc_n_notify_uart_state(0, state);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline bool tud_cdc_notify_conn_speed_change(const cdc_notify_conn_speed_change_t* conn_speed_change) {
+  return tud_cdc_n_notify_conn_speed_change(0, conn_speed_change);
+}
+#endif
+
 //--------------------------------------------------------------------+
 // Application API (Single Port)
 //--------------------------------------------------------------------+
@@ -195,29 +217,32 @@ TU_ATTR_ALWAYS_INLINE static inline bool tud_cdc_write_clear(void) {
 }
 
 //--------------------------------------------------------------------+
-// Application Callback API (weak is optional)
+// Application Callback API
 //--------------------------------------------------------------------+
 
 // Invoked when received new data
-TU_ATTR_WEAK void tud_cdc_rx_cb(uint8_t itf);
+void tud_cdc_rx_cb(uint8_t itf);
 
 // Invoked when received `wanted_char`
-TU_ATTR_WEAK void tud_cdc_rx_wanted_cb(uint8_t itf, char wanted_char);
+void tud_cdc_rx_wanted_cb(uint8_t itf, char wanted_char);
 
 // Invoked when a TX is complete and therefore space becomes available in TX buffer
-TU_ATTR_WEAK void tud_cdc_tx_complete_cb(uint8_t itf);
+void tud_cdc_tx_complete_cb(uint8_t itf);
+
+// Invoked when a notification is sent to host
+void tud_cdc_notify_complete_cb(uint8_t itf);
 
 // Invoked when line state DTR & RTS are changed via SET_CONTROL_LINE_STATE
-TU_ATTR_WEAK void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts);
+void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts);
 
 // Invoked when line coding is change via SET_LINE_CODING
-TU_ATTR_WEAK void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding);
+void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding);
 
 // Invoked when received send break
 // \param[in]  itf  interface for which send break was received.
 // \param[in]  duration_ms  the length of time, in milliseconds, of the break signal. If a value of FFFFh, then the
 //                          device will send a break until another SendBreak request is received with value 0000h.
-TU_ATTR_WEAK void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms);
+void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms);
 
 //--------------------------------------------------------------------+
 // INTERNAL USBD-CLASS DRIVER API
@@ -233,4 +258,4 @@ bool     cdcd_xfer_cb         (uint8_t rhport, uint8_t ep_addr, xfer_result_t re
  }
 #endif
 
-#endif /* _TUSB_CDC_DEVICE_H_ */
+#endif /* TUSB_CDC_DEVICE_H_ */
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index bf245db3f..35717ddf6 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -24,7 +24,7 @@
  * This file is part of the TinyUSB stack.
  *
  * Contribution
- * - Heiko Kuester: CH34x support
+ * - Heiko Kuester: add support of CH34x & PL2303, improve support of FTDI & CP210x
  */
 
 #include "tusb_option.h"
@@ -35,13 +35,19 @@
 #include "host/usbh_pvt.h"
 
 #include "cdc_host.h"
+#include "serial/ftdi_sio.h"
+#include "serial/cp210x.h"
+#include "serial/ch34x.h"
+#include "serial/pl2303.h"
 
 // Level where CFG_TUSB_DEBUG must be at least for this driver is logged
 #ifndef CFG_TUH_CDC_LOG_LEVEL
-  #define CFG_TUH_CDC_LOG_LEVEL   CFG_TUH_LOG_LEVEL
+  #define CFG_TUH_CDC_LOG_LEVEL   2
 #endif
 
-#define TU_LOG_DRV(...)   TU_LOG(CFG_TUH_CDC_LOG_LEVEL, __VA_ARGS__)
+#define TU_LOG_DRV(...)                 TU_LOG(CFG_TUH_CDC_LOG_LEVEL, __VA_ARGS__)
+#define TU_LOG_CDC(_cdc, _format, ...)  TU_LOG_DRV("[:%u:%u] CDCh %s " _format "\r\n", _cdc->daddr, _cdc->bInterfaceNumber, \
+                                                    serial_drivers[_cdc->serial_drid].name, ##__VA_ARGS__)
 
 //--------------------------------------------------------------------+
 // Host CDC Interface
@@ -56,30 +62,40 @@ typedef struct {
   uint8_t ep_notif;
   uint8_t serial_drid; // Serial Driver ID
   bool mounted;        // Enumeration is complete
-  cdc_acm_capability_t acm_capability;
 
-  TU_ATTR_ALIGNED(4) cdc_line_coding_t line_coding; // Baudrate, stop bits, parity, data width
-  uint8_t line_state;                               // DTR (bit0), RTS (bit1)
+  struct {
+    TU_ATTR_ALIGNED(4) cdc_line_coding_t coding; // Baudrate, stop bits, parity, data width
+    cdc_line_control_state_t control_state;      // DTR, RTS
+  } line, requested_line;
 
-  #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_CP210X || CFG_TUH_CDC_CH34X
-  cdc_line_coding_t requested_line_coding;
-  // 1 byte padding
-  #endif
+  tuh_xfer_cb_t user_complete_cb; // required since we handle request internally first
+
+  union {
+    struct {
+      cdc_acm_capability_t capability;
+    } acm;
+
+    #if CFG_TUH_CDC_FTDI
+    ftdi_private_t ftdi;
+    #endif
 
-  tuh_xfer_cb_t user_control_cb;
+    #if CFG_TUH_CDC_PL2303
+    pl2303_private_t pl2303;
+    #endif
+  };
 
   struct {
     tu_edpt_stream_t tx;
     tu_edpt_stream_t rx;
 
     uint8_t tx_ff_buf[CFG_TUH_CDC_TX_BUFSIZE];
-    uint8_t rx_ff_buf[CFG_TUH_CDC_TX_BUFSIZE];
+    uint8_t rx_ff_buf[CFG_TUH_CDC_RX_BUFSIZE];
   } stream;
 } cdch_interface_t;
 
 typedef struct {
   TUH_EPBUF_DEF(tx, CFG_TUH_CDC_TX_EPSIZE);
-  TUH_EPBUF_DEF(rx, CFG_TUH_CDC_TX_EPSIZE);
+  TUH_EPBUF_DEF(rx, CFG_TUH_CDC_RX_EPSIZE);
 } cdch_epbuf_t;
 
 static cdch_interface_t cdch_data[CFG_TUH_CDC];
@@ -89,58 +105,70 @@ CFG_TUH_MEM_SECTION static cdch_epbuf_t cdch_epbuf[CFG_TUH_CDC];
 // Serial Driver
 //--------------------------------------------------------------------+
 
+// General driver
+static void cdch_process_set_config(tuh_xfer_t *xfer);
+static void cdch_process_line_state_on_enum(tuh_xfer_t *xfer); // invoked after set config is processed
+static void cdch_internal_control_complete(tuh_xfer_t *xfer);
+static void cdch_set_line_coding_stage1_baudrate_complete(tuh_xfer_t *xfer);
+static void cdch_set_line_coding_stage2_data_format_complete(tuh_xfer_t *xfer);
+
 //------------- ACM prototypes -------------//
-static bool acm_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
-static void acm_process_config(tuh_xfer_t* xfer);
+static bool acm_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static bool acm_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void acm_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
 
-static bool acm_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_control_line_state(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 //------------- FTDI prototypes -------------//
 #if CFG_TUH_CDC_FTDI
-#include "serial/ftdi_sio.h"
-
 static uint16_t const ftdi_vid_pid_list[][2] = {CFG_TUH_CDC_FTDI_VID_PID_LIST};
+static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t * itf_desc, uint16_t max_len);
+static bool ftdi_proccess_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void ftdi_internal_control_complete(cdch_interface_t* p_cdc, tuh_xfer_t *xfer);
 
-static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
-static void ftdi_process_config(tuh_xfer_t* xfer);
-
-static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- CP210X prototypes -------------//
 #if CFG_TUH_CDC_CP210X
-#include "serial/cp210x.h"
-
 static uint16_t const cp210x_vid_pid_list[][2] = {CFG_TUH_CDC_CP210X_VID_PID_LIST};
 
-static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
-static void cp210x_process_config(tuh_xfer_t* xfer);
+static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static bool cp210x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void cp210x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
 
-static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- CH34x prototypes -------------//
 #if CFG_TUH_CDC_CH34X
-#include "serial/ch34x.h"
-
 static uint16_t const ch34x_vid_pid_list[][2] = {CFG_TUH_CDC_CH34X_VID_PID_LIST};
 
-static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len);
-static void ch34x_process_config(tuh_xfer_t* xfer);
+static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static bool ch34x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void ch34x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
 
-static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+#endif
+
+//------------- PL2303 prototypes -------------//
+#if CFG_TUH_CDC_PL2303
+static uint16_t const pl2303_vid_pid_list[][2] = {CFG_TUH_CDC_PL2303_VID_PID_LIST};
+static const pl2303_type_data_t pl2303_type_data[PL2303_TYPE_COUNT] = {PL2303_TYPE_DATA};
+
+static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static bool pl2303_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+static void pl2303_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer);
+
+static bool pl2303_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool pl2303_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- Common -------------//
@@ -159,31 +187,48 @@ enum {
   SERIAL_DRIVER_CH34X,
 #endif
 
+#if CFG_TUH_CDC_PL2303
+  SERIAL_DRIVER_PL2303,
+#endif
+
   SERIAL_DRIVER_COUNT
 };
 
+typedef bool (*serial_driver_func_t)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+
 typedef struct {
   uint16_t const (*vid_pid_list)[2];
   uint16_t const vid_pid_count;
-  bool (*const open)(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
-  void (*const process_set_config)(tuh_xfer_t* xfer);
-  bool (*const set_control_line_state)(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_baudrate)(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_data_format)(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_line_coding)(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const open)(uint8_t daddr, const tusb_desc_interface_t * itf_desc, uint16_t max_len);
+  bool (*const process_set_config)(cdch_interface_t * p_cdc, tuh_xfer_t * xfer);
+  void (*const request_complete)(cdch_interface_t * p_cdc, tuh_xfer_t * xfer); // internal request complete handler to update line state
+
+  serial_driver_func_t set_control_line_state, set_baudrate, set_data_format, set_line_coding;
+
+  #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+  const char * name;
+  #endif
 } cdch_serial_driver_t;
 
+#if CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+  #define DRIVER_NAME_DECLARE(_str)  .name = _str
+#else
+  #define DRIVER_NAME_DECLARE(_str)
+#endif
+
 // Note driver list must be in the same order as SERIAL_DRIVER enum
 static const cdch_serial_driver_t serial_drivers[] = {
   {
       .vid_pid_list           = NULL,
       .vid_pid_count          = 0,
       .open                   = acm_open,
-      .process_set_config     = acm_process_config,
+      .process_set_config     = acm_process_set_config,
+      .request_complete       = acm_internal_control_complete,
       .set_control_line_state = acm_set_control_line_state,
-      .set_baudrate           = acm_set_baudrate,
-      .set_data_format        = acm_set_data_format,
-      .set_line_coding        = acm_set_line_coding
+      .set_baudrate           = acm_set_line_coding,
+      .set_data_format        = acm_set_line_coding,
+      .set_line_coding        = acm_set_line_coding,
+      DRIVER_NAME_DECLARE("ACM")
   },
 
   #if CFG_TUH_CDC_FTDI
@@ -191,11 +236,13 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .vid_pid_list           = ftdi_vid_pid_list,
       .vid_pid_count          = TU_ARRAY_SIZE(ftdi_vid_pid_list),
       .open                   = ftdi_open,
-      .process_set_config     = ftdi_process_config,
-      .set_control_line_state = ftdi_sio_set_modem_ctrl,
-      .set_baudrate           = ftdi_sio_set_baudrate,
+      .process_set_config     = ftdi_proccess_set_config,
+      .request_complete       = ftdi_internal_control_complete,
+      .set_control_line_state = ftdi_set_modem_ctrl,
+      .set_baudrate           = ftdi_set_baudrate,
       .set_data_format        = ftdi_set_data_format,
-      .set_line_coding        = ftdi_set_line_coding
+      .set_line_coding        = NULL, // 2 stage set line coding
+      DRIVER_NAME_DECLARE("FTDI")
   },
   #endif
 
@@ -204,11 +251,13 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .vid_pid_list           = cp210x_vid_pid_list,
       .vid_pid_count          = TU_ARRAY_SIZE(cp210x_vid_pid_list),
       .open                   = cp210x_open,
-      .process_set_config     = cp210x_process_config,
+      .process_set_config     = cp210x_process_set_config,
+      .request_complete       = cp210x_internal_control_complete,
       .set_control_line_state = cp210x_set_modem_ctrl,
       .set_baudrate           = cp210x_set_baudrate,
       .set_data_format        = cp210x_set_data_format,
-      .set_line_coding        = cp210x_set_line_coding
+      .set_line_coding        = NULL, // 2 stage set line coding
+      DRIVER_NAME_DECLARE("CP210x")
   },
   #endif
 
@@ -217,13 +266,31 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .vid_pid_list           = ch34x_vid_pid_list,
       .vid_pid_count          = TU_ARRAY_SIZE(ch34x_vid_pid_list),
       .open                   = ch34x_open,
-      .process_set_config     = ch34x_process_config,
+      .process_set_config     = ch34x_process_set_config,
+      .request_complete       = ch34x_internal_control_complete,
+
       .set_control_line_state = ch34x_set_modem_ctrl,
       .set_baudrate           = ch34x_set_baudrate,
       .set_data_format        = ch34x_set_data_format,
-      .set_line_coding        = ch34x_set_line_coding
+      .set_line_coding        = NULL, // 2 stage set line coding
+      DRIVER_NAME_DECLARE("CH34x")
   },
   #endif
+
+  #if CFG_TUH_CDC_PL2303
+  {
+      .vid_pid_list           = pl2303_vid_pid_list,
+      .vid_pid_count          = TU_ARRAY_SIZE(pl2303_vid_pid_list),
+      .open                   = pl2303_open,
+      .process_set_config     = pl2303_process_set_config,
+      .request_complete       = pl2303_internal_control_complete,
+      .set_control_line_state = pl2303_set_modem_ctrl,
+      .set_baudrate           = pl2303_set_line_coding,
+      .set_data_format        = pl2303_set_line_coding,
+      .set_line_coding        = pl2303_set_line_coding,
+      DRIVER_NAME_DECLARE("PL2303")
+  }
+  #endif
 };
 
 TU_VERIFY_STATIC(TU_ARRAY_SIZE(serial_drivers) == SERIAL_DRIVER_COUNT, "Serial driver count mismatch");
@@ -231,18 +298,22 @@ TU_VERIFY_STATIC(TU_ARRAY_SIZE(serial_drivers) == SERIAL_DRIVER_COUNT, "Serial d
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
+static bool open_ep_stream_pair(cdch_interface_t *p_cdc, const tusb_desc_endpoint_t *desc_ep);
 
-static inline cdch_interface_t* get_itf(uint8_t idx) {
+TU_ATTR_ALWAYS_INLINE static inline cdch_interface_t * get_itf(uint8_t idx) {
   TU_ASSERT(idx < CFG_TUH_CDC, NULL);
-  cdch_interface_t* p_cdc = &cdch_data[idx];
-
+  cdch_interface_t * p_cdc = &cdch_data[idx];
   return (p_cdc->daddr != 0) ? p_cdc : NULL;
 }
 
+TU_ATTR_ALWAYS_INLINE static inline uint8_t get_idx_by_ptr(cdch_interface_t* p_cdc) {
+  return (uint8_t) (p_cdc - cdch_data);
+}
+
 static inline uint8_t get_idx_by_ep_addr(uint8_t daddr, uint8_t ep_addr) {
   for(uint8_t i=0; i<CFG_TUH_CDC; i++) {
-    cdch_interface_t* p_cdc = &cdch_data[i];
-    if ( (p_cdc->daddr == daddr) &&
+    cdch_interface_t * p_cdc = &cdch_data[i];
+    if ((p_cdc->daddr == daddr) &&
          (ep_addr == p_cdc->ep_notif || ep_addr == p_cdc->stream.rx.ep_addr || ep_addr == p_cdc->stream.tx.ep_addr)) {
       return i;
     }
@@ -251,15 +322,67 @@ static inline uint8_t get_idx_by_ep_addr(uint8_t daddr, uint8_t ep_addr) {
   return TUSB_INDEX_INVALID_8;
 }
 
-static cdch_interface_t* make_new_itf(uint8_t daddr, tusb_desc_interface_t const *itf_desc) {
+// determine the interface from the completed transfer
+static cdch_interface_t* get_itf_by_xfer(const tuh_xfer_t * xfer) {
+  TU_VERIFY(xfer->daddr != 0, NULL);
+  for(uint8_t i=0; i<CFG_TUH_CDC; i++) {
+    cdch_interface_t * p_cdc = &cdch_data[i];
+    if (p_cdc->daddr == xfer->daddr) {
+      switch (p_cdc->serial_drid) {
+        #if CFG_TUH_CDC_CP210X
+        case SERIAL_DRIVER_CP210X:
+        #endif
+        case SERIAL_DRIVER_ACM: {
+          // Driver use wIndex for bInterfaceNumber
+          const uint8_t itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+          if (p_cdc->bInterfaceNumber == itf_num) {
+            return p_cdc;
+          }
+          break;
+        }
+
+        #if CFG_TUH_CDC_FTDI
+        case SERIAL_DRIVER_FTDI: {
+          // FTDI uses wIndex for channel number, if channel is 0 then it is the default channel
+          const uint8_t channel = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+          if (p_cdc->ftdi.channel == 0 || p_cdc->ftdi.channel == channel) {
+            return p_cdc;
+          }
+          break;
+        }
+        #endif
+
+        #if CFG_TUH_CDC_CH34X
+        case SERIAL_DRIVER_CH34X:
+          // ch34x has only one interface
+          return p_cdc;
+        #endif
+
+        #if CFG_TUH_CDC_PL2303
+        case SERIAL_DRIVER_PL2303:
+          // pl2303 has only one interface
+          return p_cdc;
+        #endif
+
+        default:
+          break; // unknown driver
+      }
+    }
+  }
+
+  return NULL;
+}
+
+static cdch_interface_t * make_new_itf(uint8_t daddr, tusb_desc_interface_t const * itf_desc) {
   for(uint8_t i=0; i<CFG_TUH_CDC; i++) {
     if (cdch_data[i].daddr == 0) {
-      cdch_interface_t* p_cdc = &cdch_data[i];
+      cdch_interface_t * p_cdc = &cdch_data[i];
       p_cdc->daddr              = daddr;
       p_cdc->bInterfaceNumber   = itf_desc->bInterfaceNumber;
       p_cdc->bInterfaceSubClass = itf_desc->bInterfaceSubClass;
       p_cdc->bInterfaceProtocol = itf_desc->bInterfaceProtocol;
-      p_cdc->line_state         = 0;
+      p_cdc->line.coding        = (cdc_line_coding_t) { 0, 0, 0, 0 };
+      p_cdc->line.control_state.value = 0;
       return p_cdc;
     }
   }
@@ -267,9 +390,24 @@ static cdch_interface_t* make_new_itf(uint8_t daddr, tusb_desc_interface_t const
   return NULL;
 }
 
-static bool open_ep_stream_pair(cdch_interface_t* p_cdc , tusb_desc_endpoint_t const *desc_ep);
-static void set_config_complete(cdch_interface_t * p_cdc, uint8_t idx, uint8_t itf_num);
-static void cdch_internal_control_complete(tuh_xfer_t* xfer);
+//--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tuh_cdc_mount_cb(uint8_t idx) {
+  (void) idx;
+}
+
+TU_ATTR_WEAK void tuh_cdc_umount_cb(uint8_t idx) {
+  (void) idx;
+}
+
+TU_ATTR_WEAK void tuh_cdc_rx_cb(uint8_t idx) {
+  (void) idx;
+}
+
+TU_ATTR_WEAK void tuh_cdc_tx_complete_cb(uint8_t idx) {
+  (void) idx;
+}
 
 //--------------------------------------------------------------------+
 // APPLICATION API
@@ -277,21 +415,20 @@ static void cdch_internal_control_complete(tuh_xfer_t* xfer);
 
 uint8_t tuh_cdc_itf_get_index(uint8_t daddr, uint8_t itf_num) {
   for (uint8_t i = 0; i < CFG_TUH_CDC; i++) {
-    const cdch_interface_t* p_cdc = &cdch_data[i];
-    if (p_cdc->daddr == daddr && p_cdc->bInterfaceNumber == itf_num) return i;
+    const cdch_interface_t * p_cdc = &cdch_data[i];
+    if (p_cdc->daddr == daddr && p_cdc->bInterfaceNumber == itf_num) { return i; }
   }
-
   return TUSB_INDEX_INVALID_8;
 }
 
-bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t* info) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t * info) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && info);
 
   info->daddr = p_cdc->daddr;
 
-  // re-construct descriptor
-  tusb_desc_interface_t* desc = &info->desc;
+  // re-construct interface descriptor
+  tusb_desc_interface_t * desc = &info->desc;
   desc->bLength            = sizeof(tusb_desc_interface_t);
   desc->bDescriptorType    = TUSB_DESC_INTERFACE;
 
@@ -307,31 +444,22 @@ bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t* info) {
 }
 
 bool tuh_cdc_mounted(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
   return p_cdc->mounted;
 }
 
-bool tuh_cdc_get_dtr(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_VERIFY(p_cdc);
-
-  return (p_cdc->line_state & CDC_CONTROL_LINE_STATE_DTR) ? true : false;
-}
-
-bool tuh_cdc_get_rts(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_get_control_line_state_local(uint8_t idx, uint16_t* line_state) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
-  return (p_cdc->line_state & CDC_CONTROL_LINE_STATE_RTS) ? true : false;
+  *line_state = p_cdc->line.control_state.value;
+  return true;
 }
 
-bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t* line_coding) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_get_line_coding_local(uint8_t idx, cdc_line_coding_t * line_coding) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
-  *line_coding = p_cdc->line_coding;
-
+  *line_coding = p_cdc->line.coding;
   return true;
 }
 
@@ -339,31 +467,27 @@ bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t* line_coding)
 // Write
 //--------------------------------------------------------------------+
 
-uint32_t tuh_cdc_write(uint8_t idx, void const* buffer, uint32_t bufsize) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+uint32_t tuh_cdc_write(uint8_t idx, void const * buffer, uint32_t bufsize) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
   return tu_edpt_stream_write(p_cdc->daddr, &p_cdc->stream.tx, buffer, bufsize);
 }
 
 uint32_t tuh_cdc_write_flush(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
   return tu_edpt_stream_write_xfer(p_cdc->daddr, &p_cdc->stream.tx);
 }
 
 bool tuh_cdc_write_clear(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
   return tu_edpt_stream_clear(&p_cdc->stream.tx);
 }
 
 uint32_t tuh_cdc_write_available(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
   return tu_edpt_stream_write_available(p_cdc->daddr, &p_cdc->stream.tx);
 }
 
@@ -371,33 +495,30 @@ uint32_t tuh_cdc_write_available(uint8_t idx) {
 // Read
 //--------------------------------------------------------------------+
 
-uint32_t tuh_cdc_read (uint8_t idx, void* buffer, uint32_t bufsize) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+uint32_t tuh_cdc_read (uint8_t idx, void * buffer, uint32_t bufsize) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
   return tu_edpt_stream_read(p_cdc->daddr, &p_cdc->stream.rx, buffer, bufsize);
 }
 
 uint32_t tuh_cdc_read_available(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
   return tu_edpt_stream_read_available(&p_cdc->stream.rx);
 }
 
-bool tuh_cdc_peek(uint8_t idx, uint8_t* ch) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_peek(uint8_t idx, uint8_t * ch) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
-
   return tu_edpt_stream_peek(&p_cdc->stream.rx, ch);
 }
 
 bool tuh_cdc_read_clear (uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   bool ret = tu_edpt_stream_clear(&p_cdc->stream.rx);
-  tu_edpt_stream_read_xfer(p_cdc->daddr, &p_cdc->stream.rx);
+  (void)tu_edpt_stream_read_xfer(p_cdc->daddr, &p_cdc->stream.rx);
   return ret;
 }
 
@@ -405,218 +526,115 @@ bool tuh_cdc_read_clear (uint8_t idx) {
 // Control Endpoint API
 //--------------------------------------------------------------------+
 
-static void process_internal_control_complete(tuh_xfer_t* xfer, uint8_t itf_num) {
-  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
-  uint16_t const value = tu_le16toh(xfer->setup->wValue);
-
-  if (xfer->result == XFER_RESULT_SUCCESS) {
-    switch (p_cdc->serial_drid) {
-      case SERIAL_DRIVER_ACM:
-        switch (xfer->setup->bRequest) {
-          case CDC_REQUEST_SET_CONTROL_LINE_STATE:
-            p_cdc->line_state = (uint8_t) value;
-            break;
-
-          case CDC_REQUEST_SET_LINE_CODING: {
-            uint16_t const len = tu_min16(sizeof(cdc_line_coding_t), tu_le16toh(xfer->setup->wLength));
-            memcpy(&p_cdc->line_coding, xfer->buffer, len);
-            break;
-          }
-
-          default: break;
-        }
-        break;
-
-      #if CFG_TUH_CDC_FTDI
-      case SERIAL_DRIVER_FTDI:
-        switch (xfer->setup->bRequest) {
-          case FTDI_SIO_MODEM_CTRL:
-            p_cdc->line_state = (uint8_t) value;
-            break;
-
-          case FTDI_SIO_SET_BAUD_RATE:
-            p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-            break;
-
-          default: break;
-        }
-        break;
-      #endif
-
-      #if CFG_TUH_CDC_CP210X
-      case SERIAL_DRIVER_CP210X:
-        switch(xfer->setup->bRequest) {
-          case CP210X_SET_MHS:
-            p_cdc->line_state = (uint8_t) value;
-            break;
-
-          case CP210X_SET_BAUDRATE: {
-            uint32_t baudrate;
-            memcpy(&baudrate, xfer->buffer, sizeof(uint32_t));
-            p_cdc->line_coding.bit_rate = tu_le32toh(baudrate);
-            break;
-          }
-
-          default: break;
-        }
-        break;
-      #endif
-
-      #if CFG_TUH_CDC_CH34X
-      case SERIAL_DRIVER_CH34X:
-        switch (xfer->setup->bRequest) {
-          case CH34X_REQ_WRITE_REG:
-            // register write request
-            switch (value) {
-              case CH34X_REG16_DIVISOR_PRESCALER:
-                // baudrate
-                p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-                break;
-
-              case CH32X_REG16_LCR2_LCR:
-                // data format
-                p_cdc->line_coding.stop_bits = p_cdc->requested_line_coding.stop_bits;
-                p_cdc->line_coding.parity = p_cdc->requested_line_coding.parity;
-                p_cdc->line_coding.data_bits = p_cdc->requested_line_coding.data_bits;
-                break;
-
-              default: break;
-            }
-            break;
-
-          case CH34X_REQ_MODEM_CTRL: {
-            // set modem controls RTS/DTR request. Note: signals are inverted
-            uint16_t const modem_signal = ~value;
-            if (modem_signal & CH34X_BIT_RTS) {
-              p_cdc->line_state |= CDC_CONTROL_LINE_STATE_RTS;
-            } else {
-              p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_RTS;
-            }
-
-            if (modem_signal & CH34X_BIT_DTR) {
-              p_cdc->line_state |= CDC_CONTROL_LINE_STATE_DTR;
-            } else {
-              p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_DTR;
-            }
-            break;
-          }
-
-          default: break;
-        }
-        break;
-      #endif
-
-      default: break;
-    }
-  }
-
-  xfer->complete_cb = p_cdc->user_control_cb;
-  if (xfer->complete_cb) {
-    xfer->complete_cb(xfer);
-  }
-}
-
-// internal control complete to update state such as line state, encoding
-static void cdch_internal_control_complete(tuh_xfer_t* xfer) {
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  process_internal_control_complete(xfer, itf_num);
-}
-
 bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
+  TU_LOG_CDC(p_cdc, "set control line state dtr = %u rts = %u", p_cdc->requested_line.control_state.dtr, p_cdc->requested_line.control_state.rts);
+  const cdch_serial_driver_t * driver = &serial_drivers[p_cdc->serial_drid];
 
-  if (complete_cb) {
-    return driver->set_control_line_state(p_cdc, line_state, complete_cb, user_data);
-  } else {
-    // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_control_line_state(p_cdc, line_state, complete_cb, (uintptr_t) &result);
-
-    if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
-    }
+  p_cdc->requested_line.control_state.value = (uint8_t) line_state;
+  p_cdc->user_complete_cb = complete_cb;
+  TU_VERIFY(driver->set_control_line_state(p_cdc, complete_cb ? cdch_internal_control_complete : NULL, user_data));
 
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
-    p_cdc->line_state = (uint8_t) line_state;
-    return true;
+  if (!complete_cb) {
+    // blocking, update line state if request was successful
+    p_cdc->line.control_state.value = (uint8_t) line_state;
   }
+
+  return true;
 }
 
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t *p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
+  TU_LOG_CDC(p_cdc, "set baudrate %lu", baudrate);
+  const cdch_serial_driver_t *driver = &serial_drivers[p_cdc->serial_drid];
 
-  if (complete_cb) {
-    return driver->set_baudrate(p_cdc, baudrate, complete_cb, user_data);
-  } else {
-    // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_baudrate(p_cdc, baudrate, complete_cb, (uintptr_t) &result);
+  p_cdc->requested_line = p_cdc->line; // keep current line coding
+  p_cdc->requested_line.coding.bit_rate = baudrate;
+  p_cdc->user_complete_cb = complete_cb;
+  TU_VERIFY(driver->set_baudrate(p_cdc, complete_cb ? cdch_internal_control_complete : NULL, user_data));
 
-    if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
-    }
-
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
-    p_cdc->line_coding.bit_rate = baudrate;
-    return true;
+  if (!complete_cb) {
+    p_cdc->line.coding.bit_rate = baudrate;
   }
+
+  return true;
 }
 
 bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
                              tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t *p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
+  TU_LOG_CDC(p_cdc, "set data format %u%c%s",
+               data_bits, CDC_LINE_CODING_PARITY_CHAR(parity),
+               CDC_LINE_CODING_STOP_BITS_TEXT(stop_bits));
+  const cdch_serial_driver_t *driver = &serial_drivers[p_cdc->serial_drid];
 
-  if (complete_cb) {
-    return driver->set_data_format(p_cdc, stop_bits, parity, data_bits, complete_cb, user_data);
-  } else {
-    // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_data_format(p_cdc, stop_bits, parity, data_bits, complete_cb, (uintptr_t) &result);
+  p_cdc->requested_line = p_cdc->line; // keep current line coding
+  p_cdc->requested_line.coding.stop_bits = stop_bits;
+  p_cdc->requested_line.coding.parity    = parity;
+  p_cdc->requested_line.coding.data_bits = data_bits;
 
-    if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
-    }
+  p_cdc->user_complete_cb = complete_cb;
+  TU_VERIFY(driver->set_data_format(p_cdc, complete_cb ? cdch_internal_control_complete : NULL, user_data));
 
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
-    p_cdc->line_coding.stop_bits = stop_bits;
-    p_cdc->line_coding.parity = parity;
-    p_cdc->line_coding.data_bits = data_bits;
-    return true;
+  if (!complete_cb) {
+    // blocking
+    p_cdc->line.coding.stop_bits = stop_bits;
+    p_cdc->line.coding.parity    = parity;
+    p_cdc->line.coding.data_bits = data_bits;
   }
+
+  return true;
 }
 
-bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const *line_coding,
+                             tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  cdch_interface_t *p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
+  TU_LOG_CDC(p_cdc, "set line coding %lu %u%c%s",
+               line_coding->bit_rate, line_coding->data_bits,
+               CDC_LINE_CODING_PARITY_CHAR(line_coding->parity),
+               CDC_LINE_CODING_STOP_BITS_TEXT(line_coding->stop_bits));
+  cdch_serial_driver_t const *driver = &serial_drivers[p_cdc->serial_drid];
+  p_cdc->requested_line.coding = *line_coding;
+  p_cdc->user_complete_cb = complete_cb;
 
-  if ( complete_cb ) {
-    return driver->set_line_coding(p_cdc, line_coding, complete_cb, user_data);
-  } else {
-    // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_line_coding(p_cdc, line_coding, complete_cb, (uintptr_t) &result);
+  if (driver->set_line_coding != NULL) {
+    // driver support set_line_coding request
+    TU_VERIFY(driver->set_line_coding(p_cdc, complete_cb ? cdch_internal_control_complete : NULL, user_data));
 
-    if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
+    if (!complete_cb) {
+      p_cdc->line.coding = *line_coding;
     }
+  } else {
+    // driver does not support set_line_coding and need 2 stage to set baudrate and data format separately
+    if (complete_cb != NULL) {
+      // non-blocking
+      TU_VERIFY(driver->set_baudrate(p_cdc, cdch_set_line_coding_stage1_baudrate_complete, user_data));
+    } else {
+      // blocking
+      xfer_result_t result = XFER_RESULT_INVALID;
 
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
-    p_cdc->line_coding = *line_coding;
-    return true;
+      TU_VERIFY(driver->set_baudrate(p_cdc, NULL, (uintptr_t) &result));
+      if (user_data != 0) {
+        *((xfer_result_t *) user_data) = result;
+      }
+      TU_VERIFY(result == XFER_RESULT_SUCCESS);
+      p_cdc->line.coding.bit_rate = p_cdc->requested_line.coding.bit_rate; // update baudrate
+
+      result = XFER_RESULT_INVALID;
+      TU_VERIFY(driver->set_data_format(p_cdc, NULL, (uintptr_t) &result));
+      if (user_data != 0) {
+        *((xfer_result_t *) user_data) = result;
+      }
+      TU_VERIFY(result == XFER_RESULT_SUCCESS);
+      p_cdc->line.coding = p_cdc->requested_line.coding; // update data format
+    }
   }
+
+  return true;
 }
 
 //--------------------------------------------------------------------+
@@ -627,15 +645,12 @@ bool cdch_init(void) {
   TU_LOG_DRV("sizeof(cdch_interface_t) = %u\r\n", sizeof(cdch_interface_t));
   tu_memclr(cdch_data, sizeof(cdch_data));
   for (size_t i = 0; i < CFG_TUH_CDC; i++) {
-    cdch_interface_t* p_cdc = &cdch_data[i];
-    cdch_epbuf_t* epbuf = &cdch_epbuf[i];
-    tu_edpt_stream_init(&p_cdc->stream.tx, true, true, false,
-                        p_cdc->stream.tx_ff_buf, CFG_TUH_CDC_TX_BUFSIZE,
-                        epbuf->tx, CFG_TUH_CDC_TX_EPSIZE);
-
-    tu_edpt_stream_init(&p_cdc->stream.rx, true, false, false,
-                        p_cdc->stream.rx_ff_buf, CFG_TUH_CDC_RX_BUFSIZE,
-                        epbuf->rx, CFG_TUH_CDC_RX_EPSIZE);
+    cdch_interface_t *p_cdc = &cdch_data[i];
+    cdch_epbuf_t *epbuf = &cdch_epbuf[i];
+    TU_ASSERT(tu_edpt_stream_init(&p_cdc->stream.tx, true, true, false, p_cdc->stream.tx_ff_buf, CFG_TUH_CDC_TX_BUFSIZE,
+                                  epbuf->tx, CFG_TUH_CDC_TX_EPSIZE));
+    TU_ASSERT(tu_edpt_stream_init(&p_cdc->stream.rx, true, false, false, p_cdc->stream.rx_ff_buf,
+                                  CFG_TUH_CDC_RX_BUFSIZE, epbuf->rx, CFG_TUH_CDC_RX_EPSIZE));
   }
 
   return true;
@@ -643,25 +658,21 @@ bool cdch_init(void) {
 
 bool cdch_deinit(void) {
   for (size_t i = 0; i < CFG_TUH_CDC; i++) {
-    cdch_interface_t* p_cdc = &cdch_data[i];
-    tu_edpt_stream_deinit(&p_cdc->stream.tx);
-    tu_edpt_stream_deinit(&p_cdc->stream.rx);
+    cdch_interface_t *p_cdc = &cdch_data[i];
+    (void)tu_edpt_stream_deinit(&p_cdc->stream.tx);
+    (void)tu_edpt_stream_deinit(&p_cdc->stream.rx);
   }
   return true;
 }
 
 void cdch_close(uint8_t daddr) {
   for (uint8_t idx = 0; idx < CFG_TUH_CDC; idx++) {
-    cdch_interface_t* p_cdc = &cdch_data[idx];
+    cdch_interface_t *p_cdc = &cdch_data[idx];
     if (p_cdc->daddr == daddr) {
-      TU_LOG_DRV("  CDCh close addr = %u index = %u\r\n", daddr, idx);
-
-      // Invoke application callback
-      if (tuh_cdc_umount_cb) {
-        tuh_cdc_umount_cb(idx);
-      }
+      TU_LOG_CDC(p_cdc, "close");
+      tuh_cdc_umount_cb(idx); // invoke callback
 
-      p_cdc->daddr = 0;
+      p_cdc->daddr            = 0;
       p_cdc->bInterfaceNumber = 0;
       p_cdc->mounted = false;
       tu_edpt_stream_close(&p_cdc->stream.tx);
@@ -675,43 +686,40 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
   TU_VERIFY(event == XFER_RESULT_SUCCESS);
 
   uint8_t const idx = get_idx_by_ep_addr(daddr, ep_addr);
-  cdch_interface_t * p_cdc = get_itf(idx);
+  cdch_interface_t *p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc);
 
-  if ( ep_addr == p_cdc->stream.tx.ep_addr ) {
-    // invoke tx complete callback to possibly refill tx fifo
-    if (tuh_cdc_tx_complete_cb) {
-      tuh_cdc_tx_complete_cb(idx);
-    }
+  if (ep_addr == p_cdc->stream.tx.ep_addr) {
+    tuh_cdc_tx_complete_cb(idx); // invoke transmit complete callback
 
-    if ( 0 == tu_edpt_stream_write_xfer(daddr, &p_cdc->stream.tx) ) {
+    if (0 == tu_edpt_stream_write_xfer(daddr, &p_cdc->stream.tx)) {
       // If there is no data left, a ZLP should be sent if:
       // - xferred_bytes is multiple of EP Packet size and not zero
-      tu_edpt_stream_write_zlp_if_needed(daddr, &p_cdc->stream.tx, xferred_bytes);
+      (void)tu_edpt_stream_write_zlp_if_needed(daddr, &p_cdc->stream.tx, xferred_bytes);
     }
-  } else if ( ep_addr == p_cdc->stream.rx.ep_addr ) {
+  } else if (ep_addr == p_cdc->stream.rx.ep_addr) {
     #if CFG_TUH_CDC_FTDI
-    if (p_cdc->serial_drid == SERIAL_DRIVER_FTDI && xferred_bytes > 2) {
+    if (p_cdc->serial_drid == SERIAL_DRIVER_FTDI) {
       // FTDI reserve 2 bytes for status
       // uint8_t status[2] = {p_cdc->stream.rx.ep_buf[0], p_cdc->stream.rx.ep_buf[1]};
-      tu_edpt_stream_read_xfer_complete_with_buf(&p_cdc->stream.rx, p_cdc->stream.rx.ep_buf+2, xferred_bytes-2);
-    }else
+      if (xferred_bytes > 2) {
+        tu_edpt_stream_read_xfer_complete_with_buf(&p_cdc->stream.rx, p_cdc->stream.rx.ep_buf + 2, xferred_bytes - 2);
+
+        tuh_cdc_rx_cb(idx); // invoke receive callback
+      }
+    } else
     #endif
     {
       tu_edpt_stream_read_xfer_complete(&p_cdc->stream.rx, xferred_bytes);
-    }
-
-    // invoke receive callback
-    if (tuh_cdc_rx_cb) {
-      tuh_cdc_rx_cb(idx);
+      tuh_cdc_rx_cb(idx); // invoke receive callback
     }
 
     // prepare for next transfer if needed
     tu_edpt_stream_read_xfer(daddr, &p_cdc->stream.rx);
-  }else if ( ep_addr == p_cdc->ep_notif ) {
+  } else if (ep_addr == p_cdc->ep_notif) {
     // TODO handle notification endpoint
-  }else {
-    TU_ASSERT(false);
+  } else {
+    return false;
   }
 
   return true;
@@ -720,20 +728,17 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
 //--------------------------------------------------------------------+
 // Enumeration
 //--------------------------------------------------------------------+
-
-static bool open_ep_stream_pair(cdch_interface_t* p_cdc, tusb_desc_endpoint_t const* desc_ep) {
+static bool open_ep_stream_pair(cdch_interface_t *p_cdc, tusb_desc_endpoint_t const *desc_ep) {
   for (size_t i = 0; i < 2; i++) {
     TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType &&
               TUSB_XFER_BULK == desc_ep->bmAttributes.xfer);
     TU_ASSERT(tuh_edpt_open(p_cdc->daddr, desc_ep));
+    tu_edpt_stream_t *stream =
+      (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) ? &p_cdc->stream.rx : &p_cdc->stream.tx;
+    tu_edpt_stream_open(stream, desc_ep);
+    tu_edpt_stream_clear(stream);
 
-    if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
-      tu_edpt_stream_open(&p_cdc->stream.rx, desc_ep);
-    } else {
-      tu_edpt_stream_open(&p_cdc->stream.tx, desc_ep);
-    }
-
-    desc_ep = (tusb_desc_endpoint_t const*) tu_desc_next(desc_ep);
+    desc_ep = (const tusb_desc_endpoint_t *)tu_desc_next(desc_ep);
   }
 
   return true;
@@ -741,10 +746,9 @@ static bool open_ep_stream_pair(cdch_interface_t* p_cdc, tusb_desc_endpoint_t co
 
 bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
   (void) rhport;
-
   // For CDC: only support ACM subclass
   // Note: Protocol 0xFF can be RNDIS device
-  if (TUSB_CLASS_CDC                           == itf_desc->bInterfaceClass &&
+  if (TUSB_CLASS_CDC == itf_desc->bInterfaceClass &&
       CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass) {
     return acm_open(daddr, itf_desc, max_len);
   } else if (SERIAL_DRIVER_COUNT > 1 &&
@@ -753,175 +757,226 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_d
     TU_VERIFY(tuh_vid_pid_get(daddr, &vid, &pid));
 
     for (size_t dr = 1; dr < SERIAL_DRIVER_COUNT; dr++) {
-      cdch_serial_driver_t const* driver = &serial_drivers[dr];
+      const cdch_serial_driver_t *driver = &serial_drivers[dr];
       for (size_t i = 0; i < driver->vid_pid_count; i++) {
         if (driver->vid_pid_list[i][0] == vid && driver->vid_pid_list[i][1] == pid) {
-          return driver->open(daddr, itf_desc, max_len);
+          const bool ret = driver->open(daddr, itf_desc, max_len);
+          TU_LOG_DRV("[:%u:%u] CDCh %s open %s\r\n", daddr, itf_desc->bInterfaceNumber, driver->name, ret ? "OK" : "FAILED");
+          return ret;
         }
       }
     }
+  } else {
+    // not supported class
   }
 
   return false;
 }
 
-static void set_config_complete(cdch_interface_t * p_cdc, uint8_t idx, uint8_t itf_num) {
-  TU_LOG_DRV("CDCh Set Configure complete\r\n");
-  p_cdc->mounted = true;
-  if (tuh_cdc_mount_cb) {
-    tuh_cdc_mount_cb(idx);
-  }
-
-  // Prepare for incoming data
-  tu_edpt_stream_read_xfer(p_cdc->daddr, &p_cdc->stream.rx);
-
-  // notify usbh that driver enumeration is complete
-  usbh_driver_set_config_complete(p_cdc->daddr, itf_num);
-}
-
 bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
   tusb_control_request_t request;
   request.wIndex = tu_htole16((uint16_t) itf_num);
+  uint8_t const idx = tuh_cdc_itf_get_index(daddr, itf_num);
+  cdch_interface_t *p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  TU_LOG_CDC(p_cdc, "set config");
 
-  // fake transfer to kick-off process
+  // fake transfer to kick-off process_set_config()
   tuh_xfer_t xfer;
-  xfer.daddr  = daddr;
+  xfer.daddr = daddr;
   xfer.result = XFER_RESULT_SUCCESS;
-  xfer.setup  = &request;
-  xfer.user_data = 0; // initial state
+  xfer.setup = &request;
+  xfer.user_data = 0; // initial state 0
+  cdch_process_set_config(&xfer);
 
-  uint8_t const idx = tuh_cdc_itf_get_index(daddr, itf_num);
-  cdch_interface_t * p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-
-  serial_drivers[p_cdc->serial_drid].process_set_config(&xfer);
   return true;
 }
 
-//--------------------------------------------------------------------+
-// ACM
-//--------------------------------------------------------------------+
+static void set_config_complete(cdch_interface_t *p_cdc, bool success) {
+  if (success) {
+    const uint8_t idx = get_idx_by_ptr(p_cdc);
+    p_cdc->mounted = true;
+    tuh_cdc_mount_cb(idx);
+    // Prepare for incoming data
+    tu_edpt_stream_read_xfer(p_cdc->daddr, &p_cdc->stream.rx);
+  } else {
+    // clear the interface entry
+    p_cdc->daddr = 0;
+    p_cdc->bInterfaceNumber = 0;
+  }
 
-enum {
-  CONFIG_ACM_SET_CONTROL_LINE_STATE = 0,
-  CONFIG_ACM_SET_LINE_CODING,
-  CONFIG_ACM_COMPLETE,
-};
+  // notify usbh that driver enumeration is complete
+  const uint8_t itf_offset = (p_cdc->serial_drid == SERIAL_DRIVER_ACM) ? 1 : 0;
+  usbh_driver_set_config_complete(p_cdc->daddr, p_cdc->bInterfaceNumber + itf_offset);
+}
 
-static bool acm_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len) {
-  uint8_t const* p_desc_end = ((uint8_t const*) itf_desc) + max_len;
+static void cdch_process_set_config(tuh_xfer_t *xfer) {
+  cdch_interface_t *p_cdc = get_itf_by_xfer(xfer);
+  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT,);
+  TU_LOG_DRV("  state = %u\r\n", xfer->user_data);
+  const cdch_serial_driver_t *driver = &serial_drivers[p_cdc->serial_drid];
 
-  cdch_interface_t* p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
-  p_cdc->serial_drid = SERIAL_DRIVER_ACM;
+  if (!driver->process_set_config(p_cdc, xfer)) {
+    set_config_complete(p_cdc, false);
+  }
+}
 
-  //------------- Control Interface -------------//
-  uint8_t const* p_desc = tu_desc_next(itf_desc);
+// return false if there is no active transfer
+static bool set_line_state_on_enum(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  enum {
+    ENUM_SET_LINE_CODING = 0,
+    ENUM_SET_LINE_CONTROL,
+    ENUM_SET_LINE_COMPLETE,
+  };
+  const uint8_t idx = get_idx_by_ptr(p_cdc);
+  const uintptr_t state = xfer->user_data;
 
-  // Communication Functional Descriptors
-  while ((p_desc < p_desc_end) && (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc))) {
-    if (CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc)) {
-      // save ACM bmCapabilities
-      p_cdc->acm_capability = ((cdc_desc_func_acm_t const*) p_desc)->bmCapabilities;
+  switch (state) {
+    case ENUM_SET_LINE_CODING: {
+      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
+      #if CFG_TUH_CDC_CH34X
+      // ch34x already set line coding in serial init
+      if (p_cdc->serial_drid != SERIAL_DRIVER_CH34X)
+      #endif
+      {
+        const cdc_line_coding_t line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM;
+        TU_ASSERT(tuh_cdc_set_line_coding(idx, &line_coding,
+                                          cdch_process_line_state_on_enum, ENUM_SET_LINE_CONTROL));
+        break;
+      }
+      #endif
+      TU_ATTR_FALLTHROUGH;
     }
 
-    p_desc = tu_desc_next(p_desc);
+    case ENUM_SET_LINE_CONTROL:
+      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+      TU_ASSERT(tuh_cdc_set_control_line_state(idx, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM,
+                                               cdch_process_line_state_on_enum, ENUM_SET_LINE_COMPLETE));
+      break;
+      #else
+      TU_ATTR_FALLTHROUGH;
+      #endif
+
+    case ENUM_SET_LINE_COMPLETE:
+      set_config_complete(p_cdc, true);
+      break;
+
+    default:
+      return false;
   }
 
-  // Open notification endpoint of control interface if any
-  if (itf_desc->bNumEndpoints == 1) {
-    TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc));
-    tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) p_desc;
+  return true;
+}
 
-    TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
-    p_cdc->ep_notif = desc_ep->bEndpointAddress;
+static void cdch_process_line_state_on_enum(tuh_xfer_t *xfer) {
+  cdch_interface_t *p_cdc = get_itf_by_xfer(xfer);
+  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT,);
+  if (xfer->result != XFER_RESULT_SUCCESS || !set_line_state_on_enum(p_cdc, xfer)) {
+    set_config_complete(p_cdc, false);
+  }
+}
 
-    p_desc = tu_desc_next(p_desc);
+
+static void cdch_internal_control_complete(tuh_xfer_t *xfer) {
+  cdch_interface_t *p_cdc = get_itf_by_xfer(xfer);
+  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT,);
+  TU_LOG_DRV("  request result = %u\r\n", xfer->result);
+  const cdch_serial_driver_t *driver = &serial_drivers[p_cdc->serial_drid];
+  driver->request_complete(p_cdc, xfer);
+
+  // Invoke application callback
+  xfer->complete_cb = p_cdc->user_complete_cb;
+  if (xfer->complete_cb != NULL) {
+    xfer->complete_cb(xfer);
   }
+}
 
-  //------------- Data Interface (if any) -------------//
-  if ((TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
-      (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const*) p_desc)->bInterfaceClass)) {
-    // next to endpoint descriptor
-    p_desc = tu_desc_next(p_desc);
+static void cdch_set_line_coding_stage1_baudrate_complete(tuh_xfer_t *xfer) {
+  cdch_interface_t *p_cdc = get_itf_by_xfer(xfer);
+  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT,);
+  TU_LOG_DRV("  stage1 set baudrate result = %u\r\n", xfer->result);
+  const cdch_serial_driver_t *driver = &serial_drivers[p_cdc->serial_drid];
 
-    // data endpoints expected to be in pairs
-    TU_ASSERT(open_ep_stream_pair(p_cdc, (tusb_desc_endpoint_t const*) p_desc));
+  if (xfer->result == XFER_RESULT_SUCCESS) {
+    p_cdc->line.coding.bit_rate = p_cdc->requested_line.coding.bit_rate; // update baudrate
+    TU_ASSERT(driver->set_data_format(p_cdc, cdch_set_line_coding_stage2_data_format_complete, xfer->user_data),);
+  } else {
+    xfer->complete_cb = p_cdc->user_complete_cb;
+    if (xfer->complete_cb != NULL) {
+      xfer->complete_cb(xfer);
+    }
   }
+}
 
-  return true;
+static void cdch_set_line_coding_stage2_data_format_complete(tuh_xfer_t *xfer) {
+  cdch_interface_t *p_cdc = get_itf_by_xfer(xfer);
+  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT,);
+  TU_LOG_DRV("  stage2 set data format result = %u\r\n", xfer->result);
+
+  if (xfer->result == XFER_RESULT_SUCCESS) {
+    p_cdc->line.coding = p_cdc->requested_line.coding; // update data format
+  }
+
+  xfer->complete_cb = p_cdc->user_complete_cb;
+  if (xfer->complete_cb != NULL) {
+    xfer->complete_cb(xfer);
+  }
 }
 
-static void acm_process_config(tuh_xfer_t* xfer) {
-  uintptr_t const state = xfer->user_data;
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc,);
+//--------------------------------------------------------------------+
+// ACM
+//--------------------------------------------------------------------+
 
-  switch (state) {
-    case CONFIG_ACM_SET_CONTROL_LINE_STATE:
-      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-      if (p_cdc->acm_capability.support_line_request) {
-        TU_ASSERT(acm_set_control_line_state(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, acm_process_config, CONFIG_ACM_SET_LINE_CODING),);
-        break;
-      }
-      #endif
-      TU_ATTR_FALLTHROUGH;
+// internal control complete to update state such as line state, encoding
+static void acm_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_VERIFY (xfer->result == XFER_RESULT_SUCCESS,);
+  const tusb_control_request_t * setup = xfer->setup;
 
-    case CONFIG_ACM_SET_LINE_CODING:
-      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      if (p_cdc->acm_capability.support_line_request) {
-        cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-        TU_ASSERT(acm_set_line_coding(p_cdc, &line_coding, acm_process_config, CONFIG_ACM_COMPLETE),);
-        break;
-      }
-      #endif
-      TU_ATTR_FALLTHROUGH;
+  switch (setup->bRequest) {
+    case CDC_REQUEST_SET_CONTROL_LINE_STATE:
+      p_cdc->line.control_state = p_cdc->requested_line.control_state;
+      break;
 
-    case CONFIG_ACM_COMPLETE:
-      // itf_num+1 to account for data interface as well
-      set_config_complete(p_cdc, idx, itf_num + 1);
+    case CDC_REQUEST_SET_LINE_CODING:
+      p_cdc->line.coding = p_cdc->requested_line.coding;
       break;
 
     default:
-      break;
+      break; // unknown request
   }
 }
 
-static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_VERIFY(p_cdc->acm_capability.support_line_request);
-  TU_LOG_DRV("CDC ACM Set Control Line State\r\n");
+static bool acm_set_control_line_state(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  TU_VERIFY(p_cdc->acm.capability.support_line_request != 0);
 
-  tusb_control_request_t const request = {
+  const tusb_control_request_t request = {
     .bmRequestType_bit = {
       .recipient = TUSB_REQ_RCPT_INTERFACE,
       .type      = TUSB_REQ_TYPE_CLASS,
       .direction = TUSB_DIR_OUT
     },
     .bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE,
-    .wValue   = tu_htole16(line_state),
+    .wValue   = tu_htole16((uint16_t) p_cdc->requested_line.control_state.value),
     .wIndex   = tu_htole16((uint16_t) p_cdc->bInterfaceNumber),
     .wLength  = 0
   };
 
-  p_cdc->user_control_cb = complete_cb;
-
   tuh_xfer_t xfer = {
     .daddr       = p_cdc->daddr,
     .ep_addr     = 0,
     .setup       = &request,
     .buffer      = NULL,
-    .complete_cb = complete_cb ? cdch_internal_control_complete : NULL, // complete_cb is NULL for sync call
+    .complete_cb = complete_cb,
     .user_data   = user_data
   };
 
-  TU_ASSERT(tuh_control_xfer(&xfer));
-  return true;
+  return tuh_control_xfer(&xfer);
 }
 
-static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC ACM Set Line Conding\r\n");
+static bool acm_set_line_coding(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  TU_VERIFY(p_cdc->acm.capability.support_line_request != 0);
+  TU_VERIFY((p_cdc->requested_line.coding.data_bits >= 5 && p_cdc->requested_line.coding.data_bits <= 8) ||
+            p_cdc->requested_line.coding.data_bits == 16);
 
   tusb_control_request_t const request = {
     .bmRequestType_bit = {
@@ -931,46 +986,93 @@ static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const
     },
     .bRequest = CDC_REQUEST_SET_LINE_CODING,
     .wValue   = 0,
-    .wIndex   = tu_htole16(p_cdc->bInterfaceNumber),
-    .wLength  = tu_htole16(sizeof(cdc_line_coding_t))
+    .wIndex   = tu_htole16((uint16_t) p_cdc->bInterfaceNumber),
+    .wLength  = tu_htole16((uint16_t) sizeof(cdc_line_coding_t))
   };
 
   // use usbh enum buf to hold line coding since user line_coding variable does not live long enough
-  uint8_t* enum_buf = usbh_get_enum_buf();
-  memcpy(enum_buf, line_coding, sizeof(cdc_line_coding_t));
+  uint8_t *enum_buf = usbh_get_enum_buf();
+  memcpy(enum_buf, &p_cdc->requested_line.coding, sizeof(cdc_line_coding_t));
 
-  p_cdc->user_control_cb = complete_cb;
   tuh_xfer_t xfer = {
     .daddr       = p_cdc->daddr,
     .ep_addr     = 0,
     .setup       = &request,
     .buffer      = enum_buf,
-    .complete_cb = complete_cb ? cdch_internal_control_complete : NULL, // complete_cb is NULL for sync call
+    .complete_cb = complete_cb,
     .user_data   = user_data
   };
 
-  TU_ASSERT(tuh_control_xfer(&xfer));
-  return true;
+  return tuh_control_xfer(&xfer);
 }
 
-static bool acm_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC ACM Set Data Format\r\n");
+//------------- Enumeration -------------//
+enum {
+  CONFIG_ACM_COMPLETE = 0
+};
+
+static bool acm_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+  uint8_t const *p_desc_end = ((uint8_t const *) itf_desc) + max_len;
+
+  cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
+
+  p_cdc->serial_drid = SERIAL_DRIVER_ACM;
 
-  cdc_line_coding_t line_coding;
-  line_coding.bit_rate = p_cdc->line_coding.bit_rate;
-  line_coding.stop_bits = stop_bits;
-  line_coding.parity = parity;
-  line_coding.data_bits = data_bits;
+  //------------- Control Interface -------------//
+  uint8_t const *p_desc = tu_desc_next(itf_desc);
+
+  // Communication Functional Descriptors
+  while ((p_desc < p_desc_end) && (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc))) {
+    if (CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc)) {
+      // save ACM bmCapabilities
+      p_cdc->acm.capability = ((cdc_desc_func_acm_t const *) p_desc)->bmCapabilities;
+    }
+
+    p_desc = tu_desc_next(p_desc);
+  }
 
-  return acm_set_line_coding(p_cdc, &line_coding, complete_cb, user_data);
+  // Open notification endpoint of control interface if any
+  if (itf_desc->bNumEndpoints == 1) {
+    TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc));
+    tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) p_desc;
+
+    TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
+    p_cdc->ep_notif = desc_ep->bEndpointAddress;
+
+    p_desc = tu_desc_next(p_desc);
+  }
+
+  //------------- Data Interface (if any) -------------//
+  if ((TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
+      (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass)) {
+    // next to endpoint descriptor
+    p_desc = tu_desc_next(p_desc);
+
+    // data endpoints expected to be in pairs
+    TU_ASSERT(open_ep_stream_pair(p_cdc, (tusb_desc_endpoint_t const *) p_desc));
+  }
+
+  return true;
 }
 
-static bool acm_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_VERIFY(p_cdc->acm_capability.support_line_request);
-  cdc_line_coding_t line_coding = p_cdc->line_coding;
-  line_coding.bit_rate = baudrate;
-  return acm_set_line_coding(p_cdc, &line_coding, complete_cb, user_data);
+static bool acm_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_ASSERT(xfer->result == XFER_RESULT_SUCCESS);
+  (void) p_cdc;
+  const uintptr_t state = xfer->user_data;
+
+  switch (state) {
+    case CONFIG_ACM_COMPLETE: {
+      xfer->user_data = 0; // kick-off set line state on enum
+      cdch_process_line_state_on_enum(xfer);
+      break;
+    }
+
+    default:
+      return false; // invalid state
+  }
+
+  return true;
 }
 
 //--------------------------------------------------------------------+
@@ -978,50 +1080,26 @@ static bool acm_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfe
 //--------------------------------------------------------------------+
 #if CFG_TUH_CDC_FTDI
 
-enum {
-  CONFIG_FTDI_RESET = 0,
-  CONFIG_FTDI_MODEM_CTRL,
-  CONFIG_FTDI_SET_BAUDRATE,
-  CONFIG_FTDI_SET_DATA,
-  CONFIG_FTDI_COMPLETE
-};
-
-static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
-  // FTDI Interface includes 1 vendor interface + 2 bulk endpoints
-  TU_VERIFY(itf_desc->bInterfaceSubClass == 0xff && itf_desc->bInterfaceProtocol == 0xff && itf_desc->bNumEndpoints == 2);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
-
-  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
-
-  TU_LOG_DRV("FTDI opened\r\n");
-  p_cdc->serial_drid = SERIAL_DRIVER_FTDI;
-
-  // endpoint pair
-  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+static bool ftdi_determine_type(cdch_interface_t *p_cdc);
+static uint32_t ftdi_get_divisor(cdch_interface_t *p_cdc);
 
-  // data endpoints expected to be in pairs
-  return open_ep_stream_pair(p_cdc, desc_ep);
-}
+//------------- Control Request -------------//
 
 // set request without data
-static bool ftdi_sio_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_t value, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  tusb_control_request_t const request = {
-    .bmRequestType_bit = {
-      .recipient = TUSB_REQ_RCPT_DEVICE,
-      .type      = TUSB_REQ_TYPE_VENDOR,
-      .direction = TUSB_DIR_OUT
-    },
-    .bRequest = command,
-    .wValue   = tu_htole16(value),
-    .wIndex   = 0,
-    .wLength  = 0
+static bool ftdi_set_request(cdch_interface_t *p_cdc, uint8_t request, uint8_t requesttype,
+                             uint16_t value, uint16_t index, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  tusb_control_request_t const request_setup = {
+    .bmRequestType = requesttype,
+    .bRequest      = request,
+    .wValue        = tu_htole16(value),
+    .wIndex        = tu_htole16(index),
+    .wLength       = 0
   };
 
   tuh_xfer_t xfer = {
     .daddr       = p_cdc->daddr,
     .ep_addr     = 0,
-    .setup       = &request,
+    .setup       = &request_setup,
     .buffer      = NULL,
     .complete_cb = complete_cb,
     .user_data   = user_data
@@ -1030,162 +1108,382 @@ static bool ftdi_sio_set_request(cdch_interface_t* p_cdc, uint8_t command, uint1
   return tuh_control_xfer(&xfer);
 }
 
-static bool ftdi_sio_reset(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  return ftdi_sio_set_request(p_cdc, FTDI_SIO_RESET, FTDI_SIO_RESET_SIO, complete_cb, user_data);
+#ifdef CFG_TUH_CDC_FTDI_LATENCY
+static int8_t ftdi_write_latency_timer(cdch_interface_t * p_cdc, uint16_t latency,
+                                       tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  if (p_cdc->ftdi.chip_type == FTDI_SIO /* || p_cdc->ftdi.chip_type == FT232A */ )
+    return FTDI_NOT_POSSIBLE;
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_LATENCY_TIMER_REQUEST, FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
+                          latency, p_cdc->ftdi.channel, complete_cb, user_data) ? FTDI_REQUESTED : FTDI_FAIL;
 }
+#endif
 
-static bool ftdi_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                 tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  (void) p_cdc;
-  (void) stop_bits;
-  (void) parity;
-  (void) data_bits;
-  (void) complete_cb;
-  (void) user_data;
-  // TODO not implemented yet
-  return false;
+static inline bool ftdi_sio_reset(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  return ftdi_set_request(p_cdc, FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE, FTDI_SIO_RESET_SIO,
+                          p_cdc->ftdi.channel, complete_cb, user_data);
 }
 
-static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  (void) p_cdc;
-  (void) line_coding;
-  (void) complete_cb;
-  (void) user_data;
-  // TODO not implemented yet
-  return false;
-}
 
-static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC FTDI Set Control Line State\r\n");
-  p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_MODEM_CTRL, 0x0300 | line_state,
-                                 complete_cb ? cdch_internal_control_complete : NULL, user_data));
-  return true;
-}
+//------------- Driver API -------------//
 
-static uint32_t ftdi_232bm_baud_base_to_divisor(uint32_t baud, uint32_t base) {
-  const uint8_t divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
-  uint32_t divisor;
+// internal control complete to update state such as line state, line_coding
+static void ftdi_internal_control_complete(cdch_interface_t* p_cdc, tuh_xfer_t *xfer) {
+  const tusb_control_request_t * setup = xfer->setup;
+  if (xfer->result == XFER_RESULT_SUCCESS) {
+    if (setup->bRequest      == FTDI_SIO_SET_MODEM_CTRL_REQUEST &&
+        setup->bmRequestType == FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE ) {
+      p_cdc->line.control_state = p_cdc->requested_line.control_state;
+    }
+    if (setup->bRequest      == FTDI_SIO_SET_DATA_REQUEST &&
+        setup->bmRequestType == FTDI_SIO_SET_DATA_REQUEST_TYPE ) {
+      p_cdc->line.coding.stop_bits = p_cdc->requested_line.coding.stop_bits;
+      p_cdc->line.coding.parity    = p_cdc->requested_line.coding.parity;
+      p_cdc->line.coding.data_bits = p_cdc->requested_line.coding.data_bits;
+    }
+    if (setup->bRequest      == FTDI_SIO_SET_BAUDRATE_REQUEST &&
+        setup->bmRequestType == FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE ) {
+      p_cdc->line.coding.bit_rate = p_cdc->requested_line.coding.bit_rate;
+    }
+  }
+}
 
-  /* divisor shifted 3 bits to the left */
-  uint32_t divisor3 = base / (2 * baud);
-  divisor = (divisor3 >> 3);
-  divisor |= (uint32_t) divfrac[divisor3 & 0x7] << 14;
+static bool ftdi_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  TU_VERIFY(p_cdc->requested_line.coding.data_bits >= 7 && p_cdc->requested_line.coding.data_bits <= 8, 0);
+  uint16_t value = (uint16_t) ((p_cdc->requested_line.coding.data_bits & 0xfUL) |       // data bit quantity is stored in bits 0-3
+                               (p_cdc->requested_line.coding.parity    & 0x7UL) << 8 |  // parity is stored in bits 8-10, same coding
+                               (p_cdc->requested_line.coding.stop_bits & 0x3UL) << 11); // stop bits quantity is stored in bits 11-12, same coding
+                                                                                        // not each FTDI supports 1.5 stop bits
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_DATA_REQUEST, FTDI_SIO_SET_DATA_REQUEST_TYPE,
+                          value, p_cdc->ftdi.channel, complete_cb, user_data);
+}
 
-  /* Deal with special cases for highest baud rates. */
-  if (divisor == 1) { /* 1.0 */
-    divisor = 0;
-  }
-  else if (divisor == 0x4001) { /* 1.5 */
-    divisor = 1;
+static bool ftdi_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint32_t index_value = ftdi_get_divisor(p_cdc);
+  TU_VERIFY(index_value != 0);
+  uint16_t value = (uint16_t) index_value;
+  uint16_t index = (uint16_t) (index_value >> 16);
+  if (p_cdc->ftdi.channel != 0) {
+    index = (uint16_t) ((index << 8) | p_cdc->ftdi.channel);
   }
 
-  return divisor;
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_BAUDRATE_REQUEST, FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
+                          value, index, complete_cb, user_data);
 }
 
-static uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud) {
-  return ftdi_232bm_baud_base_to_divisor(baud, 48000000u);
+static bool ftdi_set_modem_ctrl(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint16_t line_state = (uint16_t) ((p_cdc->requested_line.control_state.dtr ? FTDI_SIO_SET_DTR_HIGH : FTDI_SIO_SET_DTR_LOW) |
+                                    (p_cdc->requested_line.control_state.rts ? FTDI_SIO_SET_RTS_HIGH : FTDI_SIO_SET_RTS_LOW));
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_MODEM_CTRL_REQUEST, FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+                          line_state, p_cdc->ftdi.channel, complete_cb ? cdch_internal_control_complete : NULL, user_data);
 }
 
-static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(baudrate);
-  TU_LOG_DRV("CDC FTDI Set BaudRate = %" PRIu32 ", divisor = 0x%04x\r\n", baudrate, divisor);
+//------------- Enumeration -------------//
+enum {
+  CONFIG_FTDI_DETERMINE_TYPE = 0,
+  CONFIG_FTDI_WRITE_LATENCY,
+  CONFIG_FTDI_SIO_RESET,
+  CONFIG_FTDI_FLOW_CONTROL,
+  CONFIG_FTDI_COMPLETE
+};
 
-  p_cdc->user_control_cb = complete_cb;
-  p_cdc->requested_line_coding.bit_rate = baudrate;
-  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_SET_BAUD_RATE, divisor,
-                                 complete_cb ? cdch_internal_control_complete : NULL, user_data));
+static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
+  // FTDI Interface includes 1 vendor interface + 2 bulk endpoints
+  TU_VERIFY(itf_desc->bInterfaceSubClass == 0xff && itf_desc->bInterfaceProtocol == 0xff &&
+            itf_desc->bNumEndpoints == 2);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2 * sizeof(tusb_desc_endpoint_t) <= max_len);
 
-  return true;
-}
+  cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
 
-static void ftdi_process_config(tuh_xfer_t* xfer) {
-  uintptr_t const state = xfer->user_data;
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t * p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
+  p_cdc->serial_drid = SERIAL_DRIVER_FTDI;
 
-  switch(state) {
-    // Note may need to read FTDI eeprom
-    case CONFIG_FTDI_RESET:
-      TU_ASSERT(ftdi_sio_reset(p_cdc, ftdi_process_config, CONFIG_FTDI_MODEM_CTRL),);
-      break;
+  // endpoint pair
+  tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
 
-    case CONFIG_FTDI_MODEM_CTRL:
-      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-      TU_ASSERT(ftdi_sio_set_modem_ctrl(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, ftdi_process_config, CONFIG_FTDI_SET_BAUDRATE),);
-      break;
-      #else
+  /*
+   * NOTE: Some customers have programmed FT232R/FT245R devices
+   * with an endpoint size of 0 - not good.
+   */
+  TU_ASSERT(desc_ep->wMaxPacketSize != 0);
+
+  // data endpoints expected to be in pairs
+  return open_ep_stream_pair(p_cdc, desc_ep);
+}
+
+static bool ftdi_proccess_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_ASSERT(xfer->result == XFER_RESULT_SUCCESS);
+  const uintptr_t state = xfer->user_data;
+  switch (state) {
+    // from here sequence overtaken from Linux Kernel function ftdi_port_probe()
+    case CONFIG_FTDI_DETERMINE_TYPE:
+      // determine type
+      if (p_cdc->bInterfaceNumber == 0) {
+        TU_ASSERT(ftdi_determine_type(p_cdc));
+      } else {
+        // other interfaces have same type as interface 0
+        uint8_t const idx_itf0 = tuh_cdc_itf_get_index(xfer->daddr, 0);
+        cdch_interface_t const *p_cdc_itf0 = get_itf(idx_itf0);
+        TU_ASSERT(p_cdc_itf0);
+        p_cdc->ftdi.chip_type = p_cdc_itf0->ftdi.chip_type;
+      }
       TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_FTDI_WRITE_LATENCY:
+      #ifdef CFG_TUH_CDC_FTDI_LATENCY
+      int8_t result = ftdi_write_latency_timer(p_cdc, CFG_TUH_CDC_FTDI_LATENCY, ftdi_process_config,
+                                               CONFIG_FTDI_SIO_RESET);
+      TU_ASSERT(result != FTDI_FAIL);
+      if (result == FTDI_REQUESTED) {
+        break;
+      }// else FTDI_NOT_POSSIBLE => continue directly with next state
       #endif
+      TU_ATTR_FALLTHROUGH;
 
-    case CONFIG_FTDI_SET_BAUDRATE: {
-      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      TU_ASSERT(ftdi_sio_set_baudrate(p_cdc, line_coding.bit_rate, ftdi_process_config, CONFIG_FTDI_SET_DATA),);
+      // from here sequence overtaken from Linux Kernel function ftdi_open()
+    case CONFIG_FTDI_SIO_RESET:
+      TU_ASSERT(ftdi_sio_reset(p_cdc, cdch_process_set_config, CONFIG_FTDI_FLOW_CONTROL));
       break;
-      #else
-      TU_ATTR_FALLTHROUGH;
-      #endif
-    }
 
-    case CONFIG_FTDI_SET_DATA: {
-      #if 0 // TODO set data format
-      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      TU_ASSERT(ftdi_sio_set_data(p_cdc, process_ftdi_config, CONFIG_FTDI_COMPLETE),);
+    case CONFIG_FTDI_FLOW_CONTROL:
+      // disable flow control
+      TU_ASSERT(ftdi_set_request(p_cdc, FTDI_SIO_SET_FLOW_CTRL_REQUEST, FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE, FTDI_SIO_DISABLE_FLOW_CTRL,
+                                 p_cdc->ftdi.channel, cdch_process_set_config, CONFIG_FTDI_COMPLETE));
       break;
-      #endif
-      #endif
 
-      TU_ATTR_FALLTHROUGH;
+    case CONFIG_FTDI_COMPLETE: {
+      xfer->user_data = 0; // kick-off set line state on enum
+      cdch_process_line_state_on_enum(xfer);
+      break;
     }
 
-    case CONFIG_FTDI_COMPLETE:
-      set_config_complete(p_cdc, idx, itf_num);
+    default:
+      return false;
+  }
+
+  return true;
+}
+
+//------------- Helper -------------//
+
+static bool ftdi_determine_type(cdch_interface_t *p_cdc) {
+  tusb_desc_device_t desc_dev;
+  TU_VERIFY(tuh_descriptor_get_device_local(p_cdc->daddr, &desc_dev));
+  uint16_t const version = desc_dev.bcdDevice;
+  uint8_t const itf_num = p_cdc->bInterfaceNumber;
+
+  p_cdc->ftdi.chip_type = FTDI_UNKNOWN;
+
+  /* Assume Hi-Speed type */
+  p_cdc->ftdi.channel = CHANNEL_A + itf_num;
+
+  switch (version) {
+    case 0x200:
+      // FT232A not supported to keep it simple (no extra _read_latency_timer()) not testable
+      // p_cdc->ftdi.chip_type = FT232A;
+      // p_cdc->ftdi.baud_base = 48000000 / 2;
+      // p_cdc->ftdi.channel = 0;
+      // /*
+      //  * FT232B devices have a bug where bcdDevice gets set to 0x200
+      //  * when iSerialNumber is 0. Assume it is an FT232B in case the
+      //  * latency timer is readable.
+      //  */
+      // if (desc->iSerialNumber == 0 &&
+      //     _read_latency_timer(port) >= 0) {
+      //   p_cdc->ftdi.chip_type = FTDI_FT232B;
+      // }
       break;
 
+    case 0x400 : p_cdc->ftdi.chip_type = FTDI_FT232B; p_cdc->ftdi.channel = 0; break;
+    case 0x500 : p_cdc->ftdi.chip_type = FTDI_FT2232C; break;
+    case 0x600 : p_cdc->ftdi.chip_type = FTDI_FT232R; p_cdc->ftdi.channel = 0; break;
+    case 0x700 : p_cdc->ftdi.chip_type = FTDI_FT2232H; break;
+    case 0x800 : p_cdc->ftdi.chip_type = FTDI_FT4232H; break;
+    case 0x900 : p_cdc->ftdi.chip_type = FTDI_FT232H; break;
+    case 0x1000: p_cdc->ftdi.chip_type = FTDI_FTX; break;
+    case 0x2800: p_cdc->ftdi.chip_type = FTDI_FT2233HP; break;
+    case 0x2900: p_cdc->ftdi.chip_type = FTDI_FT4233HP; break;
+    case 0x3000: p_cdc->ftdi.chip_type = FTDI_FT2232HP; break;
+    case 0x3100: p_cdc->ftdi.chip_type = FTDI_FT4232HP; break;
+    case 0x3200: p_cdc->ftdi.chip_type = FTDI_FT233HP; break;
+    case 0x3300: p_cdc->ftdi.chip_type = FTDI_FT232HP; break;
+    case 0x3600: p_cdc->ftdi.chip_type = FTDI_FT4232HA; break;
+
     default:
+      if (version < 0x200) {
+        p_cdc->ftdi.chip_type = FTDI_SIO;
+        p_cdc->ftdi.channel = 0;
+      }
       break;
   }
+
+  #if CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+  const char * ftdi_chip_name[] = { FTDI_CHIP_NAMES };
+  TU_LOG_CDC(p_cdc, "%s detected (bcdDevice = 0x%04x)",
+               ftdi_chip_name[p_cdc->ftdi.chip_type], version);
+  #endif
+
+  return (p_cdc->ftdi.chip_type != FTDI_UNKNOWN);
 }
 
-#endif
+// FT232A not supported
+//static uint32_t ftdi_232am_baud_base_to_divisor(uint32_t baud, uint32_t base)
+//{
+//  uint32_t divisor;
+//  /* divisor shifted 3 bits to the left */
+//  uint32_t divisor3 = DIV_ROUND_CLOSEST(base, 2 * baud);
+//  if ((divisor3 & 0x7) == 7)
+//    divisor3++; /* round x.7/8 up to x+1 */
+//  divisor = divisor3 >> 3;
+//  divisor3 &= 0x7;
+//  if (divisor3 == 1)
+//    divisor |= 0xc000;  /* +0.125 */
+//  else if (divisor3 >= 4)
+//    divisor |= 0x4000;  /* +0.5 */
+//  else if (divisor3 != 0)
+//    divisor |= 0x8000;  /* +0.25 */
+//  else if (divisor == 1)
+//    divisor = 0;    /* special case for maximum baud rate */
+//  return divisor;
+//}
 
-//--------------------------------------------------------------------+
-// CP210x
-//--------------------------------------------------------------------+
+// FT232A not supported
+//static inline uint32_t ftdi_232am_baud_to_divisor(uint32_t baud)
+//{
+//   return ftdi_232am_baud_base_to_divisor(baud, (uint32_t) 48000000);
+//}
 
-#if CFG_TUH_CDC_CP210X
+static uint32_t ftdi_232bm_baud_base_to_divisor(uint32_t baud, uint32_t base) {
+  uint8_t divfrac[8] = {0, 3, 2, 4, 1, 5, 6, 7};
+  uint32_t divisor;
+  /* divisor shifted 3 bits to the left */
+  uint32_t divisor3 = tu_div_round_nearest(base, 2 * baud);
+  divisor = divisor3 >> 3;
+  divisor |= (uint32_t) divfrac[divisor3 & 0x7] << 14;
+  /* Deal with special cases for highest baud rates. */
+  if (divisor == 1) /* 1.0 */ {
+    divisor = 0;
+  } else if (divisor == 0x4001) /* 1.5 */ {
+    divisor = 1;
+  } else {
+    // nothing to do
+  }
+  return divisor;
+}
 
-enum {
-  CONFIG_CP210X_IFC_ENABLE = 0,
-  CONFIG_CP210X_SET_BAUDRATE,
-  CONFIG_CP210X_SET_LINE_CTL,
-  CONFIG_CP210X_SET_DTR_RTS,
-  CONFIG_CP210X_COMPLETE
-};
+static inline uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud) {
+  return ftdi_232bm_baud_base_to_divisor(baud, 48000000);
+}
 
-static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
-  // CP210x Interface includes 1 vendor interface + 2 bulk endpoints
-  TU_VERIFY(itf_desc->bInterfaceSubClass == 0 && itf_desc->bInterfaceProtocol == 0 && itf_desc->bNumEndpoints == 2);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
+static uint32_t ftdi_2232h_baud_base_to_divisor(uint32_t baud, uint32_t base) {
+  static const unsigned char divfrac[8] = {0, 3, 2, 4, 1, 5, 6, 7};
+  uint32_t divisor;
+  uint32_t divisor3;
 
-  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
+  /* hi-speed baud rate is 10-bit sampling instead of 16-bit */
+  divisor3 = tu_div_round_nearest(8 * base, 10 * baud);
 
-  TU_LOG_DRV("CP210x opened\r\n");
-  p_cdc->serial_drid = SERIAL_DRIVER_CP210X;
+  divisor = divisor3 >> 3;
+  divisor |= (uint32_t) divfrac[divisor3 & 0x7] << 14;
+  /* Deal with special cases for highest baud rates. */
+  if (divisor == 1) /* 1.0 */ {
+    divisor = 0;
+  } else if (divisor == 0x4001) /* 1.5 */ {
+    divisor = 1;
+  } else {
+    // nothing to do
+  }
 
-  // endpoint pair
-  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+  /* Set this bit to turn off a divide by 2.5 on baud rate generator
+   * This enables baud rates up to 12Mbaud but cannot reach below 1200
+   * baud with this bit set */
+  divisor |= 0x00020000;
+  return divisor;
+}
 
-  // data endpoints expected to be in pairs
-  return open_ep_stream_pair(p_cdc, desc_ep);
+static inline uint32_t ftdi_2232h_baud_to_divisor(uint32_t baud) {
+  return ftdi_2232h_baud_base_to_divisor(baud, (uint32_t) 120000000);
+}
+
+static inline uint32_t ftdi_get_divisor(cdch_interface_t *p_cdc) {
+  uint32_t baud = p_cdc->requested_line.coding.bit_rate;
+  uint32_t div_value = 0;
+  TU_VERIFY(baud != 0);
+
+  switch (p_cdc->ftdi.chip_type) {
+    case FTDI_UNKNOWN:
+      return 0;
+    case FTDI_SIO:
+      switch (baud) {
+        case 300: div_value = ftdi_sio_b300; break;
+        case 600: div_value = ftdi_sio_b600; break;
+        case 1200: div_value = ftdi_sio_b1200; break;
+        case 2400: div_value = ftdi_sio_b2400; break;
+        case 4800: div_value = ftdi_sio_b4800; break;
+        case 9600: div_value = ftdi_sio_b9600; break;
+        case 19200: div_value = ftdi_sio_b19200; break;
+        case 38400: div_value = ftdi_sio_b38400; break;
+        case 57600: div_value = ftdi_sio_b57600;  break;
+        case 115200: div_value = ftdi_sio_b115200; break;
+        default:
+          // Baudrate not supported
+          return 0;
+          break;
+      }
+      break;
+      // FT232A not supported
+      // case FT232A:
+      //   if (baud <= 3000000) {
+      //     div_value = ftdi_232am_baud_to_divisor(baud);
+      //   } else {
+      //     // Baud rate too high!
+      //     baud = 9600;
+      //     div_value = ftdi_232am_baud_to_divisor(9600);
+      //     div_okay = false;
+      //   }
+      //   break;
+    case FTDI_FT232B:
+    case FTDI_FT2232C:
+    case FTDI_FT232R:
+    case FTDI_FTX:
+      TU_VERIFY(baud <= 3000000); // else Baud rate too high!
+      div_value = ftdi_232bm_baud_to_divisor(baud);
+      break;
+    case FTDI_FT232H:
+    case FTDI_FT2232H:
+    case FTDI_FT4232H:
+    case FTDI_FT4232HA:
+    case FTDI_FT232HP:
+    case FTDI_FT233HP:
+    case FTDI_FT2232HP:
+    case FTDI_FT2233HP:
+    case FTDI_FT4232HP:
+    case FTDI_FT4233HP:
+    default:
+      TU_VERIFY(baud <= 12000000); // else Baud rate too high!
+      if (baud >= 1200) {
+        div_value = ftdi_2232h_baud_to_divisor(baud);
+      } else {
+        div_value = ftdi_232bm_baud_to_divisor(baud);
+      }
+      break;
+  }
+
+  TU_LOG_CDC(p_cdc, "Baudrate divisor = 0x%lu", div_value);
+
+  return div_value;
 }
 
-static bool cp210x_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_t value, uint8_t* buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+#endif
+
+//--------------------------------------------------------------------+
+// CP210x
+//--------------------------------------------------------------------+
+#if CFG_TUH_CDC_CP210X
+
+//------------- Control Request -------------//
+
+static bool cp210x_set_request(cdch_interface_t * p_cdc, uint8_t command, uint16_t value,
+                               uint8_t * buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   tusb_control_request_t const request = {
     .bmRequestType_bit = {
       .recipient = TUSB_REQ_RCPT_INTERFACE,
@@ -1194,12 +1492,12 @@ static bool cp210x_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_
     },
     .bRequest = command,
     .wValue   = tu_htole16(value),
-    .wIndex   = p_cdc->bInterfaceNumber,
+    .wIndex   = tu_htole16((uint16_t) p_cdc->bInterfaceNumber),
     .wLength  = tu_htole16(length)
   };
 
   // use usbh enum buf since application variable does not live long enough
-  uint8_t* enum_buf = NULL;
+  uint8_t * enum_buf = NULL;
 
   if (buffer && length > 0) {
     enum_buf = usbh_get_enum_buf();
@@ -1218,91 +1516,104 @@ static bool cp210x_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_
   return tuh_control_xfer(&xfer);
 }
 
-static bool cp210x_ifc_enable(cdch_interface_t* p_cdc, uint16_t enabled, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+TU_ATTR_ALWAYS_INLINE static inline bool cp210x_ifc_enable(cdch_interface_t *p_cdc, uint16_t enabled, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return cp210x_set_request(p_cdc, CP210X_IFC_ENABLE, enabled, NULL, 0, complete_cb, user_data);
 }
 
-static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  // TODO implement later
-  (void) p_cdc;
-  (void) line_coding;
-  (void) complete_cb;
-  (void) user_data;
-  return false;
+TU_ATTR_ALWAYS_INLINE static inline bool cp210x_set_mhs(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // CP210x has the same bit coding
+  return cp210x_set_request(p_cdc, CP210X_SET_MHS,
+                            (uint16_t) (CP210X_CONTROL_WRITE_DTR | CP210X_CONTROL_WRITE_RTS | p_cdc->requested_line.control_state.value),
+                            NULL, 0, complete_cb, user_data);
 }
 
-static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC CP210x Set BaudRate = %" PRIu32 "\r\n", baudrate);
-  uint32_t baud_le = tu_htole32(baudrate);
-  p_cdc->user_control_cb = complete_cb;
-  return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4,
-                            complete_cb ? cdch_internal_control_complete : NULL, user_data);
+//------------- Driver API -------------//
+
+// internal control complete to update state such as line state, encoding
+static void cp210x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_VERIFY(xfer->result == XFER_RESULT_SUCCESS,);
+  switch (xfer->setup->bRequest) {
+    case CP210X_SET_MHS:
+      p_cdc->line.control_state = p_cdc->requested_line.control_state;
+      break;
+
+    case CP210X_SET_LINE_CTL:
+      p_cdc->line.coding.stop_bits = p_cdc->requested_line.coding.stop_bits;
+      p_cdc->line.coding.parity    = p_cdc->requested_line.coding.parity;
+      p_cdc->line.coding.data_bits = p_cdc->requested_line.coding.data_bits;
+      break;
+
+    case CP210X_SET_BAUDRATE:
+      p_cdc->line.coding.bit_rate = p_cdc->requested_line.coding.bit_rate;
+      break;
+
+    default:
+      break; // unsupported request
+  }
 }
 
-static bool cp210x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                   tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  (void) p_cdc;
-  (void) stop_bits;
-  (void) parity;
-  (void) data_bits;
-  (void) complete_cb;
-  (void) user_data;
-  // TODO not implemented yet
-  return false;
+static bool cp210x_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // Not every baud rate is supported. See datasheets and AN205 "CP210x Baud Rate Support"
+  uint32_t baud_le = tu_htole32(p_cdc->requested_line.coding.bit_rate);
+  return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4, complete_cb, user_data);
 }
 
-static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC CP210x Set Control Line State\r\n");
-  p_cdc->user_control_cb = complete_cb;
-  return cp210x_set_request(p_cdc, CP210X_SET_MHS, 0x0300 | line_state, NULL, 0,
-                            complete_cb ? cdch_internal_control_complete : NULL, user_data);
+static bool cp210x_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  TU_VERIFY(p_cdc->requested_line.coding.data_bits >= 5 && p_cdc->requested_line.coding.data_bits <= 8, 0);
+  uint16_t lcr = (uint16_t) ((p_cdc->requested_line.coding.data_bits & 0xfUL) << 8 | // data bit quantity is stored in bits 8-11
+                             (p_cdc->requested_line.coding.parity    & 0xfUL) << 4 | // parity is stored in bits 4-7, same coding
+                             (p_cdc->requested_line.coding.stop_bits & 0xfUL));      // parity is stored in bits 0-3, same coding
+
+  return cp210x_set_request(p_cdc, CP210X_SET_LINE_CTL, lcr, NULL, 0, complete_cb, user_data);
 }
 
-static void cp210x_process_config(tuh_xfer_t* xfer) {
-  uintptr_t const state   = xfer->user_data;
-  uint8_t const   itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  uint8_t const   idx     = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t *p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc,);
+static bool cp210x_set_modem_ctrl(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  return cp210x_set_mhs(p_cdc, complete_cb, user_data);
+}
 
-  switch (state) {
-    case CONFIG_CP210X_IFC_ENABLE:
-      TU_ASSERT(cp210x_ifc_enable(p_cdc, 1, cp210x_process_config, CONFIG_CP210X_SET_BAUDRATE),);
-      break;
+//------------- Enumeration -------------//
 
-    case CONFIG_CP210X_SET_BAUDRATE: {
-      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      TU_ASSERT(cp210x_set_baudrate(p_cdc, line_coding.bit_rate, cp210x_process_config, CONFIG_CP210X_SET_LINE_CTL),);
-      break;
-      #else
-      TU_ATTR_FALLTHROUGH;
-      #endif
-    }
+enum {
+  CONFIG_CP210X_IFC_ENABLE = 0,
+  CONFIG_CP210X_COMPLETE
+};
 
-    case CONFIG_CP210X_SET_LINE_CTL: {
-      #if defined(CFG_TUH_CDC_LINE_CODING_ON_ENUM) && 0 // skip for now
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      break;
-      #else
-      TU_ATTR_FALLTHROUGH;
-      #endif
-    }
+static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+  // CP210x Interface includes 1 vendor interface + 2 bulk endpoints
+  TU_VERIFY(itf_desc->bInterfaceSubClass == 0 && itf_desc->bInterfaceProtocol == 0 && itf_desc->bNumEndpoints == 2);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2 * sizeof(tusb_desc_endpoint_t) <= max_len);
+
+  cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
+
+  p_cdc->serial_drid = SERIAL_DRIVER_CP210X;
+
+  // endpoint pair
+  tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+
+  // data endpoints expected to be in pairs
+  return open_ep_stream_pair(p_cdc, desc_ep);
+}
 
-    case CONFIG_CP210X_SET_DTR_RTS:
-      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-      TU_ASSERT(cp210x_set_modem_ctrl(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, cp210x_process_config, CONFIG_CP210X_COMPLETE),);
+static bool cp210x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_ASSERT(xfer->result == XFER_RESULT_SUCCESS);
+  const uintptr_t state = xfer->user_data;
+
+    switch (state) {
+    case CONFIG_CP210X_IFC_ENABLE:
+      TU_ASSERT(cp210x_ifc_enable(p_cdc, CP210X_UART_ENABLE, cdch_process_set_config, CONFIG_CP210X_COMPLETE));
       break;
-      #else
-      TU_ATTR_FALLTHROUGH;
-      #endif
 
     case CONFIG_CP210X_COMPLETE:
-      set_config_complete(p_cdc, idx, itf_num);
+      xfer->user_data = 0;// kick-off set line state on enum
+      cdch_process_line_state_on_enum(xfer);
       break;
 
-    default: break;
+    default:
+      return false;
   }
+
+  return true;
 }
 
 #endif
@@ -1313,13 +1624,14 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
 
 #if CFG_TUH_CDC_CH34X
 
-static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bits);
-static uint16_t ch34x_get_divisor_prescaler(uint32_t baval);
+static uint8_t ch34x_get_lcr(cdch_interface_t *p_cdc);
+static uint16_t ch34x_get_divisor_prescaler(cdch_interface_t *p_cdc);
 
-//------------- control request -------------//
+//------------- Control Request -------------//
 
-static bool ch34x_set_request(cdch_interface_t* p_cdc, uint8_t direction, uint8_t request, uint16_t value,
-                              uint16_t index, uint8_t* buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ch34x_set_request(cdch_interface_t *p_cdc, uint8_t direction, uint8_t request,
+                              uint16_t value, uint16_t index, uint8_t *buffer, uint16_t length,
+                              tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   tusb_control_request_t const request_setup = {
       .bmRequestType_bit = {
           .recipient = TUSB_REQ_RCPT_DEVICE,
@@ -1327,13 +1639,13 @@ static bool ch34x_set_request(cdch_interface_t* p_cdc, uint8_t direction, uint8_
           .direction = direction & 0x01u
       },
       .bRequest = request,
-      .wValue   = tu_htole16 (value),
-      .wIndex   = tu_htole16 (index),
-      .wLength  = tu_htole16 (length)
+      .wValue   = tu_htole16(value),
+      .wIndex   = tu_htole16(index),
+      .wLength  = tu_htole16(length)
   };
 
   // use usbh enum buf since application variable does not live long enough
-  uint8_t* enum_buf = NULL;
+  uint8_t *enum_buf = NULL;
 
   if (buffer && length > 0) {
     enum_buf = usbh_get_enum_buf();
@@ -1354,164 +1666,103 @@ static bool ch34x_set_request(cdch_interface_t* p_cdc, uint8_t direction, uint8_
   return tuh_control_xfer(&xfer);
 }
 
-static inline bool ch34x_control_out(cdch_interface_t* p_cdc, uint8_t request, uint16_t value, uint16_t index,
-                                     tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+TU_ATTR_ALWAYS_INLINE static inline bool ch34x_control_out(cdch_interface_t *p_cdc, uint8_t request, uint16_t value, uint16_t index,
+                                                           tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return ch34x_set_request(p_cdc, TUSB_DIR_OUT, request, value, index, NULL, 0, complete_cb, user_data);
 }
 
-static inline bool ch34x_control_in(cdch_interface_t* p_cdc, uint8_t request, uint16_t value, uint16_t index,
-                                    uint8_t* buffer, uint16_t buffersize, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+TU_ATTR_ALWAYS_INLINE static inline bool ch34x_control_in(cdch_interface_t *p_cdc, uint8_t request, uint16_t value, uint16_t index,
+                                                          uint8_t *buffer, uint16_t buffersize, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return ch34x_set_request(p_cdc, TUSB_DIR_IN, request, value, index, buffer, buffersize,
                            complete_cb, user_data);
 }
 
-static inline bool ch34x_write_reg(cdch_interface_t* p_cdc, uint16_t reg, uint16_t reg_value, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+TU_ATTR_ALWAYS_INLINE static inline bool ch34x_write_reg(cdch_interface_t *p_cdc, uint16_t reg, uint16_t reg_value,
+                                                         tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return ch34x_control_out(p_cdc, CH34X_REQ_WRITE_REG, reg, reg_value, complete_cb, user_data);
 }
 
-//static bool ch34x_read_reg_request ( cdch_interface_t* p_cdc, uint16_t reg,
+//static bool ch34x_read_reg_request ( cdch_interface_t * p_cdc, uint16_t reg,
 //                                     uint8_t *buffer, uint16_t buffersize, tuh_xfer_cb_t complete_cb, uintptr_t user_data )
 //{
 //  return ch34x_control_in ( p_cdc, CH34X_REQ_READ_REG, reg, 0, buffer, buffersize, complete_cb, user_data );
 //}
 
-static bool ch34x_write_reg_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate,
-                                     tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint16_t const div_ps = ch34x_get_divisor_prescaler(baudrate);
-  TU_VERIFY(div_ps);
-  TU_ASSERT(ch34x_write_reg(p_cdc, CH34X_REG16_DIVISOR_PRESCALER, div_ps,
-                            complete_cb, user_data));
-  return true;
-}
-
 //------------- Driver API -------------//
 
 // internal control complete to update state such as line state, encoding
-static void ch34x_control_complete(tuh_xfer_t* xfer) {
-  // CH34x only has 1 interface and use wIndex as payload and not for bInterfaceNumber
-  process_internal_control_complete(xfer, 0);
-}
-
-static bool ch34x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  p_cdc->requested_line_coding.stop_bits = stop_bits;
-  p_cdc->requested_line_coding.parity = parity;
-  p_cdc->requested_line_coding.data_bits = data_bits;
+static void ch34x_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_VERIFY(xfer->result == XFER_RESULT_SUCCESS,);
+  switch (xfer->setup->bRequest) {
+    case CH34X_REQ_WRITE_REG:
+      // register write request
+      switch (tu_le16toh(xfer->setup->wValue)) {
+        case CH34X_REG16_DIVISOR_PRESCALER:
+          // baudrate
+          p_cdc->line.coding.bit_rate = p_cdc->requested_line.coding.bit_rate;
+          break;
 
-  uint8_t const lcr = ch34x_get_lcr(stop_bits, parity, data_bits);
-  TU_VERIFY(lcr);
-  TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_WRITE_REG, CH32X_REG16_LCR2_LCR, lcr,
-                               complete_cb ? ch34x_control_complete : NULL, user_data));
-  return true;
-}
+        case CH32X_REG16_LCR2_LCR:
+          // data format
+          p_cdc->line.coding.stop_bits = p_cdc->requested_line.coding.stop_bits;
+          p_cdc->line.coding.parity    = p_cdc->requested_line.coding.parity;
+          p_cdc->line.coding.data_bits = p_cdc->requested_line.coding.data_bits;
+          break;
 
-static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate,
-                               tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  p_cdc->requested_line_coding.bit_rate = baudrate;
-  p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, baudrate,
-                                     complete_cb ? ch34x_control_complete : NULL, user_data));
-  return true;
-}
+        default:
+          break; // unsupported
+      }
+      break;
 
-static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t* xfer) {
-  // CH34x only has 1 interface and use wIndex as payload and not for bInterfaceNumber
-  uint8_t const itf_num = 0;
-  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
+    case CH34X_REQ_MODEM_CTRL:
+      p_cdc->line.control_state = p_cdc->requested_line.control_state;
+      break;
 
-  if (xfer->result == XFER_RESULT_SUCCESS) {
-    // stage 1 success, continue to stage 2
-    p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-    TU_ASSERT(ch34x_set_data_format(p_cdc, p_cdc->requested_line_coding.stop_bits, p_cdc->requested_line_coding.parity,
-                                    p_cdc->requested_line_coding.data_bits, ch34x_control_complete, xfer->user_data), );
-  } else {
-    // stage 1 failed, notify user
-    xfer->complete_cb = p_cdc->user_control_cb;
-    if (xfer->complete_cb) {
-      xfer->complete_cb(xfer);
-    }
+    default:
+      break; // unsupported request
   }
 }
 
-// 2 stages: set baudrate (stage1) + set data format (stage2)
-static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding,
-                                  tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  p_cdc->requested_line_coding = *line_coding;
-  p_cdc->user_control_cb = complete_cb;
-
-  if (complete_cb) {
-    // stage 1 set baudrate
-    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, line_coding->bit_rate,
-                                       ch34x_set_line_coding_stage1_complete, user_data));
-  } else {
-    // sync call
-    xfer_result_t result;
-
-    // stage 1 set baudrate
-    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, line_coding->bit_rate, NULL, (uintptr_t) &result));
-    TU_VERIFY(result == XFER_RESULT_SUCCESS);
-    p_cdc->line_coding.bit_rate = line_coding->bit_rate;
-
-    // stage 2 set data format
-    TU_ASSERT(ch34x_set_data_format(p_cdc, line_coding->stop_bits, line_coding->parity, line_coding->data_bits,
-                                    NULL, (uintptr_t) &result));
-    TU_VERIFY(result == XFER_RESULT_SUCCESS);
-    p_cdc->line_coding.stop_bits = line_coding->stop_bits;
-    p_cdc->line_coding.parity = line_coding->parity;
-    p_cdc->line_coding.data_bits = line_coding->data_bits;
-
-    // update transfer result, user_data is expected to point to xfer_result_t
-    if (user_data) {
-      *((xfer_result_t*) user_data) = result;
-    }
-  }
-
-  return true;
+static bool ch34x_set_data_format(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  const uint8_t lcr = ch34x_get_lcr(p_cdc);
+  TU_VERIFY(lcr > 0);
+  return ch34x_write_reg(p_cdc, CH32X_REG16_LCR2_LCR, lcr, complete_cb, user_data);
 }
 
-static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state,
-                                 tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint8_t control = 0;
-  if (line_state & CDC_CONTROL_LINE_STATE_RTS) {
-    control |= CH34X_BIT_RTS;
-  }
-  if (line_state & CDC_CONTROL_LINE_STATE_DTR) {
-    control |= CH34X_BIT_DTR;
-  }
+static bool ch34x_set_baudrate(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  const uint16_t div_ps = ch34x_get_divisor_prescaler(p_cdc);
+  TU_VERIFY(div_ps > 0);
+  return ch34x_write_reg(p_cdc, CH34X_REG16_DIVISOR_PRESCALER, div_ps, complete_cb, user_data);
+}
 
+static bool ch34x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   // CH34x signals are inverted
-  control = ~control;
-
-  p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_MODEM_CTRL, control, 0,
-                               complete_cb ? ch34x_control_complete : NULL, user_data));
-  return true;
+  uint8_t control = ~((p_cdc->requested_line.control_state.rts ? CH34X_BIT_RTS : 0) |
+                      (p_cdc->requested_line.control_state.dtr ? CH34X_BIT_DTR : 0));
+  return ch34x_control_out(p_cdc, CH34X_REQ_MODEM_CTRL, control, 0, complete_cb, user_data);
 }
 
 //------------- Enumeration -------------//
+
 enum {
   CONFIG_CH34X_READ_VERSION = 0,
   CONFIG_CH34X_SERIAL_INIT,
   CONFIG_CH34X_SPECIAL_REG_WRITE,
   CONFIG_CH34X_FLOW_CONTROL,
-  CONFIG_CH34X_MODEM_CONTROL,
   CONFIG_CH34X_COMPLETE
 };
 
-static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len) {
+static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len) {
   // CH34x Interface includes 1 vendor interface + 2 bulk + 1 interrupt endpoints
-  TU_VERIFY (itf_desc->bNumEndpoints == 3);
-  TU_VERIFY (sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
+  TU_VERIFY(itf_desc->bNumEndpoints == 3);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
 
-  cdch_interface_t* p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY (p_cdc);
+  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
 
-  TU_LOG_DRV ("CH34x opened\r\n");
   p_cdc->serial_drid = SERIAL_DRIVER_CH34X;
 
-  tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) tu_desc_next(itf_desc);
+  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
 
   // data endpoints expected to be in pairs
   TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep));
@@ -1526,69 +1777,66 @@ static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uin
   return true;
 }
 
-static void ch34x_process_config(tuh_xfer_t* xfer) {
-  // CH34x only has 1 interface and use wIndex as payload and not for bInterfaceNumber
-  uint8_t const itf_num = 0;
-  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  uintptr_t const state = xfer->user_data;
-  uint8_t buffer[2]; // TODO remove
-  TU_ASSERT (p_cdc,);
-  TU_ASSERT (xfer->result == XFER_RESULT_SUCCESS,);
+static bool ch34x_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_ASSERT(xfer->result == XFER_RESULT_SUCCESS);
+  const uintptr_t state = xfer->user_data;
 
   switch (state) {
-    case CONFIG_CH34X_READ_VERSION:
-      TU_LOG_DRV("[%u] CDCh CH34x attempt to read Chip Version\r\n", p_cdc->daddr);
-      TU_ASSERT (ch34x_control_in(p_cdc, CH34X_REQ_READ_VERSION, 0, 0, buffer, 2, ch34x_process_config, CONFIG_CH34X_SERIAL_INIT),);
+    case CONFIG_CH34X_READ_VERSION: {
+      uint8_t* enum_buf = usbh_get_enum_buf();
+      TU_ASSERT(ch34x_control_in(p_cdc, CH34X_REQ_READ_VERSION, 0, 0, enum_buf, 2,
+                                 cdch_process_set_config, CONFIG_CH34X_SERIAL_INIT));
       break;
+    }
 
     case CONFIG_CH34X_SERIAL_INIT: {
       // handle version read data, set CH34x line coding (incl. baudrate)
       uint8_t const version = xfer->buffer[0];
-      TU_LOG_DRV("[%u] CDCh CH34x Chip Version = %02x\r\n", p_cdc->daddr, version);
-      // only versions >= 0x30 are tested, below 0x30 seems having other programming, see drivers from WCH vendor, Linux kernel and FreeBSD
-      TU_ASSERT (version >= 0x30,);
-      // init CH34x with line coding
-      cdc_line_coding_t const line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
-      uint16_t const div_ps = ch34x_get_divisor_prescaler(line_coding.bit_rate);
-      TU_ASSERT(div_ps, );
-      uint8_t const lcr = ch34x_get_lcr(line_coding.stop_bits, line_coding.parity, line_coding.data_bits);
-      TU_ASSERT(lcr, );
-      TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_SERIAL_INIT, tu_u16(lcr, 0x9c), div_ps,
-                                   ch34x_process_config, CONFIG_CH34X_SPECIAL_REG_WRITE),);
+      TU_LOG_CDC(p_cdc, "Chip Version = 0x%02x", version);
+      // only versions >= 0x30 are tested, below 0x30 seems having other programming
+      // see drivers from WCH vendor, Linux kernel and FreeBSD
+      if (version >= 0x30) {
+        // init CH34x with line coding
+        p_cdc->requested_line.coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
+        uint16_t const div_ps = ch34x_get_divisor_prescaler(p_cdc);
+        uint8_t const lcr = ch34x_get_lcr(p_cdc);
+        TU_ASSERT(div_ps != 0 && lcr != 0);
+        TU_ASSERT(ch34x_control_out(p_cdc, CH34X_REQ_SERIAL_INIT, tu_u16(lcr, 0x9c), div_ps,
+                                    cdch_process_set_config, CONFIG_CH34X_SPECIAL_REG_WRITE));
+      }
       break;
     }
 
     case CONFIG_CH34X_SPECIAL_REG_WRITE:
       // overtake line coding and do special reg write, purpose unknown, overtaken from WCH driver
-      p_cdc->line_coding = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X);
-      TU_ASSERT (ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x0F, CH341_REG_0x2C), 0x0007, ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL),);
+      p_cdc->line.coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
+      TU_ASSERT(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x0F, CH341_REG_0x2C), 0x0007,
+                                cdch_process_set_config, CONFIG_CH34X_FLOW_CONTROL));
       break;
 
     case CONFIG_CH34X_FLOW_CONTROL:
       // no hardware flow control
-      TU_ASSERT (ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x27, CH341_REG_0x27), 0x0000, ch34x_process_config, CONFIG_CH34X_MODEM_CONTROL),);
-      break;
-
-    case CONFIG_CH34X_MODEM_CONTROL:
-      // !always! set modem controls RTS/DTR (CH34x has no reset state after CH34X_REQ_SERIAL_INIT)
-      TU_ASSERT (ch34x_set_modem_ctrl(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, ch34x_process_config, CONFIG_CH34X_COMPLETE),);
+      TU_ASSERT(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x27, CH341_REG_0x27), 0x0000,
+                                cdch_process_set_config, CONFIG_CH34X_COMPLETE));
       break;
 
     case CONFIG_CH34X_COMPLETE:
-      set_config_complete(p_cdc, idx, itf_num);
+      xfer->user_data = 0; // kick-off set line state on enum
+      cdch_process_line_state_on_enum(xfer);
       break;
 
     default:
-      TU_ASSERT (false,);
-      break;
+      return false;
   }
+
+  return true;
 }
 
-//------------- CH34x helper  -------------//
+//------------- Helper -------------//
 
 // calculate divisor and prescaler for baudrate, return it as 16-bit combined value
-static uint16_t ch34x_get_divisor_prescaler(uint32_t baval) {
+static uint16_t ch34x_get_divisor_prescaler(cdch_interface_t *p_cdc) {
+  uint32_t const baval = p_cdc->requested_line.coding.bit_rate;
   uint8_t a;
   uint8_t b;
   uint32_t c;
@@ -1633,16 +1881,20 @@ static uint16_t ch34x_get_divisor_prescaler(uint32_t baval) {
   // reg divisor = a, reg prescaler = b
   // According to linux code we need to set bit 7 of UCHCOM_REG_BPS_PRE,
   // otherwise the chip will buffer data.
-  return (uint16_t) ((uint16_t)a << 8 | 0x80 | b);
+  return (uint16_t) ((uint16_t) a << 8 | 0x80 | b);
 }
 
 // calculate lcr value from data coding
-static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bits) {
+static uint8_t ch34x_get_lcr(cdch_interface_t *p_cdc) {
+  uint8_t const stop_bits = p_cdc->requested_line.coding.stop_bits;
+  uint8_t const parity = p_cdc->requested_line.coding.parity;
+  uint8_t const data_bits = p_cdc->requested_line.coding.data_bits;
+
   uint8_t lcr = CH34X_LCR_ENABLE_RX | CH34X_LCR_ENABLE_TX;
-  TU_VERIFY(data_bits >= 5 && data_bits <= 8, 0);
+  TU_VERIFY(data_bits >= 5 && data_bits <= 8);
   lcr |= (uint8_t) (data_bits - 5);
 
-  switch(parity) {
+  switch (parity) {
     case CDC_LINE_CODING_PARITY_NONE:
       break;
 
@@ -1662,11 +1914,12 @@ static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bit
       lcr |= CH34X_LCR_ENABLE_PAR | CH34X_LCR_MARK_SPACE | CH34X_LCR_PAR_EVEN;
       break;
 
-    default: break;
+    default:
+      break; // invalid parity
   }
 
   // 1.5 stop bits not supported
-  TU_VERIFY(stop_bits != CDC_LINE_CODING_STOP_BITS_1_5, 0);
+  TU_VERIFY(stop_bits != CDC_LINE_CODING_STOP_BITS_1_5);
   if (stop_bits == CDC_LINE_CODING_STOP_BITS_2) {
     lcr |= CH34X_LCR_STOP_BITS_2;
   }
@@ -1674,7 +1927,616 @@ static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bit
   return lcr;
 }
 
-
 #endif // CFG_TUH_CDC_CH34X
 
+//--------------------------------------------------------------------+
+// PL2303
+//--------------------------------------------------------------------+
+#if CFG_TUH_CDC_PL2303
+
+static pl2303_type_t pl2303_detect_type(cdch_interface_t *p_cdc, uint8_t step);
+static bool pl2303_encode_baud_rate(cdch_interface_t *p_cdc, uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE]);
+
+//------------- Control Request -------------//
+static bool pl2303_set_request(cdch_interface_t *p_cdc, uint8_t request, uint8_t requesttype,
+                               uint16_t value, uint16_t index, uint8_t *buffer, uint16_t length,
+                               tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  tusb_control_request_t const request_setup = {
+    .bmRequestType = requesttype,
+    .bRequest      = request,
+    .wValue        = tu_htole16(value),
+    .wIndex        = tu_htole16(index),
+    .wLength       = tu_htole16(length)
+  };
+
+  // use usbh enum buf since application variable does not live long enough
+  uint8_t *enum_buf = NULL;
+
+  if (buffer && length > 0) {
+    enum_buf = usbh_get_enum_buf();
+    if (request_setup.bmRequestType_bit.direction == TUSB_DIR_OUT) {
+      tu_memcpy_s(enum_buf, CFG_TUH_ENUMERATION_BUFSIZE, buffer, length);
+    }
+  }
+
+  tuh_xfer_t xfer = {
+    .daddr       = p_cdc->daddr,
+    .ep_addr     = 0,
+    .setup       = &request_setup,
+    .buffer      = enum_buf,
+    .complete_cb = complete_cb,
+    .user_data   = user_data
+  };
+
+  return tuh_control_xfer(&xfer);
+}
+
+static bool pl2303_vendor_read(cdch_interface_t *p_cdc, uint16_t value, uint8_t *buf,
+                               tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint8_t request = p_cdc->pl2303.type == PL2303_TYPE_HXN ? PL2303_VENDOR_READ_NREQUEST : PL2303_VENDOR_READ_REQUEST;
+  return pl2303_set_request(p_cdc, request, PL2303_VENDOR_READ_REQUEST_TYPE, value, 0, buf, 1, complete_cb, user_data);
+}
+
+static bool pl2303_vendor_write(cdch_interface_t *p_cdc, uint16_t value, uint16_t index,
+                                tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint8_t request = p_cdc->pl2303.type == PL2303_TYPE_HXN ? PL2303_VENDOR_WRITE_NREQUEST : PL2303_VENDOR_WRITE_REQUEST;
+  return pl2303_set_request(p_cdc, request, PL2303_VENDOR_WRITE_REQUEST_TYPE, value, index, NULL, 0, complete_cb, user_data);
+}
+
+static inline bool pl2303_supports_hx_status(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint8_t buf = 0;
+  return pl2303_set_request(p_cdc, PL2303_VENDOR_READ_REQUEST, PL2303_VENDOR_READ_REQUEST_TYPE, PL2303_READ_TYPE_HX_STATUS, 0,
+                            &buf, 1, complete_cb, user_data);
+}
+
+//static bool pl2303_get_line_request(cdch_interface_t * p_cdc, uint8_t buf[PL2303_LINE_CODING_BUFSIZE]) {
+//  return pl2303_set_request(p_cdc, PL2303_GET_LINE_REQUEST, PL2303_GET_LINE_REQUEST_TYPE, 0, 0, buf, PL2303_LINE_CODING_BUFSIZE);
+//}
+
+//static bool pl2303_set_break(cdch_interface_t * p_cdc, bool enable) {
+//  uint16_t state = enable ? PL2303_BREAK_ON : PL2303_BREAK_OFF;
+//  return pl2303_set_request(p_cdc, PL2303_BREAK_REQUEST, PL2303_BREAK_REQUEST_TYPE, state, 0, NULL, 0);
+//}
+
+static inline bool
+pl2303_clear_halt(cdch_interface_t *p_cdc, uint8_t endp, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  /* we don't care if it wasn't halted first. in fact some devices
+   * (like some ibmcam model 1 units) seem to expect hosts to make
+   * this request for iso endpoints, which can't halt!
+   */
+  return pl2303_set_request(
+      p_cdc, TUSB_REQ_CLEAR_FEATURE, PL2303_CLEAR_HALT_REQUEST_TYPE, TUSB_REQ_FEATURE_EDPT_HALT, endp, NULL, 0,
+      complete_cb, user_data);
+}
+
+//------------- Driver API -------------//
+
+// internal control complete to update state such as line state, encoding
+static void pl2303_internal_control_complete(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  TU_VERIFY(xfer->result == XFER_RESULT_SUCCESS,);
+  if (xfer->setup->bRequest == PL2303_SET_LINE_REQUEST &&
+      xfer->setup->bmRequestType == PL2303_SET_LINE_REQUEST_TYPE) {
+    p_cdc->line.coding = p_cdc->requested_line.coding;
+  }
+  if (xfer->setup->bRequest == PL2303_SET_CONTROL_REQUEST &&
+      xfer->setup->bmRequestType == PL2303_SET_CONTROL_REQUEST_TYPE) {
+    p_cdc->line.control_state = p_cdc->requested_line.control_state;
+  }
+}
+
+static bool pl2303_set_line_coding(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // the caller has to precheck, that the new line coding different than the current, else false returned
+  uint8_t buf[PL2303_LINE_CODING_BUFSIZE];
+  /*
+   * Some PL2303 are known to lose bytes if you change serial settings
+   * even to the same values as before. Thus we actually need to filter
+   * in this specific case.
+   */
+  TU_VERIFY(p_cdc->requested_line.coding.data_bits != p_cdc->line.coding.data_bits ||
+            p_cdc->requested_line.coding.stop_bits != p_cdc->line.coding.stop_bits ||
+            p_cdc->requested_line.coding.parity    != p_cdc->line.coding.parity    ||
+            p_cdc->requested_line.coding.bit_rate  != p_cdc->line.coding.bit_rate );
+
+  /* For reference buf[6] data bits value */
+  TU_VERIFY(p_cdc->requested_line.coding.data_bits >= 5 && p_cdc->requested_line.coding.data_bits <= 8, 0);
+  buf[6] = p_cdc->requested_line.coding.data_bits;
+
+  /* For reference buf[0]:buf[3] baud rate value */
+  TU_VERIFY(pl2303_encode_baud_rate(p_cdc, &buf[0]));
+
+  /* For reference buf[4]=0 is 1 stop bits */
+  /* For reference buf[4]=1 is 1.5 stop bits */
+  /* For reference buf[4]=2 is 2 stop bits */
+  buf[4] = p_cdc->requested_line.coding.stop_bits; // PL2303 has the same coding
+
+  /* For reference buf[5]=0 is none parity */
+  /* For reference buf[5]=1 is odd parity */
+  /* For reference buf[5]=2 is even parity */
+  /* For reference buf[5]=3 is mark parity */
+  /* For reference buf[5]=4 is space parity */
+  buf[5] = p_cdc->requested_line.coding.parity; // PL2303 has the same coding
+
+  return pl2303_set_request(p_cdc, PL2303_SET_LINE_REQUEST, PL2303_SET_LINE_REQUEST_TYPE, 0, 0,
+                            buf, PL2303_LINE_CODING_BUFSIZE, complete_cb, user_data);
+}
+
+static bool pl2303_set_modem_ctrl(cdch_interface_t *p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // PL2303 has the same bit coding
+  return pl2303_set_request(p_cdc, PL2303_SET_CONTROL_REQUEST, PL2303_SET_CONTROL_REQUEST_TYPE,
+                            p_cdc->requested_line.control_state.value, 0, NULL, 0, complete_cb, user_data);
+}
+
+//------------- Enumeration -------------//
+
+enum {
+  CONFIG_PL2303_DETECT_TYPE = 0,
+  CONFIG_PL2303_READ1,
+  CONFIG_PL2303_WRITE1,
+  CONFIG_PL2303_READ2,
+  CONFIG_PL2303_READ3,
+  CONFIG_PL2303_READ4,
+  CONFIG_PL2303_WRITE2,
+  CONFIG_PL2303_READ5,
+  CONFIG_PL2303_READ6,
+  CONFIG_PL2303_WRITE3,
+  CONFIG_PL2303_WRITE4,
+  CONFIG_PL2303_WRITE5,
+  CONFIG_PL2303_RESET_ENDP1,
+  CONFIG_PL2303_RESET_ENDP2,
+//  CONFIG_PL2303_FLOW_CTRL_READ,
+//  CONFIG_PL2303_FLOW_CTRL_WRITE,
+  CONFIG_PL2303_COMPLETE
+};
+
+static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+  // PL2303 Interface includes 1 vendor interface + 1 interrupt endpoints + 2 bulk
+  TU_VERIFY(itf_desc->bNumEndpoints == 3);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
+
+  cdch_interface_t *p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
+
+  p_cdc->serial_drid = SERIAL_DRIVER_PL2303;
+  p_cdc->pl2303.quirks = 0;
+  p_cdc->pl2303.supports_hx_status = false;
+
+  tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+
+  // Interrupt endpoint: not used for now
+  TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(desc_ep) &&
+            TUSB_XFER_INTERRUPT == desc_ep->bmAttributes.xfer);
+  TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
+  p_cdc->ep_notif = desc_ep->bEndpointAddress;
+  desc_ep += 1;
+
+  // data endpoints expected to be in pairs
+  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep));
+
+  return true;
+}
+
+static bool pl2303_process_set_config(cdch_interface_t *p_cdc, tuh_xfer_t *xfer) {
+  // state CONFIG_PL2303_READ1 may have no success due to expected stall by pl2303_supports_hx_status()
+  const uintptr_t state = xfer->user_data;
+  TU_ASSERT(xfer->result == XFER_RESULT_SUCCESS || state == CONFIG_PL2303_READ1);
+  uint8_t* enum_buf = usbh_get_enum_buf();
+  pl2303_type_t type;
+
+  switch (state) {
+    // from here sequence overtaken from Linux Kernel function pl2303_startup()
+    case CONFIG_PL2303_DETECT_TYPE:
+      // get type and quirks (step 1)
+      type = pl2303_detect_type(p_cdc, 1);
+      TU_ASSERT(type != PL2303_TYPE_UNKNOWN);
+      if (type == PL2303_TYPE_NEED_SUPPORTS_HX_STATUS) {
+        TU_ASSERT(pl2303_supports_hx_status(p_cdc, cdch_process_set_config, CONFIG_PL2303_READ1));
+        break;
+      }
+      // no transfer triggered and continue with CONFIG_PL2303_READ1
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ1:
+      // get supports_hx_status, type and quirks (step 2), do special read
+      // will not be true, if coming directly from previous case
+      if (xfer->user_data == CONFIG_PL2303_READ1 && xfer->result == XFER_RESULT_SUCCESS) {
+        p_cdc->pl2303.supports_hx_status = true;
+      }
+      type = pl2303_detect_type(p_cdc, 2); // step 2 now with supports_hx_status
+      TU_ASSERT(type != PL2303_TYPE_UNKNOWN);
+      TU_LOG_DRV("  PL2303 type detected: %u\r\n", type);
+
+      p_cdc->pl2303.type = type;
+      p_cdc->pl2303.quirks |= pl2303_type_data[type].quirks;
+
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_read(p_cdc, 0x8484, enum_buf, cdch_process_set_config, CONFIG_PL2303_WRITE1));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE1:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_write(p_cdc, 0x0404, 0, cdch_process_set_config, CONFIG_PL2303_READ2));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ2:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_read(p_cdc, 0x8484, enum_buf, cdch_process_set_config, CONFIG_PL2303_READ3));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ3:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_read(p_cdc, 0x8383, enum_buf, cdch_process_set_config, CONFIG_PL2303_READ4));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ4:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_read(p_cdc, 0x8484, enum_buf, cdch_process_set_config, CONFIG_PL2303_WRITE2));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE2:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_write(p_cdc, 0x0404, 1, cdch_process_set_config, CONFIG_PL2303_READ5));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ5:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_read(p_cdc, 0x8484, enum_buf, cdch_process_set_config, CONFIG_PL2303_READ6));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ6:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_read(p_cdc, 0x8383, enum_buf, cdch_process_set_config, CONFIG_PL2303_WRITE3));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE3:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_write(p_cdc, 0, 1, cdch_process_set_config, CONFIG_PL2303_WRITE4));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE4:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        TU_ASSERT(pl2303_vendor_write(p_cdc, 1, 0, cdch_process_set_config, CONFIG_PL2303_WRITE5));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE5:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.type != PL2303_TYPE_HXN) {
+        uint16_t const windex = (p_cdc->pl2303.quirks & PL2303_QUIRK_LEGACY) ? 0x24 : 0x44;
+        TU_ASSERT(pl2303_vendor_write(p_cdc, 2, windex, cdch_process_set_config, CONFIG_PL2303_RESET_ENDP1));
+        break;
+      }// else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    // from here sequence overtaken from Linux Kernel function pl2303_open()
+    case CONFIG_PL2303_RESET_ENDP1:
+      // step 1
+      if (p_cdc->pl2303.quirks & PL2303_QUIRK_LEGACY) {
+        TU_ASSERT(pl2303_clear_halt(p_cdc, PL2303_OUT_EP, cdch_process_set_config, CONFIG_PL2303_RESET_ENDP2));
+      } else {
+        /* reset upstream data pipes */
+        if (p_cdc->pl2303.type == PL2303_TYPE_HXN) {
+          TU_ASSERT(pl2303_vendor_write(p_cdc, PL2303_HXN_RESET_REG,// skip CONFIG_PL2303_RESET_ENDP2, no 2nd step
+                                        PL2303_HXN_RESET_UPSTREAM_PIPE | PL2303_HXN_RESET_DOWNSTREAM_PIPE,
+                                        cdch_process_set_config, CONFIG_PL2303_COMPLETE));
+        } else {
+          pl2303_vendor_write(p_cdc, 8, 0, cdch_process_set_config, CONFIG_PL2303_RESET_ENDP2);
+        }
+      }
+      break;
+
+    case CONFIG_PL2303_RESET_ENDP2:
+      // step 2
+      if (p_cdc->pl2303.quirks & PL2303_QUIRK_LEGACY) {
+        TU_ASSERT(pl2303_clear_halt(p_cdc, PL2303_IN_EP, cdch_process_set_config, CONFIG_PL2303_COMPLETE));
+      } else {
+        /* reset upstream data pipes */
+        if (p_cdc->pl2303.type == PL2303_TYPE_HXN) {
+          // here nothing to do, only structure of previous step overtaken for better reading and comparison
+        } else {
+          TU_ASSERT(pl2303_vendor_write(p_cdc, 9, 0, cdch_process_set_config, CONFIG_PL2303_COMPLETE));
+        }
+      }
+      break;
+
+  // skipped, because it's not working with each PL230x. flow control can be also set by PL2303 EEPROM Writer Program
+  //    case CONFIG_PL2303_FLOW_CTRL_READ:
+  //      // read flow control register for modify & write back in next step
+  //      if (p_cdc->pl2303.type == PL2303_TYPE_HXN) {
+  //        TU_LOG_P_CDC ( "1\r\n" );
+  //        TU_ASSERT(pl2303_vendor_read(p_cdc, PL2303_HXN_FLOWCTRL_REG, &buf,
+  //                                     cdch_process_set_config, CONFIG_PL2303_FLOW_CTRL_WRITE));
+  //      } else {
+  //        TU_LOG_P_CDC ( "2\r\n" );
+  //        TU_ASSERT(pl2303_vendor_read(p_cdc, 0, &buf, cdch_process_set_config, CONFIG_PL2303_FLOW_CTRL_WRITE));
+  //      }
+  //      break;
+  //
+  //    case CONFIG_PL2303_FLOW_CTRL_WRITE:
+  //      // no flow control
+  //      buf = xfer->buffer[0];
+  //      if (p_cdc->pl2303.type == PL2303_TYPE_HXN) {
+  //        buf &= (uint8_t) ~PL2303_HXN_FLOWCTRL_MASK;
+  //        buf |= PL2303_HXN_FLOWCTRL_NONE;
+  //        TU_ASSERT(pl2303_vendor_write(p_cdc, PL2303_HXN_FLOWCTRL_REG, buf,
+  //                                      cdch_process_set_config, CONFIG_PL2303_COMPLETE));
+  //      } else {
+  //        buf &= (uint8_t) ~PL2303_FLOWCTRL_MASK;
+  //        TU_ASSERT(pl2303_vendor_write(p_cdc, 0, buf,
+  //                                      cdch_process_set_config, CONFIG_PL2303_COMPLETE));
+  //      }
+  //      break;
+
+    case CONFIG_PL2303_COMPLETE:
+      xfer->user_data = 0; // kick-off set line state on enum
+      cdch_process_line_state_on_enum(xfer);
+      break;
+
+    default:
+      return false;
+  }
+
+  return true;
+}
+
+//------------- Helper -------------//
+
+static pl2303_type_t pl2303_detect_type(cdch_interface_t *p_cdc, uint8_t step) {
+  tusb_desc_device_t desc_dev;
+  TU_VERIFY(tuh_descriptor_get_device_local(p_cdc->daddr, &desc_dev), PL2303_TYPE_UNKNOWN);
+
+  // Legacy PL2303H, variants 0 and 1 (difference unknown).
+  if (desc_dev.bDeviceClass == 0x02) {
+    return PL2303_TYPE_H; /* variant 0 */
+  }
+
+  if (desc_dev.bMaxPacketSize0 != 0x40) {
+    if (desc_dev.bDeviceClass == 0x00 || desc_dev.bDeviceClass == 0xff) {
+      return PL2303_TYPE_H; /* variant 1 */
+    }
+    return PL2303_TYPE_H; /* variant 0 */
+  }
+
+  switch (desc_dev.bcdUSB) {
+    case 0x101:
+      /* USB 1.0.1? Let's assume they meant 1.1... */
+      TU_ATTR_FALLTHROUGH;
+    case 0x110:
+      switch (desc_dev.bcdDevice) {
+        case 0x300: return PL2303_TYPE_HX;
+        case 0x400: return PL2303_TYPE_HXD;
+        default: return PL2303_TYPE_HX;
+      }
+      break;
+
+    case 0x200:
+      switch (desc_dev.bcdDevice) {
+        case 0x100: /* GC */
+        case 0x105:
+          return PL2303_TYPE_HXN;
+
+        case 0x300: /* GT / TA */
+          if (step == 1) {
+            // step 1 trigger pl2303_supports_hx_status() request
+            return PL2303_TYPE_NEED_SUPPORTS_HX_STATUS;
+          } else {
+            // step 2 use supports_hx_status
+            if (p_cdc->pl2303.supports_hx_status) {
+              return PL2303_TYPE_TA;
+            }
+          }
+          TU_ATTR_FALLTHROUGH;
+        case 0x305:
+        case 0x400: /* GL */
+        case 0x405:
+          return PL2303_TYPE_HXN;
+
+        case 0x500: /* GE / TB */
+          if (step == 1) {
+            // step 1 trigger pl2303_supports_hx_status() request
+            return PL2303_TYPE_NEED_SUPPORTS_HX_STATUS;
+          } else {
+            // step 2 use supports_hx_status
+            if (p_cdc->pl2303.supports_hx_status) {
+              return PL2303_TYPE_TB;
+            }
+          }
+          TU_ATTR_FALLTHROUGH;
+        case 0x505:
+        case 0x600: /* GS */
+        case 0x605:
+        case 0x700: /* GR */
+        case 0x705:
+          return PL2303_TYPE_HXN;
+
+        default:
+          break; // unknown device
+      }
+      break;
+
+    default:
+      break; // unknown device
+  }
+
+  TU_LOG_CDC(p_cdc, "unknown device type bcdUSB = 0x%04x", desc_dev.bcdUSB);
+  return PL2303_TYPE_UNKNOWN;
+}
+
+/*
+ * Returns the nearest supported baud rate that can be set directly without
+ * using divisors.
+ */
+static uint32_t pl2303_get_supported_baud_rate(uint32_t baud) {
+  static const uint32_t baud_sup[] = {
+    75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
+    14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
+    614400, 921600, 1228800, 2457600, 3000000, 6000000
+  };
+
+  uint8_t i;
+  for (i = 0; i < TU_ARRAY_SIZE(baud_sup); ++i) {
+    if (baud_sup[i] > baud) {
+      break;
+    }
+  }
+
+  if (i == TU_ARRAY_SIZE(baud_sup)) {
+    baud = baud_sup[i - 1];
+  } else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1])) {
+    baud = baud_sup[i - 1];
+  } else {
+    baud = baud_sup[i];
+  }
+
+  return baud;
+}
+
+/*
+ * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
+ *       use 9600 baud.
+ */
+static uint32_t pl2303_encode_baud_rate_direct(uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE], uint32_t baud) {
+  uint32_t baud_le = tu_htole32(baud);
+  buf[0] = (uint8_t) ( baud_le        & 0xff);
+  buf[1] = (uint8_t) ((baud_le >>  8) & 0xff);
+  buf[2] = (uint8_t) ((baud_le >> 16) & 0xff);
+  buf[3] = (uint8_t) ((baud_le >> 24) & 0xff);
+
+  return baud;
+}
+
+static uint32_t pl2303_encode_baud_rate_divisor(uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE], uint32_t baud) {
+  uint32_t baseline, mantissa, exponent;
+
+  /*
+   * Apparently the formula is:
+   *   baudrate = 12M * 32 / (mantissa * 4^exponent)
+   * where
+   *   mantissa = buf[8:0]
+   *   exponent = buf[11:9]
+   */
+  baseline = 12000000 * 32;
+  mantissa = baseline / baud;
+  if (mantissa == 0) {
+    mantissa = 1; /* Avoid dividing by zero if baud > 32 * 12M. */
+  }
+  exponent = 0;
+  while (mantissa >= 512) {
+    if (exponent < 7) {
+      mantissa >>= 2; /* divide by 4 */
+      exponent++;
+    } else {
+      /* Exponent is maxed. Trim mantissa and leave. */
+      mantissa = 511;
+      break;
+    }
+  }
+
+  buf[3] = 0x80;
+  buf[2] = 0;
+  buf[1] = (uint8_t) ((exponent << 1 | mantissa >> 8) & 0xff);
+  buf[0] = (uint8_t) (mantissa & 0xff);
+
+  /* Calculate and return the exact baud rate. */
+  baud = (baseline / mantissa) >> (exponent << 1);
+
+  return baud;
+}
+
+static uint32_t pl2303_encode_baud_rate_divisor_alt(uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE], uint32_t baud) {
+  uint32_t baseline, mantissa, exponent;
+
+  /*
+   * Apparently, for the TA version the formula is:
+   *   baudrate = 12M * 32 / (mantissa * 2^exponent)
+   * where
+   *   mantissa = buf[10:0]
+   *   exponent = buf[15:13 16]
+   */
+  baseline = 12000000 * 32;
+  mantissa = baseline / baud;
+  if (mantissa == 0) {
+    mantissa = 1; /* Avoid dividing by zero if baud > 32 * 12M. */
+  }
+  exponent = 0;
+  while (mantissa >= 2048) {
+    if (exponent < 15) {
+      mantissa >>= 1; /* divide by 2 */
+      exponent++;
+    } else {
+      /* Exponent is maxed. Trim mantissa and leave. */
+      mantissa = 2047;
+      break;
+    }
+  }
+
+  buf[3] = 0x80;
+  buf[2] = (uint8_t) (exponent & 0x01);
+  buf[1] = (uint8_t) (((exponent & (uint32_t) ~0x01) << 4 | mantissa >> 8) & 0xff);
+  buf[0] = (uint8_t) (mantissa & 0xff);
+
+  /* Calculate and return the exact baud rate. */
+  baud = (baseline / mantissa) >> exponent;
+
+  return baud;
+}
+
+static bool pl2303_encode_baud_rate(cdch_interface_t *p_cdc, uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE]) {
+  uint32_t baud = p_cdc->requested_line.coding.bit_rate;
+  uint32_t baud_sup;
+  const pl2303_type_data_t* type_data = &pl2303_type_data[p_cdc->pl2303.type];
+
+  TU_VERIFY(baud && baud <= type_data->max_baud_rate);
+  /*
+   * Use direct method for supported baud rates, otherwise use divisors.
+   * Newer chip types do not support divisor encoding.
+   */
+  if (type_data->no_divisors != 0) {
+    baud_sup = baud;
+  } else {
+    baud_sup = pl2303_get_supported_baud_rate(baud);
+  }
+
+  if (baud == baud_sup) {
+    baud = pl2303_encode_baud_rate_direct(buf, baud);
+  } else if (type_data->alt_divisors != 0) {
+    baud = pl2303_encode_baud_rate_divisor_alt(buf, baud);
+  } else {
+    baud = pl2303_encode_baud_rate_divisor(buf, baud);
+  }
+  TU_LOG_CDC(p_cdc, "real baudrate %lu", baud);
+
+  return true;
+}
+
+#endif // CFG_TUH_CDC_PL2303
+
 #endif
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index 8c5399534..e8637beac 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_CDC_HOST_H_
-#define _TUSB_CDC_HOST_H_
+#ifndef TUSB_CDC_HOST_H_
+#define TUSB_CDC_HOST_H_
 
 #include "cdc.h"
 
@@ -37,16 +37,6 @@
 // Class Driver Configuration
 //--------------------------------------------------------------------+
 
-// Set Line Control state on enumeration/mounted: DTR ( bit 0), RTS (bit 1)
-#ifndef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-#define CFG_TUH_CDC_LINE_CONTROL_ON_ENUM    0
-#endif
-
-// Set Line Coding on enumeration/mounted, value for cdc_line_coding_t
-//#ifndef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-//#define CFG_TUH_CDC_LINE_CODING_ON_ENUM   { 115200, CDC_LINE_CODING_STOP_BITS_1, CDC_LINE_CODING_PARITY_NONE, 8 }
-//#endif
-
 // RX FIFO size
 #ifndef CFG_TUH_CDC_RX_BUFSIZE
 #define CFG_TUH_CDC_RX_BUFSIZE TUH_EPSIZE_BULK_MPS
@@ -79,14 +69,27 @@ uint8_t tuh_cdc_itf_get_index(uint8_t daddr, uint8_t itf_num);
 // return true if index is correct and interface is currently mounted
 bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t* info);
 
-// Check if a interface is mounted
+// Check if an interface is mounted
 bool tuh_cdc_mounted(uint8_t idx);
 
+// Get local (cached) line state
+// This function should return correct values if tuh_cdc_set_control_line_state() / tuh_cdc_get_control_line_state()
+// are invoked previously or CFG_TUH_CDC_LINE_STATE_ON_ENUM is defined.
+bool tuh_cdc_get_control_line_state_local(uint8_t idx, uint16_t* line_state);
+
 // Get current DTR status
-bool tuh_cdc_get_dtr(uint8_t idx);
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_get_dtr(uint8_t idx) {
+  uint16_t line_state;
+  TU_VERIFY(tuh_cdc_get_control_line_state_local(idx, &line_state));
+  return (line_state & CDC_CONTROL_LINE_STATE_DTR) != 0;
+}
 
 // Get current RTS status
-bool tuh_cdc_get_rts(uint8_t idx);
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_get_rts(uint8_t idx) {
+  uint16_t line_state;
+  TU_VERIFY(tuh_cdc_get_control_line_state_local(idx, &line_state));
+  return (line_state & CDC_CONTROL_LINE_STATE_RTS) != 0;
+}
 
 // Check if interface is connected (DTR active)
 TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_connected(uint8_t idx) {
@@ -97,7 +100,9 @@ TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_connected(uint8_t idx) {
 // This function should return correct values if tuh_cdc_set_line_coding() / tuh_cdc_get_line_coding()
 // are invoked previously or CFG_TUH_CDC_LINE_CODING_ON_ENUM is defined.
 // NOTE: This function does not make any USB transfer request to device.
-bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t* line_coding);
+bool tuh_cdc_get_line_coding_local(uint8_t idx, cdc_line_coding_t* line_coding);
+
+#define tuh_cdc_get_local_line_coding tuh_cdc_get_line_coding_local // backward compatibility
 
 //--------------------------------------------------------------------+
 // Write API
@@ -132,18 +137,31 @@ bool tuh_cdc_peek(uint8_t idx, uint8_t* ch);
 bool tuh_cdc_read_clear (uint8_t idx);
 
 //--------------------------------------------------------------------+
-// Control Endpoint (Request) API
+// Control Request API
 // Each Function will make a USB control transfer request to/from device
 // - If complete_cb is provided, the function will return immediately and invoke
 // the callback when request is complete.
 // - If complete_cb is NULL, the function will block until request is complete.
-//   - In this case, user_data should be pointed to xfer_result_t to hold the transfer result.
-//   - The function will return true if transfer is successful, false otherwise.
+// In this case, user_data should be usb_xfer_result_t* to hold the transfer result.
 //--------------------------------------------------------------------+
 
 // Request to Set Control Line State: DTR (bit 0), RTS (bit 1)
 bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
+// Request to Set DTR
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_set_dtr(uint8_t idx, bool dtr_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  cdc_line_control_state_t line_state = { .dtr = dtr_state };
+  line_state.rts = tuh_cdc_get_rts(idx);
+  return tuh_cdc_set_control_line_state(idx, line_state.value, complete_cb, user_data);
+}
+
+// Request to Set RTS
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_set_rts(uint8_t idx, bool rts_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  cdc_line_control_state_t line_state = { .rts = rts_state };
+  line_state.dtr = tuh_cdc_get_dtr(idx);
+  return tuh_cdc_set_control_line_state(idx, line_state.value, complete_cb, user_data);
+}
+
 // Request to set baudrate
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
@@ -160,33 +178,68 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const* line_coding,
 // bool tuh_cdc_get_line_coding(uint8_t idx, cdc_line_coding_t* coding);
 
 // Connect by set both DTR, RTS
-TU_ATTR_ALWAYS_INLINE static inline
-bool tuh_cdc_connect(uint8_t idx, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_connect(uint8_t idx, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return tuh_cdc_set_control_line_state(idx, CDC_CONTROL_LINE_STATE_DTR | CDC_CONTROL_LINE_STATE_RTS, complete_cb, user_data);
 }
 
 // Disconnect by clear both DTR, RTS
-TU_ATTR_ALWAYS_INLINE static inline
-bool tuh_cdc_disconnect(uint8_t idx, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+TU_ATTR_ALWAYS_INLINE static inline bool tuh_cdc_disconnect(uint8_t idx, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return tuh_cdc_set_control_line_state(idx, 0x00, complete_cb, user_data);
 }
 
 //--------------------------------------------------------------------+
+// Control Request Sync API
+// Each Function will make a USB control transfer request to/from device the function will block until request is
+// complete. The function will return the transfer request result
+//--------------------------------------------------------------------+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_control_line_state_sync(uint8_t idx, uint16_t line_state) {
+  TU_API_SYNC(tuh_cdc_set_control_line_state, idx, line_state);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_dtr_sync(uint8_t idx, bool dtr_state) {
+  TU_API_SYNC(tuh_cdc_set_dtr, idx, dtr_state);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_rts_sync(uint8_t idx, bool rts_state) {
+  TU_API_SYNC(tuh_cdc_set_rts, idx, rts_state);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_baudrate_sync(uint8_t idx, uint32_t baudrate) {
+  TU_API_SYNC(tuh_cdc_set_baudrate, idx, baudrate);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_data_format_sync(uint8_t idx, uint8_t stop_bits, uint8_t parity, uint8_t data_bits) {
+  TU_API_SYNC(tuh_cdc_set_data_format, idx, stop_bits, parity, data_bits);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_set_line_coding_sync(uint8_t idx, cdc_line_coding_t const* line_coding) {
+  TU_API_SYNC(tuh_cdc_set_line_coding, idx, line_coding);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_connect_sync(uint8_t idx) {
+  TU_API_SYNC(tuh_cdc_connect, idx);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline tusb_xfer_result_t tuh_cdc_disconnect_sync(uint8_t idx) {
+  TU_API_SYNC(tuh_cdc_disconnect, idx);
+}
+
+//--------------------------------------------------------------------+
 // CDC APPLICATION CALLBACKS
 //--------------------------------------------------------------------+
 
 // Invoked when a device with CDC interface is mounted
 // idx is index of cdc interface in the internal pool.
-TU_ATTR_WEAK extern void tuh_cdc_mount_cb(uint8_t idx);
+extern void tuh_cdc_mount_cb(uint8_t idx);
 
 // Invoked when a device with CDC interface is unmounted
-TU_ATTR_WEAK extern void tuh_cdc_umount_cb(uint8_t idx);
+extern void tuh_cdc_umount_cb(uint8_t idx);
 
 // Invoked when received new data
-TU_ATTR_WEAK extern void tuh_cdc_rx_cb(uint8_t idx);
+extern void tuh_cdc_rx_cb(uint8_t idx);
 
 // Invoked when a TX is complete and therefore space becomes available in TX buffer
-TU_ATTR_WEAK extern void tuh_cdc_tx_complete_cb(uint8_t idx);
+extern void tuh_cdc_tx_complete_cb(uint8_t idx);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
@@ -202,4 +255,4 @@ void cdch_close      (uint8_t dev_addr);
  }
 #endif
 
-#endif /* _TUSB_CDC_HOST_H_ */
+#endif /* TUSB_CDC_HOST_H_ */
diff --git a/src/class/cdc/cdc_rndis.h b/src/class/cdc/cdc_rndis.h
index ad153e0ac..fbbd43206 100644
--- a/src/class/cdc/cdc_rndis.h
+++ b/src/class/cdc/cdc_rndis.h
@@ -30,8 +30,8 @@
  *  \defgroup CDC_RNDIS_Common Common Definitions
  *  @{ */
 
-#ifndef _TUSB_CDC_RNDIS_H_
-#define _TUSB_CDC_RNDIS_H_
+#ifndef TUSB_CDC_RNDIS_H_
+#define TUSB_CDC_RNDIS_H_
 
 #include "cdc.h"
 
@@ -295,7 +295,7 @@ typedef enum
  }
 #endif
 
-#endif /* _TUSB_CDC_RNDIS_H_ */
+#endif /* TUSB_CDC_RNDIS_H_ */
 
 /** @} */
 /** @} */
diff --git a/src/class/cdc/cdc_rndis_host.c b/src/class/cdc/cdc_rndis_host.c
index 11a5355aa..e975ea440 100644
--- a/src/class/cdc/cdc_rndis_host.c
+++ b/src/class/cdc/cdc_rndis_host.c
@@ -103,7 +103,7 @@ static tusb_error_t rndis_body_subtask(void)
 
   }
 
-  osal_task_delay(100);
+  tusb_time_delay_ms_api(100);
 
   OSAL_SUBTASK_END
 }
diff --git a/src/class/cdc/cdc_rndis_host.h b/src/class/cdc/cdc_rndis_host.h
index bb431ec1f..e70d27f79 100644
--- a/src/class/cdc/cdc_rndis_host.h
+++ b/src/class/cdc/cdc_rndis_host.h
@@ -28,8 +28,8 @@
  * \defgroup CDC_RNSID_Host Host
  *  @{ */
 
-#ifndef _TUSB_CDC_RNDIS_HOST_H_
-#define _TUSB_CDC_RNDIS_HOST_H_
+#ifndef TUSB_CDC_RNDIS_HOST_H_
+#define TUSB_CDC_RNDIS_HOST_H_
 
 #include "common/tusb_common.h"
 #include "host/usbh.h"
@@ -58,6 +58,6 @@ void rndish_close(uint8_t dev_addr);
  }
 #endif
 
-#endif /* _TUSB_CDC_RNDIS_HOST_H_ */
+#endif /* TUSB_CDC_RNDIS_HOST_H_ */
 
 /** @} */
diff --git a/src/class/cdc/serial/ch34x.h b/src/class/cdc/serial/ch34x.h
index c18066f57..0e08b0acd 100644
--- a/src/class/cdc/serial/ch34x.h
+++ b/src/class/cdc/serial/ch34x.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _CH34X_H_
-#define _CH34X_H_
+#ifndef TUSB_CH34X_H
+#define TUSB_CH34X_H
 
 // There is no official documentation for the CH34x (CH340, CH341) chips. Reference can be found
 // - https://github.com/WCHSoftGroup/ch341ser_linux
@@ -34,51 +34,51 @@
 
 // set line_coding @ enumeration
 #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-#define CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X CFG_TUH_CDC_LINE_CODING_ON_ENUM
+  #define CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X CFG_TUH_CDC_LINE_CODING_ON_ENUM
 #else // this default is necessary to work properly
-#define CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X { 9600, CDC_LINE_CONDING_STOP_BITS_1, CDC_LINE_CODING_PARITY_NONE, 8 }
+  #define CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X { 9600, CDC_LINE_CONDING_STOP_BITS_1, CDC_LINE_CODING_PARITY_NONE, 8 }
 #endif
 
 // USB requests
-#define CH34X_REQ_READ_VERSION 0x5F // dec  95
-#define CH34X_REQ_WRITE_REG    0x9A // dec 154
-#define CH34X_REQ_READ_REG     0x95 // dec 149
-#define CH34X_REQ_SERIAL_INIT  0xA1 // dec 161
-#define CH34X_REQ_MODEM_CTRL   0xA4 // dev 164
+#define CH34X_REQ_READ_VERSION        0x5F // dec  95
+#define CH34X_REQ_WRITE_REG           0x9A // dec 154
+#define CH34X_REQ_READ_REG            0x95 // dec 149
+#define CH34X_REQ_SERIAL_INIT         0xA1 // dec 161
+#define CH34X_REQ_MODEM_CTRL          0xA4 // dev 164
 
 // registers
-#define CH34X_REG_BREAK        0x05
-#define CH34X_REG_PRESCALER    0x12
-#define CH34X_REG_DIVISOR      0x13
-#define CH34X_REG_LCR          0x18
-#define CH34X_REG_LCR2         0x25
-#define CH34X_REG_MCR_MSR      0x06
-#define CH34X_REG_MCR_MSR2     0x07
-#define CH34X_NBREAK_BITS      0x01
+#define CH34X_REG_BREAK               0x05
+#define CH34X_REG_PRESCALER           0x12
+#define CH34X_REG_DIVISOR             0x13
+#define CH34X_REG_LCR                 0x18
+#define CH34X_REG_LCR2                0x25
+#define CH34X_REG_MCR_MSR             0x06
+#define CH34X_REG_MCR_MSR2            0x07
+#define CH34X_NBREAK_BITS             0x01
 
-#define CH341_REG_0x0F         0x0F // undocumented register
-#define CH341_REG_0x2C         0x2C // undocumented register
-#define CH341_REG_0x27         0x27 // hardware flow control (cts/rts)
+#define CH341_REG_0x0F                0x0F // undocumented register
+#define CH341_REG_0x2C                0x2C // undocumented register
+#define CH341_REG_0x27                0x27 // hardware flow control (cts/rts)
 
-#define CH34X_REG16_DIVISOR_PRESCALER  TU_U16(CH34X_REG_DIVISOR, CH34X_REG_PRESCALER)
-#define CH32X_REG16_LCR2_LCR           TU_U16(CH34X_REG_LCR2, CH34X_REG_LCR)
+#define CH34X_REG16_DIVISOR_PRESCALER TU_U16(CH34X_REG_DIVISOR, CH34X_REG_PRESCALER)
+#define CH32X_REG16_LCR2_LCR          TU_U16(CH34X_REG_LCR2, CH34X_REG_LCR)
 
 // modem control bits
-#define CH34X_BIT_RTS ( 1 << 6 )
-#define CH34X_BIT_DTR ( 1 << 5 )
+#define CH34X_BIT_RTS                 (1 << 6)
+#define CH34X_BIT_DTR                 (1 << 5)
 
 // line control bits
-#define CH34X_LCR_ENABLE_RX    0x80
-#define CH34X_LCR_ENABLE_TX    0x40
-#define CH34X_LCR_MARK_SPACE   0x20
-#define CH34X_LCR_PAR_EVEN     0x10
-#define CH34X_LCR_ENABLE_PAR   0x08
-#define CH34X_LCR_PAR_MASK     0x38 // all parity bits
-#define CH34X_LCR_STOP_BITS_2  0x04
-#define CH34X_LCR_CS8          0x03
-#define CH34X_LCR_CS7          0x02
-#define CH34X_LCR_CS6          0x01
-#define CH34X_LCR_CS5          0x00
-#define CH34X_LCR_CS_MASK      0x03 // all CSx bits
+#define CH34X_LCR_ENABLE_RX           0x80
+#define CH34X_LCR_ENABLE_TX           0x40
+#define CH34X_LCR_MARK_SPACE          0x20
+#define CH34X_LCR_PAR_EVEN            0x10
+#define CH34X_LCR_ENABLE_PAR          0x08
+#define CH34X_LCR_PAR_MASK            0x38 // all parity bits
+#define CH34X_LCR_STOP_BITS_2         0x04
+#define CH34X_LCR_CS8                 0x03
+#define CH34X_LCR_CS7                 0x02
+#define CH34X_LCR_CS6                 0x01
+#define CH34X_LCR_CS5                 0x00
+#define CH34X_LCR_CS_MASK             0x03 // all CSx bits
 
-#endif /* _CH34X_H_ */
+#endif // TUSB_CH34X_H
diff --git a/src/class/cdc/serial/cp210x.h b/src/class/cdc/serial/cp210x.h
index 2c749f522..a0eff9e40 100644
--- a/src/class/cdc/serial/cp210x.h
+++ b/src/class/cdc/serial/cp210x.h
@@ -28,9 +28,10 @@
 // Protocol details can be found at AN571: CP210x Virtual COM Port Interface
 // https://www.silabs.com/documents/public/application-notes/AN571.pdf
 
-#define TU_CP210X_VID 0x10C4
+// parts are overtaken from vendors driver
+// https://www.silabs.com/documents/public/software/cp210x-3.1.0.tar.gz
 
-/* Config request codes */
+// Config request codes
 #define CP210X_IFC_ENABLE      0x00
 #define CP210X_SET_BAUDDIV     0x01
 #define CP210X_GET_BAUDDIV     0x02
@@ -59,4 +60,55 @@
 #define CP210X_SET_BAUDRATE    0x1E
 #define CP210X_VENDOR_SPECIFIC 0xFF // GPIO, Recipient must be Device
 
+// SILABSER_IFC_ENABLE_REQUEST_CODE
+#define CP210X_UART_ENABLE              0x0001
+#define CP210X_UART_DISABLE             0x0000
+
+// SILABSER_SET_BAUDDIV_REQUEST_CODE
+#define CP210X_BAUD_RATE_GEN_FREQ     0x384000
+
+// SILABSER_SET_LINE_CTL_REQUEST_CODE
+#define CP210X_BITS_DATA_MASK           0x0f00
+#define CP210X_BITS_DATA_5              0x0500
+#define CP210X_BITS_DATA_6              0x0600
+#define CP210X_BITS_DATA_7              0x0700
+#define CP210X_BITS_DATA_8              0x0800
+#define CP210X_BITS_DATA_9              0x0900
+
+#define CP210X_BITS_PARITY_MASK         0x00f0
+#define CP210X_BITS_PARITY_NONE         0x0000
+#define CP210X_BITS_PARITY_ODD          0x0010
+#define CP210X_BITS_PARITY_EVEN         0x0020
+#define CP210X_BITS_PARITY_MARK         0x0030
+#define CP210X_BITS_PARITY_SPACE        0x0040
+
+#define CP210X_BITS_STOP_MASK           0x000f
+#define CP210X_BITS_STOP_1              0x0000
+#define CP210X_BITS_STOP_1_5            0x0001
+#define CP210X_BITS_STOP_2              0x0002
+
+// SILABSER_SET_BREAK_REQUEST_CODE
+#define CP210X_BREAK_ON                 0x0001
+#define CP210X_BREAK_OFF                0x0000
+
+// SILABSER_SET_MHS_REQUEST_CODE
+#define CP210X_MCR_DTR                  0x0001
+#define CP210X_MCR_RTS                  0x0002
+#define CP210X_MCR_ALL                  0x0003
+#define CP210X_MSR_CTS                  0x0010
+#define CP210X_MSR_DSR                  0x0020
+#define CP210X_MSR_RING                 0x0040
+#define CP210X_MSR_DCD                  0x0080
+#define CP210X_MSR_ALL                  0x00F0
+
+#define CP210X_CONTROL_WRITE_DTR        0x0100UL
+#define CP210X_CONTROL_WRITE_RTS        0x0200UL
+
+#define CP210X_LSR_BREAK                0x0001
+#define CP210X_LSR_FRAMING_ERROR        0x0002
+#define CP210X_LSR_HW_OVERRUN           0x0004
+#define CP210X_LSR_QUEUE_OVERRUN        0x0008
+#define CP210X_LSR_PARITY_ERROR         0x0010
+#define CP210X_LSR_ALL                  0x001F
+
 #endif //TUSB_CP210X_H
diff --git a/src/class/cdc/serial/ftdi_sio.h b/src/class/cdc/serial/ftdi_sio.h
index 0825f0719..9bd56cef4 100644
--- a/src/class/cdc/serial/ftdi_sio.h
+++ b/src/class/cdc/serial/ftdi_sio.h
@@ -25,222 +25,194 @@
 #ifndef TUSB_FTDI_SIO_H
 #define TUSB_FTDI_SIO_H
 
-// VID for matching FTDI devices
-#define TU_FTDI_VID 0x0403
+#include <stdint.h>
 
 // Commands
-#define FTDI_SIO_RESET             	0    /* Reset the port */
-#define FTDI_SIO_MODEM_CTRL        	1    /* Set the modem control register */
-#define FTDI_SIO_SET_FLOW_CTRL     	2    /* Set flow control register */
-#define FTDI_SIO_SET_BAUD_RATE     	3    /* Set baud rate */
-#define FTDI_SIO_SET_DATA          	4    /* Set the data characteristics of the port */
-#define FTDI_SIO_GET_MODEM_STATUS  	5    /* Retrieve current value of modem status register */
-#define FTDI_SIO_SET_EVENT_CHAR    	6    /* Set the event character */
-#define FTDI_SIO_SET_ERROR_CHAR    	7    /* Set the error character */
-#define FTDI_SIO_SET_LATENCY_TIMER 	9    /* Set the latency timer */
-#define FTDI_SIO_GET_LATENCY_TIMER 	0x0a /* Get the latency timer */
-#define FTDI_SIO_SET_BITMODE       	0x0b /* Set bitbang mode */
-#define FTDI_SIO_READ_PINS         	0x0c /* Read immediate value of pins */
-#define FTDI_SIO_READ_EEPROM       	0x90 /* Read EEPROM */
+#define FTDI_SIO_RESET                0 // Reset the port
+#define FTDI_SIO_MODEM_CTRL           1 // Set the modem control register
+#define FTDI_SIO_SET_FLOW_CTRL        2 // Set flow control register
+#define FTDI_SIO_SET_BAUD_RATE        3 // Set baud rate
+#define FTDI_SIO_SET_DATA             4 // Set the data characteristics of the port
+#define FTDI_SIO_GET_MODEM_STATUS     5 // Retrieve current value of modem status register
+#define FTDI_SIO_SET_EVENT_CHAR       6 // Set the event character
+#define FTDI_SIO_SET_ERROR_CHAR       7 // Set the error character
+#define FTDI_SIO_SET_LATENCY_TIMER    9 // Set the latency timer
+#define FTDI_SIO_GET_LATENCY_TIMER   10 // Get the latency timer
+#define FTDI_SIO_SET_BITMODE         11 // Set bitbang mode
+#define FTDI_SIO_READ_PINS           12 // Read immediate value of pins
+#define FTDI_SIO_READ_EEPROM       0x90 // Read EEPROM
 
-/* FTDI_SIO_RESET */
-#define FTDI_SIO_RESET_SIO 0
-#define FTDI_SIO_RESET_PURGE_RX 1
-#define FTDI_SIO_RESET_PURGE_TX 2
+// Channel indices for FT2232, FT2232H and FT4232H devices
+#define CHANNEL_A 1
+#define CHANNEL_B 2
+#define CHANNEL_C 3
+#define CHANNEL_D 4
 
-/*
- * BmRequestType:  0100 0000B
- * bRequest:       FTDI_SIO_RESET
- * wValue:         Control Value
- *                   0 = Reset SIO
- *                   1 = Purge RX buffer
- *                   2 = Purge TX buffer
- * wIndex:         Port
- * wLength:        0
- * Data:           None
- *
- * The Reset SIO command has this effect:
- *
- *    Sets flow control set to 'none'
- *    Event char = $0D
- *    Event trigger = disabled
- *    Purge RX buffer
- *    Purge TX buffer
- *    Clear DTR
- *    Clear RTS
- *    baud and data format not reset
- *
- * The Purge RX and TX buffer commands affect nothing except the buffers
- *
-   */
+// Port Identifier Table
+#define PIT_DEFAULT  0 // SIOA
+#define PIT_SIOA     1 // SIOA
+// The device this driver is tested with one has only one port
+#define PIT_SIOB     2 // SIOB
+#define PIT_PARALLEL 3 // Parallel
 
-/* FTDI_SIO_MODEM_CTRL */
-/*
- * BmRequestType:   0100 0000B
- * bRequest:        FTDI_SIO_MODEM_CTRL
- * wValue:          ControlValue (see below)
- * wIndex:          Port
- * wLength:         0
- * Data:            None
- *
- * NOTE: If the device is in RTS/CTS flow control, the RTS set by this
- * command will be IGNORED without an error being returned
- * Also - you can not set DTR and RTS with one control message
- */
+// FTDI_SIO_RESET
+#define FTDI_SIO_RESET_REQUEST                    FTDI_SIO_RESET
+#define FTDI_SIO_RESET_REQUEST_TYPE               0x40
+#define FTDI_SIO_RESET_SIO                        0
+#define FTDI_SIO_RESET_PURGE_RX                   1
+#define FTDI_SIO_RESET_PURGE_TX                   2
 
-#define FTDI_SIO_SET_DTR_MASK 0x1
-#define FTDI_SIO_SET_DTR_HIGH ((FTDI_SIO_SET_DTR_MASK << 8) | 1)
-#define FTDI_SIO_SET_DTR_LOW  ((FTDI_SIO_SET_DTR_MASK << 8) | 0)
-#define FTDI_SIO_SET_RTS_MASK 0x2
-#define FTDI_SIO_SET_RTS_HIGH ((FTDI_SIO_SET_RTS_MASK << 8) | 2)
-#define FTDI_SIO_SET_RTS_LOW  ((FTDI_SIO_SET_RTS_MASK << 8) | 0)
+// FTDI_SIO_SET_BAUDRATE
+#define FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE        0x40
+#define FTDI_SIO_SET_BAUDRATE_REQUEST             3
 
-/*
- * ControlValue
- * B0    DTR state
- *          0 = reset
- *          1 = set
- * B1    RTS state
- *          0 = reset
- *          1 = set
- * B2..7 Reserved
- * B8    DTR state enable
- *          0 = ignore
- *          1 = use DTR state
- * B9    RTS state enable
- *          0 = ignore
- *          1 = use RTS state
- * B10..15 Reserved
- */
+enum ftdi_sio_baudrate {
+  ftdi_sio_b300 = 0,
+  ftdi_sio_b600 = 1,
+  ftdi_sio_b1200 = 2,
+  ftdi_sio_b2400 = 3,
+  ftdi_sio_b4800 = 4,
+  ftdi_sio_b9600 = 5,
+  ftdi_sio_b19200 = 6,
+  ftdi_sio_b38400 = 7,
+  ftdi_sio_b57600 = 8,
+  ftdi_sio_b115200 = 9
+};
 
-/* FTDI_SIO_SET_FLOW_CTRL */
-#define FTDI_SIO_DISABLE_FLOW_CTRL 0x0
-#define FTDI_SIO_RTS_CTS_HS (0x1 << 8)
-#define FTDI_SIO_DTR_DSR_HS (0x2 << 8)
-#define FTDI_SIO_XON_XOFF_HS (0x4 << 8)
+// FTDI_SIO_SET_DATA
+#define FTDI_SIO_SET_DATA_REQUEST                 FTDI_SIO_SET_DATA
+#define FTDI_SIO_SET_DATA_REQUEST_TYPE            0x40
+#define FTDI_SIO_SET_DATA_PARITY_NONE             (0x0 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_ODD              (0x1 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_EVEN             (0x2 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_MARK             (0x3 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_SPACE            (0x4 << 8)
+#define FTDI_SIO_SET_DATA_STOP_BITS_1             (0x0 << 11) // same coding as ACM
+#define FTDI_SIO_SET_DATA_STOP_BITS_15            (0x1 << 11) // 1.5 not supported, for future use?
+#define FTDI_SIO_SET_DATA_STOP_BITS_2             (0x2 << 11)
+#define FTDI_SIO_SET_BREAK                        (0x1 << 14)
 
-/*
- *   BmRequestType:  0100 0000b
- *   bRequest:       FTDI_SIO_SET_FLOW_CTRL
- *   wValue:         Xoff/Xon
- *   wIndex:         Protocol/Port - hIndex is protocol / lIndex is port
- *   wLength:        0
- *   Data:           None
- *
- * hIndex protocol is:
- *   B0 Output handshaking using RTS/CTS
- *       0 = disabled
- *       1 = enabled
- *   B1 Output handshaking using DTR/DSR
- *       0 = disabled
- *       1 = enabled
- *   B2 Xon/Xoff handshaking
- *       0 = disabled
- *       1 = enabled
- *
- * A value of zero in the hIndex field disables handshaking
- *
- * If Xon/Xoff handshaking is specified, the hValue field should contain the
- * XOFF character and the lValue field contains the XON character.
- */
+// FTDI_SIO_MODEM_CTRL
+#define FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE      0x40
+#define FTDI_SIO_SET_MODEM_CTRL_REQUEST           FTDI_SIO_MODEM_CTRL
 
-/* FTDI_SIO_SET_BAUD_RATE */
-/*
- * BmRequestType:  0100 0000B
- * bRequest:       FTDI_SIO_SET_BAUDRATE
- * wValue:         BaudDivisor value - see below
- * wIndex:         Port
- * wLength:        0
- * Data:           None
- * The BaudDivisor values are calculated as follows (too complicated):
- */
+#define FTDI_SIO_SET_DTR_MASK                     0x1UL
+#define FTDI_SIO_SET_DTR_HIGH                     ((FTDI_SIO_SET_DTR_MASK << 8) | 1UL)
+#define FTDI_SIO_SET_DTR_LOW                      ((FTDI_SIO_SET_DTR_MASK << 8) | 0UL)
+#define FTDI_SIO_SET_RTS_MASK                     0x2UL
+#define FTDI_SIO_SET_RTS_HIGH                     ((FTDI_SIO_SET_RTS_MASK << 8) | 2UL)
+#define FTDI_SIO_SET_RTS_LOW                      ((FTDI_SIO_SET_RTS_MASK << 8) | 0UL)
 
-/* FTDI_SIO_SET_DATA */
-#define FTDI_SIO_SET_DATA_PARITY_NONE	(0x0 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_ODD	(0x1 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_EVEN	(0x2 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_MARK	(0x3 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_SPACE	(0x4 << 8)
-#define FTDI_SIO_SET_DATA_STOP_BITS_1	(0x0 << 11)
-#define FTDI_SIO_SET_DATA_STOP_BITS_15	(0x1 << 11)
-#define FTDI_SIO_SET_DATA_STOP_BITS_2	(0x2 << 11)
-#define FTDI_SIO_SET_BREAK		(0x1 << 14)
+// FTDI_SIO_SET_FLOW_CTRL
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE       0x40
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST            FTDI_SIO_SET_FLOW_CTRL
+#define FTDI_SIO_DISABLE_FLOW_CTRL                0x0
+#define FTDI_SIO_RTS_CTS_HS                       (0x1 << 8)
+#define FTDI_SIO_DTR_DSR_HS                       (0x2 << 8)
+#define FTDI_SIO_XON_XOFF_HS                      (0x4 << 8)
 
-/*
- * BmRequestType:  0100 0000B
- * bRequest:       FTDI_SIO_SET_DATA
- * wValue:         Data characteristics (see below)
- * wIndex:         Port
- * wLength:        0
- * Data:           No
- *
- * Data characteristics
- *
- *   B0..7   Number of data bits
- *   B8..10  Parity
- *           0 = None
- *           1 = Odd
- *           2 = Even
- *           3 = Mark
- *           4 = Space
- *   B11..13 Stop Bits
- *           0 = 1
- *           1 = 1.5
- *           2 = 2
- *   B14
- *           1 = TX ON (break)
- *           0 = TX OFF (normal state)
- *   B15 Reserved
- *
- */
+// FTDI_SIO_GET_LATENCY_TIMER
+#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST       FTDI_SIO_GET_LATENCY_TIMER
+#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE  0xC0
 
-/*
-* DATA FORMAT
-*
-* IN Endpoint
-*
-* The device reserves the first two bytes of data on this endpoint to contain
-* the current values of the modem and line status registers. In the absence of
-* data, the device generates a message consisting of these two status bytes
-  * every 40 ms
-  *
-  * Byte 0: Modem Status
-*
-* Offset	Description
-* B0	Reserved - must be 1
-* B1	Reserved - must be 0
-* B2	Reserved - must be 0
-* B3	Reserved - must be 0
-* B4	Clear to Send (CTS)
-* B5	Data Set Ready (DSR)
-* B6	Ring Indicator (RI)
-* B7	Receive Line Signal Detect (RLSD)
-*
-* Byte 1: Line Status
-*
-* Offset	Description
-* B0	Data Ready (DR)
-* B1	Overrun Error (OE)
-* B2	Parity Error (PE)
-* B3	Framing Error (FE)
-* B4	Break Interrupt (BI)
-* B5	Transmitter Holding Register (THRE)
-* B6	Transmitter Empty (TEMT)
-* B7	Error in RCVR FIFO
-*
-*/
-#define FTDI_RS0_CTS	(1 << 4)
-#define FTDI_RS0_DSR	(1 << 5)
-#define FTDI_RS0_RI	(1 << 6)
-#define FTDI_RS0_RLSD	(1 << 7)
+// FTDI_SIO_SET_LATENCY_TIMER
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST       FTDI_SIO_SET_LATENCY_TIMER
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE  0x40
+
+// FTDI_SIO_SET_EVENT_CHAR
+#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST          FTDI_SIO_SET_EVENT_CHAR
+#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE     0x40
+
+// FTDI_SIO_GET_MODEM_STATUS
+#define FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE    0xc0
+#define FTDI_SIO_GET_MODEM_STATUS_REQUEST         FTDI_SIO_GET_MODEM_STATUS
+#define FTDI_SIO_CTS_MASK                         0x10
+#define FTDI_SIO_DSR_MASK                         0x20
+#define FTDI_SIO_RI_MASK                          0x40
+#define FTDI_SIO_RLSD_MASK                        0x80
+
+// FTDI_SIO_SET_BITMODE
+#define FTDI_SIO_SET_BITMODE_REQUEST_TYPE         0x40
+#define FTDI_SIO_SET_BITMODE_REQUEST              FTDI_SIO_SET_BITMODE
+
+// Possible bitmodes for FTDI_SIO_SET_BITMODE_REQUEST
+#define FTDI_SIO_BITMODE_RESET                    0x00
+#define FTDI_SIO_BITMODE_CBUS                     0x20
+
+// FTDI_SIO_READ_PINS
+#define FTDI_SIO_READ_PINS_REQUEST_TYPE           0xc0
+#define FTDI_SIO_READ_PINS_REQUEST                FTDI_SIO_READ_PINS
+
+// FTDI_SIO_READ_EEPROM
+#define FTDI_SIO_READ_EEPROM_REQUEST_TYPE         0xc0
+#define FTDI_SIO_READ_EEPROM_REQUEST              FTDI_SIO_READ_EEPROM
+
+#define FTDI_FTX_CBUS_MUX_GPIO    0x8
+#define FTDI_FT232R_CBUS_MUX_GPIO 0xa
+
+#define FTDI_RS0_CTS  (1 << 4)
+#define FTDI_RS0_DSR  (1 << 5)
+#define FTDI_RS0_RI   (1 << 6)
+#define FTDI_RS0_RLSD (1 << 7)
+
+#define FTDI_RS_DR    1
+#define FTDI_RS_OE    (1 << 1)
+#define FTDI_RS_PE    (1 << 2)
+#define FTDI_RS_FE    (1 << 3)
+#define FTDI_RS_BI    (1 << 4)
+#define FTDI_RS_THRE  (1 << 5)
+#define FTDI_RS_TEMT  (1 << 6)
+#define FTDI_RS_FIFO  (1 << 7)
+
+// chip types and names
+typedef enum ftdi_chip_type {
+  FTDI_SIO = 0,
+//  FTDI_FT232A,
+  FTDI_FT232B,
+  FTDI_FT2232C,
+  FTDI_FT232R,
+  FTDI_FT232H,
+  FTDI_FT2232H,
+  FTDI_FT4232H,
+  FTDI_FT4232HA,
+  FTDI_FT232HP,
+  FTDI_FT233HP,
+  FTDI_FT2232HP,
+  FTDI_FT2233HP,
+  FTDI_FT4232HP,
+  FTDI_FT4233HP,
+  FTDI_FTX,
+  FTDI_UNKNOWN
+} ftdi_chip_type_t;
+
+#define FTDI_CHIP_NAMES \
+  [FTDI_SIO]       = "SIO", /* the serial part of FT8U100AX */ \
+/*  [FTDI_FT232A]    = "FT232A", */ \
+  [FTDI_FT232B]    = "FT232B", \
+  [FTDI_FT2232C]   = "FT2232C/D", \
+  [FTDI_FT232R]    = "FT232R", \
+  [FTDI_FT232H]    = "FT232H", \
+  [FTDI_FT2232H]   = "FTDI_FT2232H", \
+  [FTDI_FT4232H]   = "FT4232H", \
+  [FTDI_FT4232HA]  = "FT4232HA", \
+  [FTDI_FT232HP]   = "FT232HP", \
+  [FTDI_FT233HP]   = "FT233HP", \
+  [FTDI_FT2232HP]  = "FT2232HP", \
+  [FTDI_FT2233HP]  = "FT2233HP", \
+  [FTDI_FT4232HP]  = "FT4232HP", \
+  [FTDI_FT4233HP]  = "FT4233HP", \
+  [FTDI_FTX]       = "FT-X", \
+  [FTDI_UNKNOWN]   = "UNKNOWN"
+
+// private interface data
+typedef struct ftdi_private {
+  ftdi_chip_type_t chip_type;
+  uint8_t channel;                  // channel index, or 0 for legacy types
+} ftdi_private_t;
 
-#define FTDI_RS_DR	1
-#define FTDI_RS_OE	(1<<1)
-#define FTDI_RS_PE	(1<<2)
-#define FTDI_RS_FE	(1<<3)
-#define FTDI_RS_BI	(1<<4)
-#define FTDI_RS_THRE	(1<<5)
-#define FTDI_RS_TEMT	(1<<6)
-#define FTDI_RS_FIFO	(1<<7)
+#define FTDI_OK           true
+#define FTDI_FAIL         false
+#define FTDI_NOT_POSSIBLE -1
+#define FTDI_REQUESTED    -2
 
 #endif //TUSB_FTDI_SIO_H
diff --git a/src/class/cdc/serial/pl2303.h b/src/class/cdc/serial/pl2303.h
new file mode 100644
index 000000000..63910c7bb
--- /dev/null
+++ b/src/class/cdc/serial/pl2303.h
@@ -0,0 +1,159 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Heiko Kuester
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#ifndef TUSB_PL2303_H
+#define TUSB_PL2303_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+// There is no official documentation for the PL2303 chips.
+// Reference can be found
+// - https://github.com/torvalds/linux/blob/master/drivers/usb/serial/pl2303.h and
+//   https://github.com/torvalds/linux/blob/master/drivers/usb/serial/pl2303.c
+// - https://github.com/freebsd/freebsd-src/blob/main/sys/dev/usb/serial/uplcom.c
+
+// quirks
+#define PL2303_QUIRK_UART_STATE_IDX0      1
+#define PL2303_QUIRK_LEGACY               2
+#define PL2303_QUIRK_ENDPOINT_HACK        4
+
+// requests and bits
+#define PL2303_SET_LINE_REQUEST_TYPE      0x21    // class request host to device interface
+#define PL2303_SET_LINE_REQUEST           0x20    // dec 32
+
+#define PL2303_SET_CONTROL_REQUEST_TYPE   0x21    // class request host to device interface
+#define PL2303_SET_CONTROL_REQUEST        0x22    // dec 34
+#define PL2303_CONTROL_DTR                0x01    // dec 1
+#define PL2303_CONTROL_RTS                0x02    // dec 2
+
+#define PL2303_BREAK_REQUEST_TYPE         0x21    // class request host to device interface
+#define PL2303_BREAK_REQUEST              0x23    // dec 35
+#define PL2303_BREAK_ON                   0xffff
+#define PL2303_BREAK_OFF                  0x0000
+
+#define PL2303_GET_LINE_REQUEST_TYPE      0xa1    // class request device to host interface
+#define PL2303_GET_LINE_REQUEST           0x21    // dec 33
+
+#define PL2303_VENDOR_WRITE_REQUEST_TYPE  0x40    // vendor request host to device interface
+#define PL2303_VENDOR_WRITE_REQUEST       0x01    // dec 1
+#define PL2303_VENDOR_WRITE_NREQUEST      0x80    // dec 128
+
+#define PL2303_VENDOR_READ_REQUEST_TYPE   0xc0    // vendor request device to host interface
+#define PL2303_VENDOR_READ_REQUEST        0x01    // dec 1
+#define PL2303_VENDOR_READ_NREQUEST       0x81    // dec 129
+
+#define PL2303_UART_STATE_INDEX           8
+#define PL2303_UART_STATE_MSR_MASK        0x8b
+#define PL2303_UART_STATE_TRANSIENT_MASK  0x74
+#define PL2303_UART_DCD                   0x01
+#define PL2303_UART_DSR                   0x02
+#define PL2303_UART_BREAK_ERROR           0x04
+#define PL2303_UART_RING                  0x08
+#define PL2303_UART_FRAME_ERROR           0x10
+#define PL2303_UART_PARITY_ERROR          0x20
+#define PL2303_UART_OVERRUN_ERROR         0x40
+#define PL2303_UART_CTS                   0x80
+
+#define PL2303_FLOWCTRL_MASK              0xf0
+
+#define PL2303_CLEAR_HALT_REQUEST_TYPE    0x02    // standard request host to device endpoint
+
+// registers via vendor read/write requests
+#define PL2303_READ_TYPE_HX_STATUS        0x8080
+
+#define PL2303_HXN_RESET_REG              0x07
+#define PL2303_HXN_RESET_UPSTREAM_PIPE    0x02
+#define PL2303_HXN_RESET_DOWNSTREAM_PIPE  0x01
+
+#define PL2303_HXN_FLOWCTRL_REG           0x0a
+#define PL2303_HXN_FLOWCTRL_MASK          0x1c
+#define PL2303_HXN_FLOWCTRL_NONE          0x1c
+#define PL2303_HXN_FLOWCTRL_RTS_CTS       0x18
+#define PL2303_HXN_FLOWCTRL_XON_XOFF      0x0c
+
+// type data
+typedef enum pl2303_type {
+  PL2303_TYPE_H = 0, // 0
+  PL2303_TYPE_HX,    // 1
+  PL2303_TYPE_TA,    // 2
+  PL2303_TYPE_TB,    // 3
+  PL2303_TYPE_HXD,   // 4
+  PL2303_TYPE_HXN,   // 5
+  PL2303_TYPE_COUNT,
+  PL2303_TYPE_NEED_SUPPORTS_HX_STATUS,
+  PL2303_TYPE_UNKNOWN,
+} pl2303_type_t;
+
+typedef struct pl2303_type_data {
+  uint32_t max_baud_rate;
+  uint8_t  quirks;
+  uint8_t  no_autoxonxoff : 1;
+  uint8_t  no_divisors    : 1;
+  uint8_t  alt_divisors   : 1;
+} pl2303_type_data_t;
+
+#define PL2303_TYPE_DATA \
+  [PL2303_TYPE_H] = { \
+    .max_baud_rate = 1228800, .quirks = PL2303_QUIRK_LEGACY, \
+    .no_autoxonxoff = 1, .no_divisors = 0, .alt_divisors = 0 \
+  }, \
+  [PL2303_TYPE_HX] = { \
+    .max_baud_rate = 6000000, .quirks = 0, \
+    .no_autoxonxoff = 0, .no_divisors = 0, .alt_divisors = 0 \
+  }, \
+  [PL2303_TYPE_TA] = { \
+    .max_baud_rate = 6000000, .quirks = 0, \
+    .no_autoxonxoff = 0, .no_divisors = 0, .alt_divisors = 1 \
+  }, \
+  [PL2303_TYPE_TB] = { \
+    .max_baud_rate = 12000000, .quirks = 0, \
+    .no_autoxonxoff = 0, .no_divisors = 0, .alt_divisors = 1 \
+  }, \
+  [PL2303_TYPE_HXD] = { \
+    .max_baud_rate = 12000000, .quirks = 0, \
+    .no_autoxonxoff = 0, .no_divisors = 0, .alt_divisors = 0 \
+  }, \
+  [PL2303_TYPE_HXN] = { \
+    .max_baud_rate = 12000000, .quirks = 0, \
+    .no_autoxonxoff = 0, .no_divisors = 1, .alt_divisors = 0 \
+  }
+
+typedef struct TU_ATTR_PACKED {
+  pl2303_type_t type;
+  uint8_t quirks;
+  bool supports_hx_status;
+} pl2303_private_t;
+
+// buffer sizes for line coding data
+#define PL2303_LINE_CODING_BUFSIZE          7
+#define PL2303_LINE_CODING_BAUDRATE_BUFSIZE 4
+
+// bulk endpoints
+#define PL2303_OUT_EP                       0x02
+#define PL2303_IN_EP                        0x83
+
+#endif // TUSB_PL2303_H
diff --git a/src/class/dfu/dfu.h b/src/class/dfu/dfu.h
index 114c827b8..8cd63656a 100644
--- a/src/class/dfu/dfu.h
+++ b/src/class/dfu/dfu.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_DFU_H_
-#define _TUSB_DFU_H_
+#ifndef TUSB_DFU_H_
+#define TUSB_DFU_H_
 
 #include "common/tusb_common.h"
 
@@ -116,4 +116,4 @@ TU_VERIFY_STATIC( sizeof(dfu_status_response_t) == 6, "size is not correct");
  }
 #endif
 
-#endif /* _TUSB_DFU_H_ */
+#endif /* TUSB_DFU_H_ */
diff --git a/src/class/dfu/dfu_device.c b/src/class/dfu/dfu_device.c
index d9e2d3f2f..0d2b63b57 100644
--- a/src/class/dfu/dfu_device.c
+++ b/src/class/dfu/dfu_device.c
@@ -77,6 +77,24 @@ static bool process_download_get_status(uint8_t rhport, uint8_t stage, const tus
 static bool process_manifest_get_status(uint8_t rhport, uint8_t stage, const tusb_control_request_t* request);
 
 //--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_dfu_detach_cb(void) {
+}
+
+TU_ATTR_WEAK void tud_dfu_abort_cb(uint8_t alt) {
+  (void) alt;
+}
+
+TU_ATTR_WEAK uint16_t tud_dfu_upload_cb(uint8_t alt, uint16_t block_num, uint8_t* data, uint16_t length) {
+  (void) alt;
+  (void) block_num;
+  (void) data;
+  (void) length;
+  return 0;
+}
+
+//--------------------------------------------------------------------+
 // Debug
 //--------------------------------------------------------------------+
 #if CFG_TUSB_DEBUG >= 2
@@ -234,9 +252,7 @@ bool dfu_moded_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control
         if (stage == CONTROL_STAGE_SETUP) {
           tud_control_status(rhport, request);
         } else if (stage == CONTROL_STAGE_ACK) {
-          if (tud_dfu_detach_cb) {
-            tud_dfu_detach_cb();
-          }
+          tud_dfu_detach_cb();
         }
         break;
 
@@ -258,16 +274,13 @@ bool dfu_moded_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control
           reset_state();
           tud_control_status(rhport, request);
         } else if (stage == CONTROL_STAGE_ACK) {
-          if (tud_dfu_abort_cb) {
-            tud_dfu_abort_cb(_dfu_ctx.alt);
-          }
+          tud_dfu_abort_cb(_dfu_ctx.alt);
         }
         break;
 
       case DFU_REQUEST_UPLOAD:
         if (stage == CONTROL_STAGE_SETUP) {
           TU_VERIFY(_dfu_ctx.attrs & DFU_ATTR_CAN_UPLOAD);
-          TU_VERIFY(tud_dfu_upload_cb);
           TU_VERIFY(request->wLength <= CFG_TUD_DFU_XFER_BUFSIZE);
 
           const uint16_t xfer_len = tud_dfu_upload_cb(_dfu_ctx.alt, request->wValue, _dfu_epbuf.transfer_buf,
diff --git a/src/class/dfu/dfu_device.h b/src/class/dfu/dfu_device.h
index 00c22ea8b..b22b4c450 100644
--- a/src/class/dfu/dfu_device.h
+++ b/src/class/dfu/dfu_device.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_DFU_DEVICE_H_
-#define _TUSB_DFU_DEVICE_H_
+#ifndef TUSB_DFU_DEVICE_H_
+#define TUSB_DFU_DEVICE_H_
 
 #include "dfu.h"
 
@@ -74,13 +74,13 @@ void tud_dfu_manifest_cb(uint8_t alt);
 // Invoked when received DFU_UPLOAD request
 // Application must populate data with up to length bytes and
 // Return the number of written bytes
-TU_ATTR_WEAK uint16_t tud_dfu_upload_cb(uint8_t alt, uint16_t block_num, uint8_t* data, uint16_t length);
+uint16_t tud_dfu_upload_cb(uint8_t alt, uint16_t block_num, uint8_t* data, uint16_t length);
 
 // Invoked when a DFU_DETACH request is received
-TU_ATTR_WEAK void tud_dfu_detach_cb(void);
+void tud_dfu_detach_cb(void);
 
 // Invoked when the Host has terminated a download or upload transfer
-TU_ATTR_WEAK void tud_dfu_abort_cb(uint8_t alt);
+void tud_dfu_abort_cb(uint8_t alt);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
@@ -96,4 +96,4 @@ bool     dfu_moded_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_r
  }
 #endif
 
-#endif /* _TUSB_DFU_MODE_DEVICE_H_ */
+#endif /* TUSB_DFU_MODE_DEVICE_H_ */
diff --git a/src/class/dfu/dfu_rt_device.h b/src/class/dfu/dfu_rt_device.h
index 67eb26d95..c4116d8fe 100644
--- a/src/class/dfu/dfu_rt_device.h
+++ b/src/class/dfu/dfu_rt_device.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_DFU_RT_DEVICE_H_
-#define _TUSB_DFU_RT_DEVICE_H_
+#ifndef TUSB_DFU_RT_DEVICE_H_
+#define TUSB_DFU_RT_DEVICE_H_
 
 #include "dfu.h"
 
@@ -52,4 +52,4 @@ bool     dfu_rtd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_req
  }
 #endif
 
-#endif /* _TUSB_DFU_RT_DEVICE_H_ */
+#endif /* TUSB_DFU_RT_DEVICE_H_ */
diff --git a/src/class/hid/hid.h b/src/class/hid/hid.h
index c2434c20d..0883d95ac 100644
--- a/src/class/hid/hid.h
+++ b/src/class/hid/hid.h
@@ -28,8 +28,8 @@
  *  \defgroup ClassDriver_HID Human Interface Device (HID)
  *  @{ */
 
-#ifndef _TUSB_HID_H_
-#define _TUSB_HID_H_
+#ifndef TUSB_HID_H_
+#define TUSB_HID_H_
 
 #include "common/tusb_common.h"
 
@@ -807,7 +807,9 @@ enum {
   HID_USAGE_PAGE_MEDICAL_INSTRUMENT        = 0x40,
   HID_USAGE_PAGE_LIGHTING_AND_ILLUMINATION = 0x59,
   HID_USAGE_PAGE_MONITOR                   = 0x80, // 0x80 - 0x83
-  HID_USAGE_PAGE_POWER                     = 0x84, // 0x084 - 0x87
+  HID_USAGE_PAGE_POWER                     = 0x84,
+  HID_USAGE_PAGE_BATTERY                   = 0x85,
+  // 0x86 - 0x87 is reserved for Power Device
   HID_USAGE_PAGE_BARCODE_SCANNER           = 0x8c,
   HID_USAGE_PAGE_SCALE                     = 0x8d,
   HID_USAGE_PAGE_MSR                       = 0x8e,
@@ -893,14 +895,51 @@ enum {
 /// HID Usage Table: Consumer Page (0x0C)
 /// Only contains controls that supported by Windows (whole list is too long)
 enum {
+  HID_USAGE_CONSUMER_UNASSIGNED                        = 0x0000,
+
   // Generic Control
   HID_USAGE_CONSUMER_CONTROL                           = 0x0001,
+  HID_USAGE_CONSUMER_NUMERIC_KEY_PAD                   = 0x0002,
+  HID_USAGE_CONSUMER_PROGRAMMABLE_BUTTONS              = 0x0003,
+  HID_USAGE_CONSUMER_MICROPHONE                        = 0x0004,
+  HID_USAGE_CONSUMER_HEADPHONE                         = 0x0005,
+  HID_USAGE_CONSUMER_GRAPHIC_EQUALIZER                 = 0x0006,
+  // 07-1F Reserved
+
+  HID_USAGE_CONSUMER_PLUS_10                           = 0x0020,
+  HID_USAGE_CONSUMER_PLUS_100                          = 0x0021,
+  HID_USAGE_CONSUMER_AM_PM                             = 0x0022,
+  // 23-3F Reserved
 
   // Power Control
   HID_USAGE_CONSUMER_POWER                             = 0x0030,
   HID_USAGE_CONSUMER_RESET                             = 0x0031,
   HID_USAGE_CONSUMER_SLEEP                             = 0x0032,
 
+  HID_USAGE_CONSUMER_SLEEP_AFTER                       = 0x0033,
+  HID_USAGE_CONSUMER_SLEEP_MODE                        = 0x0034,
+  HID_USAGE_CONSUMER_ILLUMINATION                      = 0x0035,
+  HID_USAGE_CONSUMER_FUNCTION_BUTTONS                  = 0x0036,
+  // 37-3F Reserved
+  HID_USAGE_CONSUMER_MENU                              = 0x0040,
+  HID_USAGE_CONSUMER_MENU_PICK                         = 0x0041,
+  HID_USAGE_CONSUMER_MENU_UP                           = 0x0042,
+  HID_USAGE_CONSUMER_MENU_DOWN                         = 0x0043,
+  HID_USAGE_CONSUMER_MENU_LEFT                         = 0x0044,
+  HID_USAGE_CONSUMER_MENU_RIGHT                        = 0x0045,
+  HID_USAGE_CONSUMER_MENU_ESCAPE                       = 0x0046,
+  HID_USAGE_CONSUMER_MENU_VALUE_INCREASE               = 0x0047,
+  HID_USAGE_CONSUMER_MENU_VALUE_DECREASE               = 0x0048,
+  // 49-5F Reserved
+  HID_USAGE_CONSUMER_DATA_ON_SCREEN                    = 0x0060,
+  HID_USAGE_CONSUMER_CLOSED_CAPTION                    = 0x0061,
+  HID_USAGE_CONSUMER_CLOSED_CAPTION_SELECT             = 0x0062,
+  HID_USAGE_CONSUMER_VCR_TV                            = 0x0063,
+  HID_USAGE_CONSUMER_BROADCAST_MODE                    = 0x0064,
+  HID_USAGE_CONSUMER_SNAPSHOT                          = 0x0065,
+  HID_USAGE_CONSUMER_STILL                             = 0x0066,
+
+  // 67-7F Reserved
   // Screen Brightness
   HID_USAGE_CONSUMER_BRIGHTNESS_INCREMENT              = 0x006F,
   HID_USAGE_CONSUMER_BRIGHTNESS_DECREMENT              = 0x0070,
@@ -912,40 +951,382 @@ enum {
   HID_USAGE_CONSUMER_WIRELESS_RADIO_LED                = 0x00C7,
   HID_USAGE_CONSUMER_WIRELESS_RADIO_SLIDER_SWITCH      = 0x00C8,
 
+  HID_USAGE_CONSUMER_SELECTION                         = 0x0080,
+  HID_USAGE_CONSUMER_ASSIGN_SELECTION                  = 0x0081,
+  HID_USAGE_CONSUMER_MODE_STEP                         = 0x0082,
+  HID_USAGE_CONSUMER_RECALL_LAST                       = 0x0083,
+  HID_USAGE_CONSUMER_ENTER_CHANNEL                     = 0x0084,
+  HID_USAGE_CONSUMER_ORDER_MOVIE                       = 0x0085,
+  HID_USAGE_CONSUMER_CHANNEL                           = 0x0086,
+  HID_USAGE_CONSUMER_MEDIA_SELECTION                   = 0x0087,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_COMPUTER             = 0x0088,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_TV                   = 0x0089,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_WWW                  = 0x008A,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_DVD                  = 0x008B,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_TELEPHONE            = 0x008C,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_PROGRAM_GUIDE        = 0x008D,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_VIDEO_PHONE          = 0x008E,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_GAMES                = 0x008F,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_MESSAGES             = 0x0090,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_CD                   = 0x0091,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_VCR                  = 0x0092,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_TUNER                = 0x0093,
+  HID_USAGE_CONSUMER_QUIT                              = 0x0094,
+  HID_USAGE_CONSUMER_HELP                              = 0x0095,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_TAPE                 = 0x0096,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_CABLE                = 0x0097,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_SATELLITE            = 0x0098,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_SECURITY             = 0x0099,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_HOME                 = 0x009A,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_CALL                 = 0x009B,
+  HID_USAGE_CONSUMER_CHANNEL_INCREMENT                 = 0x009C,
+  HID_USAGE_CONSUMER_CHANNEL_DECREMENT                 = 0x009D,
+  HID_USAGE_CONSUMER_MEDIA_SELECT_SAP                  = 0x009E,
+  // 9F Reserved
+  HID_USAGE_CONSUMER_VCR_PLUS                          = 0x00A0,
+  HID_USAGE_CONSUMER_ONCE                              = 0x00A1,
+  HID_USAGE_CONSUMER_DAILY                             = 0x00A2,
+  HID_USAGE_CONSUMER_WEEKLY                            = 0x00A3,
+  HID_USAGE_CONSUMER_MONTHLY                           = 0x00A4,
+  // A5-AF Reserved
+
+  HID_USAGE_CONSUMER_PLAY                              = 0x00B0,
+  HID_USAGE_CONSUMER_PAUSE                             = 0x00B1,
+  HID_USAGE_CONSUMER_RECORD                            = 0x00B2,
+  HID_USAGE_CONSUMER_FAST_FORWARD                      = 0x00B3,
+  HID_USAGE_CONSUMER_REWIND                            = 0x00B4,
+  HID_USAGE_CONSUMER_SCAN_NEXT_TRACK                   = 0x00B5,
+  HID_USAGE_CONSUMER_SCAN_PREVIOUS_TRACK               = 0x00B6,
+  HID_USAGE_CONSUMER_STOP                              = 0x00B7,
+  HID_USAGE_CONSUMER_EJECT                             = 0x00B8,
+  HID_USAGE_CONSUMER_RANDOM_PLAY                       = 0x00B9,
+  HID_USAGE_CONSUMER_SELECT_DISC                       = 0x00BA,
+  HID_USAGE_CONSUMER_ENTER_DISC                        = 0x00BB,
+  HID_USAGE_CONSUMER_REPEAT                            = 0x00BC,
+  HID_USAGE_CONSUMER_TRACKING                          = 0x00BD,
+  HID_USAGE_CONSUMER_TRACK_NORMAL                      = 0x00BE,
+  HID_USAGE_CONSUMER_SLOW_TRACKING                     = 0x00BF,
+  HID_USAGE_CONSUMER_FRAME_FORWARD                     = 0x00C0,
+  HID_USAGE_CONSUMER_FRAME_BACK                        = 0x00C1,
+  HID_USAGE_CONSUMER_MARK                              = 0x00C2,
+  HID_USAGE_CONSUMER_CLEAR_MARK                        = 0x00C3,
+  HID_USAGE_CONSUMER_REPEAT_FROM_MARK                  = 0x00C4,
+  HID_USAGE_CONSUMER_RETURN_TO_MARK                    = 0x00C5,
+  HID_USAGE_CONSUMER_SEARCH_MARK_FORWARD               = 0x00C6,
+  HID_USAGE_CONSUMER_SEARCH_MARK_BACKWARDS             = 0x00C7,
+  HID_USAGE_CONSUMER_COUNTER_RESET                     = 0x00C8,
+  HID_USAGE_CONSUMER_SHOW_COUNTER                      = 0x00C9,
+  HID_USAGE_CONSUMER_TRACKING_INCREMENT                = 0x00CA,
+  HID_USAGE_CONSUMER_TRACKING_DECREMENT                = 0x00CB,
+  HID_USAGE_CONSUMER_STOP_EJECT                        = 0x00CC,
+
+
   // Media Control
   HID_USAGE_CONSUMER_PLAY_PAUSE                        = 0x00CD,
-  HID_USAGE_CONSUMER_SCAN_NEXT                         = 0x00B5,
-  HID_USAGE_CONSUMER_SCAN_PREVIOUS                     = 0x00B6,
-  HID_USAGE_CONSUMER_STOP                              = 0x00B7,
+
+  HID_USAGE_CONSUMER_PLAY_SKIP                         = 0x00CE,
+
+  // CF-DF Reserved
   HID_USAGE_CONSUMER_VOLUME                            = 0x00E0,
+  HID_USAGE_CONSUMER_BALANCE                           = 0x00E1,
   HID_USAGE_CONSUMER_MUTE                              = 0x00E2,
   HID_USAGE_CONSUMER_BASS                              = 0x00E3,
   HID_USAGE_CONSUMER_TREBLE                            = 0x00E4,
   HID_USAGE_CONSUMER_BASS_BOOST                        = 0x00E5,
+  HID_USAGE_CONSUMER_SURROUND_MODE                     = 0x00E6,
+  HID_USAGE_CONSUMER_LOUDNESS                          = 0x00E7,
+  HID_USAGE_CONSUMER_MPX                               = 0x00E8,
   HID_USAGE_CONSUMER_VOLUME_INCREMENT                  = 0x00E9,
   HID_USAGE_CONSUMER_VOLUME_DECREMENT                  = 0x00EA,
+  // EB-EF Reserved
+  HID_USAGE_CONSUMER_SPEED_SELECT                      = 0x00F0,
+  HID_USAGE_CONSUMER_PLAYBACK_SPEED                    = 0x00F1,
+  HID_USAGE_CONSUMER_STANDARD_PLAY                     = 0x00F2,
+  HID_USAGE_CONSUMER_LONG_PLAY                         = 0x00F3,
+  HID_USAGE_CONSUMER_EXTENDED_PLAY                     = 0x00F4,
+  HID_USAGE_CONSUMER_SLOW                              = 0x00F5,
+  // F6-FF Reserved
+  HID_USAGE_CONSUMER_FAN_ENABLE                        = 0x0100,
+  HID_USAGE_CONSUMER_FAN_SPEED                         = 0x0101,
+  HID_USAGE_CONSUMER_LIGHT_ENABLE                      = 0x0102,
+  HID_USAGE_CONSUMER_LIGHT_ILLUMINATION_LEVEL          = 0x0103,
+  HID_USAGE_CONSUMER_CLIMATE_CONTROL_ENABLE            = 0x0104,
+  HID_USAGE_CONSUMER_ROOM_TEMPERATURE                  = 0x0105,
+  HID_USAGE_CONSUMER_SECURITY_ENABLE                   = 0x0106,
+  HID_USAGE_CONSUMER_FIRE_ALARM                        = 0x0107,
+  HID_USAGE_CONSUMER_POLICE_ALARM                      = 0x0108,
+  HID_USAGE_CONSUMER_PROXIMITY                         = 0x0109,
+  HID_USAGE_CONSUMER_MOTION                            = 0x010A,
+  HID_USAGE_CONSUMER_DURESS_ALARM                      = 0x010B,
+  HID_USAGE_CONSUMER_HOLDUP_ALARM                      = 0x010C,
+  HID_USAGE_CONSUMER_MEDICAL_ALARM                     = 0x010D,
+  // 10E-14F Reserved
+  HID_USAGE_CONSUMER_BALANCE_RIGHT                     = 0x0150,
+  HID_USAGE_CONSUMER_BALANCE_LEFT                      = 0x0151,
   HID_USAGE_CONSUMER_BASS_INCREMENT                    = 0x0152,
   HID_USAGE_CONSUMER_BASS_DECREMENT                    = 0x0153,
   HID_USAGE_CONSUMER_TREBLE_INCREMENT                  = 0x0154,
   HID_USAGE_CONSUMER_TREBLE_DECREMENT                  = 0x0155,
 
-  // Application Launcher
+  // 156-15F Reserved
+  HID_USAGE_CONSUMER_SPEAKER_SYSTEM                    = 0x0160,
+  HID_USAGE_CONSUMER_CHANNEL_LEFT                      = 0x0161,
+  HID_USAGE_CONSUMER_CHANNEL_RIGHT                     = 0x0162,
+  HID_USAGE_CONSUMER_CHANNEL_CENTER                    = 0x0163,
+  HID_USAGE_CONSUMER_CHANNEL_FRONT                     = 0x0164,
+  HID_USAGE_CONSUMER_CHANNEL_CENTER_FRONT              = 0x0165,
+  HID_USAGE_CONSUMER_CHANNEL_SIDE                      = 0x0166,
+  HID_USAGE_CONSUMER_CHANNEL_SURROUND                  = 0x0167,
+  HID_USAGE_CONSUMER_CHANNEL_LOW_FREQUENCY             = 0x0168,
+  // Enhancement
+  // CL 15.12.1
+  HID_USAGE_CONSUMER_CHANNEL_TOP                       = 0x0169,
+  HID_USAGE_CONSUMER_CHANNEL_UNKNOWN                   = 0x016A,
+  // 16B-16F Reserved
+  HID_USAGE_CONSUMER_SUB_CHANNEL                       = 0x0170,
+  HID_USAGE_CONSUMER_SUB_CHANNEL_INCREMENT             = 0x0171,
+  HID_USAGE_CONSUMER_SUB_CHANNEL_DECREMENT             = 0x0172,
+  HID_USAGE_CONSUMER_ALTERNATE_AUDIO_INCREMENT         = 0x0173,
+  HID_USAGE_CONSUMER_ALTERNATE_AUDIO_DECREMENT         = 0x0174,
+  // 175-17F Reserved
+  HID_USAGE_CONSUMER_APPLICATION_LAUNCH_BUTTONS        = 0x0180,
+  HID_USAGE_CONSUMER_AL_LAUNCH_BUTTON_CONFIGURATION    = 0x0181,
+  // Tool
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_PROGRAMMABLE_BUTTON            = 0x0182,
+  // Configuration
+  // Sel 15.15
   HID_USAGE_CONSUMER_AL_CONSUMER_CONTROL_CONFIGURATION = 0x0183,
+  // Configuration
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_WORD_PROCESSOR                 = 0x0184,
+  HID_USAGE_CONSUMER_AL_TEXT_EDITOR                    = 0x0185,
+  HID_USAGE_CONSUMER_AL_SPREADSHEET                    = 0x0186,
+  HID_USAGE_CONSUMER_AL_GRAPHICS_EDITOR                = 0x0187,
+  HID_USAGE_CONSUMER_AL_PRESENTATION_APP               = 0x0188,
+  HID_USAGE_CONSUMER_AL_DATABASE_APP                   = 0x0189,
   HID_USAGE_CONSUMER_AL_EMAIL_READER                   = 0x018A,
+  HID_USAGE_CONSUMER_AL_NEWSREADER                     = 0x018B,
+  HID_USAGE_CONSUMER_AL_VOICEMAIL                      = 0x018C,
+  HID_USAGE_CONSUMER_AL_CONTACTS_ADDRESS_BOOK          = 0x018D,
+  HID_USAGE_CONSUMER_AL_CALENDAR_SCHEDULE              = 0x018E,
+  HID_USAGE_CONSUMER_AL_TASK_PROJECT_MANAGER           = 0x018F,
+  HID_USAGE_CONSUMER_AL_LOG_JOURNAL_TIMECARD           = 0x0190,
+  HID_USAGE_CONSUMER_AL_CHECKBOOK_FINANCE              = 0x0191,
   HID_USAGE_CONSUMER_AL_CALCULATOR                     = 0x0192,
-  HID_USAGE_CONSUMER_AL_LOCAL_BROWSER                  = 0x0194,
-
+  HID_USAGE_CONSUMER_AL_A_V_CAPTURE_PLAYBACK           = 0x0193,
+  HID_USAGE_CONSUMER_AL_LOCAL_MACHINE_BROWSER          = 0x0194,
+  HID_USAGE_CONSUMER_AL_LAN_WAN_BROWSER                = 0x0195,
+  HID_USAGE_CONSUMER_AL_INTERNET_BROWSER               = 0x0196,
+  HID_USAGE_CONSUMER_AL_REMOTE_NETWORKING_ISP          = 0x0197,
+  // Connect
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_NETWORK_CONFERENCE             = 0x0198,
+  HID_USAGE_CONSUMER_AL_NETWORK_CHAT                   = 0x0199,
+  HID_USAGE_CONSUMER_AL_TELEPHONY_DIALER               = 0x019A,
+  HID_USAGE_CONSUMER_AL_LOGON                          = 0x019B,
+  HID_USAGE_CONSUMER_AL_LOGOFF                         = 0x019C,
+  HID_USAGE_CONSUMER_AL_LOGON_LOGOFF                   = 0x019D,
+  HID_USAGE_CONSUMER_AL_TERMINAL_LOCK_SCREENSAVER      = 0x019E,
+  HID_USAGE_CONSUMER_AL_CONTROL_PANEL                  = 0x019F,
+  HID_USAGE_CONSUMER_AL_COMMAND_LINE_PROCESSOR_RUN     = 0x01A0,
+  HID_USAGE_CONSUMER_AL_PROCESS_TASK_MANAGER           = 0x01A1,
+  HID_USAGE_CONSUMER_AL_SELECT_TASK_APPLICATION        = 0x01A2,
+  HID_USAGE_CONSUMER_AL_NEXT_TASK_APPLICATION          = 0x01A3,
+  HID_USAGE_CONSUMER_AL_PREVIOUS_TASK_APPLICATION      = 0x01A4,
+  HID_USAGE_CONSUMER_AL_PREEMPTIVE_HALT                = 0x01A5,
+  // Task_Application
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_INTEGRATED_HELP_CENTER         = 0x01A6,
+  HID_USAGE_CONSUMER_AL_DOCUMENTS                      = 0x01A7,
+  HID_USAGE_CONSUMER_AL_THESAURUS                      = 0x01A8,
+  HID_USAGE_CONSUMER_AL_DICTIONARY                     = 0x01A9,
+  HID_USAGE_CONSUMER_AL_DESKTOP                        = 0x01AA,
+  HID_USAGE_CONSUMER_AL_SPELL_CHECK                    = 0x01AB,
+  HID_USAGE_CONSUMER_AL_GRAMMAR_CHECK                  = 0x01AC,
+  HID_USAGE_CONSUMER_AL_WIRELESS_STATUS                = 0x01AD,
+  HID_USAGE_CONSUMER_AL_KEYBOARD_LAYOUT                = 0x01AE,
+  HID_USAGE_CONSUMER_AL_VIRUS_PROTECTION               = 0x01AF,
+  HID_USAGE_CONSUMER_AL_ENCRYPTION                     = 0x01B0,
+  HID_USAGE_CONSUMER_AL_SCREEN_SAVER                   = 0x01B1,
+  HID_USAGE_CONSUMER_AL_ALARMS                         = 0x01B2,
+  HID_USAGE_CONSUMER_AL_CLOCK                          = 0x01B3,
+  HID_USAGE_CONSUMER_AL_FILE_BROWSER                   = 0x01B4,
+  HID_USAGE_CONSUMER_AL_POWER_STATUS                   = 0x01B5,
+  HID_USAGE_CONSUMER_AL_IMAGE_BROWSER                  = 0x01B6,
+  HID_USAGE_CONSUMER_AL_AUDIO_BROWSER                  = 0x01B7,
+  HID_USAGE_CONSUMER_AL_MOVIE_BROWSER                  = 0x01B8,
+  HID_USAGE_CONSUMER_AL_DIGITAL_RIGHTS_MANAGER         = 0x01B9,
+  HID_USAGE_CONSUMER_AL_DIGITAL_WALLET                 = 0x01BA,
+  // 1BB Reserved
+  HID_USAGE_CONSUMER_AL_INSTANT_MESSAGING              = 0x01BC,
+  HID_USAGE_CONSUMER_AL_OEM_FEATURES_TIPS_TUTORIAL     = 0x01BD,
+  // Browser
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_OEM_HELP                       = 0x01BE,
+  HID_USAGE_CONSUMER_AL_ONLINE_COMMUNITY               = 0x01BF,
+  HID_USAGE_CONSUMER_AL_ENTERTAINMENT_CONTENT          = 0x01C0,
+  // Browser
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_ONLINE_SHOPPING_BROWSER        = 0x01C1,
+  HID_USAGE_CONSUMER_AL_SMARTCARD_INFORMATION_HELP     = 0x01C2,
+  HID_USAGE_CONSUMER_AL_MARKET_MONITOR_FINANCE         = 0x01C3,
+  // Browser
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_CUSTOMIZED_CORPORATE_NEWS      = 0x01C4,
+  // Browser
+  // Sel 15.15
+  HID_USAGE_CONSUMER_AL_ONLINE_ACTIVITY_BROWSER        = 0x01C5,
+  HID_USAGE_CONSUMER_AL_RESEARCH_SEARCH_BROWSER        = 0x01C6,
+  HID_USAGE_CONSUMER_AL_AUDIO_PLAYER                   = 0x01C7,
+  // 1C8-1FF Reserved
+  HID_USAGE_CONSUMER_GENERIC_GUI_APPLICATION           = 0x0200,
+  // ' Controls
+  // '
+  HID_USAGE_CONSUMER_AC_NEW                            = 0x0201,
+  HID_USAGE_CONSUMER_AC_OPEN                           = 0x0202,
+  HID_USAGE_CONSUMER_AC_CLOSE                          = 0x0203,
+  HID_USAGE_CONSUMER_AC_EXIT                           = 0x0204,
+  HID_USAGE_CONSUMER_AC_MAXIMIZE                       = 0x0205,
+  HID_USAGE_CONSUMER_AC_MINIMIZE                       = 0x0206,
+  HID_USAGE_CONSUMER_AC_SAVE                           = 0x0207,
+  HID_USAGE_CONSUMER_AC_PRINT                          = 0x0208,
+  HID_USAGE_CONSUMER_AC_PROPERTIES                     = 0x0209,
+  HID_USAGE_CONSUMER_AC_UNDO                           = 0x021A,
+  HID_USAGE_CONSUMER_AC_COPY                           = 0x021B,
+  HID_USAGE_CONSUMER_AC_CUT                            = 0x021C,
+  HID_USAGE_CONSUMER_AC_PASTE                          = 0x021D,
+  HID_USAGE_CONSUMER_AC_SELECT_ALL                     = 0x021E,
+  HID_USAGE_CONSUMER_AC_FIND                           = 0x021F,
+  HID_USAGE_CONSUMER_AC_FIND_AND_REPLACE               = 0x0220,
   // Browser/Explorer Specific
   HID_USAGE_CONSUMER_AC_SEARCH                         = 0x0221,
+  HID_USAGE_CONSUMER_AC_GO_TO                          = 0x0222,
   HID_USAGE_CONSUMER_AC_HOME                           = 0x0223,
   HID_USAGE_CONSUMER_AC_BACK                           = 0x0224,
   HID_USAGE_CONSUMER_AC_FORWARD                        = 0x0225,
   HID_USAGE_CONSUMER_AC_STOP                           = 0x0226,
   HID_USAGE_CONSUMER_AC_REFRESH                        = 0x0227,
+  HID_USAGE_CONSUMER_AC_PREVIOUS_LINK                  = 0x0228,
+  HID_USAGE_CONSUMER_AC_NEXT_LINK                      = 0x0229,
   HID_USAGE_CONSUMER_AC_BOOKMARKS                      = 0x022A,
-
+  HID_USAGE_CONSUMER_AC_HISTORY                        = 0x022B,
+  HID_USAGE_CONSUMER_AC_SUBSCRIPTIONS                  = 0x022C,
+  HID_USAGE_CONSUMER_AC_ZOOM_IN                        = 0x022D,
+  HID_USAGE_CONSUMER_AC_ZOOM_OUT                       = 0x022E,
+  HID_USAGE_CONSUMER_AC_ZOOM                           = 0x022F,
+  HID_USAGE_CONSUMER_AC_FULL_SCREEN_VIEW               = 0x0230,
+  HID_USAGE_CONSUMER_AC_NORMAL_VIEW                    = 0x0231,
+  HID_USAGE_CONSUMER_AC_VIEW_TOGGLE                    = 0x0232,
+  HID_USAGE_CONSUMER_AC_SCROLL_UP                      = 0x0233,
+  HID_USAGE_CONSUMER_AC_SCROLL_DOWN                    = 0x0234,
+  HID_USAGE_CONSUMER_AC_SCROLL                         = 0x0235,
+  HID_USAGE_CONSUMER_AC_PAN_LEFT                       = 0x0236,
+  HID_USAGE_CONSUMER_AC_PAN_RIGHT                      = 0x0237,
   // Mouse Horizontal scroll
   HID_USAGE_CONSUMER_AC_PAN                            = 0x0238,
+  HID_USAGE_CONSUMER_AC_NEW_WINDOW                     = 0x0239,
+  HID_USAGE_CONSUMER_AC_TILE_HORIZONTALLY              = 0x023A,
+  HID_USAGE_CONSUMER_AC_TILE_VERTICALLY                = 0x023B,
+  HID_USAGE_CONSUMER_AC_FORMAT                         = 0x023C,
+  HID_USAGE_CONSUMER_AC_EDIT                           = 0x023D,
+  HID_USAGE_CONSUMER_AC_BOLD                           = 0x023E,
+  HID_USAGE_CONSUMER_AC_ITALICS                        = 0x023F,
+  HID_USAGE_CONSUMER_AC_UNDERLINE                      = 0x0240,
+  HID_USAGE_CONSUMER_AC_STRIKETHROUGH                  = 0x0241,
+  HID_USAGE_CONSUMER_AC_SUBSCRIPT                      = 0x0242,
+  HID_USAGE_CONSUMER_AC_SUPERSCRIPT                    = 0x0243,
+  HID_USAGE_CONSUMER_AC_ALL_CAPS                       = 0x0244,
+  HID_USAGE_CONSUMER_AC_ROTATE                         = 0x0245,
+  HID_USAGE_CONSUMER_AC_RESIZE                         = 0x0246,
+  HID_USAGE_CONSUMER_AC_FLIP_HORIZONTAL                = 0x0247,
+  HID_USAGE_CONSUMER_AC_FLIP_VERTICAL                  = 0x0248,
+  HID_USAGE_CONSUMER_AC_MIRROR_HORIZONTAL              = 0x0249,
+  HID_USAGE_CONSUMER_AC_MIRROR_VERTICAL                = 0x024A,
+  HID_USAGE_CONSUMER_AC_FONT_SELECT                    = 0x024B,
+  HID_USAGE_CONSUMER_AC_FONT_COLOR                     = 0x024C,
+  HID_USAGE_CONSUMER_AC_FONT_SIZE                      = 0x024D,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_LEFT                   = 0x024E,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_CENTER_H               = 0x024F,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_RIGHT                  = 0x0250,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_BLOCK_H                = 0x0251,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_TOP                    = 0x0252,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_CENTER_V               = 0x0253,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_BOTTOM                 = 0x0254,
+  HID_USAGE_CONSUMER_AC_JUSTIFY_BLOCK_V                = 0x0255,
+  HID_USAGE_CONSUMER_AC_INDENT_DECREASE                = 0x0256,
+  HID_USAGE_CONSUMER_AC_INDENT_INCREASE                = 0x0257,
+  HID_USAGE_CONSUMER_AC_NUMBERED_LIST                  = 0x0258,
+  HID_USAGE_CONSUMER_AC_RESTART_NUMBERING              = 0x0259,
+  HID_USAGE_CONSUMER_AC_BULLETED_LIST                  = 0x025A,
+  HID_USAGE_CONSUMER_AC_PROMOTE                        = 0x025B,
+  HID_USAGE_CONSUMER_AC_DEMOTE                         = 0x025C,
+  HID_USAGE_CONSUMER_AC_YES                            = 0x025D,
+  HID_USAGE_CONSUMER_AC_NO                             = 0x025E,
+  HID_USAGE_CONSUMER_AC_CANCEL                         = 0x025F,
+  HID_USAGE_CONSUMER_AC_CATALOG                        = 0x0260,
+  HID_USAGE_CONSUMER_AC_BUY_CHECKOUT                   = 0x0261,
+  HID_USAGE_CONSUMER_AC_ADD_TO_CART                    = 0x0262,
+  HID_USAGE_CONSUMER_AC_EXPAND                         = 0x0263,
+  HID_USAGE_CONSUMER_AC_EXPAND_ALL                     = 0x0264,
+  HID_USAGE_CONSUMER_AC_COLLAPSE                       = 0x0265,
+  HID_USAGE_CONSUMER_AC_COLLAPSE_ALL                   = 0x0266,
+  HID_USAGE_CONSUMER_AC_PRINT_PREVIEW                  = 0x0267,
+  HID_USAGE_CONSUMER_AC_PASTE_SPECIAL                  = 0x0268,
+  HID_USAGE_CONSUMER_AC_INSERT_MODE                    = 0x0269,
+  HID_USAGE_CONSUMER_AC_DELETE                         = 0x026A,
+  HID_USAGE_CONSUMER_AC_LOCK                           = 0x026B,
+  HID_USAGE_CONSUMER_AC_UNLOCK                         = 0x026C,
+  HID_USAGE_CONSUMER_AC_PROTECT                        = 0x026D,
+  HID_USAGE_CONSUMER_AC_UNPROTECT                      = 0x026E,
+  HID_USAGE_CONSUMER_AC_ATTACH_COMMENT                 = 0x026F,
+  HID_USAGE_CONSUMER_AC_DELETE_COMMENT                 = 0x0270,
+  HID_USAGE_CONSUMER_AC_VIEW_COMMENT                   = 0x0271,
+  HID_USAGE_CONSUMER_AC_SELECT_WORD                    = 0x0272,
+  HID_USAGE_CONSUMER_AC_SELECT_SENTENCE                = 0x0273,
+  HID_USAGE_CONSUMER_AC_SELECT_PARAGRAPH               = 0x0274,
+  HID_USAGE_CONSUMER_AC_SELECT_COLUMN                  = 0x0275,
+  HID_USAGE_CONSUMER_AC_SELECT_ROW                     = 0x0276,
+  HID_USAGE_CONSUMER_AC_SELECT_TABLE                   = 0x0277,
+  HID_USAGE_CONSUMER_AC_SELECT_OBJECT                  = 0x0278,
+  HID_USAGE_CONSUMER_AC_REDO_REPEAT                    = 0x0279,
+  HID_USAGE_CONSUMER_AC_SORT                           = 0x027A,
+  HID_USAGE_CONSUMER_AC_SORT_ASCENDING                 = 0x027B,
+  HID_USAGE_CONSUMER_AC_SORT_DESCENDING                = 0x027C,
+  HID_USAGE_CONSUMER_AC_FILTER                         = 0x027D,
+  HID_USAGE_CONSUMER_AC_SET_CLOCK                      = 0x027E,
+  HID_USAGE_CONSUMER_AC_VIEW_CLOCK                     = 0x027F,
+  HID_USAGE_CONSUMER_AC_SELECT_TIME_ZONE               = 0x0280,
+  HID_USAGE_CONSUMER_AC_EDIT_TIME_ZONES                = 0x0281,
+  HID_USAGE_CONSUMER_AC_SET_ALARM                      = 0x0282,
+  HID_USAGE_CONSUMER_AC_CLEAR_ALARM                    = 0x0283,
+  HID_USAGE_CONSUMER_AC_SNOOZE_ALARM                   = 0x0284,
+  HID_USAGE_CONSUMER_AC_RESET_ALARM                    = 0x0285,
+  HID_USAGE_CONSUMER_AC_SYNCHRONIZE                    = 0x0286,
+  HID_USAGE_CONSUMER_AC_SEND_RECEIVE                   = 0x0287,
+  HID_USAGE_CONSUMER_AC_SEND_TO                        = 0x0288,
+  HID_USAGE_CONSUMER_AC_REPLY                          = 0x0289,
+  HID_USAGE_CONSUMER_AC_REPLY_ALL                      = 0x028A,
+  HID_USAGE_CONSUMER_AC_FORWARD_MSG                    = 0x028B,
+  HID_USAGE_CONSUMER_AC_SEND                           = 0x028C,
+  HID_USAGE_CONSUMER_AC_ATTACH_FILE                    = 0x028D,
+  HID_USAGE_CONSUMER_AC_UPLOAD                         = 0x028E,
+  HID_USAGE_CONSUMER_AC_DOWNLOAD_SAVE_TARGET_AS        = 0x028F,
+  HID_USAGE_CONSUMER_AC_SET_BORDERS                    = 0x0290,
+  HID_USAGE_CONSUMER_AC_INSERT_ROW                     = 0x0291,
+  HID_USAGE_CONSUMER_AC_INSERT_COLUMN                  = 0x0292,
+  HID_USAGE_CONSUMER_AC_INSERT_FILE                    = 0x0293,
+  HID_USAGE_CONSUMER_AC_INSERT_PICTURE                 = 0x0294,
+  HID_USAGE_CONSUMER_AC_INSERT_OBJECT                  = 0x0295,
+  HID_USAGE_CONSUMER_AC_INSERT_SYMBOL                  = 0x0296,
+  HID_USAGE_CONSUMER_AC_SAVE_AND_CLOSE                 = 0x0297,
+  HID_USAGE_CONSUMER_AC_RENAME                         = 0x0298,
+  HID_USAGE_CONSUMER_AC_MERGE                          = 0x0299,
+  HID_USAGE_CONSUMER_AC_SPLIT                          = 0x029A,
+  HID_USAGE_CONSUMER_AC_DISRIBUTE_HORIZONTALLY         = 0x029B,
+  HID_USAGE_CONSUMER_AC_DISTRIBUTE_VERTICALLY          = 0x029C,
+  // 29D-FFFF Reserved
+
 };
 
 /// HID Usage Table: Digitizer Page (0x0D)
@@ -1216,6 +1597,200 @@ enum {
   HID_USAGE_LIGHTING_AUTONOMOUS_MODE                     = 0x71,
 };
 
+/// HID Usage Table: Power Device Page (0x84)
+enum {
+  HID_USAGE_POWER_UNDEFINED              = 0x00,
+  HID_USAGE_POWER_I_NAME                 = 0x01,
+  HID_USAGE_POWER_PRESENT_STATUS         = 0x02,
+  HID_USAGE_POWER_CHANGED_STATUS         = 0x03,
+  HID_USAGE_POWER_UPS                    = 0x04,
+  HID_USAGE_POWER_POWER_SUPPLY           = 0x05,
+  // 06-0F Reserved
+  HID_USAGE_POWER_BATTERY_SYSTEM         = 0x10,
+  HID_USAGE_POWER_BATTERY_SYSTEM_ID      = 0x11,
+  HID_USAGE_POWER_BATTERY                = 0x12,
+  HID_USAGE_POWER_BATTERY_ID             = 0x13,
+  HID_USAGE_POWER_CHARGER                = 0x14,
+  HID_USAGE_POWER_CHARGER_ID             = 0x15,
+  HID_USAGE_POWER_POWER_CONVERTER        = 0x16,
+  HID_USAGE_POWER_POWER_CONVERTER_ID     = 0x17,
+  HID_USAGE_POWER_OUTLET_SYSTEM          = 0x18,
+  HID_USAGE_POWER_OUTLET_SYSTEM_ID       = 0x19,
+  HID_USAGE_POWER_INPUT                  = 0x1A,
+  HID_USAGE_POWER_INPUT_ID               = 0x1B,
+  HID_USAGE_POWER_OUTPUT                 = 0x1C,
+  HID_USAGE_POWER_OUTPUT_ID              = 0x1D,
+  HID_USAGE_POWER_FLOW                   = 0x1E,
+  HID_USAGE_POWER_FLOW_ID                = 0x1F,
+  HID_USAGE_POWER_OUTLET                 = 0x20,
+  HID_USAGE_POWER_OUTLET_ID              = 0x21,
+  HID_USAGE_POWER_GANG                   = 0x22,
+  HID_USAGE_POWER_GANG_ID                = 0x23,
+  HID_USAGE_POWER_POWER_SUMMARY          = 0x24,
+  HID_USAGE_POWER_POWER_SUMMARY_ID       = 0x25,
+  // 26-2F Reserved
+  HID_USAGE_POWER_VOLTAGE                = 0x30,
+  HID_USAGE_POWER_CURRENT                = 0x31,
+  HID_USAGE_POWER_FREQUENCY              = 0x32,
+  HID_USAGE_POWER_APPARENT_POWER         = 0x33,
+  HID_USAGE_POWER_ACTIVE_POWER           = 0x34,
+  HID_USAGE_POWER_PERCENT_LOAD           = 0x35,
+  HID_USAGE_POWER_TEMPERATURE            = 0x36,
+  HID_USAGE_POWER_HUMIDITY               = 0x37,
+  HID_USAGE_POWER_BAD_COUNT              = 0x38,
+  // 39-3F Reserved
+  HID_USAGE_POWER_CONFIG_VOLTAGE         = 0x40,
+  HID_USAGE_POWER_CONFIG_CURRENT         = 0x41,
+  HID_USAGE_POWER_CONFIG_FREQUENCY       = 0x42,
+  HID_USAGE_POWER_CONFIG_APPARENT_POWER  = 0x43,
+  HID_USAGE_POWER_CONFIG_ACTIVE_POWER    = 0x44,
+  HID_USAGE_POWER_CONFIG_PERCENT_LOAD    = 0x45,
+  HID_USAGE_POWER_CONFIG_TEMPERATURE     = 0x46,
+  HID_USAGE_POWER_CONFIG_HUMIDITY        = 0x47,
+  // 48-4F Reserved
+  HID_USAGE_POWER_SWITCH_ON_CONTROL      = 0x50,
+  HID_USAGE_POWER_SWITCH_OFF_CONTROL     = 0x51,
+  HID_USAGE_POWER_TOGGLE_CONTROL         = 0x52,
+  HID_USAGE_POWER_LOW_VOLTAGE_TRANSFER   = 0x53,
+  HID_USAGE_POWER_HIGH_VOLTAGE_TRANSFER  = 0x54,
+  HID_USAGE_POWER_DELAY_BEFORE_REBOOT    = 0x55,
+  HID_USAGE_POWER_DELAY_BEFORE_STARTUP   = 0x56,
+  HID_USAGE_POWER_DELAY_BEFORE_SHUTDOWN  = 0x57,
+  HID_USAGE_POWER_TEST                   = 0x58,
+  HID_USAGE_POWER_MODULE_RESET           = 0x59,
+  HID_USAGE_POWER_AUDIBLE_ALARM_CONTROL  = 0x5A,
+  // 5B-5F Reserved
+  HID_USAGE_POWER_PRESENT                = 0x60,
+  HID_USAGE_POWER_GOOD                   = 0x61,
+  HID_USAGE_POWER_INTERNAL_FAILURE       = 0x62,
+  HID_USAGE_POWER_VOLTAGE_OUT_OF_RANGE   = 0x63,
+  HID_USAGE_POWER_FREQUENCY_OUT_OF_RANGE = 0x64,
+  HID_USAGE_POWER_OVERLOAD               = 0x65,
+  HID_USAGE_POWER_OVER_CHARGED           = 0x66,
+  HID_USAGE_POWER_OVER_TEMPERATURE       = 0x67,
+  HID_USAGE_POWER_SHUTDOWN_REQUESTED     = 0x68,
+  HID_USAGE_POWER_SHUTDOWN_IMMINENT      = 0x69,
+  // 6A Reserved
+  HID_USAGE_POWER_SWITCH_ON_OFF          = 0x6B,
+  HID_USAGE_POWER_SWITCHABLE             = 0x6C,
+  HID_USAGE_POWER_USED                   = 0x6D,
+  HID_USAGE_POWER_BOOST                  = 0x6E,
+  HID_USAGE_POWER_BUCK                   = 0x6F,
+  HID_USAGE_POWER_INITIALIZED            = 0x70,
+  HID_USAGE_POWER_TESTED                 = 0x71,
+  HID_USAGE_POWER_AWAITING_POWER         = 0x72,
+  HID_USAGE_POWER_COMMUNICATION_LOST     = 0x73,
+  // 74-FC Reserved
+  HID_USAGE_POWER_I_MANUFACTURER         = 0xFD,
+  HID_USAGE_POWER_I_PRODUCT              = 0xFE,
+  HID_USAGE_POWER_I_SERIAL_NUMBER        = 0xFF
+};
+
+/// HID Usage Table: Battery System Page (0x85)
+enum {
+  HID_USAGE_BATTERY_UNDEFINED                      = 0x00,
+  HID_USAGE_BATTERY_SMB_BATTERY_MODE               = 0x01,
+  HID_USAGE_BATTERY_SMB_BATTERY_STATUS             = 0x02,
+  HID_USAGE_BATTERY_SMB_ALARM_WARNING              = 0x03,
+  HID_USAGE_BATTERY_SMB_CHARGER_MODE               = 0x04,
+  HID_USAGE_BATTERY_SMB_CHARGER_STATUS             = 0x05,
+  HID_USAGE_BATTERY_SMB_CHARGER_SPEC_INFO          = 0x06,
+  HID_USAGE_BATTERY_SMB_SELECTOR_STATE             = 0x07,
+  HID_USAGE_BATTERY_SMB_SELECTOR_PRESETS           = 0x08,
+  HID_USAGE_BATTERY_SMB_SELECTOR_INFO              = 0x09,
+  // 0A-0F Reserved
+  HID_USAGE_BATTERY_OPTIONAL_MFG_FUNCTION_1        = 0x10,
+  HID_USAGE_BATTERY_OPTIONAL_MFG_FUNCTION_2        = 0x11,
+  HID_USAGE_BATTERY_OPTIONAL_MFG_FUNCTION_3        = 0x12,
+  HID_USAGE_BATTERY_OPTIONAL_MFG_FUNCTION_4        = 0x13,
+  HID_USAGE_BATTERY_OPTIONAL_MFG_FUNCTION_5        = 0x14,
+  HID_USAGE_BATTERY_CONNECTION_TO_SMBUS            = 0x15,
+  HID_USAGE_BATTERY_OUTPUT_CONNECTION              = 0x16,
+  HID_USAGE_BATTERY_CHARGER_CONNECTION             = 0x17,
+  HID_USAGE_BATTERY_BATTERY_INSERTION              = 0x18,
+  HID_USAGE_BATTERY_USE_NEXT                       = 0x19,
+  HID_USAGE_BATTERY_OK_TO_USE                      = 0x1A,
+  HID_USAGE_BATTERY_BATTERY_SUPPORTED              = 0x1B,
+  HID_USAGE_BATTERY_SELECTOR_REVISION              = 0x1C,
+  HID_USAGE_BATTERY_CHARGING_INDICATOR             = 0x1D,
+  // 1E-27 Reserved
+  HID_USAGE_BATTERY_MANUFACTURER_ACCESS            = 0x28,
+  HID_USAGE_BATTERY_REMAINING_CAPACITY_LIMIT       = 0x29,
+  HID_USAGE_BATTERY_REMAINING_TIME_LIMIT           = 0x2A,
+  HID_USAGE_BATTERY_AT_RATE                        = 0x2B,
+  HID_USAGE_BATTERY_CAPACITY_MODE                  = 0x2C,
+  HID_USAGE_BATTERY_BROADCAST_TO_CHARGER           = 0x2D,
+  HID_USAGE_BATTERY_PRIMARY_BATTERY                = 0x2E,
+  HID_USAGE_BATTERY_CHARGE_CONTROLLER              = 0x2F,
+  // 30-3F Reserved
+  HID_USAGE_BATTERY_TERMINATE_CHARGE               = 0x40,
+  HID_USAGE_BATTERY_TERMINATE_DISCHARGE            = 0x41,
+  HID_USAGE_BATTERY_BELOW_REMAINING_CAPACITY_LIMIT = 0x42,
+  HID_USAGE_BATTERY_REMAINING_TIME_LIMIT_EXPIRED   = 0x43,
+  HID_USAGE_BATTERY_CHARGING                       = 0x44,
+  HID_USAGE_BATTERY_DISCHARGING                    = 0x45,
+  HID_USAGE_BATTERY_FULLY_CHARGED                  = 0x46,
+  HID_USAGE_BATTERY_FULLY_DISCHARGED               = 0x47,
+  HID_USAGE_BATTERY_CONDITIONING_FLAG              = 0x48,
+  HID_USAGE_BATTERY_AT_RATE_OK                     = 0x49,
+  HID_USAGE_BATTERY_SMB_ERROR_CODE                 = 0x4A,
+  HID_USAGE_BATTERY_NEED_REPLACEMENT               = 0x4B,
+  // 4C-5F Reserved
+  HID_USAGE_BATTERY_AT_RATE_TIME_TO_FULL           = 0x60,
+  HID_USAGE_BATTERY_AT_RATE_TIME_TO_EMPTY          = 0x61,
+  HID_USAGE_BATTERY_AVERAGE_CURRENT                = 0x62,
+  HID_USAGE_BATTERY_MAX_ERROR                      = 0x63,
+  HID_USAGE_BATTERY_RELATIVE_STATE_OF_CHARGE       = 0x64,
+  HID_USAGE_BATTERY_ABSOLUTE_STATE_OF_CHARGE       = 0x65,
+  HID_USAGE_BATTERY_REMAINING_CAPACITY             = 0x66,
+  HID_USAGE_BATTERY_FULL_CHARGE_CAPACITY           = 0x67,
+  HID_USAGE_BATTERY_RUN_TIME_TO_EMPTY              = 0x68,
+  HID_USAGE_BATTERY_AVERAGE_TIME_TO_EMPTY          = 0x69,
+  HID_USAGE_BATTERY_AVERAGE_TIME_TO_FULL           = 0x6A,
+  HID_USAGE_BATTERY_CYCLE_COUNT                    = 0x6B,
+  // 6C-7F Reserved
+  HID_USAGE_BATTERY_BATT_PACK_MODEL_LEVEL          = 0x80,
+  HID_USAGE_BATTERY_INTERNAL_CHARGE_CONTROLLER     = 0x81,
+  HID_USAGE_BATTERY_PRIMARY_BATTERY_SUPPORT        = 0x82,
+  HID_USAGE_BATTERY_DESIGN_CAPACITY                = 0x83,
+  HID_USAGE_BATTERY_SPECIFICATION_INFO             = 0x84,
+  HID_USAGE_BATTERY_MANUFACTURER_DATE              = 0x85,
+  HID_USAGE_BATTERY_SERIAL_NUMBER                  = 0x86,
+  HID_USAGE_BATTERY_I_MANUFACTURER_NAME            = 0x87,
+  HID_USAGE_BATTERY_I_DEVICE_NAME                  = 0x88,
+  HID_USAGE_BATTERY_I_DEVICE_CHEMISTRY             = 0x89,
+  HID_USAGE_BATTERY_MANUFACTURER_DATA              = 0x8A,
+  HID_USAGE_BATTERY_RECHARGEABLE                   = 0x8B,
+  HID_USAGE_BATTERY_WARNING_CAPACITY_LIMIT         = 0x8C,
+  HID_USAGE_BATTERY_CAPACITY_GRANULARITY_1         = 0x8D,
+  HID_USAGE_BATTERY_CAPACITY_GRANULARITY_2         = 0x8E,
+  HID_USAGE_BATTERY_I_OEMINFORMATION               = 0x8F,
+  // 90-BF Reserved
+  HID_USAGE_BATTERY_INHIBIT_CHARGE                 = 0xC0,
+  HID_USAGE_BATTERY_ENABLE_POLLING                 = 0xC1,
+  HID_USAGE_BATTERY_RESET_TO_ZERO                  = 0xC2,
+  // C3-CF Reserved
+  HID_USAGE_BATTERY_AC_PRESENT                     = 0xD0,
+  HID_USAGE_BATTERY_BATTERY_PRESENT                = 0xD1,
+  HID_USAGE_BATTERY_POWER_FAIL                     = 0xD2,
+  HID_USAGE_BATTERY_ALARM_INHIBITED                = 0xD3,
+  HID_USAGE_BATTERY_THERMISTOR_UNDER_RANGE         = 0xD4,
+  HID_USAGE_BATTERY_THERMISTOR_HOT                 = 0xD5,
+  HID_USAGE_BATTERY_THERMISTOR_COLD                = 0xD6,
+  HID_USAGE_BATTERY_THERMISTOR_OVER_RANGE          = 0xD7,
+  HID_USAGE_BATTERY_VOLTAGE_OUT_OF_RANGE           = 0xD8,
+  HID_USAGE_BATTERY_CURRENT_OUT_OF_RANGE           = 0xD9,
+  HID_USAGE_BATTERY_CURRENT_NOT_REGULATED          = 0xDA,
+  HID_USAGE_BATTERY_VOLTAGE_NOT_REGULATED          = 0xDB,
+  HID_USAGE_BATTERY_MASTER_MODE                    = 0xDC,
+  // DD-EF Reserved
+  HID_USAGE_BATTERY_CHARGER_SELECTOR_SUPPORT       = 0xF0,
+  HID_USAGE_BATTERY_CHARGER_SPEC                   = 0xF1,
+  HID_USAGE_BATTERY_LEVEL_2                        = 0xF2,
+  HID_USAGE_BATTERY_LEVEL_3                        = 0xF3
+  // F4-FF Reserved
+};
+
 /// HID Usage Table: FIDO Alliance Page (0xF1D0)
 enum {
   HID_USAGE_FIDO_U2FHID   = 0x01, // U2FHID usage for top-level collection
@@ -1496,6 +2071,6 @@ enum {
  }
 #endif
 
-#endif /* _TUSB_HID_H__ */
+#endif /* TUSB_HID_H__ */
 
 /// @}
diff --git a/src/class/hid/hid_device.h b/src/class/hid/hid_device.h
index fc1dbcbd8..32b572973 100644
--- a/src/class/hid/hid_device.h
+++ b/src/class/hid/hid_device.h
@@ -267,14 +267,14 @@ void tud_hid_report_failed_cb(uint8_t instance, hid_report_type_t report_type, u
 // Stylus Pen Report Descriptor Template
 #define TUD_HID_REPORT_DESC_STYLUS_PEN(...) \
   HID_USAGE_PAGE ( HID_USAGE_PAGE_DIGITIZER )                     , \
-  HID_USAGE      ( HID_USAGE_DIGITIZER_TOUCH_SCREEN )             , \
+  HID_USAGE      ( HID_USAGE_DIGITIZER_PEN )                      , \
   HID_COLLECTION ( HID_COLLECTION_APPLICATION  )                  , \
     /* Report ID if any */\
     __VA_ARGS__ \
-    HID_USAGE    ( HID_USAGE_DIGITIZER_STYLUS )                   , \
-    HID_COLLECTION ( HID_COLLECTION_PHYSICAL   )                  , \
-      HID_USAGE_PAGE  ( HID_USAGE_DIGITIZER_TIP_SWITCH )          , \
-      HID_USAGE_PAGE  ( HID_USAGE_DIGITIZER_IN_RANGE )            , \
+    HID_USAGE    ( HID_USAGE_DIGITIZER_STYLUS                    ), \
+    HID_COLLECTION ( HID_COLLECTION_PHYSICAL                     ), \
+        HID_USAGE  ( HID_USAGE_DIGITIZER_TIP_SWITCH              ), \
+        HID_USAGE  ( HID_USAGE_DIGITIZER_IN_RANGE                ), \
         HID_LOGICAL_MIN ( 0                                      ), \
         HID_LOGICAL_MAX ( 1                                      ), \
         HID_REPORT_SIZE ( 1                                      ), \
diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index 57e437196..da776d04c 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -71,6 +71,50 @@ CFG_TUH_MEM_SECTION static hidh_epbuf_t _hidh_epbuf[CFG_TUH_HID];
 static uint8_t _hidh_default_protocol = HID_PROTOCOL_BOOT;
 
 //--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report_desc, uint16_t desc_len) {
+  (void) dev_addr;
+  (void) idx;
+  (void) report_desc;
+  (void) desc_len;
+}
+
+TU_ATTR_WEAK void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t idx) {
+  (void) dev_addr;
+  (void) idx;
+}
+
+TU_ATTR_WEAK void tuh_hid_report_sent_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report, uint16_t len) {
+  (void) dev_addr;
+  (void) idx;
+  (void) report;
+  (void) len;
+}
+
+TU_ATTR_WEAK void tuh_hid_get_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len) {
+  (void) dev_addr;
+  (void) idx;
+  (void) report_id;
+  (void) report_type;
+  (void) len;
+}
+
+TU_ATTR_WEAK void tuh_hid_set_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len) {
+  (void) dev_addr;
+  (void) idx;
+  (void) report_id;
+  (void) report_type;
+  (void) len;
+}
+
+TU_ATTR_WEAK void tuh_hid_set_protocol_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t protocol) {
+  (void) dev_addr;
+  (void) idx;
+  (void) protocol;
+}
+
+//--------------------------------------------------------------------+
 // Helper
 //--------------------------------------------------------------------+
 TU_ATTR_ALWAYS_INLINE static inline hidh_interface_t* get_hid_itf(uint8_t daddr, uint8_t idx) {
@@ -183,9 +227,7 @@ static void set_protocol_complete(tuh_xfer_t* xfer) {
     p_hid->protocol_mode = (uint8_t) tu_le16toh(xfer->setup->wValue);
   }
 
-  if (tuh_hid_set_protocol_complete_cb) {
-    tuh_hid_set_protocol_complete_cb(daddr, idx, p_hid->protocol_mode);
-  }
+  tuh_hid_set_protocol_complete_cb(daddr, idx, p_hid->protocol_mode);
 }
 
 void tuh_hid_set_default_protocol(uint8_t protocol) {
@@ -230,16 +272,14 @@ bool tuh_hid_set_protocol(uint8_t daddr, uint8_t idx, uint8_t protocol) {
 static void get_report_complete(tuh_xfer_t* xfer) {
   TU_LOG_DRV("HID Get Report complete\r\n");
 
-  if (tuh_hid_get_report_complete_cb) {
-    uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-    uint8_t const idx = tuh_hid_itf_get_index(xfer->daddr, itf_num);
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  uint8_t const idx = tuh_hid_itf_get_index(xfer->daddr, itf_num);
 
-    uint8_t const report_type = tu_u16_high(xfer->setup->wValue);
+  uint8_t const report_type = tu_u16_high(xfer->setup->wValue);
     uint8_t const report_id = tu_u16_low(xfer->setup->wValue);
 
-    tuh_hid_get_report_complete_cb(xfer->daddr, idx, report_id, report_type,
-                                   (xfer->result == XFER_RESULT_SUCCESS) ? xfer->setup->wLength : 0);
-  }
+  tuh_hid_get_report_complete_cb(xfer->daddr, idx, report_id, report_type,
+                                 (xfer->result == XFER_RESULT_SUCCESS) ? xfer->setup->wLength : 0);
 }
 
 bool tuh_hid_get_report(uint8_t daddr, uint8_t idx, uint8_t report_id, uint8_t report_type, void* report, uint16_t len) {
@@ -274,16 +314,14 @@ bool tuh_hid_get_report(uint8_t daddr, uint8_t idx, uint8_t report_id, uint8_t r
 static void set_report_complete(tuh_xfer_t* xfer) {
   TU_LOG_DRV("HID Set Report complete\r\n");
 
-  if (tuh_hid_set_report_complete_cb) {
-    uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-    uint8_t const idx = tuh_hid_itf_get_index(xfer->daddr, itf_num);
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  uint8_t const idx = tuh_hid_itf_get_index(xfer->daddr, itf_num);
 
-    uint8_t const report_type = tu_u16_high(xfer->setup->wValue);
-    uint8_t const report_id = tu_u16_low(xfer->setup->wValue);
+  uint8_t const report_type = tu_u16_high(xfer->setup->wValue);
+  uint8_t const report_id = tu_u16_low(xfer->setup->wValue);
 
-    tuh_hid_set_report_complete_cb(xfer->daddr, idx, report_id, report_type,
-                                   (xfer->result == XFER_RESULT_SUCCESS) ? xfer->setup->wLength : 0);
-  }
+  tuh_hid_set_report_complete_cb(xfer->daddr, idx, report_id, report_type,
+                                 (xfer->result == XFER_RESULT_SUCCESS) ? xfer->setup->wLength : 0);
 }
 
 bool tuh_hid_set_report(uint8_t daddr, uint8_t idx, uint8_t report_id, uint8_t report_type, void* report, uint16_t len) {
@@ -448,9 +486,7 @@ bool hidh_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t result, uint32_t
     TU_LOG3_MEM(epbuf->epin, xferred_bytes, 2);
     tuh_hid_report_received_cb(daddr, idx, epbuf->epin, (uint16_t) xferred_bytes);
   } else {
-    if (tuh_hid_report_sent_cb) {
-      tuh_hid_report_sent_cb(daddr, idx, epbuf->epout, (uint16_t) xferred_bytes);
-    }
+    tuh_hid_report_sent_cb(daddr, idx, epbuf->epout, (uint16_t) xferred_bytes);
   }
 
   return true;
@@ -461,9 +497,7 @@ void hidh_close(uint8_t daddr) {
     hidh_interface_t* p_hid = &_hidh_itf[i];
     if (p_hid->daddr == daddr) {
       TU_LOG_DRV("  HIDh close addr = %u index = %u\r\n", daddr, i);
-      if (tuh_hid_umount_cb) {
-        tuh_hid_umount_cb(daddr, i);
-      }
+      tuh_hid_umount_cb(daddr, i);
       tu_memclr(p_hid, sizeof(hidh_interface_t));
     }
   }
@@ -519,7 +553,8 @@ bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const* desc_
 
   // Assume bNumDescriptors = 1
   p_hid->report_desc_type = desc_hid->bReportType;
-  p_hid->report_desc_len = tu_unaligned_read16(&desc_hid->wReportLength);
+  // Use offsetof to avoid pointer to the odd/misaligned address
+  p_hid->report_desc_len = tu_unaligned_read16((uint8_t const*)desc_hid + offsetof(tusb_hid_descriptor_hid_t, wReportLength));
 
   // Per HID Specs: default is Report protocol, though we will force Boot protocol when set_config
   p_hid->protocol_mode = _hidh_default_protocol;
@@ -624,7 +659,7 @@ static void config_driver_mount_complete(uint8_t daddr, uint8_t idx, uint8_t con
   p_hid->mounted = true;
 
   // enumeration is complete
-  if (tuh_hid_mount_cb) tuh_hid_mount_cb(daddr, idx, desc_report, desc_len);
+  tuh_hid_mount_cb(daddr, idx, desc_report, desc_len);
 
   // notify usbh that driver enumeration is complete
   usbh_driver_set_config_complete(daddr, p_hid->itf_num);
@@ -662,9 +697,12 @@ uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr,
 
     uint8_t const tag = header.tag;
     uint8_t const type = header.type;
-    uint8_t const size = header.size;
+    uint8_t size = header.size;
+    if (size == 3) {
+      size = 4; // HID 1.11 6.2.2.2 3 is 4 bytes
+    }
 
-    uint8_t const data8 = desc_report[0];
+    uint8_t const data8 = (size > 0) ? desc_report[0] : 0;
 
     TU_LOG(3, "tag = %d, type = %d, size = %d, data = ", tag, type, size);
     for (uint32_t i = 0; i < size; i++) {
diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index 9681c704b..87f0e7dc9 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_HID_HOST_H_
-#define _TUSB_HID_HOST_H_
+#ifndef TUSB_HID_HOST_H_
+#define TUSB_HID_HOST_H_
 
 #include "hid.h"
 
@@ -145,28 +145,28 @@ bool tuh_hid_send_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, const
 // can be used to parse common/simple enough descriptor.
 // Note: if report descriptor length > CFG_TUH_ENUMERATION_BUFSIZE, it will be skipped
 // therefore report_desc = NULL, desc_len = 0
-TU_ATTR_WEAK void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report_desc, uint16_t desc_len);
+void tuh_hid_mount_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report_desc, uint16_t desc_len);
 
 // Invoked when device with hid interface is un-mounted
-TU_ATTR_WEAK void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t idx);
+void tuh_hid_umount_cb(uint8_t dev_addr, uint8_t idx);
 
 // Invoked when received report from device via interrupt endpoint
 // Note: if there is report ID (composite), it is 1st byte of report
 void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report, uint16_t len);
 
 // Invoked when sent report to device successfully via interrupt endpoint
-TU_ATTR_WEAK void tuh_hid_report_sent_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report, uint16_t len);
+void tuh_hid_report_sent_cb(uint8_t dev_addr, uint8_t idx, uint8_t const* report, uint16_t len);
 
 // Invoked when Get Report to device via either control endpoint
 // len = 0 indicate there is error in the transfer e.g stalled response
-TU_ATTR_WEAK void tuh_hid_get_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len);
+void tuh_hid_get_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len);
 
 // Invoked when Sent Report to device via either control endpoint
 // len = 0 indicate there is error in the transfer e.g stalled response
-TU_ATTR_WEAK void tuh_hid_set_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len);
+void tuh_hid_set_report_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, uint16_t len);
 
 // Invoked when Set Protocol request is complete
-TU_ATTR_WEAK void tuh_hid_set_protocol_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t protocol);
+void tuh_hid_set_protocol_complete_cb(uint8_t dev_addr, uint8_t idx, uint8_t protocol);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
@@ -182,4 +182,4 @@ void hidh_close(uint8_t dev_addr);
 }
 #endif
 
-#endif /* _TUSB_HID_HOST_H_ */
+#endif /* TUSB_HID_HOST_H_ */
diff --git a/src/class/midi/midi_device.c b/src/class/midi/midi_device.c
index 0bbb3caf4..b20903d68 100644
--- a/src/class/midi/midi_device.c
+++ b/src/class/midi/midi_device.c
@@ -37,12 +37,18 @@
 #include "midi_device.h"
 
 //--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_midi_rx_cb(uint8_t itf) {
+  (void)itf;
+}
+
+//--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
 typedef struct {
+  uint8_t rhport;
   uint8_t itf_num;
-  uint8_t ep_in;
-  uint8_t ep_out;
 
   // For Stream read()/write() API
   // Messages are always 4 bytes long, queue them for reading and writing so the
@@ -51,126 +57,97 @@ typedef struct {
   midi_driver_stream_t stream_read;
 
   /*------------- From this point, data is not cleared by bus reset -------------*/
-  // FIFO
-  tu_fifo_t rx_ff;
-  tu_fifo_t tx_ff;
-  uint8_t rx_ff_buf[CFG_TUD_MIDI_RX_BUFSIZE];
-  uint8_t tx_ff_buf[CFG_TUD_MIDI_TX_BUFSIZE];
+  // Endpoint stream
+  struct {
+    tu_edpt_stream_t tx;
+    tu_edpt_stream_t rx;
 
-  #if CFG_FIFO_MUTEX
-  osal_mutex_def_t rx_ff_mutex;
-  osal_mutex_def_t tx_ff_mutex;
-  #endif
+    uint8_t rx_ff_buf[CFG_TUD_MIDI_RX_BUFSIZE];
+    uint8_t tx_ff_buf[CFG_TUD_MIDI_TX_BUFSIZE];
+  } ep_stream;
 } midid_interface_t;
 
-#define ITF_MEM_RESET_SIZE   offsetof(midid_interface_t, rx_ff)
+#define ITF_MEM_RESET_SIZE offsetof(midid_interface_t, ep_stream)
+
+static midid_interface_t _midid_itf[CFG_TUD_MIDI];
 
 // Endpoint Transfer buffer
-CFG_TUD_MEM_SECTION static struct {
+typedef struct {
   TUD_EPBUF_DEF(epin, CFG_TUD_MIDI_EP_BUFSIZE);
   TUD_EPBUF_DEF(epout, CFG_TUD_MIDI_EP_BUFSIZE);
-} _midid_epbuf[CFG_TUD_MIDI];
+} midid_epbuf_t;
+
+CFG_TUD_MEM_SECTION static midid_epbuf_t _midid_epbuf[CFG_TUD_MIDI];
 
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
-static midid_interface_t _midid_itf[CFG_TUD_MIDI];
-
 bool tud_midi_n_mounted (uint8_t itf) {
-  midid_interface_t* midi = &_midid_itf[itf];
-  return midi->ep_in && midi->ep_out;
-}
+  midid_interface_t *p_midi = &_midid_itf[itf];
 
-static void _prep_out_transaction(uint8_t idx) {
-  const uint8_t rhport = 0;
-  midid_interface_t* p_midi = &_midid_itf[idx];
-  uint16_t available = tu_fifo_remaining(&p_midi->rx_ff);
-
-  // Prepare for incoming data but only allow what we can store in the ring buffer.
-  // TODO Actually we can still carry out the transfer, keeping count of received bytes
-  // and slowly move it to the FIFO when read().
-  // This pre-check reduces endpoint claiming
-  TU_VERIFY(available >= CFG_TUD_MIDI_EP_BUFSIZE, );
-
-  // claim endpoint
-  TU_VERIFY(usbd_edpt_claim(rhport, p_midi->ep_out), );
-
-  // fifo can be changed before endpoint is claimed
-  available = tu_fifo_remaining(&p_midi->rx_ff);
-
-  if ( available >= CFG_TUD_MIDI_EP_BUFSIZE )  {
-    usbd_edpt_xfer(rhport, p_midi->ep_out, _midid_epbuf[idx].epout, CFG_TUD_MIDI_EP_BUFSIZE);
-  }else
-  {
-    // Release endpoint since we don't make any transfer
-    usbd_edpt_release(rhport, p_midi->ep_out);
-  }
+  const bool tx_opened = tu_edpt_stream_is_opened(&p_midi->ep_stream.tx);
+  const bool rx_opened = tu_edpt_stream_is_opened(&p_midi->ep_stream.rx);
+  return tx_opened && rx_opened;
 }
 
 //--------------------------------------------------------------------+
 // READ API
 //--------------------------------------------------------------------+
-uint32_t tud_midi_n_available(uint8_t itf, uint8_t cable_num)
-{
+uint32_t tud_midi_n_available(uint8_t itf, uint8_t cable_num) {
   (void) cable_num;
-
-  midid_interface_t* midi = &_midid_itf[itf];
-  const midi_driver_stream_t* stream = &midi->stream_read;
+  const midid_interface_t    *p_midi = &_midid_itf[itf];
+  const midi_driver_stream_t *stream = &p_midi->stream_read;
+  const tu_edpt_stream_t     *ep_str = &p_midi->ep_stream.rx;
 
   // when using with packet API stream total & index are both zero
-  return tu_fifo_count(&midi->rx_ff) + (uint8_t) (stream->total - stream->index);
+  return tu_edpt_stream_read_available(ep_str) + (uint8_t)(stream->total - stream->index);
 }
 
-uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void* buffer, uint32_t bufsize)
-{
+uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void *buffer, uint32_t bufsize) {
   (void) cable_num;
-  TU_VERIFY(bufsize, 0);
+  TU_VERIFY(buffer != NULL && bufsize > 0, 0);
 
-  uint8_t* buf8 = (uint8_t*) buffer;
-
-  midid_interface_t* midi = &_midid_itf[itf];
-  midi_driver_stream_t* stream = &midi->stream_read;
+  uint8_t              *buf8   = (uint8_t *)buffer;
+  midid_interface_t    *p_midi = &_midid_itf[itf];
+  midi_driver_stream_t *stream = &p_midi->stream_read;
 
   uint32_t total_read = 0;
-  while( bufsize )
-  {
+  while (bufsize > 0) {
     // Get new packet from fifo, then set packet expected bytes
-    if ( stream->total == 0 )
-    {
-      // return if there is no more data from fifo
-      if ( !tud_midi_n_packet_read(itf, stream->buffer) ) return total_read;
+    if (stream->total == 0) {
+      if (!tud_midi_n_packet_read(itf, stream->buffer)) {
+        return total_read; // return if there is no more data from fifo
+      }
 
-      uint8_t const code_index = stream->buffer[0] & 0x0f;
+      const uint8_t code_index = stream->buffer[0] & 0x0f;
 
       // MIDI 1.0 Table 4-1: Code Index Number Classifications
-      switch(code_index)
-      {
+      switch (code_index) {
         case MIDI_CIN_MISC:
         case MIDI_CIN_CABLE_EVENT:
           // These are reserved and unused, possibly issue somewhere, skip this packet
           return 0;
-        break;
 
         case MIDI_CIN_SYSEX_END_1BYTE:
         case MIDI_CIN_1BYTE_DATA:
           stream->total = 1;
-        break;
+          break;
 
         case MIDI_CIN_SYSCOM_2BYTE     :
         case MIDI_CIN_SYSEX_END_2BYTE  :
         case MIDI_CIN_PROGRAM_CHANGE   :
         case MIDI_CIN_CHANNEL_PRESSURE :
           stream->total = 2;
-        break;
+          break;
 
         default:
           stream->total = 3;
-        break;
+          break;
       }
     }
 
     // Copy data up to bufsize
-    uint8_t const count = (uint8_t) tu_min32(stream->total - stream->index, bufsize);
+    const uint8_t count = (uint8_t)tu_min32((uint32_t)(stream->total - stream->index), bufsize);
 
     // Skip the header (1st byte) in the buffer
     TU_VERIFY(0 == tu_memcpy_s(buf8, bufsize, stream->buffer + 1 + stream->index, count));
@@ -181,8 +158,7 @@ uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void* buffer, ui
     bufsize -= count;
 
     // complete current event packet, reset stream
-    if ( stream->total == stream->index )
-    {
+    if (stream->total == stream->index) {
       stream->index = 0;
       stream->total = 0;
     }
@@ -191,150 +167,107 @@ uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void* buffer, ui
   return total_read;
 }
 
-bool tud_midi_n_packet_read (uint8_t itf, uint8_t packet[4])
-{
-  midid_interface_t* midi = &_midid_itf[itf];
-  TU_VERIFY(midi->ep_out);
+bool tud_midi_n_packet_read(uint8_t itf, uint8_t packet[4]) {
+  midid_interface_t *p_midi = &_midid_itf[itf];
+  tu_edpt_stream_t  *ep_str = &p_midi->ep_stream.rx;
+  TU_VERIFY(tu_edpt_stream_is_opened(ep_str));
+  return 4 == tu_edpt_stream_read(p_midi->rhport, ep_str, packet, 4);
+}
 
-  const uint32_t num_read = tu_fifo_read_n(&midi->rx_ff, packet, 4);
-  _prep_out_transaction(itf);
-  return (num_read == 4);
+uint32_t tud_midi_n_packet_read_n(uint8_t itf, uint8_t packets[], uint32_t max_packets) {
+  midid_interface_t *p_midi = &_midid_itf[itf];
+  tu_edpt_stream_t  *ep_str = &p_midi->ep_stream.rx;
+  TU_VERIFY(tu_edpt_stream_is_opened(ep_str), 0);
+
+  const uint32_t num_read = tu_edpt_stream_read(p_midi->rhport, ep_str, packets, 4u * max_packets);
+  return num_read >> 2u;
 }
 
 //--------------------------------------------------------------------+
 // WRITE API
 //--------------------------------------------------------------------+
-
-static uint32_t write_flush(uint8_t idx) {
-  midid_interface_t* midi = &_midid_itf[idx];
-
-  if (!tu_fifo_count(&midi->tx_ff)) {
-    return 0; // No data to send
-  }
-
-  const uint8_t rhport = 0;
-
-  // skip if previous transfer not complete
-  TU_VERIFY( usbd_edpt_claim(rhport, midi->ep_in), 0 );
-
-  uint16_t count = tu_fifo_read_n(&midi->tx_ff, _midid_epbuf[idx].epin, CFG_TUD_MIDI_EP_BUFSIZE);
-
-  if (count) {
-    TU_ASSERT( usbd_edpt_xfer(rhport, midi->ep_in, _midid_epbuf[idx].epin, count), 0 );
-    return count;
-  }else {
-    // Release endpoint since we don't make any transfer
-    usbd_edpt_release(rhport, midi->ep_in);
-    return 0;
-  }
-}
-
-uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t* buffer, uint32_t bufsize)
-{
-  midid_interface_t* midi = &_midid_itf[itf];
-  TU_VERIFY(midi->ep_in, 0);
-
-  midi_driver_stream_t* stream = &midi->stream_write;
+uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t *buffer, uint32_t bufsize) {
+  midid_interface_t *p_midi = &_midid_itf[itf];
+  midi_driver_stream_t *stream = &p_midi->stream_write;
+  tu_edpt_stream_t  *ep_str = &p_midi->ep_stream.tx;
+  TU_VERIFY(tu_edpt_stream_is_opened(ep_str), 0);
 
   uint32_t i = 0;
-  while ( (i < bufsize) && (tu_fifo_remaining(&midi->tx_ff) >= 4) )
-  {
+  while (i < bufsize) {
+    if (tu_edpt_stream_write_available(p_midi->rhport, ep_str) < 4) {
+      break;
+    }
+
     const uint8_t data = buffer[i];
     i++;
 
-    if ( stream->index == 0 )
-    {
+    if (stream->index == 0) {
       //------------- New event packet -------------//
       const uint8_t msg = data >> 4;
 
-      stream->index = 2;
+      stream->index     = 2;
       stream->buffer[1] = data;
 
       // Check to see if we're still in a SysEx transmit.
-      if ( ((stream->buffer[0]) & 0xF) == MIDI_CIN_SYSEX_START )
-      {
-        if ( data == MIDI_STATUS_SYSEX_END )
-        {
-          stream->buffer[0] = (uint8_t) ((cable_num << 4) | MIDI_CIN_SYSEX_END_1BYTE);
-          stream->total = 2;
-        }
-        else
-        {
+      if (((stream->buffer[0]) & 0xF) == MIDI_CIN_SYSEX_START) {
+        if (data == MIDI_STATUS_SYSEX_END) {
+          stream->buffer[0] = (uint8_t)((cable_num << 4) | MIDI_CIN_SYSEX_END_1BYTE);
+          stream->total     = 2;
+        } else {
           stream->total = 4;
         }
-      }
-      else if ( (msg >= 0x8 && msg <= 0xB) || msg == 0xE )
-      {
+      } else if ((msg >= 0x8 && msg <= 0xB) || msg == 0xE) {
         // Channel Voice Messages
-        stream->buffer[0] = (uint8_t) ((cable_num << 4) | msg);
-        stream->total = 4;
-      }
-      else if ( msg == 0xC || msg == 0xD)
-      {
+        stream->buffer[0] = (uint8_t)((cable_num << 4) | msg);
+        stream->total     = 4;
+      } else if (msg == 0xC || msg == 0xD) {
         // Channel Voice Messages, two-byte variants (Program Change and Channel Pressure)
-        stream->buffer[0] = (uint8_t) ((cable_num << 4) | msg);
-        stream->total = 3;
-      }
-      else if ( msg == 0xf )
-      {
+        stream->buffer[0] = (uint8_t)((cable_num << 4) | msg);
+        stream->total     = 3;
+      } else if (msg == 0xf) {
         // System message
-        if ( data == MIDI_STATUS_SYSEX_START )
-        {
+        if (data == MIDI_STATUS_SYSEX_START) {
           stream->buffer[0] = MIDI_CIN_SYSEX_START;
-          stream->total = 4;
-        }
-        else if ( data == MIDI_STATUS_SYSCOM_TIME_CODE_QUARTER_FRAME || data == MIDI_STATUS_SYSCOM_SONG_SELECT )
-        {
+          stream->total     = 4;
+        } else if (data == MIDI_STATUS_SYSCOM_TIME_CODE_QUARTER_FRAME || data == MIDI_STATUS_SYSCOM_SONG_SELECT) {
           stream->buffer[0] = MIDI_CIN_SYSCOM_2BYTE;
-          stream->total = 3;
-        }
-        else if ( data == MIDI_STATUS_SYSCOM_SONG_POSITION_POINTER )
-        {
+          stream->total     = 3;
+        } else if (data == MIDI_STATUS_SYSCOM_SONG_POSITION_POINTER) {
           stream->buffer[0] = MIDI_CIN_SYSCOM_3BYTE;
-          stream->total = 4;
-        }
-        else
-        {
+          stream->total     = 4;
+        } else {
           stream->buffer[0] = MIDI_CIN_SYSEX_END_1BYTE;
-          stream->total = 2;
+          stream->total     = 2;
         }
         stream->buffer[0] |= (uint8_t)(cable_num << 4);
-      }
-      else
-      {
+      } else {
         // Pack individual bytes if we don't support packing them into words.
-        stream->buffer[0] = (uint8_t) (cable_num << 4 | 0xf);
+        stream->buffer[0] = (uint8_t)(cable_num << 4 | 0xf);
         stream->buffer[2] = 0;
         stream->buffer[3] = 0;
-        stream->index = 2;
-        stream->total = 2;
+        stream->total     = 2; // index already set to 2
       }
-    }
-    else
-    {
+    } else {
       //------------- On-going (buffering) packet -------------//
-
       TU_ASSERT(stream->index < 4, i);
       stream->buffer[stream->index] = data;
       stream->index++;
 
       // See if this byte ends a SysEx.
-      if ( (stream->buffer[0] & 0xF) == MIDI_CIN_SYSEX_START && data == MIDI_STATUS_SYSEX_END )
-      {
-        stream->buffer[0] = (uint8_t) ((cable_num << 4) | (MIDI_CIN_SYSEX_START + (stream->index - 1)));
-        stream->total = stream->index;
+      if ((stream->buffer[0] & 0xF) == MIDI_CIN_SYSEX_START && data == MIDI_STATUS_SYSEX_END) {
+        stream->buffer[0] = (uint8_t)((cable_num << 4) | (MIDI_CIN_SYSEX_START + (stream->index - 1)));
+        stream->total     = stream->index;
       }
     }
 
     // Send out packet
-    if ( stream->index == stream->total )
-    {
+    if (stream->index == stream->total) {
       // zeroes unused bytes
       for (uint8_t idx = stream->total; idx < 4; idx++) {
         stream->buffer[idx] = 0;
       }
 
-      const uint16_t count = tu_fifo_write_n(&midi->tx_ff, stream->buffer, 4);
+      const uint32_t count = tu_edpt_stream_write(p_midi->rhport, ep_str, stream->buffer, 4);
 
       // complete current event packet, reset stream
       stream->index = stream->total = 0;
@@ -344,25 +277,37 @@ uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t*
     }
   }
 
-  write_flush(itf);
+  (void)tu_edpt_stream_write_xfer(p_midi->rhport, ep_str);
 
   return i;
 }
 
 bool tud_midi_n_packet_write (uint8_t itf, const uint8_t packet[4]) {
-  midid_interface_t* midi = &_midid_itf[itf];
-  TU_VERIFY(midi->ep_in);
-
-  if (tu_fifo_remaining(&midi->tx_ff) < 4) {
-    return false;
-  }
+  midid_interface_t *p_midi = &_midid_itf[itf];
+  tu_edpt_stream_t  *ep_str = &p_midi->ep_stream.tx;
+  TU_VERIFY(tu_edpt_stream_is_opened(ep_str));
 
-  tu_fifo_write_n(&midi->tx_ff, packet, 4);
-  write_flush(itf);
+  TU_VERIFY(tu_edpt_stream_write_available(p_midi->rhport, ep_str) >= 4);
+  TU_VERIFY(tu_edpt_stream_write(p_midi->rhport, ep_str, packet, 4) > 0);
+  (void)tu_edpt_stream_write_xfer(p_midi->rhport, ep_str);
 
   return true;
 }
 
+uint32_t tud_midi_n_packet_write_n(uint8_t itf, const uint8_t packets[], uint32_t n_packets) {
+  midid_interface_t *p_midi = &_midid_itf[itf];
+  tu_edpt_stream_t  *ep_str = &p_midi->ep_stream.tx;
+  TU_VERIFY(tu_edpt_stream_is_opened(ep_str), 0);
+
+  uint32_t n_bytes = tu_edpt_stream_write_available(p_midi->rhport, ep_str);
+  n_bytes          = tu_min32(tu_align4(n_bytes), n_packets << 2u);
+
+  const uint32_t n_write = tu_edpt_stream_write(p_midi->rhport, ep_str, packets, n_bytes);
+  (void)tu_edpt_stream_write_xfer(p_midi->rhport, ep_str);
+
+  return n_write >> 2u;
+}
+
 //--------------------------------------------------------------------+
 // USBD Driver API
 //--------------------------------------------------------------------+
@@ -370,72 +315,64 @@ void midid_init(void) {
   tu_memclr(_midid_itf, sizeof(_midid_itf));
 
   for (uint8_t i = 0; i < CFG_TUD_MIDI; i++) {
-    midid_interface_t* midi = &_midid_itf[i];
+    midid_interface_t *p_midi  = &_midid_itf[i];
+    midid_epbuf_t     *p_epbuf = &_midid_epbuf[i];
 
-    // config fifo
-    tu_fifo_config(&midi->rx_ff, midi->rx_ff_buf, CFG_TUD_MIDI_RX_BUFSIZE, 1, false); // true, true
-    tu_fifo_config(&midi->tx_ff, midi->tx_ff_buf, CFG_TUD_MIDI_TX_BUFSIZE, 1, false); // OBVS.
+    tu_edpt_stream_init(
+        &p_midi->ep_stream.rx, false, false, false, p_midi->ep_stream.rx_ff_buf, CFG_TUD_MIDI_RX_BUFSIZE,
+        p_epbuf->epout, CFG_TUD_MIDI_EP_BUFSIZE);
 
-    #if CFG_FIFO_MUTEX
-    osal_mutex_t mutex_rd = osal_mutex_create(&midi->rx_ff_mutex);
-    osal_mutex_t mutex_wr = osal_mutex_create(&midi->tx_ff_mutex);
-    TU_ASSERT(mutex_wr != NULL && mutex_wr != NULL, );
-
-    tu_fifo_config_mutex(&midi->rx_ff, NULL, mutex_rd);
-    tu_fifo_config_mutex(&midi->tx_ff, mutex_wr, NULL);
-    #endif
+    tu_edpt_stream_init(
+        &p_midi->ep_stream.tx, false, true, false, p_midi->ep_stream.tx_ff_buf, CFG_TUD_MIDI_TX_BUFSIZE, p_epbuf->epin,
+        CFG_TUD_MIDI_EP_BUFSIZE);
   }
 }
 
 bool midid_deinit(void) {
-  #if CFG_FIFO_MUTEX
-  for(uint8_t i=0; i<CFG_TUD_MIDI; i++) {
-    midid_interface_t* midi = &_midid_itf[i];
-    osal_mutex_t mutex_rd = midi->rx_ff.mutex_rd;
-    osal_mutex_t mutex_wr = midi->tx_ff.mutex_wr;
-
-    if (mutex_rd) {
-      osal_mutex_delete(mutex_rd);
-      tu_fifo_config_mutex(&midi->rx_ff, NULL, NULL);
-    }
-
-    if (mutex_wr) {
-      osal_mutex_delete(mutex_wr);
-      tu_fifo_config_mutex(&midi->tx_ff, NULL, NULL);
-    }
+  for (uint8_t i = 0; i < CFG_TUD_MIDI; i++) {
+    midid_interface_t *p_midi = &_midid_itf[i];
+    tu_edpt_stream_deinit(&p_midi->ep_stream.rx);
+    tu_edpt_stream_deinit(&p_midi->ep_stream.tx);
   }
-  #endif
-
   return true;
 }
 
-void midid_reset(uint8_t rhport)
-{
-  (void) rhport;
+void midid_reset(uint8_t rhport) {
+  (void)rhport;
+  for (uint8_t i = 0; i < CFG_TUD_MIDI; i++) {
+    midid_interface_t *p_midi = &_midid_itf[i];
+    tu_memclr(p_midi, ITF_MEM_RESET_SIZE);
+
+    tu_edpt_stream_clear(&p_midi->ep_stream.rx);
+    tu_edpt_stream_close(&p_midi->ep_stream.rx);
 
-  for(uint8_t i=0; i<CFG_TUD_MIDI; i++)
-  {
-    midid_interface_t* midi = &_midid_itf[i];
-    tu_memclr(midi, ITF_MEM_RESET_SIZE);
-    tu_fifo_clear(&midi->rx_ff);
-    tu_fifo_clear(&midi->tx_ff);
+    tu_edpt_stream_clear(&p_midi->ep_stream.tx);
+    tu_edpt_stream_close(&p_midi->ep_stream.tx);
   }
 }
 
-uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uint16_t max_len) {
-  uint16_t drv_len = 0;
-  uint8_t const * p_desc = (uint8_t const *)desc_itf;
+TU_ATTR_ALWAYS_INLINE static inline uint8_t find_midi_itf(uint8_t ep_addr) {
+  for (uint8_t idx = 0; idx < CFG_TUD_MIDI; idx++) {
+    const midid_interface_t *p_midi = &_midid_itf[idx];
+    if (ep_addr == p_midi->ep_stream.rx.ep_addr || ep_addr == p_midi->ep_stream.tx.ep_addr) {
+      return idx;
+    }
+  }
+  return TUSB_INDEX_INVALID_8;
+}
+
+uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t *desc_itf, uint16_t max_len) {
+  const uint8_t *p_desc   = (const uint8_t *)desc_itf;
+  const uint8_t *desc_end = p_desc + max_len;
 
   // 1st Interface is Audio Control v1 (optional)
   if (TUSB_CLASS_AUDIO               == desc_itf->bInterfaceClass    &&
       AUDIO_SUBCLASS_CONTROL         == desc_itf->bInterfaceSubClass &&
       AUDIO_FUNC_PROTOCOL_CODE_UNDEF == desc_itf->bInterfaceProtocol) {
-    drv_len = tu_desc_len(desc_itf);
     p_desc = tu_desc_next(desc_itf);
     // Skip Class Specific descriptors
-    while (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc) && drv_len <= max_len) {
-      drv_len += tu_desc_len(p_desc);
-      p_desc   = tu_desc_next(p_desc);
+    while (tu_desc_in_bounds(p_desc, desc_end) && TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc)) {
+      p_desc = tu_desc_next(p_desc);
     }
   }
 
@@ -443,59 +380,48 @@ uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uint1
   TU_VERIFY(TUSB_DESC_INTERFACE == tu_desc_type(p_desc), 0);
   const tusb_desc_interface_t* desc_midi = (const tusb_desc_interface_t*) p_desc;
 
-  TU_VERIFY(TUSB_CLASS_AUDIO               == desc_midi->bInterfaceClass    &&
-            AUDIO_SUBCLASS_MIDI_STREAMING  == desc_midi->bInterfaceSubClass &&
-            AUDIO_FUNC_PROTOCOL_CODE_UNDEF == desc_midi->bInterfaceProtocol, 0);
+  TU_VERIFY(TUSB_CLASS_AUDIO == desc_midi->bInterfaceClass &&
+              AUDIO_SUBCLASS_MIDI_STREAMING == desc_midi->bInterfaceSubClass &&
+              AUDIO_FUNC_PROTOCOL_CODE_UNDEF == desc_midi->bInterfaceProtocol,
+            0);
 
-  // Find available interface
-  midid_interface_t * p_midi = NULL;
-  uint8_t idx;
-  for(idx=0; idx<CFG_TUD_MIDI; idx++) {
-    if ( _midid_itf[idx].ep_in == 0 && _midid_itf[idx].ep_out == 0 ) {
-      p_midi = &_midid_itf[idx];
-      break;
-    }
-  }
-  TU_ASSERT(p_midi);
+  uint8_t idx = find_midi_itf(0); // find unused interface
+  TU_ASSERT(idx < CFG_TUD_MIDI, 0);
+  midid_interface_t *p_midi = &_midid_itf[idx];
 
+  p_midi->rhport  = rhport;
   p_midi->itf_num = desc_midi->bInterfaceNumber;
   (void) p_midi->itf_num;
 
-  // next descriptor
-  drv_len += tu_desc_len(p_desc);
-  p_desc   = tu_desc_next(p_desc);
+  p_desc = tu_desc_next(p_desc);
 
   // Find and open endpoint descriptors
-  uint8_t found_endpoints = 0;
-  while ( (found_endpoints < desc_midi->bNumEndpoints) && (drv_len <= max_len)  )
-  {
-    if ( TUSB_DESC_ENDPOINT == tu_desc_type(p_desc) )
-    {
-      TU_ASSERT(usbd_edpt_open(rhport, (const tusb_desc_endpoint_t*) p_desc), 0);
-      uint8_t ep_addr = ((const tusb_desc_endpoint_t*) p_desc)->bEndpointAddress;
+  uint8_t found_ep = 0;
+  while ((found_ep < desc_midi->bNumEndpoints) && tu_desc_in_bounds(p_desc, desc_end)) {
+    if (TUSB_DESC_ENDPOINT == tu_desc_type(p_desc)) {
+      const tusb_desc_endpoint_t *desc_ep = (const tusb_desc_endpoint_t *)p_desc;
+      TU_ASSERT(usbd_edpt_open(rhport, desc_ep), 0);
+      const uint8_t ep_addr = ((const tusb_desc_endpoint_t *)p_desc)->bEndpointAddress;
 
-      if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN)
-      {
-        p_midi->ep_in = ep_addr;
+      if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN) {
+        tu_edpt_stream_t *stream_tx = &p_midi->ep_stream.tx;
+        tu_edpt_stream_open(stream_tx, desc_ep);
+        tu_edpt_stream_clear(stream_tx);
       } else {
-        p_midi->ep_out = ep_addr;
+        tu_edpt_stream_t *stream_rx = &p_midi->ep_stream.rx;
+        tu_edpt_stream_open(stream_rx, desc_ep);
+        tu_edpt_stream_clear(stream_rx);
+        TU_ASSERT(tu_edpt_stream_read_xfer(rhport, stream_rx) > 0, 0); // prepare to receive data
       }
 
-      // Class Specific MIDI Stream endpoint descriptor
-      drv_len += tu_desc_len(p_desc);
-      p_desc   = tu_desc_next(p_desc);
-
-      found_endpoints += 1;
+      p_desc = tu_desc_next(p_desc);                                   // skip CS Endpoint descriptor
+      found_ep++;
     }
 
-    drv_len += tu_desc_len(p_desc);
-    p_desc   = tu_desc_next(p_desc);
+    p_desc = tu_desc_next(p_desc);
   }
 
-  // Prepare for incoming data
-  _prep_out_transaction(idx);
-
-  return drv_len;
+  return (uint16_t)(p_desc - (const uint8_t *)desc_itf);
 }
 
 // Invoked when a control transfer occurred on an interface of this class
@@ -506,46 +432,31 @@ bool midid_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_req
   return false; // driver doesn't support any request yet
 }
 
-bool midid_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
-{
-  (void) result;
-  (void) rhport;
-
-  uint8_t idx;
-  midid_interface_t* p_midi;
+bool midid_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
+  (void)result;
 
-  // Identify which interface to use
-  for (idx = 0; idx < CFG_TUD_MIDI; idx++) {
-    p_midi = &_midid_itf[idx];
-    if ((ep_addr == p_midi->ep_out) || (ep_addr == p_midi->ep_in)) {
-      break;
-    }
-  }
+  uint8_t idx = find_midi_itf(ep_addr);
   TU_ASSERT(idx < CFG_TUD_MIDI);
+  midid_interface_t *p_midi = &_midid_itf[idx];
 
-  // receive new data
-  if (ep_addr == p_midi->ep_out) {
-    tu_fifo_write_n(&p_midi->rx_ff, _midid_epbuf[idx].epout, (uint16_t)xferred_bytes);
+  tu_edpt_stream_t *ep_st_rx = &p_midi->ep_stream.rx;
+  tu_edpt_stream_t *ep_st_tx = &p_midi->ep_stream.tx;
 
-    // invoke receive callback if available
-    if (tud_midi_rx_cb) {
-      tud_midi_rx_cb(idx);
+  if (ep_addr == ep_st_rx->ep_addr) {
+    // Received new data: put into stream's fifo
+    if (result == XFER_RESULT_SUCCESS) {
+      tu_edpt_stream_read_xfer_complete(ep_st_rx, xferred_bytes);
+      tud_midi_rx_cb(idx);                      // invoke callback
     }
-
-    // prepare for next
-    // TODO for now ep_out is not used by public API therefore there is no race condition,
-    // and does not need to claim like ep_in
-    _prep_out_transaction(idx);
-  } else if (ep_addr == p_midi->ep_in) {
-    if (0 == write_flush(idx)) {
-      // If there is no data left, a ZLP should be sent if
-      // xferred_bytes is multiple of EP size and not zero
-      if (!tu_fifo_count(&p_midi->tx_ff) && xferred_bytes && (0 == (xferred_bytes % CFG_TUD_MIDI_EP_BUFSIZE))) {
-        if (usbd_edpt_claim(rhport, p_midi->ep_in)) {
-          usbd_edpt_xfer(rhport, p_midi->ep_in, NULL, 0);
-        }
-      }
+    tu_edpt_stream_read_xfer(rhport, ep_st_rx); // prepare for next data
+  } else if (ep_addr == ep_st_tx->ep_addr && result == XFER_RESULT_SUCCESS) {
+    // sent complete: try to send more if possible
+    if (0 == tu_edpt_stream_write_xfer(rhport, ep_st_tx)) {
+      // If there is no data left, a ZLP should be sent if needed
+      (void)tu_edpt_stream_write_zlp_if_needed(rhport, ep_st_tx, xferred_bytes);
     }
+  } else {
+    return false;
   }
 
   return true;
diff --git a/src/class/midi/midi_device.h b/src/class/midi/midi_device.h
index 3e89cc0a3..ddbc2f9f0 100644
--- a/src/class/midi/midi_device.h
+++ b/src/class/midi/midi_device.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_MIDI_DEVICE_H_
-#define _TUSB_MIDI_DEVICE_H_
+#ifndef TUSB_MIDI_DEVICE_H_
+#define TUSB_MIDI_DEVICE_H_
 
 #include "class/audio/audio.h"
 #include "midi.h"
@@ -36,21 +36,21 @@
 
 #if !defined(CFG_TUD_MIDI_EP_BUFSIZE) && defined(CFG_TUD_MIDI_EPSIZE)
   #warning CFG_TUD_MIDI_EPSIZE is renamed to CFG_TUD_MIDI_EP_BUFSIZE, please update to use the new name
-  #define CFG_TUD_MIDI_EP_BUFSIZE    CFG_TUD_MIDI_EPSIZE
+  #define CFG_TUD_MIDI_EP_BUFSIZE CFG_TUD_MIDI_EPSIZE
 #endif
 
 #ifndef CFG_TUD_MIDI_EP_BUFSIZE
-  #define CFG_TUD_MIDI_EP_BUFSIZE     (TUD_OPT_HIGH_SPEED ? 512 : 64)
+  #define CFG_TUD_MIDI_EP_BUFSIZE (TUD_OPT_HIGH_SPEED ? 512 : 64)
 #endif
 
 #ifdef __cplusplus
- extern "C" {
+extern "C" {
 #endif
 
-/** \addtogroup MIDI_Serial Serial
- *  @{
- *  \defgroup   MIDI_Serial_Device Device
- *  @{ */
+//--------------------------------------------------------------------+
+// Application Callback API (optional)
+//--------------------------------------------------------------------+
+void tud_midi_rx_cb(uint8_t itf);
 
 //--------------------------------------------------------------------+
 // Application API (Multiple Interfaces)
@@ -58,117 +58,77 @@
 //--------------------------------------------------------------------+
 
 // Check if midi interface is mounted
-bool     tud_midi_n_mounted      (uint8_t itf);
+bool tud_midi_n_mounted(uint8_t itf);
 
 // Get the number of bytes available for reading
-uint32_t tud_midi_n_available    (uint8_t itf, uint8_t cable_num);
-
-// Read byte stream              (legacy)
-uint32_t tud_midi_n_stream_read  (uint8_t itf, uint8_t cable_num, void* buffer, uint32_t bufsize);
-
-// Write byte Stream             (legacy)
-uint32_t tud_midi_n_stream_write (uint8_t itf, uint8_t cable_num, uint8_t const* buffer, uint32_t bufsize);
-
-// Read event packet             (4 bytes)
-bool     tud_midi_n_packet_read  (uint8_t itf, uint8_t packet[4]);
-
-// Write event packet            (4 bytes)
-bool     tud_midi_n_packet_write (uint8_t itf, uint8_t const packet[4]);
-
-//--------------------------------------------------------------------+
-// Application API (Single Interface)
-//--------------------------------------------------------------------+
-static inline bool     tud_midi_mounted      (void);
-static inline uint32_t tud_midi_available    (void);
-
-static inline uint32_t tud_midi_stream_read  (void* buffer, uint32_t bufsize);
-static inline uint32_t tud_midi_stream_write (uint8_t cable_num, uint8_t const* buffer, uint32_t bufsize);
+uint32_t tud_midi_n_available(uint8_t itf, uint8_t cable_num);
 
-static inline bool     tud_midi_packet_read  (uint8_t packet[4]);
-static inline bool     tud_midi_packet_write (uint8_t const packet[4]);
-
-//------------- Deprecated API name  -------------//
-// TODO remove after 0.10.0 release
-
-TU_ATTR_DEPRECATED("tud_midi_read() is renamed to tud_midi_stream_read()")
-static inline uint32_t tud_midi_read (void* buffer, uint32_t bufsize)
-{
-  return tud_midi_stream_read(buffer, bufsize);
-}
+// Read byte stream (legacy)
+uint32_t tud_midi_n_stream_read(uint8_t itf, uint8_t cable_num, void *buffer, uint32_t bufsize);
 
-TU_ATTR_DEPRECATED("tud_midi_write() is renamed to tud_midi_stream_write()")
-static inline uint32_t tud_midi_write(uint8_t cable_num, uint8_t const* buffer, uint32_t bufsize)
-{
-  return tud_midi_stream_write(cable_num, buffer, bufsize);
-}
+// Write byte Stream (legacy)
+uint32_t tud_midi_n_stream_write(uint8_t itf, uint8_t cable_num, const uint8_t *buffer, uint32_t bufsize);
 
+// Read an event 4-byte packet
+bool tud_midi_n_packet_read(uint8_t itf, uint8_t packet[4]);
 
-TU_ATTR_DEPRECATED("tud_midi_send() is renamed to tud_midi_packet_write()")
-static inline bool tud_midi_send(uint8_t packet[4])
-{
-  return tud_midi_packet_write(packet);
-}
+// Read multiple event packets, return number of read packets
+uint32_t tud_midi_n_packet_read_n(uint8_t itf, uint8_t packets[], uint32_t max_packets);
 
-TU_ATTR_DEPRECATED("tud_midi_receive() is renamed to tud_midi_packet_read()")
-static inline bool tud_midi_receive(uint8_t packet[4])
-{
-  return tud_midi_packet_read(packet);
-}
+// Write an event 4-byte packet
+bool tud_midi_n_packet_write(uint8_t itf, const uint8_t packet[4]);
 
-//--------------------------------------------------------------------+
-// Application Callback API (weak is optional)
-//--------------------------------------------------------------------+
-TU_ATTR_WEAK void tud_midi_rx_cb(uint8_t itf);
+// Write multiple event packets, return number of written packets
+uint32_t tud_midi_n_packet_write_n(uint8_t itf, const uint8_t packets[], uint32_t n_packets);
 
 //--------------------------------------------------------------------+
-// Inline Functions
+// Application API (Single Interface)
 //--------------------------------------------------------------------+
-
-static inline bool tud_midi_mounted (void)
-{
+TU_ATTR_ALWAYS_INLINE static inline bool tud_midi_mounted(void) {
   return tud_midi_n_mounted(0);
 }
 
-static inline uint32_t tud_midi_available (void)
-{
+TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_midi_available(void) {
   return tud_midi_n_available(0, 0);
 }
 
-static inline uint32_t tud_midi_stream_read (void* buffer, uint32_t bufsize)
-{
+TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_midi_stream_read(void *buffer, uint32_t bufsize) {
   return tud_midi_n_stream_read(0, 0, buffer, bufsize);
 }
 
-static inline uint32_t tud_midi_stream_write (uint8_t cable_num, uint8_t const* buffer, uint32_t bufsize)
-{
+TU_ATTR_ALWAYS_INLINE static inline uint32_t
+tud_midi_stream_write(uint8_t cable_num, const uint8_t *buffer, uint32_t bufsize) {
   return tud_midi_n_stream_write(0, cable_num, buffer, bufsize);
 }
 
-static inline bool tud_midi_packet_read (uint8_t packet[4])
-{
+TU_ATTR_ALWAYS_INLINE static inline bool tud_midi_packet_read(uint8_t packet[4]) {
   return tud_midi_n_packet_read(0, packet);
 }
 
-static inline bool tud_midi_packet_write (uint8_t const packet[4])
-{
+TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_midi_packet_read_n(uint8_t packets[], uint32_t max_packets) {
+  return tud_midi_n_packet_read_n(0, packets, max_packets);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline bool tud_midi_packet_write(const uint8_t packet[4]) {
   return tud_midi_n_packet_write(0, packet);
 }
 
+TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_midi_packet_write_n(const uint8_t packets[], uint32_t n_packets) {
+  return tud_midi_n_packet_write_n(0, packets, n_packets);
+}
+
 //--------------------------------------------------------------------+
 // Internal Class Driver API
 //--------------------------------------------------------------------+
-void     midid_init            (void);
-bool     midid_deinit          (void);
-void     midid_reset           (uint8_t rhport);
-uint16_t midid_open            (uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
-bool     midid_control_xfer_cb (uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
-bool     midid_xfer_cb         (uint8_t rhport, uint8_t edpt_addr, xfer_result_t result, uint32_t xferred_bytes);
+void     midid_init(void);
+bool     midid_deinit(void);
+void     midid_reset(uint8_t rhport);
+uint16_t midid_open(uint8_t rhport, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
+bool     midid_control_xfer_cb(uint8_t rhport, uint8_t stage, const tusb_control_request_t *request);
+bool     midid_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t result, uint32_t xferred_bytes);
 
 #ifdef __cplusplus
- }
+}
 #endif
 
-#endif /* _TUSB_MIDI_DEVICE_H_ */
-
-/** @} */
-/** @} */
+#endif
diff --git a/src/class/midi/midi_host.c b/src/class/midi/midi_host.c
index cd6e115ee..07062875c 100644
--- a/src/class/midi/midi_host.c
+++ b/src/class/midi/midi_host.c
@@ -59,9 +59,6 @@ typedef struct {
   uint8_t iInterface;
   uint8_t itf_count;        // number of interface including Audio Control + MIDI streaming
 
-  uint8_t ep_in;          // IN endpoint address
-  uint8_t ep_out;         // OUT endpoint address
-
   uint8_t rx_cable_count;  // IN endpoint CS descriptor bNumEmbMIDIJack value
   uint8_t tx_cable_count;  // OUT endpoint CS descriptor bNumEmbMIDIJack value
 
@@ -147,8 +144,6 @@ void midih_close(uint8_t daddr) {
       TU_LOG_DRV("  MIDI close addr = %u index = %u\r\n", daddr, idx);
       tuh_midi_umount_cb(idx);
 
-      p_midi->ep_in = 0;
-      p_midi->ep_out = 0;
       p_midi->bInterfaceNumber = 0;
       p_midi->rx_cable_count = 0;
       p_midi->tx_cable_count = 0;
@@ -169,23 +164,25 @@ bool midih_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t result, uint
   const uint8_t idx = get_idx_by_ep_addr(dev_addr, ep_addr);
   TU_VERIFY(idx < CFG_TUH_MIDI);
   midih_interface_t *p_midi = &_midi_host[idx];
+  tu_edpt_stream_t  *ep_str_rx = &p_midi->ep_stream.rx;
+  tu_edpt_stream_t  *ep_str_tx = &p_midi->ep_stream.tx;
 
-  if (ep_addr == p_midi->ep_stream.rx.ep_addr) {
+  if (ep_addr == ep_str_rx->ep_addr) {
     // receive new data, put it into FIFO and invoke callback if available
     // Note: some devices send back all zero packets even if there is no data ready
-    if (xferred_bytes && !tu_mem_is_zero(p_midi->ep_stream.rx.ep_buf, xferred_bytes)) {
-      tu_edpt_stream_read_xfer_complete(&p_midi->ep_stream.rx, xferred_bytes);
+    if (xferred_bytes && !tu_mem_is_zero(ep_str_rx->ep_buf, xferred_bytes)) {
+      tu_edpt_stream_read_xfer_complete(ep_str_rx, xferred_bytes);
       tuh_midi_rx_cb(idx, xferred_bytes);
     }
 
-    tu_edpt_stream_read_xfer(dev_addr, &p_midi->ep_stream.rx); // prepare for next transfer
-  } else if (ep_addr == p_midi->ep_stream.tx.ep_addr) {
+    tu_edpt_stream_read_xfer(dev_addr, ep_str_rx); // prepare for next transfer
+  } else if (ep_addr == ep_str_tx->ep_addr) {
     tuh_midi_tx_cb(idx, xferred_bytes);
 
-    if (0 == tu_edpt_stream_write_xfer(dev_addr, &p_midi->ep_stream.tx)) {
+    if (0 == tu_edpt_stream_write_xfer(dev_addr, ep_str_tx)) {
       // If there is no data left, a ZLP should be sent if
       // xferred_bytes is multiple of EP size and not zero
-      tu_edpt_stream_write_zlp_if_needed(dev_addr, &p_midi->ep_stream.tx, xferred_bytes);
+      tu_edpt_stream_write_zlp_if_needed(dev_addr, ep_str_tx, xferred_bytes);
     }
   }
 
@@ -211,19 +208,36 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
   desc_cb.jack_num = 0;
 
   // There can be just a MIDI or an Audio + MIDI interface
-  // If there is Audio Control Interface + Audio Header descriptor, skip it
+  // - If there is Audio Control Interface + Audio Header descriptor, then skip it.
+  // - If there is an Audio Control Interface + Audio Streaming Interface, then ignore the Audio Streaming Interface.
+  // Future:
+  // Note that if this driver is used with an USB Audio Streaming host driver,
+  // then call that driver first. If the MIDI interface comes before the
+  // audio streaming interface, then the audio driver will have to call this
+  // driver after parsing the audio control interface and then resume parsing
+  // the streaming audio interface.
   if (AUDIO_SUBCLASS_CONTROL == desc_itf->bInterfaceSubClass) {
-    TU_VERIFY(max_len > 2*sizeof(tusb_desc_interface_t) + sizeof(audio_desc_cs_ac_interface_t));
+    TU_VERIFY(max_len > 2*sizeof(tusb_desc_interface_t) + sizeof(midi10_desc_cs_ac_interface_t));
 
     p_desc = tu_desc_next(p_desc);
     TU_VERIFY(tu_desc_type(p_desc) == TUSB_DESC_CS_INTERFACE &&
-              tu_desc_subtype(p_desc) == AUDIO_CS_AC_INTERFACE_HEADER);
+              tu_desc_subtype(p_desc) == AUDIO10_CS_AC_INTERFACE_HEADER);
     desc_cb.desc_audio_control = desc_itf;
 
     p_desc = tu_desc_next(p_desc);
     desc_itf = (const tusb_desc_interface_t *)p_desc;
-    TU_VERIFY(TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass);
     p_midi->itf_count = 1;
+    // skip non-interface and non-midi streaming descriptors
+    while (tu_desc_in_bounds(p_desc, p_end) &&
+      (desc_itf->bDescriptorType != TUSB_DESC_INTERFACE || (desc_itf->bInterfaceClass == TUSB_CLASS_AUDIO && desc_itf->bInterfaceSubClass != AUDIO_SUBCLASS_MIDI_STREAMING))) {
+      if (desc_itf->bDescriptorType == TUSB_DESC_INTERFACE && desc_itf->bAlternateSetting == 0) {
+        p_midi->itf_count++;
+      }
+      p_desc = tu_desc_next(p_desc);
+      desc_itf = (tusb_desc_interface_t const *)p_desc;
+    }
+    TU_VERIFY(p_desc < p_end); // TODO: If MIDI interface comes after Audio Streaming, then max_len did not include the MIDI interface descriptor
+    TU_VERIFY(TUSB_CLASS_AUDIO == desc_itf->bInterfaceClass);
   }
   TU_VERIFY(AUDIO_SUBCLASS_MIDI_STREAMING == desc_itf->bInterfaceSubClass);
 
@@ -236,7 +250,7 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
   p_desc = tu_desc_next(p_desc); // next to CS Header
 
   bool found_new_interface = false;
-  while ((p_desc < p_end) && (tu_desc_next(p_desc) <= p_end) && !found_new_interface) {
+  while (tu_desc_in_bounds(p_desc, p_end) && !found_new_interface) {
     switch (tu_desc_type(p_desc)) {
       case TUSB_DESC_INTERFACE:
         found_new_interface = true;
@@ -278,21 +292,20 @@ bool midih_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *d
         const midi_desc_cs_endpoint_t *p_csep = (const midi_desc_cs_endpoint_t *) p_desc;
 
         TU_LOG_DRV("  Endpoint and CS_Endpoint descriptor %02x\r\n", p_ep->bEndpointAddress);
+        tu_edpt_stream_t *ep_stream;
         if (tu_edpt_dir(p_ep->bEndpointAddress) == TUSB_DIR_OUT) {
-          p_midi->ep_out = p_ep->bEndpointAddress;
           p_midi->tx_cable_count = p_csep->bNumEmbMIDIJack;
           desc_cb.desc_epout = p_ep;
-
-          TU_ASSERT(tuh_edpt_open(dev_addr, p_ep));
-          tu_edpt_stream_open(&p_midi->ep_stream.tx, p_ep);
+          ep_stream              = &p_midi->ep_stream.tx;
         } else {
-          p_midi->ep_in = p_ep->bEndpointAddress;
           p_midi->rx_cable_count = p_csep->bNumEmbMIDIJack;
-          desc_cb.desc_epin = p_ep;
-
-          TU_ASSERT(tuh_edpt_open(dev_addr, p_ep));
-          tu_edpt_stream_open(&p_midi->ep_stream.rx, p_ep);
+          desc_cb.desc_epin      = p_ep;
+          ep_stream              = &p_midi->ep_stream.rx;
         }
+        TU_ASSERT(tuh_edpt_open(dev_addr, p_ep));
+        tu_edpt_stream_open(ep_stream, p_ep);
+        tu_edpt_stream_clear(ep_stream);
+
         break;
       }
 
@@ -362,8 +375,14 @@ bool tuh_midi_itf_get_info(uint8_t idx, tuh_itf_info_t* info) {
   desc->bDescriptorType    = TUSB_DESC_INTERFACE;
 
   desc->bInterfaceNumber   = p_midi->bInterfaceNumber;
-  desc->bAlternateSetting  = 0;
-  desc->bNumEndpoints      = (uint8_t)((p_midi->ep_in != 0 ? 1:0) + (p_midi->ep_out != 0 ? 1:0));
+  desc->bAlternateSetting = 0;
+  desc->bNumEndpoints     = 0;
+  if (tu_edpt_stream_is_opened(&p_midi->ep_stream.tx)) {
+    desc->bNumEndpoints++;
+  }
+  if (tu_edpt_stream_is_opened(&p_midi->ep_stream.rx)) {
+    desc->bNumEndpoints++;
+  }
   desc->bInterfaceClass    = TUSB_CLASS_AUDIO;
   desc->bInterfaceSubClass = AUDIO_SUBCLASS_MIDI_STREAMING;
   desc->bInterfaceProtocol = 0;
@@ -558,6 +577,11 @@ uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buff
             }
           }
         }
+        else {
+          // bad packet discard
+          nread = tu_edpt_stream_read(p_midi->daddr, &p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
+          continue;
+        }
       } else if (status < MIDI_STATUS_SYSEX_START) {
         // then it is a channel message either three bytes or two
         uint8_t fake_cin = (status & 0xf0) >> 4;
@@ -600,6 +624,11 @@ uint32_t tuh_midi_stream_read(uint8_t idx, uint8_t *p_cable_num, uint8_t *p_buff
         bytes_to_add_to_stream = 1;
       }
     }
+    else {
+      // bad packet discard
+      nread = tu_edpt_stream_read(p_midi->daddr, &p_midi->ep_stream.rx, p_midi->stream_read.buffer, 4);
+      continue;
+    }
 
     for (uint8_t i = 1; i <= bytes_to_add_to_stream; i++) {
       *p_buffer++ = p_midi->stream_read.buffer[i];
diff --git a/src/class/msc/msc.h b/src/class/msc/msc.h
index bbfd35a43..3b5d4a855 100644
--- a/src/class/msc/msc.h
+++ b/src/class/msc/msc.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_MSC_H_
-#define _TUSB_MSC_H_
+#ifndef TUSB_MSC_H_
+#define TUSB_MSC_H_
 
 #include "common/tusb_common.h"
 
@@ -108,8 +108,7 @@ TU_VERIFY_STATIC(sizeof(msc_csw_t) == 13, "size is not correct");
 //--------------------------------------------------------------------+
 
 /// SCSI Command Operation Code
-typedef enum
-{
+typedef enum {
   SCSI_CMD_TEST_UNIT_READY              = 0x00, ///< The SCSI Test Unit Ready command is used to determine if a device is ready to transfer data (read/write), i.e. if a disk has spun up, if a tape is loaded and ready etc. The device does not perform a self-test operation.
   SCSI_CMD_INQUIRY                      = 0x12, ///< The SCSI Inquiry command is used to obtain basic information from a target device.
   SCSI_CMD_MODE_SELECT_6                = 0x15, ///<  provides a means for the application client to specify medium, logical unit, or peripheral device parameters to the device server. Device servers that implement the MODE SELECT(6) command shall also implement the MODE SENSE(6) command. Application clients should issue MODE SENSE(6) prior to each MODE SELECT(6) to determine supported mode pages, page lengths, and other parameters.
@@ -124,8 +123,7 @@ typedef enum
 }scsi_cmd_type_t;
 
 /// SCSI Sense Key
-typedef enum
-{
+typedef enum {
   SCSI_SENSE_NONE            = 0x00, ///< no specific Sense Key. This would be the case for a successful command
   SCSI_SENSE_RECOVERED_ERROR = 0x01, ///< Indicates the last command completed successfully with some recovery action performed by the disc drive.
   SCSI_SENSE_NOT_READY       = 0x02, ///< Indicates the logical unit addressed cannot be accessed.
@@ -141,6 +139,27 @@ typedef enum
   SCSI_SENSE_MISCOMPARE      = 0x0e  ///< Indicates that the source data did not match the data read from the medium.
 }scsi_sense_key_type_t;
 
+
+typedef enum {
+  SCSI_PDT_DIRECT_ACCESS = 0x0,
+  SCSI_PDT_SEQUENTIAL_ACCESS = 0x1,
+  SCSI_PDT_PRINTER = 0x2,
+  SCSI_PDT_PROCESSOR = 0x3,
+  SCSI_PDT_WRITE_ONCE = 0x4,
+  SCSI_PDT_CD_DVD = 0x5,
+  SCSI_PDT_SCANNER = 0x6,
+  SCSI_PDT_OPTICAL_DEVICE = 0x7,
+  SCSI_PDT_MEDIUM_CHANGER = 0x8,
+  SCSI_PDT_COMMUNICATIONS = 0x9, // obsolete
+  SCSI_PDT_RAID = 0x0c,
+  SCSI_PDT_ENCLOSURE_SERVICES = 0x0d,
+  SCSI_PDT_SIMPLIFIED_DIRECT_ACCESS = 0x0e,
+  SCSI_PDT_OPTICAL_CARD_READER = 0x0f,
+  SCSI_PDT_BRIDGE = 0x10, ///< Bridge device, e.g. USB to SCSI bridge
+  SCSI_PDT_OBJECT_BASED_STORAGE = 0x11, ///< Object-based storage device
+  SCSI_PDT_AUTOMATION_DRIVE_INTERFACE = 0x12, ///< Automation/Drive Interface (ADI) device
+} scsi_peripheral_device_type_t;
+
 //--------------------------------------------------------------------+
 // SCSI Primary Command (SPC-4)
 //--------------------------------------------------------------------+
@@ -379,4 +398,4 @@ TU_VERIFY_STATIC(sizeof(scsi_write10_t) == 10, "size is not correct");
  }
 #endif
 
-#endif /* _TUSB_MSC_H_ */
+#endif /* TUSB_MSC_H_ */
diff --git a/src/class/msc/msc_device.c b/src/class/msc/msc_device.c
index 87c77c9a7..41d9cdfa0 100644
--- a/src/class/msc/msc_device.c
+++ b/src/class/msc/msc_device.c
@@ -42,6 +42,17 @@
 #define TU_LOG_DRV(...)   TU_LOG(CFG_TUD_MSC_LOG_LEVEL, __VA_ARGS__)
 
 //--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4]) {
+  (void) lun; (void) vendor_id; (void) product_id; (void) product_rev;
+}
+TU_ATTR_WEAK uint32_t tud_msc_inquiry2_cb(uint8_t lun, scsi_inquiry_resp_t *inquiry_resp, uint32_t bufsize) {
+  (void) lun; (void) inquiry_resp; (void) bufsize;
+  return 0;
+}
+
+//--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
 enum {
@@ -53,23 +64,26 @@ enum {
 };
 
 typedef struct {
-  TU_ATTR_ALIGNED(4) msc_cbw_t cbw;
-  TU_ATTR_ALIGNED(4) msc_csw_t csw;
+  TU_ATTR_ALIGNED(4) msc_cbw_t cbw; // 31 bytes
+  uint8_t  rhport;
 
+  TU_ATTR_ALIGNED(4) msc_csw_t csw; // 13 bytes
   uint8_t  itf_num;
   uint8_t  ep_in;
   uint8_t  ep_out;
 
-  // Bulk Only Transfer (BOT) Protocol
-  uint8_t  stage;
-
   uint32_t total_len;   // byte to be transferred, can be smaller than total_bytes in cbw
   uint32_t xferred_len; // numbered of bytes transferred so far in the Data Stage
 
-  // Sense Response Data
+  // Bulk Only Transfer (BOT) Protocol
+  uint8_t stage;
+
+  // SCSI Sense Response Data
   uint8_t sense_key;
   uint8_t add_sense_code;
   uint8_t add_sense_qualifier;
+
+  bool pending_io; // pending async IO
 }mscd_interface_t;
 
 static mscd_interface_t _mscd_itf;
@@ -78,35 +92,42 @@ CFG_TUD_MEM_SECTION static struct {
   TUD_EPBUF_DEF(buf, CFG_TUD_MSC_EP_BUFSIZE);
 } _mscd_epbuf;
 
+TU_VERIFY_STATIC(CFG_TUD_MSC_EP_BUFSIZE >= 64, "CFG_TUD_MSC_EP_BUFSIZE must be at least 64");
+
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
 static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_t* buffer, uint32_t bufsize);
-static void proc_read10_cmd(uint8_t rhport, mscd_interface_t* p_msc);
-
-static void proc_write10_cmd(uint8_t rhport, mscd_interface_t* p_msc);
-static void proc_write10_new_data(uint8_t rhport, mscd_interface_t* p_msc, uint32_t xferred_bytes);
+static void proc_read10_cmd(mscd_interface_t* p_msc);
+static void proc_read_io_data(mscd_interface_t* p_msc, int32_t nbytes);
+static void proc_write10_cmd(mscd_interface_t* p_msc);
+static void proc_write10_host_data(mscd_interface_t* p_msc, uint32_t xferred_bytes);
+static void proc_write_io_data(mscd_interface_t* p_msc, uint32_t xferred_bytes, int32_t nbytes);
+static bool proc_stage_status(mscd_interface_t* p_msc);
 
 TU_ATTR_ALWAYS_INLINE static inline bool is_data_in(uint8_t dir) {
   return tu_bit_test(dir, 7);
 }
 
-static inline bool send_csw(uint8_t rhport, mscd_interface_t* p_msc) {
+TU_ATTR_ALWAYS_INLINE static inline bool send_csw(mscd_interface_t* p_msc) {
   // Data residue is always = host expect - actual transferred
+  uint8_t rhport = p_msc->rhport;
   p_msc->csw.data_residue = p_msc->cbw.total_bytes - p_msc->xferred_len;
   p_msc->stage = MSC_STAGE_STATUS_SENT;
-  memcpy(_mscd_epbuf.buf, &p_msc->csw, sizeof(msc_csw_t));
+  memcpy(_mscd_epbuf.buf, &p_msc->csw, sizeof(msc_csw_t)); //-V1086
   return usbd_edpt_xfer(rhport, p_msc->ep_in , _mscd_epbuf.buf, sizeof(msc_csw_t));
 }
 
-static inline bool prepare_cbw(uint8_t rhport, mscd_interface_t* p_msc) {
+TU_ATTR_ALWAYS_INLINE static inline bool prepare_cbw(mscd_interface_t* p_msc) {
+  uint8_t rhport = p_msc->rhport;
   p_msc->stage = MSC_STAGE_CMD;
   return usbd_edpt_xfer(rhport, p_msc->ep_out,  _mscd_epbuf.buf, sizeof(msc_cbw_t));
 }
 
-static void fail_scsi_op(uint8_t rhport, mscd_interface_t* p_msc, uint8_t status) {
+static void fail_scsi_op(mscd_interface_t* p_msc, uint8_t status) {
   msc_cbw_t const * p_cbw = &p_msc->cbw;
   msc_csw_t       * p_csw = &p_msc->csw;
+  uint8_t rhport = p_msc->rhport;
 
   p_csw->status       = status;
   p_csw->data_residue = p_msc->cbw.total_bytes - p_msc->xferred_len;
@@ -114,7 +135,7 @@ static void fail_scsi_op(uint8_t rhport, mscd_interface_t* p_msc, uint8_t status
 
   // failed but sense key is not set: default to Illegal Request
   if (p_msc->sense_key == 0) {
-    tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
+    (void) tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
   }
 
   // If there is data stage and not yet complete, stall it
@@ -127,18 +148,18 @@ static void fail_scsi_op(uint8_t rhport, mscd_interface_t* p_msc, uint8_t status
   }
 }
 
-static inline uint32_t rdwr10_get_lba(uint8_t const command[]) {
+TU_ATTR_ALWAYS_INLINE static inline uint32_t rdwr10_get_lba(uint8_t const command[]) {
   // use offsetof to avoid pointer to the odd/unaligned address
   const uint32_t lba = tu_unaligned_read32(command + offsetof(scsi_write10_t, lba));
   return tu_ntohl(lba); // lba is in Big Endian
 }
 
-static inline uint16_t rdwr10_get_blockcount(msc_cbw_t const* cbw) {
+TU_ATTR_ALWAYS_INLINE static inline uint16_t rdwr10_get_blockcount(msc_cbw_t const* cbw) {
   uint16_t const block_count = tu_unaligned_read16(cbw->command + offsetof(scsi_write10_t, block_count));
   return tu_ntohs(block_count);
 }
 
-static inline uint16_t rdwr10_get_blocksize(msc_cbw_t const* cbw) {
+TU_ATTR_ALWAYS_INLINE static inline uint16_t rdwr10_get_blocksize(msc_cbw_t const* cbw) {
   // first extract block count in the command
   uint16_t const block_count = rdwr10_get_blockcount(cbw);
   if (block_count == 0) {
@@ -152,7 +173,7 @@ static uint8_t rdwr10_validate_cmd(msc_cbw_t const* cbw) {
   uint16_t const block_count = rdwr10_get_blockcount(cbw);
 
   if (cbw->total_bytes == 0) {
-    if (block_count) {
+    if (block_count > 0) {
       TU_LOG_DRV("  SCSI case 2 (Hn < Di) or case 3 (Hn < Do) \r\n");
       status = MSC_CSW_STATUS_PHASE_ERROR;
     } else {
@@ -171,12 +192,88 @@ static uint8_t rdwr10_validate_cmd(msc_cbw_t const* cbw) {
     } else if (cbw->total_bytes / block_count == 0) {
       TU_LOG_DRV(" Computed block size = 0. SCSI case 7 Hi < Di (READ10) or case 13 Ho < Do (WRIT10)\r\n");
       status = MSC_CSW_STATUS_PHASE_ERROR;
+    } else {
+      // nothing to do
     }
   }
 
   return status;
 }
 
+static bool proc_stage_status(mscd_interface_t *p_msc) {
+  uint8_t rhport = p_msc->rhport;
+  msc_cbw_t const *p_cbw = &p_msc->cbw;
+
+  // skip status if epin is currently stalled, will do it when received Clear Stall request
+  if (!usbd_edpt_stalled(rhport, p_msc->ep_in)) {
+    if ((p_cbw->total_bytes > p_msc->xferred_len) && is_data_in(p_cbw->dir)) {
+      // 6.7 The 13 Cases: case 5 (Hi > Di): STALL before status
+      // TU_LOG_DRV("  SCSI case 5 (Hi > Di): %lu > %lu\r\n", p_cbw->total_bytes, p_msc->xferred_len);
+      usbd_edpt_stall(rhport, p_msc->ep_in);
+    } else {
+      TU_ASSERT(send_csw(p_msc));
+    }
+  }
+
+  #if TU_CHECK_MCU(OPT_MCU_CXD56)
+  // WORKAROUND: cxd56 has its own nuttx usb stack which does not forward Set/ClearFeature(Endpoint) to DCD.
+  // There is no way for us to know when EP is un-stall, therefore we will unconditionally un-stall here and
+  // hope everything will work
+  if (usbd_edpt_stalled(rhport, p_msc->ep_in)) {
+    usbd_edpt_clear_stall(rhport, p_msc->ep_in);
+    send_csw(p_msc);
+  }
+  #endif
+  return true;
+}
+
+//--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_msc_read10_complete_cb(uint8_t lun) {
+  (void) lun;
+}
+
+TU_ATTR_WEAK void tud_msc_write10_complete_cb(uint8_t lun) {
+  (void) lun;
+}
+
+TU_ATTR_WEAK void tud_msc_scsi_complete_cb(uint8_t lun, uint8_t const scsi_cmd[16]) {
+  (void) lun;
+  (void) scsi_cmd;
+}
+
+TU_ATTR_WEAK uint8_t tud_msc_get_maxlun_cb(void) {
+  return 1;
+}
+
+TU_ATTR_WEAK bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, bool load_eject) {
+  (void) lun;
+  (void) power_condition;
+  (void) start;
+  (void) load_eject;
+  return true;
+}
+
+TU_ATTR_WEAK bool tud_msc_prevent_allow_medium_removal_cb(uint8_t lun, uint8_t prohibit_removal, uint8_t control) {
+  (void) lun;
+  (void) prohibit_removal;
+  (void) control;
+  return true;
+}
+
+TU_ATTR_WEAK int32_t tud_msc_request_sense_cb(uint8_t lun, void* buffer, uint16_t bufsize) {
+  (void) lun;
+  (void) buffer;
+  (void) bufsize;
+  return sizeof(scsi_sense_fixed_resp_t);
+}
+
+TU_ATTR_WEAK bool tud_msc_is_writable_cb(uint8_t lun) {
+  (void) lun;
+  return true;
+}
+
 //--------------------------------------------------------------------+
 // Debug
 //--------------------------------------------------------------------+
@@ -214,15 +311,51 @@ bool tud_msc_set_sense(uint8_t lun, uint8_t sense_key, uint8_t add_sense_code, u
   return true;
 }
 
-static inline void set_sense_medium_not_present(uint8_t lun) {
+TU_ATTR_ALWAYS_INLINE static inline void set_sense_medium_not_present(uint8_t lun) {
   // default sense is NOT READY, MEDIUM NOT PRESENT
-  tud_msc_set_sense(lun, SCSI_SENSE_NOT_READY, 0x3A, 0x00);
+  (void) tud_msc_set_sense(lun, SCSI_SENSE_NOT_READY, 0x3A, 0x00);
+}
+
+static void proc_async_io_done(void *bytes_io) {
+  mscd_interface_t *p_msc = &_mscd_itf;
+  TU_VERIFY(p_msc->pending_io, );
+  const int32_t nbytes = (int32_t) (intptr_t) bytes_io;
+  const uint8_t cmd = p_msc->cbw.command[0];
+
+  p_msc->pending_io = false;
+  switch (cmd) {
+    case SCSI_CMD_READ_10:
+      proc_read_io_data(p_msc, nbytes);
+      break;
+
+    case SCSI_CMD_WRITE_10:
+      proc_write_io_data(p_msc, (uint32_t) nbytes, nbytes);
+      break;
+
+    default: break; // nothing to do
+  }
+
+  // send status if stage is transitioned to STATUS
+  if (p_msc->stage == MSC_STAGE_STATUS) {
+    proc_stage_status(p_msc);
+  }
+}
+
+bool tud_msc_async_io_done(int32_t bytes_io, bool in_isr) {
+  // Precheck to avoid queueing multiple RW done callback
+  TU_VERIFY(_mscd_itf.pending_io);
+  if (bytes_io == 0) {
+    bytes_io = TUD_MSC_RET_ERROR; // 0 is treated as error, no reason to call this with BUSY here
+  }
+  usbd_defer_func(proc_async_io_done, (void *) (intptr_t) bytes_io, in_isr);
+  return true;
 }
 
 //--------------------------------------------------------------------+
 // USBD Driver API
 //--------------------------------------------------------------------+
 void mscd_init(void) {
+  TU_LOG_INT(CFG_TUD_MSC_LOG_LEVEL, sizeof(mscd_interface_t));
   tu_memclr(&_mscd_itf, sizeof(mscd_interface_t));
 }
 
@@ -245,12 +378,13 @@ uint16_t mscd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint1
 
   mscd_interface_t * p_msc = &_mscd_itf;
   p_msc->itf_num = itf_desc->bInterfaceNumber;
+  p_msc->rhport = rhport;
 
   // Open endpoint pair
   TU_ASSERT(usbd_open_edpt_pair(rhport, tu_desc_next(itf_desc), 2, TUSB_XFER_BULK, &p_msc->ep_out, &p_msc->ep_in), 0);
 
   // Prepare for Command Block Wrapper
-  TU_ASSERT(prepare_cbw(rhport, p_msc), drv_len);
+  TU_ASSERT(prepare_cbw(p_msc), drv_len);
 
   return drv_len;
 }
@@ -289,16 +423,18 @@ bool mscd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t
       if (ep_addr == p_msc->ep_in) {
         if (p_msc->stage == MSC_STAGE_STATUS) {
           // resume sending SCSI status if we are in this stage previously before stalled
-          TU_ASSERT(send_csw(rhport, p_msc));
+          TU_ASSERT(send_csw(p_msc));
         }
       } else if (ep_addr == p_msc->ep_out) {
         if (p_msc->stage == MSC_STAGE_CMD) {
           // part of reset recovery (probably due to invalid CBW) -> prepare for new command
           // Note: skip if already queued previously
           if (usbd_edpt_ready(rhport, p_msc->ep_out)) {
-            TU_ASSERT(prepare_cbw(rhport, p_msc));
+            TU_ASSERT(prepare_cbw(p_msc));
           }
         }
+      } else {
+        // nothing to do
       }
     }
 
@@ -320,11 +456,8 @@ bool mscd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t
       TU_LOG_DRV("  MSC Get Max Lun\r\n");
       TU_VERIFY(request->wValue == 0 && request->wLength == 1);
 
-      uint8_t maxlun = 1;
-      if (tud_msc_get_maxlun_cb) {
-        maxlun = tud_msc_get_maxlun_cb();
-      }
-      TU_VERIFY(maxlun);
+      uint8_t maxlun = tud_msc_get_maxlun_cb();
+      TU_VERIFY(maxlun != 0);
       maxlun--; // MAX LUN is minus 1 by specs
       tud_control_xfer(rhport, request, &maxlun, 1);
       break;
@@ -382,12 +515,12 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
         uint8_t const status = rdwr10_validate_cmd(p_cbw);
 
         if (status != MSC_CSW_STATUS_PASSED) {
-          fail_scsi_op(rhport, p_msc, status);
-        } else if (p_cbw->total_bytes) {
+          fail_scsi_op(p_msc, status);
+        } else if (p_cbw->total_bytes > 0) {
           if (SCSI_CMD_READ_10 == p_cbw->command[0]) {
-            proc_read10_cmd(rhport, p_msc);
+            proc_read10_cmd(p_msc);
           } else {
-            proc_write10_cmd(rhport, p_msc);
+            proc_write10_cmd(p_msc);
           }
         } else {
           // no data transfer, only exist in complaint test suite
@@ -400,7 +533,7 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
         if ((p_cbw->total_bytes > 0) && !is_data_in(p_cbw->dir)) {
           if (p_cbw->total_bytes > CFG_TUD_MSC_EP_BUFSIZE) {
             TU_LOG_DRV("  SCSI reject non READ10/WRITE10 with large data\r\n");
-            fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
+            fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
           } else {
             // Didn't check for case 9 (Ho > Dn), which requires examining scsi command first
             // but it is OK to just receive data then responded with failed status
@@ -418,12 +551,12 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
           if (resplen < 0) {
             // unsupported command
             TU_LOG_DRV("  SCSI unsupported or failed command\r\n");
-            fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
+            fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
           } else if (resplen == 0) {
-            if (p_cbw->total_bytes) {
+            if (p_cbw->total_bytes > 0) {
               // 6.7 The 13 Cases: case 4 (Hi > Dn)
               // TU_LOG_DRV("  SCSI case 4 (Hi > Dn): %lu\r\n", p_cbw->total_bytes);
-              fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
+              fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
             } else {
               // case 1 Hn = Dn: all good
               p_msc->stage = MSC_STAGE_STATUS;
@@ -432,7 +565,7 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
             if (p_cbw->total_bytes == 0) {
               // 6.7 The 13 Cases: case 2 (Hn < Di)
               // TU_LOG_DRV("  SCSI case 2 (Hn < Di): %lu\r\n", p_cbw->total_bytes);
-              fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
+              fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
             } else {
               // cannot return more than host expect
               p_msc->total_len = tu_min32((uint32_t)resplen, p_cbw->total_bytes);
@@ -456,10 +589,10 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
           // Data Stage is complete
           p_msc->stage = MSC_STAGE_STATUS;
         }else {
-          proc_read10_cmd(rhport, p_msc);
+          proc_read10_cmd(p_msc);
         }
       } else if (SCSI_CMD_WRITE_10 == p_cbw->command[0]) {
-        proc_write10_new_data(rhport, p_msc, xferred_bytes);
+        proc_write10_host_data(p_msc, xferred_bytes);
       } else {
         p_msc->xferred_len += xferred_bytes;
 
@@ -470,7 +603,7 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
           if ( cb_result < 0 ) {
             // unsupported command
             TU_LOG_DRV("  SCSI unsupported command\r\n");
-            fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
+            fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
           }else {
             // TODO haven't implement this scenario any further yet
           }
@@ -491,7 +624,7 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
     break;
 
     case MSC_STAGE_STATUS_SENT:
-      // Wait for the Status phase to complete
+      // Status phase is complete
       if ((ep_addr == p_msc->ep_in) && (xferred_bytes == sizeof(msc_csw_t))) {
         TU_LOG_DRV("  SCSI Status [Lun%u] = %u\r\n", p_cbw->lun, p_csw->status);
         // TU_LOG_MEM(CFG_TUD_MSC_LOG_LEVEL, p_csw, xferred_bytes, 2);
@@ -501,55 +634,30 @@ bool mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t
         // if complete_cb() is invoked after queuing the status.
         switch (p_cbw->command[0]) {
           case SCSI_CMD_READ_10:
-            if (tud_msc_read10_complete_cb) {
-              tud_msc_read10_complete_cb(p_cbw->lun);
-            }
+            tud_msc_read10_complete_cb(p_cbw->lun);
             break;
 
           case SCSI_CMD_WRITE_10:
-            if (tud_msc_write10_complete_cb) {
-              tud_msc_write10_complete_cb(p_cbw->lun);
-            }
+            tud_msc_write10_complete_cb(p_cbw->lun);
             break;
 
           default:
-            if (tud_msc_scsi_complete_cb) {
-              tud_msc_scsi_complete_cb(p_cbw->lun, p_cbw->command);
-            }
+            tud_msc_scsi_complete_cb(p_cbw->lun, p_cbw->command);
             break;
         }
 
-        TU_ASSERT(prepare_cbw(rhport, p_msc));
+        TU_ASSERT(prepare_cbw(p_msc));
       } else {
-        // Any xfer ended here is consider unknown error, ignore it
+        // Any xfer ended here is considered unknown error, ignore it
         TU_LOG1("  Warning expect SCSI Status but received unknown data\r\n");
       }
       break;
 
-    default: break;
+    default: break; // nothing to do
   }
 
   if (p_msc->stage == MSC_STAGE_STATUS) {
-    // skip status if epin is currently stalled, will do it when received Clear Stall request
-    if (!usbd_edpt_stalled(rhport, p_msc->ep_in)) {
-      if ((p_cbw->total_bytes > p_msc->xferred_len) && is_data_in(p_cbw->dir)) {
-        // 6.7 The 13 Cases: case 5 (Hi > Di): STALL before status
-        // TU_LOG_DRV("  SCSI case 5 (Hi > Di): %lu > %lu\r\n", p_cbw->total_bytes, p_msc->xferred_len);
-        usbd_edpt_stall(rhport, p_msc->ep_in);
-      } else {
-        TU_ASSERT(send_csw(rhport, p_msc));
-      }
-    }
-
-    #if TU_CHECK_MCU(OPT_MCU_CXD56)
-    // WORKAROUND: cxd56 has its own nuttx usb stack which does not forward Set/ClearFeature(Endpoint) to DCD.
-    // There is no way for us to know when EP is un-stall, therefore we will unconditionally un-stall here and
-    // hope everything will work
-    if ( usbd_edpt_stalled(rhport, p_msc->ep_in) ) {
-      usbd_edpt_clear_stall(rhport, p_msc->ep_in);
-      send_csw(rhport, p_msc);
-    }
-    #endif
+    TU_ASSERT(proc_stage_status(p_msc));
   }
 
   return true;
@@ -581,40 +689,35 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
       }
       break;
 
-    case SCSI_CMD_START_STOP_UNIT:
+    case SCSI_CMD_START_STOP_UNIT: {
       resplen = 0;
+      scsi_start_stop_unit_t const* start_stop = (scsi_start_stop_unit_t const*)scsi_cmd;
+      if (!tud_msc_start_stop_cb(lun, start_stop->power_condition, start_stop->start, start_stop->load_eject)) {
+        // Failed status response
+        resplen = -1;
 
-      if (tud_msc_start_stop_cb) {
-        scsi_start_stop_unit_t const* start_stop = (scsi_start_stop_unit_t const*)scsi_cmd;
-        if (!tud_msc_start_stop_cb(lun, start_stop->power_condition, start_stop->start, start_stop->load_eject)) {
-          // Failed status response
-          resplen = -1;
-
-          // set default sense if not set by callback
-          if (p_msc->sense_key == 0) {
-            set_sense_medium_not_present(lun);
-          }
+        // set default sense if not set by callback
+        if (p_msc->sense_key == 0) {
+          set_sense_medium_not_present(lun);
         }
       }
       break;
+    }
 
-    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
+    case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL: {
       resplen = 0;
+      scsi_prevent_allow_medium_removal_t const* prevent_allow = (scsi_prevent_allow_medium_removal_t const*)scsi_cmd;
+      if (!tud_msc_prevent_allow_medium_removal_cb(lun, prevent_allow->prohibit_removal, prevent_allow->control)) {
+        // Failed status response
+        resplen = -1;
 
-      if (tud_msc_prevent_allow_medium_removal_cb) {
-        scsi_prevent_allow_medium_removal_t const* prevent_allow = (scsi_prevent_allow_medium_removal_t const*)scsi_cmd;
-        if (!tud_msc_prevent_allow_medium_removal_cb(lun, prevent_allow->prohibit_removal, prevent_allow->control)) {
-          // Failed status response
-          resplen = -1;
-
-          // set default sense if not set by callback
-          if (p_msc->sense_key == 0) {
-            set_sense_medium_not_present(lun);
-          }
+        // set default sense if not set by callback
+        if (p_msc->sense_key == 0) {
+          set_sense_medium_not_present(lun);
         }
       }
       break;
-
+    }
 
     case SCSI_CMD_READ_CAPACITY_10: {
       uint32_t block_count;
@@ -642,12 +745,11 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         resplen = sizeof(read_capa10);
         TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &read_capa10, (size_t) resplen));
       }
+      break;
     }
-    break;
 
     case SCSI_CMD_READ_FORMAT_CAPACITY: {
-      scsi_read_format_capacity_data_t read_fmt_capa =
-      {
+      scsi_read_format_capacity_data_t read_fmt_capa = {
         .list_length = 8,
         .block_num = 0,
         .descriptor_type = 2, // formatted media
@@ -675,33 +777,28 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         resplen = sizeof(read_fmt_capa);
         TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &read_fmt_capa, (size_t) resplen));
       }
+      break;
     }
-    break;
 
     case SCSI_CMD_INQUIRY: {
-      scsi_inquiry_resp_t inquiry_rsp =
-      {
-        .is_removable = 1,
-        .version = 2,
-        .response_data_format = 2,
-        .additional_length = sizeof(scsi_inquiry_resp_t) - 5,
-      };
+      scsi_inquiry_resp_t *inquiry_rsp = (scsi_inquiry_resp_t *) buffer;
+      tu_memclr(inquiry_rsp, sizeof(scsi_inquiry_resp_t));
+      inquiry_rsp->is_removable = 1;
+      inquiry_rsp->version = 2;
+      inquiry_rsp->response_data_format = 2;
+      inquiry_rsp->additional_length = sizeof(scsi_inquiry_resp_t) - 5;
 
-      // vendor_id, product_id, product_rev is space padded string
-      memset(inquiry_rsp.vendor_id  , ' ', sizeof(inquiry_rsp.vendor_id));
-      memset(inquiry_rsp.product_id , ' ', sizeof(inquiry_rsp.product_id));
-      memset(inquiry_rsp.product_rev, ' ', sizeof(inquiry_rsp.product_rev));
-
-      tud_msc_inquiry_cb(lun, inquiry_rsp.vendor_id, inquiry_rsp.product_id, inquiry_rsp.product_rev);
-
-      resplen = sizeof(inquiry_rsp);
-      TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &inquiry_rsp, (size_t) resplen));
+      resplen = (int32_t) tud_msc_inquiry2_cb(lun, inquiry_rsp, bufsize);
+      if (resplen == 0) {
+        // stub callback with no response, use v1 callback
+        tud_msc_inquiry_cb(lun, inquiry_rsp->vendor_id, inquiry_rsp->product_id, inquiry_rsp->product_rev);
+        resplen = sizeof(scsi_inquiry_resp_t);
+      }
+      break;
     }
-    break;
 
     case SCSI_CMD_MODE_SENSE_6: {
-      scsi_mode_sense6_resp_t mode_resp =
-      {
+      scsi_mode_sense6_resp_t mode_resp = {
         .data_len = 3,
         .medium_type = 0,
         .write_protected = false,
@@ -709,21 +806,17 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
         .block_descriptor_len = 0 // no block descriptor are included
       };
 
-      bool writable = true;
-      if (tud_msc_is_writable_cb) {
-        writable = tud_msc_is_writable_cb(lun);
-      }
+      bool writable = tud_msc_is_writable_cb(lun);
 
       mode_resp.write_protected = !writable;
 
       resplen = sizeof(mode_resp);
       TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &mode_resp, (size_t) resplen));
+      break;
     }
-    break;
 
     case SCSI_CMD_REQUEST_SENSE: {
-      scsi_sense_fixed_resp_t sense_rsp =
-      {
+      scsi_sense_fixed_resp_t sense_rsp = {
         .response_code = 0x70, // current, fixed format
         .valid = 1
       };
@@ -737,14 +830,12 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
       TU_VERIFY(0 == tu_memcpy_s(buffer, bufsize, &sense_rsp, (size_t) resplen));
 
       // request sense callback could overwrite the sense data
-      if (tud_msc_request_sense_cb) {
-        resplen = tud_msc_request_sense_cb(lun, buffer, (uint16_t)bufsize);
-      }
+      resplen = tud_msc_request_sense_cb(lun, buffer, (uint16_t)bufsize);
 
       // Clear sense data after copy
-      tud_msc_set_sense(lun, 0, 0, 0);
+      (void) tud_msc_set_sense(lun, 0, 0, 0);
+      break;
     }
-    break;
 
     default: resplen = -1;
       break;
@@ -753,95 +844,108 @@ static int32_t proc_builtin_scsi(uint8_t lun, uint8_t const scsi_cmd[16], uint8_
   return resplen;
 }
 
-static void proc_read10_cmd(uint8_t rhport, mscd_interface_t* p_msc) {
+static void proc_read10_cmd(mscd_interface_t* p_msc) {
   msc_cbw_t const* p_cbw = &p_msc->cbw;
-
-  // block size already verified not zero
-  uint16_t const block_sz = rdwr10_get_blocksize(p_cbw);
-
-  // Adjust lba with transferred bytes
+  uint16_t const block_sz = rdwr10_get_blocksize(p_cbw); // already verified non-zero
+  TU_VERIFY(block_sz != 0, );
+  // Adjust lba & offset with transferred bytes
   uint32_t const lba = rdwr10_get_lba(p_cbw->command) + (p_msc->xferred_len / block_sz);
+  uint32_t const offset = p_msc->xferred_len % block_sz;
 
   // remaining bytes capped at class buffer
   int32_t nbytes = (int32_t)tu_min32(CFG_TUD_MSC_EP_BUFSIZE, p_cbw->total_bytes - p_msc->xferred_len);
 
-  // Application can consume smaller bytes
-  uint32_t const offset = p_msc->xferred_len % block_sz;
+  p_msc->pending_io = true;
   nbytes = tud_msc_read10_cb(p_cbw->lun, lba, offset, _mscd_epbuf.buf, (uint32_t)nbytes);
+  if (nbytes != TUD_MSC_RET_ASYNC) {
+    p_msc->pending_io = false;
+    proc_read_io_data(p_msc, nbytes);
+  }
+}
 
-  if (nbytes < 0) {
-    // negative means error -> endpoint is stalled & status in CSW set to failed
-    TU_LOG_DRV("  tud_msc_read10_cb() return -1\r\n");
+static void proc_read_io_data(mscd_interface_t* p_msc, int32_t nbytes) {
+  const uint8_t rhport = p_msc->rhport;
+  if (nbytes > 0) {
+    TU_ASSERT(usbd_edpt_xfer(rhport, p_msc->ep_in, _mscd_epbuf.buf, (uint16_t) nbytes),);
+  } else {
+    // nbytes is status
+    switch (nbytes) {
+      case TUD_MSC_RET_ERROR:
+        // error -> endpoint is stalled & status in CSW set to failed
+        TU_LOG_DRV("  IO read() failed\r\n");
+        set_sense_medium_not_present(p_msc->cbw.lun);
+        fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
+        break;
 
-    // set sense
-    set_sense_medium_not_present(p_cbw->lun);
+      case TUD_MSC_RET_BUSY:
+        // not ready yet -> fake a transfer complete so that this driver callback will fire again
+        dcd_event_xfer_complete(rhport, p_msc->ep_in, 0, XFER_RESULT_SUCCESS, false);
+        break;
 
-    fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
-  } else if (nbytes == 0) {
-    // zero means not ready -> simulate an transfer complete so that this driver callback will fired again
-    dcd_event_xfer_complete(rhport, p_msc->ep_in, 0, XFER_RESULT_SUCCESS, false);
-  } else {
-    TU_ASSERT(usbd_edpt_xfer(rhport, p_msc->ep_in, _mscd_epbuf.buf, (uint16_t) nbytes),);
+      default: break; // nothing to do
+    }
   }
 }
 
-static void proc_write10_cmd(uint8_t rhport, mscd_interface_t* p_msc) {
+static void proc_write10_cmd(mscd_interface_t* p_msc) {
   msc_cbw_t const* p_cbw = &p_msc->cbw;
-  bool writable = true;
-
-  if (tud_msc_is_writable_cb) {
-    writable = tud_msc_is_writable_cb(p_cbw->lun);
-  }
+  const bool writable = tud_msc_is_writable_cb(p_cbw->lun);
 
   if (!writable) {
     // Not writable, complete this SCSI op with error
     // Sense = Write protected
-    tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_DATA_PROTECT, 0x27, 0x00);
-    fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
+    (void) tud_msc_set_sense(p_cbw->lun, SCSI_SENSE_DATA_PROTECT, 0x27, 0x00);
+    fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
     return;
   }
 
   // remaining bytes capped at class buffer
   uint16_t nbytes = (uint16_t)tu_min32(CFG_TUD_MSC_EP_BUFSIZE, p_cbw->total_bytes - p_msc->xferred_len);
-
   // Write10 callback will be called later when usb transfer complete
-  TU_ASSERT(usbd_edpt_xfer(rhport, p_msc->ep_out, _mscd_epbuf.buf, nbytes),);
+  TU_ASSERT(usbd_edpt_xfer(p_msc->rhport, p_msc->ep_out, _mscd_epbuf.buf, nbytes),);
 }
 
 // process new data arrived from WRITE10
-static void proc_write10_new_data(uint8_t rhport, mscd_interface_t* p_msc, uint32_t xferred_bytes) {
+static void proc_write10_host_data(mscd_interface_t* p_msc, uint32_t xferred_bytes) {
   msc_cbw_t const* p_cbw = &p_msc->cbw;
+  uint16_t const block_sz = rdwr10_get_blocksize(p_cbw); // already verified non-zero
+  TU_VERIFY(block_sz != 0, );
 
-  // block size already verified not zero
-  uint16_t const block_sz = rdwr10_get_blocksize(p_cbw);
-
-  // Adjust lba with transferred bytes
+  // Adjust lba & offset with transferred bytes
   uint32_t const lba = rdwr10_get_lba(p_cbw->command) + (p_msc->xferred_len / block_sz);
-
-  // Invoke callback to consume new data
   uint32_t const offset = p_msc->xferred_len % block_sz;
-  int32_t nbytes = tud_msc_write10_cb(p_cbw->lun, lba, offset, _mscd_epbuf.buf, xferred_bytes);
 
-  if (nbytes < 0) {
-    // negative means error -> failed this scsi op
-    TU_LOG_DRV("  tud_msc_write10_cb() return -1\r\n");
+  p_msc->pending_io = true;
+  int32_t nbytes =  tud_msc_write10_cb(p_cbw->lun, lba, offset, _mscd_epbuf.buf, xferred_bytes);
+  if (nbytes != TUD_MSC_RET_ASYNC) {
+    p_msc->pending_io = false;
+    proc_write_io_data(p_msc, xferred_bytes, nbytes);
+  }
+}
 
-    // update actual byte before failed
-    p_msc->xferred_len += xferred_bytes;
+static void proc_write_io_data(mscd_interface_t* p_msc, uint32_t xferred_bytes, int32_t nbytes) {
+  if (nbytes < 0) {
+    // nbytes is status
+    switch (nbytes) {
+      case TUD_MSC_RET_ERROR:
+        // IO error -> failed this scsi op
+        TU_LOG_DRV("  IO write() failed\r\n");
+        set_sense_medium_not_present(p_msc->cbw.lun);
+        fail_scsi_op(p_msc, MSC_CSW_STATUS_FAILED);
+        break;
 
-    set_sense_medium_not_present(p_cbw->lun);
-    fail_scsi_op(rhport, p_msc, MSC_CSW_STATUS_FAILED);
+      default: break; // nothing to do
+    }
   } else {
     if ((uint32_t)nbytes < xferred_bytes) {
-      // Application consume less than what we got (including zero)
+      // Application consume less than what we got including TUD_MSC_RET_BUSY (0)
       const uint32_t left_over = xferred_bytes - (uint32_t)nbytes;
       if (nbytes > 0) {
-        p_msc->xferred_len += (uint16_t)nbytes;
         memmove(_mscd_epbuf.buf, _mscd_epbuf.buf + nbytes, left_over);
       }
 
-      // simulate a transfer complete with adjusted parameters --> callback will be invoked with adjusted parameter
-      dcd_event_xfer_complete(rhport, p_msc->ep_out, left_over, XFER_RESULT_SUCCESS, false);
+      // fake a transfer complete with adjusted parameters --> callback will be invoked with adjusted parameters
+      dcd_event_xfer_complete(p_msc->rhport, p_msc->ep_out, left_over, XFER_RESULT_SUCCESS, false);
     } else {
       // Application consume all bytes in our buffer
       p_msc->xferred_len += xferred_bytes;
@@ -851,7 +955,7 @@ static void proc_write10_new_data(uint8_t rhport, mscd_interface_t* p_msc, uint3
         p_msc->stage = MSC_STAGE_STATUS;
       } else {
         // prepare to receive more data from host
-        proc_write10_cmd(rhport, p_msc);
+        proc_write10_cmd(p_msc);
       }
     }
   }
diff --git a/src/class/msc/msc_device.h b/src/class/msc/msc_device.h
index 29acd280a..21e24971b 100644
--- a/src/class/msc/msc_device.h
+++ b/src/class/msc/msc_device.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_MSC_DEVICE_H_
-#define _TUSB_MSC_DEVICE_H_
+#ifndef TUSB_MSC_DEVICE_H_
+#define TUSB_MSC_DEVICE_H_
 
 #include "common/tusb_common.h"
 #include "msc.h"
@@ -48,6 +48,13 @@
   #error CFG_TUD_MSC_EP_BUFSIZE must be defined, value of a block size should work well, the more the better
 #endif
 
+// Return value of callback functions
+enum {
+  TUD_MSC_RET_BUSY = 0,   // Busy, e.g disk I/O is not ready
+  TUD_MSC_RET_ERROR = -1,
+  TUD_MSC_RET_ASYNC = -2, // Asynchronous IO
+};
+
 TU_VERIFY_STATIC(CFG_TUD_MSC_EP_BUFSIZE < UINT16_MAX, "Size is not correct");
 
 //--------------------------------------------------------------------+
@@ -57,44 +64,41 @@ TU_VERIFY_STATIC(CFG_TUD_MSC_EP_BUFSIZE < UINT16_MAX, "Size is not correct");
 // Set SCSI sense response
 bool tud_msc_set_sense(uint8_t lun, uint8_t sense_key, uint8_t add_sense_code, uint8_t add_sense_qualifier);
 
+// Called by Application once asynchronous I/O operation is done
+// bytes_io is number of bytes in I/O op, typically the bufsize in read/write_cb() or
+// TUD_MSC_RET_ERROR (-1) for error. Note TUD_MSC_RET_BUSY (0) will be treated as error as well.
+bool tud_msc_async_io_done(int32_t bytes_io, bool in_isr);
+
 //--------------------------------------------------------------------+
 // Application Callbacks (WEAK is optional)
 //--------------------------------------------------------------------+
 
-// Invoked when received SCSI READ10 command
-// - Address = lba * BLOCK_SIZE + offset
-//   - offset is only needed if CFG_TUD_MSC_EP_BUFSIZE is smaller than BLOCK_SIZE.
-//
-// - Application fill the buffer (up to bufsize) with address contents and return number of read byte. If
-//   - read < bufsize : These bytes are transferred first and callback invoked again for remaining data.
-//
-//   - read == 0      : Indicate application is not ready yet e.g disk I/O busy.
-//                      Callback invoked again with the same parameters later on.
-//
-//   - read < 0       : Indicate application error e.g invalid address. This request will be STALLed
-//                      and return failed status in command status wrapper phase.
+/*
+  Invoked when received SCSI READ10/WRITE10 command
+  - Address = lba * BLOCK_SIZE + offset
+    - offset is only needed if CFG_TUD_MSC_EP_BUFSIZE is smaller than BLOCK_SIZE.
+  - Application fill the buffer (up to bufsize) with address contents and return number of bytes read or status.
+    - 0 < ret < bufsize: These bytes are transferred first and callback will be invoked again for remaining data.
+    - TUD_MSC_RET_BUSY
+        Application is buys e.g disk I/O not ready. Callback will be invoked again with the same parameters later on.
+    - TUD_MSC_RET_ERROR
+        error such as invalid address. This request will be STALLed and scsi command will be failed
+    - TUD_MSC_RET_ASYNC
+        Data I/O will be done asynchronously in a background task. Application should return immediately.
+        tud_msc_async_io_done() must be called once IO/ is done to signal completion.
+*/
 int32_t tud_msc_read10_cb (uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);
-
-// Invoked when received SCSI WRITE10 command
-// - Address = lba * BLOCK_SIZE + offset
-//   - offset is only needed if CFG_TUD_MSC_EP_BUFSIZE is smaller than BLOCK_SIZE.
-//
-// - Application write data from buffer to address contents (up to bufsize) and return number of written byte. If
-//   - write < bufsize : callback invoked again with remaining data later on.
-//
-//   - write == 0      : Indicate application is not ready yet e.g disk I/O busy.
-//                       Callback invoked again with the same parameters later on.
-//
-//   - write < 0       : Indicate application error e.g invalid address. This request will be STALLed
-//                       and return failed status in command status wrapper phase.
-//
-// TODO change buffer to const uint8_t*
 int32_t tud_msc_write10_cb (uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);
 
-// Invoked when received SCSI_CMD_INQUIRY
+// Invoked when received SCSI_CMD_INQUIRY, v1, application should use v2 if possible
 // Application fill vendor id, product id and revision with string up to 8, 16, 4 characters respectively
 void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4]);
 
+// Invoked when received SCSI_CMD_INQUIRY, v2 with full inquiry response
+// Some inquiry_resp's fields are already filled with default values, application can update them
+// Return length of inquiry response, typically sizeof(scsi_inquiry_resp_t) (36 bytes), can be longer if included vendor data.
+uint32_t tud_msc_inquiry2_cb(uint8_t lun, scsi_inquiry_resp_t *inquiry_resp, uint32_t bufsize);
+
 // Invoked when received Test Unit Ready command.
 // return true allowing host to read/write this LUN e.g SD card inserted
 bool tud_msc_test_unit_ready_cb(uint8_t lun);
@@ -124,30 +128,30 @@ int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer,
 /*------------- Optional callbacks -------------*/
 
 // Invoked when received GET_MAX_LUN request, required for multiple LUNs implementation
-TU_ATTR_WEAK uint8_t tud_msc_get_maxlun_cb(void);
+uint8_t tud_msc_get_maxlun_cb(void);
 
 // Invoked when received Start Stop Unit command
 // - Start = 0 : stopped power mode, if load_eject = 1 : unload disk storage
 // - Start = 1 : active mode, if load_eject = 1 : load disk storage
-TU_ATTR_WEAK bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, bool load_eject);
+bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, bool load_eject);
 
 //Invoked when we receive the Prevent / Allow Medium Removal command
-TU_ATTR_WEAK bool tud_msc_prevent_allow_medium_removal_cb(uint8_t lun, uint8_t prohibit_removal, uint8_t control);
+bool tud_msc_prevent_allow_medium_removal_cb(uint8_t lun, uint8_t prohibit_removal, uint8_t control);
 
 // Invoked when received REQUEST_SENSE
-TU_ATTR_WEAK int32_t tud_msc_request_sense_cb(uint8_t lun, void* buffer, uint16_t bufsize);
+int32_t tud_msc_request_sense_cb(uint8_t lun, void* buffer, uint16_t bufsize);
 
 // Invoked when Read10 command is complete
-TU_ATTR_WEAK void tud_msc_read10_complete_cb(uint8_t lun);
+void tud_msc_read10_complete_cb(uint8_t lun);
 
 // Invoke when Write10 command is complete, can be used to flush flash caching
-TU_ATTR_WEAK void tud_msc_write10_complete_cb(uint8_t lun);
+void tud_msc_write10_complete_cb(uint8_t lun);
 
 // Invoked when command in tud_msc_scsi_cb is complete
-TU_ATTR_WEAK void tud_msc_scsi_complete_cb(uint8_t lun, uint8_t const scsi_cmd[16]);
+void tud_msc_scsi_complete_cb(uint8_t lun, uint8_t const scsi_cmd[16]);
 
 // Invoked to check if device is writable as part of SCSI WRITE10
-TU_ATTR_WEAK bool tud_msc_is_writable_cb(uint8_t lun);
+bool tud_msc_is_writable_cb(uint8_t lun);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
@@ -163,4 +167,4 @@ bool     mscd_xfer_cb         (uint8_t rhport, uint8_t ep_addr, xfer_result_t ev
  }
 #endif
 
-#endif /* _TUSB_MSC_DEVICE_H_ */
+#endif /* TUSB_MSC_DEVICE_H_ */
diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index ef0635bbe..daff345c5 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -88,6 +88,17 @@ TU_ATTR_ALWAYS_INLINE static inline msch_epbuf_t* get_epbuf(uint8_t daddr) {
 }
 
 //--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tuh_msc_mount_cb(uint8_t dev_addr) {
+  (void) dev_addr;
+}
+
+TU_ATTR_WEAK void tuh_msc_umount_cb(uint8_t dev_addr) {
+  (void) dev_addr;
+}
+
+//--------------------------------------------------------------------+
 // PUBLIC API
 //--------------------------------------------------------------------+
 uint8_t tuh_msc_get_maxlun(uint8_t dev_addr) {
@@ -112,7 +123,10 @@ bool tuh_msc_mounted(uint8_t dev_addr) {
 
 bool tuh_msc_ready(uint8_t dev_addr) {
   msch_interface_t* p_msc = get_itf(dev_addr);
-  return p_msc->mounted && !usbh_edpt_busy(dev_addr, p_msc->ep_in) && !usbh_edpt_busy(dev_addr, p_msc->ep_out);
+  TU_VERIFY(p_msc->mounted);
+  const bool epin_busy = usbh_edpt_busy(dev_addr, p_msc->ep_in);
+  const bool epout_busy = usbh_edpt_busy(dev_addr, p_msc->ep_out);
+  return !epin_busy && !epout_busy;
 }
 
 //--------------------------------------------------------------------+
@@ -141,7 +155,7 @@ bool tuh_msc_scsi_command(uint8_t daddr, msc_cbw_t const* cbw, void* data,
   p_msc->stage = MSC_STAGE_CMD;
 
   if (!usbh_edpt_xfer(daddr, p_msc->ep_out, (uint8_t*) &epbuf->cbw, sizeof(msc_cbw_t))) {
-    usbh_edpt_release(daddr, p_msc->ep_out);
+    (void) usbh_edpt_release(daddr, p_msc->ep_out);
     return false;
   }
 
@@ -180,7 +194,7 @@ bool tuh_msc_inquiry(uint8_t dev_addr, uint8_t lun, scsi_inquiry_resp_t* respons
       .cmd_code     = SCSI_CMD_INQUIRY,
       .alloc_length = sizeof(scsi_inquiry_resp_t)
   };
-  memcpy(cbw.command, &cmd_inquiry, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_inquiry, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg);
 }
@@ -214,7 +228,7 @@ bool tuh_msc_request_sense(uint8_t dev_addr, uint8_t lun, void* response,
       .cmd_code     = SCSI_CMD_REQUEST_SENSE,
       .alloc_length = 18
   };
-  memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_request_sense, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, response, complete_cb, arg);
 }
@@ -236,7 +250,7 @@ bool tuh_msc_read10(uint8_t dev_addr, uint8_t lun, void* buffer, uint32_t lba, u
       .lba         = tu_htonl(lba),
       .block_count = tu_htons(block_count)
   };
-  memcpy(cbw.command, &cmd_read10, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_read10, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, buffer, complete_cb, arg);
 }
@@ -258,7 +272,7 @@ bool tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const* buffer, uint32_t
       .lba         = tu_htonl(lba),
       .block_count = tu_htons(block_count)
   };
-  memcpy(cbw.command, &cmd_write10, cbw.cmd_len);
+  memcpy(cbw.command, &cmd_write10, cbw.cmd_len); //-V1086
 
   return tuh_msc_scsi_command(dev_addr, &cbw, (void*) (uintptr_t) buffer, complete_cb, arg);
 }
@@ -304,9 +318,7 @@ void msch_close(uint8_t dev_addr) {
 
   // invoke Application Callback
   if (p_msc->mounted) {
-    if (tuh_msc_umount_cb) {
-      tuh_msc_umount_cb(dev_addr);
-    }
+    tuh_msc_umount_cb(dev_addr);
   }
 
   tu_memclr(p_msc, sizeof(msch_interface_t));
@@ -329,8 +341,7 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
         TU_ASSERT(usbh_edpt_xfer(dev_addr, ep_data, p_msc->buffer, (uint16_t) cbw->total_bytes));
         break;
       }
-
-      TU_ATTR_FALLTHROUGH; // fallthrough to status stage
+      TU_ATTR_FALLTHROUGH; // fallthrough to data stage
 
     case MSC_STAGE_DATA:
       // Status stage
@@ -341,20 +352,19 @@ bool msch_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
     case MSC_STAGE_STATUS:
       // SCSI op is complete
       p_msc->stage = MSC_STAGE_IDLE;
-
-      if (p_msc->complete_cb) {
+      if (p_msc->complete_cb != NULL) {
         tuh_msc_complete_data_t const cb_data = {
             .cbw = cbw,
             .csw = csw,
             .scsi_data = p_msc->buffer,
             .user_arg = p_msc->complete_arg
         };
-        p_msc->complete_cb(dev_addr, &cb_data);
+        (void) p_msc->complete_cb(dev_addr, &cb_data);
       }
       break;
 
-      // unknown state
     default:
+      // unknown state
       break;
   }
 
@@ -492,14 +502,12 @@ static bool config_read_capacity_complete(uint8_t dev_addr, tuh_msc_complete_dat
 
   // Capacity response field: Block size and Last LBA are both Big-Endian
   scsi_read_capacity10_resp_t* resp = (scsi_read_capacity10_resp_t*) (uintptr_t) enum_buf;
-  p_msc->capacity[cbw->lun].block_count = tu_ntohl(resp->last_lba) + 1;
+  p_msc->capacity[cbw->lun].block_count = (uint32_t) (tu_ntohl(resp->last_lba) + 1u);
   p_msc->capacity[cbw->lun].block_size  = tu_ntohl(resp->block_size);
 
   // Mark enumeration is complete
   p_msc->mounted = true;
-  if (tuh_msc_mount_cb) {
-    tuh_msc_mount_cb(dev_addr);
-  }
+  tuh_msc_mount_cb(dev_addr);
 
   // notify usbh that driver enumeration is complete
   usbh_driver_set_config_complete(dev_addr, p_msc->itf_num);
diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index 09d777066..b5fd55547 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -109,10 +109,10 @@ bool tuh_msc_read_capacity(uint8_t dev_addr, uint8_t lun, scsi_read_capacity10_r
 //------------- Application Callback -------------//
 
 // Invoked when a device with MassStorage interface is mounted
-TU_ATTR_WEAK void tuh_msc_mount_cb(uint8_t dev_addr);
+void tuh_msc_mount_cb(uint8_t dev_addr);
 
 // Invoked when a device with MassStorage interface is unmounted
-TU_ATTR_WEAK void tuh_msc_umount_cb(uint8_t dev_addr);
+void tuh_msc_umount_cb(uint8_t dev_addr);
 
 //--------------------------------------------------------------------+
 // Internal Class Driver API
diff --git a/src/class/mtp/mtp.h b/src/class/mtp/mtp.h
new file mode 100644
index 000000000..236cf98e0
--- /dev/null
+++ b/src/class/mtp/mtp.h
@@ -0,0 +1,888 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ennebi Elettronica (https://ennebielettronica.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#ifndef TUSB_MTP_H_
+#define TUSB_MTP_H_
+
+#include "common/tusb_common.h"
+
+#if (CFG_TUD_ENABLED && CFG_TUD_MTP)
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+//--------------------------------------------------------------------+
+// Media Transfer Protocol Class Constant
+//--------------------------------------------------------------------+
+
+// Media Transfer Protocol Subclass
+typedef enum {
+  MTP_SUBCLASS_STILL_IMAGE = 1
+} mtp_subclass_type_t;
+
+// MTP Protocol.
+typedef enum {
+  MTP_PROTOCOL_PIMA_15470 = 1, ///< Picture Transfer Protocol (PIMA 15470)
+} mtp_protocol_type_t;
+
+// PTP/MTP protocol phases
+typedef enum {
+  MTP_PHASE_COMMAND = 0,
+  MTP_PHASE_DATA,
+  MTP_PHASE_RESPONSE,
+  MTP_PHASE_ERROR
+} mtp_phase_type_t;
+
+// PTP/MTP Class requests, PIMA 15740-2000: D.5.2
+typedef enum {
+  MTP_REQ_CANCEL             = 0x64,
+  MTP_REQ_GET_EXT_EVENT_DATA = 0x65,
+  MTP_REQ_RESET              = 0x66,
+  MTP_REQ_GET_DEVICE_STATUS  = 0x67,
+} mtp_class_request_t;
+
+// PTP/MTP Container type
+typedef enum {
+  MTP_CONTAINER_TYPE_UNDEFINED      = 0,
+  MTP_CONTAINER_TYPE_COMMAND_BLOCK  = 1,
+  MTP_CONTAINER_TYPE_DATA_BLOCK     = 2,
+  MTP_CONTAINER_TYPE_RESPONSE_BLOCK = 3,
+  MTP_CONTAINER_TYPE_EVENT_BLOCK    = 4,
+} mtp_container_type_t;
+
+// MTP 1.1 Appendix A: Object formats
+typedef enum {
+  // ---- Base formats ----
+  MTP_OBJ_FORMAT_UNDEFINED        = 0x3000u, // Undefined object
+  MTP_OBJ_FORMAT_ASSOCIATION      = 0x3001u, // Association (for example, a folder)
+  MTP_OBJ_FORMAT_SCRIPT           = 0x3002u, // Device model-specific script
+  MTP_OBJ_FORMAT_EXECUTABLE       = 0x3003u, // Device model-specific binary executable
+  MTP_OBJ_FORMAT_TEXT             = 0x3004u, // Text file
+  MTP_OBJ_FORMAT_HTML             = 0x3005u, // Hypertext Markup Language file (text)
+  MTP_OBJ_FORMAT_DPOF             = 0x3006u, // Digital Print Order Format file (text)
+  MTP_OBJ_FORMAT_AIFF             = 0x3007u, // Audio clip (AIFF)
+  MTP_OBJ_FORMAT_WAV              = 0x3008u, // Audio clip (WAV)
+  MTP_OBJ_FORMAT_MP3              = 0x3009u, // MPEG-1 Layer III audio (ISO/IEC 13818-3)
+  MTP_OBJ_FORMAT_AVI              = 0x300Au, // Video clip (AVI)
+  MTP_OBJ_FORMAT_MPEG             = 0x300Bu, // Video clip (MPEG)
+  MTP_OBJ_FORMAT_ASF              = 0x300Cu, // Microsoft Advanced Streaming Format (video)
+
+  // ---- Image formats ----
+  MTP_OBJ_FORMAT_UNDEFINED_IMAGE  = 0x3800u, // Undefined image object
+  MTP_OBJ_FORMAT_EXIF_JPEG        = 0x3801u, // Exchangeable Image Format, JEIDA standard
+  MTP_OBJ_FORMAT_TIFF_EP          = 0x3802u, // Tag Image File Format for Electronic Photography
+  MTP_OBJ_FORMAT_FLASHPIX         = 0x3803u, // Structured Storage Image Format (FlashPix)
+  MTP_OBJ_FORMAT_BMP              = 0x3804u, // Microsoft Windows Bitmap file
+  MTP_OBJ_FORMAT_CIFF             = 0x3805u, // Canon Camera Image File Format
+  MTP_OBJ_FORMAT_UNDEFINED_3806   = 0x3806u, // Reserved / Undefined
+  MTP_OBJ_FORMAT_GIF              = 0x3807u, // Graphics Interchange Format
+  MTP_OBJ_FORMAT_JFIF             = 0x3808u, // JPEG File Interchange Format
+  MTP_OBJ_FORMAT_CD               = 0x3809u, // PhotoCD Image Pac
+  MTP_OBJ_FORMAT_PICT             = 0x380Au, // Quickdraw Image Format
+  MTP_OBJ_FORMAT_PNG              = 0x380Bu, // Portable Network Graphics
+  MTP_OBJ_FORMAT_UNDEFINED_380C   = 0x380Cu, // Reserved / Undefined
+  MTP_OBJ_FORMAT_TIFF             = 0x380Du, // Tag Image File Format (baseline)
+  MTP_OBJ_FORMAT_TIFF_IT          = 0x380Eu, // Tag Image File Format for IT (graphic arts)
+  MTP_OBJ_FORMAT_JP2              = 0x380Fu, // JPEG2000 Baseline File Format
+  MTP_OBJ_FORMAT_JPX              = 0x3810u, // JPEG2000 Extended File Format
+
+  // ---- Firmware & misc ----
+  MTP_OBJ_FORMAT_UNDEFINED_FIRMWARE = 0xB802u, // Undefined Firmware
+  MTP_OBJ_FORMAT_WBMP               = 0xB803u, // Wireless Application Protocol Bitmap Format (.wbmp)
+  MTP_OBJ_FORMAT_WINDOWS_IMAGE      = 0xB881u, // Windows Image Format
+  MTP_OBJ_FORMAT_JPEGXR             = 0xB804u, // JPEG XR (.hdp, .jxr, .wdp)
+
+  // ---- Audio formats ----
+  MTP_OBJ_FORMAT_UNDEFINED_AUDIO  = 0xB900u, // Undefined audio object
+  MTP_OBJ_FORMAT_WMA              = 0xB901u, // Windows Media Audio
+  MTP_OBJ_FORMAT_OGG              = 0xB902u, // OGG container
+  MTP_OBJ_FORMAT_AAC              = 0xB903u, // Advanced Audio Coding (.aac)
+  MTP_OBJ_FORMAT_AUDIBLE          = 0xB904u, // Audible format
+  MTP_OBJ_FORMAT_FLAC             = 0xB906u, // Free Lossless Audio Codec
+  MTP_OBJ_FORMAT_QCELP            = 0xB907u, // Qualcomm Code Excited Linear Prediction (.qcp)
+  MTP_OBJ_FORMAT_AMR              = 0xB908u, // Adaptive Multi-Rate audio (.amr)
+
+  // ---- Video formats ----
+  MTP_OBJ_FORMAT_UNDEFINED_VIDEO  = 0xB980u, // Undefined video object
+  MTP_OBJ_FORMAT_WMV              = 0xB981u, // Windows Media Video
+  MTP_OBJ_FORMAT_MP4              = 0xB982u, // MP4 Container (ISO 14496-1)
+  MTP_OBJ_FORMAT_MP2              = 0xB983u, // MPEG-1 Layer II audio
+  MTP_OBJ_FORMAT_3GP              = 0xB984u, // 3GP Container
+  MTP_OBJ_FORMAT_3G2              = 0xB985u, // 3GPP2 Container
+  MTP_OBJ_FORMAT_AVCHD            = 0xB986u, // AVCHD (MPEG-4 AVC + Dolby Digital)
+  MTP_OBJ_FORMAT_ATSC_TS          = 0xB987u, // ATSC-compliant MPEG-2 Transport Stream
+  MTP_OBJ_FORMAT_DVB_TS           = 0xB988u, // DVB-compliant MPEG-2 Transport Stream
+
+  // ---- Collections ----
+  MTP_OBJ_FORMAT_UNDEFINED_COLLECTION          = 0xBA00u, // Undefined collection
+  MTP_OBJ_FORMAT_ABSTRACT_MULTIMEDIA_ALBUM     = 0xBA01u, // Abstract Multimedia Album
+  MTP_OBJ_FORMAT_ABSTRACT_IMAGE_ALBUM          = 0xBA02u, // Abstract Image Album
+  MTP_OBJ_FORMAT_ABSTRACT_AUDIO_ALBUM          = 0xBA03u, // Abstract Audio Album
+  MTP_OBJ_FORMAT_ABSTRACT_VIDEO_ALBUM          = 0xBA04u, // Abstract Video Album
+  MTP_OBJ_FORMAT_ABSTRACT_AV_PLAYLIST          = 0xBA05u, // Abstract Audio & Video Playlist
+  MTP_OBJ_FORMAT_ABSTRACT_CONTACT_GROUP        = 0xBA06u, // Abstract Contact Group
+  MTP_OBJ_FORMAT_ABSTRACT_MESSAGE_FOLDER       = 0xBA07u, // Abstract Message Folder
+  MTP_OBJ_FORMAT_ABSTRACT_CHAPTERED_PRODUCTION = 0xBA08u, // Abstract Chaptered Production
+  MTP_OBJ_FORMAT_ABSTRACT_AUDIO_PLAYLIST       = 0xBA09u, // Abstract Audio Playlist
+  MTP_OBJ_FORMAT_ABSTRACT_VIDEO_PLAYLIST       = 0xBA0Au, // Abstract Video Playlist
+  MTP_OBJ_FORMAT_ABSTRACT_MEDIACAST            = 0xBA0Bu, // Abstract Mediacast (RSS enclosure)
+
+  // ---- Playlist formats ----
+  MTP_OBJ_FORMAT_WPL_PLAYLIST     = 0xBA10u, // Windows Media Player Playlist (.wpl)
+  MTP_OBJ_FORMAT_M3U_PLAYLIST     = 0xBA11u, // M3U Playlist
+  MTP_OBJ_FORMAT_MPL_PLAYLIST     = 0xBA12u, // MPL Playlist
+  MTP_OBJ_FORMAT_ASX_PLAYLIST     = 0xBA13u, // ASX Playlist
+  MTP_OBJ_FORMAT_PLS_PLAYLIST     = 0xBA14u, // PLS Playlist
+
+  // ---- Document formats ----
+  MTP_OBJ_FORMAT_UNDEFINED_DOC    = 0xBA80u, // Undefined Document
+  MTP_OBJ_FORMAT_ABSTRACT_DOC     = 0xBA81u, // Abstract Document
+  MTP_OBJ_FORMAT_XML_DOC          = 0xBA82u, // XML Document
+  MTP_OBJ_FORMAT_DOC              = 0xBA83u, // Microsoft Word Document
+  MTP_OBJ_FORMAT_MHT_DOC          = 0xBA84u, // MHT Compiled HTML Document
+  MTP_OBJ_FORMAT_XLS              = 0xBA85u, // Microsoft Excel Spreadsheet
+  MTP_OBJ_FORMAT_PPT              = 0xBA86u, // Microsoft PowerPoint Presentation
+
+  // ---- Messaging ----
+  MTP_OBJ_FORMAT_UNDEFINED_MSG    = 0xBB00u, // Undefined Message
+  MTP_OBJ_FORMAT_ABSTRACT_MSG     = 0xBB01u, // Abstract Message
+
+  // ---- Bookmarks ----
+  MTP_OBJ_FORMAT_UNDEFINED_BOOKMARK = 0xBB10u, // Undefined Bookmark
+  MTP_OBJ_FORMAT_ABSTRACT_BOOKMARK  = 0xBB11u, // Abstract Bookmark
+
+  // ---- Appointments ----
+  MTP_OBJ_FORMAT_UNDEFINED_APPT   = 0xBB20u, // Undefined Appointment
+  MTP_OBJ_FORMAT_ABSTRACT_APPT    = 0xBB21u, // Abstract Appointment
+  MTP_OBJ_FORMAT_VCALENDAR1       = 0xBB22u, // vCalendar 1.0
+
+  // ---- Tasks ----
+  MTP_OBJ_FORMAT_UNDEFINED_TASK   = 0xBB40u, // Undefined Task
+  MTP_OBJ_FORMAT_ABSTRACT_TASK    = 0xBB41u, // Abstract Task
+  MTP_OBJ_FORMAT_ICALENDAR        = 0xBB42u, // iCalendar
+
+  // ---- Notes ----
+  MTP_OBJ_FORMAT_UNDEFINED_NOTE   = 0xBB60u, // Undefined Note
+  MTP_OBJ_FORMAT_ABSTRACT_NOTE    = 0xBB61u, // Abstract Note
+
+  // ---- Contacts ----
+  MTP_OBJ_FORMAT_UNDEFINED_CONTACT= 0xBB80u, // Undefined Contact
+  MTP_OBJ_FORMAT_ABSTRACT_CONTACT = 0xBB81u, // Abstract Contact
+  MTP_OBJ_FORMAT_VCARD2           = 0xBB82u, // vCard 2.1
+  MTP_OBJ_FORMAT_VCARD3           = 0xBB83u, // vCard 3.0
+} mtp_object_formats_t;
+
+// MTP 1.1 Appendix B: Object Properties
+typedef enum {
+  MTP_OBJ_PROP_STORAGE_ID                 = 0xDC01u, // StorageID
+  MTP_OBJ_PROP_OBJECT_FORMAT              = 0xDC02u, // Object Format
+  MTP_OBJ_PROP_PROTECTION_STATUS          = 0xDC03u, // Protection Status
+  MTP_OBJ_PROP_OBJECT_SIZE                = 0xDC04u, // Object Size
+  MTP_OBJ_PROP_ASSOCIATION_TYPE           = 0xDC05u, // Association Type
+  MTP_OBJ_PROP_ASSOCIATION_DESC           = 0xDC06u, // Association Description
+  MTP_OBJ_PROP_OBJECT_FILE_NAME           = 0xDC07u, // Object File Name
+  MTP_OBJ_PROP_DATE_CREATED               = 0xDC08u, // Date Created
+  MTP_OBJ_PROP_DATE_MODIFIED              = 0xDC09u, // Date Modified
+  MTP_OBJ_PROP_KEYWORDS                   = 0xDC0Au, // Keywords
+  MTP_OBJ_PROP_PARENT_OBJECT              = 0xDC0Bu, // Parent Object
+  MTP_OBJ_PROP_ALLOWED_FOLDER_CONTENTS    = 0xDC0Cu, // Allowed Folder Contents
+  MTP_OBJ_PROP_HIDDEN                     = 0xDC0Du, // Hidden
+  MTP_OBJ_PROP_SYSTEM_OBJECT              = 0xDC0Eu, // System Object
+  // 0xDC0F-0xDC40 is reserved
+
+  MTP_OBJ_PROP_PERSISTENT_UID             = 0xDC41u, // Persistent Unique Object Identifier
+  MTP_OBJ_PROP_SYNC_ID                    = 0xDC42u, // SyncID
+  MTP_OBJ_PROP_PROPERTY_BAG               = 0xDC43u, // Property Bag
+  MTP_OBJ_PROP_NAME                       = 0xDC44u, // Name
+  MTP_OBJ_PROP_CREATED_BY                 = 0xDC45u, // Created By
+  MTP_OBJ_PROP_ARTIST                     = 0xDC46u, // Artist
+  MTP_OBJ_PROP_DATE_AUTHORED              = 0xDC47u, // Date Authored
+  MTP_OBJ_PROP_DESCRIPTION                = 0xDC48u, // Description
+  MTP_OBJ_PROP_URL_REFERENCE              = 0xDC49u, // URL Reference
+  MTP_OBJ_PROP_LANGUAGE_LOCALE            = 0xDC4Au, // Language-Locale
+  MTP_OBJ_PROP_COPYRIGHT_INFO             = 0xDC4Bu, // Copyright Information
+  MTP_OBJ_PROP_SOURCE                     = 0xDC4Cu, // Source
+  MTP_OBJ_PROP_ORIGIN_LOCATION            = 0xDC4Du, // Origin Location
+  MTP_OBJ_PROP_DATE_ADDED                 = 0xDC4Eu, // Date Added
+  MTP_OBJ_PROP_NON_CONSUMABLE             = 0xDC4Fu, // Non-Consumable
+  MTP_OBJ_PROP_CORRUPT_UNPLAYABLE         = 0xDC50u, // Corrupt/Unplayable
+  MTP_OBJ_PROP_PRODUCER_SERIAL_NUMBER     = 0xDC51u, // ProducerSerialNumber
+  // 0xDC52-0xDC80 is reserved
+
+  MTP_OBJ_PROP_REP_SAMPLE_FORMAT          = 0xDC81u, // Representative Sample Format
+  MTP_OBJ_PROP_REP_SAMPLE_SIZE            = 0xDC82u, // Representative Sample Size
+  MTP_OBJ_PROP_REP_SAMPLE_HEIGHT          = 0xDC83u, // Representative Sample Height
+  MTP_OBJ_PROP_REP_SAMPLE_WIDTH           = 0xDC84u, // Representative Sample Width
+  MTP_OBJ_PROP_REP_SAMPLE_DURATION        = 0xDC85u, // Representative Sample Duration
+  MTP_OBJ_PROP_REP_SAMPLE_DATA            = 0xDC86u, // Representative Sample Data
+  MTP_OBJ_PROP_WIDTH                      = 0xDC87u, // Width
+  MTP_OBJ_PROP_HEIGHT                     = 0xDC88u, // Height
+  MTP_OBJ_PROP_DURATION                   = 0xDC89u, // Duration
+  MTP_OBJ_PROP_RATING                     = 0xDC8Au, // Rating
+  MTP_OBJ_PROP_TRACK                      = 0xDC8Bu, // Track
+  MTP_OBJ_PROP_GENRE                      = 0xDC8Cu, // Genre
+  MTP_OBJ_PROP_CREDITS                    = 0xDC8Du, // Credits
+  MTP_OBJ_PROP_LYRICS                     = 0xDC8Eu, // Lyrics
+  MTP_OBJ_PROP_SUBSCRIPTION_CONTENT_ID    = 0xDC8Fu, // Subscription Content ID
+  MTP_OBJ_PROP_PRODUCED_BY                = 0xDC90u, // Produced By
+  MTP_OBJ_PROP_USE_COUNT                  = 0xDC91u, // Use Count
+  MTP_OBJ_PROP_SKIP_COUNT                 = 0xDC92u, // Skip Count
+  MTP_OBJ_PROP_LAST_ACCESSED              = 0xDC93u, // Last Accessed
+  MTP_OBJ_PROP_PARENTAL_RATING            = 0xDC94u, // Parental Rating
+  MTP_OBJ_PROP_META_GENRE                 = 0xDC95u, // Meta Genre
+  MTP_OBJ_PROP_COMPOSER                   = 0xDC96u, // Composer
+  MTP_OBJ_PROP_EFFECTIVE_RATING           = 0xDC97u, // Effective Rating
+  MTP_OBJ_PROP_SUBTITLE                   = 0xDC98u, // Subtitle
+  MTP_OBJ_PROP_ORIGINAL_RELEASE_DATE      = 0xDC99u, // Original Release Date
+  MTP_OBJ_PROP_ALBUM_NAME                 = 0xDC9Au, // Album Name
+  MTP_OBJ_PROP_ALBUM_ARTIST               = 0xDC9Bu, // Album Artist
+  MTP_OBJ_PROP_MOOD                       = 0xDC9Cu, // Mood
+  MTP_OBJ_PROP_DRM_STATUS                 = 0xDC9Du, // DRM Status
+  MTP_OBJ_PROP_SUB_DESCRIPTION            = 0xDC9Eu, // Sub Description
+  // 0xDC9F-0xDCD0 is reserved
+
+  MTP_OBJ_PROP_IS_CROPPED                 = 0xDCD1u, // Is Cropped
+  MTP_OBJ_PROP_IS_COLOUR_CORRECTED        = 0xDCD2u, // Is Colour Corrected
+  MTP_OBJ_PROP_IMAGE_BIT_DEPTH            = 0xDCD3u, // Image Bit Depth
+  MTP_OBJ_PROP_FNUMBER                    = 0xDCD4u, // Fnumber (aperture ×100)
+  MTP_OBJ_PROP_EXPOSURE_TIME              = 0xDCD5u, // Exposure Time (sec ×10,000)
+  MTP_OBJ_PROP_EXPOSURE_INDEX             = 0xDCD6u, // Exposure Index (ISO)
+  // 0xDCD7-0xDCDF is reserved
+
+  MTP_OBJ_PROP_DISPLAY_NAME               = 0xDCE0u, // Display Name
+  MTP_OBJ_PROP_BODY_TEXT                  = 0xDCE1u, // Body Text
+  MTP_OBJ_PROP_SUBJECT                    = 0xDCE2u, // Subject
+  MTP_OBJ_PROP_PRIORITY                   = 0xDCE3u, // Priority
+  // 0xDCE4-0xDCFF is reserved
+
+  MTP_OBJ_PROP_GIVEN_NAME                 = 0xDD00u, // Given Name
+  MTP_OBJ_PROP_MIDDLE_NAMES               = 0xDD01u, // Middle Names
+  MTP_OBJ_PROP_FAMILY_NAME                = 0xDD02u, // Family Name
+  MTP_OBJ_PROP_PREFIX                     = 0xDD03u, // Prefix
+  MTP_OBJ_PROP_SUFFIX                     = 0xDD04u, // Suffix
+  MTP_OBJ_PROP_PHONETIC_GIVEN_NAME        = 0xDD05u, // Phonetic Given Name
+  MTP_OBJ_PROP_PHONETIC_FAMILY_NAME       = 0xDD06u, // Phonetic Family Name
+  MTP_OBJ_PROP_EMAIL_PRIMARY              = 0xDD07u, // Email Primary
+  MTP_OBJ_PROP_EMAIL_PERSONAL_1           = 0xDD08u, // Email Personal 1
+  MTP_OBJ_PROP_EMAIL_PERSONAL_2           = 0xDD09u, // Email Personal 2
+  MTP_OBJ_PROP_EMAIL_BUSINESS_1           = 0xDD0Au, // Email Business 1
+  MTP_OBJ_PROP_EMAIL_BUSINESS_2           = 0xDD0Bu, // Email Business 2
+  MTP_OBJ_PROP_EMAIL_OTHERS               = 0xDD0Cu, // Email Others
+  MTP_OBJ_PROP_PHONE_PRIMARY              = 0xDD0Du, // Phone Number Primary
+  MTP_OBJ_PROP_PHONE_PERSONAL_1           = 0xDD0Eu, // Phone Number Personal
+  MTP_OBJ_PROP_PHONE_PERSONAL_2           = 0xDD0Fu, // Phone Number Personal 2
+  MTP_OBJ_PROP_PHONE_BUSINESS_1           = 0xDD10u, // Phone Number Business
+  MTP_OBJ_PROP_PHONE_BUSINESS_2           = 0xDD11u, // Phone Number Business 2
+  MTP_OBJ_PROP_PHONE_MOBILE_1             = 0xDD12u, // Phone Number Mobile
+  MTP_OBJ_PROP_PHONE_MOBILE_2             = 0xDD13u, // Phone Number Mobile 2
+  MTP_OBJ_PROP_FAX_PRIMARY                = 0xDD14u, // Fax Number Primary
+  MTP_OBJ_PROP_FAX_PERSONAL               = 0xDD15u, // Fax Number Personal
+  MTP_OBJ_PROP_FAX_BUSINESS               = 0xDD16u, // Fax Number Business
+  MTP_OBJ_PROP_PAGER_NUMBER               = 0xDD17u, // Pager Number
+  MTP_OBJ_PROP_PHONE_OTHERS               = 0xDD18u, // Phone Number Others
+  MTP_OBJ_PROP_WEB_PRIMARY                = 0xDD19u, // Primary Web Address
+  MTP_OBJ_PROP_WEB_PERSONAL               = 0xDD1Au, // Personal Web Address
+  MTP_OBJ_PROP_WEB_BUSINESS               = 0xDD1Bu, // Business Web Address
+  MTP_OBJ_PROP_IM_ADDRESS_1               = 0xDD1Cu, // Instant Messenger Address
+  MTP_OBJ_PROP_IM_ADDRESS_2               = 0xDD1Du, // Instant Messenger Address 2
+  MTP_OBJ_PROP_IM_ADDRESS_3               = 0xDD1Eu, // Instant Messenger Address 3
+  MTP_OBJ_PROP_ADDR_PERSONAL_FULL         = 0xDD1Fu, // Postal Address Personal Full
+  MTP_OBJ_PROP_ADDR_PERSONAL_LINE1        = 0xDD20u, // Postal Address Personal Line 1
+  MTP_OBJ_PROP_ADDR_PERSONAL_LINE2        = 0xDD21u, // Postal Address Personal Line 2
+  MTP_OBJ_PROP_ADDR_PERSONAL_CITY         = 0xDD22u, // Postal Address Personal City
+  MTP_OBJ_PROP_ADDR_PERSONAL_REGION       = 0xDD23u, // Postal Address Personal Region
+  MTP_OBJ_PROP_ADDR_PERSONAL_POSTAL_CODE  = 0xDD24u, // Postal Address Personal Postal Code
+  MTP_OBJ_PROP_ADDR_PERSONAL_COUNTRY      = 0xDD25u, // Postal Address Personal Country
+  MTP_OBJ_PROP_ADDR_BUSINESS_FULL         = 0xDD26u, // Postal Address Business Full
+  MTP_OBJ_PROP_ADDR_BUSINESS_LINE1        = 0xDD27u, // Postal Address Business Line 1
+  MTP_OBJ_PROP_ADDR_BUSINESS_LINE2        = 0xDD28u, // Postal Address Business Line 2
+  MTP_OBJ_PROP_ADDR_BUSINESS_CITY         = 0xDD29u, // Postal Address Business City
+  MTP_OBJ_PROP_ADDR_BUSINESS_REGION       = 0xDD2Au, // Postal Address Business Region
+  MTP_OBJ_PROP_ADDR_BUSINESS_POSTAL_CODE  = 0xDD2Bu, // Postal Address Business Postal Code
+  MTP_OBJ_PROP_ADDR_BUSINESS_COUNTRY      = 0xDD2Cu, // Postal Address Business Country
+  MTP_OBJ_PROP_ADDR_OTHER_FULL            = 0xDD2Du, // Postal Address Other Full
+  MTP_OBJ_PROP_ADDR_OTHER_LINE1           = 0xDD2Eu, // Postal Address Other Line 1
+  MTP_OBJ_PROP_ADDR_OTHER_LINE2           = 0xDD2Fu, // Postal Address Other Line 2
+  MTP_OBJ_PROP_ADDR_OTHER_CITY            = 0xDD30u, // Postal Address Other City
+  MTP_OBJ_PROP_ADDR_OTHER_REGION          = 0xDD31u, // Postal Address Other Region
+  MTP_OBJ_PROP_ADDR_OTHER_POSTAL_CODE     = 0xDD32u, // Postal Address Other Postal Code
+  MTP_OBJ_PROP_ADDR_OTHER_COUNTRY         = 0xDD33u, // Postal Address Other Country
+  MTP_OBJ_PROP_ORGANIZATION_NAME          = 0xDD34u, // Organization Name
+  MTP_OBJ_PROP_PHONETIC_ORG_NAME          = 0xDD35u, // Phonetic Organization Name
+  MTP_OBJ_PROP_ROLE                       = 0xDD36u, // Role
+  MTP_OBJ_PROP_BIRTHDATE                  = 0xDD37u, // Birthdate
+  // 0xDD38-0xDD3F is reserved
+
+  MTP_OBJ_PROP_MESSAGE_TO                 = 0xDD40u, // Message To
+  MTP_OBJ_PROP_MESSAGE_CC                 = 0xDD41u, // Message CC
+  MTP_OBJ_PROP_MESSAGE_BCC                = 0xDD42u, // Message BCC
+  MTP_OBJ_PROP_MESSAGE_READ               = 0xDD43u, // Message Read
+  MTP_OBJ_PROP_MESSAGE_RECEIVED_TIME      = 0xDD44u, // Message Received Time
+  MTP_OBJ_PROP_MESSAGE_SENDER             = 0xDD45u, // Message Sender
+  // 0xDD46-0xDD4F is reserved
+
+  MTP_OBJ_PROP_ACTIVITY_BEGIN_TIME        = 0xDD50u, // Activity Begin Time
+  MTP_OBJ_PROP_ACTIVITY_END_TIME          = 0xDD51u, // Activity End Time
+  MTP_OBJ_PROP_ACTIVITY_LOCATION          = 0xDD52u, // Activity Location
+  // 0xDD53 is reserved
+  MTP_OBJ_PROP_ACTIVITY_REQUIRED_ATTENDEES= 0xDD54u, // Activity Required Attendees
+  MTP_OBJ_PROP_ACTIVITY_OPTIONAL_ATTENDEES= 0xDD55u, // Activity Optional Attendees
+  MTP_OBJ_PROP_ACTIVITY_RESOURCES         = 0xDD56u, // Activity Resources
+  MTP_OBJ_PROP_ACTIVITY_ACCEPTED          = 0xDD57u, // Activity Accepted
+  MTP_OBJ_PROP_ACTIVITY_TENTATIVE         = 0xDD58u, // Activity Tentative
+  MTP_OBJ_PROP_ACTIVITY_DECLINED          = 0xDD59u, // Activity Declined
+  MTP_OBJ_PROP_ACTIVITY_REMINDER_TIME     = 0xDD5Au, // Activity Reminder Time
+  MTP_OBJ_PROP_ACTIVITY_OWNER             = 0xDD5Bu, // Activity Owner
+  MTP_OBJ_PROP_ACTIVITY_STATUS            = 0xDD5Cu, // Activity Status
+  MTP_OBJ_PROP_OWNER                      = 0xDD5Du, // Owner
+  MTP_OBJ_PROP_EDITOR                     = 0xDD5Eu, // Editor
+  MTP_OBJ_PROP_WEBMASTER                  = 0xDD5Fu, // Webmaster
+
+  MTP_OBJ_PROP_URL_SOURCE                 = 0xDD60u, // URL Source
+  MTP_OBJ_PROP_URL_DESTINATION            = 0xDD61u, // URL Destination
+  MTP_OBJ_PROP_TIME_BOOKMARK              = 0xDD62u, // Time Bookmark
+  MTP_OBJ_PROP_OBJECT_BOOKMARK            = 0xDD63u, // Object Bookmark
+  MTP_OBJ_PROP_BYTE_BOOKMARK              = 0xDD64u, // Byte Bookmark
+  // 0xDD65-0xDD6F is reserved
+
+  MTP_OBJ_PROP_LAST_BUILD_DATE            = 0xDD70u, // Last Build Date
+  MTP_OBJ_PROP_TIME_TO_LIVE               = 0xDD71u, // Time to Live (minutes)
+  MTP_OBJ_PROP_MEDIA_GUID                 = 0xDD72u, // Media GUID
+  // 0xDD73-0xDDFF is reserved
+
+  // media encoding
+  MTP_OBJ_PROP_TOTAL_BITRATE              = 0xDE91u, // Total BitRate
+  MTP_OBJ_PROP_BITRATE_TYPE               = 0xDE92u, // Bitrate Type
+  MTP_OBJ_PROP_SAMPLE_RATE                = 0xDE93u, // Sample Rate
+  MTP_OBJ_PROP_NUM_CHANNELS               = 0xDE94u, // Number Of Channels
+  MTP_OBJ_PROP_AUDIO_BITDEPTH             = 0xDE95u, // Audio BitDepth
+  // 0xDE96 is reserved
+  MTP_OBJ_PROP_SCAN_TYPE                  = 0xDE97u, // Scan Type
+  // 0xDE98 is reserved
+  MTP_OBJ_PROP_AUDIO_WAVE_CODEC           = 0xDE99u, // Audio WAVE Codec
+  MTP_OBJ_PROP_AUDIO_BITRATE              = 0xDE9Au, // Audio BitRate
+  MTP_OBJ_PROP_VIDEO_FOURCC_CODEC         = 0xDE9Bu, // Video FourCC Codec
+  MTP_OBJ_PROP_VIDEO_BITRATE              = 0xDE9Cu, // Video BitRate
+  MTP_OBJ_PROP_FRAMES_PER_KSEC            = 0xDE9Du, // Frames Per Thousand Seconds
+  MTP_OBJ_PROP_KEYFRAME_DISTANCE          = 0xDE9Eu, // KeyFrame Distance (ms)
+  MTP_OBJ_PROP_BUFFER_SIZE                = 0xDE9Fu, // Buffer Size
+  MTP_OBJ_PROP_ENCODING_QUALITY           = 0xDEA0u, // Encoding Quality
+  MTP_OBJ_PROP_ENCODING_PROFILE           = 0xDEA1u  // Encoding Profile
+} mtp_object_properties_t;
+
+
+// MTP 1.1 Appendeix C: Device Properties
+typedef enum {
+  MTP_DEV_PROP_UNDEFINED                      = 0x5000u,
+  MTP_DEV_PROP_BATTERY_LEVEL                  = 0x5001u,
+  MTP_DEV_PROP_FUNCTIONAL_MODE                = 0x5002u,
+  MTP_DEV_PROP_IMAGE_SIZE                     = 0x5003u,
+  MTP_DEV_PROP_COMPRESSION_SETTING            = 0x5004u,
+  MTP_DEV_PROP_WHITE_BALANCE                  = 0x5005u,
+  MTP_DEV_PROP_RGB_GAIN                       = 0x5006u,
+  MTP_DEV_PROP_F_NUMBER                       = 0x5007u,
+  MTP_DEV_PROP_FOCAL_LENGTH                   = 0x5008u,
+  MTP_DEV_PROP_FOCUS_DISTANCE                 = 0x5009u,
+  MTP_DEV_PROP_FOCUS_MODE                     = 0x500Au,
+  MTP_DEV_PROP_EXPOSURE_METERING_MODE         = 0x500Bu,
+  MTP_DEV_PROP_FLASH_MODE                     = 0x500Cu,
+  MTP_DEV_PROP_EXPOSURE_TIME                  = 0x500Du,
+  MTP_DEV_PROP_EXPOSURE_PROGRAM_MODE          = 0x500Eu,
+  MTP_DEV_PROP_EXPOSURE_INDEX                 = 0x500Fu,
+  MTP_DEV_PROP_EXPOSURE_BIAS_COMPENSATION     = 0x5010u,
+  MTP_DEV_PROP_DATE_TIME                      = 0x5011u,
+  MTP_DEV_PROP_CAPTURE_DELAY                  = 0x5012u,
+  MTP_DEV_PROP_STILL_CAPTURE_MODE             = 0x5013u,
+  MTP_DEV_PROP_CONTRAST                       = 0x5014u,
+  MTP_DEV_PROP_SHARPNESS                      = 0x5015u,
+  MTP_DEV_PROP_DIGITAL_ZOOM                   = 0x5016u,
+  MTP_DEV_PROP_EFFECT_MODE                    = 0x5017u,
+  MTP_DEV_PROP_BURST_NUMBER                   = 0x5018u,
+  MTP_DEV_PROP_BURST_INTERVAL                 = 0x5019u,
+  MTP_DEV_PROP_TIMELAPSE_NUMBER               = 0x501Au,
+  MTP_DEV_PROP_TIMELAPSE_INTERVAL             = 0x501Bu,
+  MTP_DEV_PROP_FOCUS_METERING_MODE            = 0x501Cu,
+  MTP_DEV_PROP_UPLOAD_URL                     = 0x501Du,
+  MTP_DEV_PROP_ARTIST                         = 0x501Eu,
+  MTP_DEV_PROP_COPYRIGHT_INFO                 = 0x501Fu,
+  MTP_DEV_PROP_SYNCHRONIZTION_PARTNER         = 0xD401,
+  MTP_DEV_PROP_DEVICE_FRIENDLY_NAME           = 0xD402u,
+  MTP_DEV_PROP_VOLUME                         = 0xD403u,
+  MTP_DEV_PROP_SUPPORTED_FORMATS_ORDERED      = 0xD404u,
+  MTP_DEV_PROP_DEVICE_ICON                    = 0xD405u,
+  MTP_DEV_PROP_SECTION_INITIATOR_VERSION_INFO = 0xD406u,
+  MTP_DEV_PROP_PERCEIVED_DEVICE_TYPE          = 0xD407u,
+  MTP_DEV_PROP_PLAYBACK_RATE                  = 0xD410u,
+  MTP_DEV_PROP_PLAYBACK_OBJECT                = 0xD411u,
+  MTP_DEV_PROP_PLAYBACK_CONTAINER_INDEX       = 0xD412u,
+} mtp_event_properties_t;
+
+// MTP 1.1 Appendix D: Operations
+typedef enum {
+  MTP_OP_UNDEFINED                  = 0x1000u,
+  MTP_OP_GET_DEVICE_INFO            = 0x1001u,
+  MTP_OP_OPEN_SESSION               = 0x1002u,
+  MTP_OP_CLOSE_SESSION              = 0x1003u,
+  MTP_OP_GET_STORAGE_IDS            = 0x1004u,
+  MTP_OP_GET_STORAGE_INFO           = 0x1005u,
+  MTP_OP_GET_NUM_OBJECTS            = 0x1006u,
+  MTP_OP_GET_OBJECT_HANDLES         = 0x1007u,
+  MTP_OP_GET_OBJECT_INFO            = 0x1008u,
+  MTP_OP_GET_OBJECT                 = 0x1009u,
+  MTP_OP_GET_THUMB                  = 0x100Au,
+  MTP_OP_DELETE_OBJECT              = 0x100Bu,
+  MTP_OP_SEND_OBJECT_INFO           = 0x100Cu,
+  MTP_OP_SEND_OBJECT                = 0x100Du,
+  MTP_OP_INITIATE_CAPTURE           = 0x100Eu,
+  MTP_OP_FORMAT_STORE               = 0x100Fu,
+  MTP_OP_RESET_DEVICE               = 0x1010u,
+  MTP_OP_SELF_TEST                  = 0x1011u,
+  MTP_OP_SET_OBJECT_PROTECTION      = 0x1012u,
+  MTP_OP_POWER_DOWN                 = 0x1013u,
+  MTP_OP_GET_DEVICE_PROP_DESC       = 0x1014u,
+  MTP_OP_GET_DEVICE_PROP_VALUE      = 0x1015u,
+  MTP_OP_SET_DEVICE_PROP_VALUE      = 0x1016u,
+  MTP_OP_RESET_DEVICE_PROP_VALUE    = 0x1017u,
+  MTP_OP_TERMINATE_OPEN_CAPTURE     = 0x1018u,
+  MTP_OP_MOVE_OBJECT                = 0x1019u,
+  MTP_OP_COPY_OBJECT                = 0x101Au,
+  MTP_OP_GET_PARTIAL_OBJECT         = 0x101Bu,
+  MTP_OP_INITIATE_OPEN_CAPTURE      = 0x101Bu,
+  MTP_OP_GET_OBJECT_PROPS_SUPPORTED = 0x9801u,
+  MTP_OP_GET_OBJECT_PROP_DESC       = 0x9802u,
+  MTP_OP_GET_OBJECT_PROP_VALUE      = 0x9803u,
+  MTP_OP_SET_OBJECT_PROP_VALUE      = 0x9804u,
+  MTP_OP_GET_OBJECT_PROPLIST        = 0x9805u,
+  MTP_OP_GET_OBJECT_PROP_REFERENCES = 0x9810u,
+
+  MTP_OP_GET_SERVICE_IDS            = 0x9301u,
+  MTP_OP_GET_SERVICE_INFO           = 0x9302u,
+  MTP_OP_GET_SERVICE_CAPABILITIES   = 0x9303u,
+  MTP_OP_GET_SERVICE_PROP_DESC      = 0x9304u,
+
+  // Appendix E: Enhanced Operations
+  MTP_OP_GET_OBJECT_PROP_LIST         = 0x9805u,
+  MTP_OP_SET_OBJECT_PROP_LIST         = 0x9806u,
+  MTP_OP_GET_INTERDEPENDENT_PROP_DESC = 0x9807u,
+  MTP_OP_SEND_OBJECT_PROP_LIST        = 0x9808u,
+} mtp_operation_code_t;
+
+// Appendix F: Responses
+typedef enum {
+  MTP_RESP_UNDEFINED                           = 0x2000u,
+  MTP_RESP_OK                                  = 0x2001u,
+  MTP_RESP_GENERAL_ERROR                       = 0x2002u,
+  MTP_RESP_SESSION_NOT_OPEN                    = 0x2003u,
+  MTP_RESP_INVALID_TRANSACTION_ID              = 0x2004u,
+  MTP_RESP_OPERATION_NOT_SUPPORTED             = 0x2005u,
+  MTP_RESP_PARAMETER_NOT_SUPPORTED             = 0x2006u,
+  MTP_RESP_INCOMPLETE_TRANSFER                 = 0x2007u,
+  MTP_RESP_INVALID_STORAGE_ID                  = 0x2008u,
+  MTP_RESP_INVALID_OBJECT_HANDLE               = 0x2009u,
+  MTP_RESP_DEVICE_PROP_NOT_SUPPORTED           = 0x200Au,
+  MTP_RESP_INVALID_OBJECT_FORMAT_CODE          = 0x200Bu,
+  MTP_RESP_STORE_FULL                          = 0x200Cu,
+  MTP_RESP_OBJECT_WRITE_PROTECTED              = 0x200Du,
+  MPT_RESC_STORE_READ_ONLY                     = 0x200Eu,
+  MTP_RESP_ACCESS_DENIED                       = 0x200Fu,
+  MTP_RESP_NO_THUMBNAIL_PRESENT                = 0x2010u,
+  MTP_RESP_SELF_TEST_FAILED                    = 0x2011u,
+  MTP_RESP_PARTIAL_DELETION                    = 0x2012u,
+  MTP_RESP_STORE_NOT_AVAILABLE                 = 0x2013u,
+  MTP_RESP_SPECIFICATION_BY_FORMAT_UNSUPPORTED = 0x2014u,
+  MTP_RESP_NO_VALID_OBJECTINFO                 = 0x2015u,
+  MTP_RESP_INVALID_CODE_FORMAT                 = 0x2016u,
+  MTP_RESP_UNKNOWN_VENDOR_CODE                 = 0x2017u,
+  MTP_RESP_CAPTURE_ALREADY_TERMINATED          = 0x2018u,
+  MTP_RESP_DEVICE_BUSY                         = 0x2019u,
+  MTP_RESP_INVALID_PARENT_OBJECT               = 0x201Au,
+  MTP_RESP_INVALID_DEVICE_PROP_FORMAT          = 0x201Bu,
+  MTP_RESP_INVALID_DEVICE_PROP_VALUE           = 0x201Cu,
+  MTP_RESP_INVALID_PARAMETER                   = 0x201Du,
+  MTP_RESP_SESSION_ALREADY_OPEN                = 0x201Eu,
+  MTP_RESP_TRANSACTION_CANCELLED               = 0x201Fu,
+  MTP_RESP_SPEC_OF_DESTINATION_UNSUPPORTED     = 0x2020u,
+
+  MTP_RESP_INVALID_OBJECT_PROP_CODE            = 0xA801u,
+  MTP_RESP_INVALID_OBJECT_PROP_FORMAT          = 0xA802u,
+  MTP_RESP_INVALID_OBJECT_PROP_VALUE           = 0xA803u,
+  MTP_RESP_INVALID_OBJECT_REFERENCE            = 0xA804u,
+  MTP_RESP_GROUP_NOT_SUPPORTED                 = 0xA805u,
+  MTP_RESP_INVALID_DATASET                     = 0xA806u,
+  MTP_RESP_SPEC_BY_GROUP_UNSUPPORTED           = 0xA807u,
+  MTP_RESP_SPEC_BY_DEPTH_UNSUPPORTED           = 0xA808u,
+  MTP_RESP_OBJECT_TOO_LARGE                    = 0xA809u,
+  MTP_RESP_OBJECT_PROP_NOT_SUPPORTED           = 0xA80Au,
+} mtp_response_t;
+
+// Appendix G: Events
+typedef enum {
+  MTP_EVENT_UNDEFINED                 = 0x4000,
+  MTP_EVENT_CANCEL_TRANSACTION        = 0x4001,
+  MTP_EVENT_OBJECT_ADDED              = 0x4002,
+  MTP_EVENT_OBJECT_REMOVED            = 0x4003,
+  MTP_EVENT_STORE_ADDED               = 0x4004,
+  MTP_EVENT_STORE_REMOVED             = 0x4005,
+  MTP_EVENT_DEVICE_PROP_CHANGED       = 0x4006,
+  MTP_EVENT_OBJECT_INFO_CHANGED       = 0x4007,
+  MTP_EVENT_DEVICE_INFO_CHANGED       = 0x4008,
+  MTP_EVENT_REQUEST_OBJECT_TRANSFER   = 0x4009,
+  MTP_EVENT_STORE_FULL                = 0x400Au,
+  MTP_EVENT_DEVICE_RESET              = 0x400Bu,
+  MTP_EVENT_STORAGE_INFO_CHANGED      = 0x400Cu,
+  MTP_EVENT_CAPTURE_COMPLETE          = 0x400Du,
+  MTP_EVENT_UNREPORTED_STATUS         = 0x400Eu,
+  MTP_EVENT_OBJECT_PROP_CHANGED       = 0xC801u,
+  MTP_EVENT_OBJECT_PROP_DESC_CHANGED  = 0xC802u,
+  MTP_EVENT_OBJECT_REFERENCES_CHANGED = 0xC803u,
+} mtp_event_code_t;
+
+// Datatypes
+typedef enum {
+  MTP_DATA_TYPE_UNDEFINED = 0x0000u,
+  // scalars
+  MTP_DATA_TYPE_INT8      = 0x0001u,
+  MTP_DATA_TYPE_UINT8     = 0x0002u,
+  MTP_DATA_TYPE_INT16     = 0x0003u,
+  MTP_DATA_TYPE_UINT16    = 0x0004u,
+  MTP_DATA_TYPE_INT32     = 0x0005u,
+  MTP_DATA_TYPE_UINT32    = 0x0006u,
+  MTP_DATA_TYPE_INT64     = 0x0007u,
+  MTP_DATA_TYPE_UINT64    = 0x0008u,
+  MTP_DATA_TYPE_INT128    = 0x0009u,
+  MTP_DATA_TYPE_UINT128   = 0x000Au,
+  // array
+  MTP_DATA_TYPE_AINT8     = 0x4001u,
+  MTP_DATA_TYPE_AUINT8    = 0x4002u,
+  MTP_DATA_TYPE_AINT16    = 0x4003u,
+  MTP_DATA_TYPE_AUINT16   = 0x4004u,
+  MTP_DATA_TYPE_AINT32    = 0x4005u,
+  MTP_DATA_TYPE_AUINT32   = 0x4006u,
+  MTP_DATA_TYPE_AINT64    = 0x4007u,
+  MTP_DATA_TYPE_AUINT64   = 0x4008u,
+  MTP_DATA_TYPE_AINT128   = 0x4009u,
+  MTP_DATA_TYPE_AUINT128  = 0x400Au,
+  MTP_DATA_TYPE_STR       = 0xFFFFu,
+} mtp_data_type_t;
+
+// Get/Set
+typedef enum {
+  MTP_MODE_GET     = 0x00u,
+  MTP_MODE_GET_SET = 0x01u,
+} mtp_mode_get_set_t;
+
+typedef enum {
+  MTP_STORAGE_TYPE_UNDEFINED     = 0x0000u,
+  MTP_STORAGE_TYPE_FIXED_ROM     = 0x0001u,
+  MTP_STORAGE_TYPE_REMOVABLE_ROM = 0x0002u,
+  MTP_STORAGE_TYPE_FIXED_RAM     = 0x0003u,
+  MTP_STORAGE_TYPE_REMOVABLE_RAM = 0x0004u,
+} mtp_storage_type_t;
+
+typedef enum {
+  MTP_FILESYSTEM_TYPE_UNDEFINED            = 0x0000u,
+  MTP_FILESYSTEM_TYPE_GENERIC_FLAT         = 0x0001u,
+  MTP_FILESYSTEM_TYPE_GENERIC_HIERARCHICAL = 0x0002u,
+  MTP_FILESYSTEM_TYPE_DCF                  = 0x0003u,
+} mtp_filesystem_type_t;
+
+typedef enum {
+  MTP_ACCESS_CAPABILITY_READ_WRITE                        = 0x0000u,
+  MTP_ACCESS_CAPABILITY_READ_ONLY_WITHOUT_OBJECT_DELETION = 0x0001u,
+  MTP_ACCESS_CAPABILITY_READ_ONLY_WITH_OBJECT_DELETION    = 0x0002u,
+} mtp_access_capability_t;
+
+typedef enum {
+  MTP_PROTECTION_STATUS_NO_PROTECTION  = 0x0000u,
+  MTP_PROTECTION_STATUS_READ_ONLY      = 0x0001u,
+  MTP_PROTECTION_STATUS_READ_ONLY_DATA = 0x8002u,
+  MTP_PROTECTION_NON_TRANSFERABLE_DATA = 0x8003u,
+} mtp_protection_status_t;
+
+typedef enum {
+  MTP_ASSOCIATION_UNDEFINED            = 0x0000u,
+  MTP_ASSOCIATION_GENERIC_FOLDER       = 0x0001u,
+  MTP_ASSOCIATION_ALBUM                = 0x0002u,
+  MTP_ASSOCIATION_TIME_SEQUENCE        = 0x0003u,
+  MTP_ASSOCIATION_HORIZONTAL_PANORAMIC = 0x0004u,
+  MTP_ASSOCIATION_VERTICAL_PANORAMIC   = 0x0005u,
+  MTP_ASSOCIATION_2D_PANORAMIC         = 0x0006u,
+  MTP_ASSOCIATION_ANCILLARY_DATA       = 0x0007u,
+} mtp_association_t;
+
+//--------------------------------------------------------------------+
+// Data structures
+//--------------------------------------------------------------------+
+typedef struct TU_ATTR_PACKED {
+  uint32_t len;
+  uint16_t type;
+  uint16_t code;
+  uint32_t transaction_id;
+} mtp_container_header_t;
+TU_VERIFY_STATIC(sizeof(mtp_container_header_t) == 12, "size is not correct");
+
+typedef struct TU_ATTR_PACKED {
+  mtp_container_header_t header;
+  uint32_t params[5];
+} mtp_container_command_t;
+TU_VERIFY_STATIC(sizeof(mtp_container_command_t) == 32, "size is not correct");
+
+// PTP/MTP Generic container
+typedef struct TU_ATTR_PACKED {
+  mtp_container_header_t header;
+  uint8_t payload[(CFG_TUD_MTP_EP_BUFSIZE - sizeof(mtp_container_header_t))];
+} mtp_generic_container_t;
+
+typedef struct {
+  mtp_container_header_t* header;
+  union {
+    uint8_t*  payload;
+    uint16_t* payload16;
+    uint32_t* payload32;
+  };
+  uint32_t payload_bytes; // available bytes for read/write
+} mtp_container_info_t;
+
+typedef struct TU_ATTR_PACKED {
+  uint16_t code;
+  uint32_t session_id;
+  uint32_t transaction_id;
+  uint32_t params[3];
+} mtp_event_t;
+TU_VERIFY_STATIC(sizeof(mtp_event_t) == 22, "size is not correct");
+
+#define mtp_string_t(_nchars) \
+  struct TU_ATTR_PACKED { \
+    uint8_t count; /* in characters including null */ \
+    uint16_t utf16[_nchars]; \
+  }
+
+#define mtp_array_t(_type, _count) \
+   struct TU_ATTR_PACKED { \
+     uint32_t count; \
+     _type arr[_count];\
+   }
+
+#define mtp_aint8_t(_count)  mtp_array_t(int8_t, _count)
+#define mtp_auint16_t(_count) mtp_array_t(uint16_t, _count)
+#define mtp_auint32_t(_count) mtp_array_t(uint32_t, _count)
+#define mtp_auint64_t(_count) mtp_array_t(uint64_t, _count)
+
+#define MTP_STORAGE_INFO_STRUCT(_storage_desc_chars, _volume_id_chars) \
+  struct TU_ATTR_PACKED { \
+    uint16_t storage_type; \
+    uint16_t filesystem_type; \
+    uint16_t access_capability; \
+    uint64_t max_capacity_in_bytes; \
+    uint64_t free_space_in_bytes; \
+    uint32_t free_space_in_objects; \
+    mtp_string_t(_storage_desc_chars) storage_description; \
+    mtp_string_t(_volume_id_chars) volume_identifier; \
+  }
+
+// Object Info Dataset without dynamic string: filename, date_created, date_modified, keywords
+typedef struct TU_ATTR_PACKED {
+  uint32_t storage_id;
+  uint16_t object_format;
+  uint16_t protection_status;
+  uint32_t object_compressed_size;
+  uint16_t thumb_format;
+  uint32_t thumb_compressed_size;
+  uint32_t thumb_pix_width;
+  uint32_t thumb_pix_height;
+  uint32_t image_pix_width;
+  uint32_t image_pix_height;
+  uint32_t image_bit_depth;
+  uint32_t parent_object; // 0: root
+  uint16_t association_type;
+  uint32_t association_desc;
+  uint32_t sequence_number;
+  // mtp_string_t() filename
+  // mtp_string_t() date_created
+  // mtp_string_t() date_modified
+  // mtp_string_t() keywords
+} mtp_object_info_header_t;
+
+// Device property desc up to get/set
+typedef struct TU_ATTR_PACKED {
+  uint16_t device_property_code;
+  uint16_t datatype;
+  uint8_t  get_set;
+} mtp_device_prop_desc_header_t;
+
+// The following fields will be dynamically added to the struct at runtime:
+// - wstring factory_def_value;
+// - wstring current_value_len;
+// - uint8_t form_flag;
+
+// no form
+#define MTP_DEVICE_PROPERTIES_STRUCT(_type) \
+   struct TU_ATTR_PACKED { \
+     uint16_t device_property_code; \
+     uint16_t datatype; \
+     uint8_t get_set; \
+     _type factory_default; \
+     _type current_value; \
+     uint8_t form_flag; /* 0: none, 1: range, 2: enum */ \
+   };
+
+typedef struct TU_ATTR_PACKED {
+  uint16_t code;
+  uint32_t transaction_id;
+} mtp_request_reset_cancel_data_t;
+TU_VERIFY_STATIC(sizeof(mtp_request_reset_cancel_data_t) == 6, "size is not correct");
+
+//--------------------------------------------------------------------+
+// Container helper function
+// return number of bytes added
+//--------------------------------------------------------------------+
+
+// return payload buffer for next write
+TU_ATTR_ALWAYS_INLINE static inline uint8_t* mtp_container_payload_ptr(mtp_container_info_t* p_container) {
+  // only 1st packet include header
+  uint32_t pos = p_container->header->len - sizeof(mtp_container_header_t);
+  while (pos > CFG_TUD_MTP_EP_BUFSIZE) {
+    pos -= CFG_TUD_MTP_EP_BUFSIZE;
+  }
+  return p_container->payload + pos;
+}
+
+// only add_raw does partial copy
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_raw(mtp_container_info_t* p_container, const void* data, uint32_t len) {
+  uint8_t* buf = mtp_container_payload_ptr(p_container);
+  const uint32_t added_len = tu_min32(len, CFG_TUD_MTP_EP_BUFSIZE - p_container->header->len);
+  if (added_len > 0) {
+    memcpy(buf, data, added_len);
+  }
+  p_container->header->len += len; // always increase len, even partial copy
+  return added_len;
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_array(mtp_container_info_t* p_container, uint8_t scalar_size, uint32_t count, const void* data) {
+  const uint32_t added_len = 4 + count * scalar_size;
+  TU_ASSERT(p_container->header->len + added_len < CFG_TUD_MTP_EP_BUFSIZE, 0);
+  uint8_t* buf = p_container->payload + p_container->header->len - sizeof(mtp_container_header_t);
+
+  tu_unaligned_write32(buf, count);
+  p_container->header->len += 4;
+  buf += 4;
+
+  memcpy(buf, data, count * scalar_size);
+  p_container->header->len += count * scalar_size;
+
+  return added_len;
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_string(mtp_container_info_t* p_container, uint16_t* utf16) {
+  uint8_t count = 0;
+  while (utf16[count] != 0u) {
+    count++;
+  }
+  const uint32_t added_len = 1u + (uint32_t) count * 2u;
+  TU_ASSERT(p_container->header->len + added_len < CFG_TUD_MTP_EP_BUFSIZE, 0);
+  uint8_t* buf = p_container->payload + p_container->header->len - sizeof(mtp_container_header_t);
+
+  *buf++ = count;
+  p_container->header->len++;
+
+  memcpy(buf, utf16, 2u * (uint32_t) count);
+  p_container->header->len += 2u * count;
+
+  return added_len;
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_cstring(mtp_container_info_t* p_container, const char* str) {
+  const uint8_t len = (uint8_t) (strlen(str) + 1); // include null
+  TU_ASSERT(p_container->header->len + 1 + 2 * len < CFG_TUD_MTP_EP_BUFSIZE, 0);
+  uint8_t* buf = p_container->payload + p_container->header->len - sizeof(mtp_container_header_t);
+
+  if (len == 1) {
+    // empty string (null only): single zero byte
+    *buf = 0;
+    p_container->header->len++;
+    return 1u;
+  } else {
+    *buf++ = len;
+    p_container->header->len++;
+
+    for (uint8_t i = 0; i < len; i++) {
+      buf[0] = str[i];
+      buf[1] = 0;
+      buf += 2;
+      p_container->header->len += 2;
+    }
+    return 1u + 2u * len;
+  }
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_uint8(mtp_container_info_t* p_container, uint8_t data) {
+  return mtp_container_add_raw(p_container, &data, 1);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_uint16(mtp_container_info_t* p_container, uint16_t data) {
+  return mtp_container_add_raw(p_container, &data, 2);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_uint32(mtp_container_info_t* p_container, uint32_t data) {
+  return mtp_container_add_raw(p_container, &data, 4);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_uint64(mtp_container_info_t* p_container, uint64_t data) {
+  return mtp_container_add_raw(p_container, &data, 8);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_uint128(mtp_container_info_t* p_container, const void* data) {
+  return mtp_container_add_raw(p_container, data, 16);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_auint8(mtp_container_info_t* p_container, uint32_t count, const uint8_t* data) {
+  return mtp_container_add_array(p_container, sizeof(uint8_t), count, data);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_auint16(mtp_container_info_t* p_container, uint32_t count, const uint16_t* data) {
+  return mtp_container_add_array(p_container, sizeof(uint16_t), count, data);
+}
+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_add_auint32(mtp_container_info_t* p_container, uint32_t count, const uint32_t* data) {
+  return mtp_container_add_array(p_container, sizeof(uint32_t), count, data);
+}
+
+//--------------------------------------------------------------------+
+//
+//--------------------------------------------------------------------+
+TU_ATTR_ALWAYS_INLINE static inline uint32_t mtp_container_get_string(uint8_t* buf, uint16_t utf16[]) {
+  size_t nchars = *buf++;
+  memcpy(utf16, buf, 2u * nchars);
+  return 1u + 2u * nchars;
+}
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif
+#endif
diff --git a/src/class/mtp/mtp_device.c b/src/class/mtp/mtp_device.c
new file mode 100644
index 000000000..04bde9415
--- /dev/null
+++ b/src/class/mtp/mtp_device.c
@@ -0,0 +1,540 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ennebi Elettronica (https://ennebielettronica.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#include "tusb_option.h"
+
+#if (CFG_TUD_ENABLED && CFG_TUD_MTP)
+
+//--------------------------------------------------------------------+
+// INCLUDE
+//--------------------------------------------------------------------+
+#include "device/dcd.h"
+#include "device/usbd.h"
+#include "device/usbd_pvt.h"
+
+#include "mtp_device.h"
+
+// Level where CFG_TUSB_DEBUG must be at least for this driver is logged
+#ifndef CFG_TUD_MTP_LOG_LEVEL
+  #define CFG_TUD_MTP_LOG_LEVEL   CFG_TUD_LOG_LEVEL
+#endif
+
+#define TU_LOG_DRV(...)   TU_LOG(CFG_TUD_MTP_LOG_LEVEL, __VA_ARGS__)
+
+//--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK bool tud_mtp_request_cancel_cb(tud_mtp_request_cb_data_t* cb_data) {
+  (void) cb_data;
+  return false;
+}
+TU_ATTR_WEAK bool tud_mtp_request_device_reset_cb(tud_mtp_request_cb_data_t* cb_data) {
+  (void) cb_data;
+  return false;
+}
+TU_ATTR_WEAK int32_t tud_mtp_request_get_extended_event_cb(tud_mtp_request_cb_data_t* cb_data) {
+  (void) cb_data;
+  return -1;
+}
+TU_ATTR_WEAK int32_t tud_mtp_request_get_device_status_cb(tud_mtp_request_cb_data_t* cb_data) {
+  (void) cb_data;
+  return -1;
+}
+TU_ATTR_WEAK bool tud_mtp_request_vendor_cb(tud_mtp_request_cb_data_t* cb_data) {
+  (void) cb_data;
+  return false;
+}
+TU_ATTR_WEAK int32_t tud_mtp_command_received_cb(tud_mtp_cb_data_t * cb_data) {
+  (void) cb_data;
+  return -1;
+}
+TU_ATTR_WEAK int32_t tud_mtp_data_xfer_cb(tud_mtp_cb_data_t* cb_data) {
+  (void) cb_data;
+  return -1;
+}
+TU_ATTR_WEAK int32_t tud_mtp_data_complete_cb(tud_mtp_cb_data_t* cb_data) {
+  (void) cb_data;
+  return -1;
+}
+TU_ATTR_WEAK int32_t tud_mtp_response_complete_cb(tud_mtp_cb_data_t* cb_data) {
+  (void) cb_data;
+  return -1;
+}
+
+//--------------------------------------------------------------------+
+// STRUCT
+//--------------------------------------------------------------------+
+typedef struct {
+  uint8_t rhport;
+  uint8_t itf_num;
+  uint8_t ep_in;
+  uint8_t ep_out;
+  uint8_t ep_event;
+
+  // Bulk Only Transfer (BOT) Protocol
+  uint8_t  phase;
+
+  uint32_t total_len;
+  uint32_t xferred_len;
+
+  uint32_t session_id;
+  mtp_container_command_t command;
+  mtp_container_header_t io_header;
+
+  TU_ATTR_ALIGNED(4) uint8_t control_buf[CFG_TUD_MTP_EP_CONTROL_BUFSIZE];
+} mtpd_interface_t;
+
+typedef struct {
+  TUD_EPBUF_DEF(buf, CFG_TUD_MTP_EP_BUFSIZE);
+  TUD_EPBUF_TYPE_DEF(mtp_event_t, buf_event);
+} mtpd_epbuf_t;
+
+//--------------------------------------------------------------------+
+// INTERNAL FUNCTION DECLARATION
+//--------------------------------------------------------------------+
+static mtpd_interface_t _mtpd_itf;
+CFG_TUD_MEM_SECTION static mtpd_epbuf_t _mtpd_epbuf;
+
+static void preprocess_cmd(mtpd_interface_t* p_mtp, tud_mtp_cb_data_t* cb_data);
+
+//--------------------------------------------------------------------+
+// Debug
+//--------------------------------------------------------------------+
+#if CFG_TUSB_DEBUG >= CFG_TUD_MTP_LOG_LEVEL
+
+TU_ATTR_UNUSED static tu_lookup_entry_t const _mpt_op_lookup[] = {
+{.key = MTP_OP_UNDEFINED                    , .data = "Undefined"                 } ,
+{.key = MTP_OP_GET_DEVICE_INFO              , .data = "GetDeviceInfo"             } ,
+{.key = MTP_OP_OPEN_SESSION                 , .data = "OpenSession"               } ,
+{.key = MTP_OP_CLOSE_SESSION                , .data = "CloseSession"              } ,
+{.key = MTP_OP_GET_STORAGE_IDS              , .data = "GetStorageIDs"             } ,
+{.key = MTP_OP_GET_STORAGE_INFO             , .data = "GetStorageInfo"            } ,
+{.key = MTP_OP_GET_NUM_OBJECTS              , .data = "GetNumObjects"             } ,
+{.key = MTP_OP_GET_OBJECT_HANDLES           , .data = "GetObjectHandles"          } ,
+{.key = MTP_OP_GET_OBJECT_INFO              , .data = "GetObjectInfo"             } ,
+{.key = MTP_OP_GET_OBJECT                   , .data = "GetObject"                 } ,
+{.key = MTP_OP_GET_THUMB                    , .data = "GetThumb"                  } ,
+{.key = MTP_OP_DELETE_OBJECT                , .data = "DeleteObject"              } ,
+{.key = MTP_OP_SEND_OBJECT_INFO             , .data = "SendObjectInfo"            } ,
+{.key = MTP_OP_SEND_OBJECT                  , .data = "SendObject"                } ,
+{.key = MTP_OP_INITIATE_CAPTURE             , .data = "InitiateCapture"           } ,
+{.key = MTP_OP_FORMAT_STORE                 , .data = "FormatStore"               } ,
+{.key = MTP_OP_RESET_DEVICE                 , .data = "ResetDevice"               } ,
+{.key = MTP_OP_SELF_TEST                    , .data = "SelfTest"                  } ,
+{.key = MTP_OP_SET_OBJECT_PROTECTION        , .data = "SetObjectProtection"       } ,
+{.key = MTP_OP_POWER_DOWN                   , .data = "PowerDown"                 } ,
+{.key = MTP_OP_GET_DEVICE_PROP_DESC         , .data = "GetDevicePropDesc"         } ,
+{.key = MTP_OP_GET_DEVICE_PROP_VALUE        , .data = "GetDevicePropValue"        } ,
+{.key = MTP_OP_SET_DEVICE_PROP_VALUE        , .data = "SetDevicePropValue"        } ,
+{.key = MTP_OP_RESET_DEVICE_PROP_VALUE      , .data = "ResetDevicePropValue"      } ,
+{.key = MTP_OP_TERMINATE_OPEN_CAPTURE       , .data = "TerminateOpenCapture"      } ,
+{.key = MTP_OP_MOVE_OBJECT                  , .data = "MoveObject"                } ,
+{.key = MTP_OP_COPY_OBJECT                  , .data = "CopyObject"                } ,
+{.key = MTP_OP_GET_PARTIAL_OBJECT           , .data = "GetPartialObject"          } ,
+{.key = MTP_OP_INITIATE_OPEN_CAPTURE        , .data = "InitiateOpenCapture"       } ,
+{.key = MTP_OP_GET_OBJECT_PROPS_SUPPORTED   , .data = "GetObjectPropsSupported"   } ,
+{.key = MTP_OP_GET_OBJECT_PROP_DESC         , .data = "GetObjectPropDesc"         } ,
+{.key = MTP_OP_GET_OBJECT_PROP_VALUE        , .data = "GetObjectPropValue"        } ,
+{.key = MTP_OP_SET_OBJECT_PROP_VALUE        , .data = "SetObjectPropValue"        } ,
+{.key = MTP_OP_GET_OBJECT_PROPLIST          , .data = "GetObjectPropList"         } ,
+{.key = MTP_OP_GET_OBJECT_PROP_REFERENCES   , .data = "GetObjectPropReferences"   } ,
+{.key = MTP_OP_GET_SERVICE_IDS              , .data = "GetServiceIDs"             } ,
+{.key = MTP_OP_GET_SERVICE_INFO             , .data = "GetServiceInfo"            } ,
+{.key = MTP_OP_GET_SERVICE_CAPABILITIES     , .data = "GetServiceCapabilities"    } ,
+{.key = MTP_OP_GET_SERVICE_PROP_DESC        , .data = "GetServicePropDesc"        } ,
+{.key = MTP_OP_GET_OBJECT_PROP_LIST         , .data = "GetObjectPropList"         } ,
+{.key = MTP_OP_SET_OBJECT_PROP_LIST         , .data = "SetObjectPropList"         } ,
+{.key = MTP_OP_GET_INTERDEPENDENT_PROP_DESC , .data = "GetInterdependentPropDesc" } ,
+{.key = MTP_OP_SEND_OBJECT_PROP_LIST        , .data = "SendObjectPropList"        }
+};
+
+TU_ATTR_UNUSED static tu_lookup_table_t const _mtp_op_table = {
+  .count = TU_ARRAY_SIZE(_mpt_op_lookup),
+  .items = _mpt_op_lookup
+};
+
+TU_ATTR_UNUSED static const char* _mtp_phase_str[] = {
+  "Command",
+  "Data",
+  "Response",
+  "Error"
+};
+
+#endif
+
+
+//--------------------------------------------------------------------+
+// Helper
+//--------------------------------------------------------------------+
+static bool prepare_new_command(mtpd_interface_t* p_mtp) {
+  p_mtp->phase = MTP_PHASE_COMMAND;
+  return usbd_edpt_xfer(p_mtp->rhport, p_mtp->ep_out, _mtpd_epbuf.buf, CFG_TUD_MTP_EP_BUFSIZE);
+}
+
+static bool mtpd_data_xfer(mtp_container_info_t* p_container, uint8_t ep_addr) {
+  mtpd_interface_t* p_mtp = &_mtpd_itf;
+  if (p_mtp->phase == MTP_PHASE_COMMAND) {
+    // 1st data block: header + payload
+    p_mtp->phase = MTP_PHASE_DATA;
+    p_mtp->xferred_len = 0;
+
+    if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN) {
+      p_mtp->total_len = p_container->header->len;
+      p_container->header->type = MTP_CONTAINER_TYPE_DATA_BLOCK;
+      p_container->header->transaction_id = p_mtp->command.header.transaction_id;
+      p_mtp->io_header = *p_container->header; // save header for subsequent data
+    } else {
+      // OUT transfer: total length is at least max packet size
+      p_mtp->total_len = tu_max32(p_container->header->len, CFG_TUD_MTP_EP_BUFSIZE);
+    }
+  } else {
+    // subsequent data block: payload only
+    TU_ASSERT(p_mtp->phase == MTP_PHASE_DATA);
+  }
+
+  const uint16_t xact_len = (uint16_t) tu_min32(p_mtp->total_len - p_mtp->xferred_len, CFG_TUD_MTP_EP_BUFSIZE);
+  if (xact_len) {
+    // already transferred all bytes in header's length. Application make an unnecessary extra call
+    TU_VERIFY(usbd_edpt_claim(p_mtp->rhport, ep_addr));
+    TU_ASSERT(usbd_edpt_xfer(p_mtp->rhport, ep_addr, _mtpd_epbuf.buf, xact_len));
+  }
+  return true;
+}
+
+bool tud_mtp_data_send(mtp_container_info_t* p_container) {
+  return mtpd_data_xfer(p_container, _mtpd_itf.ep_in);
+}
+
+bool tud_mtp_data_receive(mtp_container_info_t* p_container) {
+  return mtpd_data_xfer(p_container, _mtpd_itf.ep_out);
+}
+
+bool tud_mtp_response_send(mtp_container_info_t* p_container) {
+  mtpd_interface_t* p_mtp = &_mtpd_itf;
+  p_mtp->phase = MTP_PHASE_RESPONSE;
+  p_container->header->type = MTP_CONTAINER_TYPE_RESPONSE_BLOCK;
+  p_container->header->transaction_id = p_mtp->command.header.transaction_id;
+  TU_VERIFY(usbd_edpt_claim(p_mtp->rhport, p_mtp->ep_in));
+  return usbd_edpt_xfer(p_mtp->rhport, p_mtp->ep_in, _mtpd_epbuf.buf, (uint16_t)p_container->header->len);
+}
+
+bool tud_mtp_mounted(void) {
+  mtpd_interface_t* p_mtp = &_mtpd_itf;
+  return p_mtp->ep_out != 0 && p_mtp->ep_in != 0;
+}
+
+bool tud_mtp_event_send(mtp_event_t* event) {
+  mtpd_interface_t* p_mtp = &_mtpd_itf;
+  TU_VERIFY(p_mtp->ep_event != 0);
+  _mtpd_epbuf.buf_event = *event;
+  TU_VERIFY(usbd_edpt_claim(p_mtp->rhport, p_mtp->ep_event)); // Claim the endpoint
+  return usbd_edpt_xfer(p_mtp->rhport, p_mtp->ep_event, (uint8_t*) &_mtpd_epbuf.buf_event, sizeof(mtp_event_t));
+}
+
+//--------------------------------------------------------------------+
+// USBD Driver API
+//--------------------------------------------------------------------+
+void mtpd_init(void) {
+  tu_memclr(&_mtpd_itf, sizeof(mtpd_interface_t));
+}
+
+bool mtpd_deinit(void) {
+  return true; // nothing to do
+}
+
+void mtpd_reset(uint8_t rhport) {
+  (void) rhport;
+  tu_memclr(&_mtpd_itf, sizeof(mtpd_interface_t));
+}
+
+uint16_t mtpd_open(uint8_t rhport, tusb_desc_interface_t const* itf_desc, uint16_t max_len) {
+  // only support PIMA 15470 protocol
+  TU_VERIFY(TUSB_CLASS_IMAGE == itf_desc->bInterfaceClass &&
+            MTP_SUBCLASS_STILL_IMAGE == itf_desc->bInterfaceSubClass &&
+            MTP_PROTOCOL_PIMA_15470 == itf_desc->bInterfaceProtocol, 0);
+
+  // mtp driver length is fixed
+  const uint16_t mtpd_itf_size = sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t);
+
+  // Max length must be at least 1 interface + 3 endpoints
+  TU_ASSERT(itf_desc->bNumEndpoints == 3 && max_len >= mtpd_itf_size);
+  mtpd_interface_t* p_mtp = &_mtpd_itf;
+  tu_memclr(p_mtp, sizeof(mtpd_interface_t));
+  p_mtp->rhport = rhport;
+  p_mtp->itf_num = itf_desc->bInterfaceNumber;
+
+  // Open interrupt IN endpoint
+  const tusb_desc_endpoint_t* ep_desc = (const tusb_desc_endpoint_t*) tu_desc_next(itf_desc);
+  TU_ASSERT(ep_desc->bDescriptorType == TUSB_DESC_ENDPOINT && ep_desc->bmAttributes.xfer == TUSB_XFER_INTERRUPT, 0);
+  TU_ASSERT(usbd_edpt_open(rhport, ep_desc), 0);
+  p_mtp->ep_event = ep_desc->bEndpointAddress;
+
+  // Open endpoint pair
+  TU_ASSERT(usbd_open_edpt_pair(rhport, tu_desc_next(ep_desc), 2, TUSB_XFER_BULK, &p_mtp->ep_out, &p_mtp->ep_in), 0);
+  TU_ASSERT(prepare_new_command(p_mtp), 0);
+
+  return mtpd_itf_size;
+}
+
+// Invoked when a control transfer occurred on an interface of this class
+// Driver response accordingly to the request and the transfer stage (setup/data/ack)
+// return false to stall control endpoint (e.g unsupported request)
+bool mtpd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const* request) {
+  mtpd_interface_t* p_mtp = &_mtpd_itf;
+  tud_mtp_request_cb_data_t cb_data = {
+    .idx = 0,
+    .stage = stage,
+    .session_id = p_mtp->session_id,
+    .request = request,
+    .buf = p_mtp->control_buf,
+    .bufsize = tu_le16toh(request->wLength),
+  };
+
+  switch (request->bRequest) {
+    case MTP_REQ_CANCEL:
+      TU_LOG_DRV("  MTP request: Cancel\n");
+      if (stage == CONTROL_STAGE_SETUP) {
+        return tud_control_xfer(rhport, request, p_mtp->control_buf, CFG_TUD_MTP_EP_CONTROL_BUFSIZE);
+      } else if (stage == CONTROL_STAGE_ACK) {
+        return tud_mtp_request_cancel_cb(&cb_data);
+      }
+      break;
+
+    case MTP_REQ_GET_EXT_EVENT_DATA:
+      TU_LOG_DRV("  MTP request: Get Extended Event Data\n");
+      if (stage == CONTROL_STAGE_SETUP) {
+        const int32_t len = tud_mtp_request_get_extended_event_cb(&cb_data);
+        TU_VERIFY(len > 0);
+        return tud_control_xfer(rhport,request, p_mtp->control_buf, (uint16_t) len);
+      }
+      break;
+
+    case MTP_REQ_RESET:
+      TU_LOG_DRV("  MTP request: Device Reset\n");
+      // used by the host to return the Still Image Capture Device to the Idle state after the Bulk-pipe has stalled
+      if (stage == CONTROL_STAGE_SETUP) {
+        // clear stalled
+        if (usbd_edpt_stalled(rhport, p_mtp->ep_out)) {
+          usbd_edpt_clear_stall(rhport, p_mtp->ep_out);
+        }
+        if (usbd_edpt_stalled(rhport, p_mtp->ep_in)) {
+          usbd_edpt_clear_stall(rhport, p_mtp->ep_in);
+        }
+      } else if (stage == CONTROL_STAGE_ACK) {
+        prepare_new_command(p_mtp);
+        return tud_mtp_request_device_reset_cb(&cb_data);
+      }
+      break;
+
+    case MTP_REQ_GET_DEVICE_STATUS: {
+      TU_LOG_DRV("  MTP request: Get Device Status\n");
+      if (stage == CONTROL_STAGE_SETUP) {
+        const int32_t len = tud_mtp_request_get_device_status_cb(&cb_data);
+        TU_VERIFY(len > 0);
+        return tud_control_xfer(rhport, request, p_mtp->control_buf, (uint16_t) len);
+      }
+      break;
+    }
+
+    default:
+      return tud_mtp_request_vendor_cb(&cb_data);
+  }
+
+  return true;
+}
+
+// Transfer on bulk endpoints
+bool mtpd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes) {
+  if (ep_addr == _mtpd_itf.ep_event) {
+    // nothing to do
+    return true;
+  }
+
+  mtpd_interface_t* p_mtp = &_mtpd_itf;
+  mtp_generic_container_t* p_container = (mtp_generic_container_t*) _mtpd_epbuf.buf;
+
+#if CFG_TUSB_DEBUG >= CFG_TUD_MTP_LOG_LEVEL
+  tu_lookup_find(&_mtp_op_table, p_mtp->command.header.code);
+  TU_LOG_DRV("  MTP %s: %s phase\r\n", (const char *) tu_lookup_find(&_mtp_op_table, p_mtp->command.header.code),
+    _mtp_phase_str[p_mtp->phase]);
+#endif
+
+  const mtp_container_info_t headered_packet = {
+    .header = &p_container->header,
+    .payload = p_container->payload,
+    .payload_bytes = CFG_TUD_MTP_EP_BUFSIZE - sizeof(mtp_container_header_t)
+  };
+
+  const mtp_container_info_t headerless_packet = {
+    .header = &p_mtp->io_header,
+    .payload = _mtpd_epbuf.buf,
+    .payload_bytes = CFG_TUD_MTP_EP_BUFSIZE
+  };
+
+  tud_mtp_cb_data_t cb_data;
+  cb_data.idx = 0;
+  cb_data.phase = p_mtp->phase;
+  cb_data.session_id = p_mtp->session_id;
+  cb_data.command_container = &p_mtp->command;
+  cb_data.io_container = headered_packet;
+  cb_data.total_xferred_bytes = 0;
+  cb_data.xfer_result = event;
+
+  switch (p_mtp->phase) {
+    case MTP_PHASE_COMMAND: {
+      // received new command
+      TU_VERIFY(ep_addr == p_mtp->ep_out && p_container->header.type == MTP_CONTAINER_TYPE_COMMAND_BLOCK);
+      memcpy(&p_mtp->command, p_container, sizeof(mtp_container_command_t)); // save new command
+      p_container->header.len = sizeof(mtp_container_header_t); // default container to header only
+      preprocess_cmd(p_mtp, &cb_data);
+      if (tud_mtp_command_received_cb(&cb_data) < 0) {
+        p_mtp->phase = MTP_PHASE_ERROR;
+      }
+      break;
+    }
+
+    case MTP_PHASE_DATA: {
+      const uint16_t bulk_mps = (tud_speed_get() == TUSB_SPEED_HIGH) ? 512 : 64;
+      p_mtp->xferred_len += xferred_bytes;
+      cb_data.total_xferred_bytes = p_mtp->xferred_len;
+
+      bool is_complete = false;
+      // complete if ZLP or short packet or overflow
+      if (xferred_bytes == 0 || // ZLP
+          (xferred_bytes & (bulk_mps - 1)) || // short packet
+          p_mtp->xferred_len > p_mtp->total_len) {
+        is_complete = true;
+      }
+
+      if (ep_addr == p_mtp->ep_in) {
+        // Data In
+        if (is_complete) {
+          cb_data.io_container.header->len = sizeof(mtp_container_header_t);
+          tud_mtp_data_complete_cb(&cb_data);
+        } else {
+          // 2nd+ packet: payload only
+          cb_data.io_container = headerless_packet;
+          tud_mtp_data_xfer_cb(&cb_data);
+        }
+      } else {
+        // Data Out
+        if (p_mtp->xferred_len == xferred_bytes) {
+          // 1st OUT packet: header + payload
+          p_mtp->io_header = p_container->header; // save header for subsequent transaction
+          cb_data.io_container.payload_bytes = xferred_bytes - sizeof(mtp_container_header_t);
+        } else {
+          // 2nd+ packet: payload only
+          cb_data.io_container = headerless_packet;
+          cb_data.io_container.payload_bytes = xferred_bytes;
+        }
+        tud_mtp_data_xfer_cb(&cb_data);
+
+        if (is_complete) {
+          // back to header + payload for response
+          cb_data.io_container = headered_packet;
+          cb_data.io_container.header->len = sizeof(mtp_container_header_t);
+          tud_mtp_data_complete_cb(&cb_data);
+        }
+      }
+      break;
+    }
+
+    case MTP_PHASE_RESPONSE:
+      // response phase is complete -> prepare for new command
+      TU_ASSERT(ep_addr == p_mtp->ep_in);
+      tud_mtp_response_complete_cb(&cb_data);
+      prepare_new_command(p_mtp);
+      break;
+
+    case MTP_PHASE_ERROR:
+      // handled after switch, supposedly to be empty
+      break;
+    default: return false;
+  }
+
+   if (p_mtp->phase == MTP_PHASE_ERROR) {
+    // stall both IN & OUT endpoints
+    usbd_edpt_stall(rhport, p_mtp->ep_out);
+    usbd_edpt_stall(rhport, p_mtp->ep_in);
+  }
+
+  return true;
+}
+
+
+//--------------------------------------------------------------------+
+// MTPD Internal functionality
+//--------------------------------------------------------------------+
+
+// pre-processed commands
+void preprocess_cmd(mtpd_interface_t* p_mtp, tud_mtp_cb_data_t* cb_data) {
+  switch (p_mtp->command.header.code) {
+    case MTP_OP_GET_DEVICE_INFO: {
+      tud_mtp_device_info_t dev_info = {
+        .standard_version = 100,
+        .mtp_vendor_extension_id = 6, // MTP specs say 0xFFFFFFFF but libMTP check for value 6
+        .mtp_version = 100,
+        .mtp_extensions = {
+          .count = sizeof(CFG_TUD_MTP_DEVICEINFO_EXTENSIONS),
+          .utf16 = { 0 }
+        },
+        .functional_mode = 0x0000,
+        .supported_operations = {
+          .count = TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS),
+          .arr = { CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS }
+        },
+        .supported_events = {
+          .count = TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_EVENTS),
+          .arr = { CFG_TUD_MTP_DEVICEINFO_SUPPORTED_EVENTS }
+        },
+        .supported_device_properties = {
+          .count = TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_DEVICE_PROPERTIES),
+          .arr = { CFG_TUD_MTP_DEVICEINFO_SUPPORTED_DEVICE_PROPERTIES }
+        },
+        .capture_formats = {
+          .count = TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_CAPTURE_FORMATS),
+          .arr = { CFG_TUD_MTP_DEVICEINFO_CAPTURE_FORMATS }
+        },
+        .playback_formats = {
+          .count = TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_PLAYBACK_FORMATS),
+          .arr = { CFG_TUD_MTP_DEVICEINFO_PLAYBACK_FORMATS }
+        }
+      };
+
+      for (uint8_t i=0; i < dev_info.mtp_extensions.count; i++) {
+        dev_info.mtp_extensions.utf16[i] = (uint16_t)CFG_TUD_MTP_DEVICEINFO_EXTENSIONS[i];
+      }
+
+      mtp_container_add_raw(&cb_data->io_container, &dev_info, sizeof(tud_mtp_device_info_t));
+      break;
+    }
+
+    default:
+      break;
+  }
+}
+
+#endif
diff --git a/src/class/mtp/mtp_device.h b/src/class/mtp/mtp_device.h
new file mode 100644
index 000000000..a33f1dc08
--- /dev/null
+++ b/src/class/mtp/mtp_device.h
@@ -0,0 +1,169 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ennebi Elettronica (https://ennebielettronica.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN0
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#ifndef TUSB_MTP_DEVICE_H_
+#define TUSB_MTP_DEVICE_H_
+
+#include "common/tusb_common.h"
+#include "mtp.h"
+
+#if (CFG_TUD_ENABLED && CFG_TUD_MTP)
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+// callback data for Bulk Only Transfer (BOT) protocol
+typedef struct {
+  uint8_t idx; // mtp instance
+  uint8_t phase; // current phase
+  uint32_t session_id;
+
+  const mtp_container_command_t* command_container;
+  mtp_container_info_t io_container;
+
+  tusb_xfer_result_t xfer_result;
+  uint32_t total_xferred_bytes; // number of bytes transferred so far in this phase
+} tud_mtp_cb_data_t;
+
+// callback data for Control requests
+typedef struct {
+  uint8_t idx;
+  uint8_t stage; // control stage
+
+  // buffer for data stage
+  uint16_t bufsize;
+  uint8_t* buf;
+
+  const tusb_control_request_t* request;
+
+  uint32_t session_id;
+} tud_mtp_request_cb_data_t;
+
+// Number of supported operations, events, device properties, capture formats, playback formats
+// and max number of characters for strings manufacturer, model, device_version, serial_number
+#define MTP_DEVICE_INFO_STRUCT(_extension_nchars, _op_count, _event_count, _devprop_count, _capture_count, _playback_count) \
+  struct TU_ATTR_PACKED { \
+    uint16_t standard_version; \
+    uint32_t mtp_vendor_extension_id; \
+    uint16_t mtp_version; \
+    mtp_string_t(_extension_nchars) mtp_extensions; \
+    uint16_t functional_mode; \
+    mtp_auint16_t(_op_count) supported_operations; \
+    mtp_auint16_t(_event_count) supported_events; \
+    mtp_auint16_t(_devprop_count) supported_device_properties; \
+    mtp_auint16_t(_capture_count) capture_formats; \
+    mtp_auint16_t(_playback_count) playback_formats; \
+    /* string fields will be added using append function */ \
+  }
+
+typedef MTP_DEVICE_INFO_STRUCT( //-V2586 [MISRA-C-18.7] Flexible array members should not be declared
+  sizeof(CFG_TUD_MTP_DEVICEINFO_EXTENSIONS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_OPERATIONS),
+  TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_EVENTS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_SUPPORTED_DEVICE_PROPERTIES),
+  TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_CAPTURE_FORMATS), TU_ARGS_NUM(CFG_TUD_MTP_DEVICEINFO_PLAYBACK_FORMATS)
+) tud_mtp_device_info_t;
+
+//--------------------------------------------------------------------+
+// Application API
+//--------------------------------------------------------------------+
+
+// check if mtp interface is mounted
+bool tud_mtp_mounted(void);
+
+// send data phase
+bool tud_mtp_data_send(mtp_container_info_t* p_container);
+
+// receive data phase
+bool tud_mtp_data_receive(mtp_container_info_t* p_container);
+
+// send response
+bool tud_mtp_response_send(mtp_container_info_t* p_container);
+
+// send event notification on event endpoint
+bool tud_mtp_event_send(mtp_event_t* event);
+
+//--------------------------------------------------------------------+
+// Control request Callbacks
+//--------------------------------------------------------------------+
+
+// Invoked when received Cancel request. Data is available in callback data's buffer
+// return false to stall the request
+bool tud_mtp_request_cancel_cb(tud_mtp_request_cb_data_t* cb_data);
+
+// Invoked when received Device Reset request
+// return false to stall the request
+bool tud_mtp_request_device_reset_cb(tud_mtp_request_cb_data_t* cb_data);
+
+// Invoked when received Get Extended Event request. Application fill callback data's buffer for response
+// return negative to stall the request
+int32_t tud_mtp_request_get_extended_event_cb(tud_mtp_request_cb_data_t* cb_data);
+
+// Invoked when received Get DeviceStatus request. Application fill callback data's buffer for response
+// return negative to stall the request
+int32_t tud_mtp_request_get_device_status_cb(tud_mtp_request_cb_data_t* cb_data);
+
+// Invoked when received vendor-specific request not in the above standard MTP requests
+// return false to stall the request
+bool tud_mtp_request_vendor_cb(tud_mtp_request_cb_data_t* cb_data);
+
+//--------------------------------------------------------------------+
+// Bulk only protocol Callbacks
+//--------------------------------------------------------------------+
+
+// Invoked when new command is received. Application fill the cb_data->io_container and call tud_mtp_data_send() or
+// tud_mtp_response_send() for Data or Response phase.
+// Return negative to stall the endpoints
+int32_t tud_mtp_command_received_cb(tud_mtp_cb_data_t * cb_data);
+
+// Invoked when a data packet is transferred. If data spans over multiple packets, application can use
+// total_xferred_bytes and io_container's payload_bytes to determine the offset and remaining bytes to be transferred.
+// Return negative to stall the endpoints
+int32_t tud_mtp_data_xfer_cb(tud_mtp_cb_data_t* cb_data);
+
+// Invoked when all bytes in DATA phase is complete. A response packet is expected
+// Return negative to stall the endpoints
+int32_t tud_mtp_data_complete_cb(tud_mtp_cb_data_t* cb_data);
+
+// Invoked when response phase is complete
+// Return negative to stall the endpoints
+int32_t tud_mtp_response_complete_cb(tud_mtp_cb_data_t* cb_data);
+
+//--------------------------------------------------------------------+
+// Internal Class Driver API
+//--------------------------------------------------------------------+
+void     mtpd_init            (void);
+bool     mtpd_deinit          (void);
+void     mtpd_reset           (uint8_t rhport);
+uint16_t mtpd_open            (uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
+bool     mtpd_control_xfer_cb (uint8_t rhport, uint8_t stage, tusb_control_request_t const *p_request);
+bool     mtpd_xfer_cb         (uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif
+#endif
diff --git a/src/class/net/ecm_rndis_device.c b/src/class/net/ecm_rndis_device.c
index a54e6d662..7dff66823 100644
--- a/src/class/net/ecm_rndis_device.c
+++ b/src/class/net/ecm_rndis_device.c
@@ -35,8 +35,6 @@
 #include "net_device.h"
 #include "rndis_protocol.h"
 
-extern void rndis_class_set_handler(uint8_t *data, int size); /* found in ./misc/networking/rndis_reports.c */
-
 #define CFG_TUD_NET_PACKET_PREFIX_LEN sizeof(rndis_data_packet_t)
 #define CFG_TUD_NET_PACKET_SUFFIX_LEN 0
 
@@ -81,6 +79,7 @@ typedef struct {
 static netd_interface_t _netd_itf;
 CFG_TUD_MEM_SECTION static netd_epbuf_t _netd_epbuf;
 static bool can_xmit;
+static bool ecm_link_is_up = true;  // Store link state for ECM mode
 
 void tud_network_recv_renew(void) {
   usbd_edpt_xfer(0, _netd_itf.ep_out, _netd_epbuf.rx, NETD_PACKET_SIZE);
@@ -95,7 +94,11 @@ void netd_report(uint8_t *buf, uint16_t len) {
   const uint8_t rhport = 0;
   len = tu_min16(len, sizeof(ecm_notify_t));
 
-  TU_VERIFY(usbd_edpt_claim(rhport, _netd_itf.ep_notif), );
+  if (!usbd_edpt_claim(rhport, _netd_itf.ep_notif)) {
+    TU_LOG1("ECM: Failed to claim notification endpoint\n");
+    return;
+  }
+
   memcpy(_netd_epbuf.notify, buf, len);
   usbd_edpt_xfer(rhport, _netd_itf.ep_notif, _netd_epbuf.notify, len);
 }
@@ -181,8 +184,6 @@ uint16_t netd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint1
     // Open endpoint pair for RNDIS
     TU_ASSERT(usbd_open_edpt_pair(rhport, p_desc, 2, TUSB_XFER_BULK, &_netd_itf.ep_out, &_netd_itf.ep_in), 0);
 
-    tud_network_init_cb();
-
     // we are ready to transmit a packet
     can_xmit = true;
 
@@ -196,11 +197,11 @@ uint16_t netd_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint1
 }
 
 static void ecm_report(bool nc) {
-  const ecm_notify_t ecm_notify_nc = {
+  ecm_notify_t ecm_notify_nc = {
     .header = {
       .bmRequestType = 0xA1,
       .bRequest = 0, /* NETWORK_CONNECTION aka NetworkConnection */
-      .wValue = 1,   /* Connected */
+      .wValue = ecm_link_is_up ? 1 : 0,   /* Use current link state */
       .wLength = 0,
     },
   };
@@ -259,7 +260,6 @@ bool netd_control_xfer_cb (uint8_t rhport, uint8_t stage, tusb_control_request_t
 
                 // TODO should be merge with RNDIS's after endpoint opened
                 // Also should have opposite callback for application to disable network !!
-                tud_network_init_cb();
                 can_xmit = true; // we are ready to transmit a packet
                 tud_network_recv_renew(); // prepare for incoming packets
               }
@@ -286,7 +286,10 @@ bool netd_control_xfer_cb (uint8_t rhport, uint8_t stage, tusb_control_request_t
           /* the only required CDC-ECM Management Element Request is SetEthernetPacketFilter */
           if (0x43 /* SET_ETHERNET_PACKET_FILTER */ == request->bRequest) {
             tud_control_xfer(rhport, request, NULL, 0);
-            ecm_report(true);
+            // Only send connection notification if link is up
+            if (ecm_link_is_up) {
+              ecm_report(true);
+            }
           }
         } else {
           if (request->bmRequestType_bit.direction == TUSB_DIR_IN) {
@@ -363,9 +366,8 @@ bool netd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_
   }
 
   if (_netd_itf.ecm_mode && (ep_addr == _netd_itf.ep_notif)) {
-    if (sizeof(tusb_control_request_t) == xferred_bytes) {
-      ecm_report(false);
-    }
+    // Notification transfer complete - endpoint is now free
+    // Don't automatically send speed change notification after link state changes
   }
 
   return true;
@@ -398,4 +400,31 @@ void tud_network_xmit(void *ref, uint16_t arg) {
   do_in_xfer(_netd_epbuf.tx, len);
 }
 
+// Set the network link state (up/down) and notify the host
+void tud_network_link_state(uint8_t rhport, bool is_up) {
+  (void)rhport;
+
+  if (_netd_itf.ecm_mode) {
+    ecm_link_is_up = is_up;
+
+    // For ECM mode, send network connection notification only
+    // Don't trigger speed change notification for link state changes
+    ecm_notify_t notify = {
+      .header = {
+        .bmRequestType = 0xA1,
+        .bRequest = 0,        /* NETWORK_CONNECTION */
+        .wValue = is_up ? 1 : 0,  /* 0 = disconnected, 1 = connected */
+        .wLength = 0,
+      },
+    };
+    notify.header.wIndex = _netd_itf.itf_num;
+    netd_report((uint8_t *)&notify, sizeof(notify.header));
+  } else {
+    // For RNDIS mode, we would need to implement RNDIS status indication
+    // This is more complex and requires RNDIS_INDICATE_STATUS_MSG
+    // For now, RNDIS doesn't support dynamic link state changes
+    (void)is_up;
+  }
+}
+
 #endif
diff --git a/src/class/net/ncm.h b/src/class/net/ncm.h
index 0245a87f2..8989fe0b4 100644
--- a/src/class/net/ncm.h
+++ b/src/class/net/ncm.h
@@ -25,8 +25,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_NCM_H_
-#define _TUSB_NCM_H_
+#ifndef TUSB_NCM_H_
+#define TUSB_NCM_H_
 
 #include "common/tusb_common.h"
 
diff --git a/src/class/net/ncm_device.c b/src/class/net/ncm_device.c
index f9fda0698..ea3c250fe 100644
--- a/src/class/net/ncm_device.c
+++ b/src/class/net/ncm_device.c
@@ -50,10 +50,6 @@
 
 #if (CFG_TUD_ENABLED && CFG_TUD_NCM)
 
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-
 #include "device/usbd.h"
 #include "device/usbd_pvt.h"
 
@@ -110,6 +106,7 @@ typedef struct {
     NOTIFICATION_DONE
   } notification_xmit_state;                            // state of notification transmission
   bool notification_xmit_is_running;                    // notification is currently transmitted
+  bool link_is_up;                                      // current link state
 
   // misc
   bool tud_network_recv_renew_active;                   // tud_network_recv_renew() is active (avoid recursive invocations)
@@ -218,7 +215,7 @@ static void notification_xmit(uint8_t rhport, bool force_next) {
           .direction = TUSB_DIR_IN
         },
         .bRequest = CDC_NOTIF_NETWORK_CONNECTION,
-        .wValue = 1 /* Connected */,
+        .wValue = ncm_interface.link_is_up ? 1 : 0,  /* Dynamic link state */
         .wIndex = ncm_interface.itf_num,
         .wLength = 0,
       },
@@ -232,6 +229,7 @@ static void notification_xmit(uint8_t rhport, bool force_next) {
     ncm_interface.notification_xmit_is_running = true;
   } else {
     TU_LOG_DRV("  NOTIFICATION_FINISHED\n");
+    ncm_interface.notification_xmit_is_running = false;
   }
 } // notification_xmit
 
@@ -755,6 +753,32 @@ static void tud_network_recv_renew_r(uint8_t rhport) {
   tud_network_recv_renew();
 } // tud_network_recv_renew
 
+/**
+ * Set the link state and send notification to host
+ */
+void tud_network_link_state(uint8_t rhport, bool is_up) {
+  TU_LOG_DRV("tud_network_link_state(%d, %d)\n", rhport, is_up);
+
+  if (ncm_interface.link_is_up == is_up) {
+    // No change in link state
+    return;
+  }
+
+  ncm_interface.link_is_up = is_up;
+
+  // Only send notification if we have an active data interface
+  if (ncm_interface.itf_data_alt != 1) {
+    TU_LOG_DRV("  link state notification skipped (interface not active)\n");
+    return;
+  }
+
+  // Reset notification state to send link state update
+  ncm_interface.notification_xmit_state = NOTIFICATION_CONNECTED;
+
+  // Trigger notification transmission
+  notification_xmit(rhport, false);
+}
+
 //-----------------------------------------------------------------------------
 //
 // all the netd_*() stuff (interface TinyUSB -> driver)
@@ -774,6 +798,12 @@ void netd_init(void) {
   for (int i = 0; i < RECV_NTB_N; ++i) {
     ncm_interface.recv_free_ntb[i] = &ncm_epbuf.recv[i].ntb;
   }
+  // Default link state - can be configured via CFG_TUD_NCM_DEFAULT_LINK_UP
+  #ifdef CFG_TUD_NCM_DEFAULT_LINK_UP
+  ncm_interface.link_is_up = CFG_TUD_NCM_DEFAULT_LINK_UP;
+  #else
+  ncm_interface.link_is_up = true; // Default to link up if not set.
+  #endif
 } // netd_init
 
 /**
diff --git a/src/class/net/net_device.h b/src/class/net/net_device.h
index 4c9a92f2d..96c03fd61 100644
--- a/src/class/net/net_device.h
+++ b/src/class/net/net_device.h
@@ -25,8 +25,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_NET_DEVICE_H_
-#define _TUSB_NET_DEVICE_H_
+#ifndef TUSB_NET_DEVICE_H_
+#define TUSB_NET_DEVICE_H_
 
 #include <stdint.h>
 #include "class/cdc/cdc.h"
@@ -56,6 +56,13 @@ typedef enum
 #endif
 
 //--------------------------------------------------------------------+
+// Implemented by Application
+//--------------------------------------------------------------------+
+#if CFG_TUD_ECM_RNDIS
+extern void rndis_class_set_handler(uint8_t *data, int size);
+#endif
+
+//--------------------------------------------------------------------+
 // Application API
 //--------------------------------------------------------------------+
 
@@ -87,6 +94,11 @@ void tud_network_init_cb(void);
 // TODO removed later since it is not part of tinyusb stack
 extern uint8_t tud_network_mac_address[6];
 
+//------------- NCM -------------//
+
+// Set the network link state (up/down) and notify the host
+void tud_network_link_state(uint8_t rhport, bool is_up);
+
 //--------------------------------------------------------------------+
 // INTERNAL USBD-CLASS DRIVER API
 //--------------------------------------------------------------------+
@@ -102,4 +114,4 @@ void     netd_report          (uint8_t *buf, uint16_t len);
  }
 #endif
 
-#endif /* _TUSB_NET_DEVICE_H_ */
+#endif /* TUSB_NET_DEVICE_H_ */
diff --git a/src/class/usbtmc/usbtmc.h b/src/class/usbtmc/usbtmc.h
index 327de087c..3bf5e1a17 100644
--- a/src/class/usbtmc/usbtmc.h
+++ b/src/class/usbtmc/usbtmc.h
@@ -25,8 +25,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_USBTMC_H__
-#define _TUSB_USBTMC_H__
+#ifndef TUSB_USBTMC_H__
+#define TUSB_USBTMC_H__
 
 #include "common/tusb_common.h"
 
diff --git a/src/class/usbtmc/usbtmc_device.c b/src/class/usbtmc/usbtmc_device.c
index abde9679f..3f6bedd4c 100644
--- a/src/class/usbtmc/usbtmc_device.c
+++ b/src/class/usbtmc/usbtmc_device.c
@@ -45,7 +45,7 @@
  */
 
 //Limitations:
-// "vendor-specific" commands are not handled.
+// "vendor-specific" commands are handled similar to normal messages, except that the MsgID is changed to "vendor-specific".
 // Dealing with "termchar" must be handled by the application layer,
 //    though additional error checking is does in this module.
 // talkOnly and listenOnly are NOT supported. They're not permitted
@@ -76,11 +76,6 @@
 
 #include "usbtmc_device.h"
 
-#ifdef xDEBUG
-#include "uart_util.h"
-tu_static char logMsg[150];
-#endif
-
 // Buffer size must be an exact multiple of the max packet size for both
 // bulk  (up to 64 bytes for FS, 512 bytes for HS). In addation, this driver
 // imposes a minimum buffer size of 32 bytes.
@@ -88,7 +83,7 @@ tu_static char logMsg[150];
 
 // Interrupt endpoint buffer size, default to 2 bytes as USB488 specification.
 #ifndef CFG_TUD_USBTMC_INT_EP_SIZE
-#define CFG_TUD_USBTMC_INT_EP_SIZE 2
+  #define CFG_TUD_USBTMC_INT_EP_SIZE 2
 #endif
 
 /*
@@ -96,27 +91,26 @@ tu_static char logMsg[150];
  * consistent with USBTMC.
  */
 
-typedef enum
-{
-  STATE_CLOSED,  // Endpoints have not yet been opened since USB reset
-  STATE_NAK,     // Bulk-out endpoint is in NAK state.
-  STATE_IDLE,    // Bulk-out endpoint is waiting for CMD.
-  STATE_RCV,     // Bulk-out is receiving DEV_DEP message
+typedef enum {
+  STATE_CLOSED,// Endpoints have not yet been opened since USB reset
+  STATE_NAK,   // Bulk-out endpoint is in NAK state.
+  STATE_IDLE,  // Bulk-out endpoint is waiting for CMD.
+  STATE_RCV,   // Bulk-out is receiving DEV_DEP message
   STATE_TX_REQUESTED,
   STATE_TX_INITIATED,
   STATE_TX_SHORTED,
   STATE_CLEARING,
   STATE_ABORTING_BULK_IN,
-  STATE_ABORTING_BULK_IN_SHORTED, // aborting, and short packet has been queued for transmission
-  STATE_ABORTING_BULK_IN_ABORTED, // aborting, and short packet has been transmitted
+  STATE_ABORTING_BULK_IN_SHORTED,// aborting, and short packet has been queued for transmission
+  STATE_ABORTING_BULK_IN_ABORTED,// aborting, and short packet has been transmitted
   STATE_ABORTING_BULK_OUT,
   STATE_NUM_STATES
 } usbtmcd_state_enum;
 
 #if (CFG_TUD_USBTMC_ENABLE_488)
-  typedef usbtmc_response_capabilities_488_t usbtmc_capabilities_specific_t;
+typedef usbtmc_response_capabilities_488_t usbtmc_capabilities_specific_t;
 #else
-  typedef usbtmc_response_capabilities_t usbtmc_capabilities_specific_t;
+typedef usbtmc_response_capabilities_t usbtmc_capabilities_specific_t;
 #endif
 
 
@@ -131,15 +125,15 @@ typedef struct
   uint8_t ep_int_in;
   uint32_t ep_bulk_in_wMaxPacketSize;
   uint32_t ep_bulk_out_wMaxPacketSize;
-  uint32_t transfer_size_remaining; // also used for requested length for bulk IN.
-  uint32_t transfer_size_sent;      // To keep track of data bytes that have been queued in FIFO (not header bytes)
+  uint32_t transfer_size_remaining;// also used for requested length for bulk IN.
+  uint32_t transfer_size_sent;     // To keep track of data bytes that have been queued in FIFO (not header bytes)
 
-  uint8_t lastBulkOutTag; // used for aborts (mostly)
+  uint8_t lastBulkOutTag;// used for aborts (mostly)
   uint8_t lastBulkInTag; // used for aborts (mostly)
 
-  uint8_t const * devInBuffer; // pointer to application-layer used for transmissions
+  uint8_t const *devInBuffer;// pointer to application-layer used for transmissions
 
-  usbtmc_capabilities_specific_t const * capabilities;
+  usbtmc_capabilities_specific_t const *capabilities;
 } usbtmc_interface_state_t;
 
 typedef struct {
@@ -154,43 +148,62 @@ typedef struct {
 } usbtmc_epbuf_t;
 
 static usbtmc_interface_state_t usbtmc_state = {
-  .itf_id = 0xFF,
+    .itf_id = 0xFF,
 };
 
 CFG_TUD_MEM_SECTION static usbtmc_epbuf_t usbtmc_epbuf;
 
 // We need all headers to fit in a single packet in this implementation, 32 bytes will fit all standard USBTMC headers
-TU_VERIFY_STATIC(USBTMCD_BUFFER_SIZE >= 32u,"USBTMC dev buffer size too small");
+TU_VERIFY_STATIC(USBTMCD_BUFFER_SIZE >= 32u, "USBTMC dev buffer size too small");
 
 static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len);
 static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t packetLen);
 
+
+// USBTMC Device Callbacks weak implementations
+TU_ATTR_WEAK bool tud_usbtmc_notification_complete_cb(void) {
+  return true;
+}
+
+TU_ATTR_WEAK bool tud_usbtmc_indicator_pulse_cb(tusb_control_request_t const * msg, uint8_t *tmcResult) {
+  (void) msg;
+  (void) tmcResult;
+  return true;
+}
+
+#if (CFG_TUD_USBTMC_ENABLE_488)
+TU_ATTR_WEAK bool tud_usbtmc_msg_trigger_cb(usbtmc_msg_generic_t* msg) {
+  (void) msg;
+  return true;
+}
+#endif
+
 #ifndef NDEBUG
 tu_static uint8_t termChar;
 #endif
 
 tu_static uint8_t termCharRequested = false;
 
+tu_static bool usbtmcVendorSpecificRequested = false;
+
 #if OSAL_MUTEX_REQUIRED
 static OSAL_MUTEX_DEF(usbtmcLockBuffer);
 #endif
 osal_mutex_t usbtmcLock;
 
 // Our own private lock, mostly for the state variable.
-#define criticalEnter() do { (void) osal_mutex_lock(usbtmcLock,OSAL_TIMEOUT_WAIT_FOREVER); } while (0)
-#define criticalLeave() do { (void) osal_mutex_unlock(usbtmcLock); } while (0)
+#define criticalEnter() \
+  do { (void) osal_mutex_lock(usbtmcLock, OSAL_TIMEOUT_WAIT_FOREVER); } while (0)
+#define criticalLeave() \
+  do { (void) osal_mutex_unlock(usbtmcLock); } while (0)
 
-static bool atomicChangeState(usbtmcd_state_enum expectedState, usbtmcd_state_enum newState)
-{
+static bool atomicChangeState(usbtmcd_state_enum expectedState, usbtmcd_state_enum newState) {
   bool ret = true;
   criticalEnter();
   usbtmcd_state_enum oldState = usbtmc_state.state;
-  if (oldState == expectedState)
-  {
+  if (oldState == expectedState) {
     usbtmc_state.state = newState;
-  }
-  else
-  {
+  } else {
     ret = false;
   }
   criticalLeave();
@@ -205,54 +218,54 @@ static bool atomicChangeState(usbtmcd_state_enum expectedState, usbtmcd_state_en
 // We can't just send the whole thing at once because we need to concatanate the
 // header with the data.
 bool tud_usbtmc_transmit_dev_msg_data(
-    const void * data, size_t len,
+    const void *data, size_t len,
     bool endOfMessage,
-    bool usingTermChar)
-{
+    bool usingTermChar) {
   const unsigned int txBufLen = USBTMCD_BUFFER_SIZE;
 
 #ifndef NDEBUG
   TU_ASSERT(len > 0u);
   TU_ASSERT(len <= usbtmc_state.transfer_size_remaining);
   TU_ASSERT(usbtmc_state.transfer_size_sent == 0u);
-  if(usingTermChar)
-  {
+  if (usingTermChar) {
     TU_ASSERT(usbtmc_state.capabilities->bmDevCapabilities.canEndBulkInOnTermChar);
     TU_ASSERT(termCharRequested);
-    TU_ASSERT(((uint8_t const*)data)[len-1u] == termChar);
+    TU_ASSERT(((uint8_t const *) data)[len - 1u] == termChar);
   }
 #endif
 
   TU_VERIFY(usbtmc_state.state == STATE_TX_REQUESTED);
-  usbtmc_msg_dev_dep_msg_in_header_t *hdr = (usbtmc_msg_dev_dep_msg_in_header_t*)usbtmc_epbuf.epin;
+  usbtmc_msg_dev_dep_msg_in_header_t *hdr = (usbtmc_msg_dev_dep_msg_in_header_t *) usbtmc_epbuf.epin;
   tu_varclr(hdr);
-  hdr->header.MsgID = USBTMC_MSGID_DEV_DEP_MSG_IN;
+  if (usbtmcVendorSpecificRequested) {
+    hdr->header.MsgID = USBTMC_MSGID_VENDOR_SPECIFIC_IN;
+  } else {
+    hdr->header.MsgID = USBTMC_MSGID_DEV_DEP_MSG_IN;
+  }
   hdr->header.bTag = usbtmc_state.lastBulkInTag;
-  hdr->header.bTagInverse = (uint8_t)~(usbtmc_state.lastBulkInTag);
+  hdr->header.bTagInverse = (uint8_t) ~(usbtmc_state.lastBulkInTag);
   hdr->TransferSize = len;
   hdr->bmTransferAttributes.EOM = endOfMessage;
   hdr->bmTransferAttributes.UsingTermChar = usingTermChar;
 
   // Copy in the header
   const size_t headerLen = sizeof(*hdr);
-  const size_t dataLen = ((headerLen + hdr->TransferSize) <= txBufLen) ?
-                            len : (txBufLen - headerLen);
+  const size_t dataLen = ((headerLen + hdr->TransferSize) <= txBufLen) ? len : (txBufLen - headerLen);
   const size_t packetLen = headerLen + dataLen;
 
-  memcpy((uint8_t*)(usbtmc_epbuf.epin) + headerLen, data, dataLen);
+  memcpy((uint8_t *) (usbtmc_epbuf.epin) + headerLen, data, dataLen);
   usbtmc_state.transfer_size_remaining = len - dataLen;
   usbtmc_state.transfer_size_sent = dataLen;
-  usbtmc_state.devInBuffer = (uint8_t const*) data + (dataLen);
+  usbtmc_state.devInBuffer = (uint8_t const *) data + (dataLen);
 
   bool stateChanged =
       atomicChangeState(STATE_TX_REQUESTED, (packetLen >= txBufLen) ? STATE_TX_INITIATED : STATE_TX_SHORTED);
   TU_VERIFY(stateChanged);
-  TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t)packetLen));
+  TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) packetLen));
   return true;
 }
 
-bool tud_usbtmc_transmit_notification_data(const void * data, size_t len)
-{
+bool tud_usbtmc_transmit_notification_data(const void *data, size_t len) {
 #ifndef NDEBUG
   TU_ASSERT(len > 0);
   TU_ASSERT(usbtmc_state.ep_int_in != 0);
@@ -260,51 +273,43 @@ bool tud_usbtmc_transmit_notification_data(const void * data, size_t len)
   TU_VERIFY(usbd_edpt_busy(usbtmc_state.rhport, usbtmc_state.ep_int_in));
 
   TU_VERIFY(tu_memcpy_s(usbtmc_epbuf.epnotif, CFG_TUD_USBTMC_INT_EP_SIZE, data, len) == 0);
-  TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_int_in, usbtmc_epbuf.epnotif, (uint16_t)len));
+  TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_int_in, usbtmc_epbuf.epnotif, (uint16_t) len));
   return true;
 }
 
-void usbtmcd_init_cb(void)
-{
+void usbtmcd_init_cb(void) {
   usbtmc_state.capabilities = tud_usbtmc_get_capabilities_cb();
 #ifndef NDEBUG
-# if CFG_TUD_USBTMC_ENABLE_488
-  if (usbtmc_state.capabilities->bmIntfcCapabilities488.supportsTrigger) {
-    TU_ASSERT(&tud_usbtmc_msg_trigger_cb != NULL,);
-  }
+  #if CFG_TUD_USBTMC_ENABLE_488
   // Per USB488 spec: table 8
-  TU_ASSERT(!usbtmc_state.capabilities->bmIntfcCapabilities.listenOnly,);
-  TU_ASSERT(!usbtmc_state.capabilities->bmIntfcCapabilities.talkOnly,);
-# endif
-  if (usbtmc_state.capabilities->bmIntfcCapabilities.supportsIndicatorPulse) {
-    TU_ASSERT(&tud_usbtmc_indicator_pulse_cb != NULL,);
-  }
+  TU_ASSERT(!usbtmc_state.capabilities->bmIntfcCapabilities.listenOnly, );
+  TU_ASSERT(!usbtmc_state.capabilities->bmIntfcCapabilities.talkOnly, );
+  #endif
 #endif
 
   usbtmcLock = osal_mutex_create(&usbtmcLockBuffer);
 }
 
 bool usbtmcd_deinit(void) {
-  #if OSAL_MUTEX_REQUIRED
+#if OSAL_MUTEX_REQUIRED
   osal_mutex_delete(usbtmcLock);
-  #endif
+#endif
   return true;
 }
 
-uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uint16_t max_len)
-{
-  (void)rhport;
+uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+  (void) rhport;
 
   uint16_t drv_len;
-  uint8_t const * p_desc;
+  uint8_t const *p_desc;
   uint8_t found_endpoints = 0;
 
-  TU_VERIFY(itf_desc->bInterfaceClass    == TUD_USBTMC_APP_CLASS   , 0);
+  TU_VERIFY(itf_desc->bInterfaceClass == TUD_USBTMC_APP_CLASS, 0);
   TU_VERIFY(itf_desc->bInterfaceSubClass == TUD_USBTMC_APP_SUBCLASS, 0);
 
 #ifndef NDEBUG
   // Only 2 or 3 endpoints are allowed for USBTMC.
-  TU_ASSERT((itf_desc->bNumEndpoints == 2) || (itf_desc->bNumEndpoints ==3), 0);
+  TU_ASSERT((itf_desc->bNumEndpoints == 2) || (itf_desc->bNumEndpoints == 3), 0);
 #endif
 
   TU_ASSERT(usbtmc_state.state == STATE_CLOSED, 0);
@@ -316,17 +321,14 @@ uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc,
   usbtmc_state.itf_id = itf_desc->bInterfaceNumber;
   usbtmc_state.rhport = rhport;
 
-  while (found_endpoints < itf_desc->bNumEndpoints && drv_len <= max_len)
-  {
-    if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])
-    {
-      tusb_desc_endpoint_t const *ep_desc = (tusb_desc_endpoint_t const *)p_desc;
-      switch(ep_desc->bmAttributes.xfer) {
+  while (found_endpoints < itf_desc->bNumEndpoints && drv_len <= max_len) {
+    if (TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE]) {
+      tusb_desc_endpoint_t const *ep_desc = (tusb_desc_endpoint_t const *) p_desc;
+      switch (ep_desc->bmAttributes.xfer) {
         case TUSB_XFER_BULK:
           // Ensure  buffer is an exact multiple of the maxPacketSize
           TU_ASSERT((USBTMCD_BUFFER_SIZE % tu_edpt_packet_size(ep_desc)) == 0, 0);
-          if (tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN)
-          {
+          if (tu_edpt_dir(ep_desc->bEndpointAddress) == TUSB_DIR_IN) {
             usbtmc_state.ep_bulk_in = ep_desc->bEndpointAddress;
             usbtmc_state.ep_bulk_in_wMaxPacketSize = tu_edpt_packet_size(ep_desc);
           } else {
@@ -345,33 +347,29 @@ uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc,
         default:
           TU_ASSERT(false, 0);
       }
-      TU_ASSERT( usbd_edpt_open(rhport, ep_desc), 0);
+      TU_ASSERT(usbd_edpt_open(rhport, ep_desc), 0);
       found_endpoints++;
     }
 
     drv_len += tu_desc_len(p_desc);
-    p_desc   = tu_desc_next(p_desc);
+    p_desc = tu_desc_next(p_desc);
   }
 
-  // bulk endpoints are required, but interrupt IN is optional
+// bulk endpoints are required, but interrupt IN is optional
 #ifndef NDEBUG
-  TU_ASSERT(usbtmc_state.ep_bulk_in  != 0, 0);
+  TU_ASSERT(usbtmc_state.ep_bulk_in != 0, 0);
   TU_ASSERT(usbtmc_state.ep_bulk_out != 0, 0);
-  if (itf_desc->bNumEndpoints == 2)
-  {
+  if (itf_desc->bNumEndpoints == 2) {
     TU_ASSERT(usbtmc_state.ep_int_in == 0, 0);
-  }
-  else if (itf_desc->bNumEndpoints == 3)
-  {
+  } else if (itf_desc->bNumEndpoints == 3) {
     TU_ASSERT(usbtmc_state.ep_int_in != 0, 0);
   }
-#if (CFG_TUD_USBTMC_ENABLE_488)
-  if(usbtmc_state.capabilities->bmIntfcCapabilities488.is488_2 ||
-      usbtmc_state.capabilities->bmDevCapabilities488.SR1)
-  {
+  #if (CFG_TUD_USBTMC_ENABLE_488)
+  if (usbtmc_state.capabilities->bmIntfcCapabilities488.is488_2 ||
+      usbtmc_state.capabilities->bmDevCapabilities488.SR1) {
     TU_ASSERT(usbtmc_state.ep_int_in != 0, 0);
   }
-#endif
+  #endif
 #endif
   atomicChangeState(STATE_CLOSED, STATE_NAK);
   tud_usbtmc_open_cb(itf_desc->iInterface);
@@ -384,30 +382,27 @@ uint16_t usbtmcd_open_cb(uint8_t rhport, tusb_desc_interface_t const * itf_desc,
 // processing a command (such as a clear). Returns true if it was
 // in the NAK state and successfully transitioned to the ACK wait
 // state.
-bool tud_usbtmc_start_bus_read(void)
-{
+bool tud_usbtmc_start_bus_read(void) {
   usbtmcd_state_enum oldState = usbtmc_state.state;
-  switch(oldState)
-  {
-  // These may transition to IDLE
-  case STATE_NAK:
-  case STATE_ABORTING_BULK_IN_ABORTED:
-    TU_VERIFY(atomicChangeState(oldState, STATE_IDLE));
-    break;
-  // When receiving, let it remain receiving
-  case STATE_RCV:
-    break;
-  default:
-    return false;
+  switch (oldState) {
+    // These may transition to IDLE
+    case STATE_NAK:
+    case STATE_ABORTING_BULK_IN_ABORTED:
+      TU_VERIFY(atomicChangeState(oldState, STATE_IDLE));
+      break;
+    // When receiving, let it remain receiving
+    case STATE_RCV:
+      break;
+    default:
+      return false;
   }
-  TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_out, usbtmc_epbuf.epout, (uint16_t)usbtmc_state.ep_bulk_out_wMaxPacketSize));
+  TU_VERIFY(usbd_edpt_xfer(usbtmc_state.rhport, usbtmc_state.ep_bulk_out, usbtmc_epbuf.epout, (uint16_t) usbtmc_state.ep_bulk_out_wMaxPacketSize));
   return true;
 }
 
-void usbtmcd_reset_cb(uint8_t rhport)
-{
-  (void)rhport;
-  usbtmc_capabilities_specific_t const * capabilities = tud_usbtmc_get_capabilities_cb();
+void usbtmcd_reset_cb(uint8_t rhport) {
+  (void) rhport;
+  usbtmc_capabilities_specific_t const *capabilities = tud_usbtmc_get_capabilities_cb();
 
   criticalEnter();
   tu_varclr(&usbtmc_state);
@@ -416,35 +411,32 @@ void usbtmcd_reset_cb(uint8_t rhport)
   criticalLeave();
 }
 
-static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len)
-{
-  (void)rhport;
+static bool handle_devMsgOutStart(uint8_t rhport, void *data, size_t len) {
+  (void) rhport;
   // return true upon failure, as we can assume error is being handled elsewhere.
   TU_VERIFY(atomicChangeState(STATE_IDLE, STATE_RCV), true);
   usbtmc_state.transfer_size_sent = 0u;
 
   // must be a header, should have been confirmed before calling here.
-  usbtmc_msg_request_dev_dep_out *msg = (usbtmc_msg_request_dev_dep_out*)data;
+  usbtmc_msg_request_dev_dep_out *msg = (usbtmc_msg_request_dev_dep_out *) data;
   usbtmc_state.transfer_size_remaining = msg->TransferSize;
   TU_VERIFY(tud_usbtmc_msgBulkOut_start_cb(msg));
 
-  TU_VERIFY(handle_devMsgOut(rhport, (uint8_t*)data + sizeof(*msg), len - sizeof(*msg), len));
+  TU_VERIFY(handle_devMsgOut(rhport, (uint8_t *) data + sizeof(*msg), len - sizeof(*msg), len));
   usbtmc_state.lastBulkOutTag = msg->header.bTag;
   return true;
 }
 
-static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t packetLen)
-{
-  (void)rhport;
+static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t packetLen) {
+  (void) rhport;
   // return true upon failure, as we can assume error is being handled elsewhere.
-  TU_VERIFY(usbtmc_state.state == STATE_RCV,true);
+  TU_VERIFY(usbtmc_state.state == STATE_RCV, true);
 
   bool shortPacket = (packetLen < usbtmc_state.ep_bulk_out_wMaxPacketSize);
 
   // Packet is to be considered complete when we get enough data or at a short packet.
   bool atEnd = false;
-  if(len >= usbtmc_state.transfer_size_remaining || shortPacket)
-  {
+  if (len >= usbtmc_state.transfer_size_remaining || shortPacket) {
     atEnd = true;
     TU_VERIFY(atomicChangeState(STATE_RCV, STATE_NAK));
   }
@@ -455,8 +447,7 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
   usbtmc_state.transfer_size_sent += len;
 
   // App may (should?) call the wait_for_bus() command at this point
-  if(!tud_usbtmc_msg_data_cb(data, len, atEnd))
-  {
+  if (!tud_usbtmc_msg_data_cb(data, len, atEnd)) {
     // TODO: Go to an error state upon failure other than just stalling the EP?
     return false;
   }
@@ -465,10 +456,9 @@ static bool handle_devMsgOut(uint8_t rhport, void *data, size_t len, size_t pack
   return true;
 }
 
-static bool handle_devMsgIn(void *data, size_t len)
-{
+static bool handle_devMsgIn(void *data, size_t len) {
   TU_VERIFY(len == sizeof(usbtmc_msg_request_dev_dep_in));
-  usbtmc_msg_request_dev_dep_in *msg = (usbtmc_msg_request_dev_dep_in*)data;
+  usbtmc_msg_request_dev_dep_in *msg = (usbtmc_msg_request_dev_dep_in *) data;
   bool stateChanged = atomicChangeState(STATE_IDLE, STATE_TX_REQUESTED);
   TU_VERIFY(stateChanged);
   usbtmc_state.lastBulkInTag = msg->header.bTag;
@@ -481,137 +471,136 @@ static bool handle_devMsgIn(void *data, size_t len)
   termChar = msg->TermChar;
 #endif
 
-  if(termCharRequested)
+  if (termCharRequested)
     TU_VERIFY(usbtmc_state.capabilities->bmDevCapabilities.canEndBulkInOnTermChar);
 
   TU_VERIFY(tud_usbtmc_msgBulkIn_request_cb(msg));
   return true;
 }
 
-bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
-{
+bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
   TU_VERIFY(result == XFER_RESULT_SUCCESS);
   //uart_tx_str_sync("TMC XFER CB\r\n");
-  if(usbtmc_state.state == STATE_CLEARING) {
+  if (usbtmc_state.state == STATE_CLEARING) {
     return true; /* I think we can ignore everything here */
   }
 
-  if(ep_addr == usbtmc_state.ep_bulk_out)
-  {
+  if (ep_addr == usbtmc_state.ep_bulk_out) {
     usbtmc_msg_generic_t *msg = NULL;
 
-    switch(usbtmc_state.state)
-    {
-    case STATE_IDLE:
-      {
+    switch (usbtmc_state.state) {
+      case STATE_IDLE: {
         TU_VERIFY(xferred_bytes >= sizeof(usbtmc_msg_generic_t));
-        msg = (usbtmc_msg_generic_t*)(usbtmc_epbuf.epout);
-        uint8_t invInvTag = (uint8_t)~(msg->header.bTagInverse);
+        msg = (usbtmc_msg_generic_t *) (usbtmc_epbuf.epout);
+        uint8_t invInvTag = (uint8_t) ~(msg->header.bTagInverse);
         TU_VERIFY(msg->header.bTag == invInvTag);
         TU_VERIFY(msg->header.bTag != 0x00);
 
-        switch(msg->header.MsgID) {
-        case USBTMC_MSGID_DEV_DEP_MSG_OUT:
-          if(!handle_devMsgOutStart(rhport, msg, xferred_bytes))
-          {
-            usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
-            return false;
-          }
-          break;
+        switch (msg->header.MsgID) {
+          case USBTMC_MSGID_DEV_DEP_MSG_OUT:
+            usbtmcVendorSpecificRequested = false;
+            if (!handle_devMsgOutStart(rhport, msg, xferred_bytes)) {
+              usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
+              return false;
+            }
+            break;
 
-        case USBTMC_MSGID_DEV_DEP_MSG_IN:
-          TU_VERIFY(handle_devMsgIn(msg, xferred_bytes));
-          break;
+          case USBTMC_MSGID_DEV_DEP_MSG_IN:
+            usbtmcVendorSpecificRequested = false;
+            TU_VERIFY(handle_devMsgIn(msg, xferred_bytes));
+            break;
 
 #if (CFG_TUD_USBTMC_ENABLE_488)
-        case USBTMC_MSGID_USB488_TRIGGER:
-          // Spec says we halt the EP if we didn't declare we support it.
-          TU_VERIFY(usbtmc_state.capabilities->bmIntfcCapabilities488.supportsTrigger);
-          TU_VERIFY(tud_usbtmc_msg_trigger_cb(msg));
+          case USBTMC_MSGID_USB488_TRIGGER:
+            // Spec says we halt the EP if we didn't declare we support it.
+            TU_VERIFY(usbtmc_state.capabilities->bmIntfcCapabilities488.supportsTrigger);
+            TU_VERIFY(tud_usbtmc_msg_trigger_cb(msg));
 
-          break;
+            break;
 #endif
-        case USBTMC_MSGID_VENDOR_SPECIFIC_MSG_OUT:
-        case USBTMC_MSGID_VENDOR_SPECIFIC_IN:
-        default:
+          case USBTMC_MSGID_VENDOR_SPECIFIC_MSG_OUT:
+            usbtmcVendorSpecificRequested = true;
+            if (!handle_devMsgOutStart(rhport, msg, xferred_bytes)) {
+              usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
+              return false;
+            }
+            break;
+
+          case USBTMC_MSGID_VENDOR_SPECIFIC_IN:
+            usbtmcVendorSpecificRequested = true;
+            TU_VERIFY(handle_devMsgIn(msg, xferred_bytes));
+            break;
+
+          default:
+            usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
+            return false;
+        }
+        return true;
+      }
+      case STATE_RCV:
+        if (!handle_devMsgOut(rhport, usbtmc_epbuf.epout, xferred_bytes, xferred_bytes)) {
           usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
           return false;
         }
         return true;
-      }
-    case STATE_RCV:
-      if(!handle_devMsgOut(rhport, usbtmc_epbuf.epout, xferred_bytes, xferred_bytes))
-      {
-        usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
-        return false;
-      }
-      return true;
 
-    case STATE_ABORTING_BULK_OUT:
-      // Should be stalled by now, shouldn't have received a packet.
-      return false;
+      case STATE_ABORTING_BULK_OUT:
+        // Should be stalled by now, shouldn't have received a packet.
+        return false;
 
-    case STATE_TX_REQUESTED:
-    case STATE_TX_INITIATED:
-    case STATE_ABORTING_BULK_IN:
-    case STATE_ABORTING_BULK_IN_SHORTED:
-    case STATE_ABORTING_BULK_IN_ABORTED:
-    default:
-      return false;
+      case STATE_TX_REQUESTED:
+      case STATE_TX_INITIATED:
+      case STATE_ABORTING_BULK_IN:
+      case STATE_ABORTING_BULK_IN_SHORTED:
+      case STATE_ABORTING_BULK_IN_ABORTED:
+      default:
+        return false;
     }
-  }
-  else if(ep_addr == usbtmc_state.ep_bulk_in)
-  {
-    switch(usbtmc_state.state) {
-    case STATE_TX_SHORTED:
-      TU_VERIFY(atomicChangeState(STATE_TX_SHORTED, STATE_NAK));
-      TU_VERIFY(tud_usbtmc_msgBulkIn_complete_cb());
-      break;
+  } else if (ep_addr == usbtmc_state.ep_bulk_in) {
+    switch (usbtmc_state.state) {
+      case STATE_TX_SHORTED:
+        TU_VERIFY(atomicChangeState(STATE_TX_SHORTED, STATE_NAK));
+        TU_VERIFY(tud_usbtmc_msgBulkIn_complete_cb());
+        break;
 
-    case STATE_TX_INITIATED:
-      if(usbtmc_state.transfer_size_remaining >= USBTMCD_BUFFER_SIZE)
-      {
-        // Copy buffer to ensure alignment correctness
-        memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, USBTMCD_BUFFER_SIZE);
-        TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, USBTMCD_BUFFER_SIZE));
-        usbtmc_state.devInBuffer += USBTMCD_BUFFER_SIZE;
-        usbtmc_state.transfer_size_remaining -= USBTMCD_BUFFER_SIZE;
-        usbtmc_state.transfer_size_sent += USBTMCD_BUFFER_SIZE;
-      }
-      else // last packet
-      {
-        size_t packetLen = usbtmc_state.transfer_size_remaining;
-        memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining);
-          usbtmc_state.transfer_size_sent += sizeof(usbtmc_state.transfer_size_remaining);
-        usbtmc_state.transfer_size_remaining = 0;
-        usbtmc_state.devInBuffer = NULL;
-        TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t)packetLen) );
-        if(((packetLen % usbtmc_state.ep_bulk_in_wMaxPacketSize) != 0) || (packetLen == 0 ))
+      case STATE_TX_INITIATED:
+        if (usbtmc_state.transfer_size_remaining >= USBTMCD_BUFFER_SIZE) {
+          // Copy buffer to ensure alignment correctness
+          memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, USBTMCD_BUFFER_SIZE);
+          TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, USBTMCD_BUFFER_SIZE));
+          usbtmc_state.devInBuffer += USBTMCD_BUFFER_SIZE;
+          usbtmc_state.transfer_size_remaining -= USBTMCD_BUFFER_SIZE;
+          usbtmc_state.transfer_size_sent += USBTMCD_BUFFER_SIZE;
+        } else// last packet
         {
-          usbtmc_state.state = STATE_TX_SHORTED;
+          size_t packetLen = usbtmc_state.transfer_size_remaining;
+          memcpy(usbtmc_epbuf.epin, usbtmc_state.devInBuffer, usbtmc_state.transfer_size_remaining);
+          usbtmc_state.transfer_size_sent += packetLen;
+          usbtmc_state.transfer_size_remaining = 0;
+          usbtmc_state.devInBuffer = NULL;
+          TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) packetLen));
+          if (((packetLen % usbtmc_state.ep_bulk_in_wMaxPacketSize) != 0) || (packetLen == 0)) {
+            usbtmc_state.state = STATE_TX_SHORTED;
+          }
         }
-      }
-      return true;
+        return true;
 
-    case STATE_ABORTING_BULK_IN:
-      // need to send short packet  (ZLP?)
-      TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin,(uint16_t)0u));
-      usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
-      return true;
+      case STATE_ABORTING_BULK_IN:
+        // need to send short packet  (ZLP?)
+        TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) 0u));
+        usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
+        return true;
 
-    case STATE_ABORTING_BULK_IN_SHORTED:
-      /* Done. :)*/
-      usbtmc_state.state = STATE_ABORTING_BULK_IN_ABORTED;
-      return true;
+      case STATE_ABORTING_BULK_IN_SHORTED:
+        /* Done. :)*/
+        usbtmc_state.state = STATE_ABORTING_BULK_IN_ABORTED;
+        return true;
 
-    default:
-      TU_ASSERT(false);
-    }
-  }
-  else if (ep_addr == usbtmc_state.ep_int_in) {
-    if (tud_usbtmc_notification_complete_cb) {
-      TU_VERIFY(tud_usbtmc_notification_complete_cb());
+      default:
+        TU_ASSERT(false);
     }
+  } else if (ep_addr == usbtmc_state.ep_int_in) {
+    TU_VERIFY(tud_usbtmc_notification_complete_cb());
     return true;
   }
   return false;
@@ -620,188 +609,157 @@ bool usbtmcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
 // Invoked when a control transfer occurred on an interface of this class
 // Driver response accordingly to the request and the transfer stage (setup/data/ack)
 // return false to stall control endpoint (e.g unsupported request)
-bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
-{
+bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const *request) {
   // nothing to do with DATA and ACK stage
-  if ( stage != CONTROL_STAGE_SETUP ) return true;
+  if (stage != CONTROL_STAGE_SETUP) return true;
 
   uint8_t tmcStatusCode = USBTMC_STATUS_FAILED;
 #if (CFG_TUD_USBTMC_ENABLE_488)
   uint8_t bTag;
 #endif
 
-  if((request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD) &&
+  if ((request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD) &&
       (request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_ENDPOINT) &&
       (request->bRequest == TUSB_REQ_CLEAR_FEATURE) &&
-      (request->wValue == TUSB_REQ_FEATURE_EDPT_HALT))
-  {
+      (request->wValue == TUSB_REQ_FEATURE_EDPT_HALT)) {
     uint32_t ep_addr = (request->wIndex);
 
     // At this point, a transfer MAY be in progress. Based on USB spec, when clearing bulk EP HALT,
     // the EP transfer buffer needs to be cleared and DTOG needs to be reset, even if
     // the EP is not halted. The only USBD API interface to do this is to stall and then un-stall the EP.
-    if(ep_addr == usbtmc_state.ep_bulk_out)
-    {
+    if (ep_addr == usbtmc_state.ep_bulk_out) {
       criticalEnter();
-      usbd_edpt_stall(rhport, (uint8_t)ep_addr);
-      usbd_edpt_clear_stall(rhport, (uint8_t)ep_addr);
-      usbtmc_state.state = STATE_NAK; // USBD core has placed EP in NAK state for us
+      usbd_edpt_stall(rhport, (uint8_t) ep_addr);
+      usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr);
+      usbtmc_state.state = STATE_NAK;// USBD core has placed EP in NAK state for us
       criticalLeave();
       tud_usbtmc_bulkOut_clearFeature_cb();
-    }
-    else if (ep_addr == usbtmc_state.ep_bulk_in)
-    {
-      usbd_edpt_stall(rhport, (uint8_t)ep_addr);
-      usbd_edpt_clear_stall(rhport, (uint8_t)ep_addr);
+    } else if (ep_addr == usbtmc_state.ep_bulk_in) {
+      usbd_edpt_stall(rhport, (uint8_t) ep_addr);
+      usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr);
       tud_usbtmc_bulkIn_clearFeature_cb();
-    }
-    else if ((usbtmc_state.ep_int_in != 0) && (ep_addr == usbtmc_state.ep_int_in))
-    {
+    } else if ((usbtmc_state.ep_int_in != 0) && (ep_addr == usbtmc_state.ep_int_in)) {
       // Clearing interrupt in EP
-      usbd_edpt_stall(rhport, (uint8_t)ep_addr);
-      usbd_edpt_clear_stall(rhport, (uint8_t)ep_addr);
-    }
-     else
-    {
+      usbd_edpt_stall(rhport, (uint8_t) ep_addr);
+      usbd_edpt_clear_stall(rhport, (uint8_t) ep_addr);
+    } else {
       return false;
     }
     return true;
   }
 
   // Otherwise, we only handle class requests.
-  if(request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS)
-  {
+  if (request->bmRequestType_bit.type != TUSB_REQ_TYPE_CLASS) {
     return false;
   }
 
   // Verification that we own the interface is unneeded since it's been routed to us specifically.
 
-  switch(request->bRequest)
-  {
-  // USBTMC required requests
-  case USBTMC_bREQUEST_INITIATE_ABORT_BULK_OUT:
-  {
-    usbtmc_initiate_abort_rsp_t rsp = {
-        .bTag = usbtmc_state.lastBulkOutTag,
-    };
-    TU_VERIFY(request->bmRequestType == 0xA2); // in,class,interface
-    TU_VERIFY(request->wLength == sizeof(rsp));
-    TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
+  switch (request->bRequest) {
+    // USBTMC required requests
+    case USBTMC_bREQUEST_INITIATE_ABORT_BULK_OUT: {
+      usbtmc_initiate_abort_rsp_t rsp = {
+          .bTag = usbtmc_state.lastBulkOutTag,
+      };
+      TU_VERIFY(request->bmRequestType == 0xA2);// in,class,interface
+      TU_VERIFY(request->wLength == sizeof(rsp));
+      TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
 
-    // wValue is the requested bTag to abort
-    if(usbtmc_state.state != STATE_RCV)
-    {
-      rsp.USBTMC_status = USBTMC_STATUS_FAILED;
+      // wValue is the requested bTag to abort
+      if (usbtmc_state.state != STATE_RCV) {
+        rsp.USBTMC_status = USBTMC_STATUS_FAILED;
+      } else if (usbtmc_state.lastBulkOutTag == (request->wValue & 0x7Fu)) {
+        rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
+      } else {
+        rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
+        // Check if we've queued a short packet
+        criticalEnter();
+        usbtmc_state.state = STATE_ABORTING_BULK_OUT;
+        criticalLeave();
+        TU_VERIFY(tud_usbtmc_initiate_abort_bulk_out_cb(&(rsp.USBTMC_status)));
+        usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
+      }
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp)));
+      return true;
     }
-    else if(usbtmc_state.lastBulkOutTag == (request->wValue & 0x7Fu))
-    {
-      rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
+
+    case USBTMC_bREQUEST_CHECK_ABORT_BULK_OUT_STATUS: {
+      usbtmc_check_abort_bulk_rsp_t rsp = {
+          .USBTMC_status = USBTMC_STATUS_SUCCESS,
+          .NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent};
+      TU_VERIFY(request->bmRequestType == 0xA2);// in,class,EP
+      TU_VERIFY(request->wLength == sizeof(rsp));
+      TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
+      TU_VERIFY(tud_usbtmc_check_abort_bulk_out_cb(&rsp));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp)));
+      return true;
     }
-    else
-    {
-      rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
-      // Check if we've queued a short packet
-      criticalEnter();
-      usbtmc_state.state = STATE_ABORTING_BULK_OUT;
-      criticalLeave();
-      TU_VERIFY(tud_usbtmc_initiate_abort_bulk_out_cb(&(rsp.USBTMC_status)));
-      usbd_edpt_stall(rhport, usbtmc_state.ep_bulk_out);
+
+    case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN: {
+      usbtmc_initiate_abort_rsp_t rsp = {
+          .bTag = usbtmc_state.lastBulkInTag,
+      };
+      TU_VERIFY(request->bmRequestType == 0xA2);// in,class,interface
+      TU_VERIFY(request->wLength == sizeof(rsp));
+      TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_in);
+      // wValue is the requested bTag to abort
+      if ((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED) &&
+          usbtmc_state.lastBulkInTag == (request->wValue & 0x7Fu)) {
+        rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
+        usbtmc_state.transfer_size_remaining = 0u;
+        // Check if we've queued a short packet
+        criticalEnter();
+        usbtmc_state.state = ((usbtmc_state.transfer_size_sent % usbtmc_state.ep_bulk_in_wMaxPacketSize) == 0) ? STATE_ABORTING_BULK_IN : STATE_ABORTING_BULK_IN_SHORTED;
+        criticalLeave();
+        if (usbtmc_state.transfer_size_sent == 0) {
+          // Send short packet, nothing is in the buffer yet
+          TU_VERIFY(usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin, (uint16_t) 0u));
+          usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
+        }
+        TU_VERIFY(tud_usbtmc_initiate_abort_bulk_in_cb(&(rsp.USBTMC_status)));
+      } else if ((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED)) {// FIXME: Unsure how to check  if the OUT endpoint fifo is non-empty....
+        rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
+      } else {
+        rsp.USBTMC_status = USBTMC_STATUS_FAILED;
+      }
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp)));
+      return true;
     }
-    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp)));
-    return true;
-  }
 
-  case USBTMC_bREQUEST_CHECK_ABORT_BULK_OUT_STATUS:
-  {
-    usbtmc_check_abort_bulk_rsp_t rsp = {
-        .USBTMC_status = USBTMC_STATUS_SUCCESS,
-        .NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent
-    };
-    TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
-    TU_VERIFY(request->wLength == sizeof(rsp));
-    TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_out);
-    TU_VERIFY(tud_usbtmc_check_abort_bulk_out_cb(&rsp));
-    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp)));
-    return true;
-  }
+    case USBTMC_bREQUEST_CHECK_ABORT_BULK_IN_STATUS: {
+      TU_VERIFY(request->bmRequestType == 0xA2);// in,class,EP
+      TU_VERIFY(request->wLength == 8u);
 
-  case USBTMC_bREQUEST_INITIATE_ABORT_BULK_IN:
-  {
-    usbtmc_initiate_abort_rsp_t rsp = {
-        .bTag = usbtmc_state.lastBulkInTag,
-    };
-    TU_VERIFY(request->bmRequestType == 0xA2); // in,class,interface
-    TU_VERIFY(request->wLength == sizeof(rsp));
-    TU_VERIFY(request->wIndex == usbtmc_state.ep_bulk_in);
-    // wValue is the requested bTag to abort
-    if((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED) &&
-        usbtmc_state.lastBulkInTag == (request->wValue & 0x7Fu))
-    {
-      rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
-    usbtmc_state.transfer_size_remaining = 0u;
-      // Check if we've queued a short packet
+      usbtmc_check_abort_bulk_rsp_t rsp =
+          {
+              .USBTMC_status = USBTMC_STATUS_FAILED,
+              .bmAbortBulkIn =
+                  {
+                      .BulkInFifoBytes = (usbtmc_state.state != STATE_ABORTING_BULK_IN_ABORTED)},
+              .NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent,
+          };
+      TU_VERIFY(tud_usbtmc_check_abort_bulk_in_cb(&rsp));
       criticalEnter();
-      usbtmc_state.state = ((usbtmc_state.transfer_size_sent % usbtmc_state.ep_bulk_in_wMaxPacketSize) == 0) ?
-              STATE_ABORTING_BULK_IN : STATE_ABORTING_BULK_IN_SHORTED;
-      criticalLeave();
-      if(usbtmc_state.transfer_size_sent  == 0)
-      {
-        // Send short packet, nothing is in the buffer yet
-        TU_VERIFY( usbd_edpt_xfer(rhport, usbtmc_state.ep_bulk_in, usbtmc_epbuf.epin,(uint16_t)0u));
-        usbtmc_state.state = STATE_ABORTING_BULK_IN_SHORTED;
+      switch (usbtmc_state.state) {
+        case STATE_ABORTING_BULK_IN_ABORTED:
+          rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
+          usbtmc_state.state = STATE_IDLE;
+          break;
+        case STATE_ABORTING_BULK_IN:
+        case STATE_ABORTING_BULK_OUT:
+          rsp.USBTMC_status = USBTMC_STATUS_PENDING;
+          break;
+        default:
+          break;
       }
-      TU_VERIFY(tud_usbtmc_initiate_abort_bulk_in_cb(&(rsp.USBTMC_status)));
-    }
-    else if((usbtmc_state.state == STATE_TX_REQUESTED || usbtmc_state.state == STATE_TX_INITIATED))
-    { // FIXME: Unsure how to check  if the OUT endpoint fifo is non-empty....
-      rsp.USBTMC_status = USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
-    }
-    else
-    {
-      rsp.USBTMC_status = USBTMC_STATUS_FAILED;
-    }
-    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp)));
-    return true;
-  }
-
-  case USBTMC_bREQUEST_CHECK_ABORT_BULK_IN_STATUS:
-  {
-    TU_VERIFY(request->bmRequestType == 0xA2); // in,class,EP
-    TU_VERIFY(request->wLength == 8u);
+      criticalLeave();
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp)));
 
-    usbtmc_check_abort_bulk_rsp_t rsp =
-    {
-        .USBTMC_status = USBTMC_STATUS_FAILED,
-        .bmAbortBulkIn =
-        {
-            .BulkInFifoBytes = (usbtmc_state.state != STATE_ABORTING_BULK_IN_ABORTED)
-        },
-        .NBYTES_RXD_TXD = usbtmc_state.transfer_size_sent,
-    };
-    TU_VERIFY(tud_usbtmc_check_abort_bulk_in_cb(&rsp));
-    criticalEnter();
-    switch(usbtmc_state.state)
-    {
-    case STATE_ABORTING_BULK_IN_ABORTED:
-      rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
-      usbtmc_state.state = STATE_IDLE;
-      break;
-    case STATE_ABORTING_BULK_IN:
-    case STATE_ABORTING_BULK_OUT:
-      rsp.USBTMC_status = USBTMC_STATUS_PENDING;
-      break;
-    default:
-      break;
+      return true;
     }
-    criticalLeave();
-    TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp,sizeof(rsp)));
 
-    return true;
-  }
-
-  case USBTMC_bREQUEST_INITIATE_CLEAR:
-    {
-      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+    case USBTMC_bREQUEST_INITIATE_CLEAR: {
+      TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
       TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
       // After receiving an INITIATE_CLEAR request, the device must Halt the Bulk-OUT endpoint, queue the
       // control endpoint response shown in Table 31, and clear all input buffers and output buffers.
@@ -811,112 +769,97 @@ bool usbtmcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request
       usbtmc_state.state = STATE_CLEARING;
       criticalLeave();
       TU_VERIFY(tud_usbtmc_initiate_clear_cb(&tmcStatusCode));
-      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode,sizeof(tmcStatusCode)));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &tmcStatusCode, sizeof(tmcStatusCode)));
       return true;
     }
 
-  case USBTMC_bREQUEST_CHECK_CLEAR_STATUS:
-    {
-      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+    case USBTMC_bREQUEST_CHECK_CLEAR_STATUS: {
+      TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
       usbtmc_get_clear_status_rsp_t clearStatusRsp = {0};
       TU_VERIFY(request->wLength == sizeof(clearStatusRsp));
 
-      if(usbd_edpt_busy(rhport, usbtmc_state.ep_bulk_in))
-      {
+      if (usbd_edpt_busy(rhport, usbtmc_state.ep_bulk_in)) {
         // Stuff stuck in TX buffer?
         clearStatusRsp.bmClear.BulkInFifoBytes = 1;
         clearStatusRsp.USBTMC_status = USBTMC_STATUS_PENDING;
-      }
-      else
-      {
+      } else {
         // Let app check if it's clear
         TU_VERIFY(tud_usbtmc_check_clear_cb(&clearStatusRsp));
       }
-      if(clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS)
-      {
+      if (clearStatusRsp.USBTMC_status == USBTMC_STATUS_SUCCESS) {
         criticalEnter();
         usbtmc_state.state = STATE_IDLE;
         criticalLeave();
       }
-      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&clearStatusRsp,sizeof(clearStatusRsp)));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &clearStatusRsp, sizeof(clearStatusRsp)));
       return true;
     }
 
-  case USBTMC_bREQUEST_GET_CAPABILITIES:
-    {
-      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+    case USBTMC_bREQUEST_GET_CAPABILITIES: {
+      TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
       TU_VERIFY(request->wLength == sizeof(*(usbtmc_state.capabilities)));
-      TU_VERIFY(tud_control_xfer(rhport, request, (void*)(uintptr_t) usbtmc_state.capabilities, sizeof(*usbtmc_state.capabilities)));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) (uintptr_t) usbtmc_state.capabilities, sizeof(*usbtmc_state.capabilities)));
       return true;
     }
-  // USBTMC Optional Requests
+      // USBTMC Optional Requests
 
-  case USBTMC_bREQUEST_INDICATOR_PULSE: // Optional
+    case USBTMC_bREQUEST_INDICATOR_PULSE:// Optional
     {
-      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
       TU_VERIFY(request->wLength == sizeof(tmcStatusCode));
       TU_VERIFY(usbtmc_state.capabilities->bmIntfcCapabilities.supportsIndicatorPulse);
       TU_VERIFY(tud_usbtmc_indicator_pulse_cb(request, &tmcStatusCode));
-      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&tmcStatusCode, sizeof(tmcStatusCode)));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &tmcStatusCode, sizeof(tmcStatusCode)));
       return true;
     }
 #if (CFG_TUD_USBTMC_ENABLE_488)
 
-    // USB488 required requests
-  case USB488_bREQUEST_READ_STATUS_BYTE:
-    {
+      // USB488 required requests
+    case USB488_bREQUEST_READ_STATUS_BYTE: {
       usbtmc_read_stb_rsp_488_t rsp;
       TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
-      TU_VERIFY(request->wLength == sizeof(rsp)); // in,class,interface
+      TU_VERIFY(request->wLength == sizeof(rsp));// in,class,interface
 
       bTag = request->wValue & 0x7F;
       TU_VERIFY(request->bmRequestType == 0xA1);
-      TU_VERIFY((request->wValue & (~0x7F)) == 0u); // Other bits are required to be zero (USB488v1.0 Table 11)
+      TU_VERIFY((request->wValue & (~0x7F)) == 0u);// Other bits are required to be zero (USB488v1.0 Table 11)
       TU_VERIFY(bTag >= 0x02 && bTag <= 127);
       TU_VERIFY(request->wIndex == usbtmc_state.itf_id);
       TU_VERIFY(request->wLength == 0x0003);
-      rsp.bTag = (uint8_t)bTag;
-      if(usbtmc_state.ep_int_in != 0)
-      {
-        rsp.statusByte = 0x00; // Use interrupt endpoint, instead. Must be 0x00 (USB488v1.0 4.3.1.2)
-        if(usbd_edpt_busy(rhport, usbtmc_state.ep_int_in))
-        {
+      rsp.bTag = (uint8_t) bTag;
+      if (usbtmc_state.ep_int_in != 0) {
+        rsp.statusByte = 0x00;// Use interrupt endpoint, instead. Must be 0x00 (USB488v1.0 4.3.1.2)
+        if (usbd_edpt_busy(rhport, usbtmc_state.ep_int_in)) {
           rsp.USBTMC_status = USB488_STATUS_INTERRUPT_IN_BUSY;
-        }
-        else
-        {
+        } else {
           rsp.USBTMC_status = USBTMC_STATUS_SUCCESS;
           usbtmc_read_stb_interrupt_488_t intMsg =
-          {
-            .bNotify1 = {
-                .one = 1,
-                .bTag = bTag & 0x7Fu,
-            },
-            .StatusByte = tud_usbtmc_get_stb_cb(&(rsp.USBTMC_status))
-          };
+              {
+                  .bNotify1 = {
+                      .one = 1,
+                      .bTag = bTag & 0x7Fu,
+                  },
+                  .StatusByte = tud_usbtmc_get_stb_cb(&(rsp.USBTMC_status))};
           // Must be queued before control request response sent (USB488v1.0 4.3.1.2)
-          usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void*)&intMsg, sizeof(intMsg));
+          usbd_edpt_xfer(rhport, usbtmc_state.ep_int_in, (void *) &intMsg, sizeof(intMsg));
         }
-      }
-      else
-      {
+      } else {
         rsp.statusByte = tud_usbtmc_get_stb_cb(&(rsp.USBTMC_status));
       }
-      TU_VERIFY(tud_control_xfer(rhport, request, (void*)&rsp, sizeof(rsp)));
+      TU_VERIFY(tud_control_xfer(rhport, request, (void *) &rsp, sizeof(rsp)));
       return true;
     }
-    // USB488 optional requests
-  case USB488_bREQUEST_REN_CONTROL:
-  case USB488_bREQUEST_GO_TO_LOCAL:
-  case USB488_bREQUEST_LOCAL_LOCKOUT:
-    {
-      TU_VERIFY(request->bmRequestType == 0xA1); // in,class,interface
+      // USB488 optional requests
+    case USB488_bREQUEST_REN_CONTROL:
+    case USB488_bREQUEST_GO_TO_LOCAL:
+    case USB488_bREQUEST_LOCAL_LOCKOUT: {
+      TU_VERIFY(request->bmRequestType == 0xA1);// in,class,interface
       return false;
     }
 #endif
 
-  default:
-    return false;
+    default:
+      return false;
   }
 }
 
diff --git a/src/class/usbtmc/usbtmc_device.h b/src/class/usbtmc/usbtmc_device.h
index b85ef12b5..235f1276e 100644
--- a/src/class/usbtmc/usbtmc_device.h
+++ b/src/class/usbtmc/usbtmc_device.h
@@ -75,15 +75,14 @@ bool tud_usbtmc_check_clear_cb(usbtmc_get_clear_status_rsp_t *rsp);
 
 // The interrupt-IN endpoint buffer was transmitted to the host. Use
 // tud_usbtmc_transmit_notification_data to send another notification.
-TU_ATTR_WEAK bool tud_usbtmc_notification_complete_cb(void);
+bool tud_usbtmc_notification_complete_cb(void);
 
 // Indicator pulse should be 0.5 to 1.0 seconds long
-TU_ATTR_WEAK bool tud_usbtmc_indicator_pulse_cb(tusb_control_request_t const * msg, uint8_t *tmcResult);
+bool tud_usbtmc_indicator_pulse_cb(tusb_control_request_t const * msg, uint8_t *tmcResult);
 
 #if (CFG_TUD_USBTMC_ENABLE_488)
 uint8_t tud_usbtmc_get_stb_cb(uint8_t *tmcResult);
-TU_ATTR_WEAK bool tud_usbtmc_msg_trigger_cb(usbtmc_msg_generic_t* msg);
-//TU_ATTR_WEAK bool tud_usbtmc_app_go_to_local_cb();
+bool tud_usbtmc_msg_trigger_cb(usbtmc_msg_generic_t* msg);
 #endif
 
 // Called from app
diff --git a/src/class/vendor/vendor_device.c b/src/class/vendor/vendor_device.c
index 2fc0ac944..7da4d2239 100644
--- a/src/class/vendor/vendor_device.c
+++ b/src/class/vendor/vendor_device.c
@@ -67,6 +67,20 @@ typedef struct {
 
 CFG_TUD_MEM_SECTION static vendord_epbuf_t _vendord_epbuf[CFG_TUD_VENDOR];
 
+//--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_vendor_rx_cb(uint8_t itf, uint8_t const* buffer, uint16_t bufsize) {
+  (void) itf;
+  (void) buffer;
+  (void) bufsize;
+}
+
+TU_ATTR_WEAK void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes) {
+  (void) itf;
+  (void) sent_bytes;
+}
+
 //--------------------------------------------------------------------
 // Application API
 //--------------------------------------------------------------------
@@ -188,48 +202,52 @@ void vendord_reset(uint8_t rhport) {
     vendord_interface_t* p_itf = &_vendord_itf[i];
     tu_memclr(p_itf, ITF_MEM_RESET_SIZE);
     tu_edpt_stream_clear(&p_itf->rx.stream);
-    tu_edpt_stream_clear(&p_itf->tx.stream);
     tu_edpt_stream_close(&p_itf->rx.stream);
+
+    tu_edpt_stream_clear(&p_itf->tx.stream);
     tu_edpt_stream_close(&p_itf->tx.stream);
   }
 }
 
 uint16_t vendord_open(uint8_t rhport, const tusb_desc_interface_t* desc_itf, uint16_t max_len) {
   TU_VERIFY(TUSB_CLASS_VENDOR_SPECIFIC == desc_itf->bInterfaceClass, 0);
+  const uint8_t* desc_end = (const uint8_t*)desc_itf + max_len;
   const uint8_t* p_desc = tu_desc_next(desc_itf);
-  const uint8_t* desc_end = (uint8_t const*)desc_itf + max_len;
 
   // Find available interface
   vendord_interface_t* p_vendor = NULL;
-  for(uint8_t i=0; i<CFG_TUD_VENDOR; i++) {
-    if (!tud_vendor_n_mounted(i)) {
-      p_vendor = &_vendord_itf[i];
+  uint8_t itf;
+  for(itf=0; itf<CFG_TUD_VENDOR; itf++) {
+    if (!tud_vendor_n_mounted(itf)) {
+      p_vendor = &_vendord_itf[itf];
       break;
     }
   }
   TU_VERIFY(p_vendor, 0);
 
   p_vendor->itf_num = desc_itf->bInterfaceNumber;
-  uint8_t found_ep = 0;
-  while (found_ep < desc_itf->bNumEndpoints) {
-    // skip non-endpoint descriptors
-    while ( (TUSB_DESC_ENDPOINT != tu_desc_type(p_desc)) && (p_desc < desc_end) ) {
-      p_desc = tu_desc_next(p_desc);
-    }
-    if (p_desc >= desc_end) {
-      break;
-    }
-
-    const tusb_desc_endpoint_t* desc_ep = (const tusb_desc_endpoint_t*) p_desc;
-    TU_ASSERT(usbd_edpt_open(rhport, desc_ep));
-    found_ep++;
+  while (tu_desc_in_bounds(p_desc, desc_end)) {
+    const uint8_t desc_type = tu_desc_type(p_desc);
+    if (desc_type == TUSB_DESC_INTERFACE || desc_type == TUSB_DESC_INTERFACE_ASSOCIATION) {
+      break; // end of this interface
+    } else if (desc_type == TUSB_DESC_ENDPOINT) {
+      const tusb_desc_endpoint_t* desc_ep = (const tusb_desc_endpoint_t*) p_desc;
+      TU_ASSERT(usbd_edpt_open(rhport, desc_ep));
 
-    if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
-      tu_edpt_stream_open(&p_vendor->tx.stream, desc_ep);
-      tud_vendor_n_write_flush((uint8_t)(p_vendor - _vendord_itf));
-    } else {
-      tu_edpt_stream_open(&p_vendor->rx.stream, desc_ep);
-      TU_ASSERT(tu_edpt_stream_read_xfer(rhport, &p_vendor->rx.stream) > 0, 0); // prepare for incoming data
+      // open endpoint stream, skip if already opened (multiple IN/OUT endpoints)
+      if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
+        tu_edpt_stream_t *stream_tx = &p_vendor->tx.stream;
+        if (stream_tx->ep_addr == 0) {
+          tu_edpt_stream_open(stream_tx, desc_ep);
+          tu_edpt_stream_write_xfer(rhport, stream_tx); // flush pending data
+        }
+      } else {
+        tu_edpt_stream_t *stream_rx = &p_vendor->rx.stream;
+        if (stream_rx->ep_addr == 0) {
+          tu_edpt_stream_open(stream_rx, desc_ep);
+          TU_ASSERT(tu_edpt_stream_read_xfer(rhport, stream_rx) > 0, 0); // prepare for incoming data
+        }
+      }
     }
 
     p_desc = tu_desc_next(p_desc);
@@ -258,16 +276,12 @@ bool vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint
     tu_edpt_stream_read_xfer_complete(&p_vendor->rx.stream, xferred_bytes);
 
     // Invoked callback if any
-    if (tud_vendor_rx_cb) {
-      tud_vendor_rx_cb(itf, p_epbuf->epout, (uint16_t) xferred_bytes);
-    }
+    tud_vendor_rx_cb(itf, p_epbuf->epout, (uint16_t) xferred_bytes);
 
     tu_edpt_stream_read_xfer(rhport, &p_vendor->rx.stream);
   } else if ( ep_addr == p_vendor->tx.stream.ep_addr ) {
     // Send complete
-    if (tud_vendor_tx_cb) {
-      tud_vendor_tx_cb(itf, (uint16_t) xferred_bytes);
-    }
+    tud_vendor_tx_cb(itf, (uint16_t) xferred_bytes);
 
     #if CFG_TUD_VENDOR_TX_BUFSIZE > 0
     // try to send more if possible
diff --git a/src/class/vendor/vendor_device.h b/src/class/vendor/vendor_device.h
index 149ae2d56..5376f3917 100644
--- a/src/class/vendor/vendor_device.h
+++ b/src/class/vendor/vendor_device.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_VENDOR_DEVICE_H_
-#define _TUSB_VENDOR_DEVICE_H_
+#ifndef TUSB_VENDOR_DEVICE_H_
+#define TUSB_VENDOR_DEVICE_H_
 
 #include "common/tusb_common.h"
 
@@ -119,9 +119,9 @@ TU_ATTR_ALWAYS_INLINE static inline uint32_t tud_vendor_write_available(void) {
 //--------------------------------------------------------------------+
 
 // Invoked when received new data
-TU_ATTR_WEAK void tud_vendor_rx_cb(uint8_t itf, uint8_t const* buffer, uint16_t bufsize);
+void tud_vendor_rx_cb(uint8_t itf, uint8_t const* buffer, uint16_t bufsize);
 // Invoked when last rx transfer finished
-TU_ATTR_WEAK void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes);
+void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes);
 
 //--------------------------------------------------------------------+
 // Inline Functions
@@ -141,4 +141,4 @@ bool     vendord_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, u
  }
 #endif
 
-#endif /* _TUSB_VENDOR_DEVICE_H_ */
+#endif /* TUSB_VENDOR_DEVICE_H_ */
diff --git a/src/class/vendor/vendor_host.h b/src/class/vendor/vendor_host.h
index acfebe7a4..00e3c3402 100644
--- a/src/class/vendor/vendor_host.h
+++ b/src/class/vendor/vendor_host.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _TUSB_VENDOR_HOST_H_
-#define _TUSB_VENDOR_HOST_H_
+#ifndef TUSB_VENDOR_HOST_H_
+#define TUSB_VENDOR_HOST_H_
 
 #include "common/tusb_common.h"
 
@@ -64,4 +64,4 @@ void cush_close(uint8_t dev_addr);
  }
 #endif
 
-#endif /* _TUSB_VENDOR_HOST_H_ */
+#endif /* TUSB_VENDOR_HOST_H_ */
diff --git a/src/class/video/video.h b/src/class/video/video.h
index f348e187b..5bdf4b840 100644
--- a/src/class/video/video.h
+++ b/src/class/video/video.h
@@ -219,11 +219,11 @@ typedef enum {
     uint8_t  baInterfaceNr[_nitf]; \
   }
 
-typedef tusb_desc_video_control_header_nitf_t()  tusb_desc_video_control_header_t;
-typedef tusb_desc_video_control_header_nitf_t(1) tusb_desc_video_control_header_1itf_t;
-typedef tusb_desc_video_control_header_nitf_t(2) tusb_desc_video_control_header_2itf_t;
-typedef tusb_desc_video_control_header_nitf_t(3) tusb_desc_video_control_header_3itf_t;
-typedef tusb_desc_video_control_header_nitf_t(4) tusb_desc_video_control_header_4itf_t;
+typedef tusb_desc_video_control_header_nitf_t()  tusb_desc_video_control_header_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(1) tusb_desc_video_control_header_1itf_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(2) tusb_desc_video_control_header_2itf_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(3) tusb_desc_video_control_header_3itf_t; //-V2586 incorrectly detected as flexible array
+typedef tusb_desc_video_control_header_nitf_t(4) tusb_desc_video_control_header_4itf_t; //-V2586 incorrectly detected as flexible array
 
 typedef struct TU_ATTR_PACKED {
   uint8_t  bLength;
diff --git a/src/class/video/video_device.c b/src/class/video/video_device.c
index 3124d5596..844a5e672 100644
--- a/src/class/video/video_device.c
+++ b/src/class/video/video_device.c
@@ -103,7 +103,7 @@ typedef struct TU_ATTR_PACKED {
   uint8_t index_vc;  /* index of bound video control interface */
   uint8_t index_vs;  /* index from the video control interface */
   struct {
-    uint16_t beg;    /* Offset of the begging of video streaming interface descriptor */
+    uint16_t beg;    /* Offset of the beginning of video streaming interface descriptor */
     uint16_t end;    /* Offset of the end of video streaming interface descriptor */
     uint16_t cur;    /* Offset of the current settings */
     uint16_t ep[2];  /* Offset of endpoint descriptors. 0: streaming, 1: still capture */
@@ -193,6 +193,34 @@ static char const* const tu_str_video_vs_control_selector[] = {
 #endif
 
 //--------------------------------------------------------------------+
+// Weak stubs: invoked if no strong implementation is available
+//--------------------------------------------------------------------+
+TU_ATTR_WEAK void tud_video_frame_xfer_complete_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx) {
+  (void) ctl_idx;
+  (void) stm_idx;
+}
+
+TU_ATTR_WEAK int tud_video_power_mode_cb(uint_fast8_t ctl_idx, uint8_t power_mod) {
+  (void) ctl_idx;
+  (void) power_mod;
+  return VIDEO_ERROR_NONE;
+}
+
+TU_ATTR_WEAK int tud_video_commit_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx,
+                                    video_probe_and_commit_control_t const *parameters) {
+  (void) ctl_idx;
+  (void) stm_idx;
+  (void) parameters;
+  return VIDEO_ERROR_NONE;
+}
+
+TU_ATTR_WEAK void tud_video_prepare_payload_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, tud_video_payload_request_t* request) {
+  (void) ctl_idx;
+  (void) stm_idx;
+  (void) request;
+}
+
+//--------------------------------------------------------------------+
 //
 //--------------------------------------------------------------------+
 
@@ -222,9 +250,13 @@ static inline uint8_t _desc_ep_addr(void const *desc) {
  * @return instance */
 static videod_streaming_interface_t* _get_instance_streaming(uint_fast8_t ctl_idx, uint_fast8_t stm_idx) {
   videod_interface_t *ctl = &_videod_itf[ctl_idx];
-  if (!ctl->beg) return NULL;
+  if (!ctl->beg) {
+    return NULL;
+  }
   videod_streaming_interface_t *stm = &_videod_streaming_itf[ctl->stm[stm_idx]];
-  if (!stm->desc.beg) return NULL;
+  if (!stm->desc.beg) {
+    return NULL;
+  }
   return stm;
 }
 
@@ -233,7 +265,9 @@ static tusb_desc_vc_itf_t const* _get_desc_vc(videod_interface_t const *self) {
 }
 
 static tusb_desc_vs_itf_t const* _get_desc_vs(videod_streaming_interface_t const *self) {
-  if (!self->desc.cur) return NULL;
+  if (!self->desc.cur) {
+    return NULL;
+  }
   uint8_t const *desc = _videod_itf[self->index_vc].beg;
   return (tusb_desc_vs_itf_t const*)(desc + self->desc.cur);
 }
@@ -344,8 +378,12 @@ static void const* _find_desc_ep(void const *beg, void const *end)
 {
   for (void const *cur = beg; cur < end; cur = tu_desc_next(cur)) {
     uint_fast8_t desc_type = tu_desc_type(cur);
-    if (TUSB_DESC_ENDPOINT == desc_type) return cur;
-    if (TUSB_DESC_INTERFACE == desc_type) break;
+    if (TUSB_DESC_ENDPOINT == desc_type) {
+      return cur;
+    }
+    if (TUSB_DESC_INTERFACE == desc_type) {
+      break;
+    }
   }
   return end;
 }
@@ -431,8 +469,10 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
   tusb_desc_vs_itf_t const *vs = _get_desc_vs(stm);
   uint_fast8_t fmtnum = param->bFormatIndex;
   TU_ASSERT(vs && fmtnum <= vs->stm.bNumFormats);
-  if (!fmtnum) {
-    if (1 < vs->stm.bNumFormats) return true; /* Need to negotiate all variables. */
+  if (0 == fmtnum) {
+    if (1 < vs->stm.bNumFormats) {
+      return true; /* Need to negotiate all variables. */
+    }
     fmtnum = 1;
     param->bFormatIndex = 1;
   }
@@ -470,8 +510,10 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
 
   uint_fast8_t frmnum = param->bFrameIndex;
   TU_ASSERT(frmnum <= fmt->bNumFrameDescriptors);
-  if (!frmnum) {
-    if (1 < fmt->bNumFrameDescriptors) return true;
+  if (0 == frmnum) {
+    if (1 < fmt->bNumFrameDescriptors) {
+      return true;
+    }
     frmnum = 1;
     param->bFrameIndex = 1;
   }
@@ -480,7 +522,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
 
   /* Set the parameters determined by the frame  */
   uint_fast32_t frame_size = param->dwMaxVideoFrameSize;
-  if (!frame_size) {
+  if (0 == frame_size) {
     switch (fmt->bDescriptorSubType) {
       case VIDEO_CS_ITF_VS_FORMAT_UNCOMPRESSED:
         frame_size = (uint_fast32_t)frm->wWidth * frm->wHeight * fmt->uncompressed.bBitsPerPixel / 8;
@@ -500,7 +542,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
   }
 
   uint_fast32_t interval = param->dwFrameInterval;
-  if (!interval) {
+  if (0 == interval) {
     if ((1 < frm->uncompressed.bFrameIntervalType) ||
         ((0 == frm->uncompressed.bFrameIntervalType) &&
          (frm->uncompressed.dwFrameInterval[1] != frm->uncompressed.dwFrameInterval[0]))) {
@@ -510,7 +552,7 @@ static bool _update_streaming_parameters(videod_streaming_interface_t const *stm
     param->dwFrameInterval = interval;
   }
   uint_fast32_t interval_ms = interval / 10000;
-  TU_ASSERT(interval_ms);
+  TU_ASSERT(interval_ms != 0);
   uint_fast32_t payload_size = (frame_size + interval_ms - 1) / interval_ms + 2;
   if (CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE < payload_size) {
     payload_size = CFG_TUD_VIDEO_STREAMING_EP_BUFSIZE;
@@ -528,7 +570,7 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
                                             video_probe_and_commit_control_t *param)
 {
   uint_fast8_t const fmtnum = param->bFormatIndex;
-  if (!fmtnum) {
+  if (0 == fmtnum) {
     switch (request) {
       case VIDEO_REQUEST_GET_MAX:
         if (_get_desc_vs(stm))
@@ -559,7 +601,7 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
   }
 
   uint_fast8_t frmnum = param->bFrameIndex;
-  if (!frmnum) {
+  if (0 == frmnum) {
     tusb_desc_vs_itf_t const *vs = _get_desc_vs(stm);
     TU_ASSERT(vs);
     void const *end = _end_of_streaming_descriptor(vs);
@@ -615,7 +657,7 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
     return true;
   }
 
-  if (!param->dwFrameInterval) {
+  if (0 == param->dwFrameInterval) {
     tusb_desc_vs_itf_t const *vs = _get_desc_vs(stm);
     TU_ASSERT(vs);
     void const *end = _end_of_streaming_descriptor(vs);
@@ -664,12 +706,12 @@ static bool _negotiate_streaming_parameters(videod_streaming_interface_t const *
       default: return false;
     }
     param->dwFrameInterval = interval;
-    if (!interval) {
+    if (0 == interval) {
       param->dwMaxPayloadTransferSize = 0;
     } else {
       uint_fast32_t frame_size = param->dwMaxVideoFrameSize;
       uint_fast32_t payload_size;
-      if (!interval_ms) {
+      if (0 == interval_ms) {
         payload_size = frame_size + 2;
       } else {
         payload_size = (frame_size + interval_ms - 1) / interval_ms + 2;
@@ -697,7 +739,7 @@ static bool _close_vc_itf(uint8_t rhport, videod_interface_t *self)
 
   /* The end of the video control interface descriptor. */
   void const *end = _end_of_control_descriptor(vc);
-  if (vc->std.bNumEndpoints) {
+  if (vc->std.bNumEndpoints != 0) {
     /* Find the notification endpoint descriptor. */
     cur = _find_desc(cur, end, TUSB_DESC_ENDPOINT);
     TU_ASSERT(cur < end);
@@ -735,7 +777,7 @@ static bool _open_vc_itf(uint8_t rhport, videod_interface_t *self, uint_fast8_t
   cur += vc->std.bLength + vc->ctl.bLength;
   TU_LOG_DRV("    bNumEndpoints %d\r\n", vc->std.bNumEndpoints);
   /* Open the notification endpoint if it exist. */
-  if (vc->std.bNumEndpoints) {
+  if (vc->std.bNumEndpoints != 0) {
     /* Support for 1 endpoint only. */
     TU_VERIFY(1 == vc->std.bNumEndpoints);
     /* Find the notification endpoint descriptor. */
@@ -821,7 +863,7 @@ static bool _open_vs_itf(uint8_t rhport, videod_streaming_interface_t *stm, uint
     stm->desc.ep[i] = (uint16_t) (cur - desc);
     TU_LOG_DRV("    open EP%02x\r\n", _desc_ep_addr(cur));
   }
-  if (altnum) {
+  if (altnum != 0) {
     stm->state = VS_STATE_STREAMING;
   }
   TU_LOG_DRV("    done\r\n");
@@ -838,7 +880,16 @@ static uint_fast16_t _prepare_in_payload(videod_streaming_interface_t *stm, uint
   }
   TU_ASSERT(pkt_len >= hdr_len);
   uint_fast16_t data_len = pkt_len - hdr_len;
-  memcpy(&ep_buf[hdr_len], stm->buffer + stm->offset, data_len);
+  if (stm->buffer) {
+    memcpy(&ep_buf[hdr_len], stm->buffer + stm->offset, data_len);
+  } else {
+    tud_video_payload_request_t rqst = {
+      .buf = &ep_buf[hdr_len],
+      .length = data_len,
+      .offset = stm->offset
+    };
+    tud_video_prepare_payload_cb(stm->index_vc, stm->index_vs, &rqst);
+  }
   stm->offset += data_len;
   remaining -= data_len;
   if (!remaining) {
@@ -902,21 +953,19 @@ static int handle_video_ctl_cs_req(uint8_t rhport, uint8_t stage,
             TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)), VIDEO_ERROR_UNKNOWN);
           } else if (stage == CONTROL_STAGE_DATA) {
-            if (tud_video_power_mode_cb) return tud_video_power_mode_cb(ctl_idx, self->power_mode);
+            return tud_video_power_mode_cb(ctl_idx, self->power_mode);
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_CUR:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, &self->power_mode, sizeof(self->power_mode)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_INFO:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)(uintptr_t) &_cap_get_set, sizeof(_cap_get_set)), VIDEO_ERROR_UNKNOWN);
           }
@@ -929,15 +978,13 @@ static int handle_video_ctl_cs_req(uint8_t rhport, uint8_t stage,
     case VIDEO_VC_CTL_REQUEST_ERROR_CODE:
       switch (request->bRequest) {
         case VIDEO_REQUEST_GET_CUR:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(tud_control_xfer(rhport, request, &self->error_code, sizeof(uint8_t)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_INFO:
-          if (stage == CONTROL_STAGE_SETUP)
-          {
+          if (stage == CONTROL_STAGE_SETUP) {
             TU_VERIFY(tud_control_xfer(rhport, request, (uint8_t*)(uintptr_t) &_cap_get, sizeof(_cap_get)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
@@ -964,7 +1011,7 @@ static int handle_video_ctl_req(uint8_t rhport, uint8_t stage,
 
     case TUSB_REQ_TYPE_CLASS: {
       uint_fast8_t entity_id = TU_U16_HIGH(request->wIndex);
-      if (!entity_id) {
+      if (0 == entity_id) {
         return handle_video_ctl_cs_req(rhport, stage, request, ctl_idx);
       } else {
         TU_VERIFY(_find_desc_entity(_get_desc_vc(&_videod_itf[ctl_idx]), entity_id), VIDEO_ERROR_INVALID_REQUEST);
@@ -979,14 +1026,12 @@ static int handle_video_ctl_req(uint8_t rhport, uint8_t stage,
 
 static int handle_video_stm_std_req(uint8_t rhport, uint8_t stage,
                                     tusb_control_request_t const *request,
-                                    uint_fast8_t stm_idx)
-{
+                                    uint_fast8_t stm_idx) {
   TU_LOG_DRV("\r\n");
   videod_streaming_interface_t *self = &_videod_streaming_itf[stm_idx];
   switch (request->bRequest) {
     case TUSB_REQ_GET_INTERFACE:
-      if (stage == CONTROL_STAGE_SETUP)
-      {
+      if (stage == CONTROL_STAGE_SETUP) {
         TU_VERIFY(1 == request->wLength, VIDEO_ERROR_UNKNOWN);
         tusb_desc_vs_itf_t const *vs = _get_desc_vs(self);
         TU_VERIFY(vs, VIDEO_ERROR_UNKNOWN);
@@ -1053,12 +1098,14 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
           } else if (stage == CONTROL_STAGE_DATA) {
             TU_VERIFY(_update_streaming_parameters(stm, &stm->probe_commit_payload),
                       VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
+          } else {
+            // nothing to do
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_CUR:
           if (stage == CONTROL_STAGE_SETUP) {
-            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(request->wLength != 0, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, &stm->probe_commit_payload, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
@@ -1068,7 +1115,7 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
         case VIDEO_REQUEST_GET_RES:
         case VIDEO_REQUEST_GET_DEF:
           if (stage == CONTROL_STAGE_SETUP) {
-            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(request->wLength != 0, VIDEO_ERROR_UNKNOWN);
             video_probe_and_commit_control_t tmp = stm->probe_commit_payload;
             TU_VERIFY(_negotiate_streaming_parameters(stm, request->bRequest, &tmp), VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
             TU_VERIFY(tud_control_xfer(rhport, request, &tmp, sizeof(tmp)), VIDEO_ERROR_UNKNOWN);
@@ -1104,10 +1151,7 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
             TU_VERIFY(_update_streaming_parameters(stm, param), VIDEO_ERROR_INVALID_VALUE_WITHIN_RANGE);
             /* Set the negotiated value */
             stm->max_payload_transfer_size = param->dwMaxPayloadTransferSize;
-            int ret = VIDEO_ERROR_NONE;
-            if (tud_video_commit_cb) {
-              ret = tud_video_commit_cb(stm->index_vc, stm->index_vs, param);
-            }
+            int ret = tud_video_commit_cb(stm->index_vc, stm->index_vs, param);
             if (VIDEO_ERROR_NONE == ret) {
               stm->state   = VS_STATE_COMMITTED;
               stm->buffer  = NULL;
@@ -1118,12 +1162,14 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
               hdr->bHeaderLength = sizeof(*hdr);
               hdr->bmHeaderInfo  = 0;
             }
+          } else {
+            // nothing to do
           }
           return VIDEO_ERROR_NONE;
 
         case VIDEO_REQUEST_GET_CUR:
           if (stage == CONTROL_STAGE_SETUP) {
-            TU_VERIFY(request->wLength, VIDEO_ERROR_UNKNOWN);
+            TU_VERIFY(request->wLength != 0, VIDEO_ERROR_UNKNOWN);
             TU_VERIFY(tud_control_xfer(rhport, request, &stm->probe_commit_payload, sizeof(video_probe_and_commit_control_t)), VIDEO_ERROR_UNKNOWN);
           }
           return VIDEO_ERROR_NONE;
@@ -1166,14 +1212,15 @@ static int handle_video_stm_cs_req(uint8_t rhport, uint8_t stage,
 
 static int handle_video_stm_req(uint8_t rhport, uint8_t stage,
                                 tusb_control_request_t const *request,
-                                uint_fast8_t stm_idx)
-{
+                                uint_fast8_t stm_idx) {
   switch (request->bmRequestType_bit.type) {
     case TUSB_REQ_TYPE_STANDARD:
       return handle_video_stm_std_req(rhport, stage, request, stm_idx);
 
     case TUSB_REQ_TYPE_CLASS:
-      if (TU_U16_HIGH(request->wIndex)) return VIDEO_ERROR_INVALID_REQUEST;
+      if (0 != TU_U16_HIGH(request->wIndex)) {
+        return VIDEO_ERROR_INVALID_REQUEST;
+      }
       return handle_video_stm_cs_req(rhport, stage, request, stm_idx);
 
     default: return VIDEO_ERROR_INVALID_REQUEST;
@@ -1184,11 +1231,12 @@ static int handle_video_stm_req(uint8_t rhport, uint8_t stage,
 // APPLICATION API
 //--------------------------------------------------------------------+
 
-bool tud_video_n_connected(uint_fast8_t ctl_idx)
-{
+bool tud_video_n_connected(uint_fast8_t ctl_idx) {
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, 0);
-  if (stm) return true;
+  if (stm != NULL) {
+    return true;
+  }
   return false;
 }
 
@@ -1197,15 +1245,21 @@ bool tud_video_n_streaming(uint_fast8_t ctl_idx, uint_fast8_t stm_idx)
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
-  if (!stm || !stm->desc.ep[0]) return false;
-  if (stm->state == VS_STATE_PROBING) return false;
+  if (NULL == stm || 0 == stm->desc.ep[0]) {
+    return false;
+  }
+  if (stm->state == VS_STATE_PROBING) {
+    return false;
+  }
 
-#ifdef TUP_DCD_EDPT_ISO_ALLOC
+  #ifdef TUP_DCD_EDPT_ISO_ALLOC
   uint8_t const *desc = _videod_itf[stm->index_vc].beg;
   uint_fast16_t ofs_ep = stm->desc.ep[0];
   tusb_desc_endpoint_t const *ep = (tusb_desc_endpoint_t const*)(desc + ofs_ep);
   if (ep->bmAttributes.xfer == TUSB_XFER_ISOCHRONOUS) {
-    if (stm->state == VS_STATE_COMMITTED) return false;
+    if (stm->state == VS_STATE_COMMITTED) {
+      return false;
+    }
   }
 #endif
 
@@ -1216,25 +1270,36 @@ bool tud_video_n_frame_xfer(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, void *bu
   TU_ASSERT(ctl_idx < CFG_TUD_VIDEO);
   TU_ASSERT(stm_idx < CFG_TUD_VIDEO_STREAMING);
 
-  if (!buffer || !bufsize) return false;
+  if (0 == bufsize) {
+    return false;
+  }
+
   videod_streaming_interface_t *stm = _get_instance_streaming(ctl_idx, stm_idx);
   videod_streaming_epbuf_t *stm_epbuf = &_videod_streaming_epbuf[ctl_idx];
 
-  if (!stm || !stm->desc.ep[0] || stm->buffer) return false;
-  if (stm->state == VS_STATE_PROBING) return false;
+  if (NULL == stm || 0 == stm->desc.ep[0] || stm->bufsize) {
+    return false;
+  }
+  if (stm->state == VS_STATE_PROBING) {
+    return false;
+  }
 
   /* Find EP address */
   uint8_t const *desc = _videod_itf[stm->index_vc].beg;
   uint8_t ep_addr = 0;
   for (uint_fast8_t i = 0; i < CFG_TUD_VIDEO_STREAMING; ++i) {
     uint_fast16_t ofs_ep = stm->desc.ep[i];
-    if (!ofs_ep) continue;
+    if (0 == ofs_ep) {
+      continue;
+    }
     ep_addr = _desc_ep_addr(desc + ofs_ep);
     break;
   }
-  if (!ep_addr) return false;
+  if (0 == ep_addr) {
+    return false;
+  }
 
-  TU_VERIFY( usbd_edpt_claim(0, ep_addr) );
+  TU_VERIFY(usbd_edpt_claim(0, ep_addr));
   /* update the packet header */
   tusb_video_payload_header_t *hdr = (tusb_video_payload_header_t*)stm_epbuf->buf;
   hdr->FrameID   ^= 1;
@@ -1286,7 +1351,9 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
   videod_interface_t *self = NULL;
   uint8_t ctl_idx;
   for (ctl_idx = 0; ctl_idx < CFG_TUD_VIDEO; ++ctl_idx) {
-    if (_videod_itf[ctl_idx].beg) continue;
+    if (NULL != _videod_itf[ctl_idx].beg) {
+      continue;
+    }
     self = &_videod_itf[ctl_idx];
     break;
   }
@@ -1307,7 +1374,9 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
     videod_streaming_interface_t *stm = NULL;
     /* find free streaming interface handle */
     for (uint8_t i = 0; i < CFG_TUD_VIDEO_STREAMING; ++i) {
-      if (_videod_streaming_itf[i].desc.beg) continue;
+      if (0 != _videod_streaming_itf[i].desc.beg) {
+        continue;
+      }
       stm = &_videod_streaming_itf[i];
       self->stm[stm_idx] = i;
       break;
@@ -1335,7 +1404,9 @@ uint16_t videod_open(uint8_t rhport, tusb_desc_interface_t const * itf_desc, uin
       }
       p_desc = tu_desc_next(p_desc);
     }
-    if(ep_addr > 0 && ep_size > 0) usbd_edpt_iso_alloc(rhport, ep_addr, ep_size);
+    if(ep_addr > 0 && ep_size > 0) {
+      usbd_edpt_iso_alloc(rhport, ep_addr, ep_size);
+    }
 #endif
     if (0 == stm_idx && 1 == bInCollection) {
       /* If there is only one streaming interface and no alternate settings,
@@ -1362,31 +1433,43 @@ bool videod_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_
   uint_fast8_t itf;
   for (itf = 0; itf < CFG_TUD_VIDEO; ++itf) {
     void const *desc = _videod_itf[itf].beg;
-    if (!desc) continue;
-    if (itfnum == _desc_itfnum(desc)) break;
+    if (!desc) {
+      continue;
+    }
+    if (itfnum == _desc_itfnum(desc)) {
+      break;
+    }
   }
 
   if (itf < CFG_TUD_VIDEO) {
     TU_LOG_DRV("  VC[%d]: ", itf);
     err = handle_video_ctl_req(rhport, stage, request, itf);
     _videod_itf[itf].error_code = (uint8_t)err;
-    if (err) return false;
+    if (0 != err) {
+      return false;
+    }
     return true;
   }
 
   /* Identify which streaming interface to use */
   for (itf = 0; itf < CFG_TUD_VIDEO_STREAMING; ++itf) {
     videod_streaming_interface_t *stm = &_videod_streaming_itf[itf];
-    if (!stm->desc.beg) continue;
+    if (0 == stm->desc.beg) {
+      continue;
+    }
     uint8_t const *desc = _videod_itf[stm->index_vc].beg;
-    if (itfnum == _desc_itfnum(desc + stm->desc.beg)) break;
+    if (itfnum == _desc_itfnum(desc + stm->desc.beg)) {
+      break;
+    }
   }
 
   if (itf < CFG_TUD_VIDEO_STREAMING) {
     TU_LOG_DRV("  VS[%d]: ", itf);
     err = handle_video_stm_req(rhport, stage, request, itf);
     _videod_streaming_itf[itf].error_code = (uint8_t)err;
-    if (err) return false;
+    if (err != 0) {
+      return false;
+    }
     return true;
   }
   return false;
@@ -1402,26 +1485,28 @@ bool videod_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint3
   for (itf = 0; itf < CFG_TUD_VIDEO_STREAMING; ++itf) {
     stm = &_videod_streaming_itf[itf];
     uint_fast16_t const ep_ofs = stm->desc.ep[0];
-    if (!ep_ofs) continue;
+    if (0 == ep_ofs) {
+      continue;
+    }
     ctl = &_videod_itf[stm->index_vc];
     uint8_t const *desc = ctl->beg;
-    if (ep_addr == _desc_ep_addr(desc + ep_ofs)) break;
+    if (ep_addr == _desc_ep_addr(desc + ep_ofs)) {
+      break;
+    }
   }
   TU_ASSERT(itf < CFG_TUD_VIDEO_STREAMING);
   videod_streaming_epbuf_t *stm_epbuf = &_videod_streaming_epbuf[itf];
 
   if (stm->offset < stm->bufsize) {
     /* Claim the endpoint */
-    TU_VERIFY( usbd_edpt_claim(rhport, ep_addr), 0);
+    TU_VERIFY(usbd_edpt_claim(rhport, ep_addr), 0);
     uint_fast16_t pkt_len = _prepare_in_payload(stm, stm_epbuf->buf);
-    TU_ASSERT( usbd_edpt_xfer(rhport, ep_addr, stm_epbuf->buf, (uint16_t) pkt_len), 0);
+    TU_ASSERT(usbd_edpt_xfer(rhport, ep_addr, stm_epbuf->buf, (uint16_t) pkt_len), 0);
   } else {
     stm->buffer  = NULL;
     stm->bufsize = 0;
     stm->offset  = 0;
-    if (tud_video_frame_xfer_complete_cb) {
-      tud_video_frame_xfer_complete_cb(stm->index_vc, stm->index_vs);
-    }
+    tud_video_frame_xfer_complete_cb(stm->index_vc, stm->index_vs);
   }
   return true;
 }
diff --git a/src/class/video/video_device.h b/src/class/video/video_device.h
index 648a221d5..f14555e4f 100644
--- a/src/class/video/video_device.h
+++ b/src/class/video/video_device.h
@@ -35,6 +35,16 @@
 extern "C" {
 #endif
 
+
+//--------------------------------------------------------------------+
+// Payload request
+//--------------------------------------------------------------------+
+typedef struct TU_ATTR_PACKED {
+    void* buf;      /* Payload buffer to be filled */
+    size_t length;  /* Length of the requested data in bytes */
+    size_t offset;  /* Offset within the frame (in bytes) */
+} tud_video_payload_request_t;
+
 //--------------------------------------------------------------------+
 // Application API (Multiple Ports)
 // CFG_TUD_VIDEO > 1
@@ -61,7 +71,7 @@ bool tud_video_n_frame_xfer(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, void *bu
  *
  * @param[in] ctl_idx    Destination control interface index
  * @param[in] stm_idx    Destination streaming interface index */
-TU_ATTR_WEAK void tud_video_frame_xfer_complete_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx);
+void tud_video_frame_xfer_complete_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx);
 
 //--------------------------------------------------------------------+
 // Application Callback API (weak is optional)
@@ -72,7 +82,7 @@ TU_ATTR_WEAK void tud_video_frame_xfer_complete_cb(uint_fast8_t ctl_idx, uint_fa
  * @param[in] ctl_idx    Destination control interface index
  * @param[in] stm_idx    Destination streaming interface index
  * @return video_error_code_t */
-TU_ATTR_WEAK int tud_video_power_mode_cb(uint_fast8_t ctl_idx, uint8_t power_mod);
+int tud_video_power_mode_cb(uint_fast8_t ctl_idx, uint8_t power_mod);
 
 /** Invoked when VS_COMMIT_CONTROL(SET_CUR) request received
  *
@@ -80,9 +90,19 @@ TU_ATTR_WEAK int tud_video_power_mode_cb(uint_fast8_t ctl_idx, uint8_t power_mod
  * @param[in] stm_idx     Destination streaming interface index
  * @param[in] parameters  Video streaming parameters
  * @return video_error_code_t */
-TU_ATTR_WEAK int tud_video_commit_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx,
+int tud_video_commit_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx,
                                      video_probe_and_commit_control_t const *parameters);
 
+/** Invoked if buffer is set to NULL (allows bufferless on the fly data generation)
+ *
+ * @param[in]   ctl_idx       Destination control interface index
+ * @param[in]   stm_idx       Destination streaming interface index
+ * @param[out]  payload_buf   Payload storage buffer (target buffer for requested data)
+ * @param[in]   payload_size  Size of payload_buf (requested data size)
+ * @param[in]   offset        Current byte offset relative to given bufsize from tud_video_n_frame_xfer (framesize)
+ * @return video_error_code_t */
+void tud_video_prepare_payload_cb(uint_fast8_t ctl_idx, uint_fast8_t stm_idx, tud_video_payload_request_t* request);
+
 //--------------------------------------------------------------------+
 // INTERNAL USBD-CLASS DRIVER API
 //--------------------------------------------------------------------+