rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/platform/hal/hal_trace.c
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

2891 lines
77 KiB
C
Raw Blame History

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#if !(defined(DEBUG) || defined(REL_TRACE_ENABLE))
// Implement a local copy of dummy trace functions for library linking (which
// might be built with DEBUG enabled)
#define TRACE_FUNC_SPEC
#endif
#include "hal_trace.h"
#include "cmsis_nvic.h"
#ifdef RTOS
#include "cmsis_os.h"
#endif
#include "hal_bootmode.h"
#include "hal_chipid.h"
#include "hal_cmu.h"
#include "hal_codec.h"
#include "hal_dma.h"
#include "hal_iomux.h"
#include "hal_location.h"
#include "hal_memsc.h"
#include "hal_sysfreq.h"
#include "hal_timer.h"
#include "hal_uart.h"
#include "stdarg.h"
#include "stdio.h"
#include "string.h"
#ifdef CORE_DUMP
#include "CrashCatcherApi.h"
#endif
extern const char sys_build_info[];
extern void nv_record_flash_flush(void);
#ifdef FAULT_DUMP
void hal_trace_fault_dump(const uint32_t *regs, const uint32_t *extra,
uint32_t extra_len);
#ifndef __ARM_ARCH_ISA_ARM
static void hal_trace_fault_handler(void);
#endif
#endif
#if !(defined(ROM_BUILD) || defined(PROGRAMMER))
#define ASSERT_MUTE_CODEC
#define CRASH_DUMP_ENABLE
#if !(defined(NO_TRACE_TIME_STAMP) || defined(AUDIO_DEBUG_V0_1_0))
#define TRACE_TIME_STAMP
#endif
#if (defined(DUMP_LOG_ENABLE) || defined(DUMP_CRASH_ENABLE))
#define TRACE_TO_APP
#endif
#ifdef CHIP_HAS_CP
#define CP_TRACE_ENABLE
#endif
#endif
#define TRACE_IDLE_OUTPUT 0
#ifndef TRACE_BAUD_RATE
#define TRACE_BAUD_RATE (921600)
#endif
#ifndef TRACE_BUF_SIZE
#ifdef AUDIO_DEBUG
#define TRACE_BUF_SIZE (6 * 1024)
#else
#define TRACE_BUF_SIZE (4 * 1024)
#endif
#endif
#define CRASH_BUF_SIZE 100
#define CRASH_BUF_ATTR ALIGNED(4) USED
#ifndef TRACE_STACK_DUMP_PREV_WORD
#define TRACE_STACK_DUMP_PREV_WORD 16
#endif
#ifndef TRACE_STACK_DUMP_WORD
#define TRACE_STACK_DUMP_WORD 32
#endif
#ifndef TRACE_BACKTRACE_NUM
#define TRACE_BACKTRACE_NUM 20
#endif
#ifndef TRACE_BACKTRACE_SEARCH_WORD
#define TRACE_BACKTRACE_SEARCH_WORD 1024
#endif
#define STACK_DUMP_CNT_PER_LEN 4
#define STACK_DUMP_CNT_PREV \
((TRACE_STACK_DUMP_PREV_WORD + STACK_DUMP_CNT_PER_LEN - 1) / \
STACK_DUMP_CNT_PER_LEN * STACK_DUMP_CNT_PER_LEN)
#define STACK_DUMP_CNT \
((TRACE_STACK_DUMP_WORD + STACK_DUMP_CNT_PER_LEN - 1) / \
STACK_DUMP_CNT_PER_LEN * STACK_DUMP_CNT_PER_LEN)
#define TRACE_FLUSH_TIMEOUT MS_TO_TICKS(2000)
#define TRACE_NEAR_FULL_THRESH 200
#define TRACE_CRLF
#ifdef TRACE_CRLF
#define NEW_LINE_STR "\r\n"
#else
#define NEW_LINE_STR "\n"
#endif
#define HAL_TRACE_ASSERT_ID 0xBE57AAAA
#define HAL_TRACE_EXCEPTION_ID 0xBE57EEEE
#define HAL_MEMSC_ID_TRACE HAL_MEMSC_ID_0
#define TRACE_BUF_LOC SYNC_FLAGS_LOC
struct ASSERT_INFO_T {
uint32_t ID;
uint32_t CPU_ID;
const char *FILE;
const char *FUNC;
uint32_t LINE;
const char *FMT;
uint32_t R[15];
#ifndef __ARM_ARCH_ISA_ARM
uint32_t MSP;
uint32_t PSP;
uint32_t CONTROL;
#ifdef __ARM_ARCH_8M_MAIN__
uint32_t MSPLIM;
uint32_t PSPLIM;
#endif
#endif
};
struct EXCEPTION_INFO_T {
uint32_t ID;
uint32_t CPU_ID;
const uint32_t *REGS;
#ifdef __ARM_ARCH_ISA_ARM
const uint32_t *extra;
uint32_t extra_len;
#else
uint32_t MSP;
uint32_t PSP;
uint8_t PRIMASK;
uint8_t FAULTMASK;
uint8_t BASEPRI;
uint8_t CONTROL;
uint32_t ICSR;
uint32_t AIRCR;
uint32_t SCR;
uint32_t CCR;
uint32_t SHCSR;
uint32_t CFSR;
uint32_t HFSR;
uint32_t AFSR;
uint32_t MMFAR;
uint32_t BFAR;
#ifdef __ARM_ARCH_8M_MAIN__
uint32_t MSPLIM;
uint32_t PSPLIM;
#endif
#endif
};
static CRASH_BUF_ATTR char crash_buf[CRASH_BUF_SIZE];
STATIC_ASSERT(sizeof(crash_buf) >= sizeof(((struct ASSERT_INFO_T *)0)->R),
"crash_buf too small to hold assert registers");
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
struct HAL_TRACE_BUF_T {
unsigned char buf[TRACE_BUF_SIZE];
unsigned short wptr;
unsigned short rptr;
#if (TRACE_IDLE_OUTPUT == 0)
unsigned short sends[2];
#endif
unsigned short discards;
bool sending;
bool in_trace;
bool wrapped;
};
STATIC_ASSERT(TRACE_BUF_SIZE <
(1 << (8 * sizeof(((struct HAL_TRACE_BUF_T *)0)->wptr))),
"TRACE_BUF_SIZE is too large to fit in wptr/rptr variable");
static const struct HAL_UART_CFG_T uart_cfg = {
.parity = HAL_UART_PARITY_NONE,
.stop = HAL_UART_STOP_BITS_1,
.data = HAL_UART_DATA_BITS_8,
.flow = HAL_UART_FLOW_CONTROL_NONE, // HAL_UART_FLOW_CONTROL_RTSCTS,
.tx_level = HAL_UART_FIFO_LEVEL_1_2,
.rx_level = HAL_UART_FIFO_LEVEL_1_2,
.baud = TRACE_BAUD_RATE,
#ifdef HAL_TRACE_RX_ENABLE
.dma_rx = true,
#else
.dma_rx = false,
#endif
#if (TRACE_IDLE_OUTPUT == 0)
.dma_tx = true,
#else
.dma_tx = false,
#endif
.dma_rx_stop_on_err = false,
};
#if (TRACE_IDLE_OUTPUT == 0)
static const enum HAL_DMA_PERIPH_T uart_periph[] = {
HAL_GPDMA_UART0_TX,
#if (CHIP_HAS_UART > 1)
HAL_GPDMA_UART1_TX,
#endif
#if (CHIP_HAS_UART > 2)
HAL_GPDMA_UART2_TX,
#endif
};
static const struct HAL_UART_CFG_T uart_rx_enable_cfg = {
.parity = HAL_UART_PARITY_NONE,
.stop = HAL_UART_STOP_BITS_1,
.data = HAL_UART_DATA_BITS_8,
.flow = HAL_UART_FLOW_CONTROL_NONE, // HAL_UART_FLOW_CONTROL_RTSCTS,
.tx_level = HAL_UART_FIFO_LEVEL_1_2,
.rx_level = HAL_UART_FIFO_LEVEL_1_2,
.baud = TRACE_BAUD_RATE,
.dma_rx = true,
#if (TRACE_IDLE_OUTPUT == 0)
.dma_tx = true,
#else
.dma_tx = false,
#endif
.dma_rx_stop_on_err = false,
};
static struct HAL_DMA_CH_CFG_T dma_cfg;
TRACE_BUF_LOC static struct HAL_DMA_DESC_T dma_desc[2];
#endif
static enum HAL_TRACE_TRANSPORT_T trace_transport = HAL_TRACE_TRANSPORT_QTY;
static enum HAL_UART_ID_T trace_uart;
TRACE_BUF_LOC
static struct HAL_TRACE_BUF_T trace;
POSSIBLY_UNUSED
static const char newline[] = NEW_LINE_STR;
static const char discards_prefix[] = NEW_LINE_STR "LOST ";
static const uint32_t max_discards = 99999;
// 5 digits + "\r\n" = 7 chars
static char discards_buf[sizeof(discards_prefix) - 1 + 7];
static const unsigned char discards_digit_start = sizeof(discards_prefix) - 1;
static bool crash_dump_onprocess = false;
#ifdef CRASH_DUMP_ENABLE
static HAL_TRACE_CRASH_DUMP_CB_T
crash_dump_cb_list[HAL_TRACE_CRASH_DUMP_MODULE_END];
static bool crash_handling;
#ifdef TRACE_TO_APP
static HAL_TRACE_APP_NOTIFY_T app_notify_cb = NULL;
static HAL_TRACE_APP_OUTPUT_T app_output_cb = NULL;
static HAL_TRACE_APP_OUTPUT_T app_crash_custom_cb = NULL;
static bool app_output_enabled =
#if defined(DUMP_LOG_ENABLE)
true;
#else
false;
#endif
#endif // TRACE_TO_APP
#endif // CRASH_DUMP_ENABLE
#ifdef CP_TRACE_ENABLE
static HAL_TRACE_APP_NOTIFY_T cp_notify_cb = NULL;
static HAL_TRACE_BUF_CTRL_T cp_buffer_cb = NULL;
#endif
#ifdef AUDIO_DEBUG_V0_1_0
static const char trace_head_buf[] = "[trace]";
#endif
static enum LOG_LEVEL_T trace_max_level;
static uint32_t trace_mod_map[(LOG_MODULE_QTY + 31) / 32];
static bool hal_trace_is_uart_transport(enum HAL_TRACE_TRANSPORT_T transport) {
if (transport == HAL_TRACE_TRANSPORT_UART0
#if (CHIP_HAS_UART > 1)
|| transport == HAL_TRACE_TRANSPORT_UART1
#endif
#if (CHIP_HAS_UART > 2)
|| transport == HAL_TRACE_TRANSPORT_UART2
#endif
) {
return true;
}
return false;
}
#if (TRACE_IDLE_OUTPUT == 0)
static void hal_trace_uart_send(void) {
uint32_t wptr, rptr;
uint32_t sends[2];
uint32_t lock;
lock = int_lock();
wptr = trace.wptr;
rptr = trace.rptr;
// There is a race condition if we do not check s/w flag, but only check the
// h/w status. [e.g., hal_gpdma_chan_busy(dma_cfg.ch)] When the DMA is done,
// but DMA IRQ handler is still pending due to interrupt lock or higher
// priority IRQ, it will have a chance to send the same content twice.
if (!trace.sending && wptr != rptr) {
trace.sending = true;
sends[1] = 0;
if (wptr > rptr) {
sends[0] = wptr - rptr;
} else {
sends[0] = TRACE_BUF_SIZE - rptr;
if (sends[0] <= HAL_DMA_MAX_DESC_XFER_SIZE) {
sends[1] = wptr;
}
}
if (sends[0] > HAL_DMA_MAX_DESC_XFER_SIZE) {
sends[1] = sends[0] - HAL_DMA_MAX_DESC_XFER_SIZE;
sends[0] = HAL_DMA_MAX_DESC_XFER_SIZE;
}
if (sends[1] > HAL_DMA_MAX_DESC_XFER_SIZE) {
sends[1] = HAL_DMA_MAX_DESC_XFER_SIZE;
}
dma_cfg.src = (uint32_t)&trace.buf[rptr];
if (sends[1] == 0) {
dma_cfg.src_tsize = sends[0];
hal_gpdma_init_desc(&dma_desc[0], &dma_cfg, NULL, 1);
} else {
dma_cfg.src_tsize = sends[0];
hal_gpdma_init_desc(&dma_desc[0], &dma_cfg, &dma_desc[1], 0);
if (rptr + sends[0] < TRACE_BUF_SIZE) {
dma_cfg.src = (uint32_t)&trace.buf[rptr + sends[0]];
} else {
dma_cfg.src = (uint32_t)&trace.buf[0];
}
dma_cfg.src_tsize = sends[1];
hal_gpdma_init_desc(&dma_desc[1], &dma_cfg, NULL, 1);
}
trace.sends[0] = sends[0];
trace.sends[1] = sends[1];
hal_gpdma_sg_start(&dma_desc[0], &dma_cfg);
}
int_unlock(lock);
}
static void hal_trace_uart_xfer_done(uint8_t chan, uint32_t remain_tsize,
uint32_t error,
struct HAL_DMA_DESC_T *lli) {
uint32_t sends[2];
uint32_t lock;
lock = int_lock();
sends[0] = trace.sends[0];
sends[1] = trace.sends[1];
if (error) {
if (lli || sends[1] == 0) {
if (sends[0] > remain_tsize) {
sends[0] -= remain_tsize;
} else {
sends[0] = 0;
}
sends[1] = 0;
} else {
if (sends[1] > remain_tsize) {
sends[1] -= remain_tsize;
} else {
sends[1] = 0;
}
}
}
trace.rptr += sends[0] + sends[1];
if (trace.rptr >= TRACE_BUF_SIZE) {
trace.rptr -= TRACE_BUF_SIZE;
}
trace.sends[0] = 0;
trace.sends[1] = 0;
trace.sending = false;
hal_trace_uart_send();
int_unlock(lock);
}
static void hal_trace_send(void) {
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
return;
}
#endif
if (hal_trace_is_uart_transport(trace_transport)) {
hal_trace_uart_send();
}
}
#else // TRACE_IDLE_OUTPUT
static void hal_trace_uart_idle_send(void) {
int i;
uint32_t lock;
unsigned short wptr, rptr;
lock = int_lock();
wptr = trace.wptr;
rptr = trace.rptr;
int_unlock(lock);
if (wptr == rptr) {
return;
}
if (wptr < rptr) {
for (i = rptr; i < TRACE_BUF_SIZE; i++) {
hal_uart_blocked_putc(trace_uart, trace.buf[i]);
}
rptr = 0;
}
for (i = rptr; i < wptr; i++) {
hal_uart_blocked_putc(trace_uart, trace.buf[i]);
}
trace.rptr = wptr;
if (trace.rptr >= TRACE_BUF_SIZE) {
trace.rptr -= TRACE_BUF_SIZE;
}
}
void hal_trace_idle_send(void) {
if (hal_trace_is_uart_transport(trace_transport)) {
hal_trace_uart_idle_send();
}
}
#endif // TRACE_IDLE_OUTPUT
int hal_trace_open(enum HAL_TRACE_TRANSPORT_T transport) {
int ret;
crash_dump_onprocess = false;
#if (CHIP_HAS_UART > 1)
#ifdef FORCE_TRACE_UART1
transport = HAL_TRACE_TRANSPORT_UART1;
#endif
#endif
#if (CHIP_HAS_UART > 2)
#ifdef FORCE_TRACE_UART2
transport = HAL_TRACE_TRANSPORT_UART2;
#endif
#endif
if (transport >= HAL_TRACE_TRANSPORT_QTY) {
return 1;
}
#ifdef CHIP_HAS_USB
if (transport == HAL_TRACE_TRANSPORT_USB) {
return 1;
}
#endif
if (trace_transport != HAL_TRACE_TRANSPORT_QTY) {
return hal_trace_switch(transport);
}
trace_max_level = LOG_LEVEL_INFO;
for (int i = 0; i < ARRAY_SIZE(trace_mod_map); i++) {
trace_mod_map[i] = ~0;
}
memcpy(discards_buf, discards_prefix, discards_digit_start);
trace.wptr = 0;
trace.rptr = 0;
trace.discards = 0;
trace.sending = false;
trace.in_trace = false;
trace.wrapped = false;
if (hal_trace_is_uart_transport(transport)) {
trace_uart = HAL_UART_ID_0 + (transport - HAL_TRACE_TRANSPORT_UART0);
ret = hal_uart_open(trace_uart, &uart_cfg);
if (ret) {
return ret;
}
#if (TRACE_IDLE_OUTPUT == 0)
trace.sends[0] = 0;
trace.sends[1] = 0;
memset(&dma_cfg, 0, sizeof(dma_cfg));
dma_cfg.dst = 0; // useless
dma_cfg.dst_bsize = HAL_DMA_BSIZE_8;
dma_cfg.dst_periph = uart_periph[trace_uart - HAL_UART_ID_0];
dma_cfg.dst_width = HAL_DMA_WIDTH_BYTE;
dma_cfg.handler = hal_trace_uart_xfer_done;
dma_cfg.src_bsize = HAL_DMA_BSIZE_32;
dma_cfg.src_periph = 0; // useless
dma_cfg.src_width = HAL_DMA_WIDTH_BYTE;
dma_cfg.type = HAL_DMA_FLOW_M2P_DMA;
dma_cfg.try_burst = 0;
dma_cfg.ch = hal_gpdma_get_chan(dma_cfg.dst_periph, HAL_DMA_HIGH_PRIO);
ASSERT(dma_cfg.ch != HAL_DMA_CHAN_NONE, "Failed to get DMA channel");
#endif
}
#ifdef FAULT_DUMP
#ifdef __ARM_ARCH_ISA_ARM
GIC_SetFaultDumpHandler(hal_trace_fault_dump);
#else
NVIC_SetDefaultFaultHandler(hal_trace_fault_handler);
#endif
#endif
trace_transport = transport;
#ifdef HAL_TRACE_RX_ENABLE
hal_trace_rx_open();
#endif
// Show build info
static const char dbl_new_line[] = NEW_LINE_STR NEW_LINE_STR;
hal_trace_output((unsigned char *)dbl_new_line, sizeof(dbl_new_line));
hal_trace_output((unsigned char *)sys_build_info, strlen(sys_build_info) + 1);
char buf[50];
int len;
len = snprintf(buf, sizeof(buf),
NEW_LINE_STR NEW_LINE_STR "------" NEW_LINE_STR
"METAL_ID: %d" NEW_LINE_STR
"------" NEW_LINE_STR NEW_LINE_STR,
hal_get_chip_metal_id());
hal_trace_output((unsigned char *)buf, len + 1);
return 0;
}
int hal_trace_switch(enum HAL_TRACE_TRANSPORT_T transport) {
uint32_t POSSIBLY_UNUSED lock;
int ret;
#if (CHIP_HAS_UART > 1)
#ifdef FORCE_TRACE_UART1
transport = HAL_TRACE_TRANSPORT_UART1;
#endif
#endif
#if (CHIP_HAS_UART > 2)
#ifdef FORCE_TRACE_UART2
transport = HAL_TRACE_TRANSPORT_UART2;
#endif
#endif
#ifdef CHIP_HAS_USB
if (transport == HAL_TRACE_TRANSPORT_USB) {
return 1;
}
#endif
if (transport >= HAL_TRACE_TRANSPORT_QTY) {
return 1;
}
if (trace_transport >= HAL_TRACE_TRANSPORT_QTY) {
return 1;
}
if (trace_transport == transport) {
return 0;
}
ret = 0;
#if (CHIP_HAS_UART > 1)
lock = int_lock();
if (hal_trace_is_uart_transport(trace_transport)) {
#if (TRACE_IDLE_OUTPUT == 0)
if (dma_cfg.ch != HAL_DMA_CHAN_NONE) {
hal_gpdma_cancel(dma_cfg.ch);
}
#endif
hal_uart_close(trace_uart);
}
if (hal_trace_is_uart_transport(transport)) {
trace_uart = HAL_UART_ID_0 + (transport - HAL_TRACE_TRANSPORT_UART0);
#if (TRACE_IDLE_OUTPUT == 0)
dma_cfg.dst_periph = uart_periph[trace_uart - HAL_UART_ID_0];
trace.sends[0] = 0;
trace.sends[1] = 0;
#endif
ret = hal_uart_open(trace_uart, &uart_cfg);
if (ret) {
#if (TRACE_IDLE_OUTPUT == 0)
hal_gpdma_free_chan(dma_cfg.ch);
dma_cfg.ch = HAL_DMA_CHAN_NONE;
#endif
trace_transport = HAL_TRACE_TRANSPORT_QTY;
goto _exit;
}
}
trace.sending = false;
trace_transport = transport;
_exit:
int_unlock(lock);
#endif // CHIP_HAS_UART > 1
return ret;
}
int hal_trace_close(void) {
if (trace_transport >= HAL_TRACE_TRANSPORT_QTY) {
goto _exit;
}
#ifdef CHIP_HAS_USB
if (trace_transport == HAL_TRACE_TRANSPORT_USB) {
goto _exit;
}
#endif
if (hal_trace_is_uart_transport(trace_transport)) {
#if (TRACE_IDLE_OUTPUT == 0)
if (dma_cfg.ch != HAL_DMA_CHAN_NONE) {
hal_gpdma_cancel(dma_cfg.ch);
hal_gpdma_free_chan(dma_cfg.ch);
dma_cfg.ch = HAL_DMA_CHAN_NONE;
}
#endif
hal_uart_close(trace_uart);
}
_exit:
trace_transport = HAL_TRACE_TRANSPORT_QTY;
return 0;
}
int hal_trace_enable_log_module(enum LOG_MODULE_T module) {
if (module >= LOG_MODULE_QTY) {
return 1;
}
trace_mod_map[module >> 5] |= (1 << (module & 0x1F));
return 0;
}
int hal_trace_disable_log_module(enum LOG_MODULE_T module) {
if (module >= LOG_MODULE_QTY) {
return 1;
}
trace_mod_map[module >> 5] &= ~(1 << (module & 0x1F));
return 0;
}
int hal_trace_set_log_module(const uint32_t *map, uint32_t word_cnt) {
if (map == NULL || word_cnt == 0) {
return 1;
}
if (word_cnt > ARRAY_SIZE(trace_mod_map)) {
word_cnt = ARRAY_SIZE(trace_mod_map);
}
for (int i = 0; i < word_cnt; i++) {
trace_mod_map[i] = map[i];
}
return 0;
}
int hal_trace_set_log_level(enum LOG_LEVEL_T level) {
if (level >= LOG_LEVEL_QTY) {
return 1;
}
trace_max_level = level;
return 0;
}
void hal_trace_get_history_buffer(const unsigned char **buf1,
unsigned int *len1,
const unsigned char **buf2,
unsigned int *len2) {
uint32_t lock;
uint8_t *b1, *b2;
uint32_t l1, l2;
b1 = b2 = NULL;
l1 = l2 = 0;
lock = int_lock();
if (TRACE_BUF_SIZE > trace.wptr) {
if (trace.wrapped) {
b1 = &trace.buf[trace.wptr];
l1 = TRACE_BUF_SIZE - trace.wptr;
b2 = &trace.buf[0];
l2 = trace.wptr;
} else {
b1 = &trace.buf[0];
l1 = trace.wptr;
b2 = NULL;
l2 = 0;
}
}
int_unlock(lock);
if (buf1) {
*buf1 = b1;
}
if (len1) {
*len1 = l1;
}
if (buf2) {
*buf2 = b2;
}
if (len2) {
*len2 = l2;
}
}
static void hal_trace_print_discards(uint32_t discards) {
static const uint8_t base = 10;
char digit[5], *d, *out;
uint16_t len;
uint16_t size;
if (discards > max_discards) {
discards = max_discards;
}
d = &digit[0];
do {
*d++ = (discards % base) + '0';
} while (discards /= base);
out = &discards_buf[discards_digit_start];
do {
*out++ = *--d;
} while (d > &digit[0]);
#ifdef TRACE_CRLF
*out++ = '\r';
#endif
*out++ = '\n';
len = out - &discards_buf[0];
size = TRACE_BUF_SIZE - trace.wptr;
if (size >= len) {
size = len;
}
memcpy(&trace.buf[trace.wptr], &discards_buf[0], size);
if (size < len) {
memcpy(&trace.buf[0], &discards_buf[size], len - size);
}
trace.wptr += len;
if (trace.wptr >= TRACE_BUF_SIZE) {
trace.wptr -= TRACE_BUF_SIZE;
}
}
#ifdef AUDIO_DEBUG_V0_1_0
static void hal_trace_print_head(void) {
uint16_t len;
uint16_t size;
len = sizeof(trace_head_buf) - 1;
size = TRACE_BUF_SIZE - trace.wptr;
if (size >= len) {
size = len;
}
memcpy(&trace.buf[trace.wptr], &trace_head_buf[0], size);
if (size < len) {
memcpy(&trace.buf[0], &trace_head_buf[size], len - size);
}
trace.wptr += len;
if (trace.wptr >= TRACE_BUF_SIZE) {
trace.wptr -= TRACE_BUF_SIZE;
}
}
#endif
int hal_trace_output(const unsigned char *buf, unsigned int buf_len) {
int ret;
uint32_t lock;
uint32_t avail;
uint32_t out_len;
uint16_t size;
ret = 0;
lock = int_lock();
#ifdef CP_TRACE_ENABLE
while (hal_memsc_lock(HAL_MEMSC_ID_TRACE) == 0)
;
#endif
// Avoid troubles when NMI occurs during trace
if (!trace.in_trace) {
trace.in_trace = true;
if (trace.wptr >= trace.rptr) {
avail = TRACE_BUF_SIZE - (trace.wptr - trace.rptr) - 1;
} else {
avail = (trace.rptr - trace.wptr) - 1;
}
out_len = buf_len;
#ifdef AUDIO_DEBUG_V0_1_0
out_len += sizeof(trace_head_buf) - 1;
#endif
if (trace.discards) {
out_len += sizeof(discards_buf);
}
if (avail < out_len) {
ret = 1;
if (trace.discards < (1 << (sizeof(trace.discards) * 8)) - 1) {
trace.discards++;
}
#ifdef CP_TRACE_ENABLE
#if (TRACE_IDLE_OUTPUT == 0)
hal_trace_send();
#endif
#endif
} else {
#ifdef AUDIO_DEBUG_V0_1_0
hal_trace_print_head();
#endif
if (trace.discards) {
hal_trace_print_discards(trace.discards);
trace.discards = 0;
}
size = TRACE_BUF_SIZE - trace.wptr;
if (size >= buf_len) {
size = buf_len;
}
memcpy(&trace.buf[trace.wptr], &buf[0], size);
if (size < buf_len) {
memcpy(&trace.buf[0], &buf[size], buf_len - size);
}
trace.wptr += buf_len;
if (trace.wptr >= TRACE_BUF_SIZE) {
trace.wptr -= TRACE_BUF_SIZE;
trace.wrapped = true;
}
#if (TRACE_IDLE_OUTPUT == 0)
hal_trace_send();
#endif
}
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
if (cp_buffer_cb) {
if (avail < out_len) {
cp_buffer_cb(HAL_TRACE_BUF_STATE_FULL);
} else if (avail - out_len < TRACE_NEAR_FULL_THRESH) {
cp_buffer_cb(HAL_TRACE_BUF_STATE_NEAR_FULL);
}
}
}
#endif
trace.in_trace = false;
#ifdef CRASH_DUMP_ENABLE
#ifdef TRACE_TO_APP
if (app_output_cb && app_output_enabled) {
bool saved_output_state;
saved_output_state = app_output_enabled;
app_output_enabled = false;
app_output_cb(buf, buf_len);
app_output_enabled = saved_output_state;
}
#endif
#endif
}
#ifdef CP_TRACE_ENABLE
hal_memsc_unlock(HAL_MEMSC_ID_TRACE);
#endif
int_unlock(lock);
return ret ? 0 : buf_len;
}
#ifdef USE_TRACE_ID
// define USE_CRC_CHECK
//#define LITE_VERSION
typedef struct {
uint32_t crc : 6;
uint32_t count : 4;
uint32_t tskid : 5;
uint32_t addr : 17; // 127 KB trace space support
} trace_info_t;
typedef struct {
uint32_t crc : 8;
uint32_t timestamp : 24; // 4 hours support
} trace_head_t;
typedef struct {
#ifndef LITE_VERSION
trace_head_t trace_head;
#endif
trace_info_t trace_info;
} __attribute__((packed)) LOG_DATA_T;
extern const char *unkonw_str;
extern uint32_t __trc_str_start__[];
extern uint32_t __trc_str_end__[];
uint8_t crc8(uint8_t *data, uint32_t length) {
uint8_t i;
uint8_t crc = 0; // Initial value
while (length--) {
crc ^= *data++; // crc ^= *data; data++;
for (i = 0; i < 8; i++) {
if (crc & 0x80)
crc = (crc << 1) ^ 0x07;
else
crc <<= 1;
}
}
return crc;
}
uint8_t crc6(uint8_t *data, uint32_t length) {
uint8_t i;
uint8_t crc = 0; // Initial value
while (length--) {
crc ^= *data++; // crc ^= *data; data++;
for (i = 0; i < 8; ++i) {
if (crc & 1)
crc = (crc >> 1) ^ 0x30; // 0x30 = (reverse 0x03)>>(8-6)
else
crc = (crc >> 1);
}
}
return crc;
}
static int hal_trace_format_id(uint32_t attr, char *buf, uint32_t size,
const char *fmt, va_list ap) {
uint8_t num;
unsigned int value[10];
LOG_DATA_T trace;
if (size < sizeof(trace) + sizeof(value)) {
return -1;
}
num = GET_BITFIELD(attr, LOG_ATTR_ARG_NUM);
if (num > 10) {
num = 10;
}
for (int i = 0; i < num; i++) {
value[i] = va_arg(ap, unsigned long);
}
// memset(buf, 0, size);
trace.trace_info.count = num;
trace.trace_info.addr =
(uint32_t)fmt -
(uint32_t)0xFFFC0000; //(uint32_t)fmt-(uint32_t)__trc_str_start__;
trace.trace_info.tskid = osGetThreadIntId();
trace.trace_info.crc = 0x2A;
#ifndef LITE_VERSION
trace.trace_head.timestamp = TICKS_TO_MS(hal_sys_timer_get());
#ifdef USE_CRC_CHECK
trace.trace_head.crc = crc8(((uint8_t *)&trace) + 1, 7);
#else
trace.trace_head.crc = 0xBE;
#endif
#else
trace.trace_info.crc = crc6(((uint8_t *)&trace) + 1, 3);
#endif
memcpy(buf, &trace, sizeof(trace));
if (num != 0) {
memcpy(buf + sizeof(trace), value, 4 * num);
}
return sizeof(trace) + 4 * num;
}
#endif
static int hal_trace_print_time(enum LOG_LEVEL_T level,
enum LOG_MODULE_T module, char *buf,
unsigned int size) {
#ifdef TRACE_TIME_STAMP
static const char level_ch[] = {
'C', 'E', 'W', 'N', 'I', 'D', 'V', '-',
};
char ctx[10];
int len;
int i;
const char *mod_name;
#ifdef CRASH_DUMP_ENABLE
if (crash_handling) {
return 0;
}
#endif
if (0) {
#ifdef CP_TRACE_ENABLE
} else if (get_cpu_id()) {
ctx[0] = ' ';
ctx[1] = 'C';
ctx[2] = 'P';
ctx[3] = '\0';
#endif
} else if (in_isr()) {
len = snprintf(ctx, sizeof(ctx), "%2d", (int8_t)NVIC_GetCurrentActiveIRQ());
if (len + 1 < ARRAY_SIZE(ctx)) {
ctx[len] = 'E';
ctx[len + 1] = '\0';
} else {
ctx[ARRAY_SIZE(ctx) - 2] = '.';
ctx[ARRAY_SIZE(ctx) - 1] = '\0';
}
} else {
#ifdef RTOS
#ifdef KERNEL_RTX5
/* const char *thread_name = osGetThreadName(); */
/* snprintf(ctx, sizeof(ctx), "%.9s", thread_name ? (char *)thread_name :
* "NULL"); */
ctx[0] = ' ';
ctx[1] = ' ';
ctx[2] = 't';
ctx[3] = '\0';
#else
snprintf(ctx, sizeof(ctx), "%3d", osGetThreadIntId());
#endif
#else
ctx[0] = ' ';
ctx[1] = ' ';
ctx[2] = '0';
ctx[3] = '\0';
#endif
}
ctx[ARRAY_SIZE(ctx) - 1] = '\0';
len = 0;
len += snprintf(&buf[len], size - len, "%9u/",
(unsigned)TICKS_TO_MS(hal_sys_timer_get()));
if (size > len + 2) {
buf[len++] = level_ch[level];
buf[len++] = '/';
}
if (size > len + 7) {
mod_name = hal_trace_get_log_module_desc(module);
for (i = 0; i < 6; i++) {
if (mod_name[i] == '\0') {
break;
}
buf[len++] = mod_name[i];
}
for (; i < 6; i++) {
buf[len++] = ' ';
}
buf[len++] = '/';
}
len += snprintf(&buf[len], size - len, "%s | ", ctx);
return len;
#else // !TRACE_TIME_STAMP
return 0;
#endif // !TRACE_TIME_STAMP
}
static inline int hal_trace_format_va(uint32_t attr, char *buf,
unsigned int size, const char *fmt,
va_list ap) {
int len;
len = vsnprintf(&buf[0], size, fmt, ap);
if ((attr & LOG_ATTR_NO_LF) == 0) {
#ifdef TRACE_CRLF
if (len + 2 < size) {
buf[len++] = '\r';
}
#endif
if (len + 1 < size) {
buf[len++] = '\n';
}
}
// if (len < size) buf[len] = 0;
return len;
}
static int hal_trace_printf_internal(uint32_t attr, const char *fmt,
va_list ap) {
#ifdef USE_TRACE_ID
char buf[60];
#else
char buf[120];
#endif
int len = 0;
enum LOG_LEVEL_T level;
enum LOG_MODULE_T module;
level = GET_BITFIELD(attr, LOG_ATTR_LEVEL);
module = GET_BITFIELD(attr, LOG_ATTR_MOD);
#ifdef CRASH_DUMP_ENABLE
if (!crash_handling)
#endif
{
if (level > trace_max_level) {
return 0;
}
if (level > LOG_LEVEL_CRITICAL &&
(trace_mod_map[module >> 5] & (1 << (module & 0x1F))) == 0) {
return 0;
}
}
#ifdef USE_TRACE_ID
if ((attr & LOG_ATTR_NO_ID) ||
(len = hal_trace_format_id(attr, buf, sizeof(buf), fmt, ap)) < 0)
#endif
{
len = 0;
if ((attr & LOG_ATTR_NO_TS) == 0) {
len += hal_trace_print_time(level, module, &buf[len], sizeof(buf) - len);
}
len += hal_trace_format_va(attr, &buf[len], sizeof(buf) - len, fmt, ap);
}
return hal_trace_output((unsigned char *)buf, len);
}
int hal_trace_printf(uint32_t attr, const char *fmt, ...) {
int ret;
va_list ap;
if (attr & LOG_ATTR_IMM) {
hal_trace_flush_buffer();
}
va_start(ap, fmt);
ret = hal_trace_printf_internal(attr, fmt, ap);
va_end(ap);
if (attr & LOG_ATTR_IMM) {
hal_trace_flush_buffer();
}
return ret;
}
int hal_trace_dump(const char *fmt, unsigned int size, unsigned int count,
const void *buffer) {
char buf[255] = {0};
int len = 0, n = 0, i = 0;
switch (size) {
case sizeof(uint32_t):
while (i < count && len < sizeof(buf)) {
len += snprintf(&buf[len], sizeof(buf) - len, fmt,
*(uint32_t *)((uint32_t *)buffer + i));
i++;
}
break;
case sizeof(uint16_t):
while (i < count && len < sizeof(buf)) {
len += snprintf(&buf[len], sizeof(buf) - len, fmt,
*(int16_t *)((int16_t *)buffer + i));
i++;
}
break;
case sizeof(uint8_t):
default:
while (i < count && len < sizeof(buf)) {
len += snprintf(&buf[len], sizeof(buf) - len, fmt,
*(uint8_t *)((uint8_t *)buffer + i));
i++;
}
break;
}
#ifdef TRACE_CRLF
if (len + 2 < sizeof(buf)) {
buf[len++] = '\r';
}
#endif
if (len + 1 < sizeof(buf)) {
buf[len++] = '\n';
}
n = hal_trace_output((unsigned char *)buf, len + 1);
return n;
}
int hal_trace_busy(void) {
union HAL_UART_FLAG_T flag;
if (hal_trace_is_uart_transport(trace_transport)) {
if (hal_uart_opened(trace_uart)) {
flag = hal_uart_get_flag(trace_uart);
return flag.BUSY;
}
}
return 0;
}
int hal_trace_pause(void) {
if (hal_trace_is_uart_transport(trace_transport)) {
return hal_uart_pause(trace_uart);
}
return 1;
}
int hal_trace_continue(void) {
if (hal_trace_is_uart_transport(trace_transport)) {
return hal_uart_continue(trace_uart);
}
return 1;
}
int hal_trace_flush_buffer(void) {
uint32_t lock;
uint32_t time;
int ret;
enum HAL_DMA_RET_T dma_ret;
if (!hal_trace_is_uart_transport(trace_transport)) {
return -1;
}
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
if (cp_buffer_cb) {
cp_buffer_cb(HAL_TRACE_BUF_STATE_FLUSH);
}
return 0;
}
#endif
hal_uart_continue(trace_uart);
lock = int_lock();
time = hal_sys_timer_get();
while (trace.wptr != trace.rptr &&
hal_sys_timer_get() - time < TRACE_FLUSH_TIMEOUT) {
#if (TRACE_IDLE_OUTPUT == 0)
while (hal_gpdma_chan_busy(dma_cfg.ch))
;
dma_ret = hal_gpdma_irq_run_chan(dma_cfg.ch);
if (dma_ret != HAL_DMA_OK) {
hal_trace_send();
}
#else
hal_trace_idle_send();
#endif
}
ret = (trace.wptr == trace.rptr) ? 0 : 1;
int_unlock(lock);
return ret;
}
uint32_t hal_trace_get_backtrace_addr(uint32_t addr) {
if (!hal_trace_address_executable(addr)) {
return 0;
}
#ifndef __ARM_ARCH_ISA_ARM
#if defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_8M_MAIN__)
// BL Instruction
// OFFSET: 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 15 14 13 12 11 10
// 09 08 07 06 05 04 03 02 01 00 VALUE : 1 1 1 1 0 - - - - - - -
// - - - - 1 1 - 1 - - - - - - - - - - - -
// BLX Instruction
// OFFSET: 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
// VALUE : 0 1 0 0 0 1 1 1 1 - - - - - - -
uint16_t val;
uint32_t new_addr;
new_addr = (addr & ~1) - 2;
val = *(uint16_t *)new_addr;
if ((val & 0xFF80) == 0x4780) {
// BLX
return new_addr;
} else if ((val & 0xD000) == 0xD000) {
new_addr -= 2;
val = *(uint16_t *)new_addr;
if ((val & 0xF800) == 0xF000) {
// BL
return new_addr;
}
}
#else
#error "Only ARMv7-M/ARMv8-M function can be checked for BL/BLX instructions"
#endif
#endif
return 0;
}
#ifndef __ARM_ARCH_ISA_ARM
void hal_trace_print_special_stack_registers(void) {
int len;
hal_trace_output((const unsigned char *)newline, sizeof(newline) - 1);
len =
snprintf(crash_buf, sizeof(crash_buf), "MSP=%08X, PSP=%08X" NEW_LINE_STR,
(unsigned)__get_MSP(), (unsigned)__get_PSP());
hal_trace_output((unsigned char *)crash_buf, len);
#ifdef __ARM_ARCH_8M_MAIN__
len = snprintf(crash_buf, sizeof(crash_buf),
"MSPLIM=%08X, PSPLIM=%08X" NEW_LINE_STR,
(unsigned)__get_MSPLIM(), (unsigned)__get_PSPLIM());
hal_trace_output((unsigned char *)crash_buf, len);
#endif
}
#endif
void hal_trace_print_common_registers(const uint32_t *regs) {
int len;
int i;
int index;
hal_trace_output((const unsigned char *)newline, sizeof(newline) - 1);
for (i = 0; i < 3; i++) {
index = i * 4;
len = snprintf(
crash_buf, sizeof(crash_buf),
"R%-2d=%08X, R%-2d=%08X, R%-2d=%08X, R%-2d=%08X" NEW_LINE_STR, index,
(unsigned)regs[index], index + 1, (unsigned)regs[index + 1], index + 2,
(unsigned)regs[index + 2], index + 3, (unsigned)regs[index + 3]);
hal_trace_output((unsigned char *)crash_buf, len);
}
len = snprintf(crash_buf, sizeof(crash_buf),
"R12=%08X, SP =%08X, LR =%08X" NEW_LINE_STR,
(unsigned)regs[12], (unsigned)regs[13], (unsigned)regs[14]);
hal_trace_output((unsigned char *)crash_buf, len);
}
void hal_trace_print_stack(uint32_t addr) {
static const char stack_title[] = "Stack:" NEW_LINE_STR;
int len = 0;
int i;
int pos;
uint32_t *stack;
addr &= ~3;
if (!hal_trace_address_writable(addr)) {
return;
}
hal_trace_output((const unsigned char *)newline, sizeof(newline) - 1);
hal_trace_output((const unsigned char *)stack_title, sizeof(stack_title) - 1);
stack = (uint32_t *)addr - STACK_DUMP_CNT_PREV;
for (i = 0; i < (STACK_DUMP_CNT_PREV + STACK_DUMP_CNT); i++) {
if (!hal_trace_address_writable((uint32_t)&stack[i])) {
break;
}
pos = (i % STACK_DUMP_CNT_PER_LEN);
if (pos == 0) {
len = snprintf(crash_buf, sizeof(crash_buf), "%c %08X: %08X",
(i == STACK_DUMP_CNT_PREV) ? '*' : ' ',
(unsigned)&stack[i], (unsigned)stack[i]);
} else {
len += snprintf(crash_buf + len, sizeof(crash_buf) - len, " %08X",
(unsigned)stack[i]);
if (pos == (STACK_DUMP_CNT_PER_LEN - 1)) {
#ifdef TRACE_CRLF
if (len + 2 < sizeof(crash_buf)) {
crash_buf[len++] = '\r';
}
#endif
if (len + 1 < sizeof(crash_buf)) {
crash_buf[len++] = '\n';
}
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_flush_buffer();
}
}
}
}
void hal_trace_print_backtrace(uint32_t addr, uint32_t search_cnt,
uint32_t print_cnt) {
static const char bt_title[] = "Possible Backtrace:" NEW_LINE_STR;
int i, j;
int len;
uint32_t *stack;
uint32_t call_addr;
addr &= ~3;
if (!hal_trace_address_writable(addr)) {
return;
}
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_output((const unsigned char *)bt_title, sizeof(bt_title));
stack = (uint32_t *)addr;
for (i = 0, j = 0; i < search_cnt && j < print_cnt; i++) {
if (!hal_trace_address_writable((uint32_t)&stack[i])) {
break;
}
call_addr = hal_trace_get_backtrace_addr(stack[i]);
if (call_addr) {
len = snprintf(crash_buf, sizeof(crash_buf), "%8X" NEW_LINE_STR,
(unsigned)call_addr);
hal_trace_output((unsigned char *)crash_buf, len + 1);
j++;
}
}
}
uint32_t hal_trace_get_baudrate(void) { return uart_cfg.baud; }
bool hal_trace_crash_dump_onprocess(void) { return crash_dump_onprocess; }
int hal_trace_crash_dump_register(enum HAL_TRACE_CRASH_DUMP_MODULE_T module,
HAL_TRACE_CRASH_DUMP_CB_T cb) {
#ifdef CRASH_DUMP_ENABLE
ASSERT(module < HAL_TRACE_CRASH_DUMP_MODULE_END, "%s module %d", __func__,
module);
crash_dump_cb_list[module] = cb;
#endif
return 0;
}
#ifdef CRASH_DUMP_ENABLE
static void hal_trace_crash_dump_callback(void) {
int i;
crash_handling = true;
for (i = 0; i < ARRAY_SIZE(crash_dump_cb_list); i++) {
if (crash_dump_cb_list[i]) {
crash_dump_cb_list[i]();
}
}
}
#endif
void hal_trace_app_register(HAL_TRACE_APP_NOTIFY_T notify_cb,
HAL_TRACE_APP_OUTPUT_T output_cb) {
#ifdef TRACE_TO_APP
app_notify_cb = notify_cb;
app_output_cb = output_cb;
#endif
}
void hal_trace_app_custom_register(HAL_TRACE_APP_NOTIFY_T notify_cb,
HAL_TRACE_APP_OUTPUT_T output_cb,
HAL_TRACE_APP_OUTPUT_T crash_custom_cb) {
#ifdef TRACE_TO_APP
hal_trace_app_register(notify_cb, output_cb);
app_crash_custom_cb = crash_custom_cb;
#endif
}
void hal_trace_cp_register(HAL_TRACE_APP_NOTIFY_T notify_cb,
HAL_TRACE_BUF_CTRL_T buf_cb) {
#ifdef CP_TRACE_ENABLE
cp_notify_cb = notify_cb;
cp_buffer_cb = buf_cb;
#endif
}
#else // !(DEBUG || REL_TRACE_ENABLE)
int hal_trace_open(enum HAL_TRACE_TRANSPORT_T transport) {
#ifdef FAULT_DUMP
#ifdef __ARM_ARCH_ISA_ARM
GIC_SetFaultDumpHandler(hal_trace_fault_dump);
#else
NVIC_SetDefaultFaultHandler(hal_trace_fault_handler);
#endif
#endif
return 0;
}
#endif // !(DEBUG || REL_TRACE_ENABLE)
int hal_trace_open_cp(void) {
#ifdef CP_TRACE_ENABLE
#ifdef FAULT_DUMP
NVIC_SetDefaultFaultHandler_cp(hal_trace_fault_handler);
#endif
#endif
return 0;
}
int hal_trace_address_writable(uint32_t addr) {
if (RAM_BASE < addr && addr < RAM_BASE + RAM_SIZE) {
return 1;
}
#ifdef PSRAM_BASE
if (PSRAM_BASE < addr && addr < PSRAM_BASE + PSRAM_SIZE) {
return 1;
}
#endif
#ifdef PSRAM_NC_BASE
if (PSRAM_NC_BASE < addr && addr < PSRAM_NC_BASE + PSRAM_SIZE) {
return 1;
}
#endif
#ifdef PSRAMUHS_BASE
if (PSRAMUHS_BASE < addr && addr < PSRAMUHS_BASE + PSRAMUHS_SIZE) {
return 1;
}
#endif
#ifdef PSRAMUHS_NC_BASE
if (PSRAMUHS_NC_BASE < addr && addr < PSRAMUHS_NC_BASE + PSRAMUHS_SIZE) {
return 1;
}
#endif
#ifdef RAMRET_BASE
if (RAMRET_BASE < addr && addr < RAMRET_BASE + RAMRET_SIZE) {
return 1;
}
#endif
#ifdef RAMCP_BASE
if (RAMCP_BASE < addr && addr < RAMCP_BASE + RAMCP_SIZE) {
return 1;
}
#endif
return 0;
}
int hal_trace_address_executable(uint32_t addr) {
// Avoid reading out of valid memory region when parsing instruction content
#define X_ADDR_OFFSET 0x10
// Check thumb code
if ((addr & 1) == 0) {
return 0;
}
// Check location
if (RAMX_BASE + X_ADDR_OFFSET < addr && addr < RAMX_BASE + RAM_SIZE) {
return 1;
}
if (FLASHX_BASE + X_ADDR_OFFSET < addr && addr < FLASHX_BASE + FLASH_SIZE) {
return 1;
}
#ifdef PSRAMX_BASE
if (PSRAMX_BASE + X_ADDR_OFFSET < addr && addr < PSRAMX_BASE + PSRAM_SIZE) {
return 1;
}
#endif
#ifdef PSRAMUHSX_BASE
if (PSRAMUHSX_BASE + X_ADDR_OFFSET < addr &&
addr < PSRAMUHSX_BASE + PSRAMUHS_SIZE) {
return 1;
}
#endif
#ifdef RAMXRET_BASE
if (RAMXRET_BASE < addr && addr < RAMXRET_BASE + RAMRET_SIZE) {
return 1;
}
#endif
//#define CHECK_ROM_CODE
#ifdef CHECK_ROM_CODE
#ifndef USED_ROM_SIZE
#define USED_ROM_SIZE ROM_SIZE
#endif
if (ROM_BASE + (NVIC_USER_IRQ_OFFSET * 4) < addr &&
addr < ROM_BASE + USED_ROM_SIZE) {
return 1;
}
#endif
#if 0
if (FLASHX_NC_BASE < addr && addr < FLASHX_NC_BASE + FLASH_SIZE) {
return 1;
}
#ifdef PSRAMX_NC_BASE
if (PSRAMX_NC_BASE < addr && addr < PSRAMX_NC_BASE + PSRAM_SIZE) {
return 1;
}
#endif
#ifdef PSRAMUHSX_NC_BASE
if (PSRAMUHSX_NC_BASE < addr && addr < PSRAMUHSX_NC_BASE + PSRAMUHS_SIZE) {
return 1;
}
#endif
#endif
return 0;
}
int hal_trace_address_readable(uint32_t addr) {
if (hal_trace_address_writable(addr)) {
return 1;
}
if (hal_trace_address_executable(addr)) {
return 1;
}
if (FLASH_BASE < addr && addr < FLASH_BASE + FLASH_SIZE) {
return 1;
}
if (FLASH_NC_BASE < addr && addr < FLASH_NC_BASE + FLASH_SIZE) {
return 1;
}
#ifdef PSRAM_NC_BASE
if (PSRAM_NC_BASE < addr && addr < PSRAM_NC_BASE + PSRAM_SIZE) {
return 1;
}
#endif
#ifdef PSRAMUHS_NC_BASE
if (PSRAMUHS_NC_BASE < addr && addr < PSRAMUHS_NC_BASE + PSRAMUHS_SIZE) {
return 1;
}
#endif
return 0;
}
static void NORETURN hal_trace_crash_end(void) {
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_flush_buffer();
hal_sys_timer_delay(MS_TO_TICKS(5));
#endif
// Tag failure for simulation environment
hal_cmu_simu_fail();
#ifndef PROGRAMMER
#ifndef __BES_OTA_MODE__
nv_record_flash_flush();
#endif
#endif
#ifdef CRASH_REBOOT
hal_sw_bootmode_set(HAL_SW_BOOTMODE_REBOOT |
HAL_SW_BOOTMODE_REBOOT_FROM_CRASH);
hal_cmu_sys_reboot();
#else
hal_iomux_set_analog_i2c();
hal_iomux_set_jtag();
hal_cmu_jtag_clock_enable();
#endif
SAFE_PROGRAM_STOP();
}
__STATIC_FORCEINLINE uint32_t get_cpu_id_tag(void) {
uint32_t cpu_id;
#ifdef CP_TRACE_ENABLE
cpu_id = get_cpu_id();
#elif defined(__ARM_ARCH_ISA_ARM)
cpu_id = 0xAAAA0000 | (get_cpu_id() & 0xFFFF);
#else
cpu_id = 0;
#endif
return cpu_id;
}
static void NORETURN USED hal_trace_assert_dump_internal(ASSERT_DUMP_ARGS) {
const uint32_t *p_regs;
struct ASSERT_INFO_T info;
int i;
// MUST SAVE REGISTERS FIRST!
p_regs = (const uint32_t *)crash_buf;
for (i = 0; i < ARRAY_SIZE(info.R); i++) {
info.R[i] = p_regs[i];
}
int_lock_global();
info.ID = HAL_TRACE_ASSERT_ID;
info.CPU_ID = get_cpu_id_tag();
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE)) && \
defined(ASSERT_SHOW_FILE_FUNC)
info.FILE = file;
#elif (defined(DEBUG) || defined(REL_TRACE_ENABLE)) && defined(ASSERT_SHOW_FILE)
info.FILE = scope;
#else
info.FILE = NULL;
#endif
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE)) && \
defined(ASSERT_SHOW_FILE_FUNC)
info.FUNC = func;
#elif (defined(DEBUG) || defined(REL_TRACE_ENABLE)) && defined(ASSERT_SHOW_FUNC)
info.FUNC = scope;
#else
info.FUNC = NULL;
#endif
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE)) && \
(defined(ASSERT_SHOW_FILE_FUNC) || defined(ASSERT_SHOW_FILE) || \
defined(ASSERT_SHOW_FUNC))
info.LINE = line;
#else
info.LINE = 0;
#endif
info.FMT = fmt;
#ifndef __ARM_ARCH_ISA_ARM
info.MSP = __get_MSP();
info.PSP = __get_PSP();
info.CONTROL = __get_CONTROL();
#ifdef __ARM_ARCH_8M_MAIN__
info.MSPLIM = __get_MSPLIM();
info.PSPLIM = __get_PSPLIM();
#endif
#endif
*(volatile uint32_t *)RAM_BASE = (uint32_t)&info;
#ifdef ASSERT_MUTE_CODEC
bool crash_mute = true;
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
// Forbid CP to access CODEC
crash_mute = false;
}
#endif
if (crash_mute) {
hal_codec_crash_mute();
}
#endif
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
static const char POSSIBLY_UNUSED desc_file[] = "FILE : ";
static const char POSSIBLY_UNUSED desc_func[] = "FUNCTION: ";
static const char POSSIBLY_UNUSED desc_line[] = "LINE : ";
int len;
va_list ap;
#ifdef CRASH_DUMP_ENABLE
bool full_dump = true;
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
full_dump = false;
if (cp_notify_cb) {
cp_notify_cb(HAL_TRACE_STATE_CRASH_ASSERT_START);
}
}
#endif
if (full_dump) {
#ifdef TRACE_TO_APP
if (app_notify_cb) {
app_notify_cb(HAL_TRACE_STATE_CRASH_ASSERT_START);
}
app_output_enabled = true;
#endif
crash_dump_onprocess = true;
for (uint8_t i = 0; i < 10; i++) {
REL_TRACE_IMM(0, " "
" ");
REL_TRACE_IMM(0, " "
" " NEW_LINE_STR);
hal_sys_timer_delay(MS_TO_TICKS(50));
}
}
#endif
hal_trace_flush_buffer();
hal_sysfreq_req(HAL_SYSFREQ_USER_INIT, HAL_CMU_FREQ_52M);
len = hal_trace_print_time(LOG_LEVEL_CRITICAL, LOG_MODULE_NONE, &crash_buf[0],
sizeof(crash_buf));
if (len > 0) {
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_output((unsigned char *)crash_buf, len);
}
len = snprintf(&crash_buf[0], sizeof(crash_buf),
NEW_LINE_STR "### ASSERT @ 0x%08X ###" NEW_LINE_STR,
(unsigned)info.R[14]);
hal_trace_output((unsigned char *)crash_buf, len);
#if defined(ASSERT_SHOW_FILE_FUNC) || defined(ASSERT_SHOW_FILE) || \
defined(ASSERT_SHOW_FUNC)
const char separate_line[] =
"----------------------------------------" NEW_LINE_STR;
#ifdef ASSERT_SHOW_FILE
const char *file = scope;
#elif defined(ASSERT_SHOW_FUNC)
const char *func = scope;
#endif
#if defined(ASSERT_SHOW_FILE_FUNC) || defined(ASSERT_SHOW_FILE)
hal_trace_output((const unsigned char *)desc_file, sizeof(desc_file));
hal_trace_output((const unsigned char *)file, strlen(file) + 1);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
#endif
#if defined(ASSERT_SHOW_FILE_FUNC) || defined(ASSERT_SHOW_FUNC)
hal_trace_output((const unsigned char *)desc_func, sizeof(desc_func));
hal_trace_output((const unsigned char *)func, strlen(func) + !);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
#endif
hal_trace_output((const unsigned char *)desc_line, sizeof(desc_func));
len = snprintf(crash_buf, sizeof(crash_buf), "%u", line);
hal_trace_output((const unsigned char *)crash_buf, len);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_output((unsigned char *)separate_line, sizeof(separate_line));
hal_trace_flush_buffer();
#endif
va_start(ap, fmt);
len = hal_trace_format_va(0, crash_buf, sizeof(crash_buf), fmt, ap);
va_end(ap);
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_flush_buffer();
hal_trace_print_common_registers(info.R);
hal_trace_print_special_stack_registers();
hal_trace_print_stack(info.R[13]);
hal_trace_print_backtrace(info.R[13], TRACE_BACKTRACE_SEARCH_WORD,
TRACE_BACKTRACE_NUM);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_flush_buffer();
#ifdef CRASH_DUMP_ENABLE
if (full_dump) {
hal_trace_crash_dump_callback();
hal_trace_flush_buffer();
hal_sys_timer_delay(MS_TO_TICKS(5));
#ifdef CORE_DUMP
AssertCatcher_Entry();
hal_sys_timer_delay(MS_TO_TICKS(5));
#endif
#ifdef TRACE_TO_APP
if (app_notify_cb) {
app_notify_cb(HAL_TRACE_STATE_CRASH_END);
}
#endif
}
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
if (cp_notify_cb) {
cp_notify_cb(HAL_TRACE_STATE_CRASH_END);
}
SAFE_PROGRAM_STOP();
}
#endif
#endif // CRASH_DUMP_ENABLE
#endif // DEBUG || REL_TRACE_ENABLE
hal_trace_crash_end();
}
void NORETURN NAKED hal_trace_assert_dump(ASSERT_DUMP_ARGS) {
asm volatile("subs sp, sp, #4*" TO_STRING(
STACK_DUMP_CNT_PREV) ";"
".cfi_def_cfa_offset 4*" TO_STRING(
STACK_DUMP_CNT_PREV) ";"
"push {r0, r1};"
"ldr r0, =crash_buf;"
"ldr r1, [sp];"
"str r1, [r0], 4;"
"ldr r1, [sp, 4];"
"str r1, [r0], 4;"
"stmia r0!, {r2-r12};"
"add r1, sp, "
"#4*(2+" TO_STRING(
STACK_DUMP_CNT_PREV) ")"
";"
"s"
"t"
"r"
" "
"r"
"1"
","
" "
"["
"r"
"0"
"]"
","
" "
"4"
";"
"s"
"t"
"r"
" "
"l"
"r"
","
" "
"["
"r"
"0"
"]"
","
" "
"4"
";"
"p"
"o"
"p"
" "
"{"
"r"
"0"
","
" "
"r"
"1"
"}"
";"
"b"
"."
"w"
" "
"h"
"a"
"l"
"_"
"t"
"r"
"a"
"c"
"e"
"_"
"a"
"s"
"s"
"e"
"r"
"t"
"_"
"d"
"u"
"m"
"p"
"_"
"i"
"n"
"t"
"e"
"r"
"n"
"a"
"l"
";");
}
#ifdef FAULT_DUMP
static void hal_trace_fill_exception_info(struct EXCEPTION_INFO_T *info,
const uint32_t *regs,
const uint32_t *extra,
uint32_t extra_len) {
info->ID = HAL_TRACE_EXCEPTION_ID;
info->CPU_ID = get_cpu_id_tag();
info->REGS = regs;
#ifdef __ARM_ARCH_ISA_ARM
info->extra = extra;
info->extra_len = extra_len;
#else
info->MSP = __get_MSP();
info->PSP = __get_PSP();
info->PRIMASK = regs[17];
info->FAULTMASK = __get_FAULTMASK();
info->BASEPRI = __get_BASEPRI();
info->CONTROL = __get_CONTROL();
info->ICSR = SCB->ICSR;
info->AIRCR = SCB->AIRCR;
info->SCR = SCB->SCR;
info->CCR = SCB->CCR;
info->SHCSR = SCB->SHCSR;
info->CFSR = SCB->CFSR;
info->HFSR = SCB->HFSR;
info->AFSR = SCB->AFSR;
info->MMFAR = SCB->MMFAR;
info->BFAR = SCB->BFAR;
#ifdef __ARM_ARCH_8M_MAIN__
info->MSPLIM = __get_MSPLIM();
info->PSPLIM = __get_PSPLIM();
#endif
#endif
}
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
#ifdef __ARM_ARCH_ISA_ARM
static void hal_trace_print_fault_info_ca(const struct EXCEPTION_INFO_T *info) {
const struct FAULT_REGS_T *fregs;
const uint32_t *extra;
// uint32_t extra_len;
enum EXCEPTION_ID_T id;
int len;
uint32_t val;
const char *desc;
fregs = (const struct FAULT_REGS_T *)info->REGS;
extra = info->extra;
// extra_len = info->extra_len;
id = (enum EXCEPTION_ID_T)extra[0];
len = snprintf(crash_buf, sizeof(crash_buf), "PC =%08X",
(unsigned)fregs->r[15]);
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
", ExceptionNumber=%d" NEW_LINE_STR, id);
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_print_common_registers(fregs->r);
len = snprintf(crash_buf, sizeof(crash_buf), "SPSR=%08X",
(unsigned)fregs->spsr);
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, ", APSR=%c%c%c%c%c",
(fregs->spsr & (1 << 31)) ? 'N' : 'n',
(fregs->spsr & (1 << 30)) ? 'Z' : 'z',
(fregs->spsr & (1 << 29)) ? 'C' : 'c',
(fregs->spsr & (1 << 28)) ? 'V' : 'v',
(fregs->spsr & (1 << 27)) ? 'Q' : 'q');
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, ", XC=%c%c%c%c%c",
(fregs->spsr & (1 << 9)) ? 'E' : 'e',
(fregs->spsr & (1 << 8)) ? 'A' : 'a',
(fregs->spsr & (1 << 7)) ? 'I' : 'i',
(fregs->spsr & (1 << 6)) ? 'F' : 'f',
(fregs->spsr & (1 << 5)) ? 'T' : 't');
val = fregs->spsr & 0x1F;
if (val == 0x10) {
desc = "USR";
} else if (val == 0x11) {
desc = "FIQ";
} else if (val == 0x12) {
desc = "IRQ";
} else if (val == 0x13) {
desc = "SVC";
} else if (val == 0x16) {
desc = "MON";
} else if (val == 0x17) {
desc = "ABT";
} else if (val == 0x1A) {
desc = "HYP";
} else if (val == 0x1B) {
desc = "UND";
} else if (val == 0x1F) {
desc = "SYS";
} else {
desc = "UNKNOWN";
}
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, ", MODE=%02X (%s)",
(unsigned)val, desc);
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_flush_buffer();
if (id == EXCEPTION_UNDEF) {
} else if (id == EXCEPTION_SVC) {
} else if (id == EXCEPTION_PABT) {
} else if (id == EXCEPTION_DABT) {
} else {
}
}
#else
static void hal_trace_print_fault_info_cm(const struct EXCEPTION_INFO_T *info) {
const uint32_t *regs;
int len;
uint32_t val;
uint32_t primask;
regs = info->REGS;
primask = regs[17];
len = snprintf(crash_buf, sizeof(crash_buf), "PC =%08X", (unsigned)regs[15]);
val = __get_IPSR();
if (val == 0) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
", ThreadMode" NEW_LINE_STR);
} else {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
", ExceptionNumber=%d" NEW_LINE_STR, (int)val - 16);
}
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_print_common_registers(regs);
hal_trace_print_special_stack_registers();
hal_trace_output((const unsigned char *)newline, sizeof(newline));
len = snprintf(
crash_buf, sizeof(crash_buf),
"PRIMASK=%02X, FAULTMASK=%02X, BASEPRI=%02X, CONTROL=%02X" NEW_LINE_STR,
(unsigned)primask, (unsigned)__get_FAULTMASK(), (unsigned)__get_BASEPRI(),
(unsigned)__get_CONTROL());
hal_trace_output((unsigned char *)crash_buf, len);
len = snprintf(crash_buf, sizeof(crash_buf), "XPSR=%08X", (unsigned)regs[16]);
len += snprintf(
&crash_buf[len], sizeof(crash_buf) - len, ", APSR=%c%c%c%c%c",
(regs[16] & (1 << 31)) ? 'N' : 'n', (regs[16] & (1 << 30)) ? 'Z' : 'z',
(regs[16] & (1 << 29)) ? 'C' : 'c', (regs[16] & (1 << 28)) ? 'V' : 'v',
(regs[16] & (1 << 27)) ? 'Q' : 'q');
val = regs[16] & 0xFF;
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
", EPSR=%08X, IPSR=%02X", (unsigned)(regs[16] & 0x0700FC00),
(unsigned)val);
if (val == 0) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (NoException)");
}
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_flush_buffer();
len = snprintf(crash_buf, sizeof(crash_buf),
"ICSR =%08X, AIRCR=%08X, SCR =%08X, CCR =%08X" NEW_LINE_STR,
(unsigned)info->ICSR, (unsigned)info->AIRCR,
(unsigned)info->SCR, (unsigned)info->CCR);
hal_trace_output((unsigned char *)crash_buf, len);
len = snprintf(crash_buf, sizeof(crash_buf),
"SHCSR=%08X, CFSR =%08X, HFSR =%08X, AFSR =%08X" NEW_LINE_STR,
(unsigned)info->SHCSR, (unsigned)info->CFSR,
(unsigned)info->HFSR, (unsigned)info->AFSR);
hal_trace_output((unsigned char *)crash_buf, len);
len = snprintf(crash_buf, sizeof(crash_buf),
"MMFAR=%08X, BFAR =%08X" NEW_LINE_STR, (unsigned)info->MMFAR,
(unsigned)info->BFAR);
hal_trace_output((unsigned char *)crash_buf, len);
if (info->HFSR & (1 << 30)) {
len = snprintf(crash_buf, sizeof(crash_buf),
"(Escalation HardFault)" NEW_LINE_STR);
hal_trace_output((unsigned char *)crash_buf, len);
}
len = snprintf(crash_buf, sizeof(crash_buf), "FaultInfo :");
if ((info->SHCSR & 0x3F) == 0) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (None)");
} else {
if (info->SHCSR & (1 << 0)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (MemFault)");
}
if (info->SHCSR & (1 << 1)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (BusFault)");
}
#ifdef __ARM_ARCH_8M_MAIN__
if (info->SHCSR & (1 << 2)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (HardFault)");
}
#endif
if (info->SHCSR & (1 << 3)) {
len +=
snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (UsageFault)");
}
#ifdef __ARM_ARCH_8M_MAIN__
if (info->SHCSR & (1 << 4)) {
len +=
snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (SecureFault)");
}
if (info->SHCSR & (1 << 5)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (NMI)");
}
#endif
}
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
len = snprintf(crash_buf, sizeof(crash_buf), "FaultCause:");
if (info->CFSR == 0) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (None)");
} else {
if (info->CFSR & (1 << 0)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Instruction access violation)");
}
if (info->CFSR & (1 << 1)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Data access violation)");
}
if (info->CFSR & (1 << 3)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (MemFault on unstacking for a return from exception)");
}
if (info->CFSR & (1 << 4)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (MemFault on stacking for exception entry)");
}
if (info->CFSR & (1 << 5)) {
len +=
snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (MemFault during floating-point lazy state preservation)");
}
if (info->CFSR & (1 << 7)) {
len +=
snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (MMFAR valid)");
}
if (len) {
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_flush_buffer();
len = 0;
}
if (info->CFSR & (1 << 8)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Instruction bus error)");
}
if (info->CFSR & (1 << 9)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Precise data bus error)");
}
#ifndef __ARM_ARCH_8M_MAIN__
if (info->CFSR & (1 << 10)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Imprecise data bus error)");
}
#endif
if (info->CFSR & (1 << 11)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (BusFault on unstacking for a return from exception)");
}
if (info->CFSR & (1 << 12)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (BusFault on stacking for exception entry)");
}
if (info->CFSR & (1 << 13)) {
len +=
snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (BusFault during floating-point lazy state preservation)");
}
if (info->CFSR & (1 << 15)) {
len +=
snprintf(&crash_buf[len], sizeof(crash_buf) - len, " (BFAR valid)");
}
if (len) {
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_flush_buffer();
len = 0;
}
if (info->CFSR & (1 << 16)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Undefined instruction UsageFault)");
}
if (info->CFSR & (1 << 17)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Invalid state UsageFault)");
}
if (info->CFSR & (1 << 18)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Invalid PC load by EXC_RETURN UsageFault)");
}
if (info->CFSR & (1 << 19)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (No coprocessor UsageFault)");
}
#ifdef __ARM_ARCH_8M_MAIN__
if (info->CFSR & (1 << 20)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Stack overflow UsageFault)");
}
#endif
if (info->CFSR & (1 << 24)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Unaligned access UsageFault)");
}
if (info->CFSR & (1 << 25)) {
len += snprintf(&crash_buf[len], sizeof(crash_buf) - len,
" (Divide by zero UsageFault)");
}
}
hal_trace_output((unsigned char *)crash_buf, len);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
}
#endif
static void hal_trace_print_fault_info(const struct EXCEPTION_INFO_T *info) {
#ifdef __ARM_ARCH_ISA_ARM
hal_trace_print_fault_info_ca(info);
#else
hal_trace_print_fault_info_cm(info);
#endif
}
#endif // DEBUG || REL_TRACE_ENABLE
void hal_trace_fault_dump(const uint32_t *regs, const uint32_t *extra,
uint32_t extra_len) {
struct EXCEPTION_INFO_T info;
int_lock_global();
hal_trace_fill_exception_info(&info, regs, extra, extra_len);
*(volatile uint32_t *)RAM_BASE = (uint32_t)&info;
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
static const char title[] = NEW_LINE_STR "### EXCEPTION ###" NEW_LINE_STR;
int len;
#ifdef CRASH_DUMP_ENABLE
bool full_dump = true;
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
full_dump = false;
if (cp_notify_cb) {
cp_notify_cb(HAL_TRACE_STATE_CRASH_FAULT_START);
}
}
#endif
if (full_dump) {
#ifdef TRACE_TO_APP
if (app_notify_cb) {
app_notify_cb(HAL_TRACE_STATE_CRASH_FAULT_START);
}
if (app_crash_custom_cb == NULL) {
app_output_enabled = true;
}
#endif
crash_dump_onprocess = true;
for (uint8_t i = 0; i < 10; i++) {
REL_TRACE_IMM(0, " "
" ");
REL_TRACE_IMM(0, " "
" " NEW_LINE_STR);
hal_sys_timer_delay(MS_TO_TICKS(50));
}
}
#endif
hal_trace_flush_buffer();
hal_sysfreq_req(HAL_SYSFREQ_USER_INIT, HAL_CMU_FREQ_52M);
len = hal_trace_print_time(LOG_LEVEL_CRITICAL, LOG_MODULE_NONE, &crash_buf[0],
sizeof(crash_buf));
if (len > 0) {
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_output((unsigned char *)crash_buf, len);
}
hal_trace_output((unsigned char *)title, sizeof(title));
hal_trace_print_fault_info(&info);
hal_trace_flush_buffer();
hal_trace_print_stack(regs[13]);
hal_trace_print_backtrace(regs[13], TRACE_BACKTRACE_SEARCH_WORD,
TRACE_BACKTRACE_NUM);
hal_trace_output((const unsigned char *)newline, sizeof(newline));
hal_trace_flush_buffer();
#ifdef CRASH_DUMP_ENABLE
if (full_dump) {
hal_trace_crash_dump_callback();
hal_trace_flush_buffer();
#ifndef __ARM_ARCH_ISA_ARM
#ifdef TRACE_TO_APP
// Crash-Dump "Lite-Version"
if (app_crash_custom_cb) {
app_crash_custom_cb((unsigned char *)regs,
CRASH_DUMP_REGISTERS_NUM_BYTES);
stack = (uint32_t *)(__get_MSP() & ~3);
app_crash_custom_cb((unsigned char *)stack,
((CRASH_DUMP_STACK_NUM_BYTES) / 2));
stack = (uint32_t *)(__get_PSP() & ~3);
app_crash_custom_cb((unsigned char *)stack,
((CRASH_DUMP_STACK_NUM_BYTES) / 2));
}
#endif
#ifdef CORE_DUMP
{
static CrashCatcherExceptionRegisters eregs;
eregs.msp = info.MSP;
eregs.psp = info.PSP;
eregs.exceptionPSR = regs[16] & 0x0700FE00;
eregs.r4 = regs[4];
eregs.r5 = regs[5];
eregs.r6 = regs[6];
eregs.r7 = regs[7];
eregs.r8 = regs[8];
eregs.r9 = regs[9];
eregs.r10 = regs[10];
eregs.r11 = regs[11];
eregs.exceptionLR = regs[14];
CrashCatcher_Entry(&eregs);
}
#endif
#endif // !__ARM_ARCH_ISA_ARM
#ifdef TRACE_TO_APP
if (app_notify_cb) {
app_notify_cb(HAL_TRACE_STATE_CRASH_END);
}
#endif
}
#ifdef CP_TRACE_ENABLE
if (get_cpu_id()) {
if (cp_notify_cb) {
cp_notify_cb(HAL_TRACE_STATE_CRASH_END);
}
SAFE_PROGRAM_STOP();
}
#endif
#endif // CRASH_DUMP_ENABLE
#endif // DEBUG || REL_TRACE_ENABLE
hal_trace_crash_end();
}
#ifndef __ARM_ARCH_ISA_ARM
static void NAKED hal_trace_fault_handler(void) {
// TODO: Save FP registers (and check lazy Floating-point context
// preservation)
asm volatile(
// Check EXC_RETURN.SPSEL (bit[2])
"tst lr, #0x04;"
"ite eq;"
// Using MSP
"mrseq r3, msp;"
// Using PSP
"mrsne r3, psp;"
// Check EXC_RETURN.FType (bit[4])
"tst lr, #0x10;"
"ite eq;"
// FPU context saved
"moveq r1, #1;"
// No FPU context
"movne r1, #0;"
#if defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
"mov, r0, #0;"
// -- Check EXC_RETURN.S (bit[6])
"tst lr, #0x40;"
"beq _done_sec_cntx;"
// -- Check EXC_RETURN.ES (bit[0])
"tst lr, #0x01;"
"bne _done_sec_cntx;"
// -- Check EXC_RETURN.DCRS (bit[5])
"tst lr, #0x20;"
"bne _done_sec_cntx;"
"mov, r0, #1;"
"push {r4-r11};"
"add r3, #2*4;"
"ldm r3!, {r4-r11};"
"_done_sec_cntx:;"
"push {r0};"
#endif
// Make room for r0-r15,psr,primask
"sub sp, #18*4;"
".cfi_def_cfa_offset 18*4;"
// Save r4-r11
"add r0, sp, #4*4;"
"stm r0, {r4-r11};"
".cfi_offset r4, -14*4;"
".cfi_offset r5, -13*4;"
".cfi_offset r6, -12*4;"
".cfi_offset r7, -11*4;"
".cfi_offset r8, -10*4;"
".cfi_offset r9, -9*4;"
".cfi_offset r10, -8*4;"
".cfi_offset r11, -7*4;"
// Save r0-r3
"ldm r3, {r4-r7};"
"stm sp, {r4-r7};"
".cfi_offset r0, -18*4;"
".cfi_offset r1, -17*4;"
".cfi_offset r2, -16*4;"
".cfi_offset r3, -15*4;"
// Save r12
"ldr r0, [r3, #4*4];"
"str r0, [sp, #12*4];"
".cfi_offset r12, -6*4;"
// Save sp
"teq r1, 0;"
"itt eq;"
"addeq r0, r3, #8*4;"
"beq _done_stack_frame;"
"add r0, r3, #(8+18)*4;"
#if defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
// -- Check EXC_RETURN.S (bit[6])
"tst lr, #0x40;"
"beq _done_stack_frame;"
// -- Check FPCCR_S.TS (bit[26])
"ldr r4, =0xE000EF34;"
"ldr r4, [r4];"
"tst r4, #(1 << 26);"
"it ne;"
"addne r3, #16*4;"
#endif
"_done_stack_frame:;"
// -- Check RETPSR.SPREALIGN (bit[9])
"ldr r4, [r3, #7*4];"
"tst r4, #(1 << 9);"
"it ne;"
"addne r0, #4;"
"str r0, [sp, #13*4];"
// Save lr
"ldr r0, [r3, #5*4];"
"str r0, [sp, #14*4];"
// Save pc
"ldr r0, [r3, #6*4];"
"str r0, [sp, #15*4];"
// Save PSR
"ldr r0, [r3, #7*4];"
"str r0, [sp, #16*4];"
// Save primask
"mrs r0, primask;"
"str r0, [sp, #17*4];"
// Save current exception lr
"mov r4, lr;"
".cfi_register lr, r4;"
// Invoke the fault handler
"mov r0, sp;"
"ldr r2, =hal_trace_fault_dump;"
"blx r2;"
// Restore current exception lr
"mov lr, r4;"
// Restore r4-r7
"add r0, sp, #4*4;"
"ldm r0, {r4-r7};"
"mov r0, r3;"
// Restore sp
"add sp, #18*4;"
#if defined(__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
"pop {r0};"
"cmp r0, #1;"
"it eq;"
"popeq {r4-r11};"
#endif
"bx lr;"
"");
}
#endif
#endif
#define HAL_TRACE_RX_HEAD_SIZE 4
#define HAL_TRACE_RX_NAME_SIZE 20
#define HAL_TRACE_RX_BUF_SIZE 1024
#define HAL_TRACE_RX_ROLE_NUM 6
#define HAL_TRACE_RX_HEAD '['
#define HAL_TRACE_RX_END ']'
#define HAL_TRACE_RX_SEPARATOR ','
// static struct HAL_DMA_CH_CFG_T dma_cfg_rx;
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
static struct HAL_DMA_DESC_T dma_desc_rx;
#endif
typedef struct {
char *name;
uint32_t len;
uint8_t *buf;
} HAL_TRACE_RX_CFG_T;
typedef struct {
char name[HAL_TRACE_RX_NAME_SIZE];
HAL_TRACE_RX_CALLBACK_T callback;
} HAL_TRACE_RX_LIST_T;
typedef struct {
uint32_t list_num;
HAL_TRACE_RX_LIST_T list[HAL_TRACE_RX_ROLE_NUM];
uint32_t rx_enable;
uint32_t pos;
uint8_t buf[HAL_TRACE_RX_BUF_SIZE];
} HAL_TRACE_RX_T;
#if defined(_AUTO_TEST_)
extern int auto_test_prase(uint8_t *cmd);
#endif
HAL_TRACE_RX_T hal_trace_rx;
int hal_trace_rx_dump_list(void) {
for (int i = 0; i < HAL_TRACE_RX_ROLE_NUM; i++) {
TRACE(2, "%d: %s", i, hal_trace_rx.list[i].name);
}
return 0;
}
int hal_trace_rx_is_in_list(const char *name) {
for (int i = 0; i < HAL_TRACE_RX_ROLE_NUM; i++) {
if (!strcmp(hal_trace_rx.list[i].name, name)) {
return i;
}
}
hal_trace_rx_dump_list();
// TRACE(1,"%s", hal_trace_rx.list[0].name);
// TRACE(1,"%s", name);
// TRACE(1,"%d", strlen(hal_trace_rx.list[0].name));
// TRACE(1,"%d", strlen(name));
// TRACE(1,"%d", strcmp(hal_trace_rx.list[0].name, name));
return -1;
}
int hal_trace_rx_add_item_to_list(const char *name,
HAL_TRACE_RX_CALLBACK_T callback) {
for (int i = 0; i < HAL_TRACE_RX_ROLE_NUM; i++) {
if (hal_trace_rx.list[i].name[0] == 0) {
memcpy(hal_trace_rx.list[i].name, name, strlen(name));
hal_trace_rx.list[i].callback = callback;
hal_trace_rx.list_num++;
return 0;
}
}
return 1;
}
int hal_trace_rx_del_item_to_list(int id) {
memset(hal_trace_rx.list[id].name, 0, sizeof(hal_trace_rx.list[id].name));
hal_trace_rx.list[id].callback = NULL;
hal_trace_rx.list_num--;
return 0;
}
int hal_trace_rx_register(const char *name, HAL_TRACE_RX_CALLBACK_T callback) {
TRACE(2, "[%s] Add %s", __func__, name);
if (hal_trace_rx_is_in_list(name) == -1) {
hal_trace_rx_add_item_to_list(name, callback);
return 0;
} else {
return 0;
}
}
int hal_trace_rx_deregister(const char *name) {
int id = 0;
id = hal_trace_rx_is_in_list(name);
if (id != -1) {
hal_trace_rx_del_item_to_list(id);
return 0;
} else {
return 1;
}
}
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
static int hal_trace_rx_reset(void) {
hal_trace_rx.pos = 0;
memset(hal_trace_rx.buf, 0, HAL_TRACE_RX_BUF_SIZE);
return 0;
}
#endif
// [test,12,102.99]
static int hal_trace_rx_parse(int8_t *buf, HAL_TRACE_RX_CFG_T *cfg) {
// TRACE(1,"[%s] Start...", __func__);
int pos = 0;
int len = 0;
for (; pos < HAL_TRACE_RX_HEAD_SIZE; pos++) {
if (buf[pos] == HAL_TRACE_RX_HEAD) {
buf[pos] = 0;
break;
}
}
if (pos == HAL_TRACE_RX_HEAD_SIZE) {
return 3;
}
pos++;
cfg->name = (char *)(buf + pos);
for (; pos < HAL_TRACE_RX_NAME_SIZE + HAL_TRACE_RX_HEAD_SIZE; pos++) {
if (buf[pos] == HAL_TRACE_RX_SEPARATOR) {
buf[pos] = 0;
break;
}
}
// TRACE(1,"Step1: %s", cfg->name);
// TRACE(1,"%d", strlen(cfg->name));
if (pos == HAL_TRACE_RX_NAME_SIZE) {
return 1;
}
pos++;
len = 0;
cfg->buf = (uint8_t *)(buf + pos);
for (; pos < HAL_TRACE_RX_BUF_SIZE; pos++) {
if (buf[pos] == HAL_TRACE_RX_END) {
buf[pos] = 0;
break;
}
len++;
}
cfg->len = len;
if (pos == HAL_TRACE_RX_BUF_SIZE) {
return 2;
}
return 0;
}
#if defined(IBRT)
void app_ibrt_peripheral_automate_test(const char *ibrt_cmd, uint32_t cmd_len);
void app_ibrt_peripheral_perform_test(const char *ibrt_cmd);
#endif
int hal_trace_rx_process(uint8_t *buf, uint32_t len) {
HAL_TRACE_RX_CFG_T cfg;
int id = 0;
int res = 0;
#if defined(IBRT)
if (buf && strlen((char *)buf) >= 10 &&
((strncmp((char *)buf, "auto_test:", 10) == 0) ||
(strncmp((char *)buf, "ibrt_test:", 10) == 0))) {
#ifdef BES_AUTOMATE_TEST
app_ibrt_peripheral_automate_test((char *)(buf + 10), len - 10);
#else
app_ibrt_peripheral_perform_test((char *)(buf + 10));
#endif
return 0;
}
#endif
res = hal_trace_rx_parse((int8_t *)buf, &cfg);
if (res) {
TRACE(1, "ERROR: hal_trace_rx_parse %d", res);
return 1;
} else {
// TRACE(1,"%s rx OK", cfg.name);
}
id = hal_trace_rx_is_in_list(cfg.name);
if (id == -1) {
TRACE(1, "%s is invalid", cfg.name);
return -1;
}
if (hal_trace_rx.list[id].callback) {
hal_trace_rx.list[id].callback(cfg.buf, cfg.len);
} else {
TRACE(1, "%s has not callback", hal_trace_rx.list[id].name);
}
return 0;
}
#if (defined(DEBUG) || defined(REL_TRACE_ENABLE))
void hal_trace_rx_start(void) {
uint32_t desc_cnt = 1;
union HAL_UART_IRQ_T mask;
mask.reg = 0;
mask.BE = 0;
mask.FE = 0;
mask.OE = 0;
mask.PE = 0;
mask.RT = 1;
hal_uart_dma_recv_mask(trace_uart, hal_trace_rx.buf, HAL_TRACE_RX_BUF_SIZE,
&dma_desc_rx, &desc_cnt, &mask);
}
void hal_trace_rx_irq_handler(uint32_t xfer_size, int dma_error,
union HAL_UART_IRQ_T status) {
int res;
// TRACE(4,"[%s] %d, %d, %d", __func__, xfer_size, dma_error, status);
if (xfer_size) {
hal_trace_rx.buf[xfer_size] = 0;
#if defined(_AUTO_TEST_)
res = auto_test_prase(hal_trace_rx.buf);
if (res) {
TRACE(2, "%s:auto_test_prase prase data error, err_code = %d", __func__,
res);
}
#else
// TRACE(2,"[%s] RX = %s", __func__, hal_trace_rx.buf);
res = hal_trace_rx_process(hal_trace_rx.buf, xfer_size);
if (res) {
TRACE(2, "%s:hal_trace_rx_process prase data error, err_code = %d",
__func__, res);
}
#endif
hal_trace_rx_reset();
hal_trace_rx_start();
}
}
uint32_t app_test_callback(unsigned char *buf, uint32_t len) {
TRACE(2, "[%s] len = %d", __func__, len);
// Process string
int num_int = 0;
int num_float = 0.0;
TRACE(2, "[%s] %s", __func__, buf);
hal_trace_rx_parser((char *)buf, "%d,%d", &num_int, &num_float);
TRACE(3, "[%s] %d:%d", __func__, num_int, num_float);
return 0;
}
int hal_trace_rx_open() {
hal_uart_irq_set_dma_handler(trace_uart, hal_trace_rx_irq_handler, NULL);
hal_trace_rx_start();
hal_trace_rx_register("test", (HAL_TRACE_RX_CALLBACK_T)app_test_callback);
return 0;
}
int hal_trace_rx_reopen() {
hal_uart_reopen(trace_uart, &uart_rx_enable_cfg);
hal_trace_rx_open();
return 0;
}
#endif
Reference in a new issue View git blame Copy permalink