Merge pull request #20 from hathach/devlocal

Host stack rework

4 files changed, 92 insertions, 122 deletions

diff --git a/src/class/cdc/cdc_device.c b/src/class/cdc/cdc_device.c
index 040c8d4f4..d477a0d23 100644
--- a/src/class/cdc/cdc_device.c
+++ b/src/class/cdc/cdc_device.c
@@ -41,9 +41,7 @@
 #if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_CDC)

 

 #define _TINY_USB_SOURCE_FILE_

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

-// INCLUDE

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

+

 #include "cdc_device.h"

 #include "device/usbd_pvt.h"

 

@@ -236,8 +234,7 @@ tusb_error_t cdcd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface
   if ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL != p_interface_desc->bInterfaceSubClass) return TUSB_ERROR_CDC_UNSUPPORTED_SUBCLASS;

 

   // Only support AT commands, no protocol and vendor specific commands.

-  if ( !(tu_within(CDC_COMM_PROTOCOL_ATCOMMAND, p_interface_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||

-         p_interface_desc->bInterfaceProtocol == CDC_COMM_PROTOCOL_NONE ||

+  if ( !(tu_within(CDC_COMM_PROTOCOL_NONE, p_interface_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||

          p_interface_desc->bInterfaceProtocol == 0xff ) )

   {

     return TUSB_ERROR_CDC_UNSUPPORTED_PROTOCOL;

diff --git a/src/class/cdc/cdc_host.c b/src/class/cdc/cdc_host.c
index 0a3661878..159a13990 100644
--- a/src/class/cdc/cdc_host.c
+++ b/src/class/cdc/cdc_host.c
@@ -38,100 +38,92 @@
 

 #include "tusb_option.h"

 

-#if (MODE_HOST_SUPPORTED && CFG_TUSB_HOST_CDC)

+#if (TUSB_OPT_HOST_ENABLED && CFG_TUH_CDC)

 

 #define _TINY_USB_SOURCE_FILE_

 

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

-// INCLUDE

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

 #include "common/tusb_common.h"

 #include "cdc_host.h"

 

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

 // MACRO CONSTANT TYPEDEF

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

+typedef struct {

+  uint8_t itf_num;

+  uint8_t itf_protocol;

 

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

-// INTERNAL OBJECT & FUNCTION DECLARATION

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

-STATIC_VAR cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX]; // TODO to be static

+  uint8_t ep_notif;

+  uint8_t ep_in;

+  uint8_t ep_out;

 

-static inline cdc_pipeid_t get_app_pipeid(pipe_handle_t pipe_hdl)

-{

-  cdch_data_t const * p_cdc = &cdch_data[pipe_hdl.dev_addr-1];

+  cdc_acm_capability_t acm_capability;

 

-  return pipehandle_is_equal( pipe_hdl, p_cdc->pipe_notification ) ? CDC_PIPE_NOTIFICATION :

-         pipehandle_is_equal( pipe_hdl, p_cdc->pipe_in           ) ? CDC_PIPE_DATA_IN      :

-         pipehandle_is_equal( pipe_hdl, p_cdc->pipe_out          ) ? CDC_PIPE_DATA_OUT     : CDC_PIPE_ERROR;

-}

+} cdch_data_t;

 

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

+// INTERNAL OBJECT & FUNCTION DECLARATION

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

+static cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX];

 

-static inline bool tusbh_cdc_is_mounted(uint8_t dev_addr)

+bool tuh_cdc_mounted(uint8_t dev_addr)

 {

-// FIXME cannot use mounted class flag as at the point _open_sublass is called, the flag is not set yet

-#ifdef _TEST_

- return (tusbh_device_get_mounted_class_flag(dev_addr) & BIT_(TUSB_CLASS_CDC)) != 0;

-#else

-  return pipehandle_is_valid(cdch_data[dev_addr-1].pipe_in) &&

-      pipehandle_is_valid(cdch_data[dev_addr-1].pipe_out);

-#endif

+  cdch_data_t* cdc = &cdch_data[dev_addr-1];

+  return cdc->ep_in && cdc->ep_out;

 }

 

 bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)

 {

-  if ( !tusbh_cdc_is_mounted(dev_addr) ) return false;

+  if ( !tuh_cdc_mounted(dev_addr) ) return false;

 

   cdch_data_t const * p_cdc = &cdch_data[dev_addr-1];

 

   switch (pipeid)

   {

     case CDC_PIPE_NOTIFICATION:

-      return hcd_pipe_is_busy( p_cdc->pipe_notification );

+      return hcd_edpt_busy(dev_addr, p_cdc->ep_notif );

 

     case CDC_PIPE_DATA_IN:

-      return hcd_pipe_is_busy( p_cdc->pipe_in );

+      return hcd_edpt_busy(dev_addr, p_cdc->ep_in );

 

     case CDC_PIPE_DATA_OUT:

-      return hcd_pipe_is_busy( p_cdc->pipe_out );

+      return hcd_edpt_busy(dev_addr, p_cdc->ep_out );

 

     default:

       return false;

   }

 }

 

-

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

 // APPLICATION API (parameter validation needed)

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

 bool tuh_cdc_serial_is_mounted(uint8_t dev_addr)

 {

   // TODO consider all AT Command as serial candidate

-  return tusbh_cdc_is_mounted(dev_addr)                                         &&

-      (CDC_COMM_PROTOCOL_ATCOMMAND <= cdch_data[dev_addr-1].interface_protocol) &&

-      (cdch_data[dev_addr-1].interface_protocol <= CDC_COMM_PROTOCOL_ATCOMMAND_CDMA);

+  return tuh_cdc_mounted(dev_addr)                                         &&

+      (CDC_COMM_PROTOCOL_ATCOMMAND <= cdch_data[dev_addr-1].itf_protocol) &&

+      (cdch_data[dev_addr-1].itf_protocol <= CDC_COMM_PROTOCOL_ATCOMMAND_CDMA);

 }

 

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

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

 {

-  TU_ASSERT( tusbh_cdc_is_mounted(dev_addr),  TUSB_ERROR_CDCH_DEVICE_NOT_MOUNTED);

-  TU_ASSERT( p_data != NULL && length, TUSB_ERROR_INVALID_PARA);

+  TU_VERIFY( tuh_cdc_mounted(dev_addr) );

+  TU_VERIFY( p_data != NULL && length, TUSB_ERROR_INVALID_PARA);

 

-  pipe_handle_t pipe_out = cdch_data[dev_addr-1].pipe_out;

-  if ( hcd_pipe_is_busy(pipe_out) ) return TUSB_ERROR_INTERFACE_IS_BUSY;

+  uint8_t const ep_out = cdch_data[dev_addr-1].ep_out;

+  if ( hcd_edpt_busy(dev_addr, ep_out) ) return false;

 

-  return hcd_pipe_xfer( pipe_out, (void *) p_data, length, is_notify);

+  return hcd_pipe_xfer(dev_addr, ep_out, (void *) p_data, length, is_notify);

 }

 

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

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

 {

-  TU_ASSERT( tusbh_cdc_is_mounted(dev_addr),  TUSB_ERROR_CDCH_DEVICE_NOT_MOUNTED);

-  TU_ASSERT( p_buffer != NULL && length, TUSB_ERROR_INVALID_PARA);

+  TU_VERIFY( tuh_cdc_mounted(dev_addr) );

+  TU_VERIFY( p_buffer != NULL && length, TUSB_ERROR_INVALID_PARA);

 

-  pipe_handle_t pipe_in = cdch_data[dev_addr-1].pipe_in;

-  if ( hcd_pipe_is_busy(pipe_in) ) return TUSB_ERROR_INTERFACE_IS_BUSY;

+  uint8_t const ep_in = cdch_data[dev_addr-1].ep_in;

+  if ( hcd_edpt_busy(dev_addr, ep_in) ) return false;

 

-  return hcd_pipe_xfer( pipe_in, p_buffer, length, is_notify);

+  return hcd_pipe_xfer(dev_addr, ep_in, p_buffer, length, is_notify);

 }

 

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

@@ -142,35 +134,33 @@ void cdch_init(void)
   tu_memclr(cdch_data, sizeof(cdch_data_t)*CFG_TUSB_HOST_DEVICE_MAX);

 }

 

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

+bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length)

 {

-  OSAL_SUBTASK_BEGIN

-  // TODO change following assert to subtask_assert

-

-  if ( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL != p_interface_desc->bInterfaceSubClass) return TUSB_ERROR_CDC_UNSUPPORTED_SUBCLASS;

+  // Only support ACM

+  TU_VERIFY( CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL == itf_desc->bInterfaceSubClass);

 

-  if ( !(tu_within(CDC_COMM_PROTOCOL_ATCOMMAND, p_interface_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||

-         0xff == p_interface_desc->bInterfaceProtocol) )

-  {

-    return TUSB_ERROR_CDC_UNSUPPORTED_PROTOCOL;

-  }

+  // Only support AT commands, no protocol and vendor specific commands.

+  TU_VERIFY(tu_within(CDC_COMM_PROTOCOL_NONE, itf_desc->bInterfaceProtocol, CDC_COMM_PROTOCOL_ATCOMMAND_CDMA) ||

+            0xff == itf_desc->bInterfaceProtocol);

 

   uint8_t const * p_desc;

   cdch_data_t * p_cdc;

 

-  p_desc = descriptor_next ( (uint8_t const *) p_interface_desc );

-  p_cdc  = &cdch_data[dev_addr-1]; // non-static variable cannot be used after OS service call

+  p_desc = descriptor_next ( (uint8_t const *) itf_desc );

+  p_cdc  = &cdch_data[dev_addr-1];

 

-  p_cdc->interface_number   = p_interface_desc->bInterfaceNumber;

-  p_cdc->interface_protocol = p_interface_desc->bInterfaceProtocol; // TODO 0xff is consider as rndis candidate, other is virtual Com

+  p_cdc->itf_num   = itf_desc->bInterfaceNumber;

+  p_cdc->itf_protocol = itf_desc->bInterfaceProtocol; // TODO 0xff is consider as rndis candidate, other is virtual Com

 

   //------------- Communication Interface -------------//

   (*p_length) = sizeof(tusb_desc_interface_t);

 

+  // Communication Functional Descriptors

   while( TUSB_DESC_CLASS_SPECIFIC == p_desc[DESC_OFFSET_TYPE] )

-  { // Communication Functional Descriptors

+  {

     if ( CDC_FUNC_DESC_ABSTRACT_CONTROL_MANAGEMENT == cdc_functional_desc_typeof(p_desc) )

-    { // save ACM bmCapabilities

+    {

+      // save ACM bmCapabilities

       p_cdc->acm_capability = ((cdc_desc_func_acm_t const *) p_desc)->bmCapabilities;

     }

 

@@ -179,18 +169,20 @@ tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
   }

 

   if ( TUSB_DESC_ENDPOINT == p_desc[DESC_OFFSET_TYPE])

-  { // notification endpoint if any

-    p_cdc->pipe_notification = hcd_pipe_open(dev_addr, (tusb_desc_endpoint_t const *) p_desc, TUSB_CLASS_CDC);

+  {

+    // notification endpoint

+    tusb_desc_endpoint_t const * ep_desc = (tusb_desc_endpoint_t const *) p_desc;

+

+    TU_ASSERT( hcd_edpt_open(rhport, dev_addr, ep_desc) );

+    p_cdc->ep_notif = ep_desc->bEndpointAddress;

 

     (*p_length) += p_desc[DESC_OFFSET_LEN];

     p_desc = descriptor_next(p_desc);

-

-    TU_ASSERT(pipehandle_is_valid(p_cdc->pipe_notification), TUSB_ERROR_HCD_OPEN_PIPE_FAILED);

   }

 

   //------------- Data Interface (if any) -------------//

   if ( (TUSB_DESC_INTERFACE == p_desc[DESC_OFFSET_TYPE]) &&

-       (TUSB_CLASS_CDC_DATA      == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass) )

+       (TUSB_CLASS_CDC_DATA == ((tusb_desc_interface_t const *) p_desc)->bInterfaceClass) )

   {

     (*p_length) += p_desc[DESC_OFFSET_LEN];

     p_desc = descriptor_next(p_desc);

@@ -198,46 +190,50 @@ tusb_error_t cdch_open_subtask(uint8_t dev_addr, tusb_desc_interface_t const *p_
     // data endpoints expected to be in pairs

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

     {

-      tusb_desc_endpoint_t const *p_endpoint = (tusb_desc_endpoint_t const *) p_desc;

-      TU_ASSERT(TUSB_DESC_ENDPOINT == p_endpoint->bDescriptorType, TUSB_ERROR_USBH_DESCRIPTOR_CORRUPTED);

-      TU_ASSERT(TUSB_XFER_BULK == p_endpoint->bmAttributes.xfer, TUSB_ERROR_USBH_DESCRIPTOR_CORRUPTED);

+      tusb_desc_endpoint_t const *ep_desc = (tusb_desc_endpoint_t const *) p_desc;

+      TU_ASSERT(TUSB_DESC_ENDPOINT == ep_desc->bDescriptorType);

+      TU_ASSERT(TUSB_XFER_BULK == ep_desc->bmAttributes.xfer);

 

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

-          &p_cdc->pipe_in : &p_cdc->pipe_out;

+      TU_ASSERT(hcd_edpt_open(rhport, dev_addr, ep_desc));

 

-      (*p_pipe_hdl) = hcd_pipe_open(dev_addr, p_endpoint, TUSB_CLASS_CDC);

-      TU_ASSERT ( pipehandle_is_valid(*p_pipe_hdl), TUSB_ERROR_HCD_OPEN_PIPE_FAILED );

+      if ( edpt_dir(ep_desc->bEndpointAddress) ==  TUSB_DIR_IN )

+      {

+        p_cdc->ep_in = ep_desc->bEndpointAddress;

+      }else

+      {

+        p_cdc->ep_out = ep_desc->bEndpointAddress;

+      }

 

       (*p_length) += p_desc[DESC_OFFSET_LEN];

       p_desc = descriptor_next( p_desc );

     }

   }

 

+  // FIXME move to seperate API : connect

+  tusb_control_request_t request =

   {

-    // FIXME mounted class flag is not set yet

-    tuh_cdc_mounted_cb(dev_addr);

-  }

+    .bmRequestType_bit = { .recipient = TUSB_REQ_RCPT_INTERFACE, .type = TUSB_REQ_TYPE_CLASS, .direction = TUSB_DIR_OUT },

+    .bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE,

+    .wValue = 0x03, // dtr on, cst on

+    .wIndex = p_cdc->itf_num,

+    .wLength = 0

+  };

+

+  TU_ASSERT( usbh_control_xfer(dev_addr, &request, NULL) );

 

-  OSAL_SUBTASK_END

+  return true;

 }

 

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

+void cdch_isr(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)

 {

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

+  (void) ep_addr;

+  tuh_cdc_xfer_isr( dev_addr, event, 0, xferred_bytes );

 }

 

 void cdch_close(uint8_t dev_addr)

 {

   cdch_data_t * p_cdc = &cdch_data[dev_addr-1];

-

-  (void) hcd_pipe_close(p_cdc->pipe_notification);

-  (void) hcd_pipe_close(p_cdc->pipe_in);

-  (void) hcd_pipe_close(p_cdc->pipe_out);

-

   tu_memclr(p_cdc, sizeof(cdch_data_t));

-

-  tuh_cdc_unmounted_cb(dev_addr);

-

 }

 

 #endif

diff --git a/src/class/cdc/cdc_host.h b/src/class/cdc/cdc_host.h
index 0b863bb61..5388a8f60 100644
--- a/src/class/cdc/cdc_host.h
+++ b/src/class/cdc/cdc_host.h
@@ -62,7 +62,7 @@
  * \retval      true if device supports

  * \retval      false if device does not support or is not mounted

  */

-bool tuh_cdc_serial_is_mounted(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;

+bool tuh_cdc_serial_is_mounted(uint8_t dev_addr);

 

 /** \brief      Check if the interface is currently busy or not

  * \param[in]   dev_addr device address

@@ -73,7 +73,7 @@ bool tuh_cdc_serial_is_mounted(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESU
  *              can be scheduled. User needs to make sure the corresponding interface is mounted

  *              (by \ref tuh_cdc_serial_is_mounted) before calling this function.

  */

-bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)  ATTR_PURE ATTR_WARN_UNUSED_RESULT;

+bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid);

 

 /** \brief 			Perform USB OUT transfer to device

  * \param[in]		dev_addr	device address

@@ -86,7 +86,7 @@ bool tuh_cdc_is_busy(uint8_t dev_addr, cdc_pipeid_t pipeid)  ATTR_PURE ATTR_WARN
  * \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_MEM_SECTION.

  */

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

+bool 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

@@ -99,22 +99,11 @@ tusb_error_t tuh_cdc_send(uint8_t dev_addr, void const * p_data, uint32_t length
  * \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_MEM_SECTION.

  */

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

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

 

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

 // CDC APPLICATION CALLBACKS

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

-/** \brief 			Callback function that will be invoked when a device with CDC Abstract Control Model interface is mounted

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

- * \note        This callback should be used by Application to set-up interface-related data

- */

-void tuh_cdc_mounted_cb(uint8_t dev_addr);

-

-/** \brief 			Callback function that will be invoked when a device with CDC Abstract Control Model interface is unmounted

- * \param[in] 	dev_addr Address of newly unmounted device

- * \note        This callback should be used by Application to tear-down interface-related data

- */

-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

@@ -137,22 +126,10 @@ void tuh_cdc_xfer_isr(uint8_t dev_addr, xfer_result_t event, cdc_pipeid_t pipe_i
 //--------------------------------------------------------------------+

 #ifdef _TINY_USB_SOURCE_FILE_

 

-typedef struct {

-  uint8_t interface_number;

-  uint8_t interface_protocol;

-

-  cdc_acm_capability_t acm_capability;

-

-  pipe_handle_t pipe_notification, pipe_out, pipe_in;

-

-} cdch_data_t;

-

-extern cdch_data_t cdch_data[CFG_TUSB_HOST_DEVICE_MAX]; // TODO consider to move to cdch internal header file

-

-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, xfer_result_t event, uint32_t xferred_bytes);

-void         cdch_close(uint8_t dev_addr);

+void cdch_init(void);

+bool cdch_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *itf_desc, uint16_t *p_length);

+void cdch_isr(uint8_t dev_addr, uint8_t ep_addr, 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 89ea3b32f..ae61bf8b5 100644
--- a/src/class/cdc/cdc_rndis_host.c
+++ b/src/class/cdc/cdc_rndis_host.c
@@ -38,7 +38,7 @@
 
 #include "tusb_option.h"
 
-#if (MODE_HOST_SUPPORTED && CFG_TUSB_HOST_CDC && CFG_TUSB_HOST_CDC_RNDIS)
+#if (TUSB_OPT_HOST_ENABLED && CFG_TUH_CDC && CFG_TUH_CDC_RNDIS)
 
 #define _TINY_USB_SOURCE_FILE_