Merge branch 'feature/parlio_driver' into 'master'

Parallel IO TX driver && LED Matrix example

Closes IDF-6607

See merge request espressif/esp-idf!22163

components/driver/.build-test-rules.yml

@@ -64,6 +64,10 @@ components/driver/test_apps/mcpwm:
   disable:
     - if: SOC_MCPWM_SUPPORTED != 1
 
+components/driver/test_apps/parlio:
+  disable:
+    - if: SOC_PARLIO_SUPPORTED != 1
+
 components/driver/test_apps/pulse_cnt:
   disable:
     - if: SOC_PCNT_SUPPORTED != 1

components/driver/CMakeLists.txt

@@ -17,6 +17,7 @@ set(includes "include"
              "i2s/include"
              "ledc/include"
              "mcpwm/include"
+             "parlio/include"
              "pcnt/include"
              "rmt/include"
              "sdio_slave/include"
@@ -49,6 +50,11 @@ if(CONFIG_SOC_DAC_SUPPORTED)
                      "deprecated/${target}/dac_legacy.c")
 endif()
 
+# Parallel IO related source files
+if(CONFIG_SOC_PARLIO_SUPPORTED)
+    list(APPEND srcs "parlio/parlio_common.c" "parlio/parlio_tx.c")
+endif()
+
 # GPIO related source files
 if(CONFIG_SOC_DEDICATED_GPIO_SUPPORTED)
     list(APPEND srcs "gpio/dedic_gpio.c")

components/driver/Kconfig

@@ -478,4 +478,24 @@ menu "Driver Configurations"
                 USB Serial/JTAG is in use.
     endmenu # USB Serial/JTAG Configuration
 
+    menu "Parallel IO Configuration"
+        depends on SOC_PARLIO_SUPPORTED
+
+        config PARLIO_ENABLE_DEBUG_LOG
+            bool "Enable debug log"
+            default n
+            help
+                Wether to enable the debug log message for parallel IO driver.
+                Note that, this option only controls the parallel IO driver log, won't affect other drivers.
+
+        config PARLIO_ISR_IRAM_SAFE
+            bool "Parallel IO ISR IRAM-Safe"
+            default n
+            select GDMA_CTRL_FUNC_IN_IRAM # the driver needs to start the GDMA in the interrupt
+            help
+                Ensure the Parallel IO interrupt is IRAM-Safe by allowing the interrupt handler to be
+                executable when the cache is disabled (e.g. SPI Flash write).
+
+    endmenu # Parallel IO Configuration
+
 endmenu  # Driver configurations

components/driver/gptimer/gptimer.c

@@ -87,7 +87,7 @@ static void gptimer_unregister_from_group(gptimer_t *timer)
     gptimer_release_group_handle(group);
 }
 
-static esp_err_t gptimer_destory(gptimer_t *timer)
+static esp_err_t gptimer_destroy(gptimer_t *timer)
 {
     if (timer->pm_lock) {
         ESP_RETURN_ON_ERROR(esp_pm_lock_delete(timer->pm_lock), TAG, "delete pm_lock failed");
@@ -145,7 +145,7 @@ esp_err_t gptimer_new_timer(const gptimer_config_t *config, gptimer_handle_t *re
 
 err:
     if (timer) {
-        gptimer_destory(timer);
+        gptimer_destroy(timer);
     }
     return ret;
 }
@@ -161,7 +161,7 @@ esp_err_t gptimer_del_timer(gptimer_handle_t timer)
     ESP_LOGD(TAG, "del timer (%d,%d)", group_id, timer_id);
     timer_hal_deinit(&timer->hal);
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(gptimer_destory(timer), TAG, "destory gptimer failed");
+    ESP_RETURN_ON_ERROR(gptimer_destroy(timer), TAG, "destroy gptimer failed");
 
     switch (clk_src) {
 #if SOC_TIMER_GROUP_SUPPORT_RC_FAST

components/driver/mcpwm/mcpwm_cap.c

@@ -66,7 +66,7 @@ static void mcpwm_cap_timer_unregister_from_group(mcpwm_cap_timer_t *cap_timer)
     mcpwm_release_group_handle(group);
 }
 
-static esp_err_t mcpwm_cap_timer_destory(mcpwm_cap_timer_t *cap_timer)
+static esp_err_t mcpwm_cap_timer_destroy(mcpwm_cap_timer_t *cap_timer)
 {
     if (cap_timer->pm_lock) {
         ESP_RETURN_ON_ERROR(esp_pm_lock_delete(cap_timer->pm_lock), TAG, "delete pm_lock failed");
@@ -124,7 +124,7 @@ esp_err_t mcpwm_new_capture_timer(const mcpwm_capture_timer_config_t *config, mc
 
 err:
     if (cap_timer) {
-        mcpwm_cap_timer_destory(cap_timer);
+        mcpwm_cap_timer_destroy(cap_timer);
     }
     return ret;
 }
@@ -140,7 +140,7 @@ esp_err_t mcpwm_del_capture_timer(mcpwm_cap_timer_handle_t cap_timer)
 
     ESP_LOGD(TAG, "del capture timer in group %d", group->group_id);
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_cap_timer_destory(cap_timer), TAG, "destory capture timer failed");
+    ESP_RETURN_ON_ERROR(mcpwm_cap_timer_destroy(cap_timer), TAG, "destroy capture timer failed");
     return ESP_OK;
 }
 
@@ -228,7 +228,7 @@ static void mcpwm_capture_channel_unregister_from_timer(mcpwm_cap_channel_t *cap
     portEXIT_CRITICAL(&cap_timer->spinlock);
 }
 
-static esp_err_t mcpwm_capture_channel_destory(mcpwm_cap_channel_t *cap_chan)
+static esp_err_t mcpwm_capture_channel_destroy(mcpwm_cap_channel_t *cap_chan)
 {
     if (cap_chan->intr) {
         ESP_RETURN_ON_ERROR(esp_intr_free(cap_chan->intr), TAG, "delete interrupt service failed");
@@ -282,7 +282,7 @@ esp_err_t mcpwm_new_capture_channel(mcpwm_cap_timer_handle_t cap_timer, const mc
     return ESP_OK;
 err:
     if (cap_chan) {
-        mcpwm_capture_channel_destory(cap_chan);
+        mcpwm_capture_channel_destroy(cap_chan);
     }
     return ret;
 }
@@ -307,7 +307,7 @@ esp_err_t mcpwm_del_capture_channel(mcpwm_cap_channel_handle_t cap_channel)
     portEXIT_CRITICAL(&group->spinlock);
 
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_capture_channel_destory(cap_channel), TAG, "destory capture channel failed");
+    ESP_RETURN_ON_ERROR(mcpwm_capture_channel_destroy(cap_channel), TAG, "destroy capture channel failed");
     return ESP_OK;
 }
 

components/driver/mcpwm/mcpwm_cmpr.c

@@ -58,7 +58,7 @@ static void mcpwm_comparator_unregister_from_operator(mcpwm_cmpr_t *cmpr)
     portEXIT_CRITICAL(&oper->spinlock);
 }
 
-static esp_err_t mcpwm_comparator_destory(mcpwm_cmpr_t *cmpr)
+static esp_err_t mcpwm_comparator_destroy(mcpwm_cmpr_t *cmpr)
 {
     if (cmpr->intr) {
         ESP_RETURN_ON_ERROR(esp_intr_free(cmpr->intr), TAG, "uninstall interrupt service failed");
@@ -97,7 +97,7 @@ esp_err_t mcpwm_new_comparator(mcpwm_oper_handle_t oper, const mcpwm_comparator_
 
 err:
     if (cmpr) {
-        mcpwm_comparator_destory(cmpr);
+        mcpwm_comparator_destroy(cmpr);
     }
     return ret;
 }
@@ -118,7 +118,7 @@ esp_err_t mcpwm_del_comparator(mcpwm_cmpr_handle_t cmpr)
 
     ESP_LOGD(TAG, "del comparator (%d,%d,%d)", group->group_id, oper_id, cmpr_id);
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_comparator_destory(cmpr), TAG, "destory comparator failed");
+    ESP_RETURN_ON_ERROR(mcpwm_comparator_destroy(cmpr), TAG, "destroy comparator failed");
     return ESP_OK;
 }
 

components/driver/mcpwm/mcpwm_fault.c

@@ -71,7 +71,7 @@ static void mcpwm_gpio_fault_unregister_from_group(mcpwm_gpio_fault_t *fault)
     mcpwm_release_group_handle(group);
 }
 
-static esp_err_t mcpwm_gpio_fault_destory(mcpwm_gpio_fault_t *fault)
+static esp_err_t mcpwm_gpio_fault_destroy(mcpwm_gpio_fault_t *fault)
 {
     if (fault->intr) {
         ESP_RETURN_ON_ERROR(esp_intr_free(fault->intr), TAG, "uninstall interrupt service failed");
@@ -133,7 +133,7 @@ esp_err_t mcpwm_new_gpio_fault(const mcpwm_gpio_fault_config_t *config, mcpwm_fa
 
 err:
     if (fault) {
-        mcpwm_gpio_fault_destory(fault);
+        mcpwm_gpio_fault_destroy(fault);
     }
     return ret;
 }
@@ -157,7 +157,7 @@ static esp_err_t mcpwm_del_gpio_fault(mcpwm_fault_handle_t fault)
     mcpwm_ll_fault_enable_detection(hal->dev, fault_id, false);
 
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_gpio_fault_destory(gpio_fault), TAG, "destory GPIO fault failed");
+    ESP_RETURN_ON_ERROR(mcpwm_gpio_fault_destroy(gpio_fault), TAG, "destroy GPIO fault failed");
     return ESP_OK;
 }
 

components/driver/mcpwm/mcpwm_gen.c

@@ -56,7 +56,7 @@ static void mcpwm_generator_unregister_from_operator(mcpwm_gen_t *gen)
     portEXIT_CRITICAL(&oper->spinlock);
 }
 
-static esp_err_t mcpwm_generator_destory(mcpwm_gen_t *gen)
+static esp_err_t mcpwm_generator_destroy(mcpwm_gen_t *gen)
 {
     if (gen->oper) {
         mcpwm_generator_unregister_from_operator(gen);
@@ -105,7 +105,7 @@ esp_err_t mcpwm_new_generator(mcpwm_oper_handle_t oper, const mcpwm_generator_co
 
 err:
     if (gen) {
-        mcpwm_generator_destory(gen);
+        mcpwm_generator_destroy(gen);
     }
     return ret;
 }
@@ -118,7 +118,7 @@ esp_err_t mcpwm_del_generator(mcpwm_gen_handle_t gen)
 
     ESP_LOGD(TAG, "del generator (%d,%d,%d)", group->group_id, oper->oper_id, gen->gen_id);
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_generator_destory(gen), TAG, "destory generator failed");
+    ESP_RETURN_ON_ERROR(mcpwm_generator_destroy(gen), TAG, "destroy generator failed");
     return ESP_OK;
 }
 

components/driver/mcpwm/mcpwm_oper.c

@@ -68,7 +68,7 @@ static void mcpwm_operator_unregister_from_group(mcpwm_oper_t *oper)
     mcpwm_release_group_handle(group);
 }
 
-static esp_err_t mcpwm_operator_destory(mcpwm_oper_t *oper)
+static esp_err_t mcpwm_operator_destroy(mcpwm_oper_t *oper)
 {
     if (oper->intr) {
         ESP_RETURN_ON_ERROR(esp_intr_free(oper->intr), TAG, "uninstall interrupt service failed");
@@ -123,7 +123,7 @@ esp_err_t mcpwm_new_operator(const mcpwm_operator_config_t *config, mcpwm_oper_h
 
 err:
     if (oper) {
-        mcpwm_operator_destory(oper);
+        mcpwm_operator_destroy(oper);
     }
     return ret;
 }
@@ -149,7 +149,7 @@ esp_err_t mcpwm_del_operator(mcpwm_oper_handle_t oper)
 
     ESP_LOGD(TAG, "del operator (%d,%d)", group->group_id, oper_id);
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_operator_destory(oper), TAG, "destory operator failed");
+    ESP_RETURN_ON_ERROR(mcpwm_operator_destroy(oper), TAG, "destroy operator failed");
     return ESP_OK;
 }
 

components/driver/mcpwm/mcpwm_sync.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -57,7 +57,7 @@ static void mcpwm_timer_sync_src_unregister_from_timer(mcpwm_timer_sync_src_t *t
     portEXIT_CRITICAL(&timer->spinlock);
 }
 
-static esp_err_t mcpwm_timer_sync_src_destory(mcpwm_timer_sync_src_t *timer_sync_src)
+static esp_err_t mcpwm_timer_sync_src_destroy(mcpwm_timer_sync_src_t *timer_sync_src)
 {
     if (timer_sync_src->timer) {
         mcpwm_timer_sync_src_unregister_from_timer(timer_sync_src);
@@ -104,7 +104,7 @@ esp_err_t mcpwm_new_timer_sync_src(mcpwm_timer_handle_t timer, const mcpwm_timer
 
 err:
     if (timer_sync_src) {
-        mcpwm_timer_sync_src_destory(timer_sync_src);
+        mcpwm_timer_sync_src_destroy(timer_sync_src);
     }
     return ret;
 }
@@ -118,7 +118,7 @@ static esp_err_t mcpwm_del_timer_sync_src(mcpwm_sync_t *sync_src)
 
     mcpwm_ll_timer_disable_sync_out(group->hal.dev, timer_id);
     ESP_LOGD(TAG, "del timer sync_src in timer (%d,%d)", group->group_id, timer_id);
-    ESP_RETURN_ON_ERROR(mcpwm_timer_sync_src_destory(timer_sync_src), TAG, "destory timer sync_src failed");
+    ESP_RETURN_ON_ERROR(mcpwm_timer_sync_src_destroy(timer_sync_src), TAG, "destroy timer sync_src failed");
     return ESP_OK;
 }
 
@@ -163,7 +163,7 @@ static void mcpwm_gpio_sync_src_unregister_from_group(mcpwm_gpio_sync_src_t *gpi
     mcpwm_release_group_handle(group);
 }
 
-static esp_err_t mcpwm_gpio_sync_src_destory(mcpwm_gpio_sync_src_t *gpio_sync_src)
+static esp_err_t mcpwm_gpio_sync_src_destroy(mcpwm_gpio_sync_src_t *gpio_sync_src)
 {
     if (gpio_sync_src->base.group) {
         mcpwm_gpio_sync_src_unregister_from_group(gpio_sync_src);
@@ -217,7 +217,7 @@ esp_err_t mcpwm_new_gpio_sync_src(const mcpwm_gpio_sync_src_config_t *config, mc
 
 err:
     if (gpio_sync_src) {
-        mcpwm_gpio_sync_src_destory(gpio_sync_src);
+        mcpwm_gpio_sync_src_destroy(gpio_sync_src);
     }
     return ret;
 }
@@ -231,7 +231,7 @@ static esp_err_t mcpwm_del_gpio_sync_src(mcpwm_sync_t *sync_src)
     gpio_reset_pin(gpio_sync_src->gpio_num);
 
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_gpio_sync_src_destory(gpio_sync_src), TAG, "destory GPIO sync_src failed");
+    ESP_RETURN_ON_ERROR(mcpwm_gpio_sync_src_destroy(gpio_sync_src), TAG, "destroy GPIO sync_src failed");
     return ESP_OK;
 }
 

components/driver/mcpwm/mcpwm_timer.c

@@ -69,7 +69,7 @@ static void mcpwm_timer_unregister_from_group(mcpwm_timer_t *timer)
     mcpwm_release_group_handle(group);
 }
 
-static esp_err_t mcpwm_timer_destory(mcpwm_timer_t *timer)
+static esp_err_t mcpwm_timer_destroy(mcpwm_timer_t *timer)
 {
     if (timer->intr) {
         ESP_RETURN_ON_ERROR(esp_intr_free(timer->intr), TAG, "uninstall interrupt service failed");
@@ -136,7 +136,7 @@ esp_err_t mcpwm_new_timer(const mcpwm_timer_config_t *config, mcpwm_timer_handle
 
 err:
     if (timer) {
-        mcpwm_timer_destory(timer);
+        mcpwm_timer_destroy(timer);
     }
     return ret;
 }
@@ -159,7 +159,7 @@ esp_err_t mcpwm_del_timer(mcpwm_timer_handle_t timer)
 
     ESP_LOGD(TAG, "del timer (%d,%d)", group->group_id, timer_id);
     // recycle memory resource
-    ESP_RETURN_ON_ERROR(mcpwm_timer_destory(timer), TAG, "destory timer failed");
+    ESP_RETURN_ON_ERROR(mcpwm_timer_destroy(timer), TAG, "destroy timer failed");
     return ESP_OK;
 }