kingkevin
/
passkey_fw
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2516 from hathach/minor-code-format 

Minor code format
This commit is contained in:
Ha Thach 2024-03-12 16:55:00 +07:00 committed by GitHub
parent a0e5626bc5 2a4b27ed33
commit 6b7ceed25c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 363 additions and 504 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
examples/device/cdc_dual_ports/src/main.c
View File

@ -31,12 +31,24 @@
#include "bsp/board_api.h" #include "bsp/board_api.h"
#include "tusb.h" #include "tusb.h"
//------------- prototypes -------------// /* Blink pattern
* - 250 ms : device not mounted
* - 1000 ms : device mounted
* - 2500 ms : device is suspended
*/
enum {
BLINK_NOT_MOUNTED = 250,
BLINK_MOUNTED = 1000,
BLINK_SUSPENDED = 2500,
};
static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED;
static void led_blinking_task(void);
static void cdc_task(void); static void cdc_task(void);
/*------------- MAIN -------------*/ /*------------- MAIN -------------*/
int main(void) int main(void) {
{
board_init(); board_init();
// init device stack on configured roothub port // init device stack on configured roothub port
@ -46,28 +58,23 @@ int main(void)
board_init_after_tusb(); board_init_after_tusb();
} }
while (1) while (1) {
{
tud_task(); // tinyusb device task tud_task(); // tinyusb device task
cdc_task(); cdc_task();
led_blinking_task();
} }
} }
// echo to either Serial0 or Serial1 // echo to either Serial0 or Serial1
// with Serial0 as all lower case, Serial1 as all upper case // with Serial0 as all lower case, Serial1 as all upper case
static void echo_serial_port(uint8_t itf, uint8_t buf[], uint32_t count) static void echo_serial_port(uint8_t itf, uint8_t buf[], uint32_t count) {
{
uint8_t const case_diff = 'a' - 'A'; uint8_t const case_diff = 'a' - 'A';
for(uint32_t i=0; i<count; i++) for (uint32_t i = 0; i < count; i++) {
{ if (itf == 0) {
if (itf == 0)
{
// echo back 1st port as lower case // echo back 1st port as lower case
if (isupper(buf[i])) buf[i] += case_diff; if (isupper(buf[i])) buf[i] += case_diff;
} } else {
else
{
// echo back 2nd port as upper case // echo back 2nd port as upper case
if (islower(buf[i])) buf[i] -= case_diff; if (islower(buf[i])) buf[i] -= case_diff;
} }
@ -77,21 +84,29 @@ static void echo_serial_port(uint8_t itf, uint8_t buf[], uint32_t count)
tud_cdc_n_write_flush(itf); tud_cdc_n_write_flush(itf);
} }
// Invoked when device is mounted
void tud_mount_cb(void) {
blink_interval_ms = BLINK_MOUNTED;
}
// Invoked when device is unmounted
void tud_umount_cb(void) {
blink_interval_ms = BLINK_NOT_MOUNTED;
}
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// USB CDC // USB CDC
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
static void cdc_task(void) static void cdc_task(void) {
{
uint8_t itf; uint8_t itf;
for (itf = 0; itf < CFG_TUD_CDC; itf++) for (itf = 0; itf < CFG_TUD_CDC; itf++) {
{
// connected() check for DTR bit // connected() check for DTR bit
// Most but not all terminal client set this when making connection // Most but not all terminal client set this when making connection
// if ( tud_cdc_n_connected(itf) ) // if ( tud_cdc_n_connected(itf) )
{ {
if ( tud_cdc_n_available(itf) ) if (tud_cdc_n_available(itf)) {
{
uint8_t buf[64]; uint8_t buf[64];
uint32_t count = tud_cdc_n_read(itf, buf, sizeof(buf)); uint32_t count = tud_cdc_n_read(itf, buf, sizeof(buf));
@ -103,3 +118,18 @@ static void cdc_task(void)
} }
} }
} }
//--------------------------------------------------------------------+
// BLINKING TASK
//--------------------------------------------------------------------+
void led_blinking_task(void) {
static uint32_t start_ms = 0;
static bool led_state = false;
// Blink every interval ms
if (board_millis() - start_ms < blink_interval_ms) return; // not enough time
start_ms += blink_interval_ms;
board_led_write(led_state);
led_state = 1 - led_state; // toggle
}

306
src/device/usbd.c
View File

@ -372,10 +372,9 @@ bool tud_inited(void) {
return _usbd_rhport != RHPORT_INVALID; return _usbd_rhport != RHPORT_INVALID;
} }
bool tud_init (uint8_t rhport) bool tud_init(uint8_t rhport) {
{
// skip if already initialized // skip if already initialized
if ( tud_inited() ) return true; if (tud_inited()) return true;
TU_LOG_USBD("USBD init on controller %u\r\n", rhport); TU_LOG_USBD("USBD init on controller %u\r\n", rhport);
TU_LOG_INT(CFG_TUD_LOG_LEVEL, sizeof(usbd_device_t)); TU_LOG_INT(CFG_TUD_LOG_LEVEL, sizeof(usbd_device_t));
@ -395,15 +394,13 @@ bool tud_init (uint8_t rhport)
TU_ASSERT(_usbd_q); TU_ASSERT(_usbd_q);
// Get application driver if available // Get application driver if available
if ( usbd_app_driver_get_cb ) if (usbd_app_driver_get_cb) {
{
_app_driver = usbd_app_driver_get_cb(&_app_driver_count); _app_driver = usbd_app_driver_get_cb(&_app_driver_count);
} }
// Init class drivers // Init class drivers
for (uint8_t i = 0; i < TOTAL_DRIVER_COUNT; i++) for (uint8_t i = 0; i < TOTAL_DRIVER_COUNT; i++) {
{ usbd_class_driver_t const* driver = get_driver(i);
usbd_class_driver_t const * driver = get_driver(i);
TU_ASSERT(driver); TU_ASSERT(driver);
TU_LOG_USBD("%s init\r\n", driver->name); TU_LOG_USBD("%s init\r\n", driver->name);
driver->init(); driver->init();
@ -418,31 +415,26 @@ bool tud_init (uint8_t rhport)
return true; return true;
} }
static void configuration_reset(uint8_t rhport) static void configuration_reset(uint8_t rhport) {
{ for (uint8_t i = 0; i < TOTAL_DRIVER_COUNT; i++) {
for ( uint8_t i = 0; i < TOTAL_DRIVER_COUNT; i++ ) usbd_class_driver_t const* driver = get_driver(i);
{ TU_ASSERT(driver,);
usbd_class_driver_t const * driver = get_driver(i);
TU_ASSERT(driver, );
driver->reset(rhport); driver->reset(rhport);
} }
tu_varclr(&_usbd_dev); tu_varclr(&_usbd_dev);
memset(_usbd_dev.itf2drv, DRVID_INVALID, sizeof(_usbd_dev.itf2drv)); // invalid mapping memset(_usbd_dev.itf2drv, DRVID_INVALID, sizeof(_usbd_dev.itf2drv)); // invalid mapping
memset(_usbd_dev.ep2drv , DRVID_INVALID, sizeof(_usbd_dev.ep2drv )); // invalid mapping memset(_usbd_dev.ep2drv, DRVID_INVALID, sizeof(_usbd_dev.ep2drv)); // invalid mapping
} }
static void usbd_reset(uint8_t rhport) static void usbd_reset(uint8_t rhport) {
{
configuration_reset(rhport); configuration_reset(rhport);
usbd_control_reset(); usbd_control_reset();
} }
bool tud_task_event_ready(void) bool tud_task_event_ready(void) {
{
// Skip if stack is not initialized // Skip if stack is not initialized
if ( !tud_inited() ) return false; if (!tud_inited()) return false;
return !osal_queue_empty(_usbd_q); return !osal_queue_empty(_usbd_q);
} }
@ -450,53 +442,44 @@ bool tud_task_event_ready(void)
* This top level thread manages all device controller event and delegates events to class-specific drivers. * This top level thread manages all device controller event and delegates events to class-specific drivers.
* This should be called periodically within the mainloop or rtos thread. * This should be called periodically within the mainloop or rtos thread.
* *
@code int main(void) {
int main(void)
{
application_init(); application_init();
tusb_init(); tusb_init();
while(1) // the mainloop while(1) { // the mainloop
{
application_code(); application_code();
tud_task(); // tinyusb device task tud_task(); // tinyusb device task
} }
} }
@endcode
*/ */
void tud_task_ext(uint32_t timeout_ms, bool in_isr) void tud_task_ext(uint32_t timeout_ms, bool in_isr) {
{
(void) in_isr; // not implemented yet (void) in_isr; // not implemented yet
// Skip if stack is not initialized // Skip if stack is not initialized
if ( !tud_inited() ) return; if (!tud_inited()) return;
// Loop until there is no more events in the queue // Loop until there is no more events in the queue
while (1) while (1) {
{
dcd_event_t event; dcd_event_t event;
if ( !osal_queue_receive(_usbd_q, &event, timeout_ms) ) return; if (!osal_queue_receive(_usbd_q, &event, timeout_ms)) return;
#if CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL #if CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL
if (event.event_id == DCD_EVENT_SETUP_RECEIVED) TU_LOG_USBD("\r\n"); // extra line for setup if (event.event_id == DCD_EVENT_SETUP_RECEIVED) TU_LOG_USBD("\r\n"); // extra line for setup
TU_LOG_USBD("USBD %s ", event.event_id < DCD_EVENT_COUNT ? _usbd_event_str[event.event_id] : "CORRUPTED"); TU_LOG_USBD("USBD %s ", event.event_id < DCD_EVENT_COUNT ? _usbd_event_str[event.event_id] : "CORRUPTED");
#endif #endif
switch ( event.event_id ) switch (event.event_id) {
{
case DCD_EVENT_BUS_RESET: case DCD_EVENT_BUS_RESET:
TU_LOG_USBD(": %s Speed\r\n", tu_str_speed[event.bus_reset.speed]); TU_LOG_USBD(": %s Speed\r\n", tu_str_speed[event.bus_reset.speed]);
usbd_reset(event.rhport); usbd_reset(event.rhport);
_usbd_dev.speed = event.bus_reset.speed; _usbd_dev.speed = event.bus_reset.speed;
break; break;
case DCD_EVENT_UNPLUGGED: case DCD_EVENT_UNPLUGGED:
TU_LOG_USBD("\r\n"); TU_LOG_USBD("\r\n");
usbd_reset(event.rhport); usbd_reset(event.rhport);
// invoke callback
if (tud_umount_cb) tud_umount_cb(); if (tud_umount_cb) tud_umount_cb();
break; break;
case DCD_EVENT_SETUP_RECEIVED: case DCD_EVENT_SETUP_RECEIVED:
TU_LOG_BUF(CFG_TUD_LOG_LEVEL, &event.setup_received, 8); TU_LOG_BUF(CFG_TUD_LOG_LEVEL, &event.setup_received, 8);
@ -508,81 +491,72 @@ void tud_task_ext(uint32_t timeout_ms, bool in_isr)
// mark both in & out control as free // mark both in & out control as free
_usbd_dev.ep_status[0][TUSB_DIR_OUT].busy = 0; _usbd_dev.ep_status[0][TUSB_DIR_OUT].busy = 0;
_usbd_dev.ep_status[0][TUSB_DIR_OUT].claimed = 0; _usbd_dev.ep_status[0][TUSB_DIR_OUT].claimed = 0;
_usbd_dev.ep_status[0][TUSB_DIR_IN ].busy = 0; _usbd_dev.ep_status[0][TUSB_DIR_IN].busy = 0;
_usbd_dev.ep_status[0][TUSB_DIR_IN ].claimed = 0; _usbd_dev.ep_status[0][TUSB_DIR_IN].claimed = 0;
// Process control request // Process control request
if ( !process_control_request(event.rhport, &event.setup_received) ) if (!process_control_request(event.rhport, &event.setup_received)) {
{
TU_LOG_USBD(" Stall EP0\r\n"); TU_LOG_USBD(" Stall EP0\r\n");
// Failed -> stall both control endpoint IN and OUT // Failed -> stall both control endpoint IN and OUT
dcd_edpt_stall(event.rhport, 0); dcd_edpt_stall(event.rhport, 0);
dcd_edpt_stall(event.rhport, 0 | TUSB_DIR_IN_MASK); dcd_edpt_stall(event.rhport, 0 | TUSB_DIR_IN_MASK);
} }
break; break;
case DCD_EVENT_XFER_COMPLETE: case DCD_EVENT_XFER_COMPLETE: {
{
// Invoke the class callback associated with the endpoint address // Invoke the class callback associated with the endpoint address
uint8_t const ep_addr = event.xfer_complete.ep_addr; uint8_t const ep_addr = event.xfer_complete.ep_addr;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const ep_dir = tu_edpt_dir(ep_addr); uint8_t const ep_dir = tu_edpt_dir(ep_addr);
TU_LOG_USBD("on EP %02X with %u bytes\r\n", ep_addr, (unsigned int) event.xfer_complete.len); TU_LOG_USBD("on EP %02X with %u bytes\r\n", ep_addr, (unsigned int) event.xfer_complete.len);
_usbd_dev.ep_status[epnum][ep_dir].busy = 0; _usbd_dev.ep_status[epnum][ep_dir].busy = 0;
_usbd_dev.ep_status[epnum][ep_dir].claimed = 0; _usbd_dev.ep_status[epnum][ep_dir].claimed = 0;
if ( 0 == epnum ) if (0 == epnum) {
{ usbd_control_xfer_cb(event.rhport, ep_addr, (xfer_result_t) event.xfer_complete.result,
usbd_control_xfer_cb(event.rhport, ep_addr, (xfer_result_t) event.xfer_complete.result, event.xfer_complete event.xfer_complete.len);
.len); } else {
} usbd_class_driver_t const* driver = get_driver(_usbd_dev.ep2drv[epnum][ep_dir]);
else TU_ASSERT(driver,);
{
usbd_class_driver_t const * driver = get_driver( _usbd_dev.ep2drv[epnum][ep_dir] );
TU_ASSERT(driver, );
TU_LOG_USBD(" %s xfer callback\r\n", driver->name); TU_LOG_USBD(" %s xfer callback\r\n", driver->name);
driver->xfer_cb(event.rhport, ep_addr, (xfer_result_t) event.xfer_complete.result, event.xfer_complete.len); driver->xfer_cb(event.rhport, ep_addr, (xfer_result_t) event.xfer_complete.result, event.xfer_complete.len);
} }
break;
} }
break;
case DCD_EVENT_SUSPEND: case DCD_EVENT_SUSPEND:
// NOTE: When plugging/unplugging device, the D+/D- state are unstable and // NOTE: When plugging/unplugging device, the D+/D- state are unstable and
// can accidentally meet the SUSPEND condition ( Bus Idle for 3ms ), which result in a series of event // can accidentally meet the SUSPEND condition ( Bus Idle for 3ms ), which result in a series of event
// e.g suspend -> resume -> unplug/plug. Skip suspend/resume if not connected // e.g suspend -> resume -> unplug/plug. Skip suspend/resume if not connected
if ( _usbd_dev.connected ) if (_usbd_dev.connected) {
{
TU_LOG_USBD(": Remote Wakeup = %u\r\n", _usbd_dev.remote_wakeup_en); TU_LOG_USBD(": Remote Wakeup = %u\r\n", _usbd_dev.remote_wakeup_en);
if (tud_suspend_cb) tud_suspend_cb(_usbd_dev.remote_wakeup_en); if (tud_suspend_cb) tud_suspend_cb(_usbd_dev.remote_wakeup_en);
}else } else {
{
TU_LOG_USBD(" Skipped\r\n"); TU_LOG_USBD(" Skipped\r\n");
} }
break; break;
case DCD_EVENT_RESUME: case DCD_EVENT_RESUME:
if ( _usbd_dev.connected ) if (_usbd_dev.connected) {
{
TU_LOG_USBD("\r\n"); TU_LOG_USBD("\r\n");
if (tud_resume_cb) tud_resume_cb(); if (tud_resume_cb) tud_resume_cb();
}else } else {
{
TU_LOG_USBD(" Skipped\r\n"); TU_LOG_USBD(" Skipped\r\n");
} }
break; break;
case USBD_EVENT_FUNC_CALL: case USBD_EVENT_FUNC_CALL:
TU_LOG_USBD("\r\n"); TU_LOG_USBD("\r\n");
if ( event.func_call.func ) event.func_call.func(event.func_call.param); if (event.func_call.func) event.func_call.func(event.func_call.param);
break; break;
case DCD_EVENT_SOF: case DCD_EVENT_SOF:
default: default:
TU_BREAKPOINT(); TU_BREAKPOINT();
break; break;
} }
#if CFG_TUSB_OS != OPT_OS_NONE && CFG_TUSB_OS != OPT_OS_PICO #if CFG_TUSB_OS != OPT_OS_NONE && CFG_TUSB_OS != OPT_OS_PICO
@ -597,8 +571,7 @@ void tud_task_ext(uint32_t timeout_ms, bool in_isr)
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Helper to invoke class driver control request handler // Helper to invoke class driver control request handler
static bool invoke_class_control(uint8_t rhport, usbd_class_driver_t const * driver, tusb_control_request_t const * request) static bool invoke_class_control(uint8_t rhport, usbd_class_driver_t const * driver, tusb_control_request_t const * request) {
{
usbd_control_set_complete_callback(driver->control_xfer_cb); usbd_control_set_complete_callback(driver->control_xfer_cb);
TU_LOG_USBD(" %s control request\r\n", driver->name); TU_LOG_USBD(" %s control request\r\n", driver->name);
return driver->control_xfer_cb(rhport, CONTROL_STAGE_SETUP, request); return driver->control_xfer_cb(rhport, CONTROL_STAGE_SETUP, request);
@ -606,15 +579,12 @@ static bool invoke_class_control(uint8_t rhport, usbd_class_driver_t const * dri
// This handles the actual request and its response. // This handles the actual request and its response.
// return false will cause its caller to stall control endpoint // return false will cause its caller to stall control endpoint
static bool process_control_request(uint8_t rhport, tusb_control_request_t const * p_request) static bool process_control_request(uint8_t rhport, tusb_control_request_t const * p_request) {
{
usbd_control_set_complete_callback(NULL); usbd_control_set_complete_callback(NULL);
TU_ASSERT(p_request->bmRequestType_bit.type < TUSB_REQ_TYPE_INVALID); TU_ASSERT(p_request->bmRequestType_bit.type < TUSB_REQ_TYPE_INVALID);
// Vendor request // Vendor request
if ( p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_VENDOR ) if ( p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_VENDOR ) {
{
TU_VERIFY(tud_vendor_control_xfer_cb); TU_VERIFY(tud_vendor_control_xfer_cb);
usbd_control_set_complete_callback(tud_vendor_control_xfer_cb); usbd_control_set_complete_callback(tud_vendor_control_xfer_cb);
@ -622,19 +592,16 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
} }
#if CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL #if CFG_TUSB_DEBUG >= CFG_TUD_LOG_LEVEL
if (TUSB_REQ_TYPE_STANDARD == p_request->bmRequestType_bit.type && p_request->bRequest <= TUSB_REQ_SYNCH_FRAME) if (TUSB_REQ_TYPE_STANDARD == p_request->bmRequestType_bit.type && p_request->bRequest <= TUSB_REQ_SYNCH_FRAME) {
{
TU_LOG_USBD(" %s", tu_str_std_request[p_request->bRequest]); TU_LOG_USBD(" %s", tu_str_std_request[p_request->bRequest]);
if (TUSB_REQ_GET_DESCRIPTOR != p_request->bRequest) TU_LOG_USBD("\r\n"); if (TUSB_REQ_GET_DESCRIPTOR != p_request->bRequest) TU_LOG_USBD("\r\n");
} }
#endif #endif
switch ( p_request->bmRequestType_bit.recipient ) switch ( p_request->bmRequestType_bit.recipient ) {
{
//------------- Device Requests e.g in enumeration -------------// //------------- Device Requests e.g in enumeration -------------//
case TUSB_REQ_RCPT_DEVICE: case TUSB_REQ_RCPT_DEVICE:
if ( TUSB_REQ_TYPE_CLASS == p_request->bmRequestType_bit.type ) if ( TUSB_REQ_TYPE_CLASS == p_request->bmRequestType_bit.type ) {
{
uint8_t const itf = tu_u16_low(p_request->wIndex); uint8_t const itf = tu_u16_low(p_request->wIndex);
TU_VERIFY(itf < TU_ARRAY_SIZE(_usbd_dev.itf2drv)); TU_VERIFY(itf < TU_ARRAY_SIZE(_usbd_dev.itf2drv));
@ -645,15 +612,13 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
return invoke_class_control(rhport, driver, p_request); return invoke_class_control(rhport, driver, p_request);
} }
if ( TUSB_REQ_TYPE_STANDARD != p_request->bmRequestType_bit.type ) if ( TUSB_REQ_TYPE_STANDARD != p_request->bmRequestType_bit.type ) {
{
// Non standard request is not supported // Non standard request is not supported
TU_BREAKPOINT(); TU_BREAKPOINT();
return false; return false;
} }
switch ( p_request->bRequest ) switch ( p_request->bRequest ) {
{
case TUSB_REQ_SET_ADDRESS: case TUSB_REQ_SET_ADDRESS:
// Depending on mcu, status phase could be sent either before or after changing device address, // Depending on mcu, status phase could be sent either before or after changing device address,
// or even require stack to not response with status at all // or even require stack to not response with status at all
@ -664,22 +629,18 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
_usbd_dev.addressed = 1; _usbd_dev.addressed = 1;
break; break;
case TUSB_REQ_GET_CONFIGURATION: case TUSB_REQ_GET_CONFIGURATION: {
{
uint8_t cfg_num = _usbd_dev.cfg_num; uint8_t cfg_num = _usbd_dev.cfg_num;
tud_control_xfer(rhport, p_request, &cfg_num, 1); tud_control_xfer(rhport, p_request, &cfg_num, 1);
} }
break; break;
case TUSB_REQ_SET_CONFIGURATION: case TUSB_REQ_SET_CONFIGURATION: {
{
uint8_t const cfg_num = (uint8_t) p_request->wValue; uint8_t const cfg_num = (uint8_t) p_request->wValue;
// Only process if new configure is different // Only process if new configure is different
if (_usbd_dev.cfg_num != cfg_num) if (_usbd_dev.cfg_num != cfg_num) {
{ if ( _usbd_dev.cfg_num ) {
if ( _usbd_dev.cfg_num )
{
// already configured: need to clear all endpoints and driver first // already configured: need to clear all endpoints and driver first
TU_LOG_USBD(" Clear current Configuration (%u) before switching\r\n", _usbd_dev.cfg_num); TU_LOG_USBD(" Clear current Configuration (%u) before switching\r\n", _usbd_dev.cfg_num);
@ -694,15 +655,11 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
} }
// Handle the new configuration and execute the corresponding callback // Handle the new configuration and execute the corresponding callback
if ( cfg_num ) if ( cfg_num ) {
{
// switch to new configuration if not zero // switch to new configuration if not zero
TU_ASSERT( process_set_config(rhport, cfg_num) ); TU_ASSERT( process_set_config(rhport, cfg_num) );
if ( tud_mount_cb ) tud_mount_cb(); if ( tud_mount_cb ) tud_mount_cb();
} } else {
else
{
if ( tud_umount_cb ) tud_umount_cb(); if ( tud_umount_cb ) tud_umount_cb();
} }
} }
@ -738,15 +695,14 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
tud_control_status(rhport, p_request); tud_control_status(rhport, p_request);
break; break;
case TUSB_REQ_GET_STATUS: case TUSB_REQ_GET_STATUS: {
{
// Device status bit mask // Device status bit mask
// - Bit 0: Self Powered // - Bit 0: Self Powered
// - Bit 1: Remote Wakeup enabled // - Bit 1: Remote Wakeup enabled
uint16_t status = (uint16_t) ((_usbd_dev.self_powered ? 1u : 0u) | (_usbd_dev.remote_wakeup_en ? 2u : 0u)); uint16_t status = (uint16_t) ((_usbd_dev.self_powered ? 1u : 0u) | (_usbd_dev.remote_wakeup_en ? 2u : 0u));
tud_control_xfer(rhport, p_request, &status, 2); tud_control_xfer(rhport, p_request, &status, 2);
break;
} }
break;
// Unknown/Unsupported request // Unknown/Unsupported request
default: TU_BREAKPOINT(); return false; default: TU_BREAKPOINT(); return false;
@ -754,8 +710,7 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
break; break;
//------------- Class/Interface Specific Request -------------// //------------- Class/Interface Specific Request -------------//
case TUSB_REQ_RCPT_INTERFACE: case TUSB_REQ_RCPT_INTERFACE: {
{
uint8_t const itf = tu_u16_low(p_request->wIndex); uint8_t const itf = tu_u16_low(p_request->wIndex);
TU_VERIFY(itf < TU_ARRAY_SIZE(_usbd_dev.itf2drv)); TU_VERIFY(itf < TU_ARRAY_SIZE(_usbd_dev.itf2drv));
@ -764,25 +719,21 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
// all requests to Interface (STD or Class) is forwarded to class driver. // all requests to Interface (STD or Class) is forwarded to class driver.
// notable requests are: GET HID REPORT DESCRIPTOR, SET_INTERFACE, GET_INTERFACE // notable requests are: GET HID REPORT DESCRIPTOR, SET_INTERFACE, GET_INTERFACE
if ( !invoke_class_control(rhport, driver, p_request) ) if ( !invoke_class_control(rhport, driver, p_request) ) {
{
// For GET_INTERFACE and SET_INTERFACE, it is mandatory to respond even if the class // For GET_INTERFACE and SET_INTERFACE, it is mandatory to respond even if the class
// driver doesn't use alternate settings or implement this // driver doesn't use alternate settings or implement this
TU_VERIFY(TUSB_REQ_TYPE_STANDARD == p_request->bmRequestType_bit.type); TU_VERIFY(TUSB_REQ_TYPE_STANDARD == p_request->bmRequestType_bit.type);
switch(p_request->bRequest) switch(p_request->bRequest) {
{
case TUSB_REQ_GET_INTERFACE: case TUSB_REQ_GET_INTERFACE:
case TUSB_REQ_SET_INTERFACE: case TUSB_REQ_SET_INTERFACE:
// Clear complete callback if driver set since it can also stall the request. // Clear complete callback if driver set since it can also stall the request.
usbd_control_set_complete_callback(NULL); usbd_control_set_complete_callback(NULL);
if (TUSB_REQ_GET_INTERFACE == p_request->bRequest) if (TUSB_REQ_GET_INTERFACE == p_request->bRequest) {
{
uint8_t alternate = 0; uint8_t alternate = 0;
tud_control_xfer(rhport, p_request, &alternate, 1); tud_control_xfer(rhport, p_request, &alternate, 1);
}else }else {
{
tud_control_status(rhport, p_request); tud_control_status(rhport, p_request);
} }
break; break;
@ -790,54 +741,42 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
default: return false; default: return false;
} }
} }
break;
} }
break;
//------------- Endpoint Request -------------// //------------- Endpoint Request -------------//
case TUSB_REQ_RCPT_ENDPOINT: case TUSB_REQ_RCPT_ENDPOINT: {
{
uint8_t const ep_addr = tu_u16_low(p_request->wIndex); uint8_t const ep_addr = tu_u16_low(p_request->wIndex);
uint8_t const ep_num = tu_edpt_number(ep_addr); uint8_t const ep_num = tu_edpt_number(ep_addr);
uint8_t const ep_dir = tu_edpt_dir(ep_addr); uint8_t const ep_dir = tu_edpt_dir(ep_addr);
TU_ASSERT(ep_num < TU_ARRAY_SIZE(_usbd_dev.ep2drv) ); TU_ASSERT(ep_num < TU_ARRAY_SIZE(_usbd_dev.ep2drv) );
usbd_class_driver_t const * driver = get_driver(_usbd_dev.ep2drv[ep_num][ep_dir]); usbd_class_driver_t const * driver = get_driver(_usbd_dev.ep2drv[ep_num][ep_dir]);
if ( TUSB_REQ_TYPE_STANDARD != p_request->bmRequestType_bit.type ) if ( TUSB_REQ_TYPE_STANDARD != p_request->bmRequestType_bit.type ) {
{
// Forward class request to its driver // Forward class request to its driver
TU_VERIFY(driver); TU_VERIFY(driver);
return invoke_class_control(rhport, driver, p_request); return invoke_class_control(rhport, driver, p_request);
} } else {
else
{
// Handle STD request to endpoint // Handle STD request to endpoint
switch ( p_request->bRequest ) switch ( p_request->bRequest ) {
{ case TUSB_REQ_GET_STATUS: {
case TUSB_REQ_GET_STATUS:
{
uint16_t status = usbd_edpt_stalled(rhport, ep_addr) ? 0x0001 : 0x0000; uint16_t status = usbd_edpt_stalled(rhport, ep_addr) ? 0x0001 : 0x0000;
tud_control_xfer(rhport, p_request, &status, 2); tud_control_xfer(rhport, p_request, &status, 2);
} }
break; break;
case TUSB_REQ_CLEAR_FEATURE: case TUSB_REQ_CLEAR_FEATURE:
case TUSB_REQ_SET_FEATURE: case TUSB_REQ_SET_FEATURE: {
{ if ( TUSB_REQ_FEATURE_EDPT_HALT == p_request->wValue ) {
if ( TUSB_REQ_FEATURE_EDPT_HALT == p_request->wValue ) if ( TUSB_REQ_CLEAR_FEATURE == p_request->bRequest ) {
{
if ( TUSB_REQ_CLEAR_FEATURE == p_request->bRequest )
{
usbd_edpt_clear_stall(rhport, ep_addr); usbd_edpt_clear_stall(rhport, ep_addr);
}else }else {
{
usbd_edpt_stall(rhport, ep_addr); usbd_edpt_stall(rhport, ep_addr);
} }
} }
if (driver) if (driver) {
{
// Some classes such as USBTMC needs to clear/re-init its buffer when receiving CLEAR_FEATURE request // Some classes such as USBTMC needs to clear/re-init its buffer when receiving CLEAR_FEATURE request
// We will also forward std request targeted endpoint to class drivers as well // We will also forward std request targeted endpoint to class drivers as well
@ -853,14 +792,18 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
break; break;
// Unknown/Unsupported request // Unknown/Unsupported request
default: TU_BREAKPOINT(); return false; default:
TU_BREAKPOINT();
return false;
} }
} }
} }
break; break;
// Unknown recipient // Unknown recipient
default: TU_BREAKPOINT(); return false; default:
TU_BREAKPOINT();
return false;
} }
return true; return true;
@ -1185,8 +1128,7 @@ void usbd_defer_func(osal_task_func_t func, void* param, bool in_isr) {
// USBD Endpoint API // USBD Endpoint API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool usbd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const * desc_ep) bool usbd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const* desc_ep) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
TU_ASSERT(tu_edpt_number(desc_ep->bEndpointAddress) < CFG_TUD_ENDPPOINT_MAX); TU_ASSERT(tu_edpt_number(desc_ep->bEndpointAddress) < CFG_TUD_ENDPPOINT_MAX);
@ -1195,37 +1137,34 @@ bool usbd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const * desc_ep)
return dcd_edpt_open(rhport, desc_ep); return dcd_edpt_open(rhport, desc_ep);
} }
bool usbd_edpt_claim(uint8_t rhport, uint8_t ep_addr) bool usbd_edpt_claim(uint8_t rhport, uint8_t ep_addr) {
{
(void) rhport; (void) rhport;
// TODO add this check later, also make sure we don't starve an out endpoint while suspending // TODO add this check later, also make sure we don't starve an out endpoint while suspending
// TU_VERIFY(tud_ready()); // TU_VERIFY(tud_ready());
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
tu_edpt_state_t* ep_state = &_usbd_dev.ep_status[epnum][dir]; tu_edpt_state_t* ep_state = &_usbd_dev.ep_status[epnum][dir];
return tu_edpt_claim(ep_state, _usbd_mutex); return tu_edpt_claim(ep_state, _usbd_mutex);
} }
bool usbd_edpt_release(uint8_t rhport, uint8_t ep_addr) bool usbd_edpt_release(uint8_t rhport, uint8_t ep_addr) {
{
(void) rhport; (void) rhport;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
tu_edpt_state_t* ep_state = &_usbd_dev.ep_status[epnum][dir]; tu_edpt_state_t* ep_state = &_usbd_dev.ep_status[epnum][dir];
return tu_edpt_release(ep_state, _usbd_mutex); return tu_edpt_release(ep_state, _usbd_mutex);
} }
bool usbd_edpt_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes) bool usbd_edpt_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t* buffer, uint16_t total_bytes) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
// TODO skip ready() check for now since enumeration also use this API // TODO skip ready() check for now since enumeration also use this API
// TU_VERIFY(tud_ready()); // TU_VERIFY(tud_ready());
@ -1239,11 +1178,9 @@ bool usbd_edpt_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t * buffer, uint16_t
// could return and USBD task can preempt and clear the busy // could return and USBD task can preempt and clear the busy
_usbd_dev.ep_status[epnum][dir].busy = 1; _usbd_dev.ep_status[epnum][dir].busy = 1;
if ( dcd_edpt_xfer(rhport, ep_addr, buffer, total_bytes) ) if (dcd_edpt_xfer(rhport, ep_addr, buffer, total_bytes)) {
{
return true; return true;
}else } else {
{
// DCD error, mark endpoint as ready to allow next transfer // DCD error, mark endpoint as ready to allow next transfer
_usbd_dev.ep_status[epnum][dir].busy = 0; _usbd_dev.ep_status[epnum][dir].busy = 0;
_usbd_dev.ep_status[epnum][dir].claimed = 0; _usbd_dev.ep_status[epnum][dir].claimed = 0;
@ -1257,12 +1194,11 @@ bool usbd_edpt_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t * buffer, uint16_t
// bytes should be written and second to keep the return value free to give back a boolean // bytes should be written and second to keep the return value free to give back a boolean
// success message. If total_bytes is too big, the FIFO will copy only what is available // success message. If total_bytes is too big, the FIFO will copy only what is available
// into the USB buffer! // into the USB buffer!
bool usbd_edpt_xfer_fifo(uint8_t rhport, uint8_t ep_addr, tu_fifo_t * ff, uint16_t total_bytes) bool usbd_edpt_xfer_fifo(uint8_t rhport, uint8_t ep_addr, tu_fifo_t* ff, uint16_t total_bytes) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
TU_LOG_USBD(" Queue ISO EP %02X with %u bytes ... ", ep_addr, total_bytes); TU_LOG_USBD(" Queue ISO EP %02X with %u bytes ... ", ep_addr, total_bytes);
@ -1273,12 +1209,10 @@ bool usbd_edpt_xfer_fifo(uint8_t rhport, uint8_t ep_addr, tu_fifo_t * ff, uint16
// and usbd task can preempt and clear the busy // and usbd task can preempt and clear the busy
_usbd_dev.ep_status[epnum][dir].busy = 1; _usbd_dev.ep_status[epnum][dir].busy = 1;
if (dcd_edpt_xfer_fifo(rhport, ep_addr, ff, total_bytes)) if (dcd_edpt_xfer_fifo(rhport, ep_addr, ff, total_bytes)) {
{
TU_LOG_USBD("OK\r\n"); TU_LOG_USBD("OK\r\n");
return true; return true;
}else } else {
{
// DCD error, mark endpoint as ready to allow next transfer // DCD error, mark endpoint as ready to allow next transfer
_usbd_dev.ep_status[epnum][dir].busy = 0; _usbd_dev.ep_status[epnum][dir].busy = 0;
_usbd_dev.ep_status[epnum][dir].claimed = 0; _usbd_dev.ep_status[epnum][dir].claimed = 0;
@ -1288,26 +1222,23 @@ bool usbd_edpt_xfer_fifo(uint8_t rhport, uint8_t ep_addr, tu_fifo_t * ff, uint16
} }
} }
bool usbd_edpt_busy(uint8_t rhport, uint8_t ep_addr) bool usbd_edpt_busy(uint8_t rhport, uint8_t ep_addr) {
{
(void) rhport; (void) rhport;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
return _usbd_dev.ep_status[epnum][dir].busy; return _usbd_dev.ep_status[epnum][dir].busy;
} }
void usbd_edpt_stall(uint8_t rhport, uint8_t ep_addr) void usbd_edpt_stall(uint8_t rhport, uint8_t ep_addr) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
// only stalled if currently cleared // only stalled if currently cleared
if ( !_usbd_dev.ep_status[epnum][dir].stalled ) if (!_usbd_dev.ep_status[epnum][dir].stalled) {
{
TU_LOG_USBD(" Stall EP %02X\r\n", ep_addr); TU_LOG_USBD(" Stall EP %02X\r\n", ep_addr);
dcd_edpt_stall(rhport, ep_addr); dcd_edpt_stall(rhport, ep_addr);
_usbd_dev.ep_status[epnum][dir].stalled = 1; _usbd_dev.ep_status[epnum][dir].stalled = 1;
@ -1315,16 +1246,14 @@ void usbd_edpt_stall(uint8_t rhport, uint8_t ep_addr)
} }
} }
void usbd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr) void usbd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
// only clear if currently stalled // only clear if currently stalled
if ( _usbd_dev.ep_status[epnum][dir].stalled ) if (_usbd_dev.ep_status[epnum][dir].stalled) {
{
TU_LOG_USBD(" Clear Stall EP %02X\r\n", ep_addr); TU_LOG_USBD(" Clear Stall EP %02X\r\n", ep_addr);
dcd_edpt_clear_stall(rhport, ep_addr); dcd_edpt_clear_stall(rhport, ep_addr);
_usbd_dev.ep_status[epnum][dir].stalled = 0; _usbd_dev.ep_status[epnum][dir].stalled = 0;
@ -1332,31 +1261,27 @@ void usbd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr)
} }
} }
bool usbd_edpt_stalled(uint8_t rhport, uint8_t ep_addr) bool usbd_edpt_stalled(uint8_t rhport, uint8_t ep_addr) {
{
(void) rhport; (void) rhport;
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
return _usbd_dev.ep_status[epnum][dir].stalled; return _usbd_dev.ep_status[epnum][dir].stalled;
} }
/** /**
* usbd_edpt_close will disable an endpoint. * usbd_edpt_close will disable an endpoint.
*
* In progress transfers on this EP may be delivered after this call. * In progress transfers on this EP may be delivered after this call.
*
*/ */
void usbd_edpt_close(uint8_t rhport, uint8_t ep_addr) void usbd_edpt_close(uint8_t rhport, uint8_t ep_addr) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
TU_ASSERT(dcd_edpt_close, /**/); TU_ASSERT(dcd_edpt_close, /**/);
TU_LOG_USBD(" CLOSING Endpoint: 0x%02X\r\n", ep_addr); TU_LOG_USBD(" CLOSING Endpoint: 0x%02X\r\n", ep_addr);
uint8_t const epnum = tu_edpt_number(ep_addr); uint8_t const epnum = tu_edpt_number(ep_addr);
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
dcd_edpt_close(rhport, ep_addr); dcd_edpt_close(rhport, ep_addr);
_usbd_dev.ep_status[epnum][dir].stalled = 0; _usbd_dev.ep_status[epnum][dir].stalled = 0;
@ -1366,8 +1291,7 @@ void usbd_edpt_close(uint8_t rhport, uint8_t ep_addr)
return; return;
} }
void usbd_sof_enable(uint8_t rhport, bool en) void usbd_sof_enable(uint8_t rhport, bool en) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
// TODO: Check needed if all drivers including the user sof_cb does not need an active SOF ISR any more. // TODO: Check needed if all drivers including the user sof_cb does not need an active SOF ISR any more.
@ -1375,8 +1299,7 @@ void usbd_sof_enable(uint8_t rhport, bool en)
dcd_sof_enable(rhport, en); dcd_sof_enable(rhport, en);
} }
bool usbd_edpt_iso_alloc(uint8_t rhport, uint8_t ep_addr, uint16_t largest_packet_size) bool usbd_edpt_iso_alloc(uint8_t rhport, uint8_t ep_addr, uint16_t largest_packet_size) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
TU_ASSERT(dcd_edpt_iso_alloc); TU_ASSERT(dcd_edpt_iso_alloc);
@ -1385,12 +1308,11 @@ bool usbd_edpt_iso_alloc(uint8_t rhport, uint8_t ep_addr, uint16_t largest_packe
return dcd_edpt_iso_alloc(rhport, ep_addr, largest_packet_size); return dcd_edpt_iso_alloc(rhport, ep_addr, largest_packet_size);
} }
bool usbd_edpt_iso_activate(uint8_t rhport, tusb_desc_endpoint_t const * desc_ep) bool usbd_edpt_iso_activate(uint8_t rhport, tusb_desc_endpoint_t const* desc_ep) {
{
rhport = _usbd_rhport; rhport = _usbd_rhport;
uint8_t const epnum = tu_edpt_number(desc_ep->bEndpointAddress); uint8_t const epnum = tu_edpt_number(desc_ep->bEndpointAddress);
uint8_t const dir = tu_edpt_dir(desc_ep->bEndpointAddress); uint8_t const dir = tu_edpt_dir(desc_ep->bEndpointAddress);
TU_ASSERT(dcd_edpt_iso_activate); TU_ASSERT(dcd_edpt_iso_activate);
TU_ASSERT(epnum < CFG_TUD_ENDPPOINT_MAX); TU_ASSERT(epnum < CFG_TUD_ENDPPOINT_MAX);

324
src/portable/raspberrypi/rp2040/dcd_rp2040.c
View File

@ -48,7 +48,7 @@
*------------------------------------------------------------------*/ *------------------------------------------------------------------*/
// Init these in dcd_init // Init these in dcd_init
static uint8_t *next_buffer_ptr; static uint8_t* next_buffer_ptr;
// USB_MAX_ENDPOINTS Endpoints, direction TUSB_DIR_OUT for out and TUSB_DIR_IN for in. // USB_MAX_ENDPOINTS Endpoints, direction TUSB_DIR_OUT for out and TUSB_DIR_IN for in.
static struct hw_endpoint hw_endpoints[USB_MAX_ENDPOINTS][2]; static struct hw_endpoint hw_endpoints[USB_MAX_ENDPOINTS][2];
@ -56,79 +56,70 @@ static struct hw_endpoint hw_endpoints[USB_MAX_ENDPOINTS][2];
// SOF may be used by remote wakeup as RESUME, this indicate whether SOF is actually used by usbd // SOF may be used by remote wakeup as RESUME, this indicate whether SOF is actually used by usbd
static bool _sof_enable = false; static bool _sof_enable = false;
TU_ATTR_ALWAYS_INLINE static inline struct hw_endpoint *hw_endpoint_get_by_num(uint8_t num, tusb_dir_t dir) TU_ATTR_ALWAYS_INLINE static inline struct hw_endpoint* hw_endpoint_get_by_num(uint8_t num, tusb_dir_t dir) {
{
return &hw_endpoints[num][dir]; return &hw_endpoints[num][dir];
} }
static struct hw_endpoint *hw_endpoint_get_by_addr(uint8_t ep_addr) static struct hw_endpoint* hw_endpoint_get_by_addr(uint8_t ep_addr) {
{
uint8_t num = tu_edpt_number(ep_addr); uint8_t num = tu_edpt_number(ep_addr);
tusb_dir_t dir = tu_edpt_dir(ep_addr); tusb_dir_t dir = tu_edpt_dir(ep_addr);
return hw_endpoint_get_by_num(num, dir); return hw_endpoint_get_by_num(num, dir);
} }
static void _hw_endpoint_alloc(struct hw_endpoint *ep, uint8_t transfer_type) static void _hw_endpoint_alloc(struct hw_endpoint* ep, uint8_t transfer_type) {
{
// size must be multiple of 64 // size must be multiple of 64
uint size = tu_div_ceil(ep->wMaxPacketSize, 64) * 64u; uint size = tu_div_ceil(ep->wMaxPacketSize, 64) * 64u;
// double buffered Bulk endpoint // double buffered Bulk endpoint
if ( transfer_type == TUSB_XFER_BULK ) if (transfer_type == TUSB_XFER_BULK) {
{
size *= 2u; size *= 2u;
} }
ep->hw_data_buf = next_buffer_ptr; ep->hw_data_buf = next_buffer_ptr;
next_buffer_ptr += size; next_buffer_ptr += size;
assert(((uintptr_t )next_buffer_ptr & 0b111111u) == 0); assert(((uintptr_t) next_buffer_ptr & 0b111111u) == 0);
uint dpram_offset = hw_data_offset(ep->hw_data_buf); uint dpram_offset = hw_data_offset(ep->hw_data_buf);
hard_assert(hw_data_offset(next_buffer_ptr) <= USB_DPRAM_MAX); hard_assert(hw_data_offset(next_buffer_ptr) <= USB_DPRAM_MAX);
pico_info(" Allocated %d bytes at offset 0x%x (0x%p)\r\n", size, dpram_offset, ep->hw_data_buf); pico_info(" Allocated %d bytes at offset 0x%x (0x%p)\r\n", size, dpram_offset, ep->hw_data_buf);
// Fill in endpoint control register with buffer offset // Fill in endpoint control register with buffer offset
uint32_t const reg = EP_CTRL_ENABLE_BITS | ((uint)transfer_type << EP_CTRL_BUFFER_TYPE_LSB) | dpram_offset; uint32_t const reg = EP_CTRL_ENABLE_BITS | ((uint) transfer_type << EP_CTRL_BUFFER_TYPE_LSB) | dpram_offset;
*ep->endpoint_control = reg; *ep->endpoint_control = reg;
} }
static void _hw_endpoint_close(struct hw_endpoint *ep) static void _hw_endpoint_close(struct hw_endpoint* ep) {
{ // Clear hardware registers and then zero the struct
// Clear hardware registers and then zero the struct // Clears endpoint enable
// Clears endpoint enable *ep->endpoint_control = 0;
*ep->endpoint_control = 0; // Clears buffer available, etc
// Clears buffer available, etc *ep->buffer_control = 0;
*ep->buffer_control = 0; // Clear any endpoint state
// Clear any endpoint state memset(ep, 0, sizeof(struct hw_endpoint));
memset(ep, 0, sizeof(struct hw_endpoint));
// Reclaim buffer space if all endpoints are closed // Reclaim buffer space if all endpoints are closed
bool reclaim_buffers = true; bool reclaim_buffers = true;
for ( uint8_t i = 1; i < USB_MAX_ENDPOINTS; i++ ) for (uint8_t i = 1; i < USB_MAX_ENDPOINTS; i++) {
{ if (hw_endpoint_get_by_num(i, TUSB_DIR_OUT)->hw_data_buf != NULL ||
if (hw_endpoint_get_by_num(i, TUSB_DIR_OUT)->hw_data_buf != NULL || hw_endpoint_get_by_num(i, TUSB_DIR_IN)->hw_data_buf != NULL) hw_endpoint_get_by_num(i, TUSB_DIR_IN)->hw_data_buf != NULL) {
{ reclaim_buffers = false;
reclaim_buffers = false; break;
break;
}
}
if (reclaim_buffers)
{
next_buffer_ptr = &usb_dpram->epx_data[0];
} }
}
if (reclaim_buffers) {
next_buffer_ptr = &usb_dpram->epx_data[0];
}
} }
static void hw_endpoint_close(uint8_t ep_addr) static void hw_endpoint_close(uint8_t ep_addr) {
{ struct hw_endpoint* ep = hw_endpoint_get_by_addr(ep_addr);
struct hw_endpoint *ep = hw_endpoint_get_by_addr(ep_addr); _hw_endpoint_close(ep);
_hw_endpoint_close(ep);
} }
static void hw_endpoint_init(uint8_t ep_addr, uint16_t wMaxPacketSize, uint8_t transfer_type) static void hw_endpoint_init(uint8_t ep_addr, uint16_t wMaxPacketSize, uint8_t transfer_type) {
{ struct hw_endpoint* ep = hw_endpoint_get_by_addr(ep_addr);
struct hw_endpoint *ep = hw_endpoint_get_by_addr(ep_addr);
const uint8_t num = tu_edpt_number(ep_addr); const uint8_t num = tu_edpt_number(ep_addr);
const tusb_dir_t dir = tu_edpt_dir(ep_addr); const tusb_dir_t dir = tu_edpt_dir(ep_addr);
@ -143,35 +134,26 @@ static void hw_endpoint_init(uint8_t ep_addr, uint16_t wMaxPacketSize, uint8_t t
ep->transfer_type = transfer_type; ep->transfer_type = transfer_type;
// Every endpoint has a buffer control register in dpram // Every endpoint has a buffer control register in dpram
if ( dir == TUSB_DIR_IN ) if (dir == TUSB_DIR_IN) {
{
ep->buffer_control = &usb_dpram->ep_buf_ctrl[num].in; ep->buffer_control = &usb_dpram->ep_buf_ctrl[num].in;
} } else {
else
{
ep->buffer_control = &usb_dpram->ep_buf_ctrl[num].out; ep->buffer_control = &usb_dpram->ep_buf_ctrl[num].out;
} }
// Clear existing buffer control state // Clear existing buffer control state
*ep->buffer_control = 0; *ep->buffer_control = 0;
if ( num == 0 ) if (num == 0) {
{
// EP0 has no endpoint control register because the buffer offsets are fixed // EP0 has no endpoint control register because the buffer offsets are fixed
ep->endpoint_control = NULL; ep->endpoint_control = NULL;
// Buffer offset is fixed (also double buffered) // Buffer offset is fixed (also double buffered)
ep->hw_data_buf = (uint8_t*) &usb_dpram->ep0_buf_a[0]; ep->hw_data_buf = (uint8_t*) &usb_dpram->ep0_buf_a[0];
} } else {
else
{
// Set the endpoint control register (starts at EP1, hence num-1) // Set the endpoint control register (starts at EP1, hence num-1)
if ( dir == TUSB_DIR_IN ) if (dir == TUSB_DIR_IN) {
{
ep->endpoint_control = &usb_dpram->ep_ctrl[num - 1].in; ep->endpoint_control = &usb_dpram->ep_ctrl[num - 1].in;
} } else {
else
{
ep->endpoint_control = &usb_dpram->ep_ctrl[num - 1].out; ep->endpoint_control = &usb_dpram->ep_ctrl[num - 1].out;
} }
@ -180,76 +162,65 @@ static void hw_endpoint_init(uint8_t ep_addr, uint16_t wMaxPacketSize, uint8_t t
} }
} }
static void hw_endpoint_xfer(uint8_t ep_addr, uint8_t *buffer, uint16_t total_bytes) static void hw_endpoint_xfer(uint8_t ep_addr, uint8_t* buffer, uint16_t total_bytes) {
{ struct hw_endpoint* ep = hw_endpoint_get_by_addr(ep_addr);
struct hw_endpoint *ep = hw_endpoint_get_by_addr(ep_addr); hw_endpoint_xfer_start(ep, buffer, total_bytes);
hw_endpoint_xfer_start(ep, buffer, total_bytes);
} }
static void __tusb_irq_path_func(hw_handle_buff_status)(void) static void __tusb_irq_path_func(hw_handle_buff_status)(void) {
{ uint32_t remaining_buffers = usb_hw->buf_status;
uint32_t remaining_buffers = usb_hw->buf_status; pico_trace("buf_status = 0x%08lx\r\n", remaining_buffers);
pico_trace("buf_status = 0x%08lx\r\n", remaining_buffers); uint bit = 1u;
uint bit = 1u; for (uint8_t i = 0; remaining_buffers && i < USB_MAX_ENDPOINTS * 2; i++) {
for (uint8_t i = 0; remaining_buffers && i < USB_MAX_ENDPOINTS * 2; i++) if (remaining_buffers & bit) {
{ // clear this in advance
if (remaining_buffers & bit) usb_hw_clear->buf_status = bit;
{
// clear this in advance
usb_hw_clear->buf_status = bit;
// IN transfer for even i, OUT transfer for odd i // IN transfer for even i, OUT transfer for odd i
struct hw_endpoint *ep = hw_endpoint_get_by_num(i >> 1u, (i & 1u) ? TUSB_DIR_OUT : TUSB_DIR_IN); struct hw_endpoint* ep = hw_endpoint_get_by_num(i >> 1u, (i & 1u) ? TUSB_DIR_OUT : TUSB_DIR_IN);
// Continue xfer // Continue xfer
bool done = hw_endpoint_xfer_continue(ep); bool done = hw_endpoint_xfer_continue(ep);
if (done) if (done) {
{ // Notify
// Notify dcd_event_xfer_complete(0, ep->ep_addr, ep->xferred_len, XFER_RESULT_SUCCESS, true);
dcd_event_xfer_complete(0, ep->ep_addr, ep->xferred_len, XFER_RESULT_SUCCESS, true); hw_endpoint_reset_transfer(ep);
hw_endpoint_reset_transfer(ep); }
} remaining_buffers &= ~bit;
remaining_buffers &= ~bit;
}
bit <<= 1u;
} }
bit <<= 1u;
}
} }
TU_ATTR_ALWAYS_INLINE static inline void reset_ep0_pid(void) TU_ATTR_ALWAYS_INLINE static inline void reset_ep0_pid(void) {
{ // If we have finished this transfer on EP0 set pid back to 1 for next
// If we have finished this transfer on EP0 set pid back to 1 for next // setup transfer. Also clear a stall in case
// setup transfer. Also clear a stall in case uint8_t addrs[] = {0x0, 0x80};
uint8_t addrs[] = {0x0, 0x80}; for (uint i = 0; i < TU_ARRAY_SIZE(addrs); i++) {
for (uint i = 0 ; i < TU_ARRAY_SIZE(addrs); i++) struct hw_endpoint* ep = hw_endpoint_get_by_addr(addrs[i]);
{ ep->next_pid = 1u;
struct hw_endpoint *ep = hw_endpoint_get_by_addr(addrs[i]); }
ep->next_pid = 1u;
}
} }
static void __tusb_irq_path_func(reset_non_control_endpoints)(void) static void __tusb_irq_path_func(reset_non_control_endpoints)(void) {
{
// Disable all non-control // Disable all non-control
for ( uint8_t i = 0; i < USB_MAX_ENDPOINTS-1; i++ ) for (uint8_t i = 0; i < USB_MAX_ENDPOINTS - 1; i++) {
{
usb_dpram->ep_ctrl[i].in = 0; usb_dpram->ep_ctrl[i].in = 0;
usb_dpram->ep_ctrl[i].out = 0; usb_dpram->ep_ctrl[i].out = 0;
} }
// clear non-control hw endpoints // clear non-control hw endpoints
tu_memclr(hw_endpoints[1], sizeof(hw_endpoints) - 2*sizeof(hw_endpoint_t)); tu_memclr(hw_endpoints[1], sizeof(hw_endpoints) - 2 * sizeof(hw_endpoint_t));
// reclaim buffer space // reclaim buffer space
next_buffer_ptr = &usb_dpram->epx_data[0]; next_buffer_ptr = &usb_dpram->epx_data[0];
} }
static void __tusb_irq_path_func(dcd_rp2040_irq)(void) static void __tusb_irq_path_func(dcd_rp2040_irq)(void) {
{
uint32_t const status = usb_hw->ints; uint32_t const status = usb_hw->ints;
uint32_t handled = 0; uint32_t handled = 0;
if ( status & USB_INTF_DEV_SOF_BITS ) if (status & USB_INTF_DEV_SOF_BITS) {
{
bool keep_sof_alive = false; bool keep_sof_alive = false;
handled |= USB_INTF_DEV_SOF_BITS; handled |= USB_INTF_DEV_SOF_BITS;
@ -258,20 +229,17 @@ static void __tusb_irq_path_func(dcd_rp2040_irq)(void)
// Errata 15 workaround for Device Bulk-In endpoint // Errata 15 workaround for Device Bulk-In endpoint
e15_last_sof = time_us_32(); e15_last_sof = time_us_32();
for ( uint8_t i = 0; i < USB_MAX_ENDPOINTS; i++ ) for (uint8_t i = 0; i < USB_MAX_ENDPOINTS; i++) {
{ struct hw_endpoint* ep = hw_endpoint_get_by_num(i, TUSB_DIR_IN);
struct hw_endpoint * ep = hw_endpoint_get_by_num(i, TUSB_DIR_IN);
// Active Bulk IN endpoint requires SOF // Active Bulk IN endpoint requires SOF
if ( (ep->transfer_type == TUSB_XFER_BULK) && ep->active ) if ((ep->transfer_type == TUSB_XFER_BULK) && ep->active) {
{
keep_sof_alive = true; keep_sof_alive = true;
hw_endpoint_lock_update(ep, 1); hw_endpoint_lock_update(ep, 1);
// Deferred enable? // Deferred enable?
if ( ep->pending ) if (ep->pending) {
{
ep->pending = 0; ep->pending = 0;
hw_endpoint_start_next_buffer(ep); hw_endpoint_start_next_buffer(ep);
} }
@ -282,23 +250,21 @@ static void __tusb_irq_path_func(dcd_rp2040_irq)(void)
#endif #endif
// disable SOF interrupt if it is used for RESUME in remote wakeup // disable SOF interrupt if it is used for RESUME in remote wakeup
if ( !keep_sof_alive && !_sof_enable ) usb_hw_clear->inte = USB_INTS_DEV_SOF_BITS; if (!keep_sof_alive && !_sof_enable) usb_hw_clear->inte = USB_INTS_DEV_SOF_BITS;
dcd_event_sof(0, usb_hw->sof_rd & USB_SOF_RD_BITS, true); dcd_event_sof(0, usb_hw->sof_rd & USB_SOF_RD_BITS, true);
} }
// xfer events are handled before setup req. So if a transfer completes immediately // xfer events are handled before setup req. So if a transfer completes immediately
// before closing the EP, the events will be delivered in same order. // before closing the EP, the events will be delivered in same order.
if ( status & USB_INTS_BUFF_STATUS_BITS ) if (status & USB_INTS_BUFF_STATUS_BITS) {
{
handled |= USB_INTS_BUFF_STATUS_BITS; handled |= USB_INTS_BUFF_STATUS_BITS;
hw_handle_buff_status(); hw_handle_buff_status();
} }
if ( status & USB_INTS_SETUP_REQ_BITS ) if (status & USB_INTS_SETUP_REQ_BITS) {
{
handled |= USB_INTS_SETUP_REQ_BITS; handled |= USB_INTS_SETUP_REQ_BITS;
uint8_t const * setup = remove_volatile_cast(uint8_t const*, &usb_dpram->setup_packet); uint8_t const* setup = remove_volatile_cast(uint8_t const*, &usb_dpram->setup_packet);
// reset pid to both 1 (data and ack) // reset pid to both 1 (data and ack)
reset_ep0_pid(); reset_ep0_pid();
@ -329,8 +295,7 @@ static void __tusb_irq_path_func(dcd_rp2040_irq)(void)
#endif #endif
// SE0 for 2.5 us or more (will last at least 10ms) // SE0 for 2.5 us or more (will last at least 10ms)
if ( status & USB_INTS_BUS_RESET_BITS ) if (status & USB_INTS_BUS_RESET_BITS) {
{
pico_trace("BUS RESET\r\n"); pico_trace("BUS RESET\r\n");
handled |= USB_INTS_BUS_RESET_BITS; handled |= USB_INTS_BUS_RESET_BITS;
@ -342,7 +307,7 @@ static void __tusb_irq_path_func(dcd_rp2040_irq)(void)
#if TUD_OPT_RP2040_USB_DEVICE_ENUMERATION_FIX #if TUD_OPT_RP2040_USB_DEVICE_ENUMERATION_FIX
// Only run enumeration workaround if pull up is enabled // Only run enumeration workaround if pull up is enabled
if ( usb_hw->sie_ctrl & USB_SIE_CTRL_PULLUP_EN_BITS ) rp2040_usb_device_enumeration_fix(); if (usb_hw->sie_ctrl & USB_SIE_CTRL_PULLUP_EN_BITS) rp2040_usb_device_enumeration_fix();
#endif #endif
} }
@ -354,22 +319,19 @@ static void __tusb_irq_path_func(dcd_rp2040_irq)(void)
* because without VBUS detection, it is impossible to tell the difference between * because without VBUS detection, it is impossible to tell the difference between
* being disconnected and suspended. * being disconnected and suspended.
*/ */
if ( status & USB_INTS_DEV_SUSPEND_BITS ) if (status & USB_INTS_DEV_SUSPEND_BITS) {
{
handled |= USB_INTS_DEV_SUSPEND_BITS; handled |= USB_INTS_DEV_SUSPEND_BITS;
dcd_event_bus_signal(0, DCD_EVENT_SUSPEND, true); dcd_event_bus_signal(0, DCD_EVENT_SUSPEND, true);
usb_hw_clear->sie_status = USB_SIE_STATUS_SUSPENDED_BITS; usb_hw_clear->sie_status = USB_SIE_STATUS_SUSPENDED_BITS;
} }
if ( status & USB_INTS_DEV_RESUME_FROM_HOST_BITS ) if (status & USB_INTS_DEV_RESUME_FROM_HOST_BITS) {
{
handled |= USB_INTS_DEV_RESUME_FROM_HOST_BITS; handled |= USB_INTS_DEV_RESUME_FROM_HOST_BITS;
dcd_event_bus_signal(0, DCD_EVENT_RESUME, true); dcd_event_bus_signal(0, DCD_EVENT_RESUME, true);
usb_hw_clear->sie_status = USB_SIE_STATUS_RESUME_BITS; usb_hw_clear->sie_status = USB_SIE_STATUS_RESUME_BITS;
} }
if ( status ^ handled ) if (status ^ handled) {
{
panic("Unhandled IRQ 0x%x\n", (uint) (status ^ handled)); panic("Unhandled IRQ 0x%x\n", (uint) (status ^ handled));
} }
} }
@ -390,8 +352,7 @@ static void __tusb_irq_path_func(dcd_rp2040_irq)(void)
#define PICO_SHARED_IRQ_HANDLER_HIGHEST_ORDER_PRIORITY 0xff #define PICO_SHARED_IRQ_HANDLER_HIGHEST_ORDER_PRIORITY 0xff
#endif #endif
void dcd_init (uint8_t rhport) void dcd_init(uint8_t rhport) {
{
assert(rhport == 0); assert(rhport == 0);
// Reset hardware to default state // Reset hardware to default state
@ -405,7 +366,7 @@ void dcd_init (uint8_t rhport)
irq_add_shared_handler(USBCTRL_IRQ, dcd_rp2040_irq, PICO_SHARED_IRQ_HANDLER_HIGHEST_ORDER_PRIORITY); irq_add_shared_handler(USBCTRL_IRQ, dcd_rp2040_irq, PICO_SHARED_IRQ_HANDLER_HIGHEST_ORDER_PRIORITY);
// Init control endpoints // Init control endpoints
tu_memclr(hw_endpoints[0], 2*sizeof(hw_endpoint_t)); tu_memclr(hw_endpoints[0], 2 * sizeof(hw_endpoint_t));
hw_endpoint_init(0x0, 64, TUSB_XFER_CONTROL); hw_endpoint_init(0x0, 64, TUSB_XFER_CONTROL);
hw_endpoint_init(0x80, 64, TUSB_XFER_CONTROL); hw_endpoint_init(0x80, 64, TUSB_XFER_CONTROL);
@ -420,27 +381,24 @@ void dcd_init (uint8_t rhport)
// for the global interrupt enable... // for the global interrupt enable...
// Note: Force VBUS detect cause disconnection not detectable // Note: Force VBUS detect cause disconnection not detectable
usb_hw->sie_ctrl = USB_SIE_CTRL_EP0_INT_1BUF_BITS; usb_hw->sie_ctrl = USB_SIE_CTRL_EP0_INT_1BUF_BITS;
usb_hw->inte = USB_INTS_BUFF_STATUS_BITS | USB_INTS_BUS_RESET_BITS | USB_INTS_SETUP_REQ_BITS | usb_hw->inte = USB_INTS_BUFF_STATUS_BITS | USB_INTS_BUS_RESET_BITS | USB_INTS_SETUP_REQ_BITS |
USB_INTS_DEV_SUSPEND_BITS | USB_INTS_DEV_RESUME_FROM_HOST_BITS | USB_INTS_DEV_SUSPEND_BITS | USB_INTS_DEV_RESUME_FROM_HOST_BITS |
(FORCE_VBUS_DETECT ? 0 : USB_INTS_DEV_CONN_DIS_BITS); (FORCE_VBUS_DETECT ? 0 : USB_INTS_DEV_CONN_DIS_BITS);
dcd_connect(rhport); dcd_connect(rhport);
} }
void dcd_int_enable(__unused uint8_t rhport) void dcd_int_enable(__unused uint8_t rhport) {
{ assert(rhport == 0);
assert(rhport == 0); irq_set_enabled(USBCTRL_IRQ, true);
irq_set_enabled(USBCTRL_IRQ, true);
} }
void dcd_int_disable(__unused uint8_t rhport) void dcd_int_disable(__unused uint8_t rhport) {
{ assert(rhport == 0);
assert(rhport == 0); irq_set_enabled(USBCTRL_IRQ, false);
irq_set_enabled(USBCTRL_IRQ, false);
} }
void dcd_set_address (__unused uint8_t rhport, __unused uint8_t dev_addr) void dcd_set_address(__unused uint8_t rhport, __unused uint8_t dev_addr) {
{
assert(rhport == 0); assert(rhport == 0);
// Can't set device address in hardware until status xfer has complete // Can't set device address in hardware until status xfer has complete
@ -448,8 +406,7 @@ void dcd_set_address (__unused uint8_t rhport, __unused uint8_t dev_addr)
hw_endpoint_xfer(0x80, NULL, 0); hw_endpoint_xfer(0x80, NULL, 0);
} }
void dcd_remote_wakeup(__unused uint8_t rhport) void dcd_remote_wakeup(__unused uint8_t rhport) {
{
pico_info("dcd_remote_wakeup %d\n", rhport); pico_info("dcd_remote_wakeup %d\n", rhport);
assert(rhport == 0); assert(rhport == 0);
@ -460,100 +417,88 @@ void dcd_remote_wakeup(__unused uint8_t rhport)
} }
// disconnect by disabling internal pull-up resistor on D+/D- // disconnect by disabling internal pull-up resistor on D+/D-
void dcd_disconnect(__unused uint8_t rhport) void dcd_disconnect(__unused uint8_t rhport) {
{
(void) rhport; (void) rhport;
usb_hw_clear->sie_ctrl = USB_SIE_CTRL_PULLUP_EN_BITS; usb_hw_clear->sie_ctrl = USB_SIE_CTRL_PULLUP_EN_BITS;
} }
// connect by enabling internal pull-up resistor on D+/D- // connect by enabling internal pull-up resistor on D+/D-
void dcd_connect(__unused uint8_t rhport) void dcd_connect(__unused uint8_t rhport) {
{
(void) rhport; (void) rhport;
usb_hw_set->sie_ctrl = USB_SIE_CTRL_PULLUP_EN_BITS; usb_hw_set->sie_ctrl = USB_SIE_CTRL_PULLUP_EN_BITS;
} }
void dcd_sof_enable(uint8_t rhport, bool en) void dcd_sof_enable(uint8_t rhport, bool en) {
{
(void) rhport; (void) rhport;
_sof_enable = en; _sof_enable = en;
if (en) if (en) {
{
usb_hw_set->inte = USB_INTS_DEV_SOF_BITS; usb_hw_set->inte = USB_INTS_DEV_SOF_BITS;
}else }
{ #if !TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX
else {
// Don't clear immediately if the SOF workaround is in use. // Don't clear immediately if the SOF workaround is in use.
// The SOF handler will conditionally disable the interrupt. // The SOF handler will conditionally disable the interrupt.
#if !TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX
usb_hw_clear->inte = USB_INTS_DEV_SOF_BITS; usb_hw_clear->inte = USB_INTS_DEV_SOF_BITS;
#endif
} }
#endif
} }
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/* DCD Endpoint port /* DCD Endpoint port
*------------------------------------------------------------------*/ *------------------------------------------------------------------*/
void dcd_edpt0_status_complete(uint8_t rhport, tusb_control_request_t const * request) void dcd_edpt0_status_complete(uint8_t rhport, tusb_control_request_t const* request) {
{
(void) rhport; (void) rhport;
if ( request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_DEVICE && if (request->bmRequestType_bit.recipient == TUSB_REQ_RCPT_DEVICE &&
request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD && request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD &&
request->bRequest == TUSB_REQ_SET_ADDRESS ) request->bRequest == TUSB_REQ_SET_ADDRESS) {
{
usb_hw->dev_addr_ctrl = (uint8_t) request->wValue; usb_hw->dev_addr_ctrl = (uint8_t) request->wValue;
} }
} }
bool dcd_edpt_open (__unused uint8_t rhport, tusb_desc_endpoint_t const * desc_edpt) bool dcd_edpt_open(__unused uint8_t rhport, tusb_desc_endpoint_t const* desc_edpt) {
{ assert(rhport == 0);
assert(rhport == 0); hw_endpoint_init(desc_edpt->bEndpointAddress, tu_edpt_packet_size(desc_edpt), desc_edpt->bmAttributes.xfer);
hw_endpoint_init(desc_edpt->bEndpointAddress, tu_edpt_packet_size(desc_edpt), desc_edpt->bmAttributes.xfer); return true;
return true;
} }
void dcd_edpt_close_all (uint8_t rhport) void dcd_edpt_close_all(uint8_t rhport) {
{
(void) rhport; (void) rhport;
// may need to use EP Abort // may need to use EP Abort
reset_non_control_endpoints(); reset_non_control_endpoints();
} }
bool dcd_edpt_xfer(__unused uint8_t rhport, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes) bool dcd_edpt_xfer(__unused uint8_t rhport, uint8_t ep_addr, uint8_t* buffer, uint16_t total_bytes) {
{ assert(rhport == 0);
assert(rhport == 0); hw_endpoint_xfer(ep_addr, buffer, total_bytes);
hw_endpoint_xfer(ep_addr, buffer, total_bytes); return true;
return true;
} }
void dcd_edpt_stall(uint8_t rhport, uint8_t ep_addr) void dcd_edpt_stall(uint8_t rhport, uint8_t ep_addr) {
{
(void) rhport; (void) rhport;
if ( tu_edpt_number(ep_addr) == 0 ) if (tu_edpt_number(ep_addr) == 0) {
{
// A stall on EP0 has to be armed so it can be cleared on the next setup packet // A stall on EP0 has to be armed so it can be cleared on the next setup packet
usb_hw_set->ep_stall_arm = (tu_edpt_dir(ep_addr) == TUSB_DIR_IN) ? USB_EP_STALL_ARM_EP0_IN_BITS : USB_EP_STALL_ARM_EP0_OUT_BITS; usb_hw_set->ep_stall_arm = (tu_edpt_dir(ep_addr) == TUSB_DIR_IN) ? USB_EP_STALL_ARM_EP0_IN_BITS
: USB_EP_STALL_ARM_EP0_OUT_BITS;
} }
struct hw_endpoint *ep = hw_endpoint_get_by_addr(ep_addr); struct hw_endpoint* ep = hw_endpoint_get_by_addr(ep_addr);
// stall and clear current pending buffer // stall and clear current pending buffer
// may need to use EP_ABORT // may need to use EP_ABORT
_hw_endpoint_buffer_control_set_value32(ep, USB_BUF_CTRL_STALL); _hw_endpoint_buffer_control_set_value32(ep, USB_BUF_CTRL_STALL);
} }
void dcd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr) void dcd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr) {
{
(void) rhport; (void) rhport;
if (tu_edpt_number(ep_addr)) if (tu_edpt_number(ep_addr)) {
{ struct hw_endpoint* ep = hw_endpoint_get_by_addr(ep_addr);
struct hw_endpoint *ep = hw_endpoint_get_by_addr(ep_addr);
// clear stall also reset toggle to DATA0, ready for next transfer // clear stall also reset toggle to DATA0, ready for next transfer
ep->next_pid = 0; ep->next_pid = 0;
@ -561,16 +506,13 @@ void dcd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr)
} }
} }
void dcd_edpt_close (uint8_t rhport, uint8_t ep_addr) void dcd_edpt_close(uint8_t rhport, uint8_t ep_addr) {
{ (void) rhport;
(void) rhport; pico_trace("dcd_edpt_close %02x\r\n", ep_addr);
hw_endpoint_close(ep_addr);
pico_trace("dcd_edpt_close %02x\r\n", ep_addr);
hw_endpoint_close(ep_addr);
} }
void __tusb_irq_path_func(dcd_int_handler)(uint8_t rhport) void __tusb_irq_path_func(dcd_int_handler)(uint8_t rhport) {
{
(void) rhport; (void) rhport;
dcd_rp2040_irq(); dcd_rp2040_irq();
} }

167
src/portable/raspberrypi/rp2040/rp2040_usb.c
View File

@ -37,24 +37,23 @@
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Direction strings for debug // Direction strings for debug
const char *ep_dir_string[] = { const char* ep_dir_string[] = {
"out", "out",
"in", "in",
}; };
static void _hw_endpoint_xfer_sync(struct hw_endpoint *ep); static void _hw_endpoint_xfer_sync(struct hw_endpoint* ep);
#if TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX #if TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX
static bool e15_is_bulkin_ep(struct hw_endpoint *ep); static bool e15_is_bulkin_ep(struct hw_endpoint* ep);
static bool e15_is_critical_frame_period(struct hw_endpoint *ep); static bool e15_is_critical_frame_period(struct hw_endpoint* ep);
#else #else
#define e15_is_bulkin_ep(x) (false) #define e15_is_bulkin_ep(x) (false)
#define e15_is_critical_frame_period(x) (false) #define e15_is_critical_frame_period(x) (false)
#endif #endif
// if usb hardware is in host mode // if usb hardware is in host mode
TU_ATTR_ALWAYS_INLINE static inline bool is_host_mode(void) TU_ATTR_ALWAYS_INLINE static inline bool is_host_mode(void) {
{
return (usb_hw->main_ctrl & USB_MAIN_CTRL_HOST_NDEVICE_BITS) ? true : false; return (usb_hw->main_ctrl & USB_MAIN_CTRL_HOST_NDEVICE_BITS) ? true : false;
} }
@ -62,8 +61,7 @@ TU_ATTR_ALWAYS_INLINE static inline bool is_host_mode(void)
// Implementation // Implementation
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
void rp2040_usb_init(void) void rp2040_usb_init(void) {
{
// Reset usb controller // Reset usb controller
reset_block(RESETS_RESET_USBCTRL_BITS); reset_block(RESETS_RESET_USBCTRL_BITS);
unreset_block_wait(RESETS_RESET_USBCTRL_BITS); unreset_block_wait(RESETS_RESET_USBCTRL_BITS);
@ -88,45 +86,40 @@ void rp2040_usb_init(void)
TU_LOG2_INT(sizeof(hw_endpoint_t)); TU_LOG2_INT(sizeof(hw_endpoint_t));
} }
void __tusb_irq_path_func(hw_endpoint_reset_transfer)(struct hw_endpoint *ep) void __tusb_irq_path_func(hw_endpoint_reset_transfer)(struct hw_endpoint* ep) {
{
ep->active = false; ep->active = false;
ep->remaining_len = 0; ep->remaining_len = 0;
ep->xferred_len = 0; ep->xferred_len = 0;
ep->user_buf = 0; ep->user_buf = 0;
} }
void __tusb_irq_path_func(_hw_endpoint_buffer_control_update32)(struct hw_endpoint *ep, uint32_t and_mask, uint32_t or_mask) void __tusb_irq_path_func(_hw_endpoint_buffer_control_update32)(struct hw_endpoint* ep, uint32_t and_mask,
{ uint32_t or_mask) {
uint32_t value = 0; uint32_t value = 0;
if ( and_mask ) if (and_mask) {
{
value = *ep->buffer_control & and_mask; value = *ep->buffer_control & and_mask;
} }
if ( or_mask ) if (or_mask) {
{
value |= or_mask; value |= or_mask;
if ( or_mask & USB_BUF_CTRL_AVAIL ) if (or_mask & USB_BUF_CTRL_AVAIL) {
{ if (*ep->buffer_control & USB_BUF_CTRL_AVAIL) {
if ( *ep->buffer_control & USB_BUF_CTRL_AVAIL )
{
panic("ep %d %s was already available", tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)]); panic("ep %d %s was already available", tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)]);
} }
*ep->buffer_control = value & ~USB_BUF_CTRL_AVAIL; *ep->buffer_control = value & ~USB_BUF_CTRL_AVAIL;
// 12 cycle delay.. (should be good for 48*12Mhz = 576Mhz) // 12 cycle delay.. (should be good for 48*12Mhz = 576Mhz)
// Don't need delay in host mode as host is in charge // Don't need delay in host mode as host is in charge
#if !CFG_TUH_ENABLED #if !CFG_TUH_ENABLED
__asm volatile ( __asm volatile (
"b 1f\n" "b 1f\n"
"1: b 1f\n" "1: b 1f\n"
"1: b 1f\n" "1: b 1f\n"
"1: b 1f\n" "1: b 1f\n"
"1: b 1f\n" "1: b 1f\n"
"1: b 1f\n" "1: b 1f\n"
"1:\n" "1:\n"
: : : "memory"); : : : "memory");
#endif #endif
} }
} }
@ -135,10 +128,9 @@ void __tusb_irq_path_func(_hw_endpoint_buffer_control_update32)(struct hw_endpoi
} }
// prepare buffer, return buffer control // prepare buffer, return buffer control
static uint32_t __tusb_irq_path_func(prepare_ep_buffer)(struct hw_endpoint *ep, uint8_t buf_id) static uint32_t __tusb_irq_path_func(prepare_ep_buffer)(struct hw_endpoint* ep, uint8_t buf_id) {
{
uint16_t const buflen = tu_min16(ep->remaining_len, ep->wMaxPacketSize); uint16_t const buflen = tu_min16(ep->remaining_len, ep->wMaxPacketSize);
ep->remaining_len = (uint16_t)(ep->remaining_len - buflen); ep->remaining_len = (uint16_t) (ep->remaining_len - buflen);
uint32_t buf_ctrl = buflen | USB_BUF_CTRL_AVAIL; uint32_t buf_ctrl = buflen | USB_BUF_CTRL_AVAIL;
@ -146,10 +138,9 @@ static uint32_t __tusb_irq_path_func(prepare_ep_buffer)(struct hw_endpoint *ep,
buf_ctrl |= ep->next_pid ? USB_BUF_CTRL_DATA1_PID : USB_BUF_CTRL_DATA0_PID; buf_ctrl |= ep->next_pid ? USB_BUF_CTRL_DATA1_PID : USB_BUF_CTRL_DATA0_PID;
ep->next_pid ^= 1u; ep->next_pid ^= 1u;
if ( !ep->rx ) if (!ep->rx) {
{
// Copy data from user buffer to hw buffer // Copy data from user buffer to hw buffer
memcpy(ep->hw_data_buf + buf_id*64, ep->user_buf, buflen); memcpy(ep->hw_data_buf + buf_id * 64, ep->user_buf, buflen);
ep->user_buf += buflen; ep->user_buf += buflen;
// Mark as full // Mark as full
@ -159,8 +150,7 @@ static uint32_t __tusb_irq_path_func(prepare_ep_buffer)(struct hw_endpoint *ep,
// Is this the last buffer? Only really matters for host mode. Will trigger // Is this the last buffer? Only really matters for host mode. Will trigger
// the trans complete irq but also stop it polling. We only really care about // the trans complete irq but also stop it polling. We only really care about
// trans complete for setup packets being sent // trans complete for setup packets being sent
if (ep->remaining_len == 0) if (ep->remaining_len == 0) {
{
buf_ctrl |= USB_BUF_CTRL_LAST; buf_ctrl |= USB_BUF_CTRL_LAST;
} }
@ -170,8 +160,7 @@ static uint32_t __tusb_irq_path_func(prepare_ep_buffer)(struct hw_endpoint *ep,
} }
// Prepare buffer control register value // Prepare buffer control register value
void __tusb_irq_path_func(hw_endpoint_start_next_buffer)(struct hw_endpoint *ep) void __tusb_irq_path_func(hw_endpoint_start_next_buffer)(struct hw_endpoint* ep) {
{
uint32_t ep_ctrl = *ep->endpoint_control; uint32_t ep_ctrl = *ep->endpoint_control;
// always compute and start with buffer 0 // always compute and start with buffer 0
@ -186,8 +175,7 @@ void __tusb_irq_path_func(hw_endpoint_start_next_buffer)(struct hw_endpoint *ep)
bool const force_single = (!is_host && !tu_edpt_dir(ep->ep_addr)) || bool const force_single = (!is_host && !tu_edpt_dir(ep->ep_addr)) ||
(is_host && tu_edpt_number(ep->ep_addr) != 0); (is_host && tu_edpt_number(ep->ep_addr) != 0);
if(ep->remaining_len && !force_single) if (ep->remaining_len && !force_single) {
{
// Use buffer 1 (double buffered) if there is still data // Use buffer 1 (double buffered) if there is still data
// TODO: Isochronous for buffer1 bit-field is different than CBI (control bulk, interrupt) // TODO: Isochronous for buffer1 bit-field is different than CBI (control bulk, interrupt)
@ -196,8 +184,7 @@ void __tusb_irq_path_func(hw_endpoint_start_next_buffer)(struct hw_endpoint *ep)
// Set endpoint control double buffered bit if needed // Set endpoint control double buffered bit if needed
ep_ctrl &= ~EP_CTRL_INTERRUPT_PER_BUFFER; ep_ctrl &= ~EP_CTRL_INTERRUPT_PER_BUFFER;
ep_ctrl |= EP_CTRL_DOUBLE_BUFFERED_BITS | EP_CTRL_INTERRUPT_PER_DOUBLE_BUFFER; ep_ctrl |= EP_CTRL_DOUBLE_BUFFERED_BITS | EP_CTRL_INTERRUPT_PER_DOUBLE_BUFFER;
}else } else {
{
// Single buffered since 1 is enough // Single buffered since 1 is enough
ep_ctrl &= ~(EP_CTRL_DOUBLE_BUFFERED_BITS | EP_CTRL_INTERRUPT_PER_DOUBLE_BUFFER); ep_ctrl &= ~(EP_CTRL_DOUBLE_BUFFERED_BITS | EP_CTRL_INTERRUPT_PER_DOUBLE_BUFFER);
ep_ctrl |= EP_CTRL_INTERRUPT_PER_BUFFER; ep_ctrl |= EP_CTRL_INTERRUPT_PER_BUFFER;
@ -212,35 +199,30 @@ void __tusb_irq_path_func(hw_endpoint_start_next_buffer)(struct hw_endpoint *ep)
_hw_endpoint_buffer_control_set_value32(ep, buf_ctrl); _hw_endpoint_buffer_control_set_value32(ep, buf_ctrl);
} }
void hw_endpoint_xfer_start(struct hw_endpoint *ep, uint8_t *buffer, uint16_t total_len) void hw_endpoint_xfer_start(struct hw_endpoint* ep, uint8_t* buffer, uint16_t total_len) {
{
hw_endpoint_lock_update(ep, 1); hw_endpoint_lock_update(ep, 1);
if ( ep->active ) if (ep->active) {
{
// TODO: Is this acceptable for interrupt packets? // TODO: Is this acceptable for interrupt packets?
TU_LOG(1, "WARN: starting new transfer on already active ep %d %s\r\n", tu_edpt_number(ep->ep_addr), TU_LOG(1, "WARN: starting new transfer on already active ep %d %s\r\n", tu_edpt_number(ep->ep_addr),
ep_dir_string[tu_edpt_dir(ep->ep_addr)]); ep_dir_string[tu_edpt_dir(ep->ep_addr)]);
hw_endpoint_reset_transfer(ep); hw_endpoint_reset_transfer(ep);
} }
// Fill in info now that we're kicking off the hw // Fill in info now that we're kicking off the hw
ep->remaining_len = total_len; ep->remaining_len = total_len;
ep->xferred_len = 0; ep->xferred_len = 0;
ep->active = true; ep->active = true;
ep->user_buf = buffer; ep->user_buf = buffer;
if ( e15_is_bulkin_ep(ep) ) if (e15_is_bulkin_ep(ep)) {
{
usb_hw_set->inte = USB_INTS_DEV_SOF_BITS; usb_hw_set->inte = USB_INTS_DEV_SOF_BITS;
} }
if ( e15_is_critical_frame_period(ep) ) if (e15_is_critical_frame_period(ep)) {
{
ep->pending = 1; ep->pending = 1;
} else } else {
{
hw_endpoint_start_next_buffer(ep); hw_endpoint_start_next_buffer(ep);
} }
@ -248,34 +230,30 @@ void hw_endpoint_xfer_start(struct hw_endpoint *ep, uint8_t *buffer, uint16_t to
} }
// sync endpoint buffer and return transferred bytes // sync endpoint buffer and return transferred bytes
static uint16_t __tusb_irq_path_func(sync_ep_buffer)(struct hw_endpoint *ep, uint8_t buf_id) static uint16_t __tusb_irq_path_func(sync_ep_buffer)(struct hw_endpoint* ep, uint8_t buf_id) {
{
uint32_t buf_ctrl = _hw_endpoint_buffer_control_get_value32(ep); uint32_t buf_ctrl = _hw_endpoint_buffer_control_get_value32(ep);
if (buf_id) buf_ctrl = buf_ctrl >> 16; if (buf_id) buf_ctrl = buf_ctrl >> 16;
uint16_t xferred_bytes = buf_ctrl & USB_BUF_CTRL_LEN_MASK; uint16_t xferred_bytes = buf_ctrl & USB_BUF_CTRL_LEN_MASK;
if ( !ep->rx ) if (!ep->rx) {
{
// We are continuing a transfer here. If we are TX, we have successfully // We are continuing a transfer here. If we are TX, we have successfully
// sent some data can increase the length we have sent // sent some data can increase the length we have sent
assert(!(buf_ctrl & USB_BUF_CTRL_FULL)); assert(!(buf_ctrl & USB_BUF_CTRL_FULL));
ep->xferred_len = (uint16_t)(ep->xferred_len + xferred_bytes); ep->xferred_len = (uint16_t) (ep->xferred_len + xferred_bytes);
}else } else {
{
// If we have received some data, so can increase the length // If we have received some data, so can increase the length
// we have received AFTER we have copied it to the user buffer at the appropriate offset // we have received AFTER we have copied it to the user buffer at the appropriate offset
assert(buf_ctrl & USB_BUF_CTRL_FULL); assert(buf_ctrl & USB_BUF_CTRL_FULL);
memcpy(ep->user_buf, ep->hw_data_buf + buf_id*64, xferred_bytes); memcpy(ep->user_buf, ep->hw_data_buf + buf_id * 64, xferred_bytes);
ep->xferred_len = (uint16_t)(ep->xferred_len + xferred_bytes); ep->xferred_len = (uint16_t) (ep->xferred_len + xferred_bytes);
ep->user_buf += xferred_bytes; ep->user_buf += xferred_bytes;
} }
// Short packet // Short packet
if (xferred_bytes < ep->wMaxPacketSize) if (xferred_bytes < ep->wMaxPacketSize) {
{
pico_trace(" Short packet on buffer %d with %u bytes\r\n", buf_id, xferred_bytes); pico_trace(" Short packet on buffer %d with %u bytes\r\n", buf_id, xferred_bytes);
// Reduce total length as this is last packet // Reduce total length as this is last packet
ep->remaining_len = 0; ep->remaining_len = 0;
@ -284,8 +262,7 @@ static uint16_t __tusb_irq_path_func(sync_ep_buffer)(struct hw_endpoint *ep, uin
return xferred_bytes; return xferred_bytes;
} }
static void __tusb_irq_path_func(_hw_endpoint_xfer_sync) (struct hw_endpoint *ep) static void __tusb_irq_path_func(_hw_endpoint_xfer_sync)(struct hw_endpoint* ep) {
{
// Update hw endpoint struct with info from hardware // Update hw endpoint struct with info from hardware
// after a buff status interrupt // after a buff status interrupt
@ -296,14 +273,11 @@ static void __tusb_irq_path_func(_hw_endpoint_xfer_sync) (struct hw_endpoint *ep
uint16_t buf0_bytes = sync_ep_buffer(ep, 0); uint16_t buf0_bytes = sync_ep_buffer(ep, 0);
// sync buffer 1 if double buffered // sync buffer 1 if double buffered
if ( (*ep->endpoint_control) & EP_CTRL_DOUBLE_BUFFERED_BITS ) if ((*ep->endpoint_control) & EP_CTRL_DOUBLE_BUFFERED_BITS) {
{ if (buf0_bytes == ep->wMaxPacketSize) {
if (buf0_bytes == ep->wMaxPacketSize)
{
// sync buffer 1 if not short packet // sync buffer 1 if not short packet
sync_ep_buffer(ep, 1); sync_ep_buffer(ep, 1);
}else } else {
{
// short packet on buffer 0 // short packet on buffer 0
// TODO couldn't figure out how to handle this case which happen with net_lwip_webserver example // TODO couldn't figure out how to handle this case which happen with net_lwip_webserver example
// At this time (currently trigger per 2 buffer), the buffer1 is probably filled with data from // At this time (currently trigger per 2 buffer), the buffer1 is probably filled with data from
@ -335,14 +309,13 @@ static void __tusb_irq_path_func(_hw_endpoint_xfer_sync) (struct hw_endpoint *ep
} }
// Returns true if transfer is complete // Returns true if transfer is complete
bool __tusb_irq_path_func(hw_endpoint_xfer_continue)(struct hw_endpoint *ep) bool __tusb_irq_path_func(hw_endpoint_xfer_continue)(struct hw_endpoint* ep) {
{
hw_endpoint_lock_update(ep, 1); hw_endpoint_lock_update(ep, 1);
// Part way through a transfer // Part way through a transfer
if (!ep->active) if (!ep->active) {
{ panic("Can't continue xfer on inactive ep %d %s", tu_edpt_number(ep->ep_addr),
panic("Can't continue xfer on inactive ep %d %s", tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)]); ep_dir_string[tu_edpt_dir(ep->ep_addr)]);
} }
// Update EP struct from hardware state // Update EP struct from hardware state
@ -350,21 +323,16 @@ bool __tusb_irq_path_func(hw_endpoint_xfer_continue)(struct hw_endpoint *ep)
// Now we have synced our state with the hardware. Is there more data to transfer? // Now we have synced our state with the hardware. Is there more data to transfer?
// If we are done then notify tinyusb // If we are done then notify tinyusb
if (ep->remaining_len == 0) if (ep->remaining_len == 0) {
{
pico_trace("Completed transfer of %d bytes on ep %d %s\r\n", pico_trace("Completed transfer of %d bytes on ep %d %s\r\n",
ep->xferred_len, tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)]); ep->xferred_len, tu_edpt_number(ep->ep_addr), ep_dir_string[tu_edpt_dir(ep->ep_addr)]);
// Notify caller we are done so it can notify the tinyusb stack // Notify caller we are done so it can notify the tinyusb stack
hw_endpoint_lock_update(ep, -1); hw_endpoint_lock_update(ep, -1);
return true; return true;
} } else {
else if (e15_is_critical_frame_period(ep)) {
{
if ( e15_is_critical_frame_period(ep) )
{
ep->pending = 1; ep->pending = 1;
} else } else {
{
hw_endpoint_start_next_buffer(ep); hw_endpoint_start_next_buffer(ep);
} }
} }
@ -399,16 +367,14 @@ bool __tusb_irq_path_func(hw_endpoint_xfer_continue)(struct hw_endpoint *ep)
volatile uint32_t e15_last_sof = 0; volatile uint32_t e15_last_sof = 0;
// check if Errata 15 is needed for this endpoint i.e device bulk-in // check if Errata 15 is needed for this endpoint i.e device bulk-in
static bool __tusb_irq_path_func(e15_is_bulkin_ep) (struct hw_endpoint *ep) static bool __tusb_irq_path_func(e15_is_bulkin_ep)(struct hw_endpoint* ep) {
{
return (!is_host_mode() && tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN && return (!is_host_mode() && tu_edpt_dir(ep->ep_addr) == TUSB_DIR_IN &&
ep->transfer_type == TUSB_XFER_BULK); ep->transfer_type == TUSB_XFER_BULK);
} }
// check if we need to apply Errata 15 workaround : i.e // check if we need to apply Errata 15 workaround : i.e
// Endpoint is BULK IN and is currently in critical frame period i.e 20% of last usb frame // Endpoint is BULK IN and is currently in critical frame period i.e 20% of last usb frame
static bool __tusb_irq_path_func(e15_is_critical_frame_period) (struct hw_endpoint *ep) static bool __tusb_irq_path_func(e15_is_critical_frame_period)(struct hw_endpoint* ep) {
{
TU_VERIFY(e15_is_bulkin_ep(ep)); TU_VERIFY(e15_is_bulkin_ep(ep));
/* Avoid the last 200us (uframe 6.5-7) of a frame, up to the EOF2 point. /* Avoid the last 200us (uframe 6.5-7) of a frame, up to the EOF2 point.
@ -419,11 +385,10 @@ static bool __tusb_irq_path_func(e15_is_critical_frame_period) (struct hw_endpoi
if (delta < 800 || delta > 998) { if (delta < 800 || delta > 998) {
return false; return false;
} }
TU_LOG(3, "Avoiding sof %lu now %lu last %lu\r\n", (usb_hw->sof_rd + 1) & USB_SOF_RD_BITS, time_us_32(), e15_last_sof); TU_LOG(3, "Avoiding sof %lu now %lu last %lu\r\n", (usb_hw->sof_rd + 1) & USB_SOF_RD_BITS, time_us_32(),
e15_last_sof);
return true; return true;
} }
#endif #endif // TUD_OPT_RP2040_USB_DEVICE_UFRAME_FIX
#endif #endif