refactor(apptrace): replace xxx_TRAX with xxx_JTAG

erhankur · espressif-bot · commit 3d7d7813c91a · 2025-07-17T12:36:39.000+08:00
diff --git a/components/app_trace/Kconfig b/components/app_trace/Kconfig
@@ -8,7 +8,7 @@ menu "Application Level Tracing"
 
         config APPTRACE_DEST_JTAG
             bool "JTAG"
-            select APPTRACE_DEST_TRAX if IDF_TARGET_ARCH_XTENSA
+            select APPTRACE_TRAX_ENABLE if IDF_TARGET_ARCH_XTENSA
             select APPTRACE_MEMBUFS_APPTRACE_PROTO_ENABLE
             select APPTRACE_ENABLE
 
@@ -135,7 +135,7 @@ menu "Application Level Tracing"
             UART task priority. In case of high events rate,
             this parameter could be changed up to (configMAX_PRIORITIES-1).
 
-    config APPTRACE_DEST_TRAX
+    config APPTRACE_TRAX_ENABLE
         bool
         depends on IDF_TARGET_ARCH_XTENSA && !ESP32_TRAX && !ESP32S2_TRAX && !ESP32S3_TRAX
         select ESP32_MEMMAP_TRACEMEM
@@ -186,7 +186,7 @@ menu "Application Level Tracing"
 
     config APPTRACE_BUF_SIZE
         int "Size of the apptrace buffer"
-        depends on APPTRACE_MEMBUFS_APPTRACE_PROTO_ENABLE && !APPTRACE_DEST_TRAX
+        depends on APPTRACE_MEMBUFS_APPTRACE_PROTO_ENABLE && !APPTRACE_TRAX_ENABLE
         default 16384
         help
             Size of the memory buffer for trace data in bytes.
diff --git a/components/app_trace/gcov/gcov_rtio.c b/components/app_trace/gcov/gcov_rtio.c
@@ -53,7 +53,7 @@ void gcov_dump_task(void *pvParameter)
     __gcov_reset();
     free(down_buf);
     ESP_EARLY_LOGV(TAG, "Finish file transfer session");
-    dump_result = esp_apptrace_fstop(ESP_APPTRACE_DEST_TRAX);
+    dump_result = esp_apptrace_fstop(ESP_APPTRACE_DEST_JTAG);
     if (dump_result != ESP_OK) {
         ESP_EARLY_LOGE(TAG, "Failed to send files transfer stop cmd (%d)!", dump_result);
     }
@@ -119,7 +119,7 @@ void esp_gcov_dump(void)
 {
     ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__);
 
-    while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_TRAX)) {
+    while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_JTAG)) {
         vTaskDelay(pdMS_TO_TICKS(10));
     }
 
@@ -134,48 +134,48 @@ void esp_gcov_dump(void)
 void *gcov_rtio_fopen(const char *path, const char *mode)
 {
     ESP_EARLY_LOGV(TAG, "%s '%s' '%s'", __FUNCTION__, path, mode);
-    void *f = esp_apptrace_fopen(ESP_APPTRACE_DEST_TRAX, path, mode);
+    void *f = esp_apptrace_fopen(ESP_APPTRACE_DEST_JTAG, path, mode);
     ESP_EARLY_LOGV(TAG, "%s ret %p", __FUNCTION__, f);
     return f;
 }
 
 int gcov_rtio_fclose(void *stream)
 {
     ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__);
-    return esp_apptrace_fclose(ESP_APPTRACE_DEST_TRAX, stream);
+    return esp_apptrace_fclose(ESP_APPTRACE_DEST_JTAG, stream);
 }
 
 size_t gcov_rtio_fread(void *ptr, size_t size, size_t nmemb, void *stream)
 {
     ESP_EARLY_LOGV(TAG, "%s read %u", __FUNCTION__, size * nmemb);
-    size_t sz = esp_apptrace_fread(ESP_APPTRACE_DEST_TRAX, ptr, size, nmemb, stream);
+    size_t sz = esp_apptrace_fread(ESP_APPTRACE_DEST_JTAG, ptr, size, nmemb, stream);
     ESP_EARLY_LOGV(TAG, "%s actually read %u", __FUNCTION__, sz);
     return sz;
 }
 
 size_t gcov_rtio_fwrite(const void *ptr, size_t size, size_t nmemb, void *stream)
 {
     ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__);
-    return esp_apptrace_fwrite(ESP_APPTRACE_DEST_TRAX, ptr, size, nmemb, stream);
+    return esp_apptrace_fwrite(ESP_APPTRACE_DEST_JTAG, ptr, size, nmemb, stream);
 }
 
 int gcov_rtio_fseek(void *stream, long offset, int whence)
 {
-    int ret = esp_apptrace_fseek(ESP_APPTRACE_DEST_TRAX, stream, offset, whence);
+    int ret = esp_apptrace_fseek(ESP_APPTRACE_DEST_JTAG, stream, offset, whence);
     ESP_EARLY_LOGV(TAG, "%s(%p %ld %d) = %d", __FUNCTION__, stream, offset, whence, ret);
     return ret;
 }
 
 long gcov_rtio_ftell(void *stream)
 {
-    long ret = esp_apptrace_ftell(ESP_APPTRACE_DEST_TRAX, stream);
+    long ret = esp_apptrace_ftell(ESP_APPTRACE_DEST_JTAG, stream);
     ESP_EARLY_LOGV(TAG, "%s(%p) = %ld", __FUNCTION__, stream, ret);
     return ret;
 }
 
 int gcov_rtio_feof(void *stream)
 {
-    int ret = esp_apptrace_feof(ESP_APPTRACE_DEST_TRAX, stream);
+    int ret = esp_apptrace_feof(ESP_APPTRACE_DEST_JTAG, stream);
     ESP_EARLY_LOGV(TAG, "%s(%p) = %d", __FUNCTION__, stream, ret);
     return ret;
 }
diff --git a/components/app_trace/include/esp_app_trace.h b/components/app_trace/include/esp_app_trace.h
@@ -17,12 +17,10 @@ extern "C" {
 /**
  * Application trace data destinations bits.
  */
-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_NUM
+ typedef enum {
+    ESP_APPTRACE_DEST_JTAG,                         ///< JTAG destination
+    ESP_APPTRACE_DEST_UART,                         ///< UART destination
+    ESP_APPTRACE_DEST_MAX,
 } esp_apptrace_dest_t;
 
 /**
@@ -117,7 +115,7 @@ esp_err_t esp_apptrace_flush(esp_apptrace_dest_t dest, uint32_t tmo);
  *        This is a special version of esp_apptrace_flush which should be called from panic handler.
  *
  * @param dest   Indicates HW interface to flush data on.
- * @param min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only.
+ * @param min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. JTAG destinations only.
  * @param tmo    Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely.
  *
  * @return ESP_OK on success, otherwise see esp_err_t
diff --git a/components/app_trace/sys_view/esp/SEGGER_RTT_esp.c b/components/app_trace/sys_view/esp/SEGGER_RTT_esp.c
@@ -42,7 +42,7 @@ static uint8_t s_down_buf[SYSVIEW_DOWN_BUF_SIZE];
 #endif // CONFIG_APPTRACE_SV_DEST_CPU_0
 
 #elif CONFIG_APPTRACE_SV_DEST_JTAG || (CONFIG_APPTRACE_ENABLE && CONFIG_APPTRACE_DEST_UART_NONE)
-#define ESP_APPTRACE_DEST_SYSVIEW ESP_APPTRACE_DEST_TRAX
+#define ESP_APPTRACE_DEST_SYSVIEW ESP_APPTRACE_DEST_JTAG
 #endif
 
 /*********************************************************************
@@ -60,7 +60,7 @@ static uint8_t s_down_buf[SYSVIEW_DOWN_BUF_SIZE];
 *    Flushes buffered events.
 *
 *  Parameters
-*    min_sz  Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only.
+*    min_sz  Threshold for flushing data. If current filling level is above this value, data will be flushed. JTAG destinations only.
 *    tmo     Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely.
 *
 *  Return value
@@ -91,7 +91,7 @@ void SEGGER_RTT_ESP_FlushNoLock(unsigned long min_sz, unsigned long tmo)
 *    Flushes buffered events.
 *
 *  Parameters
-*    min_sz  Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only.
+*    min_sz  Threshold for flushing data. If current filling level is above this value, data will be flushed. JTAG destinations only.
 *    tmo     Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely.
 *
 *  Return value
diff --git a/components/app_trace/test_apps/main/test_trace.c b/components/app_trace/test_apps/main/test_trace.c
@@ -67,9 +67,9 @@ const static char *TAG = "esp_apptrace_test";
 #define ESP_APPTRACE_TEST_LOGO( format, ... )  ESP_APPTRACE_TEST_LOG_LEVEL(E, ESP_LOG_NONE, format, ##__VA_ARGS__)
 
 #if CONFIG_APPTRACE_SV_ENABLE == 0
-#define ESP_APPTRACE_TEST_WRITE(_b_, _s_)            esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, ESP_APPTRACE_TMO_INFINITE)
-#define ESP_APPTRACE_TEST_WRITE_FROM_ISR(_b_, _s_)   esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, 0UL)
-#define ESP_APPTRACE_TEST_WRITE_NOWAIT(_b_, _s_)     esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, 0)
+#define ESP_APPTRACE_TEST_WRITE(_b_, _s_)            esp_apptrace_write(ESP_APPTRACE_DEST_JTAG, _b_, _s_, ESP_APPTRACE_TMO_INFINITE)
+#define ESP_APPTRACE_TEST_WRITE_FROM_ISR(_b_, _s_)   esp_apptrace_write(ESP_APPTRACE_DEST_JTAG, _b_, _s_, 0UL)
+#define ESP_APPTRACE_TEST_WRITE_NOWAIT(_b_, _s_)     esp_apptrace_write(ESP_APPTRACE_DEST_JTAG, _b_, _s_, 0)
 
 typedef struct {
     uint8_t *buf;
@@ -625,7 +625,7 @@ static int esp_logtrace_printf(const char *fmt, ...)
 
     va_start(ap, fmt);
 
-    int ret = esp_apptrace_vprintf_to(ESP_APPTRACE_DEST_TRAX, ESP_APPTRACE_TMO_INFINITE, fmt, ap);
+    int ret = esp_apptrace_vprintf_to(ESP_APPTRACE_DEST_JTAG, ESP_APPTRACE_TMO_INFINITE, fmt, ap);
 
     va_end(ap);
 
@@ -657,7 +657,7 @@ static void esp_logtrace_task(void *p)
             break;
         }
     }
-    esp_err_t ret = esp_apptrace_flush(ESP_APPTRACE_DEST_TRAX, ESP_APPTRACE_TMO_INFINITE);
+    esp_err_t ret = esp_apptrace_flush(ESP_APPTRACE_DEST_JTAG, ESP_APPTRACE_TMO_INFINITE);
     if (ret != ESP_OK) {
         ESP_APPTRACE_TEST_LOGE("Failed to flush printf buf (%d)!", ret);
     }
diff --git a/components/esp_system/panic.c b/components/esp_system/panic.c
@@ -361,7 +361,7 @@ void esp_panic_handler(panic_info_t *info)
 #if CONFIG_APPTRACE_SV_ENABLE
         SEGGER_RTT_ESP_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
+        esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_JTAG, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                                   APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
@@ -401,7 +401,7 @@ void esp_panic_handler(panic_info_t *info)
 #if CONFIG_APPTRACE_SV_ENABLE
     SEGGER_RTT_ESP_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_JTAG, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                               APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif // CONFIG_APPTRACE_ENABLE
@@ -472,7 +472,7 @@ void __attribute__((noreturn, no_sanitize_undefined)) panic_abort(const char *de
 #if CONFIG_APPTRACE_SV_ENABLE
     SEGGER_RTT_ESP_FlushNoLock(CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH, APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #else
-    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_TRAX, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
+    esp_apptrace_flush_nolock(ESP_APPTRACE_DEST_JTAG, CONFIG_APPTRACE_POSTMORTEM_FLUSH_THRESH,
                               APPTRACE_ONPANIC_HOST_FLUSH_TMO);
 #endif
 #endif
diff --git a/docs/en/api-guides/app_trace.rst b/docs/en/api-guides/app_trace.rst
@@ -78,7 +78,7 @@ In general, users should decide what type of data should be transferred in every
         #include "esp_app_trace.h"
         ...
         char buf[] = "Hello World!";
-        esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, buf, strlen(buf), ESP_APPTRACE_TMO_INFINITE);
+        esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_JTAG, buf, strlen(buf), ESP_APPTRACE_TMO_INFINITE);
         if (res != ESP_OK) {
             ESP_LOGE(TAG, "Failed to write data to host!");
             return res;
@@ -91,13 +91,13 @@ In general, users should decide what type of data should be transferred in every
         #include "esp_app_trace.h"
         ...
         int number = 10;
-        char *ptr = (char *)esp_apptrace_buffer_get(ESP_APPTRACE_DEST_TRAX, 32, 100/*tmo in us*/);
+        char *ptr = (char *)esp_apptrace_buffer_get(ESP_APPTRACE_DEST_JTAG, 32, 100/*tmo in us*/);
         if (ptr == NULL) {
             ESP_LOGE(TAG, "Failed to get buffer!");
             return ESP_FAIL;
         }
         sprintf(ptr, "Here is the number %d", number);
-        esp_err_t res = esp_apptrace_buffer_put(ESP_APPTRACE_DEST_TRAX, ptr, 100/*tmo in us*/);
+        esp_err_t res = esp_apptrace_buffer_put(ESP_APPTRACE_DEST_JTAG, ptr, 100/*tmo in us*/);
         if (res != ESP_OK) {
             /* in case of error host tracing tool (e.g., OpenOCD) will report incomplete user buffer */
             ESP_LOGE(TAG, "Failed to put buffer!");
@@ -117,7 +117,7 @@ In general, users should decide what type of data should be transferred in every
         /* config down buffer */
         esp_apptrace_down_buffer_config(down_buf, sizeof(down_buf));
         /* check for incoming data and read them if any */
-        esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_TRAX, buf, &sz, 0/*do not wait*/);
+        esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_JTAG, buf, &sz, 0/*do not wait*/);
         if (res != ESP_OK) {
             ESP_LOGE(TAG, "Failed to read data from host!");
             return res;
@@ -139,7 +139,7 @@ In general, users should decide what type of data should be transferred in every
 
         /* config down buffer */
         esp_apptrace_down_buffer_config(down_buf, sizeof(down_buf));
-        char *ptr = (char *)esp_apptrace_down_buffer_get(ESP_APPTRACE_DEST_TRAX, &sz, 100/*tmo in us*/);
+        char *ptr = (char *)esp_apptrace_down_buffer_get(ESP_APPTRACE_DEST_JTAG, &sz, 100/*tmo in us*/);
         if (ptr == NULL) {
             ESP_LOGE(TAG, "Failed to get buffer!");
             return ESP_FAIL;
@@ -150,7 +150,7 @@ In general, users should decide what type of data should be transferred in every
         } else {
             printf("No data");
         }
-        esp_err_t res = esp_apptrace_down_buffer_put(ESP_APPTRACE_DEST_TRAX, ptr, 100/*tmo in us*/);
+        esp_err_t res = esp_apptrace_down_buffer_put(ESP_APPTRACE_DEST_JTAG, ptr, 100/*tmo in us*/);
         if (res != ESP_OK) {
             /* in case of error host tracing tool (e.g., OpenOCD) will report incomplete user buffer */
             ESP_LOGE(TAG, "Failed to put buffer!");
diff --git a/docs/en/migration-guides/release-6.x/6.0/system.rst b/docs/en/migration-guides/release-6.x/6.0/system.rst
@@ -57,9 +57,10 @@ The deprecated ``soc_memory_types.h`` header file has been removed. Please inclu
 
 App Trace
 ----------
-
 Removed extra data buffering option. `CONFIG_APPTRACE_PENDING_DATA_SIZE_MAX` is no longer supported.
 
+Removed deprecated `ESP_APPTRACE_DEST_TRAX` enum value. Use `ESP_APPTRACE_DEST_JTAG` instead.
+
 FreeRTOS
 --------
 
diff --git a/docs/zh_CN/api-guides/app_trace.rst b/docs/zh_CN/api-guides/app_trace.rst
@@ -78,7 +78,7 @@ ESP-IDF 中提供了应用层跟踪功能，用于分析应用程序的行为。
       #include "esp_app_trace.h"
       ...
       char buf[] = "Hello World!";
-      esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, buf, strlen(buf), ESP_APPTRACE_TMO_INFINITE);
+      esp_err_t res = esp_apptrace_write(ESP_APPTRACE_DEST_JTAG, buf, strlen(buf), ESP_APPTRACE_TMO_INFINITE);
       if (res != ESP_OK) {
           ESP_LOGE(TAG, "Failed to write data to host!");
           return res;
@@ -91,13 +91,13 @@ ESP-IDF 中提供了应用层跟踪功能，用于分析应用程序的行为。
       #include "esp_app_trace.h"
       ...
       int number = 10;
-      char *ptr = (char *)esp_apptrace_buffer_get(ESP_APPTRACE_DEST_TRAX, 32, 100/*tmo in us*/);
+      char *ptr = (char *)esp_apptrace_buffer_get(ESP_APPTRACE_DEST_JTAG, 32, 100/*tmo in us*/);
       if (ptr == NULL) {
           ESP_LOGE(TAG, "Failed to get buffer!");
           return ESP_FAIL;
       }
       sprintf(ptr, "Here is the number %d", number);
-      esp_err_t res = esp_apptrace_buffer_put(ESP_APPTRACE_DEST_TRAX, ptr, 100/*tmo in us*/);
+      esp_err_t res = esp_apptrace_buffer_put(ESP_APPTRACE_DEST_JTAG, ptr, 100/*tmo in us*/);
       if (res != ESP_OK) {
           /* in case of error host tracing tool (e.g. OpenOCD) will report incomplete user buffer */
           ESP_LOGE(TAG, "Failed to put buffer!");
@@ -117,7 +117,7 @@ ESP-IDF 中提供了应用层跟踪功能，用于分析应用程序的行为。
       /* config down buffer */
       esp_apptrace_down_buffer_config(down_buf, sizeof(down_buf));
       /* check for incoming data and read them if any */
-      esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_TRAX, buf, &sz, 0/*do not wait*/);
+      esp_err_t res = esp_apptrace_read(ESP_APPTRACE_DEST_JTAG, buf, &sz, 0/*do not wait*/);
       if (res != ESP_OK) {
           ESP_LOGE(TAG, "Failed to read data from host!");
           return res;
@@ -139,7 +139,7 @@ ESP-IDF 中提供了应用层跟踪功能，用于分析应用程序的行为。
 
       /* config down buffer */
       esp_apptrace_down_buffer_config(down_buf, sizeof(down_buf));
-      char *ptr = (char *)esp_apptrace_down_buffer_get(ESP_APPTRACE_DEST_TRAX, &sz, 100/*tmo in us*/);
+      char *ptr = (char *)esp_apptrace_down_buffer_get(ESP_APPTRACE_DEST_JTAG, &sz, 100/*tmo in us*/);
       if (ptr == NULL) {
           ESP_LOGE(TAG, "Failed to get buffer!");
           return ESP_FAIL;
@@ -150,7 +150,7 @@ ESP-IDF 中提供了应用层跟踪功能，用于分析应用程序的行为。
       } else {
           printf("No data");
       }
-      esp_err_t res = esp_apptrace_down_buffer_put(ESP_APPTRACE_DEST_TRAX, ptr, 100/*tmo in us*/);
+      esp_err_t res = esp_apptrace_down_buffer_put(ESP_APPTRACE_DEST_JTAG, ptr, 100/*tmo in us*/);
       if (res != ESP_OK) {
           /* in case of error host tracing tool (e.g. OpenOCD) will report incomplete user buffer */
           ESP_LOGE(TAG, "Failed to put buffer!");
diff --git a/examples/network/simple_sniffer/main/Kconfig.projbuild b/examples/network/simple_sniffer/main/Kconfig.projbuild
@@ -21,7 +21,7 @@ menu "Example Configuration"
                 Store pcap file to SD card.
         config SNIFFER_PCAP_DESTINATION_JTAG
             bool "JTAG (App Trace)"
-            depends on APPTRACE_DEST_TRAX
+            depends on APPTRACE_DEST_JTAG
             help
                 Store pcap file to host via JTAG interface.
         config SNIFFER_PCAP_DESTINATION_MEMORY
diff --git a/examples/network/simple_sniffer/main/cmd_pcap.c b/examples/network/simple_sniffer/main/cmd_pcap.c
@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
 /* cmd_pcap example.
    This example code is in the Public Domain (or CC0 licensed, at your option.)
 
@@ -68,18 +73,18 @@ static pcap_cmd_runtime_t pcap_cmd_rt = {0};
 #if CONFIG_SNIFFER_PCAP_DESTINATION_JTAG
 static int trace_writefun(void *cookie, const char *buf, int len)
 {
-    return esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, buf, len, SNIFFER_PROCESS_APPTRACE_TIMEOUT_US) ==
+    return esp_apptrace_write(ESP_APPTRACE_DEST_JTAG, buf, len, SNIFFER_PROCESS_APPTRACE_TIMEOUT_US) ==
            ESP_OK ? len : -1;
 }
 
 static int trace_closefun(void *cookie)
 {
-    return esp_apptrace_flush(ESP_APPTRACE_DEST_TRAX, ESP_APPTRACE_TMO_INFINITE) == ESP_OK ? 0 : -1;
+    return esp_apptrace_flush(ESP_APPTRACE_DEST_JTAG, ESP_APPTRACE_TMO_INFINITE) == ESP_OK ? 0 : -1;
 }
 
 void pcap_flush_apptrace_timer_cb(TimerHandle_t pxTimer)
 {
-    esp_apptrace_flush(ESP_APPTRACE_DEST_TRAX, pdMS_TO_TICKS(10));
+    esp_apptrace_flush(ESP_APPTRACE_DEST_JTAG, pdMS_TO_TICKS(10));
 }
 #endif // CONFIG_SNIFFER_PCAP_DESTINATION_JTAG
 
@@ -151,7 +156,7 @@ esp_err_t sniff_packet_start(pcap_link_type_t link_type)
 #if CONFIG_SNIFFER_PCAP_DESTINATION_JTAG
     uint32_t retry = 0;
     /* wait until apptrace communication established or timeout */
-    while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_TRAX) && (retry < SNIFFER_APPTRACE_RETRY)) {
+    while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_JTAG) && (retry < SNIFFER_APPTRACE_RETRY)) {
         retry++;
         ESP_LOGW(CMD_PCAP_TAG, "waiting for apptrace established");
         vTaskDelay(pdMS_TO_TICKS(1000));

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ void gcov_dump_task(void *pvParameter)`
`53`	`53`	`__gcov_reset();`
`54`	`54`	`free(down_buf);`
`55`	`55`	`ESP_EARLY_LOGV(TAG, "Finish file transfer session");`
`56`		`- dump_result = esp_apptrace_fstop(ESP_APPTRACE_DEST_TRAX);`
	`56`	`+ dump_result = esp_apptrace_fstop(ESP_APPTRACE_DEST_JTAG);`
`57`	`57`	`if (dump_result != ESP_OK) {`
`58`	`58`	`ESP_EARLY_LOGE(TAG, "Failed to send files transfer stop cmd (%d)!", dump_result);`
`59`	`59`	`}`
`@@ -119,7 +119,7 @@ void esp_gcov_dump(void)`
`119`	`119`	`{`
`120`	`120`	`ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__);`
`121`	`121`
`122`		`- while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_TRAX)) {`
	`122`	`+ while (!esp_apptrace_host_is_connected(ESP_APPTRACE_DEST_JTAG)) {`
`123`	`123`	`vTaskDelay(pdMS_TO_TICKS(10));`
`124`	`124`	`}`
`125`	`125`
`@@ -134,48 +134,48 @@ void esp_gcov_dump(void)`
`134`	`134`	`void gcov_rtio_fopen(const char path, const char *mode)`
`135`	`135`	`{`
`136`	`136`	`ESP_EARLY_LOGV(TAG, "%s '%s' '%s'", __FUNCTION__, path, mode);`
`137`		`- void *f = esp_apptrace_fopen(ESP_APPTRACE_DEST_TRAX, path, mode);`
	`137`	`+ void *f = esp_apptrace_fopen(ESP_APPTRACE_DEST_JTAG, path, mode);`
`138`	`138`	`ESP_EARLY_LOGV(TAG, "%s ret %p", __FUNCTION__, f);`
`139`	`139`	`return f;`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`int gcov_rtio_fclose(void *stream)`
`143`	`143`	`{`
`144`	`144`	`ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__);`
`145`		`- return esp_apptrace_fclose(ESP_APPTRACE_DEST_TRAX, stream);`
	`145`	`+ return esp_apptrace_fclose(ESP_APPTRACE_DEST_JTAG, stream);`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`size_t gcov_rtio_fread(void ptr, size_t size, size_t nmemb, void stream)`
`149`	`149`	`{`
`150`	`150`	`ESP_EARLY_LOGV(TAG, "%s read %u", __FUNCTION__, size * nmemb);`
`151`		`- size_t sz = esp_apptrace_fread(ESP_APPTRACE_DEST_TRAX, ptr, size, nmemb, stream);`
	`151`	`+ size_t sz = esp_apptrace_fread(ESP_APPTRACE_DEST_JTAG, ptr, size, nmemb, stream);`
`152`	`152`	`ESP_EARLY_LOGV(TAG, "%s actually read %u", __FUNCTION__, sz);`
`153`	`153`	`return sz;`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`size_t gcov_rtio_fwrite(const void ptr, size_t size, size_t nmemb, void stream)`
`157`	`157`	`{`
`158`	`158`	`ESP_EARLY_LOGV(TAG, "%s", __FUNCTION__);`
`159`		`- return esp_apptrace_fwrite(ESP_APPTRACE_DEST_TRAX, ptr, size, nmemb, stream);`
	`159`	`+ return esp_apptrace_fwrite(ESP_APPTRACE_DEST_JTAG, ptr, size, nmemb, stream);`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`int gcov_rtio_fseek(void *stream, long offset, int whence)`
`163`	`163`	`{`
`164`		`- int ret = esp_apptrace_fseek(ESP_APPTRACE_DEST_TRAX, stream, offset, whence);`
	`164`	`+ int ret = esp_apptrace_fseek(ESP_APPTRACE_DEST_JTAG, stream, offset, whence);`
`165`	`165`	`ESP_EARLY_LOGV(TAG, "%s(%p %ld %d) = %d", __FUNCTION__, stream, offset, whence, ret);`
`166`	`166`	`return ret;`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`long gcov_rtio_ftell(void *stream)`
`170`	`170`	`{`
`171`		`- long ret = esp_apptrace_ftell(ESP_APPTRACE_DEST_TRAX, stream);`
	`171`	`+ long ret = esp_apptrace_ftell(ESP_APPTRACE_DEST_JTAG, stream);`
`172`	`172`	`ESP_EARLY_LOGV(TAG, "%s(%p) = %ld", __FUNCTION__, stream, ret);`
`173`	`173`	`return ret;`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`int gcov_rtio_feof(void *stream)`
`177`	`177`	`{`
`178`		`- int ret = esp_apptrace_feof(ESP_APPTRACE_DEST_TRAX, stream);`
	`178`	`+ int ret = esp_apptrace_feof(ESP_APPTRACE_DEST_JTAG, stream);`
`179`	`179`	`ESP_EARLY_LOGV(TAG, "%s(%p) = %d", __FUNCTION__, stream, ret);`
`180`	`180`	`return ret;`
`181`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ static uint8_t s_down_buf[SYSVIEW_DOWN_BUF_SIZE];`
`42`	`42`	`#endif // CONFIG_APPTRACE_SV_DEST_CPU_0`
`43`	`43`
`44`	`44`	`#elif CONFIG_APPTRACE_SV_DEST_JTAG \|\| (CONFIG_APPTRACE_ENABLE && CONFIG_APPTRACE_DEST_UART_NONE)`
`45`		`-#define ESP_APPTRACE_DEST_SYSVIEW ESP_APPTRACE_DEST_TRAX`
	`45`	`+#define ESP_APPTRACE_DEST_SYSVIEW ESP_APPTRACE_DEST_JTAG`
`46`	`46`	`#endif`
`47`	`47`
`48`	`48`	`/*********************************************************************`
`@@ -60,7 +60,7 @@ static uint8_t s_down_buf[SYSVIEW_DOWN_BUF_SIZE];`
`60`	`60`	`* Flushes buffered events.`
`61`	`61`	`*`
`62`	`62`	`* Parameters`
`63`		`-* min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only.`
	`63`	`+* min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. JTAG destinations only.`
`64`	`64`	`* tmo Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely.`
`65`	`65`	`*`
`66`	`66`	`* Return value`
`@@ -91,7 +91,7 @@ void SEGGER_RTT_ESP_FlushNoLock(unsigned long min_sz, unsigned long tmo)`
`91`	`91`	`* Flushes buffered events.`
`92`	`92`	`*`
`93`	`93`	`* Parameters`
`94`		`-* min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. TRAX destinations only.`
	`94`	`+* min_sz Threshold for flushing data. If current filling level is above this value, data will be flushed. JTAG destinations only.`
`95`	`95`	`* tmo Timeout for operation (in us). Use ESP_APPTRACE_TMO_INFINITE to wait indefinitely.`
`96`	`96`	`*`
`97`	`97`	`* Return value`