Merge remote-tracking branch 'origin/master' into add-ch58x-usbfs

6 files changed, 211 insertions, 182 deletions

diff --git a/examples/device/audio_test_freertos/sdkconfig.defaults b/examples/device/audio_test_freertos/sdkconfig.defaults
index 83871619e..6e7a1cf52 100644
--- a/examples/device/audio_test_freertos/sdkconfig.defaults
+++ b/examples/device/audio_test_freertos/sdkconfig.defaults
@@ -1,3 +1,6 @@
 CONFIG_IDF_CMAKE=y
+# 1000 Hz tick: the UAC iso IN endpoint must be serviced every 1 ms frame;
+# ESP-IDF's default 100 Hz starves the audio task -> host capture fails (arecord EIO).
+CONFIG_FREERTOS_HZ=1000
 CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK=y
 CONFIG_FREERTOS_SUPPORT_STATIC_ALLOCATION=y
diff --git a/examples/device/cdc_uac2/src/uac2_app.c b/examples/device/cdc_uac2/src/uac2_app.c
index 6e9d1d9e3..a504c3b57 100644
--- a/examples/device/cdc_uac2/src/uac2_app.c
+++ b/examples/device/cdc_uac2/src/uac2_app.c
@@ -82,20 +82,20 @@ void audio_task(void) {
 }
 
 // Helper for clock get requests
-static bool tud_audio_clock_get_request(uint8_t rhport, audio20_control_request_t const *request)
+static bool tud_audio_clock_get_request(uint8_t rhport, tusb_control_request_t const *p_request)
 {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
+  uint8_t const ctrl_sel = TU_U16_HIGH(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ)
+  if (ctrl_sel == AUDIO20_CS_CTRL_SAM_FREQ)
   {
-    if (request->bRequest == AUDIO20_CS_REQ_CUR)
+    if (p_request->bRequest == AUDIO20_CS_REQ_CUR)
     {
       TU_LOG1("Clock get current freq %" PRIu32 "\r\n", current_sample_rate);
 
       audio20_control_cur_4_t curf = { (int32_t) tu_htole32(current_sample_rate) };
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &curf, sizeof(curf));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &curf, sizeof(curf));
     }
-    else if (request->bRequest == AUDIO20_CS_REQ_RANGE)
+    else if (p_request->bRequest == AUDIO20_CS_REQ_RANGE)
     {
       audio20_control_range_4_n_t(N_SAMPLE_RATES) rangef =
       {
@@ -110,32 +110,33 @@ static bool tud_audio_clock_get_request(uint8_t rhport, audio20_control_request_
         TU_LOG1("Range %d (%d, %d, %d)\r\n", i, (int)rangef.subrange[i].bMin, (int)rangef.subrange[i].bMax, (int)rangef.subrange[i].bRes);
       }
 
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &rangef, sizeof(rangef));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &rangef, sizeof(rangef));
     }
   }
-  else if (request->bControlSelector == AUDIO20_CS_CTRL_CLK_VALID &&
-           request->bRequest == AUDIO20_CS_REQ_CUR)
+  else if (ctrl_sel == AUDIO20_CS_CTRL_CLK_VALID &&
+           p_request->bRequest == AUDIO20_CS_REQ_CUR)
   {
     audio20_control_cur_1_t cur_valid = { .bCur = 1 };
     TU_LOG1("Clock get is valid %u\r\n", cur_valid.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &cur_valid, sizeof(cur_valid));
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &cur_valid, sizeof(cur_valid));
   }
-  TU_LOG1("Clock get request not supported, entity = %u, selector = %u, request = %u\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+  TU_LOG1("Clock get request not supported, selector = %u, request = %u\r\n",
+          ctrl_sel, p_request->bRequest);
   return false;
 }
 
 // Helper for clock set requests
-static bool tud_audio_clock_set_request(uint8_t rhport, audio20_control_request_t const *request, uint8_t const *buf)
+static bool tud_audio_clock_set_request(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t const *buf)
 {
   (void)rhport;
 
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
-  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
+  uint8_t const ctrl_sel = TU_U16_HIGH(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ)
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
+
+  if (ctrl_sel == AUDIO20_CS_CTRL_SAM_FREQ)
   {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_4_t));
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_4_t));
 
     current_sample_rate = (uint32_t) ((audio20_control_cur_4_t const *)buf)->bCur;
 
@@ -145,80 +146,83 @@ static bool tud_audio_clock_set_request(uint8_t rhport, audio20_control_request_
   }
   else
   {
-    TU_LOG1("Clock set request not supported, entity = %u, selector = %u, request = %u\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+    TU_LOG1("Clock set request not supported, selector = %u, request = %u\r\n",
+            ctrl_sel, p_request->bRequest);
     return false;
   }
 }
 
 // Helper for feature unit get requests
-static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio20_control_request_t const *request)
+static bool tud_audio_feature_unit_get_request(uint8_t rhport, tusb_control_request_t const *p_request)
 {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT);
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_FU_CTRL_MUTE && request->bRequest == AUDIO20_CS_REQ_CUR)
+  if (ctrl_sel == AUDIO20_FU_CTRL_MUTE && p_request->bRequest == AUDIO20_CS_REQ_CUR)
   {
-    audio20_control_cur_1_t mute1 = { .bCur = mute[request->bChannelNumber] };
-    TU_LOG1("Get channel %u mute %d\r\n", request->bChannelNumber, mute1.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &mute1, sizeof(mute1));
+    audio20_control_cur_1_t mute1 = { .bCur = mute[channel_num] };
+    TU_LOG1("Get channel %u mute %d\r\n", channel_num, mute1.bCur);
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &mute1, sizeof(mute1));
   }
-  else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME)
+  else if (ctrl_sel == AUDIO20_FU_CTRL_VOLUME)
   {
-    if (request->bRequest == AUDIO20_CS_REQ_RANGE)
+    if (p_request->bRequest == AUDIO20_CS_REQ_RANGE)
     {
       audio20_control_range_2_n_t(1) range_vol = {
         .wNumSubRanges = tu_htole16(1),
         .subrange[0] = { .bMin = tu_htole16(-VOLUME_CTRL_50_DB), tu_htole16(VOLUME_CTRL_0_DB), tu_htole16(256) }
       };
-      TU_LOG1("Get channel %u volume range (%d, %d, %u) dB\r\n", request->bChannelNumber,
+      TU_LOG1("Get channel %u volume range (%d, %d, %u) dB\r\n", channel_num,
               range_vol.subrange[0].bMin / 256, range_vol.subrange[0].bMax / 256, range_vol.subrange[0].bRes / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &range_vol, sizeof(range_vol));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &range_vol, sizeof(range_vol));
     }
-    else if (request->bRequest == AUDIO20_CS_REQ_CUR)
+    else if (p_request->bRequest == AUDIO20_CS_REQ_CUR)
     {
-      audio20_control_cur_2_t cur_vol = { .bCur = tu_htole16(volume[request->bChannelNumber]) };
-      TU_LOG1("Get channel %u volume %d dB\r\n", request->bChannelNumber, cur_vol.bCur / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *)request, &cur_vol, sizeof(cur_vol));
+      audio20_control_cur_2_t cur_vol = { .bCur = tu_htole16(volume[channel_num]) };
+      TU_LOG1("Get channel %u volume %d dB\r\n", channel_num, cur_vol.bCur / 256);
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &cur_vol, sizeof(cur_vol));
     }
   }
-  TU_LOG1("Feature unit get request not supported, entity = %u, selector = %u, request = %u\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+  TU_LOG1("Feature unit get request not supported, selector = %u, request = %u\r\n",
+          ctrl_sel, p_request->bRequest);
 
   return false;
 }
 
 // Helper for feature unit set requests
-static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio20_control_request_t const *request, uint8_t const *buf)
+static bool tud_audio_feature_unit_set_request(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t const *buf)
 {
   (void)rhport;
 
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT);
-  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
+
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO20_FU_CTRL_MUTE)
+  if (ctrl_sel == AUDIO20_FU_CTRL_MUTE)
   {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_1_t));
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_1_t));
 
-    mute[request->bChannelNumber] = ((audio20_control_cur_1_t const *)buf)->bCur;
+    mute[channel_num] = ((audio20_control_cur_1_t const *)buf)->bCur;
 
-    TU_LOG1("Set channel %d Mute: %d\r\n", request->bChannelNumber, mute[request->bChannelNumber]);
+    TU_LOG1("Set channel %d Mute: %d\r\n", channel_num, mute[channel_num]);
 
     return true;
   }
-  else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME)
+  else if (ctrl_sel == AUDIO20_FU_CTRL_VOLUME)
   {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_2_t));
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_2_t));
 
-    volume[request->bChannelNumber] = ((audio20_control_cur_2_t const *)buf)->bCur;
+    volume[channel_num] = ((audio20_control_cur_2_t const *)buf)->bCur;
 
-    TU_LOG1("Set channel %d volume: %d dB\r\n", request->bChannelNumber, volume[request->bChannelNumber] / 256);
+    TU_LOG1("Set channel %d volume: %d dB\r\n", channel_num, volume[channel_num] / 256);
 
     return true;
   }
   else
   {
-    TU_LOG1("Feature unit set request not supported, entity = %u, selector = %u, request = %u\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+    TU_LOG1("Feature unit set request not supported, selector = %u, request = %u\r\n",
+            ctrl_sel, p_request->bRequest);
     return false;
   }
 }
@@ -229,32 +233,32 @@ static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio20_control_r
 
 // Invoked when audio class specific get request received for an entity
 bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
-  audio20_control_request_t const *request = (audio20_control_request_t const *)p_request;
+  uint8_t const entity_id = TU_U16_HIGH(p_request->wIndex);
 
-  if (request->bEntityID == UAC2_ENTITY_CLOCK) {
-    return tud_audio_clock_get_request(rhport, request);
+  if (entity_id == UAC2_ENTITY_CLOCK) {
+    return tud_audio_clock_get_request(rhport, p_request);
   }
-  if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT) {
-    return tud_audio_feature_unit_get_request(rhport, request);
+  if (entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT) {
+    return tud_audio_feature_unit_get_request(rhport, p_request);
   } else {
     TU_LOG1("Get request not handled, entity = %d, selector = %d, request = %d\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+            entity_id, TU_U16_HIGH(p_request->wValue), p_request->bRequest);
   }
   return false;
 }
 
 // Invoked when audio class specific set request received for an entity
 bool tud_audio_set_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t *buf) {
-  audio20_control_request_t const *request = (audio20_control_request_t const *)p_request;
+  uint8_t const entity_id = TU_U16_HIGH(p_request->wIndex);
 
-  if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT) {
-    return tud_audio_feature_unit_set_request(rhport, request, buf);
+  if (entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT) {
+    return tud_audio_feature_unit_set_request(rhport, p_request, buf);
   }
-  if (request->bEntityID == UAC2_ENTITY_CLOCK) {
-    return tud_audio_clock_set_request(rhport, request, buf);
+  if (entity_id == UAC2_ENTITY_CLOCK) {
+    return tud_audio_clock_set_request(rhport, p_request, buf);
   }
   TU_LOG1("Set request not handled, entity = %d, selector = %d, request = %d\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+          entity_id, TU_U16_HIGH(p_request->wValue), p_request->bRequest);
 
   return false;
 }
diff --git a/examples/device/midi2_device/src/usb_descriptors.c b/examples/device/midi2_device/src/usb_descriptors.c
index 19a43f2d8..f035f9c48 100644
--- a/examples/device/midi2_device/src/usb_descriptors.c
+++ b/examples/device/midi2_device/src/usb_descriptors.c
@@ -70,7 +70,11 @@ enum {
 
 // Endpoint addresses
 #define EPNUM_MIDI2_OUT 0x01
+#if CFG_TUD_ENDPOINT_ONE_DIRECTION_ONLY
+#define EPNUM_MIDI2_IN 0x82
+#else
 #define EPNUM_MIDI2_IN 0x81
+#endif
 
 static uint8_t const desc_fs_configuration[] = {
   // Config number, interface count, string index, total length, attribute, power in mA
diff --git a/examples/device/uac2_headset/src/main.c b/examples/device/uac2_headset/src/main.c
index 779e927bc..c30b31f67 100644
--- a/examples/device/uac2_headset/src/main.c
+++ b/examples/device/uac2_headset/src/main.c
@@ -319,16 +319,16 @@ static bool audio10_get_req_entity(uint8_t rhport, tusb_control_request_t const
 #if TUD_OPT_HIGH_SPEED
 
 // Helper for clock get requests
-static bool audio20_clock_get_request(uint8_t rhport, audio20_control_request_t const *request) {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
+static bool audio20_clock_get_request(uint8_t rhport, tusb_control_request_t const *p_request) {
+  uint8_t const ctrl_sel = TU_U16_HIGH(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
-    if (request->bRequest == AUDIO20_CS_REQ_CUR) {
+  if (ctrl_sel == AUDIO20_CS_CTRL_SAM_FREQ) {
+    if (p_request->bRequest == AUDIO20_CS_REQ_CUR) {
       TU_LOG1("Clock get current freq %" PRIu32 "\r\n", current_sample_rate);
 
       audio20_control_cur_4_t curf = {(int32_t) tu_htole32(current_sample_rate)};
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &curf, sizeof(curf));
-    } else if (request->bRequest == AUDIO20_CS_REQ_RANGE) {
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &curf, sizeof(curf));
+    } else if (p_request->bRequest == AUDIO20_CS_REQ_RANGE) {
       audio20_control_range_4_n_t(N_SAMPLE_RATES) rangef =
           {
               .wNumSubRanges = tu_htole16(N_SAMPLE_RATES)};
@@ -340,28 +340,29 @@ static bool audio20_clock_get_request(uint8_t rhport, audio20_control_request_t
         TU_LOG1("Range %d (%d, %d, %d)\r\n", i, (int) rangef.subrange[i].bMin, (int) rangef.subrange[i].bMax, (int) rangef.subrange[i].bRes);
       }
 
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &rangef, sizeof(rangef));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &rangef, sizeof(rangef));
     }
-  } else if (request->bControlSelector == AUDIO20_CS_CTRL_CLK_VALID &&
-             request->bRequest == AUDIO20_CS_REQ_CUR) {
+  } else if (ctrl_sel == AUDIO20_CS_CTRL_CLK_VALID &&
+             p_request->bRequest == AUDIO20_CS_REQ_CUR) {
     audio20_control_cur_1_t cur_valid = {.bCur = 1};
     TU_LOG1("Clock get is valid %u\r\n", cur_valid.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_valid, sizeof(cur_valid));
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &cur_valid, sizeof(cur_valid));
   }
-  TU_LOG1("Clock get request not supported, entity = %u, selector = %u, request = %u\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+  TU_LOG1("Clock get request not supported, selector = %u, request = %u\r\n",
+          ctrl_sel, p_request->bRequest);
   return false;
 }
 
 // Helper for clock set requests
-static bool audio20_clock_set_request(uint8_t rhport, audio20_control_request_t const *request, uint8_t const *buf) {
+static bool audio20_clock_set_request(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t const *buf) {
   (void) rhport;
 
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
-  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
+  uint8_t const ctrl_sel = TU_U16_HIGH(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_4_t));
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
+
+  if (ctrl_sel == AUDIO20_CS_CTRL_SAM_FREQ) {
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_4_t));
 
     current_sample_rate = (uint32_t) ((audio20_control_cur_4_t const *) buf)->bCur;
 
@@ -369,93 +370,96 @@ static bool audio20_clock_set_request(uint8_t rhport, audio20_control_request_t
 
     return true;
   } else {
-    TU_LOG1("Clock set request not supported, entity = %u, selector = %u, request = %u\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+    TU_LOG1("Clock set request not supported, selector = %u, request = %u\r\n",
+            ctrl_sel, p_request->bRequest);
     return false;
   }
 }
 
 // Helper for feature unit get requests
-static bool audio20_feature_unit_get_request(uint8_t rhport, audio20_control_request_t const *request) {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT);
+static bool audio20_feature_unit_get_request(uint8_t rhport, tusb_control_request_t const *p_request) {
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_FU_CTRL_MUTE && request->bRequest == AUDIO20_CS_REQ_CUR) {
-    audio20_control_cur_1_t mute1 = {.bCur = mute[request->bChannelNumber]};
-    TU_LOG1("Get channel %u mute %d\r\n", request->bChannelNumber, mute1.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &mute1, sizeof(mute1));
-  } else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME) {
-    if (request->bRequest == AUDIO20_CS_REQ_RANGE) {
+  if (ctrl_sel == AUDIO20_FU_CTRL_MUTE && p_request->bRequest == AUDIO20_CS_REQ_CUR) {
+    audio20_control_cur_1_t mute1 = {.bCur = mute[channel_num]};
+    TU_LOG1("Get channel %u mute %d\r\n", channel_num, mute1.bCur);
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &mute1, sizeof(mute1));
+  } else if (ctrl_sel == AUDIO20_FU_CTRL_VOLUME) {
+    if (p_request->bRequest == AUDIO20_CS_REQ_RANGE) {
       audio20_control_range_2_n_t(1) range_vol = {
           .wNumSubRanges = tu_htole16(1),
           .subrange[0] = {.bMin = tu_htole16(-VOLUME_CTRL_50_DB), tu_htole16(VOLUME_CTRL_0_DB), tu_htole16(256)}};
-      TU_LOG1("Get channel %u volume range (%d, %d, %u) dB\r\n", request->bChannelNumber,
+      TU_LOG1("Get channel %u volume range (%d, %d, %u) dB\r\n", channel_num,
               range_vol.subrange[0].bMin / 256, range_vol.subrange[0].bMax / 256, range_vol.subrange[0].bRes / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &range_vol, sizeof(range_vol));
-    } else if (request->bRequest == AUDIO20_CS_REQ_CUR) {
-      audio20_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[request->bChannelNumber])};
-      TU_LOG1("Get channel %u volume %d dB\r\n", request->bChannelNumber, cur_vol.bCur / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_vol, sizeof(cur_vol));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &range_vol, sizeof(range_vol));
+    } else if (p_request->bRequest == AUDIO20_CS_REQ_CUR) {
+      audio20_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[channel_num])};
+      TU_LOG1("Get channel %u volume %d dB\r\n", channel_num, cur_vol.bCur / 256);
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &cur_vol, sizeof(cur_vol));
     }
   }
-  TU_LOG1("Feature unit get request not supported, entity = %u, selector = %u, request = %u\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+  TU_LOG1("Feature unit get request not supported, selector = %u, request = %u\r\n",
+          ctrl_sel, p_request->bRequest);
 
   return false;
 }
 
 // Helper for feature unit set requests
-static bool audio20_feature_unit_set_request(uint8_t rhport, audio20_control_request_t const *request, uint8_t const *buf) {
+static bool audio20_feature_unit_set_request(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t const *buf) {
   (void) rhport;
 
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT);
-  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
+
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO20_FU_CTRL_MUTE) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_1_t));
+  if (ctrl_sel == AUDIO20_FU_CTRL_MUTE) {
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_1_t));
 
-    mute[request->bChannelNumber] = ((audio20_control_cur_1_t const *) buf)->bCur;
+    mute[channel_num] = ((audio20_control_cur_1_t const *) buf)->bCur;
 
-    TU_LOG1("Set channel %d Mute: %d\r\n", request->bChannelNumber, mute[request->bChannelNumber]);
+    TU_LOG1("Set channel %d Mute: %d\r\n", channel_num, mute[channel_num]);
 
     return true;
-  } else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_2_t));
+  } else if (ctrl_sel == AUDIO20_FU_CTRL_VOLUME) {
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_2_t));
 
-    volume[request->bChannelNumber] = ((audio20_control_cur_2_t const *) buf)->bCur;
+    volume[channel_num] = ((audio20_control_cur_2_t const *) buf)->bCur;
 
-    TU_LOG1("Set channel %d volume: %d dB\r\n", request->bChannelNumber, volume[request->bChannelNumber] / 256);
+    TU_LOG1("Set channel %d volume: %d dB\r\n", channel_num, volume[channel_num] / 256);
 
     return true;
   } else {
-    TU_LOG1("Feature unit set request not supported, entity = %u, selector = %u, request = %u\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+    TU_LOG1("Feature unit set request not supported, selector = %u, request = %u\r\n",
+            ctrl_sel, p_request->bRequest);
     return false;
   }
 }
 
 static bool audio20_get_req_entity(uint8_t rhport, tusb_control_request_t const *p_request) {
-  audio20_control_request_t const *request = (audio20_control_request_t const *) p_request;
+  uint8_t const entity_id = TU_U16_HIGH(p_request->wIndex);
 
-  if (request->bEntityID == UAC2_ENTITY_CLOCK)
-    return audio20_clock_get_request(rhport, request);
-  if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT)
-    return audio20_feature_unit_get_request(rhport, request);
+  if (entity_id == UAC2_ENTITY_CLOCK)
+    return audio20_clock_get_request(rhport, p_request);
+  if (entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT)
+    return audio20_feature_unit_get_request(rhport, p_request);
   else {
     TU_LOG1("Get request not handled, entity = %d, selector = %d, request = %d\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+            entity_id, TU_U16_HIGH(p_request->wValue), p_request->bRequest);
   }
   return false;
 }
 
 static bool audio20_set_req_entity(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t *buf) {
-  audio20_control_request_t const *request = (audio20_control_request_t const *) p_request;
+  uint8_t const entity_id = TU_U16_HIGH(p_request->wIndex);
 
-  if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT)
-    return audio20_feature_unit_set_request(rhport, request, buf);
-  if (request->bEntityID == UAC2_ENTITY_CLOCK)
-    return audio20_clock_set_request(rhport, request, buf);
+  if (entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT)
+    return audio20_feature_unit_set_request(rhport, p_request, buf);
+  if (entity_id == UAC2_ENTITY_CLOCK)
+    return audio20_clock_set_request(rhport, p_request, buf);
   TU_LOG1("Set request not handled, entity = %d, selector = %d, request = %d\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+          entity_id, TU_U16_HIGH(p_request->wValue), p_request->bRequest);
 
   return false;
 }
diff --git a/examples/device/uac2_speaker_fb/src/main.c b/examples/device/uac2_speaker_fb/src/main.c
index 402642162..7e4d27f1c 100644
--- a/examples/device/uac2_speaker_fb/src/main.c
+++ b/examples/device/uac2_speaker_fb/src/main.c
@@ -315,16 +315,16 @@ const uint32_t sample_rates[] = {44100, 48000, 88200, 96000};
 
 #define N_SAMPLE_RATES TU_ARRAY_SIZE(sample_rates)
 
-static bool audio20_clock_get_request(uint8_t rhport, audio20_control_request_t const *request) {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
+static bool audio20_clock_get_request(uint8_t rhport, tusb_control_request_t const *p_request) {
+  uint8_t const ctrl_sel = TU_U16_HIGH(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
-    if (request->bRequest == AUDIO20_CS_REQ_CUR) {
+  if (ctrl_sel == AUDIO20_CS_CTRL_SAM_FREQ) {
+    if (p_request->bRequest == AUDIO20_CS_REQ_CUR) {
       TU_LOG1("Clock get current freq %" PRIu32 "\r\n", current_sample_rate);
 
       audio20_control_cur_4_t curf = {(int32_t) tu_htole32(current_sample_rate)};
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &curf, sizeof(curf));
-    } else if (request->bRequest == AUDIO20_CS_REQ_RANGE) {
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &curf, sizeof(curf));
+    } else if (p_request->bRequest == AUDIO20_CS_REQ_RANGE) {
       audio20_control_range_4_n_t(N_SAMPLE_RATES) rangef =
           {
               .wNumSubRanges = tu_htole16(N_SAMPLE_RATES)};
@@ -336,25 +336,26 @@ static bool audio20_clock_get_request(uint8_t rhport, audio20_control_request_t
         TU_LOG1("Range %d (%d, %d, %d)\r\n", i, (int) rangef.subrange[i].bMin, (int) rangef.subrange[i].bMax, (int) rangef.subrange[i].bRes);
       }
 
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &rangef, sizeof(rangef));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &rangef, sizeof(rangef));
     }
-  } else if (request->bControlSelector == AUDIO20_CS_CTRL_CLK_VALID &&
-             request->bRequest == AUDIO20_CS_REQ_CUR) {
+  } else if (ctrl_sel == AUDIO20_CS_CTRL_CLK_VALID &&
+             p_request->bRequest == AUDIO20_CS_REQ_CUR) {
     audio20_control_cur_1_t cur_valid = {.bCur = 1};
     TU_LOG1("Clock get is valid %u\r\n", cur_valid.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_valid, sizeof(cur_valid));
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &cur_valid, sizeof(cur_valid));
   }
-  TU_LOG1("Clock get request not supported, entity = %u, selector = %u, request = %u\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+  TU_LOG1("Clock get request not supported, selector = %u, request = %u\r\n",
+          ctrl_sel, p_request->bRequest);
   return false;
 }
 
-static bool audio20_clock_set_request(audio20_control_request_t const *request, uint8_t const *buf) {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
-  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
+static bool audio20_clock_set_request(tusb_control_request_t const *p_request, uint8_t const *buf) {
+  uint8_t const ctrl_sel = TU_U16_HIGH(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_4_t));
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
+
+  if (ctrl_sel == AUDIO20_CS_CTRL_SAM_FREQ) {
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_4_t));
 
     current_sample_rate = (uint32_t) ((audio20_control_cur_4_t const *) buf)->bCur;
 
@@ -362,89 +363,92 @@ static bool audio20_clock_set_request(audio20_control_request_t const *request,
 
     return true;
   } else {
-    TU_LOG1("Clock set request not supported, entity = %u, selector = %u, request = %u\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+    TU_LOG1("Clock set request not supported, selector = %u, request = %u\r\n",
+            ctrl_sel, p_request->bRequest);
     return false;
   }
 }
 
-static bool audio20_feature_unit_get_request(uint8_t rhport, audio20_control_request_t const *request) {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_FEATURE_UNIT);
+static bool audio20_feature_unit_get_request(uint8_t rhport, tusb_control_request_t const *p_request) {
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_FU_CTRL_MUTE && request->bRequest == AUDIO20_CS_REQ_CUR) {
-    audio20_control_cur_1_t mute1 = {.bCur = mute[request->bChannelNumber]};
-    TU_LOG1("Get channel %u mute %d\r\n", request->bChannelNumber, mute1.bCur);
-    return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &mute1, sizeof(mute1));
-  } else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME) {
-    if (request->bRequest == AUDIO20_CS_REQ_RANGE) {
+  if (ctrl_sel == AUDIO20_FU_CTRL_MUTE && p_request->bRequest == AUDIO20_CS_REQ_CUR) {
+    audio20_control_cur_1_t mute1 = {.bCur = mute[channel_num]};
+    TU_LOG1("Get channel %u mute %d\r\n", channel_num, mute1.bCur);
+    return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &mute1, sizeof(mute1));
+  } else if (ctrl_sel == AUDIO20_FU_CTRL_VOLUME) {
+    if (p_request->bRequest == AUDIO20_CS_REQ_RANGE) {
       audio20_control_range_2_n_t(1) range_vol = {
           .wNumSubRanges = tu_htole16(1),
           .subrange[0] = {.bMin = tu_htole16(-VOLUME_CTRL_50_DB), tu_htole16(VOLUME_CTRL_0_DB), tu_htole16(256)}};
-      TU_LOG1("Get channel %u volume range (%d, %d, %u) dB\r\n", request->bChannelNumber,
+      TU_LOG1("Get channel %u volume range (%d, %d, %u) dB\r\n", channel_num,
               range_vol.subrange[0].bMin / 256, range_vol.subrange[0].bMax / 256, range_vol.subrange[0].bRes / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &range_vol, sizeof(range_vol));
-    } else if (request->bRequest == AUDIO20_CS_REQ_CUR) {
-      audio20_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[request->bChannelNumber])};
-      TU_LOG1("Get channel %u volume %d dB\r\n", request->bChannelNumber, cur_vol.bCur / 256);
-      return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_vol, sizeof(cur_vol));
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &range_vol, sizeof(range_vol));
+    } else if (p_request->bRequest == AUDIO20_CS_REQ_CUR) {
+      audio20_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[channel_num])};
+      TU_LOG1("Get channel %u volume %d dB\r\n", channel_num, cur_vol.bCur / 256);
+      return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &cur_vol, sizeof(cur_vol));
     }
   }
-  TU_LOG1("Feature unit get request not supported, entity = %u, selector = %u, request = %u\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+  TU_LOG1("Feature unit get request not supported, selector = %u, request = %u\r\n",
+          ctrl_sel, p_request->bRequest);
 
   return false;
 }
 
-static bool audio20_feature_unit_set_request(audio20_control_request_t const *request, uint8_t const *buf) {
-  TU_ASSERT(request->bEntityID == UAC2_ENTITY_FEATURE_UNIT);
-  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
+static bool audio20_feature_unit_set_request(tusb_control_request_t const *p_request, uint8_t const *buf) {
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
+
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO20_FU_CTRL_MUTE) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_1_t));
+  if (ctrl_sel == AUDIO20_FU_CTRL_MUTE) {
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_1_t));
 
-    mute[request->bChannelNumber] = ((audio20_control_cur_1_t const *) buf)->bCur;
+    mute[channel_num] = ((audio20_control_cur_1_t const *) buf)->bCur;
 
-    TU_LOG1("Set channel %d Mute: %d\r\n", request->bChannelNumber, mute[request->bChannelNumber]);
+    TU_LOG1("Set channel %d Mute: %d\r\n", channel_num, mute[channel_num]);
 
     return true;
-  } else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_2_t));
+  } else if (ctrl_sel == AUDIO20_FU_CTRL_VOLUME) {
+    TU_VERIFY(p_request->wLength == sizeof(audio20_control_cur_2_t));
 
-    volume[request->bChannelNumber] = ((audio20_control_cur_2_t const *) buf)->bCur;
+    volume[channel_num] = ((audio20_control_cur_2_t const *) buf)->bCur;
 
-    TU_LOG1("Set channel %d volume: %d dB\r\n", request->bChannelNumber, volume[request->bChannelNumber] / 256);
+    TU_LOG1("Set channel %d volume: %d dB\r\n", channel_num, volume[channel_num] / 256);
 
     return true;
   } else {
-    TU_LOG1("Feature unit set request not supported, entity = %u, selector = %u, request = %u\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+    TU_LOG1("Feature unit set request not supported, selector = %u, request = %u\r\n",
+            ctrl_sel, p_request->bRequest);
     return false;
   }
 }
 
 static bool audio20_get_req_entity(uint8_t rhport, tusb_control_request_t const *p_request) {
-  audio20_control_request_t const *request = (audio20_control_request_t const *) p_request;
+  uint8_t const entity_id = TU_U16_HIGH(p_request->wIndex);
 
-  if (request->bEntityID == UAC2_ENTITY_CLOCK)
-    return audio20_clock_get_request(rhport, request);
-  if (request->bEntityID == UAC2_ENTITY_FEATURE_UNIT)
-    return audio20_feature_unit_get_request(rhport, request);
+  if (entity_id == UAC2_ENTITY_CLOCK)
+    return audio20_clock_get_request(rhport, p_request);
+  if (entity_id == UAC2_ENTITY_FEATURE_UNIT)
+    return audio20_feature_unit_get_request(rhport, p_request);
   else {
     TU_LOG1("Get request not handled, entity = %d, selector = %d, request = %d\r\n",
-            request->bEntityID, request->bControlSelector, request->bRequest);
+            entity_id, TU_U16_HIGH(p_request->wValue), p_request->bRequest);
   }
   return false;
 }
 
 static bool audio20_set_req_entity(tusb_control_request_t const *p_request, uint8_t *buf) {
-  audio20_control_request_t const *request = (audio20_control_request_t const *) p_request;
+  uint8_t const entity_id = TU_U16_HIGH(p_request->wIndex);
 
-  if (request->bEntityID == UAC2_ENTITY_FEATURE_UNIT)
-    return audio20_feature_unit_set_request(request, buf);
-  if (request->bEntityID == UAC2_ENTITY_CLOCK)
-    return audio20_clock_set_request(request, buf);
+  if (entity_id == UAC2_ENTITY_FEATURE_UNIT)
+    return audio20_feature_unit_set_request(p_request, buf);
+  if (entity_id == UAC2_ENTITY_CLOCK)
+    return audio20_clock_set_request(p_request, buf);
   TU_LOG1("Set request not handled, entity = %d, selector = %d, request = %d\r\n",
-          request->bEntityID, request->bControlSelector, request->bRequest);
+          entity_id, TU_U16_HIGH(p_request->wValue), p_request->bRequest);
 
   return false;
 }
diff --git a/examples/device/usbtmc/src/usb_descriptors.c b/examples/device/usbtmc/src/usb_descriptors.c
index 16bd176f8..ecdcef834 100644
--- a/examples/device/usbtmc/src/usb_descriptors.c
+++ b/examples/device/usbtmc/src/usb_descriptors.c
@@ -79,16 +79,26 @@ uint8_t const * tud_descriptor_device_cb(void)
 
 #if defined(CFG_TUD_USBTMC)
 
+#if CFG_TUD_ENDPOINT_ONE_DIRECTION_ONLY
+#  define EPNUM_USBTMC_OUT 0x01
+#  define EPNUM_USBTMC_IN  0x82
+#  define EPNUM_USBTMC_INT 0x83
+#else
+#  define EPNUM_USBTMC_OUT 0x01
+#  define EPNUM_USBTMC_IN  0x81
+#  define EPNUM_USBTMC_INT 0x82
+#endif
+
 #  define TUD_USBTMC_DESC_MAIN(_itfnum,_bNumEndpoints, _bulkMaxPacketLength) \
      TUD_USBTMC_IF_DESCRIPTOR(_itfnum, _bNumEndpoints,  /*_stridx = */ 4u, TUD_USBTMC_PROTOCOL_USB488), \
-     TUD_USBTMC_BULK_DESCRIPTORS(/* OUT = */0x01, /* IN = */ 0x81, /* packet size = */_bulkMaxPacketLength)
+     TUD_USBTMC_BULK_DESCRIPTORS(EPNUM_USBTMC_OUT, EPNUM_USBTMC_IN, /* packet size = */_bulkMaxPacketLength)
 
 #if CFG_TUD_USBTMC_ENABLE_INT_EP
 // USBTMC Interrupt xfer always has length of 2, but we use epMaxSize=8 for
 //  compatibility with mcus that only allow 8, 16, 32 or 64 for FS endpoints
 #  define TUD_USBTMC_DESC(_itfnum, _bulkMaxPacketLength) \
      TUD_USBTMC_DESC_MAIN(_itfnum, /* _epCount = */ 3, _bulkMaxPacketLength), \
-     TUD_USBTMC_INT_DESCRIPTOR(/* INT ep # */ 0x82, /* epMaxSize = */ 8, /* bInterval = */16u )
+     TUD_USBTMC_INT_DESCRIPTOR(EPNUM_USBTMC_INT, /* epMaxSize = */ 8, /* bInterval = */16u )
 #  define TUD_USBTMC_DESC_LEN (TUD_USBTMC_IF_DESCRIPTOR_LEN + TUD_USBTMC_BULK_DESCRIPTORS_LEN + TUD_USBTMC_INT_DESCRIPTOR_LEN)
 
 #else