Merge pull request #45 from hathach/develop

Board uart rename and better support mynewt

examples/device/cdc_msc_hid/Makefile

@@ -34,7 +34,6 @@ MKDIR = mkdir
 SED = sed
 CP = cp
 RM = rm
-AS = $(CROSS_COMPILE)as
 
 INC += -Isrc \
 	-I$(TOP)/hw \

examples/device/cdc_msc_hid/src/main.c

@@ -93,6 +93,7 @@ void virtual_com_task(void)
   }
 }
 
+// Invoked when cdc when line state changed e.g connected/disconnected
 void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
 {
   (void) itf;
@@ -104,6 +105,13 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
     tud_cdc_write_str("\r\nTinyUSB CDC MSC HID device example\r\n");
   }
 }
+
+// Invoked when CDC interface received data from host
+void tud_cdc_rx_cb(uint8_t itf)
+{
+  (void) itf;
+}
+
 #endif
 
 //--------------------------------------------------------------------+
@@ -168,20 +176,18 @@ void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_t
 //--------------------------------------------------------------------+
 // tinyusb callbacks
 //--------------------------------------------------------------------+
+
+// Invoked when device is mounted
 void tud_mount_cb(void)
 {
 
 }
 
+// Invoked when device is unmounted
 void tud_umount_cb(void)
 {
 }
 
-void tud_cdc_rx_cb(uint8_t itf)
-{
-  (void) itf;
-}
-
 //--------------------------------------------------------------------+
 // BLINKING TASK
 //--------------------------------------------------------------------+

examples/device/cdc_msc_hid_mynewt/readme.md

@@ -0,0 +1 @@
+Please check out this repo https://github.com/hathach/mynewt-tinyusb-exmaple For mynewt example

hw/bsp/board.h

@@ -65,6 +65,8 @@
   #include "metro_m4_express/board_metro_m4_express.h"
 #elif defined BOARD_METRO_M0_EXPRESS
   #include "metro_m0_express/board_metro_m0_express.h"
+
+// ST STM32
 #elif defined BOARD_STM32F407G_DISC1
   #include "stm32f407g_disc1/board_stm32f407g_disc1.h"
 #else
@@ -76,7 +78,7 @@
 #define board_tick2ms(tck)   ( ( ((uint64_t)(tck)) * 1000) / BOARD_TICKS_HZ )
 
 
-/// Initialize on-board peripherals
+// Initialize on-board peripherals
 void board_init(void);
 
 //--------------------------------------------------------------------+
@@ -104,16 +106,27 @@ static inline void board_led_off(void)
  */
 uint32_t board_buttons(void);
 
-/** Get a character input from UART
+//--------------------------------------------------------------------+
- * \return ASCII code of the input character or zero if none.
+// UART
- */
+//--------------------------------------------------------------------+
-uint8_t  board_uart_getchar(void);
 
-/** Send a character to UART
+// Get characters from UART
- * \param[in]  c the character to be sent
+int board_uart_read(uint8_t* buf, int len);
- */
-void board_uart_putchar(uint8_t c);
 
+// Send characters to UART
+int board_uart_write(void const * buf, int len);
+
+
+static inline int8_t board_uart_getchar(void)
+{
+  uint8_t c;
+  return board_uart_read(&c, 1) ? c : (-1);
+}
+
+static inline int board_uart_putchar(uint8_t c)
+{
+  return board_uart_write(&c, 1);
+}
 
 #ifdef __cplusplus
  }

hw/bsp/ea4088qs/board_ea4088qs.c

@@ -137,18 +137,21 @@ uint32_t board_buttons(void)
   return result;
 }
 
-
 //------------- UART -------------//
-uint8_t  board_uart_getchar(void)
+int board_uart_read(uint8_t* buf, int len)
 {
   //return UART_ReceiveByte(BOARD_UART_PORT);
+  (void) buf;
+  (void) len;
   return 0;
 }
 
-void board_uart_putchar(uint8_t c)
+int board_uart_write(void const * buf, int len)
 {
   //UART_Send(BOARD_UART_PORT, &c, 1, BLOCKING);
-  (void) c;
+  (void) buf;
+  (void) len;
+  return 0;
 }
 
 

hw/bsp/ea4357/board_ea4357.c

@@ -282,16 +282,20 @@ uint32_t board_buttons(void)
 //--------------------------------------------------------------------+
 // UART
 //--------------------------------------------------------------------+
-uint8_t  board_uart_getchar(void)
+int board_uart_read(uint8_t* buf, int len)
 {
   //return UART_ReceiveByte(BOARD_UART_PORT);
+  (void) buf;
+  (void) len;
   return 0;
 }
 
-void board_uart_putchar(uint8_t c)
+int board_uart_write(void const * buf, int len)
 {
   //UART_Send(BOARD_UART_PORT, &c, 1, BLOCKING);
-  (void) c;
+  (void) buf;
+  (void) len;
+  return 0;
 }
 
 #endif

hw/bsp/lpcxpresso11u68/board_lpcxpresso11u68.c

@@ -128,15 +128,19 @@ uint32_t board_buttons(void)
 //--------------------------------------------------------------------+
 // UART
 //--------------------------------------------------------------------+
-void board_uart_putchar(uint8_t c)
+int board_uart_read(uint8_t* buf, int len)
-{
-  (void) c;
-  //UARTSend(&c, 1);
-}
-
-uint8_t  board_uart_getchar(void)
 {
 //  *buffer = get_key(); TODO cannot find available code for uart getchar
+  (void) buf;
+  (void) len;
+  return 0;
+}
+
+int board_uart_write(void const * buf, int len)
+{
+  //UARTSend(&c, 1);
+  (void) buf;
+  (void) len;
   return 0;
 }
 

hw/bsp/lpcxpresso1347/board_lpcxpresso1347.c

@@ -153,14 +153,18 @@ uint32_t board_buttons(void)
 //--------------------------------------------------------------------+
 // UART
 //--------------------------------------------------------------------+
-void board_uart_putchar(uint8_t c)
+int board_uart_read(uint8_t* buf, int len)
 {
-  (void) c;
+  (void) buf;
-//  UARTSend(&c, 1);
+  (void) len;
+  return 0;
 }
 
-uint8_t  board_uart_getchar(void)
+int board_uart_write(void const * buf, int len)
 {
+//  UARTSend(&c, 1);
+  (void) buf;
+  (void) len;
   return 0;
 }
 

hw/bsp/lpcxpresso1769/board_lpcxpresso1769.c

@@ -193,15 +193,20 @@ uint32_t board_buttons(void)
 //--------------------------------------------------------------------+
 // UART
 //--------------------------------------------------------------------+
-void board_uart_putchar(uint8_t c)
+int board_uart_read(uint8_t* buf, int len)
-{
-  (void) c;
-//  UART_Send(BOARD_UART_PORT, &c, 1, BLOCKING);
-}
-
-uint8_t  board_uart_getchar(void)
 {
 //  return UART_ReceiveByte(BOARD_UART_PORT);
+  (void) buf;
+  (void) len;
+  return 0;
+
+}
+
+int board_uart_write(void const * buf, int len)
+{
+//  UART_Send(BOARD_UART_PORT, &c, 1, BLOCKING);
+  (void) buf;
+  (void) len;
   return 0;
 }
 

hw/bsp/mcb1800/board_mcb1800.c

@@ -205,16 +205,20 @@ uint32_t board_buttons(void)
 
 
 //------------- UART -------------//
-uint8_t  board_uart_getchar(void)
+int board_uart_read(uint8_t* buf, int len)
 {
   //return UART_ReceiveByte(BOARD_UART_PORT);
+  (void) buf;
+  (void) len;
   return 0;
 }
 
-void board_uart_putchar(uint8_t c)
+int board_uart_write(void const * buf, int len)
 {
-  (void) c;
   //UART_Send(BOARD_UART_PORT, &c, 1, BLOCKING);
+  (void) buf;
+  (void) len;
+  return 0;
 }
 
 /*------------------------------------------------------------------*/

hw/bsp/pca10056/board_pca10056.c

@@ -247,14 +247,18 @@ uint32_t board_buttons(void)
   return ret;
 }
 
-uint8_t board_uart_getchar(void)
+int board_uart_read(uint8_t* buf, int len)
 {
+  (void) buf;
+  (void) len;
   return 0;
 }
 
-void board_uart_putchar(uint8_t c)
+int board_uart_write(void const * buf, int len)
 {
-  (void) c;
+  (void) buf;
+  (void) len;
+  return 0;
 }
 
 #ifdef SOFTDEVICE_PRESENT

hw/bsp/printf_retarget.c

@@ -168,8 +168,8 @@ size_t __read(int handle, unsigned char *buf, size_t bufSize)
   size_t i;
   for (i=0; i<bufSize; i++)
   {
-    uint8_t ch = board_uart_getchar();
+    int8_t ch = board_uart_getchar();
-    if (ch == 0) break;
+    if (ch == -1) break;
     buf[i] = ch;
   }
 

src/osal/osal.h

@@ -69,7 +69,7 @@ typedef void (*osal_task_func_t)( void * );
    *    osal_semaphore_def_t, osal_semaphore_t
    *    osal_semaphore_t osal_semaphore_create(osal_semaphore_def_t* semdef)
    *    bool osal_semaphore_post(osal_semaphore_t sem_hdl, bool in_isr)
- *    bool osal_semaphore_wait(osal_semaphore_t sem_hdl, uint32_t msec)
+   *    bool osal_semaphore_wait(osal_semaphore_t sem_hdl, uint32_t msec)
    *    void osal_semaphore_reset(osal_semaphore_t const sem_hdl)
    *
    * Mutex

src/osal/osal_freertos.h

@@ -24,15 +24,10 @@
  * This file is part of the TinyUSB stack.
  */
 
-/** \ingroup group_osal
- * @{
- *  \defgroup Group_FreeRTOS  FreeRTOS
- *  @{ */
-
 #ifndef _TUSB_OSAL_FREERTOS_H_
 #define _TUSB_OSAL_FREERTOS_H_
 
-//------------- FreeRTOS Headers -------------//
+// FreeRTOS Headers
 #include "FreeRTOS.h"
 #include "semphr.h"
 #include "queue.h"
@@ -42,14 +37,6 @@
 extern "C" {
 #endif
 
-#if 0
-// Helper to determine if we are in ISR to use ISR API (only cover ARM Cortex)
-static inline bool in_isr(void)
-{
-  return (SCB->ICSR & SCB_ICSR_VECTACTIVE_Msk);
-}
-#endif
-
 //--------------------------------------------------------------------+
 // TASK API
 //--------------------------------------------------------------------+
@@ -148,6 +135,3 @@ static inline void osal_queue_reset(osal_queue_t const queue_hdl)
 #endif
 
 #endif /* _TUSB_OSAL_FREERTOS_H_ */
-
-/** @} */
-/** @} */

src/osal/osal_mynewt.h

@@ -41,6 +41,56 @@ static inline void osal_task_delay(uint32_t msec)
   os_time_delay( os_time_ms_to_ticks32(msec) );
 }
 
+//--------------------------------------------------------------------+
+// Semaphore API
+//--------------------------------------------------------------------+
+typedef struct os_sem  osal_semaphore_def_t;
+typedef struct os_sem* osal_semaphore_t;
+
+static inline osal_semaphore_t osal_semaphore_create(osal_semaphore_def_t* semdef)
+{
+  return (os_sem_init(semdef, 0) == OS_OK) ? (osal_semaphore_t) semdef : NULL;
+}
+
+static inline bool osal_semaphore_post(osal_semaphore_t sem_hdl, bool in_isr)
+{
+  (void) in_isr;
+  return os_sem_release(sem_hdl) == OS_OK;
+}
+
+static inline bool osal_semaphore_wait(osal_semaphore_t sem_hdl, uint32_t msec)
+{
+  uint32_t const ticks = (msec == OSAL_TIMEOUT_WAIT_FOREVER) ? OS_TIMEOUT_NEVER : os_time_ms_to_ticks32(msec);
+  return os_sem_pend(sem_hdl, ticks) == OS_OK;
+}
+
+static inline void osal_semaphore_reset(osal_semaphore_t sem_hdl)
+{
+  // TODO implement later
+}
+
+//--------------------------------------------------------------------+
+// MUTEX API (priority inheritance)
+//--------------------------------------------------------------------+
+typedef struct os_mutex osal_mutex_def_t;
+typedef struct os_mutex* osal_mutex_t;
+
+static inline osal_mutex_t osal_mutex_create(osal_mutex_def_t* mdef)
+{
+  return (os_mutex_init(mdef) == OS_OK) ? (osal_mutex_t) mdef : NULL;
+}
+
+static inline bool osal_mutex_lock(osal_mutex_t mutex_hdl, uint32_t msec)
+{
+  uint32_t const ticks = (msec == OSAL_TIMEOUT_WAIT_FOREVER) ? OS_TIMEOUT_NEVER : os_time_ms_to_ticks32(msec);
+  return os_mutex_pend(mutex_hdl, ticks) == OS_OK;
+}
+
+static inline bool osal_mutex_unlock(osal_mutex_t mutex_hdl)
+{
+  return os_mutex_release(mutex_hdl) == OS_OK;
+}
+
 //--------------------------------------------------------------------+
 // QUEUE API
 //--------------------------------------------------------------------+
@@ -75,109 +125,47 @@ static inline osal_queue_t osal_queue_create(osal_queue_def_t* qdef)
   return (osal_queue_t) qdef;
 }
 
-static inline void osal_queue_receive (osal_queue_t const queue_hdl, void *p_data, uint32_t msec, tusb_error_t *p_error)
+static inline bool osal_queue_receive(osal_queue_t const qhdl, void* data)
 {
-  (void) msec;
   struct os_event* ev;
+  ev = os_eventq_get(&qhdl->evq);
 
-  if ( msec == 0 )
+  memcpy(data, ev->ev_arg, qhdl->item_sz); // copy message
-  {
+  os_memblock_put(&qhdl->mpool, ev->ev_arg); // put back mem block
-    ev = os_eventq_get_no_wait(&queue_hdl->evq);
+  os_memblock_put(&qhdl->epool, ev);         // put back ev block
-    if ( !ev )
-    {
-      *p_error = TUSB_ERROR_OSAL_TIMEOUT;
-      return;
-    }
-  }else
-  {
-    ev = os_eventq_get(&queue_hdl->evq);
-  }
 
-  memcpy(p_data, ev->ev_arg, queue_hdl->item_sz); // copy message
+  return true;
-  os_memblock_put(&queue_hdl->mpool, ev->ev_arg); // put back mem block
-  os_memblock_put(&queue_hdl->epool, ev);         // put back ev block
-
-  *p_error = TUSB_ERROR_NONE;
 }
 
-static inline bool osal_queue_send(osal_queue_t const queue_hdl, void const * data, bool in_isr)
+static inline bool osal_queue_send(osal_queue_t const qhdl, void const * data, bool in_isr)
 {
   (void) in_isr;
 
   // get a block from mem pool for data
-  void* ptr = os_memblock_get(&queue_hdl->mpool);
+  void* ptr = os_memblock_get(&qhdl->mpool);
   if (!ptr) return false;
-  memcpy(ptr, data, queue_hdl->item_sz);
+  memcpy(ptr, data, qhdl->item_sz);
 
   // get a block from event pool to put into queue
-  struct os_event* ev = (struct os_event*) os_memblock_get(&queue_hdl->epool);
+  struct os_event* ev = (struct os_event*) os_memblock_get(&qhdl->epool);
   if (!ev)
   {
-    os_memblock_put(&queue_hdl->mpool, ptr);
+    os_memblock_put(&qhdl->mpool, ptr);
     return false;
   }
   tu_memclr(ev, sizeof(struct os_event));
   ev->ev_arg = ptr;
 
-  os_eventq_put(&queue_hdl->evq, ev);
+  os_eventq_put(&qhdl->evq, ev);
 
   return true;
 }
 
-static inline void osal_queue_flush(osal_queue_t const queue_hdl)
+static inline void osal_queue_reset(osal_queue_t const queue_hdl)
 {
-
+  // TODO implement later
 }
 
-//--------------------------------------------------------------------+
-// Semaphore API
-//--------------------------------------------------------------------+
-typedef struct os_sem  osal_semaphore_def_t;
-typedef struct os_sem* osal_semaphore_t;
-
-static inline osal_semaphore_t osal_semaphore_create(osal_semaphore_def_t* semdef)
-{
-  return (os_sem_init(semdef, 0) == OS_OK) ? (osal_semaphore_t) semdef : NULL;
-}
-
-static inline bool osal_semaphore_post(osal_semaphore_t sem_hdl, bool in_isr)
-{
-  (void) in_isr;
-  return os_sem_release(sem_hdl) == OS_OK;
-}
-
-static inline void osal_semaphore_wait(osal_semaphore_t sem_hdl, uint32_t msec, tusb_error_t *p_error)
-{
-  uint32_t const ticks = (msec == OSAL_TIMEOUT_WAIT_FOREVER) ? OS_TIMEOUT_NEVER : os_time_ms_to_ticks32(msec);
-  (*p_error) = ( (os_sem_pend(sem_hdl, ticks) == OS_OK) ? TUSB_ERROR_NONE : TUSB_ERROR_OSAL_TIMEOUT );
-}
-
-static inline void osal_semaphore_reset_isr(osal_semaphore_t const sem_hdl)
-{
-//  xSemaphoreTakeFromISR(sem_hdl, NULL);
-}
-
-#if 0
-//--------------------------------------------------------------------+
-// MUTEX API (priority inheritance)
-//--------------------------------------------------------------------+
-typedef struct os_mutex osal_mutex_t;
-
-#define osal_mutex_create(x) xSemaphoreCreateMutex()
-
-static inline bool osal_mutex_release(osal_mutex_t mutex_hdl)
-{
-  return xSemaphoreGive(mutex_hdl);
-}
-
-static inline void osal_mutex_wait(osal_mutex_t mutex_hdl, uint32_t msec, tusb_error_t *p_error)
-{
-  uint32_t const ticks = (msec == OSAL_TIMEOUT_WAIT_FOREVER) ? portMAX_DELAY : pdMS_TO_TICKS(msec);
-  (*p_error) = (xSemaphoreTake(mutex_hdl, ticks) ? TUSB_ERROR_NONE : TUSB_ERROR_OSAL_TIMEOUT);
-}
-#endif
-
-
 #ifdef __cplusplus
  }
 #endif

src/osal/osal_none.h

@@ -24,10 +24,6 @@
  * This file is part of the TinyUSB stack.
  */
 
-/** \ingroup group_osal
- * \defgroup Group_OSNone None OS
- *  @{ */
-
 #ifndef _TUSB_OSAL_NONE_H_
 #define _TUSB_OSAL_NONE_H_
 
@@ -69,11 +65,6 @@ static inline bool osal_semaphore_post(osal_semaphore_t sem_hdl, bool in_isr)
   return true;
 }
 
-static inline void osal_semaphore_reset(osal_semaphore_t sem_hdl)
-{
-  sem_hdl->count = 0;
-}
-
 // TODO blocking for now
 static inline bool osal_semaphore_wait (osal_semaphore_t sem_hdl, uint32_t msec)
 {
@@ -85,6 +76,11 @@ static inline bool osal_semaphore_wait (osal_semaphore_t sem_hdl, uint32_t msec)
   return true;
 }
 
+static inline void osal_semaphore_reset(osal_semaphore_t sem_hdl)
+{
+  sem_hdl->count = 0;
+}
+
 //--------------------------------------------------------------------+
 // MUTEX API
 // Within tinyusb, mutex is never used in ISR context
@@ -98,8 +94,8 @@ static inline osal_mutex_t osal_mutex_create(osal_mutex_def_t* mdef)
   return mdef;
 }
 
-#define osal_mutex_unlock(_mutex_hdl)   osal_semaphore_post(_mutex_hdl, false)
 #define osal_mutex_lock                 osal_semaphore_wait
+#define osal_mutex_unlock(_mutex_hdl)   osal_semaphore_post(_mutex_hdl, false)
 
 //--------------------------------------------------------------------+
 // QUEUE API
@@ -168,6 +164,16 @@ static inline osal_queue_t osal_queue_create(osal_queue_def_t* qdef)
   return (osal_queue_t) qdef;
 }
 
+// non blocking
+static inline bool osal_queue_receive(osal_queue_t const qhdl, void* data)
+{
+  _osal_q_lock(qhdl);
+  bool success = tu_fifo_read(&qhdl->ff, data);
+  _osal_q_unlock(qhdl);
+
+  return success;
+}
+
 static inline bool osal_queue_send(osal_queue_t const qhdl, void const * data, bool in_isr)
 {
   if (!in_isr) {
@@ -190,20 +196,8 @@ static inline void osal_queue_reset(osal_queue_t const qhdl)
   // tusb_hal_int_enable_all();
 }
 
-// non blocking
-static inline bool osal_queue_receive(osal_queue_t const qhdl, void* data)
-{
-  _osal_q_lock(qhdl);
-  bool success = tu_fifo_read(&qhdl->ff, data);
-  _osal_q_unlock(qhdl);
-
-  return success;
-}
-
 #ifdef __cplusplus
  }
 #endif
 
 #endif /* _TUSB_OSAL_NONE_H_ */
-
-/** @} */

src/portable/nxp/lpc11_13_15/dcd_lpc11_13_15.c

@@ -30,7 +30,6 @@
 
 #include "chip.h"
 #include "device/dcd.h"
-#include "dcd_lpc11_13_15.h"
 
 //--------------------------------------------------------------------+
 // MACRO CONSTANT TYPEDEF

src/portable/nxp/lpc11_13_15/dcd_lpc11_13_15.h

@@ -1,39 +0,0 @@
-/* 
- * The MIT License (MIT)
- *
- * Copyright (c) 2018, hathach (tinyusb.org)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- * This file is part of the TinyUSB stack.
- */
-
-#ifndef _TUSB_DCD_LPC11_13_15_H_
-#define _TUSB_DCD_LPC11_13_15_H_
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-
-#ifdef __cplusplus
- }
-#endif
-
-#endif /* _TUSB_DCD_LPC11_13_15_H_ */