osal clean up

remove OSAL_TASK_DEF, osal_task_create. Applicaton should create a task
and call tinyusb_task(). This make API consistent with NO OS.

docs/configuration.txt

@@ -20,7 +20,6 @@
 
 #define CFG_TUSB_MCU          ///< Select one of the supported MCU, the value must be from \ref group_mcu
 #define CFG_TUSB_OS           ///< Select one of the supported RTOS, the value must be from \ref group_supported_os.
-#define CFG_TUD_TASK_PRIO ///< If \ref CFG_TUSB_OS is configured to use a real RTOS (other than OPT_OS_NONE). This determines the priority of the usb stack task.
 
 //--------------------------------------------------------------------+
 // HOST CONFIGURATION

docs/getting_started.md

@@ -37,7 +37,7 @@ It is relatively simple to incorporate tinyusb to your (existing) project
 1. Copy or `git submodule` this repo into your project in a subfolder. Let's say it is *your_project/tinyusb*
 2. Add all the .c in the src folder to your project settings (uvproj, ewp, makefile)
 3. Add *your_project/tinysb* to your include path. Also make sure your current include path also contains the configuration file tusb_config.h. Or you could simply put the tusb_config.h into the tinyusb folder as well.
-4. Make sure all required macros are all defined properly in tusb_config.h (configure file in demo application is sufficient, but you need to add a few more such as CFG_TUSB_MCU, CFG_TUSB_OS, CFG_TUD_TASK_PRIO since they are passed by IDE/compiler to maintain a unique configure for all demo projects).
+4. Make sure all required macros are all defined properly in tusb_config.h (configure file in demo application is sufficient, but you need to add a few more such as CFG_TUSB_MCU, CFG_TUSB_OS since they are passed by IDE/compiler to maintain a unique configure for all demo projects).
 5. If you use the device stack, make sure you have created/modified usb descriptors for your own need. Ultimately you need to fill out required pointers in tusbd_descriptor_pointers for that stack to work.
 6. Add tusb_init() call to your reset initialization code.
 7. Implement all enabled classes's callbacks.

examples/device/cdc_msc_hid/src/main.c

@@ -46,7 +46,6 @@
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF PROTYPES
 //--------------------------------------------------------------------+
-void print_greeting(void);
 void led_blinking_task(void);
 
 extern void virtual_com_task(void);
@@ -56,7 +55,6 @@ extern void usb_hid_task(void);
 int main(void)
 {
   board_init();
-  print_greeting();
 
   tusb_init();
 
@@ -84,9 +82,9 @@ int main(void)
 #if CFG_TUD_CDC
 void virtual_com_task(void)
 {
-  // connected and there are data available
   if ( tud_cdc_connected() )
   {
+      // connected and there are data available
     if ( tud_cdc_available() )
     {
       uint8_t buf[64];
@@ -98,11 +96,7 @@ void virtual_com_task(void)
       {
         tud_cdc_write_char(buf[i]);
 
-        if ( buf[i] == '\r' )
+        if ( buf[i] == '\r' ) tud_cdc_write_char('\n');
-        {
-          tud_cdc_write_char('\n');
-          tud_cdc_write_str("tinyusb cdc: ");
-        }
       }
 
       tud_cdc_write_flush();
@@ -117,8 +111,8 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
   // connected
   if ( dtr && rts )
   {
-    // print greeting
+    // print initial message when connected
-    tud_cdc_write_str("tinyusb cdc: ");
+    tud_cdc_write_str("\r\nTinyUSB CDC MSC HID device example\r\n");
   }
 }
 #endif
@@ -213,28 +207,3 @@ void led_blinking_task(void)
   board_led_control(led_state);
   led_state = 1 - led_state; // toggle
 }
-
-//--------------------------------------------------------------------+
-// HELPER FUNCTION
-//--------------------------------------------------------------------+
-void print_greeting(void)
-{
-  char const * const rtos_name[] =
-  {
-      [OPT_OS_NONE]      = "None",
-      [OPT_OS_FREERTOS]  = "FreeRTOS",
-  };
-
-  printf("\n--------------------------------------------------------------------\n");
-  printf("-                     Device Demo (a tinyusb example)\n");
-  printf("- if you find any bugs or get any questions, feel free to file an\n");
-  printf("- issue at https://github.com/hathach/tinyusb\n");
-  printf("--------------------------------------------------------------------\n\n");
-
-  printf("This DEVICE demo is configured to support:");
-  printf("  - RTOS = %s\n", rtos_name[CFG_TUSB_OS]);
-  if (CFG_TUD_CDC          ) puts("  - Communication Device Class");
-  if (CFG_TUD_MSC          ) puts("  - Mass Storage");
-  if (CFG_TUD_HID_KEYBOARD ) puts("  - HID Keyboard");
-  if (CFG_TUD_HID_MOUSE    ) puts("  - HID Mouse");
-}

examples/device/cdc_msc_hid_freertos/ses/nrf5x/nrf5x.emProject

@@ -18,11 +18,12 @@
       arm_target_debug_interface_type="ADIv5"
       arm_target_device_name="nRF52840_xxAA"
       arm_target_interface_type="SWD"
-      build_treat_warnings_as_errors="Yes"
+      build_treat_warnings_as_errors="No"
       c_preprocessor_definitions="NRF52840_XXAA;__nRF_FAMILY;ARM_MATH_CM4;FLASH_PLACEMENT=1;BOARD_PCA10056;CFG_TUSB_MCU=OPT_MCU_NRF5X"
       c_user_include_directories="./;../../src;$(rootDir)/hw/cmsis/Include;$(rootDir)/hw;$(rootDir)/src;$(nrfxDir)/..;$(nrfxDir);$(nrfxDir)/mdk;$(nrfxDir)/hal;$(nrfxDir)/drivers/include;$(freertosDir)/Source/include;$(freertosDir)/Source/portable/GCC/ARM_CM4F"
       debug_register_definition_file="nrf52840_Registers.xml"
       debug_target_connection="J-Link"
+      gcc_enable_all_warnings="Yes"
       gcc_entry_point="Reset_Handler"
       link_use_linker_script_file="No"
       linker_memory_map_file="nRF52840_xxAA_MemoryMap.xml"

examples/device/cdc_msc_hid_freertos/src/main.c

@@ -59,14 +59,13 @@
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
-void print_greeting(void);
 void led_blinky_cb(TimerHandle_t xTimer);
+void usb_device_task(void* param);
 
 /*------------- MAIN -------------*/
 int main(void)
 {
   board_init();
-  print_greeting();
 
   // soft timer for blinky
   TimerHandle_t tm_hdl = xTimerCreate(NULL, pdMS_TO_TICKS(1000), true, NULL, led_blinky_cb);
@@ -74,10 +73,13 @@ int main(void)
 
   tusb_init();
 
+  // Create a task for tinyusb device stack
+  xTaskCreate( usb_device_task, "usbd", 150, NULL, configMAX_PRIORITIES-1, NULL);
+
   // Create task
 #if CFG_TUD_CDC
   extern void cdc_task(void* params);
-  xTaskCreate( cdc_task, "cdc", 256, NULL, 2, NULL);
+  xTaskCreate( cdc_task, "cdc", 256, NULL, configMAX_PRIORITIES-2, NULL);
 #endif
 
 #if CFG_TUD_HID
@@ -90,6 +92,19 @@ int main(void)
   return 0;
 }
 
+// USB Device Driver task
+// This top level thread process all usb events and invoke callbacks
+void usb_device_task(void* param)
+{
+  (void) param;
+
+  // RTOS forever loop
+  while (1)
+  {
+    tusb_task();
+  }
+}
+
 //--------------------------------------------------------------------+
 // USB CDC
 //--------------------------------------------------------------------+
@@ -98,11 +113,12 @@ void cdc_task(void* params)
 {
   (void) params;
 
+  // RTOS forever loop
   while ( 1 )
   {
-    // connected and there are data available
     if ( tud_cdc_connected() )
     {
+      // connected and there are data available
       if ( tud_cdc_available() )
       {
         uint8_t buf[64];
@@ -110,10 +126,15 @@ void cdc_task(void* params)
         // read and echo back
         uint32_t count = tud_cdc_read(buf, sizeof(buf));
 
-        tud_cdc_write(buf, count);
+        for(uint32_t i=0; i<count; i++)
-      }
+        {
+          tud_cdc_write_char(buf[i]);
 
-      tud_cdc_write_flush();
+          if ( buf[i] == '\r' ) tud_cdc_write_char('\n');
+        }
+
+        tud_cdc_write_flush();
+      }
     }
   }
 }
@@ -125,8 +146,8 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
   // connected
   if ( dtr && rts )
   {
-    // print greeting
+    // print initial message when connected
-    tud_cdc_write_str("tinyusb usb cdc\n");
+    tud_cdc_write_str("\r\nTinyUSB CDC MSC HID device with FreeRTOS example\r\n");
   }
 }
 #endif
@@ -206,6 +227,7 @@ void tud_umount_cb(void)
 
 void tud_cdc_rx_cb(uint8_t itf)
 {
+  (void) itf;
 }
 
 //--------------------------------------------------------------------+
@@ -219,28 +241,3 @@ void led_blinky_cb(TimerHandle_t xTimer)
   board_led_control(led_state);
   led_state = 1 - led_state; // toggle
 }
-
-//--------------------------------------------------------------------+
-// HELPER FUNCTION
-//--------------------------------------------------------------------+
-void print_greeting(void)
-{
-  char const * const rtos_name[] =
-  {
-      [OPT_OS_NONE]      = "None",
-      [OPT_OS_FREERTOS]  = "FreeRTOS",
-  };
-
-  printf("\n--------------------------------------------------------------------\n");
-  printf("-                     Device Demo (a tinyusb example)\n");
-  printf("- if you find any bugs or get any questions, feel free to file an\n");
-  printf("- issue at https://github.com/hathach/tinyusb\n");
-  printf("--------------------------------------------------------------------\n\n");
-
-  printf("This DEVICE demo is configured to support:");
-  printf("  - RTOS = %s\n", rtos_name[CFG_TUSB_OS]);
-  if (CFG_TUD_CDC          ) puts("  - Communication Device Class");
-  if (CFG_TUD_MSC          ) puts("  - Mass Storage");
-  if (CFG_TUD_HID_KEYBOARD ) puts("  - HID Keyboard");
-  if (CFG_TUD_HID_MOUSE    ) puts("  - HID Mouse");
-}

examples/device/cdc_msc_hid_freertos/src/tusb_config.h

@@ -53,14 +53,8 @@
 #endif
 
 #define CFG_TUSB_RHPORT0_MODE       OPT_MODE_DEVICE
-
-#define CFG_TUSB_DEBUG              2
-
-/*------------- RTOS -------------*/
 #define CFG_TUSB_OS                 OPT_OS_FREERTOS
-#define CFG_TUD_TASK_PRIO           (configMAX_PRIORITIES-1)
+#define CFG_TUSB_DEBUG              2
-//#define CFG_TUD_TASK_QUEUE_SZ     16
-//#define CFG_TUD_TASK_STACK_SZ     150
 
 /* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment.
  * Tinyusb use follows macros to declare transferring memory so that they can be put

examples/host/cdc_msc_hid/src/tusb_config.h

@@ -80,14 +80,14 @@
 // DEVICE CONFIGURATION
 //--------------------------------------------------------------------
 
-#define CFG_TUH_HUB               1
+#define CFG_TUH_HUB                 1
-#define CFG_TUH_CDC               1
+#define CFG_TUH_CDC                 1
-#define CFG_TUH_HID_KEYBOARD      0
+#define CFG_TUH_HID_KEYBOARD        0
-#define CFG_TUH_HID_MOUSE         0
+#define CFG_TUH_HID_MOUSE           0
-#define CFG_TUSB_HOST_HID_GENERIC 0 // (not yet supported)
+#define CFG_TUSB_HOST_HID_GENERIC   0 // (not yet supported)
-#define CFG_TUH_MSC               0
+#define CFG_TUH_MSC                 0
 
-#define CFG_TUSB_HOST_DEVICE_MAX        (CFG_TUH_HUB ? 5 : 1) // normal hub has 4 ports
+#define CFG_TUSB_HOST_DEVICE_MAX    (CFG_TUH_HUB ? 5 : 1) // normal hub has 4 ports
 
 //------------- CLASS -------------//
 #define CFG_TUD_CDC                 0

examples/obsolete/device/src/tusb_config.h

@@ -55,9 +55,6 @@
 
 /*------------- RTOS -------------*/
 //#define CFG_TUSB_OS               OPT_OS_NONE // be passed from IDE/command line for easy project switching
-//#define CFG_TUD_TASK_PRIO         0
-//#define CFG_TUD_TASK_QUEUE_SZ     16
-//#define CFG_TUD_TASK_STACK_SZ     150
 
 //--------------------------------------------------------------------+
 // DEVICE CONFIGURATION

lib/FreeRTOS/freertos_hook.c

@@ -46,16 +46,17 @@
 
 void vApplicationMallocFailedHook(void)
 {
-	taskDISABLE_INTERRUPTS();
+  taskDISABLE_INTERRUPTS();
-	TU_ASSERT(false, );
+  TU_ASSERT(false, );
 }
 
 void vApplicationStackOverflowHook(xTaskHandle pxTask, signed char *pcTaskName)
 {
-	(void) pxTask;
+  (void) pxTask;
+  (void) pcTaskName;
 
-	taskDISABLE_INTERRUPTS();
+  taskDISABLE_INTERRUPTS();
-	TU_ASSERT(false, );
+  TU_ASSERT(false, );
 }
 
 /* configSUPPORT_STATIC_ALLOCATION is set to 1, so the application must provide an

src/common/tusb_fifo.c

@@ -48,9 +48,7 @@ static void tu_fifo_lock(tu_fifo_t *f)
 {
   if (f->mutex)
   {
-    uint32_t err;
+    osal_mutex_lock(f->mutex, OSAL_TIMEOUT_WAIT_FOREVER);
-    (void) err;
-    osal_mutex_lock(f->mutex, OSAL_TIMEOUT_WAIT_FOREVER, &err);
   }
 }
 

src/device/usbd.c

@@ -36,8 +36,6 @@
 */
 /**************************************************************************/
 
-// This top level class manages the bus state and delegates events to class-specific drivers.
-
 #include "tusb_option.h"
 
 #if TUSB_OPT_DEVICE_ENABLED
@@ -52,15 +50,6 @@
 #define CFG_TUD_TASK_QUEUE_SZ   16
 #endif
 
-#ifndef CFG_TUD_TASK_STACK_SZ
-#define CFG_TUD_TASK_STACK_SZ 150
-#endif
-
-#ifndef CFG_TUD_TASK_PRIO
-#define CFG_TUD_TASK_PRIO 0
-#endif
-
-
 //--------------------------------------------------------------------+
 // Device Data
 //--------------------------------------------------------------------+
@@ -153,16 +142,14 @@ static usbd_class_driver_t const usbd_class_drivers[] =
   #endif
 };
 
-enum { USBD_CLASS_DRIVER_COUNT = sizeof(usbd_class_drivers) / sizeof(usbd_class_driver_t) };
+enum { USBD_CLASS_DRIVER_COUNT = TU_ARRAY_SZIE(usbd_class_drivers) };
-
 
 //--------------------------------------------------------------------+
 // DCD Event
 //--------------------------------------------------------------------+
-OSAL_TASK_DEF(_usbd_task_def, "usbd", usbd_task, CFG_TUD_TASK_PRIO, CFG_TUD_TASK_STACK_SZ);
 
 // Event queue
-// role device/host is used by OS NONE for mutex (disable usb isr) only
+// OPT_MODE_DEVICE is used by OS NONE for mutex (disable usb isr)
 OSAL_QUEUE_DEF(OPT_MODE_DEVICE, _usbd_qdef, CFG_TUD_TASK_QUEUE_SZ, dcd_event_t);
 static osal_queue_t _usbd_q;
 
@@ -195,8 +182,6 @@ bool usbd_init (void)
   _usbd_q = osal_queue_create(&_usbd_qdef);
   TU_ASSERT(_usbd_q != NULL);
 
-  osal_task_create(&_usbd_task_def);
-
   // Init class drivers
   for (uint8_t i = 0; i < USBD_CLASS_DRIVER_COUNT; i++) usbd_class_drivers[i].init();
 
@@ -221,9 +206,13 @@ static void usbd_reset(uint8_t rhport)
   }
 }
 
-// Main device task implementation
+/* USB Device Driver task
-static void usbd_task_body(void)
+ * This top level thread manages all device controller event and delegates events to class-specific drivers.
+ */
+void usbd_task( void* param)
 {
+  (void) param;
+
   // Loop until there is no more events in the queue
   while (1)
   {
@@ -297,25 +286,6 @@ static void usbd_task_body(void)
   }
 }
 
-/* USB device task
- * Thread that handles all device events. With an real RTOS, the task must be a forever loop and never return.
- * For coding convenience with no RTOS, we use wrapped sub-function for processing to easily return at any time.
- */
-void usbd_task( void* param)
-{
-  (void) param;
-
-#if CFG_TUSB_OS != OPT_OS_NONE
-  while (1) {
-#endif
-
-  usbd_task_body();
-
-#if CFG_TUSB_OS != OPT_OS_NONE
-  }
-#endif
-}
-
 //--------------------------------------------------------------------+
 // Control Request Parser & Handling
 //--------------------------------------------------------------------+

src/host/usbh.c

@@ -46,15 +46,6 @@
 #define CFG_TUH_TASK_QUEUE_SZ   16
 #endif
 
-#ifndef CFG_TUH_TASK_STACK_SZ
-#define CFG_TUH_TASK_STACK_SZ 200
-#endif
-
-#ifndef CFG_TUH_TASK_PRIO
-#define CFG_TUH_TASK_PRIO 0
-#endif
-
-
 //--------------------------------------------------------------------+
 // INCLUDE
 //--------------------------------------------------------------------+
@@ -123,9 +114,9 @@ enum { USBH_CLASS_DRIVER_COUNT = TU_ARRAY_SZIE(usbh_class_drivers) };
 //--------------------------------------------------------------------+
 // INTERNAL OBJECT & FUNCTION DECLARATION
 //--------------------------------------------------------------------+
-CFG_TUSB_MEM_SECTION usbh_device_t _usbh_devices[CFG_TUSB_HOST_DEVICE_MAX+1]; // including zero-address
 
-OSAL_TASK_DEF(_usbh_task_def, "usbh", usbh_task, CFG_TUH_TASK_PRIO, CFG_TUH_TASK_STACK_SZ);
+// including zero-address
+CFG_TUSB_MEM_SECTION usbh_device_t _usbh_devices[CFG_TUSB_HOST_DEVICE_MAX+1];
 
 // Event queue
 // role device/host is used by OS NONE for mutex (disable usb isr) only
@@ -161,8 +152,6 @@ bool usbh_init(void)
   _usbh_q = osal_queue_create( &_usbh_qdef );
   TU_ASSERT(_usbh_q != NULL);
 
-  osal_task_create(&_usbh_task_def);
-
   //------------- Semaphore, Mutex for Control Pipe -------------//
   for(uint8_t i=0; i<CFG_TUSB_HOST_DEVICE_MAX+1; i++) // including address zero
   {
@@ -610,12 +599,18 @@ bool enum_task(hcd_event_t* event)
   return true;
 }
 
-bool usbh_task_body(void)
+/* USB Host Driver task
+ * This top level thread manages all host controller event and delegates events to class-specific drivers.
+ */
+void usbh_task(void* param)
 {
+  (void) param;
+
+  // Loop until there is no more events in the queue
   while (1)
   {
     hcd_event_t event;
-    if ( !osal_queue_receive(_usbh_q, &event) ) return false;
+    if ( !osal_queue_receive(_usbh_q, &event) ) return;
 
     switch (event.event_id)
     {
@@ -629,25 +624,6 @@ bool usbh_task_body(void)
   }
 }
 
-/* USB Host task
- * Thread that handles all device events. With an real RTOS, the task must be a forever loop and never return.
- * For coding convenience with no RTOS, we use wrapped sub-function for processing to easily return at any time.
- */
-void usbh_task(void* param)
-{
-  (void) param;
-
-#if CFG_TUSB_OS != OPT_OS_NONE
-  while (1) {
-#endif
-
-  usbh_task_body();
-
-#if CFG_TUSB_OS != OPT_OS_NONE
-  }
-#endif
-}
-
 //--------------------------------------------------------------------+
 // INTERNAL HELPER
 //--------------------------------------------------------------------+

src/osal/osal.h

@@ -68,8 +68,6 @@ typedef void (*osal_task_func_t)( void * );
    * uint32_t tusb_hal_millis(void)
    *
    * Task
-   *    osal_task_def_t
-   *    bool osal_task_create(osal_task_def_t* taskdef)
    *    void osal_task_delay(uint32_t msec)
    *
    * Queue

src/osal/osal_freertos.h

@@ -65,27 +65,6 @@ static inline bool in_isr(void)
 //--------------------------------------------------------------------+
 // TASK API
 //--------------------------------------------------------------------+
-#define OSAL_TASK_DEF(_name, _str, _func, _prio, _stack_sz) \
-  static uint8_t _name##_##buf[_stack_sz*sizeof(StackType_t)]; \
-  osal_task_def_t _name = { .func = _func, .prio = _prio, .stack_sz = _stack_sz, .buf = _name##_##buf, .strname = _str };
-
-typedef struct
-{
-  osal_task_func_t func;
-
-  uint16_t prio;
-  uint16_t stack_sz;
-  void*    buf;
-  const char* strname;
-
-  StaticTask_t stask;
-}osal_task_def_t;
-
-static inline bool osal_task_create(osal_task_def_t* taskdef)
-{
-  return NULL != xTaskCreateStatic(taskdef->func, taskdef->strname, taskdef->stack_sz, NULL, taskdef->prio, (StackType_t*) taskdef->buf, &taskdef->stask);
-}
-
 static inline void osal_task_delay(uint32_t msec)
 {
   vTaskDelay( pdMS_TO_TICKS(msec) );

src/osal/osal_mynewt.h

@@ -46,27 +46,6 @@
 //--------------------------------------------------------------------+
 // TASK API
 //--------------------------------------------------------------------+
-#define OSAL_TASK_DEF(_name, _str, _func, _prio, _stack_sz) \
-  static os_stack_t _name##_##buf[_stack_sz]; \
-  osal_task_def_t _name = { .func = _func, .prio = _prio, .stack_sz = _stack_sz, .buf = _name##_##buf, .strname = _str };
-
-typedef struct
-{
-  struct os_task mynewt_task;
-  osal_task_func_t func;
-
-  uint16_t prio;
-  uint16_t stack_sz;
-  void*    buf;
-  const char* strname;
-}osal_task_def_t;
-
-static inline bool osal_task_create(osal_task_def_t* taskdef)
-{
-  return OS_OK == os_task_init(&taskdef->mynewt_task, taskdef->strname, taskdef->func, NULL, taskdef->prio, OS_WAIT_FOREVER,
-                               (os_stack_t*) taskdef->buf, taskdef->stack_sz);
-}
-
 static inline void osal_task_delay(uint32_t msec)
 {
   os_time_delay( os_time_ms_to_ticks32(msec) );

src/osal/osal_none.h

@@ -51,17 +51,7 @@
 
 //--------------------------------------------------------------------+
 // TASK API
-// Virtually do nothing in osal none
 //--------------------------------------------------------------------+
-#define OSAL_TASK_DEF(_name, _str, _func, _prio, _stack_sz)  osal_task_def_t _name;
-typedef uint8_t osal_task_def_t;
-
-static inline bool osal_task_create(osal_task_def_t* taskdef)
-{
-  (void) taskdef;
-  return true;
-}
-
 static inline void osal_task_delay(uint32_t msec)
 {
   uint32_t start = tusb_hal_millis();

src/tusb.c

@@ -68,7 +68,6 @@ bool tusb_init(void)
   return TUSB_ERROR_NONE;
 }
 
-#if CFG_TUSB_OS == OPT_OS_NONE
 void tusb_task(void)
 {
   #if TUSB_OPT_HOST_ENABLED
@@ -79,8 +78,6 @@ void tusb_task(void)
   usbd_task(NULL);
   #endif
 }
-#endif
-
 
 /*------------------------------------------------------------------*/
 /* Debug

src/tusb.h

@@ -105,11 +105,9 @@
 // return true if success
 bool tusb_init(void);
 
-#if CFG_TUSB_OS == OPT_OS_NONE
+/** Run all tinyusb's internal tasks (e.g host task, device task) and invoke callback
-/** \brief Run all tinyusb's internal tasks (e.g host task, device task).
+ * This should be called periodically within the mainloop.
- * \note   This function is only required when using no RTOS (\ref CFG_TUSB_OS == OPT_OS_NONE). All the stack functions
+
- *         & callback are invoked within this function. This should be called periodically within the mainloop
- *
     @code
     int main(void)
     {
@@ -126,10 +124,9 @@ bool tusb_init(void);
       }
     }
     @endcode
- *
+
  */
 void tusb_task(void);
-#endif
 
 /** @} */
 

src/tusb_option.h

@@ -224,11 +224,6 @@
 //------------------------------------------------------------------
 // Configuration Validation
 //------------------------------------------------------------------
-
-#if (CFG_TUSB_OS != OPT_OS_NONE) && !defined (CFG_TUD_TASK_PRIO)
-  #error CFG_TUD_TASK_PRIO need to be defined (hint: use the highest if possible)
-#endif
-
 #if CFG_TUD_ENDOINT0_SIZE > 64
   #error Control Endpoint Max Packet Size cannot be larger than 64
 #endif