Merge branch 'refactor/mcpwm_hal_driver_doc' into 'master'

mcpwm: don't support disable carrier one-shot pulse

Closes IDFGH-7406

See merge request espressif/esp-idf!18295

components/driver/Kconfig

@@ -1,6 +1,6 @@
-menu "Driver configurations"
+menu "Driver Configurations"
 
-    menu "ADC configuration"
+    menu "ADC Configuration"
 
         config ADC_FORCE_XPD_FSM
             bool "Use the FSM to control ADC power"
@@ -21,20 +21,7 @@ menu "Driver configurations"
 
     endmenu  # ADC Configuration
 
-    menu "MCPWM configuration"
-        depends on SOC_MCPWM_SUPPORTED
-        config MCPWM_ISR_IN_IRAM
-            bool "Place MCPWM ISR function into IRAM"
-            default n
-            help
-                If this option is not selected, the MCPWM interrupt will be deferred when the Cache
-                is in a disabled state (e.g. Flash write/erase operation).
-
-                Note that if this option is selected, all user registered ISR callbacks should never
-                try to use cache as well. (with IRAM_ATTR)
-    endmenu # MCPWM Configuration
-
-    menu "SPI configuration"
+    menu "SPI Configuration"
 
         config SPI_MASTER_IN_IRAM
             bool "Place transmitting functions of SPI master into IRAM"
@@ -84,7 +71,7 @@ menu "Driver configurations"
 
     endmenu # SPI Configuration
 
-    menu "TWAI configuration"
+    menu "TWAI Configuration"
         depends on SOC_TWAI_SUPPORTED
 
         config TWAI_ISR_IN_IRAM
@@ -166,7 +153,7 @@ menu "Driver configurations"
 
     endmenu # TEMP_SENSOR Configuration
 
-    menu "UART configuration"
+    menu "UART Configuration"
 
         config UART_ISR_IN_IRAM
             bool "Place UART ISR function into IRAM"
@@ -306,4 +293,16 @@ menu "Driver configurations"
                 Note that, this option only controls the RMT driver log, won't affect other drivers.
     endmenu # RMT Configuration
 
-endmenu  # Driver configurations
+    menu "MCPWM Configuration"
+        depends on SOC_MCPWM_SUPPORTED
+        config MCPWM_ISR_IRAM_SAFE
+            bool "Place MCPWM ISR function into IRAM"
+            default n
+            help
+                This will ensure the MCPWM interrupt handle is IRAM-Safe, allow to avoid flash
+                cache misses, and also be able to run whilst the cache is disabled.
+                (e.g. SPI Flash write)
+
+    endmenu # MCPWM Configuration
+
+endmenu  # Driver Configurations

components/driver/include/driver/mcpwm.h

@@ -6,11 +6,12 @@
 
 #pragma once
 
-#include "soc/soc_caps.h"
-#if SOC_MCPWM_SUPPORTED
+#include <stdbool.h>
+#include <stdint.h>
 #include "esp_err.h"
-#include "driver/gpio.h"
+#include "esp_bit_defs.h"
 #include "esp_intr_alloc.h"
+#include "soc/soc_caps.h"
 #include "hal/mcpwm_types.h"
 
 #ifdef __cplusplus
@@ -100,14 +101,6 @@ typedef enum {
 #define MCPWM_OPR_MAX   MCPWM_GEN_MAX       ///< @deprecated
 typedef mcpwm_generator_t mcpwm_operator_t; ///< @deprecated
 
-/**
- * @brief MCPWM carrier oneshot mode, in this mode the width of the first pulse of carrier can be programmed
- */
-typedef enum {
-    MCPWM_ONESHOT_MODE_DIS, /*!<Enable oneshot mode*/
-    MCPWM_ONESHOT_MODE_EN,  /*!<Disable oneshot mode*/
-} mcpwm_carrier_os_t;
-
 /**
  * @brief MCPWM carrier output inversion, high frequency carrier signal active with MCPWM signal is high
  */
@@ -138,7 +131,7 @@ typedef enum {
     MCPWM_SELECT_GPIO_SYNC2,      /*!<Select GPIO SYNC2 as input*/
 } mcpwm_sync_signal_t;
 
- // backward compatibility
+// backward compatibility
 #define MCPWM_SELCT_SYNC0 MCPWM_SELCT_GPIO_SYNC0
 #define MCPWM_SELCT_SYNC1 MCPWM_SELCT_GPIO_SYNC1
 #define MCPWM_SELCT_SYNC2 MCPWM_SELCT_GPIO_SYNC2
@@ -288,7 +281,6 @@ typedef struct {
     uint8_t carrier_period;                    /*!<Set carrier period = (carrier_period + 1)*800ns, carrier_period should be < 16*/
     uint8_t carrier_duty;                      /*!<Set carrier duty cycle, carrier_duty should be less than 8 (increment every 12.5%)*/
     uint8_t pulse_width_in_os;                 /*!<Set pulse width of first pulse in one shot mode = (carrier period)*(pulse_width_in_os + 1), should be less then 16*/
-    mcpwm_carrier_os_t carrier_os_mode;        /*!<Enable or disable carrier oneshot mode*/
     mcpwm_carrier_out_ivt_t carrier_ivt_mode;  /*!<Invert output of carrier*/
 } mcpwm_carrier_config_t;
 
@@ -449,14 +441,14 @@ esp_err_t mcpwm_set_duty_in_us(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num,
 esp_err_t mcpwm_set_duty_type(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, mcpwm_generator_t gen, mcpwm_duty_type_t duty_type);
 
 /**
-* @brief Get frequency of timer
-*
-* @param mcpwm_num set MCPWM unit(0-1)
-* @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
-*
-* @return
-*     - frequency of timer
-*/
+ * @brief Get frequency of timer
+ *
+ * @param mcpwm_num set MCPWM unit(0-1)
+ * @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
+ *
+ * @return
+ *     - frequency of timer
+ */
 uint32_t mcpwm_get_frequency(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num);
 
 /**
@@ -489,7 +481,7 @@ uint32_t mcpwm_get_duty_in_us(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, m
  * @param mcpwm_num set MCPWM unit(0-1)
  * @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
  * @param gen set the operator(MCPWMXA/MCPWMXB), 'x' is timer number selected
-
+ *
  *
  * @return
  *     - ESP_OK Success
@@ -503,7 +495,7 @@ esp_err_t mcpwm_set_signal_high(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num,
  * @param mcpwm_num set MCPWM unit(0-1)
  * @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
  * @param gen set the operator(MCPWMXA/MCPWMXB), 'x' is timer number selected
-
+ *
  *
  * @return
  *     - ESP_OK Success
@@ -549,15 +541,15 @@ esp_err_t mcpwm_stop(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num);
 esp_err_t mcpwm_carrier_init(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, const mcpwm_carrier_config_t *carrier_conf);
 
 /**
-* @brief Enable MCPWM carrier submodule, for respective timer
-*
-* @param mcpwm_num set MCPWM unit(0-1)
-* @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
-*
-* @return
-*     - ESP_OK Success
-*     - ESP_ERR_INVALID_ARG Parameter error
-*/
+ * @brief Enable MCPWM carrier submodule, for respective timer
+ *
+ * @param mcpwm_num set MCPWM unit(0-1)
+ * @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
+ *
+ * @return
+ *     - ESP_OK Success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
 esp_err_t mcpwm_carrier_enable(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num);
 
 /**
@@ -603,6 +595,8 @@ esp_err_t mcpwm_carrier_set_duty_cycle(mcpwm_unit_t mcpwm_num, mcpwm_timer_t tim
 /**
  * @brief Enable and set width of first pulse in carrier oneshot mode
  *
+ * @note The carrier oneshot pulse can't disabled.
+ *
  * @param mcpwm_num set MCPWM unit(0-1)
  * @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
  * @param pulse_width set pulse width of first pulse in oneshot mode, width = (carrier period)*(pulse_width +1)
@@ -614,18 +608,6 @@ esp_err_t mcpwm_carrier_set_duty_cycle(mcpwm_unit_t mcpwm_num, mcpwm_timer_t tim
  */
 esp_err_t mcpwm_carrier_oneshot_mode_enable(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, uint8_t pulse_width);
 
-/**
- * @brief Disable oneshot mode, width of first pulse = carrier period
- *
- * @param mcpwm_num set MCPWM unit(0-1)
- * @param timer_num set timer number(0-2) of MCPWM, each MCPWM unit has 3 timers
- *
- * @return
- *     - ESP_OK Success
- *     - ESP_ERR_INVALID_ARG Parameter error
- */
-esp_err_t mcpwm_carrier_oneshot_mode_disable(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num);
-
 /**
  * @brief Enable or disable carrier output inversion
  *
@@ -847,5 +829,3 @@ esp_err_t mcpwm_sync_invert_gpio_synchro(mcpwm_unit_t mcpwm_num, mcpwm_sync_sign
 #ifdef __cplusplus
 }
 #endif
-
-#endif  //SOC_MCPWM_SUPPORTED

components/driver/mcpwm.c

@@ -19,6 +19,7 @@
 #include "hal/mcpwm_hal.h"
 #include "hal/gpio_hal.h"
 #include "hal/mcpwm_ll.h"
+#include "driver/gpio.h"
 #include "driver/mcpwm.h"
 #include "esp_private/periph_ctrl.h"
 
@@ -36,16 +37,17 @@ static const char *TAG = "mcpwm";
 #define MCPWM_DT_ERROR          "MCPWM DEADTIME TYPE ERROR"
 #define MCPWM_CAP_EXIST_ERROR   "MCPWM USER CAP INT SERVICE ALREADY EXISTS"
 
-#ifdef CONFIG_MCPWM_ISR_IN_IRAM
+#ifdef CONFIG_MCPWM_ISR_IRAM_SAFE
 #define MCPWM_ISR_ATTR     IRAM_ATTR
-#define MCPWM_INTR_FLAG  (ESP_INTR_FLAG_IRAM)
+#define MCPWM_INTR_FLAG    ESP_INTR_FLAG_IRAM
 #else
 #define MCPWM_ISR_ATTR
 #define MCPWM_INTR_FLAG  0
 #endif
 
+#define MCPWM_GROUP_CLK_SRC_HZ 160000000
 #define MCPWM_GROUP_CLK_PRESCALE (16)
-#define MCPWM_GROUP_CLK_HZ (SOC_MCPWM_BASE_CLK_HZ / MCPWM_GROUP_CLK_PRESCALE)
+#define MCPWM_GROUP_CLK_HZ (MCPWM_GROUP_CLK_SRC_HZ / MCPWM_GROUP_CLK_PRESCALE)
 #define MCPWM_TIMER_CLK_HZ (MCPWM_GROUP_CLK_HZ / 10)
 
 _Static_assert(SOC_MCPWM_OPERATORS_PER_GROUP >= SOC_MCPWM_TIMERS_PER_GROUP, "This driver assumes the timer num equals to the operator num.");
@@ -87,26 +89,30 @@ typedef struct {
 } mcpwm_context_t;
 
 static mcpwm_context_t context[SOC_MCPWM_GROUPS] = {
-        [0] = {
-                .hal = {MCPWM_LL_GET_HW(0)},
-                .spinlock = portMUX_INITIALIZER_UNLOCKED,
-                .group_id = 0,
-                .group_pre_scale = SOC_MCPWM_BASE_CLK_HZ / MCPWM_GROUP_CLK_HZ,
-                .timer_pre_scale = {[0 ... SOC_MCPWM_TIMERS_PER_GROUP - 1] =
-                MCPWM_GROUP_CLK_HZ / MCPWM_TIMER_CLK_HZ},
-                .mcpwm_intr_handle = NULL,
-                .cap_isr_func = {[0 ... SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER - 1] = {NULL, NULL}},
+    [0] = {
+        .hal = {MCPWM_LL_GET_HW(0)},
+        .spinlock = portMUX_INITIALIZER_UNLOCKED,
+        .group_id = 0,
+        .group_pre_scale = MCPWM_GROUP_CLK_SRC_HZ / MCPWM_GROUP_CLK_HZ,
+        .timer_pre_scale = {
+            [0 ... SOC_MCPWM_TIMERS_PER_GROUP - 1] =
+            MCPWM_GROUP_CLK_HZ / MCPWM_TIMER_CLK_HZ
         },
-        [1] = {
-                .hal = {MCPWM_LL_GET_HW(1)},
-                .spinlock = portMUX_INITIALIZER_UNLOCKED,
-                .group_id = 1,
-                .group_pre_scale = SOC_MCPWM_BASE_CLK_HZ / MCPWM_GROUP_CLK_HZ,
-                .timer_pre_scale = {[0 ... SOC_MCPWM_TIMERS_PER_GROUP - 1] =
-                MCPWM_GROUP_CLK_HZ / MCPWM_TIMER_CLK_HZ},
-                .mcpwm_intr_handle = NULL,
-                .cap_isr_func = {[0 ... SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER - 1] = {NULL, NULL}},
-        }
+        .mcpwm_intr_handle = NULL,
+        .cap_isr_func = {[0 ... SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER - 1] = {NULL, NULL}},
+    },
+    [1] = {
+        .hal = {MCPWM_LL_GET_HW(1)},
+        .spinlock = portMUX_INITIALIZER_UNLOCKED,
+        .group_id = 1,
+        .group_pre_scale = MCPWM_GROUP_CLK_SRC_HZ / MCPWM_GROUP_CLK_HZ,
+        .timer_pre_scale = {
+            [0 ... SOC_MCPWM_TIMERS_PER_GROUP - 1] =
+            MCPWM_GROUP_CLK_HZ / MCPWM_TIMER_CLK_HZ
+        },
+        .mcpwm_intr_handle = NULL,
+        .cap_isr_func = {[0 ... SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER - 1] = {NULL, NULL}},
+    }
 };
 
 typedef void (*mcpwm_ll_gen_set_event_action_t)(mcpwm_dev_t *mcpwm, int op, int gen, int action);
@@ -121,11 +127,13 @@ static inline void mcpwm_critical_exit(mcpwm_unit_t mcpwm_num)
     portEXIT_CRITICAL(&context[mcpwm_num].spinlock);
 }
 
-static inline void mcpwm_mutex_lock(mcpwm_unit_t mcpwm_num){
+static inline void mcpwm_mutex_lock(mcpwm_unit_t mcpwm_num)
+{
     _lock_acquire(&context[mcpwm_num].mutex_lock);
 }
 
-static inline void mcpwm_mutex_unlock(mcpwm_unit_t mcpwm_num){
+static inline void mcpwm_mutex_unlock(mcpwm_unit_t mcpwm_num)
+{
     _lock_release(&context[mcpwm_num].mutex_lock);
 }
 
@@ -187,7 +195,7 @@ esp_err_t mcpwm_start(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num)
     MCPWM_TIMER_CHECK(mcpwm_num, timer_num);
 
     mcpwm_critical_enter(mcpwm_num);
-    mcpwm_ll_timer_set_execute_command(context[mcpwm_num].hal.dev, timer_num, MCPWM_TIMER_START_NO_STOP);
+    mcpwm_ll_timer_set_start_stop_command(context[mcpwm_num].hal.dev, timer_num, MCPWM_TIMER_START_NO_STOP);
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;
 }
@@ -197,14 +205,15 @@ esp_err_t mcpwm_stop(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num)
     MCPWM_TIMER_CHECK(mcpwm_num, timer_num);
 
     mcpwm_critical_enter(mcpwm_num);
-    mcpwm_ll_timer_set_execute_command(context[mcpwm_num].hal.dev, timer_num, MCPWM_TIMER_STOP_AT_ZERO);
+    mcpwm_ll_timer_set_start_stop_command(context[mcpwm_num].hal.dev, timer_num, MCPWM_TIMER_STOP_EMPTY);
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;
 }
 
-esp_err_t mcpwm_group_set_resolution(mcpwm_unit_t mcpwm_num, unsigned long int resolution) {
+esp_err_t mcpwm_group_set_resolution(mcpwm_unit_t mcpwm_num, unsigned long int resolution)
+{
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
-    int pre_scale_temp = SOC_MCPWM_BASE_CLK_HZ / resolution;
+    int pre_scale_temp = MCPWM_GROUP_CLK_SRC_HZ / resolution;
     ESP_RETURN_ON_FALSE(pre_scale_temp >= 1, ESP_ERR_INVALID_ARG, TAG, "invalid resolution");
     context[mcpwm_num].group_pre_scale = pre_scale_temp;
     mcpwm_critical_enter(mcpwm_num);
@@ -213,11 +222,12 @@ esp_err_t mcpwm_group_set_resolution(mcpwm_unit_t mcpwm_num, unsigned long int r
     return ESP_OK;
 }
 
-esp_err_t mcpwm_timer_set_resolution(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, unsigned long int resolution) {
+esp_err_t mcpwm_timer_set_resolution(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, unsigned long int resolution)
+{
     MCPWM_TIMER_CHECK(mcpwm_num, timer_num);
 
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
-    int pre_scale_temp = SOC_MCPWM_BASE_CLK_HZ / context[mcpwm_num].group_pre_scale / resolution;
+    int pre_scale_temp = MCPWM_GROUP_CLK_SRC_HZ / context[mcpwm_num].group_pre_scale / resolution;
     ESP_RETURN_ON_FALSE(pre_scale_temp >= 1, ESP_ERR_INVALID_ARG, TAG, "invalid resolution");
     context[mcpwm_num].timer_pre_scale[timer_num] = pre_scale_temp;
     mcpwm_critical_enter(mcpwm_num);
@@ -239,7 +249,7 @@ esp_err_t mcpwm_set_frequency(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, u
     uint32_t previous_peak = mcpwm_ll_timer_get_peak(hal->dev, timer_num, false);
     int real_group_prescale = mcpwm_ll_group_get_clock_prescale(hal->dev);
     unsigned long int real_timer_clk_hz =
-            SOC_MCPWM_BASE_CLK_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
+        MCPWM_GROUP_CLK_SRC_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
     uint32_t new_peak = real_timer_clk_hz / frequency;
     mcpwm_ll_timer_set_peak(hal->dev, timer_num, new_peak, false);
     // keep the duty cycle unchanged
@@ -286,7 +296,7 @@ esp_err_t mcpwm_set_duty_in_us(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num,
     mcpwm_critical_enter(mcpwm_num);
     int real_group_prescale = mcpwm_ll_group_get_clock_prescale(hal->dev);
     unsigned long int real_timer_clk_hz =
-            SOC_MCPWM_BASE_CLK_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
+        MCPWM_GROUP_CLK_SRC_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
     mcpwm_ll_operator_set_compare_value(hal->dev, op, cmp, duty_in_us * real_timer_clk_hz / 1000000);
     mcpwm_ll_operator_enable_update_compare_on_tez(hal->dev, op, cmp, true);
     mcpwm_critical_exit(mcpwm_num);
@@ -307,63 +317,63 @@ esp_err_t mcpwm_set_duty_type(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, m
     switch (mcpwm_ll_timer_get_count_mode(hal->dev, timer_num)) {
     case MCPWM_TIMER_COUNT_MODE_UP:
         if (duty_type == MCPWM_DUTY_MODE_0) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_GEN_ACTION_HIGH);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_PEAK, MCPWM_GEN_ACTION_KEEP);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_GEN_ACTION_KEEP);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_LOW);
         } else if (duty_type == MCPWM_DUTY_MODE_1) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_GEN_ACTION_LOW);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_NO_CHANGE);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_GEN_ACTION_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_NO_CHANGE);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_HIGH);
         } else if (duty_type == MCPWM_HAL_GENERATOR_MODE_FORCE_LOW) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_LOW);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_LOW);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_LOW);
         } else if (duty_type == MCPWM_HAL_GENERATOR_MODE_FORCE_HIGH) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_HIGH);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_HIGH);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_HIGH);
         }
         break;
     case MCPWM_TIMER_COUNT_MODE_DOWN:
         if (duty_type == MCPWM_DUTY_MODE_0) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_LOW);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_NO_CHANGE);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_NO_CHANGE);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_HIGH);
         } else if (duty_type == MCPWM_DUTY_MODE_1) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_HIGH);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_NO_CHANGE);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_NO_CHANGE);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_LOW);
         } else if (duty_type == MCPWM_HAL_GENERATOR_MODE_FORCE_LOW) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_LOW);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_LOW);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_LOW);
         } else if (duty_type == MCPWM_HAL_GENERATOR_MODE_FORCE_HIGH) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_HIGH);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_HIGH);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_HIGH);
         }
         break;
     case MCPWM_TIMER_COUNT_MODE_UP_DOWN:
         if (duty_type == MCPWM_DUTY_MODE_0) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_HIGH);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_LOW);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_HIGH);
         } else if (duty_type == MCPWM_DUTY_MODE_1) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_LOW);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_HIGH);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_LOW);
         } else if (duty_type == MCPWM_HAL_GENERATOR_MODE_FORCE_LOW) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_LOW);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_LOW);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_LOW);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_LOW);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_LOW);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_LOW);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_LOW);
         } else if (duty_type == MCPWM_HAL_GENERATOR_MODE_FORCE_HIGH) {
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_HIGH);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_HIGH);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_ZERO, MCPWM_ACTION_FORCE_HIGH);
-            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_PEAK, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_EMPTY, MCPWM_ACTION_FORCE_HIGH);
+            mcpwm_ll_generator_set_action_on_timer_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, MCPWM_TIMER_EVENT_FULL, MCPWM_ACTION_FORCE_HIGH);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_DOWN, gen, MCPWM_ACTION_FORCE_HIGH);
             mcpwm_ll_generator_set_action_on_compare_event(hal->dev, op, gen, MCPWM_TIMER_DIRECTION_UP, gen, MCPWM_ACTION_FORCE_HIGH);
         }
@@ -382,22 +392,20 @@ esp_err_t mcpwm_init(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, const mcpw
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
     periph_module_enable(mcpwm_periph_signals.groups[mcpwm_num].module);
     mcpwm_hal_init_config_t config = {
-        .host_id = mcpwm_num
+        .group_id = mcpwm_num
     };
     mcpwm_hal_init(hal, &config);
 
     mcpwm_critical_enter(mcpwm_num);
     mcpwm_ll_group_set_clock_prescale(hal->dev, context[mcpwm_num].group_pre_scale);
-    mcpwm_ll_group_enable_shadow_mode(hal->dev);
-    mcpwm_ll_group_flush_shadow(hal->dev);
     mcpwm_ll_timer_set_clock_prescale(hal->dev, timer_num, context[mcpwm_num].timer_pre_scale[timer_num]);
     mcpwm_ll_timer_set_count_mode(hal->dev, timer_num, mcpwm_conf->counter_mode);
     mcpwm_ll_timer_update_period_at_once(hal->dev, timer_num);
     int real_group_prescale = mcpwm_ll_group_get_clock_prescale(hal->dev);
     unsigned long int real_timer_clk_hz =
-            SOC_MCPWM_BASE_CLK_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
+        MCPWM_GROUP_CLK_SRC_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
     mcpwm_ll_timer_set_peak(hal->dev, timer_num, real_timer_clk_hz / mcpwm_conf->frequency, false);
-    mcpwm_ll_operator_select_timer(hal->dev, timer_num, timer_num); //the driver currently always use the timer x for operator x
+    mcpwm_ll_operator_connect_timer(hal->dev, timer_num, timer_num); //the driver currently always use the timer x for operator x
     mcpwm_critical_exit(mcpwm_num);
 
     mcpwm_set_duty(mcpwm_num, timer_num, 0, mcpwm_conf->cmpr_a);
@@ -416,7 +424,7 @@ uint32_t mcpwm_get_frequency(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num)
     mcpwm_critical_enter(mcpwm_num);
     int real_group_prescale = mcpwm_ll_group_get_clock_prescale(hal->dev);
     unsigned long int real_timer_clk_hz =
-            SOC_MCPWM_BASE_CLK_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
+        MCPWM_GROUP_CLK_SRC_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
     uint32_t peak = mcpwm_ll_timer_get_peak(hal->dev, timer_num, false);
     uint32_t freq = real_timer_clk_hz / peak;
     mcpwm_critical_exit(mcpwm_num);
@@ -435,7 +443,8 @@ float mcpwm_get_duty(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, mcpwm_gene
     return duty;
 }
 
-uint32_t mcpwm_get_duty_in_us(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, mcpwm_operator_t gen){
+uint32_t mcpwm_get_duty_in_us(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, mcpwm_operator_t gen)
+{
     //the driver currently always use the timer x for operator x
     const int op = timer_num;
     MCPWM_GEN_CHECK(mcpwm_num, timer_num, gen);
@@ -443,7 +452,7 @@ uint32_t mcpwm_get_duty_in_us(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, m
     mcpwm_critical_enter(mcpwm_num);
     int real_group_prescale = mcpwm_ll_group_get_clock_prescale(hal->dev);
     unsigned long int real_timer_clk_hz =
-            SOC_MCPWM_BASE_CLK_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
+        MCPWM_GROUP_CLK_SRC_HZ / real_group_prescale / mcpwm_ll_timer_get_clock_prescale(hal->dev, timer_num);
     uint32_t duty = mcpwm_ll_operator_get_compare_value(hal->dev, op, gen) * (1000000.0 / real_timer_clk_hz);
     mcpwm_critical_exit(mcpwm_num);
     return duty;
@@ -516,16 +525,11 @@ esp_err_t mcpwm_carrier_oneshot_mode_enable(mcpwm_unit_t mcpwm_num, mcpwm_timer_
     MCPWM_TIMER_CHECK(mcpwm_num, timer_num);
 
     mcpwm_critical_enter(mcpwm_num);
-    mcpwm_ll_carrier_set_oneshot_width(context[mcpwm_num].hal.dev, op, pulse_width + 1);
+    mcpwm_ll_carrier_set_first_pulse_width(context[mcpwm_num].hal.dev, op, pulse_width + 1);
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;
 }
 
-esp_err_t mcpwm_carrier_oneshot_mode_disable(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num)
-{
-    return mcpwm_carrier_oneshot_mode_enable(mcpwm_num, timer_num, 0);
-}
-
 esp_err_t mcpwm_carrier_output_invert(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num,
                                       mcpwm_carrier_out_ivt_t carrier_ivt_mode)
 {
@@ -549,11 +553,7 @@ esp_err_t mcpwm_carrier_init(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, co
     mcpwm_carrier_enable(mcpwm_num, timer_num);
     mcpwm_carrier_set_period(mcpwm_num, timer_num, carrier_conf->carrier_period);
     mcpwm_carrier_set_duty_cycle(mcpwm_num, timer_num, carrier_conf->carrier_duty);
-    if (carrier_conf->carrier_os_mode == MCPWM_ONESHOT_MODE_EN) {
-        mcpwm_carrier_oneshot_mode_enable(mcpwm_num, timer_num, carrier_conf->pulse_width_in_os);
-    } else {
-        mcpwm_carrier_oneshot_mode_disable(mcpwm_num, timer_num);
-    }
+    mcpwm_carrier_oneshot_mode_enable(mcpwm_num, timer_num, carrier_conf->pulse_width_in_os);
     mcpwm_carrier_output_invert(mcpwm_num, timer_num, carrier_conf->carrier_ivt_mode);
 
     mcpwm_critical_enter(mcpwm_num);
@@ -575,7 +575,7 @@ esp_err_t mcpwm_deadtime_enable(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num,
     mcpwm_critical_enter(mcpwm_num);
     mcpwm_ll_deadtime_enable_update_delay_on_tez(hal->dev, op, true);
     // The dead time delay unit equals to MCPWM group resolution
-    mcpwm_ll_deadtime_resolution_to_timer(hal->dev, op, false);
+    mcpwm_ll_operator_set_deadtime_clock_src(hal->dev, op, MCPWM_LL_DEADTIME_CLK_SRC_GROUP);
     mcpwm_ll_deadtime_set_rising_delay(hal->dev, op, red + 1);
     mcpwm_ll_deadtime_set_falling_delay(hal->dev, op, fed + 1);
     switch (dt_mode) {
@@ -691,7 +691,7 @@ esp_err_t mcpwm_fault_deinit(mcpwm_unit_t mcpwm_num, mcpwm_fault_signal_t fault_
     mcpwm_critical_enter(mcpwm_num);
     mcpwm_ll_fault_enable_detection(hal->dev, fault_sig, false);
     for (int i = 0; i < SOC_MCPWM_OPERATORS_PER_GROUP; i++) {
-        mcpwm_ll_fault_clear_ost(hal->dev, i); // make sure operator has exit the ost fault state totally
+        mcpwm_ll_brake_clear_ost(hal->dev, i); // make sure operator has exit the ost fault state totally
     }
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;
@@ -706,13 +706,13 @@ esp_err_t mcpwm_fault_set_cyc_mode(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_n
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
 
     mcpwm_critical_enter(mcpwm_num);
-    mcpwm_ll_fault_enable_cbc_mode(hal->dev, op, fault_sig, true);
-    mcpwm_ll_fault_enable_cbc_refresh_on_tez(hal->dev, op, true);
-    mcpwm_ll_fault_enable_oneshot_mode(hal->dev, op, fault_sig, false);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TRIP_TYPE_CBC, action_on_pwmxa);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_UP, MCPWM_TRIP_TYPE_CBC, action_on_pwmxa);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TRIP_TYPE_CBC, action_on_pwmxb);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_UP, MCPWM_TRIP_TYPE_CBC, action_on_pwmxb);
+    mcpwm_ll_brake_enable_cbc_mode(hal->dev, op, fault_sig, true);
+    mcpwm_ll_brake_enable_cbc_refresh_on_tez(hal->dev, op, true);
+    mcpwm_ll_brake_enable_oneshot_mode(hal->dev, op, fault_sig, false);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_OPER_BRAKE_MODE_CBC, action_on_pwmxa);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_CBC, action_on_pwmxa);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_OPER_BRAKE_MODE_CBC, action_on_pwmxb);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_CBC, action_on_pwmxb);
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;
 }
@@ -726,18 +726,19 @@ esp_err_t mcpwm_fault_set_oneshot_mode(mcpwm_unit_t mcpwm_num, mcpwm_timer_t tim
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
 
     mcpwm_critical_enter(mcpwm_num);
-    mcpwm_ll_fault_clear_ost(hal->dev, op);
-    mcpwm_ll_fault_enable_oneshot_mode(hal->dev, op, fault_sig, true);
-    mcpwm_ll_fault_enable_cbc_mode(hal->dev, op, fault_sig, false);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TRIP_TYPE_OST, action_on_pwmxa);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_UP, MCPWM_TRIP_TYPE_OST, action_on_pwmxa);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_TRIP_TYPE_OST, action_on_pwmxb);
-    mcpwm_ll_generator_set_action_on_trip_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_UP, MCPWM_TRIP_TYPE_OST, action_on_pwmxb);
+    mcpwm_ll_brake_clear_ost(hal->dev, op);
+    mcpwm_ll_brake_enable_oneshot_mode(hal->dev, op, fault_sig, true);
+    mcpwm_ll_brake_enable_cbc_mode(hal->dev, op, fault_sig, false);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_OPER_BRAKE_MODE_OST, action_on_pwmxa);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 0, MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_OST, action_on_pwmxa);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_DOWN, MCPWM_OPER_BRAKE_MODE_OST, action_on_pwmxb);
+    mcpwm_ll_generator_set_action_on_brake_event(hal->dev, op, 1, MCPWM_TIMER_DIRECTION_UP, MCPWM_OPER_BRAKE_MODE_OST, action_on_pwmxb);
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;
 }
 
-static void MCPWM_ISR_ATTR mcpwm_default_isr_handler(void *arg) {
+static void MCPWM_ISR_ATTR mcpwm_default_isr_handler(void *arg)
+{
     mcpwm_context_t *curr_context = (mcpwm_context_t *) arg;
     uint32_t intr_status = mcpwm_ll_intr_get_capture_status(curr_context->hal.dev);
     mcpwm_ll_intr_clear_capture_status(curr_context->hal.dev, intr_status);
@@ -746,11 +747,11 @@ static void MCPWM_ISR_ATTR mcpwm_default_isr_handler(void *arg) {
         if ((intr_status >> i) & 0x1) {
             if (curr_context->cap_isr_func[i].fn != NULL) {
                 cap_event_data_t edata;
-                edata.cap_edge = mcpwm_ll_capture_is_negedge(curr_context->hal.dev, i) ? MCPWM_NEG_EDGE
-                                                                                       : MCPWM_POS_EDGE;
+                edata.cap_edge = mcpwm_ll_capture_get_edge(curr_context->hal.dev, i) == MCPWM_CAP_EDGE_NEG ? MCPWM_NEG_EDGE
+                                 : MCPWM_POS_EDGE;
                 edata.cap_value = mcpwm_ll_capture_get_value(curr_context->hal.dev, i);
                 if (curr_context->cap_isr_func[i].fn(curr_context->group_id, i, &edata,
-                                                      curr_context->cap_isr_func[i].args)) {
+                                                     curr_context->cap_isr_func[i].args)) {
                     need_yield = true;
                 }
             }
@@ -773,7 +774,7 @@ esp_err_t mcpwm_capture_enable_channel(mcpwm_unit_t mcpwm_num, mcpwm_capture_cha
     periph_module_enable(mcpwm_periph_signals.groups[mcpwm_num].module);
 
     mcpwm_hal_init_config_t init_config = {
-            .host_id = mcpwm_num
+        .group_id = mcpwm_num
     };
     mcpwm_hal_init(hal, &init_config);
     mcpwm_critical_enter(mcpwm_num);
@@ -784,7 +785,7 @@ esp_err_t mcpwm_capture_enable_channel(mcpwm_unit_t mcpwm_num, mcpwm_capture_cha
     mcpwm_ll_capture_enable_posedge(hal->dev, cap_channel, cap_conf->cap_edge & MCPWM_POS_EDGE);
     mcpwm_ll_capture_set_prescale(hal->dev, cap_channel, cap_conf->cap_prescale);
     // capture feature should be used with interupt, so enable it by default
-    mcpwm_ll_intr_enable_capture(hal->dev, cap_channel, true);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_CAPTURE(cap_channel), true);
     mcpwm_ll_intr_clear_capture_status(hal->dev, 1 << cap_channel);
     mcpwm_critical_exit(mcpwm_num);
 
@@ -794,8 +795,8 @@ esp_err_t mcpwm_capture_enable_channel(mcpwm_unit_t mcpwm_num, mcpwm_capture_cha
     esp_err_t ret = ESP_OK;
     if (context[mcpwm_num].mcpwm_intr_handle == NULL) {
         ret = esp_intr_alloc(mcpwm_periph_signals.groups[mcpwm_num].irq_id, MCPWM_INTR_FLAG,
-                              mcpwm_default_isr_handler,
-                              (void *) (context + mcpwm_num), &(context[mcpwm_num].mcpwm_intr_handle));
+                             mcpwm_default_isr_handler,
+                             (void *) (context + mcpwm_num), &(context[mcpwm_num].mcpwm_intr_handle));
     }
     mcpwm_mutex_unlock(mcpwm_num);
 
@@ -811,7 +812,7 @@ esp_err_t mcpwm_capture_disable_channel(mcpwm_unit_t mcpwm_num, mcpwm_capture_ch
 
     mcpwm_critical_enter(mcpwm_num);
     mcpwm_ll_capture_enable_channel(hal->dev, cap_channel, false);
-    mcpwm_ll_intr_enable_capture(hal->dev, cap_channel, false);
+    mcpwm_ll_intr_enable(hal->dev, MCPWM_LL_EVENT_CAPTURE(cap_channel), false);
     mcpwm_critical_exit(mcpwm_num);
 
     mcpwm_mutex_lock(mcpwm_num);
@@ -828,7 +829,7 @@ esp_err_t mcpwm_capture_disable_channel(mcpwm_unit_t mcpwm_num, mcpwm_capture_ch
     esp_err_t ret = ESP_OK;
     if (should_free_handle) {
         ret = esp_intr_free(context[mcpwm_num].mcpwm_intr_handle);
-        if (ret != ESP_OK){
+        if (ret != ESP_OK) {
             ESP_LOGE(TAG, "failed to free interrupt handle");
         }
         context[mcpwm_num].mcpwm_intr_handle = NULL;
@@ -853,7 +854,7 @@ uint32_t MCPWM_ISR_ATTR mcpwm_capture_signal_get_edge(mcpwm_unit_t mcpwm_num, mc
     ESP_RETURN_ON_FALSE(mcpwm_num < SOC_MCPWM_GROUPS, ESP_ERR_INVALID_ARG, TAG, MCPWM_GROUP_NUM_ERROR);
     ESP_RETURN_ON_FALSE(cap_sig < SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER, ESP_ERR_INVALID_ARG, TAG, MCPWM_CAPTURE_ERROR);
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
-    return mcpwm_ll_capture_is_negedge(hal->dev, cap_sig) ? 2 : 1;
+    return mcpwm_ll_capture_get_edge(hal->dev, cap_sig) == MCPWM_CAP_EDGE_NEG ? 2 : 1;
 }
 
 esp_err_t mcpwm_sync_configure(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num, const mcpwm_sync_config_t *sync_conf)
@@ -868,12 +869,12 @@ esp_err_t mcpwm_sync_configure(mcpwm_unit_t mcpwm_num, mcpwm_timer_t timer_num,
     uint32_t set_phase = 0;
     set_phase = mcpwm_ll_timer_get_peak(hal->dev, timer_num, false) * sync_conf->timer_val / 1000;
     mcpwm_ll_timer_set_sync_phase_value(hal->dev, timer_num, set_phase);
-    if (sync_conf->sync_sig == MCPWM_SELECT_NO_INPUT){
-        mcpwm_ll_timer_set_soft_synchro(hal->dev, timer_num);
+    if (sync_conf->sync_sig == MCPWM_SELECT_NO_INPUT) {
+        mcpwm_ll_timer_clear_sync_input(hal->dev, timer_num);
     } else if (sync_conf->sync_sig <= MCPWM_SELECT_TIMER2_SYNC) {
-        mcpwm_ll_timer_set_timer_synchro(hal->dev, timer_num, sync_conf->sync_sig - MCPWM_SELECT_TIMER0_SYNC);
+        mcpwm_ll_timer_set_timer_sync_input(hal->dev, timer_num, sync_conf->sync_sig - MCPWM_SELECT_TIMER0_SYNC);
     } else {
-        mcpwm_ll_timer_set_gpio_synchro(hal->dev, timer_num, sync_conf->sync_sig - MCPWM_SELECT_GPIO_SYNC0);
+        mcpwm_ll_timer_set_gpio_sync_input(hal->dev, timer_num, sync_conf->sync_sig - MCPWM_SELECT_GPIO_SYNC0);
     }
     mcpwm_ll_timer_enable_sync_input(hal->dev, timer_num, true);
     mcpwm_critical_exit(mcpwm_num);
@@ -903,13 +904,14 @@ esp_err_t mcpwm_timer_trigger_soft_sync(mcpwm_unit_t mcpwm_num, mcpwm_timer_t ti
     return ESP_OK;
 }
 
-esp_err_t mcpwm_sync_invert_gpio_synchro(mcpwm_unit_t mcpwm_num, mcpwm_sync_signal_t sync_sig, bool invert){
+esp_err_t mcpwm_sync_invert_gpio_synchro(mcpwm_unit_t mcpwm_num, mcpwm_sync_signal_t sync_sig, bool invert)
+{
     ESP_RETURN_ON_FALSE(sync_sig >= MCPWM_SELECT_GPIO_SYNC0 && sync_sig <= MCPWM_SELECT_GPIO_SYNC2,
                         ESP_ERR_INVALID_ARG, TAG, "invalid sync sig");
 
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
     mcpwm_critical_enter(mcpwm_num);
-    mcpwm_ll_invert_gpio_synchro(hal->dev, sync_sig - MCPWM_SELECT_GPIO_SYNC0, invert);
+    mcpwm_ll_invert_gpio_sync_input(hal->dev, sync_sig - MCPWM_SELECT_GPIO_SYNC0, invert);
     mcpwm_critical_exit(mcpwm_num);
 
     return ESP_OK;
@@ -922,19 +924,19 @@ esp_err_t mcpwm_set_timer_sync_output(mcpwm_unit_t mcpwm_num, mcpwm_timer_t time
     mcpwm_hal_context_t *hal = &context[mcpwm_num].hal;
     mcpwm_critical_enter(mcpwm_num);
     switch (trigger) {
-        case MCPWM_SWSYNC_SOURCE_SYNCIN:
-            mcpwm_ll_timer_sync_out_penetrate(hal->dev, timer_num);
-            break;
-        case MCPWM_SWSYNC_SOURCE_TEZ:
-            mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_num, MCPWM_TIMER_EVENT_ZERO);
-            break;
-        case MCPWM_SWSYNC_SOURCE_TEP:
-            mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_num, MCPWM_TIMER_EVENT_PEAK);
-            break;
-        case MCPWM_SWSYNC_SOURCE_DISABLED:
-        default:
-            mcpwm_ll_timer_disable_sync_out(hal->dev, timer_num);
-            break;
+    case MCPWM_SWSYNC_SOURCE_SYNCIN:
+        mcpwm_ll_timer_propagate_input_sync(hal->dev, timer_num);
+        break;
+    case MCPWM_SWSYNC_SOURCE_TEZ:
+        mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_num, MCPWM_TIMER_EVENT_EMPTY);
+        break;
+    case MCPWM_SWSYNC_SOURCE_TEP:
+        mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_num, MCPWM_TIMER_EVENT_FULL);
+        break;
+    case MCPWM_SWSYNC_SOURCE_DISABLED:
+    default:
+        mcpwm_ll_timer_disable_sync_out(hal->dev, timer_num);
+        break;
     }
     mcpwm_critical_exit(mcpwm_num);
     return ESP_OK;

components/driver/sdkconfig.rename

@@ -2,3 +2,4 @@
 # CONFIG_DEPRECATED_OPTION CONFIG_NEW_OPTION
 
 CONFIG_ADC2_DISABLE_DAC     CONFIG_ADC_DISABLE_DAC
+CONFIG_MCPWM_ISR_IN_IRAM    CONFIG_MCPWM_ISR_IRAM_SAFE

components/driver/test/test_pwm.c

@@ -6,7 +6,6 @@
 #include <stdio.h>
 #include <unistd.h>
 #include "unity.h"
-#include "test_utils.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "soc/soc_caps.h"
@@ -27,7 +26,8 @@
 #define TEST_SYNC_GPIO_2 (19)
 #define TEST_CAP_GPIO (21)
 
-#define MCPWM_TEST_GROUP_CLK_HZ (SOC_MCPWM_BASE_CLK_HZ / 16)
+#define MCPWM_GROUP_CLK_SRC_HZ  160000000
+#define MCPWM_TEST_GROUP_CLK_HZ (MCPWM_GROUP_CLK_SRC_HZ / 16)
 #define MCPWM_TEST_TIMER_CLK_HZ (MCPWM_TEST_GROUP_CLK_HZ / 10)
 
 const static mcpwm_io_signals_t pwma[] = {MCPWM0A, MCPWM1A, MCPWM2A};

components/hal/include/hal/mcpwm_hal.h

@@ -1,16 +1,8 @@
-// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 /*******************************************************************************
  * NOTICE
@@ -18,18 +10,28 @@
  * See readme.md in hal/include/hal/readme.md
  ******************************************************************************/
 
-// The HAL layer for MCPWM (common part)
-
 #pragma once
 
-#include "soc/mcpwm_struct.h"
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
+typedef struct mcpwm_dev_t *mcpwm_soc_handle_t; // MCPWM SOC layer handle
+
+/**
+ * @brief HAL layer configuration
+ */
 typedef struct {
-    int host_id; ///< Which MCPWM peripheral to use, 0-1.
+    int group_id; // Indicate the MCPWM hardware group
 } mcpwm_hal_init_config_t;
 
+/**
+ * Context that should be maintained by both the driver and the HAL
+ */
 typedef struct {
-    mcpwm_dev_t *dev; ///< Beginning address of the peripheral registers of a single MCPWM unit. Call `mcpwm_hal_init` to initialize it.
+    mcpwm_soc_handle_t dev; // MCPWM SOC layer handle
 } mcpwm_hal_context_t;
 
 /**
@@ -39,3 +41,39 @@ typedef struct {
  * @param init_config Configuration for the HAL to be used only once.
  */
 void mcpwm_hal_init(mcpwm_hal_context_t *hal, const mcpwm_hal_init_config_t *init_config);
+
+/**
+ * @brief Deinitialize the HAL driver.
+ *
+ * @param hal Context of the HAL layer.
+ */
+void mcpwm_hal_deinit(mcpwm_hal_context_t *hal);
+
+/**
+ * @brief Reset MCPWM timer
+ *
+ * @param hal Context of the HAL layer.
+ * @param timer_id Timer ID
+ */
+void mcpwm_hal_timer_reset(mcpwm_hal_context_t *hal, int timer_id);
+
+/**
+ * @brief Reset MCPWM operator
+ *
+ * @param hal Context of the HAL layer.
+ * @param oper_id Operator ID
+ */
+void mcpwm_hal_operator_reset(mcpwm_hal_context_t *hal, int oper_id);
+
+/**
+ * @brief Reset MCPWM generator
+ *
+ * @param hal Context of the HAL layer.
+ * @param oper_id Operator ID
+ * @param gen_id Generator ID
+ */
+void mcpwm_hal_generator_reset(mcpwm_hal_context_t *hal, int oper_id, int gen_id);
+
+#ifdef __cplusplus
+}
+#endif

components/hal/include/hal/mcpwm_types.h

@@ -1,29 +1,47 @@
-// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 #pragma once
 
+#include "soc/clk_tree_defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief MCPWM timer clock source
+ */
+typedef soc_periph_mcpwm_timer_clk_src_t mcpwm_timer_clock_source_t;
+
+/**
+ * @brief MCPWM capture clock source
+ */
+typedef soc_periph_mcpwm_capture_clk_src_t mcpwm_capture_clock_source_t;
+
+/**
+ * @brief MCPWM timer count direction
+ */
 typedef enum {
     MCPWM_TIMER_DIRECTION_UP,   /*!< Counting direction: Increase */
     MCPWM_TIMER_DIRECTION_DOWN, /*!< Counting direction: Decrease */
 } mcpwm_timer_direction_t;
 
+/**
+ * @brief MCPWM timer events
+ */
 typedef enum {
-    MCPWM_TIMER_EVENT_ZERO, /*!< MCPWM timer counts to zero */
-    MCPWM_TIMER_EVENT_PEAK, /*!< MCPWM timer counts to peak */
+    MCPWM_TIMER_EVENT_EMPTY,   /*!< MCPWM timer counts to zero (i.e. counter is empty) */
+    MCPWM_TIMER_EVENT_FULL,    /*!< MCPWM timer counts to peak (i.e. counter is full) */
+    MCPWM_TIMER_EVENT_INVALID, /*!< MCPWM timer invalid event */
 } mcpwm_timer_event_t;
 
+/**
+ * @brief MCPWM timer count modes
+ */
 typedef enum {
     MCPWM_TIMER_COUNT_MODE_PAUSE,   /*!< MCPWM timer paused */
     MCPWM_TIMER_COUNT_MODE_UP,      /*!< MCPWM timer counting up */
@@ -31,14 +49,20 @@ typedef enum {
     MCPWM_TIMER_COUNT_MODE_UP_DOWN, /*!< MCPWM timer counting up and down */
 } mcpwm_timer_count_mode_t;
 
+/**
+ * @brief MCPWM timer commands, specify the way to start or stop the timer
+ */
 typedef enum {
-    MCPWM_TIMER_STOP_AT_ZERO,       /*!< MCPWM timer stops when couting to zero */
-    MCPWM_TIMER_STOP_AT_PEAK,       /*!< MCPWM timer stops when counting to peak */
-    MCPWM_TIMER_START_NO_STOP,      /*!< MCPWM timer starts couting */
-    MCPWM_TIMER_START_STOP_AT_ZERO, /*!< MCPWM timer starts counting and stops when couting to zero */
-    MCPWM_TIMER_START_STOP_AT_PEAK, /*!< MCPWM timer starts counting and stops when counting to peak */
-} mcpwm_timer_execute_cmd_t;
+    MCPWM_TIMER_STOP_EMPTY,       /*!< MCPWM timer stops when next count reaches zero */
+    MCPWM_TIMER_STOP_FULL,        /*!< MCPWM timer stops when next count reaches peak */
+    MCPWM_TIMER_START_NO_STOP,    /*!< MCPWM timer starts couting, and don't stop until received stop command */
+    MCPWM_TIMER_START_STOP_EMPTY, /*!< MCPWM timer starts counting and stops when next count reaches zero */
+    MCPWM_TIMER_START_STOP_FULL,  /*!< MCPWM timer starts counting and stops when next count reaches peak */
+} mcpwm_timer_start_stop_cmd_t;
 
+/**
+ * @brief MCPWM generator actions
+ */
 typedef enum {
     MCPWM_GEN_ACTION_KEEP,   /*!< Generator action: Keep the same level */
     MCPWM_GEN_ACTION_LOW,    /*!< Generator action: Force to low level */
@@ -46,7 +70,23 @@ typedef enum {
     MCPWM_GEN_ACTION_TOGGLE, /*!< Generator action: Toggle level */
 } mcpwm_generator_action_t;
 
+/**
+ * @brief MCPWM operator brake mode
+ */
 typedef enum {
-    MCPWM_TRIP_TYPE_CBC, /*!< CBC trip type, shut down the operator cycle by cycle*/
-    MCPWM_TRIP_TYPE_OST, /*!< OST trip type, shut down the operator in one shot */
-} mcpwm_trip_type_t;
+    MCPWM_OPER_BRAKE_MODE_CBC,     /*!< Brake mode: CBC (cycle by cycle)*/
+    MCPWM_OPER_BRAKE_MODE_OST,     /*!< Brake mode, OST (one shot) */
+    MCPWM_OPER_BRAKE_MODE_INVALID, /*!< MCPWM operator invalid brake mode */
+} mcpwm_operator_brake_mode_t;
+
+/**
+ * @brief MCPWM capture edge
+ */
+typedef enum {
+    MCPWM_CAP_EDGE_POS, /*!< Capture on the positive edge */
+    MCPWM_CAP_EDGE_NEG, /*!< Capture on the negative edge */
+} mcpwm_capture_edge_t;
+
+#ifdef __cplusplus
+}
+#endif

components/hal/mcpwm_hal.c

@@ -1,23 +1,56 @@
-// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// The HAL layer for MCPWM (common part)
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
+#include <stdlib.h>
+#include "soc/soc_caps.h"
 #include "hal/mcpwm_hal.h"
 #include "hal/mcpwm_ll.h"
 
 void mcpwm_hal_init(mcpwm_hal_context_t *hal, const mcpwm_hal_init_config_t *init_config)
 {
-    hal->dev = MCPWM_LL_GET_HW(init_config->host_id);
+    hal->dev = MCPWM_LL_GET_HW(init_config->group_id);
+    mcpwm_ll_group_enable_shadow_mode(hal->dev);
+    mcpwm_ll_group_flush_shadow(hal->dev);
+}
+
+void mcpwm_hal_deinit(mcpwm_hal_context_t *hal)
+{
+    hal->dev = NULL;
+}
+
+void mcpwm_hal_timer_reset(mcpwm_hal_context_t *hal, int timer_id)
+{
+    mcpwm_ll_timer_set_count_mode(hal->dev, timer_id, MCPWM_TIMER_COUNT_MODE_PAUSE);
+    mcpwm_ll_timer_update_period_at_once(hal->dev, timer_id);
+    // disable sync input and output by default
+    mcpwm_ll_timer_disable_sync_out(hal->dev, timer_id);
+    mcpwm_ll_timer_enable_sync_input(hal->dev, timer_id, false);
+    mcpwm_ll_timer_clear_sync_input(hal->dev, timer_id);
+}
+
+void mcpwm_hal_operator_reset(mcpwm_hal_context_t *hal, int oper_id)
+{
+    // allow to update action, compare, and dead time configuration
+    mcpwm_ll_operator_stop_update_action(hal->dev, oper_id, false);
+    mcpwm_ll_operator_update_action_at_once(hal->dev, oper_id);
+    mcpwm_ll_deadtime_stop_update_delay(hal->dev, oper_id, false);
+    mcpwm_ll_deadtime_update_delay_at_once(hal->dev, oper_id);
+    for (int i = 0; i < SOC_MCPWM_COMPARATORS_PER_OPERATOR; i++) {
+        mcpwm_ll_operator_stop_update_compare(hal->dev, oper_id, i, false);
+        mcpwm_ll_operator_update_compare_at_once(hal->dev, oper_id, i);
+    }
+    mcpwm_ll_brake_enable_cbc_refresh_on_tez(hal->dev, oper_id, false);
+    mcpwm_ll_fault_enable_cbc_refresh_on_tep(hal->dev, oper_id, false);
+    mcpwm_ll_brake_enable_soft_cbc(hal->dev, oper_id, false);
+    mcpwm_ll_brake_enable_soft_ost(hal->dev, oper_id, false);
+}
+
+void mcpwm_hal_generator_reset(mcpwm_hal_context_t *hal, int oper_id, int gen_id)
+{
+    mcpwm_ll_generator_reset_actions(hal->dev, oper_id, gen_id);
+    mcpwm_ll_gen_disable_continue_force_action(hal->dev, oper_id, gen_id);
+    mcpwm_ll_gen_disable_noncontinue_force_action(hal->dev, oper_id, gen_id);
 }

components/soc/esp32/include/soc/Kconfig.soc_caps.in

@@ -383,10 +383,6 @@ config SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP
     int
     default 3
 
-config SOC_MCPWM_BASE_CLK_HZ
-    int
-    default 160000000
-
 config SOC_MPU_CONFIGURABLE_REGIONS_SUPPORTED
     bool
     default n

components/soc/esp32/include/soc/clk_tree_defs.h

@@ -210,6 +210,34 @@ typedef enum {
     UART_SCLK_DEFAULT = SOC_MOD_CLK_APB,       /*!< UART source clock default choice is APB */
 } soc_periph_uart_clk_src_legacy_t;
 
+//////////////////////////////////////////////////MCPWM/////////////////////////////////////////////////////////////////
+
+/**
+ * @brief Array initializer for all supported clock sources of MCPWM Timer
+ */
+#define SOC_MCPWM_TIMER_CLKS {SOC_MOD_CLK_PLL_D2}
+
+/**
+ * @brief Type of MCPWM timer clock source
+ */
+typedef enum {
+    MCPWM_TIMER_CLK_SRC_PLL160M = SOC_MOD_CLK_PLL_D2, /*!< Select PLL_D2 (160MHz) as the source clock */
+    MCPWM_TIMER_CLK_SRC_DEFAULT = SOC_MOD_CLK_PLL_D2, /*!< Select PLL_D2 as the default clock choice */
+} soc_periph_mcpwm_timer_clk_src_t;
+
+/**
+ * @brief Array initializer for all supported clock sources of MCPWM Capture Timer
+ */
+#define SOC_MCPWM_CAPTURE_CLKS {SOC_MOD_CLK_APB}
+
+/**
+ * @brief Type of MCPWM capture clock source
+ */
+typedef enum {
+    MCPWM_CAPTURE_CLK_SRC_APB = SOC_MOD_CLK_APB,     /*!< Select APB as the source clock */
+    MCPWM_CAPTURE_CLK_SRC_DEFAULT = SOC_MOD_CLK_APB, /*!< SElect APB as the default clock choice */
+} soc_periph_mcpwm_capture_clk_src_t;
+
 #ifdef __cplusplus
 }
 #endif

components/soc/esp32/include/soc/mcpwm_struct.h

@@ -1,5 +1,5 @@
 /**
- *  SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
  *  SPDX-License-Identifier: Apache-2.0
  */
@@ -1435,7 +1435,7 @@ typedef struct {
     mcpwm_fh_status_reg_t fh_status;
 } mcpwm_operator_reg_t;
 
-typedef struct {
+typedef struct mcpwm_dev_t {
     volatile mcpwm_clk_cfg_reg_t clk_cfg;
     volatile mcpwm_timer_regs_t timer[3];
     volatile mcpwm_timer_synci_cfg_reg_t timer_synci_cfg;

components/soc/esp32/include/soc/soc_caps.h

@@ -221,7 +221,6 @@
 #define SOC_MCPWM_CAPTURE_TIMERS_PER_GROUP   (1)    ///< The number of capture timers that each group has
 #define SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER (3)    ///< The number of capture channels that each capture timer has
 #define SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP    (3)    ///< The number of GPIO synchros that each group has
-#define SOC_MCPWM_BASE_CLK_HZ       (160000000ULL)  ///< Base Clock frequency of 160MHz
 
 /*-------------------------- MPU CAPS ----------------------------------------*/
 //TODO: correct the caller and remove unsupported lines

components/soc/esp32/mcpwm_periph.c

@@ -1,16 +1,8 @@
-// Copyright 2020 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 #include "soc/soc.h"
 #include "soc/mcpwm_periph.h"

components/soc/esp32s3/include/soc/Kconfig.soc_caps.in

@@ -447,10 +447,6 @@ config SOC_MCPWM_SWSYNC_CAN_PROPAGATE
     bool
     default y
 
-config SOC_MCPWM_BASE_CLK_HZ
-    int
-    default 160000000
-
 config SOC_PCNT_GROUPS
     bool
     default y

components/soc/esp32s3/include/soc/clk_tree_defs.h

@@ -217,6 +217,34 @@ typedef enum {
     UART_SCLK_DEFAULT = SOC_MOD_CLK_APB, /*!< UART source clock default choice is APB */
 } soc_periph_uart_clk_src_legacy_t;
 
+//////////////////////////////////////////////////MCPWM/////////////////////////////////////////////////////////////////
+
+/**
+ * @brief Array initializer for all supported clock sources of MCPWM Timer
+ */
+#define SOC_MCPWM_TIMER_CLKS {SOC_MOD_CLK_PLL_D2}
+
+/**
+ * @brief Type of MCPWM timer clock source
+ */
+typedef enum {
+    MCPWM_TIMER_CLK_SRC_PLL160M = SOC_MOD_CLK_PLL_F160M, /*!< Select PLL_F160M as the source clock */
+    MCPWM_TIMER_CLK_SRC_DEFAULT = SOC_MOD_CLK_PLL_F160M, /*!< Select PLL_F160M as the default clock choice */
+} soc_periph_mcpwm_timer_clk_src_t;
+
+/**
+ * @brief Array initializer for all supported clock sources of MCPWM Capture Timer
+ */
+#define SOC_MCPWM_CAPTURE_CLKS {SOC_MOD_CLK_APB}
+
+/**
+ * @brief Type of MCPWM capture clock source
+ */
+typedef enum {
+    MCPWM_CAPTURE_CLK_SRC_APB = SOC_MOD_CLK_APB,     /*!< Select APB as the source clock */
+    MCPWM_CAPTURE_CLK_SRC_DEFAULT = SOC_MOD_CLK_APB, /*!< SElect APB as the default clock choice */
+} soc_periph_mcpwm_capture_clk_src_t;
+
 #ifdef __cplusplus
 }
 #endif

components/soc/esp32s3/include/soc/mcpwm_struct.h

@@ -1,5 +1,5 @@
 /**
- *  SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
  *  SPDX-License-Identifier: Apache-2.0
  */
@@ -1435,7 +1435,7 @@ typedef struct {
     mcpwm_fh_status_reg_t fh_status;
 } mcpwm_operator_reg_t;
 
-typedef struct {
+typedef struct mcpwm_dev_t {
     volatile mcpwm_clk_cfg_reg_t clk_cfg;
     volatile mcpwm_timer_regs_t timer[3];
     volatile mcpwm_timer_synci_cfg_reg_t timer_synci_cfg;

components/soc/esp32s3/include/soc/soc_caps.h

@@ -184,7 +184,6 @@
 #define SOC_MCPWM_CAPTURE_CHANNELS_PER_TIMER (3)    ///< The number of capture channels that each capture timer has
 #define SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP    (3)    ///< The number of GPIO synchros that each group has
 #define SOC_MCPWM_SWSYNC_CAN_PROPAGATE       (1)    ///< Software sync event can be routed to its output
-#define SOC_MCPWM_BASE_CLK_HZ       (160000000ULL)  ///< Base Clock frequency of 160MHz
 
 /*-------------------------- MPU CAPS ----------------------------------------*/
 #include "mpu_caps.h"

components/soc/esp32s3/mcpwm_periph.c

@@ -1,16 +1,8 @@
-// Copyright 2020 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 #include "soc/soc.h"
 #include "soc/mcpwm_periph.h"

components/soc/include/soc/mcpwm_periph.h

@@ -1,16 +1,8 @@
-// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 
 #pragma once
 

docs/en/migration-guides/peripherals.rst

@@ -243,15 +243,8 @@ LCD
     MCPWM
     -----
 
-    +---------------------------+---------------------------------------------------+-----------------------------------------------------------+
-    | Removed/Deprecated items  | Replacement                                       | Remarks                                                   |
-    +===========================+===================================================+===========================================================+
-    | ``mcpwm_capture_enable``  | :cpp:func:`mcpwm_capture_enable_channel`          | Enable capture channel.                                   |
-    +---------------------------+---------------------------------------------------+-----------------------------------------------------------+
-    | ``mcpwm_capture_disable`` | :cpp:func:`mcpwm_capture_capture_disable_channel` | Disable capture channel.                                  |
-    +---------------------------+---------------------------------------------------+-----------------------------------------------------------+
-    | ``mcpwm_sync_enable``     | :cpp:func:`mcpwm_sync_configure`                  | Configure synchronization.                                |
-    +---------------------------+---------------------------------------------------+-----------------------------------------------------------+
-    | ``mcpwm_isr_register``    | By registering event callbacks, e.g.              | MCPWM interrupt handling is implemented by driver itself. |
-    |                           | :cpp:member:`mcpwm_capture_config_t::capture_cb`  |                                                           |
-    +---------------------------+---------------------------------------------------+-----------------------------------------------------------+
+    - ``mcpwm_capture_enable`` is removed. To enable capture channel, please use :cpp:func:`mcpwm_capture_enable_channel`.
+    - ``mcpwm_capture_disable`` is remove. To disable capture channel, please use :cpp:func:`mcpwm_capture_capture_disable_channel`.
+    - ``mcpwm_sync_enable`` is removed. To configure synchronization, please use :cpp:func:`mcpwm_sync_configure`.
+    - ``mcpwm_isr_register`` is removed. You can register event callbacks, for capture channels. e.g. :cpp:member:`mcpwm_capture_config_t::capture_cb`.
+    - ``mcpwm_carrier_oneshot_mode_disable`` is removed. Disable the first pulse (a.k.a the one-shot pulse) in the carrier is not supported by hardware.

examples/peripherals/mcpwm/mcpwm_bldc_hall_control/main/mcpwm_bldc_hall_control_example_main.c

@@ -1,17 +1,15 @@
 
-/* MCPWM BLDC control with Hall sensor
-
-   This example code is in the Public Domain (or CC0 licensed, at your option.)
-
-   Unless required by applicable law or agreed to in writing, this
-   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-   CONDITIONS OF ANY KIND, either express or implied.
-*/
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
 
 #include <stdio.h>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "driver/mcpwm.h"
+#include "driver/gpio.h"
 #include "esp_timer.h"
 #include "esp_attr.h"
 #include "esp_log.h"

examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/main/mcpwm_capture_hc_sr04.c

@@ -1,25 +1,16 @@
-/* MCPWM capture example: HC-SR04
-
-   This example code is in the Public Domain (or CC0 licensed, at your option.)
-
-   Unless required by applicable law or agreed to in writing, this
-   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-   CONDITIONS OF ANY KIND, either express or implied.
-*/
-
 /*
- * This example will show you how to use capture function to read HC-SR04 sonar sensor.
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
  *
- * HC_SR04_SAMPLE_PERIOD_MS should be at least 50ms
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/queue.h"
 #include "esp_log.h"
-#include "esp_check.h"
 #include "esp_private/esp_clk.h"
 #include "driver/mcpwm.h"
+#include "driver/gpio.h"
 
 const static char *TAG = "hc-sr04";
 

examples/peripherals/mcpwm/mcpwm_sync_example/main/mcpwm_sync_example.c

@@ -1,28 +1,16 @@
-/* MCPWM sync example
-
-   This example code is in the Public Domain (or CC0 licensed, at your option.)
-
-   Unless required by applicable law or agreed to in writing, this
-   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-   CONDITIONS OF ANY KIND, either express or implied.
-*/
-
 /*
- * This example will show you how to use capture function to read HC-SR04 sonar sensor.
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "freertos/queue.h"
-#include "esp_rom_gpio.h"
-#include "soc/mcpwm_periph.h"
-#include "hal/gpio_hal.h"
 #include "esp_log.h"
-#include "esp_check.h"
-#include "soc/rtc.h"
 #include "driver/mcpwm.h"
+#include "driver/gpio.h"
 
-const static char *TAG = "sync_example";
+const static char *TAG = "example";
 
 #define TARGET_MCPWM_UNIT MCPWM_UNIT_0
 #define TIMER0_OUTPUT_GPIO GPIO_NUM_16

tools/ci/check_copyright_ignore.txt

@@ -863,8 +863,6 @@ components/hal/include/hal/ds_hal.h
 components/hal/include/hal/esp_flash_err.h
 components/hal/include/hal/interrupt_controller_hal.h
 components/hal/include/hal/interrupt_controller_types.h
-components/hal/include/hal/mcpwm_hal.h
-components/hal/include/hal/mcpwm_types.h
 components/hal/include/hal/mpu_hal.h
 components/hal/include/hal/mpu_types.h
 components/hal/include/hal/rtc_io_types.h
@@ -885,7 +883,6 @@ components/hal/include/hal/wdt_hal.h
 components/hal/include/hal/wdt_types.h
 components/hal/interrupt_controller_hal.c
 components/hal/ledc_hal_iram.c
-components/hal/mcpwm_hal.c
 components/hal/mpu_hal.c
 components/hal/platform_port/include/hal/assert.h
 components/hal/platform_port/include/hal/check.h
@@ -1215,7 +1212,6 @@ components/soc/esp32/include/soc/uhci_struct.h
 components/soc/esp32/include/soc/wdev_reg.h
 components/soc/esp32/interrupts.c
 components/soc/esp32/ledc_periph.c
-components/soc/esp32/mcpwm_periph.c
 components/soc/esp32/sdio_slave_periph.c
 components/soc/esp32/sdmmc_periph.c
 components/soc/esp32/sigmadelta_periph.c
@@ -1493,7 +1489,6 @@ components/soc/esp32s3/include/soc/world_controller_reg.h
 components/soc/esp32s3/include/soc/world_controller_struct.h
 components/soc/esp32s3/interrupts.c
 components/soc/esp32s3/ledc_periph.c
-components/soc/esp32s3/mcpwm_periph.c
 components/soc/esp32s3/rtc_io_periph.c
 components/soc/esp32s3/sdio_slave_periph.c
 components/soc/esp32s3/sdmmc_periph.c
@@ -1510,7 +1505,6 @@ components/soc/include/soc/gpio_periph.h
 components/soc/include/soc/i2c_periph.h
 components/soc/include/soc/interrupts.h
 components/soc/include/soc/ledc_periph.h
-components/soc/include/soc/mcpwm_periph.h
 components/soc/include/soc/rtc_cntl_periph.h
 components/soc/include/soc/rtc_periph.h
 components/soc/include/soc/sdio_slave_periph.h
@@ -1986,13 +1980,10 @@ examples/peripherals/i2s/i2s_audio_recorder_sdcard/main/i2s_recorder_main.c
 examples/peripherals/i2s/i2s_basic/main/i2s_example_main.c
 examples/peripherals/ledc/ledc_basic/main/ledc_basic_example_main.c
 examples/peripherals/ledc/ledc_fade/main/ledc_fade_example_main.c
-examples/peripherals/mcpwm/mcpwm_bldc_hall_control/main/mcpwm_bldc_hall_control_example_main.c
 examples/peripherals/mcpwm/mcpwm_brushed_dc_control/main/cmd_mcpwm_motor.c
 examples/peripherals/mcpwm/mcpwm_brushed_dc_control/main/mcpwm_brushed_dc_control_example.c
 examples/peripherals/mcpwm/mcpwm_brushed_dc_control/main/mcpwm_brushed_dc_control_example.h
-examples/peripherals/mcpwm/mcpwm_capture_hc_sr04/main/mcpwm_capture_hc_sr04.c
 examples/peripherals/mcpwm/mcpwm_servo_control/main/mcpwm_servo_control_example_main.c
-examples/peripherals/mcpwm/mcpwm_sync_example/main/mcpwm_sync_example.c
 examples/peripherals/sdio/host/main/app_main.c
 examples/peripherals/sdio/sdio_test.py
 examples/peripherals/sdio/slave/main/app_main.c