Merge pull request #13 from hathach/devlocal

add unplugged event for nrf5x

44 files changed, 216 insertions, 348 deletions

diff --git a/src/class/cdc/cdc.h b/src/class/cdc/cdc.h
index afac8379d..d07c62429 100644
--- a/src/class/cdc/cdc.h
+++ b/src/class/cdc/cdc.h
@@ -50,10 +50,6 @@
  extern "C" {

 #endif

 

-#pragma GCC diagnostic push

-#pragma GCC diagnostic ignored "-Wpacked"

-#pragma GCC diagnostic ignored "-Wattributes"

-

 /** \defgroup ClassDriver_CDC_Common Common Definitions

  *  @{ */

 

@@ -406,8 +402,6 @@ typedef struct ATTR_PACKED
 

 TU_VERIFY_STATIC(sizeof(cdc_line_control_state_t) == 2, "size is not correct");

 

-#pragma GCC diagnostic pop

-

 /** @} */

 

 #ifdef __cplusplus

diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index d8ade9c7f..b68a6a7ff 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -87,7 +87,7 @@ typedef struct
 //--------------------------------------------------------------------+

 // INTERNAL OBJECT & FUNCTION DECLARATION

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

-CFG_TUSB_ATTR_USBRAM static cdcd_interface_t _cdcd_itf[CFG_TUD_CDC];

+CFG_TUSB_MEM_SECTION static cdcd_interface_t _cdcd_itf[CFG_TUD_CDC];

 

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

 // APPLICATION API

@@ -358,7 +358,7 @@ bool cdcd_control_request(uint8_t rhport, tusb_control_request_t const * request
   return true;

 }

 

-tusb_error_t cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, uint32_t xferred_bytes)

+tusb_error_t cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)

 {

   // TODO Support multiple interfaces

   uint8_t const itf = 0;

diff --git a/src/class/cdc/cdc_device.h b/src/class/cdc/cdc_device.h
index 749351a54..ad1100e9c 100644
--- a/src/class/cdc/cdc_device.h
+++ b/src/class/cdc/cdc_device.h
@@ -116,7 +116,7 @@ void         cdcd_init               (void);
 tusb_error_t cdcd_open               (uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);

 bool cdcd_control_request (uint8_t rhport, tusb_control_request_t const * p_request);

 bool cdcd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

-tusb_error_t cdcd_xfer_cb            (uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);

+tusb_error_t cdcd_xfer_cb            (uint8_t rhport, uint8_t edpt_addr, xfer_result_t event, uint32_t xferred_bytes);

 void         cdcd_reset              (uint8_t rhport);

 

 #endif

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index af2e2c444..0a3661878 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -221,7 +221,7 @@ tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
   OSAL_SUBTASK_END

 }

 

-void cdch_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes)

+void cdch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)

 {

   tuh_cdc_xfer_isr( pipe_hdl.dev_addr, event, get_app_pipeid(pipe_hdl), xferred_bytes );

 }

diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index 77f1e5a78..0b863bb61 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -77,27 +77,27 @@ bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)  ATTR_PURE ATTR_WARN
 

 /** \brief 			Perform USB OUT transfer to device

  * \param[in]		dev_addr	device address

- * \param[in]	  p_data    Buffer containing data. Must be accessible by USB controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[in]	  p_data    Buffer containing data. Must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

  * \param[in]		length    Number of bytes to be transferred via USB bus

  * \retval      TUSB_ERROR_NONE on success

  * \retval      TUSB_ERROR_INTERFACE_IS_BUSY if the interface is already transferring data with device

  * \retval      TUSB_ERROR_DEVICE_NOT_READY if device is not yet configured (by SET CONFIGURED request)

  * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct

  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the

- *              interface's callback function. \a p_data must be declared with \ref CFG_TUSB_ATTR_USBRAM.

+ *              interface's callback function. \a p_data must be declared with \ref CFG_TUSB_MEM_SECTION.

  */

 tusb_error_t tuh_cdc_send(uint8_t dev_addr, void const * p_data, uint32_t length, bool is_notify);

 

 /** \brief 			Perform USB IN transfer to get data from device

  * \param[in]		dev_addr	device address

- * \param[in]	  p_buffer  Buffer containing received data. Must be accessible by USB controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[in]	  p_buffer  Buffer containing received data. Must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

  * \param[in]		length    Number of bytes to be transferred via USB bus

  * \retval      TUSB_ERROR_NONE on success

  * \retval      TUSB_ERROR_INTERFACE_IS_BUSY if the interface is already transferring data with device

  * \retval      TUSB_ERROR_DEVICE_NOT_READY if device is not yet configured (by SET CONFIGURED request)

  * \retval      TUSB_ERROR_INVALID_PARA if input parameters are not correct

  * \note        This function is non-blocking and returns immediately. The result of USB transfer will be reported by the

- *              interface's callback function. \a p_data must be declared with \ref CFG_TUSB_ATTR_USBRAM.

+ *              interface's callback function. \a p_data must be declared with \ref CFG_TUSB_MEM_SECTION.

  */

 tusb_error_t tuh_cdc_receive(uint8_t dev_addr, void * p_buffer, uint32_t length, bool is_notify);

 

@@ -118,16 +118,16 @@ void tuh_cdc_unmounted_cb(uint8_t dev_addr);
 

 /** \brief      Callback function that is invoked when an transferring event occurred

  * \param[in]		dev_addr	Address of device

- * \param[in]   event an value from \ref tusb_event_t

+ * \param[in]   event an value from \ref xfer_result_t

  * \param[in]   pipe_id value from \ref cdc_pipeid_t indicate the pipe

  * \param[in]   xferred_bytes Number of bytes transferred via USB bus

  * \note        event can be one of following

- *              - TUSB_EVENT_XFER_COMPLETE : previously scheduled transfer completes successfully.

- *              - TUSB_EVENT_XFER_ERROR   : previously scheduled transfer encountered a transaction error.

- *              - TUSB_EVENT_XFER_STALLED : previously scheduled transfer is stalled by device.

+ *              - XFER_RESULT_SUCCESS : previously scheduled transfer completes successfully.

+ *              - XFER_RESULT_FAILED   : previously scheduled transfer encountered a transaction error.

+ *              - XFER_RESULT_STALLED : previously scheduled transfer is stalled by device.

  * \note

  */

-void tuh_cdc_xfer_isr(uint8_t dev_addr, tusb_event_t event, cdc_pipeid_t pipe_id, uint32_t xferred_bytes);

+void tuh_cdc_xfer_isr(uint8_t dev_addr, xfer_result_t event, cdc_pipeid_t pipe_id, uint32_t xferred_bytes);

 

 /// @} // group CDC_Serial_Host

 /// @}

@@ -151,7 +151,7 @@ extern cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX]; // TODO consider to move
 

 void         cdch_init(void);

 tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;

-void         cdch_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes);

+void         cdch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);

 void         cdch_close(uint8_t dev_addr);

 

 #endif

diff --git a/src/class/cdc/cdc_rndis_host.c b/src/class/cdc/cdc_rndis_host.c
index 9b7684f77..89ea3b32f 100644
--- a/src/class/cdc/cdc_rndis_host.c
+++ b/src/class/cdc/cdc_rndis_host.c
@@ -54,8 +54,8 @@
 //--------------------------------------------------------------------+
 #define RNDIS_MSG_PAYLOAD_MAX   (1024*4)
 
-CFG_TUSB_ATTR_USBRAM static uint8_t msg_notification[CFG_TUSB_HOST_DEVICE_MAX][8];
-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(4) static uint8_t msg_payload[RNDIS_MSG_PAYLOAD_MAX];
+CFG_TUSB_MEM_SECTION static uint8_t msg_notification[CFG_TUSB_HOST_DEVICE_MAX][8];
+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(4) static uint8_t msg_payload[RNDIS_MSG_PAYLOAD_MAX];
 
 STATIC_VAR rndish_data_t rndish_data[CFG_TUSB_HOST_DEVICE_MAX];
 
@@ -224,7 +224,7 @@ tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc)
   OSAL_SUBTASK_END
 }
 
-void rndish_xfer_isr(cdch_data_t *p_cdc, pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes)
+void rndish_xfer_isr(cdch_data_t *p_cdc, pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)
 {
   if ( pipehandle_is_equal(pipe_hdl, p_cdc->pipe_notification) )
   {
diff --git a/src/class/cdc/cdc_rndis_host.h b/src/class/cdc/cdc_rndis_host.h
index c4597daa8..3b92d3f23 100644
--- a/src/class/cdc/cdc_rndis_host.h
+++ b/src/class/cdc/cdc_rndis_host.h
@@ -65,7 +65,7 @@ typedef struct {
 
 void rndish_init(void);
 tusb_error_t rndish_open_subtask(uint8_t dev_addr, cdch_data_t *p_cdc) ATTR_WARN_UNUSED_RESULT;
-void rndish_xfer_isr(cdch_data_t *p_cdc, pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes);
+void rndish_xfer_isr(cdch_data_t *p_cdc, pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);
 void rndish_close(uint8_t dev_addr);
 
 #endif
diff --git a/src/class/custom/custom_device.c b/src/class/custom/custom_device.c
index cc440fc7e..194963c17 100644
--- a/src/class/custom/custom_device.c
+++ b/src/class/custom/custom_device.c
@@ -94,7 +94,7 @@ bool cusd_control_request(uint8_t rhport, tusb_control_request_t const * p_reque
   return false;
 }
 
-tusb_error_t cusd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes)
+tusb_error_t cusd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t event, uint32_t xferred_bytes)
 {
   return TUSB_ERROR_NONE;
 }
diff --git a/src/class/custom/custom_device.h b/src/class/custom/custom_device.h
index 704c4127b..0a8f05e7d 100644
--- a/src/class/custom/custom_device.h
+++ b/src/class/custom/custom_device.h
@@ -66,7 +66,7 @@ void cusd_init(void);
 tusb_error_t cusd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);
 bool cusd_control_request_st(uint8_t rhport, tusb_control_request_t const * p_request);
 bool cusd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);
-tusb_error_t cusd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);
+tusb_error_t cusd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t event, uint32_t xferred_bytes);
 void cusd_reset(uint8_t rhport);
 #endif
 
diff --git a/src/class/custom/custom_host.c b/src/class/custom/custom_host.c
index 329012fda..9f0b70afb 100644
--- a/src/class/custom/custom_host.c
+++ b/src/class/custom/custom_host.c
@@ -131,7 +131,7 @@ tusb_error_t cush_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
   return TUSB_ERROR_NONE;
 }
 
-void cush_isr(pipe_handle_t pipe_hdl, tusb_event_t event)
+void cush_isr(pipe_handle_t pipe_hdl, xfer_result_t event)
 {
 
 }
diff --git a/src/class/custom/custom_host.h b/src/class/custom/custom_host.h
index 2bf3a8d3c..5f9c25dda 100644
--- a/src/class/custom/custom_host.h
+++ b/src/class/custom/custom_host.h
@@ -73,7 +73,7 @@ tusb_error_t tusbh_custom_write(uint8_t dev_addr, uint16_t vendor_id, uint16_t p
 
 void         cush_init(void);
 tusb_error_t cush_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;
-void         cush_isr(pipe_handle_t pipe_hdl, tusb_event_t event);
+void         cush_isr(pipe_handle_t pipe_hdl, xfer_result_t event);
 void         cush_close(uint8_t dev_addr);
 
 #endif
diff --git a/src/class/hid/hid.h b/src/class/hid/hid.h
index 0008e47fb..8bfede2da 100644
--- a/src/class/hid/hid.h
+++ b/src/class/hid/hid.h
@@ -49,10 +49,6 @@
  extern "C" {

 #endif

 

-#pragma GCC diagnostic push

-#pragma GCC diagnostic ignored "-Wpacked"

-#pragma GCC diagnostic ignored "-Wattributes"

-

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

 // Common Definitions

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

@@ -613,8 +609,6 @@ enum
   HID_USAGE_CONSUMER_AC_PAN                            = 0x0238,

 };

 

-#pragma GCC diagnostic pop

-

 #ifdef __cplusplus

  }

 #endif

diff --git a/src/class/hid/hid_device.c b/src/class/hid/hid_device.c
index b5586a488..f1ecec3c7 100644
--- a/src/class/hid/hid_device.c
+++ b/src/class/hid/hid_device.c
@@ -91,7 +91,7 @@ typedef struct
   hidd_interface_t* itf;

 } hidd_report_t ;

 

-CFG_TUSB_ATTR_USBRAM static hidd_interface_t _hidd_itf[ITF_COUNT];

+CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[ITF_COUNT];

 

 

 #if CFG_TUD_HID_KEYBOARD

@@ -510,7 +510,7 @@ bool hidd_control_request_complete(uint8_t rhport, tusb_control_request_t const
   return true;

 }

 

-tusb_error_t hidd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes)

+tusb_error_t hidd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t event, uint32_t xferred_bytes)

 {

   // nothing to do

   return TUSB_ERROR_NONE;

diff --git a/src/class/hid/hid_device.h b/src/class/hid/hid_device.h
index 7f8cd0fa7..7aff7f34d 100644
--- a/src/class/hid/hid_device.h
+++ b/src/class/hid/hid_device.h
@@ -110,7 +110,7 @@ extern const hid_ascii_to_keycode_entry_t HID_ASCII_TO_KEYCODE[128];
 

 /** Callback invoked when USB host request \ref HID_REQ_CONTROL_GET_REPORT.

  * \param[in]   report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests

- * \param[out]  buffer data that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[out]  buffer data that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

  * \param[in]   reqlen  number of bytes that host requested

  * \retval      non-zero Actual number of bytes in the response's buffer.

  * \retval      zero  indicates the current request is not supported. Tinyusb device stack will reject the request by

@@ -173,7 +173,7 @@ static inline bool tud_hid_mouse_button_release(void)
 /**

  * Callback function that is invoked when USB host request \ref HID_REQ_CONTROL_GET_REPORT.

  * \param[in]   report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests

- * \param[out]  buffer  buffer that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[out]  buffer  buffer that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

  * \param[in]   reqlen  number of bytes that host requested

  * \retval      non-zero Actual number of bytes in the response's buffer.

  * \retval      zero  indicates the current request is not supported. Tinyusb device stack will reject the request by

@@ -380,7 +380,7 @@ void hidd_init(void);
 tusb_error_t hidd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);

 bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request);

 bool hidd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

-tusb_error_t hidd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);

+tusb_error_t hidd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t event, uint32_t xferred_bytes);

 void hidd_reset(uint8_t rhport);

 

 #endif

diff --git a/src/class/hid/hid_host.c b/src/class/hid/hid_host.c
index 518297eec..6aa0748df 100644
--- a/src/class/hid/hid_host.c
+++ b/src/class/hid/hid_host.c
@@ -177,7 +177,7 @@ void hidh_init(void)
 }

 

 #if 0

-CFG_TUSB_ATTR_USBRAM uint8_t report_descriptor[256];

+CFG_TUSB_MEM_SECTION uint8_t report_descriptor[256];

 #endif

 

 tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length)

@@ -251,7 +251,7 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
   OSAL_SUBTASK_END

 }

 

-void hidh_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes)

+void hidh_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)

 {

   (void) xferred_bytes; // TODO may need to use this para later

 

diff --git a/src/class/hid/hid_host.h b/src/class/hid/hid_host.h
index b93bcdccb..cb0230e8a 100644
--- a/src/class/hid/hid_host.h
+++ b/src/class/hid/hid_host.h
@@ -80,7 +80,7 @@ bool          tuh_hid_keyboard_is_busy(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNU
 

 /** \brief        Perform a get report from Keyboard interface

  * \param[in]		  dev_addr device address

- * \param[in,out] p_report address that is used to store data from device. Must be accessible by usb controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[in,out] p_report address that is used to store data from device. Must be accessible by usb controller (see \ref CFG_TUSB_MEM_SECTION)

  * \returns       \ref tusb_error_t type to indicate success or error condition.

  * \retval        TUSB_ERROR_NONE on success

  * \retval        TUSB_ERROR_INTERFACE_IS_BUSY if the interface is already transferring data with device

@@ -93,14 +93,14 @@ tusb_error_t  tuh_hid_keyboard_get_report(uint8_t dev_addr, void * p_report) /*A
 //------------- Application Callback -------------//

 /** \brief      Callback function that is invoked when an transferring event occurred

  * \param[in]		dev_addr	Address of device

- * \param[in]   event an value from \ref tusb_event_t

+ * \param[in]   event an value from \ref xfer_result_t

  * \note        event can be one of following

- *              - TUSB_EVENT_XFER_COMPLETE : previously scheduled transfer completes successfully.

- *              - TUSB_EVENT_XFER_ERROR   : previously scheduled transfer encountered a transaction error.

- *              - TUSB_EVENT_XFER_STALLED : previously scheduled transfer is stalled by device.

+ *              - XFER_RESULT_SUCCESS : previously scheduled transfer completes successfully.

+ *              - XFER_RESULT_FAILED   : previously scheduled transfer encountered a transaction error.

+ *              - XFER_RESULT_STALLED : previously scheduled transfer is stalled by device.

  * \note        Application should schedule the next report by calling \ref tuh_hid_keyboard_get_report within this callback

  */

-void tuh_hid_keyboard_isr(uint8_t dev_addr, tusb_event_t event);

+void tuh_hid_keyboard_isr(uint8_t dev_addr, xfer_result_t event);

 

 /** \brief 			Callback function that will be invoked when a device with Keyboard interface is mounted

  * \param[in] 	dev_addr Address of newly mounted device

@@ -145,7 +145,7 @@ bool          tuh_hid_mouse_is_busy(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED
 

 /** \brief        Perform a get report from Mouse interface

  * \param[in]		  dev_addr device address

- * \param[in,out] p_report address that is used to store data from device. Must be accessible by usb controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[in,out] p_report address that is used to store data from device. Must be accessible by usb controller (see \ref CFG_TUSB_MEM_SECTION)

  * \returns       \ref tusb_error_t type to indicate success or error condition.

  * \retval        TUSB_ERROR_NONE on success

  * \retval        TUSB_ERROR_INTERFACE_IS_BUSY if the interface is already transferring data with device

@@ -158,14 +158,14 @@ tusb_error_t  tuh_hid_mouse_get_report(uint8_t dev_addr, void* p_report) /*ATTR_
 //------------- Application Callback -------------//

 /** \brief      Callback function that is invoked when an transferring event occurred

  * \param[in]		dev_addr	Address of device

- * \param[in]   event an value from \ref tusb_event_t

+ * \param[in]   event an value from \ref xfer_result_t

  * \note        event can be one of following

- *              - TUSB_EVENT_XFER_COMPLETE : previously scheduled transfer completes successfully.

- *              - TUSB_EVENT_XFER_ERROR   : previously scheduled transfer encountered a transaction error.

- *              - TUSB_EVENT_XFER_STALLED : previously scheduled transfer is stalled by device.

+ *              - XFER_RESULT_SUCCESS : previously scheduled transfer completes successfully.

+ *              - XFER_RESULT_FAILED   : previously scheduled transfer encountered a transaction error.

+ *              - XFER_RESULT_STALLED : previously scheduled transfer is stalled by device.

  * \note        Application should schedule the next report by calling \ref tuh_hid_mouse_get_report within this callback

  */

-void tuh_hid_mouse_isr(uint8_t dev_addr, tusb_event_t event);

+void tuh_hid_mouse_isr(uint8_t dev_addr, xfer_result_t event);

 

 /** \brief 			Callback function that will be invoked when a device with Mouse interface is mounted

  * \param[in]	  dev_addr Address of newly mounted device

@@ -199,7 +199,7 @@ tusb_interface_status_t tuh_hid_generic_get_status(uint8_t dev_addr) ATTR_WARN_U
 tusb_interface_status_t tuh_hid_generic_set_status(uint8_t dev_addr) ATTR_WARN_UNUSED_RESULT;

 

 //------------- Application Callback -------------//

-void tuh_hid_generic_isr(uint8_t dev_addr, tusb_event_t event);

+void tuh_hid_generic_isr(uint8_t dev_addr, xfer_result_t event);

 

 /** @} */ // Generic_Host

 /** @} */ // ClassDriver_HID_Generic

@@ -217,7 +217,7 @@ typedef struct {
 

 void         hidh_init(void);

 tusb_error_t hidh_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;

-void         hidh_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes);

+void         hidh_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);

 void         hidh_close(uint8_t dev_addr);

 

 #endif

diff --git a/src/class/msc/msc.h b/src/class/msc/msc.h
index e7c32b303..10a73bb1c 100644
--- a/src/class/msc/msc.h
+++ b/src/class/msc/msc.h
@@ -46,16 +46,12 @@
 #ifndef _TUSB_MSC_H_

 #define _TUSB_MSC_H_

 

-#include <common/tusb_common.h>

+#include "common/tusb_common.h"

 

 #ifdef __cplusplus

  extern "C" {

 #endif

 

-#pragma GCC diagnostic push

-#pragma GCC diagnostic ignored "-Wpacked"

-#pragma GCC diagnostic ignored "-Wattributes"

-

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

 // Mass Storage Class Constant

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

@@ -396,8 +392,6 @@ typedef struct ATTR_PACKED
 TU_VERIFY_STATIC(sizeof(scsi_read10_t) == 10, "size is not correct");

 TU_VERIFY_STATIC(sizeof(scsi_write10_t) == 10, "size is not correct");

 

-#pragma GCC diagnostic pop

-

 #ifdef __cplusplus

  }

 #endif

diff --git a/src/class/msc/msc_device.c b/src/class/msc/msc_device.c
index bfe708f42..88f8da6db 100644
--- a/src/class/msc/msc_device.c
+++ b/src/class/msc/msc_device.c
@@ -83,8 +83,8 @@ typedef struct {
   uint8_t add_sense_qualifier;

 }mscd_interface_t;

 

-CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN static mscd_interface_t _mscd_itf;

-CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN static uint8_t _mscd_buf[CFG_TUD_MSC_BUFSIZE];

+CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static mscd_interface_t _mscd_itf;

+CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static uint8_t _mscd_buf[CFG_TUD_MSC_BUFSIZE];

 

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

 // INTERNAL OBJECT & FUNCTION DECLARATION

@@ -324,7 +324,7 @@ int32_t proc_builtin_scsi(msc_cbw_t const * p_cbw, uint8_t* buffer, uint32_t buf
   return ret;

 }

 

-tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, uint32_t xferred_bytes)

+tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)

 {

   mscd_interface_t* p_msc = &_mscd_itf;

   msc_cbw_t const * p_cbw = &p_msc->cbw;

@@ -337,7 +337,7 @@ tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, u
       // Complete IN while waiting for CMD is usually Status of previous SCSI op, ignore it

       if(ep_addr != p_msc->ep_out) return TUSB_ERROR_NONE;

 

-      TU_ASSERT( event == DCD_XFER_SUCCESS  &&

+      TU_ASSERT( event == XFER_RESULT_SUCCESS &&

                  xferred_bytes == sizeof(msc_cbw_t) && p_cbw->signature == MSC_CBW_SIGNATURE, TUSB_ERROR_INVALID_PARA );

 

       p_csw->signature    = MSC_CSW_SIGNATURE;

@@ -467,7 +467,7 @@ tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, u
               }

 

               // simulate an transfer complete with adjusted parameters --> this driver callback will fired again

-              dcd_event_xfer_complete(rhport, p_msc->ep_out, xferred_bytes-nbytes, DCD_XFER_SUCCESS, false);

+              dcd_event_xfer_complete(rhport, p_msc->ep_out, xferred_bytes-nbytes, XFER_RESULT_SUCCESS, false);

 

               return TUSB_ERROR_NONE; // skip the rest

             }

@@ -516,7 +516,7 @@ tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t ep_addr, tusb_event_t event, u
     if ( dcd_edpt_stalled(rhport,  p_msc->ep_in) || dcd_edpt_stalled(rhport,  p_msc->ep_out) )

     {

       // simulate an transfer complete with adjusted parameters --> this driver callback will fired again

-      dcd_event_xfer_complete(rhport, p_msc->ep_out, 0, DCD_XFER_SUCCESS, false);

+      dcd_event_xfer_complete(rhport, p_msc->ep_out, 0, XFER_RESULT_SUCCESS, false);

     }

     else

     {

@@ -578,7 +578,7 @@ static void proc_read10_cmd(uint8_t rhport, mscd_interface_t* p_msc)
   else if ( nbytes == 0 )

   {

     // zero means not ready -> simulate an transfer complete so that this driver callback will fired again

-    dcd_event_xfer_complete(rhport, p_msc->ep_in, 0, DCD_XFER_SUCCESS, false);

+    dcd_event_xfer_complete(rhport, p_msc->ep_in, 0, XFER_RESULT_SUCCESS, false);

   }

   else

   {

diff --git a/src/class/msc/msc_device.h b/src/class/msc/msc_device.h
index c1c51255a..c4476f56f 100644
--- a/src/class/msc/msc_device.h
+++ b/src/class/msc/msc_device.h
@@ -180,7 +180,7 @@ void mscd_init(void);
 tusb_error_t mscd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length);

 bool mscd_control_request(uint8_t rhport, tusb_control_request_t const * p_request);

 bool mscd_control_request_complete (uint8_t rhport, tusb_control_request_t const * p_request);

-tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes);

+tusb_error_t mscd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t event, uint32_t xferred_bytes);

 void mscd_reset(uint8_t rhport);

 

 #endif

diff --git a/src/class/msc/msc_host.c b/src/class/msc/msc_host.c
index 9250b8df7..baef7ff44 100644
--- a/src/class/msc/msc_host.c
+++ b/src/class/msc/msc_host.c
@@ -51,13 +51,13 @@
 //--------------------------------------------------------------------+

 // MACRO CONSTANT TYPEDEF

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

-CFG_TUSB_ATTR_USBRAM STATIC_VAR msch_interface_t msch_data[CFG_TUSB_HOST_DEVICE_MAX];

+CFG_TUSB_MEM_SECTION STATIC_VAR msch_interface_t msch_data[CFG_TUSB_HOST_DEVICE_MAX];

 

 //------------- Initalization Data -------------//

 static osal_semaphore_t msch_sem_hdl;

 

 // buffer used to read scsi information when mounted, largest response data currently is inquiry

-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(4) STATIC_VAR uint8_t msch_buffer[sizeof(scsi_inquiry_data_t)];

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(4) STATIC_VAR uint8_t msch_buffer[sizeof(scsi_inquiry_data_t)];

 

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

 // INTERNAL OBJECT & FUNCTION DECLARATION

@@ -397,7 +397,7 @@ tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
   OSAL_SUBTASK_END

 }

 

-void msch_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes)

+void msch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)

 {

   if ( pipehandle_is_equal(pipe_hdl, msch_data[pipe_hdl.dev_addr-1].bulk_in) )

   {

diff --git a/src/class/msc/msc_host.h b/src/class/msc/msc_host.h
index dce275fc8..a408bbeaf 100644
--- a/src/class/msc/msc_host.h
+++ b/src/class/msc/msc_host.h
@@ -104,7 +104,7 @@ tusb_error_t tuh_msc_get_capacity(uint8_t dev_addr, uint32_t* p_last_lba, uint32
 /** \brief 			Perform SCSI READ 10 command to read data from MassStorage device

  * \param[in]		dev_addr	device address

  * \param[in]		lun       Targeted Logical Unit

- * \param[out]	p_buffer  Buffer used to store data read from device. Must be accessible by USB controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[out]	p_buffer  Buffer used to store data read from device. Must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

  * \param[in]		lba       Starting Logical Block Address to be read

  * \param[in]		block_count Number of Block to be read

  * \retval      TUSB_ERROR_NONE on success

@@ -118,7 +118,7 @@ tusb_error_t tuh_msc_read10 (uint8_t dev_addr, uint8_t lun, void * p_buffer, uin
 /** \brief 			Perform SCSI WRITE 10 command to write data to MassStorage device

  * \param[in]		dev_addr	device address

  * \param[in]		lun       Targeted Logical Unit

- * \param[in]	  p_buffer  Buffer containing data. Must be accessible by USB controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[in]	  p_buffer  Buffer containing data. Must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

  * \param[in]		lba       Starting Logical Block Address to be written

  * \param[in]		block_count Number of Block to be written

  * \retval      TUSB_ERROR_NONE on success

@@ -132,7 +132,7 @@ tusb_error_t tuh_msc_write10(uint8_t dev_addr, uint8_t lun, void const * p_buffe
 /** \brief 			Perform SCSI REQUEST SENSE command, used to retrieve sense data from MassStorage device

  * \param[in]		dev_addr	device address

  * \param[in]		lun       Targeted Logical Unit

- * \param[in]	  p_data    Buffer to store response's data from device. Must be accessible by USB controller (see \ref CFG_TUSB_ATTR_USBRAM)

+ * \param[in]	  p_data    Buffer to store response's data from device. Must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)

  * \retval      TUSB_ERROR_NONE on success

  * \retval      TUSB_ERROR_INTERFACE_IS_BUSY if the interface is already transferring data with device

  * \retval      TUSB_ERROR_DEVICE_NOT_READY if device is not yet configured (by SET CONFIGURED request)

@@ -171,15 +171,15 @@ void tuh_msc_unmounted_cb(uint8_t dev_addr);
 

 /** \brief      Callback function that is invoked when an transferring event occurred

  * \param[in]		dev_addr	Address of device

- * \param[in]   event an value from \ref tusb_event_t

+ * \param[in]   event an value from \ref xfer_result_t

  * \param[in]   xferred_bytes Number of bytes transferred via USB bus

  * \note        event can be one of following

- *              - TUSB_EVENT_XFER_COMPLETE : previously scheduled transfer completes successfully.

- *              - TUSB_EVENT_XFER_ERROR   : previously scheduled transfer encountered a transaction error.

- *              - TUSB_EVENT_XFER_STALLED : previously scheduled transfer is stalled by device.

+ *              - XFER_RESULT_SUCCESS : previously scheduled transfer completes successfully.

+ *              - XFER_RESULT_FAILED   : previously scheduled transfer encountered a transaction error.

+ *              - XFER_RESULT_STALLED : previously scheduled transfer is stalled by device.

  * \note

  */

-void tuh_msc_isr(uint8_t dev_addr, tusb_event_t event, uint32_t xferred_bytes);

+void tuh_msc_isr(uint8_t dev_addr, xfer_result_t event, uint32_t xferred_bytes);

 

 

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

@@ -205,7 +205,7 @@ typedef struct {
 

 void         msch_init(void);

 tusb_error_t msch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;

-void         msch_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes);

+void         msch_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);

 void         msch_close(uint8_t dev_addr);

 #endif

 

diff --git a/src/common/compiler/tusb_compiler_gcc.h b/src/common/compiler/tusb_compiler_gcc.h
index c9f716d48..e40ad9c41 100644
--- a/src/common/compiler/tusb_compiler_gcc.h
+++ b/src/common/compiler/tusb_compiler_gcc.h
@@ -66,10 +66,8 @@
 
 /// The packed attribute specifies that a variable or structure field should have the smallest possible alignment—one byte for a variable, and one bit for a field, unless you specify a larger value with the aligned attribute
 #define ATTR_PACKED                __attribute__ ((packed))
-
 #define ATTR_PREPACKED
 
-#define ATTR_PACKED_STRUCT(x)     x __attribute__ ((packed))
 /** @} */
 
 /** \defgroup Group_FuncAttr Function Attributes
diff --git a/src/common/compiler/tusb_compiler_iar.h b/src/common/compiler/tusb_compiler_iar.h
index 1703ea45f..1f8936859 100644
--- a/src/common/compiler/tusb_compiler_iar.h
+++ b/src/common/compiler/tusb_compiler_iar.h
@@ -53,8 +53,6 @@
 #endif

 

 #define ALIGN_OF(x)     __ALIGNOF__(x)

-

-#define ATTR_PACKED_STRUCT(x)     __packed x

 #define ATTR_PREPACKED  __packed

 #define ATTR_PACKED

 //#define ATTR_SECTION(section)      _Pragma((#section))

diff --git a/src/common/tusb_types.h b/src/common/tusb_types.h
index 32632cd90..b11481b18 100644
--- a/src/common/tusb_types.h
+++ b/src/common/tusb_types.h
@@ -51,10 +51,6 @@
  extern "C" {

 #endif

 

-#pragma GCC diagnostic push

-#pragma GCC diagnostic ignored "-Wpacked"

-#pragma GCC diagnostic ignored "-Wattributes"

-

 /*------------------------------------------------------------------*/

 /* CONSTANTS

  *------------------------------------------------------------------*/

@@ -197,11 +193,10 @@ typedef enum
 

 typedef enum

 {

-  TUSB_EVENT_NONE = 0,

-  TUSB_EVENT_XFER_COMPLETE,

-  TUSB_EVENT_XFER_ERROR,

-  TUSB_EVENT_XFER_STALLED,

-}tusb_event_t;

+  XFER_RESULT_SUCCESS,

+  XFER_RESULT_FAILED,

+  XFER_RESULT_STALLED,

+}xfer_result_t;

 

 enum

 {

@@ -428,8 +423,6 @@ static inline uint8_t descriptor_len(uint8_t const p_desc[])
 // Convert comma-separated string to descriptor unicode format

 #define TUD_DESC_STRCONV( ... )     (const uint16_t[]) { TUD_DESC_STR_HEADER(VA_ARGS_NUM_(__VA_ARGS__)), __VA_ARGS__ }

 

-#pragma GCC diagnostic pop

-

 #ifdef __cplusplus

  }

 #endif

diff --git a/src/device/dcd.h b/src/device/dcd.h
index f07bda2d3..db84df839 100644
--- a/src/device/dcd.h
+++ b/src/device/dcd.h
@@ -49,13 +49,6 @@
  extern "C" {

 #endif

 

-enum

-{

-  DCD_XFER_SUCCESS = 0,

-  DCD_XFER_FAILED,

-  DCD_XFER_STALLED

-};

-

 typedef enum

 {

   DCD_EVENT_BUS_RESET = 1,

diff --git a/src/device/usbd.c b/src/device/usbd.c
index f39605987..8c7e588e0 100644
--- a/src/device/usbd.c
+++ b/src/device/usbd.c
@@ -92,7 +92,7 @@ typedef struct {
   tusb_error_t (* open           ) (uint8_t rhport, tusb_desc_interface_t const * desc_intf, uint16_t* p_length);

   bool         (* control_request ) (uint8_t rhport, tusb_control_request_t const * request);

   bool (* control_request_complete ) (uint8_t rhport, tusb_control_request_t const * request);

-  tusb_error_t (* xfer_cb        ) (uint8_t rhport, uint8_t ep_addr, tusb_event_t, uint32_t);

+  tusb_error_t (* xfer_cb        ) (uint8_t rhport, uint8_t ep_addr, xfer_result_t, uint32_t);

   void         (* sof            ) (uint8_t rhport);

   void         (* reset          ) (uint8_t);

 } usbd_class_driver_t;

@@ -174,7 +174,7 @@ static bool process_set_config(uint8_t rhport, uint8_t config_number);
 static void const* get_descriptor(tusb_control_request_t const * p_request, uint16_t* desc_len);

 

 void usbd_control_reset (uint8_t rhport);

-bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, tusb_event_t event, uint32_t xferred_bytes);

+bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes);

 void usbd_control_set_complete_callback( bool (*fp) (uint8_t, tusb_control_request_t const * ) );

 

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

@@ -581,7 +581,7 @@ void dcd_event_handler(dcd_event_t const * event, bool in_isr)
       if ( 0 == edpt_number(event->xfer_complete.ep_addr) && event->xfer_complete.len == 0) break;

 

       osal_queue_send(_usbd_q, event, in_isr);

-      TU_ASSERT(event->xfer_complete.result == DCD_XFER_SUCCESS,);

+      TU_ASSERT(event->xfer_complete.result == XFER_RESULT_SUCCESS,);

     break;

 

     default: break;

diff --git a/src/device/usbd_control.c b/src/device/usbd_control.c
index 8564d1ae9..31d74edf0 100644
--- a/src/device/usbd_control.c
+++ b/src/device/usbd_control.c
@@ -64,7 +64,7 @@ typedef struct
 

 static usbd_control_xfer_t _control_state;

 

-CFG_TUSB_ATTR_USBRAM CFG_TUSB_MEM_ALIGN uint8_t _usbd_ctrl_buf[CFG_TUD_ENDOINT0_SIZE];

+CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN uint8_t _usbd_ctrl_buf[CFG_TUD_ENDOINT0_SIZE];

 

 void usbd_control_reset (uint8_t rhport)

 {

@@ -126,7 +126,7 @@ bool usbd_control_xfer(uint8_t rhport, tusb_control_request_t const * request, v
 }

 

 // callback when a transaction complete on DATA stage of control endpoint

-bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, tusb_event_t event, uint32_t xferred_bytes)

+bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)

 {

   if ( _control_state.request.bmRequestType_bit.direction == TUSB_DIR_OUT )

   {

diff --git a/src/host/ehci/ehci.c b/src/host/ehci/ehci.c
index c7ff70d70..27808d59b 100644
--- a/src/host/ehci/ehci.c
+++ b/src/host/ehci/ehci.c
@@ -56,12 +56,12 @@
 //--------------------------------------------------------------------+

 // INTERNAL OBJECT & FUNCTION DECLARATION

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

-CFG_TUSB_ATTR_USBRAM STATIC_VAR ehci_data_t ehci_data;

+CFG_TUSB_MEM_SECTION STATIC_VAR ehci_data_t ehci_data;

 

 #if EHCI_PERIODIC_LIST

 

   #if (CFG_TUSB_RHPORT0_MODE & OPT_MODE_HOST)

-  CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(4096) STATIC_VAR ehci_link_t period_frame_list0[EHCI_FRAMELIST_SIZE];

+  CFG_TUSB_MEM_SECTION ATTR_ALIGNED(4096) STATIC_VAR ehci_link_t period_frame_list0[EHCI_FRAMELIST_SIZE];

 

     #ifndef __ICCARM__ // IAR cannot able to determine the alignment with datalignment pragma

     TU_VERIFY_STATIC( ALIGN_OF(period_frame_list0) == 4096, "Period Framelist must be 4k alginment"); // validation

@@ -69,7 +69,7 @@ CFG_TUSB_ATTR_USBRAM STATIC_VAR ehci_data_t ehci_data;
   #endif

 

   #if (CFG_TUSB_RHPORT1_MODE & OPT_MODE_HOST)

-  CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(4096) STATIC_VAR ehci_link_t period_frame_list1[EHCI_FRAMELIST_SIZE];

+  CFG_TUSB_MEM_SECTION ATTR_ALIGNED(4096) STATIC_VAR ehci_link_t period_frame_list1[EHCI_FRAMELIST_SIZE];

 

     #ifndef __ICCARM__ // IAR cannot able to determine the alignment with datalignment pragma

     TU_VERIFY_STATIC( ALIGN_OF(period_frame_list1) == 4096, "Period Framelist must be 4k alginment"); // validation

@@ -570,7 +570,7 @@ static void qhd_xfer_complete_isr(ehci_qhd_t * p_qhd)
     if (is_ioc) // end of request

     { // call USBH callback

       usbh_xfer_isr( qhd_create_pipe_handle(p_qhd, xfer_type),

-                     p_qhd->class_code, TUSB_EVENT_XFER_COMPLETE,

+                     p_qhd->class_code, XFER_RESULT_SUCCESS,

                      p_qhd->total_xferred_bytes - (xfer_type == TUSB_XFER_CONTROL ? 8 : 0) ); // subtract setup packet size if control,

       p_qhd->total_xferred_bytes = 0;

     }

@@ -638,15 +638,15 @@ static void qhd_xfer_error_isr(ehci_qhd_t * p_qhd)
         qhd_has_xact_error(p_qhd) )

   { // current qhd has error in transaction

     tusb_xfer_type_t const xfer_type = qhd_get_xfer_type(p_qhd);

-    tusb_event_t error_event;

+    xfer_result_t error_event;

 

     // no error bits are set, endpoint is halted due to STALL

-    error_event = qhd_has_xact_error(p_qhd) ? TUSB_EVENT_XFER_ERROR : TUSB_EVENT_XFER_STALLED;

+    error_event = qhd_has_xact_error(p_qhd) ? XFER_RESULT_FAILED : XFER_RESULT_STALLED;

 

     p_qhd->total_xferred_bytes += p_qhd->p_qtd_list_head->expected_bytes - p_qhd->p_qtd_list_head->total_bytes;

 

 

-//    if ( TUSB_EVENT_XFER_ERROR == error_event )    TU_BREAKPOINT(); // TODO skip unplugged device

+//    if ( XFER_RESULT_FAILED == error_event )    TU_BREAKPOINT(); // TODO skip unplugged device

 

     p_qhd->p_qtd_list_head->used = 0; // free QTD

     qtd_remove_1st_from_qhd(p_qhd);

diff --git a/src/host/hub.c b/src/host/hub.c
index 624e43563..55c8597ad 100644
--- a/src/host/hub.c
+++ b/src/host/hub.c
@@ -58,8 +58,8 @@ typedef struct {
   uint8_t status_change; // data from status change interrupt endpoint

 }usbh_hub_t;

 

-CFG_TUSB_ATTR_USBRAM STATIC_VAR usbh_hub_t hub_data[CFG_TUSB_HOST_DEVICE_MAX];

-ATTR_ALIGNED(4) CFG_TUSB_ATTR_USBRAM STATIC_VAR uint8_t hub_enum_buffer[sizeof(descriptor_hub_desc_t)];

+CFG_TUSB_MEM_SECTION STATIC_VAR usbh_hub_t hub_data[CFG_TUSB_HOST_DEVICE_MAX];

+ATTR_ALIGNED(4) CFG_TUSB_MEM_SECTION STATIC_VAR uint8_t hub_enum_buffer[sizeof(descriptor_hub_desc_t)];

 

 //OSAL_SEM_DEF(hub_enum_semaphore);

 //static osal_semaphore_handle_t hub_enum_sem_hdl;

@@ -209,13 +209,13 @@ tusb_error_t hub_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_i
 }

 

 // is the response of interrupt endpoint polling

-void hub_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes)

+void hub_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes)

 {

   (void) xferred_bytes; // TODO can be more than 1 for hub with lots of ports

 

   usbh_hub_t * p_hub = &hub_data[pipe_hdl.dev_addr-1];

 

-  if ( event == TUSB_EVENT_XFER_COMPLETE )

+  if ( event == XFER_RESULT_SUCCESS )

   {

     for (uint8_t port=1; port <= p_hub->port_number; port++)

     { // TODO HUB ignore bit0 hub_status_change

diff --git a/src/host/hub.h b/src/host/hub.h
index 67c02f2e3..9376a2698 100644
--- a/src/host/hub.h
+++ b/src/host/hub.h
@@ -196,7 +196,7 @@ tusb_error_t hub_status_pipe_queue(uint8_t dev_addr);
 

 void         hub_init(void);

 tusb_error_t hub_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_interface_desc, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;

-void         hub_isr(pipe_handle_t pipe_hdl, tusb_event_t event, uint32_t xferred_bytes);

+void         hub_isr(pipe_handle_t pipe_hdl, xfer_result_t event, uint32_t xferred_bytes);

 void         hub_close(uint8_t dev_addr);

 

 #endif

diff --git a/src/host/ohci/ohci.c b/src/host/ohci/ohci.c
index b9183a025..91d9b6243 100644
--- a/src/host/ohci/ohci.c
+++ b/src/host/ohci/ohci.c
@@ -142,7 +142,7 @@ enum {
 //--------------------------------------------------------------------+

 // INTERNAL OBJECT & FUNCTION DECLARATION

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

-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(256) STATIC_VAR ohci_data_t ohci_data;

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(256) STATIC_VAR ohci_data_t ohci_data;

 

 static ohci_ed_t * const p_ed_head[] =

 {

@@ -617,11 +617,11 @@ static void done_queue_isr(uint8_t hostid)
     // TODO check if td_head is iso td

     //------------- Non ISO transfer -------------//

     ohci_gtd_t * const p_qtd = (ohci_gtd_t *) td_head;

-    tusb_event_t const event = (p_qtd->condition_code == OHCI_CCODE_NO_ERROR) ? TUSB_EVENT_XFER_COMPLETE :

-                               (p_qtd->condition_code == OHCI_CCODE_STALL) ? TUSB_EVENT_XFER_STALLED : TUSB_EVENT_XFER_ERROR;

+    xfer_result_t const event = (p_qtd->condition_code == OHCI_CCODE_NO_ERROR) ? XFER_RESULT_SUCCESS :

+                               (p_qtd->condition_code == OHCI_CCODE_STALL) ? XFER_RESULT_STALLED : XFER_RESULT_FAILED;

 

     p_qtd->used = 0; // free TD

-    if ( (p_qtd->delay_interrupt == OHCI_INT_ON_COMPLETE_YES) || (event != TUSB_EVENT_XFER_COMPLETE) )

+    if ( (p_qtd->delay_interrupt == OHCI_INT_ON_COMPLETE_YES) || (event != XFER_RESULT_SUCCESS) )

     {

       ohci_ed_t * const p_ed  = gtd_get_ed(p_qtd);

 

@@ -634,11 +634,11 @@ static void done_queue_isr(uint8_t hostid)
       // --> HC will not process Control list (due to service ratio when Bulk list not empty)

       // To walk-around this, the halted ED will have TailP = HeadP (empty list condition), when clearing halt

       // the TailP must be set back to NULL for processing remaining TDs

-      if ((event != TUSB_EVENT_XFER_COMPLETE))

+      if ((event != XFER_RESULT_SUCCESS))

       {

         p_ed->td_tail.address &= 0x0Ful;

         p_ed->td_tail.address |= tu_align16(p_ed->td_head.address); // mark halted EP as empty queue

-        if ( event == TUSB_EVENT_XFER_STALLED ) p_ed->is_stalled = 1;

+        if ( event == XFER_RESULT_STALLED ) p_ed->is_stalled = 1;

       }

 

       pipe_handle_t pipe_hdl =

diff --git a/src/host/usbh.c b/src/host/usbh.c
index f996d7a70..a0aab3b96 100644
--- a/src/host/usbh.c
+++ b/src/host/usbh.c
@@ -109,13 +109,13 @@ enum { USBH_CLASS_DRIVER_COUNT = sizeof(usbh_class_drivers) / sizeof(host_class_
 //--------------------------------------------------------------------+

 // INTERNAL OBJECT & FUNCTION DECLARATION

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

-CFG_TUSB_ATTR_USBRAM usbh_device_info_t usbh_devices[CFG_TUSB_HOST_DEVICE_MAX+1]; // including zero-address

+CFG_TUSB_MEM_SECTION usbh_device_info_t usbh_devices[CFG_TUSB_HOST_DEVICE_MAX+1]; // including zero-address

 

 //------------- Enumeration Task Data -------------/

 enum { ENUM_QUEUE_DEPTH = 16 };

 

 STATIC_VAR osal_queue_t enum_queue_hdl;

-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(4) STATIC_VAR uint8_t enum_data_buffer[CFG_TUSB_HOST_ENUM_BUFFER_SIZE];

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(4) STATIC_VAR uint8_t enum_data_buffer[CFG_TUSB_HOST_ENUM_BUFFER_SIZE];

 

 //------------- Reporter Task Data -------------//

 

@@ -199,7 +199,7 @@ tusb_error_t usbh_control_xfer_subtask(uint8_t dev_addr, uint8_t bmRequestType,
 #ifndef _TEST_

   usbh_devices[dev_addr].control.pipe_status = 0;

 #else

-  usbh_devices[dev_addr].control.pipe_status = TUSB_EVENT_XFER_COMPLETE; // in Test project, mark as complete immediately

+  usbh_devices[dev_addr].control.pipe_status = XFER_RESULT_SUCCESS; // in Test project, mark as complete immediately

 #endif

 

   error = hcd_pipe_control_xfer(dev_addr, &usbh_devices[dev_addr].control.request, data);

@@ -207,11 +207,11 @@ tusb_error_t usbh_control_xfer_subtask(uint8_t dev_addr, uint8_t bmRequestType,
   osal_mutex_release(usbh_devices[dev_addr].control.mutex_hdl);

 

   STASK_ASSERT_ERR(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);

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

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

 

 //  STASK_ASSERT_HDLR(TUSB_ERROR_NONE == error &&

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

+//                              XFER_RESULT_SUCCESS == usbh_devices[dev_addr].control.pipe_status,

 //                              tuh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_DEVICE_NOT_RESPOND, NULL) );

 

   OSAL_SUBTASK_END

@@ -256,7 +256,7 @@ static inline uint8_t std_class_code_to_index(uint8_t std_class_code)
 // USBH-HCD ISR/Callback API

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

 // interrupt caused by a TD (with IOC=1) in pipe of class class_code

-void usbh_xfer_isr(pipe_handle_t pipe_hdl, uint8_t class_code, tusb_event_t event, uint32_t xferred_bytes)

+void usbh_xfer_isr(pipe_handle_t pipe_hdl, uint8_t class_code, xfer_result_t event, uint32_t xferred_bytes)

 {

   uint8_t class_index = std_class_code_to_index(class_code);

   if (TUSB_XFER_CONTROL == pipe_hdl.xfer_type)

diff --git a/src/host/usbh.h b/src/host/usbh.h
index 5aaeb4186..22fdef162 100644
--- a/src/host/usbh.h
+++ b/src/host/usbh.h
@@ -66,7 +66,7 @@ typedef enum tusb_interface_status_{
 typedef struct {
   void (* const init) (void);
   tusb_error_t (* const open_subtask)(uint8_t, tusb_desc_interface_t const *, uint16_t*);
-  void (* const isr) (pipe_handle_t, tusb_event_t, uint32_t);
+  void (* const isr) (pipe_handle_t, xfer_result_t, uint32_t);
   void (* const close) (uint8_t);
 } host_class_driver_t;
 //--------------------------------------------------------------------+
diff --git a/src/host/usbh_hcd.h b/src/host/usbh_hcd.h
index 1c2c4ad0b..f6b72273a 100644
--- a/src/host/usbh_hcd.h
+++ b/src/host/usbh_hcd.h
@@ -101,7 +101,7 @@ extern usbh_device_info_t usbh_devices[CFG_TUSB_HOST_DEVICE_MAX+1]; // including
 //--------------------------------------------------------------------+
 // callback from HCD ISR
 //--------------------------------------------------------------------+
-void usbh_xfer_isr(pipe_handle_t pipe_hdl, uint8_t class_code, tusb_event_t event, uint32_t xferred_bytes);
+void usbh_xfer_isr(pipe_handle_t pipe_hdl, uint8_t class_code, xfer_result_t event, uint32_t xferred_bytes);
 void usbh_hcd_rhport_plugged_isr(uint8_t hostid);
 void usbh_hcd_rhport_unplugged_isr(uint8_t hostid);
 
diff --git a/src/osal/osal_none.h b/src/osal/osal_none.h
index 46930aeda..b21c3332a 100644
--- a/src/osal/osal_none.h
+++ b/src/osal/osal_none.h
@@ -156,10 +156,12 @@ static inline void osal_queue_reset(osal_queue_t const queue_hdl)
 static inline bool osal_queue_receive(osal_queue_t const queue_hdl, void* data)

 {

   // osal none return immediately without blocking

+  // extern void tusb_hal_int_disable(uint8_t rhport);

+  // extern void tusb_hal_int_enable(uint8_t rhport);

 

-  // tusb_hal_int_disable_all();

+//  tusb_hal_int_disable(0);

   bool rc = tu_fifo_read(queue_hdl, data);

-  // tusb_hal_int_enable_all();

+//  tusb_hal_int_enable(0);

 

   return rc;

 }

diff --git a/src/portable/microchip/samd21/dcd_samd21.c b/src/portable/microchip/samd21/dcd_samd21.c
index b31db547d..c6101f312 100644
--- a/src/portable/microchip/samd21/dcd_samd21.c
+++ b/src/portable/microchip/samd21/dcd_samd21.c
@@ -275,7 +275,7 @@ void maybe_transfer_complete(void) {
             total_transfer_size = bank->PCKSIZE.bit.BYTE_COUNT;
 
             uint8_t ep_addr = epnum | TUSB_DIR_IN_MASK;
-            dcd_event_xfer_complete(0, ep_addr, total_transfer_size, DCD_XFER_SUCCESS, true);
+            dcd_event_xfer_complete(0, ep_addr, total_transfer_size, XFER_RESULT_SUCCESS, true);
         }
 
         // Handle OUT completions
@@ -286,7 +286,7 @@ void maybe_transfer_complete(void) {
             total_transfer_size = bank->PCKSIZE.bit.BYTE_COUNT;
 
             uint8_t ep_addr = epnum;
-            dcd_event_xfer_complete(0, ep_addr, total_transfer_size, DCD_XFER_SUCCESS, true);
+            dcd_event_xfer_complete(0, ep_addr, total_transfer_size, XFER_RESULT_SUCCESS, true);
         }
 
         // just finished status stage (total size = 0), prepare for next setup packet
diff --git a/src/portable/microchip/samd51/dcd_samd51.c b/src/portable/microchip/samd51/dcd_samd51.c
index 6fff12ba7..6e8053e59 100644
--- a/src/portable/microchip/samd51/dcd_samd51.c
+++ b/src/portable/microchip/samd51/dcd_samd51.c
@@ -304,7 +304,7 @@ void transfer_complete(uint8_t direction) {
         if (direction == TUSB_DIR_IN) {
             ep_addr |= TUSB_DIR_IN_MASK;
         }
-        dcd_event_xfer_complete(0, ep_addr, total_transfer_size, DCD_XFER_SUCCESS, true);
+        dcd_event_xfer_complete(0, ep_addr, total_transfer_size, XFER_RESULT_SUCCESS, true);
 
         // just finished status stage (total size = 0), prepare for next setup packet
         if (epnum == 0 && total_transfer_size == 0) {
diff --git a/src/portable/nordic/nrf5x/dcd_nrf5x.c b/src/portable/nordic/nrf5x/dcd_nrf5x.c
index 816ff62ae..4fb88689c 100644
--- a/src/portable/nordic/nrf5x/dcd_nrf5x.c
+++ b/src/portable/nordic/nrf5x/dcd_nrf5x.c
@@ -261,7 +261,7 @@ bool dcd_edpt_xfer (uint8_t rhport, uint8_t ep_addr, uint8_t * buffer, uint16_t
     edpt_dma_end();
 
     // The nRF doesn't interrupt on status transmit so we queue up a success response.
-    dcd_event_xfer_complete(0, ep_addr, 0, DCD_XFER_SUCCESS, false);
+    dcd_event_xfer_complete(0, ep_addr, 0, XFER_RESULT_SUCCESS, false);
   }
   else if ( dir == TUSB_DIR_OUT )
   {
@@ -459,7 +459,7 @@ void USBD_IRQHandler(void)
         xfer->total_len = xfer->actual_len;
 
         // BULK/INT OUT complete
-        dcd_event_xfer_complete(0, epnum, xfer->actual_len, DCD_XFER_SUCCESS, true);
+        dcd_event_xfer_complete(0, epnum, xfer->actual_len, XFER_RESULT_SUCCESS, true);
       }
     }
 
@@ -494,7 +494,7 @@ void USBD_IRQHandler(void)
         } else
         {
           // Bulk/Int IN complete
-          dcd_event_xfer_complete(0, epnum | TUSB_DIR_IN_MASK, xfer->actual_len, DCD_XFER_SUCCESS, true);
+          dcd_event_xfer_complete(0, epnum | TUSB_DIR_IN_MASK, xfer->actual_len, XFER_RESULT_SUCCESS, true);
         }
       }
     }
diff --git a/src/portable/nordic/nrf5x/hal_nrf5x.c b/src/portable/nordic/nrf5x/hal_nrf5x.c
index 4ce512746..f40e904d7 100644
--- a/src/portable/nordic/nrf5x/hal_nrf5x.c
+++ b/src/portable/nordic/nrf5x/hal_nrf5x.c
@@ -61,6 +61,7 @@ enum {
 #endif
 
 #include "tusb_hal.h"
+#include "device/dcd.h"
 
 /*------------------------------------------------------------------*/
 /* MACRO TYPEDEF CONSTANT ENUM
@@ -291,6 +292,8 @@ void tusb_hal_nrf_power_event (uint32_t event)
 
         nrf_usbd_disable();
         hfclk_disable();
+
+        dcd_event_bus_signal(0, DCD_EVENT_UNPLUGGED, true);
       }
     break;
 
diff --git a/src/portable/nxp/lpc11xx_lpc13xx/dcd_lpc_11uxx_13uxx.c b/src/portable/nxp/lpc11xx_lpc13xx/dcd_lpc_11uxx_13uxx.c
index 5c64cbb6b..4e514d6e2 100644
--- a/src/portable/nxp/lpc11xx_lpc13xx/dcd_lpc_11uxx_13uxx.c
+++ b/src/portable/nxp/lpc11xx_lpc13xx/dcd_lpc_11uxx_13uxx.c
@@ -141,11 +141,11 @@ typedef struct {
 //--------------------------------------------------------------------+

 // INTERNAL OBJECT & FUNCTION DECLARATION

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

-// CFG_TUSB_ATTR_USBRAM must have ATTR_ALIGNED(64) for lpc11u & lpc13u

+// CFG_TUSB_MEM_SECTION must have ATTR_ALIGNED(64) for lpc11u & lpc13u

 #ifdef __ICCARM__

-ATTR_ALIGNED(256) CFG_TUSB_ATTR_USBRAM // for IAR the first ATTR_ALIGNED takes effect

+ATTR_ALIGNED(256) CFG_TUSB_MEM_SECTION // for IAR the first ATTR_ALIGNED takes effect

 #else

-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(256) // GCC & Keil the last ATTR_ALIGNED takes effect

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(256) // GCC & Keil the last ATTR_ALIGNED takes effect

 #endif

 STATIC_VAR dcd_11u_13u_data_t dcd_data;

 

diff --git a/src/portable/nxp/lpc17xx/dcd_lpc175x_6x.c b/src/portable/nxp/lpc17xx/dcd_lpc175x_6x.c
index 850e257c6..ce8362546 100644
--- a/src/portable/nxp/lpc17xx/dcd_lpc175x_6x.c
+++ b/src/portable/nxp/lpc17xx/dcd_lpc175x_6x.c
@@ -68,7 +68,7 @@ typedef struct {
 

 }dcd_data_t;

 

-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(128) STATIC_VAR dcd_data_t dcd_data;

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(128) STATIC_VAR dcd_data_t dcd_data;

 

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

 // INTERNAL OBJECT & FUNCTION DECLARATION

diff --git a/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.c b/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.c
index 8d53759e6..2f83f4203 100644
--- a/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.c
+++ b/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.c
@@ -66,19 +66,30 @@ typedef struct {
   dcd_qtd_t qtd[DCD_QTD_MAX] ATTR_ALIGNED(32);

 }dcd_data_t;

 

-extern ATTR_WEAK dcd_data_t dcd_data0;

-extern ATTR_WEAK dcd_data_t dcd_data1;

-

 #if (CFG_TUSB_RHPORT0_MODE & OPT_MODE_DEVICE)

-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(2048) STATIC_VAR dcd_data_t dcd_data0;

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(2048) static dcd_data_t dcd_data0;

 #endif

 

 #if (CFG_TUSB_RHPORT1_MODE & OPT_MODE_DEVICE)

-CFG_TUSB_ATTR_USBRAM ATTR_ALIGNED(2048) STATIC_VAR dcd_data_t dcd_data1;

+CFG_TUSB_MEM_SECTION ATTR_ALIGNED(2048) static dcd_data_t dcd_data1;

 #endif

 

 static LPC_USB0_Type * const LPC_USB[2] = { LPC_USB0, ((LPC_USB0_Type*) LPC_USB1_BASE) };

-static dcd_data_t* const dcd_data_ptr[2] = { &dcd_data0, &dcd_data1 };

+

+static dcd_data_t* const dcd_data_ptr[2] =

+{

+#if (CFG_TUSB_RHPORT0_MODE & OPT_MODE_DEVICE)

+  &dcd_data0,

+#else

+  NULL,

+#endif

+

+#if (CFG_TUSB_RHPORT1_MODE & OPT_MODE_DEVICE)

+  &dcd_data1

+#else

+  NULL

+#endif

+};

 

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

 // CONTROLLER API

@@ -104,12 +115,11 @@ static void bus_reset(uint8_t rhport)
   LPC_USB0_Type* const lpc_usb = LPC_USB[rhport];

 

   // The reset value for all endpoint types is the control endpoint. If one endpoint

-  //direction is enabled and the paired endpoint of opposite direction is disabled, then the

-  //endpoint type of the unused direction must bechanged from the control type to any other

-  //type (e.g. bulk). Leaving an unconfigured endpoint control will cause undefined behavior

-  //for the data PID tracking on the active endpoint.

-  lpc_usb->ENDPTCTRL1 = lpc_usb->ENDPTCTRL2 = lpc_usb->ENDPTCTRL3 =

-      (TUSB_XFER_BULK << 2) | (TUSB_XFER_BULK << 18);

+  // direction is enabled and the paired endpoint of opposite direction is disabled, then the

+  // endpoint type of the unused direction must bechanged from the control type to any other

+  // type (e.g. bulk). Leaving an unconfigured endpoint control will cause undefined behavior

+  // for the data PID tracking on the active endpoint.

+  lpc_usb->ENDPTCTRL1 = lpc_usb->ENDPTCTRL2 = lpc_usb->ENDPTCTRL3 = (TUSB_XFER_BULK << 2) | (TUSB_XFER_BULK << 18);

 

   // USB1 only has 3 non-control endpoints

   if ( rhport == 0)

@@ -165,41 +175,18 @@ bool dcd_init(uint8_t rhport)
 }

 

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

-// PIPE HELPER

+// HELPER

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

-#if 0

-static inline uint8_t edpt_pos2phy(uint8_t pos)

-{ // 0-5 --> OUT, 16-21 IN

-  return (pos < DCD_QHD_MAX/2) ? (2*pos) : (2*(pos-16)+1);

-}

-#endif

-

-static inline uint8_t edpt_phy2pos(uint8_t physical_endpoint)

+// index to bit position in register

+static inline uint8_t ep_idx2bit(uint8_t ep_idx)

 {

-  return physical_endpoint/2 + ( (physical_endpoint%2) ? 16 : 0);

-}

-

-static inline uint8_t edpt_addr2phy(uint8_t endpoint_addr)

-{

-  return 2*(endpoint_addr & 0x0F) + ((endpoint_addr & TUSB_DIR_IN_MASK) ? 1 : 0);

-}

-

-static inline uint8_t edpt_phy2addr(uint8_t ep_idx)

-{

-  return (ep_idx/2) | ( ep_idx & 0x01 ? TUSB_DIR_IN_MASK : 0 );

-}

-

-static inline uint8_t edpt_phy2log(uint8_t physical_endpoint)

-{

-  return physical_endpoint/2;

+  return ep_idx/2 + ( (ep_idx%2) ? 16 : 0);

 }

 

 static void qtd_init(dcd_qtd_t* p_qtd, void * data_ptr, uint16_t total_bytes)

 {

   tu_memclr(p_qtd, sizeof(dcd_qtd_t));

 

-  p_qtd->used        = 1;

-

   p_qtd->next        = QTD_NEXT_INVALID;

   p_qtd->active      = 1;

   p_qtd->total_bytes = p_qtd->expected_bytes = total_bytes;

@@ -214,81 +201,49 @@ static void qtd_init(dcd_qtd_t* p_qtd, void * data_ptr, uint16_t total_bytes)
   }

 }

 

-// retval 0: invalid

-static inline uint8_t qtd_find_free(uint8_t rhport)

+static inline volatile uint32_t * get_endpt_ctrl_reg(uint8_t rhport, uint8_t ep_idx)

 {

-  // QTD0 is reserved for control transfer

-  for(uint8_t i=1; i<DCD_QTD_MAX; i++)

-  {

-    if ( dcd_data_ptr[rhport]->qtd[i].used == 0) return i;

-  }

-

-  return 0;

+ return &(LPC_USB[rhport]->ENDPTCTRL0) + ep_idx/2;

 }

 

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

-// CONTROL PIPE API

+// DCD Endpoint Port

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

-

-// control transfer does not need to use qtd find function

-// follows UM 24.10.8.1.1 Setup packet handling using setup lockout mechanism

-bool dcd_control_xfer(uint8_t rhport, uint8_t dir, uint8_t * p_buffer, uint16_t length)

-{

-  LPC_USB0_Type* const lpc_usb = LPC_USB[rhport];

-  dcd_data_t* const p_dcd      = dcd_data_ptr[rhport];

-

-  uint8_t const ep_phy = (dir == TUSB_DIR_IN) ? 1 : 0;

-

-  dcd_qhd_t* qhd = &p_dcd->qhd[ep_phy];

-

-  // wait until ENDPTSETUPSTAT before priming data/status in response TODO add time out

-  while(lpc_usb->ENDPTSETUPSTAT & BIT_(0)) {}

-

-  TU_VERIFY( !qhd->qtd_overlay.active );

-

-  dcd_qtd_t* qtd = &p_dcd->qtd[0];

-  qtd_init(qtd, p_buffer, length);

-

-  // skip xfer complete for Status

-  qtd->int_on_complete = (length > 0 ? 1 : 0);

-

-  qhd->qtd_overlay.next = (uint32_t) qtd;

-

-  lpc_usb->ENDPTPRIME = BIT_(edpt_phy2pos(ep_phy));

-

-  return true;

-}

-

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

-// BULK/INTERRUPT/ISOCHRONOUS PIPE API

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

-static inline volatile uint32_t * get_reg_control_addr(uint8_t rhport, uint8_t physical_endpoint)

-{

- return &(LPC_USB[rhport]->ENDPTCTRL0) + edpt_phy2log(physical_endpoint);

-}

-

 void dcd_edpt_stall(uint8_t rhport, uint8_t ep_addr)

 {

-  uint8_t ep_idx    = edpt_addr2phy(ep_addr);

-  volatile uint32_t * reg_control = get_reg_control_addr(rhport, ep_idx);

+  uint8_t const epnum  = edpt_number(ep_addr);

+  uint8_t const dir    = edpt_dir(ep_addr);

+  uint8_t const ep_idx = 2*epnum + dir;

 

-  if ( ep_addr == 0)

+  volatile uint32_t * endpt_ctrl = get_endpt_ctrl_reg(rhport, ep_idx);

+

+  if ( epnum == 0)

   {

     // Stall both Control IN and OUT

-    (*reg_control) |= ( (ENDPTCTRL_MASK_STALL << 16) || (ENDPTCTRL_MASK_STALL << 0) );

+    (*endpt_ctrl) |= ( (ENDPTCTRL_MASK_STALL << 16) || (ENDPTCTRL_MASK_STALL << 0) );

   }else

   {

-    (*reg_control) |= ENDPTCTRL_MASK_STALL << (ep_idx & 0x01 ? 16 : 0);

+    (*endpt_ctrl) |= ENDPTCTRL_MASK_STALL << (ep_idx & 0x01 ? 16 : 0);

   }

 }

 

+// TOOD implement later

+bool dcd_edpt_stalled (uint8_t rhport, uint8_t ep_addr)

+{

+  return false;

+}

+

 void dcd_edpt_clear_stall(uint8_t rhport, uint8_t ep_addr)

 {

-  volatile uint32_t * reg_control = get_reg_control_addr(rhport, edpt_addr2phy(ep_addr));

+  uint8_t const epnum  = edpt_number(ep_addr);

+  uint8_t const dir    = edpt_dir(ep_addr);

+  uint8_t const ep_idx = 2*epnum + dir;

+

+  volatile uint32_t * endpt_ctrl = get_endpt_ctrl_reg(rhport, ep_idx);

 

   // data toggle also need to be reset

-  (*reg_control) |= ENDPTCTRL_MASK_TOGGLE_RESET << ((ep_addr & TUSB_DIR_IN_MASK) ? 16 : 0);

-  (*reg_control) &= ~(ENDPTCTRL_MASK_STALL << ((ep_addr & TUSB_DIR_IN_MASK) ? 16 : 0));

+  (*endpt_ctrl) |= ENDPTCTRL_MASK_TOGGLE_RESET << ((ep_addr & TUSB_DIR_IN_MASK) ? 16 : 0);

+  (*endpt_ctrl) &= ~(ENDPTCTRL_MASK_STALL << ((ep_addr & TUSB_DIR_IN_MASK) ? 16 : 0));

 }

 

 bool dcd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const * p_endpoint_desc)

@@ -297,12 +252,12 @@ bool dcd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const * p_endpoint_desc)
   // TODO not support ISO yet

   TU_VERIFY ( p_endpoint_desc->bmAttributes.xfer != TUSB_XFER_ISOCHRONOUS);

 

-  tusb_dir_t dir = (p_endpoint_desc->bEndpointAddress & TUSB_DIR_IN_MASK) ? TUSB_DIR_IN : TUSB_DIR_OUT;

+  uint8_t const epnum  = edpt_number(p_endpoint_desc->bEndpointAddress);

+  uint8_t const dir    = edpt_dir(p_endpoint_desc->bEndpointAddress);

+  uint8_t const ep_idx = 2*epnum + dir;

 

   //------------- Prepare Queue Head -------------//

-  uint8_t ep_idx    = edpt_addr2phy(p_endpoint_desc->bEndpointAddress);

   dcd_qhd_t * p_qhd = &dcd_data_ptr[rhport]->qhd[ep_idx];

-

   tu_memclr(p_qhd, sizeof(dcd_qhd_t));

 

   p_qhd->zero_length_termination = 1;

@@ -310,105 +265,61 @@ bool dcd_edpt_open(uint8_t rhport, tusb_desc_endpoint_t const * p_endpoint_desc)
   p_qhd->qtd_overlay.next        = QTD_NEXT_INVALID;

 

   //------------- Endpoint Control Register -------------//

-  volatile uint32_t * reg_control = get_reg_control_addr(rhport, ep_idx);

+  volatile uint32_t * endpt_ctrl = get_endpt_ctrl_reg(rhport, ep_idx);

 

   // endpoint must not be already enabled

-  TU_VERIFY( !( (*reg_control) &  (ENDPTCTRL_MASK_ENABLE << (dir ? 16 : 0)) ) );

+  TU_VERIFY( !( (*endpt_ctrl) &  (ENDPTCTRL_MASK_ENABLE << (dir ? 16 : 0)) ) );

 

-  (*reg_control) |= ((p_endpoint_desc->bmAttributes.xfer << 2) | ENDPTCTRL_MASK_ENABLE | ENDPTCTRL_MASK_TOGGLE_RESET) << (dir ? 16 : 0);

+  (*endpt_ctrl) |= ((p_endpoint_desc->bmAttributes.xfer << 2) | ENDPTCTRL_MASK_ENABLE | ENDPTCTRL_MASK_TOGGLE_RESET) << (dir ? 16 : 0);

 

   return true;

 }

 

 bool dcd_edpt_busy(uint8_t rhport, uint8_t ep_addr)

 {

-  uint8_t ep_idx    = edpt_addr2phy(ep_addr);

+  uint8_t const epnum  = edpt_number(ep_addr);

+  uint8_t const dir    = edpt_dir(ep_addr);

+  uint8_t const ep_idx = 2*epnum + dir;

+

   dcd_qhd_t const * p_qhd = &dcd_data_ptr[rhport]->qhd[ep_idx];

+  dcd_qtd_t * p_qtd = &dcd_data_ptr[rhport]->qtd[ep_idx];

 

-  return p_qhd->list_qtd_idx[0] != 0; // qtd list is not empty

+  return p_qtd->active;

 //  return !p_qhd->qtd_overlay.halted && p_qhd->qtd_overlay.active;

 }

 

-// add only, controller virtually cannot know

-// TODO remove and merge to dcd_edpt_xfer

-static bool pipe_add_xfer(uint8_t rhport, uint8_t ed_idx, void * buffer, uint16_t total_bytes, bool int_on_complete)

+bool  dcd_edpt_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes)

 {

-  uint8_t qtd_idx  = qtd_find_free(rhport);

-  TU_ASSERT(qtd_idx != 0);

+  uint8_t const epnum = edpt_number(ep_addr);

+  uint8_t const dir   = edpt_dir(ep_addr);

+  uint8_t const ep_idx = 2*epnum + dir;

 

-  dcd_data_t* p_dcd = dcd_data_ptr[rhport];

-  dcd_qhd_t * p_qhd = &p_dcd->qhd[ed_idx];

-  dcd_qtd_t * p_qtd = &p_dcd->qtd[qtd_idx];

-

-  //------------- Find free slot in qhd's array list -------------//

-  uint8_t free_slot;

-  for(free_slot=0; free_slot < DCD_QTD_PER_QHD_MAX; free_slot++)

+  if ( epnum == 0 )

   {

-    if ( p_qhd->list_qtd_idx[free_slot] == 0 )  break; // found free slot

+    // follows UM 24.10.8.1.1 Setup packet handling using setup lockout mechanism

+    // wait until ENDPTSETUPSTAT before priming data/status in response TODO add time out

+    while(LPC_USB[rhport]->ENDPTSETUPSTAT & BIT_(0)) {}

   }

-  TU_ASSERT(free_slot < DCD_QTD_PER_QHD_MAX);

 

-  p_qhd->list_qtd_idx[free_slot] = qtd_idx; // add new qtd to qhd's array list

+  dcd_data_t* p_dcd = dcd_data_ptr[rhport];

+  dcd_qhd_t * p_qhd = &p_dcd->qhd[ep_idx];

+  dcd_qtd_t * p_qtd = &p_dcd->qtd[ep_idx];

 

   //------------- Prepare qtd -------------//

   qtd_init(p_qtd, buffer, total_bytes);

-  p_qtd->int_on_complete = int_on_complete;

+  p_qtd->int_on_complete = true;

+  p_qhd->qtd_overlay.next = (uint32_t) p_qtd; // link qtd to qhd

 

-  if ( free_slot > 0 ) p_dcd->qtd[ p_qhd->list_qtd_idx[free_slot-1] ].next = (uint32_t) p_qtd;

+  // start transfer

+  LPC_USB[rhport]->ENDPTPRIME = BIT_( ep_idx2bit(ep_idx) ) ;

 

   return true;

 }

 

-bool  dcd_edpt_xfer(uint8_t rhport, uint8_t ep_addr, uint8_t * buffer, uint16_t total_bytes)

-{

-  uint8_t ep_idx = edpt_addr2phy(ep_addr);

-

-  TU_VERIFY ( pipe_add_xfer(rhport, ep_idx, buffer, total_bytes, true) );

-

-  dcd_qhd_t* p_qhd = &dcd_data_ptr[rhport]->qhd[ ep_idx ];

-  dcd_qtd_t* p_qtd = &dcd_data_ptr[rhport]->qtd[ p_qhd->list_qtd_idx[0] ];

-

-  p_qhd->qtd_overlay.next = (uint32_t) p_qtd; // attach head QTD to QHD start transferring

-

-	LPC_USB[rhport]->ENDPTPRIME = BIT_( edpt_phy2pos(ep_idx) ) ;

-

-	return true;

-}

-

-//------------- Device Controller Driver's Interrupt Handler -------------//

-void xfer_complete_isr(uint8_t rhport, uint32_t reg_complete)

-{

-  for(uint8_t ep_idx = 2; ep_idx < DCD_QHD_MAX; ep_idx++)

-  {

-    if ( BIT_TEST_(reg_complete, edpt_phy2pos(ep_idx)) )

-    { // 23.10.12.3 Failed QTD also get ENDPTCOMPLETE set

-      dcd_qhd_t * p_qhd = &dcd_data_ptr[rhport]->qhd[ep_idx];

-

-      // retire all QTDs in array list, up to 1st still-active QTD

-      while( p_qhd->list_qtd_idx[0] != 0 )

-      {

-        dcd_qtd_t * p_qtd = &dcd_data_ptr[rhport]->qtd[ p_qhd->list_qtd_idx[0] ];

-

-        if (p_qtd->active)  break; // stop immediately if found still-active QTD and shift array list

-

-        //------------- Free QTD and shift array list -------------//

-        p_qtd->used = 0; // free QTD

-        memmove( (void*) p_qhd->list_qtd_idx, (void*) (p_qhd->list_qtd_idx+1), DCD_QTD_PER_QHD_MAX-1);

-        p_qhd->list_qtd_idx[DCD_QTD_PER_QHD_MAX-1]=0;

-

-        if (p_qtd->int_on_complete)

-        {

-          uint8_t result = p_qtd->halted  ? DCD_XFER_STALLED :

-                           ( p_qtd->xact_err ||p_qtd->buffer_err ) ? DCD_XFER_FAILED : DCD_XFER_SUCCESS;

-

-          uint8_t ep_addr = edpt_phy2addr(ep_idx);

-          dcd_event_xfer_complete(rhport, ep_addr, p_qtd->expected_bytes - p_qtd->total_bytes, result, true); // only number of bytes in the IOC qtd

-        }

-      }

-    }

-  }

-}

 

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

+// ISR

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

 void hal_dcd_isr(uint8_t rhport)

 {

   LPC_USB0_Type* const lpc_usb = LPC_USB[rhport];

@@ -457,9 +368,9 @@ void hal_dcd_isr(uint8_t rhport)
 

     dcd_data_t* const p_dcd = dcd_data_ptr[rhport];

 

-    //------------- Set up Received -------------//

     if (lpc_usb->ENDPTSETUPSTAT)

     {

+      //------------- Set up Received -------------//

       // 23.10.10.2 Operational model for setup transfers

       lpc_usb->ENDPTSETUPSTAT = lpc_usb->ENDPTSETUPSTAT;// acknowledge

 

@@ -469,28 +380,23 @@ void hal_dcd_isr(uint8_t rhport)
       dcd_event_handler(&event, true);

     }

 

-    //------------- Control Request Completed -------------//

-    else if ( edpt_complete & ( BIT_(0) | BIT_(16)) )

+    if ( edpt_complete )

     {

-      // determine Control OUT or IN

-      uint8_t ep_idx =  BIT_TEST_(edpt_complete, 0) ? 0 : 1;

-

-      // TODO use the actual QTD instead of the qhd's overlay to get expected bytes for actual byte xferred

-      dcd_qtd_t* const p_qtd =  (dcd_qtd_t*) p_dcd->qhd[ep_idx].qtd_addr;

-

-      if ( p_qtd->int_on_complete )

+      for(uint8_t ep_idx = 0; ep_idx < DCD_QHD_MAX; ep_idx++)

       {

-        uint8_t result = p_qtd->halted  ? DCD_XFER_STALLED :

-                        ( p_qtd->xact_err ||p_qtd->buffer_err ) ? DCD_XFER_FAILED : DCD_XFER_SUCCESS;

+        if ( BIT_TEST_(edpt_complete, ep_idx2bit(ep_idx)) )

+        {

+          // 23.10.12.3 Failed QTD also get ENDPTCOMPLETE set

+          dcd_qhd_t * p_qhd = &dcd_data_ptr[rhport]->qhd[ep_idx];

+          dcd_qtd_t * p_qtd = &dcd_data_ptr[rhport]->qtd[ep_idx];

 

-        dcd_event_xfer_complete(rhport, 0, p_qtd->expected_bytes - p_qtd->total_bytes, result, true);

-      }

-    }

+          uint8_t result = p_qtd->halted  ? XFER_RESULT_STALLED :

+              ( p_qtd->xact_err ||p_qtd->buffer_err ) ? XFER_RESULT_FAILED : XFER_RESULT_SUCCESS;

 

-    //------------- Transfer Complete -------------//

-    if ( edpt_complete & ~(BIT_(0) | BIT_(16)) )

-    {

-      xfer_complete_isr(rhport, edpt_complete);

+          uint8_t ep_addr = (ep_idx/2) | ( (ep_idx & 0x01) ? TUSB_DIR_IN_MASK : 0 );

+          dcd_event_xfer_complete(rhport, ep_addr, p_qtd->expected_bytes - p_qtd->total_bytes, result, true); // only number of bytes in the IOC qtd

+        }

+      }

     }

   }

 

@@ -504,7 +410,4 @@ void hal_dcd_isr(uint8_t rhport)
   if (int_status & INT_MASK_ERROR) TU_ASSERT(false, );

 }

 

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

-// HELPER

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

 #endif

diff --git a/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.h b/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.h
index 1476c0d30..85334a34d 100644
--- a/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.h
+++ b/src/portable/nxp/lpc43xx_lpc18xx/dcd_lpc43xx.h
@@ -54,7 +54,6 @@
 //--------------------------------------------------------------------+

 #define DCD_QHD_MAX 12

 #define DCD_QTD_MAX 12

-#define DCD_QTD_PER_QHD_MAX 2 // maximum number of qtd that are linked into one queue head at a time

 

 #define QTD_NEXT_INVALID 0x01

 

@@ -91,7 +90,6 @@ enum {
   PORTSC_CURRENT_CONNECT_STATUS_MASK = BIT_(0),

   PORTSC_FORCE_PORT_RESUME_MASK      = BIT_(6),

   PORTSC_SUSPEND_MASK                = BIT_(7)

-

 };

 

 typedef struct

@@ -118,8 +116,7 @@ typedef struct
 

   //------------- DCD Area -------------//

   uint16_t expected_bytes;

-  uint8_t used;

-  uint8_t reserved;

+  uint8_t reserved[2];

 } dcd_qtd_t;

 

 TU_VERIFY_STATIC( sizeof(dcd_qtd_t) == 32, "size is not correct");

@@ -148,9 +145,7 @@ typedef struct
   /// Due to the fact QHD is 64 bytes aligned but occupies only 48 bytes

 	/// thus there are 16 bytes padding free that we can make use of.

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

-  volatile uint8_t list_qtd_idx[DCD_QTD_PER_QHD_MAX];

-

-	uint8_t reserved[16-DCD_QTD_PER_QHD_MAX];

+	uint8_t reserved[16];

 }  dcd_qhd_t;

 

 TU_VERIFY_STATIC( sizeof(dcd_qhd_t) == 64, "size is not correct");

diff --git a/src/tusb_option.h b/src/tusb_option.h
index f19ff4076..18e1e245e 100644
--- a/src/tusb_option.h
+++ b/src/tusb_option.h
@@ -131,8 +131,9 @@
   #warning CFG_TUSB_DEBUG is not defined, default value is 0

 #endif

 

-#ifndef CFG_TUSB_ATTR_USBRAM

- #error CFG_TUSB_ATTR_USBRAM is not defined, please help me know how to place data in accessible RAM for usb controller

+// place data in accessible RAM for usb controller

+#ifndef CFG_TUSB_MEM_SECTION

+#define CFG_TUSB_MEM_SECTION

 #endif

 

 #ifndef CFG_TUSB_OS