From a0ef187d10cf98c668f011e86ca754f7393d013b Mon Sep 17 00:00:00 2001 From: Erhan Kurubas Date: Sun, 19 May 2024 12:08:30 +0200 Subject: [PATCH] refactor(apptrace): format apptrace component with astyle --- .../app_trace/app_trace_membufs_proto.c | 32 ++-- components/app_trace/app_trace_util.c | 2 +- components/app_trace/gcov/gcov_rtio.c | 4 +- components/app_trace/heap_trace_tohost.c | 2 +- components/app_trace/host_file_io.c | 22 +-- components/app_trace/include/esp_app_trace.h | 36 ++-- .../app_trace/include/esp_app_trace_util.h | 10 +- components/app_trace/port/port_uart.c | 42 +++-- components/app_trace/port/riscv/port.c | 15 +- components/app_trace/port/xtensa/port.c | 24 ++- .../app_trace/sys_view/esp/SEGGER_RTT_esp.c | 161 +++++++++--------- .../sys_view/ext/heap_trace_module.c | 13 +- tools/ci/astyle-rules.yml | 1 - 13 files changed, 178 insertions(+), 186 deletions(-) diff --git a/components/app_trace/app_trace_membufs_proto.c b/components/app_trace/app_trace_membufs_proto.c index 548ebdacd2..9b96ff6da8 100644 --- a/components/app_trace/app_trace_membufs_proto.c +++ b/components/app_trace/app_trace_membufs_proto.c @@ -52,7 +52,6 @@ const static char *TAG = "esp_apptrace"; static uint32_t esp_apptrace_membufs_down_buffer_write_nolock(esp_apptrace_membufs_proto_data_t *proto, uint8_t *data, uint32_t size); - esp_err_t esp_apptrace_membufs_init(esp_apptrace_membufs_proto_data_t *proto, const esp_apptrace_mem_block_t blocks_cfg[2]) { // disabled by default @@ -66,7 +65,7 @@ esp_err_t esp_apptrace_membufs_init(esp_apptrace_membufs_proto_data_t *proto, co proto->state.in_block = 0; #if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 esp_apptrace_rb_init(&proto->rb_pend, proto->pending_data, - sizeof(proto->pending_data)); + sizeof(proto->pending_data)); #endif return ESP_OK; } @@ -101,13 +100,13 @@ static esp_err_t esp_apptrace_membufs_swap(esp_apptrace_membufs_proto_data_t *pr // TODO: add support for multiple blocks from host, currently there is no need for that uint8_t *p = proto->blocks[new_block_num].start + proto->blocks[new_block_num].sz; ESP_APPTRACE_LOGD("Recvd %" PRIu16 " bytes from host (@ %p) [%x %x %x %x %x %x %x %x .. %x %x %x %x %x %x %x %x]", - hdr->block_sz, proto->blocks[new_block_num].start, - *(proto->blocks[new_block_num].start+0), *(proto->blocks[new_block_num].start+1), - *(proto->blocks[new_block_num].start+2), *(proto->blocks[new_block_num].start+3), - *(proto->blocks[new_block_num].start+4), *(proto->blocks[new_block_num].start+5), - *(proto->blocks[new_block_num].start+6), *(proto->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_membufs_down_buffer_write_nolock(proto, (uint8_t *)(hdr+1), hdr->block_sz); + hdr->block_sz, proto->blocks[new_block_num].start, + *(proto->blocks[new_block_num].start + 0), *(proto->blocks[new_block_num].start + 1), + *(proto->blocks[new_block_num].start + 2), *(proto->blocks[new_block_num].start + 3), + *(proto->blocks[new_block_num].start + 4), *(proto->blocks[new_block_num].start + 5), + *(proto->blocks[new_block_num].start + 6), *(proto->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_membufs_down_buffer_write_nolock(proto, (uint8_t *)(hdr + 1), hdr->block_sz); if (sz != hdr->block_sz) { ESP_APPTRACE_LOGE("Failed to write %" PRIu32 " bytes to down buffer (%" PRIu16 " %" PRIu32 ")!", hdr->block_sz - sz, hdr->block_sz, sz); } @@ -129,8 +128,8 @@ static esp_err_t esp_apptrace_membufs_swap(esp_apptrace_membufs_proto_data_t *pr break; } 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)); + 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(proto->blocks[new_block_num].start + proto->state.markers[new_block_num], ptr, read_sz); proto->state.markers[new_block_num] += read_sz; } @@ -209,7 +208,7 @@ static uint32_t esp_apptrace_membufs_down_buffer_write_nolock(esp_apptrace_membu while (total_sz < size) { ESP_APPTRACE_LOGD("esp_apptrace_trax_down_buffer_write_nolock WRS %" PRIu32 "-%" PRIu32 "-%" PRIu32 " %" PRIu32, proto->rb_down.wr, proto->rb_down.rd, - proto->rb_down.cur_size, size); + proto->rb_down.cur_size, size); uint32_t wr_sz = esp_apptrace_rb_write_size_get(&proto->rb_down); if (wr_sz == 0) { break; @@ -319,10 +318,10 @@ uint8_t *esp_apptrace_membufs_up_buffer_get(esp_apptrace_membufs_proto_data_t *p if (1) { #endif if (ESP_APPTRACE_INBLOCK_MARKER(proto) + ESP_APPTRACE_USR_BLOCK_RAW_SZ(size) > ESP_APPTRACE_INBLOCK(proto)->sz) { - #if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 +#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0 ESP_APPTRACE_LOGD("Block full. Get %" PRIu32 " bytes from PEND buffer", size); buf_ptr = esp_apptrace_rb_produce(&proto->rb_pend, ESP_APPTRACE_USR_BLOCK_RAW_SZ(size)); - #endif +#endif if (buf_ptr == NULL) { int pended_buf; ESP_APPTRACE_LOGD(" full. Get %" PRIu32 " bytes from pend buffer", size); @@ -372,10 +371,11 @@ esp_err_t esp_apptrace_membufs_flush_nolock(esp_apptrace_membufs_proto_data_t *p ESP_APPTRACE_LOGD("Try to flush %" PRIu32 " bytes", ESP_APPTRACE_INBLOCK_MARKER(proto)); res = esp_apptrace_membufs_swap_waitus(proto, tmo); if (res != ESP_OK) { - if (res == ESP_ERR_TIMEOUT) + if (res == ESP_ERR_TIMEOUT) { ESP_APPTRACE_LOGW("Failed to switch to another block in %" PRIi32 " us!", (int32_t)tmo->elapsed); - else + } else { ESP_APPTRACE_LOGE("Failed to switch to another block, res: %d", res); + } return res; } } diff --git a/components/app_trace/app_trace_util.c b/components/app_trace/app_trace_util.c index 44299b381e..c6cc141566 100644 --- a/components/app_trace/app_trace_util.c +++ b/components/app_trace/app_trace_util.c @@ -44,7 +44,7 @@ void esp_apptrace_log_unlock(void) esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo) { - if (tmo->tmo != (int64_t)-1) { + if (tmo->tmo != (int64_t) -1) { tmo->elapsed = esp_timer_get_time() - tmo->start; if (tmo->elapsed >= tmo->tmo) { return ESP_ERR_TIMEOUT; diff --git a/components/app_trace/gcov/gcov_rtio.c b/components/app_trace/gcov/gcov_rtio.c index fe1468040c..ef79d33df5 100644 --- a/components/app_trace/gcov/gcov_rtio.c +++ b/components/app_trace/gcov/gcov_rtio.c @@ -73,7 +73,7 @@ void gcov_create_task(void *arg) { ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__); xTaskCreatePinnedToCore(&gcov_dump_task, "gcov_dump_task", CONFIG_APPTRACE_GCOV_DUMP_TASK_STACK_SIZE, - (void *)&s_gcov_task_running, configMAX_PRIORITIES - 1, NULL, 0); + (void *)&s_gcov_task_running, configMAX_PRIORITIES - 1, NULL, 0); } static IRAM_ATTR @@ -180,7 +180,7 @@ int gcov_rtio_feof(void *stream) return ret; } -void gcov_rtio_setbuf(void *arg1 __attribute__ ((unused)), void *arg2 __attribute__ ((unused))) +void gcov_rtio_setbuf(void *arg1 __attribute__((unused)), void *arg2 __attribute__((unused))) { return; } diff --git a/components/app_trace/heap_trace_tohost.c b/components/app_trace/heap_trace_tohost.c index 3175932a71..9292268529 100644 --- a/components/app_trace/heap_trace_tohost.c +++ b/components/app_trace/heap_trace_tohost.c @@ -33,7 +33,7 @@ esp_err_t heap_trace_init_tohost(void) esp_err_t heap_trace_start(heap_trace_mode_t mode_param) { #if CONFIG_APPTRACE_SV_ENABLE - esp_err_t ret = esp_sysview_heap_trace_start((uint32_t)-1); + esp_err_t ret = esp_sysview_heap_trace_start((uint32_t) -1); if (ret != ESP_OK) { return ret; } diff --git a/components/app_trace/host_file_io.c b/components/app_trace/host_file_io.c index 72f840c34b..020000db1e 100644 --- a/components/app_trace/host_file_io.c +++ b/components/app_trace/host_file_io.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2017-2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -152,7 +152,7 @@ void *esp_apptrace_fopen(esp_apptrace_dest_t dest, const char *path, const char cmd_args.mode_len = strlen(mode) + 1; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FOPEN, esp_apptrace_fopen_args_prepare, - &cmd_args, cmd_args.path_len+cmd_args.mode_len); + &cmd_args, cmd_args.path_len + cmd_args.mode_len); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return NULL; @@ -182,7 +182,7 @@ int esp_apptrace_fclose(esp_apptrace_dest_t dest, void *stream) cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FCLOSE, esp_apptrace_fclose_args_prepare, - &cmd_args, sizeof(cmd_args)); + &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return EOF; @@ -211,7 +211,7 @@ size_t esp_apptrace_fwrite(esp_apptrace_dest_t dest, const void *ptr, size_t siz { esp_apptrace_fwrite_args_t cmd_args; - ESP_EARLY_LOGV(TAG, "esp_apptrace_fwrite f %p l %d", stream, size*nmemb); + ESP_EARLY_LOGV(TAG, "esp_apptrace_fwrite f %p l %d", stream, size * nmemb); if (ptr == NULL) { return 0; @@ -221,7 +221,7 @@ size_t esp_apptrace_fwrite(esp_apptrace_dest_t dest, const void *ptr, size_t siz cmd_args.size = size * nmemb; cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FWRITE, esp_apptrace_fwrite_args_prepare, - &cmd_args, sizeof(cmd_args.file)+cmd_args.size); + &cmd_args, sizeof(cmd_args.file) + cmd_args.size); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return 0; @@ -253,7 +253,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size { esp_apptrace_fread_args_t cmd_args; - ESP_EARLY_LOGV(TAG, "esp_apptrace_fread f %p l %d", stream, size*nmemb); + ESP_EARLY_LOGV(TAG, "esp_apptrace_fread f %p l %d", stream, size * nmemb); if (ptr == NULL) { return 0; @@ -262,7 +262,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size cmd_args.size = size * nmemb; cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FREAD, esp_apptrace_fread_args_prepare, - &cmd_args, sizeof(cmd_args)); + &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return 0; @@ -288,7 +288,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size * fread(buf, 1 ,size, file); * So, total read bytes count returns */ - return resp/size; // return the number of items read + return resp / size; // return the number of items read } static void esp_apptrace_fseek_args_prepare(uint8_t *buf, void *priv) @@ -310,7 +310,7 @@ int esp_apptrace_fseek(esp_apptrace_dest_t dest, void *stream, long offset, int cmd_args.offset = offset; cmd_args.whence = whence; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FSEEK, esp_apptrace_fseek_args_prepare, - &cmd_args, sizeof(cmd_args)); + &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return -1; @@ -340,7 +340,7 @@ int esp_apptrace_ftell(esp_apptrace_dest_t dest, void *stream) cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FTELL, esp_apptrace_ftell_args_prepare, - &cmd_args, sizeof(cmd_args)); + &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return -1; @@ -380,7 +380,7 @@ int esp_apptrace_feof(esp_apptrace_dest_t dest, void *stream) cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FEOF, esp_apptrace_feof_args_prepare, - &cmd_args, sizeof(cmd_args)); + &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return EOF; diff --git a/components/app_trace/include/esp_app_trace.h b/components/app_trace/include/esp_app_trace.h index d581b0eb89..2726b88800 100644 --- a/components/app_trace/include/esp_app_trace.h +++ b/components/app_trace/include/esp_app_trace.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2017-2023 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -19,9 +19,9 @@ extern "C" { */ typedef enum { ESP_APPTRACE_DEST_JTAG = 1, ///< JTAG destination - ESP_APPTRACE_DEST_TRAX = ESP_APPTRACE_DEST_JTAG, ///< xxx_TRAX name is obsolete, use more common xxx_JTAG - ESP_APPTRACE_DEST_UART, ///< UART destination - ESP_APPTRACE_DEST_MAX = ESP_APPTRACE_DEST_UART+1, + ESP_APPTRACE_DEST_TRAX = ESP_APPTRACE_DEST_JTAG, ///< xxx_TRAX name is obsolete, use more common xxx_JTAG + ESP_APPTRACE_DEST_UART, ///< UART destination + ESP_APPTRACE_DEST_MAX = ESP_APPTRACE_DEST_UART + 1, ESP_APPTRACE_DEST_NUM } esp_apptrace_dest_t; @@ -171,7 +171,7 @@ bool esp_apptrace_host_is_connected(esp_apptrace_dest_t dest); /** * @brief Opens file on host. - * This function has the same semantic as 'fopen' except for the first argument. + * This function has the same semantic as 'fopen' except for the first argument. * * @param dest Indicates HW interface to use. * @param path Path to file. @@ -183,7 +183,7 @@ void *esp_apptrace_fopen(esp_apptrace_dest_t dest, const char *path, const char /** * @brief Closes file on host. - * This function has the same semantic as 'fclose' except for the first argument. + * This function has the same semantic as 'fclose' except for the first argument. * * @param dest Indicates HW interface to use. * @param stream File handle returned by esp_apptrace_fopen. @@ -194,11 +194,11 @@ int esp_apptrace_fclose(esp_apptrace_dest_t dest, void *stream); /** * @brief Writes to file on host. - * This function has the same semantic as 'fwrite' except for the first argument. + * This function has the same semantic as 'fwrite' except for the first argument. * * @param dest Indicates HW interface to use. - * @param ptr Address of data to write. - * @param size Size of an item. + * @param ptr Address of data to write. + * @param size Size of an item. * @param nmemb Number of items to write. * @param stream File handle returned by esp_apptrace_fopen. * @@ -208,11 +208,11 @@ size_t esp_apptrace_fwrite(esp_apptrace_dest_t dest, const void *ptr, size_t siz /** * @brief Read file on host. - * This function has the same semantic as 'fread' except for the first argument. + * This function has the same semantic as 'fread' except for the first argument. * * @param dest Indicates HW interface to use. - * @param ptr Address to store read data. - * @param size Size of an item. + * @param ptr Address to store read data. + * @param size Size of an item. * @param nmemb Number of items to read. * @param stream File handle returned by esp_apptrace_fopen. * @@ -222,7 +222,7 @@ size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size /** * @brief Set position indicator in file on host. - * This function has the same semantic as 'fseek' except for the first argument. + * This function has the same semantic as 'fseek' except for the first argument. * * @param dest Indicates HW interface to use. * @param stream File handle returned by esp_apptrace_fopen. @@ -235,7 +235,7 @@ int esp_apptrace_fseek(esp_apptrace_dest_t dest, void *stream, long offset, int /** * @brief Get current position indicator for file on host. - * This function has the same semantic as 'ftell' except for the first argument. + * This function has the same semantic as 'ftell' except for the first argument. * * @param dest Indicates HW interface to use. * @param stream File handle returned by esp_apptrace_fopen. @@ -246,8 +246,8 @@ int esp_apptrace_ftell(esp_apptrace_dest_t dest, void *stream); /** * @brief Indicates to the host that all file operations are complete. - * This function should be called after all file operations are finished and - * indicate to the host that it can perform cleanup operations (close open files etc.). + * This function should be called after all file operations are finished and + * indicate to the host that it can perform cleanup operations (close open files etc.). * * @param dest Indicates HW interface to use. * @@ -257,7 +257,7 @@ int esp_apptrace_fstop(esp_apptrace_dest_t dest); /** * @brief Test end-of-file indicator on a stream. - * This function has the same semantic as 'feof' except for the first argument. + * This function has the same semantic as 'feof' except for the first argument. * * @param dest Indicates HW interface to use. * @param stream File handle returned by esp_apptrace_fopen. @@ -268,7 +268,7 @@ int esp_apptrace_feof(esp_apptrace_dest_t dest, void *stream); /** * @brief Triggers gcov info dump. - * This function waits for the host to connect to target before dumping data. + * This function waits for the host to connect to target before dumping data. */ void esp_gcov_dump(void); diff --git a/components/app_trace/include/esp_app_trace_util.h b/components/app_trace/include/esp_app_trace_util.h index da2ee57668..264ae655bd 100644 --- a/components/app_trace/include/esp_app_trace_util.h +++ b/components/app_trace/include/esp_app_trace_util.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2017-2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -32,12 +32,12 @@ typedef struct { * @brief Initializes timeout structure. * * @param tmo Pointer to timeout structure to be initialized. - * @param user_tmo Timeout value (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly. + * @param user_tmo Timeout value (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely. */ static inline void esp_apptrace_tmo_init(esp_apptrace_tmo_t *tmo, uint32_t user_tmo) { tmo->start = esp_timer_get_time(); - tmo->tmo = user_tmo == ESP_APPTRACE_TMO_INFINITE ? (int64_t)-1 : (int64_t)user_tmo; + tmo->tmo = user_tmo == ESP_APPTRACE_TMO_INFINITE ? (int64_t) -1 : (int64_t)user_tmo; tmo->elapsed = 0; } @@ -52,7 +52,7 @@ esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo); static inline uint32_t esp_apptrace_tmo_remaining_us(esp_apptrace_tmo_t *tmo) { - return tmo->tmo != (int64_t)-1 ? (tmo->elapsed - tmo->tmo) : ESP_APPTRACE_TMO_INFINITE; + return tmo->tmo != (int64_t) -1 ? (tmo->elapsed - tmo->tmo) : ESP_APPTRACE_TMO_INFINITE; } /** Tracing module synchronization lock */ @@ -94,7 +94,7 @@ esp_err_t esp_apptrace_lock_give(esp_apptrace_lock_t *lock); /** Ring buffer control structure. * * @note For purposes of application tracing module if there is no enough space for user data and write pointer can be wrapped - * current ring buffer size can be temporarily shrinked in order to provide buffer with requested size. + * current ring buffer size can be temporarily shrunk in order to provide buffer with requested size. */ typedef struct { uint8_t *data; ///< pointer to data storage diff --git a/components/app_trace/port/port_uart.c b/components/app_trace/port/port_uart.c index c4146d09d3..3fbc08b3b5 100644 --- a/components/app_trace/port/port_uart.c +++ b/components/app_trace/port/port_uart.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2017-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -14,7 +14,6 @@ #include "string.h" #include "driver/gpio.h" - #define APPTRACE_DEST_UART (CONFIG_APPTRACE_DEST_UART0 | CONFIG_APPTRACE_DEST_UART1 | CONFIG_APPTRACE_DEST_UART2) #define APP_TRACE_MAX_TX_BUFF_UART CONFIG_APPTRACE_UART_TX_BUFF_SIZE @@ -59,7 +58,7 @@ const static char *TAG = "esp_apptrace_uart"; esp_apptrace_hw_t *esp_apptrace_uart_hw_get(int num, void **data) { - ESP_LOGD(TAG,"esp_apptrace_uart_hw_get - %i", num); + ESP_LOGD(TAG, "esp_apptrace_uart_hw_get - %i", num); #if APPTRACE_DEST_UART static esp_apptrace_uart_data_t s_uart_hw_data = { }; @@ -69,7 +68,7 @@ esp_apptrace_hw_t *esp_apptrace_uart_hw_get(int num, void **data) .put_up_buffer = (esp_err_t (*)(void *, uint8_t *, esp_apptrace_tmo_t *))esp_apptrace_uart_up_buffer_put, .flush_up_buffer_nolock = (esp_err_t (*)(void *, uint32_t, esp_apptrace_tmo_t *))esp_apptrace_uart_flush_nolock, .flush_up_buffer = (esp_err_t (*)(void *, esp_apptrace_tmo_t *))esp_apptrace_uart_flush, - .down_buffer_config = (void (*)(void *, uint8_t *, uint32_t ))esp_apptrace_uart_down_buffer_config, + .down_buffer_config = (void (*)(void *, uint8_t *, uint32_t))esp_apptrace_uart_down_buffer_config, .get_down_buffer = (uint8_t *(*)(void *, uint32_t *, esp_apptrace_tmo_t *))esp_apptrace_uart_down_buffer_get, .put_down_buffer = (esp_err_t (*)(void *, uint8_t *, esp_apptrace_tmo_t *))esp_apptrace_uart_down_buffer_put, .host_is_connected = (bool (*)(void *))esp_apptrace_uart_host_is_connected, @@ -109,7 +108,6 @@ static inline void esp_apptrace_uart_hw_init(void) ESP_APPTRACE_LOGI("Initialized UART on CPU%d", esp_cpu_get_core_id()); } - /*****************************************************************************************/ /***************************** Apptrace HW iface *****************************************/ /*****************************************************************************************/ @@ -128,9 +126,8 @@ static esp_err_t esp_apptrace_send_uart_data(esp_apptrace_uart_data_t *hw_data, len_free = out_position - hw_data->tx_data_buff_in; } int check_len = APP_TRACE_MAX_TX_BUFF_UART - hw_data->tx_data_buff_in; - if (size <= len_free) - { - if ( check_len >= size) { + if (size <= len_free) { + if (check_len >= size) { memcpy(&hw_data->tx_data_buff[hw_data->tx_data_buff_in], data, size); hw_data->tx_data_buff_in += size; } else { @@ -183,13 +180,11 @@ static void esp_apptrace_send_uart_tx_task(void *arg) while (1) { send_buff_data(hw_data, &tmo); vTaskDelay(10); - if (hw_data->circular_buff_overflow == true) - { + if (hw_data->circular_buff_overflow == true) { hw_data->circular_buff_overflow = false; ESP_LOGE(TAG, "Buffer overflow. Please increase UART baudrate, or increase UART TX ring buffer size in menuconfig."); } - if (hw_data->message_buff_overflow == true) - { + if (hw_data->message_buff_overflow == true) { hw_data->message_buff_overflow = false; ESP_LOGE(TAG, "Message size more then message buffer!"); } @@ -202,15 +197,14 @@ static esp_err_t esp_apptrace_uart_init(esp_apptrace_uart_data_t *hw_data) { int core_id = esp_cpu_get_core_id(); if (core_id == 0) { - hw_data->tx_data_buff = (uint8_t *)heap_caps_malloc(APP_TRACE_MAX_TX_BUFF_UART, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); - if (hw_data->tx_data_buff == NULL){ + hw_data->tx_data_buff = (uint8_t *)heap_caps_malloc(APP_TRACE_MAX_TX_BUFF_UART, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT); + if (hw_data->tx_data_buff == NULL) { return ESP_ERR_NO_MEM; } hw_data->tx_data_buff_in = 0; hw_data->tx_data_buff_out = 0; - hw_data->tx_msg_buff = (uint8_t *)heap_caps_malloc(APP_TRACE_MAX_TX_MSG_UART, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); - if (hw_data->tx_msg_buff == NULL) - { + hw_data->tx_msg_buff = (uint8_t *)heap_caps_malloc(APP_TRACE_MAX_TX_MSG_UART, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT); + if (hw_data->tx_msg_buff == NULL) { return ESP_ERR_NO_MEM; } hw_data->tx_msg_buff_size = 0; @@ -222,8 +216,9 @@ static esp_err_t esp_apptrace_uart_init(esp_apptrace_uart_data_t *hw_data) int source_clk = UART_SCLK_DEFAULT; #if SOC_UART_LP_NUM > 0 - if (hw_data->port_num >= SOC_UART_HP_NUM) + if (hw_data->port_num >= SOC_UART_HP_NUM) { source_clk = LP_UART_SCLK_DEFAULT; + } #endif const uart_config_t uart_config = { @@ -244,7 +239,9 @@ static esp_err_t esp_apptrace_uart_init(esp_apptrace_uart_data_t *hw_data) assert((err == ESP_OK) && "Not possible to configure UART RX/TX pins. Please check and change menuconfig parameters!"); int uart_prio = CONFIG_APPTRACE_UART_TASK_PRIO; - if (uart_prio >= (configMAX_PRIORITIES-1)) uart_prio = configMAX_PRIORITIES - 1; + if (uart_prio >= (configMAX_PRIORITIES - 1)) { + uart_prio = configMAX_PRIORITIES - 1; + } err = xTaskCreate(esp_apptrace_send_uart_tx_task, "app_trace_uart_tx_task", 2500, hw_data, uart_prio, NULL); assert((err == pdPASS) && "Not possible to configure UART. Not possible to create task!"); @@ -266,8 +263,7 @@ static uint8_t *esp_apptrace_uart_up_buffer_get(esp_apptrace_uart_data_t *hw_dat hw_data->message_buff_overflow = true; return NULL; } - if (hw_data->tx_msg_buff_size != 0) - { + if (hw_data->tx_msg_buff_size != 0) { // A previous message was not sent. return NULL; } @@ -296,7 +292,7 @@ static esp_err_t esp_apptrace_uart_up_buffer_put(esp_apptrace_uart_data_t *hw_da static void esp_apptrace_uart_down_buffer_config(esp_apptrace_uart_data_t *hw_data, uint8_t *buf, uint32_t size) { hw_data->down_buffer = (uint8_t *)malloc(size); - if (hw_data->down_buffer == NULL){ + if (hw_data->down_buffer == NULL) { assert(false && "Failed to allocate apptrace uart down buffer!"); } hw_data->down_buffer_size = size; @@ -323,7 +319,7 @@ static uint8_t *esp_apptrace_uart_down_buffer_get(esp_apptrace_uart_data_t *hw_d } *size = uart_fifolen; ptr = hw_data->down_buffer; - *size =uart_read_bytes(hw_data->port_num, ptr, uart_fifolen, 0); + *size = uart_read_bytes(hw_data->port_num, ptr, uart_fifolen, 0); } if (esp_apptrace_uart_unlock(hw_data) != ESP_OK) { diff --git a/components/app_trace/port/riscv/port.c b/components/app_trace/port/riscv/port.c index 8b014e0dd1..512705714b 100644 --- a/components/app_trace/port/riscv/port.c +++ b/components/app_trace/port/riscv/port.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 OR MIT */ @@ -54,7 +54,6 @@ static esp_err_t esp_apptrace_riscv_buffer_swap(uint32_t new_block_id, uint32_t static esp_err_t esp_apptrace_riscv_buffer_swap_end(uint32_t new_block_id, uint32_t prev_block_len); static bool esp_apptrace_riscv_host_data_pending(void); - const static char *TAG = "esp_apptrace"; #if SOC_CACHE_INTERNAL_MEM_VIA_L1CACHE @@ -85,7 +84,7 @@ esp_apptrace_hw_t *esp_apptrace_jtag_hw_get(void **data) .put_up_buffer = (esp_err_t (*)(void *, uint8_t *, esp_apptrace_tmo_t *))esp_apptrace_riscv_up_buffer_put, .flush_up_buffer_nolock = (esp_err_t (*)(void *, uint32_t, esp_apptrace_tmo_t *))esp_apptrace_riscv_flush_nolock, .flush_up_buffer = (esp_err_t (*)(void *, esp_apptrace_tmo_t *))esp_apptrace_riscv_flush, - .down_buffer_config = (void (*)(void *, uint8_t *, uint32_t ))esp_apptrace_riscv_down_buffer_config, + .down_buffer_config = (void (*)(void *, uint8_t *, uint32_t))esp_apptrace_riscv_down_buffer_config, .get_down_buffer = (uint8_t *(*)(void *, uint32_t *, esp_apptrace_tmo_t *))esp_apptrace_riscv_down_buffer_get, .put_down_buffer = (esp_err_t (*)(void *, uint8_t *, esp_apptrace_tmo_t *))esp_apptrace_riscv_down_buffer_put, .host_is_connected = (bool (*)(void *))esp_apptrace_riscv_host_is_connected, @@ -166,8 +165,8 @@ static esp_err_t esp_apptrace_riscv_init(esp_apptrace_riscv_data_t *hw_data) s_tracing_ctrl[core_id].mem_blocks = hw_data->membufs.blocks; for (int i = 0; i < 2; i++) { ESP_APPTRACE_LOGD("Mem buf[%d] %" PRIu32 " bytes @ %p (%p/%p)", i, - s_tracing_ctrl[core_id].mem_blocks[i].sz, s_tracing_ctrl[core_id].mem_blocks[i].start, - &(s_tracing_ctrl[core_id].mem_blocks[i].start), &(s_tracing_ctrl[core_id].mem_blocks[i].sz)); + s_tracing_ctrl[core_id].mem_blocks[i].sz, s_tracing_ctrl[core_id].mem_blocks[i].start, + &(s_tracing_ctrl[core_id].mem_blocks[i].start), &(s_tracing_ctrl[core_id].mem_blocks[i].sz)); } // notify host about control block address int res = esp_apptrace_advertise_ctrl_block(&s_tracing_ctrl[core_id]); @@ -314,7 +313,7 @@ static __attribute__((noinline)) void esp_apptrace_riscv_buffer_swap_unlock(void s_tracing_ctrl[esp_cpu_get_core_id()].stat = 0; // TODO: currently host sets breakpoint, use break instruction to stop; // it will allow to use ESP_APPTRACE_RISCV_STAT_REG for other purposes - asm volatile ( + asm volatile( " .global __esp_apptrace_riscv_updated\n" "__esp_apptrace_riscv_updated:\n"); // host will set bp here to resolve collision at streaming start } @@ -332,7 +331,7 @@ static esp_err_t esp_apptrace_riscv_buffer_swap_start(uint32_t curr_block_id) uint32_t host_to_read = ESP_APPTRACE_RISCV_BLOCK_LEN_GET(ctrl_reg); if (host_to_read != 0 || acked_block != (curr_block_id & ESP_APPTRACE_RISCV_BLOCK_ID_MSK)) { ESP_APPTRACE_LOGD("[%d]: Can not switch %" PRIx32 " %" PRIu32 " %" PRIx32 " %" PRIx32 "/%" PRIx32, esp_cpu_get_core_id(), ctrl_reg, host_to_read, acked_block, - curr_block_id & ESP_APPTRACE_RISCV_BLOCK_ID_MSK, curr_block_id); + curr_block_id & ESP_APPTRACE_RISCV_BLOCK_ID_MSK, curr_block_id); res = ESP_ERR_NO_MEM; goto _on_err; } @@ -348,7 +347,7 @@ static esp_err_t esp_apptrace_riscv_buffer_swap_end(uint32_t new_block_id, uint3 uint32_t ctrl_reg = s_tracing_ctrl[esp_cpu_get_core_id()].ctrl; uint32_t host_connected = ESP_APPTRACE_RISCV_HOST_CONNECT & ctrl_reg; s_tracing_ctrl[esp_cpu_get_core_id()].ctrl = ESP_APPTRACE_RISCV_BLOCK_ID(new_block_id) | - host_connected | ESP_APPTRACE_RISCV_BLOCK_LEN(prev_block_len); + host_connected | ESP_APPTRACE_RISCV_BLOCK_LEN(prev_block_len); esp_apptrace_riscv_buffer_swap_unlock(); return ESP_OK; } diff --git a/components/app_trace/port/xtensa/port.c b/components/app_trace/port/xtensa/port.c index c86584cb31..edc4e66b23 100644 --- a/components/app_trace/port/xtensa/port.c +++ b/components/app_trace/port/xtensa/port.c @@ -197,7 +197,6 @@ typedef struct { esp_apptrace_membufs_proto_data_t membufs; } esp_apptrace_trax_data_t; - static esp_err_t esp_apptrace_trax_init(esp_apptrace_trax_data_t *hw_data); static esp_err_t esp_apptrace_trax_flush(esp_apptrace_trax_data_t *hw_data, esp_apptrace_tmo_t *tmo); static esp_err_t esp_apptrace_trax_flush_nolock(esp_apptrace_trax_data_t *hw_data, uint32_t min_sz, esp_apptrace_tmo_t *tmo); @@ -212,7 +211,6 @@ static esp_err_t esp_apptrace_trax_buffer_swap(uint32_t new_block_id, uint32_t p static esp_err_t esp_apptrace_trax_buffer_swap_end(uint32_t new_block_id, uint32_t prev_block_len); static bool esp_apptrace_trax_host_data_pending(void); - const static char *TAG = "esp_apptrace"; static uint8_t * const s_trax_blocks[] = { @@ -240,7 +238,7 @@ esp_apptrace_hw_t *esp_apptrace_jtag_hw_get(void **data) .put_up_buffer = (esp_err_t (*)(void *, uint8_t *, esp_apptrace_tmo_t *))esp_apptrace_trax_up_buffer_put, .flush_up_buffer_nolock = (esp_err_t (*)(void *, uint32_t, esp_apptrace_tmo_t *))esp_apptrace_trax_flush_nolock, .flush_up_buffer = (esp_err_t (*)(void *, esp_apptrace_tmo_t *))esp_apptrace_trax_flush, - .down_buffer_config = (void (*)(void *, uint8_t *, uint32_t ))esp_apptrace_trax_down_buffer_config, + .down_buffer_config = (void (*)(void *, uint8_t *, uint32_t))esp_apptrace_trax_down_buffer_config, .get_down_buffer = (uint8_t *(*)(void *, uint32_t *, esp_apptrace_tmo_t *))esp_apptrace_trax_down_buffer_get, .put_down_buffer = (esp_err_t (*)(void *, uint8_t *, esp_apptrace_tmo_t *))esp_apptrace_trax_down_buffer_put, .host_is_connected = (bool (*)(void *))esp_apptrace_trax_host_is_connected, @@ -291,13 +289,13 @@ static inline void esp_apptrace_trax_select_memory_block(int block_num) #if CONFIG_IDF_TARGET_ESP32 DPORT_WRITE_PERI_REG(DPORT_TRACEMEM_MUX_MODE_REG, block_num ? TRACEMEM_MUX_BLK0_ONLY : TRACEMEM_MUX_BLK1_ONLY); #elif CONFIG_IDF_TARGET_ESP32S2 - WRITE_PERI_REG(DPORT_PMS_OCCUPY_3_REG, block_num ? BIT(TRACEMEM_MUX_BLK0_NUM-4) : BIT(TRACEMEM_MUX_BLK1_NUM-4)); + WRITE_PERI_REG(DPORT_PMS_OCCUPY_3_REG, block_num ? BIT(TRACEMEM_MUX_BLK0_NUM - 4) : BIT(TRACEMEM_MUX_BLK1_NUM - 4)); #elif CONFIG_IDF_TARGET_ESP32S3 // select memory block to be exposed to the TRAX module (accessed by host) uint32_t block_bits = block_num ? TRACEMEM_CORE0_MUX_BLK_BITS(TRACEMEM_MUX_BLK0_NUM) - : TRACEMEM_CORE0_MUX_BLK_BITS(TRACEMEM_MUX_BLK1_NUM); + : TRACEMEM_CORE0_MUX_BLK_BITS(TRACEMEM_MUX_BLK1_NUM); block_bits |= block_num ? TRACEMEM_CORE1_MUX_BLK_BITS(TRACEMEM_MUX_BLK0_NUM) - : TRACEMEM_CORE1_MUX_BLK_BITS(TRACEMEM_MUX_BLK1_NUM); + : TRACEMEM_CORE1_MUX_BLK_BITS(TRACEMEM_MUX_BLK1_NUM); ESP_EARLY_LOGV(TAG, "Select block %d @ %p (bits 0x%" PRIx32 ")", block_num, s_trax_blocks[block_num], block_bits); DPORT_WRITE_PERI_REG(SENSITIVE_INTERNAL_SRAM_USAGE_2_REG, block_bits); #endif @@ -306,11 +304,11 @@ static inline void esp_apptrace_trax_select_memory_block(int block_num) static inline void esp_apptrace_trax_memory_enable(void) { #if CONFIG_IDF_TARGET_ESP32 - /* Enable trace memory on PRO CPU */ - DPORT_WRITE_PERI_REG(DPORT_PRO_TRACEMEM_ENA_REG, DPORT_PRO_TRACEMEM_ENA_M); + /* Enable trace memory on PRO CPU */ + DPORT_WRITE_PERI_REG(DPORT_PRO_TRACEMEM_ENA_REG, DPORT_PRO_TRACEMEM_ENA_M); #if CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE == 0 - /* Enable trace memory on APP CPU */ - DPORT_WRITE_PERI_REG(DPORT_APP_TRACEMEM_ENA_REG, DPORT_APP_TRACEMEM_ENA_M); + /* Enable trace memory on APP CPU */ + DPORT_WRITE_PERI_REG(DPORT_APP_TRACEMEM_ENA_REG, DPORT_APP_TRACEMEM_ENA_M); #endif #endif } @@ -491,7 +489,7 @@ static __attribute__((noinline)) void esp_apptrace_trax_buffer_swap_unlock(void) eri_write(ESP_APPTRACE_TRAX_STAT_REG, 0x0); // TODO: currently host sets breakpoint, use break instruction to stop; // it will allow to use ESP_APPTRACE_TRAX_STAT_REG for other purposes - asm volatile ( + 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 } @@ -509,8 +507,8 @@ static esp_err_t esp_apptrace_trax_buffer_swap_start(uint32_t curr_block_id) uint32_t host_to_read = ESP_APPTRACE_TRAX_BLOCK_LEN_GET(ctrl_reg); if (host_to_read != 0 || acked_block != (curr_block_id & ESP_APPTRACE_TRAX_BLOCK_ID_MSK)) { ESP_APPTRACE_LOGD("HC[%d]: Can not switch %" PRIx32 " %" PRIu32 " %" PRIx32 " %" PRIx32 "/%" PRIx32, - esp_cpu_get_core_id(), ctrl_reg, host_to_read, acked_block, - curr_block_id & ESP_APPTRACE_TRAX_BLOCK_ID_MSK, curr_block_id); + esp_cpu_get_core_id(), ctrl_reg, host_to_read, acked_block, + curr_block_id & ESP_APPTRACE_TRAX_BLOCK_ID_MSK, curr_block_id); res = ESP_ERR_NO_MEM; goto _on_err; } diff --git a/components/app_trace/sys_view/esp/SEGGER_RTT_esp.c b/components/app_trace/sys_view/esp/SEGGER_RTT_esp.c index 493cde5e0e..db9941f1a8 100644 --- a/components/app_trace/sys_view/esp/SEGGER_RTT_esp.c +++ b/components/app_trace/sys_view/esp/SEGGER_RTT_esp.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2017-2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -61,7 +61,7 @@ static uint8_t s_down_buf[SYSVIEW_DOWN_BUF_SIZE]; * * Parameters * min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only. -* tmo Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly. +* tmo Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely. * * Return value * None. @@ -70,15 +70,15 @@ void SEGGER_RTT_ESP_FlushNoLock(unsigned long min_sz, unsigned long tmo) { esp_err_t res; if (s_events_buf_filled > 0) { - res = esp_apptrace_write(ESP_APPTRACE_DEST_SYSVIEW, s_events_buf, s_events_buf_filled, tmo); - if (res != ESP_OK) { - ESP_LOGE(TAG, "Failed to flush buffered events (%d)!", res); - } + res = esp_apptrace_write(ESP_APPTRACE_DEST_SYSVIEW, s_events_buf, s_events_buf_filled, tmo); + if (res != ESP_OK) { + ESP_LOGE(TAG, "Failed to flush buffered events (%d)!", res); + } } // flush even if we failed to write buffered events, because no new events will be sent after STOP res = esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_SYSVIEW, min_sz, tmo); if (res != ESP_OK) { - ESP_LOGE(TAG, "Failed to flush apptrace data (%d)!", res); + ESP_LOGE(TAG, "Failed to flush apptrace data (%d)!", res); } s_events_buf_filled = 0; } @@ -92,7 +92,7 @@ void SEGGER_RTT_ESP_FlushNoLock(unsigned long min_sz, unsigned long tmo) * * Parameters * min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only. -* tmo Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinetly. +* tmo Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely. * * Return value * None. @@ -121,13 +121,14 @@ void SEGGER_RTT_ESP_Flush(unsigned long min_sz, unsigned long tmo) * Return value * Number of bytes that have been read. */ -unsigned SEGGER_RTT_ReadNoLock(unsigned BufferIndex, void* pData, unsigned BufferSize) { - uint32_t size = BufferSize; - esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_SYSVIEW, pData, &size, 0); - if (res != ESP_OK) { - return 0; - } - return size; +unsigned SEGGER_RTT_ReadNoLock(unsigned BufferIndex, void* pData, unsigned BufferSize) +{ + uint32_t size = BufferSize; + esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_SYSVIEW, pData, &size, 0); + if (res != ESP_OK) { + return 0; + } + return size; } /********************************************************************* @@ -154,80 +155,79 @@ unsigned SEGGER_RTT_ReadNoLock(unsigned BufferIndex, void* pData, unsigned Buffe * and may only be called after RTT has been initialized. * Either by calling SEGGER_RTT_Init() or calling another RTT API function first. */ -unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) { - uint8_t *pbuf = (uint8_t *)pBuffer; - uint8_t event_id = *pbuf; +unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes) +{ + uint8_t *pbuf = (uint8_t *)pBuffer; + uint8_t event_id = *pbuf; #if CONFIG_APPTRACE_SV_DEST_UART - if ( - (APPTRACE_SV_DEST_CPU != esp_cpu_get_core_id()) && - ( - (event_id == SYSVIEW_EVTID_ISR_ENTER) || - (event_id == SYSVIEW_EVTID_ISR_EXIT) || - (event_id == SYSVIEW_EVTID_TASK_START_EXEC) || - (event_id == SYSVIEW_EVTID_TASK_STOP_EXEC) || - (event_id == SYSVIEW_EVTID_TASK_START_READY) || - (event_id == SYSVIEW_EVTID_TASK_STOP_READY) || - (event_id == SYSVIEW_EVTID_MARK_START) || - (event_id == SYSVIEW_EVTID_MARK_STOP) || - (event_id == SYSVIEW_EVTID_TIMER_ENTER) || - (event_id == SYSVIEW_EVTID_TIMER_EXIT) || - (event_id == SYSVIEW_EVTID_STACK_INFO) || - (event_id == SYSVIEW_EVTID_MODULEDESC) - ) - ){ - return NumBytes; - } + if ( + (APPTRACE_SV_DEST_CPU != esp_cpu_get_core_id()) && + ( + (event_id == SYSVIEW_EVTID_ISR_ENTER) || + (event_id == SYSVIEW_EVTID_ISR_EXIT) || + (event_id == SYSVIEW_EVTID_TASK_START_EXEC) || + (event_id == SYSVIEW_EVTID_TASK_STOP_EXEC) || + (event_id == SYSVIEW_EVTID_TASK_START_READY) || + (event_id == SYSVIEW_EVTID_TASK_STOP_READY) || + (event_id == SYSVIEW_EVTID_MARK_START) || + (event_id == SYSVIEW_EVTID_MARK_STOP) || + (event_id == SYSVIEW_EVTID_TIMER_ENTER) || + (event_id == SYSVIEW_EVTID_TIMER_EXIT) || + (event_id == SYSVIEW_EVTID_STACK_INFO) || + (event_id == SYSVIEW_EVTID_MODULEDESC) + ) + ) { + return NumBytes; + } // This is workaround for SystemView! // Without this line SystemView will hangs on when heap tracing enabled. - if(event_id == SYSVIEW_EVTID_MODULEDESC){ - return NumBytes; - } + if (event_id == SYSVIEW_EVTID_MODULEDESC) { + return NumBytes; + } #endif // CONFIG_APPTRACE_SV_DEST_UART - if (NumBytes > SYSVIEW_EVENTS_BUF_SZ) { - ESP_LOGE(TAG, "Too large event %u bytes!", NumBytes); - return 0; - } -#if CONFIG_APPTRACE_SV_DEST_JTAG - if (esp_cpu_get_core_id()) { // dual core specific code - // use the highest - 1 bit of event ID to indicate core ID - // the highest bit can not be used due to event ID encoding method - // this reduces supported ID range to [0..63] (for 1 byte IDs) plus [128..16383] (for 2 bytes IDs) - if (*pbuf & 0x80) { // 2 bytes ID - *(pbuf + 1) |= (1 << 6); - } else if (NumBytes != 10 || *pbuf != 0) { // ignore sync sequence - *pbuf |= (1 << 6); + if (NumBytes > SYSVIEW_EVENTS_BUF_SZ) { + ESP_LOGE(TAG, "Too large event %u bytes!", NumBytes); + return 0; + } +#if CONFIG_APPTRACE_SV_DEST_JTAG + if (esp_cpu_get_core_id()) { // dual core specific code + // use the highest - 1 bit of event ID to indicate core ID + // the highest bit can not be used due to event ID encoding method + // this reduces supported ID range to [0..63] (for 1 byte IDs) plus [128..16383] (for 2 bytes IDs) + if (*pbuf & 0x80) { // 2 bytes ID + *(pbuf + 1) |= (1 << 6); + } else if (NumBytes != 10 || *pbuf != 0) { // ignore sync sequence + *pbuf |= (1 << 6); + } } - } #endif // CONFIG_APPTRACE_SV_DEST_JTAG #if CONFIG_APPTRACE_SV_DEST_JTAG - if (s_events_buf_filled + NumBytes > SYSVIEW_EVENTS_BUF_SZ) { + if (s_events_buf_filled + NumBytes > SYSVIEW_EVENTS_BUF_SZ) { - esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_SYSVIEW, s_events_buf, s_events_buf_filled, SEGGER_HOST_WAIT_TMO); - if (res != ESP_OK) { - return 0; // skip current data buffer only, accumulated events are kept + esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_SYSVIEW, s_events_buf, s_events_buf_filled, SEGGER_HOST_WAIT_TMO); + if (res != ESP_OK) { + return 0; // skip current data buffer only, accumulated events are kept + } + s_events_buf_filled = 0; } - s_events_buf_filled = 0; - } #endif - memcpy(&s_events_buf[s_events_buf_filled], pBuffer, NumBytes); - s_events_buf_filled += NumBytes; + memcpy(&s_events_buf[s_events_buf_filled], pBuffer, NumBytes); + s_events_buf_filled += NumBytes; #if CONFIG_APPTRACE_SV_DEST_UART - esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_SYSVIEW, pBuffer, NumBytes, SEGGER_HOST_WAIT_TMO); - if (res != ESP_OK) - { - return 0; // skip current data buffer only, accumulated events are kept - } - s_events_buf_filled = 0; + esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_SYSVIEW, pBuffer, NumBytes, SEGGER_HOST_WAIT_TMO); + if (res != ESP_OK) { + return 0; // skip current data buffer only, accumulated events are kept + } + s_events_buf_filled = 0; #endif - if (event_id == SYSVIEW_EVTID_TRACE_STOP) - { - SEGGER_RTT_ESP_FlushNoLock(0, SEGGER_STOP_WAIT_TMO); - } - return NumBytes; + if (event_id == SYSVIEW_EVTID_TRACE_STOP) { + SEGGER_RTT_ESP_FlushNoLock(0, SEGGER_STOP_WAIT_TMO); + } + return NumBytes; } /********************************************************************* @@ -255,9 +255,10 @@ unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pBuffer, u * May only be called once per buffer. * Buffer name and flags can be reconfigured using the appropriate functions. */ -int SEGGER_RTT_ConfigUpBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { - s_events_buf_filled = 0; - return 0; +int SEGGER_RTT_ConfigUpBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) +{ + s_events_buf_filled = 0; + return 0; } /********************************************************************* @@ -285,9 +286,10 @@ int SEGGER_RTT_ConfigUpBuffer(unsigned BufferIndex, const char* sName, void* pBu * May only be called once per buffer. * Buffer name and flags can be reconfigured using the appropriate functions. */ -int SEGGER_RTT_ConfigDownBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) { - esp_apptrace_down_buffer_config(s_down_buf, sizeof(s_down_buf)); - return 0; +int SEGGER_RTT_ConfigDownBuffer(unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags) +{ + esp_apptrace_down_buffer_config(s_down_buf, sizeof(s_down_buf)); + return 0; } /*************************** Init hook **************************** @@ -302,5 +304,4 @@ ESP_SYSTEM_INIT_FN(sysview_init, SECONDARY, BIT(0), 120) return ESP_OK; } - /*************************** End of file ****************************/ diff --git a/components/app_trace/sys_view/ext/heap_trace_module.c b/components/app_trace/sys_view/ext/heap_trace_module.c index 2919162bf5..cbe81723d8 100644 --- a/components/app_trace/sys_view/ext/heap_trace_module.c +++ b/components/app_trace/sys_view/ext/heap_trace_module.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2018-2021 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2018-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ @@ -27,14 +27,13 @@ static SEGGER_SYSVIEW_MODULE s_esp_sysview_heap_module = { static bool s_mod_registered; - esp_err_t esp_sysview_heap_trace_start(uint32_t tmo) { - uint32_t tmo_ticks = tmo/(1000*portTICK_PERIOD_MS); + uint32_t tmo_ticks = tmo / (1000 * portTICK_PERIOD_MS); ESP_EARLY_LOGV(TAG, "%s", __func__); do { - if (tmo != (uint32_t)-1) { + if (tmo != (uint32_t) -1) { // Currently timeout implementation is simple and has granularity of 1 OS tick, // so just count down the number of times to call vTaskDelay if (tmo_ticks-- == 0) { @@ -42,7 +41,7 @@ esp_err_t esp_sysview_heap_trace_start(uint32_t tmo) } } vTaskDelay(1); - } while(!SEGGER_SYSVIEW_Started()); + } while (!SEGGER_SYSVIEW_Started()); SEGGER_SYSVIEW_RegisterModule(&s_esp_sysview_heap_module); s_mod_registered = true; @@ -58,7 +57,7 @@ esp_err_t esp_sysview_heap_trace_stop(void) void esp_sysview_heap_trace_alloc(const void *addr, uint32_t size, const void *callers) { - U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + (2+CALLSTACK_SIZE)*SEGGER_SYSVIEW_QUANTA_U32]; + U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + (2 + CALLSTACK_SIZE)*SEGGER_SYSVIEW_QUANTA_U32]; U8* pPayload = SEGGER_SYSVIEW_PREPARE_PACKET(aPacket); U32 *calls = (U32 *)callers; @@ -76,7 +75,7 @@ void esp_sysview_heap_trace_alloc(const void *addr, uint32_t size, const void *c void esp_sysview_heap_trace_free(const void *addr, const void *callers) { - U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + (1+CALLSTACK_SIZE)*SEGGER_SYSVIEW_QUANTA_U32]; + U8 aPacket[SEGGER_SYSVIEW_INFO_SIZE + (1 + CALLSTACK_SIZE)*SEGGER_SYSVIEW_QUANTA_U32]; U8* pPayload = SEGGER_SYSVIEW_PREPARE_PACKET(aPacket); U32 *calls = (U32 *)callers; diff --git a/tools/ci/astyle-rules.yml b/tools/ci/astyle-rules.yml index ad50bb3fb0..de8a111bb2 100644 --- a/tools/ci/astyle-rules.yml +++ b/tools/ci/astyle-rules.yml @@ -43,7 +43,6 @@ components_not_formatted_temporary: # 2. If no, move it to 'components_not_formatted_permanent' section below. check: false include: - - "/components/app_trace/" - "/components/app_update/" - "/components/bootloader_support/" - "/components/bootloader/"