fix: add BE bitfield guards for audio and fix UAC2 example endian-safe field extraction

- Add TU_BITFIELD_ORDER guards for audio10_desc_as_iso_data_ep_t.bmAttributes in audio.h
- Add TU_BITFIELD_ORDER guards for audio20_control_request_t.bmRequestType_bit in audio.h
- Fix cdc_uac2/src/uac2_app.c: replace alias cast with TU_U16_LOW/HIGH field extraction
- Fix uac2_headset/src/main.c: replace alias cast with TU_U16_LOW/HIGH field extraction
- Fix uac2_speaker_fb/src/main.c: replace alias cast with TU_U16_LOW/HIGH field extraction

Addresses review comment: https://github.com/hathach/tinyusb/pull/3597#issuecomment-4320042007

Agent-Logs-Url: https://github.com/hathach/tinyusb/sessions/8b695271-74b3-4a26-b3d8-c48ecdf2e481

Co-authored-by: HiFiPhile <[email protected]>

15 files changed, 227 insertions, 168 deletions

diff --git a/examples/device/cdc_uac2/src/uac2_app.c b/examples/device/cdc_uac2/src/uac2_app.c
index 6e9d1d9e3..59c695514 100644
--- a/examples/device/cdc_uac2/src/uac2_app.c
+++ b/examples/device/cdc_uac2/src/uac2_app.c
@@ -82,20 +82,23 @@ 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 entity_id   = TU_U16_HIGH(p_request->wIndex);
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ)
+  TU_ASSERT(entity_id == UAC2_ENTITY_CLOCK);
+
+  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 +113,35 @@ 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);
+          entity_id, 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 entity_id = TU_U16_HIGH(p_request->wIndex);
+  uint8_t const ctrl_sel  = TU_U16_HIGH(p_request->wValue);
+
+  TU_ASSERT(entity_id == UAC2_ENTITY_CLOCK);
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ)
+  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;
 
@@ -146,79 +152,87 @@ 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);
+            entity_id, 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 entity_id  = TU_U16_HIGH(p_request->wIndex);
+  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)
+  TU_ASSERT(entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT);
+
+  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);
+          entity_id, 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 entity_id   = TU_U16_HIGH(p_request->wIndex);
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
+
+  TU_ASSERT(entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT);
+  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);
+            entity_id, ctrl_sel, p_request->bRequest);
     return false;
   }
 }
@@ -229,32 +243,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/uac2_headset/src/main.c b/examples/device/uac2_headset/src/main.c
index 779e927bc..10ffa00f8 100644
--- a/examples/device/uac2_headset/src/main.c
+++ b/examples/device/uac2_headset/src/main.c
@@ -319,16 +319,19 @@ 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 entity_id = TU_U16_HIGH(p_request->wIndex);
+  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) {
+  TU_ASSERT(entity_id == UAC2_ENTITY_CLOCK);
+
+  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 +343,31 @@ 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);
+          entity_id, 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 entity_id = TU_U16_HIGH(p_request->wIndex);
+  uint8_t const ctrl_sel  = TU_U16_HIGH(p_request->wValue);
+
+  TU_ASSERT(entity_id == UAC2_ENTITY_CLOCK);
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_4_t));
+  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;
 
@@ -370,92 +376,100 @@ 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);
+            entity_id, 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 entity_id   = TU_U16_HIGH(p_request->wIndex);
+  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) {
+  TU_ASSERT(entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT);
+
+  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);
+          entity_id, 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 entity_id   = TU_U16_HIGH(p_request->wIndex);
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
+
+  TU_ASSERT(entity_id == UAC2_ENTITY_SPK_FEATURE_UNIT);
+  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);
+            entity_id, 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..1680807e5 100644
--- a/examples/device/uac2_speaker_fb/src/main.c
+++ b/examples/device/uac2_speaker_fb/src/main.c
@@ -315,16 +315,19 @@ 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 entity_id = TU_U16_HIGH(p_request->wIndex);
+  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) {
+  TU_ASSERT(entity_id == UAC2_ENTITY_CLOCK);
+
+  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 +339,28 @@ 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);
+          entity_id, 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 entity_id = TU_U16_HIGH(p_request->wIndex);
+  uint8_t const ctrl_sel  = TU_U16_HIGH(p_request->wValue);
+
+  TU_ASSERT(entity_id == UAC2_ENTITY_CLOCK);
+  TU_VERIFY(p_request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
-    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_4_t));
+  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;
 
@@ -363,88 +369,96 @@ 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);
+            entity_id, 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 entity_id   = TU_U16_HIGH(p_request->wIndex);
+  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) {
+  TU_ASSERT(entity_id == UAC2_ENTITY_FEATURE_UNIT);
+
+  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);
+          entity_id, 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 entity_id   = TU_U16_HIGH(p_request->wIndex);
+  uint8_t const ctrl_sel    = TU_U16_HIGH(p_request->wValue);
+  uint8_t const channel_num = TU_U16_LOW(p_request->wValue);
+
+  TU_ASSERT(entity_id == UAC2_ENTITY_FEATURE_UNIT);
+  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);
+            entity_id, 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/hw/mcu/raspberry_pi/FreeRTOS-Kernel b/hw/mcu/raspberry_pi/FreeRTOS-Kernel
new file mode 160000
+Subproject 4f7299d6ea746b27a9dd19e87af568e34bd65b1
diff --git a/hw/mcu/raspberry_pi/Pico-PIO-USB b/hw/mcu/raspberry_pi/Pico-PIO-USB
new file mode 160000
+Subproject 675543bcc9baa8170f868ab7ba316d418dbcf41
diff --git a/hw/mcu/st/cmsis_device_f4 b/hw/mcu/st/cmsis_device_f4
new file mode 160000
+Subproject 3c77349ce04c8af401454cc51f85ea9a50e34fc
diff --git a/hw/mcu/st/stm32f4xx_hal_driver b/hw/mcu/st/stm32f4xx_hal_driver
new file mode 160000
+Subproject b6f0ed3829f3829eb358a2e7417d80bba1a42db
diff --git a/lib/CMSIS_5 b/lib/CMSIS_5
new file mode 160000
+Subproject 2b7495b8535bdcb306dac29b9ded4cfb679d7e5
diff --git a/lib/FreeRTOS-Kernel b/lib/FreeRTOS-Kernel
new file mode 160000
+Subproject 9b777ae5c5b8e9e456065a00294d1e5f5f9facf
diff --git a/lib/fatfs b/lib/fatfs
new file mode 160000
+Subproject 30ca13c62615df0d2e9104ab41256985b96590c
diff --git a/lib/lwip b/lib/lwip
new file mode 160000
+Subproject 159e31b689577dbf69cf0683bbaffbd71fa5ee1
diff --git a/lib/threadx b/lib/threadx
new file mode 160000
+Subproject 4b6e8100d932a3a67b34c6eb17f84f3bffb9e2a
diff --git a/src/class/audio/audio.h b/src/class/audio/audio.h
index cff38cc22..d0d50cf5b 100644
--- a/src/class/audio/audio.h
+++ b/src/class/audio/audio.h
@@ -490,10 +490,19 @@ typedef struct TU_ATTR_PACKED {
   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 {
+#if (TU_BITFIELD_ORDER == TU_BITFIELD_LE)
     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;
+#elif (TU_BITFIELD_ORDER == TU_BITFIELD_BE)
+    uint8_t       : 2;
+    uint8_t usage : 2;        // Data, Feedback, Implicit feedback
+    uint8_t sync  : 2;        // None, Asynchronous, Adaptive, Synchronous
+    uint8_t xfer  : 2;        // Control, ISO, Bulk, Interrupt
+#else
+  #error "Please define TU_BITFIELD_ORDER as TU_BITFIELD_LE or TU_BITFIELD_BE"
+#endif
   } 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.
@@ -1181,9 +1190,17 @@ typedef struct TU_ATTR_PACKED {
 typedef struct TU_ATTR_PACKED {
   union {
     struct TU_ATTR_PACKED {
+#if (TU_BITFIELD_ORDER == TU_BITFIELD_LE)
       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
+#elif (TU_BITFIELD_ORDER == TU_BITFIELD_BE)
+      uint8_t direction : 1;///< Direction type. tusb_dir_t
+      uint8_t type : 2;     ///< Request type tusb_request_type_t.
+      uint8_t recipient : 5;///< Recipient type tusb_request_recipient_t.
+#else
+  #error "Please define TU_BITFIELD_ORDER as TU_BITFIELD_LE or TU_BITFIELD_BE"
+#endif
     } bmRequestType_bit;
 
     uint8_t bmRequestType;
diff --git a/tools/linkermap b/tools/linkermap
new file mode 160000
+Subproject 8e1f440fa15c567aceb5aa0d14f6d18c329cc67
diff --git a/tools/uf2 b/tools/uf2
new file mode 160000
+Subproject c594542b2faa01cc33a2b97c9fbebc38549df80