Merge branch 'feature/esp32s2beta_apptrace_port' into 'master'

esp32s2: Adds apptrace support

Closes IDF-510 and IDF-1032

See merge request espressif/esp-idf!5610

components/app_trace/CMakeLists.txt

@@ -23,6 +23,9 @@ endif()
 
 if(CONFIG_HEAP_TRACING_TOHOST)
     list(APPEND srcs "heap_trace_tohost.c")
+    set_source_files_properties(heap_trace_tohost.c
+        PROPERTIES COMPILE_FLAGS
+        -Wno-frame-address)
 endif()
 
 idf_component_register(SRCS "${srcs}"

components/app_trace/Kconfig

@@ -1,54 +1,56 @@
 menu "Application Level Tracing"
 
-    choice ESP32_APPTRACE_DESTINATION
+    choice APPTRACE_DESTINATION
         prompt "Data Destination"
-        default ESP32_APPTRACE_DEST_NONE
+        default APPTRACE_DEST_NONE
         help
             Select destination for application trace: trace memory or none (to disable).
 
-        config ESP32_APPTRACE_DEST_TRAX
+        config APPTRACE_DEST_TRAX
             bool "Trace memory"
-            select ESP32_APPTRACE_ENABLE
-        config ESP32_APPTRACE_DEST_NONE
+            select APPTRACE_ENABLE
+        config APPTRACE_DEST_NONE
             bool "None"
     endchoice
 
-    config ESP32_APPTRACE_ENABLE
+    config APPTRACE_ENABLE
         bool
-        depends on !ESP32_TRAX
+        depends on !ESP32_TRAX && !ESP32S2_TRAX
         select ESP32_MEMMAP_TRACEMEM
+        select ESP32S2_MEMMAP_TRACEMEM
         select ESP32_MEMMAP_TRACEMEM_TWOBANKS
+        select ESP32S2_MEMMAP_TRACEMEM_TWOBANKS
         default n
         help
             Enables/disable application tracing module.
 
-    config ESP32_APPTRACE_LOCK_ENABLE
+    config APPTRACE_LOCK_ENABLE
         bool
         default !SYSVIEW_ENABLE
         help
             Enables/disable application tracing module internal sync lock.
 
-    config ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO
+    config APPTRACE_ONPANIC_HOST_FLUSH_TMO
         int "Timeout for flushing last trace data to host on panic"
-        depends on ESP32_APPTRACE_ENABLE
+        depends on APPTRACE_ENABLE
         range -1 5000
         default -1
         help
             Timeout for flushing last trace data to host in case of panic. In ms.
             Use -1 to disable timeout and wait forever.
 
-    config ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH
+    config APPTRACE_POSTMORTEM_FLUSH_THRESH
         int "Threshold for flushing last trace data to host on panic"
-        depends on ESP32_APPTRACE_DEST_TRAX
+        depends on APPTRACE_DEST_TRAX
         range 0 16384
         default 0
         help
             Threshold for flushing last trace data to host on panic in post-mortem mode.
             This is minimal amount of data needed to perform flush. In bytes.
 
-    config ESP32_APPTRACE_PENDING_DATA_SIZE_MAX
+    config APPTRACE_PENDING_DATA_SIZE_MAX
         int "Size of the pending data buffer"
-        depends on ESP32_APPTRACE_DEST_TRAX
+        depends on APPTRACE_DEST_TRAX
         default 0
         help
             Size of the buffer for events in bytes. It is useful for buffering events from
@@ -56,10 +58,10 @@ menu "Application Level Tracing"
             events will be discarded when main HW buffer is full.
 
     menu "FreeRTOS SystemView Tracing"
-        depends on ESP32_APPTRACE_ENABLE
+        depends on APPTRACE_ENABLE
         config SYSVIEW_ENABLE
             bool "SystemView Tracing Enable"
-            depends on ESP32_APPTRACE_ENABLE
+            depends on APPTRACE_ENABLE
             default n
             help
                 Enables supporrt for SEGGER SystemView tracing functionality.
@@ -208,10 +210,11 @@ menu "Application Level Tracing"
 
     endmenu
 
-    config ESP32_GCOV_ENABLE
+    config APPTRACE_GCOV_ENABLE
         bool "GCOV to Host Enable"
-        depends on ESP32_DEBUG_STUBS_ENABLE && ESP32_APPTRACE_ENABLE && !SYSVIEW_ENABLE
-        default y
+        depends on APPTRACE_ENABLE && !SYSVIEW_ENABLE
+        select ESP_DEBUG_STUBS_ENABLE
+        default n
         help
             Enables support for GCOV data transfer to host.
 

components/app_trace/app_trace.c

@@ -76,11 +76,11 @@
 //    It can happen that system panic occurs when there are very small amount of data which are not exposed to host yet (e.g. crash just after the
 //    TRAX block switch). In this case the previous 16KB of collected data will be dropped and host will see the latest, but very small piece of trace.
 //    It can be insufficient to diagnose the problem. To avoid such situations there is menuconfig option
-//    CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH
+//    CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH
 //    which controls the threshold for flushing data in case of panic.
 //  - Streaming mode. Tracing module enters this mode when host connects to target and sets respective bits in control registers (per core).
 //    In this mode before switching the block tracing module waits for the host to read all the data from the previously exposed block.
-//    On panic tracing module also waits (timeout is configured via menuconfig via CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO) for the host to read all data.
+//    On panic tracing module also waits (timeout is configured via menuconfig via CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO) for the host to read all data.
 
 // 4. Communication Protocol
 // =========================
@@ -114,7 +114,7 @@
 // has not completed reading of the previous one yet. So in this case time critical tracing calls (which can not be delayed for too long time due to
 // the lack of free memory in TRAX block) can be dropped. To avoid such scenarios tracing module implements data buffering. Buffered data will be sent
 // to the host later when TRAX block switch occurs. The maximum size of the buffered data is controlled by menuconfig option
-// CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX.
+// CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX.
 
 // 4.4 Target Connection/Disconnection
 // -----------------------------------
@@ -158,13 +158,16 @@
 #include <sys/param.h>
 #include "soc/soc.h"
 #include "soc/dport_reg.h"
+#if CONFIG_IDF_TARGET_ESP32S2BETA
+#include "soc/sensitive_reg.h"
+#endif
 #include "eri.h"
 #include "trax.h"
 #include "soc/timer_periph.h"
 #include "freertos/FreeRTOS.h"
 #include "esp_app_trace.h"
 
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 #define ESP_APPTRACE_MAX_VPRINTF_ARGS           256
 #define ESP_APPTRACE_HOST_BUF_SIZE              256
 
@@ -202,10 +205,16 @@ const static char *TAG = "esp_apptrace";
 #define ESP_APPTRACE_LOGO( format, ... )  ESP_APPTRACE_LOG_LEV(E, ESP_LOG_NONE, format, ##__VA_ARGS__)
 
 // TODO: move these (and same definitions in trax.c to dport_reg.h)
+#if CONFIG_IDF_TARGET_ESP32
 #define TRACEMEM_MUX_PROBLK0_APPBLK1            0
 #define TRACEMEM_MUX_BLK0_ONLY                  1
 #define TRACEMEM_MUX_BLK1_ONLY                  2
 #define TRACEMEM_MUX_PROBLK1_APPBLK0            3
+#elif CONFIG_IDF_TARGET_ESP32S2BETA
+#define TRACEMEM_MUX_BLK0_NUM                   19
+#define TRACEMEM_MUX_BLK1_NUM                   20
+#define TRACEMEM_BLK_NUM2ADDR(_n_)              (0x3FFB8000UL + 0x4000UL*((_n_)-4))
+#endif
 
 // TRAX is disabled, so we use its registers for our own purposes
 // | 31..XXXXXX..24 | 23 .(host_connect). 23 | 22 .(host_data). 22| 21..(block_id)..15 | 14..(block_len)..0 |
@@ -230,10 +239,17 @@ const static char *TAG = "esp_apptrace";
 #endif
 #define ESP_APPTRACE_USR_BLOCK_RAW_SZ(_s_)     ((_s_) + sizeof(esp_tracedata_hdr_t))
 
+#if CONFIG_IDF_TARGET_ESP32
 static volatile uint8_t *s_trax_blocks[] = {
     (volatile uint8_t *) 0x3FFFC000,
     (volatile uint8_t *) 0x3FFF8000
 };
+#elif CONFIG_IDF_TARGET_ESP32S2BETA
+static volatile uint8_t *s_trax_blocks[] = {
+    (volatile uint8_t *)TRACEMEM_BLK_NUM2ADDR(TRACEMEM_MUX_BLK0_NUM),
+    (volatile uint8_t *)TRACEMEM_BLK_NUM2ADDR(TRACEMEM_MUX_BLK1_NUM)
+};
+#endif
 
 #define ESP_APPTRACE_TRAX_BLOCKS_NUM            (sizeof(s_trax_blocks)/sizeof(s_trax_blocks[0]))
 
@@ -293,17 +309,17 @@ typedef struct {
 typedef struct {
     volatile esp_apptrace_trax_state_t  state;                                  // state
     esp_apptrace_mem_block_t            blocks[ESP_APPTRACE_TRAX_BLOCKS_NUM];   // memory blocks
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
     // ring buffer control struct for pending user blocks
     esp_apptrace_rb_t                   rb_pend;
     // storage for pending user blocks
-    uint8_t                             pending_data[CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX + 1];
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+    uint8_t                             pending_data[CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX + 1];
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
     // ring buffer control struct for pending user data chunks sizes,
     // every chunk contains whole number of user blocks and fit into TRAX memory block
     esp_apptrace_rb_t                   rb_pend_chunk_sz;
     // storage for above ring buffer data
-    uint16_t                            pending_chunk_sz[CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX/ESP_APPTRACE_TRAX_BLOCK_SIZE + 2];
+    uint16_t                            pending_chunk_sz[CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX/ESP_APPTRACE_TRAX_BLOCK_SIZE + 2];
     // current (accumulated) pending user data chunk size
     uint16_t                            cur_pending_chunk_sz;
 #endif
@@ -381,7 +397,7 @@ static inline void esp_apptrace_log_unlock(void)
 
 static inline esp_err_t esp_apptrace_lock_initialize(esp_apptrace_lock_t *lock)
 {
-#if CONFIG_ESP32_APPTRACE_LOCK_ENABLE
+#if CONFIG_APPTRACE_LOCK_ENABLE
     esp_apptrace_lock_init(lock);
 #endif
     return ESP_OK;
@@ -394,7 +410,7 @@ static inline esp_err_t esp_apptrace_lock_cleanup(void)
 
 esp_err_t esp_apptrace_lock(esp_apptrace_tmo_t *tmo)
 {
-#if CONFIG_ESP32_APPTRACE_LOCK_ENABLE
+#if CONFIG_APPTRACE_LOCK_ENABLE
     esp_err_t ret = esp_apptrace_lock_take(&s_trace_buf.lock, tmo);
     if (ret != ESP_OK) {
         return ESP_FAIL;
@@ -406,13 +422,24 @@ esp_err_t esp_apptrace_lock(esp_apptrace_tmo_t *tmo)
 esp_err_t esp_apptrace_unlock(void)
 {
     esp_err_t ret = ESP_OK;
-#if CONFIG_ESP32_APPTRACE_LOCK_ENABLE
+#if CONFIG_APPTRACE_LOCK_ENABLE
     ret = esp_apptrace_lock_give(&s_trace_buf.lock);
 #endif
     return ret;
 }
 
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
+
+static inline void esp_apptrace_trax_select_memory_block(int block_num)
+{
+    // select memory block to be exposed to the TRAX module (accessed by host)
+#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_ESP32S2BETA
+    DPORT_WRITE_PERI_REG(DPORT_PMS_OCCUPY_3_REG, block_num ? BIT(TRACEMEM_MUX_BLK0_NUM-4) : BIT(TRACEMEM_MUX_BLK1_NUM-4));
+#endif
+}
+
 static void esp_apptrace_trax_init(void)
 {
     // Stop trace, if any (on the current CPU)
@@ -426,7 +453,7 @@ static void esp_apptrace_trax_init(void)
     ESP_APPTRACE_LOGI("Initialized TRAX on CPU%d", xPortGetCoreID());
 }
 
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
 // keep the size of buffered data for copying to TRAX mem block.
 // Only whole user blocks should be copied from buffer to TRAX block upon the switch
 static void esp_apptrace_trax_pend_chunk_sz_update(uint16_t size)
@@ -499,7 +526,7 @@ static esp_err_t esp_apptrace_trax_block_switch(void)
     // switch to new block
     s_trace_buf.trax.state.in_block++;
 
-    DPORT_WRITE_PERI_REG(DPORT_TRACEMEM_MUX_MODE_REG, new_block_num ? TRACEMEM_MUX_BLK0_ONLY : TRACEMEM_MUX_BLK1_ONLY);
+    esp_apptrace_trax_select_memory_block(new_block_num);
     // handle data from host
     esp_hostdata_hdr_t *hdr = (esp_hostdata_hdr_t *)s_trace_buf.trax.blocks[new_block_num].start;
     if (ctrl_reg & ESP_APPTRACE_TRAX_HOST_DATA && hdr->block_sz > 0) {
@@ -517,9 +544,9 @@ static esp_err_t esp_apptrace_trax_block_switch(void)
         }
         hdr->block_sz = 0;
     }
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
     // copy pending data to TRAX block if any
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
     uint16_t max_chunk_sz = esp_apptrace_trax_pend_chunk_sz_get();
 #else
     uint16_t max_chunk_sz = s_trace_buf.trax.blocks[new_block_num].sz;
@@ -527,7 +554,7 @@ static esp_err_t esp_apptrace_trax_block_switch(void)
     while (s_trace_buf.trax.state.markers[new_block_num] < max_chunk_sz) {
         uint32_t read_sz = esp_apptrace_rb_read_size_get(&s_trace_buf.trax.rb_pend);
         if (read_sz == 0) {
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
             /* theres is a bug: esp_apptrace_trax_pend_chunk_sz_get returned wrong value,
                it must be greater or equal to one returned by esp_apptrace_rb_read_size_get */
             ESP_APPTRACE_LOGE("No pended bytes, must be > 0 and <= %d!", max_chunk_sz);
@@ -670,7 +697,7 @@ static inline uint8_t *esp_apptrace_trax_wait4buf(uint16_t size, esp_apptrace_tm
         return NULL;
     }
     // check if we still have pending data
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
     if (esp_apptrace_rb_read_size_get(&s_trace_buf.trax.rb_pend) > 0) {
         // if after TRAX block switch still have pending data (not all pending data have been pumped to TRAX block)
         // alloc new pending buffer
@@ -684,7 +711,7 @@ static inline uint8_t *esp_apptrace_trax_wait4buf(uint16_t size, esp_apptrace_tm
     {
         // update block pointers
         if (ESP_APPTRACE_TRAX_INBLOCK_MARKER() + size > ESP_APPTRACE_TRAX_INBLOCK_GET()->sz) {
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
             *pended = 1;
             ptr = esp_apptrace_rb_produce(&s_trace_buf.trax.rb_pend, size);
             if (ptr == NULL) {
@@ -714,7 +741,7 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t *
         return NULL;
     }
     // check for data in the pending buffer
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
     if (esp_apptrace_rb_read_size_get(&s_trace_buf.trax.rb_pend) > 0) {
         // if we have buffered data try to switch TRAX block
         esp_apptrace_trax_block_switch();
@@ -729,7 +756,7 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t *
             buf_ptr = esp_apptrace_trax_wait4buf(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size), tmo, &pended_buf);
             if (buf_ptr) {
                 if (pended_buf) {
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
                     esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size));
 #endif
                 } else {
@@ -739,18 +766,18 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t *
                 }
             }
         } else {
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
             esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size));
 #endif
         }
     } else
 #endif
     if (ESP_APPTRACE_TRAX_INBLOCK_MARKER() + ESP_APPTRACE_USR_BLOCK_RAW_SZ(size) > ESP_APPTRACE_TRAX_INBLOCK_GET()->sz) {
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
         ESP_APPTRACE_LOGD("TRAX full. Get %d bytes from PEND buffer", size);
         buf_ptr = esp_apptrace_rb_produce(&s_trace_buf.trax.rb_pend, ESP_APPTRACE_USR_BLOCK_RAW_SZ(size));
         if (buf_ptr) {
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
             esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size));
 #endif
         }
@@ -761,7 +788,7 @@ static uint8_t *esp_apptrace_trax_get_buffer(uint32_t size, esp_apptrace_tmo_t *
             buf_ptr = esp_apptrace_trax_wait4buf(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size), tmo, &pended_buf);
             if (buf_ptr) {
                 if (pended_buf) {
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
                     esp_apptrace_trax_pend_chunk_sz_update(ESP_APPTRACE_USR_BLOCK_RAW_SZ(size));
 #endif
                 } else {
@@ -853,22 +880,23 @@ static esp_err_t esp_apptrace_trax_dest_init(void)
         s_trace_buf.trax.state.markers[i] = 0;
     }
     s_trace_buf.trax.state.in_block = ESP_APPTRACE_TRAX_INBLOCK_START;
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > 0
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > 0
     esp_apptrace_rb_init(&s_trace_buf.trax.rb_pend, s_trace_buf.trax.pending_data,
                         sizeof(s_trace_buf.trax.pending_data));
-#if CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
+#if CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX > ESP_APPTRACE_TRAX_BLOCK_SIZE
     s_trace_buf.trax.cur_pending_chunk_sz = 0;
     esp_apptrace_rb_init(&s_trace_buf.trax.rb_pend_chunk_sz, (uint8_t *)s_trace_buf.trax.pending_chunk_sz,
                         sizeof(s_trace_buf.trax.pending_chunk_sz));
 #endif
 #endif
 
+#if CONFIG_IDF_TARGET_ESP32
     DPORT_WRITE_PERI_REG(DPORT_PRO_TRACEMEM_ENA_REG, DPORT_PRO_TRACEMEM_ENA_M);
 #if CONFIG_FREERTOS_UNICORE == 0
     DPORT_WRITE_PERI_REG(DPORT_APP_TRACEMEM_ENA_REG, DPORT_APP_TRACEMEM_ENA_M);
 #endif
-    // Expose block 1 to host, block 0 is current trace input buffer
-    DPORT_WRITE_PERI_REG(DPORT_TRACEMEM_MUX_MODE_REG, TRACEMEM_MUX_BLK1_ONLY);
+#endif
+    esp_apptrace_trax_select_memory_block(0);
 
     return ESP_OK;
 }
@@ -887,7 +915,7 @@ esp_err_t esp_apptrace_init(void)
             ESP_APPTRACE_LOGE("Failed to init log lock (%d)!", res);
             return res;
         }
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         res = esp_apptrace_trax_dest_init();
         if (res != ESP_OK) {
             ESP_APPTRACE_LOGE("Failed to init TRAX dest data (%d)!", res);
@@ -897,7 +925,7 @@ esp_err_t esp_apptrace_init(void)
 #endif
     }
 
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
     // init TRAX on this CPU
     esp_apptrace_trax_init();
 #endif
@@ -919,7 +947,7 @@ esp_err_t esp_apptrace_read(esp_apptrace_dest_t dest, void *buf, uint32_t *size,
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -956,7 +984,7 @@ uint8_t *esp_apptrace_down_buffer_get(esp_apptrace_dest_t dest, uint32_t *size,
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -980,7 +1008,7 @@ esp_err_t esp_apptrace_down_buffer_put(esp_apptrace_dest_t dest, uint8_t *ptr, u
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1005,7 +1033,7 @@ esp_err_t esp_apptrace_write(esp_apptrace_dest_t dest, const void *data, uint32_
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1041,7 +1069,7 @@ int esp_apptrace_vprintf_to(esp_apptrace_dest_t dest, uint32_t user_tmo, const c
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1105,7 +1133,7 @@ uint8_t *esp_apptrace_buffer_get(esp_apptrace_dest_t dest, uint32_t size, uint32
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1129,7 +1157,7 @@ esp_err_t esp_apptrace_buffer_put(esp_apptrace_dest_t dest, uint8_t *ptr, uint32
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1153,7 +1181,7 @@ esp_err_t esp_apptrace_flush_nolock(esp_apptrace_dest_t dest, uint32_t min_sz, u
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1197,7 +1225,7 @@ bool esp_apptrace_host_is_connected(esp_apptrace_dest_t dest)
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1215,7 +1243,7 @@ esp_err_t esp_apptrace_status_reg_set(esp_apptrace_dest_t dest, uint32_t val)
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");
@@ -1233,7 +1261,7 @@ esp_err_t esp_apptrace_status_reg_get(esp_apptrace_dest_t dest, uint32_t *val)
     esp_apptrace_hw_t *hw = NULL;
 
     if (dest == ESP_APPTRACE_DEST_TRAX) {
-#if CONFIG_ESP32_APPTRACE_DEST_TRAX
+#if CONFIG_APPTRACE_DEST_TRAX
         hw = ESP_APPTRACE_HW(ESP_APPTRACE_HW_TRAX);
 #else
         ESP_APPTRACE_LOGE("Application tracing via TRAX is disabled in menuconfig!");

components/app_trace/gcov/gcov_rtio.c

@@ -23,7 +23,7 @@
 #include "esp_private/dbg_stubs.h"
 #include "hal/timer_ll.h"
 
-#if CONFIG_ESP32_GCOV_ENABLE
+#if CONFIG_APPTRACE_GCOV_ENABLE
 
 #define ESP_GCOV_DOWN_BUF_SIZE  4200
 

components/app_trace/host_file_io.c

@@ -25,7 +25,7 @@
 #include <string.h>
 #include "esp_app_trace.h"
 
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 
 #define LOG_LOCAL_LEVEL CONFIG_LOG_DEFAULT_LEVEL
 #include "esp_log.h"

components/app_trace/sdkconfig.rename

@@ -1,4 +1,12 @@
 # sdkconfig replacement configurations for deprecated options formatted as
 # CONFIG_DEPRECATED_OPTION CONFIG_NEW_OPTION
 
-CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH      CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH
+CONFIG_ESP32_APPTRACE_DESTINATION      					CONFIG_APPTRACE_DESTINATION
+CONFIG_ESP32_APPTRACE_DEST_NONE							CONFIG_APPTRACE_DEST_NONE
+CONFIG_ESP32_APPTRACE_DEST_TRAX							CONFIG_APPTRACE_DEST_TRAX
+CONFIG_ESP32_APPTRACE_ENABLE							CONFIG_APPTRACE_ENABLE
+CONFIG_ESP32_APPTRACE_LOCK_ENABLE						CONFIG_APPTRACE_LOCK_ENABLE
+CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO			CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO
+CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH      CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH
+CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX				CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX
+CONFIG_ESP32_GCOV_ENABLE								CONFIG_APPTRACE_GCOV_ENABLE

components/app_trace/sys_view/Sample/Config/SEGGER_SYSVIEW_Config_FreeRTOS.c

@@ -63,6 +63,13 @@ Revision: $Rev: 3734 $
 */
 #include "freertos/FreeRTOS.h"
 #include "SEGGER_SYSVIEW.h"
+#if CONFIG_IDF_TARGET_ESP32
+#include "esp32/rom/ets_sys.h"
+#include "esp32/clk.h"
+#elif CONFIG_IDF_TARGET_ESP32S2BETA
+#include "esp32s2beta/rom/ets_sys.h"
+#include "esp32s2beta/clk.h"
+#endif
 #include "esp_app_trace.h"
 #include "esp_app_trace_util.h"
 #include "esp_intr_alloc.h"
@@ -136,7 +143,6 @@ extern const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI;
 #elif CONFIG_IDF_TARGET_ESP32S2BETA
 #define SYSVIEW_TIMESTAMP_FREQ  (CONFIG_ESP32S2_DEFAULT_CPU_FREQ_MHZ * 1000000)
 #endif
-
 #endif // TS_USE_CCOUNT
 
 // System Frequency.

components/app_trace/sys_view/esp32/SEGGER_RTT_esp32.c

@@ -18,7 +18,11 @@
 #include "SEGGER_SYSVIEW.h"
 #include "SEGGER_SYSVIEW_Conf.h"
 
+#if CONFIG_IDF_TARGET_ESP32
 #include "esp32/rom/ets_sys.h"
+#elif CONFIG_IDF_TARGET_ESP32S2BETA
+#include "esp32s2beta/rom/ets_sys.h"
+#endif
 #include "esp_app_trace.h"
 
 #include "esp_log.h"

components/app_trace/test/test_trace.c

@@ -9,7 +9,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 #include "freertos/task.h"
-#if CONFIG_ESP32_APPTRACE_ENABLE == 1
+#if CONFIG_APPTRACE_ENABLE == 1
 #include "esp_app_trace.h"
 #include "esp_app_trace_util.h"
 

components/esp32/Kconfig

@@ -389,14 +389,6 @@ menu "ESP32-specific"
             The FreeRTOS panic and unhandled exception handers can detect a JTAG OCD debugger and
             instead of panicking, have the debugger stop on the offending instruction.
 
-    config ESP32_DEBUG_STUBS_ENABLE
-        bool "OpenOCD debug stubs"
-        default COMPILER_OPTIMIZATION_DEFAULT
-        depends on !ESP32_TRAX
-        help
-            Debug stubs are used by OpenOCD to execute pre-compiled onboard code which does some useful debugging,
-            e.g. GCOV data dump.
-
     config ESP32_BROWNOUT_DET
         bool "Hardware brownout detect & reset"
         default y

components/esp32/cpu_start.c

@@ -372,14 +372,14 @@ void start_cpu0_default(void)
 #endif
     esp_timer_init();
     esp_set_time_from_rtc();
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
     err = esp_apptrace_init();
     assert(err == ESP_OK && "Failed to init apptrace module on PRO CPU!");
 #endif
 #if CONFIG_SYSVIEW_ENABLE
     SEGGER_SYSVIEW_Conf();
 #endif
-#if CONFIG_ESP32_DEBUG_STUBS_ENABLE
+#if CONFIG_ESP_DEBUG_STUBS_ENABLE
     esp_dbg_stubs_init();
 #endif
     err = esp_pthread_init();
@@ -474,7 +474,7 @@ void start_cpu1_default(void)
 #if CONFIG_ESP32_TRAX_TWOBANKS
     trax_start_trace(TRAX_DOWNCOUNT_WORDS);
 #endif
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
     esp_err_t err = esp_apptrace_init();
     assert(err == ESP_OK && "Failed to init apptrace module on APP CPU!");
 #endif

components/esp32/panic.c

@@ -50,10 +50,10 @@
 #include "SEGGER_RTT.h"
 #endif
 
-#if CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1
+#if CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1
 #define APPTRACE_ONPANIC_HOST_FLUSH_TMO   ESP_APPTRACE_TMO_INFINITE
 #else
-#define APPTRACE_ONPANIC_HOST_FLUSH_TMO   (1000*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO)
+#define APPTRACE_ONPANIC_HOST_FLUSH_TMO   (1000*CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO)
 #endif
 /*
   Panic handlers; these get called when an unhandled exception occurs or the assembly-level
@@ -144,11 +144,11 @@ static bool abort_called;
 static __attribute__((noreturn)) inline void invoke_abort(void)
 {
     abort_called = true;
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 #if CONFIG_SYSVIEW_ENABLE
-    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH,
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                               APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
@@ -315,11 +315,11 @@ void panicHandler(XtExcFrame *frame)
             frame->exccause == PANIC_RSN_INTWDT_CPU1) {
             timer_ll_wdt_clear_intr_status(&TIMERG1);
         }
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 #if CONFIG_SYSVIEW_ENABLE
-        SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+        SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH,
+        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                                   APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
@@ -348,11 +348,11 @@ void xt_unhandled_exception(XtExcFrame *frame)
             panicPutStr(" at pc=");
             panicPutHex(frame->pc);
             panicPutStr(". Setting bp and returning..\r\n");
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 #if CONFIG_SYSVIEW_ENABLE
-            SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+            SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-            esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH,
+            esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                                       APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
@@ -597,12 +597,12 @@ static __attribute__((noreturn)) void commonErrorHandler(XtExcFrame *frame)
     }
 #endif //!CONFIG_FREERTOS_UNICORE
 
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
     disableAllWdts();
 #if CONFIG_SYSVIEW_ENABLE
-    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH,
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                               APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
     reconfigureAllWdts();

components/esp32s2beta/Kconfig

@@ -257,7 +257,8 @@ menu "ESP32S2-specific"
 
     config ESP32S2_TRACEMEM_RESERVE_DRAM
         hex
-        default 0x4000 if ESP32S2_MEMMAP_TRACEMEM
+        default 0x8000 if ESP32S2_MEMMAP_TRACEMEM && ESP32S2_MEMMAP_TRACEMEM_TWOBANKS
+        default 0x4000 if ESP32S2_MEMMAP_TRACEMEM && !ESP32S2_MEMMAP_TRACEMEM_TWOBANKS
         default 0x0
 
 

components/esp32s2beta/cpu_start.c

@@ -294,7 +294,7 @@ void start_cpu0_default(void)
 #endif
     esp_timer_init();
     esp_set_time_from_rtc();
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
     err = esp_apptrace_init();
     assert(err == ESP_OK && "Failed to init apptrace module on PRO CPU!");
 #endif

components/esp32s2beta/ld/esp32s2beta.ld

@@ -95,8 +95,11 @@ MEMORY
 
 _static_data_end = _bss_end;
 
-/* Heap ends at top of dram0_0_seg */
-_heap_end = 0x40000000 - CONFIG_ESP32S2_TRACEMEM_RESERVE_DRAM;
+/* Heap ends at top of dram0_0_seg
+   ROM data mappings start from 0x3FFFC000,
+  0x3FFF4000...0x3FFFC000 can be reserved for trace memory mapping
+*/
+_heap_end = 0x3FFFC000 - CONFIG_ESP32S2_TRACEMEM_RESERVE_DRAM;
 
 _data_seg_org = ORIGIN(rtc_data_seg);
 

components/esp32s2beta/panic.c

@@ -48,10 +48,10 @@
 #include "SEGGER_RTT.h"
 #endif
 
-#if CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1
+#if CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO == -1
 #define APPTRACE_ONPANIC_HOST_FLUSH_TMO   ESP_APPTRACE_TMO_INFINITE
 #else
-#define APPTRACE_ONPANIC_HOST_FLUSH_TMO   (1000*CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO)
+#define APPTRACE_ONPANIC_HOST_FLUSH_TMO   (1000*CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO)
 #endif
 /*
   Panic handlers; these get called when an unhandled exception occurs or the assembly-level
@@ -128,11 +128,11 @@ static bool abort_called;
 static __attribute__((noreturn)) inline void invoke_abort(void)
 {
     abort_called = true;
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 #if CONFIG_SYSVIEW_ENABLE
-    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                               APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
@@ -380,11 +380,11 @@ void panicHandler(XtExcFrame *frame)
             frame->exccause == PANIC_RSN_INTWDT_CPU1) {
             TIMERG1.int_clr.wdt = 1;
         }
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 #if CONFIG_SYSVIEW_ENABLE
-        SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+        SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                                   APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
@@ -413,11 +413,11 @@ void xt_unhandled_exception(XtExcFrame *frame)
             panicPutStr(" at pc=");
             panicPutHex(frame->pc);
             panicPutStr(". Setting bp and returning..\r\n");
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
 #if CONFIG_SYSVIEW_ENABLE
-            SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+            SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-            esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+            esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                                       APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
@@ -625,12 +625,12 @@ static __attribute__((noreturn)) void commonErrorHandler(XtExcFrame *frame)
     }
 #endif //!CONFIG_FREERTOS_UNICORE
 
-#if CONFIG_ESP32_APPTRACE_ENABLE
+#if CONFIG_APPTRACE_ENABLE
     disableAllWdts();
 #if CONFIG_SYSVIEW_ENABLE
-    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
+    SEGGER_RTT_ESP32_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_TRAX_THRESH,
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                               APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
     reconfigureAllWdts();

components/esp_common/Kconfig

@@ -40,9 +40,9 @@ menu "Common ESP-related"
 
     config ESP_IPC_TASK_STACK_SIZE
         int "Inter-Processor Call (IPC) task stack size"
-        range 512 65536 if !ESP32_APPTRACE_ENABLE
-        range 2048 65536 if ESP32_APPTRACE_ENABLE
-        default 2048 if ESP32_APPTRACE_ENABLE
+        range 512 65536 if !APPTRACE_ENABLE
+        range 2048 65536 if APPTRACE_ENABLE
+        default 2048 if APPTRACE_ENABLE
         default 1024
         help
             Configure the IPC tasks stack size. One IPC task runs on each core
@@ -223,4 +223,12 @@ menu "Common ESP-related"
             complex issues with crashes while flash cache is disabled (for example, when writing to
             SPI flash.)
 
+    config ESP_DEBUG_STUBS_ENABLE
+        bool
+        default COMPILER_OPTIMIZATION_LEVEL_DEBUG
+        depends on !ESP32_TRAX && !ESP32S2_TRAX
+        help
+            Debug stubs are used by OpenOCD to execute pre-compiled onboard code
+            which does some useful debugging stuff, e.g. GCOV data dump.
+
 endmenu # Common ESP-related

components/esp_common/sdkconfig.rename

@@ -26,3 +26,4 @@ CONFIG_TASK_WDT_PANIC                                   CONFIG_ESP_TASK_WDT_PANI
 CONFIG_TASK_WDT_TIMEOUT_S                               CONFIG_ESP_TASK_WDT_TIMEOUT_S
 CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0                    CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
 CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1                    CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1
+CONFIG_ESP32_DEBUG_STUBS_ENABLE							CONFIG_ESP_DEBUG_STUBS_ENABLE

components/esp_common/src/dbg_stubs.c

@@ -21,7 +21,7 @@
 #include "esp_private/dbg_stubs.h"
 #include "esp_attr.h"
 
-#if CONFIG_ESP32_DEBUG_STUBS_ENABLE || CONFIG_ESP32S2_DEBUG_STUBS_ENABLE
+#if CONFIG_ESP_DEBUG_STUBS_ENABLE
 /*
     Debug stubs is actually a table of 4-byte entries. Every entry is equal to zero or must contain meaningfull data.
     The first entry is a service one and has the followinf format:

components/freertos/include/freertos/FreeRTOSConfig.h

@@ -178,7 +178,7 @@ int xt_clock_freq(void) __attribute__((deprecated));
 #define configMAX_PRIORITIES			( 25 )
 #endif
 
-#ifndef CONFIG_ESP32_APPTRACE_ENABLE
+#ifndef CONFIG_APPTRACE_ENABLE
 #define configMINIMAL_STACK_SIZE		768
 #else
 /* apptrace module requires at least 2KB of stack per task */

components/heap/CMakeLists.txt

@@ -13,6 +13,9 @@ endif()
 
 if(CONFIG_HEAP_TRACING_STANDALONE)
     list(APPEND srcs "heap_trace_standalone.c")
+    set_source_files_properties(heap_trace_standalone.c
+        PROPERTIES COMPILE_FLAGS
+        -Wno-frame-address)
 endif()
 
 idf_component_register(SRCS "${srcs}"

docs/en/api-guides/app_trace.rst

@@ -31,7 +31,7 @@ The library supports two modes of operation:
 
 **Post-mortem mode**. This is the default mode. The mode does not need interaction with the host side. In this mode tracing module does not check whether host has read all the data from *HW UP BUFFER* buffer and overwrites old data with the new ones. This mode is useful when only the latest trace data are interesting to the user, e.g. for analyzing program's behavior just before the crash. Host can read the data later on upon user request, e.g. via special OpenOCD command in case of working via JTAG interface.
 
-**Streaming mode.** Tracing module enters this mode when host connects to ESP32. In this mode before writing new data to *HW UP BUFFER* tracing module checks that there is enough space in it and if necessary waits for the host to read data and free enough memory. Maximum waiting time is controlled via timeout values passed by users to corresponding API routines. So when application tries to write data to trace buffer using finite value of the maximum waiting time it is possible situation that this data will be dropped. Especially this is true for tracing from time critical code (ISRs, OS scheduler code etc.) when infinite timeouts can lead to system malfunction. In order to avoid loss of such critical data developers can enable additional data buffering via menuconfig option :ref:`CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX`. This macro specifies the size of data which can be buffered in above conditions. The option can also help to overcome situation when data transfer to the host is temporarily slowed down, e.g due to USB bus congestions etc. But it will not help when average bitrate of trace data stream exceeds HW interface capabilities.
+**Streaming mode.** Tracing module enters this mode when host connects to ESP32. In this mode before writing new data to *HW UP BUFFER* tracing module checks that there is enough space in it and if necessary waits for the host to read data and free enough memory. Maximum waiting time is controlled via timeout values passed by users to corresponding API routines. So when application tries to write data to trace buffer using finite value of the maximum waiting time it is possible situation that this data will be dropped. Especially this is true for tracing from time critical code (ISRs, OS scheduler code etc.) when infinite timeouts can lead to system malfunction. In order to avoid loss of such critical data developers can enable additional data buffering via menuconfig option :ref:`CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX`. This macro specifies the size of data which can be buffered in above conditions. The option can also help to overcome situation when data transfer to the host is temporarily slowed down, e.g due to USB bus congestions etc. But it will not help when average bitrate of trace data stream exceeds HW interface capabilities.
 
 
 Configuration Options and Dependencies
@@ -40,7 +40,7 @@ Configuration Options and Dependencies
 Using of this feature depends on two components:
 
 1. **Host side:** Application tracing is done over JTAG, so it needs OpenOCD to be set up and running on host machine. For instructions on how to set it up, please see :doc:`JTAG Debugging <../api-guides/jtag-debugging/index>` for details.
-2. **Target side:** Application tracing functionality can be enabled in menuconfig. *Component config > Application Level Tracing* menu allows selecting destination for the trace data (HW interface for transport). Choosing any of the destinations automatically enables ``CONFIG_ESP32_APPTRACE_ENABLE`` option.
+2. **Target side:** Application tracing functionality can be enabled in menuconfig. *Component config > Application Level Tracing* menu allows selecting destination for the trace data (HW interface for transport). Choosing any of the destinations automatically enables ``CONFIG_APPTRACE_ENABLE`` option.
 
 .. note::
 
@@ -48,8 +48,8 @@ Using of this feature depends on two components:
 
 There are two additional menuconfig options not mentioned above:
 
-1.  *Threshold for flushing last trace data to host on panic* (:ref:`CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH`). This option is necessary due to the nature of working over JTAG. In that mode trace data are exposed to the host in 16 KB blocks. In post-mortem mode when one block is filled it is exposed to the host and the previous one becomes unavailable. In other words trace data are overwritten in 16 KB granularity. On panic the latest data from the current input block are exposed to host and host can read them for post-analysis. System panic may occur when very small amount of data are not exposed to the host yet. In this case the previous 16 KB of collected data will be lost and host will see the latest, but very small piece of the trace. It can be insufficient to diagnose the problem. This menuconfig option allows avoiding such situations. It controls the threshold for flushing data in case of panic. For example user can decide that it needs not less then 512 bytes of the recent trace data, so if there is less then 512 bytes of pending data at the moment of panic they will not be flushed and will not overwrite previous 16 KB. The option is only meaningful in post-mortem mode and when working over JTAG.
-2.  *Timeout for flushing last trace data to host on panic* (:ref:`CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO`). The option is only meaningful in streaming mode and controls the maximum time tracing module will wait for the host to read the last data in case of panic.
+1.  *Threshold for flushing last trace data to host on panic* (:ref:`CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH`). This option is necessary due to the nature of working over JTAG. In that mode trace data are exposed to the host in 16 KB blocks. In post-mortem mode when one block is filled it is exposed to the host and the previous one becomes unavailable. In other words trace data are overwritten in 16 KB granularity. On panic the latest data from the current input block are exposed to host and host can read them for post-analysis. System panic may occur when very small amount of data are not exposed to the host yet. In this case the previous 16 KB of collected data will be lost and host will see the latest, but very small piece of the trace. It can be insufficient to diagnose the problem. This menuconfig option allows avoiding such situations. It controls the threshold for flushing data in case of panic. For example user can decide that it needs not less then 512 bytes of the recent trace data, so if there is less then 512 bytes of pending data at the moment of panic they will not be flushed and will not overwrite previous 16 KB. The option is only meaningful in post-mortem mode and when working over JTAG.
+2.  *Timeout for flushing last trace data to host on panic* (:ref:`CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO`). The option is only meaningful in streaming mode and controls the maximum time tracing module will wait for the host to read the last data in case of panic.
 
 
 How to use this library
@@ -487,8 +487,8 @@ Project Configuration
 
 Before building a project with source code coverage, ensure that the following project configuration options are enabled by running ``idf.py menuconfig`` (or ``make menuconfig`` if using the legacy Make build system).
 
-- Enable the application tracing module by choosing *Trace Memory* for the  :ref:`CONFIG_ESP32_APPTRACE_DESTINATION` option.
-- Enable Gcov to host via the :ref:`CONFIG_ESP32_GCOV_ENABLE`
+- Enable the application tracing module by choosing *Trace Memory* for the  :ref:`CONFIG_APPTRACE_DESTINATION` option.
+- Enable Gcov to host via the :ref:`CONFIG_APPTRACE_GCOV_ENABLE`
 
 .. _app_trace-gcov-dumping-data:
 

docs/en/api-reference/system/heap_debug.rst

@@ -218,7 +218,7 @@ Host-Based Mode
 Once you've identified the code which you think is leaking:
 
 - In the project configuration menu, navigate to ``Component settings`` -> ``Heap Memory Debugging`` -> :ref:`CONFIG_HEAP_TRACING_DEST` and select ``Host-Based``.
-- In the project configuration menu, navigate to ``Component settings`` -> ``Application Level Tracing`` -> :ref:`CONFIG_ESP32_APPTRACE_DESTINATION` and select ``Trace memory``.
+- In the project configuration menu, navigate to ``Component settings`` -> ``Application Level Tracing`` -> :ref:`CONFIG_APPTRACE_DESTINATION` and select ``Trace memory``.
 - In the project configuration menu, navigate to ``Component settings`` -> ``Application Level Tracing`` -> ``FreeRTOS SystemView Tracing`` and enable :ref:`CONFIG_SYSVIEW_ENABLE`.
 - Call the function :cpp:func:`heap_trace_init_tohost` early in the program, to initialize JTAG heap tracing module.
 - Call the function :cpp:func:`heap_trace_start` to begin recording all mallocs/frees in the system. Call this immediately before the piece of code which you suspect is leaking memory.

docs/zh_CN/api-guides/app_trace.rst

@@ -30,7 +30,7 @@
 
 **后验模式：** 这是默认的模式，该模式不需要和主机进行交互。在这种模式下，跟踪模块不会检查主机是否已经从 *HW UP BUFFER* 缓冲区读走所有数据，而是直接使用新数据覆盖旧数据。该模式在用户仅对最新的跟踪数据感兴趣时会很有用，例如分析程序在崩溃之前的行为。主机可以稍后根据用户的请求来读取数据，例如通过特殊的 OpenOCD 命令（假如使用了 JTAG 接口）。
 
-**流模式：** 当主机连接到 ESP32 时，跟踪模块会进入此模式。在这种模式下，跟踪模块在新数据写入 *HW UP BUFFER* 之前会检查其中是否有足够的空间，并在必要的时候等待主机读取数据并释放足够的内存。用户会将最长的等待时间作为超时时间参数传递给相应的 API 函数，如果超时时间是个有限值，那么应用程序有可能会因为超时而将待写的数据丢弃。尤其需要注意，如果在讲究时效的代码中（如中断处理函数，操作系统调度等）指定了无限的超时时间，那么系统会产生故障。为了避免丢失此类关键数据，开发人员可以通过在 menuconfig 中开启 :ref:`CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX` 选项来启用额外的数据缓冲区。此宏还指定了在上述条件下可以缓冲的数据大小，它有助于缓解由于 USB 总线拥塞等原因导致的向主机传输数据间歇性减缓的状况。但是，当跟踪数据流的平均比特率超过硬件接口的能力时，它也无能为力。
+**流模式：** 当主机连接到 ESP32 时，跟踪模块会进入此模式。在这种模式下，跟踪模块在新数据写入 *HW UP BUFFER* 之前会检查其中是否有足够的空间，并在必要的时候等待主机读取数据并释放足够的内存。用户会将最长的等待时间作为超时时间参数传递给相应的 API 函数，如果超时时间是个有限值，那么应用程序有可能会因为超时而将待写的数据丢弃。尤其需要注意，如果在讲究时效的代码中（如中断处理函数，操作系统调度等）指定了无限的超时时间，那么系统会产生故障。为了避免丢失此类关键数据，开发人员可以通过在 menuconfig 中开启 :ref:`CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX` 选项来启用额外的数据缓冲区。此宏还指定了在上述条件下可以缓冲的数据大小，它有助于缓解由于 USB 总线拥塞等原因导致的向主机传输数据间歇性减缓的状况。但是，当跟踪数据流的平均比特率超过硬件接口的能力时，它也无能为力。
 
 
 配置选项与依赖项
@@ -40,7 +40,7 @@
 
 1. **主机端：** 应用程序跟踪是通过 JTAG 来完成的，因此需要在主机上安装并运行 OpenOCD。相关详细信息请参阅 :doc:`JTAG Debugging <../api-guides/jtag-debugging/index>`。
 
-2. **目标端：** 在 menuconfig 中开启应用程序跟踪功能。 *Component config > Application Level Tracing* 菜单允许选择跟踪数据的传输目标（具体用于传输的硬件接口），选择任一非 None 的目标都会自动开启 ``CONFIG_ESP32_APPTRACE_ENABLE`` 这个选项。
+2. **目标端：** 在 menuconfig 中开启应用程序跟踪功能。 *Component config > Application Level Tracing* 菜单允许选择跟踪数据的传输目标（具体用于传输的硬件接口），选择任一非 None 的目标都会自动开启 ``CONFIG_APPTRACE_ENABLE`` 这个选项。
 
 .. note::
 
@@ -48,9 +48,9 @@
 
 以下为前述未提及的另外两个 menuconfig 选项：
 
-1. *Threshold for flushing last trace data to host on panic* （:ref:`CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH`）。由于在 JTAG 上工作的性质，此选项是必选项。在该模式下，跟踪数据以 16 KB 数据块的形式曝露给主机。在后验模式中，当一个块被填充时，它会曝露给主机，而之前的块会变得不可用。换句话说，跟踪数据以 16 KB 的粒度进行覆盖。在发生 panic 的时候，当前输入块的最新数据将会被曝露给主机，主机可以读取它们以进行后续分析。如果系统发生 panic 的时候仍有少量数据还没来得及曝光给主机，那么之前收集的 16 KB 的数据将丢失，主机只能看到非常少的最新的跟踪部分，它可能不足以用来诊断问题所在。此 menuconfig 选项允许避免此类情况，它可以控制在发生 panic 时刷新数据的阈值，例如用户可以确定它需要不少于 512 字节的最新跟踪数据，所以如果在发生 panic 时待处理的数据少于 512 字节，它们不会被刷新，也不会覆盖之前的 16 KB。该选项仅在后验模式和 JTAG 工作时有意义。
+1. *Threshold for flushing last trace data to host on panic* （:ref:`CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH`）。由于在 JTAG 上工作的性质，此选项是必选项。在该模式下，跟踪数据以 16 KB 数据块的形式曝露给主机。在后验模式中，当一个块被填充时，它会曝露给主机，而之前的块会变得不可用。换句话说，跟踪数据以 16 KB 的粒度进行覆盖。在发生 panic 的时候，当前输入块的最新数据将会被曝露给主机，主机可以读取它们以进行后续分析。如果系统发生 panic 的时候仍有少量数据还没来得及曝光给主机，那么之前收集的 16 KB 的数据将丢失，主机只能看到非常少的最新的跟踪部分，它可能不足以用来诊断问题所在。此 menuconfig 选项允许避免此类情况，它可以控制在发生 panic 时刷新数据的阈值，例如用户可以确定它需要不少于 512 字节的最新跟踪数据，所以如果在发生 panic 时待处理的数据少于 512 字节，它们不会被刷新，也不会覆盖之前的 16 KB。该选项仅在后验模式和 JTAG 工作时有意义。
 
-2. *Timeout for flushing last trace data to host on panic* （:ref:`CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO`）。该选项仅在流模式下才起作用，它控制跟踪模块在发生 panic 时等待主机读取最新数据的最长时间。
+2. *Timeout for flushing last trace data to host on panic* （:ref:`CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO`）。该选项仅在流模式下才起作用，它控制跟踪模块在发生 panic 时等待主机读取最新数据的最长时间。
 
 
 如何使用这个库

examples/system/app_trace_to_host/sdkconfig.defaults

@@ -1,5 +1,5 @@
 # Enable application tracing by default
-CONFIG_ESP32_APPTRACE_DEST_TRAX=y
-CONFIG_ESP32_APPTRACE_ENABLE=y
+CONFIG_APPTRACE_DEST_TRAX=y
+CONFIG_APPTRACE_ENABLE=y
 # Disable WiFi stack by default
 CONFIG_WIFI_ENABLED=n

examples/system/gcov/sdkconfig.defaults

@@ -1,7 +1,8 @@
-CONFIG_ESP32_APPTRACE_DEST_TRAX=y
-# CONFIG_ESP32_APPTRACE_DEST_NONE is not set
-CONFIG_ESP32_APPTRACE_ENABLE=y
-CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y
-CONFIG_ESP32_APPTRACE_ONPANIC_HOST_FLUSH_TMO=-1
-CONFIG_ESP32_APPTRACE_POSTMORTEM_FLUSH_THRESH=0
-CONFIG_ESP32_APPTRACE_PENDING_DATA_SIZE_MAX=0
+CONFIG_APPTRACE_DEST_TRAX=y
+# CONFIG_APPTRACE_DEST_NONE is not set
+CONFIG_APPTRACE_ENABLE=y
+CONFIG_APPTRACE_LOCK_ENABLE=y
+CONFIG_APPTRACE_ONPANIC_HOST_FLUSH_TMO=-1
+CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH=0
+CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX=0
+CONFIG_APPTRACE_GCOV_ENABLE=y

examples/system/sysview_tracing/sdkconfig.defaults

@@ -4,8 +4,8 @@ CONFIG_FREERTOS_UNICORE=y
 # 1ms tick period
 CONFIG_FREERTOS_HZ=1000
 # Enable application tracing by default
-CONFIG_ESP32_APPTRACE_DEST_TRAX=y
-CONFIG_ESP32_APPTRACE_ENABLE=y
+CONFIG_APPTRACE_DEST_TRAX=y
+CONFIG_APPTRACE_ENABLE=y
 # Enable FreeRTOS SystemView Tracing by default
 CONFIG_SYSVIEW_ENABLE=y
 CONFIG_SYSVIEW_TS_SOURCE_TIMER_00=y

examples/system/sysview_tracing_heap_log/sdkconfig.defaults

@@ -4,8 +4,8 @@ CONFIG_FREERTOS_UNICORE=y
 # 1ms tick period
 CONFIG_FREERTOS_HZ=1000
 # Enable application tracing by default
-CONFIG_ESP32_APPTRACE_DEST_TRAX=y
-CONFIG_ESP32_APPTRACE_ENABLE=y
+CONFIG_APPTRACE_DEST_TRAX=y
+CONFIG_APPTRACE_ENABLE=y
 # Enable FreeRTOS SystemView Tracing by default
 CONFIG_SYSVIEW_ENABLE=y
 CONFIG_SYSVIEW_TS_SOURCE_TIMER_00=y

examples/wifi/simple_sniffer/sdkconfig.defaults

@@ -21,6 +21,6 @@ CONFIG_FATFS_LFN_HEAP=y
 CONFIG_FATFS_MAX_LFN=31
 
 # App trace
-CONFIG_ESP32_APPTRACE_DEST_TRAX=y
-CONFIG_ESP32_APPTRACE_ENABLE=y
+CONFIG_APPTRACE_DEST_TRAX=y
+CONFIG_APPTRACE_ENABLE=y