kingkevin
/
esp32-s2_dfu
1
0
Fork 0
Code Issues Releases Activity

Merge pull request #45 from hathach/develop 

Board uart rename and better support mynewt
This commit is contained in:
hathach 2019-03-21 05:13:20 -07:00 committed by GitHub
parent 02a1ce4e76 f8faf05e9e
commit 7d6085f870
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 177 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
examples/device/cdc_msc_hid/Makefile
View File

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

16
examples/device/cdc_msc_hid/src/main.c
View File

@ -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
//--------------------------------------------------------------------+

1
examples/device/cdc_msc_hid_mynewt/readme.md Normal file
View File

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

31
hw/bsp/board.h
View File

@ -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.
*/
uint8_t board_uart_getchar(void);
//--------------------------------------------------------------------+
// UART
//--------------------------------------------------------------------+
/** Send a character to UART
* \param[in] c the character to be sent
*/
void board_uart_putchar(uint8_t c);
// Get characters from UART
int board_uart_read(uint8_t* buf, int len);
// 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
}

11
hw/bsp/ea4088qs/board_ea4088qs.c
View File

@ -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;
}

10
hw/bsp/ea4357/board_ea4357.c
View File

@ -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

18
hw/bsp/lpcxpresso11u68/board_lpcxpresso11u68.c
View File

@ -128,15 +128,19 @@ uint32_t board_buttons(void)
//--------------------------------------------------------------------+
// UART
//--------------------------------------------------------------------+
void board_uart_putchar(uint8_t c)
{
(void) c;
//UARTSend(&c, 1);
}
uint8_t board_uart_getchar(void)
int board_uart_read(uint8_t* buf, int len)
{
// *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;
}

12
hw/bsp/lpcxpresso1347/board_lpcxpresso1347.c
View File

@ -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;
// UARTSend(&c, 1);
(void) buf;
(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;
}

19
hw/bsp/lpcxpresso1769/board_lpcxpresso1769.c
View File

@ -193,15 +193,20 @@ uint32_t board_buttons(void)
//--------------------------------------------------------------------+
// UART
//--------------------------------------------------------------------+
void board_uart_putchar(uint8_t c)
{
(void) c;
// UART_Send(BOARD_UART_PORT, &c, 1, BLOCKING);
}
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;
}
int board_uart_write(void const * buf, int len)
{
// UART_Send(BOARD_UART_PORT, &c, 1, BLOCKING);
(void) buf;
(void) len;
return 0;
}

10
hw/bsp/mcb1800/board_mcb1800.c
View File

@ -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;
}
/*------------------------------------------------------------------*/

10
hw/bsp/pca10056/board_pca10056.c
View File

@ -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

4
hw/bsp/printf_retarget.c
View File

@ -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();
if (ch == 0) break;
int8_t ch = board_uart_getchar();
if (ch == -1) break;
buf[i] = ch;
}

2
src/osal/osal.h
View File

@ -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

18
src/osal/osal_freertos.h
View File

@ -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_ */
/** @} */
/** @} */

140
src/osal/osal_mynewt.h
View File

@ -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 )
{
ev = os_eventq_get_no_wait(&queue_hdl->evq);
if ( !ev )
{
*p_error = TUSB_ERROR_OSAL_TIMEOUT;
return;
}
}else
{
ev = os_eventq_get(&queue_hdl->evq);
}
memcpy(data, ev->ev_arg, qhdl->item_sz); // copy message
os_memblock_put(&qhdl->mpool, ev->ev_arg); // put back mem block
os_memblock_put(&qhdl->epool, ev); // put back ev block
memcpy(p_data, ev->ev_arg, queue_hdl->item_sz); // copy message
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;
return true;
}
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

38
src/osal/osal_none.h
View File

@ -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_ */
/** @} */

1
src/portable/nxp/lpc11_13_15/dcd_lpc11_13_15.c
View File

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

39
src/portable/nxp/lpc11_13_15/dcd_lpc11_13_15.h
View File

@ -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_ */