Merge remote-tracking branch 'tinyusb/master' into copilot/fix-dcd-edpt-xfer-issue

Signed-off-by: HiFiPhile <[email protected]>

1 files changed, 283 insertions, 49 deletions

diff --git a/examples/device/uac2_headset/src/main.c b/examples/device/uac2_headset/src/main.c
index 102a6eef1..96fa66f1e 100644
--- a/examples/device/uac2_headset/src/main.c
+++ b/examples/device/uac2_headset/src/main.c
@@ -73,7 +73,7 @@ static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
 
 // Audio controls
 // Current states
-int8_t mute[CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1];   // +1 for master channel 0
+uint8_t mute[CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1];   // +1 for master channel 0
 int16_t volume[CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1];// +1 for master channel 0
 
 // Buffer for microphone data
@@ -141,18 +141,195 @@ void tud_resume_cb(void) {
   blink_interval_ms = tud_mounted() ? BLINK_MOUNTED : BLINK_NOT_MOUNTED;
 }
 
+//--------------------------------------------------------------------+
+// Audio Callback Functions
+//--------------------------------------------------------------------+
+
+//--------------------------------------------------------------------+
+// UAC1 Helper Functions
+//--------------------------------------------------------------------+
+
+static bool audio10_set_req_ep(tusb_control_request_t const *p_request, uint8_t *pBuff) {
+  uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+
+  switch (ctrlSel) {
+    case AUDIO10_EP_CTRL_SAMPLING_FREQ:
+      if (p_request->bRequest == AUDIO10_CS_REQ_SET_CUR) {
+        // Request uses 3 bytes
+        TU_VERIFY(p_request->wLength == 3);
+
+        current_sample_rate = tu_unaligned_read32(pBuff) & 0x00FFFFFF;
+
+        TU_LOG2("EP set current freq: %" PRIu32 "\r\n", current_sample_rate);
+
+        return true;
+      }
+      break;
+
+    // Unknown/Unsupported control
+    default:
+      TU_BREAKPOINT();
+      return false;
+  }
+
+  return false;
+}
+
+static bool audio10_get_req_ep(uint8_t rhport, tusb_control_request_t const *p_request) {
+  uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+
+  switch (ctrlSel) {
+    case AUDIO10_EP_CTRL_SAMPLING_FREQ:
+      if (p_request->bRequest == AUDIO10_CS_REQ_GET_CUR) {
+        TU_LOG2("EP get current freq\r\n");
+
+        uint8_t freq[3];
+        freq[0] = (uint8_t) (current_sample_rate & 0xFF);
+        freq[1] = (uint8_t) ((current_sample_rate >> 8) & 0xFF);
+        freq[2] = (uint8_t) ((current_sample_rate >> 16) & 0xFF);
+        return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, freq, sizeof(freq));
+      }
+      break;
+
+    // Unknown/Unsupported control
+    default:
+      TU_BREAKPOINT();
+      return false;
+  }
+
+  return false;
+}
+
+static bool audio10_set_req_entity(tusb_control_request_t const *p_request, uint8_t *pBuff) {
+  uint8_t channelNum = TU_U16_LOW(p_request->wValue);
+  uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+  uint8_t entityID = TU_U16_HIGH(p_request->wIndex);
+
+  // If request is for our speaker feature unit
+  if (entityID == UAC1_ENTITY_SPK_FEATURE_UNIT) {
+    switch (ctrlSel) {
+      case AUDIO10_FU_CTRL_MUTE:
+        switch (p_request->bRequest) {
+          case AUDIO10_CS_REQ_SET_CUR:
+            // Only 1st form is supported
+            TU_VERIFY(p_request->wLength == 1);
+
+            mute[channelNum] = pBuff[0];
+
+            TU_LOG2("    Set Mute: %d of channel: %u\r\n", mute[channelNum], channelNum);
+            return true;
+
+          default:
+            return false; // not supported
+        }
+
+      case AUDIO10_FU_CTRL_VOLUME:
+        switch (p_request->bRequest) {
+          case AUDIO10_CS_REQ_SET_CUR:
+            // Only 1st form is supported
+            TU_VERIFY(p_request->wLength == 2);
+
+            volume[channelNum] = (int16_t)tu_unaligned_read16(pBuff) / 256;
+
+            TU_LOG2("    Set Volume: %d dB of channel: %u\r\n", volume[channelNum], channelNum);
+            return true;
+
+          default:
+            return false; // not supported
+        }
+
+        // Unknown/Unsupported control
+      default:
+        TU_BREAKPOINT();
+        return false;
+    }
+  }
+
+  return false;
+}
+
+static bool audio10_get_req_entity(uint8_t rhport, tusb_control_request_t const *p_request) {
+  uint8_t channelNum = TU_U16_LOW(p_request->wValue);
+  uint8_t ctrlSel = TU_U16_HIGH(p_request->wValue);
+  uint8_t entityID = TU_U16_HIGH(p_request->wIndex);
+
+  // If request is for our speaker feature unit
+  if (entityID == UAC1_ENTITY_SPK_FEATURE_UNIT) {
+    switch (ctrlSel) {
+      case AUDIO10_FU_CTRL_MUTE:
+        // Audio control mute cur parameter block consists of only one byte - we thus can send it right away
+        // There does not exist a range parameter block for mute
+        TU_LOG2("    Get Mute of channel: %u\r\n", channelNum);
+        return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &mute[channelNum], 1);
+
+      case AUDIO10_FU_CTRL_VOLUME:
+        switch (p_request->bRequest) {
+          case AUDIO10_CS_REQ_GET_CUR:
+            TU_LOG2("    Get Volume of channel: %u\r\n", channelNum);
+            {
+              int16_t vol = (int16_t) volume[channelNum];
+              vol = vol * 256; // convert to 1/256 dB units
+              return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &vol, sizeof(vol));
+            }
+
+          case AUDIO10_CS_REQ_GET_MIN:
+            TU_LOG2("    Get Volume min of channel: %u\r\n", channelNum);
+            {
+              int16_t min = -90; // -90 dB
+              min = min * 256; // convert to 1/256 dB units
+              return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &min, sizeof(min));
+            }
+
+          case AUDIO10_CS_REQ_GET_MAX:
+            TU_LOG2("    Get Volume max of channel: %u\r\n", channelNum);
+            {
+              int16_t max = 30; // +30 dB
+              max = max * 256; // convert to 1/256 dB units
+              return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &max, sizeof(max));
+            }
+
+          case AUDIO10_CS_REQ_GET_RES:
+            TU_LOG2("    Get Volume res of channel: %u\r\n", channelNum);
+            {
+              int16_t res = 1; // 1 dB
+              res = res * 256; // convert to 1/256 dB units
+              return tud_audio_buffer_and_schedule_control_xfer(rhport, p_request, &res, sizeof(res));
+            }
+            // Unknown/Unsupported control
+          default:
+            TU_BREAKPOINT();
+            return false;
+        }
+        break;
+
+        // Unknown/Unsupported control
+      default:
+        TU_BREAKPOINT();
+        return false;
+    }
+  }
+
+  return false;
+}
+
+//--------------------------------------------------------------------+
+// UAC2 Helper Functions
+//--------------------------------------------------------------------+
+
+#if TUD_OPT_HIGH_SPEED
+
 // Helper for clock get requests
-static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t const *request) {
+static bool audio20_clock_get_request(uint8_t rhport, audio20_control_request_t const *request) {
   TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
 
-  if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ) {
-    if (request->bRequest == AUDIO_CS_REQ_CUR) {
+  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
+    if (request->bRequest == AUDIO20_CS_REQ_CUR) {
       TU_LOG1("Clock get current freq %" PRIu32 "\r\n", current_sample_rate);
 
-      audio_control_cur_4_t curf = {(int32_t) tu_htole32(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 == AUDIO_CS_REQ_RANGE) {
-      audio_control_range_4_n_t(N_SAMPLE_RATES) rangef =
+    } else if (request->bRequest == AUDIO20_CS_REQ_RANGE) {
+      audio20_control_range_4_n_t(N_SAMPLE_RATES) rangef =
           {
               .wNumSubRanges = tu_htole16(N_SAMPLE_RATES)};
       TU_LOG1("Clock get %d freq ranges\r\n", N_SAMPLE_RATES);
@@ -165,9 +342,9 @@ static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t
 
       return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &rangef, sizeof(rangef));
     }
-  } else if (request->bControlSelector == AUDIO_CS_CTRL_CLK_VALID &&
-             request->bRequest == AUDIO_CS_REQ_CUR) {
-    audio_control_cur_1_t cur_valid = {.bCur = 1};
+  } else if (request->bControlSelector == AUDIO20_CS_CTRL_CLK_VALID &&
+             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));
   }
@@ -177,16 +354,16 @@ static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t
 }
 
 // Helper for clock set requests
-static bool tud_audio_clock_set_request(uint8_t rhport, audio_control_request_t const *request, uint8_t const *buf) {
+static bool audio20_clock_set_request(uint8_t rhport, audio20_control_request_t const *request, uint8_t const *buf) {
   (void) rhport;
 
   TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK);
-  TU_VERIFY(request->bRequest == AUDIO_CS_REQ_CUR);
+  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ) {
-    TU_VERIFY(request->wLength == sizeof(audio_control_cur_4_t));
+  if (request->bControlSelector == AUDIO20_CS_CTRL_SAM_FREQ) {
+    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_4_t));
 
-    current_sample_rate = (uint32_t) ((audio_control_cur_4_t const *) buf)->bCur;
+    current_sample_rate = (uint32_t) ((audio20_control_cur_4_t const *) buf)->bCur;
 
     TU_LOG1("Clock set current freq: %" PRIu32 "\r\n", current_sample_rate);
 
@@ -199,23 +376,23 @@ static bool tud_audio_clock_set_request(uint8_t rhport, audio_control_request_t
 }
 
 // Helper for feature unit get requests
-static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio_control_request_t const *request) {
+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);
 
-  if (request->bControlSelector == AUDIO_FU_CTRL_MUTE && request->bRequest == AUDIO_CS_REQ_CUR) {
-    audio_control_cur_1_t mute1 = {.bCur = mute[request->bChannelNumber]};
+  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 == AUDIO_FU_CTRL_VOLUME) {
-    if (request->bRequest == AUDIO_CS_REQ_RANGE) {
-      audio_control_range_2_n_t(1) range_vol = {
+  } else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME) {
+    if (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,
               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 == AUDIO_CS_REQ_CUR) {
-      audio_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[request->bChannelNumber])};
+    } 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));
     }
@@ -227,24 +404,24 @@ static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio_control_req
 }
 
 // Helper for feature unit set requests
-static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio_control_request_t const *request, uint8_t const *buf) {
+static bool audio20_feature_unit_set_request(uint8_t rhport, audio20_control_request_t const *request, uint8_t const *buf) {
   (void) rhport;
 
   TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT);
-  TU_VERIFY(request->bRequest == AUDIO_CS_REQ_CUR);
+  TU_VERIFY(request->bRequest == AUDIO20_CS_REQ_CUR);
 
-  if (request->bControlSelector == AUDIO_FU_CTRL_MUTE) {
-    TU_VERIFY(request->wLength == sizeof(audio_control_cur_1_t));
+  if (request->bControlSelector == AUDIO20_FU_CTRL_MUTE) {
+    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_1_t));
 
-    mute[request->bChannelNumber] = ((audio_control_cur_1_t const *) buf)->bCur;
+    mute[request->bChannelNumber] = ((audio20_control_cur_1_t const *) buf)->bCur;
 
     TU_LOG1("Set channel %d Mute: %d\r\n", request->bChannelNumber, mute[request->bChannelNumber]);
 
     return true;
-  } else if (request->bControlSelector == AUDIO_FU_CTRL_VOLUME) {
-    TU_VERIFY(request->wLength == sizeof(audio_control_cur_2_t));
+  } else if (request->bControlSelector == AUDIO20_FU_CTRL_VOLUME) {
+    TU_VERIFY(request->wLength == sizeof(audio20_control_cur_2_t));
 
-    volume[request->bChannelNumber] = ((audio_control_cur_2_t const *) buf)->bCur;
+    volume[request->bChannelNumber] = ((audio20_control_cur_2_t const *) buf)->bCur;
 
     TU_LOG1("Set channel %d volume: %d dB\r\n", request->bChannelNumber, volume[request->bChannelNumber] / 256);
 
@@ -256,18 +433,13 @@ static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio_control_req
   }
 }
 
-//--------------------------------------------------------------------+
-// Application Callback API Implementations
-//--------------------------------------------------------------------+
-
-// 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) {
-  audio_control_request_t const *request = (audio_control_request_t const *) p_request;
+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;
 
   if (request->bEntityID == UAC2_ENTITY_CLOCK)
-    return tud_audio_clock_get_request(rhport, request);
+    return audio20_clock_get_request(rhport, request);
   if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT)
-    return tud_audio_feature_unit_get_request(rhport, request);
+    return audio20_feature_unit_get_request(rhport, request);
   else {
     TU_LOG1("Get request not handled, entity = %d, selector = %d, request = %d\r\n",
             request->bEntityID, request->bControlSelector, request->bRequest);
@@ -275,20 +447,78 @@ bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p
   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) {
-  audio_control_request_t const *request = (audio_control_request_t const *) p_request;
+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;
 
   if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT)
-    return tud_audio_feature_unit_set_request(rhport, request, buf);
+    return audio20_feature_unit_set_request(rhport, request, buf);
   if (request->bEntityID == UAC2_ENTITY_CLOCK)
-    return tud_audio_clock_set_request(rhport, request, buf);
+    return audio20_clock_set_request(rhport, request, buf);
   TU_LOG1("Set request not handled, entity = %d, selector = %d, request = %d\r\n",
           request->bEntityID, request->bControlSelector, request->bRequest);
 
   return false;
 }
 
+#endif // TUD_OPT_HIGH_SPEED
+
+// 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) {
+  (void) rhport;
+  (void) pBuff;
+
+  if (tud_audio_version() == 1) {
+    return audio10_set_req_ep(p_request, pBuff);
+  } else if (tud_audio_version() == 2) {
+    // We do not support any requests here
+  }
+
+  return false;// Yet not implemented
+}
+
+// Invoked when audio class specific get request received for an EP
+bool tud_audio_get_req_ep_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
+  (void) rhport;
+
+  if (tud_audio_version() == 1) {
+    return audio10_get_req_ep(rhport, p_request);
+  } else if (tud_audio_version() == 2) {
+    // We do not support any requests here
+  }
+
+  return false;// Yet not implemented
+}
+
+// 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) {
+  (void) rhport;
+
+  if (tud_audio_version() == 1) {
+    return audio10_get_req_entity(rhport, p_request);
+#if TUD_OPT_HIGH_SPEED
+  } else if (tud_audio_version() == 2) {
+    return audio20_get_req_entity(rhport, p_request);
+#endif
+  }
+
+  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) {
+  (void) rhport;
+
+  if (tud_audio_version() == 1) {
+    return audio10_set_req_entity(p_request, buf);
+#if TUD_OPT_HIGH_SPEED
+  } else if (tud_audio_version() == 2) {
+    return audio20_set_req_entity(rhport, p_request, buf);
+#endif
+  }
+
+  return false;
+}
+
 bool tud_audio_set_itf_close_ep_cb(uint8_t rhport, tusb_control_request_t const *p_request) {
   (void) rhport;
 
@@ -380,6 +610,10 @@ void audio_control_task(void) {
 
   uint32_t btn = board_button_read();
 
+  // Even UAC1 spec have status interrupt support like UAC2, most host do not support it
+  // So you have to either use UAC2 or use old day HID volume control
+  TU_VERIFY((tud_audio_version() == 1),);
+
   if (!btn_prev && btn) {
     // Adjust volume between 0dB (100%) and -30dB (10%)
     for (int i = 0; i < CFG_TUD_AUDIO_FUNC_1_N_CHANNELS_RX + 1; i++) {
@@ -387,14 +621,14 @@ void audio_control_task(void) {
     }
 
     // 6.1 Interrupt Data Message
-    const audio_interrupt_data_t data = {
+    const audio_interrupt_data_t data = {.v2 = {
         .bInfo = 0,                                      // Class-specific interrupt, originated from an interface
-        .bAttribute = AUDIO_CS_REQ_CUR,                  // Caused by current settings
+        .bAttribute = AUDIO20_CS_REQ_CUR,                // Caused by current settings
         .wValue_cn_or_mcn = 0,                           // CH0: master volume
-        .wValue_cs = AUDIO_FU_CTRL_VOLUME,               // Volume change
+        .wValue_cs = AUDIO20_FU_CTRL_VOLUME,             // Volume change
         .wIndex_ep_or_int = 0,                           // From the interface itself
         .wIndex_entity_id = UAC2_ENTITY_SPK_FEATURE_UNIT,// From feature unit
-    };
+    }};
 
     tud_audio_int_write(&data);
   }