rename osal SUBSTASK to STASK

11 files changed, 121 insertions, 121 deletions

diff --git a/tinyusb/class/cdc/cdc_device.c b/tinyusb/class/cdc/cdc_device.c
index 75c1f2df3..c027e6ffb 100644
--- a/tinyusb/class/cdc/cdc_device.c
+++ b/tinyusb/class/cdc/cdc_device.c
@@ -225,12 +225,12 @@ tusb_error_t cdcd_control_request_subtask(uint8_t port, tusb_control_request_t c
 

   if (CDC_REQUEST_GET_LINE_CODING == p_request->bRequest)

   {

-    SUBTASK_INVOKE( usbd_control_xfer_stask(port, (tusb_dir_t) p_request->bmRequestType_bit.direction,

+    STASK_INVOKE( usbd_control_xfer_stask(port, (tusb_dir_t) p_request->bmRequestType_bit.direction,

                                             (uint8_t*) &cdcd_line_coding[port], min16_of(sizeof(cdc_line_coding_t), p_request->wLength)), err );

   }

   else if (CDC_REQUEST_SET_LINE_CODING == p_request->bRequest)

   {

-    SUBTASK_INVOKE( usbd_control_xfer_stask(port, (tusb_dir_t) p_request->bmRequestType_bit.direction,

+    STASK_INVOKE( usbd_control_xfer_stask(port, (tusb_dir_t) p_request->bmRequestType_bit.direction,

                                             (uint8_t*) &cdcd_line_coding[port], min16_of(sizeof(cdc_line_coding_t), p_request->wLength)), err );

     // TODO notify application on xfer complete

   }

diff --git a/tinyusb/class/cdc/cdc_rndis_host.c b/tinyusb/class/cdc/cdc_rndis_host.c
index 7910e63a3..7157331dd 100644
--- a/tinyusb/class/cdc/cdc_rndis_host.c
+++ b/tinyusb/class/cdc/cdc_rndis_host.c
@@ -173,17 +173,17 @@ tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc)
 
   //------------- Message Initialize -------------//
   memcpy(msg_payload, &msg_init, sizeof(rndis_msg_initialize_t));
-  SUBTASK_INVOKE(
+  STASK_INVOKE(
       send_message_get_response_subtask( dev_addr, p_cdc,
                                          msg_payload, sizeof(rndis_msg_initialize_t),
                                          msg_payload),
       error
   );
-  if ( TUSB_ERROR_NONE != error )   SUBTASK_RETURN(error);
+  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
 
   // TODO currently not support multiple data packets per xfer
   rndis_msg_initialize_cmplt_t * const p_init_cmpt = (rndis_msg_initialize_cmplt_t *) msg_payload;
-  SUBTASK_ASSERT(p_init_cmpt->type == RNDIS_MSG_INITIALIZE_CMPLT && p_init_cmpt->status == RNDIS_STATUS_SUCCESS &&
+  STASK_ASSERT(p_init_cmpt->type == RNDIS_MSG_INITIALIZE_CMPLT && p_init_cmpt->status == RNDIS_STATUS_SUCCESS &&
                  p_init_cmpt->max_packet_per_xfer == 1 && p_init_cmpt->max_xfer_size <= RNDIS_MSG_PAYLOAD_MAX);
   rndish_data[dev_addr-1].max_xfer_size = p_init_cmpt->max_xfer_size;
 
@@ -191,16 +191,16 @@ tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc)
   memcpy(msg_payload, &msg_query_permanent_addr, sizeof(rndis_msg_query_t));
   memclr_(msg_payload + sizeof(rndis_msg_query_t), 6); // 6 bytes for MAC address
 
-  SUBTASK_INVOKE(
+  STASK_INVOKE(
       send_message_get_response_subtask( dev_addr, p_cdc,
                                          msg_payload, sizeof(rndis_msg_query_t) + 6,
                                          msg_payload),
       error
   );
-  if ( TUSB_ERROR_NONE != error )   SUBTASK_RETURN(error);
+  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
 
   rndis_msg_query_cmplt_t * const p_query_cmpt = (rndis_msg_query_cmplt_t *) msg_payload;
-  SUBTASK_ASSERT(p_query_cmpt->type == RNDIS_MSG_QUERY_CMPLT && p_query_cmpt->status == RNDIS_STATUS_SUCCESS);
+  STASK_ASSERT(p_query_cmpt->type == RNDIS_MSG_QUERY_CMPLT && p_query_cmpt->status == RNDIS_STATUS_SUCCESS);
   memcpy(rndish_data[dev_addr-1].mac_address, msg_payload + 8 + p_query_cmpt->buffer_offset, 6);
 
   //------------- Set OID_GEN_CURRENT_PACKET_FILTER to (DIRECTED | MULTICAST | BROADCAST) -------------//
@@ -208,16 +208,16 @@ tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc)
   memclr_(msg_payload + sizeof(rndis_msg_set_t), 4); // 4 bytes for filter flags
   ((rndis_msg_set_t*) msg_payload)->oid_buffer[0] = (RNDIS_PACKET_TYPE_DIRECTED | RNDIS_PACKET_TYPE_MULTICAST | RNDIS_PACKET_TYPE_BROADCAST);
 
-  SUBTASK_INVOKE(
+  STASK_INVOKE(
       send_message_get_response_subtask( dev_addr, p_cdc,
                                          msg_payload, sizeof(rndis_msg_set_t) + 4,
                                          msg_payload),
       error
   );
-  if ( TUSB_ERROR_NONE != error )   SUBTASK_RETURN(error);
+  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
 
   rndis_msg_set_cmplt_t * const p_set_cmpt = (rndis_msg_set_cmplt_t *) msg_payload;
-  SUBTASK_ASSERT(p_set_cmpt->type == RNDIS_MSG_SET_CMPLT && p_set_cmpt->status == RNDIS_STATUS_SUCCESS);
+  STASK_ASSERT(p_set_cmpt->type == RNDIS_MSG_SET_CMPLT && p_set_cmpt->status == RNDIS_STATUS_SUCCESS);
 
   tusbh_cdc_rndis_mounted_cb(dev_addr);
 
@@ -244,28 +244,28 @@ static tusb_error_t send_message_get_response_subtask( uint8_t dev_addr, cdch_da
   OSAL_SUBTASK_BEGIN
 
   //------------- Send RNDIS Control Message -------------//
-  SUBTASK_INVOKE(
+  STASK_INVOKE(
       usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),
                                  CDC_REQUEST_SEND_ENCAPSULATED_COMMAND, 0, p_cdc->interface_number,
                                  mess_length, p_mess),
       error
   );
-  if ( TUSB_ERROR_NONE != error )   SUBTASK_RETURN(error);
+  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
 
   //------------- waiting for Response Available notification -------------//
   (void) hcd_pipe_xfer(p_cdc->pipe_notification, msg_notification[dev_addr-1], 8, true);
   osal_semaphore_wait(rndish_data[dev_addr-1].sem_notification_hdl, OSAL_TIMEOUT_NORMAL, &error);
-  if ( TUSB_ERROR_NONE != error )   SUBTASK_RETURN(error);
-  SUBTASK_ASSERT(msg_notification[dev_addr-1][0] == 1);
+  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
+  STASK_ASSERT(msg_notification[dev_addr-1][0] == 1);
 
   //------------- Get RNDIS Message Initialize Complete -------------//
-  SUBTASK_INVOKE(
+  STASK_INVOKE(
     usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),
                                CDC_REQUEST_GET_ENCAPSULATED_RESPONSE, 0, p_cdc->interface_number,
                                RNDIS_MSG_PAYLOAD_MAX, p_response),
     error
   );
-  if ( TUSB_ERROR_NONE != error )   SUBTASK_RETURN(error);
+  if ( TUSB_ERROR_NONE != error )   STASK_RETURN(error);
 
   OSAL_SUBTASK_END
 }
diff --git a/tinyusb/class/hid/hid_device.c b/tinyusb/class/hid/hid_device.c
index 707476517..dfb239650 100644
--- a/tinyusb/class/hid/hid_device.c
+++ b/tinyusb/class/hid/hid_device.c
@@ -204,12 +204,12 @@ tusb_error_t hidd_control_request_subtask(uint8_t port, tusb_control_request_t c
 

     if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)

     {

-      SUBTASK_ASSERT ( p_hid->report_length <= HIDD_BUFFER_SIZE );

+      STASK_ASSERT ( p_hid->report_length <= HIDD_BUFFER_SIZE );

 

       // copy to allow report descriptor not to be in USBRAM

       memcpy(m_hid_buffer, p_hid->p_report_desc, p_hid->report_length);

 

-      SUBTASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, m_hid_buffer, p_hid->report_length), err );

+      STASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, m_hid_buffer, p_hid->report_length), err );

     }else

     {

       usbd_control_stall(port);

@@ -225,16 +225,16 @@ tusb_error_t hidd_control_request_subtask(uint8_t port, tusb_control_request_t c
 

       uint16_t actual_length = p_driver->get_report_cb(port, (hid_request_report_type_t) u16_high_u8(p_request->wValue),

                                                        &p_buffer, p_request->wLength);

-      SUBTASK_ASSERT( p_buffer != NULL && actual_length > 0 );

+      STASK_ASSERT( p_buffer != NULL && actual_length > 0 );

 

-      SUBTASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, p_buffer, actual_length), err );

+      STASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, p_buffer, actual_length), err );

     }

     else if ( (HID_REQUEST_CONTROL_SET_REPORT == p_request->bRequest) && (p_driver->set_report_cb != NULL) )

     {

       //        return TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT; // TODO test STALL control out endpoint (with mouse+keyboard)

       // wValue = Report Type | Report ID

-      SUBTASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, m_hid_buffer, p_request->wLength), err );

-      SUBTASK_ASSERT_STATUS(err);

+      STASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, m_hid_buffer, p_request->wLength), err );

+      STASK_ASSERT_STATUS(err);

 

       p_driver->set_report_cb(port, u16_high_u8(p_request->wValue), m_hid_buffer, p_request->wLength);

     }

diff --git a/tinyusb/class/hid/hid_host.c b/tinyusb/class/hid/hid_host.c
index 710a00424..20fe3270b 100644
--- a/tinyusb/class/hid/hid_host.c
+++ b/tinyusb/class/hid/hid_host.c
@@ -198,7 +198,7 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
   OSAL_SUBTASK_BEGIN

 

   //------------- SET IDLE (0) request -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

     usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),

                                HID_REQUEST_CONTROL_SET_IDLE, 0, p_interface_desc->bInterfaceNumber,

                                0, NULL ),

@@ -210,7 +210,7 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
   //------------- Get Report Descriptor TODO HID parser -------------//

   if ( p_desc_hid->bNumDescriptors )

   {

-    SUBTASK_INVOKE(

+    STASK_INVOKE(

         usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_INTERFACE),

                                    TUSB_REQ_GET_DESCRIPTOR, (p_desc_hid->bReportType << 8), 0,

                                    p_desc_hid->wReportLength, report_descriptor ),

@@ -225,7 +225,7 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
     #if TUSB_CFG_HOST_HID_KEYBOARD

     if ( HID_PROTOCOL_KEYBOARD == p_interface_desc->bInterfaceProtocol)

     {

-      SUBTASK_ASSERT_STATUS ( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &keyboardh_data[dev_addr-1]) );

+      STASK_ASSERT_STATUS ( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &keyboardh_data[dev_addr-1]) );

       tuh_hid_keyboard_mounted_cb(dev_addr);

     } else

     #endif

@@ -233,17 +233,17 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
     #if TUSB_CFG_HOST_HID_MOUSE

     if ( HID_PROTOCOL_MOUSE == p_interface_desc->bInterfaceProtocol)

     {

-      SUBTASK_ASSERT_STATUS ( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &mouseh_data[dev_addr-1]) );

+      STASK_ASSERT_STATUS ( hidh_interface_open(dev_addr, p_interface_desc->bInterfaceNumber, p_endpoint_desc, &mouseh_data[dev_addr-1]) );

       tuh_hid_mouse_mounted_cb(dev_addr);

     } else

     #endif

 

     {

-      SUBTASK_RETURN(TUSB_ERROR_HIDH_NOT_SUPPORTED_PROTOCOL); // exit & restart task

+      STASK_RETURN(TUSB_ERROR_HIDH_NOT_SUPPORTED_PROTOCOL); // exit & restart task

     }

   }else

   {

-    SUBTASK_RETURN(TUSB_ERROR_HIDH_NOT_SUPPORTED_SUBCLASS); // exit & restart task

+    STASK_RETURN(TUSB_ERROR_HIDH_NOT_SUPPORTED_SUBCLASS); // exit & restart task

   }

 

   *p_length = sizeof(tusb_descriptor_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + sizeof(tusb_descriptor_endpoint_t);

diff --git a/tinyusb/class/msc/msc_device.c b/tinyusb/class/msc/msc_device.c
index 4968faa1c..e3abeb9a3 100644
--- a/tinyusb/class/msc/msc_device.c
+++ b/tinyusb/class/msc/msc_device.c
@@ -140,7 +140,7 @@ tusb_error_t mscd_control_request_subtask(uint8_t port, tusb_control_request_t c
   {

     // Note: lpc11/13u need xfer data's address to be aligned 64 -> make use of scsi_data instead of using max_lun directly

     p_msc->scsi_data[0] = p_msc->max_lun;

-    SUBTASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, p_msc->scsi_data, 1), err);

+    STASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, p_msc->scsi_data, 1), err);

   }else

   {

     usbd_control_stall(port); // stall unsupported request

diff --git a/tinyusb/class/msc/msc_host.c b/tinyusb/class/msc/msc_host.c
index 6e8562307..af8f5e4c2 100644
--- a/tinyusb/class/msc/msc_host.c
+++ b/tinyusb/class/msc/msc_host.c
@@ -310,14 +310,14 @@ tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
 

   for(uint32_t i=0; i<2; i++)

   {

-    SUBTASK_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint->bDescriptorType);

-    SUBTASK_ASSERT(TUSB_XFER_BULK == p_endpoint->bmAttributes.xfer);

+    STASK_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint->bDescriptorType);

+    STASK_ASSERT(TUSB_XFER_BULK == p_endpoint->bmAttributes.xfer);

 

     pipe_handle_t * p_pipe_hdl =  ( p_endpoint->bEndpointAddress &  TUSB_DIR_IN_MASK ) ?

         &msch_data[dev_addr-1].bulk_in : &msch_data[dev_addr-1].bulk_out;

 

     (*p_pipe_hdl) = hcd_pipe_open(dev_addr, p_endpoint, TUSB_CLASS_MSC);

-    SUBTASK_ASSERT( pipehandle_is_valid(*p_pipe_hdl) );

+    STASK_ASSERT( pipehandle_is_valid(*p_pipe_hdl) );

 

     p_endpoint = (tusb_descriptor_endpoint_t const *) descriptor_next( (uint8_t const*)  p_endpoint );

   }

@@ -327,19 +327,19 @@ tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
 

 

   //------------- Get Max Lun -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

     usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),

                                MSC_REQUEST_GET_MAX_LUN, 0, msch_data[dev_addr-1].interface_number,

                                1, msch_buffer ),

     error

   );

 

-  SUBTASK_ASSERT( TUSB_ERROR_NONE == error /* && TODO STALL means zero */);

+  STASK_ASSERT( TUSB_ERROR_NONE == error /* && TODO STALL means zero */);

   msch_data[dev_addr-1].max_lun = msch_buffer[0];

 

 #if 0

   //------------- Reset -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

     usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_INTERFACE),

                                MSC_REQUEST_RESET, 0, msch_data[dev_addr-1].interface_number,

                                0, NULL ),

@@ -351,7 +351,7 @@ tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
   //------------- SCSI Inquiry -------------//

   tusbh_msc_inquiry(dev_addr, 0, msch_buffer);

   osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   memcpy(msch_data[dev_addr-1].vendor_id , ((scsi_inquiry_data_t*) msch_buffer)->vendor_id , 8);

   memcpy(msch_data[dev_addr-1].product_id, ((scsi_inquiry_data_t*) msch_buffer)->product_id, 16);

@@ -359,33 +359,33 @@ tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t con
   //------------- SCSI Read Capacity 10 -------------//

   tusbh_msc_read_capacity10(dev_addr, 0, msch_buffer);

   osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   // NOTE: my toshiba thumb-drive stall the first Read Capacity and require the sequence

   // Read Capacity --> Stalled --> Clear Stall --> Request Sense --> Read Capacity (2) to work

   if ( hcd_pipe_is_stalled(msch_data[dev_addr-1].bulk_in) )

   { // clear stall TODO abstract clear stall function

-    SUBTASK_INVOKE(

+    STASK_INVOKE(

       usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_ENDPOINT),

                                  TUSB_REQ_CLEAR_FEATURE, 0, hcd_pipe_get_endpoint_addr(msch_data[dev_addr-1].bulk_in),

                                  0, NULL ),

       error

     );

-    SUBTASK_ASSERT_STATUS(error);

+    STASK_ASSERT_STATUS(error);

 

     hcd_pipe_clear_stall(msch_data[dev_addr-1].bulk_in);

     osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error); // wait for SCSI status

-    SUBTASK_ASSERT_STATUS(error);

+    STASK_ASSERT_STATUS(error);

 

     //------------- SCSI Request Sense -------------//

     (void) tuh_msc_request_sense(dev_addr, 0, msch_buffer);

     osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-    SUBTASK_ASSERT_STATUS(error);

+    STASK_ASSERT_STATUS(error);

 

     //------------- Re-read SCSI Read Capactity -------------//

     tusbh_msc_read_capacity10(dev_addr, 0, msch_buffer);

     osal_semaphore_wait(msch_sem_hdl, SCSI_XFER_TIMEOUT, &error);

-    SUBTASK_ASSERT_STATUS(error);

+    STASK_ASSERT_STATUS(error);

   }

 

   msch_data[dev_addr-1].last_lba   = __be2n( ((scsi_read_capacity10_data_t*)msch_buffer)->last_lba );

diff --git a/tinyusb/device/usbd.c b/tinyusb/device/usbd.c
index 854649d19..783e18c75 100644
--- a/tinyusb/device/usbd.c
+++ b/tinyusb/device/usbd.c
@@ -234,7 +234,7 @@ static tusb_error_t usbd_main_stask(void)
 

 #if 1

   osal_queue_receive(usbd_queue_hdl, &event, OSAL_TIMEOUT_WAIT_FOREVER, &error);

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 #else

   enum { ROUTINE_INTERVAL_MS = 10 };

   osal_queue_receive(usbd_queue_hdl, &event, ROUTINE_INTERVAL_MS, &error);

@@ -249,13 +249,13 @@ static tusb_error_t usbd_main_stask(void)
       }

     }

 

-    SUBTASK_RETURN(error);

+    STASK_RETURN(error);

   }

 #endif

 

   if ( USBD_EVENTID_SETUP_RECEIVED == event.event_id )

   {

-    SUBTASK_INVOKE( proc_control_request_stask(event.port, &event.setup_received), error );

+    STASK_INVOKE( proc_control_request_stask(event.port, &event.setup_received), error );

   }else if (USBD_EVENTID_XFER_DONE == event.event_id)

   {

     // Call class handling function, Class that endpoint not belong to should check and return

@@ -278,7 +278,7 @@ static tusb_error_t usbd_main_stask(void)
   }

   else

   {

-    SUBTASK_ASSERT(false);

+    STASK_ASSERT(false);

   }

 

   OSAL_SUBTASK_END

@@ -299,7 +299,7 @@ tusb_error_t usbd_control_xfer_stask(uint8_t port, tusb_dir_t dir, uint8_t * buf
     tusb_dcd_control_xfer(port, dir, buffer, length);

     osal_semaphore_wait( usbd_control_xfer_sem_hdl, 100, &error );

 

-    SUBTASK_ASSERT_STATUS( error );

+    STASK_ASSERT_STATUS( error );

   }

 

   // Status opposite direction with Zero Length

@@ -328,7 +328,7 @@ static tusb_error_t proc_control_request_stask(uint8_t port, tusb_control_reques
 

       if ( len )

       {

-        SUBTASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, (uint8_t*) buffer, len ), error );

+        STASK_INVOKE( usbd_control_xfer_stask(port, p_request->bmRequestType_bit.direction, (uint8_t*) buffer, len ), error );

       }else

       {

         usbd_control_stall(port); // stall unsupported descriptor

@@ -365,7 +365,7 @@ static tusb_error_t proc_control_request_stask(uint8_t port, tusb_control_reques
     if ( (class_code > 0) && (class_code < USBD_CLASS_DRIVER_COUNT) &&

          usbd_class_drivers[class_code].control_request_subtask )

     {

-      SUBTASK_INVOKE( usbd_class_drivers[class_code].control_request_subtask(port, p_request), error );

+      STASK_INVOKE( usbd_class_drivers[class_code].control_request_subtask(port, p_request), error );

     }else

     {

       usbd_control_stall(port); // Stall unsupported request

diff --git a/tinyusb/host/hub.c b/tinyusb/host/hub.c
index 3bac09d3e..7034c02bf 100644
--- a/tinyusb/host/hub.c
+++ b/tinyusb/host/hub.c
@@ -73,32 +73,32 @@ tusb_error_t hub_port_clear_feature_subtask(uint8_t hub_addr, uint8_t hub_port,
 

   OSAL_SUBTASK_BEGIN

 

-  SUBTASK_ASSERT(HUB_FEATURE_PORT_CONNECTION_CHANGE <= feature &&

+  STASK_ASSERT(HUB_FEATURE_PORT_CONNECTION_CHANGE <= feature &&

                  feature <= HUB_FEATURE_PORT_RESET_CHANGE);

 

   //------------- Clear Port Feature request -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( hub_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_OTHER),

                                  HUB_REQUEST_CLEAR_FEATURE, feature, hub_port,

                                  0, NULL ),

       error

   );

-  SUBTASK_ASSERT_STATUS( error );

+  STASK_ASSERT_STATUS( error );

 

   //------------- Get Port Status to check if feature is cleared -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( hub_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_OTHER),

                                  HUB_REQUEST_GET_STATUS, 0, hub_port,

                                  4, hub_enum_buffer ),

       error

   );

-  SUBTASK_ASSERT_STATUS( error );

+  STASK_ASSERT_STATUS( error );

 

   //------------- Check if feature is cleared -------------//

   hub_port_status_response_t * p_port_status;

   p_port_status = (hub_port_status_response_t *) hub_enum_buffer;

 

-  SUBTASK_ASSERT( !BIT_TEST_(p_port_status->status_change.value, feature-16)  );

+  STASK_ASSERT( !BIT_TEST_(p_port_status->status_change.value, feature-16)  );

 

   OSAL_SUBTASK_END

 }

@@ -111,29 +111,29 @@ tusb_error_t hub_port_reset_subtask(uint8_t hub_addr, uint8_t hub_port)
   OSAL_SUBTASK_BEGIN

 

   //------------- Set Port Reset -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( hub_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_OTHER),

                                  HUB_REQUEST_SET_FEATURE, HUB_FEATURE_PORT_RESET, hub_port,

                                  0, NULL ),

       error

   );

-  SUBTASK_ASSERT_STATUS( error );

+  STASK_ASSERT_STATUS( error );

 

   osal_task_delay(RESET_DELAY); // TODO Hub wait for Status Endpoint on Reset Change

 

   //------------- Get Port Status to check if port is enabled, powered and reset_change -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( hub_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_OTHER),

                                  HUB_REQUEST_GET_STATUS, 0, hub_port,

                                  4, hub_enum_buffer ),

       error

   );

-  SUBTASK_ASSERT_STATUS( error );

+  STASK_ASSERT_STATUS( error );

 

   hub_port_status_response_t * p_port_status;

   p_port_status = (hub_port_status_response_t *) hub_enum_buffer;

 

-  SUBTASK_ASSERT ( p_port_status->status_change.reset && p_port_status->status_current.connect_status &&

+  STASK_ASSERT ( p_port_status->status_change.reset && p_port_status->status_current.connect_status &&

                    p_port_status->status_current.port_power && p_port_status->status_current.port_enable);

 

   OSAL_SUBTASK_END

@@ -169,23 +169,23 @@ tusb_error_t hub_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t cons
   tusb_descriptor_endpoint_t const *p_endpoint;

   p_endpoint = (tusb_descriptor_endpoint_t const *) descriptor_next( (uint8_t const*) p_interface_desc );

   

-  SUBTASK_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint->bDescriptorType);

-  SUBTASK_ASSERT(TUSB_XFER_INTERRUPT == p_endpoint->bmAttributes.xfer);

+  STASK_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint->bDescriptorType);

+  STASK_ASSERT(TUSB_XFER_INTERRUPT == p_endpoint->bmAttributes.xfer);

 

   hub_data[dev_addr-1].pipe_status = hcd_pipe_open(dev_addr, p_endpoint, TUSB_CLASS_HUB);

-  SUBTASK_ASSERT( pipehandle_is_valid(hub_data[dev_addr-1].pipe_status) );

+  STASK_ASSERT( pipehandle_is_valid(hub_data[dev_addr-1].pipe_status) );

   hub_data[dev_addr-1].interface_number = p_interface_desc->bInterfaceNumber;

 

   (*p_length) = sizeof(tusb_descriptor_interface_t) + sizeof(tusb_descriptor_endpoint_t);

 

   //------------- Get Hub Descriptor -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

     usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_DEVICE),

                                HUB_REQUEST_GET_DESCRIPTOR, 0, 0,

                                sizeof(descriptor_hub_desc_t), hub_enum_buffer ),

     error

   );

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   // only care about this field in hub descriptor

   hub_data[dev_addr-1].port_number = ((descriptor_hub_desc_t*) hub_enum_buffer)->bNbrPorts;

@@ -194,7 +194,7 @@ tusb_error_t hub_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t cons
   static uint8_t i;

   for(i=1; i <= hub_data[dev_addr-1].port_number; i++)

   {

-    SUBTASK_INVOKE(

+    STASK_INVOKE(

       usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_OTHER),

                                  HUB_REQUEST_SET_FEATURE, HUB_FEATURE_PORT_POWER, i,

                                  0, NULL ),

@@ -203,7 +203,7 @@ tusb_error_t hub_open_subtask(uint8_t dev_addr, tusb_descriptor_interface_t cons
   }

 

   //------------- Queue the initial Status endpoint transfer -------------//

-  SUBTASK_ASSERT_STATUS ( hcd_pipe_xfer(hub_data[dev_addr-1].pipe_status, &hub_data[dev_addr-1].status_change, 1, true) );

+  STASK_ASSERT_STATUS ( hcd_pipe_xfer(hub_data[dev_addr-1].pipe_status, &hub_data[dev_addr-1].status_change, 1, true) );

 

   OSAL_SUBTASK_END

 }

diff --git a/tinyusb/host/usbh.c b/tinyusb/host/usbh.c
index 196c54131..6a2ccfb2a 100644
--- a/tinyusb/host/usbh.c
+++ b/tinyusb/host/usbh.c
@@ -186,7 +186,7 @@ tusb_error_t usbh_control_xfer_subtask(uint8_t dev_addr, uint8_t bmRequestType,
   OSAL_SUBTASK_BEGIN

 

   osal_mutex_wait(usbh_devices[dev_addr].control.mutex_hdl, OSAL_TIMEOUT_NORMAL, &error);

-  SUBTASK_ASSERT_STATUS_HDLR(error, osal_mutex_release(usbh_devices[dev_addr].control.mutex_hdl));

+  STASK_ASSERT_STATUS_HDLR(error, osal_mutex_release(usbh_devices[dev_addr].control.mutex_hdl));

 

   usbh_devices[dev_addr].control.request = (tusb_control_request_t) {

                                                   {.bmRequestType = bmRequestType},

@@ -206,11 +206,11 @@ tusb_error_t usbh_control_xfer_subtask(uint8_t dev_addr, uint8_t bmRequestType,
   if ( TUSB_ERROR_NONE == error ) osal_semaphore_wait(usbh_devices[dev_addr].control.sem_hdl, OSAL_TIMEOUT_NORMAL, &error);

   osal_mutex_release(usbh_devices[dev_addr].control.mutex_hdl);

 

-  SUBTASK_ASSERT_STATUS(error);

-  if (TUSB_EVENT_XFER_STALLED == usbh_devices[dev_addr].control.pipe_status) SUBTASK_RETURN(TUSB_ERROR_USBH_XFER_STALLED);

-  if (TUSB_EVENT_XFER_ERROR   == usbh_devices[dev_addr].control.pipe_status) SUBTASK_RETURN(TUSB_ERROR_USBH_XFER_FAILED);

+  STASK_ASSERT_STATUS(error);

+  if (TUSB_EVENT_XFER_STALLED == usbh_devices[dev_addr].control.pipe_status) STASK_RETURN(TUSB_ERROR_USBH_XFER_STALLED);

+  if (TUSB_EVENT_XFER_ERROR   == usbh_devices[dev_addr].control.pipe_status) STASK_RETURN(TUSB_ERROR_USBH_XFER_FAILED);

 

-//  SUBTASK_ASSERT_HDLR(TUSB_ERROR_NONE == error &&

+//  STASK_ASSERT_HDLR(TUSB_ERROR_NONE == error &&

 //                              TUSB_EVENT_XFER_COMPLETE == usbh_devices[dev_addr].control.pipe_status,

 //                              tuh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_DEVICE_NOT_RESPOND, NULL) );

 

@@ -374,7 +374,7 @@ tusb_error_t enumeration_body_subtask(void)
   OSAL_SUBTASK_BEGIN

 

   osal_queue_receive(enum_queue_hdl, &enum_entry, OSAL_TIMEOUT_WAIT_FOREVER, &error);

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   usbh_devices[0].core_id  = enum_entry.core_id; // TODO refractor integrate to device_pool

   usbh_devices[0].hub_addr = enum_entry.hub_addr;

@@ -388,7 +388,7 @@ tusb_error_t enumeration_body_subtask(void)
     { // connection event

       osal_task_delay(POWER_STABLE_DELAY); // wait until device is stable. Increase this if the first 8 bytes is failed to get

 

-      if ( !hcd_port_connect_status(usbh_devices[0].core_id) ) SUBTASK_RETURN(TUSB_ERROR_NONE); // exit if device unplugged while delaying

+      if ( !hcd_port_connect_status(usbh_devices[0].core_id) ) STASK_RETURN(TUSB_ERROR_NONE); // exit if device unplugged while delaying

 

       hcd_port_reset( usbh_devices[0].core_id ); // port must be reset to have correct speed operation

       osal_task_delay(RESET_DELAY);

@@ -398,7 +398,7 @@ tusb_error_t enumeration_body_subtask(void)
     else

     { // disconnection event

       usbh_device_unplugged(usbh_devices[0].core_id, 0, 0);

-      SUBTASK_RETURN(TUSB_ERROR_NONE); // restart task

+      STASK_RETURN(TUSB_ERROR_NONE); // restart task

     }

   }

   #if TUSB_CFG_HOST_HUB

@@ -406,49 +406,49 @@ tusb_error_t enumeration_body_subtask(void)
   else

   {

     //------------- Get Port Status -------------//

-    SUBTASK_INVOKE(

+    STASK_INVOKE(

         usbh_control_xfer_subtask( usbh_devices[0].hub_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_CLASS, TUSB_REQ_RCPT_OTHER),

                                    HUB_REQUEST_GET_STATUS, 0, usbh_devices[0].hub_port,

                                    4, enum_data_buffer ),

         error

     );

-//    SUBTASK_ASSERT_STATUS( error );

-    SUBTASK_ASSERT_STATUS_HDLR(error, hub_status_pipe_queue( usbh_devices[0].hub_addr) ); // TODO hub refractor

+//    STASK_ASSERT_STATUS( error );

+    STASK_ASSERT_STATUS_HDLR(error, hub_status_pipe_queue( usbh_devices[0].hub_addr) ); // TODO hub refractor

 

     // Acknowledge Port Connection Change

-    SUBTASK_INVOKE( hub_port_clear_feature_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port, HUB_FEATURE_PORT_CONNECTION_CHANGE), error );

+    STASK_INVOKE( hub_port_clear_feature_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port, HUB_FEATURE_PORT_CONNECTION_CHANGE), error );

 

     hub_port_status_response_t * p_port_status;

     p_port_status = ((hub_port_status_response_t *) enum_data_buffer);

 

-    if ( ! p_port_status->status_change.connect_status )   SUBTASK_RETURN(TUSB_ERROR_NONE); // only handle connection change

+    if ( ! p_port_status->status_change.connect_status )   STASK_RETURN(TUSB_ERROR_NONE); // only handle connection change

 

     if ( ! p_port_status->status_current.connect_status )

     { // Disconnection event

       usbh_device_unplugged(usbh_devices[0].core_id, usbh_devices[0].hub_addr, usbh_devices[0].hub_port);

 

       (void) hub_status_pipe_queue( usbh_devices[0].hub_addr ); // done with hub, waiting for next data on status pipe

-      SUBTASK_RETURN(TUSB_ERROR_NONE); // restart task

+      STASK_RETURN(TUSB_ERROR_NONE); // restart task

     }

     else

     { // Connection Event

-      SUBTASK_INVOKE ( hub_port_reset_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port), error );

-//      SUBTASK_ASSERT_STATUS( error );

-      SUBTASK_ASSERT_STATUS_HDLR(error, hub_status_pipe_queue( usbh_devices[0].hub_addr) ); // TODO hub refractor

+      STASK_INVOKE ( hub_port_reset_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port), error );

+//      STASK_ASSERT_STATUS( error );

+      STASK_ASSERT_STATUS_HDLR(error, hub_status_pipe_queue( usbh_devices[0].hub_addr) ); // TODO hub refractor

 

       usbh_devices[0].speed = hub_port_get_speed();

 

       // Acknowledge Port Reset Change

-      SUBTASK_INVOKE( hub_port_clear_feature_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port, HUB_FEATURE_PORT_RESET_CHANGE), error );

+      STASK_INVOKE( hub_port_clear_feature_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port, HUB_FEATURE_PORT_RESET_CHANGE), error );

     }

   }

   #endif

 

-  SUBTASK_ASSERT_STATUS( usbh_pipe_control_open(0, 8) );

+  STASK_ASSERT_STATUS( usbh_pipe_control_open(0, 8) );

   usbh_devices[0].state = TUSB_DEVICE_STATE_ADDRESSED;

 

   //------------- Get first 8 bytes of device descriptor to get Control Endpoint Size -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( 0, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_DEVICE),

                                  TUSB_REQ_GET_DESCRIPTOR, (TUSB_DESC_DEVICE << 8), 0,

                                  8, enum_data_buffer ),

@@ -458,19 +458,19 @@ tusb_error_t enumeration_body_subtask(void)
   //------------- Reset device again before Set Address -------------//

   if (usbh_devices[0].hub_addr == 0)

   { // connected directly to roothub

-    SUBTASK_ASSERT_STATUS(error); // TODO some slow device is observed to fail the very fist controller xfer, can try more times

+    STASK_ASSERT_STATUS(error); // TODO some slow device is observed to fail the very fist controller xfer, can try more times

     hcd_port_reset( usbh_devices[0].core_id ); // reset port after 8 byte descriptor

     osal_task_delay(RESET_DELAY);

   }

   #if TUSB_CFG_HOST_HUB

   else

   { // connected via a hub

-    SUBTASK_ASSERT_STATUS_HDLR(error, hub_status_pipe_queue( usbh_devices[0].hub_addr) ); // TODO hub refractor

-    SUBTASK_INVOKE ( hub_port_reset_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port), error );

+    STASK_ASSERT_STATUS_HDLR(error, hub_status_pipe_queue( usbh_devices[0].hub_addr) ); // TODO hub refractor

+    STASK_INVOKE ( hub_port_reset_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port), error );

 

     if ( TUSB_ERROR_NONE == error )

     { // Acknowledge Port Reset Change if Reset Successful

-      SUBTASK_INVOKE( hub_port_clear_feature_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port, HUB_FEATURE_PORT_RESET_CHANGE), error );

+      STASK_INVOKE( hub_port_clear_feature_subtask(usbh_devices[0].hub_addr, usbh_devices[0].hub_port, HUB_FEATURE_PORT_RESET_CHANGE), error );

     }

 

     (void) hub_status_pipe_queue( usbh_devices[0].hub_addr ); // done with hub, waiting for next data on status pipe

@@ -479,15 +479,15 @@ tusb_error_t enumeration_body_subtask(void)
 

   //------------- Set new address -------------//

   new_addr = get_new_address();

-  SUBTASK_ASSERT(new_addr <= TUSB_CFG_HOST_DEVICE_MAX); // TODO notify application we reach max devices

+  STASK_ASSERT(new_addr <= TUSB_CFG_HOST_DEVICE_MAX); // TODO notify application we reach max devices

 

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

     usbh_control_xfer_subtask( 0, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_DEVICE),

                                TUSB_REQ_SET_ADDRESS, new_addr, 0,

                                0, NULL ),

     error

   );

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   //------------- update port info & close control pipe of addr0 -------------//

   usbh_devices[new_addr].core_id  = usbh_devices[0].core_id;

@@ -500,16 +500,16 @@ tusb_error_t enumeration_body_subtask(void)
   usbh_devices[0].state = TUSB_DEVICE_STATE_UNPLUG;

 

   // open control pipe for new address

-  SUBTASK_ASSERT_STATUS ( usbh_pipe_control_open(new_addr, ((tusb_descriptor_device_t*) enum_data_buffer)->bMaxPacketSize0 ) );

+  STASK_ASSERT_STATUS ( usbh_pipe_control_open(new_addr, ((tusb_descriptor_device_t*) enum_data_buffer)->bMaxPacketSize0 ) );

 

   //------------- Get full device descriptor -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( new_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_DEVICE),

                                  TUSB_REQ_GET_DESCRIPTOR, (TUSB_DESC_DEVICE << 8), 0,

                                  18, enum_data_buffer ),

       error

   );

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   // update device info  TODO alignment issue

   usbh_devices[new_addr].vendor_id       = ((tusb_descriptor_device_t*) enum_data_buffer)->idVendor;

@@ -517,39 +517,39 @@ tusb_error_t enumeration_body_subtask(void)
   usbh_devices[new_addr].configure_count = ((tusb_descriptor_device_t*) enum_data_buffer)->bNumConfigurations;

 

   configure_selected = get_configure_number_for_device((tusb_descriptor_device_t*) enum_data_buffer);

-  SUBTASK_ASSERT(configure_selected <= usbh_devices[new_addr].configure_count); // TODO notify application when invalid configuration

+  STASK_ASSERT(configure_selected <= usbh_devices[new_addr].configure_count); // TODO notify application when invalid configuration

 

   //------------- Get 9 bytes of configuration descriptor -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( new_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_DEVICE),

                                  TUSB_REQ_GET_DESCRIPTOR, (TUSB_DESC_CONFIGURATION << 8) | (configure_selected - 1), 0,

                                  9, enum_data_buffer ),

       error

   );

-  SUBTASK_ASSERT_STATUS(error);

-  SUBTASK_ASSERT_HDLR( TUSB_CFG_HOST_ENUM_BUFFER_SIZE >= ((tusb_descriptor_configuration_t*)enum_data_buffer)->wTotalLength,

+  STASK_ASSERT_STATUS(error);

+  STASK_ASSERT_HDLR( TUSB_CFG_HOST_ENUM_BUFFER_SIZE >= ((tusb_descriptor_configuration_t*)enum_data_buffer)->wTotalLength,

                             tuh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_CONFIG_DESC_TOO_LONG, NULL) );

 

   //------------- Get full configuration descriptor -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

       usbh_control_xfer_subtask( new_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_DEVICE),

                                  TUSB_REQ_GET_DESCRIPTOR, (TUSB_DESC_CONFIGURATION << 8) | (configure_selected - 1), 0,

                                  TUSB_CFG_HOST_ENUM_BUFFER_SIZE, enum_data_buffer ),

       error

   );

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   // update configuration info

   usbh_devices[new_addr].interface_count = ((tusb_descriptor_configuration_t*) enum_data_buffer)->bNumInterfaces;

 

   //------------- Set Configure -------------//

-  SUBTASK_INVOKE(

+  STASK_INVOKE(

     usbh_control_xfer_subtask( new_addr, bm_request_type(TUSB_DIR_OUT, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_DEVICE),

                                TUSB_REQ_SET_CONFIGURATION, configure_selected, 0,

                                0, NULL ),

     error

   );

-  SUBTASK_ASSERT_STATUS(error);

+  STASK_ASSERT_STATUS(error);

 

   usbh_devices[new_addr].state = TUSB_DEVICE_STATE_CONFIGURED;

 

@@ -570,7 +570,7 @@ tusb_error_t enumeration_body_subtask(void)
       static uint8_t class_index; // has to be static as it is used to call class's open_subtask

 

       class_index = std_class_code_to_index( ((tusb_descriptor_interface_t*) p_desc)->bInterfaceClass );

-      SUBTASK_ASSERT( class_index != 0 ); // class_index == 0 means corrupted data, abort enumeration

+      STASK_ASSERT( class_index != 0 ); // class_index == 0 means corrupted data, abort enumeration

 

       if (usbh_class_drivers[class_index].open_subtask &&

           !(class_index == TUSB_CLASS_HUB && usbh_devices[new_addr].hub_addr != 0))

@@ -578,14 +578,14 @@ tusb_error_t enumeration_body_subtask(void)
         static uint16_t length;

         length = 0;

 

-        SUBTASK_INVOKE ( // parameters in task/sub_task must be static storage (static or global)

+        STASK_INVOKE ( // parameters in task/sub_task must be static storage (static or global)

             usbh_class_drivers[class_index].open_subtask( new_addr, (tusb_descriptor_interface_t*) p_desc, &length ),

             error

         );

 

         if (error == TUSB_ERROR_NONE)

         {

-          SUBTASK_ASSERT( length >= sizeof(tusb_descriptor_interface_t) );

+          STASK_ASSERT( length >= sizeof(tusb_descriptor_interface_t) );

           usbh_devices[new_addr].flag_supported_class |= BIT_(class_index);

           p_desc += length;

         }else  // Interface open failed, for example a subclass is not supported

diff --git a/tinyusb/osal/osal.h b/tinyusb/osal/osal.h
index e4827bf37..83f2573a8 100644
--- a/tinyusb/osal/osal.h
+++ b/tinyusb/osal/osal.h
@@ -74,15 +74,15 @@
   #define OSAL_SUBTASK_BEGIN

   #define OSAL_SUBTASK_END                    return TUSB_ERROR_NONE;

 

-  #define SUBTASK_RETURN(_error)              return _error;

-  #define SUBTASK_INVOKE(_subtask, _status)   (_status) = _subtask

+  #define STASK_RETURN(_error)              return _error;

+  #define STASK_INVOKE(_subtask, _status)   (_status) = _subtask

 

   //------------- Sub Task Assert -------------//

-  #define SUBTASK_ASSERT_STATUS(sts) VERIFY_STATUS(sts)

-  #define SUBTASK_ASSERT(condition)  VERIFY(condition, TUSB_ERROR_OSAL_TASK_FAILED)

+  #define STASK_ASSERT_STATUS(sts) VERIFY_STATUS(sts)

+  #define STASK_ASSERT(condition)  VERIFY(condition, TUSB_ERROR_OSAL_TASK_FAILED)

 

-  #define SUBTASK_ASSERT_STATUS_HDLR(sts, func_call)  VERIFY_STATUS_HDLR(sts, func_call)

-  #define SUBTASK_ASSERT_HDLR(condition, func_call)   VERIFY_HDLR(condition, func_call)

+  #define STASK_ASSERT_STATUS_HDLR(sts, func_call)  VERIFY_STATUS_HDLR(sts, func_call)

+  #define STASK_ASSERT_HDLR(condition, func_call)   VERIFY_HDLR(condition, func_call)

 #endif

 

 #ifdef __cplusplus

diff --git a/tinyusb/osal/osal_none.h b/tinyusb/osal/osal_none.h
index 9bf7367ec..80670a9ca 100644
--- a/tinyusb/osal/osal_none.h
+++ b/tinyusb/osal/osal_none.h
@@ -113,7 +113,7 @@ static inline osal_task_t osal_task_create(osal_func_t code, const char* name, u
   }}                                                                            \

   return TUSB_ERROR_NONE;

 

-#define SUBTASK_INVOKE(_subtask, _status)                                       \

+#define STASK_INVOKE(_subtask, _status)                                         \

   do {                                                                          \

     _state = __LINE__; case __LINE__:                                           \

     {                                                                           \

@@ -123,13 +123,13 @@ static inline osal_task_t osal_task_create(osal_func_t code, const char* name, u
   }while(0)

 

 //------------- Sub Task Assert -------------//

-#define SUBTASK_RETURN(error)     do { TASK_RESTART; return error; } while(0)

+#define STASK_RETURN(error)     do { TASK_RESTART; return error; } while(0)

 

-#define SUBTASK_ASSERT_STATUS(sts)                  VERIFY_STATUS_HDLR(sts, TASK_RESTART)

-#define SUBTASK_ASSERT_STATUS_HDLR(sts, func_call)  VERIFY_STATUS_HDLR(sts, func_call; TASK_RESTART )

+#define STASK_ASSERT_STATUS(sts)                  VERIFY_STATUS_HDLR(sts, TASK_RESTART)

+#define STASK_ASSERT_STATUS_HDLR(sts, func_call)  VERIFY_STATUS_HDLR(sts, func_call; TASK_RESTART )

 

-#define SUBTASK_ASSERT(condition)                   VERIFY_HDLR(condition, TASK_RESTART)

-#define SUBTASK_ASSERT_HDLR(condition, func_call)   VERIFY_HDLR(condition, func_call; TASK_RESTART)

+#define STASK_ASSERT(condition)                   VERIFY_HDLR(condition, TASK_RESTART)

+#define STASK_ASSERT_HDLR(condition, func_call)   VERIFY_HDLR(condition, func_call; TASK_RESTART)

 

 //--------------------------------------------------------------------+

 // QUEUE API