refine ASSERT_DEFINE to allow special error_handler for os task

add device_addr0 for enumeration task
start to add osal port for freeRTOS

tests/project.yml

@@ -34,6 +34,8 @@
     - -:../test_old
     #- ../../CMSISv2p10_LPC13Uxx/**
     - ../../CMSISv2p10_LPC43xx_DriverLib/inc
+#    - ../../../os/FreeRTOSV7.3.0/FreeRTOS/Source/**
+#    - -:../../../os/FreeRTOSV7.3.0/FreeRTOS/Source/portable/**
   :support:
     - test/support
 

tests/test/host/test_usbd_host.c

@@ -121,7 +121,7 @@ extern osal_queue_handle_t enum_queue_hdl;
 usbh_enumerate_t enum_connect =
 {
     .core_id = 0,
-    .hub_address = 0,
+    .hub_addr = 0,
     .hub_port = 0,
     .connect_status = 1
 };

tests/test/support/tusb_config.h

@@ -89,17 +89,7 @@
 
 #define TUSB_CFG_OS TUSB_OS_NONE
 #define TUSB_CFG_OS_TICKS_PER_SECOND 1000 // 1 ms tick
-
-#ifdef __CODE_RED // make use of code red's support for ram region macros
-  #if (MCU == MCU_LPC11UXX) || (MCU == MCU_LPC13UXX)
-    #define TUSB_RAM_SECTION  ".data.$RAM2"
-  #elif  (MCU == MCU_LPC43XX)
-    #define TUSB_RAM_SECTION  ".data.$RAM3"
-  #endif
-
-  #define TUSB_CFG_ATTR_USBRAM   __attribute__ ((section(TUSB_RAM_SECTION)))
-#endif
-
+#define TUSB_CFG_ATTR_USBRAM
 
 #ifdef __cplusplus
  }

tinyusb/common/assertion.h

@@ -68,23 +68,23 @@ extern "C"
 //--------------------------------------------------------------------+
 // Assert Helper
 //--------------------------------------------------------------------+
-#define ASSERT_FILENAME  __FILE__
-#define ASSERT_FUNCTION  __PRETTY_FUNCTION__
 #define ASSERT_MESSAGE(format, ...)\
-    _PRINTF("Assert at %s: %s:%d: " format "\n", ASSERT_FILENAME, ASSERT_FUNCTION, __LINE__, __VA_ARGS__)
+    _PRINTF("Assert at %s: %s:%d: " format "\n", __FILE__, __PRETTY_FUNCTION__, __LINE__, __VA_ARGS__)
 
 #ifndef _TEST_ASSERT_
-  #define ASSERT_ERROR_HANDLE(x)  return (x)
+  #define ASSERT_ERROR_HANDLER(x)  return (x)
 #else
-  #define ASSERT_ERROR_HANDLE(x)  Throw(x)
+  #define ASSERT_ERROR_HANDLER(x)  Throw(x)
 #endif
 
-#define ASSERT_DEFINE(setup_statement, condition, error, format, ...) \
+#define ASSERT_DEFINE(...) ASSERT_DEFINE_WITH_HANDLER(ASSERT_ERROR_HANDLER, __VA_ARGS__)
+
+#define ASSERT_DEFINE_WITH_HANDLER(error_handler, setup_statement, condition, error, format, ...) \
   do{\
     setup_statement;\
 	  if (!(condition)) {\
 	    ASSERT_MESSAGE(format, __VA_ARGS__);\
-	    ASSERT_ERROR_HANDLE(error);\
+	    error_handler(error);\
 	  }\
 	}while(0)
 

tinyusb/host/hcd.h

@@ -56,6 +56,7 @@
 #endif
 
 #include "common/common.h"
+//#include "usbd_host.h"
 
 typedef uint32_t pipe_handle_t;
 
@@ -65,11 +66,12 @@ tusb_error_t hcd_init(uint8_t hostid) ATTR_WARN_UNUSED_RESULT;
 //--------------------------------------------------------------------+
 // PIPE API
 //--------------------------------------------------------------------+
+//pipe_handle_t hcd_pipe_addr0_open(usbh_device_addr0_t const * dev_addr0);
 pipe_handle_t hcd_pipe_addr0_open(uint8_t core_id, tusb_speed_t speed, uint8_t hub_addr, uint8_t hub_port);
 
 pipe_handle_t hcd_pipe_control_open(uint8_t dev_addr, uint8_t max_packet_size);
-tusb_error_t  hcd_pipe_control_xfer(pipe_handle_t pipe_hdl, const tusb_std_request_t * const p_request, uint8_t data[]);
-pipe_handle_t hcd_pipe_open(uint8_t dev_addr, tusb_descriptor_endpoint_t* endpoint_desc);
+tusb_error_t  hcd_pipe_control_xfer(pipe_handle_t pipe_hdl, tusb_std_request_t const * p_request, uint8_t data[]);
+pipe_handle_t hcd_pipe_open(uint8_t dev_addr, tusb_descriptor_endpoint_t const * endpoint_desc);
 
 #if 0
 //tusb_error_t hcd_pipe_open(

tinyusb/host/usbd_host.c

@@ -56,11 +56,6 @@
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
-struct {
-  tusb_speed_t speed;
-  uint8_t hub_addr;
-  uint8_t hub_port;
-} usbh_device_addr0[TUSB_CFG_HOST_CONTROLLER_NUM];
 
 STATIC_ usbh_device_info_t device_info_pool[TUSB_CFG_HOST_DEVICE_MAX];
 
@@ -81,39 +76,38 @@ OSAL_TASK_DEF(enum_task, usbh_enumeration_task, 128, OSAL_PRIO_HIGH);
 #define ENUM_QUEUE_DEPTH  5
 OSAL_DEF_QUEUE(enum_queue, ENUM_QUEUE_DEPTH, uin32_t);
 osal_queue_handle_t enum_queue_hdl;
+usbh_device_addr0_t device_addr0 TUSB_CFG_ATTR_USBRAM;
 
 void usbh_enumeration_task(void)
 {
-  usbh_enumerate_t enum_item;
   tusb_error_t error;
 
   OSAL_TASK_LOOP_BEGIN
 
-  osal_queue_receive(enum_queue_hdl, (uint32_t*)&enum_item, OSAL_TIMEOUT_NORMAL, &error);
+  osal_queue_receive(enum_queue_hdl, (uint32_t*)(&device_addr0.enum_entry), OSAL_TIMEOUT_NORMAL, &error);
   TASK_ASSERT_STATUS(error);
 
-  if (enum_item.hub_address == 0) // direct connection
+  if (device_addr0.enum_entry.hub_addr == 0) // direct connection
   {
-    if ( enum_item.connect_status == hcd_port_connect_status(enum_item.core_id) ) // there chances the event is out-dated
+    TASK_ASSERT(device_addr0.enum_entry.connect_status == hcd_port_connect_status(device_addr0.enum_entry.core_id)); // there chances the event is out-dated
+
+    tusb_std_request_t request_dev_desc =
     {
-      tusb_std_request_t request_dev_desc =
-      {
-          .bmRequestType =
-          {
-              .direction = TUSB_DIR_DEV_TO_HOST,
-              .type      = TUSB_REQUEST_TYPE_STANDARD,
-              .recipient = TUSB_REQUEST_RECIPIENT_DEVICE
-          },
-
-          .bRequest = TUSB_REQUEST_GET_DESCRIPTOR,
-          .wValue   = (TUSB_DESC_DEVICE << 8),
-          .wLength  = 8
-      };
-      tusb_speed_t speed = hcd_port_speed(enum_item.core_id);
-      pipe_handle_t pipe_addr0 = hcd_pipe_addr0_open(enum_item.core_id, speed, enum_item.hub_address, enum_item.hub_port);
+        .bmRequestType =
+        {
+            .direction = TUSB_DIR_DEV_TO_HOST,
+            .type      = TUSB_REQUEST_TYPE_STANDARD,
+            .recipient = TUSB_REQUEST_RECIPIENT_DEVICE
+        },
+
+        .bRequest = TUSB_REQUEST_GET_DESCRIPTOR,
+        .wValue   = (TUSB_DESC_DEVICE << 8),
+        .wLength  = 8
+    };
+    device_addr0.speed = hcd_port_speed(device_addr0.enum_entry.core_id);
+//    pipe_handle_t pipe_addr0 = hcd_pipe_addr0_open(&device_addr0);
 
       //        hcd_pipe_control_xfer(pipe_addr0, &request_dev_desc)
-    }
   }else // device connect via a hub
   {
     ASSERT_MESSAGE("%s", "Hub is not supported yet");
@@ -122,6 +116,11 @@ void usbh_enumeration_task(void)
   OSAL_TASK_LOOP_END
 }
 
+//--------------------------------------------------------------------+
+// REPORTER TASK & ITS DATA
+//--------------------------------------------------------------------+
+
+
 //--------------------------------------------------------------------+
 // CLASS-USBD API (don't require to verify parameters)
 //--------------------------------------------------------------------+

tinyusb/host/usbd_host.h

@@ -58,6 +58,7 @@
 //--------------------------------------------------------------------+
 // INCLUDE
 //--------------------------------------------------------------------+
+#include "common/common.h"
 #include "hcd.h"
 
 //--------------------------------------------------------------------+
@@ -143,11 +144,17 @@ typedef uint32_t tusb_handle_device_t;
 
 typedef struct ATTR_ALIGNED(4){
   uint8_t core_id;
-  uint8_t hub_address;
+  uint8_t hub_addr;
   uint8_t hub_port;
   uint8_t connect_status;
 } usbh_enumerate_t;
 
+typedef struct {
+  usbh_enumerate_t enum_entry;
+  tusb_speed_t speed;
+  tusb_std_request_t request_packet; // needed to be on USB RAM
+} usbh_device_addr0_t;
+
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
@@ -160,6 +167,12 @@ void         tusbh_device_mounted_cb (tusb_error_t const error, tusb_handle_devi
 tusb_error_t tusbh_configuration_set     (tusb_handle_device_t const device_hdl, uint8_t const configure_number) ATTR_WARN_UNUSED_RESULT;
 tusbh_device_status_t tusbh_device_status_get (tusb_handle_device_t const device_hdl) ATTR_WARN_UNUSED_RESULT;
 
+static inline void tusb_tick_tock(void) ATTR_ALWAYS_INLINE;
+static inline void tusb_tick_tock(void)
+{
+  osal_tick_tock();
+}
+
 
 //--------------------------------------------------------------------+
 // CLASS-USBD API

tinyusb/osal/osal.h

@@ -84,10 +84,12 @@ typedef uint32_t osal_task_t;
 
 #define OSAL_TASK_LOOP_BEGIN
 #define OSAL_TASK_LOOP_END
+
+
 #define TASK_ASSERT_STATUS(sts) \
     ASSERT_DEFINE(tusb_error_t status = (tusb_error_t)(sts),\
                   TUSB_ERROR_NONE == status, (void) 0, "%s", TUSB_ErrorStr[status])
-
+#define TASK_ASSERT(condition)  ASSERT(condition, (void) 0)
 
 tusb_error_t osal_task_create(osal_task_t *task);
 

tinyusb/osal/osal_freeRTOS.h

@@ -0,0 +1,89 @@
+/*
+ * osal_freeRTOS.h
+ *
+ *  Created on: Feb 2, 2013
+ *      Author: hathach
+ */
+
+/*
+ * Software License Agreement (BSD License)
+ * Copyright (c) 2012, hathach (tinyusb.net)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the tiny usb stack.
+ */
+
+/** \file
+ *  \brief TBD
+ *
+ *  \note TBD
+ */
+
+/** \ingroup TBD
+ *  \defgroup TBD
+ *  \brief TBD
+ *
+ *  @{
+ */
+
+#ifndef _TUSB_OSAL_FREERTOS_H_
+#define _TUSB_OSAL_FREERTOS_H_
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#include "osal_common.h"
+#include "FreeRTOS.h"
+
+//--------------------------------------------------------------------+
+// TICK API
+//--------------------------------------------------------------------+
+#define osal_tick_get xTaskGetTickCount
+
+//--------------------------------------------------------------------+
+// TASK API
+//--------------------------------------------------------------------+
+#define OSAL_TASK_LOOP_BEGIN \
+  while(1) {
+
+#define OSAL_TASK_LOOP_END \
+  }
+
+#define TASK_ASSERT(condition)
+#define TASK_ASSERT_STATUS(sts)
+
+//--------------------------------------------------------------------+
+// Semaphore API
+//--------------------------------------------------------------------+
+
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif /* _TUSB_OSAL_FREERTOS_H_ */
+
+/** @} */

tinyusb/osal/osal_none.h

@@ -90,19 +90,12 @@ uint32_t osal_tick_get(void);
     state = 0;\
   }
 
-#define TASK_ASSERT_DEFINE(setup_statement, condition, error, format, ...) \
-  do{\
-    setup_statement;\
-	  if (!(condition)) {\
-	    ASSERT_MESSAGE(format, __VA_ARGS__);\
-	    state = 0; /* reset task loop */\
-	    break;\
-	  }\
-	}while(0)
-
-#define TASK_ASSERT(condition, error)  TASK_ASSERT_DEFINE( , (condition), error, "%s", "evaluated to false")
+#define TASK_ASSERT_ERROR_HANDLER \
+  state = 0; break;
+
+#define TASK_ASSERT(condition)  ASSERT_DEFINE_WITH_HANDLER(TASK_ASSERT_ERROR_HANDLER, , (condition), (void) 0, "%s", "evaluated to false")
 #define TASK_ASSERT_STATUS(sts) \
-    TASK_ASSERT_DEFINE(tusb_error_t status = (tusb_error_t)(sts),\
+    ASSERT_DEFINE_WITH_HANDLER(TASK_ASSERT_ERROR_HANDLER, tusb_error_t status = (tusb_error_t)(sts),\
                   TUSB_ERROR_NONE == status, status, "%s", TUSB_ErrorStr[status])
 //--------------------------------------------------------------------+
 // Semaphore API