Merge branch 'feature/etm_api_update' into 'master'

etm: introduce config structure for event/task new functions

See merge request espressif/esp-idf!21483

components/driver/gptimer/gptimer_etm.c

@@ -33,19 +33,19 @@ static esp_err_t gptimer_del_etm_task(esp_etm_task_t *task)
     return ESP_OK;
 }
 
-esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, gptimer_etm_event_type_t event_type, esp_etm_event_handle_t *out_event)
+esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, const gptimer_etm_event_config_t *config, esp_etm_event_handle_t *out_event)
 {
     esp_etm_event_t *event = NULL;
     esp_err_t ret = ESP_OK;
-    ESP_GOTO_ON_FALSE(timer && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
-    ESP_GOTO_ON_FALSE(event_type < GPTIMER_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type");
+    ESP_GOTO_ON_FALSE(timer && config && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->event_type < GPTIMER_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type");
     event = heap_caps_calloc(1, sizeof(esp_etm_event_t), ETM_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(event, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM event");
 
     gptimer_group_t *group = timer->group;
     int group_id = group->group_id;
     int timer_id = timer->timer_id;
-    uint32_t event_id = TIMER_LL_ETM_EVENT_TABLE(group_id, timer_id, event_type);
+    uint32_t event_id = TIMER_LL_ETM_EVENT_TABLE(group_id, timer_id, config->event_type);
     ESP_GOTO_ON_FALSE(event_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported event type");
 
     // fill the ETM event object
@@ -62,19 +62,19 @@ err:
     return ret;
 }
 
-esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, gptimer_etm_task_type_t task_type, esp_etm_task_handle_t *out_task)
+esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, const gptimer_etm_task_config_t *config, esp_etm_task_handle_t *out_task)
 {
     esp_etm_task_t *task = NULL;
     esp_err_t ret = ESP_OK;
-    ESP_GOTO_ON_FALSE(timer && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
-    ESP_GOTO_ON_FALSE(task_type < GPTIMER_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type");
+    ESP_GOTO_ON_FALSE(timer && config && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->task_type < GPTIMER_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type");
     task = heap_caps_calloc(1, sizeof(esp_etm_task_t), ETM_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(task, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM task");
 
     gptimer_group_t *group = timer->group;
     int group_id = group->group_id;
     int timer_id = timer->timer_id;
-    uint32_t task_id = TIMER_LL_ETM_TASK_TABLE(group_id, timer_id, task_type);
+    uint32_t task_id = TIMER_LL_ETM_TASK_TABLE(group_id, timer_id, config->task_type);
     ESP_GOTO_ON_FALSE(task_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported task type");
 
     // fill the ETM task object

components/driver/include/driver/gptimer_etm.h

@@ -14,20 +14,34 @@
 extern "C" {
 #endif
 
+/**
+ * @brief GPTimer ETM event configuration
+ */
+typedef struct {
+    gptimer_etm_event_type_t event_type; /*!< GPTimer ETM event type */
+} gptimer_etm_event_config_t;
+
 /**
  * @brief Get the ETM event for GPTimer
  *
  * @note The created ETM event object can be deleted later by calling `esp_etm_del_event`
  *
  * @param[in] timer Timer handle created by `gptimer_new_timer`
- * @param[in] event_type GPTimer ETM event type
+ * @param[in] config GPTimer ETM event configuration
  * @param[out] out_event Returned ETM event handle
  * @return
  *      - ESP_OK: Get ETM event successfully
  *      - ESP_ERR_INVALID_ARG: Get ETM event failed because of invalid argument
  *      - ESP_FAIL: Get ETM event failed because of other error
  */
-esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, gptimer_etm_event_type_t event_type, esp_etm_event_handle_t *out_event);
+esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, const gptimer_etm_event_config_t *config, esp_etm_event_handle_t *out_event);
+
+/**
+ * @brief GPTimer ETM task configuration
+ */
+typedef struct {
+    gptimer_etm_task_type_t task_type; /*!< GPTimer ETM task type */
+} gptimer_etm_task_config_t;
 
 /**
  * @brief Get the ETM task for GPTimer
@@ -35,14 +49,14 @@ esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, gptimer_etm_event_type_t
  * @note The created ETM task object can be deleted later by calling `esp_etm_del_task`
  *
  * @param[in] timer Timer handle created by `gptimer_new_timer`
- * @param[in] task_type GPTimer ETM task type
+ * @param[in] config GPTimer ETM task configuration
  * @param[out] out_task Returned ETM task handle
  * @return
  *      - ESP_OK: Get ETM task successfully
  *      - ESP_ERR_INVALID_ARG: Get ETM task failed because of invalid argument
  *      - ESP_FAIL: Get ETM task failed because of other error
  */
-esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, gptimer_etm_task_type_t task_type, esp_etm_task_handle_t *out_task);
+esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, const gptimer_etm_task_config_t *config, esp_etm_task_handle_t *out_task);
 
 #ifdef __cplusplus
 }

components/esp_hw_support/dma/async_memcpy_impl_gdma.c

@@ -114,7 +114,10 @@ esp_err_t async_memcpy_impl_new_etm_event(async_memcpy_impl_t *impl, async_memcp
 {
     if (event_type == ASYNC_MEMCPY_ETM_EVENT_COPY_DONE) {
         // use the RX EOF to indicate the async memcpy done event
-        return gdma_new_etm_event(impl->rx_channel, GDMA_ETM_EVENT_EOF, out_event);
+        gdma_etm_event_config_t etm_event_conf = {
+            .event_type = GDMA_ETM_EVENT_EOF,
+        };
+        return gdma_new_etm_event(impl->rx_channel, &etm_event_conf, out_event);
     } else {
         return ESP_ERR_NOT_SUPPORTED;
     }

components/esp_hw_support/dma/gdma_etm.c

@@ -49,12 +49,12 @@ static esp_err_t gdma_del_etm_task(esp_etm_task_t *task)
     return ESP_OK;
 }
 
-esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type_t event_type, esp_etm_event_handle_t *out_event)
+esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, const gdma_etm_event_config_t *config, esp_etm_event_handle_t *out_event)
 {
     esp_etm_event_t *event = NULL;
     esp_err_t ret = ESP_OK;
-    ESP_GOTO_ON_FALSE(dma_chan && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
-    ESP_GOTO_ON_FALSE(event_type < GDMA_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type");
+    ESP_GOTO_ON_FALSE(dma_chan && config && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->event_type < GDMA_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type");
     event = heap_caps_calloc(1, sizeof(esp_etm_event_t), ETM_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(event, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM event");
 
@@ -63,9 +63,9 @@ esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type
     uint32_t event_id = 0;
 
     if (dma_chan->direction == GDMA_CHANNEL_DIRECTION_RX) {
-        event_id = GDMA_LL_RX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, event_type);
+        event_id = GDMA_LL_RX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, config->event_type);
     } else {
-        event_id = GDMA_LL_TX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, event_type);
+        event_id = GDMA_LL_TX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, config->event_type);
     }
     ESP_GOTO_ON_FALSE(event_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported event type");
 
@@ -83,12 +83,12 @@ err:
     return ret;
 }
 
-esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, gdma_etm_task_type_t task_type, esp_etm_task_handle_t *out_task)
+esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, const gdma_etm_task_config_t *config, esp_etm_task_handle_t *out_task)
 {
     gdma_etm_task_t *task = NULL;
     esp_err_t ret = ESP_OK;
-    ESP_GOTO_ON_FALSE(dma_chan && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
-    ESP_GOTO_ON_FALSE(task_type < GDMA_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type");
+    ESP_GOTO_ON_FALSE(dma_chan && config && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    ESP_GOTO_ON_FALSE(config->task_type < GDMA_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type");
     task = heap_caps_calloc(1, sizeof(gdma_etm_task_t), ETM_MEM_ALLOC_CAPS);
     ESP_GOTO_ON_FALSE(task, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM task");
 
@@ -97,10 +97,10 @@ esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, gdma_etm_task_type_t
     uint32_t task_id = 0;
 
     if (dma_chan->direction == GDMA_CHANNEL_DIRECTION_RX) {
-        task_id = GDMA_LL_RX_ETM_TASK_TABLE(group->group_id, pair->pair_id, task_type);
+        task_id = GDMA_LL_RX_ETM_TASK_TABLE(group->group_id, pair->pair_id, config->task_type);
         gdma_ll_rx_enable_etm_task(group->hal.dev, pair->pair_id, true);
     } else {
-        task_id = GDMA_LL_TX_ETM_TASK_TABLE(group->group_id, pair->pair_id, task_type);
+        task_id = GDMA_LL_TX_ETM_TASK_TABLE(group->group_id, pair->pair_id, config->task_type);
         gdma_ll_tx_enable_etm_task(group->hal.dev, pair->pair_id, true);
     }
     ESP_GOTO_ON_FALSE(task_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported task type");

components/esp_hw_support/include/esp_private/gdma.h

@@ -327,13 +327,20 @@ esp_err_t gdma_append(gdma_channel_handle_t dma_chan);
  */
 esp_err_t gdma_reset(gdma_channel_handle_t dma_chan);
 
+/**
+ * @brief GDMA ETM event configuration
+ */
+typedef struct {
+    gdma_etm_event_type_t event_type; /*!< GDMA ETM event type */
+} gdma_etm_event_config_t;
+
 /**
  * @brief Get the ETM event for GDMA channel
  *
  * @note The created ETM event object can be deleted later by calling `esp_etm_del_event`
  *
  * @param[in] dma_chan GDMA channel handle, allocated by `gdma_new_channel`
- * @param[in] event_type GDMA ETM event type
+ * @param[in] config GDMA ETM event configuration
  * @param[out] out_event Returned ETM event handle
  * @return
  *      - ESP_OK: Get ETM event successfully
@@ -341,7 +348,14 @@ esp_err_t gdma_reset(gdma_channel_handle_t dma_chan);
  *      - ESP_ERR_NOT_SUPPORTED: Get ETM event failed because the GDMA hardware doesn't support ETM event
  *      - ESP_FAIL: Get ETM event failed because of other error
  */
-esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type_t event_type, esp_etm_event_handle_t *out_event);
+esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, const gdma_etm_event_config_t *config, esp_etm_event_handle_t *out_event);
+
+/**
+ * @brief GDMA ETM task configuration
+ */
+typedef struct {
+    gdma_etm_task_type_t task_type; /*!< GDMA ETM task type */
+} gdma_etm_task_config_t;
 
 /**
  * @brief Get the ETM task for GDMA channel
@@ -349,7 +363,7 @@ esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type
  * @note The created ETM task object can be deleted later by calling `esp_etm_del_task`
  *
  * @param[in] dma_chan GDMA channel handle, allocated by `gdma_new_channel`
- * @param[in] task_type GDMA ETM task type
+ * @param[in] config GDMA ETM task configuration
  * @param[out] out_task Returned ETM task handle
  * @return
  *      - ESP_OK: Get ETM task successfully
@@ -357,7 +371,7 @@ esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type
  *      - ESP_ERR_NOT_SUPPORTED: Get ETM task failed because the gdma hardware doesn't support ETM task
  *      - ESP_FAIL: Get ETM task failed because of other error
  */
-esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, gdma_etm_task_type_t task_type, esp_etm_task_handle_t *out_task);
+esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, const gdma_etm_task_config_t *config, esp_etm_task_handle_t *out_task);
 
 #ifdef __cplusplus
 }

components/esp_hw_support/test_apps/etm/main/test_gdma_etm.c

@@ -69,6 +69,7 @@ TEST_CASE("async_memcpy_eof_event", "[etm]")
     printf("start memcpy\r\n");
     for (int j = 0; j < 19; j++) {
         TEST_ESP_OK(esp_async_memcpy(mcp_ctx, dst_buf, src_buf, buffer_size, NULL, NULL));
+        vTaskDelay(pdMS_TO_TICKS(10));
     }
     // simply wait for the last memcpy to finish
     vTaskDelay(pdMS_TO_TICKS(1000));

components/esp_hw_support/test_apps/etm/main/test_gptimer_etm.c

@@ -55,7 +55,10 @@ TEST_CASE("gptimer_etm_alarm_event_with_interrupt_enabled", "[etm]")
 
     printf("get gptimer etm event handle\r\n");
     esp_etm_event_handle_t gptimer_event = NULL;
-    TEST_ESP_OK(gptimer_new_etm_event(gptimer, GPTIMER_ETM_EVENT_ALARM_MATCH, &gptimer_event));
+    gptimer_etm_event_config_t gptimer_etm_event_conf = {
+        .event_type = GPTIMER_ETM_EVENT_ALARM_MATCH,
+    };
+    TEST_ESP_OK(gptimer_new_etm_event(gptimer, &gptimer_etm_event_conf, &gptimer_event));
 
     printf("connect event and task to the channel\r\n");
     TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event, gpio_task));
@@ -136,9 +139,15 @@ TEST_CASE("gptimer_etm_alarm_event_without_interrupt", "[etm]")
 
     printf("get gptimer etm event and task handle\r\n");
     esp_etm_event_handle_t gptimer_event = NULL;
-    TEST_ESP_OK(gptimer_new_etm_event(gptimer, GPTIMER_ETM_EVENT_ALARM_MATCH, &gptimer_event));
+    gptimer_etm_event_config_t gptimer_etm_event_conf = {
+        .event_type = GPTIMER_ETM_EVENT_ALARM_MATCH,
+    };
+    TEST_ESP_OK(gptimer_new_etm_event(gptimer, &gptimer_etm_event_conf, &gptimer_event));
     esp_etm_task_handle_t gptimer_task = NULL;
-    TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_EN_ALARM, &gptimer_task));
+    gptimer_etm_task_config_t gptimer_etm_task_conf = {
+        .task_type = GPTIMER_ETM_TASK_EN_ALARM,
+    };
+    TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, & gptimer_task));
 
     printf("connect event and task to the channel\r\n");
     TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event, gpio_task));
@@ -220,11 +229,18 @@ TEST_CASE("gptimer_auto_reload_by_etm", "[etm]")
 
     printf("get gptimer etm event and task handle\r\n");
     esp_etm_event_handle_t gptimer_event_alarm = NULL;
-    TEST_ESP_OK(gptimer_new_etm_event(gptimer, GPTIMER_ETM_EVENT_ALARM_MATCH, &gptimer_event_alarm));
+    gptimer_etm_event_config_t gptimer_etm_event_conf = {
+        .event_type = GPTIMER_ETM_EVENT_ALARM_MATCH,
+    };
+    TEST_ESP_OK(gptimer_new_etm_event(gptimer, &gptimer_etm_event_conf, &gptimer_event_alarm));
     esp_etm_task_handle_t gptimer_task_en_alarm = NULL;
-    TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_EN_ALARM, &gptimer_task_en_alarm));
+    gptimer_etm_task_config_t gptimer_etm_task_conf = {
+        .task_type = GPTIMER_ETM_TASK_EN_ALARM,
+    };
+    TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_en_alarm));
     esp_etm_task_handle_t gptimer_task_reload = NULL;
-    TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_RELOAD, &gptimer_task_reload));
+    gptimer_etm_task_conf.task_type = GPTIMER_ETM_TASK_RELOAD;
+    TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_reload));
 
     printf("connect event and task to the channel\r\n");
     TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event_alarm, gpio_task));
@@ -311,7 +327,10 @@ TEST_CASE("gptimer_etm_task_capture", "[etm]")
 
     printf("get gptimer etm task handle\r\n");
     esp_etm_task_handle_t gptimer_task = NULL;
-    TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_CAPTURE, &gptimer_task));
+    gptimer_etm_task_config_t gptimer_etm_task_conf = {
+        .task_type = GPTIMER_ETM_TASK_CAPTURE,
+    };
+    TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task));
 
     printf("connect event and task to the channel\r\n");
     TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gpio_event, gptimer_task));
@@ -393,8 +412,12 @@ TEST_CASE("gptimer_start_stop_by_etm_task", "[etm]")
 
     printf("get gptimer etm task handle\r\n");
     esp_etm_task_handle_t gptimer_task_start, gptimer_task_stop;
-    TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_START_COUNT, &gptimer_task_start));
-    TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_STOP_COUNT, &gptimer_task_stop));
+    gptimer_etm_task_config_t gptimer_etm_task_conf = {
+        .task_type = GPTIMER_ETM_TASK_START_COUNT,
+    };
+    TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_start));
+    gptimer_etm_task_conf.task_type = GPTIMER_ETM_TASK_STOP_COUNT;
+    TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_stop));
 
     printf("connect event and task to the channel\r\n");
     TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gpio_event_pos, gptimer_task_start));

examples/peripherals/timer_group/gptimer_capture_hc_sr04/main/gptimer_capture_hc_sr04.c

@@ -104,7 +104,10 @@ void app_main(void)
 
     ESP_LOGI(TAG, "Get gptimer etm task handle (capture)");
     esp_etm_task_handle_t gptimer_capture_task = NULL;
-    ESP_ERROR_CHECK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_CAPTURE, &gptimer_capture_task));
+    gptimer_etm_task_config_t gptimer_etm_task_conf = {
+        .task_type = GPTIMER_ETM_TASK_CAPTURE,
+    };
+    ESP_ERROR_CHECK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_capture_task));
 
     ESP_LOGI(TAG, "Create ETM channel then connect gpio event and gptimer task");
     esp_etm_channel_handle_t etm_chan = NULL;