2017-01-25 16:35:28 +00:00
// Copyright 2017 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Hot It Works
// ************
// 1. Components Overview
// ======================
2017-03-22 03:07:37 +00:00
// Xtensa has useful feature: TRAX debug module. It allows recording program execution flow at run-time without disturbing CPU.
2017-01-25 16:35:28 +00:00
// Exectution flow data are written to configurable Trace RAM block. Besides accessing Trace RAM itself TRAX module also allows to read/write
// trace memory via its registers by means of JTAG, APB or ERI transactions.
// ESP32 has two Xtensa cores with separate TRAX modules on them and provides two special memory regions to be used as trace memory.
2017-03-22 03:07:37 +00:00
// Chip allows muxing access to those trace memory blocks in such a way that while one block is accessed by CPUs another one can be accessed by host
// by means of reading/writing TRAX registers via JTAG. Blocks muxing is configurable at run-time and allows switching trace memory blocks between
2017-01-25 16:35:28 +00:00
// accessors in round-robin fashion so they can read/write separate memory blocks without disturbing each other.
2017-03-22 03:07:37 +00:00
// This module implements application tracing feature based on above mechanisms. It allows to transfer arbitrary user data to/from
2017-01-25 16:35:28 +00:00
// host via JTAG with minimal impact on system performance. This module is implied to be used in the following tracing scheme.
2017-03-22 03:07:37 +00:00
// ------>------ ----- (host components) -----
// | | | |
// ------------------- ----------------------- ----------------------- ---------------- ------ --------- -----------------
// |trace data source|-->|target tracing module|<--->|TRAX_MEM0 | TRAX_MEM1|---->|TRAX_DATA_REGS|<-->|JTAG|<--->|OpenOCD|-->|trace data sink|
// ------------------- ----------------------- ----------------------- ---------------- ------ --------- -----------------
// | | | |
// | ------<------ ---------------- |
// |<------------------------------------------->|TRAX_CTRL_REGS|<---->|
// ----------------
2019-01-24 04:43:06 +00:00
// In general tracing goes in the following way. User application requests tracing module to send some data by calling esp_apptrace_buffer_get(),
2017-03-22 03:07:37 +00:00
// module allocates necessary buffer in current input trace block. Then user fills received buffer with data and calls esp_apptrace_buffer_put().
2017-01-25 16:35:28 +00:00
// When current input trace block is filled with app data it is exposed to host and the second block becomes input one and buffer filling restarts.
2017-03-22 03:07:37 +00:00
// While target application fills one TRAX block host reads another one via JTAG.
// This module also allows communication in the opposite direction: from host to target. As it was said ESP32 and host can access different TRAX blocks
// simultaneously, so while target writes trace data to one block host can write its own data (e.g. tracing commands) to another one then when
// blocks are switched host receives trace data and target receives data written by host application. Target user application can read host data
// by calling esp_apptrace_read() API.
2017-01-25 16:35:28 +00:00
// To control buffer switching and for other communication purposes this implementation uses some TRAX registers. It is safe since HW TRAX tracing
// can not be used along with application tracing feature so these registers are freely readable/writeable via JTAG from host and via ERI from ESP32 cores.
2017-03-22 03:07:37 +00:00
// Overhead of this implementation on target CPU is produced only by allocating/managing buffers and copying of data.
// On the host side special OpenOCD command must be used to read trace data.
2017-01-25 16:35:28 +00:00
2017-03-22 03:07:37 +00:00
// 2. TRAX Registers layout
// ========================
2017-01-25 16:35:28 +00:00
// This module uses two TRAX HW registers to communicate with host SW (OpenOCD).
// - Control register uses TRAX_DELAYCNT as storage. Only lower 24 bits of TRAX_DELAYCNT are writable. Control register has the following bitfields:
// | 31..XXXXXX..24 | 23 .(host_connect). 23| 22..(block_id)..15 | 14..(block_len)..0 |
// 14..0 bits - actual length of user data in trace memory block. Target updates it every time it fills memory block and exposes it to host.
// Host writes zero to this field when it finishes reading exposed block;
2017-03-22 03:07:37 +00:00
// 21..15 bits - trace memory block transfer ID. Block counter. It can overflow. Updated by target, host should not modify it. Actually can be 2 bits;
// 22 bit - 'host data present' flag. If set to one there is data from host, otherwise - no host data;
2017-01-25 16:35:28 +00:00
// 23 bit - 'host connected' flag. If zero then host is not connected and tracing module works in post-mortem mode, otherwise in streaming mode;
2019-01-24 04:43:06 +00:00
// - Status register uses TRAX_TRIGGERPC as storage. If this register is not zero then current CPU is changing TRAX registers and
2017-01-25 16:35:28 +00:00
// this register holds address of the instruction which application will execute when it finishes with those registers modifications.
// See 'Targets Connection' setion for details.
// 3. Modes of operation
// =====================
// This module supports two modes of operation:
// - Post-mortem mode. This is the default mode. In this mode application tracing module does not check whether host has read all the data from block
// exposed to it and switches block in any case. The mode does not need host interaction for operation and so can be useful when only the latest
// trace data are necessary, e.g. for analyzing crashes. On panic the latest data from current input block are exposed to host and host can read them.
2017-03-22 03:07:37 +00:00
// It can happen that system panic occurs when there are very small amount of data which are not exposed to host yet (e.g. crash just after the
// TRAX block switch). In this case the previous 16KB of collected data will be dropped and host will see the latest, but very small piece of trace.
2019-05-09 11:34:34 +00:00
// It can be insufficient to diagnose the problem. To avoid such situations there is menuconfig option
// CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH
2017-03-22 03:07:37 +00:00
// which controls the threshold for flushing data in case of panic.
// - Streaming mode. Tracing module enters this mode when host connects to target and sets respective bits in control registers (per core).
// In this mode before switching the block tracing module waits for the host to read all the data from the previously exposed block.
// On panic tracing module also waits (timeout is configured via menuconfig via CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO) for the host to read all data.
2017-01-25 16:35:28 +00:00
// 4. Communication Protocol
// =========================
// 4.1 Trace Memory Blocks
2017-03-22 03:07:37 +00:00
// -----------------------
2017-01-25 16:35:28 +00:00
2019-01-24 04:43:06 +00:00
// Communication is controlled via special register. Host periodically polls control register on each core to find out if there are any data available.
2017-03-22 03:07:37 +00:00
// When current input memory block is filled it is exposed to host and 'block_len' and 'block_id' fields are updated in the control register.
// Host reads new register value and according to it's value starts reading data from exposed block. Meanwhile target starts filling another trace block.
// When host finishes reading the block it clears 'block_len' field in control register indicating to the target that it is ready to accept the next one.
// If the host has some data to transfer to the target it writes them to trace memory block before clearing 'block_len' field. Then it sets
// 'host_data_present' bit and clears 'block_len' field in control register. Upon every block switch target checks 'host_data_present' bit and if it is set
// reads them to down buffer before writing any trace data to switched TRAX block.
2017-01-25 16:35:28 +00:00
// 4.2 User Data Chunks Level
// --------------------------
// Since trace memory block is shared between user data chunks and data copying is performed on behalf of the API user (in its normal context) in
// multithreading environment it can happen that task/ISR which copies data is preempted by another high prio task/ISR. So it is possible situation
// that task/ISR will fail to complete filling its data chunk before the whole trace block is exposed to the host. To handle such conditions tracing
2017-03-22 03:07:37 +00:00
// module prepends all user data chunks with header which contains allocated buffer size and actual data length within it. OpenOCD command
2019-01-24 04:43:06 +00:00
// which reads application traces reports error when it reads incomplete user data block.
// Data which are transffered from host to target are also prepended with a header. Down channel data header is simple and consists of one two bytes field
// containing length of host data following the header.
2017-01-25 16:35:28 +00:00
2017-03-22 03:07:37 +00:00
// 4.3 Data Buffering
// ------------------
// It takes some time for the host to read TRAX memory block via JTAG. In streaming mode it can happen that target has filled its TRAX block, but host
// has not completed reading of the previous one yet. So in this case time critical tracing calls (which can not be delayed for too long time due to
// the lack of free memory in TRAX block) can be dropped. To avoid such scenarios tracing module implements data buffering. Buffered data will be sent
// to the host later when TRAX block switch occurs. The maximum size of the buffered data is controlled by menuconfig option
// CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX.
// 4.4 Target Connection/Disconnection
// -----------------------------------
2017-01-25 16:35:28 +00:00
// When host is going to start tracing in streaming mode it needs to put both ESP32 cores into initial state when 'host connected' bit is set
// on both cores. To accomplish this host halts both cores and sets this bit in TRAX registers. But target code can be halted in state when it has read control
// register but has not updated its value. To handle such situations target code indicates to the host that it is updating control register by writing
// non-zero value to status register. Actually it writes address of the instruction which it will execute when it finishes with
// the registers update. When target is halted during control register update host sets breakpoint at the address from status register and resumes CPU.
// After target code finishes with register update it is halted on breakpoint, host detects it and safely sets 'host connected' bit. When both cores
// are set up they are resumed. Tracing starts without further intrusion into CPUs work.
// When host is going to stop tracing in streaming mode it needs to disconnect targets. Disconnection process is done using the same algorithm
// as for connecting, but 'host connected' bits are cleared on ESP32 cores.
// 5. Module Access Synchronization
// ================================
// Access to internal module's data is synchronized with custom mutex. Mutex is a wrapper for portMUX_TYPE and uses almost the same sync mechanism as in
// vPortCPUAcquireMutex/vPortCPUReleaseMutex. The mechanism uses S32C1I Xtensa instruction to implement exclusive access to module's data from tasks and
// ISRs running on both cores. Also custom mutex allows specifying timeout for locking operation. Locking routine checks underlaying mutex in cycle until
// it gets its ownership or timeout expires. The differences of application tracing module's mutex implementation from vPortCPUAcquireMutex/vPortCPUReleaseMutex are:
// - Support for timeouts.
// - Local IRQs for CPU which owns the mutex are disabled till the call to unlocking routine. This is made to avoid possible task's prio inversion.
// When low prio task takes mutex and enables local IRQs gets preempted by high prio task which in its turn can try to acquire mutex using infinite timeout.
// So no local task switch occurs when mutex is locked. But this does not apply to tasks on another CPU.
// WARNING: Priority inversion can happen when low prio task works on one CPU and medium and high prio tasks work on another.
2017-03-22 03:07:37 +00:00
// WARNING: Care must be taken when selecting timeout values for trace calls from ISRs. Tracing module does not care about watchdogs when waiting
2019-01-24 04:43:06 +00:00
// on internal locks and for host to complete previous block reading, so if timeout value exceeds watchdog's one it can lead to the system reboot.
2017-01-25 16:35:28 +00:00
// 6. Timeouts
2017-03-22 03:07:37 +00:00
// ===========
2017-01-25 16:35:28 +00:00
2019-01-24 04:43:06 +00:00
// Timeout mechanism is based on xthal_get_ccount() routine and supports timeout values in microseconds.
2017-01-25 16:35:28 +00:00
// There are two situations when task/ISR can be delayed by tracing API call. Timeout mechanism takes into account both conditions:
// - Trace data are locked by another task/ISR. When wating on trace data lock.
// - Current TRAX memory input block is full when working in streaming mode (host is connected). When waiting for host to complete previous block reading.
// When wating for any of above conditions xthal_get_ccount() is called periodically to calculate time elapsed from trace API routine entry. When elapsed
// time exceeds specified timeout value operation is canceled and ESP_ERR_TIMEOUT code is returned.
# include <string.h>
2018-02-14 15:11:28 +00:00
# include <sys/param.h>
2017-01-25 16:35:28 +00:00
# include "soc/soc.h"
# include "soc/dport_reg.h"
# include "eri.h"
# include "trax.h"
2019-05-13 10:02:45 +00:00
# include "soc/timer_periph.h"
2017-07-24 16:57:44 +00:00
# include "freertos/FreeRTOS.h"
2017-01-25 16:35:28 +00:00
# include "esp_app_trace.h"
# if CONFIG_ESP32_APPTRACE_ENABLE
# define ESP_APPTRACE_MAX_VPRINTF_ARGS 256
2017-03-22 03:07:37 +00:00
# define ESP_APPTRACE_HOST_BUF_SIZE 256
2017-01-25 16:35:28 +00:00
2017-03-22 03:07:37 +00:00
# define ESP_APPTRACE_PRINT_LOCK 0
2017-01-25 16:35:28 +00:00
# include "esp_log.h"
const static char * TAG = " esp_apptrace " ;
2017-03-22 03:07:37 +00:00
# if ESP_APPTRACE_PRINT_LOCK
2017-01-25 16:35:28 +00:00
# define ESP_APPTRACE_LOG( format, ... ) \
do { \
esp_apptrace_log_lock ( ) ; \
ets_printf ( format , # # __VA_ARGS__ ) ; \
esp_apptrace_log_unlock ( ) ; \
} while ( 0 )
# else
# define ESP_APPTRACE_LOG( format, ... ) \
do { \
ets_printf ( format , # # __VA_ARGS__ ) ; \
} while ( 0 )
# endif
# define ESP_APPTRACE_LOG_LEV( _L_, level, format, ... ) \
do { \
if ( LOG_LOCAL_LEVEL > = level ) { \
ESP_APPTRACE_LOG ( LOG_FORMAT ( _L_ , format ) , esp_log_early_timestamp ( ) , TAG , # # __VA_ARGS__ ) ; \
} \
} while ( 0 )
# define ESP_APPTRACE_LOGE( format, ... ) ESP_APPTRACE_LOG_LEV(E, ESP_LOG_ERROR, format, ##__VA_ARGS__)
# define ESP_APPTRACE_LOGW( format, ... ) ESP_APPTRACE_LOG_LEV(W, ESP_LOG_WARN, format, ##__VA_ARGS__)
# define ESP_APPTRACE_LOGI( format, ... ) ESP_APPTRACE_LOG_LEV(I, ESP_LOG_INFO, format, ##__VA_ARGS__)
# define ESP_APPTRACE_LOGD( format, ... ) ESP_APPTRACE_LOG_LEV(D, ESP_LOG_DEBUG, format, ##__VA_ARGS__)
# define ESP_APPTRACE_LOGV( format, ... ) ESP_APPTRACE_LOG_LEV(V, ESP_LOG_VERBOSE, format, ##__VA_ARGS__)
# define ESP_APPTRACE_LOGO( format, ... ) ESP_APPTRACE_LOG_LEV(E, ESP_LOG_NONE, format, ##__VA_ARGS__)
// TODO: move these (and same definitions in trax.c to dport_reg.h)
# define TRACEMEM_MUX_PROBLK0_APPBLK1 0
# define TRACEMEM_MUX_BLK0_ONLY 1
# define TRACEMEM_MUX_BLK1_ONLY 2
# define TRACEMEM_MUX_PROBLK1_APPBLK0 3
// TRAX is disabled, so we use its registers for our own purposes
2017-03-22 03:07:37 +00:00
// | 31..XXXXXX..24 | 23 .(host_connect). 23 | 22 .(host_data). 22| 21..(block_id)..15 | 14..(block_len)..0 |
2017-01-25 16:35:28 +00:00
# define ESP_APPTRACE_TRAX_CTRL_REG ERI_TRAX_DELAYCNT
# define ESP_APPTRACE_TRAX_STAT_REG ERI_TRAX_TRIGGERPC
# define ESP_APPTRACE_TRAX_BLOCK_LEN_MSK 0x7FFFUL
# define ESP_APPTRACE_TRAX_BLOCK_LEN(_l_) ((_l_) & ESP_APPTRACE_TRAX_BLOCK_LEN_MSK)
# define ESP_APPTRACE_TRAX_BLOCK_LEN_GET(_v_) ((_v_) & ESP_APPTRACE_TRAX_BLOCK_LEN_MSK)
2017-03-22 03:07:37 +00:00
# define ESP_APPTRACE_TRAX_BLOCK_ID_MSK 0x7FUL
2017-01-25 16:35:28 +00:00
# define ESP_APPTRACE_TRAX_BLOCK_ID(_id_) (((_id_) & ESP_APPTRACE_TRAX_BLOCK_ID_MSK) << 15)
# define ESP_APPTRACE_TRAX_BLOCK_ID_GET(_v_) (((_v_) >> 15) & ESP_APPTRACE_TRAX_BLOCK_ID_MSK)
2017-03-22 03:07:37 +00:00
# define ESP_APPTRACE_TRAX_HOST_DATA (1 << 22)
2017-01-25 16:35:28 +00:00
# define ESP_APPTRACE_TRAX_HOST_CONNECT (1 << 23)
2017-03-22 03:07:37 +00:00
# if CONFIG_SYSVIEW_ENABLE
# define ESP_APPTRACE_USR_BLOCK_CORE(_cid_) (0)
# define ESP_APPTRACE_USR_BLOCK_LEN(_v_) (_v_)
# else
# define ESP_APPTRACE_USR_BLOCK_CORE(_cid_) ((_cid_) << 15)
# define ESP_APPTRACE_USR_BLOCK_LEN(_v_) (~(1 << 15) & (_v_))
# endif
# define ESP_APPTRACE_USR_BLOCK_RAW_SZ(_s_) ((_s_) + sizeof(esp_tracedata_hdr_t))
2017-01-25 16:35:28 +00:00
static volatile uint8_t * s_trax_blocks [ ] = {
( volatile uint8_t * ) 0x3FFFC000 ,
( volatile uint8_t * ) 0x3FFF8000
} ;
# define ESP_APPTRACE_TRAX_BLOCKS_NUM (sizeof(s_trax_blocks) / sizeof(s_trax_blocks[0]))
2017-03-22 03:07:37 +00:00
# define ESP_APPTRACE_TRAX_INBLOCK_START 0
2017-01-25 16:35:28 +00:00
2017-03-22 03:07:37 +00:00
# define ESP_APPTRACE_TRAX_INBLOCK_MARKER() (s_trace_buf.trax.state.markers[s_trace_buf.trax.state.in_block % 2])
# define ESP_APPTRACE_TRAX_INBLOCK_MARKER_UPD(_v_) do {s_trace_buf.trax.state.markers[s_trace_buf.trax.state.in_block % 2] += (_v_);}while(0)
2017-01-25 16:35:28 +00:00
# define ESP_APPTRACE_TRAX_INBLOCK_GET() (&s_trace_buf.trax.blocks[s_trace_buf.trax.state.in_block % 2])
2017-07-24 16:57:44 +00:00
# define ESP_APPTRACE_TRAX_BLOCK_SIZE (0x4000UL)
2017-03-22 03:07:37 +00:00
# if CONFIG_SYSVIEW_ENABLE
# define ESP_APPTRACE_USR_DATA_LEN_MAX 255UL
# else
# define ESP_APPTRACE_USR_DATA_LEN_MAX (ESP_APPTRACE_TRAX_BLOCK_SIZE - sizeof(esp_tracedata_hdr_t))
2017-01-25 16:35:28 +00:00
# endif
2017-08-16 23:36:00 +00:00
# define ESP_APPTRACE_HW_TRAX 0
# define ESP_APPTRACE_HW_MAX 1
# define ESP_APPTRACE_HW(_i_) (&s_trace_hw[_i_])
2017-01-25 16:35:28 +00:00
/** Trace data header. Every user data chunk is prepended with this header.
* User allocates block with esp_apptrace_buffer_get and then fills it with data ,
* in multithreading environment it can happen that tasks gets buffer and then gets interrupted ,
* so it is possible that user data are incomplete when TRAX memory block is exposed to the host .
* In this case host SW will see that wr_sz < block_sz and will report error .
*/
typedef struct {
2017-03-22 03:07:37 +00:00
# if CONFIG_SYSVIEW_ENABLE
uint8_t block_sz ; // size of allocated block for user data
uint8_t wr_sz ; // size of actually written data
# else
2017-01-25 16:35:28 +00:00
uint16_t block_sz ; // size of allocated block for user data
uint16_t wr_sz ; // size of actually written data
2017-03-22 03:07:37 +00:00
# endif
2017-01-25 16:35:28 +00:00
} esp_tracedata_hdr_t ;
2017-03-22 03:07:37 +00:00
/** TODO: docs
*/
typedef struct {
uint16_t block_sz ; // size of allocated block for user data
} esp_hostdata_hdr_t ;
2017-01-25 16:35:28 +00:00
/** TRAX HW transport state */
typedef struct {
uint32_t in_block ; // input block ID
2017-03-22 03:07:37 +00:00
// TODO: change to uint16_t
2017-01-25 16:35:28 +00:00
uint32_t markers [ ESP_APPTRACE_TRAX_BLOCKS_NUM ] ; // block filling level markers
} esp_apptrace_trax_state_t ;
/** memory block parameters */
typedef struct {
uint8_t * start ; // start address
2017-03-22 03:07:37 +00:00
uint16_t sz ; // size
2017-01-25 16:35:28 +00:00
} esp_apptrace_mem_block_t ;
/** TRAX HW transport data */
typedef struct {
volatile esp_apptrace_trax_state_t state ; // state
esp_apptrace_mem_block_t blocks [ ESP_APPTRACE_TRAX_BLOCKS_NUM ] ; // memory blocks
2017-03-22 03:07:37 +00:00
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
// ring buffer control struct for pending user blocks
esp_apptrace_rb_t rb_pend ;
// storage for pending user blocks
uint8_t pending_data [ CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX + 1 ] ;
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
// ring buffer control struct for pending user data chunks sizes,
// every chunk contains whole number of user blocks and fit into TRAX memory block
esp_apptrace_rb_t rb_pend_chunk_sz ;
// storage for above ring buffer data
uint16_t pending_chunk_sz [ CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX / ESP_APPTRACE_TRAX_BLOCK_SIZE + 2 ] ;
// current (accumulated) pending user data chunk size
uint16_t cur_pending_chunk_sz ;
# endif
# endif
2017-01-25 16:35:28 +00:00
} esp_apptrace_trax_data_t ;
/** tracing module internal data */
typedef struct {
esp_apptrace_lock_t lock ; // sync lock
uint8_t inited ; // module initialization state flag
2017-03-22 03:07:37 +00:00
// ring buffer control struct for data from host (down buffer)
esp_apptrace_rb_t rb_down ;
// storage for above ring buffer data
2017-01-25 16:35:28 +00:00
esp_apptrace_trax_data_t trax ; // TRAX HW transport data
} esp_apptrace_buffer_t ;
2017-03-22 03:07:37 +00:00
static esp_apptrace_buffer_t s_trace_buf ;
2017-01-25 16:35:28 +00:00
2017-03-22 03:07:37 +00:00
# if ESP_APPTRACE_PRINT_LOCK
static esp_apptrace_lock_t s_log_lock = { . irq_stat = 0 , . portmux = portMUX_INITIALIZER_UNLOCKED } ;
2017-01-25 16:35:28 +00:00
# endif
2017-08-16 23:36:00 +00:00
typedef struct {
uint8_t * ( * get_up_buffer ) ( uint32_t , esp_apptrace_tmo_t * ) ;
esp_err_t ( * put_up_buffer ) ( uint8_t * , esp_apptrace_tmo_t * ) ;
esp_err_t ( * flush_up_buffer ) ( uint32_t , esp_apptrace_tmo_t * ) ;
uint8_t * ( * get_down_buffer ) ( uint32_t * , esp_apptrace_tmo_t * ) ;
esp_err_t ( * put_down_buffer ) ( uint8_t * , esp_apptrace_tmo_t * ) ;
bool ( * host_is_connected ) ( void ) ;
2018-02-15 17:09:03 +00:00
esp_err_t ( * status_reg_set ) ( uint32_t val ) ;
esp_err_t ( * status_reg_get ) ( uint32_t * val ) ;
2017-08-16 23:36:00 +00:00
} esp_apptrace_hw_t ;
2017-07-24 16:57:44 +00:00
static uint32_t esp_apptrace_trax_down_buffer_write_nolock ( uint8_t * data , uint32_t size ) ;
static esp_err_t esp_apptrace_trax_flush ( uint32_t min_sz , esp_apptrace_tmo_t * tmo ) ;
2017-08-16 23:36:00 +00:00
static uint8_t * esp_apptrace_trax_get_buffer ( uint32_t size , esp_apptrace_tmo_t * tmo ) ;
static esp_err_t esp_apptrace_trax_put_buffer ( uint8_t * ptr , esp_apptrace_tmo_t * tmo ) ;
static bool esp_apptrace_trax_host_is_connected ( void ) ;
static uint8_t * esp_apptrace_trax_down_buffer_get ( uint32_t * size , esp_apptrace_tmo_t * tmo ) ;
s tatic esp_err_t esp_apptrace_trax_down_buffer_put ( uint8_t * ptr , esp_apptrace_tmo_t * tmo ) ;
2018-02-15 17:09:03 +00:00
static esp_err_t esp_apptrace_trax_status_reg_set ( uint32_t val ) ;
static esp_err_t esp_apptrace_trax_status_reg_get ( uint32_t * val ) ;
2017-08-16 23:36:00 +00:00
static esp_apptrace_hw_t s_trace_hw [ ESP_APPTRACE_HW_MAX ] = {
{
. get_up_buffer = esp_apptrace_trax_get_buffer ,
. put_up_buffer = esp_apptrace_trax_put_buffer ,
. flush_up_buffer = esp_apptrace_trax_flush ,
. get_down_buffer = esp_apptrace_trax_down_buffer_get ,
. put_down_buffer = esp_apptrace_trax_down_buffer_put ,
2018-02-15 17:09:03 +00:00
. host_is_connected = esp_apptrace_trax_host_is_connected ,
. status_reg_set = esp_apptrace_trax_status_reg_set ,
. status_reg_get = esp_apptrace_trax_status_reg_get
2017-08-16 23:36:00 +00:00
}
} ;
2017-01-25 16:35:28 +00:00
static inline int esp_apptrace_log_lock ( )
{
2017-03-22 03:07:37 +00:00
# if ESP_APPTRACE_PRINT_LOCK
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
esp_apptrace_tmo_init ( & tmo , ESP_APPTRACE_TMO_INFINITE ) ;
int ret = esp_apptrace_lock_take ( & s_log_lock , & tmo ) ;
2017-01-25 16:35:28 +00:00
return ret ;
2017-03-22 03:07:37 +00:00
# else
2017-01-25 16:35:28 +00:00
return 0 ;
2017-03-22 03:07:37 +00:00
# endif
2017-01-25 16:35:28 +00:00
}
static inline void esp_apptrace_log_unlock ( )
{
2017-03-22 03:07:37 +00:00
# if ESP_APPTRACE_PRINT_LOCK
esp_apptrace_lock_give ( & s_log_lock ) ;
2017-01-25 16:35:28 +00:00
# endif
}
2017-07-24 16:57:44 +00:00
static inline esp_err_t esp_apptrace_lock_initialize ( )
2017-01-25 16:35:28 +00:00
{
2017-07-24 16:57:44 +00:00
# if CONFIG_ESP32_APPTRACE_LOCK_ENABLE
2017-03-22 03:07:37 +00:00
esp_apptrace_lock_init ( & s_trace_buf . lock ) ;
2017-01-25 16:35:28 +00:00
# endif
return ESP_OK ;
}
2017-07-24 16:57:44 +00:00
static inline esp_err_t esp_apptrace_lock_cleanup ( )
2017-01-25 16:35:28 +00:00
{
return ESP_OK ;
}
2017-07-24 16:57:44 +00:00
esp_err_t esp_apptrace_lock ( esp_apptrace_tmo_t * tmo )
2017-01-25 16:35:28 +00:00
{
2017-07-24 16:57:44 +00:00
# if CONFIG_ESP32_APPTRACE_LOCK_ENABLE
esp_err_t ret = esp_apptrace_lock_take ( & s_trace_buf . lock , tmo ) ;
2017-01-25 16:35:28 +00:00
if ( ret ! = ESP_OK ) {
return ESP_FAIL ;
}
2017-03-22 03:07:37 +00:00
# endif
2017-01-25 16:35:28 +00:00
return ESP_OK ;
}
esp_err_t esp_apptrace_unlock ( )
{
esp_err_t ret = ESP_OK ;
2017-07-24 16:57:44 +00:00
# if CONFIG_ESP32_APPTRACE_LOCK_ENABLE
2017-03-22 03:07:37 +00:00
ret = esp_apptrace_lock_give ( & s_trace_buf . lock ) ;
2017-01-25 16:35:28 +00:00
# endif
return ret ;
}
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
static void esp_apptrace_trax_init ( )
{
// Stop trace, if any (on the current CPU)
eri_write ( ERI_TRAX_TRAXCTRL , TRAXCTRL_TRSTP ) ;
eri_write ( ERI_TRAX_TRAXCTRL , TRAXCTRL_TMEN ) ;
eri_write ( ESP_APPTRACE_TRAX_CTRL_REG , ESP_APPTRACE_TRAX_BLOCK_ID ( ESP_APPTRACE_TRAX_INBLOCK_START ) ) ;
2018-02-15 17:09:03 +00:00
// this is for OpenOCD to let him know where stub entries vector is resided
// must be read by host before any transfer using TRAX
2017-01-25 16:35:28 +00:00
eri_write ( ESP_APPTRACE_TRAX_STAT_REG , 0 ) ;
ESP_APPTRACE_LOGI ( " Initialized TRAX on CPU%d " , xPortGetCoreID ( ) ) ;
}
2017-03-22 03:07:37 +00:00
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
// keep the size of buffered data for copying to TRAX mem block.
// Only whole user blocks should be copied from buffer to TRAX block upon the switch
static void esp_apptrace_trax_pend_chunk_sz_update ( uint16_t size )
{
ESP_APPTRACE_LOGD ( " Update chunk enter %d/%d w-r-s %d-%d-%d " , s_trace_buf . trax . cur_pending_chunk_sz , size ,
s_trace_buf . trax . rb_pend_chunk_sz . wr , s_trace_buf . trax . rb_pend_chunk_sz . rd , s_trace_buf . trax . rb_pend_chunk_sz . cur_size ) ;
if ( ( uint32_t ) s_trace_buf . trax . cur_pending_chunk_sz + ( uint32_t ) size < = ESP_APPTRACE_TRAX_BLOCK_SIZE ) {
ESP_APPTRACE_LOGD ( " Update chunk %d/%d " , s_trace_buf . trax . cur_pending_chunk_sz , size ) ;
s_trace_buf . trax . cur_pending_chunk_sz + = size ;
} else {
uint16_t * chunk_sz = ( uint16_t * ) esp_apptrace_rb_produce ( & s_trace_buf . trax . rb_pend_chunk_sz , sizeof ( uint16_t ) ) ;
if ( ! chunk_sz ) {
assert ( false & & " Failed to alloc pended chunk sz slot! " ) ;
} else {
ESP_APPTRACE_LOGD ( " Update new chunk %d/%d " , s_trace_buf . trax . cur_pending_chunk_sz , size ) ;
* chunk_sz = s_trace_buf . trax . cur_pending_chunk_sz ;
s_trace_buf . trax . cur_pending_chunk_sz = size ;
}
}
}
static uint16_t esp_apptrace_trax_pend_chunk_sz_get ( )
{
uint16_t ch_sz ;
ESP_APPTRACE_LOGD ( " Get chunk enter %d w-r-s %d-%d-%d " , s_trace_buf . trax . cur_pending_chunk_sz ,
s_trace_buf . trax . rb_pend_chunk_sz . wr , s_trace_buf . trax . rb_pend_chunk_sz . rd , s_trace_buf . trax . rb_pend_chunk_sz . cur_size ) ;
uint16_t * chunk_sz = ( uint16_t * ) esp_apptrace_rb_consume ( & s_trace_buf . trax . rb_pend_chunk_sz , sizeof ( uint16_t ) ) ;
if ( ! chunk_sz ) {
ch_sz = s_trace_buf . trax . cur_pending_chunk_sz ;
s_trace_buf . trax . cur_pending_chunk_sz = 0 ;
} else {
ch_sz = * chunk_sz ;
}
return ch_sz ;
}
# endif
2017-01-25 16:35:28 +00:00
// assumed to be protected by caller from multi-core/thread access
static esp_err_t esp_apptrace_trax_block_switch ( )
{
int prev_block_num = s_trace_buf . trax . state . in_block % 2 ;
int new_block_num = prev_block_num ? ( 0 ) : ( 1 ) ;
int res = ESP_OK ;
extern uint32_t __esp_apptrace_trax_eri_updated ;
// indicate to host that we are about to update.
// this is used only to place CPU into streaming mode at tracing startup
// before starting streaming host can halt us after we read ESP_APPTRACE_TRAX_CTRL_REG and before we updated it
// HACK: in this case host will set breakpoint just after ESP_APPTRACE_TRAX_CTRL_REG update,
// here we set address to set bp at
// enter ERI update critical section
eri_write ( ESP_APPTRACE_TRAX_STAT_REG , ( uint32_t ) & __esp_apptrace_trax_eri_updated ) ;
uint32_t ctrl_reg = eri_read ( ESP_APPTRACE_TRAX_CTRL_REG ) ;
uint32_t host_connected = ESP_APPTRACE_TRAX_HOST_CONNECT & ctrl_reg ;
if ( host_connected ) {
uint32_t acked_block = ESP_APPTRACE_TRAX_BLOCK_ID_GET ( ctrl_reg ) ;
uint32_t host_to_read = ESP_APPTRACE_TRAX_BLOCK_LEN_GET ( ctrl_reg ) ;
if ( host_to_read ! = 0 | | acked_block ! = ( s_trace_buf . trax . state . in_block & ESP_APPTRACE_TRAX_BLOCK_ID_MSK ) ) {
2017-03-22 03:07:37 +00:00
ESP_APPTRACE_LOGD ( " HC[%d]: Can not switch %x %d %x %x/%lx, m %d " , xPortGetCoreID ( ) , ctrl_reg , host_to_read , acked_block ,
2017-07-24 16:57:44 +00:00
s_trace_buf . trax . state . in_block & ESP_APPTRACE_TRAX_BLOCK_ID_MSK , s_trace_buf . trax . state . in_block ,
s_trace_buf . trax . state . markers [ prev_block_num ] ) ;
2017-01-25 16:35:28 +00:00
res = ESP_ERR_NO_MEM ;
goto _on_func_exit ;
}
}
s_trace_buf . trax . state . markers [ new_block_num ] = 0 ;
// switch to new block
s_trace_buf . trax . state . in_block + + ;
2017-05-08 12:03:04 +00:00
DPORT_WRITE_PERI_REG ( DPORT_TRACEMEM_MUX_MODE_REG , new_block_num ? TRACEMEM_MUX_BLK0_ONLY : TRACEMEM_MUX_BLK1_ONLY ) ;
2017-03-22 03:07:37 +00:00
// handle data from host
esp_hostdata_hdr_t * hdr = ( esp_hostdata_hdr_t * ) s_trace_buf . trax . blocks [ new_block_num ] . start ;
if ( ctrl_reg & ESP_APPTRACE_TRAX_HOST_DATA & & hdr - > block_sz > 0 ) {
// TODO: add support for multiple blocks from host, currently there is no need for that
uint8_t * p = s_trace_buf . trax . blocks [ new_block_num ] . start + s_trace_buf . trax . blocks [ new_block_num ] . sz ;
2017-07-24 16:57:44 +00:00
ESP_APPTRACE_LOGD ( " Recvd %d bytes from host [%x %x %x %x %x %x %x %x .. %x %x %x %x %x %x %x %x] " , hdr - > block_sz ,
2017-03-22 03:07:37 +00:00
* ( s_trace_buf . trax . blocks [ new_block_num ] . start + 0 ) , * ( s_trace_buf . trax . blocks [ new_block_num ] . start + 1 ) ,
2017-07-24 16:57:44 +00:00
* ( s_trace_buf . trax . blocks [ new_block_num ] . start + 2 ) , * ( s_trace_buf . trax . blocks [ new_block_num ] . start + 3 ) ,
* ( s_trace_buf . trax . blocks [ new_block_num ] . start + 4 ) , * ( s_trace_buf . trax . blocks [ new_block_num ] . start + 5 ) ,
* ( s_trace_buf . trax . blocks [ new_block_num ] . start + 6 ) , * ( s_trace_buf . trax . blocks [ new_block_num ] . start + 7 ) ,
* ( p - 8 ) , * ( p - 7 ) , * ( p - 6 ) , * ( p - 5 ) , * ( p - 4 ) , * ( p - 3 ) , * ( p - 2 ) , * ( p - 1 ) ) ;
uint32_t sz = esp_apptrace_trax_down_buffer_write_nolock ( ( uint8_t * ) ( hdr + 1 ) , hdr - > block_sz ) ;
2017-03-22 03:07:37 +00:00
if ( sz ! = hdr - > block_sz ) {
2017-07-24 16:57:44 +00:00
ESP_APPTRACE_LOGE ( " Failed to write %d bytes to down buffer (%d %d)! " , hdr - > block_sz - sz , hdr - > block_sz , sz ) ;
2017-03-22 03:07:37 +00:00
}
hdr - > block_sz = 0 ;
}
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
// copy pending data to TRAX block if any
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
uint16_t max_chunk_sz = esp_apptrace_trax_pend_chunk_sz_get ( ) ;
# else
uint16_t max_chunk_sz = s_trace_buf . trax . blocks [ new_block_num ] . sz ;
# endif
while ( s_trace_buf . trax . state . markers [ new_block_num ] < max_chunk_sz ) {
uint32_t read_sz = esp_apptrace_rb_read_size_get ( & s_trace_buf . trax . rb_pend ) ;
if ( read_sz = = 0 ) {
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
/* theres is a bug: esp_apptrace_trax_pend_chunk_sz_get returned wrong value,
it must be greater or equal to one returned by esp_apptrace_rb_read_size_get */
ESP_APPTRACE_LOGE ( " No pended bytes, must be > 0 and <= %d! " , max_chunk_sz ) ;
# endif
break ;
}
if ( read_sz > max_chunk_sz - s_trace_buf . trax . state . markers [ new_block_num ] ) {
read_sz = max_chunk_sz - s_trace_buf . trax . state . markers [ new_block_num ] ;
}
uint8_t * ptr = esp_apptrace_rb_consume ( & s_trace_buf . trax . rb_pend , read_sz ) ;
if ( ! ptr ) {
assert ( false & & " Failed to consume pended bytes!! " ) ;
break ;
}
if ( host_connected ) {
ESP_APPTRACE_LOGD ( " Pump %d pend bytes [%x %x %x %x : %x %x %x %x : %x %x %x %x : %x %x...%x %x] " ,
read_sz , * ( ptr + 0 ) , * ( ptr + 1 ) , * ( ptr + 2 ) , * ( ptr + 3 ) , * ( ptr + 4 ) ,
* ( ptr + 5 ) , * ( ptr + 6 ) , * ( ptr + 7 ) , * ( ptr + 8 ) , * ( ptr + 9 ) , * ( ptr + 10 ) , * ( ptr + 11 ) , * ( ptr + 12 ) , * ( ptr + 13 ) , * ( ptr + read_sz - 2 ) , * ( ptr + read_sz - 1 ) ) ;
}
memcpy ( s_trace_buf . trax . blocks [ new_block_num ] . start + s_trace_buf . trax . state . markers [ new_block_num ] , ptr , read_sz ) ;
s_trace_buf . trax . state . markers [ new_block_num ] + = read_sz ;
}
# endif
2017-01-25 16:35:28 +00:00
eri_write ( ESP_APPTRACE_TRAX_CTRL_REG , ESP_APPTRACE_TRAX_BLOCK_ID ( s_trace_buf . trax . state . in_block ) |
host_connected | ESP_APPTRACE_TRAX_BLOCK_LEN ( s_trace_buf . trax . state . markers [ prev_block_num ] ) ) ;
_on_func_exit :
// exit ERI update critical section
eri_write ( ESP_APPTRACE_TRAX_STAT_REG , 0x0 ) ;
2017-03-22 03:07:37 +00:00
// TODO: currently host sets breakpoint, use break instruction to stop;
// it will allow to use ESP_APPTRACE_TRAX_STAT_REG for other purposes
2017-01-25 16:35:28 +00:00
asm volatile (
" .global __esp_apptrace_trax_eri_updated \n "
" __esp_apptrace_trax_eri_updated: \n " ) ; // host will set bp here to resolve collision at streaming start
return res ;
}
2017-07-24 16:57:44 +00:00
static esp_err_t esp_apptrace_trax_block_switch_waitus ( esp_apptrace_tmo_t * tmo )
2017-01-25 16:35:28 +00:00
{
int res ;
while ( ( res = esp_apptrace_trax_block_switch ( ) ) ! = ESP_OK ) {
2017-07-24 16:57:44 +00:00
res = esp_apptrace_tmo_check ( tmo ) ;
2017-01-25 16:35:28 +00:00
if ( res ! = ESP_OK ) {
break ;
}
}
return res ;
}
2017-07-24 16:57:44 +00:00
static uint8_t * esp_apptrace_trax_down_buffer_get ( uint32_t * size , esp_apptrace_tmo_t * tmo )
2017-01-25 16:35:28 +00:00
{
2017-07-24 16:57:44 +00:00
uint8_t * ptr = NULL ;
2017-01-25 16:35:28 +00:00
int res = esp_apptrace_lock ( tmo ) ;
if ( res ! = ESP_OK ) {
return NULL ;
}
2017-07-24 16:57:44 +00:00
while ( 1 ) {
uint32_t sz = esp_apptrace_rb_read_size_get ( & s_trace_buf . rb_down ) ;
if ( sz ! = 0 ) {
2018-02-14 15:11:28 +00:00
* size = MIN ( * size , sz ) ;
ptr = esp_apptrace_rb_consume ( & s_trace_buf . rb_down , * size ) ;
2017-07-24 16:57:44 +00:00
if ( ! ptr ) {
assert ( false & & " Failed to consume bytes from down buffer! " ) ;
}
break ;
2017-01-25 16:35:28 +00:00
}
2017-07-24 16:57:44 +00:00
// may need to flush
uint32_t ctrl_reg = eri_read ( ESP_APPTRACE_TRAX_CTRL_REG ) ;
if ( ctrl_reg & ESP_APPTRACE_TRAX_HOST_DATA ) {
ESP_APPTRACE_LOGD ( " force flush " ) ;
res = esp_apptrace_trax_block_switch_waitus ( tmo ) ;
if ( res ! = ESP_OK ) {
ESP_APPTRACE_LOGE ( " Failed to switch to another block to recv data from host! " ) ;
/*do not return error because data can be in down buffer already*/
}
} else {
// check tmo only if there is no data from host
res = esp_apptrace_tmo_check ( tmo ) ;
if ( res ! = ESP_OK ) {
return NULL ;
}
2017-01-25 16:35:28 +00:00
}
}
2017-03-22 03:07:37 +00:00
if ( esp_apptrace_unlock ( ) ! = ESP_OK ) {
assert ( false & & " Failed to unlock apptrace data! " ) ;
}
return ptr ;
}
2017-01-25 16:35:28 +00:00
2017-08-16 23:36:00 +00:00
static esp_err_t esp_apptrace_trax_down_buffer_put ( uint8_t * ptr , esp_apptrace_tmo_t * tmo )
2017-03-22 03:07:37 +00:00
{
/* nothing todo */
return ESP_OK ;
}
2017-07-24 16:57:44 +00:00
static uint32_t esp_apptrace_trax_down_buffer_write_nolock ( uint8_t * data , uint32_t size )
2017-03-22 03:07:37 +00:00
{
2017-07-24 16:57:44 +00:00
uint32_t total_sz = 0 ;
while ( total_sz < size ) {
2017-08-16 23:36:00 +00:00
ESP_APPTRACE_LOGD ( " esp_apptrace_trax_down_buffer_write_nolock WRS %d-%d-%d %d " , s_trace_buf . rb_down . wr , s_trace_buf . rb_down . rd ,
s_trace_buf . rb_down . cur_size , size ) ;
2017-07-24 16:57:44 +00:00
uint32_t wr_sz = esp_apptrace_rb_write_size_get ( & s_trace_buf . rb_down ) ;
if ( wr_sz = = 0 ) {
break ;
}
if ( wr_sz > size - total_sz ) {
wr_sz = size - total_sz ;
}
2017-08-16 23:36:00 +00:00
ESP_APPTRACE_LOGD ( " esp_apptrace_trax_down_buffer_write_nolock wr %d " , wr_sz ) ;
2017-07-24 16:57:44 +00:00
uint8_t * ptr = esp_apptrace_rb_produce ( & s_trace_buf . rb_down , wr_sz ) ;
if ( ! ptr ) {
assert ( false & & " Failed to produce bytes to down buffer! " ) ;
}
2017-08-16 23:36:00 +00:00
ESP_APPTRACE_LOGD ( " esp_apptrace_trax_down_buffer_write_nolock wr %d to 0x%x from 0x%x " , wr_sz , ptr , data + total_sz + wr_sz ) ;
2017-07-24 16:57:44 +00:00
memcpy ( ptr , data + total_sz , wr_sz ) ;
total_sz + = wr_sz ;
2017-08-16 23:36:00 +00:00
ESP_APPTRACE_LOGD ( " esp_apptrace_trax_down_buffer_write_nolock wr %d/%d " , wr_sz , total_sz ) ;
2017-03-22 03:07:37 +00:00
}
2017-07-24 16:57:44 +00:00
return total_sz ;
2017-03-22 03:07:37 +00:00
}
static inline uint8_t * esp_apptrace_data_header_init ( uint8_t * ptr , uint16_t usr_size )
{
// it is safe to use xPortGetCoreID() in macro call because arg is used only once inside it
( ( esp_tracedata_hdr_t * ) ptr ) - > block_sz = ESP_APPTRACE_USR_BLOCK_CORE ( xPortGetCoreID ( ) ) | usr_size ;
( ( esp_tracedata_hdr_t * ) ptr ) - > wr_sz = 0 ;
return ptr + sizeof ( esp_tracedata_hdr_t ) ;
}
2017-07-24 16:57:44 +00:00
static inline uint8_t * esp_apptrace_trax_wait4buf ( uint16_t size , esp_apptrace_tmo_t * tmo , int * pended )
2017-03-22 03:07:37 +00:00
{
uint8_t * ptr = NULL ;
int res = esp_apptrace_trax_block_switch_waitus ( tmo ) ;
if ( res ! = ESP_OK ) {
return NULL ;
}
// check if we still have pending data
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
if ( esp_apptrace_rb_read_size_get ( & s_trace_buf . trax . rb_pend ) > 0 ) {
// if after TRAX block switch still have pending data (not all pending data have been pumped to TRAX block)
// alloc new pending buffer
* pended = 1 ;
ptr = esp_apptrace_rb_produce ( & s_trace_buf . trax . rb_pend , size ) ;
if ( ! ptr ) {
ESP_APPTRACE_LOGE ( " Failed to alloc pend buf 1: w-r-s %d-%d-%d! " , s_trace_buf . trax . rb_pend . wr , s_trace_buf . trax . rb_pend . rd , s_trace_buf . trax . rb_pend . cur_size ) ;
}
} else
# endif
{
// update block pointers
if ( ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) + size > ESP_APPTRACE_TRAX_INBLOCK_GET ( ) - > sz ) {
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
* pended = 1 ;
ptr = esp_apptrace_rb_produce ( & s_trace_buf . trax . rb_pend , size ) ;
if ( ptr = = NULL ) {
ESP_APPTRACE_LOGE ( " Failed to alloc pend buf 2: w-r-s %d-%d-%d! " , s_trace_buf . trax . rb_pend . wr , s_trace_buf . trax . rb_pend . rd , s_trace_buf . trax . rb_pend . cur_size ) ;
2017-01-25 16:35:28 +00:00
}
2017-03-22 03:07:37 +00:00
# endif
} else {
* pended = 0 ;
ptr = ESP_APPTRACE_TRAX_INBLOCK_GET ( ) - > start + ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) ;
2017-01-25 16:35:28 +00:00
}
}
2017-03-22 03:07:37 +00:00
return ptr ;
}
2017-07-24 16:57:44 +00:00
static uint8_t * esp_apptrace_trax_get_buffer ( uint32_t size , esp_apptrace_tmo_t * tmo )
2017-03-22 03:07:37 +00:00
{
uint8_t * buf_ptr = NULL ;
2017-01-25 16:35:28 +00:00
2017-03-22 03:07:37 +00:00
if ( size > ESP_APPTRACE_USR_DATA_LEN_MAX ) {
ESP_APPTRACE_LOGE ( " Too large user data size %d! " , size ) ;
return NULL ;
}
int res = esp_apptrace_lock ( tmo ) ;
if ( res ! = ESP_OK ) {
return NULL ;
}
// check for data in the pending buffer
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
if ( esp_apptrace_rb_read_size_get ( & s_trace_buf . trax . rb_pend ) > 0 ) {
// if we have buffered data try to switch TRAX block
esp_apptrace_trax_block_switch ( ) ;
// if switch was successful, part or all pended data have been copied to TRAX block
}
if ( esp_apptrace_rb_read_size_get ( & s_trace_buf . trax . rb_pend ) > 0 ) {
// if we have buffered data alloc new pending buffer
ESP_APPTRACE_LOGD ( " Get %d bytes from PEND buffer " , size ) ;
buf_ptr = esp_apptrace_rb_produce ( & s_trace_buf . trax . rb_pend , ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
if ( buf_ptr = = NULL ) {
int pended_buf ;
2017-07-24 16:57:44 +00:00
buf_ptr = esp_apptrace_trax_wait4buf ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) , tmo , & pended_buf ) ;
2017-03-22 03:07:37 +00:00
if ( buf_ptr ) {
if ( pended_buf ) {
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
esp_apptrace_trax_pend_chunk_sz_update ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
# endif
} else {
2017-07-24 16:57:44 +00:00
ESP_APPTRACE_LOGD ( " Get %d bytes from TRAX buffer " , size ) ;
2017-03-22 03:07:37 +00:00
// update cur block marker
ESP_APPTRACE_TRAX_INBLOCK_MARKER_UPD ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
}
}
} else {
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
esp_apptrace_trax_pend_chunk_sz_update ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
# endif
}
} else
# endif
if ( ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) + ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) > ESP_APPTRACE_TRAX_INBLOCK_GET ( ) - > sz ) {
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
ESP_APPTRACE_LOGD ( " TRAX full. Get %d bytes from PEND buffer " , size ) ;
buf_ptr = esp_apptrace_rb_produce ( & s_trace_buf . trax . rb_pend , ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
if ( buf_ptr ) {
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
esp_apptrace_trax_pend_chunk_sz_update ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
# endif
}
# endif
if ( buf_ptr = = NULL ) {
int pended_buf ;
ESP_APPTRACE_LOGD ( " TRAX full. Get %d bytes from pend buffer " , size ) ;
2017-07-24 16:57:44 +00:00
buf_ptr = esp_apptrace_trax_wait4buf ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) , tmo , & pended_buf ) ;
2017-03-22 03:07:37 +00:00
if ( buf_ptr ) {
if ( pended_buf ) {
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
esp_apptrace_trax_pend_chunk_sz_update ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
# endif
} else {
ESP_APPTRACE_LOGD ( " Got %d bytes from TRAX buffer " , size ) ;
// update cur block marker
ESP_APPTRACE_TRAX_INBLOCK_MARKER_UPD ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
}
}
}
} else {
2017-07-24 16:57:44 +00:00
ESP_APPTRACE_LOGD ( " Get %d bytes from TRAX buffer " , size ) ;
2017-03-22 03:07:37 +00:00
// fit to curr TRAX nlock
buf_ptr = ESP_APPTRACE_TRAX_INBLOCK_GET ( ) - > start + ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) ;
// update cur block marker
ESP_APPTRACE_TRAX_INBLOCK_MARKER_UPD ( ESP_APPTRACE_USR_BLOCK_RAW_SZ ( size ) ) ;
}
if ( buf_ptr ) {
buf_ptr = esp_apptrace_data_header_init ( buf_ptr , size ) ;
}
2017-01-25 16:35:28 +00:00
// now we can safely unlock apptrace to allow other tasks/ISRs to get other buffers and write their data
if ( esp_apptrace_unlock ( ) ! = ESP_OK ) {
2017-03-22 03:07:37 +00:00
assert ( false & & " Failed to unlock apptrace data! " ) ;
2017-01-25 16:35:28 +00:00
}
2017-03-22 03:07:37 +00:00
return buf_ptr ;
2017-01-25 16:35:28 +00:00
}
2017-07-24 16:57:44 +00:00
static esp_err_t esp_apptrace_trax_put_buffer ( uint8_t * ptr , esp_apptrace_tmo_t * tmo )
2017-01-25 16:35:28 +00:00
{
int res = ESP_OK ;
esp_tracedata_hdr_t * hdr = ( esp_tracedata_hdr_t * ) ( ptr - sizeof ( esp_tracedata_hdr_t ) ) ;
// update written size
hdr - > wr_sz = hdr - > block_sz ;
// TODO: mark block as busy in order not to re-use it for other tracing calls until it is completely written
// TODO: avoid potential situation when all memory is consumed by low prio tasks which can not complete writing due to
// higher prio tasks and the latter can not allocate buffers at all
// this is abnormal situation can be detected on host which will receive only uncompleted buffers
// workaround: use own memcpy which will kick-off dead tracing calls
return res ;
}
2017-07-24 16:57:44 +00:00
static esp_err_t esp_apptrace_trax_flush ( uint32_t min_sz , esp_apptrace_tmo_t * tmo )
2017-01-25 16:35:28 +00:00
{
int res = ESP_OK ;
2017-03-22 03:07:37 +00:00
if ( ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) < min_sz ) {
ESP_APPTRACE_LOGI ( " Ignore flush request for min %d bytes. Bytes in TRAX block: %d. " , min_sz , ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) ) ;
return ESP_OK ;
}
// switch TRAX block while size of data is more than min size
while ( ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) > 0 ) {
2017-07-24 16:57:44 +00:00
ESP_APPTRACE_LOGD ( " Try to flush %d bytes. Wait until block switch for %u us " , ESP_APPTRACE_TRAX_INBLOCK_MARKER ( ) , tmo - > tmo ) ;
2017-03-22 03:07:37 +00:00
res = esp_apptrace_trax_block_switch_waitus ( tmo ) ;
2017-01-25 16:35:28 +00:00
if ( res ! = ESP_OK ) {
2017-03-22 03:07:37 +00:00
ESP_APPTRACE_LOGE ( " Failed to switch to another block! " ) ;
2017-01-25 16:35:28 +00:00
return res ;
}
}
return res ;
}
2017-08-16 23:36:00 +00:00
static bool esp_apptrace_trax_host_is_connected ( void )
{
return eri_read ( ESP_APPTRACE_TRAX_CTRL_REG ) & ESP_APPTRACE_TRAX_HOST_CONNECT ? true : false ;
}
2018-02-15 17:09:03 +00:00
static esp_err_t esp_apptrace_trax_status_reg_set ( uint32_t val )
{
eri_write ( ESP_APPTRACE_TRAX_STAT_REG , val ) ;
return ESP_OK ;
}
static esp_err_t esp_apptrace_trax_status_reg_get ( uint32_t * val )
{
* val = eri_read ( ESP_APPTRACE_TRAX_STAT_REG ) ;
return ESP_OK ;
}
2017-01-25 16:35:28 +00:00
static esp_err_t esp_apptrace_trax_dest_init ( )
{
for ( int i = 0 ; i < ESP_APPTRACE_TRAX_BLOCKS_NUM ; i + + ) {
s_trace_buf . trax . blocks [ i ] . start = ( uint8_t * ) s_trax_blocks [ i ] ;
s_trace_buf . trax . blocks [ i ] . sz = ESP_APPTRACE_TRAX_BLOCK_SIZE ;
s_trace_buf . trax . state . markers [ i ] = 0 ;
}
s_trace_buf . trax . state . in_block = ESP_APPTRACE_TRAX_INBLOCK_START ;
2017-03-22 03:07:37 +00:00
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
esp_apptrace_rb_init ( & s_trace_buf . trax . rb_pend , s_trace_buf . trax . pending_data ,
sizeof ( s_trace_buf . trax . pending_data ) ) ;
# if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
s_trace_buf . trax . cur_pending_chunk_sz = 0 ;
esp_apptrace_rb_init ( & s_trace_buf . trax . rb_pend_chunk_sz , ( uint8_t * ) s_trace_buf . trax . pending_chunk_sz ,
sizeof ( s_trace_buf . trax . pending_chunk_sz ) ) ;
# endif
# endif
2017-01-25 16:35:28 +00:00
2017-05-08 12:03:04 +00:00
DPORT_WRITE_PERI_REG ( DPORT_PRO_TRACEMEM_ENA_REG , DPORT_PRO_TRACEMEM_ENA_M ) ;
2017-01-25 16:35:28 +00:00
# if CONFIG_FREERTOS_UNICORE == 0
2017-05-08 12:03:04 +00:00
DPORT_WRITE_PERI_REG ( DPORT_APP_TRACEMEM_ENA_REG , DPORT_APP_TRACEMEM_ENA_M ) ;
2017-01-25 16:35:28 +00:00
# endif
// Expose block 1 to host, block 0 is current trace input buffer
2017-05-08 12:03:04 +00:00
DPORT_WRITE_PERI_REG ( DPORT_TRACEMEM_MUX_MODE_REG , TRACEMEM_MUX_BLK1_ONLY ) ;
2017-01-25 16:35:28 +00:00
return ESP_OK ;
}
# endif
esp_err_t esp_apptrace_init ( )
{
int res ;
if ( ! s_trace_buf . inited ) {
2017-03-22 03:07:37 +00:00
memset ( & s_trace_buf , 0 , sizeof ( s_trace_buf ) ) ;
2017-09-15 19:40:01 +00:00
// disabled by default
esp_apptrace_rb_init ( & s_trace_buf . rb_down , NULL , 0 ) ;
2017-03-22 03:07:37 +00:00
res = esp_apptrace_lock_initialize ( & s_trace_buf . lock ) ;
2017-01-25 16:35:28 +00:00
if ( res ! = ESP_OK ) {
ESP_APPTRACE_LOGE ( " Failed to init log lock (%d)! " , res ) ;
return res ;
}
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
res = esp_apptrace_trax_dest_init ( ) ;
if ( res ! = ESP_OK ) {
ESP_APPTRACE_LOGE ( " Failed to init TRAX dest data (%d)! " , res ) ;
esp_apptrace_lock_cleanup ( ) ;
return res ;
}
# endif
}
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
// init TRAX on this CPU
esp_apptrace_trax_init ( ) ;
# endif
s_trace_buf . inited | = 1 < < xPortGetCoreID ( ) ; // global and this CPU-specific data are inited
return ESP_OK ;
}
2017-07-24 16:57:44 +00:00
void esp_apptrace_down_buffer_config ( uint8_t * buf , uint32_t size )
{
esp_apptrace_rb_init ( & s_trace_buf . rb_down , buf , size ) ;
}
esp_err_t esp_apptrace_read ( esp_apptrace_dest_t dest , void * buf , uint32_t * size , uint32_t user_tmo )
2017-03-22 03:07:37 +00:00
{
int res = ESP_OK ;
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-03-22 03:07:37 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-03-22 03:07:37 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
2018-12-26 12:42:07 +00:00
if ( buf = = NULL | | size = = NULL | | * size = = 0 ) {
return ESP_ERR_INVALID_ARG ;
}
2017-03-22 03:07:37 +00:00
//TODO: callback system
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , user_tmo ) ;
2017-03-22 03:07:37 +00:00
uint32_t act_sz = * size ;
2017-07-24 16:57:44 +00:00
* size = 0 ;
2017-08-16 23:36:00 +00:00
uint8_t * ptr = hw - > get_down_buffer ( & act_sz , & tmo ) ;
2017-03-22 03:07:37 +00:00
if ( ptr & & act_sz > 0 ) {
ESP_APPTRACE_LOGD ( " Read %d bytes from host " , act_sz ) ;
memcpy ( buf , ptr , act_sz ) ;
2017-08-16 23:36:00 +00:00
res = hw - > put_down_buffer ( ptr , & tmo ) ;
2017-03-22 03:07:37 +00:00
* size = act_sz ;
2017-08-16 23:36:00 +00:00
} else {
res = ESP_ERR_TIMEOUT ;
2017-03-22 03:07:37 +00:00
}
return res ;
}
2017-07-24 16:57:44 +00:00
uint8_t * esp_apptrace_down_buffer_get ( esp_apptrace_dest_t dest , uint32_t * size , uint32_t user_tmo )
{
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-07-24 16:57:44 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-07-24 16:57:44 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return NULL ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return NULL ;
}
2018-12-26 12:42:07 +00:00
if ( size = = NULL | | * size = = 0 ) {
return NULL ;
}
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , user_tmo ) ;
2017-08-16 23:36:00 +00:00
return hw - > get_down_buffer ( size , & tmo ) ;
2017-07-24 16:57:44 +00:00
}
esp_err_t esp_apptrace_down_buffer_put ( esp_apptrace_dest_t dest , uint8_t * ptr , uint32_t user_tmo )
{
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-07-24 16:57:44 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-07-24 16:57:44 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
2018-12-26 12:42:07 +00:00
if ( ptr = = NULL ) {
return ESP_ERR_INVALID_ARG ;
}
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , user_tmo ) ;
2017-08-16 23:36:00 +00:00
return hw - > put_down_buffer ( ptr , & tmo ) ;
2017-07-24 16:57:44 +00:00
}
esp_err_t esp_apptrace_write ( esp_apptrace_dest_t dest , const void * data , uint32_t size , uint32_t user_tmo )
2017-01-25 16:35:28 +00:00
{
uint8_t * ptr = NULL ;
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-01-25 16:35:28 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-01-25 16:35:28 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
2018-12-26 12:42:07 +00:00
if ( data = = NULL | | size = = 0 ) {
return ESP_ERR_INVALID_ARG ;
}
2017-01-25 16:35:28 +00:00
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , user_tmo ) ;
2017-08-16 23:36:00 +00:00
ptr = hw - > get_up_buffer ( size , & tmo ) ;
2017-01-25 16:35:28 +00:00
if ( ptr = = NULL ) {
return ESP_ERR_NO_MEM ;
}
// actually can be suspended here by higher prio tasks/ISRs
2017-03-22 03:07:37 +00:00
//TODO: use own memcpy with dead trace calls kick-off algo and tmo expiration check
2017-01-25 16:35:28 +00:00
memcpy ( ptr , data , size ) ;
// now indicate that this buffer is ready to be sent off to host
2017-08-16 23:36:00 +00:00
return hw - > put_up_buffer ( ptr , & tmo ) ;
2017-01-25 16:35:28 +00:00
}
int esp_apptrace_vprintf_to ( esp_apptrace_dest_t dest , uint32_t user_tmo , const char * fmt , va_list ap )
{
uint16_t nargs = 0 ;
uint8_t * pout , * p = ( uint8_t * ) fmt ;
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-01-25 16:35:28 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-01-25 16:35:28 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
2018-12-26 12:42:07 +00:00
if ( fmt = = NULL ) {
return ESP_ERR_INVALID_ARG ;
}
2017-01-25 16:35:28 +00:00
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , user_tmo ) ;
2017-03-22 03:07:37 +00:00
ESP_APPTRACE_LOGD ( " fmt %x " , fmt ) ;
2017-01-25 16:35:28 +00:00
while ( ( p = ( uint8_t * ) strchr ( ( char * ) p , ' % ' ) ) & & nargs < ESP_APPTRACE_MAX_VPRINTF_ARGS ) {
p + + ;
if ( * p ! = ' % ' & & * p ! = 0 ) {
nargs + + ;
}
}
2017-03-22 03:07:37 +00:00
ESP_APPTRACE_LOGD ( " nargs = %d " , nargs ) ;
2017-01-25 16:35:28 +00:00
if ( p ) {
ESP_APPTRACE_LOGE ( " Failed to store all printf args! " ) ;
}
2017-08-16 23:36:00 +00:00
pout = hw - > get_up_buffer ( 1 + sizeof ( char * ) + nargs * sizeof ( uint32_t ) , & tmo ) ;
2017-01-25 16:35:28 +00:00
if ( pout = = NULL ) {
ESP_APPTRACE_LOGE ( " Failed to get buffer! " ) ;
return - 1 ;
}
p = pout ;
* pout = nargs ;
pout + + ;
* ( const char * * ) pout = fmt ;
pout + = sizeof ( char * ) ;
while ( nargs - - > 0 ) {
uint32_t arg = va_arg ( ap , uint32_t ) ;
* ( uint32_t * ) pout = arg ;
pout + = sizeof ( uint32_t ) ;
2017-03-22 03:07:37 +00:00
ESP_APPTRACE_LOGD ( " arg %x " , arg ) ;
2017-01-25 16:35:28 +00:00
}
2017-08-16 23:36:00 +00:00
int ret = hw - > put_up_buffer ( p , & tmo ) ;
2017-01-25 16:35:28 +00:00
if ( ret ! = ESP_OK ) {
ESP_APPTRACE_LOGE ( " Failed to put printf buf (%d)! " , ret ) ;
return - 1 ;
}
return ( pout - p ) ;
}
int esp_apptrace_vprintf ( const char * fmt , va_list ap )
{
return esp_apptrace_vprintf_to ( ESP_APPTRACE_DEST_TRAX , /*ESP_APPTRACE_TMO_INFINITE*/ 0 , fmt , ap ) ;
}
2017-07-24 16:57:44 +00:00
uint8_t * esp_apptrace_buffer_get ( esp_apptrace_dest_t dest , uint32_t size , uint32_t user_tmo )
2017-01-25 16:35:28 +00:00
{
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-01-25 16:35:28 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-01-25 16:35:28 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return NULL ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return NULL ;
}
2018-12-26 12:42:07 +00:00
if ( size = = 0 ) {
return NULL ;
}
2017-01-25 16:35:28 +00:00
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , user_tmo ) ;
2017-08-16 23:36:00 +00:00
return hw - > get_up_buffer ( size , & tmo ) ;
2017-01-25 16:35:28 +00:00
}
esp_err_t esp_apptrace_buffer_put ( esp_apptrace_dest_t dest , uint8_t * ptr , uint32_t user_tmo )
{
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-01-25 16:35:28 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-01-25 16:35:28 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
2018-12-26 12:42:07 +00:00
if ( ptr = = NULL ) {
return ESP_ERR_INVALID_ARG ;
}
2017-01-25 16:35:28 +00:00
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , user_tmo ) ;
2017-08-16 23:36:00 +00:00
return hw - > put_up_buffer ( ptr , & tmo ) ;
2017-01-25 16:35:28 +00:00
}
2017-07-24 16:57:44 +00:00
esp_err_t esp_apptrace_flush_nolock ( esp_apptrace_dest_t dest , uint32_t min_sz , uint32_t usr_tmo )
2017-01-25 16:35:28 +00:00
{
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
2017-08-16 23:36:00 +00:00
esp_apptrace_hw_t * hw = NULL ;
2017-01-25 16:35:28 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
2017-08-16 23:36:00 +00:00
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
2017-01-25 16:35:28 +00:00
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , usr_tmo ) ;
2017-08-16 23:36:00 +00:00
return hw - > flush_up_buffer ( min_sz , & tmo ) ;
2017-01-25 16:35:28 +00:00
}
2017-07-24 16:57:44 +00:00
esp_err_t esp_apptrace_flush ( esp_apptrace_dest_t dest , uint32_t usr_tmo )
2017-01-25 16:35:28 +00:00
{
int res ;
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_t tmo ;
2017-01-25 16:35:28 +00:00
2017-07-24 16:57:44 +00:00
esp_apptrace_tmo_init ( & tmo , usr_tmo ) ;
2017-01-25 16:35:28 +00:00
res = esp_apptrace_lock ( & tmo ) ;
if ( res ! = ESP_OK ) {
ESP_APPTRACE_LOGE ( " Failed to lock apptrace data (%d)! " , res ) ;
return res ;
}
2017-07-24 16:57:44 +00:00
res = esp_apptrace_flush_nolock ( dest , 0 , esp_apptrace_tmo_remaining_us ( & tmo ) ) ;
2017-01-25 16:35:28 +00:00
if ( res ! = ESP_OK ) {
2017-03-22 03:07:37 +00:00
ESP_APPTRACE_LOGE ( " Failed to flush apptrace data (%d)! " , res ) ;
2017-01-25 16:35:28 +00:00
}
if ( esp_apptrace_unlock ( ) ! = ESP_OK ) {
2017-03-22 03:07:37 +00:00
assert ( false & & " Failed to unlock apptrace data! " ) ;
2017-01-25 16:35:28 +00:00
}
return res ;
}
2017-08-16 23:36:00 +00:00
bool esp_apptrace_host_is_connected ( esp_apptrace_dest_t dest )
{
esp_apptrace_hw_t * hw = NULL ;
2018-02-15 17:09:03 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return false ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return false ;
}
return hw - > host_is_connected ( ) ;
}
esp_err_t esp_apptrace_status_reg_set ( esp_apptrace_dest_t dest , uint32_t val )
{
esp_apptrace_hw_t * hw = NULL ;
2017-08-16 23:36:00 +00:00
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
2018-02-15 17:09:03 +00:00
return hw - > status_reg_set ( val ) ;
}
esp_err_t esp_apptrace_status_reg_get ( esp_apptrace_dest_t dest , uint32_t * val )
{
esp_apptrace_hw_t * hw = NULL ;
if ( dest = = ESP_APPTRACE_DEST_TRAX ) {
# if CONFIG_ESP32_APPTRACE_DEST_TRAX
hw = ESP_APPTRACE_HW ( ESP_APPTRACE_HW_TRAX ) ;
# else
ESP_APPTRACE_LOGE ( " Application tracing via TRAX is disabled in menuconfig! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
# endif
} else {
ESP_APPTRACE_LOGE ( " Trace destinations other then TRAX are not supported yet! " ) ;
return ESP_ERR_NOT_SUPPORTED ;
}
return hw - > status_reg_get ( val ) ;
2017-08-16 23:36:00 +00:00
}
2017-01-25 16:35:28 +00:00
# endif