mirror/tinyusb
3
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2026-03-11 10:04:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
hathach
2026-02-26 14:33:04 +07:00
parent 942479407e
commit 56fca0076a
4 changed files with 189 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/common/tusb_private.h
View File

@ -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];

388
src/host/usbh.c
View File

@ -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);
// 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
// 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_wait_delay_ms(ENUM_DEBOUNCING_DELAY_MS, enum_after_debouncing_delay);
}
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
_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;
}
// 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
}
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);
}
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;
}
dev0_bus->speed = hcd_port_speed_get(dev0_bus->rhport);
TU_LOG_USBH("%s Speed\r\n", tu_str_speed[dev0_bus->speed]);
// 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);
}
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);
enum {
ATTEMPT_COUNT_MAX = 3,
ATTEMPT_DELAY_MS = 100
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,
};
// 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;
if (XFER_RESULT_FAILED == xfer->result) {
// 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
// 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
// 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
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);
case ENUM_AFTER_RESET_ROOT_POST_DELAY:
if (!hcd_port_connect_status(dev0_bus->rhport)) {
// device unplugged while delaying
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]);
// 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;
#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
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;
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;
}
default:
break;
}
}
// 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) {
if (XFER_RESULT_FAILED == xfer->result) {
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

1
src/host/usbh_pvt.h
View File

@ -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);

16
src/tusb_option.h
View File

@ -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