add tuh_edpt_close() API, it will abort any pending transfer

implement hcd_edpt_close() for pio-usb and max3421e, also move max3421e api into its own header.

8 files changed, 213 insertions, 159 deletions

diff --git a/examples/host/bare_api/src/main.c b/examples/host/bare_api/src/main.c
index f582f4f5a..0c76ff0c9 100644
--- a/examples/host/bare_api/src/main.c
+++ b/examples/host/bare_api/src/main.c
@@ -55,16 +55,15 @@ uint8_t* get_hid_buf(uint8_t daddr);
 void free_hid_buf(uint8_t daddr);
 
 /*------------- MAIN -------------*/
-int main(void)
-{
+int main(void) {
   board_init();
 
   printf("TinyUSB Bare API Example\r\n");
 
   // init host stack on configured roothub port
   tusb_rhport_init_t host_init = {
-    .role = TUSB_ROLE_HOST,
-    .speed = TUSB_SPEED_AUTO
+      .role = TUSB_ROLE_HOST,
+      .speed = TUSB_SPEED_AUTO
   };
   tusb_init(BOARD_TUH_RHPORT, &host_init);
 
@@ -72,8 +71,7 @@ int main(void)
     board_init_after_tusb();
   }
 
-  while (1)
-  {
+  while (1) {
     // tinyusb host task
     tuh_task();
     led_blinking_task();
@@ -85,8 +83,7 @@ int main(void)
 /*------------- TinyUSB Callbacks -------------*/
 
 // Invoked when device is mounted (configured)
-void tuh_mount_cb (uint8_t daddr)
-{
+void tuh_mount_cb(uint8_t daddr) {
   printf("Device attached, address = %d\r\n", daddr);
 
   // Get Device Descriptor
@@ -95,8 +92,7 @@ void tuh_mount_cb (uint8_t daddr)
 }
 
 /// Invoked when device is unmounted (bus reset/unplugged)
-void tuh_umount_cb(uint8_t daddr)
-{
+void tuh_umount_cb(uint8_t daddr) {
   printf("Device removed, address = %d\r\n", daddr);
   free_hid_buf(daddr);
 }
@@ -104,11 +100,8 @@ void tuh_umount_cb(uint8_t daddr)
 //--------------------------------------------------------------------+
 // Device Descriptor
 //--------------------------------------------------------------------+
-
-void print_device_descriptor(tuh_xfer_t* xfer)
-{
-  if ( XFER_RESULT_SUCCESS != xfer->result )
-  {
+void print_device_descriptor(tuh_xfer_t *xfer) {
+  if (XFER_RESULT_SUCCESS != xfer->result) {
     printf("Failed to get device descriptor\r\n");
     return;
   }
@@ -131,33 +124,29 @@ void print_device_descriptor(tuh_xfer_t* xfer)
   // Get String descriptor using Sync API
   uint16_t temp_buf[128];
 
-  printf("  iManufacturer       %u     "     , desc_device.iManufacturer);
-  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_manufacturer_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf)) )
-  {
+  printf("  iManufacturer       %u     ", desc_device.iManufacturer);
+  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_manufacturer_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf))) {
     print_utf16(temp_buf, TU_ARRAY_SIZE(temp_buf));
   }
   printf("\r\n");
 
-  printf("  iProduct            %u     "     , desc_device.iProduct);
-  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_product_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf)))
-  {
+  printf("  iProduct            %u     ", desc_device.iProduct);
+  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_product_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf))) {
     print_utf16(temp_buf, TU_ARRAY_SIZE(temp_buf));
   }
   printf("\r\n");
 
-  printf("  iSerialNumber       %u     "     , desc_device.iSerialNumber);
-  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_serial_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf)))
-  {
+  printf("  iSerialNumber       %u     ", desc_device.iSerialNumber);
+  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_serial_string_sync(daddr, LANGUAGE_ID, temp_buf, sizeof(temp_buf))) {
     print_utf16(temp_buf, TU_ARRAY_SIZE(temp_buf));
   }
   printf("\r\n");
 
-  printf("  bNumConfigurations  %u\r\n"     , desc_device.bNumConfigurations);
+  printf("  bNumConfigurations  %u\r\n", desc_device.bNumConfigurations);
 
   // Get configuration descriptor with sync API
-  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_configuration_sync(daddr, 0, temp_buf, sizeof(temp_buf)))
-  {
-    parse_config_descriptor(daddr, (tusb_desc_configuration_t*) temp_buf);
+  if (XFER_RESULT_SUCCESS == tuh_descriptor_get_configuration_sync(daddr, 0, temp_buf, sizeof(temp_buf))) {
+    parse_config_descriptor(daddr, (tusb_desc_configuration_t *) temp_buf);
   }
 }
 
@@ -171,37 +160,33 @@ uint16_t count_interface_total_len(tusb_desc_interface_t const* desc_itf, uint8_
 void open_hid_interface(uint8_t daddr, tusb_desc_interface_t const *desc_itf, uint16_t max_len);
 
 // simple configuration parser to open and listen to HID Endpoint IN
-void parse_config_descriptor(uint8_t dev_addr, tusb_desc_configuration_t const* desc_cfg)
-{
-  uint8_t const* desc_end = ((uint8_t const*) desc_cfg) + tu_le16toh(desc_cfg->wTotalLength);
-  uint8_t const* p_desc   = tu_desc_next(desc_cfg);
+void parse_config_descriptor(uint8_t dev_addr, tusb_desc_configuration_t const *desc_cfg) {
+  uint8_t const *desc_end = ((uint8_t const *) desc_cfg) + tu_le16toh(desc_cfg->wTotalLength);
+  uint8_t const *p_desc = tu_desc_next(desc_cfg);
 
   // parse each interfaces
-  while( p_desc < desc_end )
-  {
+  while (p_desc < desc_end) {
     uint8_t assoc_itf_count = 1;
 
     // Class will always starts with Interface Association (if any) and then Interface descriptor
-    if ( TUSB_DESC_INTERFACE_ASSOCIATION == tu_desc_type(p_desc) )
-    {
-      tusb_desc_interface_assoc_t const * desc_iad = (tusb_desc_interface_assoc_t const *) p_desc;
+    if (TUSB_DESC_INTERFACE_ASSOCIATION == tu_desc_type(p_desc)) {
+      tusb_desc_interface_assoc_t const *desc_iad = (tusb_desc_interface_assoc_t const *) p_desc;
       assoc_itf_count = desc_iad->bInterfaceCount;
 
-      p_desc = tu_desc_next(p_desc); // next to Interface
+      p_desc = tu_desc_next(p_desc);// next to Interface
     }
 
     // must be interface from now
-    if( TUSB_DESC_INTERFACE != tu_desc_type(p_desc) ) return;
-    tusb_desc_interface_t const* desc_itf = (tusb_desc_interface_t const*) p_desc;
+    if (TUSB_DESC_INTERFACE != tu_desc_type(p_desc)) { return; }
+    tusb_desc_interface_t const *desc_itf = (tusb_desc_interface_t const *) p_desc;
 
-    uint16_t const drv_len = count_interface_total_len(desc_itf, assoc_itf_count, (uint16_t) (desc_end-p_desc));
+    uint16_t const drv_len = count_interface_total_len(desc_itf, assoc_itf_count, (uint16_t) (desc_end - p_desc));
 
     // probably corrupted descriptor
-    if(drv_len < sizeof(tusb_desc_interface_t)) return;
+    if (drv_len < sizeof(tusb_desc_interface_t)) { return; }
 
     // only open and listen to HID endpoint IN
-    if (desc_itf->bInterfaceClass == TUSB_CLASS_HID)
-    {
+    if (desc_itf->bInterfaceClass == TUSB_CLASS_HID) {
       open_hid_interface(dev_addr, desc_itf, drv_len);
     }
 
@@ -210,25 +195,21 @@ void parse_config_descriptor(uint8_t dev_addr, tusb_desc_configuration_t const*
   }
 }
 
-uint16_t count_interface_total_len(tusb_desc_interface_t const* desc_itf, uint8_t itf_count, uint16_t max_len)
-{
-  uint8_t const* p_desc = (uint8_t const*) desc_itf;
+uint16_t count_interface_total_len(tusb_desc_interface_t const *desc_itf, uint8_t itf_count, uint16_t max_len) {
+  uint8_t const *p_desc = (uint8_t const *) desc_itf;
   uint16_t len = 0;
 
-  while (itf_count--)
-  {
+  while (itf_count--) {
     // Next on interface desc
     len += tu_desc_len(desc_itf);
     p_desc = tu_desc_next(p_desc);
 
-    while (len < max_len)
-    {
+    while (len < max_len) {
       // return on IAD regardless of itf count
-      if ( tu_desc_type(p_desc) == TUSB_DESC_INTERFACE_ASSOCIATION ) return len;
+      if (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE_ASSOCIATION) { return len; }
 
-      if ( (tu_desc_type(p_desc) == TUSB_DESC_INTERFACE) &&
-           ((tusb_desc_interface_t const*) p_desc)->bAlternateSetting == 0 )
-      {
+      if ((tu_desc_type(p_desc) == TUSB_DESC_INTERFACE) &&
+          ((tusb_desc_interface_t const *) p_desc)->bAlternateSetting == 0) {
         break;
       }
 
@@ -246,46 +227,45 @@ uint16_t count_interface_total_len(tusb_desc_interface_t const* desc_itf, uint8_
 
 void hid_report_received(tuh_xfer_t* xfer);
 
-void open_hid_interface(uint8_t daddr, tusb_desc_interface_t const *desc_itf, uint16_t max_len)
-{
+void open_hid_interface(uint8_t daddr, tusb_desc_interface_t const *desc_itf, uint16_t max_len) {
   // len = interface + hid + n*endpoints
   uint16_t const drv_len = (uint16_t) (sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) +
                                        desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
 
   // corrupted descriptor
-  if (max_len < drv_len) return;
+  if (max_len < drv_len) { return; }
 
   uint8_t const *p_desc = (uint8_t const *) desc_itf;
 
   // HID descriptor
   p_desc = tu_desc_next(p_desc);
   tusb_hid_descriptor_hid_t const *desc_hid = (tusb_hid_descriptor_hid_t const *) p_desc;
-  if(HID_DESC_TYPE_HID != desc_hid->bDescriptorType) return;
+  if (HID_DESC_TYPE_HID != desc_hid->bDescriptorType) { return; }
 
   // Endpoint descriptor
   p_desc = tu_desc_next(p_desc);
-  tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) p_desc;
+  tusb_desc_endpoint_t const *desc_ep = (tusb_desc_endpoint_t const *) p_desc;
 
-  for(int i = 0; i < desc_itf->bNumEndpoints; i++)
-  {
-    if (TUSB_DESC_ENDPOINT != desc_ep->bDescriptorType) return;
+  for (int i = 0; i < desc_itf->bNumEndpoints; i++) {
+    if (TUSB_DESC_ENDPOINT != desc_ep->bDescriptorType) { return; }
 
-    if(tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN)
-    {
-      // skip if failed to open endpoint
-      if ( ! tuh_edpt_open(daddr, desc_ep) ) return;
+    if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
+      if (!tuh_edpt_open(daddr, desc_ep)) {
+        return; // skip if failed to open endpoint
+      }
 
-      uint8_t* buf = get_hid_buf(daddr);
-      if (!buf) return; // out of memory
+      uint8_t *buf = get_hid_buf(daddr);
+      if (!buf) {
+        return;// out of memory
+      }
 
-      tuh_xfer_t xfer =
-      {
-        .daddr       = daddr,
-        .ep_addr     = desc_ep->bEndpointAddress,
-        .buflen      = 64,
-        .buffer      = buf,
-        .complete_cb = hid_report_received,
-        .user_data   = (uintptr_t) buf, // since buffer is not available in callback, use user data to store the buffer
+      tuh_xfer_t xfer = {
+          .daddr = daddr,
+          .ep_addr = desc_ep->bEndpointAddress,
+          .buflen = 64,
+          .buffer = buf,
+          .complete_cb = hid_report_received,
+          .user_data = (uintptr_t) buf,// since buffer is not available in callback, use user data to store the buffer
       };
 
       // submit transfer for this EP
@@ -299,18 +279,17 @@ void open_hid_interface(uint8_t daddr, tusb_desc_interface_t const *desc_itf, ui
   }
 }
 
-void hid_report_received(tuh_xfer_t* xfer)
-{
+void hid_report_received(tuh_xfer_t *xfer) {
   // Note: not all field in xfer is available for use (i.e filled by tinyusb stack) in callback to save sram
   // For instance, xfer->buffer is NULL. We have used user_data to store buffer when submitted callback
-  uint8_t* buf = (uint8_t*) xfer->user_data;
+  uint8_t *buf = (uint8_t *) xfer->user_data;
 
-  if (xfer->result == XFER_RESULT_SUCCESS)
-  {
+  if (xfer->result == XFER_RESULT_SUCCESS) {
     printf("[dev %u: ep %02x] HID Report:", xfer->daddr, xfer->ep_addr);
-    for(uint32_t i=0; i<xfer->actual_len; i++)
-    {
-      if (i%16 == 0) printf("\r\n  ");
+    for (uint32_t i = 0; i < xfer->actual_len; i++) {
+      if (i % 16 == 0) {
+        printf("\r\n  ");
+      }
       printf("%02X ", buf[i]);
     }
     printf("\r\n");
@@ -329,12 +308,9 @@ void hid_report_received(tuh_xfer_t* xfer)
 //--------------------------------------------------------------------+
 
 // get an buffer from pool
-uint8_t* get_hid_buf(uint8_t daddr)
-{
-  for(size_t i=0; i<BUF_COUNT; i++)
-  {
-    if (buf_owner[i] == 0)
-    {
+uint8_t *get_hid_buf(uint8_t daddr) {
+  for (size_t i = 0; i < BUF_COUNT; i++) {
+    if (buf_owner[i] == 0) {
       buf_owner[i] = daddr;
       return buf_pool[i];
     }
@@ -345,10 +321,8 @@ uint8_t* get_hid_buf(uint8_t daddr)
 }
 
 // free all buffer owned by device
-void free_hid_buf(uint8_t daddr)
-{
-  for(size_t i=0; i<BUF_COUNT; i++)
-  {
+void free_hid_buf(uint8_t daddr) {
+  for (size_t i = 0; i < BUF_COUNT; i++) {
     if (buf_owner[i] == daddr) buf_owner[i] = 0;
   }
 }
@@ -356,70 +330,70 @@ void free_hid_buf(uint8_t daddr)
 //--------------------------------------------------------------------+
 // Blinking Task
 //--------------------------------------------------------------------+
-void led_blinking_task(void)
-{
+void led_blinking_task(void) {
   const uint32_t interval_ms = 1000;
   static uint32_t start_ms = 0;
 
   static bool led_state = false;
 
   // Blink every interval ms
-  if ( board_millis() - start_ms < interval_ms) return; // not enough time
+  if (board_millis() - start_ms < interval_ms) {
+    return; // not enough time
+  }
   start_ms += interval_ms;
 
   board_led_write(led_state);
-  led_state = 1 - led_state; // toggle
+  led_state = 1 - led_state;// toggle
 }
 
 //--------------------------------------------------------------------+
 // String Descriptor Helper
 //--------------------------------------------------------------------+
-
 static void _convert_utf16le_to_utf8(const uint16_t *utf16, size_t utf16_len, uint8_t *utf8, size_t utf8_len) {
-    // TODO: Check for runover.
-    (void)utf8_len;
-    // Get the UTF-16 length out of the data itself.
+  // TODO: Check for runover.
+  (void) utf8_len;
+  // Get the UTF-16 length out of the data itself.
 
-    for (size_t i = 0; i < utf16_len; i++) {
-        uint16_t chr = utf16[i];
-        if (chr < 0x80) {
-            *utf8++ = chr & 0xffu;
-        } else if (chr < 0x800) {
-            *utf8++ = (uint8_t)(0xC0 | (chr >> 6 & 0x1F));
-            *utf8++ = (uint8_t)(0x80 | (chr >> 0 & 0x3F));
-        } else {
-            // TODO: Verify surrogate.
-            *utf8++ = (uint8_t)(0xE0 | (chr >> 12 & 0x0F));
-            *utf8++ = (uint8_t)(0x80 | (chr >> 6 & 0x3F));
-            *utf8++ = (uint8_t)(0x80 | (chr >> 0 & 0x3F));
-        }
-        // TODO: Handle UTF-16 code points that take two entries.
+  for (size_t i = 0; i < utf16_len; i++) {
+    uint16_t chr = utf16[i];
+    if (chr < 0x80) {
+      *utf8++ = chr & 0xffu;
+    } else if (chr < 0x800) {
+      *utf8++ = (uint8_t) (0xC0 | (chr >> 6 & 0x1F));
+      *utf8++ = (uint8_t) (0x80 | (chr >> 0 & 0x3F));
+    } else {
+      // TODO: Verify surrogate.
+      *utf8++ = (uint8_t) (0xE0 | (chr >> 12 & 0x0F));
+      *utf8++ = (uint8_t) (0x80 | (chr >> 6 & 0x3F));
+      *utf8++ = (uint8_t) (0x80 | (chr >> 0 & 0x3F));
     }
+    // TODO: Handle UTF-16 code points that take two entries.
+  }
 }
 
 // Count how many bytes a utf-16-le encoded string will take in utf-8.
 static int _count_utf8_bytes(const uint16_t *buf, size_t len) {
-    size_t total_bytes = 0;
-    for (size_t i = 0; i < len; i++) {
-        uint16_t chr = buf[i];
-        if (chr < 0x80) {
-            total_bytes += 1;
-        } else if (chr < 0x800) {
-            total_bytes += 2;
-        } else {
-            total_bytes += 3;
-        }
-        // TODO: Handle UTF-16 code points that take two entries.
+  size_t total_bytes = 0;
+  for (size_t i = 0; i < len; i++) {
+    uint16_t chr = buf[i];
+    if (chr < 0x80) {
+      total_bytes += 1;
+    } else if (chr < 0x800) {
+      total_bytes += 2;
+    } else {
+      total_bytes += 3;
     }
-    return (int) total_bytes;
+    // TODO: Handle UTF-16 code points that take two entries.
+  }
+  return (int) total_bytes;
 }
 
 static void print_utf16(uint16_t *temp_buf, size_t buf_len) {
-    if ((temp_buf[0] & 0xff) == 0) return;  // empty
-    size_t utf16_len = ((temp_buf[0] & 0xff) - 2) / sizeof(uint16_t);
-    size_t utf8_len = (size_t) _count_utf8_bytes(temp_buf + 1, utf16_len);
-    _convert_utf16le_to_utf8(temp_buf + 1, utf16_len, (uint8_t *) temp_buf, sizeof(uint16_t) * buf_len);
-    ((uint8_t*) temp_buf)[utf8_len] = '\0';
+  if ((temp_buf[0] & 0xff) == 0) return;// empty
+  size_t utf16_len = ((temp_buf[0] & 0xff) - 2) / sizeof(uint16_t);
+  size_t utf8_len = (size_t) _count_utf8_bytes(temp_buf + 1, utf16_len);
+  _convert_utf16le_to_utf8(temp_buf + 1, utf16_len, (uint8_t *) temp_buf, sizeof(uint16_t) * buf_len);
+  ((uint8_t *) temp_buf)[utf8_len] = '\0';
 
-    printf("%s", (char*)temp_buf);
+  printf("%s", (char *) temp_buf);
 }
diff --git a/src/host/hcd.h b/src/host/hcd.h
index 56b6fdb5d..aa9e9cf3b 100644
--- a/src/host/hcd.h
+++ b/src/host/hcd.h
@@ -165,6 +165,9 @@ void hcd_device_close(uint8_t rhport, uint8_t dev_addr);
 // Open an endpoint
 bool hcd_edpt_open(uint8_t rhport, uint8_t daddr, tusb_desc_endpoint_t const * ep_desc);
 
+// Close an endpoint
+bool hcd_edpt_close(uint8_t rhport, uint8_t daddr, uint8_t ep_addr);
+
 // Submit a transfer, when complete hcd_event_xfer_complete() must be invoked
 bool hcd_edpt_xfer(uint8_t rhport, uint8_t daddr, uint8_t ep_addr, uint8_t * buffer, uint16_t buflen);
 
diff --git a/src/host/usbh.c b/src/host/usbh.c
index 308916c9b..5925a7be0 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -994,6 +994,12 @@ bool tuh_edpt_open(uint8_t dev_addr, tusb_desc_endpoint_t const* desc_ep) {
   return hcd_edpt_open(usbh_get_rhport(dev_addr), dev_addr, desc_ep);
 }
 
+bool tuh_edpt_close(uint8_t daddr, uint8_t ep_addr) {
+  TU_VERIFY(0 != tu_edpt_number(ep_addr)); // cannot close EP0
+  tuh_edpt_abort_xfer(daddr, ep_addr); // abort any pending transfer
+  return hcd_edpt_close(usbh_get_rhport(daddr), daddr, ep_addr);
+}
+
 bool usbh_edpt_busy(uint8_t dev_addr, uint8_t ep_addr) {
   usbh_device_t* dev = get_device(dev_addr);
   TU_VERIFY(dev);
diff --git a/src/host/usbh.h b/src/host/usbh.h
index d95bb9b57..4829a8183 100644
--- a/src/host/usbh.h
+++ b/src/host/usbh.h
@@ -33,6 +33,10 @@
 
 #include "common/tusb_common.h"
 
+#if CFG_TUH_MAX3421
+#include "portable/analog/max3421/hcd_max3421.h"
+#endif
+
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF
 //--------------------------------------------------------------------+
@@ -227,6 +231,9 @@ bool tuh_edpt_xfer(tuh_xfer_t* xfer);
 // Open a non-control endpoint
 bool tuh_edpt_open(uint8_t daddr, tusb_desc_endpoint_t const * desc_ep);
 
+// Close a non-control endpoint, it will abort any pending transfer
+bool tuh_edpt_close(uint8_t daddr, uint8_t ep_addr);
+
 // Abort a queued transfer. Note: it can only abort transfer that has not been started
 // Return true if a queued transfer is aborted, false if there is no transfer to abort
 bool tuh_edpt_abort_xfer(uint8_t daddr, uint8_t ep_addr);
diff --git a/src/portable/analog/max3421/hcd_max3421.c b/src/portable/analog/max3421/hcd_max3421.c
index c5e924266..3fbf950a4 100644
--- a/src/portable/analog/max3421/hcd_max3421.c
+++ b/src/portable/analog/max3421/hcd_max3421.c
@@ -253,28 +253,6 @@ static tuh_configure_max3421_t _tuh_cfg = {
 };
 
 //--------------------------------------------------------------------+
-// API: SPI transfer with MAX3421E
-// - spi_cs_api(), spi_xfer_api(), int_api(): must be implemented by application
-// - reg_read(), reg_write(): is implemented by this driver, can be used by application
-//--------------------------------------------------------------------+
-
-// API to control MAX3421 SPI CS
-extern void tuh_max3421_spi_cs_api(uint8_t rhport, bool active);
-
-// API to transfer data with MAX3421 SPI
-// Either tx_buf or rx_buf can be NULL, which means transfer is write or read only
-extern bool tuh_max3421_spi_xfer_api(uint8_t rhport, uint8_t const* tx_buf, uint8_t* rx_buf, size_t xfer_bytes);
-
-// API to enable/disable MAX3421 INTR pin interrupt
-extern void tuh_max3421_int_api(uint8_t rhport, bool enabled);
-
-// API to read MAX3421's register. Implemented by TinyUSB
-uint8_t tuh_max3421_reg_read(uint8_t rhport, uint8_t reg, bool in_isr);
-
-// API to write MAX3421's register. Implemented by TinyUSB
-bool tuh_max3421_reg_write(uint8_t rhport, uint8_t reg, uint8_t data, bool in_isr);
-
-//--------------------------------------------------------------------+
 // SPI Commands and Helper
 //--------------------------------------------------------------------+
 
@@ -632,6 +610,9 @@ bool hcd_edpt_open(uint8_t rhport, uint8_t daddr, tusb_desc_endpoint_t const * e
   if (daddr == 0 && ep_num == 0) {
     ep = &_hcd_data.ep[0];
   }else {
+    if (NULL != find_ep_not_addr0(daddr, ep_num, ep_dir)) {
+      return false; // endpoint already opened
+    }
     ep = allocate_ep();
     TU_ASSERT(ep);
     ep->daddr = daddr;
@@ -645,6 +626,21 @@ bool hcd_edpt_open(uint8_t rhport, uint8_t daddr, tusb_desc_endpoint_t const * e
   return true;
 }
 
+bool hcd_edpt_close(uint8_t rhport, uint8_t daddr, uint8_t ep_addr) {
+  (void) rhport;
+  uint8_t const ep_num = tu_edpt_number(ep_addr);
+  tusb_dir_t const ep_dir = tu_edpt_dir(ep_addr);
+  max3421_ep_t * ep = find_ep_not_addr0(daddr, ep_num, ep_dir);
+
+  if (!ep) {
+    return false; // not opened
+  }
+
+  tu_memclr(ep, sizeof(max3421_ep_t));
+
+  return true;
+}
+
 /* The microcontroller repeatedly writes the SNDFIFO register R2 to load the FIFO with up to 64 data bytes.
  * Then the microcontroller writes the SNDBC register, which this does three things:
  * 1. Tells the MAX3421E SIE (Serial Interface Engine) how many bytes in the FIFO to send.
diff --git a/src/portable/analog/max3421/hcd_max3421.h b/src/portable/analog/max3421/hcd_max3421.h
new file mode 100644
index 000000000..4631fa21a
--- /dev/null
+++ b/src/portable/analog/max3421/hcd_max3421.h
@@ -0,0 +1,63 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ha Thach (tinyusb.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This file is part of the TinyUSB stack.
+ */
+#ifndef TUSB_HCD_MAX3421_H
+#define TUSB_HCD_MAX3421_H
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+//--------------------------------------------------------------------+
+// SPI transfer API with MAX3421E are implemented by application
+// - spi_cs_api(), spi_xfer_api(), int_api()
+//--------------------------------------------------------------------+
+
+// API to control MAX3421 SPI CS
+extern void tuh_max3421_spi_cs_api(uint8_t rhport, bool active);
+
+// API to transfer data with MAX3421 SPI
+// Either tx_buf or rx_buf can be NULL, which means transfer is write or read only
+extern bool tuh_max3421_spi_xfer_api(uint8_t rhport, uint8_t const* tx_buf, uint8_t* rx_buf, size_t xfer_bytes);
+
+// API to enable/disable MAX3421 INTR pin interrupt
+extern void tuh_max3421_int_api(uint8_t rhport, bool enabled);
+
+//--------------------------------------------------------------------+
+// API for read/write MAX3421 registers
+// are implemented by this driver, can be used by application
+//--------------------------------------------------------------------+
+
+// API to read MAX3421's register. Implemented by TinyUSB
+uint8_t tuh_max3421_reg_read(uint8_t rhport, uint8_t reg, bool in_isr);
+
+// API to write MAX3421's register. Implemented by TinyUSB
+bool tuh_max3421_reg_write(uint8_t rhport, uint8_t reg, uint8_t data, bool in_isr);
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif
diff --git a/src/portable/raspberrypi/pio_usb/hcd_pio_usb.c b/src/portable/raspberrypi/pio_usb/hcd_pio_usb.c
index 6422afff1..225a44dcf 100644
--- a/src/portable/raspberrypi/pio_usb/hcd_pio_usb.c
+++ b/src/portable/raspberrypi/pio_usb/hcd_pio_usb.c
@@ -122,6 +122,11 @@ bool hcd_edpt_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_endpoint_t const
   return pio_usb_host_endpoint_open(pio_rhport, dev_addr, (uint8_t const *) desc_ep, need_pre);
 }
 
+bool hcd_edpt_close(uint8_t rhport, uint8_t daddr, uint8_t ep_addr) {
+  uint8_t const pio_rhport = RHPORT_PIO(rhport);
+  return pio_usb_host_endpoint_close(pio_rhport, daddr, ep_addr);
+}
+
 bool hcd_edpt_xfer(uint8_t rhport, uint8_t dev_addr, uint8_t ep_addr, uint8_t *buffer, uint16_t buflen) {
   uint8_t const pio_rhport = RHPORT_PIO(rhport);
   return pio_usb_host_endpoint_transfer(pio_rhport, dev_addr, ep_addr, buffer, buflen);
diff --git a/tools/get_deps.py b/tools/get_deps.py
index 3f529bd7e..ba9dc23ce 100755
--- a/tools/get_deps.py
+++ b/tools/get_deps.py
@@ -58,8 +58,8 @@ deps_optional = {
     'hw/mcu/nxp/mcux-sdk': ['https://github.com/hathach/mcux-sdk.git',
                             '144f1eb7ea8c06512e12f12b27383601c0272410',
                             'kinetis_k kinetis_k32l2 kinetis_kl lpc51 lpc54 lpc55 mcx imxrt'],
-    'hw/mcu/raspberry_pi/Pico-PIO-USB': ['https://github.com/sekigon-gonnoc/Pico-PIO-USB.git',
-                                         '0ca3657d55ea20e7fa4483bbd21ce951bc1d6fa5',
+    'hw/mcu/raspberry_pi/Pico-PIO-USB': ['https://github.com/hathach/Pico-PIO-USB.git',
+                                         '810653f66adadba3e0e4b4b56d5167ac4f7fdbf7',
                                          'rp2040'],
     'hw/mcu/renesas/fsp': ['https://github.com/renesas/fsp.git',
                            'edcc97d684b6f716728a60d7a6fea049d9870bd6',