refactor, rename to schedule function with usbh_call_after_ms() to use with enumeration delay

4 files changed, 179 insertions, 218 deletions

diff --git a/src/common/tusb_private.h b/src/common/tusb_private.h
index 43ce7a1df..5a51dfc37 100644
--- a/src/common/tusb_private.h
+++ b/src/common/tusb_private.h
@@ -24,8 +24,8 @@
  * This file is part of the TinyUSB stack.
  */
 
-#ifndef TUSB_PRIVATE_H_
-#define TUSB_PRIVATE_H_
+#ifndef TUSB_PRIVATE_H
+#define TUSB_PRIVATE_H
 
 // Internal Helper used by Host and Device Stack
 
@@ -33,9 +33,11 @@
  extern "C" {
 #endif
 
-//--------------------------------------------------------------------+
-// Configuration
-//--------------------------------------------------------------------+
+typedef void (*tusb_defer_func_t)(uintptr_t param);
+
+ //--------------------------------------------------------------------+
+ // Configuration
+ //--------------------------------------------------------------------+
 
 #define TUP_USBIP_CONTROLLER_NUM 2
 extern tusb_role_t _tusb_rhport_role[TUP_USBIP_CONTROLLER_NUM];
diff --git a/src/host/usbh.c b/src/host/usbh.c
index f32d1336d..09f6adb15 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -175,9 +175,6 @@ OSAL_QUEUE_DEF(usbh_int_set, _usbh_daqdef, TOTAL_DEVICES, hcd_event_t);
 static osal_queue_t _usbh_daq;
 #endif
 
-// Callback after waiting
-typedef void (*usbh_wait_delay_cb)(void);
-
 // Control transfers: since most controllers do not support multiple control transfers
 // on multiple devices concurrently and control transfers are not used much except for
 // enumeration, we will only execute control transfers one at a time.
@@ -196,14 +193,16 @@ typedef struct {
   uint8_t controller_id;      // controller ID
   uint8_t enumerating_daddr;  // device address of the device being enumerated
   uint8_t attach_debouncing_bm;  // bitmask for roothub port attach debouncing
-  uint8_t enum_failed_count; // see process_enumeration()
   tuh_bus_info_t dev0_bus;    // bus info for dev0 in enumeration
   usbh_ctrl_xfer_info_t ctrl_xfer_info; // control transfer
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-  tuh_xfer_t enum_xfer_retry; // enumeration transfer to retry
-  usbh_wait_delay_cb enum_wait_delay_cb; // continuation function after waiting
-  uint32_t enum_wait_deadline; // ticks when the timer expires
-#endif
+
+  #if CFG_TUSB_OS_HAS_SCHEDULER == 0    // call after only needed for non-scheduler OS
+  struct {
+    tusb_defer_func_t func;
+    uintptr_t         arg;
+    uint32_t          at_ms;
+  } call_after;
+  #endif
 } usbh_data_t;
 
 static usbh_data_t _usbh_data = {
@@ -365,17 +364,18 @@ TU_ATTR_ALWAYS_INLINE static inline bool usbh_setup_send(uint8_t daddr, const ui
   return ret;
 }
 
-TU_ATTR_ALWAYS_INLINE static inline void usbh_wait_delay_ms(uint32_t delay_ms, usbh_wait_delay_cb complete_cb)
-{
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-  TU_LOG_USBH("USBH start timer for %u ms\r\n", (unsigned int)delay_ms);
-  _usbh_data.enum_wait_deadline = tusb_time_millis_api() + delay_ms;
-  _usbh_data.enum_wait_delay_cb = complete_cb;
-#else
-  TU_LOG_USBH("USBH sleep for %u ms\r\n", (unsigned int)delay_ms);
-  tusb_time_delay_ms_api(delay_ms);
-  complete_cb();
-#endif
+// For non-scheduler deferred callback. For scheduler OS: blocking delay then callback
+static void usbh_call_after_ms(uint32_t ms, tusb_defer_func_t func, uintptr_t param) {
+  #if CFG_TUSB_OS_HAS_SCHEDULER
+  TU_LOG_USBH("USBH sleep for %u ms\r\n", (unsigned int)ms);
+  osal_task_delay(ms);
+  func(param);
+  #else
+  TU_LOG_USBH("USBH start timer for %u ms\r\n", (unsigned int)ms);
+  _usbh_data.call_after.func  = func;
+  _usbh_data.call_after.arg   = param;
+  _usbh_data.call_after.at_ms = tusb_time_millis_api() + ms;
+  #endif
 }
 
 TU_ATTR_ALWAYS_INLINE static inline void usbh_device_close(uint8_t rhport, uint8_t daddr) {
@@ -389,9 +389,9 @@ TU_ATTR_ALWAYS_INLINE static inline void usbh_device_close(uint8_t rhport, uint8
   // invalidate if enumerating
   if (daddr == _usbh_data.enumerating_daddr) {
     _usbh_data.enumerating_daddr = TUSB_INDEX_INVALID_8;
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-    _usbh_data.enum_wait_delay_cb = NULL;
-#endif
+  #if CFG_TUSB_OS_HAS_SCHEDULER == 0
+    _usbh_data.call_after.func = NULL;
+  #endif
   }
 }
 
@@ -546,9 +546,6 @@ bool tuh_rhport_init(uint8_t rhport, const tusb_rhport_init_t* rh_init) {
 
     _usbh_data.controller_id = TUSB_INDEX_INVALID_8;
     _usbh_data.enumerating_daddr = TUSB_INDEX_INVALID_8;
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-    _usbh_data.enum_wait_delay_cb = NULL;
-#endif
 
     for (uint8_t i = 0; i < TOTAL_DEVICES; i++) {
       clear_device(&_usbh_devices[i]);
@@ -643,16 +640,16 @@ void tuh_task_ext(uint32_t timeout_ms, bool in_isr) {
     return;
   }
 
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
+#if CFG_TUSB_OS_HAS_SCHEDULER == 0
   // Process continuation function if timer is expired
-  usbh_wait_delay_cb delay_cb = _usbh_data.enum_wait_delay_cb;
-  if (delay_cb) {
-    int32_t ms = (int32_t)(_usbh_data.enum_wait_deadline - tusb_time_millis_api());
+  tusb_defer_func_t after_cb = _usbh_data.call_after.func;
+  if (after_cb) {
+    int32_t ms = (int32_t)(_usbh_data.call_after.at_ms - tusb_time_millis_api());
     if (ms <= 0) {
       // delay expired, run callback now
       TU_LOG_USBH("USBH run timer callback\r\n");
-      _usbh_data.enum_wait_delay_cb = NULL;
-      delay_cb();
+      _usbh_data.call_after.func = NULL;
+      after_cb(_usbh_data.call_after.arg);
     } else if (timeout_ms > (uint32_t)ms) {
       // reduce timeout accordingly
       timeout_ms = (uint32_t)ms;
@@ -1499,10 +1496,9 @@ enum {                                      // USB 2.0 specs 7.1.7 for timing
 enum {
   ENUM_IDLE,
   ENUM_HUB_RERSET,
-  ENUM_HUB_GET_STATUS_AFTER_RESET,
+  ENUM_HUB_RESET_COMPLETE,
   ENUM_HUB_CLEAR_RESET,
   ENUM_HUB_CLEAR_RESET_COMPLETE,
-
   ENUM_ADDR0_DEVICE_DESC,
   ENUM_SET_ADDR,
   ENUM_GET_DEVICE_DESC,
@@ -1521,128 +1517,146 @@ enum {
 };
 
 static uint8_t enum_get_new_address(bool is_hub);
-static bool enum_parse_configuration_desc (uint8_t dev_addr, tusb_desc_configuration_t const* desc_cfg);
-static void enum_full_complete(bool success);
-static void process_enumeration(tuh_xfer_t* xfer);
+static bool    enum_parse_configuration_desc(uint8_t dev_addr, const tusb_desc_configuration_t *desc_cfg);
+static void    enum_full_complete(bool success);
+static void    process_enumeration(tuh_xfer_t *xfer);
 
-// continuation functions after waiting
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-static void enum_after_attempt_delay(void);
-#endif
-static void enum_after_debouncing_delay(void);
-static void enum_after_reset_root_delay(void);
-static void enum_after_reset_root_post_delay(void);
-static void enum_after_reset_recovery_delay(void);
-static void enum_after_set_address_recovery_delay(void);
-#if CFG_TUH_HUB
-static void enum_after_reset_hub_delay(void);
-#endif
+enum {
+  ENUM_AFTER_DEBOUNCING_DELAY,
+  ENUM_AFTER_RESET_ROOT_DELAY,
+  ENUM_AFTER_RESET_ROOT_POST_DELAY,
+  ENUM_AFTER_RESET_HUB_DELAY,
+  ENUM_AFTER_RESET_RECOVERY_DELAY,
+  ENUM_AFTER_SET_ADDRESS_RECOVERY_DELAY,
+};
 
-// start a new enumeration process
-static void enum_new_device(hcd_event_t* event) {
-  tuh_bus_info_t* dev0_bus = &_usbh_data.dev0_bus;
-  dev0_bus->rhport = event->rhport;
-  dev0_bus->hub_addr = event->connection.hub_addr;
-  dev0_bus->hub_port = event->connection.hub_port;
+  // fallthrough to avoid recursive call of enum_async_delay()
+  #if CFG_TUSB_OS_HAS_SCHEDULER
+    #define ENUM_ASYNC_DELAY_OR_FALLTHROUGH(_ms, _state) \
+      osal_task_delay(_ms);                              \
+      TU_ATTR_FALLTHROUGH
+  #else
+    #define ENUM_ASYNC_DELAY_OR_FALLTHROUGH(_ms, _state) \
+      usbh_call_after_ms(_ms, enum_async_delay, _state); \
+      break
+  #endif
 
-  usbh_wait_delay_ms(ENUM_DEBOUNCING_DELAY_MS, enum_after_debouncing_delay);
-}
+// process async delay in enumeration
+static void enum_async_delay(uintptr_t state) {
+  tuh_bus_info_t *dev0_bus = &_usbh_data.dev0_bus;
+  switch (state) {
+    case ENUM_AFTER_DEBOUNCING_DELAY:
+      if (dev0_bus->hub_addr == 0) {
+        // connected directly to roothub
+        _usbh_data.attach_debouncing_bm &= (uint8_t)~TU_BIT(dev0_bus->rhport); // clear roothub debouncing delay
+        if (!hcd_port_connect_status(dev0_bus->rhport)) {
+          TU_LOG_USBH("Device unplugged while debouncing\r\n");
+          enum_full_complete(false);
+          return;
+        }
+        hcd_port_reset(dev0_bus->rhport); // reset port
+        ENUM_ASYNC_DELAY_OR_FALLTHROUGH(ENUM_RESET_ROOT_DELAY_MS, ENUM_AFTER_RESET_ROOT_DELAY);
+      }
+  #if CFG_TUH_HUB
+      else {
+        // connected via hub
+        TU_VERIFY(dev0_bus->hub_port != 0, );
+        TU_ASSERT(hub_port_get_status(dev0_bus->hub_addr, dev0_bus->hub_port, NULL, process_enumeration,
+                                      ENUM_HUB_RERSET), );
+        break;
+      }
+  #endif // hub
 
-static void enum_after_debouncing_delay(void) {
-  tuh_bus_info_t* dev0_bus = &_usbh_data.dev0_bus;
-  if (dev0_bus->hub_addr == 0) {
-    // connected directly to roothub
-    // USB bus not active and frame number is not available yet.
-    // need to depend on tusb_time_millis_api() TODO non blocking
+    case ENUM_AFTER_RESET_ROOT_DELAY:
+      hcd_port_reset_end(dev0_bus->rhport);
+      ENUM_ASYNC_DELAY_OR_FALLTHROUGH(ENUM_RESET_ROOT_POST_DELAY_MS, ENUM_AFTER_RESET_ROOT_POST_DELAY);
 
-    _usbh_data.attach_debouncing_bm &= (uint8_t) ~TU_BIT(dev0_bus->rhport); // clear roothub debouncing delay
+    case ENUM_AFTER_RESET_ROOT_POST_DELAY:
+      if (!hcd_port_connect_status(dev0_bus->rhport)) {
+        // device unplugged while delaying
+        enum_full_complete(false);
+        return;
+      }
 
-    if (!hcd_port_connect_status(dev0_bus->rhport)) {
-      TU_LOG_USBH("Device unplugged while debouncing\r\n");
-      enum_full_complete(false);
-      return;
-    }
+      dev0_bus->speed = hcd_port_speed_get(dev0_bus->rhport);
+      TU_LOG_USBH("%s Speed\r\n", tu_str_speed[dev0_bus->speed]);
 
-    // reset device
-    hcd_port_reset(dev0_bus->rhport);
-    usbh_wait_delay_ms(ENUM_RESET_ROOT_DELAY_MS, enum_after_reset_root_delay);
-  }
-  #if CFG_TUH_HUB
-  else {
-    // connected via hub
-    TU_VERIFY(dev0_bus->hub_port != 0,);
-    TU_ASSERT(hub_port_get_status(dev0_bus->hub_addr, dev0_bus->hub_port, NULL,
-                                  process_enumeration, ENUM_HUB_RERSET),);
-  }
-  #endif // hub
-}
+      // fake transfer to kick-off the enumeration process
+      tuh_xfer_t xfer;
+      xfer.daddr     = 0;
+      xfer.result    = XFER_RESULT_SUCCESS;
+      xfer.user_data = ENUM_ADDR0_DEVICE_DESC;
+      process_enumeration(&xfer);
+      break;
 
-static void enum_after_reset_root_delay(void) {
-  tuh_bus_info_t* dev0_bus = &_usbh_data.dev0_bus;
-  hcd_port_reset_end(dev0_bus->rhport);
-  return usbh_wait_delay_ms(ENUM_RESET_ROOT_POST_DELAY_MS, enum_after_reset_root_post_delay);
-}
+  #if CFG_TUH_HUB
+    case ENUM_AFTER_RESET_HUB_DELAY:
+      // get status after reset complete to check for reset change
+      TU_ASSERT(hub_port_get_status(dev0_bus->hub_addr, dev0_bus->hub_port, NULL, process_enumeration,
+                                    ENUM_HUB_CLEAR_RESET), );
+      break;
+  #endif
 
-static void enum_after_reset_root_post_delay(void) {
-  tuh_bus_info_t* dev0_bus = &_usbh_data.dev0_bus;
-  if (!hcd_port_connect_status(dev0_bus->rhport)) {
-    // device unplugged while delaying
-    enum_full_complete(false);
-    return;
-  }
+    case ENUM_AFTER_RESET_RECOVERY_DELAY:
+      // TODO probably doesn't need to open/close each enumeration
+      if (!usbh_edpt_control_open(0, 8)) {
+        TU_LOG_USBH("Failed to open dev0's control endpoint\r\n");
+        enum_full_complete(false); // Stop enumeration gracefully
+        return;
+      }
+      // Get first 8 bytes of device descriptor for control endpoint size
+      TU_LOG_USBH("Get 8 byte of Device Descriptor\r\n");
+      TU_ASSERT(tuh_descriptor_get_device(0, _usbh_epbuf.ctrl, 8, process_enumeration, ENUM_SET_ADDR), );
+      break;
 
-  dev0_bus->speed = hcd_port_speed_get(dev0_bus->rhport);
-  TU_LOG_USBH("%s Speed\r\n", tu_str_speed[dev0_bus->speed]);
+    case ENUM_AFTER_SET_ADDRESS_RECOVERY_DELAY: {
+      const uint8_t  new_addr = _usbh_data.enumerating_daddr;
+      usbh_device_t *new_dev  = get_device(new_addr);
+      TU_ASSERT(new_dev, );
+      if (!usbh_edpt_control_open(new_addr, new_dev->bMaxPacketSize0)) {
+        TU_LOG_USBH("Failed to open new device's control endpoint\r\n");
+        clear_device(new_dev);
+        enum_full_complete(false);
+        return;
+      }
+      TU_LOG_USBH("Get Device Descriptor\r\n");
+      TU_ASSERT(tuh_descriptor_get_device(new_addr, _usbh_epbuf.ctrl, sizeof(tusb_desc_device_t), process_enumeration,
+                                          ENUM_GET_STRING_LANGUAGE_ID_LEN), );
+      break;
+    }
 
-  // fake transfer to kick-off the enumeration process
-  tuh_xfer_t xfer;
-  xfer.daddr = 0;
-  xfer.result = XFER_RESULT_SUCCESS;
-  xfer.user_data = ENUM_ADDR0_DEVICE_DESC;
-  process_enumeration(&xfer);
+    default:
+      break;
+  }
 }
 
-enum {
-  ATTEMPT_COUNT_MAX = 3,
-  ATTEMPT_DELAY_MS = 100
-};
+// start a new enumeration process
+static void enum_new_device(hcd_event_t *event) {
+  tuh_bus_info_t *dev0_bus = &_usbh_data.dev0_bus;
+  dev0_bus->rhport         = event->rhport;
+  dev0_bus->hub_addr       = event->connection.hub_addr;
+  dev0_bus->hub_port       = event->connection.hub_port;
+  usbh_call_after_ms(ENUM_DEBOUNCING_DELAY_MS, enum_async_delay, ENUM_AFTER_DEBOUNCING_DELAY);
+}
 
 // process device enumeration
-static void process_enumeration(tuh_xfer_t* xfer) {
-  // Retry a few times while enumerating since device can be unstable when starting up
-  _usbh_data.enum_failed_count = 0;
+static void process_enumeration(tuh_xfer_t *xfer) {
   if (XFER_RESULT_FAILED == xfer->result) {
-
-    // retry if not reaching max attempt
-    _usbh_data.enum_failed_count++;
-    bool retry = (_usbh_data.enumerating_daddr != TUSB_INDEX_INVALID_8) && (_usbh_data.enum_failed_count < ATTEMPT_COUNT_MAX);
-    if (retry) {
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-      // save transfer for later
-      _usbh_data.enum_xfer_retry = *xfer;
-      usbh_wait_delay_ms(ATTEMPT_DELAY_MS, enum_after_attempt_delay); // wait for reset to take effect
-#else
-      if (!tuh_control_xfer(xfer))
-	enum_full_complete(false); // complete as failed
-#endif
-    } else {
-      enum_full_complete(false); // complete as failed
-    }
+    enum_full_complete(false); // failed to enum
     return;
   }
-  _usbh_data.enum_failed_count = 0;
 
-  uint8_t const daddr = xfer->daddr;
-  uintptr_t const state = xfer->user_data;
-  usbh_device_t* dev = get_device(daddr);
-  tuh_bus_info_t* dev0_bus = &_usbh_data.dev0_bus;
+  const uint8_t   daddr    = xfer->daddr;
+  const uintptr_t state    = xfer->user_data;
+  usbh_device_t  *dev      = get_device(daddr);
+  tuh_bus_info_t *dev0_bus = &_usbh_data.dev0_bus;
   if (daddr > 0) {
     TU_ASSERT(dev != NULL,);
   }
   uint16_t langid = 0x0409; // default is English
 
   switch (state) {
-    #if CFG_TUH_HUB
+  #if CFG_TUH_HUB
     case ENUM_HUB_RERSET: {
       hub_port_status_response_t port_status;
       hub_port_get_status_local(dev0_bus->hub_addr, dev0_bus->hub_port, &port_status);
@@ -1653,14 +1667,14 @@ static void process_enumeration(tuh_xfer_t* xfer) {
         return;
       }
 
-      TU_ASSERT(hub_port_reset(dev0_bus->hub_addr, dev0_bus->hub_port, process_enumeration, ENUM_HUB_GET_STATUS_AFTER_RESET),);
+      TU_ASSERT(hub_port_reset(dev0_bus->hub_addr, dev0_bus->hub_port, process_enumeration, ENUM_HUB_RESET_COMPLETE), );
       break;
     }
 
-    case ENUM_HUB_GET_STATUS_AFTER_RESET: {
-      usbh_wait_delay_ms(ENUM_RESET_HUB_DELAY_MS, enum_after_reset_hub_delay); // wait for reset to take effect
+    case ENUM_HUB_RESET_COMPLETE:
+      // wait for reset to take effect
+      usbh_call_after_ms(ENUM_RESET_HUB_DELAY_MS, enum_async_delay, ENUM_AFTER_RESET_HUB_DELAY);
       break;
-    }
 
     case ENUM_HUB_CLEAR_RESET: {
       hub_port_status_response_t port_status;
@@ -1687,17 +1701,17 @@ static void process_enumeration(tuh_xfer_t* xfer) {
         return;
       }
 
-      dev0_bus->speed = (port_status.status.high_speed) ? TUSB_SPEED_HIGH :
-                        (port_status.status.low_speed) ? TUSB_SPEED_LOW : TUSB_SPEED_FULL;
+      dev0_bus->speed = (port_status.status.high_speed)  ? TUSB_SPEED_HIGH
+                        : (port_status.status.low_speed) ? TUSB_SPEED_LOW
+                                                         : TUSB_SPEED_FULL;
 
       TU_ATTR_FALLTHROUGH;
     }
-    #endif
+  #endif
 
-    case ENUM_ADDR0_DEVICE_DESC: {
-      usbh_wait_delay_ms(ENUM_RESET_RECOVERY_DELAY_MS, enum_after_reset_recovery_delay);
+    case ENUM_ADDR0_DEVICE_DESC:
+      usbh_call_after_ms(ENUM_RESET_RECOVERY_DELAY_MS, enum_async_delay, ENUM_AFTER_RESET_RECOVERY_DELAY);
       break;
-    }
 
     case ENUM_SET_ADDR: {
       const tusb_desc_device_t *desc_device = (const tusb_desc_device_t *) _usbh_epbuf.ctrl;
@@ -1709,20 +1723,19 @@ static void process_enumeration(tuh_xfer_t* xfer) {
       new_dev->connected = 1;
       new_dev->bMaxPacketSize0 = desc_device->bMaxPacketSize0;
 
-      TU_ASSERT(tuh_address_set(0, new_addr, process_enumeration, ENUM_GET_DEVICE_DESC),);
+      TU_ASSERT(tuh_address_set(0, new_addr, process_enumeration, ENUM_GET_DEVICE_DESC), );
       break;
     }
 
     case ENUM_GET_DEVICE_DESC: {
-      const uint8_t new_addr = (uint8_t) tu_le16toh(xfer->setup->wValue);
-      usbh_device_t* new_dev = get_device(new_addr);
-      TU_ASSERT(new_dev,);
-      new_dev->addressed = 1;
+      const uint8_t  new_addr = (uint8_t)tu_le16toh(xfer->setup->wValue);
+      usbh_device_t *new_dev  = get_device(new_addr);
+      TU_ASSERT(new_dev, );
+      new_dev->addressed           = 1;
       _usbh_data.enumerating_daddr = new_addr;
 
       usbh_device_close(dev0_bus->rhport, 0); // close dev0
-
-      usbh_wait_delay_ms(ENUM_SET_ADDRESS_RECOVERY_DELAY_MS, enum_after_set_address_recovery_delay);
+      usbh_call_after_ms(ENUM_SET_ADDRESS_RECOVERY_DELAY_MS, enum_async_delay, ENUM_AFTER_SET_ADDRESS_RECOVERY_DELAY);
       break;
     }
 
@@ -1896,53 +1909,6 @@ static void process_enumeration(tuh_xfer_t* xfer) {
   }
 }
 
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-static void enum_after_attempt_delay(void) {
-  TU_LOG_USBH("Enumeration attempt %u/%u\r\n", _usbh_data.enum_failed_count+1, ATTEMPT_COUNT_MAX);
-  if (!tuh_control_xfer(&_usbh_data.enum_xfer_retry))
-    enum_full_complete(false); // complete as failed
-}
-#endif
-
-static void enum_after_set_address_recovery_delay(void) {
-  const uint8_t new_addr =_usbh_data.enumerating_daddr;
-  usbh_device_t* new_dev = get_device(new_addr);
-  TU_ASSERT(new_dev,);
-  if (!usbh_edpt_control_open(new_addr, new_dev->bMaxPacketSize0)) { // open new control endpoint
-    // Stop enumeration gracefully
-    clear_device(new_dev);
-    enum_full_complete(false);
-    TU_ASSERT(false,);
-  }
-
-  TU_LOG_USBH("Get Device Descriptor\r\n");
-  TU_ASSERT(tuh_descriptor_get_device(new_addr, _usbh_epbuf.ctrl, sizeof(tusb_desc_device_t),
-                                      process_enumeration, ENUM_GET_STRING_LANGUAGE_ID_LEN),);
-}
-
-static void enum_after_reset_recovery_delay(void) {
-  // TODO probably doesn't need to open/close each enumeration
-  uint8_t const addr0 = 0;
-  if (!usbh_edpt_control_open(addr0, 8)) {
-    // Stop enumeration gracefully
-    enum_full_complete(false);
-    TU_ASSERT(false,);
-  }
-
-  // Get first 8 bytes of device descriptor for control endpoint size
-  TU_LOG_USBH("Get 8 byte of Device Descriptor\r\n");
-  TU_ASSERT(tuh_descriptor_get_device(addr0, _usbh_epbuf.ctrl, 8,
-                                      process_enumeration, ENUM_SET_ADDR),);
-}
-
-#if CFG_TUH_HUB
-static void enum_after_reset_hub_delay(void) {
-  tuh_bus_info_t* dev0_bus = &_usbh_data.dev0_bus;
-  // get status to check for reset change
-  TU_ASSERT(hub_port_get_status(dev0_bus->hub_addr, dev0_bus->hub_port, NULL, process_enumeration, ENUM_HUB_CLEAR_RESET),);
-}
-#endif
-
 static uint8_t enum_get_new_address(bool is_hub) {
   uint8_t start;
   uint8_t end;
@@ -2060,13 +2026,13 @@ void usbh_driver_set_config_complete(uint8_t dev_addr, uint8_t itf_num) {
 
 static void enum_full_complete(bool success) {
   (void)success;
-  // mark enumeration as complete
-  _usbh_data.enumerating_daddr = TUSB_INDEX_INVALID_8;
-#if CFG_TUH_TASK_USE_TIME_MILLIS_API
-  _usbh_data.enum_wait_delay_cb = NULL;
-#endif
 
-#if CFG_TUH_HUB
+  _usbh_data.enumerating_daddr = TUSB_INDEX_INVALID_8; // mark enumeration as complete
+  #if CFG_TUSB_OS_HAS_SCHEDULER == 0
+  _usbh_data.call_after.func = NULL;
+  #endif
+
+  #if CFG_TUH_HUB
   // Hub status is already requested in case of successful enumeration
   if (_usbh_data.dev0_bus.hub_addr != 0 && !success) {
     hub_edpt_status_xfer(_usbh_data.dev0_bus.hub_addr); // get next hub status
diff --git a/src/host/usbh_pvt.h b/src/host/usbh_pvt.h
index 57428e3c5..ecb692e9d 100644
--- a/src/host/usbh_pvt.h
+++ b/src/host/usbh_pvt.h
@@ -68,6 +68,7 @@ uint8_t* usbh_get_enum_buf(void);
 
 void usbh_int_set(bool enabled);
 
+// Invoke this function later in tuh_task() by putting it into task queue
 void usbh_defer_func(osal_task_func_t func, void *param, bool in_isr);
 
 void usbh_spin_lock(bool in_isr);
diff --git a/src/tusb_option.h b/src/tusb_option.h
index 2cac501f7..44ba8879a 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -469,7 +469,6 @@
   #define TUP_MCU_STRICT_ALIGN   0
 #endif
 
-
 //--------------------------------------------------------------------+
 // Common Options (Default)
 //--------------------------------------------------------------------+
@@ -514,6 +513,10 @@
   #define CFG_TUSB_OS           OPT_OS_NONE
 #endif
 
+#ifndef CFG_TUSB_OS_HAS_SCHEDULER
+  #define CFG_TUSB_OS_HAS_SCHEDULER (CFG_TUSB_OS != OPT_OS_NONE && CFG_TUSB_OS != OPT_OS_PICO)
+#endif
+
 #ifndef CFG_TUSB_OS_INC_PATH
   #ifndef CFG_TUSB_OS_INC_PATH_DEFAULT
   #define CFG_TUSB_OS_INC_PATH_DEFAULT
@@ -698,17 +701,6 @@
   #define CFG_TUH_TASK_EVENTS_PER_RUN  16
 #endif
 
-// use tusb_time_millis_api() instead of tusb_time_delay_ms_api() in tuh_task()
-// tuh_task_ext() will be asynchronous and never sleep in tusb_time_delay_ms_api()
-#ifndef CFG_TUH_TASK_USE_TIME_MILLIS_API
-  #if CFG_TUSB_OS == OPT_OS_RTX4 || CFG_TUSB_OS == OPT_OS_PICO || defined(ESP_PLATFORM)
-    // these boards/os do not implements the required tusb_time_millis_api()
-    #define CFG_TUH_TASK_USE_TIME_MILLIS_API  0
-  #else
-    #define CFG_TUH_TASK_USE_TIME_MILLIS_API  1
-  #endif
-#endif
-
 //------------- CLASS -------------//
 
 #ifndef CFG_TUH_HUB