From b9c44eea76f92cf3719fd68c9a10b8662faf23b5 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sat, 10 Feb 2024 17:08:29 +0100
Subject: [PATCH 01/37] improved tusb_config.h comment

---
 examples/host/cdc_msc_hid/src/tusb_config.h          | 2 +-
 examples/host/cdc_msc_hid_freertos/src/tusb_config.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/host/cdc_msc_hid/src/tusb_config.h b/examples/host/cdc_msc_hid/src/tusb_config.h
index 76d59c3169..e4d74077f9 100644
--- a/examples/host/cdc_msc_hid/src/tusb_config.h
+++ b/examples/host/cdc_msc_hid/src/tusb_config.h
@@ -102,7 +102,7 @@
 #define CFG_TUH_ENUMERATION_BUFSIZE 256
 
 #define CFG_TUH_HUB                 1 // number of supported hubs
-#define CFG_TUH_CDC                 1 // CDC ACM
+#define CFG_TUH_CDC                 1 // number of supported CDC devices. also activates CDC ACM
 #define CFG_TUH_CDC_FTDI            1 // FTDI Serial.  FTDI is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CP210X          1 // CP210x Serial. CP210X is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CH34X           1 // CH340 or CH341 Serial. CH34X is not part of CDC class, only to re-use CDC driver API
diff --git a/examples/host/cdc_msc_hid_freertos/src/tusb_config.h b/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
index bb7c3388de..9dc89dc559 100644
--- a/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
+++ b/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
@@ -107,7 +107,7 @@
 #define CFG_TUH_ENUMERATION_BUFSIZE 256
 
 #define CFG_TUH_HUB                 1 // number of supported hubs
-#define CFG_TUH_CDC                 1 // CDC ACM
+#define CFG_TUH_CDC                 1 // number of supported CDC devices. also activates CDC ACM
 #define CFG_TUH_CDC_FTDI            1 // FTDI Serial.  FTDI is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CP210X          1 // CP210x Serial. CP210X is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CH34X           1 // CH340 or CH341 Serial. CH34X is not part of CDC class, only to re-use CDC driver API

From 069c68ad04bd6210fc50dbc2aeb2c62448c1731d Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Fri, 23 Feb 2024 23:27:38 +0100
Subject: [PATCH 02/37] sorted driver functions into Control Request, Driver
 API, Enumeration and Helper. no functional changes

---
 src/class/cdc/cdc_host.c | 359 +++++++++++++++++++++------------------
 1 file changed, 189 insertions(+), 170 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 2fb37d8350..26eb70c9b9 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -782,92 +782,7 @@ bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
 // ACM
 //--------------------------------------------------------------------+
 
-enum {
-  CONFIG_ACM_SET_CONTROL_LINE_STATE = 0,
-  CONFIG_ACM_SET_LINE_CODING,
-  CONFIG_ACM_COMPLETE,
-};
-
-static bool acm_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len) {
-  uint8_t const* p_desc_end = ((uint8_t const*) itf_desc) + max_len;
-
-  cdch_interface_t* p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
-  p_cdc->serial_drid = SERIAL_DRIVER_ACM;
-
-  //------------- Control Interface -------------//
-  uint8_t const* p_desc = tu_desc_next(itf_desc);
-
-  // Communication Functional Descriptors
-  while ((p_desc < p_desc_end) && (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc))) {
-    if (CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc)) {
-      // save ACM bmCapabilities
-      p_cdc->acm_capability = ((cdc_desc_func_acm_t const*) p_desc)->bmCapabilities;
-    }
-
-    p_desc = tu_desc_next(p_desc);
-  }
-
-  // Open notification endpoint of control interface if any
-  if (itf_desc->bNumEndpoints == 1) {
-    TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc));
-    tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) p_desc;
-
-    TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
-    p_cdc->ep_notif = desc_ep->bEndpointAddress;
-
-    p_desc = tu_desc_next(p_desc);
-  }
-
-  //------------- Data Interface (if any) -------------//
-  if ((TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
-      (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const*) p_desc)->bInterfaceClass)) {
-    // next to endpoint descriptor
-    p_desc = tu_desc_next(p_desc);
-
-    // data endpoints expected to be in pairs
-    TU_ASSERT(open_ep_stream_pair(p_cdc, (tusb_desc_endpoint_t const*) p_desc));
-  }
-
-  return true;
-}
-
-static void acm_process_config(tuh_xfer_t* xfer) {
-  uintptr_t const state = xfer->user_data;
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc,);
-
-  switch (state) {
-    case CONFIG_ACM_SET_CONTROL_LINE_STATE:
-      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-      if (p_cdc->acm_capability.support_line_request) {
-        TU_ASSERT(acm_set_control_line_state(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, acm_process_config, CONFIG_ACM_SET_LINE_CODING),);
-        break;
-      }
-      #endif
-      TU_ATTR_FALLTHROUGH;
-
-    case CONFIG_ACM_SET_LINE_CODING:
-      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      if (p_cdc->acm_capability.support_line_request) {
-        cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-        TU_ASSERT(acm_set_line_coding(p_cdc, &line_coding, acm_process_config, CONFIG_ACM_COMPLETE),);
-        break;
-      }
-      #endif
-      TU_ATTR_FALLTHROUGH;
-
-    case CONFIG_ACM_COMPLETE:
-      // itf_num+1 to account for data interface as well
-      set_config_complete(p_cdc, idx, itf_num + 1);
-      break;
-
-    default:
-      break;
-  }
-}
+//------------- Driver API -------------//
 
 static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
@@ -953,37 +868,104 @@ static bool acm_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfe
   return acm_set_line_coding(p_cdc, &line_coding, complete_cb, user_data);
 }
 
-//--------------------------------------------------------------------+
-// FTDI
-//--------------------------------------------------------------------+
-#if CFG_TUH_CDC_FTDI
+//------------- Enumeration -------------//
 
 enum {
-  CONFIG_FTDI_RESET = 0,
-  CONFIG_FTDI_MODEM_CTRL,
-  CONFIG_FTDI_SET_BAUDRATE,
-  CONFIG_FTDI_SET_DATA,
-  CONFIG_FTDI_COMPLETE
+  CONFIG_ACM_SET_CONTROL_LINE_STATE = 0,
+  CONFIG_ACM_SET_LINE_CODING,
+  CONFIG_ACM_COMPLETE,
 };
 
-static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
-  // FTDI Interface includes 1 vendor interface + 2 bulk endpoints
-  TU_VERIFY(itf_desc->bInterfaceSubClass == 0xff && itf_desc->bInterfaceProtocol == 0xff && itf_desc->bNumEndpoints == 2);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
+static bool acm_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len) {
+  uint8_t const* p_desc_end = ((uint8_t const*) itf_desc) + max_len;
 
-  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
+  cdch_interface_t* p_cdc = make_new_itf(daddr, itf_desc);
   TU_VERIFY(p_cdc);
+  p_cdc->serial_drid = SERIAL_DRIVER_ACM;
 
-  TU_LOG_DRV("FTDI opened\r\n");
-  p_cdc->serial_drid = SERIAL_DRIVER_FTDI;
+  //------------- Control Interface -------------//
+  uint8_t const* p_desc = tu_desc_next(itf_desc);
 
-  // endpoint pair
-  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+  // Communication Functional Descriptors
+  while ((p_desc < p_desc_end) && (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc))) {
+    if (CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc)) {
+      // save ACM bmCapabilities
+      p_cdc->acm_capability = ((cdc_desc_func_acm_t const*) p_desc)->bmCapabilities;
+    }
 
-  // data endpoints expected to be in pairs
-  return open_ep_stream_pair(p_cdc, desc_ep);
+    p_desc = tu_desc_next(p_desc);
+  }
+
+  // Open notification endpoint of control interface if any
+  if (itf_desc->bNumEndpoints == 1) {
+    TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc));
+    tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) p_desc;
+
+    TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
+    p_cdc->ep_notif = desc_ep->bEndpointAddress;
+
+    p_desc = tu_desc_next(p_desc);
+  }
+
+  //------------- Data Interface (if any) -------------//
+  if ((TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
+      (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const*) p_desc)->bInterfaceClass)) {
+    // next to endpoint descriptor
+    p_desc = tu_desc_next(p_desc);
+
+    // data endpoints expected to be in pairs
+    TU_ASSERT(open_ep_stream_pair(p_cdc, (tusb_desc_endpoint_t const*) p_desc));
+  }
+
+  return true;
 }
 
+static void acm_process_config(tuh_xfer_t* xfer) {
+  uintptr_t const state = xfer->user_data;
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t* p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+
+  switch (state) {
+    case CONFIG_ACM_SET_CONTROL_LINE_STATE:
+      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+      if (p_cdc->acm_capability.support_line_request) {
+        TU_ASSERT(acm_set_control_line_state(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, acm_process_config, CONFIG_ACM_SET_LINE_CODING),);
+        break;
+      }
+      #endif
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_ACM_SET_LINE_CODING:
+      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
+      if (p_cdc->acm_capability.support_line_request) {
+        cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
+        TU_ASSERT(acm_set_line_coding(p_cdc, &line_coding, acm_process_config, CONFIG_ACM_COMPLETE),);
+        break;
+      }
+      #endif
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_ACM_COMPLETE:
+      // itf_num+1 to account for data interface as well
+      set_config_complete(p_cdc, idx, itf_num + 1);
+      break;
+
+    default:
+      break;
+  }
+}
+
+//--------------------------------------------------------------------+
+// FTDI
+//--------------------------------------------------------------------+
+#if CFG_TUH_CDC_FTDI
+
+static uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud);
+
+//------------- Control Request -------------//
+
 // set request without data
 static bool ftdi_sio_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_t value, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   tusb_control_request_t const request = {
@@ -1014,6 +996,20 @@ static bool ftdi_sio_reset(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, u
   return ftdi_sio_set_request(p_cdc, FTDI_SIO_RESET, FTDI_SIO_RESET_SIO, complete_cb, user_data);
 }
 
+//------------- Driver API -------------//
+
+static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(baudrate);
+  TU_LOG_DRV("CDC FTDI Set BaudRate = %lu, divisor = 0x%04x\r\n", baudrate, divisor);
+
+  p_cdc->user_control_cb = complete_cb;
+  p_cdc->requested_line_coding.bit_rate = baudrate;
+  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_SET_BAUD_RATE, divisor,
+                                 complete_cb ? cdch_internal_control_complete : NULL, user_data));
+
+  return true;
+}
+
 static bool ftdi_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
                                  tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   (void) p_cdc;
@@ -1043,40 +1039,32 @@ static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state
   return true;
 }
 
-static uint32_t ftdi_232bm_baud_base_to_divisor(uint32_t baud, uint32_t base) {
-  const uint8_t divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
-  uint32_t divisor;
-
-  /* divisor shifted 3 bits to the left */
-  uint32_t divisor3 = base / (2 * baud);
-  divisor = (divisor3 >> 3);
-  divisor |= (uint32_t) divfrac[divisor3 & 0x7] << 14;
+//------------- Enumeration -------------//
 
-  /* Deal with special cases for highest baud rates. */
-  if (divisor == 1) { /* 1.0 */
-    divisor = 0;
-  }
-  else if (divisor == 0x4001) { /* 1.5 */
-    divisor = 1;
-  }
+enum {
+  CONFIG_FTDI_RESET = 0,
+  CONFIG_FTDI_MODEM_CTRL,
+  CONFIG_FTDI_SET_BAUDRATE,
+  CONFIG_FTDI_SET_DATA,
+  CONFIG_FTDI_COMPLETE
+};
 
-  return divisor;
-}
+static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
+  // FTDI Interface includes 1 vendor interface + 2 bulk endpoints
+  TU_VERIFY(itf_desc->bInterfaceSubClass == 0xff && itf_desc->bInterfaceProtocol == 0xff && itf_desc->bNumEndpoints == 2);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
 
-static uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud) {
-  return ftdi_232bm_baud_base_to_divisor(baud, 48000000u);
-}
+  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
 
-static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(baudrate);
-  TU_LOG_DRV("CDC FTDI Set BaudRate = %lu, divisor = 0x%04x\r\n", baudrate, divisor);
+  TU_LOG_DRV("FTDI opened\r\n");
+  p_cdc->serial_drid = SERIAL_DRIVER_FTDI;
 
-  p_cdc->user_control_cb = complete_cb;
-  p_cdc->requested_line_coding.bit_rate = baudrate;
-  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_SET_BAUD_RATE, divisor,
-                                 complete_cb ? cdch_internal_control_complete : NULL, user_data));
+  // endpoint pair
+  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
 
-  return true;
+  // data endpoints expected to be in pairs
+  return open_ep_stream_pair(p_cdc, desc_ep);
 }
 
 static void ftdi_process_config(tuh_xfer_t* xfer) {
@@ -1131,39 +1119,40 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
   }
 }
 
-#endif
+//------------- Helper -------------//
 
-//--------------------------------------------------------------------+
-// CP210x
-//--------------------------------------------------------------------+
+static uint32_t ftdi_232bm_baud_base_to_divisor(uint32_t baud, uint32_t base) {
+  const uint8_t divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
+  uint32_t divisor;
 
-#if CFG_TUH_CDC_CP210X
+  /* divisor shifted 3 bits to the left */
+  uint32_t divisor3 = base / (2 * baud);
+  divisor = (divisor3 >> 3);
+  divisor |= (uint32_t) divfrac[divisor3 & 0x7] << 14;
 
-enum {
-  CONFIG_CP210X_IFC_ENABLE = 0,
-  CONFIG_CP210X_SET_BAUDRATE,
-  CONFIG_CP210X_SET_LINE_CTL,
-  CONFIG_CP210X_SET_DTR_RTS,
-  CONFIG_CP210X_COMPLETE
-};
+  /* Deal with special cases for highest baud rates. */
+  if (divisor == 1) { /* 1.0 */
+    divisor = 0;
+  }
+  else if (divisor == 0x4001) { /* 1.5 */
+    divisor = 1;
+  }
 
-static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
-  // CP210x Interface includes 1 vendor interface + 2 bulk endpoints
-  TU_VERIFY(itf_desc->bInterfaceSubClass == 0 && itf_desc->bInterfaceProtocol == 0 && itf_desc->bNumEndpoints == 2);
-  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
+  return divisor;
+}
 
-  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY(p_cdc);
+static uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud) {
+  return ftdi_232bm_baud_base_to_divisor(baud, 48000000u);
+}
 
-  TU_LOG_DRV("CP210x opened\r\n");
-  p_cdc->serial_drid = SERIAL_DRIVER_CP210X;
+#endif
 
-  // endpoint pair
-  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+//--------------------------------------------------------------------+
+// CP210x
+//--------------------------------------------------------------------+
+#if CFG_TUH_CDC_CP210X
 
-  // data endpoints expected to be in pairs
-  return open_ep_stream_pair(p_cdc, desc_ep);
-}
+//------------- Control Request -------------//
 
 static bool cp210x_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_t value, uint8_t* buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   tusb_control_request_t const request = {
@@ -1202,14 +1191,7 @@ static bool cp210x_ifc_enable(cdch_interface_t* p_cdc, uint16_t enabled, tuh_xfe
   return cp210x_set_request(p_cdc, CP210X_IFC_ENABLE, enabled, NULL, 0, complete_cb, user_data);
 }
 
-static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  // TODO implement later
-  (void) p_cdc;
-  (void) line_coding;
-  (void) complete_cb;
-  (void) user_data;
-  return false;
-}
+//------------- Driver API -------------//
 
 static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_LOG_DRV("CDC CP210x Set BaudRate = %lu\r\n", baudrate);
@@ -1231,6 +1213,15 @@ static bool cp210x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, u
   return false;
 }
 
+static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // TODO implement later
+  (void) p_cdc;
+  (void) line_coding;
+  (void) complete_cb;
+  (void) user_data;
+  return false;
+}
+
 static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_LOG_DRV("CDC CP210x Set Control Line State\r\n");
   p_cdc->user_control_cb = complete_cb;
@@ -1238,6 +1229,34 @@ static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state,
                             complete_cb ? cdch_internal_control_complete : NULL, user_data);
 }
 
+//------------- Enumeration -------------//
+
+enum {
+  CONFIG_CP210X_IFC_ENABLE = 0,
+  CONFIG_CP210X_SET_BAUDRATE,
+  CONFIG_CP210X_SET_LINE_CTL,
+  CONFIG_CP210X_SET_DTR_RTS,
+  CONFIG_CP210X_COMPLETE
+};
+
+static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+  // CP210x Interface includes 1 vendor interface + 2 bulk endpoints
+  TU_VERIFY(itf_desc->bInterfaceSubClass == 0 && itf_desc->bInterfaceProtocol == 0 && itf_desc->bNumEndpoints == 2);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
+
+  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
+
+  TU_LOG_DRV("CP210x opened\r\n");
+  p_cdc->serial_drid = SERIAL_DRIVER_CP210X;
+
+  // endpoint pair
+  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
+
+  // data endpoints expected to be in pairs
+  return open_ep_stream_pair(p_cdc, desc_ep);
+}
+
 static void cp210x_process_config(tuh_xfer_t* xfer) {
   uintptr_t const state   = xfer->user_data;
   uint8_t const   itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
@@ -1296,7 +1315,7 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
 static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bits);
 static uint16_t ch34x_get_divisor_prescaler(uint32_t baval);
 
-//------------- control request -------------//
+//------------- Control Request -------------//
 
 static bool ch34x_set_request(cdch_interface_t* p_cdc, uint8_t direction, uint8_t request, uint16_t value,
                               uint16_t index, uint8_t* buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
@@ -1471,6 +1490,7 @@ static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state,
 }
 
 //------------- Enumeration -------------//
+
 enum {
   CONFIG_CH34X_READ_VERSION = 0,
   CONFIG_CH34X_SERIAL_INIT,
@@ -1565,7 +1585,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
   }
 }
 
-//------------- CH34x helper  -------------//
+//------------- Helper -------------//
 
 // calculate divisor and prescaler for baudrate, return it as 16-bit combined value
 static uint16_t ch34x_get_divisor_prescaler(uint32_t baval) {
@@ -1654,7 +1674,6 @@ static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bit
   return lcr;
 }
 
-
 #endif // CFG_TUH_CDC_CH34X
 
 #endif

From 47777a63050f9438d79364436c25d0f6a80dfd55 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Tue, 20 Feb 2024 22:08:51 +0100
Subject: [PATCH 03/37] improved TU_LOGs

---
 src/class/cdc/cdc_host.c | 86 +++++++++++++++++++++++++---------------
 1 file changed, 55 insertions(+), 31 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 26eb70c9b9..856db32fff 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -41,7 +41,11 @@
   #define CFG_TUH_CDC_LOG_LEVEL   CFG_TUH_LOG_LEVEL
 #endif
 
-#define TU_LOG_DRV(...)   TU_LOG(CFG_TUH_CDC_LOG_LEVEL, __VA_ARGS__)
+#define TU_LOG_DRV(...)                        TU_LOG(CFG_TUH_CDC_LOG_LEVEL, __VA_ARGS__)
+#define TU_LOG_CDC(TXT,DADDR,ITF_NUM,NAME,...) TU_LOG_DRV("[:%u:%u] CDCh %s " TXT "\r\n", \
+                                                          DADDR, ITF_NUM, NAME, ##__VA_ARGS__)
+#define TU_LOG_P_CDC(TXT,...)                  TU_LOG_CDC(TXT, p_cdc->daddr, p_cdc->bInterfaceNumber, \
+                                                          serial_drivers[p_cdc->serial_drid].name, ##__VA_ARGS__)
 
 //--------------------------------------------------------------------+
 // Host CDC Interface
@@ -169,6 +173,9 @@ typedef struct {
   bool (*const set_baudrate)(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
   bool (*const set_data_format)(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
   bool (*const set_line_coding)(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+  uint8_t const * name;
+  #endif
 } cdch_serial_driver_t;
 
 // Note driver list must be in the same order as SERIAL_DRIVER enum
@@ -181,7 +188,10 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .set_control_line_state = acm_set_control_line_state,
       .set_baudrate           = acm_set_baudrate,
       .set_data_format        = acm_set_data_format,
-      .set_line_coding        = acm_set_line_coding
+      .set_line_coding        = acm_set_line_coding,
+    #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+      .name                   = (uint8_t const *) "ACM"
+    #endif
   },
 
   #if CFG_TUH_CDC_FTDI
@@ -193,7 +203,10 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .set_control_line_state = ftdi_sio_set_modem_ctrl,
       .set_baudrate           = ftdi_sio_set_baudrate,
       .set_data_format        = ftdi_set_data_format,
-      .set_line_coding        = ftdi_set_line_coding
+      .set_line_coding        = ftdi_set_line_coding,
+    #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+      .name                   = (uint8_t const *) "FTDI"
+    #endif
   },
   #endif
 
@@ -206,7 +219,10 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .set_control_line_state = cp210x_set_modem_ctrl,
       .set_baudrate           = cp210x_set_baudrate,
       .set_data_format        = cp210x_set_data_format,
-      .set_line_coding        = cp210x_set_line_coding
+      .set_line_coding        = cp210x_set_line_coding,
+    #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+      .name                   = (uint8_t const *) "CP210x"
+    #endif
   },
   #endif
 
@@ -219,7 +235,10 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .set_control_line_state = ch34x_set_modem_ctrl,
       .set_baudrate           = ch34x_set_baudrate,
       .set_data_format        = ch34x_set_data_format,
-      .set_line_coding        = ch34x_set_line_coding
+      .set_line_coding        = ch34x_set_line_coding,
+    #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+      .name                   = (uint8_t const *) "CH34x"
+    #endif
   },
   #endif
 };
@@ -408,8 +427,10 @@ static void process_internal_control_complete(tuh_xfer_t* xfer, uint8_t itf_num)
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc, );
   uint16_t const value = tu_le16toh(xfer->setup->wValue);
+  bool const success = (xfer->result == XFER_RESULT_SUCCESS);
+  TU_LOG_P_CDC("control complete success = %u", success);
 
-  if (xfer->result == XFER_RESULT_SUCCESS) {
+  if (success) {
     switch (p_cdc->serial_drid) {
       case SERIAL_DRIVER_ACM:
         switch (xfer->setup->bRequest) {
@@ -525,6 +546,7 @@ static void cdch_internal_control_complete(tuh_xfer_t* xfer) {
 bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  TU_LOG_P_CDC("set control line state line_state = %u", line_state);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
   if (complete_cb) {
@@ -548,6 +570,7 @@ bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_c
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  TU_LOG_P_CDC("set baudrate = %lu", baudrate);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
   if (complete_cb) {
@@ -572,6 +595,8 @@ bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uin
                              tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  TU_LOG_P_CDC("set data format data_bits = %u parity = %u stop_bits = %u (indexes!)",
+               data_bits, parity, stop_bits);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
   if (complete_cb) {
@@ -597,6 +622,8 @@ bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uin
 bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  TU_LOG_P_CDC("set line coding baudrate = %lu data_bits = %u parity = %u stop_bits = %u (indexes!)",
+               line_coding->bit_rate, line_coding->data_bits, line_coding->parity, line_coding->stop_bits);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
   if ( complete_cb ) {
@@ -641,7 +668,7 @@ void cdch_close(uint8_t daddr) {
   for (uint8_t idx = 0; idx < CFG_TUH_CDC; idx++) {
     cdch_interface_t* p_cdc = &cdch_data[idx];
     if (p_cdc->daddr == daddr) {
-      TU_LOG_DRV("  CDCh close addr = %u index = %u\r\n", daddr, idx);
+      TU_LOG_P_CDC("close");
 
       // Invoke application callback
       if (tuh_cdc_umount_cb) tuh_cdc_umount_cb(idx);
@@ -722,33 +749,42 @@ static bool open_ep_stream_pair(cdch_interface_t* p_cdc, tusb_desc_endpoint_t co
 
 bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
   (void) rhport;
+  cdch_serial_driver_t const * driver_detected = NULL;
 
   // For CDC: only support ACM subclass
   // Note: Protocol 0xFF can be RNDIS device
   if (TUSB_CLASS_CDC                           == itf_desc->bInterfaceClass &&
       CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass) {
-    return acm_open(daddr, itf_desc, max_len);
-  }
-  else if (SERIAL_DRIVER_COUNT > 1 &&
-           TUSB_CLASS_VENDOR_SPECIFIC == itf_desc->bInterfaceClass) {
+    driver_detected = &serial_drivers[0];
+  } else if (SERIAL_DRIVER_COUNT > 1 && TUSB_CLASS_VENDOR_SPECIFIC == itf_desc->bInterfaceClass) {
     uint16_t vid, pid;
     TU_VERIFY(tuh_vid_pid_get(daddr, &vid, &pid));
 
     for (size_t dr = 1; dr < SERIAL_DRIVER_COUNT; dr++) {
-      cdch_serial_driver_t const* driver = &serial_drivers[dr];
+      cdch_serial_driver_t const * driver = &serial_drivers[dr];
       for (size_t i = 0; i < driver->vid_pid_count; i++) {
         if (driver->vid_pid_list[i][0] == vid && driver->vid_pid_list[i][1] == pid) {
-          return driver->open(daddr, itf_desc, max_len);
+          driver_detected = driver;
+          break;
         }
       }
+      if (driver_detected) {
+        break;
+      }
     }
   }
 
+  if (driver_detected) {
+    TU_LOG_CDC("open", daddr, itf_desc->bInterfaceNumber, driver_detected->name);
+    bool ret = driver_detected->open(daddr, itf_desc, max_len);
+    return ret;
+  }
+
   return false;
 }
 
 static void set_config_complete(cdch_interface_t * p_cdc, uint8_t idx, uint8_t itf_num) {
-  TU_LOG_DRV("CDCh Set Configure complete\r\n");
+  TU_LOG_P_CDC("set config complete");
   p_cdc->mounted = true;
   if (tuh_cdc_mount_cb) tuh_cdc_mount_cb(idx);
 
@@ -762,6 +798,10 @@ static void set_config_complete(cdch_interface_t * p_cdc, uint8_t idx, uint8_t i
 bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
   tusb_control_request_t request;
   request.wIndex = tu_htole16((uint16_t) itf_num);
+  uint8_t const idx = tuh_cdc_itf_get_index(daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  TU_LOG_P_CDC("set config");
 
   // fake transfer to kick-off process
   tuh_xfer_t xfer;
@@ -770,10 +810,6 @@ bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
   xfer.setup  = &request;
   xfer.user_data = 0; // initial state
 
-  uint8_t const idx = tuh_cdc_itf_get_index(daddr, itf_num);
-  cdch_interface_t * p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-
   serial_drivers[p_cdc->serial_drid].process_set_config(&xfer);
   return true;
 }
@@ -786,7 +822,6 @@ bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
 
 static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
-  TU_LOG_DRV("CDC ACM Set Control Line State\r\n");
 
   tusb_control_request_t const request = {
     .bmRequestType_bit = {
@@ -816,8 +851,6 @@ static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_st
 }
 
 static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC ACM Set Line Conding\r\n");
-
   tusb_control_request_t const request = {
     .bmRequestType_bit = {
       .recipient = TUSB_REQ_RCPT_INTERFACE,
@@ -850,7 +883,6 @@ static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const
 
 static bool acm_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
                                 tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC ACM Set Data Format\r\n");
 
   cdc_line_coding_t line_coding;
   line_coding.bit_rate = p_cdc->line_coding.bit_rate;
@@ -1000,7 +1032,6 @@ static bool ftdi_sio_reset(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, u
 
 static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(baudrate);
-  TU_LOG_DRV("CDC FTDI Set BaudRate = %lu, divisor = 0x%04x\r\n", baudrate, divisor);
 
   p_cdc->user_control_cb = complete_cb;
   p_cdc->requested_line_coding.bit_rate = baudrate;
@@ -1032,7 +1063,6 @@ static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t cons
 }
 
 static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC FTDI Set Control Line State\r\n");
   p_cdc->user_control_cb = complete_cb;
   TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_MODEM_CTRL, 0x0300 | line_state,
                                  complete_cb ? cdch_internal_control_complete : NULL, user_data));
@@ -1057,7 +1087,6 @@ static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint
   cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
   TU_VERIFY(p_cdc);
 
-  TU_LOG_DRV("FTDI opened\r\n");
   p_cdc->serial_drid = SERIAL_DRIVER_FTDI;
 
   // endpoint pair
@@ -1194,7 +1223,6 @@ static bool cp210x_ifc_enable(cdch_interface_t* p_cdc, uint16_t enabled, tuh_xfe
 //------------- Driver API -------------//
 
 static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC CP210x Set BaudRate = %lu\r\n", baudrate);
   uint32_t baud_le = tu_htole32(baudrate);
   p_cdc->user_control_cb = complete_cb;
   return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4,
@@ -1223,7 +1251,6 @@ static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t co
 }
 
 static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_LOG_DRV("CDC CP210x Set Control Line State\r\n");
   p_cdc->user_control_cb = complete_cb;
   return cp210x_set_request(p_cdc, CP210X_SET_MHS, 0x0300 | line_state, NULL, 0,
                             complete_cb ? cdch_internal_control_complete : NULL, user_data);
@@ -1247,7 +1274,6 @@ static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, ui
   cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
   TU_VERIFY(p_cdc);
 
-  TU_LOG_DRV("CP210x opened\r\n");
   p_cdc->serial_drid = SERIAL_DRIVER_CP210X;
 
   // endpoint pair
@@ -1508,7 +1534,6 @@ static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uin
   cdch_interface_t* p_cdc = make_new_itf(daddr, itf_desc);
   TU_VERIFY (p_cdc);
 
-  TU_LOG_DRV ("CH34x opened\r\n");
   p_cdc->serial_drid = SERIAL_DRIVER_CH34X;
 
   tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) tu_desc_next(itf_desc);
@@ -1538,14 +1563,13 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
 
   switch (state) {
     case CONFIG_CH34X_READ_VERSION:
-      TU_LOG_DRV("[%u] CDCh CH34x attempt to read Chip Version\r\n", p_cdc->daddr);
       TU_ASSERT (ch34x_control_in(p_cdc, CH34X_REQ_READ_VERSION, 0, 0, buffer, 2, ch34x_process_config, CONFIG_CH34X_SERIAL_INIT),);
       break;
 
     case CONFIG_CH34X_SERIAL_INIT: {
       // handle version read data, set CH34x line coding (incl. baudrate)
       uint8_t const version = xfer->buffer[0];
-      TU_LOG_DRV("[%u] CDCh CH34x Chip Version = %02x\r\n", p_cdc->daddr, version);
+      TU_LOG_P_CDC("Chip Version = %02x", version);
       // only versions >= 0x30 are tested, below 0x30 seems having other programming, see drivers from WCH vendor, Linux kernel and FreeBSD
       TU_ASSERT (version >= 0x30,);
       // init CH34x with line coding

From 829ea52873387f6fe269c44089c339cfd6d7c64e Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 22 Feb 2024 08:56:15 +0100
Subject: [PATCH 04/37] splitted cdch_internal_control_complete() into driver's
 _internal_control_complete() and moved them into driver's sections. no
 functional change

---
 src/class/cdc/cdc_host.c | 289 +++++++++++++++++++++------------------
 1 file changed, 154 insertions(+), 135 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 856db32fff..e39122e8f0 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -286,7 +286,6 @@ static cdch_interface_t* make_new_itf(uint8_t daddr, tusb_desc_interface_t const
 
 static bool open_ep_stream_pair(cdch_interface_t* p_cdc , tusb_desc_endpoint_t const *desc_ep);
 static void set_config_complete(cdch_interface_t * p_cdc, uint8_t idx, uint8_t itf_num);
-static void cdch_internal_control_complete(tuh_xfer_t* xfer);
 
 //--------------------------------------------------------------------+
 // APPLICATION API
@@ -422,127 +421,6 @@ bool tuh_cdc_read_clear (uint8_t idx) {
 // Control Endpoint API
 //--------------------------------------------------------------------+
 
-static void process_internal_control_complete(tuh_xfer_t* xfer, uint8_t itf_num) {
-  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
-  uint16_t const value = tu_le16toh(xfer->setup->wValue);
-  bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_P_CDC("control complete success = %u", success);
-
-  if (success) {
-    switch (p_cdc->serial_drid) {
-      case SERIAL_DRIVER_ACM:
-        switch (xfer->setup->bRequest) {
-          case CDC_REQUEST_SET_CONTROL_LINE_STATE:
-            p_cdc->line_state = (uint8_t) value;
-            break;
-
-          case CDC_REQUEST_SET_LINE_CODING: {
-            uint16_t const len = tu_min16(sizeof(cdc_line_coding_t), tu_le16toh(xfer->setup->wLength));
-            memcpy(&p_cdc->line_coding, xfer->buffer, len);
-            break;
-          }
-
-          default: break;
-        }
-        break;
-
-      #if CFG_TUH_CDC_FTDI
-      case SERIAL_DRIVER_FTDI:
-        switch (xfer->setup->bRequest) {
-          case FTDI_SIO_MODEM_CTRL:
-            p_cdc->line_state = (uint8_t) value;
-            break;
-
-          case FTDI_SIO_SET_BAUD_RATE:
-            p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-            break;
-
-          default: break;
-        }
-        break;
-      #endif
-
-      #if CFG_TUH_CDC_CP210X
-      case SERIAL_DRIVER_CP210X:
-        switch(xfer->setup->bRequest) {
-          case CP210X_SET_MHS:
-            p_cdc->line_state = (uint8_t) value;
-            break;
-
-          case CP210X_SET_BAUDRATE: {
-            uint32_t baudrate;
-            memcpy(&baudrate, xfer->buffer, sizeof(uint32_t));
-            p_cdc->line_coding.bit_rate = tu_le32toh(baudrate);
-            break;
-          }
-
-          default: break;
-        }
-        break;
-      #endif
-
-      #if CFG_TUH_CDC_CH34X
-      case SERIAL_DRIVER_CH34X:
-        switch (xfer->setup->bRequest) {
-          case CH34X_REQ_WRITE_REG:
-            // register write request
-            switch (value) {
-              case CH34X_REG16_DIVISOR_PRESCALER:
-                // baudrate
-                p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-                break;
-
-              case CH32X_REG16_LCR2_LCR:
-                // data format
-                p_cdc->line_coding.stop_bits = p_cdc->requested_line_coding.stop_bits;
-                p_cdc->line_coding.parity = p_cdc->requested_line_coding.parity;
-                p_cdc->line_coding.data_bits = p_cdc->requested_line_coding.data_bits;
-                break;
-
-              default: break;
-            }
-            break;
-
-          case CH34X_REQ_MODEM_CTRL: {
-            // set modem controls RTS/DTR request. Note: signals are inverted
-            uint16_t const modem_signal = ~value;
-            if (modem_signal & CH34X_BIT_RTS) {
-              p_cdc->line_state |= CDC_CONTROL_LINE_STATE_RTS;
-            } else {
-              p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_RTS;
-            }
-
-            if (modem_signal & CH34X_BIT_DTR) {
-              p_cdc->line_state |= CDC_CONTROL_LINE_STATE_DTR;
-            } else {
-              p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_DTR;
-            }
-            break;
-          }
-
-          default: break;
-        }
-        break;
-      #endif
-
-      default: break;
-    }
-  }
-
-  xfer->complete_cb = p_cdc->user_control_cb;
-  if (xfer->complete_cb) {
-    xfer->complete_cb(xfer);
-  }
-}
-
-// internal control complete to update state such as line state, encoding
-static void cdch_internal_control_complete(tuh_xfer_t* xfer) {
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  process_internal_control_complete(xfer, itf_num);
-}
-
 bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
@@ -820,6 +698,36 @@ bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
 
 //------------- Driver API -------------//
 
+// internal control complete to update state such as line state, encoding
+static void acm_internal_control_complete(tuh_xfer_t * xfer) {
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+  bool const success = (xfer->result == XFER_RESULT_SUCCESS);
+  TU_LOG_P_CDC("control complete success = %u", success);
+
+  if (success) {
+    switch (xfer->setup->bRequest) {
+      case CDC_REQUEST_SET_CONTROL_LINE_STATE:
+        p_cdc->line_state = (uint8_t) tu_le16toh(xfer->setup->wValue);
+        break;
+
+      case CDC_REQUEST_SET_LINE_CODING:
+        uint16_t const len = tu_min16(sizeof(cdc_line_coding_t), tu_le16toh(xfer->setup->wLength));
+        memcpy(&p_cdc->line_coding, xfer->buffer, len);
+        break;
+
+      default: break;
+    }
+  }
+
+  xfer->complete_cb = p_cdc->user_control_cb;
+  if (xfer->complete_cb) {
+    xfer->complete_cb(xfer);
+  }
+}
+
 static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
 
@@ -842,7 +750,7 @@ static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_st
     .ep_addr     = 0,
     .setup       = &request,
     .buffer      = NULL,
-    .complete_cb = complete_cb ? cdch_internal_control_complete : NULL, // complete_cb is NULL for sync call
+    .complete_cb = complete_cb ? acm_internal_control_complete : NULL, // complete_cb is NULL for sync call
     .user_data   = user_data
   };
 
@@ -873,7 +781,7 @@ static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const
     .ep_addr     = 0,
     .setup       = &request,
     .buffer      = enum_buf,
-    .complete_cb = complete_cb ? cdch_internal_control_complete : NULL, // complete_cb is NULL for sync call
+    .complete_cb = complete_cb ? acm_internal_control_complete : NULL, // complete_cb is NULL for sync call
     .user_data   = user_data
   };
 
@@ -1030,13 +938,42 @@ static bool ftdi_sio_reset(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, u
 
 //------------- Driver API -------------//
 
+// internal control complete to update state such as line state, line_coding
+static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+  bool const success = (xfer->result == XFER_RESULT_SUCCESS);
+  TU_LOG_P_CDC("control complete success = %u", success);
+
+  if (success) {
+    switch (xfer->setup->bRequest) {
+      case FTDI_SIO_MODEM_CTRL:
+        p_cdc->line_state = (uint8_t) tu_le16toh(xfer->setup->wValue);
+        break;
+
+      case FTDI_SIO_SET_BAUD_RATE:
+        p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
+        break;
+
+      default: break;
+    }
+  }
+
+  xfer->complete_cb = p_cdc->user_control_cb;
+  if (xfer->complete_cb) {
+    xfer->complete_cb(xfer);
+  }
+}
+
 static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(baudrate);
 
   p_cdc->user_control_cb = complete_cb;
   p_cdc->requested_line_coding.bit_rate = baudrate;
   TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_SET_BAUD_RATE, divisor,
-                                 complete_cb ? cdch_internal_control_complete : NULL, user_data));
+                                 complete_cb ? ftdi_internal_control_complete : NULL, user_data));
 
   return true;
 }
@@ -1065,7 +1002,7 @@ static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t cons
 static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
   TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_MODEM_CTRL, 0x0300 | line_state,
-                                 complete_cb ? cdch_internal_control_complete : NULL, user_data));
+                                 complete_cb ? ftdi_internal_control_complete : NULL, user_data));
   return true;
 }
 
@@ -1222,11 +1159,42 @@ static bool cp210x_ifc_enable(cdch_interface_t* p_cdc, uint16_t enabled, tuh_xfe
 
 //------------- Driver API -------------//
 
+// internal control complete to update state such as line state, encoding
+static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+  bool const success = (xfer->result == XFER_RESULT_SUCCESS);
+  TU_LOG_P_CDC("control complete success = %u", success);
+
+  if (success) {
+    switch(xfer->setup->bRequest) {
+      case CP210X_SET_MHS:
+        p_cdc->line_state = (uint8_t) tu_le16toh(xfer->setup->wValue);
+        break;
+
+      case CP210X_SET_BAUDRATE:
+        uint32_t baudrate;
+        memcpy(&baudrate, xfer->buffer, sizeof(uint32_t));
+        p_cdc->line_coding.bit_rate = tu_le32toh(baudrate);
+        break;
+
+      default: break;
+    }
+  }
+
+  xfer->complete_cb = p_cdc->user_control_cb;
+  if (xfer->complete_cb) {
+    xfer->complete_cb(xfer);
+  }
+}
+
 static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   uint32_t baud_le = tu_htole32(baudrate);
   p_cdc->user_control_cb = complete_cb;
   return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4,
-                            complete_cb ? cdch_internal_control_complete : NULL, user_data);
+                            complete_cb ? cp210x_internal_control_complete : NULL, user_data);
 }
 
 static bool cp210x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
@@ -1253,7 +1221,7 @@ static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t co
 static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
   return cp210x_set_request(p_cdc, CP210X_SET_MHS, 0x0300 | line_state, NULL, 0,
-                            complete_cb ? cdch_internal_control_complete : NULL, user_data);
+                            complete_cb ? cp210x_internal_control_complete : NULL, user_data);
 }
 
 //------------- Enumeration -------------//
@@ -1412,9 +1380,60 @@ static bool ch34x_write_reg_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate,
 //------------- Driver API -------------//
 
 // internal control complete to update state such as line state, encoding
-static void ch34x_control_complete(tuh_xfer_t* xfer) {
-  // CH34x only has 1 interface and use wIndex as payload and not for bInterfaceNumber
-  process_internal_control_complete(xfer, 0);
+static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
+  // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
+  uint8_t const itf_num = 0;
+  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+  bool const success = (xfer->result == XFER_RESULT_SUCCESS);
+  TU_LOG_P_CDC("control complete success = %u", success);
+
+  if (success) {
+    switch (xfer->setup->bRequest) {
+      case CH34X_REQ_WRITE_REG:
+        // register write request
+        switch (tu_le16toh(xfer->setup->wValue)) {
+          case CH34X_REG16_DIVISOR_PRESCALER:
+            // baudrate
+            p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
+            break;
+
+          case CH32X_REG16_LCR2_LCR:
+            // data format
+            p_cdc->line_coding.stop_bits = p_cdc->requested_line_coding.stop_bits;
+            p_cdc->line_coding.parity    = p_cdc->requested_line_coding.parity;
+            p_cdc->line_coding.data_bits = p_cdc->requested_line_coding.data_bits;
+            break;
+
+          default: break;
+        }
+        break;
+
+      case CH34X_REQ_MODEM_CTRL:
+        // set modem controls RTS/DTR request. Note: signals are inverted
+        uint16_t const modem_signal = ~tu_le16toh(xfer->setup->wValue);
+        if (modem_signal & CH34X_BIT_RTS) {
+          p_cdc->line_state |= CDC_CONTROL_LINE_STATE_RTS;
+        } else {
+          p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_RTS;
+        }
+
+        if (modem_signal & CH34X_BIT_DTR) {
+          p_cdc->line_state |= CDC_CONTROL_LINE_STATE_DTR;
+        } else {
+          p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_DTR;
+        }
+        break;
+
+      default: break;
+    }
+  }
+
+  xfer->complete_cb = p_cdc->user_control_cb;
+  if (xfer->complete_cb) {
+    xfer->complete_cb(xfer);
+  }
 }
 
 static bool ch34x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
@@ -1426,7 +1445,7 @@ static bool ch34x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, ui
   uint8_t const lcr = ch34x_get_lcr(stop_bits, parity, data_bits);
   TU_VERIFY(lcr);
   TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_WRITE_REG, CH32X_REG16_LCR2_LCR, lcr,
-                               complete_cb ? ch34x_control_complete : NULL, user_data));
+                               complete_cb ? ch34x_internal_control_complete : NULL, user_data));
   return true;
 }
 
@@ -1435,7 +1454,7 @@ static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate,
   p_cdc->requested_line_coding.bit_rate = baudrate;
   p_cdc->user_control_cb = complete_cb;
   TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, baudrate,
-                                     complete_cb ? ch34x_control_complete : NULL, user_data));
+                                     complete_cb ? ch34x_internal_control_complete : NULL, user_data));
   return true;
 }
 
@@ -1450,7 +1469,7 @@ static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t* xfer) {
     // stage 1 success, continue to stage 2
     p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
     TU_ASSERT(ch34x_set_data_format(p_cdc, p_cdc->requested_line_coding.stop_bits, p_cdc->requested_line_coding.parity,
-                                    p_cdc->requested_line_coding.data_bits, ch34x_control_complete, xfer->user_data), );
+                                    p_cdc->requested_line_coding.data_bits, ch34x_internal_control_complete, xfer->user_data), );
   } else {
     // stage 1 failed, notify user
     xfer->complete_cb = p_cdc->user_control_cb;
@@ -1511,7 +1530,7 @@ static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state,
 
   p_cdc->user_control_cb = complete_cb;
   TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_MODEM_CTRL, control, 0,
-                               complete_cb ? ch34x_control_complete : NULL, user_data));
+                               complete_cb ? ch34x_internal_control_complete : NULL, user_data));
   return true;
 }
 

From 2f50f5a4263dc3d65f3bf96b593edac5ac271a5a Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 22 Feb 2024 14:59:16 +0100
Subject: [PATCH 05/37] changed to use of p_cdc->requested_line_coding

---
 src/class/cdc/cdc_host.c | 215 +++++++++++++++++----------------------
 1 file changed, 96 insertions(+), 119 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index e39122e8f0..b2ba7c9ea7 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -63,12 +63,10 @@ typedef struct {
   cdc_acm_capability_t acm_capability;
 
   TU_ATTR_ALIGNED(4) cdc_line_coding_t line_coding; // Baudrate, stop bits, parity, data width
-  uint8_t line_state;                               // DTR (bit0), RTS (bit1)
-
-  #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_CP210X || CFG_TUH_CDC_CH34X
-  cdc_line_coding_t requested_line_coding;
+  TU_ATTR_ALIGNED(4) cdc_line_coding_t requested_line_coding;
   // 1 byte padding
-  #endif
+
+  uint8_t line_state;                               // DTR (bit0), RTS (bit1)
 
   tuh_xfer_cb_t user_control_cb;
 
@@ -95,9 +93,9 @@ static cdch_interface_t cdch_data[CFG_TUH_CDC];
 static bool acm_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
 static void acm_process_config(tuh_xfer_t* xfer);
 
-static bool acm_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 //------------- FTDI prototypes -------------//
@@ -109,9 +107,9 @@ static uint16_t const ftdi_vid_pid_list[][2] = {CFG_TUH_CDC_FTDI_VID_PID_LIST};
 static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
 static void ftdi_process_config(tuh_xfer_t* xfer);
 
-static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
@@ -124,9 +122,9 @@ static uint16_t const cp210x_vid_pid_list[][2] = {CFG_TUH_CDC_CP210X_VID_PID_LIS
 static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
 static void cp210x_process_config(tuh_xfer_t* xfer);
 
-static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
@@ -139,9 +137,9 @@ static uint16_t const ch34x_vid_pid_list[][2] = {CFG_TUH_CDC_CH34X_VID_PID_LIST}
 static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len);
 static void ch34x_process_config(tuh_xfer_t* xfer);
 
-static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
@@ -170,9 +168,9 @@ typedef struct {
   bool (*const open)(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
   void (*const process_set_config)(tuh_xfer_t* xfer);
   bool (*const set_control_line_state)(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_baudrate)(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_data_format)(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_line_coding)(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const set_baudrate)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const set_data_format)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const set_line_coding)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
   #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
   uint8_t const * name;
   #endif
@@ -276,6 +274,7 @@ static cdch_interface_t* make_new_itf(uint8_t daddr, tusb_desc_interface_t const
       p_cdc->bInterfaceNumber   = itf_desc->bInterfaceNumber;
       p_cdc->bInterfaceSubClass = itf_desc->bInterfaceSubClass;
       p_cdc->bInterfaceProtocol = itf_desc->bInterfaceProtocol;
+      p_cdc->line_coding        = (cdc_line_coding_t) { 0, 0, 0, 0 };
       p_cdc->line_state         = 0;
       return p_cdc;
     }
@@ -451,12 +450,14 @@ bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete
   TU_LOG_P_CDC("set baudrate = %lu", baudrate);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
+  p_cdc->requested_line_coding.bit_rate = baudrate;
+
   if (complete_cb) {
-    return driver->set_baudrate(p_cdc, baudrate, complete_cb, user_data);
+    return driver->set_baudrate(p_cdc, complete_cb, user_data);
   } else {
     // blocking
     xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_baudrate(p_cdc, baudrate, complete_cb, (uintptr_t) &result);
+    bool ret = driver->set_baudrate(p_cdc, complete_cb, (uintptr_t) &result);
 
     if (user_data) {
       // user_data is not NULL, return result via user_data
@@ -477,12 +478,16 @@ bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uin
                data_bits, parity, stop_bits);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
+  p_cdc->requested_line_coding.stop_bits = stop_bits;
+  p_cdc->requested_line_coding.parity    = parity;
+  p_cdc->requested_line_coding.data_bits = data_bits;
+
   if (complete_cb) {
-    return driver->set_data_format(p_cdc, stop_bits, parity, data_bits, complete_cb, user_data);
+    return driver->set_data_format(p_cdc, complete_cb, user_data);
   } else {
     // blocking
     xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_data_format(p_cdc, stop_bits, parity, data_bits, complete_cb, (uintptr_t) &result);
+    bool ret = driver->set_data_format(p_cdc, complete_cb, (uintptr_t) &result);
 
     if (user_data) {
       // user_data is not NULL, return result via user_data
@@ -491,7 +496,7 @@ bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uin
 
     TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
     p_cdc->line_coding.stop_bits = stop_bits;
-    p_cdc->line_coding.parity = parity;
+    p_cdc->line_coding.parity    = parity;
     p_cdc->line_coding.data_bits = data_bits;
     return true;
   }
@@ -504,12 +509,14 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const* line_coding,
                line_coding->bit_rate, line_coding->data_bits, line_coding->parity, line_coding->stop_bits);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
+  p_cdc->requested_line_coding = *line_coding;
+
   if ( complete_cb ) {
-    return driver->set_line_coding(p_cdc, line_coding, complete_cb, user_data);
+    return driver->set_line_coding(p_cdc, complete_cb, user_data);
   } else {
     // blocking
     xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_line_coding(p_cdc, line_coding, complete_cb, (uintptr_t) &result);
+    bool ret = driver->set_line_coding(p_cdc, complete_cb, (uintptr_t) &result);
 
     if (user_data) {
       // user_data is not NULL, return result via user_data
@@ -714,8 +721,7 @@ static void acm_internal_control_complete(tuh_xfer_t * xfer) {
         break;
 
       case CDC_REQUEST_SET_LINE_CODING:
-        uint16_t const len = tu_min16(sizeof(cdc_line_coding_t), tu_le16toh(xfer->setup->wLength));
-        memcpy(&p_cdc->line_coding, xfer->buffer, len);
+        p_cdc->line_coding = p_cdc->requested_line_coding;
         break;
 
       default: break;
@@ -758,7 +764,7 @@ static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_st
   return true;
 }
 
-static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool acm_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   tusb_control_request_t const request = {
     .bmRequestType_bit = {
       .recipient = TUSB_REQ_RCPT_INTERFACE,
@@ -773,7 +779,7 @@ static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const
 
   // use usbh enum buf to hold line coding since user line_coding variable does not live long enough
   uint8_t* enum_buf = usbh_get_enum_buf();
-  memcpy(enum_buf, line_coding, sizeof(cdc_line_coding_t));
+  memcpy(enum_buf, &p_cdc->requested_line_coding, sizeof(cdc_line_coding_t));
 
   p_cdc->user_control_cb = complete_cb;
   tuh_xfer_t xfer = {
@@ -789,23 +795,19 @@ static bool acm_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const
   return true;
 }
 
-static bool acm_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-
-  cdc_line_coding_t line_coding;
-  line_coding.bit_rate = p_cdc->line_coding.bit_rate;
-  line_coding.stop_bits = stop_bits;
-  line_coding.parity = parity;
-  line_coding.data_bits = data_bits;
+static bool acm_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->requested_line_coding.bit_rate = p_cdc->line_coding.bit_rate;
 
-  return acm_set_line_coding(p_cdc, &line_coding, complete_cb, user_data);
+  return acm_set_line_coding(p_cdc, complete_cb, user_data);
 }
 
-static bool acm_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool acm_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->requested_line_coding.stop_bits = p_cdc->line_coding.stop_bits;
+  p_cdc->requested_line_coding.parity    = p_cdc->line_coding.parity;
+  p_cdc->requested_line_coding.data_bits = p_cdc->line_coding.data_bits;
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
-  cdc_line_coding_t line_coding = p_cdc->line_coding;
-  line_coding.bit_rate = baudrate;
-  return acm_set_line_coding(p_cdc, &line_coding, complete_cb, user_data);
+
+  return acm_set_line_coding(p_cdc, complete_cb, user_data);
 }
 
 //------------- Enumeration -------------//
@@ -879,11 +881,11 @@ static void acm_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_ACM_SET_LINE_CODING:
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      if (p_cdc->acm_capability.support_line_request) {
-        cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-        TU_ASSERT(acm_set_line_coding(p_cdc, &line_coding, acm_process_config, CONFIG_ACM_COMPLETE),);
-        break;
-      }
+        if (p_cdc->acm_capability.support_line_request) {
+          p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM;
+          TU_ASSERT(acm_set_line_coding(p_cdc, acm_process_config, CONFIG_ACM_COMPLETE),);
+          break;
+        }
       #endif
       TU_ATTR_FALLTHROUGH;
 
@@ -902,7 +904,7 @@ static void acm_process_config(tuh_xfer_t* xfer) {
 //--------------------------------------------------------------------+
 #if CFG_TUH_CDC_FTDI
 
-static uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud);
+static uint32_t ftdi_232bm_baud_to_divisor(cdch_interface_t* p_cdc);
 
 //------------- Control Request -------------//
 
@@ -967,32 +969,26 @@ static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(baudrate);
+static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(p_cdc);
 
   p_cdc->user_control_cb = complete_cb;
-  p_cdc->requested_line_coding.bit_rate = baudrate;
   TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_SET_BAUD_RATE, divisor,
                                  complete_cb ? ftdi_internal_control_complete : NULL, user_data));
 
   return true;
 }
 
-static bool ftdi_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                 tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ftdi_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   (void) p_cdc;
-  (void) stop_bits;
-  (void) parity;
-  (void) data_bits;
   (void) complete_cb;
   (void) user_data;
   // TODO not implemented yet
   return false;
 }
 
-static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   (void) p_cdc;
-  (void) line_coding;
   (void) complete_cb;
   (void) user_data;
   // TODO not implemented yet
@@ -1056,11 +1052,11 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_FTDI_SET_BAUDRATE: {
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      TU_ASSERT(ftdi_sio_set_baudrate(p_cdc, line_coding.bit_rate, ftdi_process_config, CONFIG_FTDI_SET_DATA),);
-      break;
+        p_cdc->requested_line_coding.bit_rate = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM).bit_rate;
+        TU_ASSERT(ftdi_sio_set_baudrate(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_DATA),);
+        break;
       #else
-      TU_ATTR_FALLTHROUGH;
+        TU_ATTR_FALLTHROUGH;
       #endif
     }
 
@@ -1107,8 +1103,8 @@ static uint32_t ftdi_232bm_baud_base_to_divisor(uint32_t baud, uint32_t base) {
   return divisor;
 }
 
-static uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud) {
-  return ftdi_232bm_baud_base_to_divisor(baud, 48000000u);
+static uint32_t ftdi_232bm_baud_to_divisor(cdch_interface_t* p_cdc) {
+  return ftdi_232bm_baud_base_to_divisor(p_cdc->requested_line_coding.bit_rate, 48000000u);
 }
 
 #endif
@@ -1175,9 +1171,7 @@ static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
         break;
 
       case CP210X_SET_BAUDRATE:
-        uint32_t baudrate;
-        memcpy(&baudrate, xfer->buffer, sizeof(uint32_t));
-        p_cdc->line_coding.bit_rate = tu_le32toh(baudrate);
+        p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
         break;
 
       default: break;
@@ -1190,29 +1184,24 @@ static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint32_t baud_le = tu_htole32(baudrate);
+static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint32_t baud_le = tu_htole32(p_cdc->requested_line_coding.bit_rate);
   p_cdc->user_control_cb = complete_cb;
   return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4,
                             complete_cb ? cp210x_internal_control_complete : NULL, user_data);
 }
 
-static bool cp210x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                   tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool cp210x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   (void) p_cdc;
-  (void) stop_bits;
-  (void) parity;
-  (void) data_bits;
   (void) complete_cb;
   (void) user_data;
   // TODO not implemented yet
   return false;
 }
 
-static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   // TODO implement later
   (void) p_cdc;
-  (void) line_coding;
   (void) complete_cb;
   (void) user_data;
   return false;
@@ -1265,11 +1254,11 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_CP210X_SET_BAUDRATE: {
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      TU_ASSERT(cp210x_set_baudrate(p_cdc, line_coding.bit_rate, cp210x_process_config, CONFIG_CP210X_SET_LINE_CTL),);
-      break;
+        p_cdc->requested_line_coding.bit_rate = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM).bit_rate;
+        TU_ASSERT(cp210x_set_baudrate(p_cdc, cp210x_process_config, CONFIG_CP210X_SET_LINE_CTL),);
+        break;
       #else
-      TU_ATTR_FALLTHROUGH;
+        TU_ATTR_FALLTHROUGH;
       #endif
     }
 
@@ -1306,8 +1295,8 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
 
 #if CFG_TUH_CDC_CH34X
 
-static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bits);
-static uint16_t ch34x_get_divisor_prescaler(uint32_t baval);
+static uint8_t ch34x_get_lcr(cdch_interface_t * p_cdc);
+static uint16_t ch34x_get_divisor_prescaler(cdch_interface_t * p_cdc);
 
 //------------- Control Request -------------//
 
@@ -1368,9 +1357,8 @@ static inline bool ch34x_write_reg(cdch_interface_t* p_cdc, uint16_t reg, uint16
 //  return ch34x_control_in ( p_cdc, CH34X_REQ_READ_REG, reg, 0, buffer, buffersize, complete_cb, user_data );
 //}
 
-static bool ch34x_write_reg_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate,
-                                     tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint16_t const div_ps = ch34x_get_divisor_prescaler(baudrate);
+static bool ch34x_write_reg_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint16_t const div_ps = ch34x_get_divisor_prescaler(p_cdc);
   TU_VERIFY(div_ps);
   TU_ASSERT(ch34x_write_reg(p_cdc, CH34X_REG16_DIVISOR_PRESCALER, div_ps,
                             complete_cb, user_data));
@@ -1436,25 +1424,17 @@ static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool ch34x_set_data_format(cdch_interface_t* p_cdc, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
-                                tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  p_cdc->requested_line_coding.stop_bits = stop_bits;
-  p_cdc->requested_line_coding.parity = parity;
-  p_cdc->requested_line_coding.data_bits = data_bits;
-
-  uint8_t const lcr = ch34x_get_lcr(stop_bits, parity, data_bits);
+static bool ch34x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint8_t const lcr = ch34x_get_lcr(p_cdc);
   TU_VERIFY(lcr);
   TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_WRITE_REG, CH32X_REG16_LCR2_LCR, lcr,
                                complete_cb ? ch34x_internal_control_complete : NULL, user_data));
   return true;
 }
 
-static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, uint32_t baudrate,
-                               tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  p_cdc->requested_line_coding.bit_rate = baudrate;
+static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, baudrate,
-                                     complete_cb ? ch34x_internal_control_complete : NULL, user_data));
+  TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, complete_cb ? ch34x_internal_control_complete : NULL, user_data));
   return true;
 }
 
@@ -1468,8 +1448,7 @@ static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t* xfer) {
   if (xfer->result == XFER_RESULT_SUCCESS) {
     // stage 1 success, continue to stage 2
     p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-    TU_ASSERT(ch34x_set_data_format(p_cdc, p_cdc->requested_line_coding.stop_bits, p_cdc->requested_line_coding.parity,
-                                    p_cdc->requested_line_coding.data_bits, ch34x_internal_control_complete, xfer->user_data), );
+    TU_ASSERT(ch34x_set_data_format(p_cdc, ch34x_internal_control_complete, xfer->user_data), );
   } else {
     // stage 1 failed, notify user
     xfer->complete_cb = p_cdc->user_control_cb;
@@ -1480,31 +1459,24 @@ static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t* xfer) {
 }
 
 // 2 stages: set baudrate (stage1) + set data format (stage2)
-static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, cdc_line_coding_t const* line_coding,
-                                  tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  p_cdc->requested_line_coding = *line_coding;
+static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
 
   if (complete_cb) {
     // stage 1 set baudrate
-    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, line_coding->bit_rate,
-                                       ch34x_set_line_coding_stage1_complete, user_data));
+    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, ch34x_set_line_coding_stage1_complete, user_data));
   } else {
     // sync call
     xfer_result_t result;
 
     // stage 1 set baudrate
-    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, line_coding->bit_rate, NULL, (uintptr_t) &result));
+    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, NULL, (uintptr_t) &result));
     TU_VERIFY(result == XFER_RESULT_SUCCESS);
-    p_cdc->line_coding.bit_rate = line_coding->bit_rate;
+    p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
 
     // stage 2 set data format
-    TU_ASSERT(ch34x_set_data_format(p_cdc, line_coding->stop_bits, line_coding->parity, line_coding->data_bits,
-                                    NULL, (uintptr_t) &result));
+    TU_ASSERT(ch34x_set_data_format(p_cdc, NULL, (uintptr_t) &result));
     TU_VERIFY(result == XFER_RESULT_SUCCESS);
-    p_cdc->line_coding.stop_bits = line_coding->stop_bits;
-    p_cdc->line_coding.parity = line_coding->parity;
-    p_cdc->line_coding.data_bits = line_coding->data_bits;
 
     // update transfer result, user_data is expected to point to xfer_result_t
     if (user_data) {
@@ -1592,10 +1564,10 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
       // only versions >= 0x30 are tested, below 0x30 seems having other programming, see drivers from WCH vendor, Linux kernel and FreeBSD
       TU_ASSERT (version >= 0x30,);
       // init CH34x with line coding
-      cdc_line_coding_t const line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
-      uint16_t const div_ps = ch34x_get_divisor_prescaler(line_coding.bit_rate);
+      p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
+      uint16_t const div_ps = ch34x_get_divisor_prescaler(p_cdc);
       TU_ASSERT(div_ps, );
-      uint8_t const lcr = ch34x_get_lcr(line_coding.stop_bits, line_coding.parity, line_coding.data_bits);
+      uint8_t const lcr = ch34x_get_lcr(p_cdc);
       TU_ASSERT(lcr, );
       TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_SERIAL_INIT, tu_u16(lcr, 0x9c), div_ps,
                                    ch34x_process_config, CONFIG_CH34X_SPECIAL_REG_WRITE),);
@@ -1604,7 +1576,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_CH34X_SPECIAL_REG_WRITE:
       // overtake line coding and do special reg write, purpose unknown, overtaken from WCH driver
-      p_cdc->line_coding = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X);
+      p_cdc->line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
       TU_ASSERT (ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x0F, CH341_REG_0x2C), 0x0007, ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL),);
       break;
 
@@ -1631,7 +1603,8 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
 //------------- Helper -------------//
 
 // calculate divisor and prescaler for baudrate, return it as 16-bit combined value
-static uint16_t ch34x_get_divisor_prescaler(uint32_t baval) {
+static uint16_t ch34x_get_divisor_prescaler(cdch_interface_t * p_cdc) {
+  uint32_t const baval = p_cdc->requested_line_coding.bit_rate;
   uint8_t a;
   uint8_t b;
   uint32_t c;
@@ -1680,7 +1653,11 @@ static uint16_t ch34x_get_divisor_prescaler(uint32_t baval) {
 }
 
 // calculate lcr value from data coding
-static uint8_t ch34x_get_lcr(uint8_t stop_bits, uint8_t parity, uint8_t data_bits) {
+static uint8_t ch34x_get_lcr(cdch_interface_t * p_cdc) {
+  uint8_t const stop_bits = p_cdc->requested_line_coding.stop_bits;
+  uint8_t const parity    = p_cdc->requested_line_coding.parity;
+  uint8_t const data_bits = p_cdc->requested_line_coding.data_bits;
+
   uint8_t lcr = CH34X_LCR_ENABLE_RX | CH34X_LCR_ENABLE_TX;
   TU_VERIFY(data_bits >= 5 && data_bits <= 8, 0);
   lcr |= (uint8_t) (data_bits - 5);

From 7dd435cb877f5d3e0b9576dfcdb8c40e9a03c399 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Tue, 20 Feb 2024 20:45:50 +0100
Subject: [PATCH 06/37] changed to use of p_cdc->requested_line_state

---
 src/class/cdc/cdc_host.c | 82 +++++++++++++++++++---------------------
 1 file changed, 38 insertions(+), 44 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index b2ba7c9ea7..0af429e4b1 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -67,6 +67,7 @@ typedef struct {
   // 1 byte padding
 
   uint8_t line_state;                               // DTR (bit0), RTS (bit1)
+  uint8_t requested_line_state;
 
   tuh_xfer_cb_t user_control_cb;
 
@@ -96,7 +97,7 @@ static void acm_process_config(tuh_xfer_t* xfer);
 static bool acm_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool acm_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool acm_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_control_line_state(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 //------------- FTDI prototypes -------------//
 #if CFG_TUH_CDC_FTDI
@@ -110,7 +111,7 @@ static void ftdi_process_config(tuh_xfer_t* xfer);
 static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ftdi_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- CP210X prototypes -------------//
@@ -125,7 +126,7 @@ static void cp210x_process_config(tuh_xfer_t* xfer);
 static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool cp210x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- CH34x prototypes -------------//
@@ -140,7 +141,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer);
 static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ch34x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- Common -------------//
@@ -167,7 +168,7 @@ typedef struct {
   uint16_t const vid_pid_count;
   bool (*const open)(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
   void (*const process_set_config)(tuh_xfer_t* xfer);
-  bool (*const set_control_line_state)(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const set_control_line_state)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
   bool (*const set_baudrate)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
   bool (*const set_data_format)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
   bool (*const set_line_coding)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
@@ -426,12 +427,14 @@ bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_c
   TU_LOG_P_CDC("set control line state line_state = %u", line_state);
   cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
 
+  p_cdc->requested_line_state = (uint8_t) line_state;
+
   if (complete_cb) {
-    return driver->set_control_line_state(p_cdc, line_state, complete_cb, user_data);
+    return driver->set_control_line_state(p_cdc, complete_cb, user_data);
   } else {
     // blocking
     xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_control_line_state(p_cdc, line_state, complete_cb, (uintptr_t) &result);
+    bool ret = driver->set_control_line_state(p_cdc, complete_cb, (uintptr_t) &result);
 
     if (user_data) {
       // user_data is not NULL, return result via user_data
@@ -717,7 +720,7 @@ static void acm_internal_control_complete(tuh_xfer_t * xfer) {
   if (success) {
     switch (xfer->setup->bRequest) {
       case CDC_REQUEST_SET_CONTROL_LINE_STATE:
-        p_cdc->line_state = (uint8_t) tu_le16toh(xfer->setup->wValue);
+        p_cdc->line_state = p_cdc->requested_line_state;
         break;
 
       case CDC_REQUEST_SET_LINE_CODING:
@@ -734,7 +737,7 @@ static void acm_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool acm_set_control_line_state(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
 
   tusb_control_request_t const request = {
@@ -744,7 +747,7 @@ static bool acm_set_control_line_state(cdch_interface_t* p_cdc, uint16_t line_st
       .direction = TUSB_DIR_OUT
     },
     .bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE,
-    .wValue   = tu_htole16(line_state),
+    .wValue   = tu_htole16(p_cdc->requested_line_state),
     .wIndex   = tu_htole16((uint16_t) p_cdc->bInterfaceNumber),
     .wLength  = 0
   };
@@ -872,10 +875,11 @@ static void acm_process_config(tuh_xfer_t* xfer) {
   switch (state) {
     case CONFIG_ACM_SET_CONTROL_LINE_STATE:
       #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-      if (p_cdc->acm_capability.support_line_request) {
-        TU_ASSERT(acm_set_control_line_state(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, acm_process_config, CONFIG_ACM_SET_LINE_CODING),);
-        break;
-      }
+        if (p_cdc->acm_capability.support_line_request) {
+          p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+          TU_ASSERT(acm_set_control_line_state(p_cdc, acm_process_config, CONFIG_ACM_SET_LINE_CODING),);
+          break;
+        }
       #endif
       TU_ATTR_FALLTHROUGH;
 
@@ -952,7 +956,7 @@ static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
   if (success) {
     switch (xfer->setup->bRequest) {
       case FTDI_SIO_MODEM_CTRL:
-        p_cdc->line_state = (uint8_t) tu_le16toh(xfer->setup->wValue);
+        p_cdc->line_state = p_cdc->requested_line_state;
         break;
 
       case FTDI_SIO_SET_BAUD_RATE:
@@ -995,9 +999,9 @@ static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete
   return false;
 }
 
-static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_MODEM_CTRL, 0x0300 | line_state,
+  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_MODEM_CTRL, 0x0300 | p_cdc->requested_line_state,
                                  complete_cb ? ftdi_internal_control_complete : NULL, user_data));
   return true;
 }
@@ -1044,10 +1048,11 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_FTDI_MODEM_CTRL:
       #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-      TU_ASSERT(ftdi_sio_set_modem_ctrl(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, ftdi_process_config, CONFIG_FTDI_SET_BAUDRATE),);
-      break;
+        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        TU_ASSERT(ftdi_sio_set_modem_ctrl(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_BAUDRATE),);
+        break;
       #else
-      TU_ATTR_FALLTHROUGH;
+        TU_ATTR_FALLTHROUGH;
       #endif
 
     case CONFIG_FTDI_SET_BAUDRATE: {
@@ -1167,7 +1172,7 @@ static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
   if (success) {
     switch(xfer->setup->bRequest) {
       case CP210X_SET_MHS:
-        p_cdc->line_state = (uint8_t) tu_le16toh(xfer->setup->wValue);
+        p_cdc->line_state = p_cdc->requested_line_state;
         break;
 
       case CP210X_SET_BAUDRATE:
@@ -1207,9 +1212,9 @@ static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t comple
   return false;
 }
 
-static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  return cp210x_set_request(p_cdc, CP210X_SET_MHS, 0x0300 | line_state, NULL, 0,
+  return cp210x_set_request(p_cdc, CP210X_SET_MHS, 0x0300 | p_cdc->requested_line_state, NULL, 0,
                             complete_cb ? cp210x_internal_control_complete : NULL, user_data);
 }
 
@@ -1273,10 +1278,11 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_CP210X_SET_DTR_RTS:
       #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-      TU_ASSERT(cp210x_set_modem_ctrl(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, cp210x_process_config, CONFIG_CP210X_COMPLETE),);
-      break;
+        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        TU_ASSERT(cp210x_set_modem_ctrl(p_cdc, cp210x_process_config, CONFIG_CP210X_COMPLETE),);
+        break;
       #else
-      TU_ATTR_FALLTHROUGH;
+        TU_ATTR_FALLTHROUGH;
       #endif
 
     case CONFIG_CP210X_COMPLETE:
@@ -1399,19 +1405,7 @@ static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
         break;
 
       case CH34X_REQ_MODEM_CTRL:
-        // set modem controls RTS/DTR request. Note: signals are inverted
-        uint16_t const modem_signal = ~tu_le16toh(xfer->setup->wValue);
-        if (modem_signal & CH34X_BIT_RTS) {
-          p_cdc->line_state |= CDC_CONTROL_LINE_STATE_RTS;
-        } else {
-          p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_RTS;
-        }
-
-        if (modem_signal & CH34X_BIT_DTR) {
-          p_cdc->line_state |= CDC_CONTROL_LINE_STATE_DTR;
-        } else {
-          p_cdc->line_state &= (uint8_t) ~CDC_CONTROL_LINE_STATE_DTR;
-        }
+        p_cdc->line_state = p_cdc->requested_line_state;
         break;
 
       default: break;
@@ -1487,13 +1481,12 @@ static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complet
   return true;
 }
 
-static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, uint16_t line_state,
-                                 tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   uint8_t control = 0;
-  if (line_state & CDC_CONTROL_LINE_STATE_RTS) {
+  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_RTS) {
     control |= CH34X_BIT_RTS;
   }
-  if (line_state & CDC_CONTROL_LINE_STATE_DTR) {
+  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_DTR) {
     control |= CH34X_BIT_DTR;
   }
 
@@ -1587,7 +1580,8 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_CH34X_MODEM_CONTROL:
       // !always! set modem controls RTS/DTR (CH34x has no reset state after CH34X_REQ_SERIAL_INIT)
-      TU_ASSERT (ch34x_set_modem_ctrl(p_cdc, CFG_TUH_CDC_LINE_CONTROL_ON_ENUM, ch34x_process_config, CONFIG_CH34X_COMPLETE),);
+      p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+      TU_ASSERT (ch34x_set_modem_ctrl(p_cdc, ch34x_process_config, CONFIG_CH34X_COMPLETE),);
       break;
 
     case CONFIG_CH34X_COMPLETE:

From dcadf8c2a2a79b838cfccf32612fadcb15216c77 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 22 Feb 2024 15:04:24 +0100
Subject: [PATCH 07/37] created set_function_call()

---
 src/class/cdc/cdc_host.c | 108 +++++++++++++++++----------------------
 1 file changed, 47 insertions(+), 61 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 0af429e4b1..6a650071dc 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -421,115 +421,101 @@ bool tuh_cdc_read_clear (uint8_t idx) {
 // Control Endpoint API
 //--------------------------------------------------------------------+
 
-bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  TU_LOG_P_CDC("set control line state line_state = %u", line_state);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
-
-  p_cdc->requested_line_state = (uint8_t) line_state;
-
+// call of (non-)blocking set-functions (to set line state, baudrate, ...)
+static bool set_function_call (
+    cdch_interface_t * p_cdc,
+    bool (*set_function)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data),
+    tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   if (complete_cb) {
-    return driver->set_control_line_state(p_cdc, complete_cb, user_data);
+    // non-blocking with call back
+    return set_function(p_cdc, complete_cb, user_data);
   } else {
     // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_control_line_state(p_cdc, complete_cb, (uintptr_t) &result);
+    xfer_result_t result = XFER_RESULT_INVALID; // use local result, because user_data ptr may be NULL
+    bool ret = set_function(p_cdc, NULL, (uintptr_t) &result);
 
     if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
+      *((xfer_result_t *) user_data) = result;
     }
 
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
+    return (ret && result == XFER_RESULT_SUCCESS);
+  }
+}
+
+bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  TU_LOG_P_CDC("set control line state line_state = %u", line_state);
+  cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
+
+  p_cdc->requested_line_state = (uint8_t) line_state;
+
+  bool ret = set_function_call(p_cdc, driver->set_control_line_state, complete_cb, user_data);
+
+  if (ret && !complete_cb) {
     p_cdc->line_state = (uint8_t) line_state;
-    return true;
   }
+
+  return ret;
 }
 
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
   TU_LOG_P_CDC("set baudrate = %lu", baudrate);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
+  cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
   p_cdc->requested_line_coding.bit_rate = baudrate;
 
-  if (complete_cb) {
-    return driver->set_baudrate(p_cdc, complete_cb, user_data);
-  } else {
-    // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_baudrate(p_cdc, complete_cb, (uintptr_t) &result);
-
-    if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
-    }
+  bool ret = set_function_call(p_cdc, driver->set_baudrate, complete_cb, user_data);
 
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
+  if (ret && !complete_cb) {
     p_cdc->line_coding.bit_rate = baudrate;
-    return true;
   }
+
+  return ret;
 }
 
 bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uint8_t data_bits,
                              tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
   TU_LOG_P_CDC("set data format data_bits = %u parity = %u stop_bits = %u (indexes!)",
                data_bits, parity, stop_bits);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
+  cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
   p_cdc->requested_line_coding.stop_bits = stop_bits;
   p_cdc->requested_line_coding.parity    = parity;
   p_cdc->requested_line_coding.data_bits = data_bits;
 
-  if (complete_cb) {
-    return driver->set_data_format(p_cdc, complete_cb, user_data);
-  } else {
-    // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_data_format(p_cdc, complete_cb, (uintptr_t) &result);
-
-    if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
-    }
+  bool ret = set_function_call(p_cdc, driver->set_data_format, complete_cb, user_data);
 
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
+  if (ret && !complete_cb) {
     p_cdc->line_coding.stop_bits = stop_bits;
     p_cdc->line_coding.parity    = parity;
     p_cdc->line_coding.data_bits = data_bits;
-    return true;
   }
+
+  return ret;
 }
 
-bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const* line_coding, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const * line_coding,
+                             tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
   TU_LOG_P_CDC("set line coding baudrate = %lu data_bits = %u parity = %u stop_bits = %u (indexes!)",
                line_coding->bit_rate, line_coding->data_bits, line_coding->parity, line_coding->stop_bits);
-  cdch_serial_driver_t const* driver = &serial_drivers[p_cdc->serial_drid];
+  cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
   p_cdc->requested_line_coding = *line_coding;
 
-  if ( complete_cb ) {
-    return driver->set_line_coding(p_cdc, complete_cb, user_data);
-  } else {
-    // blocking
-    xfer_result_t result = XFER_RESULT_INVALID;
-    bool ret = driver->set_line_coding(p_cdc, complete_cb, (uintptr_t) &result);
+  bool ret = set_function_call(p_cdc, driver->set_line_coding, complete_cb, user_data);
 
-    if (user_data) {
-      // user_data is not NULL, return result via user_data
-      *((xfer_result_t*) user_data) = result;
-    }
-
-    TU_VERIFY(ret && result == XFER_RESULT_SUCCESS);
+  if (ret && !complete_cb) {
     p_cdc->line_coding = *line_coding;
-    return true;
   }
+
+  return ret;
 }
 
 //--------------------------------------------------------------------+

From ea86bbe5f742344b307e52945c0977143522810b Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Wed, 21 Feb 2024 16:30:02 +0100
Subject: [PATCH 08/37] added continue enum after config fail

---
 src/class/cdc/cdc_host.c | 109 ++++++++++++++++++++++++---------------
 1 file changed, 67 insertions(+), 42 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 6a650071dc..226f389e39 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -47,6 +47,16 @@
 #define TU_LOG_P_CDC(TXT,...)                  TU_LOG_CDC(TXT, p_cdc->daddr, p_cdc->bInterfaceNumber, \
                                                           serial_drivers[p_cdc->serial_drid].name, ##__VA_ARGS__)
 
+#define TU_ASSERT_COMPLETE_DEFINE(_cond, _itf_offset)                                                \
+  do {                                                                                               \
+    if (!(_cond)) { _MESS_FAILED(); TU_BREAKPOINT(); set_config_complete(idx, _itf_offset, false); } \
+  } while(0)
+
+#define TU_ASSERT_COMPLETE_1ARGS(_cond)               TU_ASSERT_COMPLETE_DEFINE(_cond, 0)
+#define TU_ASSERT_COMPLETE_2ARGS(_cond, _itf_offset)  TU_ASSERT_COMPLETE_DEFINE(_cond, _itf_offset)
+
+#define TU_ASSERT_COMPLETE(...) _GET_3RD_ARG(__VA_ARGS__, TU_ASSERT_COMPLETE_2ARGS, TU_ASSERT_COMPLETE_1ARGS, _dummy)(__VA_ARGS__)
+
 //--------------------------------------------------------------------+
 // Host CDC Interface
 //--------------------------------------------------------------------+
@@ -285,7 +295,6 @@ static cdch_interface_t* make_new_itf(uint8_t daddr, tusb_desc_interface_t const
 }
 
 static bool open_ep_stream_pair(cdch_interface_t* p_cdc , tusb_desc_endpoint_t const *desc_ep);
-static void set_config_complete(cdch_interface_t * p_cdc, uint8_t idx, uint8_t itf_num);
 
 //--------------------------------------------------------------------+
 // APPLICATION API
@@ -657,16 +666,26 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_d
   return false;
 }
 
-static void set_config_complete(cdch_interface_t * p_cdc, uint8_t idx, uint8_t itf_num) {
-  TU_LOG_P_CDC("set config complete");
-  p_cdc->mounted = true;
-  if (tuh_cdc_mount_cb) tuh_cdc_mount_cb(idx);
+static void set_config_complete(uint8_t idx, uint8_t itf_offset, bool success) {
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+  TU_LOG_P_CDC("set config complete success = %u", success);
 
-  // Prepare for incoming data
-  tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
+  if (success) {
+    p_cdc->mounted = true;
+    if (tuh_cdc_mount_cb) {
+      tuh_cdc_mount_cb(idx);
+    }
+    // Prepare for incoming data
+    tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
+  } else {
+    // clear the interface entry
+    p_cdc->daddr = 0;
+    p_cdc->bInterfaceNumber = 0;
+  }
 
   // notify usbh that driver enumeration is complete
-  usbh_driver_set_config_complete(p_cdc->daddr, itf_num);
+  usbh_driver_set_config_complete(p_cdc->daddr, p_cdc->bInterfaceNumber + itf_offset);
 }
 
 bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
@@ -856,14 +875,14 @@ static void acm_process_config(tuh_xfer_t* xfer) {
   uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
   cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc,);
+  TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS, 1);
 
   switch (state) {
     case CONFIG_ACM_SET_CONTROL_LINE_STATE:
       #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         if (p_cdc->acm_capability.support_line_request) {
           p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-          TU_ASSERT(acm_set_control_line_state(p_cdc, acm_process_config, CONFIG_ACM_SET_LINE_CODING),);
+          TU_ASSERT_COMPLETE(acm_set_control_line_state(p_cdc, acm_process_config, CONFIG_ACM_SET_LINE_CODING), 1);
           break;
         }
       #endif
@@ -873,7 +892,7 @@ static void acm_process_config(tuh_xfer_t* xfer) {
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
         if (p_cdc->acm_capability.support_line_request) {
           p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-          TU_ASSERT(acm_set_line_coding(p_cdc, acm_process_config, CONFIG_ACM_COMPLETE),);
+          TU_ASSERT_COMPLETE(acm_set_line_coding(p_cdc, acm_process_config, CONFIG_ACM_COMPLETE), 1);
           break;
         }
       #endif
@@ -881,10 +900,11 @@ static void acm_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_ACM_COMPLETE:
       // itf_num+1 to account for data interface as well
-      set_config_complete(p_cdc, idx, itf_num + 1);
+      set_config_complete(idx, 1, true);
       break;
 
     default:
+      set_config_complete(idx, 1, false);
       break;
   }
 }
@@ -1024,18 +1044,18 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
   uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
   cdch_interface_t * p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
+  TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS);
 
   switch(state) {
     // Note may need to read FTDI eeprom
     case CONFIG_FTDI_RESET:
-      TU_ASSERT(ftdi_sio_reset(p_cdc, ftdi_process_config, CONFIG_FTDI_MODEM_CTRL),);
+      TU_ASSERT_COMPLETE(ftdi_sio_reset(p_cdc, ftdi_process_config, CONFIG_FTDI_MODEM_CTRL));
       break;
 
     case CONFIG_FTDI_MODEM_CTRL:
       #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-        TU_ASSERT(ftdi_sio_set_modem_ctrl(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_BAUDRATE),);
+        TU_ASSERT_COMPLETE(ftdi_sio_set_modem_ctrl(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_BAUDRATE));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
@@ -1044,7 +1064,7 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
     case CONFIG_FTDI_SET_BAUDRATE: {
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
         p_cdc->requested_line_coding.bit_rate = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM).bit_rate;
-        TU_ASSERT(ftdi_sio_set_baudrate(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_DATA),);
+        TU_ASSERT_COMPLETE(ftdi_sio_set_baudrate(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_DATA));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
@@ -1055,7 +1075,7 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
       #if 0 // TODO set data format
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
       cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      TU_ASSERT(ftdi_sio_set_data(p_cdc, process_ftdi_config, CONFIG_FTDI_COMPLETE),);
+      TU_ASSERT_COMPLETE(ftdi_sio_set_data(p_cdc, process_ftdi_config, CONFIG_FTDI_COMPLETE));
       break;
       #endif
       #endif
@@ -1064,10 +1084,11 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
     }
 
     case CONFIG_FTDI_COMPLETE:
-      set_config_complete(p_cdc, idx, itf_num);
+      set_config_complete(idx, 0, true);
       break;
 
     default:
+      set_config_complete(idx, 0, false);
       break;
   }
 }
@@ -1150,8 +1171,8 @@ static bool cp210x_ifc_enable(cdch_interface_t* p_cdc, uint16_t enabled, tuh_xfe
 static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
   uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
   uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t * p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc,);
+  cdch_interface_t* p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc, );
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
   TU_LOG_P_CDC("control complete success = %u", success);
 
@@ -1236,17 +1257,17 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
   uint8_t const   itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
   uint8_t const   idx     = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
   cdch_interface_t *p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc,);
+  TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS);
 
   switch (state) {
     case CONFIG_CP210X_IFC_ENABLE:
-      TU_ASSERT(cp210x_ifc_enable(p_cdc, 1, cp210x_process_config, CONFIG_CP210X_SET_BAUDRATE),);
+      TU_ASSERT_COMPLETE(cp210x_ifc_enable(p_cdc, 1, cp210x_process_config, CONFIG_CP210X_SET_BAUDRATE));
       break;
 
     case CONFIG_CP210X_SET_BAUDRATE: {
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
         p_cdc->requested_line_coding.bit_rate = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM).bit_rate;
-        TU_ASSERT(cp210x_set_baudrate(p_cdc, cp210x_process_config, CONFIG_CP210X_SET_LINE_CTL),);
+        TU_ASSERT_COMPLETE(cp210x_set_baudrate(p_cdc, cp210x_process_config, CONFIG_CP210X_SET_LINE_CTL));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
@@ -1265,17 +1286,19 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
     case CONFIG_CP210X_SET_DTR_RTS:
       #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-        TU_ASSERT(cp210x_set_modem_ctrl(p_cdc, cp210x_process_config, CONFIG_CP210X_COMPLETE),);
+        TU_ASSERT_COMPLETE(cp210x_set_modem_ctrl(p_cdc, cp210x_process_config, CONFIG_CP210X_COMPLETE));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
       #endif
 
     case CONFIG_CP210X_COMPLETE:
-      set_config_complete(p_cdc, idx, itf_num);
+      set_config_complete(idx, 0, true);
       break;
 
-    default: break;
+    default:
+      set_config_complete(idx, 0, false);
+      break;
   }
 }
 
@@ -1361,11 +1384,11 @@ static bool ch34x_write_reg_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t comp
 
 // internal control complete to update state such as line state, encoding
 static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
-  // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
+  // CH34x only has 1 interface and wIndex used as payload and not for bInterfaceNumber
   uint8_t const itf_num = 0;
   uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t * p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc,);
+  cdch_interface_t* p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc, );
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
   TU_LOG_P_CDC("control complete success = %u", success);
 
@@ -1526,14 +1549,14 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
   uint8_t const itf_num = 0;
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
   cdch_interface_t* p_cdc = get_itf(idx);
+  TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS);
   uintptr_t const state = xfer->user_data;
   uint8_t buffer[2]; // TODO remove
-  TU_ASSERT (p_cdc,);
-  TU_ASSERT (xfer->result == XFER_RESULT_SUCCESS,);
 
   switch (state) {
     case CONFIG_CH34X_READ_VERSION:
-      TU_ASSERT (ch34x_control_in(p_cdc, CH34X_REQ_READ_VERSION, 0, 0, buffer, 2, ch34x_process_config, CONFIG_CH34X_SERIAL_INIT),);
+      TU_ASSERT_COMPLETE(ch34x_control_in(p_cdc, CH34X_REQ_READ_VERSION, 0, 0, buffer, 2,
+                                          ch34x_process_config, CONFIG_CH34X_SERIAL_INIT));
       break;
 
     case CONFIG_CH34X_SERIAL_INIT: {
@@ -1541,41 +1564,43 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
       uint8_t const version = xfer->buffer[0];
       TU_LOG_P_CDC("Chip Version = %02x", version);
       // only versions >= 0x30 are tested, below 0x30 seems having other programming, see drivers from WCH vendor, Linux kernel and FreeBSD
-      TU_ASSERT (version >= 0x30,);
+      TU_ASSERT_COMPLETE(version >= 0x30);
       // init CH34x with line coding
       p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
       uint16_t const div_ps = ch34x_get_divisor_prescaler(p_cdc);
-      TU_ASSERT(div_ps, );
+      TU_ASSERT_COMPLETE(div_ps);
       uint8_t const lcr = ch34x_get_lcr(p_cdc);
-      TU_ASSERT(lcr, );
-      TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_SERIAL_INIT, tu_u16(lcr, 0x9c), div_ps,
-                                   ch34x_process_config, CONFIG_CH34X_SPECIAL_REG_WRITE),);
+      TU_ASSERT_COMPLETE(lcr);
+      TU_ASSERT_COMPLETE(ch34x_control_out(p_cdc, CH34X_REQ_SERIAL_INIT, tu_u16(lcr, 0x9c), div_ps,
+                                           ch34x_process_config, CONFIG_CH34X_SPECIAL_REG_WRITE));
       break;
     }
 
     case CONFIG_CH34X_SPECIAL_REG_WRITE:
       // overtake line coding and do special reg write, purpose unknown, overtaken from WCH driver
       p_cdc->line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
-      TU_ASSERT (ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x0F, CH341_REG_0x2C), 0x0007, ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL),);
+      TU_ASSERT_COMPLETE(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x0F, CH341_REG_0x2C), 0x0007,
+                                         ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL));
       break;
 
     case CONFIG_CH34X_FLOW_CONTROL:
       // no hardware flow control
-      TU_ASSERT (ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x27, CH341_REG_0x27), 0x0000, ch34x_process_config, CONFIG_CH34X_MODEM_CONTROL),);
+      TU_ASSERT_COMPLETE(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x27, CH341_REG_0x27), 0x0000,
+                                         ch34x_process_config, CONFIG_CH34X_MODEM_CONTROL));
       break;
 
     case CONFIG_CH34X_MODEM_CONTROL:
       // !always! set modem controls RTS/DTR (CH34x has no reset state after CH34X_REQ_SERIAL_INIT)
       p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-      TU_ASSERT (ch34x_set_modem_ctrl(p_cdc, ch34x_process_config, CONFIG_CH34X_COMPLETE),);
+      TU_ASSERT_COMPLETE(ch34x_set_modem_ctrl(p_cdc, ch34x_process_config, CONFIG_CH34X_COMPLETE));
       break;
 
     case CONFIG_CH34X_COMPLETE:
-      set_config_complete(p_cdc, idx, itf_num);
+      set_config_complete(idx, 0, true);
       break;
 
     default:
-      TU_ASSERT (false,);
+      set_config_complete(idx, 0, false);
       break;
   }
 }

From 22a12c76689399bd1a67e52531171876e5d88a28 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 22 Feb 2024 09:28:06 +0100
Subject: [PATCH 09/37] improved ACM checks

---
 src/class/cdc/cdc_host.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 226f389e39..ae8245b0e5 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -773,6 +773,11 @@ static bool acm_set_control_line_state(cdch_interface_t* p_cdc, tuh_xfer_cb_t co
 }
 
 static bool acm_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  TU_VERIFY(p_cdc->acm_capability.support_line_request);
+  TU_VERIFY(p_cdc->requested_line_coding.data_bits && p_cdc->requested_line_coding.bit_rate);
+  TU_VERIFY((p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 8) ||
+             p_cdc->requested_line_coding.data_bits == 16);
+
   tusb_control_request_t const request = {
     .bmRequestType_bit = {
       .recipient = TUSB_REQ_RCPT_INTERFACE,
@@ -813,7 +818,6 @@ static bool acm_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb,
   p_cdc->requested_line_coding.stop_bits = p_cdc->line_coding.stop_bits;
   p_cdc->requested_line_coding.parity    = p_cdc->line_coding.parity;
   p_cdc->requested_line_coding.data_bits = p_cdc->line_coding.data_bits;
-  TU_VERIFY(p_cdc->acm_capability.support_line_request);
 
   return acm_set_line_coding(p_cdc, complete_cb, user_data);
 }

From 138567af3e39e08742b3d1edf5b83d27d8526a4a Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sun, 18 Feb 2024 20:33:54 +0100
Subject: [PATCH 10/37] fixed #2448 CH34x ch34x_set_line_coding() callback bug

---
 src/class/cdc/cdc_host.c | 127 +++++++++++++++++++++++----------------
 1 file changed, 75 insertions(+), 52 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index ae8245b0e5..f6804ca2b4 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -80,6 +80,9 @@ typedef struct {
   uint8_t requested_line_state;
 
   tuh_xfer_cb_t user_control_cb;
+  #if CFG_TUH_CDC_CH34X
+  tuh_xfer_cb_t requested_complete_cb;
+  #endif
 
   struct {
     tu_edpt_stream_t tx;
@@ -1376,12 +1379,33 @@ static inline bool ch34x_write_reg(cdch_interface_t* p_cdc, uint16_t reg, uint16
 //  return ch34x_control_in ( p_cdc, CH34X_REQ_READ_REG, reg, 0, buffer, buffersize, complete_cb, user_data );
 //}
 
-static bool ch34x_write_reg_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ch34x_write_reg_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint8_t const lcr = ch34x_get_lcr(p_cdc);
+  TU_VERIFY(lcr);
+
+  return ch34x_write_reg(p_cdc, CH32X_REG16_LCR2_LCR, lcr, complete_cb, user_data);
+}
+
+static bool ch34x_write_reg_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   uint16_t const div_ps = ch34x_get_divisor_prescaler(p_cdc);
   TU_VERIFY(div_ps);
-  TU_ASSERT(ch34x_write_reg(p_cdc, CH34X_REG16_DIVISOR_PRESCALER, div_ps,
-                            complete_cb, user_data));
-  return true;
+
+  return ch34x_write_reg(p_cdc, CH34X_REG16_DIVISOR_PRESCALER, div_ps, complete_cb, user_data);
+}
+
+static bool ch34x_modem_ctrl_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint8_t control = 0;
+  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_RTS) {
+    control |= CH34X_BIT_RTS;
+  }
+  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_DTR) {
+    control |= CH34X_BIT_DTR;
+  }
+
+  // CH34x signals are inverted
+  control = ~control;
+
+  return ch34x_control_out(p_cdc, CH34X_REQ_MODEM_CTRL, control, 0, complete_cb, user_data);
 }
 
 //------------- Driver API -------------//
@@ -1431,34 +1455,34 @@ static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool ch34x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint8_t const lcr = ch34x_get_lcr(p_cdc);
-  TU_VERIFY(lcr);
-  TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_WRITE_REG, CH32X_REG16_LCR2_LCR, lcr,
-                               complete_cb ? ch34x_internal_control_complete : NULL, user_data));
+static bool ch34x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->user_control_cb = complete_cb;
+  TU_ASSERT(ch34x_write_reg_data_format(p_cdc, complete_cb ? ch34x_internal_control_complete : NULL, user_data));
+
   return true;
 }
 
-static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ch34x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
   TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, complete_cb ? ch34x_internal_control_complete : NULL, user_data));
+
   return true;
 }
 
-static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t* xfer) {
-  // CH34x only has 1 interface and use wIndex as payload and not for bInterfaceNumber
+static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t * xfer) {
+  // CH34x only has 1 interface and wIndex used as payload and not for bInterfaceNumber
   uint8_t const itf_num = 0;
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc, );
 
   if (xfer->result == XFER_RESULT_SUCCESS) {
-    // stage 1 success, continue to stage 2
-    p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-    TU_ASSERT(ch34x_set_data_format(p_cdc, ch34x_internal_control_complete, xfer->user_data), );
+    // stage 1 success, continue with stage 2
+    p_cdc->user_control_cb = p_cdc->requested_complete_cb;
+    ch34x_write_reg_data_format(p_cdc, ch34x_internal_control_complete, xfer->user_data);
   } else {
     // stage 1 failed, notify user
-    xfer->complete_cb = p_cdc->user_control_cb;
+    xfer->complete_cb = p_cdc->requested_complete_cb;
     if (xfer->complete_cb) {
       xfer->complete_cb(xfer);
     }
@@ -1466,49 +1490,46 @@ static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t* xfer) {
 }
 
 // 2 stages: set baudrate (stage1) + set data format (stage2)
-static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  p_cdc->user_control_cb = complete_cb;
-
+static bool ch34x_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   if (complete_cb) {
     // stage 1 set baudrate
-    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, ch34x_set_line_coding_stage1_complete, user_data));
+    p_cdc->requested_complete_cb = complete_cb;
+    p_cdc->user_control_cb = ch34x_set_line_coding_stage1_complete;
+    return ch34x_write_reg_baudrate(p_cdc, ch34x_internal_control_complete, user_data);
   } else {
-    // sync call
-    xfer_result_t result;
-
+    // blocking sequence
     // stage 1 set baudrate
-    TU_ASSERT(ch34x_write_reg_baudrate(p_cdc, NULL, (uintptr_t) &result));
+    xfer_result_t result = XFER_RESULT_INVALID; // use local result, because user_data ptr may be NULL
+    bool ret = ch34x_write_reg_baudrate(p_cdc, NULL, (uintptr_t) &result);
+
+    // store/check results
+    if (user_data) {
+      *((xfer_result_t*) user_data) = result;
+    }
+    TU_ASSERT(ret);
     TU_VERIFY(result == XFER_RESULT_SUCCESS);
+
+    // overtake baudrate
     p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
 
     // stage 2 set data format
-    TU_ASSERT(ch34x_set_data_format(p_cdc, NULL, (uintptr_t) &result));
-    TU_VERIFY(result == XFER_RESULT_SUCCESS);
+    result = XFER_RESULT_INVALID;
+    ret = ch34x_write_reg_data_format(p_cdc, NULL, (uintptr_t) &result);
 
-    // update transfer result, user_data is expected to point to xfer_result_t
+    // store/check results
     if (user_data) {
       *((xfer_result_t*) user_data) = result;
     }
+    TU_ASSERT(ret);
+    return (result == XFER_RESULT_SUCCESS);
+    // the overtaking of remaining requested_line_coding will be done in tuh_cdc_set_line_coding()
   }
-
-  return true;
 }
 
-static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint8_t control = 0;
-  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_RTS) {
-    control |= CH34X_BIT_RTS;
-  }
-  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_DTR) {
-    control |= CH34X_BIT_DTR;
-  }
-
-  // CH34x signals are inverted
-  control = ~control;
-
+static bool ch34x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT (ch34x_control_out(p_cdc, CH34X_REQ_MODEM_CTRL, control, 0,
-                               complete_cb ? ch34x_internal_control_complete : NULL, user_data));
+  TU_ASSERT(ch34x_modem_ctrl_request(p_cdc, complete_cb ? ch34x_internal_control_complete : NULL, user_data));
+
   return true;
 }
 
@@ -1549,25 +1570,27 @@ static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uin
 }
 
 static void ch34x_process_config(tuh_xfer_t* xfer) {
-  // CH34x only has 1 interface and use wIndex as payload and not for bInterfaceNumber
+  // CH34x only has 1 interface and wIndex used as payload and not for bInterfaceNumber
+  uintptr_t const state = xfer->user_data;
   uint8_t const itf_num = 0;
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
   cdch_interface_t* p_cdc = get_itf(idx);
   TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS);
-  uintptr_t const state = xfer->user_data;
   uint8_t buffer[2]; // TODO remove
 
   switch (state) {
     case CONFIG_CH34X_READ_VERSION:
+      p_cdc->user_control_cb = ch34x_process_config; // set once for whole process config
       TU_ASSERT_COMPLETE(ch34x_control_in(p_cdc, CH34X_REQ_READ_VERSION, 0, 0, buffer, 2,
-                                          ch34x_process_config, CONFIG_CH34X_SERIAL_INIT));
+                         ch34x_process_config, CONFIG_CH34X_SERIAL_INIT));
       break;
 
     case CONFIG_CH34X_SERIAL_INIT: {
       // handle version read data, set CH34x line coding (incl. baudrate)
       uint8_t const version = xfer->buffer[0];
       TU_LOG_P_CDC("Chip Version = %02x", version);
-      // only versions >= 0x30 are tested, below 0x30 seems having other programming, see drivers from WCH vendor, Linux kernel and FreeBSD
+      // only versions >= 0x30 are tested, below 0x30 seems having other programming
+      // see drivers from WCH vendor, Linux kernel and FreeBSD
       TU_ASSERT_COMPLETE(version >= 0x30);
       // init CH34x with line coding
       p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
@@ -1584,19 +1607,19 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
       // overtake line coding and do special reg write, purpose unknown, overtaken from WCH driver
       p_cdc->line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
       TU_ASSERT_COMPLETE(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x0F, CH341_REG_0x2C), 0x0007,
-                                         ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL));
+                         ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL));
       break;
 
     case CONFIG_CH34X_FLOW_CONTROL:
       // no hardware flow control
       TU_ASSERT_COMPLETE(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x27, CH341_REG_0x27), 0x0000,
-                                         ch34x_process_config, CONFIG_CH34X_MODEM_CONTROL));
+                         ch34x_process_config, CONFIG_CH34X_MODEM_CONTROL));
       break;
 
     case CONFIG_CH34X_MODEM_CONTROL:
       // !always! set modem controls RTS/DTR (CH34x has no reset state after CH34X_REQ_SERIAL_INIT)
       p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-      TU_ASSERT_COMPLETE(ch34x_set_modem_ctrl(p_cdc, ch34x_process_config, CONFIG_CH34X_COMPLETE));
+      TU_ASSERT_COMPLETE(ch34x_modem_ctrl_request(p_cdc, ch34x_internal_control_complete, CONFIG_CH34X_COMPLETE));
       break;
 
     case CONFIG_CH34X_COMPLETE:
@@ -1668,7 +1691,7 @@ static uint8_t ch34x_get_lcr(cdch_interface_t * p_cdc) {
   uint8_t const data_bits = p_cdc->requested_line_coding.data_bits;
 
   uint8_t lcr = CH34X_LCR_ENABLE_RX | CH34X_LCR_ENABLE_TX;
-  TU_VERIFY(data_bits >= 5 && data_bits <= 8, 0);
+  TU_VERIFY(data_bits >= 5 && data_bits <= 8);
   lcr |= (uint8_t) (data_bits - 5);
 
   switch(parity) {
@@ -1695,7 +1718,7 @@ static uint8_t ch34x_get_lcr(cdch_interface_t * p_cdc) {
   }
 
   // 1.5 stop bits not supported
-  TU_VERIFY(stop_bits != CDC_LINE_CODING_STOP_BITS_1_5, 0);
+  TU_VERIFY(stop_bits != CDC_LINE_CODING_STOP_BITS_1_5);
   if (stop_bits == CDC_LINE_CODING_STOP_BITS_2) {
     lcr |= CH34X_LCR_STOP_BITS_2;
   }

From db511fb2f3df190f538d84d08b6be83746adae0e Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Mon, 19 Feb 2024 08:05:16 +0100
Subject: [PATCH 11/37] fixed CFG_TUH_CDC_LINE_CONTROL_ON_ENUM handling. only
 set if defined. value 0 is also valid

---
 src/class/cdc/cdc_host.c | 17 ++++++++++-------
 src/class/cdc/cdc_host.h | 10 ----------
 2 files changed, 10 insertions(+), 17 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index f6804ca2b4..850c1fcebf 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -886,7 +886,7 @@ static void acm_process_config(tuh_xfer_t* xfer) {
 
   switch (state) {
     case CONFIG_ACM_SET_CONTROL_LINE_STATE:
-      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         if (p_cdc->acm_capability.support_line_request) {
           p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
           TU_ASSERT_COMPLETE(acm_set_control_line_state(p_cdc, acm_process_config, CONFIG_ACM_SET_LINE_CODING), 1);
@@ -1060,7 +1060,7 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
       break;
 
     case CONFIG_FTDI_MODEM_CTRL:
-      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(ftdi_sio_set_modem_ctrl(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_BAUDRATE));
         break;
@@ -1291,7 +1291,7 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
     }
 
     case CONFIG_CP210X_SET_DTR_RTS:
-      #if CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(cp210x_set_modem_ctrl(p_cdc, cp210x_process_config, CONFIG_CP210X_COMPLETE));
         break;
@@ -1617,10 +1617,13 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
       break;
 
     case CONFIG_CH34X_MODEM_CONTROL:
-      // !always! set modem controls RTS/DTR (CH34x has no reset state after CH34X_REQ_SERIAL_INIT)
-      p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-      TU_ASSERT_COMPLETE(ch34x_modem_ctrl_request(p_cdc, ch34x_internal_control_complete, CONFIG_CH34X_COMPLETE));
-      break;
+      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        TU_ASSERT_COMPLETE(ch34x_modem_ctrl_request(p_cdc, ch34x_internal_control_complete, CONFIG_CH34X_COMPLETE));
+        break;
+      #else
+        TU_ATTR_FALLTHROUGH;
+      #endif
 
     case CONFIG_CH34X_COMPLETE:
       set_config_complete(idx, 0, true);
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index d512a23a54..ca65674533 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -37,16 +37,6 @@
 // Class Driver Configuration
 //--------------------------------------------------------------------+
 
-// Set Line Control state on enumeration/mounted: DTR ( bit 0), RTS (bit 1)
-#ifndef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-#define CFG_TUH_CDC_LINE_CONTROL_ON_ENUM    0
-#endif
-
-// Set Line Coding on enumeration/mounted, value for cdc_line_coding_t
-//#ifndef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-//#define CFG_TUH_CDC_LINE_CODING_ON_ENUM   { 115200, CDC_LINE_CODING_STOP_BITS_1, CDC_LINE_CODING_PARITY_NONE, 8 }
-//#endif
-
 // RX FIFO size
 #ifndef CFG_TUH_CDC_RX_BUFSIZE
 #define CFG_TUH_CDC_RX_BUFSIZE USBH_EPSIZE_BULK_MAX

From 0b5f85eee0f34a80dd8debe2f764607070293119 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Wed, 21 Feb 2024 17:25:13 +0100
Subject: [PATCH 12/37] created set_line_coding_sequence() and void
 set_line_coding_stage1_complete() to be reused by FTDI & CP210x

---
 src/class/cdc/cdc_host.c | 131 ++++++++++++++++++++++++---------------
 1 file changed, 81 insertions(+), 50 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 850c1fcebf..8deeffc379 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -433,6 +433,77 @@ bool tuh_cdc_read_clear (uint8_t idx) {
 // Control Endpoint API
 //--------------------------------------------------------------------+
 
+// set line coding using sequence with 2 stages: set baudrate (stage1) + set data format (stage2)
+static bool set_line_coding_sequence(
+    cdch_interface_t * p_cdc,
+    // control request function to set baudrate
+    bool (*set_baudrate_request)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data),
+    // control request function to set data format
+    bool (*set_data_format_request)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data),
+    // function to be called after stage 1 completed
+    void (*set_line_coding_stage1_complete)(tuh_xfer_t * xfer),
+    // control complete function to be called after request
+    void (*internal_control_complete)(tuh_xfer_t * xfer),
+    tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  if (complete_cb) {
+    // non-blocking
+    // stage 1 set baudrate
+    p_cdc->requested_complete_cb = complete_cb; // store complete_cb to be used in set_line_coding_stage1_complete()
+    p_cdc->user_control_cb = set_line_coding_stage1_complete;
+    return set_baudrate_request(p_cdc, internal_control_complete, user_data);
+  } else {
+    // blocking sequence
+    // stage 1 set baudrate
+    xfer_result_t result = XFER_RESULT_INVALID; // use local result, because user_data ptr may be NULL
+    bool ret = set_baudrate_request(p_cdc, NULL, (uintptr_t) &result);
+
+    if (user_data) {
+      *((xfer_result_t *) user_data) = result;
+    }
+
+    TU_ASSERT(ret);
+    TU_VERIFY(result == XFER_RESULT_SUCCESS);
+
+    // overtake baudrate after successful request
+    p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
+
+    // stage 2 set data format
+    result = XFER_RESULT_INVALID;
+    ret = set_data_format_request(p_cdc, NULL, (uintptr_t) &result);
+
+    if (user_data) {
+      *((xfer_result_t *) user_data) = result;
+    }
+
+    TU_ASSERT(ret);
+    return (result == XFER_RESULT_SUCCESS);
+    // the overtaking of remaining requested_line_coding will be done in tuh_cdc_set_line_coding()
+  }
+}
+
+static void set_line_coding_stage1_complete(
+    tuh_xfer_t * xfer, uint8_t const itf_num,
+    // control request function to set data format
+    bool (*set_data_format_request)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data),
+    // control complete function to be called after request
+    void (*internal_control_complete)(tuh_xfer_t * xfer)) {
+  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+
+  if (xfer->result == XFER_RESULT_SUCCESS) {
+    // stage 1 success, continue with stage 2
+    p_cdc->user_control_cb = p_cdc->requested_complete_cb;
+    set_data_format_request(p_cdc, internal_control_complete, xfer->user_data);
+  } else {
+    // stage 1 failed, notify user
+    xfer->complete_cb = p_cdc->requested_complete_cb;
+    if (xfer->complete_cb) {
+      xfer->complete_cb(xfer);
+    }
+  }
+}
+
 // call of (non-)blocking set-functions (to set line state, baudrate, ...)
 static bool set_function_call (
     cdch_interface_t * p_cdc,
@@ -1470,60 +1541,20 @@ static bool ch34x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_
 }
 
 static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t * xfer) {
-  // CH34x only has 1 interface and wIndex used as payload and not for bInterfaceNumber
-  uint8_t const itf_num = 0;
-  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
-
-  if (xfer->result == XFER_RESULT_SUCCESS) {
-    // stage 1 success, continue with stage 2
-    p_cdc->user_control_cb = p_cdc->requested_complete_cb;
-    ch34x_write_reg_data_format(p_cdc, ch34x_internal_control_complete, xfer->user_data);
-  } else {
-    // stage 1 failed, notify user
-    xfer->complete_cb = p_cdc->requested_complete_cb;
-    if (xfer->complete_cb) {
-      xfer->complete_cb(xfer);
-    }
-  }
+  uint8_t const itf_num = 0; // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
+  set_line_coding_stage1_complete(xfer, itf_num,
+                                  ch34x_write_reg_data_format,      // control request function to set data format
+                                  ch34x_internal_control_complete); // control complete function to be called after request
 }
 
 // 2 stages: set baudrate (stage1) + set data format (stage2)
 static bool ch34x_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  if (complete_cb) {
-    // stage 1 set baudrate
-    p_cdc->requested_complete_cb = complete_cb;
-    p_cdc->user_control_cb = ch34x_set_line_coding_stage1_complete;
-    return ch34x_write_reg_baudrate(p_cdc, ch34x_internal_control_complete, user_data);
-  } else {
-    // blocking sequence
-    // stage 1 set baudrate
-    xfer_result_t result = XFER_RESULT_INVALID; // use local result, because user_data ptr may be NULL
-    bool ret = ch34x_write_reg_baudrate(p_cdc, NULL, (uintptr_t) &result);
-
-    // store/check results
-    if (user_data) {
-      *((xfer_result_t*) user_data) = result;
-    }
-    TU_ASSERT(ret);
-    TU_VERIFY(result == XFER_RESULT_SUCCESS);
-
-    // overtake baudrate
-    p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-
-    // stage 2 set data format
-    result = XFER_RESULT_INVALID;
-    ret = ch34x_write_reg_data_format(p_cdc, NULL, (uintptr_t) &result);
-
-    // store/check results
-    if (user_data) {
-      *((xfer_result_t*) user_data) = result;
-    }
-    TU_ASSERT(ret);
-    return (result == XFER_RESULT_SUCCESS);
-    // the overtaking of remaining requested_line_coding will be done in tuh_cdc_set_line_coding()
-  }
+  return set_line_coding_sequence(p_cdc,
+                                  ch34x_write_reg_baudrate,              // control request function to set baudrate
+                                  ch34x_write_reg_data_format,           // control request function to set data format
+                                  ch34x_set_line_coding_stage1_complete, // function to be called after stage 1 completed
+                                  ch34x_internal_control_complete,       // control complete function to be called after request
+                                  complete_cb, user_data);
 }
 
 static bool ch34x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {

From 7fef5943eff0d7f1b7122e878cf2caa78bea06aa Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sat, 24 Feb 2024 12:58:45 +0100
Subject: [PATCH 13/37] improved FTDI support

---
 src/class/cdc/cdc_host.c        | 503 ++++++++++++++++++++++++++------
 src/class/cdc/serial/ftdi_sio.h | 385 ++++++++++++------------
 src/tusb_option.h               |  19 +-
 3 files changed, 616 insertions(+), 291 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 8deeffc379..f9540efbe6 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -35,6 +35,9 @@
 #include "host/usbh_pvt.h"
 
 #include "cdc_host.h"
+#include "serial/ftdi_sio.h"
+#include "serial/cp210x.h"
+#include "serial/ch34x.h"
 
 // Level where CFG_TUSB_DEBUG must be at least for this driver is logged
 #ifndef CFG_TUH_CDC_LOG_LEVEL
@@ -80,10 +83,14 @@ typedef struct {
   uint8_t requested_line_state;
 
   tuh_xfer_cb_t user_control_cb;
-  #if CFG_TUH_CDC_CH34X
+  #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_CH34X
   tuh_xfer_cb_t requested_complete_cb;
   #endif
 
+  #if CFG_TUH_CDC_FTDI
+    ftdi_private_t ftdi;
+  #endif
+
   struct {
     tu_edpt_stream_t tx;
     tu_edpt_stream_t rx;
@@ -98,6 +105,9 @@ typedef struct {
 
 CFG_TUH_MEM_SECTION
 static cdch_interface_t cdch_data[CFG_TUH_CDC];
+#if CFG_TUH_CDC_FTDI
+  static tusb_desc_device_t desc_dev[CFG_TUH_CDC][CFG_TUH_ENUMERATION_BUFSIZE];
+#endif
 
 //--------------------------------------------------------------------+
 // Serial Driver
@@ -114,23 +124,22 @@ static bool acm_set_control_line_state(cdch_interface_t* p_cdc, tuh_xfer_cb_t co
 
 //------------- FTDI prototypes -------------//
 #if CFG_TUH_CDC_FTDI
-#include "serial/ftdi_sio.h"
-
 static uint16_t const ftdi_vid_pid_list[][2] = {CFG_TUH_CDC_FTDI_VID_PID_LIST};
+#if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+static uint8_t const * ftdi_chip_name[] = { FTDI_CHIP_NAMES };
+#endif
 
 static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
 static void ftdi_process_config(tuh_xfer_t* xfer);
 
-static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ftdi_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- CP210X prototypes -------------//
 #if CFG_TUH_CDC_CP210X
-#include "serial/cp210x.h"
-
 static uint16_t const cp210x_vid_pid_list[][2] = {CFG_TUH_CDC_CP210X_VID_PID_LIST};
 
 static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
@@ -144,8 +153,6 @@ static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complet
 
 //------------- CH34x prototypes -------------//
 #if CFG_TUH_CDC_CH34X
-#include "serial/ch34x.h"
-
 static uint16_t const ch34x_vid_pid_list[][2] = {CFG_TUH_CDC_CH34X_VID_PID_LIST};
 
 static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len);
@@ -212,8 +219,8 @@ static const cdch_serial_driver_t serial_drivers[] = {
       .vid_pid_count          = TU_ARRAY_SIZE(ftdi_vid_pid_list),
       .open                   = ftdi_open,
       .process_set_config     = ftdi_process_config,
-      .set_control_line_state = ftdi_sio_set_modem_ctrl,
-      .set_baudrate           = ftdi_sio_set_baudrate,
+      .set_control_line_state = ftdi_set_modem_ctrl,
+      .set_baudrate           = ftdi_set_baudrate,
       .set_data_format        = ftdi_set_data_format,
       .set_line_coding        = ftdi_set_line_coding,
     #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
@@ -992,28 +999,27 @@ static void acm_process_config(tuh_xfer_t* xfer) {
 //--------------------------------------------------------------------+
 #if CFG_TUH_CDC_FTDI
 
-static uint32_t ftdi_232bm_baud_to_divisor(cdch_interface_t* p_cdc);
+static bool ftdi_determine_type(cdch_interface_t * p_cdc, uint8_t const idx);
+static uint32_t ftdi_get_divisor(cdch_interface_t * p_cdc);
+static uint8_t ftdi_get_idx(tuh_xfer_t * xfer);
 
 //------------- Control Request -------------//
 
 // set request without data
-static bool ftdi_sio_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_t value, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  tusb_control_request_t const request = {
-    .bmRequestType_bit = {
-      .recipient = TUSB_REQ_RCPT_DEVICE,
-      .type      = TUSB_REQ_TYPE_VENDOR,
-      .direction = TUSB_DIR_OUT
-    },
-    .bRequest = command,
-    .wValue   = tu_htole16(value),
-    .wIndex   = 0,
-    .wLength  = 0
+static bool ftdi_set_request(cdch_interface_t * p_cdc, uint8_t request, uint8_t requesttype,
+                             uint16_t value, uint16_t index, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  tusb_control_request_t const request_setup = {
+    .bmRequestType = requesttype,
+    .bRequest      = request,
+    .wValue        = tu_htole16(value),
+    .wIndex        = tu_htole16(index),
+    .wLength       = 0
   };
 
   tuh_xfer_t xfer = {
     .daddr       = p_cdc->daddr,
     .ep_addr     = 0,
-    .setup       = &request,
+    .setup       = &request_setup,
     .buffer      = NULL,
     .complete_cb = complete_cb,
     .user_data   = user_data
@@ -1022,16 +1028,57 @@ static bool ftdi_sio_set_request(cdch_interface_t* p_cdc, uint8_t command, uint1
   return tuh_control_xfer(&xfer);
 }
 
-static bool ftdi_sio_reset(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  return ftdi_sio_set_request(p_cdc, FTDI_SIO_RESET, FTDI_SIO_RESET_SIO, complete_cb, user_data);
+#ifdef CFG_TUH_CDC_FTDI_LATENCY
+static int8_t ftdi_write_latency_timer(cdch_interface_t * p_cdc, uint16_t latency,
+                                       tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  if (p_cdc->ftdi.chip_type == SIO /* || p_cdc->ftdi.chip_type == FT232A */ )
+    return FTDI_NOT_POSSIBLE;
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_LATENCY_TIMER_REQUEST, FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
+                          latency, p_cdc->ftdi.channel, complete_cb, user_data) ? FTDI_REQUESTED : FTDI_FAIL;
+}
+#endif
+
+static inline bool ftdi_sio_reset(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  return ftdi_set_request(p_cdc, FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE, FTDI_SIO_RESET_SIO,
+                          p_cdc->ftdi.channel, complete_cb, user_data);
+}
+
+static bool ftdi_change_speed(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  uint32_t index_value = ftdi_get_divisor(p_cdc);
+  TU_VERIFY(index_value);
+  uint16_t value = (uint16_t) index_value;
+  uint16_t index = (uint16_t) (index_value >> 16);
+  if (p_cdc->ftdi.channel) {
+    index = (uint16_t)((index << 8) | p_cdc->ftdi.channel);
+  }
+
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_BAUDRATE_REQUEST, FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
+                          value, index, complete_cb, user_data);
+}
+
+static bool ftdi_set_data_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 7 && p_cdc->requested_line_coding.data_bits <= 8, 0);
+  uint16_t value = (uint16_t) (
+    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xf)       |  // data bit quantity is stored in bits 0-3
+    ((uint32_t) p_cdc->requested_line_coding.parity    & 0x7) <<  8 |  // parity is stored in bits 8-10, same coding
+    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0x3) << 11 ); // stop bits quantity is stored in bits 11-12, same coding
+                                                                       // not each FTDI supports 1.5 stop bits
+
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_DATA_REQUEST, FTDI_SIO_SET_DATA_REQUEST_TYPE,
+                          value, p_cdc->ftdi.channel, complete_cb, user_data);
+}
+
+static inline bool ftdi_update_mctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // FTDI has the same bit coding
+  return ftdi_set_request(p_cdc, FTDI_SIO_SET_MODEM_CTRL_REQUEST, FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+                          p_cdc->requested_line_state, p_cdc->ftdi.channel, complete_cb, user_data);
 }
 
 //------------- Driver API -------------//
 
 // internal control complete to update state such as line state, line_coding
 static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  uint8_t const idx = ftdi_get_idx(xfer);
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
@@ -1039,11 +1086,17 @@ static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
 
   if (success) {
     switch (xfer->setup->bRequest) {
-      case FTDI_SIO_MODEM_CTRL:
+      case FTDI_SIO_SET_MODEM_CTRL_REQUEST:
         p_cdc->line_state = p_cdc->requested_line_state;
         break;
 
-      case FTDI_SIO_SET_BAUD_RATE:
+      case FTDI_SIO_SET_DATA_REQUEST:
+        p_cdc->line_coding.stop_bits = p_cdc->requested_line_coding.stop_bits;
+        p_cdc->line_coding.parity    = p_cdc->requested_line_coding.parity;
+        p_cdc->line_coding.data_bits = p_cdc->requested_line_coding.data_bits;
+        break;
+
+      case FTDI_SIO_SET_BAUDRATE_REQUEST:
         p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
         break;
 
@@ -1057,52 +1110,62 @@ static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool ftdi_sio_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint16_t const divisor = (uint16_t) ftdi_232bm_baud_to_divisor(p_cdc);
+static bool ftdi_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->user_control_cb = complete_cb;
+  TU_ASSERT(ftdi_set_data_request(p_cdc, complete_cb ? ftdi_internal_control_complete : NULL, user_data));
+
+  return true;
+}
 
+static bool ftdi_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_SET_BAUD_RATE, divisor,
-                                 complete_cb ? ftdi_internal_control_complete : NULL, user_data));
+  TU_ASSERT(ftdi_change_speed(p_cdc, complete_cb ? ftdi_internal_control_complete : NULL, user_data));
 
   return true;
 }
 
-static bool ftdi_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  (void) p_cdc;
-  (void) complete_cb;
-  (void) user_data;
-  // TODO not implemented yet
-  return false;
+static void ftdi_set_line_coding_stage1_complete(tuh_xfer_t * xfer) {
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  set_line_coding_stage1_complete(xfer, itf_num,
+                                  ftdi_set_data_request,           // control request function to set data format
+                                  ftdi_internal_control_complete); // control complete function to be called after request
 }
 
-static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  (void) p_cdc;
-  (void) complete_cb;
-  (void) user_data;
-  // TODO not implemented yet
-  return false;
+// 2 stages: set baudrate (stage1) + set data format (stage2)
+static bool ftdi_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  return set_line_coding_sequence(p_cdc,
+                                  ftdi_change_speed,                    // control request function to set baudrate
+                                  ftdi_set_data_request,                // control request function to set data format
+                                  ftdi_set_line_coding_stage1_complete, // function to be called after stage 1 completed
+                                  ftdi_internal_control_complete,       // control complete function to be called after request
+                                  complete_cb, user_data);
 }
 
-static bool ftdi_sio_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ftdi_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  TU_ASSERT(ftdi_sio_set_request(p_cdc, FTDI_SIO_MODEM_CTRL, 0x0300 | p_cdc->requested_line_state,
-                                 complete_cb ? ftdi_internal_control_complete : NULL, user_data));
+  TU_ASSERT(ftdi_update_mctrl(p_cdc, complete_cb ? ftdi_internal_control_complete : NULL, user_data));
+
   return true;
 }
 
 //------------- Enumeration -------------//
 
 enum {
-  CONFIG_FTDI_RESET = 0,
-  CONFIG_FTDI_MODEM_CTRL,
-  CONFIG_FTDI_SET_BAUDRATE,
+  CONFIG_FTDI_GET_DESC = 0,
+  CONFIG_FTDI_DETERMINE_TYPE,
+  CONFIG_FTDI_WRITE_LATENCY,
+  CONFIG_FTDI_SIO_RESET,
   CONFIG_FTDI_SET_DATA,
+  CONFIG_FTDI_SET_BAUDRATE,
+  CONFIG_FTDI_FLOW_CONTROL,
+  CONFIG_FTDI_MODEM_CTRL,
   CONFIG_FTDI_COMPLETE
 };
 
-static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len) {
+static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t * itf_desc, uint16_t max_len) {
   // FTDI Interface includes 1 vendor interface + 2 bulk endpoints
-  TU_VERIFY(itf_desc->bInterfaceSubClass == 0xff && itf_desc->bInterfaceProtocol == 0xff && itf_desc->bNumEndpoints == 2);
+  TU_VERIFY(itf_desc->bInterfaceSubClass == 0xff && itf_desc->bInterfaceProtocol == 0xff &&
+            itf_desc->bNumEndpoints == 2);
   TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
 
   cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
@@ -1113,53 +1176,96 @@ static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint
   // endpoint pair
   tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
 
+  /*
+   * NOTE: Some customers have programmed FT232R/FT245R devices
+   * with an endpoint size of 0 - not good.
+   */
+  TU_ASSERT(desc_ep->wMaxPacketSize != 0);
+
   // data endpoints expected to be in pairs
   return open_ep_stream_pair(p_cdc, desc_ep);
 }
 
-static void ftdi_process_config(tuh_xfer_t* xfer) {
+static void ftdi_process_config(tuh_xfer_t * xfer) {
   uintptr_t const state = xfer->user_data;
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
-  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  uint8_t const idx = ftdi_get_idx(xfer);
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS);
+  uint8_t const itf_num = p_cdc->bInterfaceNumber;
 
   switch(state) {
-    // Note may need to read FTDI eeprom
-    case CONFIG_FTDI_RESET:
-      TU_ASSERT_COMPLETE(ftdi_sio_reset(p_cdc, ftdi_process_config, CONFIG_FTDI_MODEM_CTRL));
+
+    // from here sequence overtaken from Linux Kernel function ftdi_port_probe()
+    case CONFIG_FTDI_GET_DESC:
+      // get device descriptor
+      p_cdc->user_control_cb = ftdi_process_config; // set once for whole process config
+      if (itf_num == 0) { // only necessary for 1st interface. other interface overtake type from interface 0
+        TU_ASSERT_COMPLETE(tuh_descriptor_get_device(xfer->daddr, desc_dev[idx], sizeof(tusb_desc_device_t),
+                                                     ftdi_process_config, CONFIG_FTDI_DETERMINE_TYPE));
+        break;
+      }
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_FTDI_DETERMINE_TYPE:
+      // determine type
+      if (itf_num == 0) {
+        TU_ASSERT_COMPLETE(ftdi_determine_type(p_cdc, idx));
+      } else {
+        // other interfaces have same type as interface 0
+        uint8_t const idx_itf0 = tuh_cdc_itf_get_index(xfer->daddr, 0);
+        cdch_interface_t const * p_cdc_itf0 = get_itf(idx_itf0);
+        p_cdc->ftdi.chip_type = p_cdc_itf0->ftdi.chip_type;
+      }
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_FTDI_WRITE_LATENCY:
+      #ifdef CFG_TUH_CDC_FTDI_LATENCY
+        int8_t result = ftdi_write_latency_timer(p_cdc, CFG_TUH_CDC_FTDI_LATENCY, ftdi_process_config,
+                                                 CONFIG_FTDI_SIO_RESET);
+        TU_ASSERT_COMPLETE(result != FTDI_FAIL);
+        if(result == FTDI_REQUESTED) {
+          break;
+        } // else FTDI_NOT_POSSIBLE => continue directly with next state
+      #endif
+      TU_ATTR_FALLTHROUGH;
+
+    // from here sequence overtaken from Linux Kernel function ftdi_open()
+    case CONFIG_FTDI_SIO_RESET:
+      TU_ASSERT_COMPLETE(ftdi_sio_reset(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_DATA));
       break;
 
-    case CONFIG_FTDI_MODEM_CTRL:
-      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-        TU_ASSERT_COMPLETE(ftdi_sio_set_modem_ctrl(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_BAUDRATE));
+    // from here sequence overtaken from Linux Kernel function ftdi_set_termios()
+    case CONFIG_FTDI_SET_DATA:
+      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
+        p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM;
+        TU_ASSERT_COMPLETE(ftdi_set_data_request(p_cdc, ftdi_internal_control_complete, CONFIG_FTDI_SET_BAUDRATE));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
       #endif
 
-    case CONFIG_FTDI_SET_BAUDRATE: {
+    case CONFIG_FTDI_SET_BAUDRATE:
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-        p_cdc->requested_line_coding.bit_rate = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM).bit_rate;
-        TU_ASSERT_COMPLETE(ftdi_sio_set_baudrate(p_cdc, ftdi_process_config, CONFIG_FTDI_SET_DATA));
+        TU_ASSERT_COMPLETE(ftdi_change_speed(p_cdc, ftdi_internal_control_complete, CONFIG_FTDI_FLOW_CONTROL));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
       #endif
-    }
 
-    case CONFIG_FTDI_SET_DATA: {
-      #if 0 // TODO set data format
-      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      TU_ASSERT_COMPLETE(ftdi_sio_set_data(p_cdc, process_ftdi_config, CONFIG_FTDI_COMPLETE));
+    case CONFIG_FTDI_FLOW_CONTROL:
+      // disable flow control
+      TU_ASSERT_COMPLETE(ftdi_set_request(p_cdc, FTDI_SIO_SET_FLOW_CTRL_REQUEST, FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
+                                          0, FTDI_SIO_DISABLE_FLOW_CTRL, ftdi_process_config, CONFIG_FTDI_MODEM_CTRL));
       break;
-      #endif
-      #endif
 
-      TU_ATTR_FALLTHROUGH;
-    }
+    case CONFIG_FTDI_MODEM_CTRL:
+      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        TU_ASSERT_COMPLETE(ftdi_update_mctrl(p_cdc, ftdi_internal_control_complete, CONFIG_FTDI_COMPLETE));
+        break;
+      #else
+        TU_ATTR_FALLTHROUGH;
+      #endif
 
     case CONFIG_FTDI_COMPLETE:
       set_config_complete(idx, 0, true);
@@ -1173,28 +1279,249 @@ static void ftdi_process_config(tuh_xfer_t* xfer) {
 
 //------------- Helper -------------//
 
+static bool ftdi_determine_type(cdch_interface_t * p_cdc, uint8_t const idx)
+{
+  uint16_t const version = desc_dev[idx]->bcdDevice;
+  uint8_t const itf_num = p_cdc->bInterfaceNumber;
+
+  p_cdc->ftdi.chip_type = UNKNOWN;
+
+  /* Assume Hi-Speed type */
+  p_cdc->ftdi.channel = CHANNEL_A + itf_num;
+
+  switch (version) {
+    case 0x200:
+      // FT232A not supported to keep it simple (no extra _read_latency_timer())
+      // not testable
+      // p_cdc->ftdi.chip_type = FT232A;
+      // p_cdc->ftdi.baud_base = 48000000 / 2;
+      // p_cdc->ftdi.channel = 0;
+      // /*
+      //  * FT232B devices have a bug where bcdDevice gets set to 0x200
+      //  * when iSerialNumber is 0. Assume it is an FT232B in case the
+      //  * latency timer is readable.
+      //  */
+      // if (desc->iSerialNumber == 0 &&
+      //     _read_latency_timer(port) >= 0) {
+      //   p_cdc->ftdi.chip_type = FT232B;
+      // }
+      break;
+    case 0x400:
+      p_cdc->ftdi.chip_type = FT232B;
+      p_cdc->ftdi.channel = 0;
+      break;
+    case 0x500:
+      p_cdc->ftdi.chip_type = FT2232C;
+      break;
+    case 0x600:
+      p_cdc->ftdi.chip_type = FT232R;
+      p_cdc->ftdi.channel = 0;
+      break;
+    case 0x700:
+      p_cdc->ftdi.chip_type = FT2232H;
+      break;
+    case 0x800:
+      p_cdc->ftdi.chip_type = FT4232H;
+      break;
+    case 0x900:
+      p_cdc->ftdi.chip_type = FT232H;
+      break;
+    case 0x1000:
+      p_cdc->ftdi.chip_type = FTX;
+      break;
+    case 0x2800:
+      p_cdc->ftdi.chip_type = FT2233HP;
+      break;
+    case 0x2900:
+      p_cdc->ftdi.chip_type = FT4233HP;
+      break;
+    case 0x3000:
+      p_cdc->ftdi.chip_type = FT2232HP;
+      break;
+    case 0x3100:
+      p_cdc->ftdi.chip_type = FT4232HP;
+      break;
+    case 0x3200:
+      p_cdc->ftdi.chip_type = FT233HP;
+      break;
+    case 0x3300:
+      p_cdc->ftdi.chip_type = FT232HP;
+      break;
+    case 0x3600:
+      p_cdc->ftdi.chip_type = FT4232HA;
+      break;
+    default:
+      if (version < 0x200) {
+        p_cdc->ftdi.chip_type = SIO;
+        p_cdc->ftdi.channel = 0;
+      }
+      break;
+  }
+
+  TU_LOG_P_CDC("%s detected", ftdi_chip_name[p_cdc->ftdi.chip_type]);
+
+  return (p_cdc->ftdi.chip_type != UNKNOWN);
+}
+
+// FT232A not supported
+//static uint32_t ftdi_232am_baud_base_to_divisor(uint32_t baud, uint32_t base)
+//{
+//  uint32_t divisor;
+//  /* divisor shifted 3 bits to the left */
+//  uint32_t divisor3 = DIV_ROUND_CLOSEST(base, 2 * baud);
+//  if ((divisor3 & 0x7) == 7)
+//    divisor3++; /* round x.7/8 up to x+1 */
+//  divisor = divisor3 >> 3;
+//  divisor3 &= 0x7;
+//  if (divisor3 == 1)
+//    divisor |= 0xc000;  /* +0.125 */
+//  else if (divisor3 >= 4)
+//    divisor |= 0x4000;  /* +0.5 */
+//  else if (divisor3 != 0)
+//    divisor |= 0x8000;  /* +0.25 */
+//  else if (divisor == 1)
+//    divisor = 0;    /* special case for maximum baud rate */
+//  return divisor;
+//}
+
+// FT232A not supported
+//static inline uint32_t ftdi_232am_baud_to_divisor(uint32_t baud)
+//{
+//   return ftdi_232am_baud_base_to_divisor(baud, (uint32_t) 48000000);
+//}
+
 static uint32_t ftdi_232bm_baud_base_to_divisor(uint32_t baud, uint32_t base) {
-  const uint8_t divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
+  uint8_t divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
   uint32_t divisor;
-
   /* divisor shifted 3 bits to the left */
-  uint32_t divisor3 = base / (2 * baud);
-  divisor = (divisor3 >> 3);
-  divisor |= (uint32_t) divfrac[divisor3 & 0x7] << 14;
+  uint32_t divisor3 = DIV_ROUND_CLOSEST(base, 2 * baud);
+  divisor = divisor3 >> 3;
+  divisor |= (uint32_t)divfrac[divisor3 & 0x7] << 14;
+  /* Deal with special cases for highest baud rates. */
+  if (divisor == 1)   /* 1.0 */
+    divisor = 0;
+  else if (divisor == 0x4001) /* 1.5 */
+    divisor = 1;
+  return divisor;
+}
+
+static inline uint32_t ftdi_232bm_baud_to_divisor(uint32_t baud)
+{
+   return ftdi_232bm_baud_base_to_divisor(baud, 48000000);
+}
+
+static uint32_t ftdi_2232h_baud_base_to_divisor(uint32_t baud, uint32_t base)
+{
+  static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
+  uint32_t divisor;
+  uint32_t divisor3;
+
+  /* hi-speed baud rate is 10-bit sampling instead of 16-bit */
+  divisor3 = DIV_ROUND_CLOSEST(8 * base, 10 * baud);
 
+  divisor = divisor3 >> 3;
+  divisor |= (uint32_t)divfrac[divisor3 & 0x7] << 14;
   /* Deal with special cases for highest baud rates. */
-  if (divisor == 1) { /* 1.0 */
+  if (divisor == 1)   /* 1.0 */
     divisor = 0;
-  }
-  else if (divisor == 0x4001) { /* 1.5 */
+  else if (divisor == 0x4001) /* 1.5 */
     divisor = 1;
+  /*
+   * Set this bit to turn off a divide by 2.5 on baud rate generator
+   * This enables baud rates up to 12Mbaud but cannot reach below 1200
+   * baud with this bit set
+   */
+  divisor |= 0x00020000;
+  return divisor;
+}
+
+static inline uint32_t ftdi_2232h_baud_to_divisor(uint32_t baud)
+{
+   return ftdi_2232h_baud_base_to_divisor(baud, (uint32_t) 120000000);
+}
+
+static inline uint32_t ftdi_get_divisor(cdch_interface_t * p_cdc)
+{
+  uint32_t baud = p_cdc->requested_line_coding.bit_rate;
+  uint32_t div_value = 0;
+  TU_VERIFY(baud);
+
+  switch (p_cdc->ftdi.chip_type) {
+    case UNKNOWN:
+      return 0;
+    case SIO:
+      switch (baud) {
+        case 300: div_value = ftdi_sio_b300; break;
+        case 600: div_value = ftdi_sio_b600; break;
+        case 1200: div_value = ftdi_sio_b1200; break;
+        case 2400: div_value = ftdi_sio_b2400; break;
+        case 4800: div_value = ftdi_sio_b4800; break;
+        case 9600: div_value = ftdi_sio_b9600; break;
+        case 19200: div_value = ftdi_sio_b19200; break;
+        case 38400: div_value = ftdi_sio_b38400; break;
+        case 57600: div_value = ftdi_sio_b57600;  break;
+        case 115200: div_value = ftdi_sio_b115200; break;
+        default:
+          // Baudrate not supported
+          return 0;
+          break;
+      }
+      break;
+      // FT232A not supported
+      // case FT232A:
+      //   if (baud <= 3000000) {
+      //     div_value = ftdi_232am_baud_to_divisor(baud);
+      //   } else {
+      //     // Baud rate too high!
+      //     baud = 9600;
+      //     div_value = ftdi_232am_baud_to_divisor(9600);
+      //     div_okay = false;
+      //   }
+      //   break;
+    case FT232B:
+    case FT2232C:
+    case FT232R:
+    case FTX:
+      TU_VERIFY(baud <= 3000000); // else Baud rate too high!
+      div_value = ftdi_232bm_baud_to_divisor(baud);
+      break;
+    case FT232H:
+    case FT2232H:
+    case FT4232H:
+    case FT4232HA:
+    case FT232HP:
+    case FT233HP:
+    case FT2232HP:
+    case FT2233HP:
+    case FT4232HP:
+    case FT4233HP:
+    default:
+      TU_VERIFY(baud <= 12000000); // else Baud rate too high!
+      if (baud >= 1200) {
+        div_value = ftdi_2232h_baud_to_divisor(baud);
+      } else {
+        div_value = ftdi_232bm_baud_to_divisor(baud);
+      }
+      break;
   }
 
-  return divisor;
+  TU_LOG_P_CDC("Baudrate divisor 0x%lu", div_value);
+
+  return div_value;
 }
 
-static uint32_t ftdi_232bm_baud_to_divisor(cdch_interface_t* p_cdc) {
-  return ftdi_232bm_baud_base_to_divisor(p_cdc->requested_line_coding.bit_rate, 48000000u);
+static uint8_t ftdi_get_idx(tuh_xfer_t * xfer) {
+  uint8_t const channel = (uint8_t) tu_le16toh(xfer->setup->wIndex); // channel index, or 0 for legacy types
+  for (uint8_t i = 0; i < CFG_TUH_CDC; i++) {
+    const cdch_interface_t * p_cdc = &cdch_data[i];
+    if (p_cdc->daddr == xfer->daddr &&
+        (!p_cdc->ftdi.channel ||           // 0 for legacy types (only interface 0)
+        channel == p_cdc->ftdi.channel)) { // or  multi-channel types (interfaces 0..n)
+      return i;
+    }
+  }
+
+  return TUSB_INDEX_INVALID_8;
 }
 
 #endif
diff --git a/src/class/cdc/serial/ftdi_sio.h b/src/class/cdc/serial/ftdi_sio.h
index 0825f07195..42716f73e2 100644
--- a/src/class/cdc/serial/ftdi_sio.h
+++ b/src/class/cdc/serial/ftdi_sio.h
@@ -25,222 +25,207 @@
 #ifndef TUSB_FTDI_SIO_H
 #define TUSB_FTDI_SIO_H
 
-// VID for matching FTDI devices
-#define TU_FTDI_VID 0x0403
+#include <stdint.h>
 
 // Commands
-#define FTDI_SIO_RESET             	0    /* Reset the port */
-#define FTDI_SIO_MODEM_CTRL        	1    /* Set the modem control register */
-#define FTDI_SIO_SET_FLOW_CTRL     	2    /* Set flow control register */
-#define FTDI_SIO_SET_BAUD_RATE     	3    /* Set baud rate */
-#define FTDI_SIO_SET_DATA          	4    /* Set the data characteristics of the port */
-#define FTDI_SIO_GET_MODEM_STATUS  	5    /* Retrieve current value of modem status register */
-#define FTDI_SIO_SET_EVENT_CHAR    	6    /* Set the event character */
-#define FTDI_SIO_SET_ERROR_CHAR    	7    /* Set the error character */
-#define FTDI_SIO_SET_LATENCY_TIMER 	9    /* Set the latency timer */
-#define FTDI_SIO_GET_LATENCY_TIMER 	0x0a /* Get the latency timer */
-#define FTDI_SIO_SET_BITMODE       	0x0b /* Set bitbang mode */
-#define FTDI_SIO_READ_PINS         	0x0c /* Read immediate value of pins */
-#define FTDI_SIO_READ_EEPROM       	0x90 /* Read EEPROM */
-
-/* FTDI_SIO_RESET */
+#define FTDI_SIO_RESET              0 // Reset the port
+#define FTDI_SIO_MODEM_CTRL         1 // Set the modem control register
+#define FTDI_SIO_SET_FLOW_CTRL      2 // Set flow control register
+#define FTDI_SIO_SET_BAUD_RATE      3 // Set baud rate
+#define FTDI_SIO_SET_DATA           4 // Set the data characteristics of the port
+#define FTDI_SIO_GET_MODEM_STATUS   5 // Retrieve current value of modem status register
+#define FTDI_SIO_SET_EVENT_CHAR     6 // Set the event character
+#define FTDI_SIO_SET_ERROR_CHAR     7 // Set the error character
+#define FTDI_SIO_SET_LATENCY_TIMER  9 // Set the latency timer
+#define FTDI_SIO_GET_LATENCY_TIMER 10 // Get the latency timer
+#define FTDI_SIO_SET_BITMODE       11 // Set bitbang mode
+#define FTDI_SIO_READ_PINS         12 // Read immediate value of pins
+#define FTDI_SIO_READ_EEPROM     0x90 // Read EEPROM
+
+// Channel indices for FT2232, FT2232H and FT4232H devices
+#define CHANNEL_A   1
+#define CHANNEL_B   2
+#define CHANNEL_C   3
+#define CHANNEL_D   4
+
+// Port Identifier Table
+#define PIT_DEFAULT   0 // SIOA
+#define PIT_SIOA      1 // SIOA
+// The device this driver is tested with one has only one port
+#define PIT_SIOB      2 // SIOB
+#define PIT_PARALLEL  3 // Parallel
+
+// FTDI_SIO_RESET
+#define FTDI_SIO_RESET_REQUEST FTDI_SIO_RESET
+#define FTDI_SIO_RESET_REQUEST_TYPE 0x40
 #define FTDI_SIO_RESET_SIO 0
 #define FTDI_SIO_RESET_PURGE_RX 1
 #define FTDI_SIO_RESET_PURGE_TX 2
 
-/*
- * BmRequestType:  0100 0000B
- * bRequest:       FTDI_SIO_RESET
- * wValue:         Control Value
- *                   0 = Reset SIO
- *                   1 = Purge RX buffer
- *                   2 = Purge TX buffer
- * wIndex:         Port
- * wLength:        0
- * Data:           None
- *
- * The Reset SIO command has this effect:
- *
- *    Sets flow control set to 'none'
- *    Event char = $0D
- *    Event trigger = disabled
- *    Purge RX buffer
- *    Purge TX buffer
- *    Clear DTR
- *    Clear RTS
- *    baud and data format not reset
- *
- * The Purge RX and TX buffer commands affect nothing except the buffers
- *
-   */
-
-/* FTDI_SIO_MODEM_CTRL */
-/*
- * BmRequestType:   0100 0000B
- * bRequest:        FTDI_SIO_MODEM_CTRL
- * wValue:          ControlValue (see below)
- * wIndex:          Port
- * wLength:         0
- * Data:            None
- *
- * NOTE: If the device is in RTS/CTS flow control, the RTS set by this
- * command will be IGNORED without an error being returned
- * Also - you can not set DTR and RTS with one control message
- */
+// FTDI_SIO_SET_BAUDRATE
+#define FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE 0x40
+#define FTDI_SIO_SET_BAUDRATE_REQUEST 3
+
+enum ftdi_sio_baudrate {
+  ftdi_sio_b300 = 0,
+  ftdi_sio_b600 = 1,
+  ftdi_sio_b1200 = 2,
+  ftdi_sio_b2400 = 3,
+  ftdi_sio_b4800 = 4,
+  ftdi_sio_b9600 = 5,
+  ftdi_sio_b19200 = 6,
+  ftdi_sio_b38400 = 7,
+  ftdi_sio_b57600 = 8,
+  ftdi_sio_b115200 = 9
+};
+
+// FTDI_SIO_SET_DATA
+#define FTDI_SIO_SET_DATA_REQUEST FTDI_SIO_SET_DATA
+#define FTDI_SIO_SET_DATA_REQUEST_TYPE  0x40
+#define FTDI_SIO_SET_DATA_PARITY_NONE (0x0 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_ODD  (0x1 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_EVEN (0x2 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_MARK (0x3 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_SPACE  (0x4 << 8)
+#define FTDI_SIO_SET_DATA_STOP_BITS_1 (0x0 << 11)
+#define FTDI_SIO_SET_DATA_STOP_BITS_15  (0x1 << 11)
+#define FTDI_SIO_SET_DATA_STOP_BITS_2 (0x2 << 11)
+#define FTDI_SIO_SET_BREAK    (0x1 << 14)
+
+// FTDI_SIO_MODEM_CTRL
+#define FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE 0x40
+#define FTDI_SIO_SET_MODEM_CTRL_REQUEST FTDI_SIO_MODEM_CTRL
 
 #define FTDI_SIO_SET_DTR_MASK 0x1
-#define FTDI_SIO_SET_DTR_HIGH ((FTDI_SIO_SET_DTR_MASK << 8) | 1)
-#define FTDI_SIO_SET_DTR_LOW  ((FTDI_SIO_SET_DTR_MASK << 8) | 0)
+#define FTDI_SIO_SET_DTR_HIGH ((FTDI_SIO_SET_DTR_MASK  << 8) | 1)
+#define FTDI_SIO_SET_DTR_LOW  ((FTDI_SIO_SET_DTR_MASK  << 8) | 0)
 #define FTDI_SIO_SET_RTS_MASK 0x2
 #define FTDI_SIO_SET_RTS_HIGH ((FTDI_SIO_SET_RTS_MASK << 8) | 2)
 #define FTDI_SIO_SET_RTS_LOW  ((FTDI_SIO_SET_RTS_MASK << 8) | 0)
 
-/*
- * ControlValue
- * B0    DTR state
- *          0 = reset
- *          1 = set
- * B1    RTS state
- *          0 = reset
- *          1 = set
- * B2..7 Reserved
- * B8    DTR state enable
- *          0 = ignore
- *          1 = use DTR state
- * B9    RTS state enable
- *          0 = ignore
- *          1 = use RTS state
- * B10..15 Reserved
- */
-
-/* FTDI_SIO_SET_FLOW_CTRL */
+// FTDI_SIO_SET_FLOW_CTRL
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE 0x40
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST FTDI_SIO_SET_FLOW_CTRL
 #define FTDI_SIO_DISABLE_FLOW_CTRL 0x0
 #define FTDI_SIO_RTS_CTS_HS (0x1 << 8)
 #define FTDI_SIO_DTR_DSR_HS (0x2 << 8)
 #define FTDI_SIO_XON_XOFF_HS (0x4 << 8)
 
-/*
- *   BmRequestType:  0100 0000b
- *   bRequest:       FTDI_SIO_SET_FLOW_CTRL
- *   wValue:         Xoff/Xon
- *   wIndex:         Protocol/Port - hIndex is protocol / lIndex is port
- *   wLength:        0
- *   Data:           None
- *
- * hIndex protocol is:
- *   B0 Output handshaking using RTS/CTS
- *       0 = disabled
- *       1 = enabled
- *   B1 Output handshaking using DTR/DSR
- *       0 = disabled
- *       1 = enabled
- *   B2 Xon/Xoff handshaking
- *       0 = disabled
- *       1 = enabled
- *
- * A value of zero in the hIndex field disables handshaking
- *
- * If Xon/Xoff handshaking is specified, the hValue field should contain the
- * XOFF character and the lValue field contains the XON character.
- */
-
-/* FTDI_SIO_SET_BAUD_RATE */
-/*
- * BmRequestType:  0100 0000B
- * bRequest:       FTDI_SIO_SET_BAUDRATE
- * wValue:         BaudDivisor value - see below
- * wIndex:         Port
- * wLength:        0
- * Data:           None
- * The BaudDivisor values are calculated as follows (too complicated):
- */
-
-/* FTDI_SIO_SET_DATA */
-#define FTDI_SIO_SET_DATA_PARITY_NONE	(0x0 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_ODD	(0x1 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_EVEN	(0x2 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_MARK	(0x3 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_SPACE	(0x4 << 8)
-#define FTDI_SIO_SET_DATA_STOP_BITS_1	(0x0 << 11)
-#define FTDI_SIO_SET_DATA_STOP_BITS_15	(0x1 << 11)
-#define FTDI_SIO_SET_DATA_STOP_BITS_2	(0x2 << 11)
-#define FTDI_SIO_SET_BREAK		(0x1 << 14)
-
-/*
- * BmRequestType:  0100 0000B
- * bRequest:       FTDI_SIO_SET_DATA
- * wValue:         Data characteristics (see below)
- * wIndex:         Port
- * wLength:        0
- * Data:           No
- *
- * Data characteristics
- *
- *   B0..7   Number of data bits
- *   B8..10  Parity
- *           0 = None
- *           1 = Odd
- *           2 = Even
- *           3 = Mark
- *           4 = Space
- *   B11..13 Stop Bits
- *           0 = 1
- *           1 = 1.5
- *           2 = 2
- *   B14
- *           1 = TX ON (break)
- *           0 = TX OFF (normal state)
- *   B15 Reserved
- *
- */
-
-/*
-* DATA FORMAT
-*
-* IN Endpoint
-*
-* The device reserves the first two bytes of data on this endpoint to contain
-* the current values of the modem and line status registers. In the absence of
-* data, the device generates a message consisting of these two status bytes
-  * every 40 ms
-  *
-  * Byte 0: Modem Status
-*
-* Offset	Description
-* B0	Reserved - must be 1
-* B1	Reserved - must be 0
-* B2	Reserved - must be 0
-* B3	Reserved - must be 0
-* B4	Clear to Send (CTS)
-* B5	Data Set Ready (DSR)
-* B6	Ring Indicator (RI)
-* B7	Receive Line Signal Detect (RLSD)
-*
-* Byte 1: Line Status
-*
-* Offset	Description
-* B0	Data Ready (DR)
-* B1	Overrun Error (OE)
-* B2	Parity Error (PE)
-* B3	Framing Error (FE)
-* B4	Break Interrupt (BI)
-* B5	Transmitter Holding Register (THRE)
-* B6	Transmitter Empty (TEMT)
-* B7	Error in RCVR FIFO
-*
-*/
-#define FTDI_RS0_CTS	(1 << 4)
-#define FTDI_RS0_DSR	(1 << 5)
-#define FTDI_RS0_RI	(1 << 6)
-#define FTDI_RS0_RLSD	(1 << 7)
-
-#define FTDI_RS_DR	1
-#define FTDI_RS_OE	(1<<1)
-#define FTDI_RS_PE	(1<<2)
-#define FTDI_RS_FE	(1<<3)
-#define FTDI_RS_BI	(1<<4)
-#define FTDI_RS_THRE	(1<<5)
-#define FTDI_RS_TEMT	(1<<6)
-#define FTDI_RS_FIFO	(1<<7)
+// FTDI_SIO_GET_LATENCY_TIMER
+#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST FTDI_SIO_GET_LATENCY_TIMER
+#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE 0xC0
+
+// FTDI_SIO_SET_LATENCY_TIMER
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST FTDI_SIO_SET_LATENCY_TIMER
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE 0x40
+
+// FTDI_SIO_SET_EVENT_CHAR
+#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST FTDI_SIO_SET_EVENT_CHAR
+#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE 0x40
+
+// FTDI_SIO_GET_MODEM_STATUS
+#define FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE 0xc0
+#define FTDI_SIO_GET_MODEM_STATUS_REQUEST FTDI_SIO_GET_MODEM_STATUS
+#define FTDI_SIO_CTS_MASK 0x10
+#define FTDI_SIO_DSR_MASK 0x20
+#define FTDI_SIO_RI_MASK  0x40
+#define FTDI_SIO_RLSD_MASK 0x80
+
+// FTDI_SIO_SET_BITMODE
+#define FTDI_SIO_SET_BITMODE_REQUEST_TYPE 0x40
+#define FTDI_SIO_SET_BITMODE_REQUEST FTDI_SIO_SET_BITMODE
+
+// Possible bitmodes for FTDI_SIO_SET_BITMODE_REQUEST
+#define FTDI_SIO_BITMODE_RESET    0x00
+#define FTDI_SIO_BITMODE_CBUS   0x20
+
+// FTDI_SIO_READ_PINS
+#define FTDI_SIO_READ_PINS_REQUEST_TYPE 0xc0
+#define FTDI_SIO_READ_PINS_REQUEST FTDI_SIO_READ_PINS
+
+// FTDI_SIO_READ_EEPROM
+#define FTDI_SIO_READ_EEPROM_REQUEST_TYPE 0xc0
+#define FTDI_SIO_READ_EEPROM_REQUEST FTDI_SIO_READ_EEPROM
+
+#define FTDI_FTX_CBUS_MUX_GPIO    0x8
+#define FTDI_FT232R_CBUS_MUX_GPIO 0xa
+
+#define FTDI_RS0_CTS  (1 << 4)
+#define FTDI_RS0_DSR  (1 << 5)
+#define FTDI_RS0_RI (1 << 6)
+#define FTDI_RS0_RLSD (1 << 7)
+
+#define FTDI_RS_DR  1
+#define FTDI_RS_OE  (1<<1)
+#define FTDI_RS_PE  (1<<2)
+#define FTDI_RS_FE  (1<<3)
+#define FTDI_RS_BI  (1<<4)
+#define FTDI_RS_THRE  (1<<5)
+#define FTDI_RS_TEMT  (1<<6)
+#define FTDI_RS_FIFO  (1<<7)
+
+// chip types and names
+enum ftdi_chip_type {
+  SIO = 0,
+//  FT232A,
+  FT232B,
+  FT2232C,
+  FT232R,
+  FT232H,
+  FT2232H,
+  FT4232H,
+  FT4232HA,
+  FT232HP,
+  FT233HP,
+  FT2232HP,
+  FT2233HP,
+  FT4232HP,
+  FT4233HP,
+  FTX,
+  UNKNOWN
+};
+
+#define FTDI_CHIP_NAMES \
+  [SIO]       = (uint8_t const*) "SIO", /* the serial part of FT8U100AX */ \
+/*  [FT232A]    = (uint8_t const*) "FT232A", */ \
+  [FT232B]    = (uint8_t const*) "FT232B", \
+  [FT2232C]   = (uint8_t const*) "FT2232C/D", \
+  [FT232R]    = (uint8_t const*) "FT232R", \
+  [FT232H]    = (uint8_t const*) "FT232H", \
+  [FT2232H]   = (uint8_t const*) "FT2232H", \
+  [FT4232H]   = (uint8_t const*) "FT4232H", \
+  [FT4232HA]  = (uint8_t const*) "FT4232HA", \
+  [FT232HP]   = (uint8_t const*) "FT232HP", \
+  [FT233HP]   = (uint8_t const*) "FT233HP", \
+  [FT2232HP]  = (uint8_t const*) "FT2232HP", \
+  [FT2233HP]  = (uint8_t const*) "FT2233HP", \
+  [FT4232HP]  = (uint8_t const*) "FT4232HP", \
+  [FT4233HP]  = (uint8_t const*) "FT4233HP", \
+  [FTX]       = (uint8_t const*) "FT-X", \
+  [UNKNOWN]   = (uint8_t const*) "UNKNOWN"
+
+// private interface data
+typedef struct ftdi_private {
+  enum ftdi_chip_type chip_type;
+  uint8_t channel; // channel index, or 0 for legacy types
+} ftdi_private_t;
+
+#define FTDI_OK true
+#define FTDI_FAIL false
+#define FTDI_NOT_POSSIBLE -1
+#define FTDI_REQUESTED -2
+
+// division and round function overtaken from math.h
+#define DIV_ROUND_CLOSEST(x, divisor)(      \
+{             \
+  typeof(x) __x = x;        \
+  typeof(divisor) __d = divisor;      \
+  (((typeof(x))-1) > 0 ||       \
+   ((typeof(divisor))-1) > 0 ||     \
+   (((__x) > 0) == ((__d) > 0))) ?    \
+    (((__x) + ((__d) / 2)) / (__d)) : \
+    (((__x) - ((__d) / 2)) / (__d));  \
+}             \
+)
 
 #endif //TUSB_FTDI_SIO_H
diff --git a/src/tusb_option.h b/src/tusb_option.h
index 767323bddf..ebf9a4d4d3 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -456,9 +456,22 @@
 #ifndef CFG_TUH_CDC_FTDI_VID_PID_LIST
   // List of product IDs that can use the FTDI CDC driver. 0x0403 is FTDI's VID
   #define CFG_TUH_CDC_FTDI_VID_PID_LIST \
-    {0x0403, 0x6001}, {0x0403, 0x6006}, {0x0403, 0x6010}, {0x0403, 0x6011}, \
-    {0x0403, 0x6014}, {0x0403, 0x6015}, {0x0403, 0x8372}, {0x0403, 0xFBFA}, \
-    {0x0403, 0xCD18}
+    {0x0403, 0x6001}, /* Similar device to SIO above */ \
+    {0x0403, 0x6006}, /* FTDI's alternate PID for above */ \
+    {0x0403, 0x6010}, /* Dual channel device */ \
+    {0x0403, 0x6011}, /* Quad channel hi-speed device */ \
+    {0x0403, 0x6014}, /* Single channel hi-speed device */ \
+    {0x0403, 0x6015}, /* FT-X series (FT201X, FT230X, FT231X, etc) */ \
+    {0x0403, 0x6040}, /* Dual channel hi-speed device with PD */ \
+    {0x0403, 0x6041}, /* Quad channel hi-speed device with PD */ \
+    {0x0403, 0x6042}, /* Dual channel hi-speed device with PD */ \
+    {0x0403, 0x6043}, /* Quad channel hi-speed device with PD */ \
+    {0x0403, 0x6044}, /* Dual channel hi-speed device with PD */ \
+    {0x0403, 0x6045}, /* Dual channel hi-speed device with PD */ \
+    {0x0403, 0x6048}, /* Quad channel automotive grade hi-speed device */ \
+    {0x0403, 0x8372}, /* Product Id SIO application of 8U100AX */ \
+    {0x0403, 0xFBFA}, /* Product ID for FT232RL */ \
+    {0x0403, 0xCD18}, /* ??? */
 #endif
 
 #ifndef CFG_TUH_CDC_CP210X

From 4547737833de0368354cb4823d908c6b250f92df Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 22 Feb 2024 15:42:33 +0100
Subject: [PATCH 14/37] improved CP210x support

---
 src/class/cdc/cdc_host.c      | 135 +++++++++++++++++++++++-----------
 src/class/cdc/serial/cp210x.h |  63 +++++++++++++++-
 src/tusb_option.h             |   4 +-
 3 files changed, 159 insertions(+), 43 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index f9540efbe6..86c010fa73 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -83,7 +83,7 @@ typedef struct {
   uint8_t requested_line_state;
 
   tuh_xfer_cb_t user_control_cb;
-  #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_CH34X
+  #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_CP210X || CFG_TUH_CDC_CH34X
   tuh_xfer_cb_t requested_complete_cb;
   #endif
 
@@ -1533,7 +1533,8 @@ static uint8_t ftdi_get_idx(tuh_xfer_t * xfer) {
 
 //------------- Control Request -------------//
 
-static bool cp210x_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_t value, uint8_t* buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool cp210x_set_request(cdch_interface_t * p_cdc, uint8_t command, uint16_t value,
+                               uint8_t * buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   tusb_control_request_t const request = {
     .bmRequestType_bit = {
       .recipient = TUSB_REQ_RCPT_INTERFACE,
@@ -1542,12 +1543,12 @@ static bool cp210x_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_
     },
     .bRequest = command,
     .wValue   = tu_htole16(value),
-    .wIndex   = p_cdc->bInterfaceNumber,
+    .wIndex   = tu_htole16(p_cdc->bInterfaceNumber),
     .wLength  = tu_htole16(length)
   };
 
   // use usbh enum buf since application variable does not live long enough
-  uint8_t* enum_buf = NULL;
+  uint8_t * enum_buf = NULL;
 
   if (buffer && length > 0) {
     enum_buf = usbh_get_enum_buf();
@@ -1566,18 +1567,52 @@ static bool cp210x_set_request(cdch_interface_t* p_cdc, uint8_t command, uint16_
   return tuh_control_xfer(&xfer);
 }
 
-static bool cp210x_ifc_enable(cdch_interface_t* p_cdc, uint16_t enabled, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static inline bool cp210x_ifc_enable(cdch_interface_t * p_cdc, uint16_t enabled,
+                                     tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return cp210x_set_request(p_cdc, CP210X_IFC_ENABLE, enabled, NULL, 0, complete_cb, user_data);
 }
 
+static bool cp210x_set_baudrate_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // Check baudrate is supported. It's only a specific list. reference: datasheets and AN205 "CP210x Baud Rate Support"
+  uint32_t const supported_baudrates_list[] = CP210X_SUPPORTED_BAUDRATES_LIST;
+  uint8_t i;
+  for ( i=0; supported_baudrates_list[i]; i++ ){
+    if (p_cdc->requested_line_coding.bit_rate == supported_baudrates_list[i]) {
+      break;
+    }
+  }
+  TU_VERIFY(supported_baudrates_list[i]);
+  uint32_t baud_le = tu_htole32(p_cdc->requested_line_coding.bit_rate);
+
+  return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4, complete_cb, user_data);
+}
+
+static bool cp210x_set_line_ctl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 9, 0);
+  uint16_t lcr = (uint16_t) (
+    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xf) << 8 | // data bit quantity is stored in bits 8-11
+    ((uint32_t) p_cdc->requested_line_coding.parity    & 0xf) << 4 | // parity is stored in bits 4-7, same coding
+    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0xf));     // parity is stored in bits 0-3, same coding
+
+  return cp210x_set_request(p_cdc, CP210X_SET_LINE_CTL, lcr, NULL, 0, complete_cb, user_data);
+}
+
+static inline bool cp210x_set_mhs(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // CP210x has the same bit coding
+  return cp210x_set_request(p_cdc, CP210X_SET_MHS,
+                            (uint16_t) ((uint32_t) CP210X_CONTROL_WRITE_DTR |
+                                        (uint32_t) CP210X_CONTROL_WRITE_RTS | p_cdc->requested_line_state),
+                            NULL, 0, complete_cb, user_data);
+}
+
 //------------- Driver API -------------//
 
 // internal control complete to update state such as line state, encoding
 static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
   uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
   uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
   TU_LOG_P_CDC("control complete success = %u", success);
 
@@ -1587,6 +1622,12 @@ static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
         p_cdc->line_state = p_cdc->requested_line_state;
         break;
 
+      case CP210X_SET_LINE_CTL:
+        p_cdc->line_coding.stop_bits = p_cdc->requested_line_coding.stop_bits;
+        p_cdc->line_coding.parity    = p_cdc->requested_line_coding.parity;
+        p_cdc->line_coding.data_bits = p_cdc->requested_line_coding.data_bits;
+        break;
+
       case CP210X_SET_BAUDRATE:
         p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
         break;
@@ -1601,46 +1642,55 @@ static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint32_t baud_le = tu_htole32(p_cdc->requested_line_coding.bit_rate);
+static bool cp210x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4,
-                            complete_cb ? cp210x_internal_control_complete : NULL, user_data);
+  TU_ASSERT(cp210x_set_baudrate_request(p_cdc, complete_cb ? cp210x_internal_control_complete : NULL, user_data));
+
+  return true;
 }
 
-static bool cp210x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  (void) p_cdc;
-  (void) complete_cb;
-  (void) user_data;
-  // TODO not implemented yet
-  return false;
+static bool cp210x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->user_control_cb = complete_cb;
+  TU_ASSERT(cp210x_set_line_ctl(p_cdc, complete_cb ? cp210x_internal_control_complete : NULL, user_data));
+
+  return true;
 }
 
-static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  // TODO implement later
-  (void) p_cdc;
-  (void) complete_cb;
-  (void) user_data;
-  return false;
+static void cp210x_set_line_coding_stage1_complete(tuh_xfer_t * xfer) {
+  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  set_line_coding_stage1_complete(xfer, itf_num,
+                                  cp210x_set_line_ctl,               // control request function to set data format
+                                  cp210x_internal_control_complete); // control complete function to be called after request
+}
+
+// 2 stages: set baudrate (stage1) + set data format (stage2)
+static bool cp210x_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  return set_line_coding_sequence(p_cdc,
+                                  cp210x_set_baudrate_request,            // control request function to set baudrate
+                                  cp210x_set_line_ctl,                    // control request function to set data format
+                                  cp210x_set_line_coding_stage1_complete, // function to be called after stage 1 completed
+                                  cp210x_internal_control_complete,       // control complete function to be called after request
+                                  complete_cb, user_data);
 }
 
-static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool cp210x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->user_control_cb = complete_cb;
-  return cp210x_set_request(p_cdc, CP210X_SET_MHS, 0x0300 | p_cdc->requested_line_state, NULL, 0,
-                            complete_cb ? cp210x_internal_control_complete : NULL, user_data);
+  TU_ASSERT(cp210x_set_mhs(p_cdc, complete_cb ? cp210x_internal_control_complete : NULL, user_data));
+
+  return true;
 }
 
 //------------- Enumeration -------------//
 
 enum {
   CONFIG_CP210X_IFC_ENABLE = 0,
-  CONFIG_CP210X_SET_BAUDRATE,
+  CONFIG_CP210X_SET_BAUDRATE_REQUEST,
   CONFIG_CP210X_SET_LINE_CTL,
   CONFIG_CP210X_SET_DTR_RTS,
   CONFIG_CP210X_COMPLETE
 };
 
-static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len) {
   // CP210x Interface includes 1 vendor interface + 2 bulk endpoints
   TU_VERIFY(itf_desc->bInterfaceSubClass == 0 && itf_desc->bInterfaceProtocol == 0 && itf_desc->bNumEndpoints == 2);
   TU_VERIFY(sizeof(tusb_desc_interface_t) + 2*sizeof(tusb_desc_endpoint_t) <= max_len);
@@ -1657,7 +1707,7 @@ static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, ui
   return open_ep_stream_pair(p_cdc, desc_ep);
 }
 
-static void cp210x_process_config(tuh_xfer_t* xfer) {
+static void cp210x_process_config(tuh_xfer_t * xfer) {
   uintptr_t const state   = xfer->user_data;
   uint8_t const   itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
   uint8_t const   idx     = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
@@ -1666,32 +1716,35 @@ static void cp210x_process_config(tuh_xfer_t* xfer) {
 
   switch (state) {
     case CONFIG_CP210X_IFC_ENABLE:
-      TU_ASSERT_COMPLETE(cp210x_ifc_enable(p_cdc, 1, cp210x_process_config, CONFIG_CP210X_SET_BAUDRATE));
+      p_cdc->user_control_cb = cp210x_process_config; // set once for whole process config
+      TU_ASSERT_COMPLETE(cp210x_ifc_enable(p_cdc, CP210X_UART_ENABLE, cp210x_process_config,
+                                           CONFIG_CP210X_SET_BAUDRATE_REQUEST));
       break;
 
-    case CONFIG_CP210X_SET_BAUDRATE: {
+    case CONFIG_CP210X_SET_BAUDRATE_REQUEST:
       #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
-        p_cdc->requested_line_coding.bit_rate = ((cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM).bit_rate;
-        TU_ASSERT_COMPLETE(cp210x_set_baudrate(p_cdc, cp210x_process_config, CONFIG_CP210X_SET_LINE_CTL));
+        p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM;
+        TU_ASSERT_COMPLETE(cp210x_set_baudrate_request(p_cdc, cp210x_internal_control_complete,
+                                                       CONFIG_CP210X_SET_LINE_CTL));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
       #endif
-    }
 
-    case CONFIG_CP210X_SET_LINE_CTL: {
-      #if defined(CFG_TUH_CDC_LINE_CODING_ON_ENUM) && 0 // skip for now
-      cdc_line_coding_t line_coding = CFG_TUH_CDC_LINE_CODING_ON_ENUM;
-      break;
+    case CONFIG_CP210X_SET_LINE_CTL:
+      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
+        TU_ASSERT_COMPLETE(cp210x_set_line_ctl(p_cdc, cp210x_internal_control_complete,
+                                               CONFIG_CP210X_SET_DTR_RTS));
+        break;
       #else
-      TU_ATTR_FALLTHROUGH;
+        TU_ATTR_FALLTHROUGH;
       #endif
-    }
 
     case CONFIG_CP210X_SET_DTR_RTS:
       #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-        TU_ASSERT_COMPLETE(cp210x_set_modem_ctrl(p_cdc, cp210x_process_config, CONFIG_CP210X_COMPLETE));
+        TU_ASSERT_COMPLETE(cp210x_set_mhs(p_cdc, cp210x_internal_control_complete,
+                                          CONFIG_CP210X_COMPLETE));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
diff --git a/src/class/cdc/serial/cp210x.h b/src/class/cdc/serial/cp210x.h
index 2c749f522a..e18da7d510 100644
--- a/src/class/cdc/serial/cp210x.h
+++ b/src/class/cdc/serial/cp210x.h
@@ -28,7 +28,8 @@
 // Protocol details can be found at AN571: CP210x Virtual COM Port Interface
 // https://www.silabs.com/documents/public/application-notes/AN571.pdf
 
-#define TU_CP210X_VID 0x10C4
+// parts are overtaken from vendors driver
+// https://www.silabs.com/documents/public/software/cp210x-3.1.0.tar.gz
 
 /* Config request codes */
 #define CP210X_IFC_ENABLE      0x00
@@ -59,4 +60,64 @@
 #define CP210X_SET_BAUDRATE    0x1E
 #define CP210X_VENDOR_SPECIFIC 0xFF // GPIO, Recipient must be Device
 
+/* SILABSER_IFC_ENABLE_REQUEST_CODE */
+#define CP210X_UART_ENABLE       0x0001
+#define CP210X_UART_DISABLE        0x0000
+
+/* SILABSER_SET_BAUDDIV_REQUEST_CODE */
+#define CP210X_BAUD_RATE_GEN_FREQ      0x384000
+
+/*SILABSER_SET_LINE_CTL_REQUEST_CODE */
+#define CP210X_BITS_DATA_MASK        0x0f00
+#define CP210X_BITS_DATA_5       0x0500
+#define CP210X_BITS_DATA_6       0x0600
+#define CP210X_BITS_DATA_7       0x0700
+#define CP210X_BITS_DATA_8       0x0800
+#define CP210X_BITS_DATA_9       0x0900
+
+#define CP210X_BITS_PARITY_MASK      0x00f0
+#define CP210X_BITS_PARITY_NONE      0x0000
+#define CP210X_BITS_PARITY_ODD       0x0010
+#define CP210X_BITS_PARITY_EVEN      0x0020
+#define CP210X_BITS_PARITY_MARK      0x0030
+#define CP210X_BITS_PARITY_SPACE     0x0040
+
+#define CP210X_BITS_STOP_MASK        0x000f
+#define CP210X_BITS_STOP_1       0x0000
+#define CP210X_BITS_STOP_1_5       0x0001
+#define CP210X_BITS_STOP_2       0x0002
+
+/* SILABSER_SET_BREAK_REQUEST_CODE */
+#define CP210X_BREAK_ON        0x0001
+#define CP210X_BREAK_OFF       0x0000
+
+/* SILABSER_SET_MHS_REQUEST_CODE */
+#define CP210X_MCR_DTR         0x0001
+#define CP210X_MCR_RTS         0x0002
+#define CP210X_MCR_ALL         0x0003
+#define CP210X_MSR_CTS         0x0010
+#define CP210X_MSR_DSR         0x0020
+#define CP210X_MSR_RING        0x0040
+#define CP210X_MSR_DCD         0x0080
+#define CP210X_MSR_ALL         0x00F0
+
+#define CP210X_CONTROL_WRITE_DTR     0x0100
+#define CP210X_CONTROL_WRITE_RTS     0x0200
+
+#define CP210X_LSR_BREAK       0x0001
+#define CP210X_LSR_FRAMING_ERROR     0x0002
+#define CP210X_LSR_HW_OVERRUN        0x0004
+#define CP210X_LSR_QUEUE_OVERRUN     0x0008
+#define CP210X_LSR_PARITY_ERROR      0x0010
+#define CP210X_LSR_ALL         0x001F
+
+// supported baudrates
+// reference: datasheets and AN205 "CP210x Baud Rate Support"
+#define CP210X_SUPPORTED_BAUDRATES_LIST { \
+  300, 600, \
+  1200, 1800, 2400, 4000, 4800, 7200, 9600, \
+  14400, 16000, 19200, 28800, 38400, 51200, 56000, 57600, 64000, 76800, \
+  115200, 128000, 153600, 230400, 250000, 256000, 460800, 500000, 576000, 921600, \
+  0 }
+
 #endif //TUSB_CP210X_H
diff --git a/src/tusb_option.h b/src/tusb_option.h
index ebf9a4d4d3..2813416853 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -482,7 +482,9 @@
 #ifndef CFG_TUH_CDC_CP210X_VID_PID_LIST
   // List of product IDs that can use the CP210X CDC driver. 0x10C4 is Silicon Labs' VID
   #define CFG_TUH_CDC_CP210X_VID_PID_LIST \
-    {0x10C4, 0xEA60}, {0x10C4, 0xEA70}
+  { 0x10C4, 0xEA60 }, /* Silicon Labs factory default */ \
+  { 0x10C4, 0xEA61 }, /* Silicon Labs factory default */ \
+  { 0x10C4, 0xEA70 }  /* Silicon Labs Dual Port factory default */
 #endif
 
 #ifndef CFG_TUH_CDC_CH34X

From aabee25e189d2a05cb52e5c54329ab1ec875f084 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 22 Feb 2024 11:45:38 +0100
Subject: [PATCH 15/37] added PL2303 support

---
 examples/host/cdc_msc_hid/src/tusb_config.h   |   1 +
 .../cdc_msc_hid_freertos/src/tusb_config.h    |   1 +
 src/class/cdc/cdc_host.c                      | 754 +++++++++++++++++-
 src/class/cdc/serial/pl2303.h                 | 172 ++++
 src/tusb_option.h                             |  18 +
 5 files changed, 942 insertions(+), 4 deletions(-)
 create mode 100644 src/class/cdc/serial/pl2303.h

diff --git a/examples/host/cdc_msc_hid/src/tusb_config.h b/examples/host/cdc_msc_hid/src/tusb_config.h
index e4d74077f9..fc956c6d3f 100644
--- a/examples/host/cdc_msc_hid/src/tusb_config.h
+++ b/examples/host/cdc_msc_hid/src/tusb_config.h
@@ -106,6 +106,7 @@
 #define CFG_TUH_CDC_FTDI            1 // FTDI Serial.  FTDI is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CP210X          1 // CP210x Serial. CP210X is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CH34X           1 // CH340 or CH341 Serial. CH34X is not part of CDC class, only to re-use CDC driver API
+#define CFG_TUH_CDC_PL2303          1 // PL2303 Serial. PL2303 is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_HID                 (3*CFG_TUH_DEVICE_MAX) // typical keyboard + mouse device can have 3-4 HID interfaces
 #define CFG_TUH_MSC                 1
 #define CFG_TUH_VENDOR              0
diff --git a/examples/host/cdc_msc_hid_freertos/src/tusb_config.h b/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
index 9dc89dc559..dd732c700e 100644
--- a/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
+++ b/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
@@ -111,6 +111,7 @@
 #define CFG_TUH_CDC_FTDI            1 // FTDI Serial.  FTDI is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CP210X          1 // CP210x Serial. CP210X is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CH34X           1 // CH340 or CH341 Serial. CH34X is not part of CDC class, only to re-use CDC driver API
+#define CFG_TUH_CDC_PL2303          1 // PL2303 Serial. PL2303 is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_HID                 (3*CFG_TUH_DEVICE_MAX) // typical keyboard + mouse device can have 3-4 HID interfaces
 #define CFG_TUH_MSC                 1
 #define CFG_TUH_VENDOR              0
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 86c010fa73..429d0a113d 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -38,6 +38,7 @@
 #include "serial/ftdi_sio.h"
 #include "serial/cp210x.h"
 #include "serial/ch34x.h"
+#include "serial/pl2303.h"
 
 // Level where CFG_TUSB_DEBUG must be at least for this driver is logged
 #ifndef CFG_TUH_CDC_LOG_LEVEL
@@ -91,6 +92,10 @@ typedef struct {
     ftdi_private_t ftdi;
   #endif
 
+  #if CFG_TUH_CDC_PL2303
+    pl2303_private_t pl2303;
+  #endif
+
   struct {
     tu_edpt_stream_t tx;
     tu_edpt_stream_t rx;
@@ -105,7 +110,7 @@ typedef struct {
 
 CFG_TUH_MEM_SECTION
 static cdch_interface_t cdch_data[CFG_TUH_CDC];
-#if CFG_TUH_CDC_FTDI
+#if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_PL2303
   static tusb_desc_device_t desc_dev[CFG_TUH_CDC][CFG_TUH_ENUMERATION_BUFSIZE];
 #endif
 
@@ -164,6 +169,22 @@ static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complet
 static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
+//------------- PL2303 prototypes -------------//
+#if CFG_TUH_CDC_PL2303
+static uint16_t const pl2303_vid_pid_list[][2] = {CFG_TUH_CDC_PL2303_VID_PID_LIST};
+static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {PL2303_TYPE_DATA};
+
+CFG_TUH_MEM_SECTION CFG_TUH_MEM_ALIGN
+
+static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static void pl2303_process_config(tuh_xfer_t * xfer);
+
+static bool pl2303_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool pl2303_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool pl2303_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool pl2303_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+#endif
+
 //------------- Common -------------//
 enum {
   SERIAL_DRIVER_ACM = 0,
@@ -180,6 +201,10 @@ enum {
   SERIAL_DRIVER_CH34X,
 #endif
 
+#if CFG_TUH_CDC_PL2303
+  SERIAL_DRIVER_PL2303,
+#endif
+
   SERIAL_DRIVER_COUNT
 };
 
@@ -260,6 +285,22 @@ static const cdch_serial_driver_t serial_drivers[] = {
     #endif
   },
   #endif
+
+  #if CFG_TUH_CDC_PL2303
+  {
+      .vid_pid_list           = pl2303_vid_pid_list,
+      .vid_pid_count          = TU_ARRAY_SIZE(pl2303_vid_pid_list),
+      .open                   = pl2303_open,
+      .process_set_config     = pl2303_process_config,
+      .set_control_line_state = pl2303_set_modem_ctrl,
+      .set_baudrate           = pl2303_set_baudrate,
+      .set_data_format        = pl2303_set_data_format,
+      .set_line_coding        = pl2303_set_line_coding,
+    #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
+      .name                   = (uint8_t const *) "PL2303"
+    #endif
+  }
+  #endif
 };
 
 TU_VERIFY_STATIC(TU_ARRAY_SIZE(serial_drivers) == SERIAL_DRIVER_COUNT, "Serial driver count mismatch");
@@ -1863,7 +1904,7 @@ static bool ch34x_modem_ctrl_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t com
 
 // internal control complete to update state such as line state, encoding
 static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
-  // CH34x only has 1 interface and wIndex used as payload and not for bInterfaceNumber
+  // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
   uint8_t const itf_num = 0;
   uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
   cdch_interface_t* p_cdc = get_itf(idx);
@@ -1921,7 +1962,8 @@ static bool ch34x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_
 }
 
 static void ch34x_set_line_coding_stage1_complete(tuh_xfer_t * xfer) {
-  uint8_t const itf_num = 0; // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
+  // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
+  uint8_t const itf_num = 0;
   set_line_coding_stage1_complete(xfer, itf_num,
                                   ch34x_write_reg_data_format,      // control request function to set data format
                                   ch34x_internal_control_complete); // control complete function to be called after request
@@ -1981,7 +2023,7 @@ static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uin
 }
 
 static void ch34x_process_config(tuh_xfer_t* xfer) {
-  // CH34x only has 1 interface and wIndex used as payload and not for bInterfaceNumber
+  // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
   uintptr_t const state = xfer->user_data;
   uint8_t const itf_num = 0;
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
@@ -2142,4 +2184,708 @@ static uint8_t ch34x_get_lcr(cdch_interface_t * p_cdc) {
 
 #endif // CFG_TUH_CDC_CH34X
 
+//--------------------------------------------------------------------+
+// PL2303
+//--------------------------------------------------------------------+
+#if CFG_TUH_CDC_PL2303
+
+static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t const idx, uint8_t step,
+                                 tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool pl2303_encode_baud_rate(cdch_interface_t * p_cdc, uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE]);
+
+//------------- Control Request -------------//
+
+static bool pl2303_set_request(cdch_interface_t * p_cdc, uint8_t request, uint8_t requesttype,
+                               uint16_t value, uint16_t index, uint8_t * buffer, uint16_t length,
+                               tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  tusb_control_request_t const request_setup = {
+    .bmRequestType = requesttype,
+    .bRequest      = request,
+    .wValue        = tu_htole16 (value),
+    .wIndex        = tu_htole16 (index),
+    .wLength       = tu_htole16 (length)
+  };
+
+  // use usbh enum buf since application variable does not live long enough
+  uint8_t * enum_buf = NULL;
+
+  if (buffer && length > 0) {
+    enum_buf = usbh_get_enum_buf();
+    if (request_setup.bmRequestType_bit.direction == TUSB_DIR_OUT) {
+      tu_memcpy_s(enum_buf, CFG_TUH_ENUMERATION_BUFSIZE, buffer, length);
+    }
+  }
+
+  tuh_xfer_t xfer = {
+    .daddr       = p_cdc->daddr,
+    .ep_addr     = 0,
+    .setup       = &request_setup,
+    .buffer      = enum_buf,
+    .complete_cb = complete_cb,
+    .user_data   = user_data
+  };
+
+  return tuh_control_xfer(&xfer);
+}
+
+static bool pl2303_vendor_read(cdch_interface_t * p_cdc, uint16_t value, uint8_t * buf,
+                               tuh_xfer_cb_t complete_cb, uintptr_t user_data)
+{
+  uint8_t request = p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN] ?
+                    PL2303_VENDOR_READ_NREQUEST : PL2303_VENDOR_READ_REQUEST;
+
+  return pl2303_set_request(p_cdc, request, PL2303_VENDOR_READ_REQUEST_TYPE, value, 0, buf, 1, complete_cb, user_data);
+}
+
+static bool pl2303_vendor_write(cdch_interface_t * p_cdc, uint16_t value, uint16_t index,
+                                tuh_xfer_cb_t complete_cb, uintptr_t user_data)
+{
+  uint8_t request = p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN] ?
+                    PL2303_VENDOR_WRITE_NREQUEST : PL2303_VENDOR_WRITE_REQUEST;
+
+  return pl2303_set_request(p_cdc, request, PL2303_VENDOR_WRITE_REQUEST_TYPE, value, index, NULL, 0, complete_cb, user_data);
+}
+
+static inline bool pl2303_supports_hx_status(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data)
+{
+  uint8_t buf;
+
+  return pl2303_set_request(p_cdc, PL2303_VENDOR_READ_REQUEST, PL2303_VENDOR_READ_REQUEST_TYPE, PL2303_READ_TYPE_HX_STATUS, 0,
+                            &buf, 1, complete_cb, user_data);
+}
+
+static inline bool pl2303_set_control_lines(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data)
+{
+  return pl2303_set_request(p_cdc, PL2303_SET_CONTROL_REQUEST, PL2303_SET_CONTROL_REQUEST_TYPE,
+                            p_cdc->requested_line_state, 0, NULL, 0, complete_cb, user_data);
+}
+
+//static bool pl2303_get_line_request(cdch_interface_t * p_cdc, uint8_t buf[PL2303_LINE_CODING_BUFSIZE])
+//{
+//  return pl2303_set_request(p_cdc, PL2303_GET_LINE_REQUEST, PL2303_GET_LINE_REQUEST_TYPE, 0, 0, buf, PL2303_LINE_CODING_BUFSIZE);
+//}
+
+static bool pl2303_set_line_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // the caller has to precheck, that the new line coding different than the current, else false returned
+  uint8_t buf[PL2303_LINE_CODING_BUFSIZE];
+  /*
+   * Some PL2303 are known to lose bytes if you change serial settings
+   * even to the same values as before. Thus we actually need to filter
+   * in this specific case.
+   */
+  // TODO really necessary to check? what to do in this case when no transfer will happen?
+  // callback is not called...
+  TU_VERIFY(memcmp(&p_cdc->requested_line_coding, &p_cdc->line_coding, sizeof(cdc_line_coding_t) ) != 0);
+
+  /* For reference buf[6] data bits value */
+  TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 8, 0);
+  buf[6] = p_cdc->requested_line_coding.data_bits;
+
+  /* For reference buf[0]:buf[3] baud rate value */
+  TU_VERIFY(pl2303_encode_baud_rate(p_cdc, &buf[0]));
+
+  /* For reference buf[4]=0 is 1 stop bits */
+  /* For reference buf[4]=1 is 1.5 stop bits */
+  /* For reference buf[4]=2 is 2 stop bits */
+  buf[4] = p_cdc->requested_line_coding.stop_bits; // PL2303 has the same coding
+
+  /* For reference buf[5]=0 is none parity */
+  /* For reference buf[5]=1 is odd parity */
+  /* For reference buf[5]=2 is even parity */
+  /* For reference buf[5]=3 is mark parity */
+  /* For reference buf[5]=4 is space parity */
+  buf[5] = p_cdc->requested_line_coding.parity; // PL2303 has the same coding
+
+  return pl2303_set_request(p_cdc, PL2303_SET_LINE_REQUEST, PL2303_SET_LINE_REQUEST_TYPE, 0, 0,
+                            buf, PL2303_LINE_CODING_BUFSIZE, complete_cb, user_data);
+}
+
+//static bool pl2303_set_break(cdch_interface_t * p_cdc, bool enable)
+//{
+//  uint16_t state = enable ? PL2303_BREAK_ON : PL2303_BREAK_OFF;
+//  return pl2303_set_request(p_cdc, PL2303_BREAK_REQUEST, PL2303_BREAK_REQUEST_TYPE, state, 0, NULL, 0);
+//}
+
+static inline int pl2303_clear_halt(cdch_interface_t * p_cdc, uint8_t endp, tuh_xfer_cb_t complete_cb, uintptr_t user_data)
+{
+  /* we don't care if it wasn't halted first. in fact some devices
+   * (like some ibmcam model 1 units) seem to expect hosts to make
+   * this request for iso endpoints, which can't halt!
+   */
+  return pl2303_set_request(p_cdc, TUSB_REQ_CLEAR_FEATURE, PL2303_CLEAR_HALT_REQUEST_TYPE, TUSB_REQ_FEATURE_EDPT_HALT, endp,
+                            NULL, 0, complete_cb, user_data);
+}
+
+//------------- Driver API -------------//
+
+// internal control complete to update state such as line state, encoding
+static void pl2303_internal_control_complete(tuh_xfer_t * xfer) {
+  // PL2303 has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
+  uint8_t const itf_num = 0;
+  uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+  bool const success = (xfer->result == XFER_RESULT_SUCCESS);
+  TU_LOG_P_CDC("control complete success = %u", success);
+
+  if (success) {
+    if (xfer->setup->bRequest == PL2303_SET_LINE_REQUEST &&
+         xfer->setup->bmRequestType == PL2303_SET_LINE_REQUEST_TYPE) {
+      p_cdc->line_coding = p_cdc->requested_line_coding;
+    }
+    if (xfer->setup->bRequest == PL2303_SET_CONTROL_REQUEST &&
+         xfer->setup->bmRequestType == PL2303_SET_CONTROL_REQUEST_TYPE) {
+      p_cdc->line_state = p_cdc->requested_line_state;
+    }
+  }
+
+  xfer->complete_cb = p_cdc->user_control_cb;
+  if (xfer->complete_cb) {
+    xfer->complete_cb(xfer);
+  }
+}
+
+static bool pl2303_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->user_control_cb = complete_cb;
+  TU_ASSERT(pl2303_set_line_request(p_cdc, complete_cb ? pl2303_internal_control_complete : NULL, user_data));
+
+  return true;
+}
+
+static bool pl2303_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->requested_line_coding.bit_rate = p_cdc->line_coding.bit_rate;
+  p_cdc->user_control_cb = complete_cb;
+  TU_ASSERT(pl2303_set_line_request(p_cdc, complete_cb ? pl2303_internal_control_complete : NULL, user_data));
+
+  return true;
+}
+
+static bool pl2303_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  p_cdc->requested_line_coding.stop_bits = p_cdc->line_coding.stop_bits;
+  p_cdc->requested_line_coding.parity    = p_cdc->line_coding.parity;
+  p_cdc->requested_line_coding.data_bits = p_cdc->line_coding.data_bits;
+  p_cdc->user_control_cb = complete_cb;
+  TU_ASSERT(pl2303_set_line_request(p_cdc, complete_cb ? pl2303_internal_control_complete : NULL, user_data));
+
+  return true;
+}
+
+static bool pl2303_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // PL2303 has the same bit coding
+  p_cdc->user_control_cb = complete_cb;
+  TU_ASSERT(pl2303_set_control_lines(p_cdc, complete_cb ? pl2303_internal_control_complete : NULL, user_data));
+
+  return true;
+}
+
+//------------- Enumeration -------------//
+
+enum {
+  CONFIG_PL2303_GET_DESC = 0,
+  CONFIG_PL2303_DETECT_TYPE,
+  CONFIG_PL2303_READ1,
+  CONFIG_PL2303_WRITE1,
+  CONFIG_PL2303_READ2,
+  CONFIG_PL2303_READ3,
+  CONFIG_PL2303_READ4,
+  CONFIG_PL2303_WRITE2,
+  CONFIG_PL2303_READ5,
+  CONFIG_PL2303_READ6,
+  CONFIG_PL2303_WRITE3,
+  CONFIG_PL2303_WRITE4,
+  CONFIG_PL2303_WRITE5,
+  CONFIG_PL2303_RESET_ENDP1,
+  CONFIG_PL2303_RESET_ENDP2,
+  CONFIG_PL2303_LINE_CODING,
+  CONFIG_PL2303_MODEM_CONTROL,
+  CONFIG_PL2303_FLOW_CTRL_READ,
+  CONFIG_PL2303_FLOW_CTRL_WRITE,
+  CONFIG_PL2303_COMPLETE
+};
+
+static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len) {
+  // PL2303 Interface includes 1 vendor interface + 1 interrupt endpoints + 2 bulk
+  TU_VERIFY(itf_desc->bNumEndpoints == 3);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
+
+  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
+
+  p_cdc->serial_drid = SERIAL_DRIVER_PL2303;
+  p_cdc->pl2303.serial_private.quirks = 0;
+  p_cdc->pl2303.supports_hx_status = false;
+
+  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const * ) tu_desc_next(itf_desc);
+
+  // Interrupt endpoint: not used for now
+  TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(desc_ep) &&
+            TUSB_XFER_INTERRUPT == desc_ep->bmAttributes.xfer);
+  TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
+  p_cdc->ep_notif = desc_ep->bEndpointAddress;
+  desc_ep += 1;
+
+  // data endpoints expected to be in pairs
+  TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep));
+
+  return true;
+}
+
+static void pl2303_process_config(tuh_xfer_t * xfer) {
+  // PL2303 has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
+  uint8_t const itf_num = 0;
+  uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  // state CONFIG_PL2303_READ1 may have no success due to expected stall by pl2303_supports_hx_status()
+  TU_ASSERT_COMPLETE(p_cdc && (xfer->result == XFER_RESULT_SUCCESS || xfer->user_data == CONFIG_PL2303_READ1));
+  uint8_t buf;
+  int8_t type;
+
+  switch (xfer->user_data) {
+
+    // from here sequence overtaken from Linux Kernel function pl2303_startup()
+    case CONFIG_PL2303_GET_DESC:
+      p_cdc->user_control_cb = pl2303_process_config; // set once for whole process config
+      // get device descriptor
+      TU_ASSERT_COMPLETE(tuh_descriptor_get_device(xfer->daddr, desc_dev[idx], sizeof(tusb_desc_device_t),
+                                                   pl2303_process_config, CONFIG_PL2303_DETECT_TYPE));
+      break;
+
+    case CONFIG_PL2303_DETECT_TYPE:
+      // get type and quirks (step 1)
+      type = pl2303_detect_type (p_cdc, idx, 1, pl2303_process_config, CONFIG_PL2303_READ1); // step 1
+      TU_ASSERT_COMPLETE(type!=PL2303_DETECT_TYPE_FAILED);
+      if (type == PL2303_SUPPORTS_HX_STATUS_TRIGGERED) {
+        break;
+      } // else: no transfer triggered and continue with CONFIG_PL2303_READ1
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ1:
+      // get supports_hx_status, type and quirks (step 2), do special read
+      p_cdc->pl2303.supports_hx_status = ( // will not be true, if coming directly from previous case
+                                           xfer->user_data == CONFIG_PL2303_READ1 && xfer->result == XFER_RESULT_SUCCESS );
+      type = pl2303_detect_type (p_cdc, idx, 2, NULL, 0); // step 2 now with supports_hx_status
+      TU_ASSERT_COMPLETE(type!=PL2303_DETECT_TYPE_FAILED);
+      p_cdc->pl2303.serial_private.type = &pl2303_type_data[type];
+      p_cdc->pl2303.serial_private.quirks |= p_cdc->pl2303.serial_private.type->quirks;
+      #if CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL && 0 // can be activated if necessary
+        TU_LOG(CFG_TUH_CDC_LOG_LEVEL, "PL2303 bDeviceClass = 0x%02x bMaxPacketSize0 = %u bcdUSB = 0x%04x bcdDevice = 0x%04x",
+               desc_dev[idx]->bDeviceClass, desc_dev[idx]->bMaxPacketSize0, desc_dev[idx]->bcdUSB, desc_dev[idx]->bcdDevice );
+        uint16_t vid, pid;
+        TU_ASSERT_COMPLETE(tuh_vid_pid_get(p_cdc->daddr, &vid, &pid));
+        TU_LOG(CFG_TUH_CDC_LOG_LEVEL, "       vid = 0x%04x pid = 0x%04x supports_hx_status = %u type = %s quirks = %u",
+               vid, pid, p_cdc->pl2303.supports_hx_status,
+               p_cdc->pl2303.serial_private.type->name, p_cdc->pl2303.serial_private.quirks);
+      #endif
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0x8484, &buf, pl2303_process_config, CONFIG_PL2303_WRITE1));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE1:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 0x0404, 0, pl2303_process_config, CONFIG_PL2303_READ2));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ2:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0x8484, &buf, pl2303_process_config, CONFIG_PL2303_READ3));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ3:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0x8383, &buf, pl2303_process_config, CONFIG_PL2303_READ4));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ4:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0x8484, &buf, pl2303_process_config, CONFIG_PL2303_WRITE2));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE2:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 0x0404, 1, pl2303_process_config, CONFIG_PL2303_READ5));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ5:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0x8484, &buf, pl2303_process_config, CONFIG_PL2303_READ6));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_READ6:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0x8383, &buf, pl2303_process_config, CONFIG_PL2303_WRITE3));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE3:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 0, 1, pl2303_process_config, CONFIG_PL2303_WRITE4));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE4:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 1, 0, pl2303_process_config, CONFIG_PL2303_WRITE5));
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    case CONFIG_PL2303_WRITE5:
+      // purpose unknown, overtaken from Linux Kernel driver
+      if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {
+        if (p_cdc->pl2303.serial_private.quirks & PL2303_QUIRK_LEGACY) {
+          TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 2, 0x24, pl2303_process_config, CONFIG_PL2303_RESET_ENDP1));
+        } else {
+          TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 2, 0x44, pl2303_process_config, CONFIG_PL2303_RESET_ENDP1));
+        }
+        break;
+      } // else: continue with next step
+      TU_ATTR_FALLTHROUGH;
+
+    // from here sequence overtaken from Linux Kernel function pl2303_open()
+    case CONFIG_PL2303_RESET_ENDP1:
+      // step 1
+      if (p_cdc->pl2303.serial_private.quirks & PL2303_QUIRK_LEGACY) {
+        TU_ASSERT_COMPLETE(pl2303_clear_halt(p_cdc, PL2303_OUT_EP, pl2303_process_config, CONFIG_PL2303_RESET_ENDP2));
+      } else {
+        /* reset upstream data pipes */
+        if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
+          TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, PL2303_HXN_RESET_REG, // skip CONFIG_PL2303_RESET_ENDP2, no 2nd step
+                                        PL2303_HXN_RESET_UPSTREAM_PIPE | PL2303_HXN_RESET_DOWNSTREAM_PIPE,
+                                        pl2303_process_config, CONFIG_PL2303_LINE_CODING));
+        } else {
+          pl2303_vendor_write(p_cdc, 8, 0, pl2303_process_config, CONFIG_PL2303_RESET_ENDP2);
+        }
+      }
+      break;
+
+    case CONFIG_PL2303_RESET_ENDP2:
+      // step 2
+      if (p_cdc->pl2303.serial_private.quirks & PL2303_QUIRK_LEGACY) {
+        TU_ASSERT_COMPLETE(pl2303_clear_halt(p_cdc, PL2303_IN_EP, pl2303_process_config, CONFIG_PL2303_LINE_CODING));
+      } else {
+        /* reset upstream data pipes */
+        if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
+          // here nothing to do, only structure of previous step overtaken for better reading and comparison
+        } else {
+          TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 9, 0, pl2303_process_config, CONFIG_PL2303_LINE_CODING));
+        }
+      }
+      break;
+
+    // from here sequence overtaken from Linux Kernel function pl2303_set_termios()
+    // unnecessary pl2303_get_line_request() is skipped due to a stall
+    case CONFIG_PL2303_LINE_CODING:
+      #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM
+        p_cdc->requested_line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM;
+        TU_ASSERT_COMPLETE( pl2303_set_line_request(p_cdc, pl2303_internal_control_complete, CONFIG_PL2303_MODEM_CONTROL));
+        break;
+      #else
+        TU_ATTR_FALLTHROUGH;
+      #endif
+
+    case CONFIG_PL2303_MODEM_CONTROL:
+      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        TU_ASSERT_COMPLETE(pl2303_set_control_lines(p_cdc, pl2303_internal_control_complete, CONFIG_PL2303_FLOW_CTRL_READ));
+        break;
+      #else
+        TU_ATTR_FALLTHROUGH;
+      #endif
+
+    case CONFIG_PL2303_FLOW_CTRL_READ:
+      // read flow control register for modify & write back in next step
+      if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, PL2303_HXN_FLOWCTRL_REG, &buf, pl2303_process_config,
+                                              CONFIG_PL2303_FLOW_CTRL_WRITE));
+      } else {
+        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0, &buf, pl2303_process_config, CONFIG_PL2303_FLOW_CTRL_WRITE));
+      }
+      break;
+
+    case CONFIG_PL2303_FLOW_CTRL_WRITE:
+      // no flow control
+      buf = xfer->buffer[0];
+      if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
+        buf &= (uint8_t) ~PL2303_HXN_FLOWCTRL_MASK;
+        buf |= PL2303_HXN_FLOWCTRL_NONE;
+        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, PL2303_HXN_FLOWCTRL_REG, buf, pl2303_process_config,
+                                               CONFIG_PL2303_COMPLETE));
+      } else {
+        buf &= (uint8_t) ~PL2303_FLOWCTRL_MASK;
+        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 0, buf, pl2303_process_config, CONFIG_PL2303_COMPLETE));
+      }
+      break;
+
+    case CONFIG_PL2303_COMPLETE:
+      set_config_complete(idx, 0, true);
+      break;
+
+    default:
+      set_config_complete(idx, 0, false);
+      break;
+  }
+}
+
+//------------- Helper -------------//
+
+static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t const idx, uint8_t step,
+                                 tuh_xfer_cb_t complete_cb, uintptr_t user_data )
+{
+  /*
+   * Legacy PL2303H, variants 0 and 1 (difference unknown).
+   */
+  if (desc_dev[idx]->bDeviceClass == 0x02) {
+    return TYPE_H;    /* variant 0 */
+  }
+
+  if (desc_dev[idx]->bMaxPacketSize0 != 0x40) {
+    if (desc_dev[idx]->bDeviceClass == 0x00 || desc_dev[idx]->bDeviceClass == 0xff) {
+      return TYPE_H;  /* variant 1 */
+    }
+    return TYPE_H;    /* variant 0 */
+  }
+
+  switch (desc_dev[idx]->bcdUSB) {
+    case 0x101:
+      /* USB 1.0.1? Let's assume they meant 1.1... */
+      TU_ATTR_FALLTHROUGH;
+    case 0x110:
+      switch (desc_dev[idx]->bcdDevice) {
+        case 0x300:
+          return TYPE_HX;
+        case 0x400:
+          return TYPE_HXD;
+        default:
+          return TYPE_HX;
+      }
+      break;
+    case 0x200:
+      switch (desc_dev[idx]->bcdDevice) {
+        case 0x100: /* GC */
+        case 0x105:
+          return TYPE_HXN;
+        case 0x300: /* GT / TA */
+          if (step == 1) {
+            // step 1 trigger pl2303_supports_hx_status() request
+            TU_ASSERT(pl2303_supports_hx_status (p_cdc, complete_cb, user_data), PL2303_DETECT_TYPE_FAILED);
+            return PL2303_SUPPORTS_HX_STATUS_TRIGGERED;
+          } else {
+            // step 2 use supports_hx_status
+            if (p_cdc->pl2303.supports_hx_status) {
+              return TYPE_TA;
+            }
+          }
+          TU_ATTR_FALLTHROUGH;
+        case 0x305:
+        case 0x400: /* GL */
+        case 0x405:
+          return TYPE_HXN;
+        case 0x500: /* GE / TB */
+          if (step == 1) {
+            // step 1 trigger pl2303_supports_hx_status() request
+            TU_ASSERT(pl2303_supports_hx_status (p_cdc, complete_cb, user_data), PL2303_DETECT_TYPE_FAILED);
+            return PL2303_SUPPORTS_HX_STATUS_TRIGGERED;
+          } else {
+            // step 2 use supports_hx_status
+            if (p_cdc->pl2303.supports_hx_status) {
+              return TYPE_TB;
+            }
+          }
+          TU_ATTR_FALLTHROUGH;
+        case 0x505:
+        case 0x600: /* GS */
+        case 0x605:
+        case 0x700: /* GR */
+        case 0x705:
+          return TYPE_HXN;
+        default:
+          break;
+      }
+      break;
+    default: break;
+  }
+
+  TU_LOG_P_CDC("unknown device type bcdUSB = 0x%04x", desc_dev[idx]->bcdUSB);
+
+  return PL2303_DETECT_TYPE_FAILED;
+}
+
+/*
+ * Returns the nearest supported baud rate that can be set directly without
+ * using divisors.
+ */
+static uint32_t pl2303_get_supported_baud_rate(uint32_t baud)
+{
+  static const uint32_t baud_sup[] = {
+    75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
+    14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
+    614400, 921600, 1228800, 2457600, 3000000, 6000000
+  };
+
+  uint8_t i;
+  for (i = 0; i < TU_ARRAY_SIZE(baud_sup); ++i) {
+    if (baud_sup[i] > baud) {
+      break;
+    }
+  }
+
+  if (i == TU_ARRAY_SIZE(baud_sup)) {
+    baud = baud_sup[i - 1];
+  } else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1])) {
+    baud = baud_sup[i - 1];
+  } else {
+    baud = baud_sup[i];
+  }
+
+  return baud;
+}
+
+/*
+ * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
+ *       use 9600 baud.
+ */
+static uint32_t pl2303_encode_baud_rate_direct(uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE], uint32_t baud)
+{
+  uint32_t baud_le = tu_htole32(baud);
+  buf[0] = (uint8_t) ( baud_le        & 0xff);
+  buf[1] = (uint8_t) ((baud_le >>  8) & 0xff);
+  buf[2] = (uint8_t) ((baud_le >> 16) & 0xff);
+  buf[3] = (uint8_t) ((baud_le >> 24) & 0xff);
+
+  return baud;
+}
+
+static uint32_t pl2303_encode_baud_rate_divisor(uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE], uint32_t baud)
+{
+  uint32_t baseline, mantissa, exponent;
+
+  /*
+   * Apparently the formula is:
+   *   baudrate = 12M * 32 / (mantissa * 4^exponent)
+   * where
+   *   mantissa = buf[8:0]
+   *   exponent = buf[11:9]
+   */
+  baseline = 12000000 * 32;
+  mantissa = baseline / baud;
+  if (mantissa == 0)
+    mantissa = 1; /* Avoid dividing by zero if baud > 32 * 12M. */
+  exponent = 0;
+  while (mantissa >= 512) {
+    if (exponent < 7) {
+      mantissa >>= 2; /* divide by 4 */
+      exponent++;
+    } else {
+      /* Exponent is maxed. Trim mantissa and leave. */
+      mantissa = 511;
+      break;
+    }
+  }
+
+  buf[3] = 0x80;
+  buf[2] = 0;
+  buf[1] = (uint8_t) ((exponent << 1 |  mantissa >> 8) & 0xff);
+  buf[0] = (uint8_t) (mantissa & 0xff);
+
+  /* Calculate and return the exact baud rate. */
+  baud = (baseline / mantissa) >> (exponent << 1);
+
+  return baud;
+}
+
+static uint32_t pl2303_encode_baud_rate_divisor_alt(uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE], uint32_t baud)
+{
+  uint32_t baseline, mantissa, exponent;
+
+  /*
+   * Apparently, for the TA version the formula is:
+   *   baudrate = 12M * 32 / (mantissa * 2^exponent)
+   * where
+   *   mantissa = buf[10:0]
+   *   exponent = buf[15:13 16]
+   */
+  baseline = 12000000 * 32;
+  mantissa = baseline / baud;
+  if (mantissa == 0) {
+    mantissa = 1;   /* Avoid dividing by zero if baud > 32 * 12M. */
+  }
+  exponent = 0;
+  while (mantissa >= 2048) {
+    if (exponent < 15) {
+      mantissa >>= 1; /* divide by 2 */
+      exponent++;
+    } else {
+      /* Exponent is maxed. Trim mantissa and leave. */
+      mantissa = 2047;
+      break;
+    }
+  }
+
+  buf[3] = 0x80;
+  buf[2] = (uint8_t) (exponent & 0x01);
+  buf[1] = (uint8_t) (((exponent &  (uint32_t) ~0x01) << 4 | mantissa >> 8 ) & 0xff);
+  buf[0] = (uint8_t) (mantissa & 0xff);
+
+  /* Calculate and return the exact baud rate. */
+  baud = (baseline / mantissa) >> exponent;
+
+  return baud;
+}
+
+static bool pl2303_encode_baud_rate(cdch_interface_t * p_cdc, uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE])
+{
+  uint32_t baud = p_cdc->requested_line_coding.bit_rate;
+  uint32_t baud_sup;
+
+  TU_VERIFY(baud && baud <= p_cdc->pl2303.serial_private.type->max_baud_rate);
+  /*
+   * Use direct method for supported baud rates, otherwise use divisors.
+   * Newer chip types do not support divisor encoding.
+   */
+  if (p_cdc->pl2303.serial_private.type->no_divisors) {
+    baud_sup = baud;
+  } else {
+    baud_sup = pl2303_get_supported_baud_rate(baud);
+  }
+
+  if (baud == baud_sup) {
+    baud = pl2303_encode_baud_rate_direct(buf, baud);
+  } else if (p_cdc->pl2303.serial_private.type->alt_divisors) {
+    baud = pl2303_encode_baud_rate_divisor_alt(buf, baud);
+  } else {
+    baud = pl2303_encode_baud_rate_divisor(buf, baud);
+  }
+  TU_LOG_P_CDC("real baudrate = %lu", baud);
+
+  return true;
+}
+
+#endif // CFG_TUH_CDC_PL2303
+
 #endif
diff --git a/src/class/cdc/serial/pl2303.h b/src/class/cdc/serial/pl2303.h
new file mode 100644
index 0000000000..bf264191bf
--- /dev/null
+++ b/src/class/cdc/serial/pl2303.h
@@ -0,0 +1,172 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Heiko Kuester
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+
+#ifndef _PL2303_H_
+#define _PL2303_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+// There is no official documentation for the PL2303 chips.
+// Reference can be found
+// - https://github.com/torvalds/linux/blob/master/drivers/usb/serial/pl2303.h and
+//   https://github.com/torvalds/linux/blob/master/drivers/usb/serial/pl2303.c
+// - https://github.com/freebsd/freebsd-src/blob/main/sys/dev/usb/serial/uplcom.c
+
+/* quirks */
+#define PL2303_QUIRK_UART_STATE_IDX0 1
+#define PL2303_QUIRK_LEGACY 2
+#define PL2303_QUIRK_ENDPOINT_HACK 4
+
+/* requests and bits */
+#define PL2303_SET_LINE_REQUEST_TYPE 0x21     // class request host to device interface
+#define PL2303_SET_LINE_REQUEST 0x20          // dec 32
+
+#define PL2303_SET_CONTROL_REQUEST_TYPE 0x21  // class request host to device interface
+#define PL2303_SET_CONTROL_REQUEST 0x22       // dec 34
+#define PL2303_CONTROL_DTR 0x01               // dec 1
+#define PL2303_CONTROL_RTS 0x02               // dec 2
+
+#define PL2303_BREAK_REQUEST_TYPE 0x21        // class request host to device interface
+#define PL2303_BREAK_REQUEST 0x23             // dec 35
+#define PL2303_BREAK_ON 0xffff
+#define PL2303_BREAK_OFF 0x0000
+
+#define PL2303_GET_LINE_REQUEST_TYPE 0xa1     // class request device to host interface
+#define PL2303_GET_LINE_REQUEST 0x21          // dec 33
+
+#define PL2303_VENDOR_WRITE_REQUEST_TYPE 0x40 // vendor request host to device interface
+#define PL2303_VENDOR_WRITE_REQUEST 0x01      // dec 1
+#define PL2303_VENDOR_WRITE_NREQUEST 0x80     // dec 128
+
+#define PL2303_VENDOR_READ_REQUEST_TYPE 0xc0  // vendor request device to host interface
+#define PL2303_VENDOR_READ_REQUEST 0x01       // dec 1
+#define PL2303_VENDOR_READ_NREQUEST 0x81      // dec 129
+
+#define PL2303_UART_STATE_INDEX 8
+#define PL2303_UART_STATE_MSR_MASK 0x8b
+#define PL2303_UART_STATE_TRANSIENT_MASK 0x74
+#define PL2303_UART_DCD 0x01
+#define PL2303_UART_DSR 0x02
+#define PL2303_UART_BREAK_ERROR 0x04
+#define PL2303_UART_RING 0x08
+#define PL2303_UART_FRAME_ERROR 0x10
+#define PL2303_UART_PARITY_ERROR 0x20
+#define PL2303_UART_OVERRUN_ERROR 0x40
+#define PL2303_UART_CTS 0x80
+
+#define PL2303_FLOWCTRL_MASK 0xf0
+
+#define PL2303_CLEAR_HALT_REQUEST_TYPE 0x02   // standard request host to device endpoint
+
+/* registers via vendor read/write requests */
+#define PL2303_READ_TYPE_HX_STATUS 0x8080
+
+#define PL2303_HXN_RESET_REG 0x07
+#define PL2303_HXN_RESET_UPSTREAM_PIPE 0x02
+#define PL2303_HXN_RESET_DOWNSTREAM_PIPE 0x01
+
+#define PL2303_HXN_FLOWCTRL_REG 0x0a
+#define PL2303_HXN_FLOWCTRL_MASK 0x1c
+#define PL2303_HXN_FLOWCTRL_NONE 0x1c
+#define PL2303_HXN_FLOWCTRL_RTS_CTS 0x18
+#define PL2303_HXN_FLOWCTRL_XON_XOFF 0x0c
+
+/* type data */
+enum pl2303_type {
+  TYPE_H,
+  TYPE_HX,
+  TYPE_TA,
+  TYPE_TB,
+  TYPE_HXD,
+  TYPE_HXN,
+  TYPE_COUNT
+};
+
+struct pl2303_type_data {
+  uint8_t const *name;
+  uint32_t const max_baud_rate;
+  uint8_t const quirks;
+  uint16_t const no_autoxonxoff:1;
+  uint16_t const no_divisors:1;
+  uint16_t const alt_divisors:1;
+};
+
+#define PL2303_TYPE_DATA \
+  [TYPE_H] = { \
+    .name = (uint8_t const*)"H", \
+    .max_baud_rate = 1228800, \
+    .quirks = PL2303_QUIRK_LEGACY, \
+    .no_autoxonxoff = true, \
+  }, \
+  [TYPE_HX] = { \
+    .name = (uint8_t const*)"HX", \
+    .max_baud_rate = 6000000, \
+  }, \
+  [TYPE_TA] = { \
+    .name = (uint8_t const*)"TA", \
+    .max_baud_rate = 6000000, \
+    .alt_divisors = true, \
+  }, \
+  [TYPE_TB] = { \
+    .name = (uint8_t const*)"TB", \
+    .max_baud_rate = 12000000, \
+    .alt_divisors = true, \
+  }, \
+  [TYPE_HXD] = { \
+    .name = (uint8_t const*)"HXD", \
+    .max_baud_rate = 12000000, \
+  }, \
+  [TYPE_HXN] = { \
+    .name = (uint8_t const*)"G (HXN)", \
+    .max_baud_rate = 12000000, \
+    .no_divisors = true, \
+  }
+
+/* private data types */
+struct pl2303_serial_private {
+  const struct pl2303_type_data* type;
+  uint8_t quirks;
+};
+
+typedef struct TU_ATTR_PACKED {
+  struct pl2303_serial_private serial_private;
+  bool supports_hx_status;
+} pl2303_private_t;
+
+/* buffer sizes for line coding data */
+#define PL2303_LINE_CODING_BUFSIZE 7
+#define PL2303_LINE_CODING_BAUDRATE_BUFSIZE 4
+
+/* bulk endpoints */
+#define PL2303_OUT_EP 0x02
+#define PL2303_IN_EP 0x83
+
+/* return values of pl2303_detect_type() */
+#define PL2303_SUPPORTS_HX_STATUS_TRIGGERED -1
+#define PL2303_DETECT_TYPE_FAILED -2
+
+#endif /* _PL2303_H_ */
diff --git a/src/tusb_option.h b/src/tusb_option.h
index 2813416853..f023b490a8 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -504,6 +504,24 @@
     { 0x9986, 0x7523 }  /* overtaken from Linux Kernel driver /drivers/usb/serial/ch341.c */
 #endif
 
+#ifndef CFG_TUH_CDC_PL2303
+  // PL2303 is not part of CDC class, only to re-use CDC driver API
+  #define CFG_TUH_CDC_PL2303 0
+#endif
+
+#ifndef CFG_TUH_CDC_PL2303_VID_PID_QUIRKS_LIST
+  // List of product IDs that can use the PL2303 CDC driver
+  #define CFG_TUH_CDC_PL2303_VID_PID_LIST \
+  { 0x067b, 0x2303 }, /* initial 2303 */ \
+  { 0x067b, 0x2304 }, /* TB */ \
+  { 0x067b, 0x23a3 }, /* GC */ \
+  { 0x067b, 0x23b3 }, /* GB */ \
+  { 0x067b, 0x23c3 }, /* GT */ \
+  { 0x067b, 0x23d3 }, /* GL */ \
+  { 0x067b, 0x23e3 }, /* GE */ \
+  { 0x067b, 0x23f3 }  /* GS */
+#endif
+
 #ifndef CFG_TUH_HID
   #define CFG_TUH_HID    0
 #endif

From ea175a78aad5bd258954aa61550aae0162bc884b Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sat, 24 Feb 2024 13:00:46 +0100
Subject: [PATCH 16/37] updated contribution, readme and some comments

---
 CONTRIBUTORS.rst         | 7 +++++++
 README.rst               | 2 +-
 src/class/cdc/cdc_host.c | 6 +++---
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/CONTRIBUTORS.rst b/CONTRIBUTORS.rst
index 085f8082a4..451ac07837 100644
--- a/CONTRIBUTORS.rst
+++ b/CONTRIBUTORS.rst
@@ -31,6 +31,13 @@ Notable contributors
 -  Most features development
 
 
+`Heiko Kuester <https://github.com/IngHK>`__
+--------------------------------------------
+
+-  Add CH34x and PL2303 support (CDC host)
+-  Improve FTDI and CP210x support (CDC host)
+
+
 `Hristo Gochkov <https://github.com/me-no-dev>`__
 -------------------------------------------------
 
diff --git a/README.rst b/README.rst
index fe2417451f..6922c231ec 100644
--- a/README.rst
+++ b/README.rst
@@ -77,7 +77,7 @@ Host Stack
 - Human Interface Device (HID): Keyboard, Mouse, Generic
 - Mass Storage Class (MSC)
 - Communication Device Class: CDC-ACM
-- Vendor serial over USB: FTDI, CP210x
+- Vendor serial over USB: FTDI, CP210x, CH34x, PL2303
 - Hub with multiple-level support
 
 Similar to the Device Stack, if you have a special requirement, `usbh_app_driver_get_cb()` can be used to write your own class driver without modifying the stack.
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 429d0a113d..b35a8fd934 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -24,7 +24,7 @@
  * This file is part of the TinyUSB stack.
  *
  * Contribution
- * - Heiko Kuester: CH34x support
+ * - Heiko Kuester: add support of CH34x & PL2303, improve support of FTDI & CP210x
  */
 
 #include "tusb_option.h"
@@ -818,12 +818,12 @@ bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
   TU_ASSERT(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
   TU_LOG_P_CDC("set config");
 
-  // fake transfer to kick-off process
+  // fake transfer to kick-off process_set_config()
   tuh_xfer_t xfer;
   xfer.daddr  = daddr;
   xfer.result = XFER_RESULT_SUCCESS;
   xfer.setup  = &request;
-  xfer.user_data = 0; // initial state
+  xfer.user_data = 0; // initial state 0
 
   serial_drivers[p_cdc->serial_drid].process_set_config(&xfer);
   return true;

From 2b507dba4d9901d1208c4166bbc6026bb6062c9b Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sat, 24 Feb 2024 13:01:38 +0100
Subject: [PATCH 17/37] small changes & code style

---
 src/class/cdc/cdc_host.c | 236 ++++++++++++++++++++-------------------
 1 file changed, 124 insertions(+), 112 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index b35a8fd934..50aa4b6f0a 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -85,7 +85,7 @@ typedef struct {
 
   tuh_xfer_cb_t user_control_cb;
   #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_CP210X || CFG_TUH_CDC_CH34X
-  tuh_xfer_cb_t requested_complete_cb;
+    tuh_xfer_cb_t requested_complete_cb;
   #endif
 
   #if CFG_TUH_CDC_FTDI
@@ -119,54 +119,54 @@ static cdch_interface_t cdch_data[CFG_TUH_CDC];
 //--------------------------------------------------------------------+
 
 //------------- ACM prototypes -------------//
-static bool acm_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
-static void acm_process_config(tuh_xfer_t* xfer);
+static bool acm_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static void acm_process_config(tuh_xfer_t * xfer);
 
-static bool acm_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool acm_set_control_line_state(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool acm_set_control_line_state(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 
 //------------- FTDI prototypes -------------//
 #if CFG_TUH_CDC_FTDI
 static uint16_t const ftdi_vid_pid_list[][2] = {CFG_TUH_CDC_FTDI_VID_PID_LIST};
 #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
-static uint8_t const * ftdi_chip_name[] = { FTDI_CHIP_NAMES };
+  static uint8_t const * ftdi_chip_name[] = { FTDI_CHIP_NAMES };
 #endif
 
-static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
-static void ftdi_process_config(tuh_xfer_t* xfer);
+static bool ftdi_open(uint8_t daddr, const tusb_desc_interface_t * itf_desc, uint16_t max_len);
+static void ftdi_process_config(tuh_xfer_t * xfer);
 
-static bool ftdi_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ftdi_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ftdi_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- CP210X prototypes -------------//
 #if CFG_TUH_CDC_CP210X
 static uint16_t const cp210x_vid_pid_list[][2] = {CFG_TUH_CDC_CP210X_VID_PID_LIST};
 
-static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len);
-static void cp210x_process_config(tuh_xfer_t* xfer);
+static bool cp210x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static void cp210x_process_config(tuh_xfer_t * xfer);
 
-static bool cp210x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool cp210x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool cp210x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- CH34x prototypes -------------//
 #if CFG_TUH_CDC_CH34X
 static uint16_t const ch34x_vid_pid_list[][2] = {CFG_TUH_CDC_CH34X_VID_PID_LIST};
 
-static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len);
-static void ch34x_process_config(tuh_xfer_t* xfer);
+static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len);
+static void ch34x_process_config(tuh_xfer_t * xfer);
 
-static bool ch34x_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-static bool ch34x_set_modem_ctrl(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+static bool ch34x_set_modem_ctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 #endif
 
 //------------- PL2303 prototypes -------------//
@@ -211,14 +211,14 @@ enum {
 typedef struct {
   uint16_t const (*vid_pid_list)[2];
   uint16_t const vid_pid_count;
-  bool (*const open)(uint8_t daddr, const tusb_desc_interface_t *itf_desc, uint16_t max_len);
-  void (*const process_set_config)(tuh_xfer_t* xfer);
-  bool (*const set_control_line_state)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_baudrate)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_data_format)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
-  bool (*const set_line_coding)(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const open)(uint8_t daddr, const tusb_desc_interface_t * itf_desc, uint16_t max_len);
+  void (*const process_set_config)(tuh_xfer_t * xfer);
+  bool (*const set_control_line_state)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const set_baudrate)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const set_data_format)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+  bool (*const set_line_coding)(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
   #if CFG_TUSB_DEBUG && CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL
-  uint8_t const * name;
+    uint8_t const * name;
   #endif
 } cdch_serial_driver_t;
 
@@ -309,17 +309,17 @@ TU_VERIFY_STATIC(TU_ARRAY_SIZE(serial_drivers) == SERIAL_DRIVER_COUNT, "Serial d
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
 
-static inline cdch_interface_t* get_itf(uint8_t idx) {
+static inline cdch_interface_t * get_itf(uint8_t idx) {
   TU_ASSERT(idx < CFG_TUH_CDC, NULL);
-  cdch_interface_t* p_cdc = &cdch_data[idx];
+  cdch_interface_t * p_cdc = &cdch_data[idx];
 
   return (p_cdc->daddr != 0) ? p_cdc : NULL;
 }
 
 static inline uint8_t get_idx_by_ep_addr(uint8_t daddr, uint8_t ep_addr) {
   for(uint8_t i=0; i<CFG_TUH_CDC; i++) {
-    cdch_interface_t* p_cdc = &cdch_data[i];
-    if ( (p_cdc->daddr == daddr) &&
+    cdch_interface_t * p_cdc = &cdch_data[i];
+    if ((p_cdc->daddr == daddr) &&
          (ep_addr == p_cdc->ep_notif || ep_addr == p_cdc->stream.rx.ep_addr || ep_addr == p_cdc->stream.tx.ep_addr)) {
       return i;
     }
@@ -328,10 +328,10 @@ static inline uint8_t get_idx_by_ep_addr(uint8_t daddr, uint8_t ep_addr) {
   return TUSB_INDEX_INVALID_8;
 }
 
-static cdch_interface_t* make_new_itf(uint8_t daddr, tusb_desc_interface_t const *itf_desc) {
+static cdch_interface_t * make_new_itf(uint8_t daddr, tusb_desc_interface_t const * itf_desc) {
   for(uint8_t i=0; i<CFG_TUH_CDC; i++) {
     if (cdch_data[i].daddr == 0) {
-      cdch_interface_t* p_cdc = &cdch_data[i];
+      cdch_interface_t * p_cdc = &cdch_data[i];
       p_cdc->daddr              = daddr;
       p_cdc->bInterfaceNumber   = itf_desc->bInterfaceNumber;
       p_cdc->bInterfaceSubClass = itf_desc->bInterfaceSubClass;
@@ -345,7 +345,7 @@ static cdch_interface_t* make_new_itf(uint8_t daddr, tusb_desc_interface_t const
   return NULL;
 }
 
-static bool open_ep_stream_pair(cdch_interface_t* p_cdc , tusb_desc_endpoint_t const *desc_ep);
+static bool open_ep_stream_pair(cdch_interface_t * p_cdc , tusb_desc_endpoint_t const *desc_ep);
 
 //--------------------------------------------------------------------+
 // APPLICATION API
@@ -353,21 +353,21 @@ static bool open_ep_stream_pair(cdch_interface_t* p_cdc , tusb_desc_endpoint_t c
 
 uint8_t tuh_cdc_itf_get_index(uint8_t daddr, uint8_t itf_num) {
   for (uint8_t i = 0; i < CFG_TUH_CDC; i++) {
-    const cdch_interface_t* p_cdc = &cdch_data[i];
+    const cdch_interface_t * p_cdc = &cdch_data[i];
     if (p_cdc->daddr == daddr && p_cdc->bInterfaceNumber == itf_num) return i;
   }
 
   return TUSB_INDEX_INVALID_8;
 }
 
-bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t* info) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t * info) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && info);
 
   info->daddr = p_cdc->daddr;
 
   // re-construct descriptor
-  tusb_desc_interface_t* desc = &info->desc;
+  tusb_desc_interface_t * desc = &info->desc;
   desc->bLength            = sizeof(tusb_desc_interface_t);
   desc->bDescriptorType    = TUSB_DESC_INTERFACE;
 
@@ -383,27 +383,27 @@ bool tuh_cdc_itf_get_info(uint8_t idx, tuh_itf_info_t* info) {
 }
 
 bool tuh_cdc_mounted(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
   return p_cdc->mounted;
 }
 
 bool tuh_cdc_get_dtr(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return (p_cdc->line_state & CDC_CONTROL_LINE_STATE_DTR) ? true : false;
 }
 
 bool tuh_cdc_get_rts(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return (p_cdc->line_state & CDC_CONTROL_LINE_STATE_RTS) ? true : false;
 }
 
-bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t* line_coding) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t * line_coding) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   *line_coding = p_cdc->line_coding;
@@ -415,29 +415,29 @@ bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t* line_coding)
 // Write
 //--------------------------------------------------------------------+
 
-uint32_t tuh_cdc_write(uint8_t idx, void const* buffer, uint32_t bufsize) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+uint32_t tuh_cdc_write(uint8_t idx, void const * buffer, uint32_t bufsize) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return tu_edpt_stream_write(&p_cdc->stream.tx, buffer, bufsize);
 }
 
 uint32_t tuh_cdc_write_flush(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return tu_edpt_stream_write_xfer(&p_cdc->stream.tx);
 }
 
 bool tuh_cdc_write_clear(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return tu_edpt_stream_clear(&p_cdc->stream.tx);
 }
 
 uint32_t tuh_cdc_write_available(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return tu_edpt_stream_write_available(&p_cdc->stream.tx);
@@ -447,33 +447,34 @@ uint32_t tuh_cdc_write_available(uint8_t idx) {
 // Read
 //--------------------------------------------------------------------+
 
-uint32_t tuh_cdc_read (uint8_t idx, void* buffer, uint32_t bufsize) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+uint32_t tuh_cdc_read (uint8_t idx, void * buffer, uint32_t bufsize) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return tu_edpt_stream_read(&p_cdc->stream.rx, buffer, bufsize);
 }
 
 uint32_t tuh_cdc_read_available(uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return tu_edpt_stream_read_available(&p_cdc->stream.rx);
 }
 
-bool tuh_cdc_peek(uint8_t idx, uint8_t* ch) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+bool tuh_cdc_peek(uint8_t idx, uint8_t * ch) {
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   return tu_edpt_stream_peek(&p_cdc->stream.rx, ch);
 }
 
 bool tuh_cdc_read_clear (uint8_t idx) {
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
   bool ret = tu_edpt_stream_clear(&p_cdc->stream.rx);
   tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
+
   return ret;
 }
 
@@ -657,7 +658,7 @@ void cdch_init(void) {
   tu_memclr(cdch_data, sizeof(cdch_data));
 
   for (size_t i = 0; i < CFG_TUH_CDC; i++) {
-    cdch_interface_t* p_cdc = &cdch_data[i];
+    cdch_interface_t * p_cdc = &cdch_data[i];
 
     tu_edpt_stream_init(&p_cdc->stream.tx, true, true, false,
                         p_cdc->stream.tx_ff_buf, CFG_TUH_CDC_TX_BUFSIZE,
@@ -671,7 +672,7 @@ void cdch_init(void) {
 
 void cdch_close(uint8_t daddr) {
   for (uint8_t idx = 0; idx < CFG_TUH_CDC; idx++) {
-    cdch_interface_t* p_cdc = &cdch_data[idx];
+    cdch_interface_t * p_cdc = &cdch_data[idx];
     if (p_cdc->daddr == daddr) {
       TU_LOG_P_CDC("close");
 
@@ -695,35 +696,37 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc);
 
-  if ( ep_addr == p_cdc->stream.tx.ep_addr ) {
+  if (ep_addr == p_cdc->stream.tx.ep_addr) {
     // invoke tx complete callback to possibly refill tx fifo
     if (tuh_cdc_tx_complete_cb) tuh_cdc_tx_complete_cb(idx);
 
-    if ( 0 == tu_edpt_stream_write_xfer(&p_cdc->stream.tx) ) {
+    if (0 == tu_edpt_stream_write_xfer(&p_cdc->stream.tx)) {
       // If there is no data left, a ZLP should be sent if:
       // - xferred_bytes is multiple of EP Packet size and not zero
       tu_edpt_stream_write_zlp_if_needed(&p_cdc->stream.tx, xferred_bytes);
     }
-  } else if ( ep_addr == p_cdc->stream.rx.ep_addr ) {
+  } else if (ep_addr == p_cdc->stream.rx.ep_addr) {
     #if CFG_TUH_CDC_FTDI
     if (p_cdc->serial_drid == SERIAL_DRIVER_FTDI) {
       // FTDI reserve 2 bytes for status
       // uint8_t status[2] = {p_cdc->stream.rx.ep_buf[0], p_cdc->stream.rx.ep_buf[1]};
       tu_edpt_stream_read_xfer_complete_offset(&p_cdc->stream.rx, xferred_bytes, 2);
-    }else
+    } else
     #endif
     {
       tu_edpt_stream_read_xfer_complete(&p_cdc->stream.rx, xferred_bytes);
     }
 
     // invoke receive callback
-    if (tuh_cdc_rx_cb) tuh_cdc_rx_cb(idx);
+    if (tuh_cdc_rx_cb) {
+      tuh_cdc_rx_cb(idx);
+    }
 
     // prepare for next transfer if needed
     tu_edpt_stream_read_xfer(&p_cdc->stream.rx);
-  }else if ( ep_addr == p_cdc->ep_notif ) {
+  } else if (ep_addr == p_cdc->ep_notif) {
     // TODO handle notification endpoint
-  }else {
+  } else {
     TU_ASSERT(false);
   }
 
@@ -734,7 +737,7 @@ bool cdch_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t event, uint32_t
 // Enumeration
 //--------------------------------------------------------------------+
 
-static bool open_ep_stream_pair(cdch_interface_t* p_cdc, tusb_desc_endpoint_t const* desc_ep) {
+static bool open_ep_stream_pair(cdch_interface_t * p_cdc, tusb_desc_endpoint_t const * desc_ep) {
   for (size_t i = 0; i < 2; i++) {
     TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType &&
               TUSB_XFER_BULK == desc_ep->bmAttributes.xfer);
@@ -746,13 +749,13 @@ static bool open_ep_stream_pair(cdch_interface_t* p_cdc, tusb_desc_endpoint_t co
       tu_edpt_stream_open(&p_cdc->stream.tx, p_cdc->daddr, desc_ep);
     }
 
-    desc_ep = (tusb_desc_endpoint_t const*) tu_desc_next(desc_ep);
+    desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(desc_ep);
   }
 
   return true;
 }
 
-bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len) {
   (void) rhport;
   cdch_serial_driver_t const * driver_detected = NULL;
 
@@ -826,6 +829,7 @@ bool cdch_set_config(uint8_t daddr, uint8_t itf_num) {
   xfer.user_data = 0; // initial state 0
 
   serial_drivers[p_cdc->serial_drid].process_set_config(&xfer);
+
   return true;
 }
 
@@ -864,7 +868,7 @@ static void acm_internal_control_complete(tuh_xfer_t * xfer) {
   }
 }
 
-static bool acm_set_control_line_state(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool acm_set_control_line_state(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
 
   tusb_control_request_t const request = {
@@ -886,15 +890,16 @@ static bool acm_set_control_line_state(cdch_interface_t* p_cdc, tuh_xfer_cb_t co
     .ep_addr     = 0,
     .setup       = &request,
     .buffer      = NULL,
-    .complete_cb = complete_cb ? acm_internal_control_complete : NULL, // complete_cb is NULL for sync call
+    .complete_cb = complete_cb ? acm_internal_control_complete : NULL,
     .user_data   = user_data
   };
 
   TU_ASSERT(tuh_control_xfer(&xfer));
+
   return true;
 }
 
-static bool acm_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool acm_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
   TU_VERIFY(p_cdc->requested_line_coding.data_bits && p_cdc->requested_line_coding.bit_rate);
   TU_VERIFY((p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 8) ||
@@ -913,30 +918,32 @@ static bool acm_set_line_coding(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_
   };
 
   // use usbh enum buf to hold line coding since user line_coding variable does not live long enough
-  uint8_t* enum_buf = usbh_get_enum_buf();
+  uint8_t * enum_buf = usbh_get_enum_buf();
   memcpy(enum_buf, &p_cdc->requested_line_coding, sizeof(cdc_line_coding_t));
 
   p_cdc->user_control_cb = complete_cb;
+
   tuh_xfer_t xfer = {
     .daddr       = p_cdc->daddr,
     .ep_addr     = 0,
     .setup       = &request,
     .buffer      = enum_buf,
-    .complete_cb = complete_cb ? acm_internal_control_complete : NULL, // complete_cb is NULL for sync call
+    .complete_cb = complete_cb ? acm_internal_control_complete : NULL,
     .user_data   = user_data
   };
 
   TU_ASSERT(tuh_control_xfer(&xfer));
+
   return true;
 }
 
-static bool acm_set_data_format(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool acm_set_data_format(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->requested_line_coding.bit_rate = p_cdc->line_coding.bit_rate;
 
   return acm_set_line_coding(p_cdc, complete_cb, user_data);
 }
 
-static bool acm_set_baudrate(cdch_interface_t* p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool acm_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   p_cdc->requested_line_coding.stop_bits = p_cdc->line_coding.stop_bits;
   p_cdc->requested_line_coding.parity    = p_cdc->line_coding.parity;
   p_cdc->requested_line_coding.data_bits = p_cdc->line_coding.data_bits;
@@ -952,21 +959,22 @@ enum {
   CONFIG_ACM_COMPLETE,
 };
 
-static bool acm_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len) {
-  uint8_t const* p_desc_end = ((uint8_t const*) itf_desc) + max_len;
+static bool acm_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len) {
+  uint8_t const * p_desc_end = ((uint8_t const *) itf_desc) + max_len;
 
-  cdch_interface_t* p_cdc = make_new_itf(daddr, itf_desc);
+  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
   TU_VERIFY(p_cdc);
+
   p_cdc->serial_drid = SERIAL_DRIVER_ACM;
 
   //------------- Control Interface -------------//
-  uint8_t const* p_desc = tu_desc_next(itf_desc);
+  uint8_t const * p_desc = tu_desc_next(itf_desc);
 
   // Communication Functional Descriptors
   while ((p_desc < p_desc_end) && (TUSB_DESC_CS_INTERFACE == tu_desc_type(p_desc))) {
     if (CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc)) {
       // save ACM bmCapabilities
-      p_cdc->acm_capability = ((cdc_desc_func_acm_t const*) p_desc)->bmCapabilities;
+      p_cdc->acm_capability = ((cdc_desc_func_acm_t const *) p_desc)->bmCapabilities;
     }
 
     p_desc = tu_desc_next(p_desc);
@@ -975,7 +983,7 @@ static bool acm_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint1
   // Open notification endpoint of control interface if any
   if (itf_desc->bNumEndpoints == 1) {
     TU_ASSERT(TUSB_DESC_ENDPOINT == tu_desc_type(p_desc));
-    tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) p_desc;
+    tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) p_desc;
 
     TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
     p_cdc->ep_notif = desc_ep->bEndpointAddress;
@@ -985,22 +993,22 @@ static bool acm_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint1
 
   //------------- Data Interface (if any) -------------//
   if ((TUSB_DESC_INTERFACE == tu_desc_type(p_desc)) &&
-      (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const*) p_desc)->bInterfaceClass)) {
+      (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass)) {
     // next to endpoint descriptor
     p_desc = tu_desc_next(p_desc);
 
     // data endpoints expected to be in pairs
-    TU_ASSERT(open_ep_stream_pair(p_cdc, (tusb_desc_endpoint_t const*) p_desc));
+    TU_ASSERT(open_ep_stream_pair(p_cdc, (tusb_desc_endpoint_t const *) p_desc));
   }
 
   return true;
 }
 
-static void acm_process_config(tuh_xfer_t* xfer) {
+static void acm_process_config(tuh_xfer_t * xfer) {
   uintptr_t const state = xfer->user_data;
   uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS, 1);
 
   switch (state) {
@@ -1814,8 +1822,9 @@ static uint16_t ch34x_get_divisor_prescaler(cdch_interface_t * p_cdc);
 
 //------------- Control Request -------------//
 
-static bool ch34x_set_request(cdch_interface_t* p_cdc, uint8_t direction, uint8_t request, uint16_t value,
-                              uint16_t index, uint8_t* buffer, uint16_t length, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static bool ch34x_set_request(cdch_interface_t * p_cdc, uint8_t direction, uint8_t request,
+                              uint16_t value, uint16_t index, uint8_t * buffer, uint16_t length,
+                              tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   tusb_control_request_t const request_setup = {
       .bmRequestType_bit = {
           .recipient = TUSB_REQ_RCPT_DEVICE,
@@ -1829,7 +1838,7 @@ static bool ch34x_set_request(cdch_interface_t* p_cdc, uint8_t direction, uint8_
   };
 
   // use usbh enum buf since application variable does not live long enough
-  uint8_t* enum_buf = NULL;
+  uint8_t * enum_buf = NULL;
 
   if (buffer && length > 0) {
     enum_buf = usbh_get_enum_buf();
@@ -1850,22 +1859,23 @@ static bool ch34x_set_request(cdch_interface_t* p_cdc, uint8_t direction, uint8_
   return tuh_control_xfer(&xfer);
 }
 
-static inline bool ch34x_control_out(cdch_interface_t* p_cdc, uint8_t request, uint16_t value, uint16_t index,
+static inline bool ch34x_control_out(cdch_interface_t * p_cdc, uint8_t request, uint16_t value, uint16_t index,
                                      tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return ch34x_set_request(p_cdc, TUSB_DIR_OUT, request, value, index, NULL, 0, complete_cb, user_data);
 }
 
-static inline bool ch34x_control_in(cdch_interface_t* p_cdc, uint8_t request, uint16_t value, uint16_t index,
-                                    uint8_t* buffer, uint16_t buffersize, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static inline bool ch34x_control_in(cdch_interface_t * p_cdc, uint8_t request, uint16_t value, uint16_t index,
+                                    uint8_t * buffer, uint16_t buffersize, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return ch34x_set_request(p_cdc, TUSB_DIR_IN, request, value, index, buffer, buffersize,
                            complete_cb, user_data);
 }
 
-static inline bool ch34x_write_reg(cdch_interface_t* p_cdc, uint16_t reg, uint16_t reg_value, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+static inline bool ch34x_write_reg(cdch_interface_t * p_cdc, uint16_t reg, uint16_t reg_value,
+                                   tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   return ch34x_control_out(p_cdc, CH34X_REQ_WRITE_REG, reg, reg_value, complete_cb, user_data);
 }
 
-//static bool ch34x_read_reg_request ( cdch_interface_t* p_cdc, uint16_t reg,
+//static bool ch34x_read_reg_request ( cdch_interface_t * p_cdc, uint16_t reg,
 //                                     uint8_t *buffer, uint16_t buffersize, tuh_xfer_cb_t complete_cb, uintptr_t user_data )
 //{
 //  return ch34x_control_in ( p_cdc, CH34X_REQ_READ_REG, reg, 0, buffer, buffersize, complete_cb, user_data );
@@ -1907,8 +1917,8 @@ static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
   // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
   uint8_t const itf_num = 0;
   uint8_t idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
-  TU_ASSERT(p_cdc, );
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
   TU_LOG_P_CDC("control complete success = %u", success);
 
@@ -1997,17 +2007,17 @@ enum {
   CONFIG_CH34X_COMPLETE
 };
 
-static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uint16_t max_len) {
+static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, uint16_t max_len) {
   // CH34x Interface includes 1 vendor interface + 2 bulk + 1 interrupt endpoints
-  TU_VERIFY (itf_desc->bNumEndpoints == 3);
-  TU_VERIFY (sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
+  TU_VERIFY(itf_desc->bNumEndpoints == 3);
+  TU_VERIFY(sizeof(tusb_desc_interface_t) + 3 * sizeof(tusb_desc_endpoint_t) <= max_len);
 
-  cdch_interface_t* p_cdc = make_new_itf(daddr, itf_desc);
-  TU_VERIFY (p_cdc);
+  cdch_interface_t * p_cdc = make_new_itf(daddr, itf_desc);
+  TU_VERIFY(p_cdc);
 
   p_cdc->serial_drid = SERIAL_DRIVER_CH34X;
 
-  tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) tu_desc_next(itf_desc);
+  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) tu_desc_next(itf_desc);
 
   // data endpoints expected to be in pairs
   TU_ASSERT(open_ep_stream_pair(p_cdc, desc_ep));
@@ -2023,11 +2033,11 @@ static bool ch34x_open(uint8_t daddr, tusb_desc_interface_t const* itf_desc, uin
 }
 
 static void ch34x_process_config(tuh_xfer_t* xfer) {
-  // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
   uintptr_t const state = xfer->user_data;
+  // CH34x has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
   uint8_t const itf_num = 0;
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
-  cdch_interface_t* p_cdc = get_itf(idx);
+  cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT_COMPLETE(p_cdc && xfer->result == XFER_RESULT_SUCCESS);
   uint8_t buffer[2]; // TODO remove
 
@@ -2035,7 +2045,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
     case CONFIG_CH34X_READ_VERSION:
       p_cdc->user_control_cb = ch34x_process_config; // set once for whole process config
       TU_ASSERT_COMPLETE(ch34x_control_in(p_cdc, CH34X_REQ_READ_VERSION, 0, 0, buffer, 2,
-                         ch34x_process_config, CONFIG_CH34X_SERIAL_INIT));
+                                          ch34x_process_config, CONFIG_CH34X_SERIAL_INIT));
       break;
 
     case CONFIG_CH34X_SERIAL_INIT: {
@@ -2060,19 +2070,20 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
       // overtake line coding and do special reg write, purpose unknown, overtaken from WCH driver
       p_cdc->line_coding = (cdc_line_coding_t) CFG_TUH_CDC_LINE_CODING_ON_ENUM_CH34X;
       TU_ASSERT_COMPLETE(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x0F, CH341_REG_0x2C), 0x0007,
-                         ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL));
+                                         ch34x_process_config, CONFIG_CH34X_FLOW_CONTROL));
       break;
 
     case CONFIG_CH34X_FLOW_CONTROL:
       // no hardware flow control
       TU_ASSERT_COMPLETE(ch34x_write_reg(p_cdc, TU_U16(CH341_REG_0x27, CH341_REG_0x27), 0x0000,
-                         ch34x_process_config, CONFIG_CH34X_MODEM_CONTROL));
+                                         ch34x_process_config, CONFIG_CH34X_MODEM_CONTROL));
       break;
 
     case CONFIG_CH34X_MODEM_CONTROL:
       #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
-        TU_ASSERT_COMPLETE(ch34x_modem_ctrl_request(p_cdc, ch34x_internal_control_complete, CONFIG_CH34X_COMPLETE));
+        TU_ASSERT_COMPLETE(ch34x_modem_ctrl_request(p_cdc, ch34x_internal_control_complete,
+                                                    CONFIG_CH34X_COMPLETE));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
@@ -2431,6 +2442,7 @@ static bool pl2303_open(uint8_t daddr, tusb_desc_interface_t const * itf_desc, u
 }
 
 static void pl2303_process_config(tuh_xfer_t * xfer) {
+  uintptr_t const state = xfer->user_data;
   // PL2303 has only interface 0, because wIndex is used as payload and not for bInterfaceNumber
   uint8_t const itf_num = 0;
   uint8_t const idx = tuh_cdc_itf_get_index(xfer->daddr, itf_num);
@@ -2440,7 +2452,7 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
   uint8_t buf;
   int8_t type;
 
-  switch (xfer->user_data) {
+  switch (state) {
 
     // from here sequence overtaken from Linux Kernel function pl2303_startup()
     case CONFIG_PL2303_GET_DESC:

From da93fcfc6dbe51ceb73e990aefea9c8d55d3fc94 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 22 Feb 2024 15:09:25 +0100
Subject: [PATCH 18/37] improved TU_LOGs

---
 src/class/cdc/cdc_host.c | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 50aa4b6f0a..f3fbe88eac 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -50,6 +50,7 @@
                                                           DADDR, ITF_NUM, NAME, ##__VA_ARGS__)
 #define TU_LOG_P_CDC(TXT,...)                  TU_LOG_CDC(TXT, p_cdc->daddr, p_cdc->bInterfaceNumber, \
                                                           serial_drivers[p_cdc->serial_drid].name, ##__VA_ARGS__)
+#define TU_LOG_RESULT(TXT,RESULT)              TU_LOG_P_CDC(TXT " " #RESULT " = %s", RESULT ? "true" : "FALSE" )
 
 #define TU_ASSERT_COMPLETE_DEFINE(_cond, _itf_offset)                                                \
   do {                                                                                               \
@@ -587,6 +588,7 @@ bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_c
   if (ret && !complete_cb) {
     p_cdc->line_state = (uint8_t) line_state;
   }
+  TU_LOG_RESULT("set control line state", ret);
 
   return ret;
 }
@@ -604,6 +606,7 @@ bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete
   if (ret && !complete_cb) {
     p_cdc->line_coding.bit_rate = baudrate;
   }
+  TU_LOG_RESULT("set baudrate", ret);
 
   return ret;
 }
@@ -627,6 +630,7 @@ bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uin
     p_cdc->line_coding.parity    = parity;
     p_cdc->line_coding.data_bits = data_bits;
   }
+  TU_LOG_RESULT("set data format", ret);
 
   return ret;
 }
@@ -646,6 +650,7 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const * line_coding,
   if (ret && !complete_cb) {
     p_cdc->line_coding = *line_coding;
   }
+  TU_LOG_RESULT("set line coding", ret);
 
   return ret;
 }
@@ -785,6 +790,7 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const * itf_
   if (driver_detected) {
     TU_LOG_CDC("open", daddr, itf_desc->bInterfaceNumber, driver_detected->name);
     bool ret = driver_detected->open(daddr, itf_desc, max_len);
+    TU_LOG_CDC("opened ret = %s", daddr, itf_desc->bInterfaceNumber, driver_detected->name, ret ? "true" : "FALSE" );
     return ret;
   }
 
@@ -794,7 +800,7 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const * itf_
 static void set_config_complete(uint8_t idx, uint8_t itf_offset, bool success) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
-  TU_LOG_P_CDC("set config complete success = %u", success);
+  TU_LOG_RESULT("set config complete", success);
 
   if (success) {
     p_cdc->mounted = true;
@@ -846,7 +852,7 @@ static void acm_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_P_CDC("control complete success = %u", success);
+  TU_LOG_RESULT("  control complete", success);
 
   if (success) {
     switch (xfer->setup->bRequest) {
@@ -1131,7 +1137,7 @@ static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_P_CDC("control complete success = %u", success);
+  TU_LOG_RESULT("  control complete", success);
 
   if (success) {
     switch (xfer->setup->bRequest) {
@@ -1407,7 +1413,7 @@ static bool ftdi_determine_type(cdch_interface_t * p_cdc, uint8_t const idx)
       break;
   }
 
-  TU_LOG_P_CDC("%s detected", ftdi_chip_name[p_cdc->ftdi.chip_type]);
+  TU_LOG_P_CDC("  %s detected", ftdi_chip_name[p_cdc->ftdi.chip_type]);
 
   return (p_cdc->ftdi.chip_type != UNKNOWN);
 }
@@ -1554,7 +1560,7 @@ static inline uint32_t ftdi_get_divisor(cdch_interface_t * p_cdc)
       break;
   }
 
-  TU_LOG_P_CDC("Baudrate divisor 0x%lu", div_value);
+  TU_LOG_P_CDC("  Baudrate divisor 0x%lu", div_value);
 
   return div_value;
 }
@@ -1663,7 +1669,7 @@ static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_P_CDC("control complete success = %u", success);
+  TU_LOG_RESULT("  control complete", success);
 
   if (success) {
     switch(xfer->setup->bRequest) {
@@ -1920,7 +1926,7 @@ static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_P_CDC("control complete success = %u", success);
+  TU_LOG_RESULT("  control complete", success);
 
   if (success) {
     switch (xfer->setup->bRequest) {
@@ -2051,7 +2057,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
     case CONFIG_CH34X_SERIAL_INIT: {
       // handle version read data, set CH34x line coding (incl. baudrate)
       uint8_t const version = xfer->buffer[0];
-      TU_LOG_P_CDC("Chip Version = %02x", version);
+      TU_LOG_P_CDC("  Chip Version = %02x", version);
       // only versions >= 0x30 are tested, below 0x30 seems having other programming
       // see drivers from WCH vendor, Linux kernel and FreeBSD
       TU_ASSERT_COMPLETE(version >= 0x30);
@@ -2337,7 +2343,7 @@ static void pl2303_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_P_CDC("control complete success = %u", success);
+  TU_LOG_RESULT("  control complete", success);
 
   if (success) {
     if (xfer->setup->bRequest == PL2303_SET_LINE_REQUEST &&
@@ -2743,7 +2749,7 @@ static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t const idx, ui
     default: break;
   }
 
-  TU_LOG_P_CDC("unknown device type bcdUSB = 0x%04x", desc_dev[idx]->bcdUSB);
+  TU_LOG_P_CDC("  unknown device type bcdUSB = 0x%04x", desc_dev[idx]->bcdUSB);
 
   return PL2303_DETECT_TYPE_FAILED;
 }
@@ -2893,7 +2899,7 @@ static bool pl2303_encode_baud_rate(cdch_interface_t * p_cdc, uint8_t buf[PL2303
   } else {
     baud = pl2303_encode_baud_rate_divisor(buf, baud);
   }
-  TU_LOG_P_CDC("real baudrate = %lu", baud);
+  TU_LOG_P_CDC("  real baudrate = %lu", baud);
 
   return true;
 }

From 46a861b0e31a7382d620986079abd0c373dfe6da Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Fri, 23 Feb 2024 08:30:50 +0100
Subject: [PATCH 19/37] improved PL2303 TU_LOGs

---
 src/class/cdc/cdc_host.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index f3fbe88eac..9d27b1e791 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -2486,13 +2486,14 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
       p_cdc->pl2303.serial_private.type = &pl2303_type_data[type];
       p_cdc->pl2303.serial_private.quirks |= p_cdc->pl2303.serial_private.type->quirks;
       #if CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL && 0 // can be activated if necessary
-        TU_LOG(CFG_TUH_CDC_LOG_LEVEL, "PL2303 bDeviceClass = 0x%02x bMaxPacketSize0 = %u bcdUSB = 0x%04x bcdDevice = 0x%04x",
-               desc_dev[idx]->bDeviceClass, desc_dev[idx]->bMaxPacketSize0, desc_dev[idx]->bcdUSB, desc_dev[idx]->bcdDevice );
+        TU_LOG_P_CDC("  bDeviceClass = 0x%02x bMaxPacketSize0 = %u bcdUSB = 0x%04x bcdDevice = 0x%04x",
+                     desc_dev[idx]->bDeviceClass, desc_dev[idx]->bMaxPacketSize0,
+                     desc_dev[idx]->bcdUSB, desc_dev[idx]->bcdDevice );
         uint16_t vid, pid;
         TU_ASSERT_COMPLETE(tuh_vid_pid_get(p_cdc->daddr, &vid, &pid));
-        TU_LOG(CFG_TUH_CDC_LOG_LEVEL, "       vid = 0x%04x pid = 0x%04x supports_hx_status = %u type = %s quirks = %u",
-               vid, pid, p_cdc->pl2303.supports_hx_status,
-               p_cdc->pl2303.serial_private.type->name, p_cdc->pl2303.serial_private.quirks);
+        TU_LOG_P_CDC("  vid = 0x%04x pid = 0x%04x supports_hx_status = %u type = %s quirks = %u",
+                     vid, pid, p_cdc->pl2303.supports_hx_status,
+                     p_cdc->pl2303.serial_private.type->name, p_cdc->pl2303.serial_private.quirks);
       #endif
       // purpose unknown, overtaken from Linux Kernel driver
       if (p_cdc->pl2303.serial_private.type != &pl2303_type_data[TYPE_HXN]) {

From f97e31226a959944785122d4c0c10d4b3304704c Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Wed, 28 Feb 2024 13:07:40 +0100
Subject: [PATCH 20/37] FTDI fixed itf_num and some improvement

---
 src/class/cdc/cdc_host.c | 37 +++++++++++++++++++------------------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 9d27b1e791..33d201c07f 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -1140,22 +1140,19 @@ static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
   TU_LOG_RESULT("  control complete", success);
 
   if (success) {
-    switch (xfer->setup->bRequest) {
-      case FTDI_SIO_SET_MODEM_CTRL_REQUEST:
-        p_cdc->line_state = p_cdc->requested_line_state;
-        break;
-
-      case FTDI_SIO_SET_DATA_REQUEST:
-        p_cdc->line_coding.stop_bits = p_cdc->requested_line_coding.stop_bits;
-        p_cdc->line_coding.parity    = p_cdc->requested_line_coding.parity;
-        p_cdc->line_coding.data_bits = p_cdc->requested_line_coding.data_bits;
-        break;
-
-      case FTDI_SIO_SET_BAUDRATE_REQUEST:
-        p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
-        break;
-
-      default: break;
+    if (xfer->setup->bRequest      == FTDI_SIO_SET_MODEM_CTRL_REQUEST &&
+        xfer->setup->bmRequestType == FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE ) {
+      p_cdc->line_state = p_cdc->requested_line_state;
+    }
+    if (xfer->setup->bRequest      == FTDI_SIO_SET_DATA_REQUEST &&
+        xfer->setup->bmRequestType == FTDI_SIO_SET_DATA_REQUEST_TYPE ) {
+      p_cdc->line_coding.stop_bits = p_cdc->requested_line_coding.stop_bits;
+      p_cdc->line_coding.parity    = p_cdc->requested_line_coding.parity;
+      p_cdc->line_coding.data_bits = p_cdc->requested_line_coding.data_bits;
+    }
+    if (xfer->setup->bRequest      == FTDI_SIO_SET_BAUDRATE_REQUEST &&
+        xfer->setup->bmRequestType == FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE ) {
+      p_cdc->line_coding.bit_rate = p_cdc->requested_line_coding.bit_rate;
     }
   }
 
@@ -1180,7 +1177,10 @@ static bool ftdi_set_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_c
 }
 
 static void ftdi_set_line_coding_stage1_complete(tuh_xfer_t * xfer) {
-  uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
+  uint8_t const idx = ftdi_get_idx(xfer);
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_ASSERT(p_cdc,);
+  uint8_t const itf_num = p_cdc->bInterfaceNumber;
   set_line_coding_stage1_complete(xfer, itf_num,
                                   ftdi_set_data_request,           // control request function to set data format
                                   ftdi_internal_control_complete); // control complete function to be called after request
@@ -1413,7 +1413,8 @@ static bool ftdi_determine_type(cdch_interface_t * p_cdc, uint8_t const idx)
       break;
   }
 
-  TU_LOG_P_CDC("  %s detected", ftdi_chip_name[p_cdc->ftdi.chip_type]);
+  TU_LOG_P_CDC("  %s detected (bcdDevice = 0x%04x)",
+               ftdi_chip_name[p_cdc->ftdi.chip_type], desc_dev[idx]->bcdDevice);
 
   return (p_cdc->ftdi.chip_type != UNKNOWN);
 }

From d3d61da0384d066b9930e8e5b658717983f02efb Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sun, 25 Feb 2024 17:20:02 +0100
Subject: [PATCH 21/37] improved & fixed compiler warnings device descriptor
 handling

---
 src/class/cdc/cdc_host.c | 44 +++++++++++++++++++++-------------------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 33d201c07f..c222e11db4 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -111,8 +111,10 @@ typedef struct {
 
 CFG_TUH_MEM_SECTION
 static cdch_interface_t cdch_data[CFG_TUH_CDC];
+
 #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_PL2303
-  static tusb_desc_device_t desc_dev[CFG_TUH_CDC][CFG_TUH_ENUMERATION_BUFSIZE];
+  CFG_TUH_MEM_SECTION CFG_TUH_MEM_ALIGN
+  static tusb_desc_device_t desc_dev[CFG_TUH_ENUMERATION_BUFSIZE];
 #endif
 
 //--------------------------------------------------------------------+
@@ -1054,7 +1056,7 @@ static void acm_process_config(tuh_xfer_t * xfer) {
 //--------------------------------------------------------------------+
 #if CFG_TUH_CDC_FTDI
 
-static bool ftdi_determine_type(cdch_interface_t * p_cdc, uint8_t const idx);
+static bool ftdi_determine_type(cdch_interface_t * p_cdc);
 static uint32_t ftdi_get_divisor(cdch_interface_t * p_cdc);
 static uint8_t ftdi_get_idx(tuh_xfer_t * xfer);
 
@@ -1255,7 +1257,7 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
       // get device descriptor
       p_cdc->user_control_cb = ftdi_process_config; // set once for whole process config
       if (itf_num == 0) { // only necessary for 1st interface. other interface overtake type from interface 0
-        TU_ASSERT_COMPLETE(tuh_descriptor_get_device(xfer->daddr, desc_dev[idx], sizeof(tusb_desc_device_t),
+        TU_ASSERT_COMPLETE(tuh_descriptor_get_device(xfer->daddr, &desc_dev, sizeof(tusb_desc_device_t),
                                                      ftdi_process_config, CONFIG_FTDI_DETERMINE_TYPE));
         break;
       }
@@ -1264,7 +1266,7 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
     case CONFIG_FTDI_DETERMINE_TYPE:
       // determine type
       if (itf_num == 0) {
-        TU_ASSERT_COMPLETE(ftdi_determine_type(p_cdc, idx));
+        TU_ASSERT_COMPLETE(ftdi_determine_type(p_cdc));
       } else {
         // other interfaces have same type as interface 0
         uint8_t const idx_itf0 = tuh_cdc_itf_get_index(xfer->daddr, 0);
@@ -1334,9 +1336,9 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
 
 //------------- Helper -------------//
 
-static bool ftdi_determine_type(cdch_interface_t * p_cdc, uint8_t const idx)
+static bool ftdi_determine_type(cdch_interface_t * p_cdc)
 {
-  uint16_t const version = desc_dev[idx]->bcdDevice;
+  uint16_t const version = desc_dev->bcdDevice;
   uint8_t const itf_num = p_cdc->bInterfaceNumber;
 
   p_cdc->ftdi.chip_type = UNKNOWN;
@@ -1414,7 +1416,7 @@ static bool ftdi_determine_type(cdch_interface_t * p_cdc, uint8_t const idx)
   }
 
   TU_LOG_P_CDC("  %s detected (bcdDevice = 0x%04x)",
-               ftdi_chip_name[p_cdc->ftdi.chip_type], desc_dev[idx]->bcdDevice);
+               ftdi_chip_name[p_cdc->ftdi.chip_type], desc_dev->bcdDevice);
 
   return (p_cdc->ftdi.chip_type != UNKNOWN);
 }
@@ -2207,7 +2209,7 @@ static uint8_t ch34x_get_lcr(cdch_interface_t * p_cdc) {
 //--------------------------------------------------------------------+
 #if CFG_TUH_CDC_PL2303
 
-static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t const idx, uint8_t step,
+static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t step,
                                  tuh_xfer_cb_t complete_cb, uintptr_t user_data);
 static bool pl2303_encode_baud_rate(cdch_interface_t * p_cdc, uint8_t buf[PL2303_LINE_CODING_BAUDRATE_BUFSIZE]);
 
@@ -2465,13 +2467,13 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
     case CONFIG_PL2303_GET_DESC:
       p_cdc->user_control_cb = pl2303_process_config; // set once for whole process config
       // get device descriptor
-      TU_ASSERT_COMPLETE(tuh_descriptor_get_device(xfer->daddr, desc_dev[idx], sizeof(tusb_desc_device_t),
+      TU_ASSERT_COMPLETE(tuh_descriptor_get_device(xfer->daddr, &desc_dev, sizeof(tusb_desc_device_t),
                                                    pl2303_process_config, CONFIG_PL2303_DETECT_TYPE));
       break;
 
     case CONFIG_PL2303_DETECT_TYPE:
       // get type and quirks (step 1)
-      type = pl2303_detect_type (p_cdc, idx, 1, pl2303_process_config, CONFIG_PL2303_READ1); // step 1
+      type = pl2303_detect_type (p_cdc, 1, pl2303_process_config, CONFIG_PL2303_READ1); // step 1
       TU_ASSERT_COMPLETE(type!=PL2303_DETECT_TYPE_FAILED);
       if (type == PL2303_SUPPORTS_HX_STATUS_TRIGGERED) {
         break;
@@ -2482,14 +2484,14 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
       // get supports_hx_status, type and quirks (step 2), do special read
       p_cdc->pl2303.supports_hx_status = ( // will not be true, if coming directly from previous case
                                            xfer->user_data == CONFIG_PL2303_READ1 && xfer->result == XFER_RESULT_SUCCESS );
-      type = pl2303_detect_type (p_cdc, idx, 2, NULL, 0); // step 2 now with supports_hx_status
+      type = pl2303_detect_type (p_cdc, 2, NULL, 0); // step 2 now with supports_hx_status
       TU_ASSERT_COMPLETE(type!=PL2303_DETECT_TYPE_FAILED);
       p_cdc->pl2303.serial_private.type = &pl2303_type_data[type];
       p_cdc->pl2303.serial_private.quirks |= p_cdc->pl2303.serial_private.type->quirks;
       #if CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL && 0 // can be activated if necessary
         TU_LOG_P_CDC("  bDeviceClass = 0x%02x bMaxPacketSize0 = %u bcdUSB = 0x%04x bcdDevice = 0x%04x",
-                     desc_dev[idx]->bDeviceClass, desc_dev[idx]->bMaxPacketSize0,
-                     desc_dev[idx]->bcdUSB, desc_dev[idx]->bcdDevice );
+                     desc_dev->bDeviceClass, desc_dev->bMaxPacketSize0,
+                     desc_dev->bcdUSB, desc_dev->bcdDevice );
         uint16_t vid, pid;
         TU_ASSERT_COMPLETE(tuh_vid_pid_get(p_cdc->daddr, &vid, &pid));
         TU_LOG_P_CDC("  vid = 0x%04x pid = 0x%04x supports_hx_status = %u type = %s quirks = %u",
@@ -2674,29 +2676,29 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
 
 //------------- Helper -------------//
 
-static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t const idx, uint8_t step,
+static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t step,
                                  tuh_xfer_cb_t complete_cb, uintptr_t user_data )
 {
   /*
    * Legacy PL2303H, variants 0 and 1 (difference unknown).
    */
-  if (desc_dev[idx]->bDeviceClass == 0x02) {
+  if (desc_dev->bDeviceClass == 0x02) {
     return TYPE_H;    /* variant 0 */
   }
 
-  if (desc_dev[idx]->bMaxPacketSize0 != 0x40) {
-    if (desc_dev[idx]->bDeviceClass == 0x00 || desc_dev[idx]->bDeviceClass == 0xff) {
+  if (desc_dev->bMaxPacketSize0 != 0x40) {
+    if (desc_dev->bDeviceClass == 0x00 || desc_dev->bDeviceClass == 0xff) {
       return TYPE_H;  /* variant 1 */
     }
     return TYPE_H;    /* variant 0 */
   }
 
-  switch (desc_dev[idx]->bcdUSB) {
+  switch (desc_dev->bcdUSB) {
     case 0x101:
       /* USB 1.0.1? Let's assume they meant 1.1... */
       TU_ATTR_FALLTHROUGH;
     case 0x110:
-      switch (desc_dev[idx]->bcdDevice) {
+      switch (desc_dev->bcdDevice) {
         case 0x300:
           return TYPE_HX;
         case 0x400:
@@ -2706,7 +2708,7 @@ static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t const idx, ui
       }
       break;
     case 0x200:
-      switch (desc_dev[idx]->bcdDevice) {
+      switch (desc_dev->bcdDevice) {
         case 0x100: /* GC */
         case 0x105:
           return TYPE_HXN;
@@ -2751,7 +2753,7 @@ static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t const idx, ui
     default: break;
   }
 
-  TU_LOG_P_CDC("  unknown device type bcdUSB = 0x%04x", desc_dev[idx]->bcdUSB);
+  TU_LOG_P_CDC("  unknown device type bcdUSB = 0x%04x", desc_dev->bcdUSB);
 
   return PL2303_DETECT_TYPE_FAILED;
 }

From edf13203916931962a53af50abc548dd3eded278 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Wed, 28 Feb 2024 13:13:18 +0100
Subject: [PATCH 22/37] removed expendable ACM check

---
 src/class/cdc/cdc_host.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index c222e11db4..4d2134f9de 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -909,7 +909,6 @@ static bool acm_set_control_line_state(cdch_interface_t * p_cdc, tuh_xfer_cb_t c
 
 static bool acm_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->acm_capability.support_line_request);
-  TU_VERIFY(p_cdc->requested_line_coding.data_bits && p_cdc->requested_line_coding.bit_rate);
   TU_VERIFY((p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 8) ||
              p_cdc->requested_line_coding.data_bits == 16);
 

From 3cf9cb98e630a0cb26bc28a2e4c67fb6df19a884 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Wed, 28 Feb 2024 13:15:37 +0100
Subject: [PATCH 23/37] small PL2303 improvements

---
 src/class/cdc/cdc_host.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 4d2134f9de..1309935470 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -2292,9 +2292,10 @@ static bool pl2303_set_line_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t comp
    * even to the same values as before. Thus we actually need to filter
    * in this specific case.
    */
-  // TODO really necessary to check? what to do in this case when no transfer will happen?
-  // callback is not called...
-  TU_VERIFY(memcmp(&p_cdc->requested_line_coding, &p_cdc->line_coding, sizeof(cdc_line_coding_t) ) != 0);
+  TU_VERIFY(p_cdc->requested_line_coding.data_bits != p_cdc->line_coding.data_bits ||
+            p_cdc->requested_line_coding.stop_bits != p_cdc->line_coding.stop_bits ||
+            p_cdc->requested_line_coding.parity    != p_cdc->line_coding.parity    ||
+            p_cdc->requested_line_coding.bit_rate  != p_cdc->line_coding.bit_rate );
 
   /* For reference buf[6] data bits value */
   TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 8, 0);

From e7308e313a1fb5482dbbb34cdfc6b7b11a54fd6b Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Wed, 28 Feb 2024 13:28:38 +0100
Subject: [PATCH 24/37] improved TU_LOGs

---
 src/class/cdc/cdc.h      | 12 ++++++++
 src/class/cdc/cdc_host.c | 65 ++++++++++++++++++++++++----------------
 2 files changed, 51 insertions(+), 26 deletions(-)

diff --git a/src/class/cdc/cdc.h b/src/class/cdc/cdc.h
index 5cbd658fe2..b1dca1ad82 100644
--- a/src/class/cdc/cdc.h
+++ b/src/class/cdc/cdc.h
@@ -192,6 +192,11 @@ typedef enum {
   CDC_LINE_CODING_STOP_BITS_2   = 2, // 2   bits
 } cdc_line_coding_stopbits_t;
 
+#define CDC_LINE_CODING_STOP_BITS_TEXT(STOP_BITS) (        \
+  STOP_BITS == CDC_LINE_CODING_STOP_BITS_1 ?   "1" :       \
+  STOP_BITS == CDC_LINE_CODING_STOP_BITS_1_5 ? "1.5" :     \
+  STOP_BITS == CDC_LINE_CODING_STOP_BITS_2 ?   "2"   : "?" )
+
 // TODO Backward compatible for typos. Maybe removed in the future release
 #define CDC_LINE_CONDING_STOP_BITS_1   CDC_LINE_CODING_STOP_BITS_1
 #define CDC_LINE_CONDING_STOP_BITS_1_5 CDC_LINE_CODING_STOP_BITS_1_5
@@ -205,6 +210,13 @@ typedef enum {
   CDC_LINE_CODING_PARITY_SPACE = 4,
 } cdc_line_coding_parity_t;
 
+#define CDC_LINE_CODING_PARITY_CHAR(PARITY) (        \
+  PARITY == CDC_LINE_CODING_PARITY_NONE  ? 'N' :     \
+  PARITY == CDC_LINE_CODING_PARITY_ODD   ? 'O' :     \
+  PARITY == CDC_LINE_CODING_PARITY_EVEN  ? 'E' :     \
+  PARITY == CDC_LINE_CODING_PARITY_MARK  ? 'M' :     \
+  PARITY == CDC_LINE_CODING_PARITY_SPACE ? 'S' : '?' )
+
 //--------------------------------------------------------------------+
 // Management Element Notification (Notification Endpoint)
 //--------------------------------------------------------------------+
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 1309935470..d2bc63d646 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -50,7 +50,7 @@
                                                           DADDR, ITF_NUM, NAME, ##__VA_ARGS__)
 #define TU_LOG_P_CDC(TXT,...)                  TU_LOG_CDC(TXT, p_cdc->daddr, p_cdc->bInterfaceNumber, \
                                                           serial_drivers[p_cdc->serial_drid].name, ##__VA_ARGS__)
-#define TU_LOG_RESULT(TXT,RESULT)              TU_LOG_P_CDC(TXT " " #RESULT " = %s", RESULT ? "true" : "FALSE" )
+#define TU_LOG_P_CDC_BOOL(TXT,VAL)             TU_LOG_P_CDC(TXT " " #VAL " = %s", VAL ? "true" : "false" )
 
 #define TU_ASSERT_COMPLETE_DEFINE(_cond, _itf_offset)                                                \
   do {                                                                                               \
@@ -395,14 +395,20 @@ bool tuh_cdc_get_dtr(uint8_t idx) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
-  return (p_cdc->line_state & CDC_CONTROL_LINE_STATE_DTR) ? true : false;
+  bool ret = (p_cdc->line_state & CDC_CONTROL_LINE_STATE_DTR);
+//  TU_LOG_P_CDC_BOOL("get DTR", ret);
+
+  return ret;
 }
 
 bool tuh_cdc_get_rts(uint8_t idx) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
-  return (p_cdc->line_state & CDC_CONTROL_LINE_STATE_RTS) ? true : false;
+  bool ret = (p_cdc->line_state & CDC_CONTROL_LINE_STATE_RTS);
+//  TU_LOG_P_CDC_BOOL("get RTS", ret);
+
+  return ret;
 }
 
 bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t * line_coding) {
@@ -410,6 +416,10 @@ bool tuh_cdc_get_local_line_coding(uint8_t idx, cdc_line_coding_t * line_coding)
   TU_VERIFY(p_cdc);
 
   *line_coding = p_cdc->line_coding;
+  TU_LOG_P_CDC("get line coding %lu %u%c%s",
+               p_cdc->line_coding.bit_rate, p_cdc->line_coding.data_bits,
+               CDC_LINE_CODING_PARITY_CHAR(p_cdc->line_coding.parity),
+               CDC_LINE_CODING_STOP_BITS_TEXT(line_coding->stop_bits));
 
   return true;
 }
@@ -590,7 +600,7 @@ bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_c
   if (ret && !complete_cb) {
     p_cdc->line_state = (uint8_t) line_state;
   }
-  TU_LOG_RESULT("set control line state", ret);
+//  TU_LOG_P_CDC_BOOL("set control line state", ret);
 
   return ret;
 }
@@ -598,7 +608,7 @@ bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_c
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  TU_LOG_P_CDC("set baudrate = %lu", baudrate);
+  TU_LOG_P_CDC("set baudrate %lu", baudrate);
   cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
   p_cdc->requested_line_coding.bit_rate = baudrate;
@@ -608,7 +618,7 @@ bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete
   if (ret && !complete_cb) {
     p_cdc->line_coding.bit_rate = baudrate;
   }
-  TU_LOG_RESULT("set baudrate", ret);
+//  TU_LOG_P_CDC_BOOL("set baudrate", ret);
 
   return ret;
 }
@@ -617,8 +627,9 @@ bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uin
                              tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  TU_LOG_P_CDC("set data format data_bits = %u parity = %u stop_bits = %u (indexes!)",
-               data_bits, parity, stop_bits);
+  TU_LOG_P_CDC("set data format %u%c%s",
+               data_bits, CDC_LINE_CODING_PARITY_CHAR(parity),
+               CDC_LINE_CODING_STOP_BITS_TEXT(stop_bits));
   cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
   p_cdc->requested_line_coding.stop_bits = stop_bits;
@@ -632,7 +643,7 @@ bool tuh_cdc_set_data_format(uint8_t idx, uint8_t stop_bits, uint8_t parity, uin
     p_cdc->line_coding.parity    = parity;
     p_cdc->line_coding.data_bits = data_bits;
   }
-  TU_LOG_RESULT("set data format", ret);
+//  TU_LOG_P_CDC_BOOL("set data format", ret);
 
   return ret;
 }
@@ -641,8 +652,10 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const * line_coding,
                              tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  TU_LOG_P_CDC("set line coding baudrate = %lu data_bits = %u parity = %u stop_bits = %u (indexes!)",
-               line_coding->bit_rate, line_coding->data_bits, line_coding->parity, line_coding->stop_bits);
+  TU_LOG_P_CDC("set line coding %lu %u%c%s",
+               line_coding->bit_rate, line_coding->data_bits,
+               CDC_LINE_CODING_PARITY_CHAR(line_coding->parity),
+               CDC_LINE_CODING_STOP_BITS_TEXT(line_coding->stop_bits));
   cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
   p_cdc->requested_line_coding = *line_coding;
@@ -652,7 +665,7 @@ bool tuh_cdc_set_line_coding(uint8_t idx, cdc_line_coding_t const * line_coding,
   if (ret && !complete_cb) {
     p_cdc->line_coding = *line_coding;
   }
-  TU_LOG_RESULT("set line coding", ret);
+//  TU_LOG_P_CDC_BOOL("set line coding", ret);
 
   return ret;
 }
@@ -792,7 +805,7 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const * itf_
   if (driver_detected) {
     TU_LOG_CDC("open", daddr, itf_desc->bInterfaceNumber, driver_detected->name);
     bool ret = driver_detected->open(daddr, itf_desc, max_len);
-    TU_LOG_CDC("opened ret = %s", daddr, itf_desc->bInterfaceNumber, driver_detected->name, ret ? "true" : "FALSE" );
+//    TU_LOG_CDC("opened ret = %s", daddr, itf_desc->bInterfaceNumber, driver_detected->name, ret ? "true" : "FALSE" );
     return ret;
   }
 
@@ -802,7 +815,7 @@ bool cdch_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const * itf_
 static void set_config_complete(uint8_t idx, uint8_t itf_offset, bool success) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
-  TU_LOG_RESULT("set config complete", success);
+  TU_LOG_P_CDC_BOOL("set config complete", success);
 
   if (success) {
     p_cdc->mounted = true;
@@ -854,7 +867,7 @@ static void acm_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_RESULT("  control complete", success);
+  TU_LOG_P_CDC_BOOL("control complete", success);
 
   if (success) {
     switch (xfer->setup->bRequest) {
@@ -1138,7 +1151,7 @@ static void ftdi_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_RESULT("  control complete", success);
+  TU_LOG_P_CDC_BOOL("control complete", success);
 
   if (success) {
     if (xfer->setup->bRequest      == FTDI_SIO_SET_MODEM_CTRL_REQUEST &&
@@ -1414,7 +1427,7 @@ static bool ftdi_determine_type(cdch_interface_t * p_cdc)
       break;
   }
 
-  TU_LOG_P_CDC("  %s detected (bcdDevice = 0x%04x)",
+  TU_LOG_P_CDC("%s detected (bcdDevice = 0x%04x)",
                ftdi_chip_name[p_cdc->ftdi.chip_type], desc_dev->bcdDevice);
 
   return (p_cdc->ftdi.chip_type != UNKNOWN);
@@ -1562,7 +1575,7 @@ static inline uint32_t ftdi_get_divisor(cdch_interface_t * p_cdc)
       break;
   }
 
-  TU_LOG_P_CDC("  Baudrate divisor 0x%lu", div_value);
+  TU_LOG_P_CDC("Baudrate divisor = 0x%lu", div_value);
 
   return div_value;
 }
@@ -1671,7 +1684,7 @@ static void cp210x_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_RESULT("  control complete", success);
+  TU_LOG_P_CDC_BOOL("control complete", success);
 
   if (success) {
     switch(xfer->setup->bRequest) {
@@ -1928,7 +1941,7 @@ static void ch34x_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_RESULT("  control complete", success);
+  TU_LOG_P_CDC_BOOL("control complete", success);
 
   if (success) {
     switch (xfer->setup->bRequest) {
@@ -2059,7 +2072,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
     case CONFIG_CH34X_SERIAL_INIT: {
       // handle version read data, set CH34x line coding (incl. baudrate)
       uint8_t const version = xfer->buffer[0];
-      TU_LOG_P_CDC("  Chip Version = %02x", version);
+      TU_LOG_P_CDC("Chip Version = 0x%02x", version);
       // only versions >= 0x30 are tested, below 0x30 seems having other programming
       // see drivers from WCH vendor, Linux kernel and FreeBSD
       TU_ASSERT_COMPLETE(version >= 0x30);
@@ -2346,7 +2359,7 @@ static void pl2303_internal_control_complete(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_ASSERT(p_cdc,);
   bool const success = (xfer->result == XFER_RESULT_SUCCESS);
-  TU_LOG_RESULT("  control complete", success);
+  TU_LOG_P_CDC_BOOL("control complete", success);
 
   if (success) {
     if (xfer->setup->bRequest == PL2303_SET_LINE_REQUEST &&
@@ -2489,12 +2502,12 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
       p_cdc->pl2303.serial_private.type = &pl2303_type_data[type];
       p_cdc->pl2303.serial_private.quirks |= p_cdc->pl2303.serial_private.type->quirks;
       #if CFG_TUSB_DEBUG >= CFG_TUH_CDC_LOG_LEVEL && 0 // can be activated if necessary
-        TU_LOG_P_CDC("  bDeviceClass = 0x%02x bMaxPacketSize0 = %u bcdUSB = 0x%04x bcdDevice = 0x%04x",
+        TU_LOG_P_CDC("bDeviceClass = 0x%02x bMaxPacketSize0 = %u bcdUSB = 0x%04x bcdDevice = 0x%04x",
                      desc_dev->bDeviceClass, desc_dev->bMaxPacketSize0,
                      desc_dev->bcdUSB, desc_dev->bcdDevice );
         uint16_t vid, pid;
         TU_ASSERT_COMPLETE(tuh_vid_pid_get(p_cdc->daddr, &vid, &pid));
-        TU_LOG_P_CDC("  vid = 0x%04x pid = 0x%04x supports_hx_status = %u type = %s quirks = %u",
+        TU_LOG_P_CDC("vid = 0x%04x pid = 0x%04x supports_hx_status = %u type = %s quirks = %u",
                      vid, pid, p_cdc->pl2303.supports_hx_status,
                      p_cdc->pl2303.serial_private.type->name, p_cdc->pl2303.serial_private.quirks);
       #endif
@@ -2753,7 +2766,7 @@ static int8_t pl2303_detect_type(cdch_interface_t * p_cdc, uint8_t step,
     default: break;
   }
 
-  TU_LOG_P_CDC("  unknown device type bcdUSB = 0x%04x", desc_dev->bcdUSB);
+  TU_LOG_P_CDC("unknown device type bcdUSB = 0x%04x", desc_dev->bcdUSB);
 
   return PL2303_DETECT_TYPE_FAILED;
 }
@@ -2903,7 +2916,7 @@ static bool pl2303_encode_baud_rate(cdch_interface_t * p_cdc, uint8_t buf[PL2303
   } else {
     baud = pl2303_encode_baud_rate_divisor(buf, baud);
   }
-  TU_LOG_P_CDC("  real baudrate = %lu", baud);
+  TU_LOG_P_CDC("real baudrate %lu", baud);
 
   return true;
 }

From e6d27b6d3e8fc928cc00ab08898243c7e037ba35 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 29 Feb 2024 20:19:35 +0100
Subject: [PATCH 25/37] fixed IAR compile error

---
 src/class/cdc/cdc_host.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index d2bc63d646..dfe078de4f 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -113,7 +113,6 @@ CFG_TUH_MEM_SECTION
 static cdch_interface_t cdch_data[CFG_TUH_CDC];
 
 #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_PL2303
-  CFG_TUH_MEM_SECTION CFG_TUH_MEM_ALIGN
   static tusb_desc_device_t desc_dev[CFG_TUH_ENUMERATION_BUFSIZE];
 #endif
 

From dea27d28bceeaaa23d3daa6468373cb536390108 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 29 Feb 2024 20:24:13 +0100
Subject: [PATCH 26/37] added explicite (uint16_t) casts inside tu_htole16()

---
 src/class/cdc/cdc_host.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index dfe078de4f..d71cda1242 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -932,8 +932,8 @@ static bool acm_set_line_coding(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete
     },
     .bRequest = CDC_REQUEST_SET_LINE_CODING,
     .wValue   = 0,
-    .wIndex   = tu_htole16(p_cdc->bInterfaceNumber),
-    .wLength  = tu_htole16(sizeof(cdc_line_coding_t))
+    .wIndex   = tu_htole16((uint16_t) p_cdc->bInterfaceNumber),
+    .wLength  = tu_htole16((uint16_t) sizeof(cdc_line_coding_t))
   };
 
   // use usbh enum buf to hold line coding since user line_coding variable does not live long enough
@@ -1612,7 +1612,7 @@ static bool cp210x_set_request(cdch_interface_t * p_cdc, uint8_t command, uint16
     },
     .bRequest = command,
     .wValue   = tu_htole16(value),
-    .wIndex   = tu_htole16(p_cdc->bInterfaceNumber),
+    .wIndex   = tu_htole16((uint16_t) p_cdc->bInterfaceNumber),
     .wLength  = tu_htole16(length)
   };
 
@@ -1852,9 +1852,9 @@ static bool ch34x_set_request(cdch_interface_t * p_cdc, uint8_t direction, uint8
           .direction = direction & 0x01u
       },
       .bRequest = request,
-      .wValue   = tu_htole16 (value),
-      .wIndex   = tu_htole16 (index),
-      .wLength  = tu_htole16 (length)
+      .wValue   = tu_htole16(value),
+      .wIndex   = tu_htole16(index),
+      .wLength  = tu_htole16(length)
   };
 
   // use usbh enum buf since application variable does not live long enough
@@ -2232,9 +2232,9 @@ static bool pl2303_set_request(cdch_interface_t * p_cdc, uint8_t request, uint8_
   tusb_control_request_t const request_setup = {
     .bmRequestType = requesttype,
     .bRequest      = request,
-    .wValue        = tu_htole16 (value),
-    .wIndex        = tu_htole16 (index),
-    .wLength       = tu_htole16 (length)
+    .wValue        = tu_htole16(value),
+    .wIndex        = tu_htole16(index),
+    .wLength       = tu_htole16(length)
   };
 
   // use usbh enum buf since application variable does not live long enough

From e0551043ca8a6b3be92fed57f5e34d6d8014406b Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sun, 3 Mar 2024 13:02:58 +0100
Subject: [PATCH 27/37] added use of cdc_line_control_state_t type in CDCh

---
 src/class/cdc/cdc.h        | 14 +++++++-----
 src/class/cdc/cdc_device.c |  2 ++
 src/class/cdc/cdc_host.c   | 45 ++++++++++++++++----------------------
 3 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/src/class/cdc/cdc.h b/src/class/cdc/cdc.h
index b1dca1ad82..10aed79abf 100644
--- a/src/class/cdc/cdc.h
+++ b/src/class/cdc/cdc.h
@@ -414,15 +414,17 @@ typedef struct TU_ATTR_PACKED
 
 TU_VERIFY_STATIC(sizeof(cdc_line_coding_t) == 7, "size is not correct");
 
-typedef struct TU_ATTR_PACKED
+typedef union TU_ATTR_PACKED
 {
-  uint16_t dtr : 1;
-  uint16_t rts : 1;
-  uint16_t : 6;
-  uint16_t : 8;
+  struct {
+  uint8_t dtr : 1;
+  uint8_t rts : 1;
+  uint8_t     : 6;
+  };
+  uint8_t all;
 } cdc_line_control_state_t;
 
-TU_VERIFY_STATIC(sizeof(cdc_line_control_state_t) == 2, "size is not correct");
+TU_VERIFY_STATIC(sizeof(cdc_line_control_state_t) == 1, "size is not correct");
 
 TU_ATTR_PACKED_END  // End of all packed definitions
 TU_ATTR_BIT_FIELD_ORDER_END
diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index c26264e60d..9f51a6d4b4 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -56,6 +56,7 @@ typedef struct
   uint8_t ep_out;
 
   // Bit 0:  DTR (Data Terminal Ready), Bit 1: RTS (Request to Send)
+  // TODO use cdc_line_control_state_t instead of uint8_t
   uint8_t line_state;
 
   /*------------- From this point, data is not cleared by bus reset -------------*/
@@ -124,6 +125,7 @@ bool tud_cdc_n_connected(uint8_t itf)
 }
 
 uint8_t tud_cdc_n_get_line_state (uint8_t itf)
+// TODO use cdc_line_control_state_t instead of uint8_t
 {
   return _cdcd_itf[itf].line_state;
 }
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index d71cda1242..a3407a5f95 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -81,8 +81,8 @@ typedef struct {
   TU_ATTR_ALIGNED(4) cdc_line_coding_t requested_line_coding;
   // 1 byte padding
 
-  uint8_t line_state;                               // DTR (bit0), RTS (bit1)
-  uint8_t requested_line_state;
+  cdc_line_control_state_t line_state;
+  cdc_line_control_state_t requested_line_state;
 
   tuh_xfer_cb_t user_control_cb;
   #if CFG_TUH_CDC_FTDI || CFG_TUH_CDC_CP210X || CFG_TUH_CDC_CH34X
@@ -339,7 +339,7 @@ static cdch_interface_t * make_new_itf(uint8_t daddr, tusb_desc_interface_t cons
       p_cdc->bInterfaceSubClass = itf_desc->bInterfaceSubClass;
       p_cdc->bInterfaceProtocol = itf_desc->bInterfaceProtocol;
       p_cdc->line_coding        = (cdc_line_coding_t) { 0, 0, 0, 0 };
-      p_cdc->line_state         = 0;
+      p_cdc->line_state.all     = 0;
       return p_cdc;
     }
   }
@@ -394,7 +394,7 @@ bool tuh_cdc_get_dtr(uint8_t idx) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
-  bool ret = (p_cdc->line_state & CDC_CONTROL_LINE_STATE_DTR);
+  bool ret = p_cdc->line_state.dtr;
 //  TU_LOG_P_CDC_BOOL("get DTR", ret);
 
   return ret;
@@ -404,7 +404,7 @@ bool tuh_cdc_get_rts(uint8_t idx) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc);
 
-  bool ret = (p_cdc->line_state & CDC_CONTROL_LINE_STATE_RTS);
+  bool ret = p_cdc->line_state.rts;
 //  TU_LOG_P_CDC_BOOL("get RTS", ret);
 
   return ret;
@@ -592,12 +592,12 @@ bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_c
   TU_LOG_P_CDC("set control line state line_state = %u", line_state);
   cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
-  p_cdc->requested_line_state = (uint8_t) line_state;
+  p_cdc->requested_line_state.all = (uint8_t) line_state;
 
   bool ret = set_function_call(p_cdc, driver->set_control_line_state, complete_cb, user_data);
 
   if (ret && !complete_cb) {
-    p_cdc->line_state = (uint8_t) line_state;
+    p_cdc->line_state.all = (uint8_t) line_state;
   }
 //  TU_LOG_P_CDC_BOOL("set control line state", ret);
 
@@ -898,7 +898,7 @@ static bool acm_set_control_line_state(cdch_interface_t * p_cdc, tuh_xfer_cb_t c
       .direction = TUSB_DIR_OUT
     },
     .bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE,
-    .wValue   = tu_htole16(p_cdc->requested_line_state),
+    .wValue   = tu_htole16((uint16_t) p_cdc->requested_line_state.all),
     .wIndex   = tu_htole16((uint16_t) p_cdc->bInterfaceNumber),
     .wLength  = 0
   };
@@ -1034,7 +1034,7 @@ static void acm_process_config(tuh_xfer_t * xfer) {
     case CONFIG_ACM_SET_CONTROL_LINE_STATE:
       #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
         if (p_cdc->acm_capability.support_line_request) {
-          p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+          p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
           TU_ASSERT_COMPLETE(acm_set_control_line_state(p_cdc, acm_process_config, CONFIG_ACM_SET_LINE_CODING), 1);
           break;
         }
@@ -1139,7 +1139,7 @@ static bool ftdi_set_data_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t comple
 static inline bool ftdi_update_mctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   // FTDI has the same bit coding
   return ftdi_set_request(p_cdc, FTDI_SIO_SET_MODEM_CTRL_REQUEST, FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
-                          p_cdc->requested_line_state, p_cdc->ftdi.channel, complete_cb, user_data);
+                          p_cdc->requested_line_state.all, p_cdc->ftdi.channel, complete_cb, user_data);
 }
 
 //------------- Driver API -------------//
@@ -1328,7 +1328,7 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
 
     case CONFIG_FTDI_MODEM_CTRL:
       #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(ftdi_update_mctrl(p_cdc, ftdi_internal_control_complete, CONFIG_FTDI_COMPLETE));
         break;
       #else
@@ -1670,7 +1670,7 @@ static inline bool cp210x_set_mhs(cdch_interface_t * p_cdc, tuh_xfer_cb_t comple
   // CP210x has the same bit coding
   return cp210x_set_request(p_cdc, CP210X_SET_MHS,
                             (uint16_t) ((uint32_t) CP210X_CONTROL_WRITE_DTR |
-                                        (uint32_t) CP210X_CONTROL_WRITE_RTS | p_cdc->requested_line_state),
+                                        (uint32_t) CP210X_CONTROL_WRITE_RTS | p_cdc->requested_line_state.all),
                             NULL, 0, complete_cb, user_data);
 }
 
@@ -1811,7 +1811,7 @@ static void cp210x_process_config(tuh_xfer_t * xfer) {
 
     case CONFIG_CP210X_SET_DTR_RTS:
       #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(cp210x_set_mhs(p_cdc, cp210x_internal_control_complete,
                                           CONFIG_CP210X_COMPLETE));
         break;
@@ -1916,16 +1916,8 @@ static bool ch34x_write_reg_baudrate(cdch_interface_t * p_cdc, tuh_xfer_cb_t com
 }
 
 static bool ch34x_modem_ctrl_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint8_t control = 0;
-  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_RTS) {
-    control |= CH34X_BIT_RTS;
-  }
-  if (p_cdc->requested_line_state & CDC_CONTROL_LINE_STATE_DTR) {
-    control |= CH34X_BIT_DTR;
-  }
-
-  // CH34x signals are inverted
-  control = ~control;
+  uint8_t control = ~((p_cdc->requested_line_state.rts ? CH34X_BIT_RTS : 0) | // CH34x signals are inverted
+                      (p_cdc->requested_line_state.dtr ? CH34X_BIT_DTR : 0));
 
   return ch34x_control_out(p_cdc, CH34X_REQ_MODEM_CTRL, control, 0, complete_cb, user_data);
 }
@@ -2101,7 +2093,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
 
     case CONFIG_CH34X_MODEM_CONTROL:
       #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(ch34x_modem_ctrl_request(p_cdc, ch34x_internal_control_complete,
                                                     CONFIG_CH34X_COMPLETE));
         break;
@@ -2287,8 +2279,9 @@ static inline bool pl2303_supports_hx_status(cdch_interface_t * p_cdc, tuh_xfer_
 
 static inline bool pl2303_set_control_lines(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data)
 {
+  // PL2303 has the same bit coding
   return pl2303_set_request(p_cdc, PL2303_SET_CONTROL_REQUEST, PL2303_SET_CONTROL_REQUEST_TYPE,
-                            p_cdc->requested_line_state, 0, NULL, 0, complete_cb, user_data);
+                            p_cdc->requested_line_state.all, 0, NULL, 0, complete_cb, user_data);
 }
 
 //static bool pl2303_get_line_request(cdch_interface_t * p_cdc, uint8_t buf[PL2303_LINE_CODING_BUFSIZE])
@@ -2645,7 +2638,7 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
 
     case CONFIG_PL2303_MODEM_CONTROL:
       #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(pl2303_set_control_lines(p_cdc, pl2303_internal_control_complete, CONFIG_PL2303_FLOW_CTRL_READ));
         break;
       #else

From a9cc07fc83599fab4d9576e6f5b793bc1bf2bf35 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sun, 10 Mar 2024 08:20:12 +0100
Subject: [PATCH 28/37] added line control function using
 cdc_line_control_state_t

---
 src/class/cdc/cdc_host.c | 35 ++++++++++++++++++++++++++++++-----
 src/class/cdc/cdc_host.h | 10 ++++++++--
 2 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index a3407a5f95..86b874b1e5 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -50,8 +50,9 @@
                                                           DADDR, ITF_NUM, NAME, ##__VA_ARGS__)
 #define TU_LOG_P_CDC(TXT,...)                  TU_LOG_CDC(TXT, p_cdc->daddr, p_cdc->bInterfaceNumber, \
                                                           serial_drivers[p_cdc->serial_drid].name, ##__VA_ARGS__)
-#define TU_LOG_P_CDC_BOOL(TXT,VAL)             TU_LOG_P_CDC(TXT " " #VAL " = %s", VAL ? "true" : "false" )
+#define TU_LOG_P_CDC_BOOL(TXT,VAL)             TU_LOG_P_CDC(TXT " " #VAL " = %d", VAL)
 
+// assert and set config complete
 #define TU_ASSERT_COMPLETE_DEFINE(_cond, _itf_offset)                                                \
   do {                                                                                               \
     if (!(_cond)) { _MESS_FAILED(); TU_BREAKPOINT(); set_config_complete(idx, _itf_offset, false); } \
@@ -586,24 +587,48 @@ static bool set_function_call (
   }
 }
 
-bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+bool tuh_cdc_set_control_line_state_u(uint8_t idx, cdc_line_control_state_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // uses cdc_line_control_state_t union for line_state
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
-  TU_LOG_P_CDC("set control line state line_state = %u", line_state);
+  TU_LOG_P_CDC("set control line state dtr = %u rts = %u", line_state.dtr, line_state.rts );
   cdch_serial_driver_t const * driver = &serial_drivers[p_cdc->serial_drid];
 
-  p_cdc->requested_line_state.all = (uint8_t) line_state;
+  p_cdc->requested_line_state = line_state;
 
   bool ret = set_function_call(p_cdc, driver->set_control_line_state, complete_cb, user_data);
 
   if (ret && !complete_cb) {
-    p_cdc->line_state.all = (uint8_t) line_state;
+    p_cdc->line_state = line_state;
   }
 //  TU_LOG_P_CDC_BOOL("set control line state", ret);
 
   return ret;
 }
 
+bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  // uses uint16_t for line_state => DTR (bit 0), RTS (bit 1)
+
+  return tuh_cdc_set_control_line_state_u(idx, (cdc_line_control_state_t) { .all = (uint8_t) line_state },
+                                          complete_cb, user_data);
+}
+
+bool tuh_cdc_set_dtr(uint8_t idx, bool dtr_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  cdc_line_control_state_t const line_state = { .dtr = dtr_state, .rts = p_cdc->line_state.rts };
+
+  return tuh_cdc_set_control_line_state_u(idx, line_state, complete_cb, user_data);
+}
+
+bool tuh_cdc_set_rts(uint8_t idx, bool rts_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
+  cdch_interface_t * p_cdc = get_itf(idx);
+  TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
+  cdc_line_control_state_t const line_state = { .rts = rts_state, .dtr = p_cdc->line_state.dtr };
+
+  return tuh_cdc_set_control_line_state_u(idx, line_state, complete_cb, user_data);
+}
+
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   cdch_interface_t * p_cdc = get_itf(idx);
   TU_VERIFY(p_cdc && p_cdc->serial_drid < SERIAL_DRIVER_COUNT);
diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index ca65674533..77081d3b03 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -132,8 +132,14 @@ bool tuh_cdc_read_clear (uint8_t idx);
 //   - The function will return true if transfer is successful, false otherwise.
 //--------------------------------------------------------------------+
 
-// Request to Set Control Line State: DTR (bit 0), RTS (bit 1)
-bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+// Request to Set Control Line State
+bool tuh_cdc_set_control_line_state_u(uint8_t idx, cdc_line_control_state_t line_state, // uses cdc_line_control_state_t union for line_state
+                                      tuh_xfer_cb_t complete_cb, uintptr_t user_data);
+bool tuh_cdc_set_control_line_state(uint8_t idx, uint16_t line_state,                   // uses uint16_t for line_state (legacy function)
+                                    tuh_xfer_cb_t complete_cb, uintptr_t user_data);    // DTR (bit 0), RTS (bit 1)
+
+bool tuh_cdc_set_dtr(uint8_t idx, bool dtr_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data); // Request to Set DTR
+bool tuh_cdc_set_rts(uint8_t idx, bool rts_state, tuh_xfer_cb_t complete_cb, uintptr_t user_data); // Request to Set RTS
 
 // Request to set baudrate
 bool tuh_cdc_set_baudrate(uint8_t idx, uint32_t baudrate, tuh_xfer_cb_t complete_cb, uintptr_t user_data);

From ee92e582b38e36df53381f8c98a0be54c2caef3e Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sun, 3 Mar 2024 13:12:10 +0100
Subject: [PATCH 29/37] added defines CFG_TUH_CDC_DTR_CONTROL_ON_ENUM &
 CFG_TUH_CDC_RTS_CONTROL_ON_ENUM

---
 examples/host/cdc_msc_hid/src/tusb_config.h   |  4 +-
 .../cdc_msc_hid_freertos/src/tusb_config.h    |  4 +-
 src/class/cdc/cdc_host.c                      | 40 ++++++++++++++-----
 3 files changed, 34 insertions(+), 14 deletions(-)

diff --git a/examples/host/cdc_msc_hid/src/tusb_config.h b/examples/host/cdc_msc_hid/src/tusb_config.h
index fc956c6d3f..32a29bd4f1 100644
--- a/examples/host/cdc_msc_hid/src/tusb_config.h
+++ b/examples/host/cdc_msc_hid/src/tusb_config.h
@@ -121,8 +121,8 @@
 //------------- CDC -------------//
 
 // Set Line Control state on enumeration/mounted:
-// DTR ( bit 0), RTS (bit 1)
-#define CFG_TUH_CDC_LINE_CONTROL_ON_ENUM    0x03
+#define CFG_TUH_CDC_DTR_CONTROL_ON_ENUM true
+#define CFG_TUH_CDC_RTS_CONTROL_ON_ENUM true
 
 // Set Line Coding on enumeration/mounted, value for cdc_line_coding_t
 // bit rate = 115200, 1 stop bit, no parity, 8 bit data width
diff --git a/examples/host/cdc_msc_hid_freertos/src/tusb_config.h b/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
index dd732c700e..88b341e957 100644
--- a/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
+++ b/examples/host/cdc_msc_hid_freertos/src/tusb_config.h
@@ -126,8 +126,8 @@
 //------------- CDC -------------//
 
 // Set Line Control state on enumeration/mounted:
-// DTR ( bit 0), RTS (bit 1)
-#define CFG_TUH_CDC_LINE_CONTROL_ON_ENUM    0x03
+#define CFG_TUH_CDC_DTR_CONTROL_ON_ENUM true
+#define CFG_TUH_CDC_RTS_CONTROL_ON_ENUM true
 
 // Set Line Coding on enumeration/mounted, value for cdc_line_coding_t
 // bit rate = 115200, 1 stop bit, no parity, 8 bit data width
diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 86b874b1e5..5b74d031da 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -63,6 +63,26 @@
 
 #define TU_ASSERT_COMPLETE(...) _GET_3RD_ARG(__VA_ARGS__, TU_ASSERT_COMPLETE_2ARGS, TU_ASSERT_COMPLETE_1ARGS, _dummy)(__VA_ARGS__)
 
+// handle line control defines
+#if defined(CFG_TUH_CDC_LINE_CONTROL_ON_ENUM) && \
+    (defined(CFG_TUH_CDC_DTR_CONTROL_ON_ENUM) || defined(CFG_TUH_CDC_RTS_CONTROL_ON_ENUM))
+  TU_VERIFY_STATIC(false, "Contradictory line control defines");
+#endif
+
+#ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+  #define LINE_CONTROL_ON_ENUM CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+#elif defined(CFG_TUH_CDC_DTR_CONTROL_ON_ENUM) || defined(CFG_TUH_CDC_RTS_CONTROL_ON_ENUM)
+  #ifndef CFG_TUH_CDC_DTR_CONTROL_ON_ENUM
+    #define CFG_TUH_CDC_DTR_CONTROL_ON_ENUM 0
+  #endif
+  #ifndef CFG_TUH_CDC_RTS_CONTROL_ON_ENUM
+    #define CFG_TUH_CDC_RTS_CONTROL_ON_ENUM 0
+  #endif
+  #define LINE_CONTROL_ON_ENUM ( ( CFG_TUH_CDC_DTR_CONTROL_ON_ENUM ? CDC_CONTROL_LINE_STATE_DTR : 0 ) | \
+                                 ( CFG_TUH_CDC_RTS_CONTROL_ON_ENUM ? CDC_CONTROL_LINE_STATE_RTS : 0 ) )
+#endif
+
+
 //--------------------------------------------------------------------+
 // Host CDC Interface
 //--------------------------------------------------------------------+
@@ -1057,9 +1077,9 @@ static void acm_process_config(tuh_xfer_t * xfer) {
 
   switch (state) {
     case CONFIG_ACM_SET_CONTROL_LINE_STATE:
-      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
+      #ifdef LINE_CONTROL_ON_ENUM
         if (p_cdc->acm_capability.support_line_request) {
-          p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+          p_cdc->requested_line_state.all = LINE_CONTROL_ON_ENUM;
           TU_ASSERT_COMPLETE(acm_set_control_line_state(p_cdc, acm_process_config, CONFIG_ACM_SET_LINE_CODING), 1);
           break;
         }
@@ -1352,8 +1372,8 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
       break;
 
     case CONFIG_FTDI_MODEM_CTRL:
-      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+      #ifdef LINE_CONTROL_ON_ENUM
+        p_cdc->requested_line_state.all = LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(ftdi_update_mctrl(p_cdc, ftdi_internal_control_complete, CONFIG_FTDI_COMPLETE));
         break;
       #else
@@ -1835,8 +1855,8 @@ static void cp210x_process_config(tuh_xfer_t * xfer) {
       #endif
 
     case CONFIG_CP210X_SET_DTR_RTS:
-      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+      #ifdef LINE_CONTROL_ON_ENUM
+        p_cdc->requested_line_state.all = LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(cp210x_set_mhs(p_cdc, cp210x_internal_control_complete,
                                           CONFIG_CP210X_COMPLETE));
         break;
@@ -2117,8 +2137,8 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
       break;
 
     case CONFIG_CH34X_MODEM_CONTROL:
-      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+      #ifdef LINE_CONTROL_ON_ENUM
+        p_cdc->requested_line_state.all = LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(ch34x_modem_ctrl_request(p_cdc, ch34x_internal_control_complete,
                                                     CONFIG_CH34X_COMPLETE));
         break;
@@ -2662,8 +2682,8 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
       #endif
 
     case CONFIG_PL2303_MODEM_CONTROL:
-      #ifdef CFG_TUH_CDC_LINE_CONTROL_ON_ENUM
-        p_cdc->requested_line_state.all = CFG_TUH_CDC_LINE_CONTROL_ON_ENUM;
+      #ifdef LINE_CONTROL_ON_ENUM
+        p_cdc->requested_line_state.all = LINE_CONTROL_ON_ENUM;
         TU_ASSERT_COMPLETE(pl2303_set_control_lines(p_cdc, pl2303_internal_control_complete, CONFIG_PL2303_FLOW_CTRL_READ));
         break;
       #else

From 2786a61e8b9811b1065cf1f36502eb4744e9d772 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Sun, 3 Mar 2024 13:25:04 +0100
Subject: [PATCH 30/37] fixed FTDI set control line

---
 src/class/cdc/cdc_host.c | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 5b74d031da..6121e59f04 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -82,7 +82,6 @@
                                  ( CFG_TUH_CDC_RTS_CONTROL_ON_ENUM ? CDC_CONTROL_LINE_STATE_RTS : 0 ) )
 #endif
 
-
 //--------------------------------------------------------------------+
 // Host CDC Interface
 //--------------------------------------------------------------------+
@@ -1172,19 +1171,21 @@ static bool ftdi_change_speed(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_c
 static bool ftdi_set_data_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 7 && p_cdc->requested_line_coding.data_bits <= 8, 0);
   uint16_t value = (uint16_t) (
-    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xf)       |  // data bit quantity is stored in bits 0-3
-    ((uint32_t) p_cdc->requested_line_coding.parity    & 0x7) <<  8 |  // parity is stored in bits 8-10, same coding
-    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0x3) << 11 ); // stop bits quantity is stored in bits 11-12, same coding
-                                                                       // not each FTDI supports 1.5 stop bits
+    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xfu)       |  // data bit quantity is stored in bits 0-3
+    ((uint32_t) p_cdc->requested_line_coding.parity    & 0x7u) <<  8 |  // parity is stored in bits 8-10, same coding
+    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0x3u) << 11 ); // stop bits quantity is stored in bits 11-12, same coding
+                                                                        // not each FTDI supports 1.5 stop bits
 
   return ftdi_set_request(p_cdc, FTDI_SIO_SET_DATA_REQUEST, FTDI_SIO_SET_DATA_REQUEST_TYPE,
                           value, p_cdc->ftdi.channel, complete_cb, user_data);
 }
 
 static inline bool ftdi_update_mctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  // FTDI has the same bit coding
+  uint16_t value = (uint16_t) ((p_cdc->requested_line_state.dtr ? (uint32_t) FTDI_SIO_SET_DTR_HIGH : (uint32_t) FTDI_SIO_SET_DTR_LOW) |
+                               (p_cdc->requested_line_state.rts ? (uint32_t) FTDI_SIO_SET_RTS_HIGH : (uint32_t) FTDI_SIO_SET_RTS_LOW));
+
   return ftdi_set_request(p_cdc, FTDI_SIO_SET_MODEM_CTRL_REQUEST, FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
-                          p_cdc->requested_line_state.all, p_cdc->ftdi.channel, complete_cb, user_data);
+                          value, p_cdc->ftdi.channel, complete_cb, user_data);
 }
 
 //------------- Driver API -------------//
@@ -1704,9 +1705,9 @@ static bool cp210x_set_baudrate_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t
 static bool cp210x_set_line_ctl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 9, 0);
   uint16_t lcr = (uint16_t) (
-    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xf) << 8 | // data bit quantity is stored in bits 8-11
-    ((uint32_t) p_cdc->requested_line_coding.parity    & 0xf) << 4 | // parity is stored in bits 4-7, same coding
-    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0xf));     // parity is stored in bits 0-3, same coding
+    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xfu) << 8 | // data bit quantity is stored in bits 8-11
+    ((uint32_t) p_cdc->requested_line_coding.parity    & 0xfu) << 4 | // parity is stored in bits 4-7, same coding
+    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0xfu));      // parity is stored in bits 0-3, same coding
 
   return cp210x_set_request(p_cdc, CP210X_SET_LINE_CTL, lcr, NULL, 0, complete_cb, user_data);
 }

From cb69ed0d0423b8e09ae77307fcc01165ae4c9386 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 21 Mar 2024 08:29:28 +0100
Subject: [PATCH 31/37] code style and clean up CDC serial header files

---
 src/class/cdc/serial/ch34x.h    |  70 ++++++-------
 src/class/cdc/serial/cp210x.h   |  86 ++++++++--------
 src/class/cdc/serial/ftdi_sio.h | 172 ++++++++++++++++----------------
 src/class/cdc/serial/pl2303.h   | 146 +++++++++++++--------------
 4 files changed, 237 insertions(+), 237 deletions(-)

diff --git a/src/class/cdc/serial/ch34x.h b/src/class/cdc/serial/ch34x.h
index c18066f578..7d91f01fe2 100644
--- a/src/class/cdc/serial/ch34x.h
+++ b/src/class/cdc/serial/ch34x.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _CH34X_H_
-#define _CH34X_H_
+#ifndef TUSB_CH34X_H
+#define TUSB_CH34X_H
 
 // There is no official documentation for the CH34x (CH340, CH341) chips. Reference can be found
 // - https://github.com/WCHSoftGroup/ch341ser_linux
@@ -40,45 +40,45 @@
 #endif
 
 // USB requests
-#define CH34X_REQ_READ_VERSION 0x5F // dec  95
-#define CH34X_REQ_WRITE_REG    0x9A // dec 154
-#define CH34X_REQ_READ_REG     0x95 // dec 149
-#define CH34X_REQ_SERIAL_INIT  0xA1 // dec 161
-#define CH34X_REQ_MODEM_CTRL   0xA4 // dev 164
+#define CH34X_REQ_READ_VERSION        0x5F // dec  95
+#define CH34X_REQ_WRITE_REG           0x9A // dec 154
+#define CH34X_REQ_READ_REG            0x95 // dec 149
+#define CH34X_REQ_SERIAL_INIT         0xA1 // dec 161
+#define CH34X_REQ_MODEM_CTRL          0xA4 // dev 164
 
 // registers
-#define CH34X_REG_BREAK        0x05
-#define CH34X_REG_PRESCALER    0x12
-#define CH34X_REG_DIVISOR      0x13
-#define CH34X_REG_LCR          0x18
-#define CH34X_REG_LCR2         0x25
-#define CH34X_REG_MCR_MSR      0x06
-#define CH34X_REG_MCR_MSR2     0x07
-#define CH34X_NBREAK_BITS      0x01
+#define CH34X_REG_BREAK               0x05
+#define CH34X_REG_PRESCALER           0x12
+#define CH34X_REG_DIVISOR             0x13
+#define CH34X_REG_LCR                 0x18
+#define CH34X_REG_LCR2                0x25
+#define CH34X_REG_MCR_MSR             0x06
+#define CH34X_REG_MCR_MSR2            0x07
+#define CH34X_NBREAK_BITS             0x01
 
-#define CH341_REG_0x0F         0x0F // undocumented register
-#define CH341_REG_0x2C         0x2C // undocumented register
-#define CH341_REG_0x27         0x27 // hardware flow control (cts/rts)
+#define CH341_REG_0x0F                0x0F // undocumented register
+#define CH341_REG_0x2C                0x2C // undocumented register
+#define CH341_REG_0x27                0x27 // hardware flow control (cts/rts)
 
-#define CH34X_REG16_DIVISOR_PRESCALER  TU_U16(CH34X_REG_DIVISOR, CH34X_REG_PRESCALER)
-#define CH32X_REG16_LCR2_LCR           TU_U16(CH34X_REG_LCR2, CH34X_REG_LCR)
+#define CH34X_REG16_DIVISOR_PRESCALER TU_U16(CH34X_REG_DIVISOR, CH34X_REG_PRESCALER)
+#define CH32X_REG16_LCR2_LCR          TU_U16(CH34X_REG_LCR2, CH34X_REG_LCR)
 
 // modem control bits
-#define CH34X_BIT_RTS ( 1 << 6 )
-#define CH34X_BIT_DTR ( 1 << 5 )
+#define CH34X_BIT_RTS                 (1 << 6)
+#define CH34X_BIT_DTR                 (1 << 5)
 
 // line control bits
-#define CH34X_LCR_ENABLE_RX    0x80
-#define CH34X_LCR_ENABLE_TX    0x40
-#define CH34X_LCR_MARK_SPACE   0x20
-#define CH34X_LCR_PAR_EVEN     0x10
-#define CH34X_LCR_ENABLE_PAR   0x08
-#define CH34X_LCR_PAR_MASK     0x38 // all parity bits
-#define CH34X_LCR_STOP_BITS_2  0x04
-#define CH34X_LCR_CS8          0x03
-#define CH34X_LCR_CS7          0x02
-#define CH34X_LCR_CS6          0x01
-#define CH34X_LCR_CS5          0x00
-#define CH34X_LCR_CS_MASK      0x03 // all CSx bits
+#define CH34X_LCR_ENABLE_RX           0x80
+#define CH34X_LCR_ENABLE_TX           0x40
+#define CH34X_LCR_MARK_SPACE          0x20
+#define CH34X_LCR_PAR_EVEN            0x10
+#define CH34X_LCR_ENABLE_PAR          0x08
+#define CH34X_LCR_PAR_MASK            0x38 // all parity bits
+#define CH34X_LCR_STOP_BITS_2         0x04
+#define CH34X_LCR_CS8                 0x03
+#define CH34X_LCR_CS7                 0x02
+#define CH34X_LCR_CS6                 0x01
+#define CH34X_LCR_CS5                 0x00
+#define CH34X_LCR_CS_MASK             0x03 // all CSx bits
 
-#endif /* _CH34X_H_ */
+#endif // TUSB_CH34X_H
diff --git a/src/class/cdc/serial/cp210x.h b/src/class/cdc/serial/cp210x.h
index e18da7d510..a553a54da4 100644
--- a/src/class/cdc/serial/cp210x.h
+++ b/src/class/cdc/serial/cp210x.h
@@ -31,7 +31,7 @@
 // parts are overtaken from vendors driver
 // https://www.silabs.com/documents/public/software/cp210x-3.1.0.tar.gz
 
-/* Config request codes */
+// Config request codes
 #define CP210X_IFC_ENABLE      0x00
 #define CP210X_SET_BAUDDIV     0x01
 #define CP210X_GET_BAUDDIV     0x02
@@ -60,56 +60,56 @@
 #define CP210X_SET_BAUDRATE    0x1E
 #define CP210X_VENDOR_SPECIFIC 0xFF // GPIO, Recipient must be Device
 
-/* SILABSER_IFC_ENABLE_REQUEST_CODE */
-#define CP210X_UART_ENABLE       0x0001
-#define CP210X_UART_DISABLE        0x0000
+// SILABSER_IFC_ENABLE_REQUEST_CODE
+#define CP210X_UART_ENABLE              0x0001
+#define CP210X_UART_DISABLE             0x0000
 
-/* SILABSER_SET_BAUDDIV_REQUEST_CODE */
-#define CP210X_BAUD_RATE_GEN_FREQ      0x384000
+// SILABSER_SET_BAUDDIV_REQUEST_CODE
+#define CP210X_BAUD_RATE_GEN_FREQ     0x384000
 
-/*SILABSER_SET_LINE_CTL_REQUEST_CODE */
-#define CP210X_BITS_DATA_MASK        0x0f00
-#define CP210X_BITS_DATA_5       0x0500
-#define CP210X_BITS_DATA_6       0x0600
-#define CP210X_BITS_DATA_7       0x0700
-#define CP210X_BITS_DATA_8       0x0800
-#define CP210X_BITS_DATA_9       0x0900
+// SILABSER_SET_LINE_CTL_REQUEST_CODE
+#define CP210X_BITS_DATA_MASK           0x0f00
+#define CP210X_BITS_DATA_5              0x0500
+#define CP210X_BITS_DATA_6              0x0600
+#define CP210X_BITS_DATA_7              0x0700
+#define CP210X_BITS_DATA_8              0x0800
+#define CP210X_BITS_DATA_9              0x0900
 
-#define CP210X_BITS_PARITY_MASK      0x00f0
-#define CP210X_BITS_PARITY_NONE      0x0000
-#define CP210X_BITS_PARITY_ODD       0x0010
-#define CP210X_BITS_PARITY_EVEN      0x0020
-#define CP210X_BITS_PARITY_MARK      0x0030
-#define CP210X_BITS_PARITY_SPACE     0x0040
+#define CP210X_BITS_PARITY_MASK         0x00f0
+#define CP210X_BITS_PARITY_NONE         0x0000
+#define CP210X_BITS_PARITY_ODD          0x0010
+#define CP210X_BITS_PARITY_EVEN         0x0020
+#define CP210X_BITS_PARITY_MARK         0x0030
+#define CP210X_BITS_PARITY_SPACE        0x0040
 
-#define CP210X_BITS_STOP_MASK        0x000f
-#define CP210X_BITS_STOP_1       0x0000
-#define CP210X_BITS_STOP_1_5       0x0001
-#define CP210X_BITS_STOP_2       0x0002
+#define CP210X_BITS_STOP_MASK           0x000f
+#define CP210X_BITS_STOP_1              0x0000
+#define CP210X_BITS_STOP_1_5            0x0001
+#define CP210X_BITS_STOP_2              0x0002
 
-/* SILABSER_SET_BREAK_REQUEST_CODE */
-#define CP210X_BREAK_ON        0x0001
-#define CP210X_BREAK_OFF       0x0000
+// SILABSER_SET_BREAK_REQUEST_CODE
+#define CP210X_BREAK_ON                 0x0001
+#define CP210X_BREAK_OFF                0x0000
 
-/* SILABSER_SET_MHS_REQUEST_CODE */
-#define CP210X_MCR_DTR         0x0001
-#define CP210X_MCR_RTS         0x0002
-#define CP210X_MCR_ALL         0x0003
-#define CP210X_MSR_CTS         0x0010
-#define CP210X_MSR_DSR         0x0020
-#define CP210X_MSR_RING        0x0040
-#define CP210X_MSR_DCD         0x0080
-#define CP210X_MSR_ALL         0x00F0
+// SILABSER_SET_MHS_REQUEST_CODE
+#define CP210X_MCR_DTR                  0x0001
+#define CP210X_MCR_RTS                  0x0002
+#define CP210X_MCR_ALL                  0x0003
+#define CP210X_MSR_CTS                  0x0010
+#define CP210X_MSR_DSR                  0x0020
+#define CP210X_MSR_RING                 0x0040
+#define CP210X_MSR_DCD                  0x0080
+#define CP210X_MSR_ALL                  0x00F0
 
-#define CP210X_CONTROL_WRITE_DTR     0x0100
-#define CP210X_CONTROL_WRITE_RTS     0x0200
+#define CP210X_CONTROL_WRITE_DTR        0x0100
+#define CP210X_CONTROL_WRITE_RTS        0x0200
 
-#define CP210X_LSR_BREAK       0x0001
-#define CP210X_LSR_FRAMING_ERROR     0x0002
-#define CP210X_LSR_HW_OVERRUN        0x0004
-#define CP210X_LSR_QUEUE_OVERRUN     0x0008
-#define CP210X_LSR_PARITY_ERROR      0x0010
-#define CP210X_LSR_ALL         0x001F
+#define CP210X_LSR_BREAK                0x0001
+#define CP210X_LSR_FRAMING_ERROR        0x0002
+#define CP210X_LSR_HW_OVERRUN           0x0004
+#define CP210X_LSR_QUEUE_OVERRUN        0x0008
+#define CP210X_LSR_PARITY_ERROR         0x0010
+#define CP210X_LSR_ALL                  0x001F
 
 // supported baudrates
 // reference: datasheets and AN205 "CP210x Baud Rate Support"
diff --git a/src/class/cdc/serial/ftdi_sio.h b/src/class/cdc/serial/ftdi_sio.h
index 42716f73e2..4afedec9bf 100644
--- a/src/class/cdc/serial/ftdi_sio.h
+++ b/src/class/cdc/serial/ftdi_sio.h
@@ -28,43 +28,43 @@
 #include <stdint.h>
 
 // Commands
-#define FTDI_SIO_RESET              0 // Reset the port
-#define FTDI_SIO_MODEM_CTRL         1 // Set the modem control register
-#define FTDI_SIO_SET_FLOW_CTRL      2 // Set flow control register
-#define FTDI_SIO_SET_BAUD_RATE      3 // Set baud rate
-#define FTDI_SIO_SET_DATA           4 // Set the data characteristics of the port
-#define FTDI_SIO_GET_MODEM_STATUS   5 // Retrieve current value of modem status register
-#define FTDI_SIO_SET_EVENT_CHAR     6 // Set the event character
-#define FTDI_SIO_SET_ERROR_CHAR     7 // Set the error character
-#define FTDI_SIO_SET_LATENCY_TIMER  9 // Set the latency timer
-#define FTDI_SIO_GET_LATENCY_TIMER 10 // Get the latency timer
-#define FTDI_SIO_SET_BITMODE       11 // Set bitbang mode
-#define FTDI_SIO_READ_PINS         12 // Read immediate value of pins
-#define FTDI_SIO_READ_EEPROM     0x90 // Read EEPROM
+#define FTDI_SIO_RESET                0 // Reset the port
+#define FTDI_SIO_MODEM_CTRL           1 // Set the modem control register
+#define FTDI_SIO_SET_FLOW_CTRL        2 // Set flow control register
+#define FTDI_SIO_SET_BAUD_RATE        3 // Set baud rate
+#define FTDI_SIO_SET_DATA             4 // Set the data characteristics of the port
+#define FTDI_SIO_GET_MODEM_STATUS     5 // Retrieve current value of modem status register
+#define FTDI_SIO_SET_EVENT_CHAR       6 // Set the event character
+#define FTDI_SIO_SET_ERROR_CHAR       7 // Set the error character
+#define FTDI_SIO_SET_LATENCY_TIMER    9 // Set the latency timer
+#define FTDI_SIO_GET_LATENCY_TIMER   10 // Get the latency timer
+#define FTDI_SIO_SET_BITMODE         11 // Set bitbang mode
+#define FTDI_SIO_READ_PINS           12 // Read immediate value of pins
+#define FTDI_SIO_READ_EEPROM       0x90 // Read EEPROM
 
 // Channel indices for FT2232, FT2232H and FT4232H devices
-#define CHANNEL_A   1
-#define CHANNEL_B   2
-#define CHANNEL_C   3
-#define CHANNEL_D   4
+#define CHANNEL_A 1
+#define CHANNEL_B 2
+#define CHANNEL_C 3
+#define CHANNEL_D 4
 
 // Port Identifier Table
-#define PIT_DEFAULT   0 // SIOA
-#define PIT_SIOA      1 // SIOA
+#define PIT_DEFAULT  0 // SIOA
+#define PIT_SIOA     1 // SIOA
 // The device this driver is tested with one has only one port
-#define PIT_SIOB      2 // SIOB
-#define PIT_PARALLEL  3 // Parallel
+#define PIT_SIOB     2 // SIOB
+#define PIT_PARALLEL 3 // Parallel
 
 // FTDI_SIO_RESET
-#define FTDI_SIO_RESET_REQUEST FTDI_SIO_RESET
-#define FTDI_SIO_RESET_REQUEST_TYPE 0x40
-#define FTDI_SIO_RESET_SIO 0
-#define FTDI_SIO_RESET_PURGE_RX 1
-#define FTDI_SIO_RESET_PURGE_TX 2
+#define FTDI_SIO_RESET_REQUEST                    FTDI_SIO_RESET
+#define FTDI_SIO_RESET_REQUEST_TYPE               0x40
+#define FTDI_SIO_RESET_SIO                        0
+#define FTDI_SIO_RESET_PURGE_RX                   1
+#define FTDI_SIO_RESET_PURGE_TX                   2
 
 // FTDI_SIO_SET_BAUDRATE
-#define FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE 0x40
-#define FTDI_SIO_SET_BAUDRATE_REQUEST 3
+#define FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE        0x40
+#define FTDI_SIO_SET_BAUDRATE_REQUEST             3
 
 enum ftdi_sio_baudrate {
   ftdi_sio_b300 = 0,
@@ -80,89 +80,89 @@ enum ftdi_sio_baudrate {
 };
 
 // FTDI_SIO_SET_DATA
-#define FTDI_SIO_SET_DATA_REQUEST FTDI_SIO_SET_DATA
-#define FTDI_SIO_SET_DATA_REQUEST_TYPE  0x40
-#define FTDI_SIO_SET_DATA_PARITY_NONE (0x0 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_ODD  (0x1 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_EVEN (0x2 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_MARK (0x3 << 8)
-#define FTDI_SIO_SET_DATA_PARITY_SPACE  (0x4 << 8)
-#define FTDI_SIO_SET_DATA_STOP_BITS_1 (0x0 << 11)
-#define FTDI_SIO_SET_DATA_STOP_BITS_15  (0x1 << 11)
-#define FTDI_SIO_SET_DATA_STOP_BITS_2 (0x2 << 11)
-#define FTDI_SIO_SET_BREAK    (0x1 << 14)
+#define FTDI_SIO_SET_DATA_REQUEST                 FTDI_SIO_SET_DATA
+#define FTDI_SIO_SET_DATA_REQUEST_TYPE            0x40
+#define FTDI_SIO_SET_DATA_PARITY_NONE             (0x0 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_ODD              (0x1 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_EVEN             (0x2 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_MARK             (0x3 << 8)
+#define FTDI_SIO_SET_DATA_PARITY_SPACE            (0x4 << 8)
+#define FTDI_SIO_SET_DATA_STOP_BITS_1             (0x0 << 11) // same coding as ACM
+#define FTDI_SIO_SET_DATA_STOP_BITS_15            (0x1 << 11) // 1.5 not supported, for future use?
+#define FTDI_SIO_SET_DATA_STOP_BITS_2             (0x2 << 11)
+#define FTDI_SIO_SET_BREAK                        (0x1 << 14)
 
 // FTDI_SIO_MODEM_CTRL
-#define FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE 0x40
-#define FTDI_SIO_SET_MODEM_CTRL_REQUEST FTDI_SIO_MODEM_CTRL
+#define FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE      0x40
+#define FTDI_SIO_SET_MODEM_CTRL_REQUEST           FTDI_SIO_MODEM_CTRL
 
-#define FTDI_SIO_SET_DTR_MASK 0x1
-#define FTDI_SIO_SET_DTR_HIGH ((FTDI_SIO_SET_DTR_MASK  << 8) | 1)
-#define FTDI_SIO_SET_DTR_LOW  ((FTDI_SIO_SET_DTR_MASK  << 8) | 0)
-#define FTDI_SIO_SET_RTS_MASK 0x2
-#define FTDI_SIO_SET_RTS_HIGH ((FTDI_SIO_SET_RTS_MASK << 8) | 2)
-#define FTDI_SIO_SET_RTS_LOW  ((FTDI_SIO_SET_RTS_MASK << 8) | 0)
+#define FTDI_SIO_SET_DTR_MASK                     0x1
+#define FTDI_SIO_SET_DTR_HIGH                     ((FTDI_SIO_SET_DTR_MASK << 8) | 1)
+#define FTDI_SIO_SET_DTR_LOW                      ((FTDI_SIO_SET_DTR_MASK << 8) | 0)
+#define FTDI_SIO_SET_RTS_MASK                     0x2
+#define FTDI_SIO_SET_RTS_HIGH                     ((FTDI_SIO_SET_RTS_MASK << 8) | 2)
+#define FTDI_SIO_SET_RTS_LOW                      ((FTDI_SIO_SET_RTS_MASK << 8) | 0)
 
 // FTDI_SIO_SET_FLOW_CTRL
-#define FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE 0x40
-#define FTDI_SIO_SET_FLOW_CTRL_REQUEST FTDI_SIO_SET_FLOW_CTRL
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE       0x40
+#define FTDI_SIO_SET_FLOW_CTRL_REQUEST            FTDI_SIO_SET_FLOW_CTRL
 #define FTDI_SIO_DISABLE_FLOW_CTRL 0x0
-#define FTDI_SIO_RTS_CTS_HS (0x1 << 8)
-#define FTDI_SIO_DTR_DSR_HS (0x2 << 8)
-#define FTDI_SIO_XON_XOFF_HS (0x4 << 8)
+#define FTDI_SIO_RTS_CTS_HS                       (0x1 << 8)
+#define FTDI_SIO_DTR_DSR_HS                       (0x2 << 8)
+#define FTDI_SIO_XON_XOFF_HS                      (0x4 << 8)
 
 // FTDI_SIO_GET_LATENCY_TIMER
-#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST FTDI_SIO_GET_LATENCY_TIMER
-#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE 0xC0
+#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST       FTDI_SIO_GET_LATENCY_TIMER
+#define  FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE  0xC0
 
 // FTDI_SIO_SET_LATENCY_TIMER
-#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST FTDI_SIO_SET_LATENCY_TIMER
-#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE 0x40
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST       FTDI_SIO_SET_LATENCY_TIMER
+#define  FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE  0x40
 
 // FTDI_SIO_SET_EVENT_CHAR
-#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST FTDI_SIO_SET_EVENT_CHAR
-#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE 0x40
+#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST          FTDI_SIO_SET_EVENT_CHAR
+#define  FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE     0x40
 
 // FTDI_SIO_GET_MODEM_STATUS
-#define FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE 0xc0
-#define FTDI_SIO_GET_MODEM_STATUS_REQUEST FTDI_SIO_GET_MODEM_STATUS
-#define FTDI_SIO_CTS_MASK 0x10
-#define FTDI_SIO_DSR_MASK 0x20
-#define FTDI_SIO_RI_MASK  0x40
-#define FTDI_SIO_RLSD_MASK 0x80
+#define FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE    0xc0
+#define FTDI_SIO_GET_MODEM_STATUS_REQUEST         FTDI_SIO_GET_MODEM_STATUS
+#define FTDI_SIO_CTS_MASK                         0x10
+#define FTDI_SIO_DSR_MASK                         0x20
+#define FTDI_SIO_RI_MASK                          0x40
+#define FTDI_SIO_RLSD_MASK                        0x80
 
 // FTDI_SIO_SET_BITMODE
-#define FTDI_SIO_SET_BITMODE_REQUEST_TYPE 0x40
-#define FTDI_SIO_SET_BITMODE_REQUEST FTDI_SIO_SET_BITMODE
+#define FTDI_SIO_SET_BITMODE_REQUEST_TYPE         0x40
+#define FTDI_SIO_SET_BITMODE_REQUEST              FTDI_SIO_SET_BITMODE
 
 // Possible bitmodes for FTDI_SIO_SET_BITMODE_REQUEST
-#define FTDI_SIO_BITMODE_RESET    0x00
-#define FTDI_SIO_BITMODE_CBUS   0x20
+#define FTDI_SIO_BITMODE_RESET                    0x00
+#define FTDI_SIO_BITMODE_CBUS                     0x20
 
 // FTDI_SIO_READ_PINS
-#define FTDI_SIO_READ_PINS_REQUEST_TYPE 0xc0
-#define FTDI_SIO_READ_PINS_REQUEST FTDI_SIO_READ_PINS
+#define FTDI_SIO_READ_PINS_REQUEST_TYPE           0xc0
+#define FTDI_SIO_READ_PINS_REQUEST                FTDI_SIO_READ_PINS
 
 // FTDI_SIO_READ_EEPROM
-#define FTDI_SIO_READ_EEPROM_REQUEST_TYPE 0xc0
-#define FTDI_SIO_READ_EEPROM_REQUEST FTDI_SIO_READ_EEPROM
+#define FTDI_SIO_READ_EEPROM_REQUEST_TYPE         0xc0
+#define FTDI_SIO_READ_EEPROM_REQUEST              FTDI_SIO_READ_EEPROM
 
 #define FTDI_FTX_CBUS_MUX_GPIO    0x8
 #define FTDI_FT232R_CBUS_MUX_GPIO 0xa
 
 #define FTDI_RS0_CTS  (1 << 4)
 #define FTDI_RS0_DSR  (1 << 5)
-#define FTDI_RS0_RI (1 << 6)
+#define FTDI_RS0_RI   (1 << 6)
 #define FTDI_RS0_RLSD (1 << 7)
 
-#define FTDI_RS_DR  1
-#define FTDI_RS_OE  (1<<1)
-#define FTDI_RS_PE  (1<<2)
-#define FTDI_RS_FE  (1<<3)
-#define FTDI_RS_BI  (1<<4)
-#define FTDI_RS_THRE  (1<<5)
-#define FTDI_RS_TEMT  (1<<6)
-#define FTDI_RS_FIFO  (1<<7)
+#define FTDI_RS_DR    1
+#define FTDI_RS_OE    (1 << 1)
+#define FTDI_RS_PE    (1 << 2)
+#define FTDI_RS_FE    (1 << 3)
+#define FTDI_RS_BI    (1 << 4)
+#define FTDI_RS_THRE  (1 << 5)
+#define FTDI_RS_TEMT  (1 << 6)
+#define FTDI_RS_FIFO  (1 << 7)
 
 // chip types and names
 enum ftdi_chip_type {
@@ -206,14 +206,14 @@ enum ftdi_chip_type {
 
 // private interface data
 typedef struct ftdi_private {
-  enum ftdi_chip_type chip_type;
-  uint8_t channel; // channel index, or 0 for legacy types
+  enum    ftdi_chip_type chip_type;
+  uint8_t channel;                  // channel index, or 0 for legacy types
 } ftdi_private_t;
 
-#define FTDI_OK true
-#define FTDI_FAIL false
+#define FTDI_OK           true
+#define FTDI_FAIL         false
 #define FTDI_NOT_POSSIBLE -1
-#define FTDI_REQUESTED -2
+#define FTDI_REQUESTED    -2
 
 // division and round function overtaken from math.h
 #define DIV_ROUND_CLOSEST(x, divisor)(      \
diff --git a/src/class/cdc/serial/pl2303.h b/src/class/cdc/serial/pl2303.h
index bf264191bf..d69bdbfae0 100644
--- a/src/class/cdc/serial/pl2303.h
+++ b/src/class/cdc/serial/pl2303.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef _PL2303_H_
-#define _PL2303_H_
+#ifndef TUSB_PL2303_H
+#define TUSB_PL2303_H
 
 #include <stdbool.h>
 #include <stdint.h>
@@ -36,66 +36,66 @@
 //   https://github.com/torvalds/linux/blob/master/drivers/usb/serial/pl2303.c
 // - https://github.com/freebsd/freebsd-src/blob/main/sys/dev/usb/serial/uplcom.c
 
-/* quirks */
-#define PL2303_QUIRK_UART_STATE_IDX0 1
-#define PL2303_QUIRK_LEGACY 2
-#define PL2303_QUIRK_ENDPOINT_HACK 4
-
-/* requests and bits */
-#define PL2303_SET_LINE_REQUEST_TYPE 0x21     // class request host to device interface
-#define PL2303_SET_LINE_REQUEST 0x20          // dec 32
-
-#define PL2303_SET_CONTROL_REQUEST_TYPE 0x21  // class request host to device interface
-#define PL2303_SET_CONTROL_REQUEST 0x22       // dec 34
-#define PL2303_CONTROL_DTR 0x01               // dec 1
-#define PL2303_CONTROL_RTS 0x02               // dec 2
-
-#define PL2303_BREAK_REQUEST_TYPE 0x21        // class request host to device interface
-#define PL2303_BREAK_REQUEST 0x23             // dec 35
-#define PL2303_BREAK_ON 0xffff
-#define PL2303_BREAK_OFF 0x0000
-
-#define PL2303_GET_LINE_REQUEST_TYPE 0xa1     // class request device to host interface
-#define PL2303_GET_LINE_REQUEST 0x21          // dec 33
-
-#define PL2303_VENDOR_WRITE_REQUEST_TYPE 0x40 // vendor request host to device interface
-#define PL2303_VENDOR_WRITE_REQUEST 0x01      // dec 1
-#define PL2303_VENDOR_WRITE_NREQUEST 0x80     // dec 128
-
-#define PL2303_VENDOR_READ_REQUEST_TYPE 0xc0  // vendor request device to host interface
-#define PL2303_VENDOR_READ_REQUEST 0x01       // dec 1
-#define PL2303_VENDOR_READ_NREQUEST 0x81      // dec 129
-
-#define PL2303_UART_STATE_INDEX 8
-#define PL2303_UART_STATE_MSR_MASK 0x8b
-#define PL2303_UART_STATE_TRANSIENT_MASK 0x74
-#define PL2303_UART_DCD 0x01
-#define PL2303_UART_DSR 0x02
-#define PL2303_UART_BREAK_ERROR 0x04
-#define PL2303_UART_RING 0x08
-#define PL2303_UART_FRAME_ERROR 0x10
-#define PL2303_UART_PARITY_ERROR 0x20
-#define PL2303_UART_OVERRUN_ERROR 0x40
-#define PL2303_UART_CTS 0x80
-
-#define PL2303_FLOWCTRL_MASK 0xf0
-
-#define PL2303_CLEAR_HALT_REQUEST_TYPE 0x02   // standard request host to device endpoint
-
-/* registers via vendor read/write requests */
-#define PL2303_READ_TYPE_HX_STATUS 0x8080
-
-#define PL2303_HXN_RESET_REG 0x07
-#define PL2303_HXN_RESET_UPSTREAM_PIPE 0x02
-#define PL2303_HXN_RESET_DOWNSTREAM_PIPE 0x01
-
-#define PL2303_HXN_FLOWCTRL_REG 0x0a
-#define PL2303_HXN_FLOWCTRL_MASK 0x1c
-#define PL2303_HXN_FLOWCTRL_NONE 0x1c
-#define PL2303_HXN_FLOWCTRL_RTS_CTS 0x18
-#define PL2303_HXN_FLOWCTRL_XON_XOFF 0x0c
-
-/* type data */
+// quirks
+#define PL2303_QUIRK_UART_STATE_IDX0      1
+#define PL2303_QUIRK_LEGACY               2
+#define PL2303_QUIRK_ENDPOINT_HACK        4
+
+// requests and bits
+#define PL2303_SET_LINE_REQUEST_TYPE      0x21    // class request host to device interface
+#define PL2303_SET_LINE_REQUEST           0x20    // dec 32
+
+#define PL2303_SET_CONTROL_REQUEST_TYPE   0x21    // class request host to device interface
+#define PL2303_SET_CONTROL_REQUEST        0x22    // dec 34
+#define PL2303_CONTROL_DTR                0x01    // dec 1
+#define PL2303_CONTROL_RTS                0x02    // dec 2
+
+#define PL2303_BREAK_REQUEST_TYPE         0x21    // class request host to device interface
+#define PL2303_BREAK_REQUEST              0x23    // dec 35
+#define PL2303_BREAK_ON                   0xffff
+#define PL2303_BREAK_OFF                  0x0000
+
+#define PL2303_GET_LINE_REQUEST_TYPE      0xa1    // class request device to host interface
+#define PL2303_GET_LINE_REQUEST           0x21    // dec 33
+
+#define PL2303_VENDOR_WRITE_REQUEST_TYPE  0x40    // vendor request host to device interface
+#define PL2303_VENDOR_WRITE_REQUEST       0x01    // dec 1
+#define PL2303_VENDOR_WRITE_NREQUEST      0x80    // dec 128
+
+#define PL2303_VENDOR_READ_REQUEST_TYPE   0xc0    // vendor request device to host interface
+#define PL2303_VENDOR_READ_REQUEST        0x01    // dec 1
+#define PL2303_VENDOR_READ_NREQUEST       0x81    // dec 129
+
+#define PL2303_UART_STATE_INDEX           8
+#define PL2303_UART_STATE_MSR_MASK        0x8b
+#define PL2303_UART_STATE_TRANSIENT_MASK  0x74
+#define PL2303_UART_DCD                   0x01
+#define PL2303_UART_DSR                   0x02
+#define PL2303_UART_BREAK_ERROR           0x04
+#define PL2303_UART_RING                  0x08
+#define PL2303_UART_FRAME_ERROR           0x10
+#define PL2303_UART_PARITY_ERROR          0x20
+#define PL2303_UART_OVERRUN_ERROR         0x40
+#define PL2303_UART_CTS                   0x80
+
+#define PL2303_FLOWCTRL_MASK              0xf0
+
+#define PL2303_CLEAR_HALT_REQUEST_TYPE    0x02    // standard request host to device endpoint
+
+// registers via vendor read/write requests
+#define PL2303_READ_TYPE_HX_STATUS        0x8080
+
+#define PL2303_HXN_RESET_REG              0x07
+#define PL2303_HXN_RESET_UPSTREAM_PIPE    0x02
+#define PL2303_HXN_RESET_DOWNSTREAM_PIPE  0x01
+
+#define PL2303_HXN_FLOWCTRL_REG           0x0a
+#define PL2303_HXN_FLOWCTRL_MASK          0x1c
+#define PL2303_HXN_FLOWCTRL_NONE          0x1c
+#define PL2303_HXN_FLOWCTRL_RTS_CTS       0x18
+#define PL2303_HXN_FLOWCTRL_XON_XOFF      0x0c
+
+// type data
 enum pl2303_type {
   TYPE_H,
   TYPE_HX,
@@ -107,9 +107,9 @@ enum pl2303_type {
 };
 
 struct pl2303_type_data {
-  uint8_t const *name;
+  uint8_t  const *name;
   uint32_t const max_baud_rate;
-  uint8_t const quirks;
+  uint8_t  const quirks;
   uint16_t const no_autoxonxoff:1;
   uint16_t const no_divisors:1;
   uint16_t const alt_divisors:1;
@@ -146,7 +146,7 @@ struct pl2303_type_data {
     .no_divisors = true, \
   }
 
-/* private data types */
+// private data types
 struct pl2303_serial_private {
   const struct pl2303_type_data* type;
   uint8_t quirks;
@@ -157,16 +157,16 @@ typedef struct TU_ATTR_PACKED {
   bool supports_hx_status;
 } pl2303_private_t;
 
-/* buffer sizes for line coding data */
-#define PL2303_LINE_CODING_BUFSIZE 7
+// buffer sizes for line coding data
+#define PL2303_LINE_CODING_BUFSIZE          7
 #define PL2303_LINE_CODING_BAUDRATE_BUFSIZE 4
 
-/* bulk endpoints */
-#define PL2303_OUT_EP 0x02
-#define PL2303_IN_EP 0x83
+// bulk endpoints
+#define PL2303_OUT_EP                       0x02
+#define PL2303_IN_EP                        0x83
 
-/* return values of pl2303_detect_type() */
+// return values of pl2303_detect_type()
 #define PL2303_SUPPORTS_HX_STATUS_TRIGGERED -1
-#define PL2303_DETECT_TYPE_FAILED -2
+#define PL2303_DETECT_TYPE_FAILED           -2
 
-#endif /* _PL2303_H_ */
+#endif // TUSB_PL2303_H

From 5e67b92b8c398d6fee92010ecd63cf50b51f8f9a Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 4 Apr 2024 14:10:31 +0200
Subject: [PATCH 32/37] fixed compile warnings

---
 src/class/cdc/cdc_host.c        | 29 ++++++++++++++++-------------
 src/class/cdc/serial/cp210x.h   |  4 ++--
 src/class/cdc/serial/ftdi_sio.h | 14 +++++++-------
 3 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index e6579ad82c..2d900a753f 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -1181,9 +1181,9 @@ static bool ftdi_change_speed(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_c
 static bool ftdi_set_data_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 7 && p_cdc->requested_line_coding.data_bits <= 8, 0);
   uint16_t value = (uint16_t) (
-    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xfu)       |  // data bit quantity is stored in bits 0-3
-    ((uint32_t) p_cdc->requested_line_coding.parity    & 0x7u) <<  8 |  // parity is stored in bits 8-10, same coding
-    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0x3u) << 11 ); // stop bits quantity is stored in bits 11-12, same coding
+    (p_cdc->requested_line_coding.data_bits & 0xfUL)       |  // data bit quantity is stored in bits 0-3
+    (p_cdc->requested_line_coding.parity    & 0x7UL) <<  8 |  // parity is stored in bits 8-10, same coding
+    (p_cdc->requested_line_coding.stop_bits & 0x3UL) << 11 ); // stop bits quantity is stored in bits 11-12, same coding
                                                                         // not each FTDI supports 1.5 stop bits
 
   return ftdi_set_request(p_cdc, FTDI_SIO_SET_DATA_REQUEST, FTDI_SIO_SET_DATA_REQUEST_TYPE,
@@ -1191,8 +1191,8 @@ static bool ftdi_set_data_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t comple
 }
 
 static inline bool ftdi_update_mctrl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  uint16_t value = (uint16_t) ((p_cdc->requested_line_state.dtr ? (uint32_t) FTDI_SIO_SET_DTR_HIGH : (uint32_t) FTDI_SIO_SET_DTR_LOW) |
-                               (p_cdc->requested_line_state.rts ? (uint32_t) FTDI_SIO_SET_RTS_HIGH : (uint32_t) FTDI_SIO_SET_RTS_LOW));
+  uint16_t value = (uint16_t) ((p_cdc->requested_line_state.dtr ? FTDI_SIO_SET_DTR_HIGH : FTDI_SIO_SET_DTR_LOW) |
+                               (p_cdc->requested_line_state.rts ? FTDI_SIO_SET_RTS_HIGH : FTDI_SIO_SET_RTS_LOW));
 
   return ftdi_set_request(p_cdc, FTDI_SIO_SET_MODEM_CTRL_REQUEST, FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
                           value, p_cdc->ftdi.channel, complete_cb, user_data);
@@ -1338,7 +1338,10 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
         // other interfaces have same type as interface 0
         uint8_t const idx_itf0 = tuh_cdc_itf_get_index(xfer->daddr, 0);
         cdch_interface_t const * p_cdc_itf0 = get_itf(idx_itf0);
-        p_cdc->ftdi.chip_type = p_cdc_itf0->ftdi.chip_type;
+        TU_ASSERT_COMPLETE(p_cdc_itf0);
+        if (p_cdc_itf0) {
+         p_cdc->ftdi.chip_type = p_cdc_itf0->ftdi.chip_type;
+        }
       }
       TU_ATTR_FALLTHROUGH;
 
@@ -1715,9 +1718,9 @@ static bool cp210x_set_baudrate_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t
 static bool cp210x_set_line_ctl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 9, 0);
   uint16_t lcr = (uint16_t) (
-    ((uint32_t) p_cdc->requested_line_coding.data_bits & 0xfu) << 8 | // data bit quantity is stored in bits 8-11
-    ((uint32_t) p_cdc->requested_line_coding.parity    & 0xfu) << 4 | // parity is stored in bits 4-7, same coding
-    ((uint32_t) p_cdc->requested_line_coding.stop_bits & 0xfu));      // parity is stored in bits 0-3, same coding
+    (p_cdc->requested_line_coding.data_bits & 0xfUL) << 8 | // data bit quantity is stored in bits 8-11
+    (p_cdc->requested_line_coding.parity    & 0xfUL) << 4 | // parity is stored in bits 4-7, same coding
+    (p_cdc->requested_line_coding.stop_bits & 0xfUL));      // parity is stored in bits 0-3, same coding
 
   return cp210x_set_request(p_cdc, CP210X_SET_LINE_CTL, lcr, NULL, 0, complete_cb, user_data);
 }
@@ -1725,8 +1728,8 @@ static bool cp210x_set_line_ctl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete
 static inline bool cp210x_set_mhs(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
   // CP210x has the same bit coding
   return cp210x_set_request(p_cdc, CP210X_SET_MHS,
-                            (uint16_t) ((uint32_t) CP210X_CONTROL_WRITE_DTR |
-                                        (uint32_t) CP210X_CONTROL_WRITE_RTS | p_cdc->requested_line_state.all),
+                            (uint16_t) (CP210X_CONTROL_WRITE_DTR | CP210X_CONTROL_WRITE_RTS |
+                                        p_cdc->requested_line_state.all),
                             NULL, 0, complete_cb, user_data);
 }
 
@@ -2327,7 +2330,7 @@ static bool pl2303_vendor_write(cdch_interface_t * p_cdc, uint16_t value, uint16
 
 static inline bool pl2303_supports_hx_status(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data)
 {
-  uint8_t buf;
+  uint8_t buf = 0;
 
   return pl2303_set_request(p_cdc, PL2303_VENDOR_READ_REQUEST, PL2303_VENDOR_READ_REQUEST_TYPE, PL2303_READ_TYPE_HX_STATUS, 0,
                             &buf, 1, complete_cb, user_data);
@@ -2519,7 +2522,7 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
   cdch_interface_t * p_cdc = get_itf(idx);
   // state CONFIG_PL2303_READ1 may have no success due to expected stall by pl2303_supports_hx_status()
   TU_ASSERT_COMPLETE(p_cdc && (xfer->result == XFER_RESULT_SUCCESS || xfer->user_data == CONFIG_PL2303_READ1));
-  uint8_t buf;
+  uint8_t buf = 0;
   int8_t type;
 
   switch (state) {
diff --git a/src/class/cdc/serial/cp210x.h b/src/class/cdc/serial/cp210x.h
index a553a54da4..ac9c273307 100644
--- a/src/class/cdc/serial/cp210x.h
+++ b/src/class/cdc/serial/cp210x.h
@@ -101,8 +101,8 @@
 #define CP210X_MSR_DCD                  0x0080
 #define CP210X_MSR_ALL                  0x00F0
 
-#define CP210X_CONTROL_WRITE_DTR        0x0100
-#define CP210X_CONTROL_WRITE_RTS        0x0200
+#define CP210X_CONTROL_WRITE_DTR        0x0100UL
+#define CP210X_CONTROL_WRITE_RTS        0x0200UL
 
 #define CP210X_LSR_BREAK                0x0001
 #define CP210X_LSR_FRAMING_ERROR        0x0002
diff --git a/src/class/cdc/serial/ftdi_sio.h b/src/class/cdc/serial/ftdi_sio.h
index 4afedec9bf..f621b39124 100644
--- a/src/class/cdc/serial/ftdi_sio.h
+++ b/src/class/cdc/serial/ftdi_sio.h
@@ -96,17 +96,17 @@ enum ftdi_sio_baudrate {
 #define FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE      0x40
 #define FTDI_SIO_SET_MODEM_CTRL_REQUEST           FTDI_SIO_MODEM_CTRL
 
-#define FTDI_SIO_SET_DTR_MASK                     0x1
-#define FTDI_SIO_SET_DTR_HIGH                     ((FTDI_SIO_SET_DTR_MASK << 8) | 1)
-#define FTDI_SIO_SET_DTR_LOW                      ((FTDI_SIO_SET_DTR_MASK << 8) | 0)
-#define FTDI_SIO_SET_RTS_MASK                     0x2
-#define FTDI_SIO_SET_RTS_HIGH                     ((FTDI_SIO_SET_RTS_MASK << 8) | 2)
-#define FTDI_SIO_SET_RTS_LOW                      ((FTDI_SIO_SET_RTS_MASK << 8) | 0)
+#define FTDI_SIO_SET_DTR_MASK                     0x1UL
+#define FTDI_SIO_SET_DTR_HIGH                     ((FTDI_SIO_SET_DTR_MASK << 8) | 1UL)
+#define FTDI_SIO_SET_DTR_LOW                      ((FTDI_SIO_SET_DTR_MASK << 8) | 0UL)
+#define FTDI_SIO_SET_RTS_MASK                     0x2UL
+#define FTDI_SIO_SET_RTS_HIGH                     ((FTDI_SIO_SET_RTS_MASK << 8) | 2UL)
+#define FTDI_SIO_SET_RTS_LOW                      ((FTDI_SIO_SET_RTS_MASK << 8) | 0UL)
 
 // FTDI_SIO_SET_FLOW_CTRL
 #define FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE       0x40
 #define FTDI_SIO_SET_FLOW_CTRL_REQUEST            FTDI_SIO_SET_FLOW_CTRL
-#define FTDI_SIO_DISABLE_FLOW_CTRL 0x0
+#define FTDI_SIO_DISABLE_FLOW_CTRL                0x0
 #define FTDI_SIO_RTS_CTS_HS                       (0x1 << 8)
 #define FTDI_SIO_DTR_DSR_HS                       (0x2 << 8)
 #define FTDI_SIO_XON_XOFF_HS                      (0x4 << 8)

From e07ee4a7b1f7c7d18f385d605dd41e08962ddba4 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 4 Apr 2024 14:12:14 +0200
Subject: [PATCH 33/37] CP210x removed baudrate check, fixed data bits check

---
 src/class/cdc/cdc_host.c      | 12 ++----------
 src/class/cdc/serial/cp210x.h |  9 ---------
 2 files changed, 2 insertions(+), 19 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 2d900a753f..73d800469b 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -1701,22 +1701,14 @@ static inline bool cp210x_ifc_enable(cdch_interface_t * p_cdc, uint16_t enabled,
 }
 
 static bool cp210x_set_baudrate_request(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  // Check baudrate is supported. It's only a specific list. reference: datasheets and AN205 "CP210x Baud Rate Support"
-  uint32_t const supported_baudrates_list[] = CP210X_SUPPORTED_BAUDRATES_LIST;
-  uint8_t i;
-  for ( i=0; supported_baudrates_list[i]; i++ ){
-    if (p_cdc->requested_line_coding.bit_rate == supported_baudrates_list[i]) {
-      break;
-    }
-  }
-  TU_VERIFY(supported_baudrates_list[i]);
+  // Not every baud rate is supported. See datasheets and AN205 "CP210x Baud Rate Support"
   uint32_t baud_le = tu_htole32(p_cdc->requested_line_coding.bit_rate);
 
   return cp210x_set_request(p_cdc, CP210X_SET_BAUDRATE, 0, (uint8_t *) &baud_le, 4, complete_cb, user_data);
 }
 
 static bool cp210x_set_line_ctl(cdch_interface_t * p_cdc, tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
-  TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 9, 0);
+  TU_VERIFY(p_cdc->requested_line_coding.data_bits >= 5 && p_cdc->requested_line_coding.data_bits <= 8, 0);
   uint16_t lcr = (uint16_t) (
     (p_cdc->requested_line_coding.data_bits & 0xfUL) << 8 | // data bit quantity is stored in bits 8-11
     (p_cdc->requested_line_coding.parity    & 0xfUL) << 4 | // parity is stored in bits 4-7, same coding
diff --git a/src/class/cdc/serial/cp210x.h b/src/class/cdc/serial/cp210x.h
index ac9c273307..a0eff9e400 100644
--- a/src/class/cdc/serial/cp210x.h
+++ b/src/class/cdc/serial/cp210x.h
@@ -111,13 +111,4 @@
 #define CP210X_LSR_PARITY_ERROR         0x0010
 #define CP210X_LSR_ALL                  0x001F
 
-// supported baudrates
-// reference: datasheets and AN205 "CP210x Baud Rate Support"
-#define CP210X_SUPPORTED_BAUDRATES_LIST { \
-  300, 600, \
-  1200, 1800, 2400, 4000, 4800, 7200, 9600, \
-  14400, 16000, 19200, 28800, 38400, 51200, 56000, 57600, 64000, 76800, \
-  115200, 128000, 153600, 230400, 250000, 256000, 460800, 500000, 576000, 921600, \
-  0 }
-
 #endif //TUSB_CP210X_H

From a1b1c1f552d944da1bf309ce002b7c07f5a270a0 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 4 Apr 2024 14:13:24 +0200
Subject: [PATCH 34/37] foxed FTDI flow control config

---
 src/class/cdc/cdc_host.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 73d800469b..6006730b7c 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -1382,7 +1382,8 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
     case CONFIG_FTDI_FLOW_CONTROL:
       // disable flow control
       TU_ASSERT_COMPLETE(ftdi_set_request(p_cdc, FTDI_SIO_SET_FLOW_CTRL_REQUEST, FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
-                                          0, FTDI_SIO_DISABLE_FLOW_CTRL, ftdi_process_config, CONFIG_FTDI_MODEM_CTRL));
+                                          FTDI_SIO_DISABLE_FLOW_CTRL, p_cdc->ftdi.channel,
+                                          ftdi_process_config, CONFIG_FTDI_MODEM_CTRL));
       break;
 
     case CONFIG_FTDI_MODEM_CTRL:

From e02a309f1dc09377fe5123c21ecfe36eb6a032c7 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 4 Apr 2024 14:14:41 +0200
Subject: [PATCH 35/37] disable PL2303 flow control config

---
 src/class/cdc/cdc_host.c | 55 +++++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 26 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 6006730b7c..b9915f5835 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -2475,8 +2475,8 @@ enum {
   CONFIG_PL2303_RESET_ENDP2,
   CONFIG_PL2303_LINE_CODING,
   CONFIG_PL2303_MODEM_CONTROL,
-  CONFIG_PL2303_FLOW_CTRL_READ,
-  CONFIG_PL2303_FLOW_CTRL_WRITE,
+//  CONFIG_PL2303_FLOW_CTRL_READ,
+//  CONFIG_PL2303_FLOW_CTRL_WRITE,
   CONFIG_PL2303_COMPLETE
 };
 
@@ -2691,35 +2691,38 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
     case CONFIG_PL2303_MODEM_CONTROL:
       #ifdef LINE_CONTROL_ON_ENUM
         p_cdc->requested_line_state.all = LINE_CONTROL_ON_ENUM;
-        TU_ASSERT_COMPLETE(pl2303_set_control_lines(p_cdc, pl2303_internal_control_complete, CONFIG_PL2303_FLOW_CTRL_READ));
+        TU_ASSERT_COMPLETE(pl2303_set_control_lines(p_cdc, pl2303_internal_control_complete, CONFIG_PL2303_COMPLETE));
         break;
       #else
         TU_ATTR_FALLTHROUGH;
       #endif
 
-    case CONFIG_PL2303_FLOW_CTRL_READ:
-      // read flow control register for modify & write back in next step
-      if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
-        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, PL2303_HXN_FLOWCTRL_REG, &buf, pl2303_process_config,
-                                              CONFIG_PL2303_FLOW_CTRL_WRITE));
-      } else {
-        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0, &buf, pl2303_process_config, CONFIG_PL2303_FLOW_CTRL_WRITE));
-      }
-      break;
-
-    case CONFIG_PL2303_FLOW_CTRL_WRITE:
-      // no flow control
-      buf = xfer->buffer[0];
-      if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
-        buf &= (uint8_t) ~PL2303_HXN_FLOWCTRL_MASK;
-        buf |= PL2303_HXN_FLOWCTRL_NONE;
-        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, PL2303_HXN_FLOWCTRL_REG, buf, pl2303_process_config,
-                                               CONFIG_PL2303_COMPLETE));
-      } else {
-        buf &= (uint8_t) ~PL2303_FLOWCTRL_MASK;
-        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 0, buf, pl2303_process_config, CONFIG_PL2303_COMPLETE));
-      }
-      break;
+// skipped, because it's not working with each PL230x. flow control can be also set by PL2303 EEPROM Writer Program
+//    case CONFIG_PL2303_FLOW_CTRL_READ:
+//      // read flow control register for modify & write back in next step
+//      if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
+//        TU_LOG_P_CDC ( "1\r\n" );
+//        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, PL2303_HXN_FLOWCTRL_REG, &buf, pl2303_process_config,
+//                                              CONFIG_PL2303_FLOW_CTRL_WRITE));
+//      } else {
+//        TU_LOG_P_CDC ( "2\r\n" );
+//        TU_ASSERT_COMPLETE(pl2303_vendor_read(p_cdc, 0, &buf, pl2303_process_config, CONFIG_PL2303_FLOW_CTRL_WRITE));
+//      }
+//      break;
+//
+//    case CONFIG_PL2303_FLOW_CTRL_WRITE:
+//      // no flow control
+//      buf = xfer->buffer[0];
+//      if (p_cdc->pl2303.serial_private.type == &pl2303_type_data[TYPE_HXN]) {
+//        buf &= (uint8_t) ~PL2303_HXN_FLOWCTRL_MASK;
+//        buf |= PL2303_HXN_FLOWCTRL_NONE;
+//        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, PL2303_HXN_FLOWCTRL_REG, buf, pl2303_process_config,
+//                                               CONFIG_PL2303_COMPLETE));
+//      } else {
+//        buf &= (uint8_t) ~PL2303_FLOWCTRL_MASK;
+//        TU_ASSERT_COMPLETE(pl2303_vendor_write(p_cdc, 0, buf, pl2303_process_config, CONFIG_PL2303_COMPLETE));
+//      }
+//      break;
 
     case CONFIG_PL2303_COMPLETE:
       set_config_complete(idx, 0, true);

From 68602e4adda941ab11826afbd7b82e44134a97ae Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 4 Apr 2024 14:16:02 +0200
Subject: [PATCH 36/37] small change process config complete

---
 src/class/cdc/cdc_host.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index b9915f5835..fbe0cc9ca2 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -1400,7 +1400,7 @@ static void ftdi_process_config(tuh_xfer_t * xfer) {
       break;
 
     default:
-      set_config_complete(idx, 0, false);
+      TU_ASSERT_COMPLETE(false);
       break;
   }
 }
@@ -1876,7 +1876,7 @@ static void cp210x_process_config(tuh_xfer_t * xfer) {
       break;
 
     default:
-      set_config_complete(idx, 0, false);
+      TU_ASSERT_COMPLETE(false);
       break;
   }
 }
@@ -2158,7 +2158,7 @@ static void ch34x_process_config(tuh_xfer_t* xfer) {
       break;
 
     default:
-      set_config_complete(idx, 0, false);
+      TU_ASSERT_COMPLETE(false);
       break;
   }
 }
@@ -2729,7 +2729,7 @@ static void pl2303_process_config(tuh_xfer_t * xfer) {
       break;
 
     default:
-      set_config_complete(idx, 0, false);
+      TU_ASSERT_COMPLETE(false);
       break;
   }
 }

From 0c5e14cdaa98b3d801fcaf05e3b6c941031a55b2 Mon Sep 17 00:00:00 2001
From: IngHK <github@hkue.de>
Date: Thu, 4 Apr 2024 14:16:39 +0200
Subject: [PATCH 37/37] updated doc

---
 docs/reference/index.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/reference/index.rst b/docs/reference/index.rst
index 9ecdf619bd..509babef20 100644
--- a/docs/reference/index.rst
+++ b/docs/reference/index.rst
@@ -27,7 +27,7 @@ Supports multiple device configurations by dynamically changing USB descriptors,
 
 -  Audio Class 2.0 (UAC2)
 -  Bluetooth Host Controller Interface (BTH HCI)
--  Communication Device Class (CDC)
+-  Communications Device Class (CDC)
 -  Device Firmware Update (DFU): DFU mode (WIP) and Runtime
 -  Human Interface Device (HID): Generic (In & Out), Keyboard, Mouse, Gamepad etc ...
 -  Mass Storage Class (MSC): with multiple LUNs
@@ -45,8 +45,8 @@ Host Stack
 
 - Human Interface Device (HID): Keyboard, Mouse, Generic
 - Mass Storage Class (MSC)
-- Communication Device Class: CDC-ACM
-- Vendor serial over USB: FTDI, CP210x
+- Communications Device Class (CDC): Abstract Control Model (ACM)
+- Vendor serial over USB: FTDI, CP210x, CH34x, PL230x
 - Hub with multiple-level support
 
 Similar to the Device Stack, if you have a special requirement, `usbh_app_driver_get_cb()` can be used to write your own class driver without modifying the stack.